Clasificador_en_tiempo_real_de_gestos_an

Ingeniería Mecánica

•

Artes

Jhonatan Rivera

7/11/2023

¡Este material tiene más páginas!

Entonces, ¿te gustó este material?

Ayude a animar a otros estudiantes a mejorar el contenido

¿Te gustó este material? ¡Compartir! 🧡

Ingeniería Mecánica

9524 Materiales compartidos

Descarga la aplicación para disfrutar aún más

Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!

Vista previa del material en texto

INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
UNIDAD CULHUACAN

Clasificador en tiempo real de gestos anímicos utilizando Deep Learning
para apoyo al profesor, por medio de una plataforma web

Tesina
Que para obtener el título de
Ingeniero en Computación

Presentan
Espinosa Juárez Alberto
Vega Reyes Diego

Asesores
Dr. Jorge Fernando Veloz Ortiz Dra. Iovanna Alejandra Rodríguez Moreno

México, Ciudad de México Mayo, 2020

CONTENIDO

RESUMEN ............................................................................................................................................................ 1
INTRODUCCIÓN .................................................................................................................................................. 3
1.1 OBJETIVO GENERAL ........................................................................................................................................ 4
1.1.2 OBJETIVOS ESPECÍFICOS ...................................................................................................................... 4
1.2 PLANTEAMIENTO DEL PROBLEMA ............................................................................................................. 4
1.3 JUSTIFICACIÓN .................................................................................................................................................. 5
1.4 ESTADO DE ARTE ............................................................................................................................................. 6
MARCO TEÓRICO ............................................................................................................................................... 7
2.1 LA EDUCACIÓN 4.0 ........................................................................................................................................... 8
2.2 INTELIGENCIA ARTIFICIAL ............................................................................................................................. 9
2.2.1 MACHINE LEARNING .............................................................................................................................. 10
2.2.2 REDES NEURONALES ARTIFICIALES ............................................................................................... 11
2.2.3 DEEP LEARNING ...................................................................................................................................... 13
2.3 EMOCIONES HUMANAS ................................................................................................................................. 14
2.4 PATRONES Y EXPRESIONES FACIALES .................................................................................................. 16
2.5 VISIÓN ARTIFICIAL .......................................................................................................................................... 16
2.5 PYTHON .............................................................................................................................................................. 17
2.6 TENSORFLOW Y KERAS ............................................................................................................................... 18
2.7 DJANGO ............................................................................................................................................................. 19
DESARROLLO ................................................................................................................................................... 20
3.1 EMOCIONES HUMANAS UNIVERSALES ................................................................................................... 21
3.2 INSTALACIÓN Y CONFIGURACIÓN DEL ENTORNO DE DESARROLLO ........................................... 23
3.3 BASES DE DATOS PÚBLICAS DE RECONOCIMIENTO DE EXPRESIONES FACIALES Y
TRATAMIENTO DE DATOS ........................................................................................................................................ 27
3.3 DISEÑO DE ARQUITECTURA DE RED NEURONAL ................................................................................ 33
3.4 ANÁLISIS DE LA EFICACIA DE RED NEURONAL ................................................................................... 41
3.5 DISEÑO DE APLICACIÓN DE CLASIFICACIÓN EN TIEMPO REAL ..................................................... 44
3.6 CREACIÓN DE LA PLATAFORMA WEB UTILIZANDO DJANGO ......................................................... 47
3.6.1 CREACIÓN DE LA BASE DE DATOS ........................................................................................................ 48
3.6.2 CREACIÓN DEL PROYECTO DJANGO ..................................................................................................... 49
3.6.3 CREACIÓN DE APLICACIÓN “GESTOS” Y VISTA PRINCIPAL .......................................................... 50

3.6.4 CREACIÓN DE VISTAS Y ENLACES URLs ............................................................... 56
3.6.5 DESARROLLO HTML Y CSS ....................................................................................................................... 60
PRUEBAS Y RESULTADOS ............................................................................................................................. 61
CONCLUSIONES Y TRABAJO A FUTURO ..................................................................................................... 68
5.1 CONCLUSIONES .............................................................................................................................................. 69
5.2 TRABAJO A FUTURO ...................................................................................................................................... 70
REFERENCIAS .................................................................................................................................................. 71

INDICE DE FIGURAS
Figura 1-Ciclo del Learning Analytics .................................................................................................... 9
Figura 2-Arquitectura básica de una red neuronal .............................................................................. 11
Figura 3-Arquitectura de una neurona ................................................................................................ 12
Figura 4-Funciones de activaciones ................................................................................................... 13
Figura 5-Atlas de emociones .............................................................................................................. 15
Figura 6-Rasgos faciales característicos de cada emoción. ............................................................... 21
Figura 7-Anaconda Suite .................................................................................................................... 23
Figura 8-Instrucciones para acceder a tmp ......................................................................................... 24
Figura 9-Comprobación HASH ........................................................................................................... 24
Figura 10-Ejecución del instalador ...................................................................................................... 24
Figura 11-Terminos de uso de Anaconda ........................................................................................... 25
Figura 12-Bibliotecas que contiene el entorno de desarrollo. ............................................................. 26
Figura 13-Visualización del conjunto de datos FER2013. ................................................................... 27
Figura 14-Ejemplos presentes en FER2013....................................................................................... 28
Figura 15-Adecuación del conjunto de datos JAFFE a tamaño 48x48 pixeles y en escala de grises. 29
Figura 16-Muestra de imágenes por clase .......................................................................................... 30
Figura 17-Representación en forma de gráfica ................................................................................... 31
Figura 18-Generador de muestras ...................................................................................................... 32
Figura 19-Importación de datos FER2013. ......................................................................................... 33
Figura 20-Un ejemplo de FER2013 .................................................................................................... 34
Figura 21-Código que representa una imagen en pixeles. ................................................................. 34
Figura 22-Normalización de los pixeles .............................................................................................. 36
Figura 23-Arquitectura de una CNN .................................................................................................... 37
Figura 24-Ejemplo de convolución ...................................................................................................... 38
Figura 25-Stride de 1 .......................................................................................................................... 38
Figura 26-Stride de dos ...................................................................................................................... 38
Figura 27-Indicación de tamaño de kernel,activación ReLu y strides en nuestro proyecto ................. 38

Figura 28-Función de activación ReLu ............................................................................................... 39
Figura 29-Arquitectura final ................................................................................................................. 40
Figura 30-Accuracy final ..................................................................................................................... 41

Figura 31-Reporte de clasificación ...................................................................... 43
Figura 32-Asignación de colores ......................................................................................................... 44
Figura 33-Utilización de la red preentrenada de OpenCV .................................................................. 45
Figura 34-Resultado final de la aplicación .......................................................................................... 46
Figura 35-pgAdmin 4 .......................................................................................................................... 48
Figura 36-Muestra de exactitud .......................................................................................................... 62
Figura 37-Campeonato Kaggle ........................................................................................................... 63
Figura 38-Prueba con rostro enojado. ................................................................................................ 63
Figura 39-Prueba con rostro neuronal. ............................................................................................... 63
Figura 40-Reconocimiento en tiempo real .......................................................................................... 64
Figura 41-Inicio de sesión ................................................................................................................... 66
Figura 42-Vista principal ..................................................................................................................... 67
Figura 43-Reconocimiento por plataforma web .................................................................................. 67

Agradecimientos
Alberto Espinosa Juárez
A mis padres, María del Carmen y José Espiridión:
Por guiarme durante todo mi trayecto estudiantil, por apoyarme en mis decisiones y prestarme gran
apoyo emocional y moral durante los periodos de gran dificultad. Su ejemplo es mi mayor guía para
seguir adelante.
A mis hermanos, Nathalia y Moisés, y amigos:
Por compartir conmigo parte de su vida, por apoyarme, por reír juntos y seguir compartiendo
momentos de gran felicidad y apoyo en momentos difíciles.
A mis asesores, Iovanna Alejandra Rodríguez Moreno y Jorge Fernando Veloz Ortiz,
Por convertirse en mano derecha de este proyecto, por compartir de su conocimiento conmigo y
brindarme la experiencia de trabajar con ustedes.
Diego Vega Reyes
A mis padres, Guadalupe Reyes Marín y Julián Vega Almazán:
Por brindarme las herramientas que necesite durante todo mi periodo estudiantil y del que presento
un gran reto, la universidad. También, por brindarme todo su apoyo y cariño en las etapas más
difíciles de mi vida.
A mi hermana, Jazmín del Carmen Vega Reyes:
Por representar a la persona que siempre quise ser y algún día superarla, como también ser una
persona que siempre me brindo sus consejos, felicidad y grandes recuerdos en todo mi periodo
estudiantil, y en mí vida.
A mis asesores, Iovanna Alejandra Rodríguez Moreno y Jorge Fernando Veloz Ortiz:
Por brindarme todo su apoyo en este proyecto, por compartir su conocimiento conmigo y por
ayudarme en diversas situaciones correspondientes al aprendizaje.

