Desbalanceo de datos en redes de clasificación binaria - Grado en Ingeniería Multimedia Trabajo Fin de Grado - RUA
←
→
Transcripción del contenido de la página
Si su navegador no muestra la página correctamente, lea el contenido de la página a continuación
Escuela
Politécnica
Superior
Desbalanceo de datos
en redes de
clasificación binaria
Grado en Ingeniería Multimedia
Trabajo Fin de Grado
Autor:
Pablo Amorós Becerra
Tutor/es:
Antonio Javier Gallego Sánchez
Jorge Calvo Zaragoza
Septiembre 2021Desbalanceo de datos en redes de
clasificación binaria
Autor
Pablo Amorós Becerra
Tutor/es
Antonio Javier Gallego Sánchez
Departamento de Lenguajes y Sistemas Informáticos
Jorge Calvo Zaragoza
Departamento de Lenguajes y Sistemas Informáticos
Grado en Ingeniería Multimedia
Escuela
Politécnica
Superior
ALICANTE, Septiembre 2021Preámbulo Con este proyecto se pretende estudiar las posibles mejoras a aplicar a una red neuronal de clasificación binaria que ha sido entrenada con un conjunto de datos desbalanceado. Para el estudio de estas mejoras se han utilizado los conjuntos de datos Modified National Insti- tute of Standards and Technology database (MNIST), National Institute of Standards and Technology database (NIST) y United States Postal Service database (USPS). La motivación que me ha llevado a escoger este trabajo, son mis ganas e interés para iniciarme en el mundo del Deep Learning y la inteligencia artificial en general. Vi en este proyecto la oportunidad perfecta para comenzar a aprender sobre el tema en cuestión.
Agradecimientos En primer Lugar, me gustaría agradecer a mis dos tutores, Jorge Calvo Zaragoza y Antonio Javier Gallego Sánchez, por toda su ayuda con el proyecto y por proponerme un tema tan interesante. Por otro lado, debo agradecer a mis amigos por apoyarme y por estar a mi lado en las buenas y en las malas. En especial, quiero darle las gracias a Julio por estar ahí cuando lo he necesitado. Por último, y más importante, papá, mamá, Sergio, gracias por todo el apoyo incondicional durante todos estos años, sin vosotros esto no habría sido posible.
El fracaso es aquí una opción.
Si las cosas no fallan es que no estás innovando lo suficiente.
Elon Musk.
ixÍndice general
1 Introducción 1
1.1 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Estructura del trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Marco Teórico 5
2.1 ¿Qué es una CNN? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Arquitectura de una Convolutinal Neural Network (CNN) . . . . . . . 5
2.1.2.1 Convolución . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2.2 Reducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.2.3 Clasificación . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.3 Backpropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.4 Funciones de pérdida . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.4.1 ¿Qué son las funciones de pérdida? . . . . . . . . . . . . . . 8
2.1.4.2 Entropía cruzada (crossentropy) . . . . . . . . . . . . . . . . 9
2.1.4.2.1 Entropía cruzada categórica (categorical crossentropy) 9
3 Herramientas y recursos 11
3.1 Tecnologías . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.1 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.1.1 NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.1.2 Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.1.3 TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.1.4 Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1.1.5 SciKit Learn . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1.1.6 Jupyter Notebook . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1.1.7 Google Colaboratory . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Datasets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2.1 MNIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2.2 NIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2.3 USPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4 Desarrollo 15
4.1 Arquitectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1.1 Etapa de extracción de características . . . . . . . . . . . . . . . . . . 15
4.1.2 Etapa de clasificación . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.1.3 Red implementada en Keras . . . . . . . . . . . . . . . . . . . . . . . . 16
xixii Índice general
4.2 Pipeline del script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2.1 Inicialización de parámetros . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2.2 Descarga del dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2.3 Preparación y desbalanceo de los datos . . . . . . . . . . . . . . . . . 18
4.2.4 Entrenamiento de la red . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2.5 Evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3 Soluciones propuestas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3.1 Aumentado de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3.2 Pesos de clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4 Métricas utilizadas en el estudio . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.4.1 Precisión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.4.2 Exhaustividad(Recall) . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.4.3 Valor-F(F1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5 Resultados 23
5.1 Casos contemplados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.1.1 Hiper-parámetros utilizados . . . . . . . . . . . . . . . . . . . . . . . . 24
5.2 Estructura de los resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.3 Modelo base sin balancear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.3.1 Resultados del entrenamiento . . . . . . . . . . . . . . . . . . . . . . . 26
5.3.1.1 MNIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.3.1.2 NIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.3.1.3 USPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.4 Aplicando el aumentado de datos . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.4.1 Resultados del entrenamiento . . . . . . . . . . . . . . . . . . . . . . . 28
5.4.1.1 MNIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.4.1.2 NIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.4.1.3 USPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.5 Aplicando los pesos de clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.5.1 Resultados del entrenamiento . . . . . . . . . . . . . . . . . . . . . . . 30
5.5.1.1 MNIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.5.1.2 NIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.5.1.3 USPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.6 Tablas comparativas de los resultados . . . . . . . . . . . . . . . . . . . . . . 32
6 Conclusiones 35
6.1 Posibles mejoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.1.1 Aplicar porcentajes distintos a cada dataset . . . . . . . . . . . . . . . 35
6.1.2 Combinar las soluciones aplicadas . . . . . . . . . . . . . . . . . . . . 35
Bibliografía 37
Lista de Acrónimos y Abreviaturas 39Índice de figuras
1.1 Esquema de la Inteligencia Artificial. Fuente: Ionos (s.f.) . . . . . . . . . . . . 1
2.1 Representación matricial de la imagen de entrada y el kernel. Fuente: Na8 (2018) 6
2.2 Representación de la matricial imagen de entrada y el mapa de características.
Fuente: Na8 (2018) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Representación matricial de aplicación de ReLU. Fuente: Na8 (2018) . . . . . 7
2.4 Representación pictorial del Max-Pooling. Fuente: Wiki (s.f.) . . . . . . . . . 7
3.1 Imágenes de muestra del conjunto de validación de MNIST. Fuente: Wikipedia
(s.f.-b) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.1 Captura del formulario de parámetros . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Algunas muestras del dataset USPS y las dimensiones de este. . . . . . . . . . 18
5.1 Learning rate bajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.2 Learning rate correcto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.3 Learning rate alto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.4 Gráficas del dataset MNIST utilizando el modelo base. . . . . . . . . . . . . . 26
5.5 Gráficas del dataset NIST utilizando el modelo base. . . . . . . . . . . . . . . 27
5.6 Gráficas del dataset USPS utilizando el modelo base. . . . . . . . . . . . . . . 27
5.7 Gráficas del dataset MNIST utilizando el aumentado de datos. . . . . . . . . 28
5.8 Gráficas del dataset NIST utilizando el aumentado de datos. . . . . . . . . . . 29
5.9 Gráficas del dataset USPS utilizando el aumentado de datos. . . . . . . . . . 29
5.10 Gráficas del dataset MNIST utilizando los pesos de clase. . . . . . . . . . . . 30
5.11 Gráficas del dataset NIST utilizando los pesos de clase. . . . . . . . . . . . . . 31
5.12 Gráficas del dataset USPS utilizando los pesos de clase. . . . . . . . . . . . . 31
xiiiÍndice de tablas
5.1 Tabla comparativa del dataset MNIST de las clases 3 y 5. . . . . . . . . . . . 32
5.2 Tabla comparativa del dataset MNIST de las clases 7 y 9. . . . . . . . . . . . 32
5.3 Tabla comparativa del dataset NIST de las clases C y G. . . . . . . . . . . . . 32
5.4 Tabla comparativa del dataset NIST de las clases V e Y. . . . . . . . . . . . . 33
5.5 Tabla comparativa del dataset USPS de las clases 3 y 5. . . . . . . . . . . . . 33
5.6 Tabla comparativa del dataset USPS de las clases 7 y 9. . . . . . . . . . . . . 33
xv1 Introducción
El Deep Learning (DL) es un concepto que cada día está mas presente en nuestra sociedad.
En un mundo cada vez más conectado y en permanente evolución, donde el Big Data es
uno de los recursos más valiosos en nuestra sociedad, el DL tiene un papel fundamental,
aunque pasa desapercibido para la mayoría de personas, que hacen uso de él diariamente sin
ni siquiera saberlo.
Éstas técnicas se están aplicando en distintos ámbitos con el fin de realizar tareas del día
a día. Por ejemplo, el DL se utiliza para el reconocimiento automático de objetos, en los
algoritmos de recomendación de anuncios en medios digitales, conducción autónoma y otros
muchos campos.
La Inteligencia Artificial, como bien dice su nombre, se trata de la creación de sistemas
informáticos que traten de imitar el pensamiento y comportamiento humano. Este concepto es
algo abstracto y amplio ya que existen muchas técnicas y ramas muy distintas de Inteligencia
Artificial. En concreto, nos vamos a enfocar en el Machine Learning (ML) o aprendizaje
automático, que es la disciplina de la Inteligencia Artificial que se basa en utilizar una gran
cantidad de datos de ejemplo para entrenar modelos de predicción.
Como el ML es un concepto bastante extenso al igual queInteligencia Artificial (IA), vamos
a especificar un poco más este término y nos vamos a centrar en el aprendizaje profundo o
DL , que se basa en la simulación de un cerebro humano utilizando redes neuronales que
emulan su comportamiento.
Figura 1.1: Esquema de la Inteligencia Artificial. Fuente: Ionos (s.f.)
12 Introducción
Una red neuronal está constituida, al igual que un cerebro, por una serie de neuronas
organizadas en capas interconectadas entre sí que trabajan en conjunto para desempeñar
una labor. Cada neurona tiene na serie de parámetros o pesos, que son variables durante el
entrenamiento, de forma que se puede dar menor o mayor importancia a cada neurona según
estos valores.
Generalmente, estas redes neuronales suelen funcionar bien para problemas comunes y en
los que los datos de entrada están controlados y balanceados. El problema aparece cuando
intentamos entrenar a una red con un conjunto de datos desbalanceado y dispar, es decir,
cuando hay mucha diferencia en la cantidad de datos de las clases a identificar. En estos
casos, la red tiende a predecir únicamente las muestras a la clase dominante.
Para resolver este problema, se proponen una serie de posibles modificaciones que resuelvan
los casos de clasificación errónea.
1.1 Objetivos
En esta sección se exponen todos los objetivos que se desean alcanzar con el desarrollo de
este Trabajo Final de Grado (TFG):
• Conocer y entender qué es y cómo funciona el Deep Learning (DL): Con este
proyecto se pretenden conocer los métodos que se utilizan en el DL, como la creación y
estudio de redes neuronales y la interpretación de los datos que estas arrojan.
• Aprendizaje de los lenguajes y frameworks utilizados en el trabajo: En este
proyecto se utiliza Python, con varias librerías y frameworks como Tensorflow, NumPy
y Keras, que previamente desconocía.
• Entender los problemas de desbalanceo en redes neuronales: En el proyecto
se utilizarán datasets desbalanceados, por lo que se debe comprender la pérdida de
rendimiento por este debalanceo y por qué se produce.
• Experimentación con posibles modificaciones de una red neuronal: Se van a
realizar ciertas modificaciones en una red neuronal previamente creada con el fin de
mejorar su rendimiento.
• Establecer un primer contacto con la investigación: En cuanto a nivel acadé-
mico, con este trabajo se espera establecer un primer contacto con los proyectos de
investigación, qué metodología se sigue, cómo se deben estructurar este tipo de proyec-
tos, etc.
1.2 Estructura del trabajo
Este trabajo está estructurado en 6 capítulos bien diferenciados. Primeramente, encontra-
mos la introducción, donde se explica brevemente en qué va a consistir el trabajo y se explican
aspectos básicos sobre el tema que se va a tratar. En segundo lugar, se encuentra el marco
teórico, en este capitulo se exponen nociones más avanzadas sobre DL y la problemática del
desbalanceo de datos en el entrenamiento de redes neuronales.1.2. Estructura del trabajo 3 El tercer capítulo consta de una explicación sobre todas las herramientas utilizadas para realizar el trabajo, exponiendo desde tecnologías empleadas hasta los conjuntos de datos que se han destinado a estudiar el desbalanceo. Siguiendo este capitulo, se inicia el desarrollo, en el cual se dan detalles de la red neuronal utilizada, los problemas producidos por el uso de datasets desbalanceados y las soluciones aplicadas. Como es lógico, posteriormente al desarrollo, se sitúa el capítulo de resultados, en el que se indican los resultados de la red neuronal en el reconocimiento de caracteres antes y después de aplicar cada una de las técnicas propuestas para mejorar los resultados. Por último, se incluye un pequeño apartado que consta de las conclusiones que se han sacado al realizar este trabajo.
2 Marco Teórico
Para entender mejor el proyecto, primeramente es necesario exponer algunos conceptos
básicos sobre las redes neuronales, con ello se entenderá el problema en el que está enfocado
el proyecto y el por qué de la implementación elegida.
2.1 ¿Qué es una CNN?
2.1.1 Introducción
Una CNN es una red multicapa que está inspirada en el cortex visual de los animales, ya que
las neuronas artificiales se disponen de una manera muy similar a como se hace en la corteza
visual de un cerebro. La primera CNN fue creada por Yann LeCun en 1998 basandose en el
Neocognitron de Kuinhiko Fukushima, este a su vez se basó en el estudio que se menciona a
continuación.
En la corteza visual, tal y como estudiaron Hubel y Wiesel en 1959, se encuentran las células
responsables de la orientación y detección de bordes. En esta zona del cerebro se encontraron
dos tipos de neuronas distintas, las denominadas células simples y células complejas.
• Las células simples tienen un patrón de posición, rotación y tamaño determinado de
forma que si un estimulo visual coincide con el patrón de la célula, esta se activa y
manda una señal.
• Las células complejas únicamente tienen una rotación particular, por lo cual si el
estímulo tiene la misma rotación que la célula esta será activada.
2.1.2 Arquitectura de una CNN
Una CNN está constituida por dos bloques bien diferenciados. Primeramente, se encuen-
tra un bloque de extracción de características que está constituidos por múltiples capas de
neuronas convolucionales seguidas por capas de completamente conectadas de neuronas que
son las que realizan la clasificación final.
2.1.2.1 Convolución
El proceso de convolución consiste en tomar un grupo de píxeles de la imagen del mismo
tamaño que el kernel y realizar un sumatorio del producto escalar con este mismo kernel.
El kernel o núcleo consiste en una matriz que se utiliza como filtro para obtener las ca-
racterísticas o patrones importantes de una imagen, inicialmente este kernel toma valores
aleatorios, pero estos valores se ajustan durante el entrenamiento mediante backpropagation,
término que se explicará posteriormente.
56 Marco Teórico
Figura 2.1: Representación matricial de la imagen de entrada y el kernel. Fuente: Na8 (2018)
Esta convolución se realiza para todos los píxeles de la imagen, de izquierda a derecha
y de arriba a abajo, de forma que el resultado de la convolución es una nueva matriz que
representa las características de la imagen, dejando con un valor numérico más alto a las
zonas más dominantes de la imagen.
Figura 2.2: Representación de la matricial imagen de entrada y el mapa de características. Fuente:
Na8 (2018)
La matriz resultante(mapa de características) tiene un tamaño igual al tamaño original de
la matriz de la imagen menos el tamaño de la matriz menos uno. De forma, que si se tiene
una imagen de tamaño 5x5 y utilizamos un kernel de tamaño 3x3 obtendremos un mapa de
características de tamaño 3x3 puesto que:
Tm = Ti − (Tk − 1)
Siendo Tm el tamaño del mapa de características, Ti el tamaño de la imagen y Tk el tamaño
del kernel.
Una vez se realiza la convolución, se aplica una función de activación sobre este resultado,
para esta aplicaciones se suele utilizar la función rectificador ReLU( por sus siglas en inglés,
Rectified Linear Unit). Esta función tiene como salida el valor máximo entre el valor del
elemento y 0, de forma que podríamos decir que esta función ”elimina” los valores negativos
del mapa de características.2.1. ¿Qué es una CNN? 7
Figura 2.3: Representación matricial de aplicación de ReLU. Fuente: Na8 (2018)
2.1.2.2 Reducción
Posteriormente, una vez se ha realizado la convolución, se procede a reducir el tamaño de
la capa. Esta se realiza para sintetizar la información proveniente del mapa de características.
De esta forma, las mismas características corresponden a una región más amplia de la imagen
original, lo cual da una cierta tolerancia para imágenes muy similares.
Primeramente, para realizar esta reducción de muestreo, se utilizaban procesos de sub-
sampling, pero tras varias investigaciones se ha demostrado que es más eficiente utilizar
operaciones de max-pooling que, además, se asemejan más al comportamiento de la corteza
visual.
La operación de max-pooling consiste en buscar el mayor valor dentro de una ventana
seleccionada, es decir, sustituir una ventana de tamaño m x n por un valor que sea el máximo
encontrado en dicha ventana.
Figura 2.4: Representación pictorial del Max-Pooling. Fuente: Wiki (s.f.)
Por último, aclarar que este proceso de reducción de características puede repetirse varias
veces según la complejidad del problema que se esté abordando.
2.1.2.3 Clasificación
Una vez finalizada la fase de extracción de características, comienza la fase de clasificación.
En esta etapa, la red obtiene mapas de características muy depurados que esta debe clasificar,
es decir, dar una etiqueta u otra según los criterios establecidos. En el caso de este proyecto,
la red deberá clasificar únicamente en dos conjuntos de datos, puesto que se va a trabajar
con clasificaciones binarias.
Esta subred(la parte final utilizada para la clasificación) tiene forma de perceptrón multi-
capa, que como bien dice su nombre, es una red formada por múltiples capas, que suelen ser
redes totalmente conectadas.
Este tipo de redes están divididas en tres partes:8 Marco Teórico
• Por un lado se encuentra la capa de entrada que conecta la red con las entradas. En
esta capa encontraremos tantas neuronas como valores de entrada se envíen a la red.
• Las capas ocultas, suelen ser múltiples capas, en ellas se encuentran una o más neu-
ronas las cuales están conectadas con las neuronas de la capa anterior para recibir la
entrada, y se conectan con la capa posterior para enviar su resultado.
• Por último, se encuentra la capa de salida, que es la encargada de conectar las capas
ocultas con la salida de la red y muestra los resultados que esta ha calculado. En esta
última capa se suele utilizar la función de activación softmax.
2.1.3 Backpropagation
En las redes neuronales tradicionales, como el perceptrón multicapa visto anteriormente,
el backpropagation o retropropagación de errores consiste en modificar el valor de los pesos
de las interconexiones entre capas de neuronas, para reducir el error cometido a la salida.
El algoritmo consta de los siguientes pasos:
1. Se calcula la salida de la red o a partir de un conjunto de prueba x.
2. Se compara la salida con los valores correctos (t) y se calcula el error con la siguiente
fórmula.
1∑
m
(2)
(1))
E(x; W ; W = (2)
(ti − oi )2
2
i=1
Siendo m el número de muestras.
3. Se calculan las derivadas parciales del error con respecto a los pesos W (2) que unen la
última capa oculta con la de salida.
4. Se calculan las derivadas parciales del error con respecto a los pesos W (1) que unen la
capa de entrada con la oculta.
5. Se ajustan los pesos de cada neurona.
6. Se repite el proceso varias veces por cada par de valores del conjunto de prueba.
En las CNN el proceso es similar, pero tiene algunas diferencias, ya que en este caso se
ajustan los pesos de los kernels utilizados en las convoluciones.
2.1.4 Funciones de pérdida
2.1.4.1 ¿Qué son las funciones de pérdida?
Las funciones de pérdida modifican el valor de salida de cada neurona y, de esta forma,
permiten aprender funciones no lineales con las que se definen modelos de discriminación
más complejos. En dependencia del tipo de arquitectura y del problema a resolver se pueden
utilizar distintos tipos de funciones de pérdida. Por ejemplo, para las capas intermedias u
ocultas de la red se suele utilizar la función ReLU, mientras que para la capa de salida
se suelen utilizar las funciones tangente hiperbólica, sigomide o lineal para problemas de
regresión, y la función softmax cuando se trata de problemas de clasificación.2.1. ¿Qué es una CNN? 9
2.1.4.2 Entropía cruzada (crossentropy)
Antes de hablar de la entropía cruzada, previamente se debe conocer que significa el término
entropía. En el mundo de la teoría de la información, a la entropía se le conoce como la medida
de incertidumbre a las posibles variables de resultado. De forma que, la entropía es máxima
cuando todas las diferentes clases están igualmente distribuidas en cantidad, por el contrario,
la entropía es mínima cuando solo una de las clases aparecen en el conjunto de datos que se
entrena. Esta definición de la entropía fue presentada por Claude Shannon en 1948.
Conociendo el término entropía, se procede a definir en qué consiste la entropía cruzada
en redes neuronales. La entropía cruzada compara la probabilidad de cada clase (que ha
sido previamente devuelta por la red neuronal mediante la función softmax) con la clase real
(teniendo esta clase las mismas dimensiones que los valores devueltos por la función softmax,
un array de 2 posiciones en este caso, en el que la clase correcta tendrá el valor 1 y la incorrecta
el 0), calculando la pérdida de forma que penaliza la probabilidad según la lejanía que esta
tenga con el valor esperado. Esta pérdida tiene forma logarítmica por lo que se genera una
pérdida grande para las diferencias grandes cercanas al 1 y una pérdida pequeña para las
diferencias pequeñas que tienden a 0.
Esta pérdida es utilizada para ajustar los pesos de la red durante el entrenamiento, consi-
guiendo así hacer mínima esta misma. Por lo tanto, un modelo perfecto tendrá una entropía
igual a 0.
La entropía cruzada se define de la siguiente forma:
∑
n
LCE = − ti log(pi )
i=1
Siendo n el numero de clases, ti el valor real de la clase i y pi la probabilidad de que el
elemento pertenezca a la clase i devuelta por la función softmax.
2.1.4.2.1 Entropía cruzada categórica (categorical crossentropy) La entropía cruzada ca-
tegórica es una ampliación de la función de la entropía cruzada adaptada a problemas en los
que se tienen que clasificar los datos en más de dos conjuntos.3 Herramientas y recursos
En este apartado se exponen todas las herramientas utilizadas para realizar este trabajo.
3.1 Tecnologías
Hoy en día existen un gran número de tecnologías a nuestra disposición para trabajar con
redes neuronales, a continuación se detallan las que han sido seleccionadas para realizar este
trabajo y el por qué de su elección.
3.1.1 Python
Este es un lenguaje de programación interpretado que, como vamos a ver más adelante,
tiene un gran número de herramientas para trabajar con redes neuronales. Aunque no sea el
lenguaje con el que mayor rendimiento se obtiene (para ello utilizaríamos lenguajes de más
bajo nivel, como C++) nos permite un prototipado rápido y flexible en lo que construcción
y análisis de redes neuronales se refiere.
3.1.1.1 NumPy
Esta es una biblioteca para Python que nos permite operar con vectores y matrices de
grandes dimensiones de una manera más cómoda y sencilla que la que permite Python por
defecto. A parte, nos ofrece una gran cantidad de funciones matemáticas predefinidas para
operar con estas matrices.
3.1.1.2 Matplotlib
De esta librería utilizamos sobretodo la estructura de datos ndarray, ya que permite crear
matrices optimizadas (en cuanto a tamaño y rendimiento) en comparación con el rendimiento
de Python nativo.
3.1.1.3 TensorFlow
TensorFlow o TensorFlow (TF) es una biblioteca de código abierto para Python que fue
desarrollada por Google. Incorpora un gran número de herramientas para construir y entrenar
redes neuronales con gran flexibilidad.
TF además permite ejecutarse en tarjetas gráficas o Graphics Processing Unit (GPU)s (por
sus siglas en inglés Graphics Processor Unit), por lo que podemos acelerar enormemente el
proceso de entrenamiento de nuestra red.
1112 Herramientas y recursos
3.1.1.4 Keras
Keras, al igual que las anteriores, es una librería de código abierto escrita en Python que
puede ejecutarse basándose en varias tecnologías de DL de más bajo nivel. En el caso de este
trabajo se utilizará apoyándose en TF.
Esta librería nos facilita la creación de redes neuronales ya que cuenta con varios bloques
preestablecidos con los que podemos trabajar directamente (como las capas, funciones de
activación, etc.), si se trabajara únicamente con TF muchos de estos bloques deberían de
programarse desde cero.
Esta librería nos proporciona dos formas de trabajar, la Application Programming interface
(API) secuencial y la funcional que es la que se utiliza en este trabajo.
3.1.1.5 SciKit Learn
Es una librería de código abierto escrita en y para Python, que contiene varias herramientas
de data science, como algoritmos de clasificación y reordenación, los cuales se utilizan en este
proyecto.
3.1.1.6 Jupyter Notebook
Se trata de una aplicación con estructura cliente-servidor creada por la organización sin
ánimo de lucro Proyecto Jupyter, que permite crear y ejecutar archivos basado en celdas que
pueden contener distinta información, como: código, texto enriquecido, fórmulas matemáticas,
etc.
Del lado del cliente es accesible por cualquier navegador web moderno, por lo que podemos
modificar y ejecutar los notebooks de forma remota en el servidor donde esté instalada la
versión servidor de Jupyter Notebook.
Esta aplicación es compatible con una gran variedad de lenguajes de programación como
C++, JavaScript, R, entre otros. Esto es posible ya que cuenta con más de 50 interpretes,
aunque nosotros utilizaremos el interprete por defecto (IPython) ya que vamos a trabajar
con Python.
3.1.1.7 Google Colaboratory
Esta es una plataforma web desarrollada por Google que nos permite editar y ejecutar
Jupyter Notebooks directamente desde la web, sin necesidad de tener nada instalado excepto
un navegador compatible con JavaScript, puesto que todo el código se ejecuta en servidores
de Google.
Es importante recalcar tres características que hacen de Google Colaboratory una herra-
mienta de gran valor para la realización de este trabajo:
• Compartición y edición colaborativa de proyectos: Permite compartir el proyecto
con otras cuentas de Google e incuso editarlo al mismo tiempo.
• Conexión sencilla con Google Drive: Nos permite guardar los archivos con los
datos devueltos por la red neuronal de una forma rápida y sencilla.
• Acceso a GPUs: Permite conectarse a servidores de Google que tienen GPU, por lo
que podemos acelerar el entrenamiento de la red considerablemente.3.2. Datasets 13 3.2 Datasets Para el estudio del desbalanceo se han utilizado tres datasets, dos en los que hay un gran número de imágenes que contienen caracteres numéricos y otro que está formado por miles de caracteres alfabéticos manuscritos escaneados. De estos datasets se han seleccionado dos pares de clases para clasificar. En cuanto a las cifras se han seleccionado los pares: • 3y5 • 7y9 Las letras seleccionadas para ser clasificadas son las siguientes: • CyG • VeY Se han seleccionado estos pares puesto que se considera que son los caracteres que más se parecen entre sí visualmente, por lo tanto, serán los más difíciles de diferenciar por la red neuronal. 3.2.1 MNIST Modified National Institute of Standards and Technology database, se trata de una base de datos creada por Chris Burges y Corinna Cortes que contiene 60000 muestras de entrena- miento y 10000 muestras de validación de caracteres numéricos escritos a mano. Las muestras son imágenes binarias (únicamente tienen dos niveles de color, blanco y negro) con un tamaño de 28x28 píxeles, en las que el dígito se encuentra centrado en la imagen. Figura 3.1: Imágenes de muestra del conjunto de validación de MNIST. Fuente: Wikipedia (s.f.-b) Esta base de datos es ampliamente utilizada en el entrenamiento de redes neuronales debido a su gran cantidad de muestras y la diversidad entre ellas.
14 Herramientas y recursos
3.2.2 NIST
Se ha seleccionado la Special Database 19 del National institute of Standards and Techno-
logy, que consta de 810000 imágenes de caracteres escritos por 3600 personas diferentes, con
lo que obtenemos una gran heterogeneidad en los datos. En esta base de datos se encuentran
letras en minúsculas y mayúsculas, pero en el trabajo se han utilizado únicamente letras
mayúsculas, que son en las que se encuentran las similitudes.
3.2.3 USPS
Se trata de un dataset recopilado por J.J. Hull en 1994 y está formado por imágenes de
cifras escaneadas de sobres del U.S. Postal Service, de ahí el nombre del conjunto. Es un
dataset que cuenta con 7291 muestras de entrenamiento y 2007 muestras de validación. Está
conformado por imágenes en escala de grises con una resolución espacial de 16x16 píxeles.
3.3 Setup
Se han utilizado las siguientes versiones de las herramientas previamente mencionadas:
Especificaciones del entorno de ejecución
Sistema operativo Ubuntu 18.04
Versión de Python 3.7.11
Versión de Jupyter Notebook 5.2.2
Versión de NumPy 1.19.5
Versión de matplotlib 3.2.2
Versión de TensorFlow 2.5.0
Versión de Keras 2.5.0
Versión de SciKit Learn 0.22.2.post14 Desarrollo
En este apartado se describe la arquitectura de la red utilizada, los problemas que presenta
y, por último, las posibles soluciones que se han aplicado para mejorar el rendimiento de la
red.
4.1 Arquitectura
La arquitectura de red que se ha utilizado para realizar este proyecto es la de una CNN o
red neuronal convolucional, puesto que es la más indicada para el reconocimiento de imágenes.
La estructura de las CNN se divide en dos etapas, como ya se ha visto previamente en el
marco teórico. La etapa de extracción de características y la etapa de clasificación.
4.1.1 Etapa de extracción de características
En esta primera etapa convolucional, se ha utilizado una red bastante simple debido a que
las imágenes de los dataset son sencillas y de una resolución baja, además estas imágenes se
encuentran en escala de grises por lo que se simplifica el proceso al contar solo con un canal
para los colores, en lugar de los 3 que se utilizarían en caso de tener imágenes en color.
Primeramente, encontramos la capa de entrada (Input en keras), a la que se le indica
la forma (shape) que deben tener los datos de entrada. En este caso, se utilizan 3 formas
distintas para los 3 datasets:
• MNIST: Al tener imágenes en escala de grises y de 28x28 píxeles, indicaremos la forma
(28, 28, 1), siendo la primera dimensión el número de píxeles de ancho, la segunda el
número de píxeles de alto, y la tercera y última dimensión se refiere al número de canales
que utiliza la imagen.
• NIST: Igualmente, se tienen imágenes en escala de grises pero en este caso de 32x32
píxeles, por lo que se indica la forma (32, 32, 1).
• USPS: Como en los dos casos anteriores, las imágenes de este dataset se encuentran
en escala de grises, pero esta vez la resolución espacial es de 16x16 píxeles, por lo que
la forma pasada a la red es (16, 16, 1).
A continuación de esta capa, se sitúa una primera capa convolucional (Conv2D en Keras),
en la que se indica como primer parámetro (filters) la cantidad de filtroso kernels en la
convolución, para este caso se ha seleccionado 8 como valor. El siguiente parámetro es el
tamaño del núcleo o kernel_size,para el que se ha utilizado un núcleo 3x3. Por último se pasa
por parámetro la función de activación, en este caso ReLU.
Posteriormente, se añade una capa de reducción de muestreo, en concreto, se ha utilizado
MaxPooling2D, en la que se indica que el tamaño de la ventana sobre el que tomar el máximo,
en este caso se selecciona 2x2.
1516 Desarrollo Una vez finalizado este ciclo de convolución, se repite la misma estructura una segunda vez, estableciendo esta vez en la capa de convolución la cantidad de filtros a 2. Por último, para que la etapa de clasificación pueda leer los datos que ha manipulado la etapa de extracción de características se deben de aplanar los datos, por ello se utiliza la capa Flatten de Keras. 4.1.2 Etapa de clasificación En el caso que se está tratando, únicamente se necesita una capa en la etapa de clasificación (es decir, en la parte final de la red), ya que se trata un problema básico. Para esta etapa, se utiliza una capa densa, es decir, que todas las neuronas de esta capa están conectadas con todas las salidas de las neuronas de la capa anterior. Además, en esta capa se utiliza la función de activación softmax. Esta función devuelve las probabilidades para cada clase en un array de la siguiente forma: [0.95, 0.05], siendo 95% la probabilidad de que la imagen tratada sea de la clase 1 y 5% de que, por el contrario, pertenezca a la clase 2. 4.1.3 Red implementada en Keras En el siguiente fragmento de código se puede encontrar la red neuronal previamente descrita implementada con la API funcional de Keras. Código 4.1: Red implemennatda en Keras 1 input = Input(shape=input_shape) 2 3 x = Conv2D(4, kernel_size=(3,3), activation=”relu”) (input) 4 x = MaxPooling2D(pool_size=(2,2)) (x) 5 6 7 x = Conv2D(2, kernel_size = (3,3), activation=”relu”) (x) 8 x = MaxPooling2D(pool_size=(2,2)) (x) 9 10 x = Flatten() (x) 11 12 output = Dense(2, activation=’softmax’)(x) 13 14 model = Model(inputs = input, outputs = output, name=”modelo”) 4.2 Pipeline del script Para implementar esta red previamente descrita y experimentar con ella se ha creado un script en Python compuesto por los siguientes pasos: 4.2.1 Inicialización de parámetros En este paso, se inicializan todos los parámetros que van a ser posteriormente utilizados por el script. Para manipularlos y editarlos con mayor facilidad se crean una serie de controles de Jupyter Notebook que permiten modificar estos datos más fácilmente. Posteriormente, se explica la función de cada uno de estos parámetros:
4.2. Pipeline del script 17
Figura 4.1: Captura del formulario de parámetros
• DBNAME: Se trata de una variable que contiene el nombre del dataset utilizado,
posteriormente servirá para indicar qué dataset debe ser utilizado.
• FILTER: Esta variable consiste en un array de dos posiciones que contiene las dos
clases que se quieren comparar, por ejemplo, si se desean clasificar los números 3 y 5,
el array contendrá el 3 en la posición 0 y el 5 en la posición 1, de esta forma [3,5].
• CHAR_TO_SKEW: En este parámetro se indica el número/carácter que se desea
desbalancear, siguiendo el ejemplo anterior, si se indicada el 3, esta sería la clase mino-
ritaria en el dataset que se envía a la red.
• PERCENT: Esta variable indica qué porcentaje (en tanto por 1) de la clase minoritaria
se desea mantener, de forma que si se indica un 1 ambas clases tendrán la misma
cantidad de imágenes, y si se indica un 0 se eliminarán todas las imágenes de la clase
minoritaria.
• EPOCHS: Esta variable indica durante cuantas épocas se desea entrenar la red. Tras
varios ensayos, se decidió que lo óptimo es indicar 50 ya que se probó con 100 épocas,
lo que provocaba overfitting (se producía un sobreentrenamiento en la red) y con 10
épocas, lo que provocaba un underfitting (la red no estaba lo suficientemente entrenada).
Por ello, en todos los entrenamientos este parámetro se mantendrá en 20.
• BATCH_SIZE: Esta variable contiene el tamaño del lote que se enviará a la red,
es decir, cuantas imágenes se utilizarán en cada paso para ajustar los pesos de la red
durante el entrenamiento. Se decidió dejar este parámetro en 16 puesto que es un
número razonable teniendo en cuenta el tamaño total de los datasets que se utilizan.
Se una ventaja trabajar con lotes pequeños ya que la red necesita menos memoria y
generalmente las redes entrenan más rápido.
• DATA_AUGMENTATION: Este parámetro es utilizado para activar o desactivar
el aumentado de datos, que es una de las soluciones que se propondrán en el apartado
4.3.1.18 Desarrollo
• CLASS_WEIGHT: Este parámetro es utilizado para activar o desactivar el class
weight, que es una de las soluciones que se propondrán en un apartado posterior.
4.2.2 Descarga del dataset
Una vez se han inicializado todos los parámetros necesarios para el correcto funcionamiento
del experimento, se descarga el dataset que previamente ha sido seleccionado en el formulario.
En este bloque también se inicializa la semilla de Numpy para que todos los números
aleatorios que se generen en el script sean los mismos en las diferentes pruebas realizadas.
Y por último, se muestra por pantalla la forma del dataset descargado y algunos ejemplos
de este, como se puede ver en la siguiente imagen.
Figura 4.2: Algunas muestras del dataset USPS y las dimensiones de este.
4.2.3 Preparación y desbalanceo de los datos
Como se puede ver en la figura 4.2 el dataset que se ha descargado en este momento
aun cuenta con todos los dígitos, por lo que en este paso se reduce el dataset guardando
solo los dígitos que han sido seleccionados en la variable FILTER previamente mencionada.
Seguidamente, después de ”filtrar” el dataset para dejar únicamente las clases que interesan,
se pasa a reducir el tamaño de la clase minoritaria. Para ello, primeramente se utiliza la
función shuffle que nos brinda la librería sklearn, que permite mezclar aleatoriamente las
imágenes del array. Posteriormente se devuelven las primeras posiciones del array hasta llegar
a la cantidad deseada, que se calcula multiplicando la variable PERCENT por el tamaño del
array que contiene las imágenes de la clase minoritaria. Por último, se formatean los datos
tal y como los debe recibir la red neuronal. convirtiendo las etiquetas de los datos de integer
encoding a one-hot encoding, es decir, se pasa de tener el valor del número a tener un array
binario en el que el 1 representa la posición del valor correcto, como se expone en la siguiente
tabla que representa el número 3 en ambas codificaciones.
Integer encoding One-hot encoding
3 0 0 0 1 0 0 0 0 0 0
Por lo tanto, se pasa de tener un array con los valores, a tener una matriz con la configu-
ración mencionada anteriormente. Para ello se utiliza la función to_categorical de la librería
keras.utils.4.3. Soluciones propuestas 19
4.2.4 Entrenamiento de la red
Una vez se tienen los datos tal y como se necesitan para enviar a la red neuronal, se
procede a la creación y al entrenamiento de esta. Esta red neuronal tiene la estructura descrita
previamente en la sección 4.1.
4.2.5 Evaluación
Cuando la red ya está entrenada se hace una predicción con el conjunto de test para ser
evaluada y posteriormente se utiliza la función classification_report de sklearn.metrics para
mostrar de una forma más amigable los resultados de la red con el conjunto de test.
4.3 Soluciones propuestas
Como se ha comentado en varias ocasiones previamente, cuando una red de este tipo es
entrenada con dos clases de las que se dispone un número de muestras muy diferente tiende
a identificar todas las muestras como las de la clase mayoritaria, dejando así gran número de
muestras de la clase minoritaria etiquetadas como pertenecientes a la clase mayoritaria.
Con el fin de intentar mejorar el rendimiento de esta red, se proponen dos técnicas distintas
a aplicar.
4.3.1 Aumentado de datos
Esta solución consiste en generar imágenes a partir de las que ya se tienen. En este caso se
propone generar solo de la clase minoritaria, con el fin de equilibrar las dos clases para que
la red funcione correctamente.
El proceso consta de los siguientes pasos:
1. Se aíslan en un array todos los elementos de la clase minoritaria.
2. Se inicializa el generador de imágenes (ImageDataGenerator) de la librería keras.preprocessing.image.
3. Se genera un iterador que continene una tupla con la imagen modificada y la clase a la
que pertenece (label).
4. Se itera y se guarda el contenido devuelto por el iterador en el array descrito en el paso
1.
5. Si el tamaño del array de la clase minoritaria es igual al de la clase mayoritaria se pasa
al siguiente paso, de lo contrario se vuelve al paso 4.
6. Por último, se une el array con la clase minoritaria al que contiene la clase mayoritaria
y se reordena aleatoriamente.
Una vez finaliza este proceso, el conjunto de datos ya se encontraría balanceado y listo para
ser enviado a la red neuronal.
El generador de imágenes previamente comentado normalmente se utilizaría en tiempo real
en la ejecución de cada lote de datos en la red neuronal, pero en este caso se deben generar
previamente las imágenes, puesto que solo se desean generar imágenes de una clase.20 Desarrollo
Este generador de imágenes consiste realmente en modificar de forma aleatoria las imáge-
nes que se tienen de la clase minoritaria mediante las siguientes transformaciones: traslación,
rotación, escalado y desencajado (shear). Estas cuatro transformaciones se realizan dentro de
unos límites enviados por parámetro al inicializar la clase. Para este trabajo se han seleccio-
nado los siguientes parámetros:
• rotation_range: 15
• width_shift_range: 0.2
• height_shift_range: 0.2
• shear_range: 0.1
• zoom_range: 0.1
Estos parámetros han sido seleccionados ya que, tras diversas pruebas con las imágenes se ha
observado que son los parámetros óptimos para los datos con los que se ha trabajado.
4.3.2 Pesos de clase
Esta técnica consiste en indicar a la red neuronal un peso para cada clase, de esta forma
la red neuronal prestará más atención a la clase que tenga un peso más alto. Para ello,
primeramente, estos pesos deben ser calculados mediante la siguiente fórmula de regresión
logística ponderada.
s
Wj =
(c ∗ sj )
Siendo:
• Wj el peso de la clase j
• s el número total de muestras
• c el número total de clases
• Sj el número de muestras de la clase j
Estos pesos son utilizados en el cálculo de la pérdida, ya que una vez se ha calculado la
pérdida de cada clase, esta es multiplicada por el peso indicado de la misma. De esta forma
conseguimos ”balancear” la importancia de ambas clases al entrenar la red.
Para la implementación en Python se ha utilizado primeramente la función compute_class_weight
de sklearn.utils.class_weight, que permite automatizar el proceso de cálculo de los pesos para
cada clase. Y posteriormente, se han enviado como parámetros estos datos formateados como
diccionario.4.4. Métricas utilizadas en el estudio 21
4.4 Métricas utilizadas en el estudio
En esta sección se exponen las métricas que se han tenido en cuenta para realizar la
experimentación de este trabajo.
Para comenzar, antes de explicar las métricas, deben quedar claros los siguientes conceptos:
• Verdaderos positivos (TP): Son los resultados que la red ha predicho correctamente y
en los que se indica que una muestra pertenece al conjunto que se le ha predicho. Por
ejemplo, si la red predice que una imagen de muestra del número 3 pertenece a la clase
3.
• Verdaderos negativos (TN): Son los resultados que la red ha predicho correctamente y
en los que se indica que una muestra no pertenece al conjunto descrito. Por ejemplo, si
la red predice que una imagen de muestra del número 3 no pertenece a la clase 5.
• Falsos positivos (FP): Son los resultados en los que la red actúa erróneamente y predice
que una muestra corresponde a una clase que no es la real. Por ejemplo, si la red predice
que una imagen de muestra del número 3 pertenece a la clase 5.
• Falsos negativos (FN): Son los resultados en los que la red actúa erróneamente y predice
que una muestra no corresponde a una clase que es la real. Por ejemplo, si la red predice
que una imagen de muestra del número 3 no pertenece a la clase 3.
Se pueden clasificar estos términos en dos conjuntos, los dos primeros elementos están agrupa-
dos dentro del término de la sensibilidad y en cambio, los dos últimos encajan con el término
de especificidad.
4.4.1 Precisión
Esta métrica permite medir la calidad del modelo y consiste como su propio nombre indica
en medir la precisión de las predicciones hechas por la red.
Esta métrica es calculada de la siguiente forma:
TP
P recision =
TP + FP
Como se puede ver, en esta métrica únicamente se tienen en cuenta los positivos por lo que
esta indica la proximidad de las distintas medidas entre sí.
4.4.2 Exhaustividad(Recall)
Esta métrica permite medir la cantidad de elementos que el modelo es capaz de identificar.
Esta métrica es calculada de la siguiente forma:
TP
Recall =
TP + FN
Permite identificar la cantidad de verdaderos positivos que la red consigue predecir.22 Desarrollo
4.4.3 Valor-F(F1)
Esta es la métrica más importante que encontramos en este estudio debido a la disparidad
en la cantidad de datos de los conjuntos a diferenciar. Esta métrica es una combinación de
las dos anteriores en un solo valor, lo cual permite obtener una comparación más sencilla del
recudimento combinado entre las dos métricas anteriores.
Esta métrica es calculada como un valor único ponderado de la precisión y la exhaustividad:
2 ∗ P recision ∗ Recall
F1 =
P recision + Recall5 Resultados
En este capítulo se van a exponer los diferentes experimentos realizados para los 3 datasets
con el fin de resolver el problema planteado en este proyecto.
5.1 Casos contemplados
Para comenzar a exponer la experimentación y sus resultados previamente se van a detallar
todas las casuísticas estudiadas y los porcentajes de desbalanceo utilizados para el estudio.
En primer lugar, se debe aclarar que se ha realizado la misma experimentación que se va
a describir a continuación para los 3 datasets que son caso de estudio.
Para estudiar este problema, en cuanto a desbalanceo se refiere, primeramente se ha rea-
lizado un entrenamiento con las clases de estudio totalmente balanceadas, es decir, con el
mismo número de elementos, para comprobar que la red neuronal se comporta correctamente
y para poder comparar los resultados con los de los siguientes experimentos.
Una vez realizado este entrenamiento con los datos totalmente balanceados, se hace un
estudio con los siguientes porcentajes: 10, 1, 0.5, 0.1.
Previamente en el estudio, se concretó que los porcentajes utilizados serían los siguientes:
100, 80, 60, 40, 20. Pero se optó por modificarlos y considerar desbalanceos todavía más
drásticos ya que la red se comportó mucho mejor de lo esperado con desbalanceos leves.
Por otro lado, en cuanto a las clases seleccionadas para el estudio, las podemos dividir en
dos según la naturaleza del dataset.
• Caracteres numéricos, en lo que respecta a este conjunto, se han seleccionado para
estudio los siguientes pares de clases:
– 3-5
– 7-9
• Caracteres alfabéticos, para este tipo de caracteres se han seleccionado los siguientes
pares:
– C-G
– V-Y
Estos conjuntos han sido seleccionados debido a que presentan grandes similitudes en la
apariencia de su escritura a mano.
Se realizarán 2 conjuntos de pruebas de todos los pares. En la primera de ellas, el primer
valor del conjunto será la clase minoritaria y en la segunda prueba el segundo valor será el
que contenga menos elementos.
2324 Resultados
5.1.1 Hiper-parámetros utilizados
En todos los casos de este estudio se han utilizado los mismos hiper-parámetros con el fin
de que todos los resultados obtenidos sean comparables entre sí. Únicamente se ha cambiado
un parámetro, el class weigths, que solo es utilizado en la solución propuesta con el mismo
nombre.
Estos hiper-parámetros son los siguientes:
• Número de épocas = 50
• Batch size = 16
• Learning rate = 0.001
• Optimizador = Adam
• Validation split = 0.2
Algunos de estos parámetros, fueron previamente explicados en la sección 4.2.1, el resto de
parámetros se expondrán a continuación.
En lo que respecta al optimizador, este hace referencia al algoritmo de aprendizaje utili-
zado durante el entrenamiento del modelo. El algoritmo de aprendizaje utilizado es conocido
como descenso del gradiente y Adam (ADAptative Moment stimation) es un optimizador
del descenso del gradiente, que en realidad es una combinación de otros dos optimizadores,
Adagrad y RMSProp. Es un algoritmo eficiente y que utiliza poca memoria, por lo que es
uno de los optimizadores más popoulares de la actualidad.
En cuanto al learning rate, este valor nos permite ajustar el factor de error que se corrige
en cada iteración del entrenamiento, de forma que, cuanto más pequeño es el valor, más lento
entrena la red y cabe la posibilidad de que quede atrapada en un mínimo local y por lo
tanto no pueda encontrar su ”pérdida mínima”. Por el contrario, si el valor es muy grande,
la red podría no encontrar nunca el mínimo global, ya que daría saltos muy grandes y nunca
convergería.1
Ejemplos de learning rate realizados en An Interactive Tutorial on Numerical Optimization
Por último, el validation split se refiere a que porcentaje del conjunto de entrenamiento se
desea utilizar como conjunto de validación al final de cada época. En Keras, al indicar este
porcentaje, se extraerá la cantidad de elementos correspondiente al porcentaje seleccionado y
ese conjunto no será utilizado para el entrenamiento, únicamente se utilizará como validación
al final de cada época.
5.2 Estructura de los resultados
A continuación de esta sección, se van a mostrar una serie de gráficos y resultados cuya
estructura va a ser expuesta en este apartado. Por un lado se mostrarán gráficos de las medias
de la métrica F1 entre las clases comparadas, la media está compuesta por la métrica f1 de
la clase 1 cuando esta es minoritaria y la métrica F1 de la clase 2 cuando esta es minoritaria.
1
En las Figuras 5.1, 5.2 y 5.3 se ouede ver un ejemplo gráfico de esta explicación.5.2. Estructura de los resultados 25
Figura 5.1: Learning rate bajo
Figura 5.2: Learning rate correcto
Figura 5.3: Learning rate alto26 Resultados
Correspondiendo la clase 1 al primer elemento de los conjuntos anteriormente mencionados
y la clase 2 al segundo elemento.
Por otro lado, se mostrarán gráficos de precisión y errores de los conjuntos de entrenamiento
y los de validación de cada época. En ellos, se podrá apreciar como, una vez entrenada la
red los resultados en estos datos cuando las clases están desbalanceadas siguen siendo buenos
en algunos casos, eso se debe a que el conjunto de validación por época es un subconjunto
del de entrenamiento, por ello este conjunto también tendrá este desbalanceo, por lo tanto,
la mayoría de sus muestras corresponderán a la clase predominante y por ello acertará la
mayoría y, por consecuencia, se obtendrán buenos resultados.
5.3 Modelo base sin balancear
La primera prueba realizada en el proyecto, consiste en entrenar a la red sin aplicar ninguna
de las soluciones que previamente se han descrito para comprobar como se comporta la red sin
ningún tipo de modificación y así poder comparar los resultados con las soluciones aplicadas
posteriormente.
5.3.1 Resultados del entrenamiento
5.3.1.1 MNIST
(a) Gráfica de la métrica F1 de las clases 3 y 5 de (b) Gráfica de la métrica F1 de las clases 7 y 9 de
MNIST utilizando el modelo base. MNIST utilizando el modelo base.
Figura 5.4: Gráficas del dataset MNIST utilizando el modelo base.
Como se puede ver en la Figuras 5.4a y 5.4b con este conjunto de datos la red se ha
comportado realmente bien aun con un desbalanceo muy notable, esto es debido a que este
dataset es realmente grande por lo que al dejar un pequeño porcentaje de la clase minoritaria,
la red sigue teniendo suficientes muestras como para poder entrenarse de una forma correcta
y ofrece un rendimiento muy notable.
Aun así, se puede observar que cuando la cantidad de muestras es realmente pequeña,
algunas decenas, la red deja de clasificar correctamente ya que no tiene las muestras suficientes
como para poder diferenciar correctamente ambos conjuntos.También puede leer
