Dispositivo empotrado para traducción de lenguaje de signos usando técnicas ML/DL

Trabajo Fin de Grado Grado En ingeniería electrónica industrial Dispositivo empotrado para traducción de lenguaje de signos usando técnicas ML/DL Autor: Santiago Moreno Ordoñez. Tutores: Luis Muñoz Saavedra, Francisco Luna Perejón. Julio 2023 2 3 Trabajo Fin de Grado Ingeniería Electrónica Industrial Dispositivo empotrado para traducción de lenguaje de signos usando técnicas ML/DL Autor: Santiago Moreno Ordoñez Tutores: Luis Muñoz Saavedra Francisco Luna Perejón Dpto. de Arquitectura y Tecnología de Computadores Escuela Politécnica Superior Universidad de Sevilla Sevilla, 2023 4 AGRADECIMIENTOS Se quieren dar agradecimientos a todas las personas que me han acompañado en este trayecto, a mis compañeros de clase por ayudarme tanto en mi crecimiento académico como personal, en especial a las personas que han sido cercanas y que hemos acabado superando esta etapa. Además, he de agradecer a mi tutor del TFG que me ha ayudado siempre que lo he necesitado y ha sido muy atento preocupándose por hacer un seguimiento. También quiero dar gracias a mi madre por ser la persona que más ha confiado y quien más me ha apoyado. Para finalizar, se hace una mención de agradecimiento al FabLab de la Universidad de Sevilla por prestar la Raspberry Pi 4 y la cámara Logitech C920 HD Pro. 5 RESUMEN En este trabajo de fin de grado se va a explicar el desarrollo de un sistema de reconocimiento del lenguaje de signos utilizando técnicas de Machine Learning (ML), Deep Learning(DL) y visión por computadora. El objetivo principal de este proyecto es diseñar e implementar un programa que permita capturar y clasificar imágenes, en este caso, que contengan los gestos de las manos que corresponden a el abecedario del lenguaje de signos inglés. Para ello, se emplea una red neuronal convolucional para el entrenamiento y la clasificación de las imágenes capturadas con una cámara. Además, se hará uso de una Raspberry Pi junto con una cámara y un display para ejecutar el programa y mostrar los resultados en un entorno visual. Los resultados obtenidos demuestran una alta precisión en el reconocimiento de las letras del lenguaje de signos, lo que valida la eficacia del sistema propuesto. 6 PALABRAS CLAVE CNN = Ren Neuronal Convolucional. AN = Neurona artificial. Dataset = Conjunto de datos que se van a usar en el entrenamiento del modelo. Display = Dispositivo que muestra información de forma visual. ML = Aprendizaje automático. DL = Aprendizaje profundo. Dropout = Tasa de abandono. ARM = Arquitectura de máquina RISC avanzada. ROI = Área de interés. 7 ABSTRACT In this undergraduate thesis, the development of a sign language recognition system using Machine Learning (ML), Deep Learning (DL), and computer vision techniques will be explained. The main objective of this project is to design and implement a program that allows for capturing and classifying images containing hand gestures corresponding to the English sign language alphabet. For this purpose, a convolutional neural network is employed for training and classifying the captured images using a camera. Furthermore, a Raspberry Pi, along with a camera and a display, is utilized to run the program and display the results in a visual environment. The obtained results demonstrate high accuracy in recognizing sign language letters, thus validating the effectiveness of the proposed system. 8 KEYWORDS CNN = Convolutional Neural Network AN = Artificial Neuron Dataset = Set of data used for model training Display = Device that shows information visually ML = Machine Learning DL = Deep Learning Dropout = Dropout rate ARM = Advanced RISC Machine ROI = Region of Interest 9 ÍNDICE 1. INTRODUCCIÓN .............................................................................. 11 1.1. Contexto y motivación ....................................................................................................... 11 1.2. Objetivos ........................................................................................................................... 11 1.3. Estructura de la memoria................................................................................................... 12 2. FUNDAMENTOS TEÓRICOS .............................................................. 14 2.1. Lenguaje de signos y su importancia .................................................................................. 14 2.2. Aprendizaje automático ..................................................................................................... 14 2.3. Identificación de imágenes ................................................................................................ 15 2.4. Redes convolucionales (CNN) ............................................................................................. 16 2.4.1. Algoritmos de aprendizaje ......................................................................................... 16 2.4.2. Neuronas biológicas ................................................................................................... 17 2.4.3. Neuronas artificiales .................................................................................................. 18 2.4.4. Redes Neuronales Artificiales (ANN) ........................................................................... 20 2.4.5. Redes Neuronales Convolucionales (CNN) .................................................................. 22 2.5. OpenCV y mediapipe ......................................................................................................... 26 2.5.1. OpenCV (Open Source Computer Vision Library) ........................................................ 26 2.5.2. MediaPipe ................................................................................................................. 27 2.6. Raspberry pi 4 y su uso en el proyecto ............................................................................... 28 3. DESARROLLO DEL TFG ..................................................................... 30 3.1. Diseño del sistema ............................................................................................................. 31 3.1.1. Descripción de los programas desarrollados ............................................................... 31 3.1.2. Arquitectura del sistema (hardware y software) ......................................................... 31 3.1.1.2 Hardware ................................................................................................................... 31 3.1.1.2 Software .................................................................................................................... 31 3.2. Implementación del programa de creación del dataset ...................................................... 32 3.2.1. Detalles de la estructura y organización del dataset ................................................... 32 3.3. Implementación del programa de entrenamiento del modelo ............................................ 40 3.3.1. Configuración de la red CNN ...................................................................................... 42 3.3.2. Preprocesamiento de imágenes ................................................................................. 44 3.3.3. Entrenamiento y evaluación del modelo .................................................................... 47 3.4. Implementación del programa de clasificación en tiempo real ........................................... 49 16 • Extracción de características: Entendiendo como características a los elementos que describen un objeto, como puede ser su tamaño, forma, color, etc. Se deben extraer los patrones o características de la mejor forma posible para que permitan identificar la imagen para llegar a tener un buen rendimiento en la clasificación. Estas características se suelen encontrar en áreas con cambios de contraste o en los contornos de los objetos. Esta fase es importante ya que constituye el conocimiento previo del clasificador, y su mal funcionamiento puede hacer que el clasificador de imágenes no funcione apropiadamente. • Representación de la imagen: Para poder tratar una imagen, es común representarla como un arreglo numérico de forma que sumando o combinando los vectores se describen las áreas de interés. También hay que recalcar que para esta representación en muchos casos es recomendable normalizar los datos para un mejor rendimiento. • Clasificación: En la fase final, se clasifica la imagen asignándole la categoría correspondiente en base al entrenamiento previo, el cual ha reunido las características comunes de los objetos de estudio, siendo capaz de reconocer las similitudes y realizar su clasificación. Para la clasificación de imágenes existen diferentes clasificadores, a continuación, se van a describir brevemente algunos de ellos: • Clasificador paramétrico: Estos clasificadores están basados en funciones de densidad de probabilidad, como podría ser una distribución normal. • Clasificador no paramétrico: A diferencia de los anteriores, evitan el uso de parámetros estadísticos para realizar la categorización. 2.4. Redes convolucionales (CNN) 2.4.1. Algoritmos de aprendizaje Antes de especificar las redes convolucionales, se va a explicar brevemente algunos de los algoritmos de aprendizaje que existen: 17 • Máquinas de soporte vectorial: Son algoritmos de aprendizaje supervisado que usan condiciones lineales para separar clases entre sí. Estas máquinas, también llamadas SVM (por sus siglas en inglés), resuelven problemas de clasificación y regresión. • Árboles de decisiones: Se forma por “árboles” de decisiones que crean ramificaciones de forma jerárquica. De la misma forma intenta dividir los datos de entrenamiento para tener el mayor número de diferencias entre clases usando diferentes nodos. Su principal objetivo es el aprendizaje inductivo a partir de observaciones y construcciones lógicas, es uno de los más utilizados. Figura 2.4.1.1 Estructura árbol de decisiones. • Algoritmos genéticos: Son algoritmos de búsqueda y aprendizaje, utilizan el cruzamiento y la mutación para generar nuevos elementos. Su eficiencia depende de los parámetros establecidos como “poblaciones sucesivas”. • K-means: Es un algoritmo de agrupamiento en cual selecciona un número de objetos al azar y después trata de encontrar los elementos más cercanos haciendo cálculos de distancia. Ahora, una vez introducidos algunos de los algoritmos que se pueden utilizar, se va a explicar más en profundidad las redes neuronales. 2.4.2. Neuronas biológicas 18 Los algoritmos de redes neuronales son modelos matemáticos inspirados en las neuronas biológicas, intentando asemejar el comportamiento al cerebro humano, por tanto, se va a introducir brevemente una neurona biológica. Su estructura, es un cuerpo celular (soma) que tiene el núcleo del que se extienden las dendritas (terminales receptoras) y el axón (elemento transmisor). La unión entre el axón y la dendrita de dos neuronas se llama sinapsis. La comunicación entre neuronas está basada en terminales bio-químicas en el axón, que se activan liberando neurotransmisores que son captados por la dendrita. Figura 2.4.2.1 Estructura de una neurona 2.4.3. Neuronas artificiales Como se ha mencionado antes, una neurona artificial intenta copiar la estructura de las redes neuronales biológicas, con el fin de conseguir una funcionalidad parecida. Hay 3 conceptos importantes que se van a emular: • Procesamiento paralelo: neuronas operando en paralelo sobre la totalidad de la imagen. • Memoria distribuida: Redundancia en el almacenamiento, para evitar pérdida de información en caso de que se dañe una sinapsis. • Adaptabilidad al entorno: Para generalizar conceptos a partir de casos particulares. En la práctica lo que se utiliza en Deep Learning son estas redes neuronas artificiales, dando la 19 posibilidad de clasificar por ejemplo imágenes o voz a nivel casi humano. Una red neuronal sigue la estructura que se muestra en la imagen siguiente: Figura 2.4.3.1 Estructura de una red neuronal artificial Figura 2.4.3.2 Estructura de una neurona El elemento fundamental de una red es la neurona, también llamada “nodo” o “perceptrón”, está compuesta por componentes principales: entradas, pesos y una función de activación. Las entradas son las señales o características que se proporcionan a la neurona (en el caso de este trabajo se introducen como un arreglo numérico). Las entradas tienen asociado un peso que se usa para la salida, dichos pesos se ajustan en el entrenamiento de la red para optimizar su rendimiento. La función de activación se aplica a la suma ponderada de las entradas y los pesos introduciendo la no linealidad. Permite a la red aprender características o patrones complejos 20 en los datos. Esta función de activación representa simultáneamente la salida de la neurona y su estado de activación. Figura 2.4.3.3 Algunas de las funciones de activación más usadas Otra de las funciones de activación más populares es la función ReLU (Rectified Linear Unit), su funcionamiento es tal que, si el valor de entrada es mayor que cero la salida es igual al valor de entrada; de contrario, la salida es cero. Es decir, activa la neurona sólo si la entrada es positiva y pone a cero los valores negativos. Si se representa el modelo matemático como un sistema eléctrico discreto que lo implementa, se tiene: Figura 2.4.3.4 Modelo electrónico con componentes discretos. 2.4.4. Redes Neuronales Artificiales (ANN) Las neuronas artificiales (AN) se pueden estructurar con capas que interconectan las neuronas por medio de las sinapsis como se puede ver en la figura 2.4.4. El comportamiento de la red se determina por la estructura de las conexiones sinápticas. Las redes se pueden formar por una capa (monocapa) o más (multicapa), además, se pueden diferenciar según el sentido de la información, pudiendo ser unidireccional o con 21 realimentación. Figura 2.4.4.1 Red monocapa realimentada y multicapa unidireccional Para formar la red se apilan las capas dando lugar a estructuras complejas con capa de entrada, capa de salida y capas ocultas. Otro elemento importante que está en las redes neuronales es el aprendizaje, este concepto se refiere a cómo los pesos y las conexiones entre las neuronas se ajustan a medida que la red aprende de los datos de entrenamiento, de forma que se adapta y mejora su rendimiento según recibe más datos de entrenamiento. Hay varios tipos de aprendizaje, pero se van a describir sólo lo más relevantes: • Aprendizaje supervisado: Tiene por objetivo crear una función que pueda predecir el valor numérico o etiqueta de un objeto de entrada, para ello la red recibe el conjunto de datos de entrenamiento etiquetados. La red aprende de estos datos y trata de predecir entradas nuevas no vistas. • Aprendizaje no supervisado: Este tipo de aprendizaje se ajusta a las observaciones, no a un conocimiento previo como en el caso del aprendizaje supervisado. La red se 22 enfrenta a un conjunto de datos no etiquetados, es decir, desconoce la respuesta correcta por lo que intenta encontrar patrones en los datos por sí misma. • Aprendizaje reforzado: Es un sistema que aprende a base de iteraciones con fallo y error. No hay un agente que guie el aprendizaje, sino que aprende a comportarse con un entorno de recompensas y castigos. Tiene por objetivo maximizar las señales de recompensa para tomar las mejores decisiones posibles. 2.4.5. Redes Neuronales Convolucionales (CNN) Una vez explicado qué es una red neuronal y los tipos de aprendizaje se va a profundizar un poco más en un tipo de red en concreto, la Red Neuronal Convolucional o Convolutional Neural Network (CNN por sus siglas en inglés). Es un tipo de red con aprendizaje supervisado que procesa sus capas imitando el ojo humano para identificar las características de su entrada permitiendo identificar objetos, es decir, son una Redes neuronales artificiales que están diseñadas para trabajar principalmente con imágenes. Estas redes son parte del área de Aprendizaje Profundo (de ahora en adelante llamado DL por sus siglas en inglés ‘DeepLearning’). Figura 2.4.5.1 Organización estructural de la IA Cabe destacar que las CNN hoy en día están entre los sistemas con mejores resultados en el campo de reconocimiento de patrones, extendiendo su uso a imágenes, vídeo, voz y audio. Las CNN cuentan con capas convolucionales, que se entienden como un conjunto de filtros llamados campos receptivos, las cuales se ajustan para la extracción de características. Una de las diferencias con las ANN está en la conexión de las neuronas; una ANN conecta todas las 23 neuronas de las capas (Fully Connected), en cambio las CNN comparten neuronas a través de los filtros que permiten extraer información. El principio de las CNN es que una imagen se puede descomponer en elementos clave y cada capa va aprendiendo con distintos niveles de abstracción. Por ejemplo, una capa aprende sobre aristas, otras sobre patrones más básicos y así sucesivamente hasta aprender patrones complejos (Figura 2.4.9). Figura 2.4.5.2 Niveles de abstracción de una CNN Las CNN tiene una arquitectura formada por tres tipos de capas: convolucional, agregación (“polling”), densa, de activación y puede incluir capas de normalización y abandono (“dropout”) según las necesidades del modelo. • Capa convolucional: Su tarea es detectar características o rasgos visuales en las imágenes y, gracias a ello, es capaz de reconocer esa característica en cualquier otro punto de la imagen, permitiendo que pueda aprender de forma eficiente conceptos cada vez más complejos. Para la aplicación de estas capas es común usar filtros o kernels, que recorren la imagen generando mapas de características. 24 Figura 2.4.5.3 Capa convolucional y ejemplo • Capa de agrupación o Pooling: Esta capa busca condensar la información contenida en la capa convolucional. Para realizar esta tarea hay varias formas, algunas de ellas son: agrupación por máximo (“max-pooling”), por mínimo (“min-pooling”) y agrupación por promedio (“average-pooling”) (ver figura 2.4.5.4 con un ejemplo de cada uno). Este trabajo es importante para reducir el coste de realizar el aprendizaje, reduciendo el input sin perder información espacial en el proceso. Figura 2.4.5.4 Tipos de agrupación o pooling • Capa densa: Conecta las neuronas de una capa con los elementos de la siguiente y se usa para clasificar las imágenes de diferentes categorías por entrenamiento. Son 25 similares a las capas de una red neuronal tradicional y son las que se encargan de la clasificación final. • Capa de activación: Es la que define la función de activación de un nodo, la cual define la salida de dicho nodo en función de unas entradas (ver figura 2.4.3.3 para ver algunas de las funciones de activación más usadas). Para este TFG se va a hacer uso de la función de activación softmax, que permite realizar una clasificación con varias opciones calculando la exponencial de cada elemento y luego normaliza cada elemento por la suma de todas las exponenciales, resaltando los valores más grandes y creando una distribución de probabilidades para poder elegir la de mayor probabilidad. • Capa de normalización y abandono (“Dropout”): La capa de normalización busca evitar la dispersión del gradiente, para ello se normaliza. Generalmente, las CNN normalizan por lotes (“Batch”) ya que la neurona recibe la entrada de todas. Por otra parte, se tiene la capa de Dropout, la cual se usa para evitar el sobre aprendizaje. Esta técnica consiste en que algunas neuronas dejan de trabajar aleatoriamente durante la fase de entrenamiento, para forzar a las que quedan a aprender en lugar de limitarse a memorizar, con lo que puede clasificar imágenes fuera de los datos del conjunto de entrenamiento. Hay que añadir que la principal diferencia entre capas de convolución y densas es que las capas densas aprenden patrones globales de la imagen, en cambio las capas de convolución aprenden patrones locales. Figura 2.4.5.5 Imagen que se separa en patrones locales 32 El software se basa en el uso de diversas herramientas y bibliotecas. A continuación, se detallan las más importantes: • Sistema operativo: Se ha elegido el Raspbian, que es el sistema operativo oficial que puede ser descargado directamente desde la página oficial de la empresa Raspberry. • Python: Es el lenguaje de programación principal que se ha usado en el desarrollo de este proyecto. Este lenguaje proporciona una gran variedad de herramientas, bibliotecas y guías para el aprendizaje automático, procesamiento de imágenes y manejo de la placa Raspberry pi. • OpenCV: Como se ha indicado antes esta es la librería más popular que se encarga de gestionar la visión artificial. • TensorFlow y Keras: Estas dos bibliotecas son específicas y optimizadas para el aprendizaje automático y redes neuronales, por lo que son las que dan forma al programa de entrenamiento. TensorFlow permite la implementación de redes neuronales de forma eficiente y optimizada, mientras que Keras facilita la construcción y entrenamiento del clasificador. • Mediapipe: También mencionada antes, es la biblioteca desarrollada por Google que simplifica la detección de la posición de las manos y ayuda a extraer el área de interés. 3.2. Implementación del programa de creación del dataset 3.2.1. Detalles de la estructura y organización del dataset Para el diseño de este trabajo, inicialmente se planteó usar un dataset ya hecho por otro usuario, para ello se hizo una búsqueda en el popular repositorio Kaggle y se eligieron distintos datasets para probarlos y ver el rendimiento del clasificador entrenado. Los distintos problemas con los datasets usados se especificarán más adelante. Puesto que los datasets descargados de kaggle daban distintos fallos, al final se optó por crear un dataset desde cero y para ello se creó un programa específico que, en resumen, accede a la cámara, dibuja un cuadro alrededor de la mano y usando una función, guarda en una dirección especificada. 33 Ahora se va a explicar las librerías usadas y después se va a explicar en detalle el programa. • Librerías o Mediapipe: Es una librería de código abierto desarrollada por Google que se va a usar para identificar las manos y su posición central, que se va a usar de referencia para dibujar el cuadro. o Os: Esta es una librería estándar de Python que permite la interacción con el sistema operativo. Esta librería se usa para crear/renombrar archivos y carpetas, obtener rutas sobre dichas carpetas archivos, etc. o Cv2: Abreviación de la librería OpenCV, como se ha explicado antes, se usa para la visión artificial y procesamiento de imágenes. Esta es la librería que va a acceder a la cámara. o Matplotlib: Se encarga de la representación de datos, permitiendo crear gráficos, diagramas, entre otros. En este caso se usa para representar imágenes y datos. o Numpy: Librería fundamental para la computación numérica en Python que proporciona funciones para realizar cálculos numéricos, tratamiento de matrices y arreglos multidimensionales. o Sutil: Otra librería estándar de Python que proporciona funciones más avanzadas para operaciones de manipulación de archivos. En este programa se usa para limpiar la carpeta del dataset. o Threading: Librería que proporciona herramientas para la programación concurrente. En este proyecto se usa para ejecutar simultáneamente una función y el programa principal. 34 Figura 3.1.1.1.1 Librerías para creación de data set Una vez introducidas las librerías se va a desarrollar el programa, se inicializan algunas funciones. La variable “capture” va a gestionar la apertura y cierre de la cámara, mientras que “clase_manos” y “manos” se usa para trabajar con la librería mediapipe. Figura 3.1.1.1.2 Inicialización Para permitir un uso más genérico del programa en lugar de introducir un vector fijo conteniendo las clases que se van a categorizar, en este caso las letras del abecedario a-z (sin la ñ), se ha creado un trozo que se va a encargar de preguntar al usuario cuales son las categorías (una a una) que se desean para crear las carpetas correspondientes donde se van a guardar las fotos y una vez se hayan introducido todas las categorías deseadas, el usuario debe escribir “fin”. El uso de la espera de “fin” se hace para no limitar a un número fijo las categorías a crear. Figura 3.1.1.1.3 Definición de categorías Como se ha mencionado, para este proyecto el vector contendrá las letras de la a-z de abecedario inglés y se va a denominar “classes”. Figura 3.1.1.1.4 Categorías a usar en este proyecto Una vez definidas las categorías que va a tener el programa, se procede de forma similar, preguntando al usuario cuántas fotos quiere el usuario para cada una de las categorías. En este 35 caso se ha limitado a que se introduzca un número de 2 dígitos de forma arbitraria, podría modificarse a cualquier otro límite o incluso quitarlo. Figura 3.1.1.1.5 Número de fotos que se van a tomar Para el data set final se han usado 70 fotos de un dataset descargado de Kaggle, y para mejorar su comportamiento se han añadido 30 fotos de la mano de un hombre y 30 fotos de la mano de una mujer. A continuación, limpia todo lo que haya en la carpeta donde van a estar las categorías, eliminando así categorías de programas anteriores o duplicados evitando posibles problemas. Para este proyecto se va a tener en la carpeta llamada ‘my_dataset’ varias carpetas con las categorías y dentro de cada carpeta de categoría estarán las fotos nombradas con el nombre de la categoría seguida de un número. Figura 3.1.1.1.6 Contenido de la carpeta “my_dataset” y contenido de una de las carpetas 36 Figura 3.1.1.1.7 Limpieza de la carpeta “my_dataset” Una vez limpia la carpeta y definidas las categorías que se desean, se van a crear las carpetas que, asignadas a cada una de las categorías, para ello se hace uso de un bucle que recorre el vector de “classes”, extrayendo la categoría y creando una carpeta con su nombre. Figura 3.1.1.1.8 Creación de las carpetas relacionadas a las categorías En este punto, se tiene creadas las carpetas, definidas las categorías y el número de fotos que se va a hacer para cada una, así que se procede con la toma de fotos. Para ellos se ha creado una función llamada “tomar_fotos” que recibe 2 argumentos: • Folder_name: Que contiene la dirección asociada a una categoría. • Num_fotos: Que como su nombre indica, contiene el número de fotos que se van a hacer para esa categoría. • X1, X2, Y1, Y2: Coordenadas que forman un cuadro con el área de interés. 37 Función “tomar_fotos”: Esta función primero comprueba que exista la carpeta de la categoría correspondiente. Una vez comprobado esto se procede a entrar en un bucle el cual primero define el nombre con el que se va a guardar la foto (recordemos es el nombre de la carpeta seguido de un número) y se concatena la dirección con el nombre. Por ejemplo, si tenemos la dirección de carpeta “C:// users/Project/my_dataset/a” y el nombre que queremos es “a1” ya que es la primera foto, al concatenar nos queda “C:// users/Project/my_dataset/a/a1.jpeg” Figura 3.1.1.1.9 Definición de la dirección para guardar la imagen Con la dirección y nombre definidos, se procede a hacer una captura de lo que se visualiza en la Cámara con la instrucción “capture.read” de OpenCV. La función termina haciendo uso de las coordenadas que se han introducido, recortando la imagen según el área de interés ROI (Region of interest) y guardándola según la dirección y nombre previamente indicados. Se ha añadido un tiempo de espera de 1 segundo para que el usuario pueda realizar pequeñas modificaciones en la posición de la mano, evitando así que se hagan todas las fotos seguidas y por tanto, que sean demasiado parecidas. Figura 3.1.1.1.10 Recorte de área de interés y guardado de la imagen recortada Bucle Antes de empezar con el bucle que se encarga de extraer las coordenadas del área de interés ROI, se hace una inicialización en la que se habilita la captura de imagen y se instancian elementos para el uso de la librería mediapipe. 38 Figura 3.1.1.1.11 Inicialización e instancia Para extraer el área de interés se ha hecho uso de un bucle que constantemente hace una captura de la imagen con la que se va a hacer un tratamiento para extraer los puntos que delimitan dicha área y posteriormente se dibuja un rectángulo para que el usuario pueda verla. Esa área, ayuda a que se pueda asegurar de que mantiene la mano dentro del cuadro para un mejor resultado en la creación del dataset. Se optó con la creación de un cuadro fijo en el área de interés ya que desarrollar un sistema que tenga en consideración la cercanía/lejanía de la mano sería muy complicado para el ámbito de este proyecto, y el cuadro es una alternativa efectiva. En este bucle lo primero que se hace es hacer la captura dela imagen antes mencionada y se cambia el formato de color de BGR (Blue-Green-Red) a RGB (Red-Green-Blue), ya que OpenCV por defecto trata las imágenes en formato BGR y mediapipe espera imágenes con formato RGB. Figura 3.1.1.1.12 Captura y adecuación de formato Ahora, con la imagen en el formato correcto, se obtendrá el mapa de puntos utilizando la biblioteca mediapipe. Para ello se utiliza "manos.process", esta función es la que pasa la imagen por el modelo de detección y seguimiento de manos desarrollado por medipipe, creando un mapa de puntos que se almacena en el atributo ".multi_hand_landmarks".Véase en la imagen 3.1.1.1.13 que, además, se crea un vector llamado “posiciones”, dicho vector va a contener elementos de 3 datos: • El id del punto, el cual es un número entre 0-20 (ver figura 2.5.2.2) • La coordenada x de dicho punto • La coordenada y de dicho punto Figura 3.1.1.1.13 Introducción en modelo de mediapipe 39 En este momento se tiene en la variable “resultados” la imagen de la mano con el mapa de puntos, sin embargo, las coordenadas que nos devuelve en x e y están normalizadas. Por tanto, para obtener las coordenadas reales se tiene que multiplicar por el ancho y alto real de la imagen. Para conseguir eso se ha usado un pequeño sub-bucle que recorre cada punto: primero guarda las dimensiones de la imagen, luego multiplica esas dimensiones por la coordenada normalizada y guarda el id junto con las coordenadas reales en el vector “posiciones”. Figura 3.1.1.1.14 Creación vector con el mapa de puntos Arbitrariamente se ha elegido el punto 9 (ver figura 2.5.2.2) como el más próximo al centro de la mano, y con esa referencia se marcan los extremos de un cuadro alrededor. El área que contiene el cuadro es la región de interés ROI, ya que contiene solamente la mano y elimina el resto de información que no es relevante para el clasificador. Figura 3.1.1.1.15 Extracción de región de interés. Para poder hacer que las fotos se hagan cada segundo mientras que el usuario puede ver en tiempo real la imagen de la cámara, hizo falta añadir una forma de que la función antes definida y el bucle se ejecuten en planos distintos. Esto se consiguió con el uso de la librería threading, la cual implementa una instrucción que ejecuta en segundo plano una función, para ello se introduce como primer argumento el nombre de la función y como segundo argumento lo elementos que espera la función. Figura 3.1.1.1.16 Ejecución en segundo plano 40 En conclusión, el programa hace emerger una ventana donde el usuario verá un cuadro alrededor de la mano, espera a que se introduzca una señal por teclado (tecla ‘c’) para empezar a hacer las fotos de una categoría, una vez ha acabado de hacer el número de fotos espera que se vuelva a mandar la señal por teclado. Para interrumpir el programa o para confirmar que se ha acabado se debe presionar la tecla ‘q’, con lo que sale del bucle, deja de capturar la imagen y cierra la ventana emergente. Figura 3.1.1.1.17 Función completa Figura 3.1.1.1.18 Inicialización y bucle completo 3.3. Implementación del programa de entrenamiento del modelo 41 Este programa es el corazón del proyecto, ya que es el que se encarga de adecuar los datos de entrenamiento, definir el modelo y entrenar la red neuronal para que aprenda a clasificar el lenguaje de signos. Usa las imágenes que se capturaron en el programa anterior para el entrenamiento y se añadieron 70 fotos de cada letra de un dataset que se obtuvo por la página Kaggle, haciendo un total de 130 fotos por cada letra, 70 de Kaggle, y 60 hechas con el programa anterior (30 de hombre y 30 de mujer). A continuación, se va a hacer una breve descripción de el uso que se ha dado a las librerías usadas (Figura ---): • Os: Al igual que en el anterior programa se usa para poder acceder a los archivos del ordenador, en este caso ayuda a cargar el dataset y leer las categorías para establecer las etiquetas. • OpenCV: Se usa para la visión artificial, permitiendo cargar las imágenes. • Numpy: Permite trabajar con números, es muy útil ya que para procesar los datos se convierten en arreglos numéricos. • Matplotlib, sklearn y seaborn: Encargadas la visualización de datos y resultados. • TensorFlow y Keras: Como se ha mencionado antes, son bibliotecas muy usadas para el aprendizaje automático, que permiten la creación y gestión de las redes neuronales. Figura 3.3.1 Librerías usadas Puesto que este programa es el que requiere mayor uso de los componentes, para que se pueda entrenar de forma mucho más rápida se ejecuta usando la GPU del ordenador. Puesto 48 Figura 3.3.3.1 Parámetros de la CNN En cuanto al optimizador, se ha usado ‘adams’ que es muy popular por optimizar el aprendizaje de los modelos de forma rápida y eficiente. Y para la función de pérdida se ha usado ‘categorical_crossentropy’ para medir el error de las predicciones del modelo, esta función es muy usada en modelos multiclase. Para poder evaluar el rendimiento del modelo durante el entrenamiento se va a evaluar la precisión del modelo, viendo la proporción de muestras correctamente clasificadas. Figura 3.3.3.2 Optimizador y función de pérdida de la CNN Una vez definidos los parámetros necesarios para el entrenamiento, se procede a entrenar el modelo. Para ello la librería keras proporciona la instrucción ‘.fit’ en la cual se introducen los datos de entrenamiento y de testeo, el batch y las épocas antes mencionadas. Además de estos parámetros se añaden dos propiedades: • Shuffle: Esta propiedad puede tener valor ‘True’ o ‘False’, y su función es barajar aleatoriamente los datos antes de empezar una época nueva, ayudando a la generalización del modelo. • Verbose: Es una propiedad que permite elegir la información que se puede ver, en este caso se ha elegido ‘1’ que es el modo que más información proporciona. Figura 3.3.3.3 Entrenamiento de la CNN Cuando el modelo ha acabo de entrenar, se hace una comprobación de la CNN en la que se puede observar la precisión final del modelo al clasificar el conjunto de datos de testeo. 49 Figura 3.3.3.4 Comprobación de la precisión de la CNN Para finalizar, el modelo entrenado se guarda en una carpeta para poder exportarlo a otros programas. Figura 3.3.3.5 Guardado del modelo 3.4. Implementación del programa de clasificación en tiempo real Este es el programa final, que va a cargar el modelo pre-entrenado y va a tomar una foto de la lo que ve la cámara, esta foto se va a recortar del mismo modo que en el programa de creación del dataset, es decir, se dibuja un cuadro alrededor de la mano y se extrae esa área de interés. Una vez tiene la foto hecha, la redimensiona para poder introducirla al modelo y hace la predicción. Esta predicción se debe imprimir en el display SSD 1306. 3.4.1. Captura de imágenes con OpenCV y mediapipe La captura de imágenes se hace del mismo modo que en el programa de creación del conjunto de datos, se usa un bucle que abre la captura de imagen de la cámara. La imagen se observa en una ventana emergente para que el usuario pueda estar al tanto de lo que se va a capturar. El programa espera a que se introduzca una señal por teclado (q) para salir del bucle, guardando la última captura que se ha hecho, deshabilitando la cámara y cerrando la ventana emergente. En el bucle además de hacer la captura, se usa la librería mediapipe para extraer las coordenadas con las que se va a dibujar el cuadro que marca el área de interés y se va a recortar la imagen. 50 Figura 3.4.1.1 Programa que extrae la región de interés y lo guarda en una foto. Con la foto guardada en una carpeta y con un nombre específico, se procede a cargar esa foto en concreto y su redimensionado para poder introducirla en el modelo. Además del redimensionado el modelo espera una imagen normalizada puesto que así se hizo en el entrenamiento, con lo que la nueva imagen también se ha de normalizar. Figura 3.4.1.2 Procesado imagen y clasificación Con el preprocesado hecho, el clasificador intenta predecir qué es lo que se visualiza en la imagen y devuelve en una variable el vector que contiene la probabilidad que tiene cada uno de los elementos. Por supuesto, esto es una forma poco visible de saber qué salida ha dado el clasificador, por lo que se usa la librería numpy para extraer la posición que tiene el número con mayor probabilidad, resultando la posición en el vector que tiene dicha probabilidad. Sabiendo la posición para poder indicar la letra que se ha reconocido, hay que hacer uso del vector que contiene todas las categorías e imprimir el elemento que tenga ducha posición. 51 Figura 3.4.1.3 Clasificación de una imagen de prueba En este punto, se tiene preparado el programa para su uso en un ordenador, pero se tiene que ejecutar en una Raspberry pi 4. Por lo que ahora se va a proceder a la configuración y adaptación del programa para poder ser usado en dicho microordenador. También hay que tener en cuenta que para el uso del display SSD 1306, hay que usar una librería especial para poder actuar sobre él desde Python. Esta librería es “Adafruit SSD 1306”. 3.4.2. Configuración Raspberry Para configurar la Raspberry pi 4, se necesitan: • Microordenador Raspberry pi 4 • Cable Ethernet • Cable de alimentación • Tarjeta microSD • Conexión a internet • Adaptador microSD a SD normal 52 Lo primero que se necesita es el sistema operativo que se va a usar, en este caso se ha elegido usar el sistema operativo oficial Raspbian, proporcionado por la propia empresa de Raspberry. Para descargar Raspbian hay que hacer uso de una herramienta que también la proporciona la empresa de Raspberry. Esta es Raspberry Pi Imager (ver figura ---), que permite formatea la microSD e instala el sistema operativo elegido. Figura 3.4.2.1 Instalador de Sistema operativo Raspbian Para esto se conecta la microSD al ordenador, se elige el sistema operativo y la tarjeta de almacenamiento. Para el sistema operativo se ha elegido el de x64 bits, es importante tener en cuenta si se instala el de x32bits que las últimas versiones de TensorFlow no son compatibles por lo que se recomienda seleccionar el de x64 bits. Antes de instalar el sistema operativo, se van a modificar algunas características en los ajustes: • Se habilita el SSH • Se establece un usuario y una contraseña 53 Figura 3.4.2.2 Activación de SSH Con esto hecho, se puede retirar la SD y conectar la microSD a la Raspberry pi 4. A veces puede dar un fallo en la activación del SSH, para solucionarlo hay que crear un archivo sin extensión en la SD con nombre “SSH” una vez se ha instalado el sistema operativo. Se va a acceder a la Raspberry en remoto usando el SSH, para ello se necesitan dos aplicaciones extra: • Advanced IP scanner: Esta se usa para obtener la dirección IP de todos los aparatos conectados a la red. • RealVNC viewer: Esta aplicación es un software que permite acceder de forma remota a un ordenador, usando el protocolo VNC (Virtual Network Computing). Hechos los pasos previos, hay que introducir la tarjeta microSD si no se ha hecho aún, conectar el cable ethernet en el puerto correspondiente y conectar la alimentación del microordenador. Estando conectada a la red, se puede hacer uso de Advanced IP scanner para obtener la IP de la Raspberry. Para empezar la configuración, desde el ordenador y con la aplicación de símbolo de sistema, se tiene que activar el VNC para poder conectarse en remoto. En el símbolo de sistema se introduce “ssh user@ip_Raspberry -y”, sustituyendo “user” por el usuario que se ha establecido en Raspberry Pi Imager y sustituyendo ip_Raspberry por la IP que se ha obtenido con Advanced IP scanner. Ejecutar el comando va a permitir acceder a la configuración después de introducir la contraseña que se definió también en Raspberry Pi Imager. 54 El propio programa va a mencionar que para acceder a la interfaz de configuración, se debe ejecutar el comando “raspi-config”, el cual hará emerger una ventana para la configuración en la que se va a activar el protocolo VNC en las opciones de interface. También se podría activar en ese mismo menú el bus I2C que usa el display SSD1306, sin embargo, se va a activar más adelante para mostrar cómo se haría desde dentro de la Raspberry. Figura 3.4.2.3 Activación de VNC Con todo hecho, se procede a usar RealVNC Viewer en el cual se introduce la ip asociada a la Raspberry y se podrá observar la interfaz operativa de Raspbian. 55 Figura 3.4.2.4 Pantalla de inicio Raspberry 3.4.3. Creación entorno Si se han hecho correctamente los pasos antes descritos, la Raspberry pi debería estar preparada para su uso por lo que se procede a la creación de un entorno virtual que contenga las librerías necesarias para la ejecución del programa. Las librerías a instalar son: • OpenCV • TensorFlow • Mediapipe • Adafruit_SSD1306 La primera biblioteca que instalar será TensorFlow, esta tiene un problema general y es que no tiene soporte para Raspberry por lo que para poder instalarla se necesita seguir unos pasos 56 previos para su descarga con Piwheels. Piwheels es un proyecto que ofrece un repositorio de paquetes ya compilados para la plataforma Raspberry Pi, proporcionando una forma más rápida y conveniente de instalar paquetes de Python. Para empezar, se van a revisar las características del sistema operativo Raspbian con el comando “cat /etc/os-release”. Se puede observar que la instalación elegida (Raspbian x64 bits) está desarrollado con Linux 11 (Bullseye). Figura 3.4.3.1 Características del SO Raspbian Es recomendable que, antes de hacer cualquier instalación se actualice el sistema de la Raspberry Pi son los comandos “sudo apt update” y “sudo apt upgrade -y”. Figura 3.4.3.2 Actualizar sistema Raspberry Con todo actualizado se procede a ver la versión de Python y la arquitectura que se está utilizando, esto es importante para saber qué versión de TensorFlow se tiene que instalar. Como se puede ver en la figura ----, en este proyecto la Raspberry tiene Python 3.9.2 y una arquitectura ARM64. 57 Figura 3.4.3.3 Versión de Python y arquitectura (arm architecture) Para poder crear un espacio virtual es necesario instalar los paquetes “Virtualenv” y “Python3”, que se utilizan con sistemas basados en Debian para crear entornos aislados para desarrollar y ejecutar programas de Python con sus propias dependencias y configuraciones. Figura 3.4.3.4 Descarga de creador de entornos Se procede a la creación y activación de un entorno en el que se van a instalar las librerías necesarias para la ejecución del programa, a este entorno se le va a llamar “tf” y se va a guardar en una carpeta especificada destinada a contener todo el contenido del programa objeto de este proyecto. Figura 3.4.3.5 Creación de un entorno virtual tf 64 En este punto se tiene ya todo preparado para el uso del programa, solo falta pasar el programa que hace la foto y la pasa por el modelo, y el modelo preentrenado, a la Raspberry. Esto se puede hacer o bien con un elemento de almacenamiento USB que contenga una copia del programa o bien si se quiere enviar por ssh usando el comando “scp archivo origen usuario@direccion_ip_Raspberry:directorio_destino” donde: Archivo origen: es la ruta completa del archivo que se va a enviar. Usuario: se introduce el usuario que se estableció en la Raspberry Pi cuando se instaló el sistema operativo (ver figura 3.4.2.1) Dirección IP Raspberry: la dirección asociada a la Raspberry que se puede conseguir haciendo uso de Advanced IP Scanner como se indicó antes. Directorio destino: Es la carpera donde se va a guardar el programa. Además, tener en cuenta que, si se va a enviar una carpeta en lugar de un archivo, antes de origen de usuario hay que añadir “-r “, que copia todos los archivos en la dirección especificada. SCP significa “secure copy”, como su nombre indica hace una copia de los elementos de la dirección origen a la dirección destino. Realizados todos los pasos correctamente, se tiene el programa disponible para su uso con el editor de código Jupyter Lab. Sin embargo, el programa se limita a hacer la predicción y guardar dicha clasificación en una variable llamada “classes”, así que se va a explicar las modificaciones que se tienen que hacer para poder representar dicha letra en el SSD 1306. 3.4.4. Preprocesamiento de imágenes en el display de la Raspberry Pi Antes de proceder a explicar el programa, se va a explicar el cableado del oled SSD 1306. Para ello se puede acceder al datasheet del fabricante, en el cual se puede observar que la tensión de alimentación puede ser de 3.3V. En la Raspberry Pi 4 se tiene un pin que permite esa tensión (ver figura 2.5.2.4). También viendo el esquema del GPIO (ver figura 2.5.2.4) se puede observar que se tiene un pin para SDA, SCL y tierra, con lo cual se procede a hacer la conexión (ver figura 3.4.4.1) 65 Figura 3.4.4.1 Esquema conexión SSD 1306 a Raspberry Pi 4 Teniendo ya el SSD1306 conectado, se va a explicar el programa. Para el correcto funcionamiento del programa hay que recordar actualizar todas las rutas que se referencian en el programa, actualizando a la ruta asignada en la Raspberry. Además, en la anterior versión del programa para obtener el vector con las categorías a clasificar se hacía con “os.listdir” y se leían las carpetas que existían en la ruta de entrenamiento. Esto se va a modificar por dos razones: • En la Raspberry sólo está el programa que clasifica la imagen, no contiene la carpeta con los datos de entrenamiento. • Se ha considerado más conveniente simplemente crearlo manualmente debido a las limitaciones de la Raspberry, esto se hace porque la Raspberry que se ha usado tiene únicamente 2GB de RAM por lo que se quiere reducir todo lo posible el uso de operaciones para evitar problemas. 66 Por lo tanto, la primera modificación que se ha hecho es crear el vector con las categorías “classes” manualmente (ver figura 3.4.4.2). Figura 3.4.4.2 Creación manual del vector “classes” Con esto y recapitulando un poco, se tiene un programa que carga un modelo, captura una imagen que contiene el área de interés haciendo uso de las librería OpenCV y Mediapipe y se hace pasar la imagen capturada por el clasificador con la librería TensorFlow, una vez hecha la clasificación se guarda en la variable “predic_label” como un vector de probabilidades, con ayuda de numpy usando la instrucción “argmax” se obtiene la posición con la mayor probabilidad, dicha posición es la del vector “classes”. Figura 3.4.4.3 Visualización de resultados Se procede a ampliar el programa para añadir la funcionalidad de pintar la letra resultado de la clasificación en el SSD 1306. Para ello se tienen que importar cuatro librerías que se descargaron antes, estas son: • Board: Proporciona constantes que facilitan el acceso a los pines y características de la Raspberry Pi, por ejemplo, en este caso se usa para poder referenciar los pines GPIO 2 y GPIO 3 como SDA y SCL respectivamente. • Busio: Se usa para crear y configurar interfaces de comunicación, es la que va a hacer posible el uso del bus I2C que usa el SSD 1306. 67 • PIL (Python Imaging Library): Permite la creación y manipulación de imágenes antes de mostrarlas en el SSD 1306. • Adafruit_ssd1306: Como se mencionó antes, es la que permite el uso del SSD 1306. Figura 3.4.4.4 Librerías para la gestión del SSD 1306 Con las librerías necesarias instaladas se hace la inicialización de la pantalla y de lo pines. Figura 3.4.4.5 Inicialización de SSD 1306 En este momento, finalmente se puede escribir el código que interactúa con el SSD 1306. Para este proyecto se ha optado por la creación de una función que será la encargada de pintar la letra resultado de la clasificación. Esta función se va a llamar “pintar_letra” y espera un único parámetro, que es la letra mencionada (como carácter, no su posición ni el vector). Función “Pintar_letra” La función empieza limpiando la pantalla para evitar que se solapen dibujos anteriores con el que se pretende pintar nuevo. Para ello se pinta toda la pantalla de negro. Figura 3.4.4.6 Limpiar pantalla Hecho esto, se procede a crear una imagen vacía donde se va a representar la letra, para ello se hace uso de la librería PIL. Esta librería crea una imagen que se va a poder pintar en blanco y negro, ya que se introduce 1 en el primer parámetro, y se establece el tamaño que tendrá, en este caso tendrá el tamaño del SSD 1306. Con la imagen creada, se va a crear un objeto 68 (draw) asociado a ella, permitiendo dibujar sobre la imagen vacía que se ha creado antes y así agregar contenido visual. Figura 3.4.4.7 Creación de imagen en blanco y objeto para interactuar Para dibujar la letra, se ha descargado una fuente desde “Google fonts” debido a que la fuente se tiene por defecto es muy pequeña y tiene un tamaño fijo, en cambio las fuentes descargadas tienen mayor variedad de estilos y tamaños. En este caso se ha descargado la fuente DM Sanz, que tiene un tamaño de hasta 36 pts, en el programa para poder trabajar con esta fuente, se ha añadido en una variable (Font) donde se le ha asignado un tamaño de 24 pts usando la librería PIL. Figura 3.4.4.8 Importar fuente descargada Para terminar la función se tiene que poner el puntero en la posición donde se va a representar en la pantalla. Puesto que es una única letra se ha decidido pintar dicha letra en el centro de la pantalla. Para ello se han obtenido las coordenadas del cuadro que delimita la letra, con ellas se calcula su ancho y alto. Para las coordenadas se resta el ancho/alto de la letra al ancho/alto de la pantalla y se divide a la mitad, quedando el puntero en una posición que centre la letra. Figura 3.4.4.9 Establecer coordenadas de la letra Para finalizar la función, simplemente se pinta en la elemento que se creo antes, en este caso se escribe en la posición central indicada por las coordenadas que se acaban de obtener, la letra que se introduce en la función y con la fuente seleccionada, además, al añadir “fill=255” 69 se indica que lo que se va a pintar va a ser en blanco en contraste al fondo negro. Para hacer visible el dibujo se indica al oled que la imagen que se va a representar es “img” y se actualiza la pantalla. Figura 3.4.4.10 Pintar en la pantalla Solo queda llamar a la función y se obtiene en el SSD 1306 la letra, dando así por finalizado el paso final del proyecto. Figura 3.4.4.11 Llamada a la función Figura 3.4.4.12 Resultado final 4. RESULTADOS Y EVALUACIÓN 4.1. Evaluación del modelo de clasificación A continuación, se va a estudiar con dos gráficos el comportamiento de la CNN. 70 Figura 4.1.1 Gráficas precisión frente épocas y pérdida frente épocas respectivamente En la primera gráfica se puede ver cómo ha ido evolucionando la precisión frente las épocas y en la segunda se puede ver cómo ha evolucionado la función de pérdida frente a las épocas. En ambas se puede ver que, aproximadamente, en la época 10 el modelo ya casi ha alcanzado una precisión del 97% y una pérdida cercana a 0. A partir de esta época mejora poco sus características, lo que nos indica que no es necesario poner tantas épocas para este modelo. Por otra parte, para poder ver desde otra perspectiva la precisión, se ha hecho uso de una matriz de confusión y un mapa de calor que permitan ver en una matriz y con colores la concentración de datos, en la diagonal de la matriz se encuentran las predicciones correctas y todo valor que esté fuera de la diagonal son predicciones incorrectas. Figura 4.1.2 Matriz de confusión del modelo 71 Como se puede observar, el modelo ha tenido un muy buen rendimiento a la hora de aprender y clasificar imágenes que forman parte del dataset, pero esto no asegura su correcto funcionamiento con imágenes que estén fuera del mismo. Como se ha podido observar, en el entrenamiento el modelo ha dado un muy buen comportamiento (ver figura 3.3.3.4), estando por encima del 98%. Sin embargo, se han hecho pruebas con todas las letras usando imágenes hechas con el programa clasificador y se ha podido observar que hay seis letras que no las clasifica adecuadamente, estas son la A, la E, la J, la R, la U y la V. Por ejemplo, la A se clasifica como un S, la E se clasifica como una E. En cuanto al resto de letras la mayoría la clasifica como se espera, dejando de lado que en algunas ocasiones se equivoca, pero al jugar con la distancia se clasifica correctamente. En general, puesto que de veintiséis letras solamente seis dan fallo, se puede considerar aceptable teniendo en cuenta las limitaciones que existen. 4.2. Análisis de los resultados obtenidos Viendo los resultados obtenidos, se puede concluir que la mayoría de los problemas se deben principalmente a dos factores: • Dataset muy pequeño (130 imágenes). • Hay signos que son muy parecidos. Para el caso de signos muy parecidos, como puede ser el caso de la A y la S (ver figura 4.2.1), se puede observar que la única diferencia es la posición del pulgar, haciendo que sea más fácil confundirse. 72 Figura 4.2.1 Similitud entre signo de la A y la S 4.3. Posibles soluciones Para el caso de el tamaño del dataset la solución es clara, aumentar el tamaño del dataset. Para ello se tiene que aumentar el número de fotos que se hace en el programa de creación del dataset. Además, sería conveniente aumentar la variedad de las fotos ya sea introduciendo cambios de luz, variar la distancia, introducir manos con características distintas como puede ser en tamaño, color de piel, manos de hombre, mujer, niño, persona mayor, etc. En definitiva, aumentar todo lo que se pueda la variedad y tamaño del dataset. También se puede considerar el uso de un generador de imágenes en el entrenamiento, este añade distintas variaciones artificiales al dataset (ver figura 4.3.1). En la realización de este proyecto se hizo un intento de modelo usando un generador de imágenes en el cual se añadían imágenes que tenían acercamiento y rotación aleatorio, pero dio un peor funcionamiento. 73 Figura 4.3.1 Propiedades del generador de imágenes. En el caso del acercamiento el fallo puede estar en que al extraer el área de interés con mediapipe y OpenCV, si se acerca la foto, se pierde información como se muestra en la siguiente figura. 80 Además, se puede intentar ampliar conocimiento para trabajar con imágenes en movimiento puesto que, siguiendo en la línea del lenguaje de signos, hay palabras que se transmiten con movimiento por lo que para su clasificación se necesita por aprender a partir de movimientos. Aplicando otro enfoque, también se puede ampliar conocimiento para clasificar señales que no necesariamente sean imágenes, por ejemplo, se podría clasificar señales de sonido. También se puede aprender a usar otros tipos de redes, ya que en este proyecto sólo se han usado redes convolucionales, pero existen otras como los árboles de decisión. 7. Diagrama de Gantt y presupuesto 7.1. Diagrama de Gantt La planificación inicial para el proyecto fue la siguiente: Sin embargo, en la práctica, el periodo de aprendizaje previo y creación del programa requirió más tiempo, teniendo que aprender a la vez que se iba desarrollando el programa. Además, 81 ha habido aspectos nuevos de los que se tuvo que aprender que surgieron mientras se desarrollaba el proyecto. 7.2. Presupuesto Para este proyecto, se necesitan distintos materiales que traen un coste. Se va a detallar cada uno de ellos: Costes básicos del proyecto Componente Precio Comentarios Raspberry Pi 4 60-100€ El precio varía en función de la memoria RAM Alimentación 36€ Coste real en una tienda de electrónica Cable Ethernet 3€ Precio medio de un cable básico en internet Tarjeta microSD 8€ Precio en Amazon Protoboard y cables 15€ Precio en Amazon Display OLED SSD1306 7€ Precio en Amazon Cámara 70€ Esos son los costes para el caso de este proyecto, en el cual se hizo la conexión remota por SSH, si no se hubiese hecho en remoto habría que añadir: Componente Precio Comentarios Teclado 10€ Coste real en una tienda de electrónica Mouse 12€ Coste real en una tienda de electrónica Cable HDMI- microHDMI 9€ Precio medio de un cable básico en internet Pantalla o monitor - En este caso el precio es muy variado según lo que desee el usuario. Hay que añadir que, por suerte, para la realización de este proyecto ya se disponía de la mayoría de los elementos. Lo que se tuvo que adquirir nuevo fueron la protoboard y cables, el display OLED SSD1306 y la alimentación de la Raspberry. En cuanto a la mano de obra, considerando que un ingeniero cobre aproximadamente 25€ la hora, y teniendo en general aproximadamente 352 horas (8h/día durante 2 meses) juntando todo lo que se ha dedicado se tendría un coste de mano de obra de 8800€ 82 8. Referencias bibliográficas Adafruit Industries. (s. f.). GitHub. Recuperado 20 de julio de 2023, de https://GitHub.com/adafruit Amezcua Aguilar, T., & Amezcua Aguilar, P. (2018). Contextos inclusivos: El reconocimiento de la lengua de signos como derecho de las personas con diversidad funcional. Index.comunicación: Revista científica en el ámbito de la Comunicación Aplicada, 8(1), 123- 148. Anwarul, S., & Joshi, D. (2020). Deep Learning With TensorFlow (pp. 96-120). https://doi.org/10.4018/978-1-7998-3095-5.ch004 Arias, V., & Manuel, J. (s. f.). Modelo de aprendizaje profundo/red neuronal convolucional (CNN) para clasificación de calidad de ácidos grasos por imágenes de semillas de Helianthus annuus. Ayora, M. J. M. (s. f.). Uso de redes neuronales para identificación de matrículas. Bishop, C. M. (s. f.). Neural Networks for Pattern Recognition. Bishop, C. M. (2006). Pattern recognition and machine learning. Springer. Chollet, F. (2018). Deep learning with Python. Manning Publications Co. clueple c (Director). (2019, junio 3). Install Jupyter Lab | Linux Or Raspbian| Set Dark Theme | 2019. https://www.youtube.com/watch?v=gV0DtmWYpLA codebasics (Director). (2020, noviembre 1). Data augmentation to address overfitting | Deep Learning Tutorial 26 (TensorFlow, Keras & Python). https://www.youtube.com/watch?v=mTVf7BN7S8w DM Sans. (s. f.). Google Fonts. Recuperado 20 de julio de 2023, de https://fonts.google.com/specimen/DM+Sans EvidenceN (Director). (2021, enero 20). How to Build and Interpret Confusion Matrix Using Python & Sklearn. https://www.youtube.com/watch?v=8gLewErTU24 83 Giovanni, R. I. I. (s. f.). Implementación de reconocimiento facial y visión artificial en robot nao con Python y OpenCV. Google/mediapipe. (2023). [C++]. Google. https://GitHub.com/google/mediapipe (Obra original publicada en 2019) Hand landmarks detection guide | MediaPipe. (s. f.). Google for Developers. Recuperado 20 de julio de 2023, de https://developers.google.com/mediapipe/solutions/vision/hand_landmarker Image Module. (s. f.). Pillow (PIL Fork). Recuperado 20 de julio de 2023, de https://pillow.readthedocs.io/en/stable/reference/reference/Image.html Instalar TensorFlow con pip. (s. f.). TensorFlow. Recuperado 20 de julio de 2023, de https://www.TensorFlow.org/install/pip?hl=es-419 Interfacing-circuit-diagram-of-OLED-Display-with-Raspberry-Pi.png (700×932). (s. f.). Recuperado 20 de julio de 2023, de https://circuitdigest.com/sites/default/files/circuitdiagram_mic/Interfacing-circuit-diagram- of-OLED-Display-with-Raspberry-Pi.png Jiménez, Y. A. (s. f.). Clasificación de Flores con Redes Neuronales Convolucionales. Keating, E., & Mirus, G. (2003). American Sign Language in virtual space: Interactions between deaf users of computer-mediated video communication and the impact of technology on language practices. Language in Society, 32(5), 693-714. https://doi.org/10.1017/S0047404503325047 Krish Naik (Director). (2019, diciembre 21). Tutorial 26- Create Image Dataset using Data Augmentation using Keras-Deep Learning-Data Science. https://www.youtube.com/watch?v=hxLU32zhze0 Larranaga, P., Inza, I., & Moujahid, A. (2023). Tema 8. Redes Neuronales. López-Saca, F. (2019). Clasificación de imágenes usando redes neuronales convolucionales. http://zaloamati.azc.uam.mx//handle/11191/6123 84 Ltd, R. P. (s. f.). Raspberry pi 4. Raspberry Pi. Recuperado 20 de julio de 2023, de https://www.Raspberrypi.com/products/Raspberry-pi-4-model-b/ Martín, J. S.-B., Delgado, A. G., & de, J. (s. f.). Aforador de vehículos en carretera mediante OpenCV sobre plataforma local. Nicholas Renotte (Director). (2022, abril 25). Build a Deep CNN Image Classifier with ANY Images. https://www.youtube.com/watch?v=jztwpsIzEGc Nonaka, A. M. (2004). The forgotten endangered languages: Lessons on the importance of remembering from Thailand’s Ban Khor Sign Language. Language in Society, 33(5), 737-767. https://doi.org/10.1017/S004740450404504X OpenCV. (s. f.). OpenCV. Recuperado 20 de julio de 2023, de https://OpenCV.org/ Ortiz, D. C., & Jiménez, F. J. F. (s. f.). Inteligencia Artificial con TensorFlow para predicción de comportamientos. Quer, J., & Steinbach, M. (2019). Handling Sign Language Data: The Impact of Modality. Frontiers in Psychology, 10. https://www.frontiersin.org/articles/10.3389/fpsyg.2019.00483 Ringa Tech (Director). (2021a, julio 17). Tu primer clasificador de imágenes con Python y TensorFlow. https://www.youtube.com/watch?v=j6eGHROLKP8 Ringa Tech (Director). (2021b, agosto 16). Redes Neuronales Convolucionales—Clasificación avanzada de imágenes con IA / ML (CNN). https://www.youtube.com/watch?v=4sWhhQwHqug Ringa Tech (Director). (2021c, septiembre 14). Crea un clasificador de perros y gatos con IA, Python y TensorFlow—Proyecto completo. https://www.youtube.com/watch?v=DbwKbsCWPSg Sam Westby Tech (Director). (2022, marzo 15). How to Install TensorFlow 2 and OpenCV on a Raspberry Pi. https://www.youtube.com/watch?v=vekblEk6UPc 85 Sistemas Inteligentes (Director). (2020, julio 14). Data Augmentation para clasificación de imágenes usando keras—TensorFlow ( Parte 1 ). https://www.youtube.com/watch?v=4G2WAgJ4G3Y Sutton, R. S., & Barto, A. G. (1998). Reinforcement learning: An introduction. MIT Press. TensorFlow Forum. (s. f.). TensorFlow Forum. Recuperado 20 de julio de 2023, de https://discuss.TensorFlow.org/ TensorFlow-bin/previous_versions at main · PINTO0309/TensorFlow-bin. (s. f.). GitHub. Recuperado 20 de julio de 2023, de https://GitHub.com/PINTO0309/TensorFlowbin/tree/main/previous_versions Tf.keras.preprocessing.image.ImageDataGenerator | TensorFlow v2.13.0. (s. f.). TensorFlow. Recuperado 20 de julio de 2023, de https://www.TensorFlow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGen erator Thakur, A. (2019, julio 20). American Sign Language Dataset. https://www.kaggle.com/datasets/ayuraj/asl-dataset Universitat Politècnica De València, E. (2014). Universitat Politècnica de València. Ingeniería del agua, 18(1), ix. https://doi.org/10.4995/ia.2014.3293 Zhang, F., Bazarevsky, V., Vakunov, A., Tkachenka, A., Sung, G., Chang, C.-L., & Grundmann, M. (2020). MediaPipe Hands: On-device Real-time Hand Tracking (arXiv:2006.10214). arXiv. http://arxiv.org/abs/2006.10214 BETANCOURT, G. . A. . (2005). LAS MÁQUINAS DE SOPORTE VECTORIAL (SVMs). Scientia Et Technica, 1(27). https://doi.org/10.22517/23447214.6895