RESUMEN
Para poder clasificar gestos anímicos en tiempo real es necesario hacer un estudio
de emociones presentes en los seres humanos, para ello, nos basamos en el trabajo
de Paul Ekman, Doctor en psicología cuyas investigaciones en las emociones
humanas y expresiones faciales lo llevaron a que en 1972 definiera que existen seis
emociones universales y, por lo tanto, seis expresiones faciales que las distinguen:
Asco, miedo, sorpresa, alegría, enojo y tristeza. Lo siguiente en realizar fue una
búsqueda de bases de datos públicas que permitieran extraer de ellas los datos
necesarios para su análisis. Encontramos tres conjuntos de datos: FER2013 (Facial
Expression Recognition 2013), FER2013+ (Facial Expression Recognition 2013+) y
JAFFE (Japanese Female Facial Expression). De los tres conjuntos de datos,
decidimos utilizar FER2013 y JAFFE, puesto que su forma de representar los datos
era más similar, por lo que nos evitaba el uso de mezcla de técnicas para la
extracción de datos. Posteriormente diseñamos una red neuronal capaz de clasificar
dichas expresiones faciales, de todos los tipos de redes neuronales, optamos por
utilizar redes neuronales convolucionales (CNN), esto debido a que a comparación
de las redes neuronales de perceptrón multicapa, las redes CNN no conectan cada
neurona con todas y cada una de las siguientes, sino, que por medio de un Pooling
o una capa de reducción se elige un subgrupo de ellas (donde se encuentra la mayor
cantidad de datos). Esto permite reducir el uso de neuronas necesarias y la
complejidad de las operaciones computacionales para su ejecución. Después de
varias pruebas de arquitectura, logramos diseñar una que nos permitía lograr una
eficacia de hasta el 80% en pruebas, lo que redujo de forma significativa el margen
de error al clasificar expresión facial. Lo siguiente en realizar fue una aplicación en
Python cuyo propósito era la clasificación de dichas expresiones faciales en tiempo
real. Para ello fue necesario recurrir a la librería de OpenCV y a una arquitectura ya
compilada que permite la detección de rostros humanos, esto para poder centrarnos
únicamente en las expresiones faciales, es una excelente forma de ahorrar tiempo
y recursos, pues ya no es necesario fijar primero un rostro humano y de ese rostro
humano realizarla extracción de las expresiones, sino, dejamos que el archivo ya
compilado anteriormente detecte automáticamente los rostros, descartando el resto.

Finalmente, para poder hacerlo amigable con los usuarios finales (los profesores),
utilizamos Django, un Framework que nos permite utilizar código Python y
presentarlo por medio de una plataforma web cuyo código vertebral o estructural
contiene código HTML5 y CSS3. HTML5 para la estructura y CSS3 para su diseño.
La aplicación web permite un inicio de sesión para profesores y la posibilidad de
cargar a clasificación una imagen o un vídeo por medio de una cámara, tomando en
cuenta los posibles casos de implementación: Imágenes fijas en distintos periodos
de tiempo o un vídeo a lo largo de la clase

CAPITULO 1
INTRODUCCIÓN

1.1 OBJETIVO GENERAL
Desarrollar un clasificador de gestos anímicos en tiempo real, utilizando Deep
Learning, programado en Python junto con las bibliotecas de Keras y TensorFlow
para ayudar a detectar estados anímicos durante las clases y así, servir de apoyo
al profesor para retroalimentación por medio de una plataforma web, siendo el
feedback (retroalimentación) una característica fundamental de la educación 4.0.
1.1.2 OBJETIVOS ESPECÍFICOS
• Reconocer los estados anímicos universales en las personas
• Clasificar gestos faciales que representen estados de ánimo por medio de
una base de datos
• Diseñar un modelo de red neuronal convolucional para aprendizaje
supervisado
• Utilizar el modelo para segmentar y detectar los estados de ánimo de
personas en un vídeo o imagen
• Realizar un reporte automático del promedio general en estado anímico del
grupo por medio de una plataforma web
1.2 PLANTEAMIENTO DEL PROBLEMA
Actualmente en distintas partes del mundo se hacen esfuerzos por integrar
inteligencia artificial en la educación, no como sustituto del profesor, sino, como
ayuda, debido a los grandes beneficios que se pueden obtener. Por ejemplo, en
China por medio de “diademas” monitorean ondas cerebrales en busca de patrones
que afecten la concentración; En Estados Unidos la universidad de Princeton cuenta
con cámaras en aulas que mide el nivel de distracción. En México no existe una
gran cantidad de proyectos enfocados a lo anterior a pesar de existir ya un enfoque
4.0 en la educación.

1.3 JUSTIFICACIÓN
Cada vez más instituciones educativas apuestan por implementar herramientas de
IA en aulas de clase. En el Instituto Politécnico Nacional, ya se habla de una
educación 4.0 donde una característica fundamental es el feedback o Learning
Analytics. Con este proyecto se busca ayudar en esa característica puesto que los
gestos anímicos son muy particulares en el proceso de aprendizaje y son reflejo del
estado en las clases.

1.4 ESTADO DE ARTE

CAPITULO 2
MARCO TEÓRICO

2.1 LA EDUCACIÓN 4.0
Desde hace un par de años, la educación 4.0 ha llegado a México de una forma
parcial, sin embargo, a pesar de que universidades como el ITESM ya la viven por
medio de sus modelos educativos, en el Instituto Politécnico Nacional aún no es el
caso; debemos recordar que la educación 4.0 es un modelo educativo en el que la
educación no está centrada en el contenido, sino, está centrada en hacer alumnos
competentes, en lograr que los alumnos identifiquen qué saben hacer y cómo lo
pueden aplicar, es decir, qué saben ser. Para ello, la dinámica y programas
escolares cambian drásticamente, donde se consideran todos los estilos de
aprendizaje, las inteligencias múltiples predominantes1 y se hace uso de tecnología
para realizar un feedback (retroalimentación)
Ese feedback o Learning Analytics, como algunos autores lo llaman, tiene como
finalidad obtener información para mejorar la práctica educativa, optimizando el
rendimiento de alumnos y profesores, así como del modelo educativo en sí. Además
del Learning Analytics, también se distingue el Academic Analytics, que funciona de
la misma manera, pero orientado a instituciones educativas, comunidades o
gobiernos, siendo implementadas concretamente en profesores o centros. Las
posibilidades de aplicar un feedback de forma correcta puede:
• Guiar a los estudiantes a través de itinerarios personalizados
• Predecir el abandono y desempeño de los participantes de un curso o clase
• Adaptar las clases a los conocimientos reales
• Identificar necesidades de aprendizaje
• Conocer el comportamiento de los estudiantes en relación a la plataforma de
trabajo
• Optimizar los recursos formativos
• Mejorar la comunicación

Figura 1-Ciclo del Learning Analytics
Eduliticas, una empresa dedicada a la Analítica del Aprendizaje fijó cinco pasos por
los cuales el Learning Analytics pasa. En nuestro proyecto está enfocado en los
primeros tres pasos del ciclo. Donde definimos el estudio de las expresiones faciales
humanas, recolectamos los datos presentes en un aula de clase y finalmente los
analizamos y visualizamos por medio de una plataforma web.
2.2 INTELIGENCIA ARTIFICIAL
Muchas instituciones educativas apuestan por utilizar la inteligencia artificial en la
Analítica del aprendizaje. La IA definida por primera vez en 1956, en la Universidad
de Dartmouth Collage2 por J.McCarthy, M. Minsky, N. Rochester y C.E Shannon,
como “Ciencia de crear maquinas que se comporten como un ser humano” nos ha
permitido desde 1994 controlar tareas básicas en la industria así como hacer
supervisiones. Hacer búsquedas a través de grandes masas de datos (Bishop,
1995) así como hacer análisis de textos que permitían a los usuarios encontrar un
documento entre billones de sitios web con escribir solo palabras clave (Lowe,
2001).
A pesar de que hoy en día existan tantos titulares acerca de que la IA supera la
capacidad humana en ciertas actividades, no es nuevo, pues está presente en la
industria desde 1980.

Huang J, decía en “Isolation of Cytokinetic Actomyosin Rings from Saccharomyces
cerevisiae and Schizosaccharomyces pombe. Methods Mol” que “La inteligencia
artificial es un subconjunto estricto de la computación, es decir, de transformación
de la información. Hay que tener en cuenta que la computación es un proceso físico,
no matemático: Requiere tiempo, espacio y energía. La inteligencia artificial es el
subconjunto de la computación que transforma un contexto en acción.
2.2.1 MACHINE LEARNING
De la definición anterior de Inteligencia Artificial, nace el término de Machine
Learning, que es muy importante ya que es una de las vertientes más importante de
este proyecto. BBVA define el Machine Learning como una rama de la inteligencia
artificial que permite que las maquinas aprendan sin ser expresamente
programadas para ello, en definitiva, un maestro del reconocimiento de patrones,
capaz de convertir una muestra de datos en un programa informático capaz de
extraer inferencias de nuevos conjuntos de datos para los que no ha sido entrenado
previamente3. El machine Learning hoy en día presenta un sinfín de aplicaciones
como las recomendaciones de Netflix o Spotify, las respuestas automáticas de
Gmail o el habla de Siri, Alexa y Cortana.
En las décadas de 1950 y 1960, distintos científicos empezaron a investigar el cómo
se podría aplicar la biología de las redes neuronales del cerebro humano en
computadoras, cuya idea derivó en la creación de las redes neuronales artificiales.
Uno de los primeros experimentos en usar dichas redes neuronales artificiales fue
realizado por Marvin Minsky y Dean Edmonds. Lograron crear un programa capaz
de aprender de la experiencia para salir de un laberinto. Esa fue la primera
computadora en capaz de aprender de sí misma para resolver una tarea sin haber
sido programada para ello de forma explícita, si no, que lo aprendió a partir de
ejemplosdados a ella previamente.
El gran hito del machine Learning es que permitió pasar de programación mediante
reglas a un modelo cuyas reglas salían de manera desasistida. Todo gracias a los
datos.

