Reconocimiento de gestos con Machine Learning
Construya el reconocimiento de gestos con la mano desde cero usando la red neuronal – Aprendizaje automático fácil y divertido
Desde Imágenes autocapturadas hasta Aprendiendo el modelo de red neuronal 19659004] Introducción
Entonces, comencemos a construir la Red neuronal de reconocimiento de gestos con las manos desde la parte inferior. Este algoritmo debería funcionar con todos los diferentes tipos de color de piel, solo asegúrate de colocar tu mano en el medio.
Para esta solución usé GNU Octave y Visual Studio Code.
Los datos y el código están disponibles en mi repositorio Github.
Gago993 / HandGestureRecognitionNeuralNetwork
Todo el trabajo que tenemos que hacer puede dividirse en 5 pasos: [19659010] Generar y preparar los datos
- Generar características
- Generar modelo ML
- Probar el modelo ML
- Predecir con el modelo ML
Entonces comencemos …
Generar y preparar los datos [19659005] Ya que estamos construyendo este proyecto desde abajo. Lo primero que debemos hacer es crear los datos que vamos a utilizar para entrenar el modelo de red neuronal.
Para este paso, utilicé la cámara incorporada de mi computadora. Capturé 78 imágenes de mi mano que mostraban 4 gestos diferentes y se dividieron en 4 carpetas. Corté algunas de las imágenes para que estén mejor “ajustadas” para entrenar nuestro modelo más adelante. Todas las imágenes de entrenamiento (preparadas) se almacenan en la carpeta dataset .
- izquierda – contiene 27 imágenes de la mano apuntando hacia la izquierda
- derecha – contiene 24 imágenes de la mano apuntando hacia la derecha
- palma – contiene 11 imágenes de la palma de la mano
- paz – contiene 14 imágenes de la mano de la paz (signo V)
Imagen 1: Ejemplo de conjunto de datos (signo de la paz V)
Características generadas
Después de que las imágenes de entrenamiento estén listas, podemos continuar con el siguiente paso que es procesar todas las imágenes y crear las características. El algoritmo principal para separar la mano de la imagen se realiza en unos sencillos pasos:
- Cargar la imagen
- Cambiar el tamaño de la imagen a 50×50
- Convertir imagen de RGB a color YCbCr
- Elegir el color del punto central ( esperar que la mano se coloque en el centro de la imagen)
- Segmenta la mano según el rango de color de la piel definido en el paso 3.
- Marca los píxeles seleccionados con color blanco y otros con color negro
Este algoritmo se coloca en processSkinImage.m archivo. Marque cada Paso dentro del código.
Este procesamiento de máscara de imagen es utilizado por el archivo create_image_dataset.m que recorre todo las imágenes las procesan usando el código de arriba y las escriben en una carpeta separada llamada dataset_resized en las carpetas izquierda, derecha, palm, paz respectivamente.
Al final necesitamos preparar nuestras imágenes para que puedan ser utilizadas Para generar y probar nuestro modelo de red neuronal más adelante. Ya que tenemos 78 imágenes y son 50×50 píxeles, las guardaremos como matrices de tamaño 78×2500 donde cada columna representa el píxel de nuestra imagen. También vamos a dividir aleatoriamente las matrices en dos como dos conjuntos separados. Se guardará una matriz de entrenamiento en x_features_train y contendrá 80% de las imágenes y la matriz de prueba en x_features_test con otro 20% de las imágenes. Las etiquetas se guardarán en y_labels_train y y_labels_test respectivamente.
El código para crear las matrices de características se ve como
... % Generar número aleatorio desde 1 a 10 randNum = ceil (rand () * 10);
% Dividir las imágenes en 80% -20% train-test set si randNum> 2 % Crear las características de la imagen X_train = [X_train; image_out(:)']; y_train = [y_train; label]; else X_test = [X_test; image_out(:)']; y_test = endif ]
Hay cuatro tipos de etiquetas:
- [1 0 0 0] – img de la mano que apunta hacia la izquierda
- [0 1 0 0] – imagen de la mano que apunta hacia la derecha
- [0 0 1 0] – imagen de mano de la palma
- [0 0 0 1] – paz sign hand image
Estas etiquetas se crean en create_image_dataset.m como se muestra en el siguiente código. Donde carpeta es el nombre de la carpeta donde se encuentra la imagen y ismember devuelve 1 de las 4 opciones de la lista de viñetas anterior.
...
label_keys = {& # 039; izquierda & # 039 ;, & # 039; derecha & # 039 ;, & # 039; palm & # 039 ;, & # 039; paz & # 039;};
...
label = ismember (label_keys, folder);
...
Una vez finalizado este script, podemos revisar la carpeta en dataset_resized para ver las imágenes procesadas y deberíamos ver algo como esto
También debería haber x_features_train y y_labels_train archivos que vamos a utilizar para entrenar nuestro modelo en el siguiente paso y también x_features_test y y_labels_test para probar nuestro modelo más tarde.
Generate ML Model
Comencemos por definir nuestra estructura NN. Usaremos una capa oculta en la red. El tamaño de la capa de entrada será de 2500 nodos, ya que nuestras imágenes son de 50×50 píxeles. El tamaño de la capa oculta será de 25 nodos y la salida será de 4 nodos (4 tipos de signos).
La definición del tamaño de la capa oculta no tiene una fórmula estricta, pero generalmente depende de la pregunta “¿Qué tan bien se ajusta a los datos? ”
Aquí vamos a usar el archivo main.m y nosotros:
- Cargaremos las características y etiquetas
- . Valores Theta (pesos de nodos NN)
- Cree la función de costo y la propagación hacia adelante
- Cree el gradiente para la función de costo NN ( Backpropagation )
- Minimice la función de costo usando fmincg [19659020] minimizador
Cargue las funciones y etiquetas
Así que comencemos el primer paso: cargar las funciones y las etiquetas. Lo hacemos utilizando la función dlmread .
... X = dlmread (& # 039; x_features_train & # 039;); % Etiquetas para cada imagen de entrenamiento procesada % [1 0 0 0] - izquierda, [0 1 0 0] - derecha, [0 0 1 0] - palma, [0 0 0 1] - paz y = dlmread (& # 039; y_labels_train & # 039;); [0 0 1 0] ...
Inicializa aleatoriamente los valores Theta (NN nodos de peso)
A continuación, debemos inicializar los valores Theta utilizando la función randInitializeWeights.m . Representado por el siguiente código
épsilon = sqrt (6) / (L_in + L_out); W = ceros (L_out, 1 + L_in); W = (rand (L_out, 1 + L_in ) * 2 * epsilon) - epsilon;
Donde los valores generados están entre [-epsilon, epsilon]. Este código está relacionado con la fórmula de estadísticas para “Variedad de distribución uniforme”. Si está más interesado en esta fórmula, dejaré los enlaces al final de este blog o puede publicar una pregunta.
Crear la función de costos y la propagación hacia adelante
Nuestro siguiente objetivo es implementar la Función de costo definida por la siguiente ecuación.
Donde g es la función de activación (función sigmoidea en este caso)
En Para calcular el costo, necesitamos usar el cálculo de Feedforward. El código se implementa en nnCostFunction.m. Usaremos un bucle for sobre los ejemplos para calcular el costo y también necesitamos agregar la columna de 1 a la matriz X que representa los valores de “sesgo”. Los valores de θ₁ (Theta 1) y θ₂ (Theta 2) son parámetros para cada unidad en el NN, la primera fila de θ₁ corresponde a la primera unidad oculta en la segunda capa.
Cree el gradiente para la función de costo NN ( Backpropagation ) [19459246] Para poder minimizar el costo de la función, es necesario que compense el valor de la lámpara. función de costo. Para eso vamos a utilizar el algoritmo abreviatura de “propagación de errores hacia atrás”, se utiliza para minimizar nuestra función de costo, lo que significa minimizar el error para nuestra NN y minimizando el error para cada neurona de salida. Este cálculo es parte del código implementado en nnCostFunction.m
Minimize la función de costo [19909038]] minimizador
Uno computó el gradiente, podemos entrenar la red neuronal minimizando la función de costo J (Θ) usando un optimizador avanzado como fmincg. Esta función no forma parte de Octave, por lo que la obtuve de Machine Learning Course por Andrew Ng . Como sé, esta función es más rápida que las implementadas en Octave y utiliza el método de gradiente conjugado .
fmincg toma 3 argumentos como se muestra en el ejemplo de código a continuación. Toma la función de costo, los parámetros iniciales θ (Theta) concatenados en un solo vector y el parámetro de opciones.
fmincg fmincg ] en nuestros ejemplos de prueba obtenemos los valores de θ en un vector y necesitamos remodelarlos en matrices para una multiplicación de matriz más fácil.
Probar el modelo ML
Ahora generamos con éxito nuestros valores Theta (peso) de la NN. Lo siguiente que debe hacer es verificar qué tan bien nuestro modelo se ajusta al entrenamiento y qué tan bien se desempeña en los datos de la prueba.
Para predecir vamos a utilizar la función predict ubicada en [19659019] predict.m
file.
Esta función toma la matriz de parámetros y características de theta. Luego, anuncia una columna de 1 que representa los valores de “sesgo” en la matriz de características. Y simplemente multiplique las características con los valores theta para ambas capas NN. Luego obtiene el vector h2 con tamaño (número_de_imágenes x 4), donde cada columna (4) representa la posibilidad de que esa imagen se encuentre en esa clase (izquierda, derecha, palma, paz). Al final, si devuelve el que tiene la mayor probabilidad.
Realicemos la precisión del conjunto de trenes y la precisión del conjunto de pruebas.
... pred = predict (Theta1, Theta2, X_train); % Compare la predicción con los valores reales [val idx] = max (y_train, []2); fprintf (& # 039; nFormación del conjunto de entrenamiento:% f n & # 039 ;, mean (double (pred == idx)) * 100);
... pred = predict (Theta1, Theta2, X_test); % Compare la predicción con los valores reales [val idx] = max (y_test, []2); fprintf (& # 039; n Exactitud del conjunto de prueba:% f n & # 039 ;, media (double (pred == idx)) * 100);
Lo que obtenemos es
Entrenamiento Precisión del conjunto: 100.000000% Precisión del conjunto de prueba: 90.909091%
Predecir con el modelo ML
También hice algunas imágenes adicionales y las puse en la carpeta prueba . Representan imágenes completas (no editadas) para que pueda probar el rendimiento del modelo NN. Lo que obtuve fue escribir predicción para los 4 de ellos.
pred = 2 Tipo: derecha
pred = 1 Tipo: izquierda
pred = 3 Tipo: palm [19659054] pred = 4 Tipo: paz
Puedes probar esto con tus imágenes e incluso con tus propias imágenes de entrenamiento. Simplemente coloque sus imágenes de entrenamiento debajo de la carpeta dataset y llame al archivo create_image_dataset.m para crear las matrices de prueba y tren. También todas las prueba imágenes en prueba carpeta y ya está listo para llamar al main.m script.
Conclusión
Felicidades por la construcción de su Máquina Aprender el modelo de red neuronal desde cero. Esperamos que esto ayude a comprender el panorama general cuando se trabaja con redes neuronales y cómo realizar el primer paso. Para cualquier pregunta o sugerencia, publique un comentario o comuníquese conmigo.
¡Espero que lo haya disfrutado!
