Aplique el entrenamiento HOG + SVM a la cámara web para la detección de objetos

He entrenado a mi clasificador SVM extrayendo características HOG de un conjunto de datos positivo y negativo

from sklearn.svm import SVC import cv2 import numpy as np hog = cv2.HOGDescriptor() def hoggify(x,z): data=[] for i in range(1,int(z)): image = cv2.imread("/Users/munirmalik/cvprojek/cod/"+x+"/"+"file"+str(i)+".jpg", 0) dim = 128 img = cv2.resize(image, (dim,dim), interpolation = cv2.INTER_AREA) img = hog.compute(img) img = np.squeeze(img) data.append(img) return data def svmClassify(features,labels): clf=SVC(C=10000,kernel="linear",gamma=0.000001) clf.fit(features,labels) return clf def list_to_matrix(lst): return np.stack(lst) 

Quiero aplicar ese entrenamiento para que el progtwig pueda detectar mi objeto personalizado (sillas).

Ya he añadido tags a cada conjunto; ¿Qué hay que hacer a continuación?

Ya tienes tres de las piezas más importantes disponibles a tu disposición. hoggify crea una lista de descriptores HOG, uno para cada imagen. Tenga en cuenta que la entrada esperada para calcular el descriptor es una imagen en escala de grises y el descriptor se devuelve como una matriz 2D con 1 columna, lo que significa que cada elemento del descriptor HOG tiene su propia fila. Sin embargo, está usando np.squeeze para eliminar la columna singleton y reemplazarla con una matriz numpy 1D en su lugar, por lo que estamos bien aquí. Luego usaría list_to_matrix para convertir la lista en una matriz numpy . Una vez que haga esto, puede usar svmClassify para finalmente formar sus datos. Esto supone que ya tiene sus labels en una matriz numpy 1D. Después de entrenar a su SVM, usaría el método SVC.predict en el que, según las características del HOG de entrada, clasificaría si la imagen pertenecía a una silla o no.

Por lo tanto, los pasos que debes hacer son:

  1. Use hoggify para crear su lista de descriptores HOG, uno por imagen. Parece que la entrada x es un prefijo para lo que llames imágenes de la silla, mientras que z indica el número total de imágenes que deseas cargar. Recuerda que el range es exclusivo del valor final, por lo que es posible que desees agregar un + 1 después de int(z) (es decir, int(z) + 1 ) para asegurarse de incluir el final. No estoy seguro de si este es el caso, pero quería tirarlo allí.

     x = '...' # Whatever prefix you called your chairs z = 100 # Load in 100 images for example lst = hoggify(x, z) 
  2. Convierta la lista de descriptores HOG en una matriz real:

     data = list_to_matrix(lst) 
  3. Entrena a tu clasificador SVM. Suponiendo que ya tiene sus tags almacenadas en labels donde un valor 0 denota no una presidencia y 1 denota una presidencia y es una matriz numpy 1D:

     labels = ... # Define labels here as a numpy array clf = svmClassify(data, labels) 
  4. Usa tu clasificador SVM para realizar predicciones. Suponiendo que tiene una imagen de prueba que desea probar con su clasificador, deberá realizar los mismos pasos de procesamiento que hizo con sus datos de entrenamiento. Supongo que eso es lo que hace hoggify donde puede especificar una x diferente para indicar diferentes conjuntos para usar. Especifique una nueva variable xtest para especificar este directorio o prefijo diferente, así como el número de imágenes que necesita, luego use hoggify combinado con list_to_matrix para obtener sus características:

     xtest = '...' # Define new test prefix here ztest = 50 # 50 test images lst_test = hoggify(xtest, ztest) test_data = list_to_matrix(lst_test) pred = clf.predict(test_data) 

    pred contendrá una matriz de tags predichas, una para cada imagen de prueba que tenga. Si lo desea, puede ver qué tan bien le fue a su SVM con los datos de capacitación, por lo que, como ya tiene esto a su disposición, simplemente use los data nuevamente en el paso # 2:

     pred_training = clf.predict(data) 

    pred_training contendrá una matriz de tags predichas, una para cada imagen de entrenamiento.


Si finalmente desea usar esto con una cámara web, el proceso sería usar un objeto VideoCapture y especificar la identificación del dispositivo que está conectado a su computadora. Por lo general, solo hay una cámara web conectada a su computadora, así que use la ID de 0. Una vez que haga esto, el proceso consistirá en usar un bucle, tomar un marco, convertirlo a escala de grises, ya que los descriptores HOG requieren una imagen en escala de grises, calcular el descriptor , luego clasificar la imagen.

Algo como esto funcionaría, suponiendo que ya ha entrenado a su modelo y que ha creado un objeto descriptor de HOG desde antes:

 cap = cv2.VideoCapture(0) dim = 128 # For HOG while True: # Capture the frame ret, frame = cap.read() # Show the image on the screen cv2.imshow('Webcam', frame) # Convert the image to grayscale gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # Convert the image into a HOG descriptor gray = cv2.resize(gray, (dim, dim), interpolation = cv2.INTER_AREA) features = hog.compute(gray) features = features.T # Transpose so that the feature is in a single row # Predict the label pred = clf.predict(features) # Show the label on the screen print("The label of the image is: " + str(pred)) # Pause for 25 ms and keep going until you push q on the keyboard if cv2.waitKey(25) == ord('q'): break cap.release() # Release the camera resource cv2.destroyAllWindows() # Close the image window 

El proceso anterior lee una imagen, la muestra en la pantalla, la convierte en escala de grises para que podamos calcular su descriptor HOG, asegura que los datos sean compatibles en una sola fila para el SVM que entrenó y luego predeciremos su etiqueta. Imprimimos esto en la pantalla y esperamos 25 ms antes de leer el siguiente cuadro para no sobrecargar su CPU. Además, puede salir del progtwig en cualquier momento presionando la tecla q en su teclado. De lo contrario, este progtwig se repetirá para siempre. Una vez que terminamos, devolvemos el recurso de la cámara a la computadora para que pueda estar disponible para otros procesos.