Sin embargo, el machine Learning parecía no tener mucho futuro debido a la falta
de datos y la poca potencia de cálculo de las computadoras de ese entonces. Fue
hasta finales del siglo XX cuando las computadoras fueron capaces de realizar
millones de operaciones en cuestión de segundos o minutos y la gran cantidad de
datos con la llegada de Internet que en 1997 se marcó un hitó, el sistema IBM Deep
Blue entrenado a partir de ver miles de partidas de ajedrez fue capaz de vencer al
campeón mundial de ese juego, Garry Kasparov.
2.2.2 REDES NEURONALES ARTIFICIALES
Las redes neuronales artificiales son modelos simples del funcionamiento del
sistema nervioso biológico. Las unidades básicas de dichas redes, son las
neuronas, que generalmente se organizan en capas, tal como se muestra en la
siguiente figura.

Figura 2-Arquitectura básica de una red neuronal
Las redes neuronales emulan el modo en que el cerebro humano procesa la
información: Funciona simultaneando un número elevado de unidades de
procesamiento interconectadas que parecen versiones abstractas de neuronas.
Como en la figura 2 se muestra, las redes neuronales artificiales se organizan en
capas. Normalmente hay tres partes: La primera, con campos de entrada; una o “n”

capas ocultas; y una capa de salida, con la unidad o unidades que representan los
destinos.
Las redes neuronales artificiales aprenden a través de un entrenamiento, donde se
le presentan a la red ejemplos para los que va conociendo su resultado y las
respuestas que proporciona se comparan con resultados conocidos. Los resultados
se pasan hacia atrás a través de la red, cambiando gradualmente.
Como se mencionó anteriormente, las redes neuronales están compuestas de
neuronas.

Figura 3-Arquitectura de una neurona
La neurona, tal como se muestra en la figura 3 está conformada por entradas, que
serán datos (a1,a2,an), también contendrán pesos, (w1,w2,w1n), que son
coeficientes entrenables que permiten determinar en que medida es importante e
influye cada variable de entrada en la salida y bias, una compensación para offsets
o desviaciones producidos por los valores de entrada y sus escalas. Finalmente
conformada por una función de activación que eliminará la “linealidad” y dará una
salida.
Las funciones de activación son las encargadas de encender la neurona y decidir
en qué medida se activa la función de salida.

Figura 4-Funciones de activaciones
De forma matemática quedaría de la siguiente manera: 𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆 = 𝑆𝑆𝑎𝑎𝑎𝑎𝑆𝑆𝑎𝑎𝑆𝑆𝑎𝑎𝑆𝑆ó𝑛𝑛(𝑆𝑆1 · 𝑤𝑤1 + 𝑆𝑆2 · 𝑤𝑤2+. . .𝑆𝑆𝑛𝑛 · 𝑤𝑤𝑛𝑛 + 𝑏𝑏𝑆𝑆𝑆𝑆𝑆𝑆)
Como se ha mencionado anteriormente, es necesario un entrenamiento de la red
neuronal, para ello utilizamos el algoritmo “Descenso por gradiente estocástrico”,
que consiste en comparar las salidas expedidas por la red neuronal diseñada con
respecto a las salidas etiquetadas que deberían ser. Calcula un error respecto a las
mismas y modifica los pesos. Esto lo hace varias veces ya que los datos no son
enviados en una sola exhibición, es decir, es enviado por paquetes de datos o
“batch” en los cuales se encuentran un número de muestras de la base de datos.
De esa forma se permite calcular errores por cada paquete de datos que al final
resultarán en una modificación de pesos.
2.2.3 DEEP LEARNING
Teniendo como base el machine learning y las redes neuronales, podemos empezar
a sumergirnos más dentro del terreno de la inteligencia artificial y definir entonces
por qué decimos que utilizamos Deep learning (aprendizaje profundo)7, que
podemos definirla como una sub-categoría del machine learning que fue descrita en
1960, que permite que los sistemas no solo aprendan de la experiencia, sino, que
sean capaces de entrenarse a sí mismas para hacerlo cada vez mejor utilizando los
datos. Nosotros hicimos uso de fotografías de gestos anímicos públicos que
contiene FER2013 (Facial Expression Recognition v2013) y JAFFE (The Japanese
Female Facial Expression) y después de unos cuantos entrenamientos mejoramos
su capacidad de detección de patrones.

El Deep Learning hoy en día es una de las bases de la IA, puesto que es utilizado
en la industria e investigación para clasificar imágenes, reconocer el habla, detectar
objetos y describir contenido.
Asistentes personales como Siri o Cortana son potenciados, en parte por el
aprendizaje profundo (DP). Una aplicación popular es la impresión automática de
subtítulos en imágenes o descripción de escenas. En 2016, Facebook anunció que
usaría Deep Learning para interpretar y describir fotos y vídeos, para poder
identificarla más fácilmente y en su posibilidad, ser descrita a personas ciegas. Esta
descripción de fotos, también es utilizada actualmente para marketing, pues, por
medio de un algoritmo de aprendizaje profundo, Facebook puede saber qué tipo de
fotografías, vídeos y texto son publicados más por una persona y de esa manera
personalizar sus anuncios.

2.3 EMOCIONES HUMANAS
Una emoción es un estado psicológico complejo que implica tres componentes
distintos: Una experiencia subjetiva, una respuesta fisiológica y una respuesta
conductual o expresiva (Hockenbury y Hockenbuty, 2007).
La experiencia subjetiva, a pesar de que científicos han afirmado que existen
emociones básicas universales y que todas las personas experimentan dichas
emociones independientemente de su origen o su cultura, las emociones no siempre
las expresamos en forma “pura”, es decir, podemos tener una mescla de emociones
derivadas de acontecimientos o situaciones de vida y las personas pueden
reaccionar de forma diferente a ellas.

Figura 5-Atlas de emociones
Es por ello que, el Dr. Paul Ekman y su hija Eve Ekman han diseñado un “Atlas de
emociones” cuya finalidad es ayudar a identificar y reconocer la subjetividad de las
emociones. De esa forma se puede visualizar de manera gráfica cómo, por ejemplo,
para la emoción “alegría” se pueden mostrar hasta trece estados ordenados de
menor a mayor intensidad, siete acciones relacionadas y ejemplos de disparadores
asociados a dicha emoción.
La respuesta fisiológica, por su parte es el cómo reacciona el cuerpo ante ellas, por
ejemplo, un “nudo” en el estómago, palpitaciones fuertes o alguna otra respuesta
en el organismo ante los estímulos estresores.
Finalmente, la respuesta conductual, que es el componente con el que más estamos
familiarizados, por ser la expresión real de la emoción (objeto de estudio en nuestro
proyecto).

Cada explosión de productos químicos emocionales, desde el momento en que se
produce en el hipotálamo hasta el momento en que se descompone y absorbe por
completo, tiene una duración aproximadamente de seis segundos. Si una persona
algo por más de seis segundos, de algún modo no consciente, el cuerpo está
tratando de recrear y reabastecer esas sensaciones.
Si bien no es posible medir directamente una emoción, los cambios producidas en
el cuerpo humano, por ejemplo, en el rostro, sí es medible, permitiendo precisar así
las características de esa determinada emoción.
2.4 PATRONES Y EXPRESIONES FACIALES
Se ha hablado ya de un patrón y hemos mencionado los patrones presentes en las
emociones, sin embargo, ¿Qué es patrón? Un patrón, según la RAE, es un modelo
que sirve de muestra para sacar otra cosa igual, esto puede ser interpretado como
aquello que se repite o es común en “algo”5 y sirve para poder identificarlo,
modificarlo o replicarlo.
Esos modelos pueden buscarse en las expresiones faciales, de tal forma que
podemos saber con cierta exactitud la emoción presente en una persona.Ray
Birdwhistell, antropólogo estadunidense, sostenía que a pesar de que las
expresiones faciales podían disimularse, exagerarse o ocultarse por completo,
existen expresiones anatómicas que son imposibles de alterarse, cuyo significado
no difiere según la cultura a la que pertenezcan.
2.5 VISIÓN ARTIFICIAL
La visión artificial se puede definir como un campo de la inteligencia artificial que,
mediante la utilización de técnicas adecuadas permite la obtención, procesamiento
y análisis de cualquier tipo de información especial obtenida a través de imágenes
digitales.
La visión artificial la componen un conjunto de procesos destinados a realizar el
análisis de imágenes. Esos procesos son: La captación de imágenes, memorización
de la información, procesado e interpretación de resultados.

Las principales aplicaciones de la visión artificial en la industria actual son:
• Identificación e inspección de objetos
• Determinación de la posición de objetos en el espacio
• Establecimiento de relaciones espaciales entre varios objetos
• Realización de mediciones angulares
• Mediciones tridimensionales
2.5 PYTHON
Utilizamos el lenguaje de programación Python8, un lenguaje de programación en
alto nivel que trabaja por medio de interpretación, orientado a objetos que gracias a
sus características no es necesario compilar ni enlazar. Sin embargo, la razón
principal por la que se opta por utilizar Python de Matlab, por ejemplo, es que
Python, hoy en día es uno de los lenguajes de programación más utilizados en el
mundo9 no sólo en el área de la investigación, sino, también en el área de desarrollo
empresarial, especialmente, dominante en el área de inteligencia artificial.
El creador de Python es Guido Van Rossum, cuyo objetivo era cubrir la necesidad
de un lenguaje orientado a objetos de sencillo uso que sirviese para tratar diversas
tareas dentro de la programación que habitualmente se hacía en C.
Python contiene características muy peculiares, como:
• Ser un lenguaje de propósito general, es decir, se pueden crear todo tipo de
programas y aunque no es un lenguaje creado específicamente para web,
actualmente es uno de las áreas donde más se ocupa Python, por ejemplo:
Netflix y Spotify lo ocupan para predecir las recomendaciones de series y
música a sus usuarios.
• Multiplataforma, Python aunque fue originalmente desarrollado para Unix,
actualmente es compatible con cualquier sistema operativo siempre y cuando
exista en la computadora un intérprete programado para él.

• Python a su vez su vez es interactivo, pues dispone de un intérprete por línea
de comandos el que se pueden introducir sentencias. Cada sentencia ser
ejecutada y producir un resultado visible, es decir, no es necesario ejecutar
todo el código, puede ejecutarse por pasos.
Actualmente empresas como Yahoo, Google, Walt Disney, NASA, Red Hat,
entre otras, utilizan Python dentro de sus servicios que ofrecen a su usuarios
finales, así como también para las áreas de investigación de dichas
empresas.
2.6 TENSORFLOW Y KERAS
Dentro de Python, existen dos bibliotecas de suma importancia para nosotros, la
primera es TensorFlow, biblioteca de código abierta creada por el equipo de Google
para satisfacer las necesidades de sistemas capaces de construir y entrenar redes
neuronales, detectar y descifrar patrones y correlaciones, así como también para la
emulación de razonamiento humano.
Los modelos matemáticos utilizados por TensorFlow son redes neuronales, que en
función de la arquitectura de capas y neuronas que la conforman se podrá modelizar
desde un simple modelo de regresión línea, hasta una arquitectura mucho más
completa de machine Learning.
Por su parte Keras es la librería base de TensorFlow (a partir de TensorFlow 2.0),
su principal función es la construcción de redes neuronales y es capaz de ejecutarse
tanto en TF como en Theano (otra biblioteca para machine Learning). Entre las
principales características de Keras se encuentran:
• Su fácil y rápido prototipado gracias a su modularidad, minimalismo y
extensibilidad
• Su soporte a redes neuronales convoluciones y recurrentes (así como la
combinación de ambas)

• Soporta esquemas de conectividad arbitrarios (incluyendo entrenamientos
multi-entrada y multi-salida)
• Es capaz de ser ejecutado tanto en CPU como en GPU
• Es compatible desde la versión de Python 2.7 hasta la más reciente, 3.7
2.7 DJANGO
Una de las cosas que Python ofrece es la integración con decenas de otros
lenguajes, así como su gran extensión de Frameworks para el desarrollo, uno de
los más conocidos es Django, un framework que permite a Python una integración
en web, que fue diseñado principalmente para la gestión de varias páginas web
complejas, colocando énfasis en el re-uso, la conectividad y extensibilidad de
componentes10.
Con todo esto mencionado, basta decir que el uso del Framework Django como
extensión de Python fue utilizado en este proyecto para el desarrollo de una
plataforma web en la cual se mostrarán los resultados obtenidos por la red neuronal,
de esta forma nos aseguramos de que todos los profesores tengan acceso a la
información requerida sin importar el dispositivo por el cual se encuentren
conectados, pues no será necesario tener una conexión web para su consulta.

CAPITULO 3
DESARROLLO

3.1 EMOCIONES HUMANAS UNIVERSALES
El Dr. Paul Ekman en 1972 define las seis emociones humanas universales después
de que en 1968 viaja a Nueva Guinea para estudiar el lenguaje no verbal de la tribu
Fore11, cuyo viaje dejó como evidencia fuerte que, hasta la fecha, las expresiones
faciales son universales, pues sin importar las diferencias de la sociedad, éstas se
encuentran presentes

Figura 6-Rasgos faciales característicos de cada emoción.
Como se observa en la Figura 6 cada emoción humana descrita por el Dr. Paul
Ekman, tiene características particulares, cuyos rasgos ayudan de forma importante
a la red neuronal para poder clasificar correctamente dichas expresiones faciales.
Con lo identificado anteriormente, sabemos que el estudio de las expresiones
faciales emocionales dentro de la educación puede ser de gran ayuda, así como lo
es en la política, en el marketing, la Experiencia de Usuario dentro de aplicaciones
y en contenido audiovisual. La razón es que las expresiones faciales son
probablemente la variable que más observamos para obtener información de las
personas, que, si bien tenemos cierto control sobre ellas, parece estar demostrado
que cuando una persona utiliza una expresión facial no acorde a su verdadero

estado de ánimo, durante un periodo corto de tiempo, en su rostro se expresa la
emoción verdadera que muchas veces pasa desapercibida.
Esto nos ayuda a identificar las emociones humanas que posteriormente se
buscaría en bancos de datos públicos para poder utilizarlos en el análisis posterior,
es decir, dentro de la red neuronal.

3.2 INSTALACIÓN Y CONFIGURACIÓN DEL ENTORNO DE
DESARROLLO
Para poder empezar a programar utilizando técnicas de Deep Learning, fue
necesario la instalación de librerías específicas, así como también hacer uso de
“Entornos virtuales”.
Para este proyecto utilizamos como entorno de desarrollo Jupyter Notebook12,
perteneciente a Anaconda Distribution, una suite de desarrollo para ciencia de
datos. Anaconda nos ofrece un entorno de desarrollo, un gestor de paquetes y una
colección de más de 720 paquetes de código abierto que podemos utilizar dentro
de nuestro proyecto.

Figura 7-Anaconda Suite

En la Figura 7 se puede observar como en el apartado color azul (librerías) existe
un apartado específico para Machine Learning, que contiene ya una
preconfiguración para la utilización de TensorFlow, así como también de las
bibliotecas Matplotlib,Numpy, Pandas y Scipy.
Se instaló Anaconda Distribution en una computadora con las siguientes
especificaciones:
• Sistema Operativo Linux Ubuntu 20.04
• Procesador Intel Core i5 de 7ma generación con 4 CPUs a 2.5Ghz
• Tarjeta de vídeo dedicada de 1GB Nvidia 940MX
• 12 GB de memoria RAM
La forma de instalación de Anaconda Suite consistió de los siguientes pasos:
1. Se abrió la terminal de Ubuntu y se procedió a la carpeta /tmp para desde allí
descargar el archivo instalador.

Figura 8-Instrucciones para acceder a tmp
2. Se verificó la integridad del archivo instalador por medio de una cadena hash
criptográfica SHA-256.

Figura 9-Comprobación HASH
3. Ejecución de la secuencia de comandos de Anaconda

Figura 10-Ejecución del instalador

4. Revisión y acuerdo de la licencia de producto.

Figura 11-Terminos de uso de Anaconda

Dentro de Anaconda, creamos un Entorno de Desarrollo, que en palabras
coloquiales se podría definir como un laboratorio independiente de la suite que
contiene herramientas específicas para el uso del espacio.
Las bibliotecas que utilizamos fueron:
• Keras
• TensorFlow
• Scipy
• Pandas
• Scikit-Learn
• Scikit-Image
• Imageio
• Flask-Socketio

Figura 12-Bibliotecas que contiene el entorno de desarrollo.
En la Figura 12 se puede observar cada una de las bibliotecas que conformó nuestro
laboratorio, así como también la versión que es utilizó. Fue de suma importancia
que ambos autores de este proyecto tuviéramos las mismas versiones de
bibliotecas, puesto que, en caso de diferir en alguna de ellas, se pudieron haber
provocado errores de sintaxis debido al cambio en muchas de ellas.

3.3 BASES DE DATOS PÚBLICAS DE RECONOCIMIENTO DE
EXPRESIONES FACIALES Y TRATAMIENTO DE DATOS
Una vez que conocemos las emociones humanas universales y con ello también los
rasgos faciales que las representan, se ha decidido realizar la búsqueda de bases
de datos públicas que contengan dentro la información que nosotros estamos
buscando, eso, antes de declinarnos en realizar nuestra propia base de datos. Para
la búsqueda hemos utilizado primeramente Kaggle, una empresa subsidiaria de
Google, cuyo propósito general es formar una comunidad de científicos de datos y
profesionales de Machine Learning. Dentro de Kaggle hemos logrado obtener un
conjunto de datos (dataset) llamado FER2013 (Facial Expression Recognition
2013)13 cuyo contenido se encuentra dentro de un archivo .CSV. Este conjunto de
datos contiene 35,887 imágenes de tamaño 48x48 pixeles en una escala de grises,
organizado en tres columnas:

Figura 13-Visualización del conjunto de datos FER2013.
Columna A: Emociones, representadas del cero al seis (0=Enojado, 1=Disgusto,
2=Miedo, 3=Feliz, 4=Triste, 5=Sorpresa, 6=Neutral), como se puede observar, se
agrega una emoción más, “neutral” cuya agregación se debe a cuando la persona
no se encuentra mostrando físicamente alguna emoción.
Columna B: Imágenes, organizadas en una matriz de pixeles.
Columna C: Uso, cuyas categorías son “Training Test” para uso de entrenamiento,
“Public Test” para uso de pruebas y “Private test” para uso de validación.

Utilizamos este dataset porque se encuentra ya dividido para su utilización en redes
neuronales, es decir, se encuentra ya dividido en los tres grupos importantes:
Entrenamiento, conjunto de datos que necesita la red neuronal para “aprender”
dichos patrones. Validación, conjunto de datos que necesita la red neuronal para
evaluar el aprendizaje de la red neuronal y Prueba, conjunto de datos que
necesitamos para comprobar el último aprendizaje de la red neuronal.
Hacemos énfasis que este conjunto de datos pertenece a un Reto Kaggle cuyo
propósito es servir de conjunto base para realizar un clasificador de gestos
anímicos.
FER2013 nos presenta una cantidad de datos increíble, sin embargo, hemos
decidido utilizar otro conjunto de datos más para poder alcanzar un mayor
porcentaje de efectividad después de haber entrenado nuestra red neuronal
(aunque no depende solo de la cantidad de datos como se mostrará a continuación,
siempre es recomendable utilizar la mayor cantidad de datos posibles).

Figura 14-Ejemplos presentes en FER2013
Para elegir un nuevo conjunto de datos, se ha optado por utilizar un dataset
presentado en el tercer IEEE International Conference on Automatic Face and
Gesture Recognition de 1998, The Japanese Female Facial Expression (JAFFE)14.

Este conjunto de datos contiene 213 imágenes organizadas en las mismas siete
categorías que FER2013 para los cuales se han utilizado 10 modelos femeninas
japonesas.
A diferencia de FER2013, JAFFE contiene las imágenes en un formato .tiff sin
compresión y en un tamaño de 256x256 pixeles, también en escala de grises.
Para poder utilizar ambos conjuntos de datos, es necesario realizar un ajuste dentro
de JAFFE, ese ajuste es redimensionar las imágenes a un tamaño de 48x48 pixeles
y posteriormente pasarlo a una matriz de pixeles para tenerlas en el mismo formato
que FER2013.

Figura 15-Adecuación del conjunto de datos JAFFE a tamaño 48x48 pixeles y en escala de grises.
En la Figura 15, un extracto de nuestro código hace referencia al método remove
que dentro contiene dos archivos, README y .DS_Store, la razón por la cual
estamos eliminando esos archivos de la carpeta, es que son archivos que no
contienen información relevante del conjunto de imágenes, es decir, son datos
basura para nuestra utilización.

Una vez importados nuestros datos, verificamos la cantidad de imágenes presentes
en cada una de las clases (emociones) de nuestro dataset.

Figura 16-Muestra de imágenes por clase
Como se muestra en la Figura 16 nuestra clase minoritaria fue la clase número 1,
con tan solo 547 muestras. El código construido indica lo siguiente:
Imprimir la cantidad de imágenes y, además, imprimir la cantidad de imágenes por
“emotion” (que dentro del dataset corresponde a la columna que representa la
emoción) presentes en el archivo .CSV.

Para obtener una visión más detallada de nuestros datos, diseñamos una gráfica de
barras que muestra con precisión la repartición. Esto nos sirvió porque
posteriormente debimos utilizar métodos de compensación de datos, de esta forma
se lograría una mayor generalización y, por lo tanto, un mejor entrenamiento.

Figura 17-Representación en forma de gráfica
Como se puede visualizar en la Figura 17, se confirma que tenemos una clase con
muy pocas imágenes. Para poder compensar las imágenes, utilizamos un
generador de imágenes15. Este generador viene incluido dentro de Keras y su
función es crear muestras artificiales tomando como base las originales. A estas se
les aplican filtros, rotaciones, aumentos de zoom y otros, para mejorar la cantidad
de imágenes por clase.

Figura 18-Generador de muestras
En la Figura 18 se puede apreciar con claridad, como hemos aplicado
ImageDataGenerator de Keras a nuestro conjunto de entrenamiento, aplicando un
escalado, una rotación, un zoom, así como también manejando los bordes de la
imagen y los rangos.
La razón por la cual fue aplicado sólo al conjunto de datos de entrenamiento fue
porque son esos datos los que alimentan la red neuronal y de los cuales depende
el qué tan bien o mal reconozca patrones.

3.3 DISEÑO DE ARQUITECTURA DE RED NEURONAL
Una vez que se realizó la selección de los datos a utilizar, se procedió a importar
los datos anteriormente mencionados, para ello, fue necesario utilizar la biblioteca
de Python “Pandas”16 que nos permite manejar con facilidad los datos dentro de
archivos, como, por ejemplo, los CSV, que nosotros tenemos en FER2013.

Figura 19-Importación de datos FER2013.
Dentro del mundo de las redes neuronales existen bastantes tipos, sinembargo,
nosotros hemos optado por utilizar una red neuronal convolucional por la facilidad
que nos da al manejar imágenes, además de necesitar menos neuronas y en
algunos casos obtener mayor cantidad de parámetros de aprendizajes.
Las redes neuronales convolucionales imitan la visión generada por el ojo humano,
especializándose en visión por jerarquías, esto quiere decir, que primero se
detectan líneas, después curvas y se va profundizando hasta poder reconocer
formas complejas como siluetas o más específicamente, rostros.

En estado puro una computadora no puede saber qué contiene una imagen, sin
embargo, sabemos que sí puede identificarlas debido a sus pixeles. Por ejemplo,
una computadora no verá la imagen como en la Figura 20, sin embargo, sí las verá
como en la Figura 21.

Figura 20-Un ejemplo de FER2013

Figura 21-Código que representa una imagen en
pixeles.

La Figura 21, es un código escrito en Python que permite visualizar la Figura 20 en
forma de pixeles. Se puede identificar fácilmente el resultado observado en la
matriz, debido a que en la imagen 5 se puede ver el comienzo con un color negro y
la finalización de la imagen en tonos grises. Si se analiza la matriz de la imagen 6
se obtienen valores de entre 184 y 186, siendo pixeles correspondientes a colores
grises.
Los pixeles observados en la Figura 21 representan la entrada de la red
convolucional, por lo que haciendo una operación básica 48x48 podemos obtener
que tendremos 2,304 neuronas de entrada y eso sólo para las imágenes a escalas
de grises, si en lugar de tener imágenes en escalas de gris, tuviéramos imágenes
totalmente a color (RGB)17 tendríamos que hacer la siguiente operación 48x48x3 y
en total tendríamos 6,912 neuronas de entrada.

Nosotros podíamos trabajar normalmente con los pixeles que toman valores de 0 a
255, sin embargo, se acostumbra a normalizar los datos entre 0 y 1, esto, de manera
práctica para hacer el entrenamiento de la red neuronal más rápida y reducir el
atascamiento del entrenamiento. Además, está confirmado que calcular los pesos
de las conexiones de red neuronal se puede hacer mejor si los datos se encuentran
normalizados, al final de cuentas, es más rápido operar con valores de entre 0 y 1,
que valores entre 0 y 255.

Figura 22-Normalización de los pixeles
En la Figura 22 se puede observar la normalización de 0 a 1 que se ha realizado en
el proyecto. Para ello hemos utilizado variables como X_train o X_test estas
variables contienen las imágenes dedicadas para Entrenamiento y Prueba, en la
imagen no se muestra, pero existe otra variable X_val la cual contendrá imágenes
de validación. Por su parte las variables Y_train,Y_test y Y_val contendrán las
etiquetas correspondientes a cada imagen, esa etiqueta, es en este caso un número
de entre 0 y 6 que corresponde como se ha indicado anteriormente a una emoción.

Figura 23-Arquitectura de una CNN

Hasta el momento conocemos la entrada de la red neuronal, que en la Figura 23
sería “Imagen de entrada”, cuando hablamos de la convolución, es decir, ese
proceso que le da nombre a la red neuronal, hablamos de seleccionar un grupo de
pixeles cercanos entre ellos en la matriz que forma la imagen de entrada e ir
realizando productos escalares contra una matriz más pequeña llamada “kernel”18.
Esto se puede expresar de la siguiente manera matemática
𝑆𝑆(𝑎𝑎) = (𝑓𝑓 ∗ 𝑔𝑔)(𝑎𝑎) = � 𝑓𝑓(𝜑𝜑)𝑔𝑔(𝑎𝑎 − 𝜑𝜑)𝑆𝑆𝜑𝜑∞−∞
Donde f es el argumento de entrada y g el kernel.

Figura 24-Ejemplo de convolución
La convolución se puede interpretar como observamos en la Figura 24, cuyo
argumento de entrada lo tomaremos como la matriz “Input” y el kernel como la matriz
“Kernel”. Como salida de las operaciones tenemos la sumatoria de dicho producto
escalar. El movimiento que hace el kernel sobre el argumento de entrada, es de
izquierda-derecha, de abajo-arriba. El movimiento que hacer el kernel por la matriz
de entrada, se llama “stride” y está definido por valores enteros.

Figura 25-Stride de 1

Figura 26-Stride de dos

Como se puede observar en las imágenes anteriores, el valor del Stride será el
número de columnas que el kernel se moverá para realizar otro producto escalar.
Esta operación se realizará tantas veces como sea necesarias para recorrer la
matriz del argumento de entrada. Como se observa en la Figura 24 dicha operación
genera una matriz de salida, esa matriz es llamada “matriz de rasgos” o “mapa de
activación”.
Esta operación se realiza para obtener las propiedades o rasgos más relevantes de
la matriz de inicio. En lugar de que la red neuronal “se fije” en toda la matriz, se
busca “fijar” la atención en las características más importantes. La convolución se
puede realizar varias veces y al proceso se le llama “aplicar filtros” que no es más
que aplicar varios kernel, aunque en realidad no dejamos de tener solamente una
matriz de rasgos o mapa de activación, eso sí, con varias capas al fondo
representadas por los filtros.

Figura 27-Indicación de tamaño de kernel,activación ReLu y strides en nuestro proyecto

Una vez que se obtuvo la matriz de rasgos, se aplicó una función rectificadora
(ReLu)19 para no incrementar la “linealidad” del resultado, pues esta función rompe
la “linealidad”.
La función Relu se define como: 𝑟𝑟𝑟𝑟𝑆𝑆𝑟𝑟(𝑧𝑧) = max (0, 𝑧𝑧)
Donde convertimos todos los valores menores a menores a cero, en cero, y todos
los valores positivos los deja tal cual.

Figura 28-Función de activación ReLu
La razón por la que utilizamos la función de activación ReLu en nuestra red
neuronal, fue que cuando procesamos un imagen, cada capa de convolución debe
capturar algún patrón en la imagen y pasarla a la siguiente capa de convolución, sin
embargo, todos los valores negativos no son importantes en el procesamiento de
imágenes, por lo tanto, es mejor establecerlos en cero, justo lo que hace ReLu; los
valores positivos sí son importantes, esos valores se quedan como están y pasan a
la siguiente capa de convolución.

Finalmente se utilizó una red neuronal multicapa, esta fue utilizada como clasificador
y tenía la función de activación Softmax, que filtra sólo el mejor resultado y lo
muestra en pantalla, es decir, es esta función de activación la que elige cual de
todas las neuronas pertenecientes a la red neuronal multicapa fue la más activa o
la que más “se encendió”.
La arquitectura final de la red neuronal fue la observada en la siguiente figura.

Figura 29-Arquitectura final

Como se puede observar en la Figura 29, nuestra arquitectura final constó de tres
capas convolucionales con activación RELU, así como también una red neuronal
multicapa que compone la capa final junto con la capa con activación Softmax.

3.4 ANÁLISIS DE LA EFICACIA DE RED NEURONAL

Una vez realizado este procedimiento, se procedió a ejecutar el entrenamiento, es
decir, a pasar una y otra vez los batch de imágenes para hacer que la red neuronal
diseñada previamente, analice las imágenes, encuentre los rasgos más
importantes.
Una vez realizado el entrenamiento, se ha verificado la eficacia de nuestra red
neuronal en primer término utilizando solamente el “accuracy”20. Obteniendo como
resultado una exactitud de hasta el 80% tal como se muestra en la Figura 30.

Figura 30-Accuracy final
Cabe recalcar que con obtener solamente un buen “accuracy” no es indicativo
suficiente para decir que la red neuronal es eficiente. Para poder lograr que nuestra
red neuronal sea eficiente, debemos checar otros índices, tales como la Precisión,
con cuya métrica podemos medir la calidad del modelo de Deep Learning.
La forma en que se calcula la precisión es:
𝑝𝑝𝑟𝑟𝑟𝑟𝑎𝑎𝑆𝑆𝑆𝑆𝑆𝑆𝑝𝑝𝑛𝑛 = 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇 + 𝐹𝐹𝑇𝑇
Donde:TP = Positivos verdaderos
FP = Falsos positivos
Además de esto, otra métrica importante es el Recall21 (Exhaustividad), cuya
métrica nos informa sobre la cantidad que el modelo creado es capaz de identificar.
Es decir, ¿qué porcentaje de los datos somos capaces de identificar correctamente?

La forma en la que se calcula el Recall es la siguiente:
𝑟𝑟𝑟𝑟𝑎𝑎𝑆𝑆𝑆𝑆𝑆𝑆 = 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇 + 𝐹𝐹𝐹𝐹
Donde:
TP = Positivos verdaderos
FN = Falsos negativos
Finalmente tenemos el valor F122, que se utiliza para combinar las medidas de precisión y
recall en un sólo valor. Es el valor más práctico porque hace más fácil el poder comparar el
rendimiento combinado de la precisión y exhaustividad entre varias soluciones.
El valor F1 se calcula haciendo la media armónica entre la precisión y la exhaustividad.
𝐹𝐹1 = 2 · 𝑝𝑝𝑟𝑟𝑟𝑟𝑎𝑎𝑆𝑆𝑆𝑆𝑆𝑆ó𝑛𝑛 · 𝑟𝑟𝑟𝑟𝑎𝑎𝑆𝑆𝑆𝑆𝑆𝑆𝑝𝑝𝑟𝑟𝑟𝑟𝑎𝑎𝑆𝑆𝑆𝑆𝑆𝑆ó𝑛𝑛 + 𝑟𝑟𝑟𝑟𝑎𝑎𝑆𝑆𝑆𝑆𝑆𝑆
El valor F1 asume que nos importa de igual forma la precisión y la exhaustividad. Aunque
esto no tiene que ser así en todos los problemas, en el caso de la clasificación que nosotros
realizamos, sí es importante.

La forma en la que se obtuvieron estos valores utilizando Python, fue haciendo uso de la
librería scikit-learn, especialmente de la función classification_report.

Figura 31-Reporte de clasificación
Como se puede observar en la Figura 31, los valores arrojados en precisión, Recall
y f1-score son muy altos. En global, tenemos un promedio de 0.80 en f1-score, cuya
conclusión rápida nos dice que obtuvimos que nuestra red neuronal lograra detectar
y clasificar hasta en un 80% los casos presentados.

3.5 DISEÑO DE APLICACIÓN DE CLASIFICACIÓN EN TIEMPO REAL
Una vez finalizado el proceso de creación de la red neuronal, fue necesario diseñar
y programar una aplicación que pudiera clasificar en tiempo real, por medio de una
cámara de vídeo, las emociones presentes en las personas. La aplicación diseñada
hace uso de una webcam, sin embargo, es posible conectar una cámara de vídeo
(como se explica en el trabajo a futuro) para lograr clasificar los estados anímicos
de los alumnos presentes en una clase.
Las especificaciones de la webcam utilizada son:
• Cámara HD HP Wide Vision
• Micrófono integrado
• Matriz digital de doble integrado
• 2.4Mpx
La aplicación hace uso de la biblioteca Open CV23, Keras y Numpy24.
OpenCV para la asignación de perímetros, Keras para la carga y función de la red
neuronal y Numpy para el manejo de números.
Lo primero que se hizo fue asignar a cada emoción un color, esto para hacerlo más
representativo.

Figura 32-Asignación de colores
En la Figura 32 se puede observar, como, además de asignar colores a las
emociones, se crea un diccionario de nombre “imotions” a los cuales se les agrega
un valor número (que representa la emoción) y su texto. Esto para posteriormente
utilizarlo en una gráfica en tiempo real. Además, para evitar inconvenientes con el
dataset utilizado.
Posteriormente se realizó la carga de la red neuronal previamente diseñada y
entrenada y hizo uso de un archivo de nombre “haarcascade_frontalface_default”.

Este archivo contiene un clasificador de rostros humanos ya preentrenado, de uso
libre y disponible para descarga desde el repositorio en github de OpenCV.

Figura 33-Utilización de la red preentrenada de OpenCV
En la Figura 33 se puede apreciar con claridad, como se cargó la red neuronal, así
como también se hizo uso del clasificador de OpenCV.
Se habilitó la cámara por medio del modulo VideoCapture de la misma biblioteca y
se procedió a utilizar la función “detectMultiScale” que permite por si sola detectar
los rostros. Cabe alcarar que al hacer uso de detectMultiScale, fue necesario pasar
la imagen detectada a escala de grises, esto, porque como se mencionaba en
apartados superiores, nuestra red neuronal sólo hace clasificaciones en escala de
grises y en un tamaño de 48x48 pixeles, tal como se indica en la función resize de
opencv dentro de la Figura 33.
Finalmente se hace uso de la función rectangle de OpenCV que permite encerrar
en un rectángulo el rostro detectado y dentro de ese rectángulo clasificar la emoción
presente, para ello, dentro de los parámetros se indica que recibirá los colores y
“imotions” que al inicio del programa fueron configurados.

El resultado de dicha aplicación es el siguiente:

Figura 34-Resultado final de la aplicación
Como se aprecia en la Figura 34 la detección del rostro sirve para poder encerrar
en un rectángulo que se colorea dependiendo de la emoción detectada, además de
que, en la parte inferior del rectángulo, muestra en color y texto la emoción
clasificada.
Es importante recalcar que en la aplicación existe un retraso de transmisión de
vídeo, esto debido a la calidad de la cámara, así como también del hardware de la
computadora utilizada, pues tiene que hacer cálculos muy extensos para lograr
intentar clasificar lo que recibe en forma de vídeo por medio de la webcam.

3.6 CREACIÓN DE LA PLATAFORMA WEB UTILIZANDO DJANGO
Una vez creado el modelo de la red neural convolucional se procedió a la creación
del Front End. Como se mencionó anteriormente, todo esto se desarrolló con el
framework Django en su versión 3 para la respectiva versión de Python utilizada en
el desarrollo de Back End.
Django nos ofreció una serie de herramientas que nos ayudó a tener una mejor
organización de los recursos empleados para el desarrollo de una interfaz. En
nuestro caso se utilizó lo siguiente:
• Creación de la base de datos.
• Creación del proyecto django.
• Creación de la aplicación captura y vista principal.
• Configuración de django.
• Creación del modelo de la aplicación captura y vista principal.
• Creación de vistas y enlaces URLs.
• Desarrollo html y css.
Cabe aclarar que el modelo no se creó mediante las herramientas que ofrece
Django, si no en un entorno de desarrollo diferente, ya que, si esto fuera así la
aplicación web se vería muy afectada en su rendimiento y necesitaría muchos
recursos en cuestión de hardware, puesto que nosotros no contábamos con estos
recursos y queríamos que fuera lo más optimo posible se trabajó en dos entornos
de desarrollo diferente.

3.6.1 CREACIÓN DE LA BASE DE DATOS
Para poder manipular las imágenes que se quieran tomar o subir a la aplicación
web, como también proveer un login a los usuarios que utilicen la aplicación
supervisada por un admin, se creó una base de datos en postgrees mediante el
gestor de BD pgAdmin 4.

En la base de datos se almacenan las imágenes subidas por el mismo usuario o las
capturas tomadas mediante la webcam en tiempo real desde la página web y los
datos de registro del usuario para el login.
La información se almacenó en dos tablas creadas a partir de los modelos
previamente hechos en Django (se habla de esto más a profundidad en su apartado
correspondiente), introducidos desde su propio gestor y mediante la página web ya
creada.

Figura 35-pgAdmin 4

3.6.2 CREACIÓN DEL PROYECTO DJANGO
Para la realización del proyecto en Django, se creó un entorno virtual para prevenir
ciertos errores y compatibilidades a la hora que se realizó el software, dentro de
este entorno virtual se instaló Django 3.0. También, como se mencionó
anteriormente se creó la base de datos del proyecto en postgrees pero como la
configuración predeterminada de Django trabaja con mysql se instaló una
herramienta o aditamento que permite conectar la BD de postgrees a django, esta
se llama psycopg2 en su versión 2.8.4.
Al instalar Django se creó automáticamente los archivos predeterminados
correspondientes a la creación de la aplicación web junto al archivo manage.py, sin
este archivo Djangono reconoce el proyecto por consiguiente no se va poder migrar
los modelos creados a la base de datos y lo más importante es que no correría la
página web.

Figura 36-Archivos generados por Django

3.6.3 CREACIÓN DE APLICACIÓN “GESTOS” Y VISTA PRINCIPAL

Estas dos aplicaciones fueron creadas desde los comandos que brinda Django en
el CMD, con el beneficio de tener una mayor organización a la hora de crear las
vistas que tiene cada aplicación, ya que cada una tiene funciones diferentes y lo
que se pretende como trabajo futuro es mejorar estas dos, por lo que los modelos
creados dentro de estas serán solo correspondientes a la función que tenga su vista.

Django cuenta con un archivo de configuración en lenguaje python el cual se llama
settings.py, en este se configuró la base de datos en la cual previamente como se
comentó. Se tuvo que instalar un aditamento para que se pudiera enlazar la base
de datos y despues se configuró en ese archivo con los siguientes datos:
• Engine: el codigo de enlace para la base de datos.
• Name: el nombre de la base de datos.
• User: admin de la base de datos (por defecto dejamos el de postgrees).
• Password: la contraseña de la BD.
• Host: el servidor que da soporte y conexión a la base de datos, en nuestro
caso trabajamos corremos todo desde nuestra computadora local o en la que
trabajamos la interfaz, por lo que seria un localhost.
• Port: es el puerto de conexión virtual donde se envian datos y vicebersa.
Figura 37-Aplicaciones login y vista general

Tambien se configuró dentro del codigo de configuración la parte del
reconocimiento de las apliaciones creadas, ya que Django permite crearlas pero al
no tener un forma de reconocer en que carpeta estan se tienen que meter
“manualmente”.

Figura 38-Apps configuradas

Como se puede observar en la Figura 38 en los dos ultimos datos de la tupla se
encuentra señalado entre comillas primero la capeta apps dentro del proyecto
seguido de un punto y por ultimo la app que se creo, dividos por una coma.
Por ultimo y no menos importante se configuraron los archivos estaticos que se
utilizaron para la realización de todo lo referente al front end, como son archivos
css, js y json, para ello se tuvo que anexar una linea de codigo proporcionada por
la pagina oficial de Django.

Figura 39-Configuración de archivos estáticos
Lo que hace esta linea de código a grandes rasgos es la vinculación de la carpeta
creada para fines ya dichos (en nuestro caso la carpeta “static”) dentro de la carpeta
del proyecto encontrada en el manage.py. Dentro de la carpeta static se introduciran
todos los archivos locales utilzados para el proyecto.

Para fines prácticos tambien se configuró una carpeta especial para los templates
o los archivos html de manera similar a la carpeta static, unas lineas debajo de
donde esta la tupla de aplicaciones del archivo settings.py se encuentra el apartado
de los templates, detro de esa configuración se le introdujó la linea de código
remarcada.

Figura 40-Configuración de la carpeta templates.
Dentro de la carpeta static se agregaron otras carpetas para fines de ordenamiento,
por ejemplo imágenes,archivos css, js y una para la red neuronal, pero ya que estan
dentro de esta carpeta ya no se tienen que configurar, ya que al estar configurada
la carpeta proncipal todo lo de adentro de igual manera de reconocera por django,
ya sean carpetas o archivos.

Dentro de django, como ya se comentó, al crear un aplicación se crea
automaticamente un archivo llamado models.py. Se crearon dos modelos:
• Registro para login: en este se crearon todos los campos correspondientes
con el registro del usuario, esto gracias a que en django se pueden crear
campos especificos para cada cosa a nivel codigo con facilidad, ya que todo
el back end es python y solo se tienen que migrar a la base de datos con los
comandos que ofrece django. Todo cambio que se haga en los modelos y se
quiera migrar, se vera reflejado en la base de datos.

Figura 41- Modelo registro
• Imágenes para vista_principal: este modelo solo se creó como un apartado
extra y desarrollo futuro para poder guardar las imágenes tomadas desde la
pagina web, por lo que solo va tener un campo de almacenamiento.

Figura 40-Modelo imágenes
Ya habiendose elaborado los modelos, se migraron a la base de datos para que
estos tengan funcionalidad, sino, no se verian reprensentados dentro del gestor
propio de django conectado a postgrees. Todas estas migraciones se guardan en
una carpeta llamada migrations, ahí se pueden observar los cambios que se hagan
a los campos del los modelos como el mismo codigo que se exporta a la base de
datos para su ingreso.

Figura 41-Migración de modelo registro

De esta forma django representa de una forma no tan compleja las migraciones que
se hagan. Dentro del objeto migrations se encuentran tres variables:
• Initial.
• Dependencies.
• Operations.
La variable initial se activa cuando se hace la migración del primer modelo por lo
que la base de datos la toma como la tabla principal en la cual se van desprender
las demas tablas o modelos. En nuestro caso se puso el modelo registro para poder
vincular el modelo imágenes, ya que del login va depender la captura de la imagen.

Figura 42-Migración de modelo imágenes

Como se observa en la “tupla dependencias” se encuentra el nombre de la app y la
migración del modelo con el que esta realcionado la migracion de imágenes,
parecido o igual a lo que seria una llave foranea. Esto se puede hacer manualmente
o en nuestro caso al ser muy siemple la relación de una tabla a otra se opto que lo
hiciera automaticamente django, haciendo primero la migración del modelo registro
y depues la de imágenes.
En la “tupla operaciones” se pueden observar en nuestro caso el nombre del modelo
y los campos creados, pero si se modifica algun campo del modelo se vera reflejado
en esta tupla.
Cabe aclarar que antes de que se migrar los modelos se tuvieron que crear estos
archivos con la instrucción makemigrations, pues si no se hace esto y se migra de
forma directa no se podran borrar los campos que se hallan hecho, por lo que se
tendria que reacer la base de datos.

Figura 43-Modelos migrados a la BD.

3.6.4 CREACIÓN DE VISTAS Y ENLACES URLs

Las vistas en Django serían las paginas dentro de la aplicación web enlazadas unas
con otras mediante URLs, los cuales se declaran dentro de carpeta principal de
Django dentro del archivo urls.py. En el archivo mencionado se tiene que importar
primero el archivo views.py indicando la carpeta donde se encuentran almacenadas
las apps e indicando cual es esa app.

Figura 43-URL’S
Como se puede observar en la Figura 43, se crearon cuatro URLs correspondientes
a cuatro vistas y una URL creada automáticamente por Django. Las tres primeras
están ligadas con views.py de login, ya que en este se encuentran almacenadas
estas tres vistas por lo que cada una tuvo su propia URL (cada vista será explicada
más adelante). La cuarta URL se vinculó con la vista principal que sería la captura
o toma de foto de la imagen mediante la webcam, o subiendo una imagen desde la
computadora donde se esté utilizando esta página web. En la última parte del
contenido de la tupla se encuentra la url del acceso al administrador de Django, aquí
el administrador puede ingresar a los usuarios que requirieran la utilización de esta
página, para poder así tener un mayor control de registros a la aplicación web y no
cualquiera se meta.

De igual manera el administrador del sitio tendrá todos los privilegios para poder
observar, quitar y agregar contenido relacionado con los modelos que se crearon,pues como ya se comentó Django está ligado en casi toda su totalidad con la base
de datos.

Figura 44- Ejemplo de administrador de Django.

Por obvias razones a la hora que se crean las URLs se tiene que haberse creado
previamente las vistas de las aplicaciones, ya que si no fuera así la página web te
direccionaría a la URL solicitada pero no tendría ningún contenido y al mismo tiempo
ninguna funcionalidad.
Las vistas creadas para la aplicación login son las siguientes:
• Welcome.
• Login.
• Logout.

La primera vista autentifica el inicio de sesión mediante una función proporcionada
por una de sus tantas librerías de Django y carga el template principal
(principal.html), si no se puede autentificar se redirecciona a la vista login mediante
su URL.

Figura 45-Vista “welcome”

La segunda vista consta de toda la funcionalidad principal del login, iniciando con
un formulario de autentificación el cual recibe los datos escritos a través de las
casillas del html principal que indican el usuario y la contraseña, después se valida
esta información con la introducida en la base de datos por el administrador de
Django y por último si existen estos datos se redirecciona a la vista “welcome”, y se
encarga de lo que se dijo anteriormente.

Figura 46-Vista login

La tercera es la vista más simple que se hizo, ya que solo se usó la función lo_logout
de Django y solo va a recibir una petición del usuario si quiere cerrar sesión y a su
misma vez lo redireccionara a la template que tiene el login.

Figura 47-Vista logout

La última vista que se desarrollo fue una especialmente dirigida al modelo de la red
neuronal mencionada anteriormente, ya que en esta se va a llevar a cabo todo el
reconocimiento anímico que pase atreves de la webcam o al subir alguna imagen a
la plataforma web. Una cosa a tomar en cuenta es que el reconocimiento en tiempo
real se lleva a cabo a través de una ventana en el sistema operativo llamada ‘”img”,
pues el modelo al ser un archivo local se reconocería como un archivo estático por
lo que aplicación web llama de manera local al modelo y su interfaz, y se ejecuta
fuera de la página.

Figura 48-Vista_principal

Para no explicar de nuevo todo el código respecto al uso o carga del modelo creado,
lo único diferente que se hizo fue la adaptación de ello a django, solamente
generando una función con un request hacia la carga del modelo y por último
redirigiéndose a la pagina principal de la página web.

3.6.5 DESARROLLO HTML Y CSS
Por último, lo que su hizo al desarrollo del proyecto fue darle un front end de fácil
uso con un login de igual manera, por lo que se hicieron dos archivos html con sus
respectivos css y un js para el uso de la webcam en la aplicación web.
Para no hablar de los estilos que se pusieron, se habla de los aspectos importantes
agregados a las plantillas (todos estos comentados anteriormente), los cuales
fueron los siguientes:
• Botones de inicio de sesión y logout.
• Selección de herramientas a utilizar (reconocimiento de archivo imagen y
reconocimiento en vivo o en tiempo real).
• Implementación de permiso y uso de la cámara web.
• Captura de imagen de la webcam.
• Direccionamiento a la carga de imágenes y reconocimiento en tiempo real a
la red neuronal.

CAPITULO 4
PRUEBAS Y
RESULTADOS

Durante el proceso de desarrollo, el diseño de la red neuronal pasó por varios
prototipos, así como también fueron probados diversos tipos de arquitecturas para
evaluar la eficacia final. A su vez, fueron programados aplicaciones individuales que
formarían parte del trabajo final. Estos desarrollos pasaron por cambios visuales
que permitieron elegir uno que lograra englobar todos los elementos principales e
importantes para el usuario final.
La versión final de nuestra arquitectura de red neuronal arrojó un resultado de hasta
un 80.61% de exactitud en pruebas, es decir, que el entrenamiento de la red
neuronal fue tan eficaz que, al ingresar un dato de prueba (es decir, una imagen
cuyo índice no indica qué tipo de emoción es representada en los gestos físicos
faciales), la red neuronal fue capaz de detectarla correctamente hasta en un 80.6%.

Figura 36-Muestra de exactitud
Uno de los dataset que se utilizó para el entrenamiento de la red neuronal, fue
extraído de Kaggle (especialmente de un concurso donde se proporcionaba el
conjunto de datos y cuya meta era lograr la mayor exactitud posible). Tomando
como base ese concurso, a pesar de haber terminado ya hace un par de años,
logramos colocar nuestra red neuronal en primera posición, hasta un 10% con
mayor exactitud que el primer lugar de la competición. Esto, lo tomamos como
referencia, pues basarnos solamente en dicho concurso no haría ni significaría que
nuestra red neuronal funcionara a la perfección, además, utilizamos un dataset más
para nuestro entrenamiento, lo cual significa que teníamos mayores probabilidades
de lograr una mejor exactitud al tener muchos más datos de entrenamiento.

Figura 37-Campeonato Kaggle
Tal como se puede observar en la Figura 37, si analizamos la exactitud de nuestra
red neuronal y la comparamos, por ejemplo, con el equipo de nombre RBM que
logró el primer lugar de la competencia, nuestro rendimiento fue mucho mayor y
esto habla de una arquitectura de red neuronal adaptada al problema, es decir, no
genérica.
Las primeras versiones de nuestras aplicaciones individuales permitían únicamente
la carga de una imagen estática para su análisis posterior. La razón principal por la
cual una de nuestras primeras pruebas fueron gráficas estáticas que representaban
imágenes estáticas, fue porque nos permitían observar con claridad si nuestra red
neuronal estaba funcionando perfectamente, de esa forma, si cargábamos una
fotografía y esta respondía con una gráfica donde la barra mayoritaria fuera la
expresión correcta, podíamos comprobar el funcionamiento.

Figura 38-Prueba con rostro enojado.

Figura 39-Prueba con rostro neuronal.
En la Figura 38 y Figura 39, la red neuronal en principio trabaja de forma correcta,
pues, en la primera figura de la página de izquierda a derecha, podemos observar
que se encuentra el rostro de uno de los autores, Alberto Espinosa, para ser
exactos, con rostro enojado y en la gráfica estática la red neuronal la evalúa de esa
manera, sin embargo, observa también un rostro posiblemente feliz, como se
muestra en una siguiente barra. Lo anterior se debe a varias posibles razones, aquí
expresamos las dos detectadas principalmente y que se corrigieron posteriormente.
1. La calidad de la fotografía, al ser tomada con una webcam de apenas 2 Mega
Pixeles, la calidad de información en la imagen es muy pobre si lo
comparamos a una prueba realizada, por ejemplo, con una cámara cuyo
sensor sea de más de 13 Mega Pixeles.
2. Por otro lado, nos encontramos con la exactitud de la red neuronal, como se
pudo observar, tiene una exactitud de 80.6%, lo que quiere decir que aún
existe un 19.4% de posible error, a eso aumentarle que, en la Figura 31 del
capitulo 3 “Desarrollo”, se puede observar como cada emoción contiene un
porcentaje de F1 (explicado en el mismo capítulo) distinto, lo que quiere decir
que, en cada emoción, la detectará con cierto porcentaje de eficacia,
diferente en cada uno.

La forma en la que trabaja el reconocimiento estático es el siguiente:
1. Se toma la fotografía vía webcam y por medio de un script, automáticamente
se renombra el archivo (para que el nombre nunca cambie y se pueda hacer
de forma automático el reconocimiento).
2. Se recorta la fotografía a un tamaño de 48x48 pixeles.
3. Se aplica un filtro de grises perteneciente a Python
4.