Detección de roya en caña de azúcar con aprendizaje profundo

TRABAJO DE FIN DE GRADO PREVIO AL TÍTULO DE INGENIERO
ELECTRÓNICO
EVALUACIÓN DE ARQUITECTURAS DE
APRENDIZAJE PROFUNDO PARA LA DETECCIÓN
DE ROYA NARANJA Y ROYA PARDA EN EL
CULTIVO DE CAÑA DE AZÚCAR
UNIVERSIDAD DEL QUINDÍO

FACULTAD DE INGENIERÍA
Viernes 20 de Septiembre del 2019
Armenia, Quindío
EVALUACIÓN DE ARQUITECTURAS DE
APRENDIZAJE PROFUNDO PARA LA DETECCIÓN
DE ROYA NARANJA Y ROYA PARDA EN EL
CULTIVO DE CAÑA DE AZÚCAR
ELABORADO POR:
Ricardo Andrés Saavedra Burbano
DIRIGIDO POR:
Jorge Iván Marín Hurtado
UNIVERSIDAD DEL QUINDÍO

FACULTAD DE INGENIERÍA
Viernes 20 de Septiembre del 2019
Armenia, Quindío
2
CONTENIDO
1. INTRODUCCIÓN .............................................................................................................. 9
2. OBJETIVOS .................................................................................................................... 11
2.1 General ....................................................................................................................................... 11
2.2 Específicos ................................................................................................................................. 11
3. MARCO TEÓRICO .......................................................................................................... 12
3.1 LA ROYA EN LA CAÑA DE AZÚCAR .................................................................................. 12
3.1.1 Roya naranja de la caña de azúcar ................................................................. 12
3.1.2 Roya parda de la caña de azúcar .................................................................... 12
3.1.3 Presencia de roya naranja en el rio del Valle del Cauca, Colombia ............... 14
3.1.4 Diferencias entre roya naranja y roya parda en caña de azúcar .................... 15
3.2 REDES NEURONALES CONVOLUCIONALES (CNN) ........................................................ 16
3.2.1 Ataques adversarios ....................................................................................... 18
3.2.2 Visualización de pesos .................................................................................... 19
3.2.3 Redes generativas adversarias (GANs) ........................................................... 19
3.2.4 AlexNet ........................................................................................................... 20
3.2.5 Inception-v3 .................................................................................................... 22
3.2.6 Inception-ResNet v2 ....................................................................................... 24
3.3 IMAGENET ............................................................................................................................... 27
3.4 FUNCIÓN DE ACTIVACIÓN .................................................................................................. 27
3.4.1 Función Sigmoide ........................................................................................... 27
3.4.2 Función unidad lineal rectificada (ReLU) ........................................................ 28
3.4.3 Función de activación LeakyReLU .................................................................. 28
3.5 DROPOUT (Abandono) ............................................................................................................. 28
3.5.1 Descripción del modelo de dropout ............................................................... 28
3.6 DESCENSO DE GRADIENTE Y SUS VARIANTES .............................................................. 30
3.6.1 Descenso de gradiente por lote ..................................................................... 30
3.6.2 Descenso de gradiente estocástico ................................................................ 30
3.6.3 Descenso de gradiente por mini-lotes ........................................................... 30
3.7 Algoritmos de optimización del descenso de gradiente .............................................................. 31
3.7.1 AdaGrad .......................................................................................................... 31
3.7.2 Adadelta.......................................................................................................... 32
3.7.3 RMSProp ......................................................................................................... 33
3.7.4 Adam............................................................................................................... 33
4. MÉTODOS Y DESARROLLO DEL PROYECTO................................................................... 35
3
4.1 PREPARACIÓN DE ENTORNO DE TRABAJO Y CREACIÓN DE AMBIENTE DE
ENTORNO DE PROGRAMACIÓN ...................................................................................................... 35
4.2 RECOLECCIÓN DE BASE DE DATOS .................................................................................. 37
4.3 AUMENTO DE BASE DE DATOS .......................................................................................... 37
4.4 ELECCIÓN DEL TIPO DE ENTRENAMIENTO ..................................................................... 40
4.5 MÉTODOS PARA COMBATIR EL SOBREAJUSTE .............................................................. 40
4.6 ENTRENAMIENTO DE LA RED DESDE 0 ............................................................................ 46
4.6.1 Criterios de elección de caracteristicas de la red ........................................... 46
4.7 ENTRENAMIENTO MEDIANTE TRANSFERENCIA DE APRENDIZAJE .......................... 52
4.8 Ataques adversarios por conjuntos para análisis de robustez ...................................................... 54
5. RESULTADOS Y DISCUSIÓN ........................................................................................... 56
5.1 COMPARACIÓN DE MODELOS CON DIFERENTES HIPERPARÁMETROS PARA
ELABORACIÓN DE RED DESDE CERO ........................................................................................... 56
5.1.1 Optimizador como criterio de elección .......................................................... 56
5.1.2 Función de activación como criterio de elección: .......................................... 57
5.1.3 Adición de capas de abandono y regularización L1, L2 como criterio de
elección 58
5.2 PROCESO DE FORMACIÓN DE RED NEURONAL ELEGIDA CON CRITERIOS DE
SELECCIÓN .......................................................................................................................................... 61
5.2.1 Efecto de tamaño de lote en proceso de aprendizaje ................................... 63
5.2.2 Efecto de usar capas de abandono................................................................. 64
5.2.3 Medidas de dispersión de la red entrenada desde 0 ..................................... 70
5.3 RESULTADOS PARA COMBATIR EL SOBREAJUSTE CON TRANSFERENCIA DE
APRENDIZAJE DE LA RED INCEPTION V3 ..................................................................................... 71
5.3.1 Medidas de dispersión de la red con transferencia de aprendizaje Inception
v3 76
5.4 RESULTADOS PARA COMBATIR EL SOBREAJUSTE CON TRANSFERENCIA DE
APRENDIZAJE DE LA RED INCEPTIONRESNET V2 ...................................................................... 77
5.4.1 Medidas de dispersión para la red InceptionResNet v2................................. 80
5.5 COMPARACIÓN ENTRE MODELOS ..................................................................................... 80
5.6 ROBUSTEZ ANTE LOS ATAQUES ADVERSARIOS............................................................ 83
5.6.1 Ataques adversarios mediante método de signo de gradiente rápido (FGSM)
83
5.6.2 Resultados de vulnerabilidad ......................................................................... 88
6. CONCLUSIONES............................................................................................................. 94
7. REFERENCIAS ................................................................................................................ 96
8. ANEXOS ......................................................................................................................... 98
4
LISTADO DE FIGURAS
NOMBRE Pág.
Figura 1. Síntomas de roya de café y roya naranja en la lámina foliar de la caña de 14

azúcar
Figura 2. Síntomas de roya naranja y parda sobre el envés de una misma hoja 15
Figura 3. Distribución de roya naranja en el mundo 16
Figura 4. Lesiones en las hojas (A), (B) y (C) Roya naranja y (D), € y (F) Roya café 17
Figura 5. Ejemplo de arquitectura de red neuronal convolucional 18
Figura 6. Imagen de la izquierda no se altera (autobús), imagen del centro (ruido), 19
imagen de la derecha alterada con ruido (avestruz)
Figura 7. Pesos de red neuronal con base de datos MNIST 20
Figura 8. Redimensionamiento de imagen para AlexNet 22
Figura 9. Arquitectura de AlexNet 22
Figura 10. Reducción de tamaño convencional (arriba a la izquierda), reducción de 24
tamaño de cuadricula eficiente (abajo a al izquierda), arquitectura detallada de reducción
de tamaño de cuadricula eficiente (derecha)
Figura 11. Arquitectura de la red neruonal inception v3 25
Figura 12. Arquitectura Inception ResNet v2 26
Figura 13. Bloque residual de Inception (Inception-ResNet-A) 27
Figura 14. Escalamiento de activaciones por una constante 28
Figura 15. Comparación de la operación básica de la red estándar y la red con Dropout 30
Figura 16. Herramientas de programación usada 37
Figura 17. Diagrama de aumento de base de datos 39
Figura 18. Aumento de datos por reflejo vertical (imagen superior), aumento de datos 40
por reflejo horizontal (imagen inferior)
Figura 19. Aumento de datos por aumento de nitidez (imagen superior), aumento de 40
datos por aumento de contraste (imagen inferior)
Figura 20. Conjunto de datos de entrenamiento, validación y prueba 41
Figura 21. Funcionamiento de introducir capas de abandono a la red neuronal 42
Figura 22. Penalidades de los dos tipos de regularizadores 43
Figura 23. Adición de parada temprana y puntos de control con modelo de transferencia 44
de aprendizaje InceptionResNetV2
Figura 24. Arquitectura de modelo formado con capas secuenciales 50
Figura 25. Configuración de red desde cero para la detección de roya en caña de azúcar 52
Figura 26. Opciones de congelamiento de capas de red pre entrenada 53
Figura 27. Configuración de las redes con transferencia de aprendizaje para la detección 54
de roya en caña de azúcar
Figura 28. Diagrama de metodología de verificación de robustez ante ataques 56
adversarios a los tres modelos de aprendizaje profundo
Figura 29. Precisión del modelo con el conjunto de entrenamiento con diferentes 58
optimizadores
Figura 30. Pérdidas con el conjunto de entrenamiento con diferentes optimizadores 58
Figura 31. Precisión con el conjunto de entrenamiento con distintas funciones de 59
activación
Figura 32. Pérdida con el conjunto de entrenamiento con distintas funciones de 59
activación
5
Figura 33. Precisión con el conjunto de entrenamiento con distintas variantes de 60
regularización, entre paréntesis está el método de optimización que se usó
Figura 34. Pérdida con el conjunto de entrenamiento con distintas variantes de 61
regularización Entre paréntesis está el método de optimización que se usó
Figura 35. Precisión de entreno y validación con solo el regularizador L1 y optimizador 61
Adam
Figura 36. Diferencia entre perdidas de modelo sin regularización y con regularización 62
Figura 37. Lectura de conjunto de datos almacenado en el disco C 63
Figura 38. Muestra de imagen sana y enferma con sus respectivas etiquetas 63
Figura 39. Número de los diferentes conjuntos de datos para el entrenamiento de la red 63
Figura 40. Rendimiento de entreno y validación de la red sin agregar capas de abandono 67
Figura 41. Pérdida de entreno y validación sin agregar capas de abandono 67
Figura 42. Rendimiento de entrenamiento y validación al agregar capas de abandono 68
Figura 43. Pérdida en conjunto de datos de entreno y validación con capas de abandono 68
añadidas
Figura 44. Rendimiento de entrenamiento con conjunto de datos de validación y 69
entrenamiento con adición de abandono y regularización L2
Figura 45. Pérdida del conjunto de entrenamiento y validación con regularización L2 69
Figura 46. Resultado de rendimiento y pérdida en época 20 70
Figura 47. Pérdida y rendimiento de la red con el conjunto de prueba 71
Figura 48. Predicción realizada por la red mediante la adición de una nueva imagen 71
afectada por la roya
Figura 49. Número de imágenes predichas con éxito y sin éxito por el modelo 72
Figura 50. Rendimiento de validación y entrenamiento con 229 capas congeladas 75
(izquierda), pérdida de validación y entrenamiento con 229 capas congeladas (derecha)
Figura 51. Rendimiento de entreno y validación con 216 capas congeladas (izquierda), 76
pérdida de rendimiento y validación con 216 capas congeladas (derecha)
Figura 52. Pérdidas y precisión con el conjunto de prueba 77
Figura 53. Predicción realizada por la red con hoja de caña de azúcar sana 77
Figura 54. Rendimiento y pérdida de la red con el conjunto de prueba 80
Figura 55. Rendimiento de entrenamiento y validación con 768 capas congeladas 81
(izquierda), pérdida de rendimiento y validación con 768 capas congeladas (derecha)
Figura 56. Predicción correcta de la red de transferencia de aprendizaje 81
InceptionResNet v2 con imagen de roya en caña de azúcar
Figura 57. Comparación de precisión de red entrenada desde cero y redes con 82
transferencia de aprendizaje
Figura 58. Comparación de pérdidas entre redes entrenadas desde 0 y redes entrenadas 83
con transferencia de aprendizaje
Figura 59. Valores de media de precisión de entrenamiento y validación para las 3 redes 84
neuronales
Figura 60. Valores de media de pérdidas de entrenamiento y validación para las 3 84
Figura 61. Ataque adversario con método de signo de gradiente rápido a red desde cero 85
con épsilon = 0.2
con épsilon = 0.1
con épsilon = 0.07
6
con épsilon = 0.06
con épsilon = 0.05
con épsilon = 0.04
con épsilon = 0.03
con épsilon = 0.02
con épsilon = 0.01
Figura 70. Muestra de los primeros 20 ataques adversarios realizados a la red entrenada 91
desde cero con épsilon = 0.04
Figura 71. Muestra de los primeros 20 ataques adversarios realizados a la red con 92
transferencia de aprendizaje Inception v3 con épsilon = 0.04
7
LISTADO DE TABLAS
NOMBRE Pág.
Tabla 1. Hiperparámetros utilizados en los diferentes entrenamientos para elección 46

de mejor modelo entrenado desde cero
Tabla 2. Entrenamiento #1 47
Tabla 9. Principales características de la red entrenada desde 0 63
Tabla 10. Prueba para establecer el tamaño de lotes después de la primera época en 65
red neuronal InceptionResNet v2.
Tabla 11. Rendimiento y pérdida del conjunto de entrenamiento y conjunto de 69
validación del modelo con dropout
Tabla 12. Valores de precisión y perdida con desviación estándar del modelo 71
entrenado desde
Tabla 13. Principales características de la red entrenada mediante la transferencia de 72
aprendizaje de la red Inception V3
Tabla 14. Prueba de congelamiento de capas 74
Tabla 15. Rendimiento y pérdida del conjunto de entrenamiento y validación con la 77
transferencia de aprendizaje Inception v3.
Tabla 16. Valores de precisión y perdida con desviación estándar del modelo con 77
transferencia de aprendizaje Inception V3
Tabla 17. Principales características de la red entrenada mediante transferencia de 78
aprendizaje de la red InceptionResNet v2
Tabla 18. Resultados de pérdida y rendimiento de validación y entrenamiento con 78
768 capas congeladas
Tabla 19. Valores de precisión y perdida con desviación estándar del modelo con 81
transferencia de aprendizaje InceptionResNet V3
Tabla 20. Valores de precisión y perdida con desviación estándar de los diferentes 82
modelos de aprendizaje profundo
Tabla 21. Resultados de entrenamiento con imágenes con ataque y sin ataque 90
adversario a la red desde cero
adversario a la red Inception v3
adversario a la red InceptionResNet v2
Tabla 24. Comparación de cantidad de parámetros de los modelos con su precisión 94
con ataques
8
1. INTRODUCCIÓN
En la agricultura, la detección de plagas y enfermedades es una de las principales

actividades de prevención para poder lograr resultados óptimos a nivel económico y
productivo de sus cultivos. Estas enfermedades y plagas pueden aparecer en diferentes
partes como raíz, tallo, hoja y fruto y en diferentes etapas de su crecimiento, por ende es
indispensable el estudio previo de la enfermedad que se pueda presentar dependiendo la
variedad que se esté utilizando.
Para este proyecto se hará énfasis en el cultivo de caña de azúcar, en el cual se encuentra
una enfermedad común denominada “roya”, la cual afecta a la caña de azúcar a nivel foliar
en grandes extensiones del territorio colombiano, especialmente en las zonas del valle del
río del Cauca [1]. Al ser esta enfermedad de importancia económica para el país, se debe
diagnosticar a tiempo para su rápido tratamiento. Para lograr un diagnóstico preciso de esta
enfermedad, los cañicultores acuden a profesionales en el área de la agricultura con el fin
de que puedan observarlo y determinar la existencia de roya. Al ser un trabajo sometido a la
supervisión humana, el resultado podría terminar en un procedimiento difícil cuando se
tratan cultivos del orden de cientos o miles de hectáreas sembradas, trabajo que requiere
mucho tiempo y personal para poder determinar con eficiencia qué tan afectado se
encuentra el cultivo de caña a causa de esta enfermedad.
Realizar sistemas computacionales capaces de detectar esta enfermedad ha sido una de las
ideas propuestas para brindarle apoyo tecnológico al agricultor y facilitar el trabajo de
detección. Estos sistemas de detección de cualquier tipo de imágenes denominados sistemas
de aprendizaje automático, normalmente requiere un proceso de extracción de
características y con base a ello un clasificador que determina el conjunto que se encuentra
la imagen [2]. Uno de los clasificadores más efectivos son los representados por redes
neuronales, las cuales constan de una serie de nodos (neuronas) que se interconectan entre
sí. Las redes neuronales cuentan con funciones de activación no lineales, las cuales
permiten obtener flexibilidad y separar un conjunto de datos de una clase en común. Uno de
los grandes avances en el área de aprendizaje automático fue la creación del aprendizaje
profundo. Mediante el surgimiento de redes neuronales profundas se ha podido facilitar el
proceso de extracción de características, el cual es realizado automáticamente a lo largo de
las diferentes capas [3], contando con diferentes filtros capaces de extraer en sus capas
iniciales características simples como bordes o esquinas, y en las capas profundas,
características más complejas. Por dichas virtudes, se usa para este proyecto redes
neuronales profundas, con el fin de detectar, con alto grado de acierto y confiabilidad, si
una imagen de cultivo de caña de azúcar se encuentra afectado por la enfermedad de roya.
Otro de los retos a cumplir en la clasificación de imágenes es la capacidad de

generalización, proceso en el cual una red neuronal es capaz de aprender características de
un conjunto de imágenes, y luego identificará con un margen de error pequeño, nuevas
imágenes que se deseen clasificar con acierto, las cuales nunca ha observado la red
(conjunto de validación).
9
En el aprendizaje profundo no siempre es fácil lograr la meta de obtener un modelo que
generalice. Dicho esto, se pueden evidenciar múltiples dificultades como: la numerosa
cantidad de parámetros de red, base de datos pequeña, escasa capacidad computacional y
tiempos largos de entrenamiento.
Otro de los problemas que se estudian en aprendizaje profundo es el que tiene que ver con
los ataques adversarios realizados a redes neuronales, los cuales tienen el fin de hacer que
la red neuronal muestre erróneamente una clase, este tipo de ataques adversarios han
significado un gran peligro para los sistemas de computación, sobre todo en lo que tiene
que ver con la seguridad.
El enfoque abordado en este trabajo de grado es el observar la robustez de los modelos
frente a la generación de ataques adversos. En la literatura, los estudios de robustez de
sistemas de aprendizaje profundo se han enfocado en una definición práctica de robustez
como el tamaño promedio de la perturbación adversaria mínima.
Infortunadamente encontrar perturbaciones adversas mínimas es casi imposible en

configuraciones prácticas [4], por lo cual en este trabajo se analiza la robustez mediante un
proceso de comparación de arquitecturas de aprendizaje profundo en donde se observa en
qué medida se puede engañar la red teniendo un conjunto seleccionado de base de datos y
observando su defensa frente a ataques adversarios generados.
Bajo el marco de este proyecto final, se muestran resultados que resumen la dinámica de la
práctica, como por ejemplo, la visualización de gráficas de rendimiento de validación y
entrenamiento, gráficas correspondientes a la pérdida con el conjunto de datos de
entrenamiento y validación, y la generación de imágenes adversarias para poner a prueba la
robustez de cada uno de los modelos entrenados.
Este informe de proyecto de grado pretende mostrar en forma ordenada, el desarrollo de las
diferentes actividades que se llevaron a cabo para detectar imágenes con presencia de roya
naranja y roya parda, combatir el sobreajuste y generar imágenes adversarias con el fin de
probar las redes con su entrenamiento ya elaborado y observar si es posible engañarlas. Se
utilizaran 3 modelos de redes neuronales como lo son: el modelo formado a partir de la
adición de capas secuenciales, modelo de transferencia de aprendizaje a partir de la red
Inception v3, y finalmente el modelo de transferencia de aprendizaje con la red
InceptionResNet v2.
10
2. OBJETIVOS
2.1 General
Evaluar modelos de aprendizaje profundo mediante el uso de entrenamiento desde cero y

transferencia de aprendizaje para la detección de roya naranja y roya parda en el cultivo de caña de
azúcar.
2.2 Específicos
 Explorar métodos que permitan combatir el sobreajuste en modelos pre entrenados y un modelo
entrenado desde cero
 Analizar la robustez de una red neuronal profunda pre-entrenada mediante la generación de
imágenes adversarias.
11
3. MARCO TEÓRICO
En este capítulo se describen las características de las enfermedades en caña de azúcar que se
pretende identificar con este trabajo como lo son la roya parda y roya naranja. Seguidamente, se
presentarán detalles sobre las técnicas de aprendizaje profundo que fueron empleadas para la
construcción de este proyecto de grado.
3.1 LA ROYA EN LA CAÑA DE AZÚCAR
3.1.1 Roya naranja de la caña de azúcar
La roya naranja es causada por el hongo Puccinia kuehnii E. J Butler. Los síntomas iniciales de la
roya naranja de caña de azúcar son lesiones minúsculas, elongadas y amarillas que forman una
aureola pálida, verde amarillento a medida que aumenta su tamaño. A medida que las lesiones
crecen pasa de naranja a naranja marrón oscuro, y las pústulas tienden a aparecer en la hoja de la
caña, a diferencia de la roya café, estas no llegan a ser marrón oscuro [1].
3.1.2 Roya parda de la caña de azúcar
Es causada por el hongo Puccinia melanocephala H. Sydow y P. Sydow, el cual ataca el sistema
foliar y en caso de infección severa puede secar las hojas y producir pérdidas en el peso de la caña.
Los síntomas consisten inicialmente en pequeñas manchas cloróticas y alargadas de color
amarillento, visibles en ambos lados de la hoja, que al aumentar de tamaño, toman un color marrón
y se rodean de un halo amarillo pálido. Las lesiones forman pústulas en el envés, aunque pueden
también aparecer en el haz. Al ocurrir la rotura de la epidermis se liberan masas de esporas de color
anaranjado, las cuales son fácilmente diseminadas por el viento a grandes distancias [5].
La roya naranja y parda son enfermedades muy similares, sin embargo, la principal diferencia se
encuentra cuando aumentan de tamaño y se presenta una coloración marrón oscura en la roya parda
y una coloración más clara en la roya naranja. Las lesiones jóvenes de roya naranja nunca llegan a
ser café oscuro [6].
12
Figura 1. Síntomas de roya de café y roya naranja en la lámina foliar de la caña de azúcar.
Fuente: [6]
13
Figura 2. Síntomas de roya naranja y parda sobre el envés de una misma hoja.
Fuente: [6]
En las Figura 1 y 2 se muestran algunos ejemplos representativos que pueden determinar algunas
diferencias entre los dos tipos de roya.
3.1.3 Presencia de roya naranja en el rio del Valle del Cauca, Colombia
En Colombia se detectó en Julio del 2010 en la variedad CC 01- 1884, en el experimento de prueba
regional para zonas húmedas en el Ingenio La Cabaña.
Desde que se detectó la presencia de roya en el país Norteamericano en el año 2007 y con la
aparición de roya café en algunas variedades de Cenicaña, se empezó la búsqueda para lograr saber
si a Colombia llegaría este hongo.
En Enero del 2008, Cenicaña envió once muestras de hojas de diferentes variedades de CC con
síntomas de roya al laboratorio de Micología sistemática del servicio de investigación agrícola del
departamento de agricultura de los Estados Unidos en Beltsville, Maryland, a fin de determinar la
presencia de roya naranja mediante los análisis morfológicos y molecular, los resultados dieron solo
positivos para roya café.
En julio del 2010 se encontró que en el Ingenio la Castilla y la Cabaña se encontraron síntomas de
la enfermedad de roya naranja. Estas muestras se analizaron y se confirmaron los síntomas visual y
morfológicamente. En 82 variedades evaluadas en semilleros para zonas de humedad, semiseca y
piedemonte, 25 resultaron positivas para roya naranja.
14
Figura 3. Distribución de roya naranja en el mundo
Fuente: [7]
En la Figura 3 se muestra la distribución de roya naranja en los diferentes países a nivel mundial, en
color anaranjado se muestran los diferentes países afectados.
La caña de azúcar es atacada por dos especies de Puccinia: la roya parda causada por P.
melanocephala y la anaranjada por P. kuehnii. La primera ha prevalecido en el continente
Americano, mientras que la segunda en Asia y Oceanía. [8]
3.1.4 Diferencias entre roya naranja y roya parda en caña de azúcar
En la literatura se reportan diferencias entre la roya naranja y la roya parda en caña de azúcar según
un estudio realizado por Cenicaña, en donde se puede decir que la única manera de diferenciar estas
dos enfermedades atacadas por hongos diferentes es mediante el estudio realizado en un laboratorio.
Las lesiones de roya café generalmente son de color café y con el tiempo se vuelven café oscuro
con áreas necróticas. Al abrirse las pústulas dejan libres las esporas la cuales también tienen un
color café. En la roya naranja se presenta una lesión de color anaranjado que luego pasa a ser entre
anaranjado y café, y en ocasiones anaranjado brillante. Las pústulas dejan libres las esporas las
cuales son de color anaranjado a anaranjado marrón. Sin embargo, algunas lesiones viejas de ambas
royas pueden ser de color marrón y adquieren una morfología similar que las hace indiferenciables
a simple vista, siendo necesaria una prueba de laboratorio para establecer una diferencia clara.
Para la comparación morfológica, se utiliza microscopio de luz convencional, donde se observa el
tamaño y forma de las estructuras como los parafisos y uredosporas (ancho de la pared, largo y
color), disposición de espínulas en la uredospora. Las observaciones muestran que en la roya café se
15
detectan uredosporas con abundantes parafisos, mientras que en las otras muestras solo se detectan
las uredosporas en ausencia de parafisos. Las uredosporas en la roya naranja presentan un
pronunciamiento en la pared característico para el patógeno P.Kuehnii, diferente a las uredosporas
de la roya café que tienen una pared de grosor uniforme.
Figura 4. Lesiones en las hojas (A), (B) y (C) Roya naranja y (D), € y (F) Roya café
Fuente: [9]
En la Figura 4 se muestran resultados vistos en la investigación realizada en [9], en donde observan
algunas de las diferencias entre los hongos de roya parda y roya naranja mediante el uso del
microscopio.
3.2 REDES NEURONALES CONVOLUCIONALES (CNN)
Las redes neuronales convolucionales son un tipo de redes de Deep learning (aprendizaje
profundo), cuya característica primordial es realizar tareas de clasificación directamente a partir de
imágenes videos, textos o sonidos. En función de la aplicación, se pueden implementar redes
neuronales desde cero, lo que conlleva un proceso más largo comparado al uso de una red
convolucional ya existente, con el objetivo de realizar modificaciones en sus capas convolucionales
y sus capas de clasificación (CNN pre-entrenada). Este tipo de redes neuronales tienen 3
características principales las cuales son [10]:
 Eliminan la necesidad de extracción de características.
 Los resultados obtenidos son buenos en comparación a otros tipos de algoritmos.
 Se puede utilizar un nuevo entrenamiento a partir de una red ya existente.
16
Las redes neuronales convolucionales pueden tener decenas o cientos de capas. Se aplican filtros a
cada imagen de entrenamiento con distintas resoluciones y la salida de cada imagen convolucionada
se emplea para entrada a la siguiente capa. Se pueden tener filtros que van desde características
simples como bordes o brillo, a características más complejas que identifican la característica que se
busca. [10]
En una red convolucional, las capas más comunes son:
a) Capas de convolución: Capas en donde se hace pasar la imagen y el objetivo
primordial es la extracción de características mediante el uso de filtros con distintas
resoluciones.
b) Capas de activación: en redes neuronales se suelen utilizar diferentes capas que
contienen funciones de activación siendo las más comunes: ReLu, Sigmoide y tangente
hiperbólica. Estas funciones actúan sobre los datos haciendo que solo las características
activadas de acuerdo a la función prosigan a la siguiente capa.
c) Capas de agrupación: En estas se disminuye la dimensión de los datos en donde se
muestrea una representación de ellos, puede usarse Max Pooling (toma solo la entrada
máxima de una región fija de su capa convolucional) o Average Pooling (toma solo el
promedio de una región fija de su capa convolucional)
d) Capas de Clasificación: Esta es la última capa de la red profunda y es la que se encarga
de establecer las categorías de salida. Es una capa que se encuentra totalmente
conectada, generando un vector con el número de clases que se quieran identificar. Este
vector tiene las probabilidades para cada clase de cualquier imagen que se esté
analizando.
En las redes convolucionales, en cada capa se aprenden características diferentes [10].
Figura 5. Ejemplo de arquitectura de red neuronal convolucional [11]

En la Figura 5 se muestra un ejemplo de una red neuronal convolucional que compitió en el desafío
de reconocimiento visual a gran escala de ImageNet (ILSVRC) la cual contaba con 60’000.000
millones de parámetros, 500.000 neuronas, 5 capas convolucionales, algunas de ellas seguidas de
capas de agrupación máxima y dos capas conectadas totalmente con una función softmax para
clasificar 1000 clases diferentes. [11]
17
3.2.1 Ataques adversarios
Los ataques adversarios en redes neuronales son uno de los problemas importantes a combatir,
debido a que estos tienen la función de llevar a que la red neuronal se equivoque en el proceso de
clasificación, estos ataques se realizan típicamente mediante la alteración de la información que
servirán de entrada a las redes de máquinas de aprendizaje.
Los ataques adversarios representan un gran problema para el campo de la inteligencia artificial,
principalmente en el área de seguridad en donde personas con conocimientos en la generación de
estos ataques adversarios pueden engañar a un sistema fácilmente. Este problema ha dado apertura
al campo de la investigación para elaborar sistemas capaces de detectar si un dato de entrada
pretende engañar a una red neuronal. [12]
Los ataques adversarios son entradas para los modelos de aprendizaje automático que un atacante
ha diseñado intencionalmente para provocar que el modelo cometa un error; son como ilusiones
ópticas para máquinas.
Figura 6. Imagen de la izquierda no se altera (autobús), imagen del centro (ruido), imagen
de la derecha alterada con ruido (avestruz)
Fuente: [12]
La Figura 6 muestra un ejemplo de ataque adversario realizado a una red neuronal mediante la
adición de ruido a la imagen original de la izquierda que es representada por un autobús. El proceso
de generación de imagen adversaria en este caso, muestra la alteración de los pixeles de la imagen
original mediante la adición de ruido, como se puede observar en la Figura 6, finalmente la imagen
de la derecha representa la sumatoria de la imagen original y el ruido añadido, el cual se observa en
la parte central de la imagen. Esta será la imagen que se le pasará a la red neuronal con el fin de
engañarla. Finalmente la red clasifica la figura alterada como una clase nueva la cual no
corresponde a la imagen original. En este ejemplo, el ruido realiza un cambio a los pixeles de la
imagen original y lleva a la red neuronal a clasificar la imagen como un avestruz.
El proceso de ataque adversario consiste en generar un ruido que lleva a la red a actualizar sus pesos
de tal forma que la clase deseada tenga mayor probabilidad. Es decir, se trata de un ruido que altere
los valores de pixeles necesarios para activar con mayor proporción ponderaciones encargadas de
clasificar a otra clase, además para ser un buen ataque adversario se debe parecer mucho a la
18
imagen original como se muestra en la figura en la parte de la derecha. A simple vista para un
humano, se consideraría un autobús, pero para la red será clasificada como un avestruz.
3.2.2 Visualización de pesos

Una de las estrategias comunes es visualizar los pesos. Estos son generalmente más interpretables
en la primera capa CONV que está mirando directamente a los datos de píxeles sin procesar, pero
también es posible mostrar los pesos de filtro más profundos en la red. Los pesos son útiles para
visualizar porque las redes bien entrenadas usualmente muestran filtros agradables y suaves sin
patrones ruidosos. Los patrones ruidosos pueden ser un indicador de una red que no ha sido
entrenada durante el tiempo suficiente, o posiblemente una fuerza de regularización muy baja que
puede haber provocado un sobreajuste. [13]
Figura 7. Pesos de red neuronal con base de datos MNIST

Fuente: [13]
En la Figura 7 se muestra la visualización de los pesos de una red neuronal clasificada con el
conjunto de datos MNIST (dígitos escritos a mano). En los diferentes pesos se muestran una
activación mayor dependiendo de la clase, en este caso se pueden observar los números del 0 al 9.
3.2.3 Redes generativas adversarias (GANs)

Son una nueva propuesta de modelo a través de procesos adversarios, en los cuales se entrenan 2
modelos: un modelo generativo G, que captura la distribución de datos, y un modelo discriminativo
D, que estima la probabilidad que una muestra provenga de los datos de entrenamiento de G. El
proceso de entrenamiento para G consiste en maximizar la probabilidad de que D cometa un error.
Esto corresponde a realizar un juego de 2 modelos. En el caso donde G y D son definidos por
perceptrones multicapa, todo el sistema puede ser entrenado con propagación hacia atrás. En el
marco de referencia, los modelos adversarios son más fáciles de aplicar cuando los dos modelos son
perceptrones multicapas. Para conocer la distribución 𝑝𝑔 sobre los datos 𝑥, se define primero sobre
la entrada, variables de ruido 𝑝𝑧 (𝑧), luego se representa un mapa de espacio de datos como
𝐺(𝑧; 𝜃𝑔 ), donde G es una función diferenciable representada por un perceptrón multicapa con
parámetros 𝜃𝑔 . También se define un segundo perceptrón multicapa 𝐷(𝑥; 𝜃𝑑 ), que produce un
escalar simple. 𝐷(𝑥) Representa la probabilidad de que 𝑥 provenga de los datos generadores 𝑝𝑔 . Se
19
entrena G para maximizar la probabilidad de asignar la etiqueta correcta para ambos ejemplos de
entrenamiento y muestras desde G. Simultáneamente se entrena G para minimizar log (1 −
𝐺(𝐷(𝑧))):
En otras palabras D y G juegan un juego con la función 𝑉(𝐺, 𝐷):
𝑚𝑖𝑛𝐺 𝑚𝑎𝑥𝐷 𝑉(𝐺, 𝐷) = 𝔼𝑥~𝑝𝑑𝑎𝑡𝑎(𝑥) [log(𝐷(𝑥))] + 𝔼𝑧~𝑝𝑧(𝑧) [log (1 − 𝐷(𝐺(𝑧)))] (1)
En la práctica, la ecuación (1) no podría proveer el suficiente gradiente para que G aprenda bien, en
el comienzo del aprendizaje D puede rechazar muestras con alta confianza porque son claramente
diferentes de los datos de entrenamiento, en este caso log (1 − 𝐷(𝐺(𝑧))) se satura. El
entrenamiento de G minimiza log (1 − 𝐷(𝐺(𝑧))), se puede entrenar G para maximizar
log (𝐷(𝐺(𝑧))). Esta función objetivo resulta en el mismo punto fijo de la dinámica de G y D para
proveer gradientes mejores al comienzo del entrenamiento. [14]
3.2.4 AlexNet
La arquitectura de AlexNet, popularmente reconocida en el año 2012, cuyo autor Alex Krizhevsky,
es una red neuronal convolucional y publicada por Llya Sutskever y el consejero de doctorado de
Alex Krizhevsky, Geoffrey Hinton.
Esta red estuvo presente en el desafío de reconocimiento visual a gran escala de ImageNet [11] el
30 de Septiembre de 2012. La red logró un error entre los 5 primeros del 15.3% y fue la ganadora
de dicho concurso. Las principales características de esta red fueron la profundidad del modelo para
su alto rendimiento que computacionalmente era costoso pero factible debido a que se usaron
unidades de procesamiento de gráficos (GPU) en el proceso de entrenamiento.
Esta red tiene como principal objetivo resolver el problema de clasificación donde la entrada es una
imagen la cual será clasificada en una categoría de 1000 clases diferentes.
La composición de esta red neuronal está organizada de la siguiente manera:
 Entrada: La entrada a AlexNet es una imagen RGB de tamaño 256 x 256. Esto significa
que todas las imágenes de entrada deberán tener el mismo tamaño, si la imagen no es de
256 x 256 deberá convertirse. En la Figura 8 se muestra un redimensionamiento que se
realiza para la red AlexNet el cual es un redimensionamiento de 256x256 ya que éste es el
tamaño de imágenes con el que trabaja esta red neuronal convolucional.
20
Figura 8. Redimensionamiento de imagen para AlexNet
Fuente:[15]
 Arquitectura: AlexNet era mucho más grande que las CNN anteriores, con 60 millones de
parámetros y 650000 neuronas, la cual tomó de 5 a 6 días entrenar en dos GPU. La Figura 8
muestra cómo se conforma la arquitectura de AlexNet.
Figura 9. Arquitectura de AlexNet

Fuente: [15]
AlexNet cuenta con 5 capas convolucionales y 3 capas totalmente conectadas. Varias capas
convolucionales extraen características de la imagen. La primera capa convolucional tiene 96 filtros
y un tamaño de 11 x 11 x 3. Las primeras capas convolucionales son seguidas por las capas de
superposición máximas, encargadas de disminuir el tamaño de la imagen para así tener menor costo
computacional. La tercera, cuarta y quinta están conectadas directamente. La quinta capa
21
convolucional es seguida por una capa de superposición máxima superpuesta. La salida de la cual
entra a una serie de capas conectadas completamente. La segunda capa completamente conectada se
alimente en un clasificador de softmax con 1000 etiquetas de clase.
La no linealidad ReLU se aplica después de todas las capas de convolución y totalmente
conectadas. [13]
3.2.5 Inception-v3
Inception v3 es una arquitectura que está compuesta de 42 capas. Existen 4 versiones de la

arquitectura de aprendizaje Inception. La arquitectura de convolución profunda de Inception se
introdujo como GoogLeNet en el 2015, también llamada Inception v1. Más tarde la arquitectura se
refinó, primero mediante la introducción de normalización de lotes (Inception v2), más adelante con
las ideas de factorización adicionales en la tercera iteración (Inception v3).
Las características más importantes de Inception v3 son:
o Factorización de convoluciones: reducen el número de conexiones/parámetros sin disminuir
eficiencia
o Clasificador auxiliar: solo utiliza 1 clasificador auxiliar en la parte superior de la última capa
17 x17, estos se utilizan para tener una red más profunda, en esta red el clasificador auxiliar se
utiliza como regularizador.
o Reducción de tamaño de rejilla eficiente: En AlexNet y VGGNet la reducción del mapa de
características se realiza mediante agrupación máxima. Inception utiliza un método llamado la
reducción de tamaño de rejilla, con la reducción eficiente de rejilla, 320 mapas de
características se realizan por convolución. 320 mapas de características se obtienen por
agrupación máxima. Y estos 2 conjuntos de mapas de características se concatenan como 640
mapas de características y pasan al siguiente módulo de inicio. Con esta reducción eficiente del
tamaño de la red se logra una red menos costosa y aún más eficiente. [16]
22
Figura 10 Reducción de tamaño convencional (arriba a la izquierda), reducción de tamaño de
cuadricula eficiente (abajo a al izquierda), arquitectura detallada de reducción de tamaño de
cuadricula eficiente (derecha)
Fuente:[17]
La Figura 10 muestra una de las caracteristicas especiales de la red Inception v3, la cual muestra los
dos tipos de reducccion del tamaño de la imagen que se pueden realizar en la red neuronal inception
v3. En la parte superior izquierda se puede observar una reducción convencional mediante el uso de
Pooling cambiando una imagen de 35x35 a una de 17x17. En la parte inferior se muestra el tipo de
reducción eficiente en donde utiliza el principio de concatenación de características. Al final de un
proceso, une los filtros de convolución y los de reducción, permitiendo utilizar menos costo
computacional.
En la arquitectura de Inception v2 existen 42 capas de profundidad, con lo cual el costo de cálculo
es solo alrededor de 2.5 más alto que el de GoogLeNet y más eficiente que el de VGGNet. En la
arquitectura de inception se utiliza Batch Norm y ReLU despues de capas convolucionales.
23
Figura 11. Arquitectura de la red neruonal inception v3
Fuente: [17]
La Figura 11 muestra de manera resumida la arquitectura de la red Inception v3 en donde se pueden

resaltar las capas de convolución, reducción promedio, reducción máxima, concatenación,
abandono, totalmente conectada y softmax; como también se puede observar el tamaño de entrada
de la imagen de 299x299x3 y los diferentes módulos de Inception.
3.2.6 Inception-ResNet v2
Se inspira en el rendimiento de la red neuronal ResNet. La versión 1 de esta red tiene un costo
computacional similar al de Inception v3, mientras que la versión 2 de Inception-ResNet es similar
a Inception v4. Esta red introduce conexiones residuales a la salida de la operación de convolución.
Este modelo reconoce 1000 clases diferentes de objetos en el desafío de reconocimiento visual a
gran escala de ImageNet 2012. La entrada al modelo es una imagen de 299x299.
Redes ResNet combinan la arquitectura de la red Inception y redes residuales haciendo que el
rendimiento sea mejor a un costo computacional relativamente bajo. La arquitectura de la red se
presenta en la Figura 11.
24
Figura 12. Arquitectura Inception ResNet v2
Fuente: [18]
En la Figura 12 se tiene la representación resumida de la red InceptionResNet v2, en la cual se

destacan capas de convolución, MaxPooling, Average Pooling, concatenación, abandono, capas
completamente conectadas, función de activación softmax y bloques residuales, mostrando una
arquitectura muy compleja pero con grandes ventajas a comparación de otro tipo de arquitecturas.
Un concepto útil en las redes Inception son los bloques residuales. La Figura 13 muestra un bloque
residual con el cual se da un aumento de profundidad con respecto a otro tipo de arquitecturas, este
aumento de profundidad (número de capas) brinda mejores resultados en el momento de generalizar
un conjunto de imágenes, siempre y cuando se cuente con un conjunto de datos grande [16].
25
Figura 13. Bloque residual de Inception (Inception-ResNet-A)
Fuente: [18]
Para que la adición residual funcione, la entrada y la salida después de la convolución deben tener
las mismas dimensiones. Por lo tanto, se usa convoluciones 1x1 después de las convoluciones
originales, para igualar los tamaños de profundidad (la profundidad aumenta después de la
convolución).
Para aumentar la estabilidad, se escalaron las activaciones residuales en un valor de alrededor de 0.1
a 0.3. La representación del escalamiento se puede observar en la Figura 14.
26
Figura 14. Escalamiento de activaciones por una constante
Fuente: [18]
3.3 IMAGENET
ImageNet es construida sobre la estructura jerárquica provista por WordNet. ImageNet tiene un
orden de 50 millones de imágenes etiquetadas. Los objetivos de ImageNet es proveer la mayor
exhaustiva y diversa cobertura de imágenes en el mundo. Contiene 12 sub-ramas (mamíferos,
carnívoros, caninos, perros, perros trabajando, vehículos, perros esquimales, arte, arte acuático,
veleros, botes, trimarán), las imágenes se encuentran esparcidas sobre 5247 categorías con un
promedio de 600 imágenes por cada categoría. [19]
3.4 FUNCIÓN DE ACTIVACIÓN
Las funciones de activación son funciones usadas en redes neuronales para calcular la suma
ponderada de entradas y sesgos, de los cuales son usados para decidir si una neurona puede ser
activada o no. Esto manipula los datos presentados a través de un procesamiento de gradiente
usualmente el descenso de gradiente y después produce una salida para la red neuronal, que
contiene los parámetros en los datos. La función de transferencia puede ser lineal o no lineal
dependiendo del uso, y son usadas para controlar la salida de las redes neuronales a través de
diferentes dominios como reconocimiento de objetos, clasificación, reconocimiento del habla,
segmentación, descripción y entendimiento de escenas, sistemas de detección de cáncer entre otros.
[20]
3.4.1 Función Sigmoide

La función Sigmoide es considerada como una función logística o función de aplastamiento en
algunas literaturas. Esta función de activación es muy usada en redes neuronales hacia adelante. Es
una función real, diferenciable y limitada, definida para valores de entrada reales con derivadas
positivas en todas partes y cierto grado de suavidad, la función Sigmoide es dada por la relación:
1
𝑓(𝑥) = ((1+𝑒𝑥𝑝−𝑥)) (2)
La función Sigmoide sufre inconvenientes que incluye gradientes agudos durante la propagación
hacia atrás desde las capas más profundas hasta las capas de entrada, saturación de gradientes,
27
convergencia lenta y ceros no centrados en la salida que causa que el gradiente se actualice y se
propague en diferentes direcciones.
3.4.2 Función unidad lineal rectificada (ReLU)

Es la función de activación extensamente más usada en aplicaciones de aprendizaje profundo,
ReLU es una función de activación rápida, la cual ha mostrado ser una función de activación que
otorga resultados satisfactorios a comparación de Sigmoide o tangente hiperbólica. Representa una
función lineal cercana y por lo tanto preserva propiedades de modelos lineales que los hace más
fácil de optimizar. La función de activación ReLU realiza una operación de umbral para cada
elemento de entrada donde los valores inferiores a cero, por lo tanto esta se da por la ecuación:
𝑥𝑖 , 𝑠𝑖 𝑥𝑖 𝑥 ≥ 0
𝑓(𝑥) = max(0, 𝑥) = { (3)
0, 𝑠𝑖 𝑥𝑖 𝑥 < 0
3.4.3 Función de activación LeakyReLU

Esta introduce una pequeña pendiente negativa para mantener las actualizaciones de peso, el
parámetro alpha fue introducido como una solución de los problemas de neuronas muertas de ReLU
de manera que los gradientes no serán cero en ningún momento durante el entrenamiento.
LeakyReLU calcula el gradiente con un pequeño valor de constante para el gradiente negativo 𝛼 en
el rango de 0.01 así LeakyReLU es calculada como:
𝑥𝑖 , 𝑠𝑖 𝑥𝑖 𝑥 ≥ 0
𝑓(𝑥) = 𝛼𝑥 + 𝑥 = { (4)
𝛼𝑥𝑖 , 𝑠𝑖 𝑥𝑖 𝑥 < 0
3.5 DROPOUT (Abandono)
El sobreajuste un problema en las redes neuronales que tienen un gran número de parámetros, Las
grandes redes también son lentas de usar, lo que dificulta lidiar con el sobreajuste. El abandono es
un método que trata este problema, la idea clave es soltar aleatoriamente neuronas (a lo largo de sus
conexiones) durante el entrenamiento de la red neuronal, esto evita que las neuronas se adapten
demasiado. En el entrenamiento dropout muestrea un número exponencial de conexiones
“reducidas”. En el tiempo de prueba es fácil aproximar los efectos promedios de predicciones de
todas estas conexiones reducidas a usar una simple red no reducida que tiene pesos más pequeños.
Esto significa reducir el sobreajuste y da una mayor mejora sobre otros métodos de regularización.
3.5.1 Descripción del modelo de dropout

Considerando una red neuronal con L capas escondidas. Dejar 𝑙 ∈ {1, … , 𝐿} como índice de las
capas ocultas de la red. Dejar a 𝑧 (𝑙) como el vector de entradas de la capa l, 𝑦 (𝑙) denota el vector de
salidas de la capa l (𝑦 (0) = 𝑥 es la entrada). 𝑊 (𝑙) 𝑦 𝑏 (𝑙) Son los pesos y sesgos de la capa l, la
operación hacia delante de una red neuronal estándar puede ser descrita como (para 𝑙 ∈
{0, … , 𝐿 − 1} y cualquier unidad escondida i.)
𝑧𝑖 (𝑙+1) = 𝑤𝑖 (𝑙+1) 𝑦 𝑙 + 𝑏𝑖 (𝑙+1)
𝑦𝑖 (𝑙+1) = 𝑓(𝑧𝑖 (𝑙+1) ) (5)
28
Donde f es cualquier función de activación, por ejemplo, 𝑓(𝑥) = 1/(1 + exp(−𝑥)) con dropout, la
operación hacia adelante llegaría a ser:
𝑟𝑗 (𝑙) ∼ Bernoulli(p)
𝑦̃ (𝑙) = 𝑟 (𝑙) ∗ 𝑦 (𝑙)
𝑧𝑖 (𝑙+1) = 𝑤𝑖 (𝑙+1) 𝑦̃ 𝑙 + 𝑏𝑖 (𝑙+1)
𝑦𝑖 (𝑙+1) = 𝑓(𝑧𝑖 (𝑙+1) ) (6)
Donde * denota el producto de dos elementos. Para cualquier capa l, 𝑟 (𝑙) es un vector independiente
de Bernoulli para cada variable aleatoria de las cuales tiene la probabilidad p de ser 1. Este vector es
muestreado y multiplicado con la salida de la capa 𝑦 (𝑙) para crear la salida reducida 𝑦̃ (𝑙). Las salidas
reducidas son luego usadas como entradas de las próximas capas. Este proceso es aplicado a cada
capa, Esto equivale a muestrear una subred de una red más grande red. Para el aprendizaje, las
derivadas de la función de perdida son propagadas hacia atrás a través de la subred. A la misma vez
los pesos son escalados como 𝑊𝑡𝑒𝑠𝑡 (𝑙) = 𝑝𝑊 (𝑙), los resultados de la red neuronal son usados sin
dropout.
(a) Red estándar (b) Red con Abandono
Figura 15. Comparación de la operación básica de la red estándar y la red con Dropout [21]
29
La Figura 15 muestra gráficamente una red neuronal estándar y una red a la que se le activa
abandono, siendo así el abandono una operación matemática realizada sobre las neuronas para ser
desactivadas de manera aleatoria en proceso de entrenamiento.
3.6 DESCENSO DE GRADIENTE Y SUS VARIANTES
El descenso de gradiente es una manera de minimizar una función objetivo J (θ) parametrizada por
un modelo con el parámetro 𝜃 ∈ ℝ𝑑 para actualizar los parámetros en la dirección opuesta del
gradiente de la función objetivo ∇ 𝜃 𝐽(𝜃). La taza de aprendizaje η determina el tamaño de los pasos
para alcanzar un mínimo local. En otras palabras se sigue la dirección cuesta debajo de la superficie
creada por la función objetivo hasta alcanzar un valle.
Hay 3 variantes de descenso de gradiente que difieren en cuantos datos se usarán para computar el
gradiente de la función objetivo. Dependiendo de la cantidad de datos se hace un intercambio entre
la precisión de los parámetros actualizados y el tiempo que toma en realizar una actualización. [22]
3.6.1 Descenso de gradiente por lote

Computa el gradiente de la función de costo para el parámetro 𝜃 para todo el conjunto de
entrenamiento:
𝜃 = 𝜃 − 𝜂 · 𝛻𝜃 𝐽(𝜃) (7)
Con esto se necesita calcular los gradientes para toda la base de datos, se realiza una sola
actualización, el descenso de gradiente por lote suele ser muy lento e intratable en conjuntos de
datos que no se ajustan en memoria.
3.6.2 Descenso de gradiente estocástico

El descenso de gradiente estocástico o por sus siglas en inglés (SGD), realiza una actualización de
parámetros por cada ejemplo de entrenamiento x (i) y etiqueta y (i).
𝜃 = 𝜃 − 𝜂 · 𝛻𝜃 𝐽(𝜃; 𝑥 (𝑖) ; 𝑦 (𝑖) ) (8)
El descenso de gradiente por lote hace una redundancia computacional para grandes conjuntos de
datos. SGD quita esta redundancia realizando una actualización a la vez. Es entonces usualmente
este un método más rápido. SGD se utiliza en actualizaciones con alta varianza que hace que la
función objetivo fluctúe fuertemente.
3.6.3 Descenso de gradiente por mini-lotes

El descenso de gradiente por mini-lotes finalmente toma lo mejor de los dos mundos, y realiza una
actualización por cada mini-lote de 𝑛 ejemplos entrenados
𝜃 = 𝜃 − 𝜂 · 𝛻𝜃 𝐽(𝜃; 𝑥 (𝑖:𝑖+𝑛) ; 𝑦 (𝑖:𝑖+𝑛) ) (9)
De esta manera reduce la varianza de los parámetros actualizados, lo cual lleva a una convergencia
más estable, tamaños comunes de mini-lotes comunes están entre 50 y 256, pero puede variar para
diferentes aplicaciones. El optimizador SGD es también empleado cuando se usa mini-lotes
30
Hay que tener en cuenta que en este algoritmo se debe escoger una taza de aprendizaje correcta con
el fin de que se pueda converger y no se demore en hacerlo. Una taza muy pequeña hace que sea
muy lenta la convergencia, mientras que una taza demasiado grande haría que no se dé la
convergencia. [22].
3.7 Algoritmos de optimización del descenso de gradiente

Se muestra a continuación los algoritmos de optimización más usados en aprendizaje profundo, no
se discutirá sobre algoritmos que son inviables de computar en la práctica por la alta dimensión del
conjunto de datos.
3.7.1 AdaGrad
AdaGrad es un algoritmo de optimización basado en gradiente, este adapta la taza de aprendizaje a
los parámetros, realizando actualizaciones más grandes para parámetros poco frecuentes y
actualizaciones más pequeñas para parámetros frecuentes. AdaGrad mejora en gran manera la
robustez de SGD y es usado a gran escala en entrenamientos de Google. Previamente se realiza una
actualización para todos los parámetros 𝜃 a la vez como todos los parámetros 𝜃𝑖 usados en la misma
taza de aprendizaje 𝜂. Como AdaGrad usa una taza de aprendizaje diferente para todos los
parámetros 𝜃𝑖 en todo el paso del tiempo t, primero se muestra una actualización por parámetros,
que luego se vectoriza. Por brevedad se configura 𝑔𝑡,𝑖 para ser el gradiente de la función objetivo
con respecto a los parámetros 𝜃𝑖 en el paso de tiempo:
𝑔𝑡,𝑖 = 𝛻θ𝑡 𝐽(𝜃 𝑡,𝑖 ) (10)
La actualización SGD para todos los parámetros 𝜃𝑖 en cada paso de tiempo t llega a ser:
𝜃𝑡+1,𝑖 = 𝜃 𝑡,𝑖 − 𝜂 · 𝑔𝑡,𝑖 (11)
En esta regla de actualización, AdaGrad modifica la taza de entrenamiento general 𝜂 en cada paso
de tiempo t para todos los parámetros 𝜃𝑖 basado en los gradientes pasados que han sido computados
por 𝜃𝑖 :
𝜂
𝜃𝑡+1,𝑖 = 𝜃 𝑡,𝑖 − · 𝑔𝑡,𝑖 (12)
√𝐺𝑡,𝑖𝑖 + 𝜖
𝐺𝑡 ∈ ℝ𝑑𝑥𝑑 Aquí esta una matriz diagonal donde cada elemento de la diagonal 𝑖, 𝑖 es la suma de los
cuadrados de los gradientes con respecto a 𝜃𝑖 hasta el paso del tiempo t, mientras que 𝜖 es un
término suavizado que evita la división por 0 (usualmente en el orden de 1e – 8). De manera
interesante sin la operación de raíz cuadrada, el algoritmo empeora.
Como 𝐺𝑡 contiene la suma de los cuadrados de los pasados gradientes con respecto a todos los
parámetros 𝜃 a lo largo de esta diagonal, podemos vectorizar realizando una multiplicación
elemento-inteligente-matriz-vector entre 𝐺𝑡 y 𝑔𝑡 :
𝜂
𝜃𝑡+1 = 𝜃 𝑡 − . 𝑔𝑡 (13)
√𝐺𝑡 + 𝜖
31
Uno de los beneficios de AdaGrad es que elimina la necesidad de ajuste manual de la taza de
aprendizaje. Más Las implementaciones usan un valor predeterminado de 0.01 y lo dejan así.
La principal debilidad de AdaGrad es que acumula el cuadrado de los gradientes en el
denominador: ya que cada término agregado es positivo, la suma acumulada se mantiene creciente
durante el entrenamiento. Esto a su vez causa que la taza de aprendizaje disminuya y eventualmente
llegue a ser infinitamente pequeña, en este punto el algoritmo ya no es capaz de adquirir
conocimiento adicional. [22]
3.7.2 Adadelta
Adadelta es un método de taza de aprendizaje por dimensión, este método se adapta dinámicamente
con el tiempo usando solo información de primer orden y tiene una sobrecarga computacional
mínima comparado al descenso de gradiente estocástico. El método no requiere ajuste manual de la
taza de aprendizaje y parece robusto a información de gradiente ruidosa. [23]
Este método es una extensión de AdaGrad que busca reducir su agresividad monotónicamente
reduciendo la taza de aprendizaje, en vez de acumular el gradiente de todos los cuadrados de los
gradientes cuadrados, Adadelta restringe la ventana de gradientes pasados acumulados a un tamaño
fijo w. En lugar de almacenar ineficientemente gradientes cuadrados previos w, la suma de los
gradientes es recursivamente definida como una caída promedio de todos los gradientes cuadrados
pasados. El promedio de funcionamiento 𝐸[𝑔]2 𝑡 en el paso de tiempo t entonces depende (como
una fracción γ similar al término de momentum) solo en el anterior promedio y el gradiente actual:
𝐸[𝑔]2 𝑡 = 𝛾𝐸[𝑔]2 𝑡−1 + (1 − 𝛾) 𝑔2 𝑡 (14)
El conjunto 𝛾 con un valor similar al término de momentum, alrededor de 0.9. Para mayor claridad
ser reescribe la actualización SGD en términos del vector de actualización de parámetros ∆𝜃𝑡 :
∆𝜃𝑡 = −𝜂 · 𝑔𝑡,𝑖
𝜃𝑡+1 = 𝜃𝑡 + ∆ 𝜃𝑡 (15)
El vector de actualización de parámetros de AdaGrad derivado anteriormente toma la forma:

𝜂
∆𝜃𝑡 = − . 𝑔𝑡 (16)
√𝐺𝑡 + 𝜖
Ahora simplemente se reemplaza la matriz diagonal 𝐺𝑡 con el promedio de caída sobre gradientes
cuadrados anteriores 𝐸[𝑔]2 𝑡 :
𝜂
∆𝜃𝑡 = − . 𝑔𝑡 (17)
√𝐸[𝑔2 ]𝑡 + 𝜖
Como el denominador es solo la raíz cuadrática media (RMS) criterio de error del gradiente, se
puede reemplazar esto con el criterio abreviado.
𝜂
∆𝜃𝑡 = − . 𝑔𝑡 (18)
𝑅𝑀𝑆[𝑔]𝑡
32
Los autores notan que las unidades en esta actualización (tan bien como en SGD, momentum o
AdaGrad) no coinciden, es decir la actualización debería tener las mismas unidades hipotéticas
como el parámetro. Para realizar esto, ellos primero definen otro promedio de caída exponencial
esta vez no de gradientes al cuadrado, sino de actualizaciones de parámetros al cuadrado.
𝐸[∆𝜃 2 ]𝑡 = 𝛾𝐸[∆𝜃 2 ]𝑡−1 + (1 − 𝛾)∆𝑡𝜃 2 𝑡 (19)
El error cuadrático medio de las actualizaciones de parámetros es:
𝑅𝑀𝑆[∆𝜃]𝑡 = √𝐸 [∆𝜃 2 ]𝑡 + 𝜖 (20)
Entonces 𝑅𝑀𝑆[∆𝜃]𝑡 es desconocido, aproximamos esto con la RMS de parámetros actualizados

hasta el paso del tiempo anterior. Reemplazando la taza de aprendizaje 𝜂 en la regla de
actualización anterior con 𝑅𝑀𝑆[∆𝜃]𝑡−1 finalmente produce la regla de actualización Adadelta:
𝑅𝑀𝑆[∆𝜃]𝑡−1
∆𝜃𝑡 = − (21)
𝑅𝑀𝑆[𝑔]𝑡
𝜃𝑡+1 = 𝜃𝑡 + ∆𝜃𝑡 (22)
Con Adadelta no se necesita establecer una taza de aprendizaje predeterminada, ya que ha sido
eliminada la regla de actualización. [22]
3.7.3 RMSProp
RMSProp es un inédito método de taza de aprendizaje adaptativo propuesto por Geoffrey Hinton.
RMSProp y Adadelta han sido desarrollados independientemente al mismo tiempo con la necesidad
de resolver la taza de aprendizaje que disminuye radicalmente en AdaGrad. RMSProp de hecho es
idéntico al primer vector de actualización de Adadelta que se derivó arriba:
𝐸[𝑔2 ]𝑡 = 0.9𝐸[𝑔2 ]𝑡−1 + 0.1𝑔2 𝑡 (23)
𝜂
𝜃𝑡+1 = 𝜃𝑡 − (24)
√𝐸[𝑔2 ]𝑡 +𝜖
RMSProp también divide la taza de aprendizaje por un exponencialmente promedio de caída del
cuadrado de gradientes. Hinton sugiere γ ser configurado a 0.9, mientras un buen valor
predeterminado para la taza de aprendizaje 𝜂 0.001. [22]
3.7.4 Adam
La estimación del momento adaptativo (Adam) es otro método que calcula tazas de aprendizaje de
forma adaptativa para cada parámetro. Además de almacenar un promedio de caída exponencial del
cuadrado de gradientes pasados 𝜈𝑡 como Adadelta y RMSProp, Adam también mantiene un
promedio de caída exponencial de los gradientes pasados 𝑚𝑡 , similar al momentum:
33
𝑚𝑡 = 𝛽1 𝑚𝑡−1 + (1 − 𝛽1 )𝑔𝑡
𝜈𝑡 = 𝛽2 𝜈𝑡−1 + (1 − 𝛽2 )𝑔2 𝑡 (25)
𝑚𝑡 Y 𝜈𝑡 son estimaciones del primer momento (la media) y el segundo momento (varianza no
centrada) de los gradientes respectivamente, por lo tanto el nombre del método. Como 𝑚𝑡 Y 𝜈𝑡 son
inicializados como vectores de 0, son parcialmente 0 especialmente durante la etapa del tiempo
inicial, y especialmente cuando la taza de caída es pequeña (es decir con 𝛽1 y 𝛽2 cercanos a 1).
Contrarrestan estos sesgos calculando sesgos corregidos de estimaciones de primer y segundo
momento:
𝑚𝑡
𝑚
̂=
1 − 𝛽𝑡1
𝑣𝑡
𝜈̂𝑡 = (26)
1−𝛽 𝑡 2
Luego los usa para actualizar los parámetros tal como se observa en Adadelta y RMSProp, lo cual
produce la regla de actualización de Adam:
𝜂
𝜃𝑡+1 = 𝜃𝑡 − 𝑚
̂𝑡 (27)
̂+𝜖
√𝜈 𝑡
Los autores proponen valores predeterminados de 0.9 para 𝛽1 , 0.999 para 𝛽2 , y 10−8 para 𝜖. Ellos
muestran empíricamente que Adam trabaja bien en la práctica y se compara favorablemente con
otros métodos de aprendizaje adaptativo. [22]
34
4. MÉTODOS Y DESARROLLO DEL PROYECTO
En el presente trabajo se llevaron a cabo una serie de pasos y estrategias que permitieron alcanzar
los objetivos principales propuestos, en donde se tuvo como principal herramienta de desarrollo el
lenguaje de programación Python. En la actualidad es uno de los lenguajes de programación más
utilizados en trabajos de inteligencia artificial y visión de máquina teniendo la ventaja ser fácil de
manejar y de código abierto. Para este trabajo se empleó la versión de Python 3,7.
La metodología que se llevó a cabo consta de 6 pasos los cuales se enumeran de la siguiente
manera:
1. Preparación de entorno de trabajo y creación de ambiente de programación
2. Recolección de base de datos
3. Aumento de base de datos
4. Elección del tipo de entrenamiento
5. Métodos para combatir el sobreajuste
6. Entrenamiento de red desde 0
7. Entrenamiento mediante transferencia de aprendizaje:
8. Generación de imagen adversaria para atacar las redes neuronales entrenadas
En las siguientes secciones se presenta detalladamente la forma como se desarrolló cada una de
estas etapas de la metodología propuesta.
4.1 PREPARACIÓN DE ENTORNO DE TRABAJO Y CREACIÓN DE

AMBIENTE DE ENTORNO DE PROGRAMACIÓN
En la preparación del entorno de trabajo se emplearon 3 importantes herramientas de trabajo que

fue necesario instalar:
 Python
 Anaconda Navigator
 Jupyter Notebook
Con la obtención de Python se empieza a formar la base de estructura de trabajo a utilizar para el
presente proyecto.
Una vez instalada la versión de Python 3.7 se procede a la instalación de Anaconda Navigator en su
versión 1.9.7. Anaconda Navigator es una interfaz gráfica de usuario de escritorio incluida en
Anaconda que permite iniciar aplicaciones y administrar fácilmente los paquetes, entornos y canales
de Anaconda sin la necesidad de usar comandos. [24]
35
Anaconda Navigator cuenta con la ventaja de crear nuevos ambientes de trabajo mediante la
consola denominada Anaconda Prompt el cual es un programa que se instala junto con la interfaz de
usuario Anaconda Navigator.
Con la oportunidad de crear nuevos ambientes de trabajo se puede tener proyectos con las librerías
necesarias para la ejecución del trabajo que se desee implementar.
El cuaderno de programación utilizado disponible en Anaconda Navigator que se escogió fue
“Jupyter Notebook” el cual es una aplicación web de código abierto y tiene una estructura fácil de
usar en donde se pueden separar bloques de código para ser compilados independientemente.
La ventaja con la que cuenta el uso de Jupyter notebook dentro del programa denominado
Anaconda Navigator es que permite realizar las descargas de las diferentes librerías mediante su
interfaz, en donde se puede observar que dependencias están o no instaladas. De forma alternativa,
se pueden descargar las librerías mediante la consola de Python con el comando pip install seguido
del nombre de la librería.
La interfaz de programación de aplicaciones (API) que se usó es KERAS [18] la cual es una API de
redes neuronales de alto nivel, está escrita en lenguaje Python y es capaz de ejecutarse sobre otras
librerías como lo es TensorFlow, CNTK o Theano [24].
Para finalizar esta sección se debe decir que fue necesario realizar un redimensionamiento de las
imágenes por motivo de memoria y capacidad de cómputo limitada. Se decidió trabajar con un
tamaño de imagen de 100 x 100 en donde se mostrarían buenos resultados. Se trató de igual forma
trabajar el tamaño que usan redes grandes como lo es un tamaño de 224 x 224 o 299 x 299, pero la
memoria con la que se cuenta no fue lo suficientemente grande para soportar dichos tamaños
haciendo imposible llegar a la fase de entrenamiento.
Figura 16. Herramientas de programación usada

Fuente: Autor
36
En la Figura 16 se muestra el formato de programación que se usó para poder entrenar los diferentes
modelos de aprendizaje profundo. Es un formato visto desde diferentes niveles, en donde el nivel 0
corresponde al lenguaje de programación Python, seguido del nivel 1 en donde se usó la biblioteca
de TensorFlow la cual tiene la capacidad de calcular automáticamente las derivadas parciales de la
función de coste, en el nivel 2 se encuentra la API de Keras la cual trabaja sobre TensorFlow y
representa una interfaz de alto nivel en donde permitió facilitar la configuración de los modelos
vistos, en un nivel 3 se encuentra la biblioteca Scikit_learn la cual tiene un formato de
programación de más alto nivel debido a que se pueden cargar directamente modelos de
aprendizaje, sin embargo esta biblioteca no se usó en este trabajo.
4.2 RECOLECCIÓN DE BASE DE DATOS
En cuanto a la recolección de la base de datos cabe resaltar que fue una tarea minuciosa en donde se
tomaron imágenes de internet con la búsqueda de hojas de caña de azúcar con roya naranja, roya
parda y hojas sanas. Estas imágenes se obtuvieron de diferentes sitios web de agricultura, los cuales
trabajan con este tipo de enfermedad, y tomadas de las páginas de centros de investigación
importantes como CENICAÑA, el cual es uno de los centros más importantes del territorio
Colombiano [5]. De igual manera se recolectó imágenes de visitas a 4 cultivos de caña de azúcar en
la ciudad de Tuluá, ubicada en el Valle del Cauca con el objetivo e recolectar imágenes con ningún
tipo de mancha sospechosa. La base de datos recolectada tuvo un tamaño total de 820 imágenes en
el rango del visible, de las cuales 410 contienen imágenes de hoja de caña de azúcar sana y 410 de
hojas afectadas por la enfermedad. En esta recolección se verificó con cuidado que la imagen
correspondiera a hojas sanas o enfermas con el objetivo de tener una base de datos coherente con la
realidad.
4.3 AUMENTO DE BASE DE DATOS
En aprendizaje profundo, es muy importante contar con un conjunto de entrenamiento grande para
que la red neuronal pueda entrenarse bien y de esta manera poder alcanzar más fácil el punto de
generalización con nuevas imágenes. Aunque precisamente ese es el ideal buscado, en ocasiones es
difícil encontrar la capacidad de generalización, teniéndose que recurrir al uso de estrategias de
control de los datos y manipulación de la red, como también numerosos procesos de
experimentación en donde se entrene la red. Lo anterior, consume tiempo en horas o quizá días
dependiendo de la capacidad de cómputo con la que se cuente. [25]
El aumento de datos es un recurso que fue necesario implementar para el presente proyecto, con el
fin de evitar el sobreajuste, problema en el cual la red neuronal memoriza los datos de
entrenamiento. Es comúnmente encontrar que una red con muchas capas generalice bien, sin
embargo no siempre es así, ya que todo depende de la manera en la que una red neuronal esté
configurada, con lo cual es posible combatir el sobreajuste. [26]
El aumento de datos se realizó utilizando 4 modificaciones a las imágenes base recolectada. A
continuación se presenta un diagrama en donde se muestra la manera que se realizó este
procedimiento:
37
Aumento de base
de datos
Hojas sanas Hojas con roya

(410) (410)
Aumento por Aumento por

reflejo horizontal reflejo horizontal
(820) (820)
Aumento de datos Aumento de datos

por reflejo vertical por reflejo vertical
(1640) (1640)
Aumento de datos Aumento de datos Aumento de datos Aumento por

por nitidez por Contraste por nitidez contraste
+1640 +1640 +1640 +1640
Total Hojas Sanas Total Hojas Con

(4920) Roya (4920)
Figura 17 Diagrama de aumento de base de datos

Fuente: Autor
En la Figura 17, se muestra en paréntesis el número de imágenes con las que se cuenta en cada
momento del proceso de aumento. Teniendo un total de 9840 imágenes, 4920 de sanas y 4920 de
imágenes con la enfermedad.
En Python se implementaron 4 programas que permiten leer el conjunto de datos de imágenes sanas
y enfermas, y a partir de ellas generar las nuevas imágenes de reflejo vertical, reflejo horizontal,
aumento de nitidez y aumento de contraste. Estas nuevas imágenes se guardan con su nombre
representativo de sanas o enfermas para poderlas dividir en dos carpetas diferentes.
Una muestra de argumento de datos mediante estos 4 métodos se puede observar de la siguiente
manera:
38
Figura 18. Aumento de datos por reflejo vertical (imagen superior), aumento de datos por reflejo
horizontal (imagen inferior)
Fuente: Autor
Se puede observar que, en la Figura 18 se produce un efecto de espejo vertical y horizontalmente a
la imagen original, como una de las técnicas usadas para incrementar la base de datos.
Tanto el aumento de datos por reflejo como el de contraste y nitidez, como las mostradas en la
Figura 19, se implementaron en un proyecto nuevo de trabajo en Python en donde se hizo una
duplicación de la base de datos por cada método aplicado. Estas imágenes se guardan en el mismo
directorio en donde se ejecuta el programa. Una vez generadas las nuevas fotos se integran todas las
nuevas imágenes en una sola carpeta para luego ser procesadas por la red neuronal.
Figura 19. Aumento de datos por aumento de nitidez (imagen superior), aumento de datos por
aumento de contraste (imagen inferior)
Fuente:Autor
39
4.4 ELECCIÓN DEL TIPO DE ENTRENAMIENTO
El tipo de entrenamiento a implementar para la detección de roya en caña de azúcar corresponde a

un tipo de entrenamiento “supervisado”, en donde se entrenará a la red con un conjunto de datos
con su correspondiente etiqueta (conjunto de entrenamiento), y luego será puesta a prueba con otro
conjunto de datos que la red no ha visto (conjunto de validación).
Al conjunto de datos total se le realiza una partición de la siguiente manera:
CONJUNTO DE DATOS
conjunto de
validacion ; 10%
conjunto de
prueba; 10%
conjunto de
entrenamiento;
80%
Figura 20. Conjunto de datos de entrenamiento, validación y prueba

Fuente: Autor
El total de imágenes con las que se cuenta es de 9840 de las cuales 4920 pertenecen a hojas sanas y
4920 a hojas con la enfermedad. Del total de imágenes, solo se usan 984 para prueba y 984 para
validación con lo cual se realiza el proceso de entrenamiento con 7872 imágenes, correspondiente al
80% del total de datos como se ilustra en la Figura 20.
4.5 MÉTODOS PARA COMBATIR EL SOBREAJUSTE
En esta sección se describirán algunos métodos utilizados para evitar que la red neuronal reconozca
los datos de entrada, siendo estos determinantes en cualquier tipo de modelo.
Estos métodos están sometidos a una serie de pruebas y experimentos de entrenamiento en donde se
evalúa con qué condiciones el modelo se comporte mejor. Algunos de estos métodos más usados y
que se implementaron para el desarrollo de este proyecto son:
40
a. Aumento de datos:
Como ya se describió anteriormente, el conjunto de datos es muy importante para que la red
pueda aprender bien y no se vea en problemas de sobreajuste o incluso sub-ajuste. Por lo
cual, se procedió a realizar un aumento de datos mediante aumento de contraste, aumento de
nitidez, cambios de posiciones tanto horizontales como verticales, llegando a tener un total de
9840 imágenes [25], mucho mejor que las 820 recolectadas inicialmente.
Este conjunto de datos se hubiese podido ampliar aún más, sin embargo hay que tener en
cuenta que es muy importante que las imágenes nuevas que se generen tengan características
relevantes.
Otro método que es muy importante resaltar corresponde al que ofrece Keras mediante la
función “ImageDataGenerator” en donde se puede llevar a cabo un aumento de datos justo en
el momento de entrenamiento mediante la modificación de la imagen como: giro, rotación,
corte, brillo, zoom, y desplazamiento. Para este caso, no se habilitan las opciones de aumento
por generación de imágenes por reflejo horizontal y vertical porque este proceso se lo realizó
anteriormente, pero si se habilita el aumento por desplazamiento vertical y horizontal, zoom y
corte.
b. Añadir capas de abandono:
Las capas de abandono son una de los métodos más eficientes para controlar el sobreajuste si
se utiliza correctamente. Estas tendrán la función de desactivar aleatoriamente algunas
neuronas solo en el proceso de entrenamiento (propagación hacia adelante y hacia atrás). Con
este método se puede evitar que la red memorice las características de entrada y no pueda
generalizar con nuevos datos. La Figura 21 explica concretamente cómo funciona el
adicionar capas de abandono:
Figura 21. Funcionamiento de introducir capas de abandono a la red neuronal

Fuente: [21]
Como se puede evidenciar en la Figura 19, se desactivan algunas neuronas en el proceso de
entrenamiento, siendo la imagen de la izquierda la conexión total de la red y la de derecha la
red con abandono. Esta técnica se realiza al finalizar cada iteración y se realiza de manera
aleatoria.
41
En Keras se usa capa de abandono con el parámetro de porcentaje de neuronas que se deseen
desactivar durante el proceso de aprendizaje, para lo cual se sigue la recomendación brindada
por el documento [21], en el cual se muestra que para capas de entrada suele usarse un valor
de 30% de deserción o abandono y para capas ocultas o finales se pueden usar valores de 20 a
50%.
En Keras el comando para añadir una capa de abandono se podrá utilizar con: model.add
(Dropout (0.5)) en donde se establecería una deserción del 50% al final de la capa en la que
se introduzca tal función.
En este proyecto, para cada uno de los modelos que se utilizó, se introdujeron capas de
abandono en donde se probaron diferentes rangos desde el 25% hasta el 50%, siendo este
último el porcentaje de deserción que se implementaría en los modelos en donde se transfería
el aprendizaje, y se dejó un porcentaje de 25% en el modelo que se entrenó desde 0.
c. Añadir regularización:
Para controlar el sobreajuste en algunas áreas se utilizan técnicas de regularización [27].

En redes neuronales existen dos tipos de regularización denominados regularización L1 y
regularización L2, cada uno de estos tiene un mecanismo de funcionamiento diferente que
permite contrarrestar el sobreajuste.
Para este proyecto se utiliza la regularización L2 la cual se adapta a las condiciones del
problema de clasificación que se propone, ya que en las imágenes se desea conservar muchas
características relevantes. Con la regularización L2 se realiza una disminución en los
coeficientes de la red sin llevarlos a cero. En contraste, la regularización L1 se aconseja
utilizar cuando se tenga seguridad de que muchos atributos del conjunto de datos son
irrelevantes, llevando esos coeficientes a 0 [28]. Sin embargo, se realizaron pruebas de
entrenamiento utilizando regularización L1 y L2 para observar la diferencia en el proceso de
entrenamiento y validación.
Estos dos tipos de regularizadores realizan penalizaciones a los pesos en diferentes
proporciones:
Para la regularización L1, penaliza los pesos en proporción a la suma de los valores absolutos
de los pesos, esta regularización ayuda a acercar los pesos de los atributos irrelevantes o poco
relevantes a 0, con lo cual muchos atributos se eliminarían del modelo. [29].
Para la regularización L2, la cual fue usada para este proyecto, penaliza los pesos en
proporción a la suma de los cuadrados de los pesos, esta regularización ayuda a llevar los
valores de los pesos atípicos (aquellos con valores negativos bajos o positivos altos) más
cerca del cero, pero no exactamente a 0. [29]
𝑀 𝑀
𝜆 ∑|𝑊𝑗| 𝜆 ∑ 𝑊𝑗 2
𝐽=0 𝑗=0
Penalización L1 Penalización L2
Figura 22. Penalidades de los dos tipos de regularizadores
42
Fuente: [30]
En la Figura 22 se puede observar la forma en que cada regularización actúa sobre los pesos
de la red neuronal.
Según [24], se recomienda usar regularización L1 para problemas de variables dispersas (con
muchos valores de 0), sin embargo para este caso se presentan variables con muchos valores
diferentes de 0 por lo cual el tipo de regularización sería el de L2, con el cual tan solo
disminuirá el valor de las ponderaciones sin llevarlas completamente a 0. Con la
regularización L2 se busca reducir la pérdida y también la complejidad del modelo. Esta
regularización se verifica la suma de los cuadrados de los pesos, en donde si el valor de la
ponderación del peso está cercano a 0, esta no tendrá mucho impacto, sin embargo, cuando
esta es atípica, es en donde su valor aumenta considerablemente, por lo cual se realizará una
disminución a esas ponderaciones que afectan la precisión al momento de validar con el
conjunto de prueba. [29]
En este proyecto, la regularización L2 se introdujo tanto para ser entrenado desde 0 como
también a los modelos con transferencia de aprendizaje. Estas penalizaciones se ingresaron a
las capas de convolución y a capas densas, las cuales aportan más parámetros a la red y
mayor complejidad.
d. Ajuste del tamaño de lote (BATCH SIZE) para cada iteración:
Otra de las características a tener en cuenta antes de entrenar un modelo con los datos
recolectados, es el conjunto de lotes que se envíen por cada iteración. En el documento [31]
se analiza el efecto del tamaño de lotes en el rendimiento de entrenamiento, mostrando que es
uno de los factores más importantes a tener en cuenta y que los profesionales de aprendizaje
profundo prefieren usar lotes más grandes debido a aceleraciones computacionales a partir
del paralelismo de la GPU. Sin embargo, usar un lote muy grande lleva a que se pierda
generalización lo cual es un caso que se encuentra en estudio.
Con base en lo anterior, se realizaron diversas pruebas con diferentes BATCH SIZE en donde
se usaron valores pequeños y grandes. Finalmente, se visualizó el rendimiento en
entrenamiento y en validación para luego escoger con cual tamaño de lote se comporta mejor
el modelo y que pueda generalizar mejor.
e. Configuración de parada temprana e inserción de puntos de control:

Una de las buenas prácticas al momento de entrenar cualquier modelo, es la implementación
de un monitoreo automático, ya sea del progreso del rendimiento o del progreso de pérdida a
través de las épocas. Esta automatización realiza un diagnóstico temprano de un caso posible
de sobreajuste.
En este proyecto, se implementa una parada temprana que monitorea la pérdida de
validación, en donde se observará a medida que pasan las épocas si esta disminuye
considerablemente para terminar el proceso de aprendizaje. Unido a esto se establecen puntos
de control (Checkpoint) que permite guardar solamente el modelo en donde se alcance el
mejor rendimiento de validación, esto con el fin de tener una mayor precisión en el momento
de realizar pruebas de predicción con nuevos conjuntos de datos.
Mediante la implementación de parada temprana se puede añadir el parámetro denominado
paciencia, el cual tiene como finalidad permitir que el entrenamiento no se interrumpa hasta
la época indicada, y a partir de ella se activará el monitoreo de parada temprana.
43
Para los modelos de aprendizaje por transferencia se implementaron paradas tempranas con
el fin de evitar el sobreajuste en posteriores épocas y se guardó el modelo con el mejor
rendimiento mediante el uso de puntos de control.
En Python la implementación de parada temprana y puntos de control se hace mediante los
comandos ilustrados en la Figura 23.
Figura 23. Adición de parada temprana y puntos de control con modelo de transferencia
de aprendizaje InceptionResNetV2
Fuente: Autor
En la Figura 23 se muestra la implementación en código Python de añadir paradas tempranas

y puntos de control, cuyas especificaciones muestran que en parada temprana se monitoreara
la pérdida de validación, buscando que esta sea mínima. Con verbose se configuran las
especificaciones del monitoreo, y con la paciencia de 10 épocas, en donde se espera que la
red entrene sin interrupciones.
En los parámetros de puntos de control, se guarda el modelo con un nombre denominado
“mejor modelo” y en este caso monitoreará el rendimiento de validación verificando que este
sea máximo.
Existen algunos criterios para utilizar la parada temprana (early stopping), la mayoría de ellos
basados en alguna métrica de error tal como [32]:
 La función objetivo o función de error del algoritmo de entrenamiento E, por ejemplo

el error cuadrático.
 El conjunto de error de entrenamiento 𝐸𝑡𝑟 (𝑡), el cuál es el error promedio medido
después de una época t.
 El error de validación 𝐸𝑣𝑎 (𝑡), el cual corresponde al error en el conjunto de
validación y es usado para el criterio de parada.
 El error de prueba 𝐸𝑡𝑒 (𝑡). Este no es conocido por el algoritmo de entrenamiento
pero estima el error de generalización y así compara la calidad de la red resultante
desde el entrenamiento.
En la vida real, el error de generalización no es conocido, y solo el error de validación puede
ser estimado. El valor 𝐸𝑜𝑝𝑡 (𝑡) es definido para ser el error más bajo del conjunto de
validación hasta t épocas se define como [32]:
𝑚𝑖𝑛
𝐸𝑜𝑝𝑡 (𝑡) = 𝐸 (𝑡 ′ ) (28)
𝑡 ′ ≤ 𝑡 𝑣𝑎
44
Ahora se define la pérdida de generalización en la época t para ser el incremento relativo del
error de validación por encima del mínimo hasta ahora (en porcentaje):
𝐸𝑣𝑎(𝑡)
𝐺𝐿(𝑡) = 100. ( − 1) (29)
𝐸𝑜𝑝𝑡 (𝑡)
Una alta pérdida de generalización es una clara razón para detener el entrenamiento, porque
esto directamente indica sobreajuste. Esto conduce al primer criterio de parada temprana:
detenerse tan pronto como la pérdida de generalización exceda cierto umbral. Se define
la clase 𝐺𝐿∝ como:
𝐺𝐿∝ : parada después de la primera época t con 𝐺𝐿(𝑡) >∝
Sin embargo, se puede evitar la detención si el entrenamiento está progresando muy

rápidamente. La razón detrás de este enfoque es que cuando el error de entrenamiento
disminuye rápidamente, las pérdidas de generalización tienen más alta probabilidad de ser
“reparadas”, entonces se asume que el sobreajuste no comienza hasta que el error disminuya
lentamente. Para formalizar esta noción, se define una “banda de entrenamiento de tamaño
k” para ser una secuencia de k épocas numeradas n+1…n+k, donde n es divisible por k. El
progreso de entrenamiento medido en miles, después de estas bandas de entrenamiento es
entonces [32]:
∑𝑡𝑡′=𝑡−𝑘+1 𝐸𝑡𝑟 (𝑡 ′)
𝑃𝑘 (𝑡) ≔ 1000. ( − 1) (30)
𝑘.𝑚𝑖𝑛𝑡𝑡′=𝑡−𝑘+1 𝐸𝑡𝑟 (𝑡 ′ )
Esto es, responder la pregunta “¿cuánto fue el error de entrenamiento promedio más grande
que el error de entrenamiento mínimo durante una banda?”. Hay que detallar que esta medida
de progreso es alta para fases inestables de entrenamiento, donde el error del conjunto de
entrenamiento sube en vez de bajar, porque muchos algoritmos de entrenamiento algunas
veces producen “inestabilidad” por tener escalas de pesos inapropiadas. La medida del
progreso es garantía de parada en entrenamientos largos, a menos que el entrenamiento sea
globalmente inestable.
El segundo criterio de parada temprana utiliza el cociente de pérdida de generalización

y progreso [32]:
𝐺𝐿(𝑡)
𝑃𝑄∝ : parada después de la primera finalización de banda de la época t con >∝
𝑃𝑘 (𝑡)
A continuación se asumirán bandas de longitud de 5 y medidas de error de validación solo al

final de cada banda.
Una clase de criterio completamente diferente en parada temprana depende solo de los signos
de los cambios en el error de generalización, se define entonces un tercer criterio de
parada temprana: parar cuando el error de generalización incrementa en s bandas
sucesivas [32].
𝑈𝑃𝑆 : Parar después de la época t si 𝑈𝑃𝑆−1 para después de la época t-k y 𝐸𝑣𝑎 (𝑡) > 𝐸𝑣𝑎 (𝑡 − 𝑘)
45
𝑈𝑃1 : Parada después de la primera finalización de banda de la época t con 𝐸𝑣𝑎 (𝑡) > 𝐸𝑣𝑎 (𝑡 −
𝑘)
La idea detrás de esta definición es que cuando el error de validación ha aumentado, no solo
una vez sino durante s consecutivas bandas, se considera que tales aumentos son el comienzo
del final del sobreajuste independientemente de su incremento. El criterio UP tiene la ventaja
de medir cambios localmente, así ellos pueden ser usados en el contexto de poda de
algoritmos, donde el error debe ser permitido hasta permanecer mucho más alto que el
mínimo anterior sobre periodos de entrenamiento largos.
Ninguno de estos criterios por si solos pueden garantizar terminación, así se los complementa
con la regla de parar el entrenamiento cuando la precisión cae alrededor del 10% o después
de como máximo 3000 épocas. Todos los criterios de parada son usados de la misma forma:
ellos deciden parar al mismo tiempo t durante el entrenamiento y los resultados de
entrenamiento serian el conjunto de pesos que mostraron el más bajo error de validación
𝐸𝑜𝑝𝑡 (𝑡). [32]
4.6 ENTRENAMIENTO DE LA RED DESDE 0
Para la formación de un modelo que se desee entrenar desde 0, se deben definir varios factores y
metricas (hiperparámetros) que se deben adicionar en las respectivas capas del modelo. Es decir, se
deben definir conceptos como el numero de capas, capas de: convolucion, reducción,
regularizacion, entre otras, y sus respectivas clases que permitan obtener un modelo capaz de
aprender los datos ingresados y luego generalizar.
Para este proyecto se tuvo como punto de partida la construcción de un modelo sencillo con una
secuencia estándar de redes neuronales profundas basada en:
Entrada  capa de convolución  capa de reducción  Capa de clasificación
4.6.1 Criterios de elección de caracteristicas de la red
Para empezar, se escoge una arquitectura simple, con el fin de observar su comportamiento
e ir añadiendo o variando características de la red neuronal.
Esta se conformó con 3 capas convolucionales seguidas cada una con capas de reducción de
máxima agrupación (MaxPooling). Se siguió una serie de experimentos de entrenamiento,
utilizando solamente hiperparámetros más usados en redes neuronales, las pruebas
realizadas se presentaron de la siguiente forma:
Tabla 1. Hiperparámetros utilizados en los diferentes entrenamientos para elección de

mejor modelo entrenado desde cero
HIPERPARÁMETROS
Función de activación Sigmoide ReLU LeakyReLU
Optimizadores SGD RMSProp Adagrad Adam
Regularización Dropout L1 L2
46
La Tabla 1 muestra los hiperparámetros con los cuales se varió la red inicial.
El conjunto de pruebas consistió en una serie de entrenamientos en donde el objetivo
primordial consistió en conseguir un modelo con el menor sobreajuste posible.
A continuación se muestra una serie de entrenamientos en donde (*) muestra los
hiperparámetros que se utilizaron para cada entrenamiento.
Tabla 2. Entrenamiento #1
HIPERPARÁMETROS
Función de activación Sigmoide * ReLU LeakyReLU
Optimizadores SGD RMSProp Adagrad Adam*
Regularización Dropout * L1 L2*
HIPERPARÁMETROS
Función de activación Sigmoide ReLU * LeakyReLU
HIPERPARÁMETROS
Función de activación Sigmoide ReLU LeakyReLU*
Regularización Dropout L1 L2
HIPERPARÁMETROS
HIPERPARÁMETROS
Optimizadores SGD RMSProp* Adagrad Adam
47
HIPERPARÁMETROS
Optimizadores SGD RMSProp Adagrad* Adam
HIPERPARÁMETROS
Regularización Dropout * L1* L2
A continuación se muestra un diagrama ejemplo en donde se puede observar una de las

arquitecturas probadas y entrenadas con el conjunto de datos de hojas de caña de azúcar. La figura
corresponde a el entrenamiento #4 la cual tiene optimizador Adam, función de activacion
LeakyReLU, Dropout y regularización L2.
48
Capa de entrada con tamaño de 100x100
Primer capa de convolución
Función de activación
Capa de reducción
Capa de abandono
Segunda capa de convolución
Capa de reducción
Capa de abandono
Tercera capa de convolución
Capa de reducción
Capa de abandono
Capa plana (conservar el orden de los pesos)
Capa completamente conectada
Capa de abandono
Capa completamente conectada
Figura 24. Arquitectura de modelo formado con capas secuenciales

Fuente: Autor
49
Como se puede observar en la Figura 24, el modelo contiene 17 capas, de las cuales 3 son de
convolución, 4 de abandono, 4 de activación LeakyRelu, 2 capas densas, 1 capa de entrada y 3
capas de reducción máxima, hay que resaltar que se añadió regularización L2 a las capas densas y
de convolución.
El procedimiento que se llevó a cabo para esta primera red consiste en:
 Creación de un nuevo proyecto

 Importación de librerías (de TensorFlow y Keras)
 Lectura y etiquetamiento de base de datos
 División de conjunto de entrenamiento, validación y prueba
 Formación de capas del modelo (modelo secuencial)
 Entrenamiento de la red utilizando las herramientas ya descritas que permiten una mejor
generalización de los datos.
 Evaluación del conjunto de prueba (realizado con el 10% del total de imágenes)
 Almacenamiento del modelo que este bien ajustado (automatizado con puntos de control)
 Visualización de resultados de rendimiento y pérdida a lo largo del historial de épocas de
aprendizaje (visualización de rendimiento vs épocas, y pérdida vs épocas)
 Predicción de clases del conjunto de prueba, en donde se ingresa una nueva imagen nunca
vista por la red y se comprueba su acierto
Un diagrama que resume el proceso de elección de la red entrenada desde cero se puede ver en la
Figura 25:
50
Figura 25. Configuración de red desde cero para la detección de roya en caña de azúcar
Fuente: Autor
51
4.7 ENTRENAMIENTO MEDIANTE TRANSFERENCIA DE
APRENDIZAJE
Se ha logrado un progreso notable en el reconocimiento de imágenes, principalmente debido a la

disponibilidad de conjuntos de datos anotados a gran escala y redes neuronales convolucionales
profundas (CNN). Actualmente existen dos técnicas principales que emplean con éxito las CNN
para la clasificación de imágenes: capacitar a la CNN desde cero, usar las funciones de CNN pre-
entrenadas y realizar la capacitación de CNN con ajuste fino supervisado (transferencia de
aprendizaje) [33].
El entrenamiento por transferencia de aprendizaje consiste en escoger un modelo que anteriormente

fue entrenado con un conjunto de datos grande y durante varios días. Según el documento analizado
en [34] se puede observar que transferir el aprendizaje en redes neuronales resulta ser una buena
alternativa cuando no se cuenta con un conjunto de datos numeroso. En este caso, se debe realizar
un procedimiento denominado congelamiento de capas, el cual es un procedimiento que consiste en
fijar los valores de los pesos de las capas iniciales del modelo, las cuales tienen como función la
extracción de características más simples como bordes o contornos, en este proceso se eliminan las
capas finales de clasificación y se ingresa una nueva con el número de clases que se deseen detectar.
De igual forma, hay que resaltar que diferentes cantidades de capas se pueden congelar como se
muestra en la Figura 63.
Figura 26. Opciones de congelamiento de capas de red pre entrenada

Fuente: [34]
En este proyecto, el procedimiento para encontrar un valor de capas a congelar estuvo sometido a
una serie de experimentos en donde se observó el rendimiento de validación, congelando diferentes
porcentajes de capas de los modelos como lo son Inception v3 e IceptionResNet v2. Para esta
ocasión, la estrategia de congelamiento que se escogió se parece mucho al de la imagen del centro
de la Figura 26. Teniendo en cuenta las recomendaciones de congelamiento descritas en [34], se
busca que no solo se presente el problema de sobreajuste (la red aprende muy bien los datos) sino
que también se evite un sub-ajuste (la red no tiene suficientes parámetros para aprender).
52
En el proceso de transferir el aprendizaje usando Inception v3 e IceptionResNet v2 se siguieron los
siguientes pasos:
 Lectura y etiquetamiento de base de datos
 División de conjunto de entrenamiento, validación y prueba
 Métodos para combatir el overfitting y pruebas de congelamiento de capas
 Entrenamiento de la red con adición de paradas tempranas y puntos de control
 Evaluación del conjunto de prueba
 Almacenamiento del modelo en formato .Keras o .h5 (formato que se guardan los modelos
de redes neuronales en Python)
 Visualización de resultados de rendimiento y pérdida (visualización de gráficas de
rendimiento vs épocas, y pérdida vs épocas)
 Predicción de clases del conjunto de prueba.
En la Figura 27 se muestra un diagrama que muestra el procedimiento realizado para obtener los
modelos mediante el procedimiento de transferencia de aprendizaje.
Figura 27. Configuración de las redes con transferencia de aprendizaje para la detección de roya
en caña de azúcar
Fuente: Autor
53
4.8 Ataques adversarios por conjuntos para análisis de robustez
Finalmente, con el objetivo de analizar la robustez de los diferentes modelos de redes neuronales
escogidos, se usa el tipo de ataque adversario de signo de gradiente rápido. El procedimiento
llevado a cabo permite observar el porcentaje con el cual la red fue engañada por un conjunto de
imágenes adversarias generadas con este método, utilizando específicamente el conjunto de datos
de prueba (test) el cual es una muestra representativa del conjunto de datos total, permitiendo tener
un total de 984 imágenes adversarias
Según [37], las principales causas de engañar modelos mediantes ataques adversarios tienen que ver
con la linealidad y el sobreajuste. Se dice que la principal causa de la vulnerabilidad de redes
neuronales ante ataques adversarios es su naturaleza lineal. La causa de estos ejemplos adversarios
fue un misterio, y explicaciones especulativas han sugerido que esto es debido a la extrema no
linealidad de redes neuronales, quizás combinada con modelos insuficientes en regularización en
modelos supervisados.
En esta sección se mostrará un método rápido de generación de ejemplos adversarios para un

entrenamiento con un conjunto de datos adversarios. Con el objetivo de analizar la robustez ante
imágenes adversarias de los modelos presentados anteriormente como los son el modelo entrenado
desde cero y los dos modelos de transferencia de aprendizaje, se describe el procedimiento
mediante 4 pasos resumidos de la siguiente forma:
Paso 1: División aleatoria de datos de entrenamiento y prueba

En el primer paso se realiza una división de datos en dos subconjuntos como lo son el conjunto de
datos de entrenamiento y el conjunto de datos de prueba, desapareciendo así el conjunto de datos de
validación el cual se utilizaba para discriminar la existencia de sobreajuste. Para esta sección
solamente se usarán estos dos subconjuntos en donde se reserva un 90% a los datos de
entrenamiento y un 10% para los datos de prueba. Esta acción de división de datos se realiza
aleatoriamente con el fin de realizar varias repeticiones de entrenamientos y pruebas que permitan
determinar la media y desviación estándar final.
Paso 2: Entrenamiento de la red y generación de imágenes adversarias con el método de signo

de gradiente rápido (FGSM)
Una vez entrenada la red se realiza la generación de imágenes adversarias con el método de signo
de gradiente rápido. Este método causa de manera confiable que una amplia variedad de modelos
clasifique erróneamente su entrada. La esencia de FGSM es agregar el ruido (no aleatorio) cuya
dirección es la misma que el gradiente de la función de costo con respecto a los datos. El ruido es
escalado por épsilon, que generalmente está limitado a ser un número pequeño. La magnitud del
gradiente no importa en esta fórmula, sino la dirección (+/-). Épsilon es un número pequeño que
controla el tamaño del ataque de confrontación, que debe elegirse para ser efectivo pero no
demasiado obvio.
La siguiente ecuación denota el método de signo de gradiente, con el cual se puede generar
ejemplos adversarios. Cabe notar que el gradiente requerido puede ser calculado eficientemente
usando la propagación hacia atrás [37]:
𝜂 = 𝜖𝑠𝑖𝑔𝑛(𝛻𝑥 𝐽(𝜃, 𝑥, 𝑦) (31)
𝑋𝐴𝐷𝑉𝐸𝑅𝑆𝐴𝑅𝐼𝐴𝐿 = 𝑋 + 𝜖𝑠𝑖𝑔𝑛(𝛻𝑥 𝐽(𝜃, 𝑥, 𝑦) (32)
54
𝜃 son los parámetros del modelo
𝑥 La entrada del modelo
𝑦 las etiquetas asociadas con 𝑥
𝐽(𝜃, 𝑥 , 𝑦) Sería el costo usado para entrenar la red neuronal.
Paso 3: Observación del porcentaje de precisión

Finalizado el proceso de generación de ataques adversarios con el conjunto de prueba, se procede a
observar los respectivos porcentajes de precisión del modelo. En este caso se realiza una
comparación de precisión de los modelos atacados y no atacados, de igual forma se muestran los
efectos que tiene la variación del valor de épsilon sobre el ruido agregado a las imágenes de entrada
y el porcentaje de error estimado.
Paso 4: Comparación de robustez en los tres modelos de aprendizaje profundo

Todo el proceso de entrenamiento y prueba tanto en redes atacadas y no atacadas, se realiza en los
tres modelos de aprendizaje profundo, realizando 10 repeticiones de entrenamiento por cada modelo
para observar la variación de cada uno de estos. Finalmente, con estos resultados se podrá visualizar
en que porcentaje estas redes pueden ser vulnerables ante la generación de imágenes adversarias
mediante el uso de FGSM el cual es un método rápido pero poderoso para atacar redes neuronales
artificiales.
A continuación se muestra un diagrama en donde se resumen los pasos anteriormente descritos
Figura 28 Diagrama de metodología de verificación de robustez ante ataques adversarios a los

tres modelos de aprendizaje profundo
Fuente: Autor
55
5. RESULTADOS Y DISCUSIÓN
A continuación se muestran los resultados obtenidos después de usar los métodos y estrategias
descritos en el capítulo anterior. Estos resultados se dividen en 6 secciones, las cuales son
distribuidas de la siguiente manera:
 Resultados para combatir el sobreajuste con red construida mediante la adición de capas
 Resultados para combatir el sobreajuste con transferencia de aprendizaje de la red Inception V3
 Resultados para combatir el sobreajuste con transferencia de aprendizaje de la red
InceptionResNet v2
 Análisis de robustez de en red entrenada desde 0
 Análisis de robustez de la red con transferencia de aprendizaje Inception v3
 Análisis de robustez de la red con transferencia de aprendizaje InceptionResNet v2
5.1 COMPARACIÓN DE MODELOS CON DIFERENTES

HIPERPARÁMETROS PARA ELABORACIÓN DE RED DESDE
CERO
Para lograr formar un modelo con el cual se realice un entrenamiento desde cero, se optó por hacer
una serie de pruebas variando distintos hiperparámetros como se explica en la sección de
metodología “criterios de elección de características de la red”, en esta sección se muestra de
manera comparativa los resultados obtenidos en el porcentaje de precisión y distancia de error en
los conjuntos de entrenamiento y validación con el fin de escoger el modelo que muestre una mejor
capacidad de generalizar.
A continuación se muestran los resultados unificados variando diferentes hiperparámetros más
usados en la actualidad:
5.1.1 Optimizador como criterio de elección
Con el fin de poder observar diferentes modelos con diferentes optimizadores se realiza el
entrenamiento de los modelos con optimizadores Adagrad, Adam, SGD y RMSProp.
En las Figuras 29 y 30 se muestran los resultados de precisión y perdida utilizando el modelo con 3
capas convolucionales, seguidas de capas de MaxPooling, función de activación LeakyReLU, y
función de perdida entropía cruzada. Cabe resaltar que se dejaron estos hiperparámetros con el fin
de observar solamente el cambio de comportamiento del modelo cuando solo se varía el
optimizador.
Al observar los resultados se tiene en cuenta que con la base de datos de hojas de caña de azúcar
enfermas y sanas, solo se podría dejar de lado el optimizador de descenso de gradiente estocástico,
debido a que las perdidas decrecen más lentamente con respecto a los otros optimizadores, esto
conlleva una mayor cantidad de épocas y por ende el tiempo necesario para que el modelo pueda
alcanzar a predecir las imágenes con un porcentaje aceptable.
Los demás optimizadores como ADAM, RMSProp y Adagrad presentan buenos comportamientos
de predicción, teniendo un porcentaje de precisión alrededor del 90% y una pérdida muy pequeña
alrededor de la época 20.
El optimizador ADAM a comparación de RMSProp y Adagrad es un poco más lento en disminuir
las pérdidas, sin embargo llega a tener un valor de perdida aproximado alrededor de la época 15 por
lo cual cualquiera de estos tres optimizadores puede ser escogido para la elección del modelo final.
56
Figura 29. Precisión del modelo con el conjunto de entrenamiento con diferentes optimizadores
Fuente: Autor
Figura 30. Pérdidas con el conjunto de entrenamiento con diferentes optimizadores

Fuente: Autor
5.1.2 Función de activación como criterio de elección:

Las funciones de activación tendrán el propósito de brindarle no linealidad al sistema de máquina
de aprendizaje con el fin de dar mayor flexibilidad. Con la observación de modelos de aprendizaje
profundo se muestra a continuación una comparativa en el rendimiento y perdida del modelo bajo
tres funciones de activación como lo son Sigmoide, ReLU y LeakyReLU.
Las Figuras 31 y 32 muestran los resultados de realizar el entrenamiento con 3 diferentes funciones
de activación, en donde se observa que tanto ReLU como LeakyReLU presentan comportamientos
satisfactorios, logrando minimizar el error y obtener alta precisión. Esto concuerda con la teoría
estudiada en donde se justifica el hecho de utilizar a ReLU o alguna de sus variantes como función
de activación en redes neuronales profundas
57
Figura 31. Precisión con el conjunto de entrenamiento con distintas funciones de activación
Fuente: Autor
Figura 32. Pérdida con el conjunto de entrenamiento con distintas funciones de activación
Fuente: Autor
Finalmente, se escoge la función de activación LeakyReLU, la cual seguirá siendo utilizada para las
siguientes series de entrenamientos debido a su principal beneficio el cual es una pequeña pendiente
para valores negativos de entrada, proporcionando un valor de gradiente pequeño, lo cual permite
que no muera la activación neuronal durante el entrenamiento.
5.1.3 Adición de capas de abandono y regularización L1, L2 como criterio de

elección
Seguido a esto se muestran algunas pruebas en donde se observa la utilización de regularizadores
como el dropout y la regularización L1 y L2, esto con el fin de observar si es necesario agregar
estos tipos de regularizadores y con qué tipo de combinaciones, es decir se hace una comparación
de entrenamientos en donde se tendrán los siguientes modelos:
58
 Dropout (Adam): modelo con abandono, sin regularización L1 o L2 con optimizador
Adam
 Without regularization (Adam): modelo sin abandono y sin regularización L1 o L2 con
optimizador Adam
 L2 Regularizer (Adam): modelo solo con regularizador L2, con optimizador Adam
 Dropout and L2 regularizer (Adam): modelo con abandono y regularizador L2, con
optimizador Adam
 Without regularization (Adagrad): modelo sin abandono y sin regularización L1 o L2
con optimizador Adagrad
Figura 33. Precisión con el conjunto de entrenamiento con distintas variantes de regularización,
entre paréntesis está el método de optimización que se usó
Fuente: Autor
Figura 34. Pérdida con el conjunto de entrenamiento con distintas variantes de regularización
Entre paréntesis está el método de optimización que se usó
Fuente: Autor
59
Figura 35. Precisión de entreno y validación con solo el regularizador L1 y optimizador Adam
Fuente: Autor
La Figura 35 muestra la precisión cuando solo se usa regularización L1, este muestra un deficiente
comportamiento de aprendizaje, llegando solamente a un 50% de precisión sin estabilizarse a los
largo de 20 épocas, de esta manera se escoge la regularización L2, con la cual se puede ver mejores
resultados debido a que no se eliminan completamente ponderaciones de los pesos con valores no
frecuentes.
Las Figuras 33 y 34 muestran la precisión y pérdidas de entrenamiento a partir de los datos de
entrenamiento, como se describió anteriormente, se realiza el proceso de aprendizaje con 5
modelos, se escoge en 4 de estos modelos como método de optimización fijo a ADAM y uno de
ellos se realiza con Adagrad para observar si se presenta alguna diferencia marcada entre estos dos
optimizadores, la cual si se pudo registrar, siendo el peor comportamiento el presentado por el
modelo con optimizador Adagrad y sin ninguna regularización.
De igual manera se puede observar que se tiene una mayor precisión con el modelo con optimizador
Adam que no tiene ninguna regularización, sin embargo cuando se observa la gráfica con el
conjunto de datos de validación se observa una menor fluctuación en el modelo que se utilizaron las
regularizaciones de abandono y L2.
(a) Pérdidas con modelo sin regularización (b) Pérdidas con modelo con regularización
Figura 36. Diferencia entre perdidas de modelo sin regularización y con regularización
Fuente: Autor
60
La Figura 36 (a) muestra las pérdidas del modelo sin aplicar ningún método de regularización y la
Figura 36 (b) muestra las pérdidas del modelo con regularización L2 y abandono, estos dos modelos
obtuvieron altos porcentajes de precisión, por lo cual el criterio de selección se realiza con la
observación de pérdidas con el conjunto de datos de validación, lo cual muestra qué modelo es
capaz de mostrar una mejor generalización del aprendizaje. De esta manera se encontró que se
reduce el sobreajuste con la utilización del abandono y la regularización L2 trabajando juntamente.
De esta manera, se establece que el modelo con función de activación LeakyReLU, con abandono y
regularización L2 es el mejor modelo debido a su alto porcentaje de precisión, bajas pérdidas y
coherencia con el entrenamiento con el conjunto de datos de validación.
En la siguiente sección se muestran los resultados obtenidos paso a paso del modelo de red neuronal
elegido.
5.2 PROCESO DE FORMACIÓN DE RED NEURONAL ELEGIDA

CON CRITERIOS DE SELECCIÓN
Una vez seleccionado el mejor modelo, se muestra paso a paso la forma en la cual se logra entrenar
el modelo con el conjunto de datos recolectado. Inicialmente se explora la factibilidad de usar el
entrenamiento desde 0. Para comenzar se indica la manera de obtención de los datos y su
preparación antes del entrenamiento.
Figura 37. Lectura de conjunto de datos almacenado en el disco C

Fuente: Autor
Se puede observar en la Figura 37 los directorios que se leyeron que en total son dos (debido a las
dos clases que se van a clasificar) y el número de imágenes que se tienen por carpeta que son de
4920 para sanas y 4920 para imágenes con la enfermedad de roya, formando así un total de
imágenes recolectadas de 9840. El paso siguiente es el de etiquetamiento de las imágenes. Para
lograr un aprendizaje supervisado, se etiquetan las imágenes con roya con el valor de ‘0’ y las
imágenes sanas con el valor de ‘1’
61
Figura 38. Muestra de imagen sana y enferma con sus respectivas etiquetas
Fuente. Autor
En la Figura 38 se presenta un ejemplo de cómo etiqueta el programa realizado en Python. En esta
figura se muestra un ejemplo de hoja con la enfermedad de roya la cual se etiqueta con el número 0,
mientras que la etiqueta de las imágenes sanas son representadas por la etiqueta 1.
La partición de los datos se hace de la siguiente manera:
Figura 39. Número de los diferentes conjuntos de datos para el entrenamiento de la red
Fuente: Autor
En la Figura 39 se muestra el número de imágenes utilizadas para el entrenamiento, como también
para validación y prueba, teniendo un total de 80% para entrenamiento y un 10% tanto para
validación y prueba. Se eligieron estos valores con el fin de que la red tenga un número
significativo de imágenes con las cuales pueda aprender mejor.
En la imagen se muestra el número y las dimensiones de los datos. Se puede observar que las
imágenes tienen un tamaño de 100 x 100 y una profundidad de color de 3, siendo los planos de
color (rojo, verde, azul), de igual forma se puede visualizar que se realizó una conversión de
etiqueta de valor entero a un valor denominado one-hot siendo esta la codificación de las etiquetas
en donde se tiene un valor de codificación de [0. 1.] para la etiqueta 0 y un valor de codificación [1.
0.] para la etiqueta 1. Muchos algoritmos de aprendizaje profundo son incapaces de trabajar con
datos categóricos, por ende se hace este tipo de codificación.
El paso siguiente fue el de formar la red mediante la adición de capas que permitieran realizar la
extracción de características automáticamente mediante el uso de capas de convolución y reducción.
62
La red se forma con la adición de 17 capas en donde se tiene el fin de evitar el sobreajuste, además
de tener un alto porcentaje de acierto en la predicción de los datos y un error pequeño. Las capas
empleadas en este proyecto se presentaron en la Figura 22.
A partir de aquí se muestra un trabajo en donde se combinan criterios de aprendizaje y
experimentación, debido a que en el proceso de visión por computador importa mucho las
características de la base de datos con la que se cuente.
5.2.1 Efecto de tamaño de lote en proceso de aprendizaje
Según las conclusiones del documento [29], el tamaño de imágenes que se pasan a la red en cada
iteración tiene un gran impacto en los resultados de aprendizaje. Escoger un lote pequeño permite
obtener un mejor rendimiento de aprendizaje, sin embargo la única deficiencia es la no
convergencia a óptimos globales (menor error). De esta manera, en este proyecto se procede a
realizar una serie de pruebas en donde se busca establecer un tamaño de lote en donde se presente
un equilibrio entre estos aspectos. El tamaño de lote se realiza solo teniendo en cuenta los divisores
del conjunto de datos que se entrenarán, para que se pase un número exacto de imágenes en cada
iteración. Se probaron con 5 divisores de 7872 que fue el total de datos para el entrenamiento que
representa el 80% del total recolectado.
Antes de mostrar los resultados proporcionados al entrenar la red, es importante dar a conocer las
principales características con las cuales se mostraron los mejores resultados en comparación con
los otros modelos probados, la Tabla 9 muestra las características de la red entrenada desde 0
elegida.
Tabla 9. Principales características de la red entrenada desde 0
CARACTERÍSTICA DESCRIPCIÓN
Tamaño de la imagen 100 x 100 x 3
Total de imágenes 9840
Numero de clases 2
Porcentaje de datos de entrenamiento 80%
Porcentaje de datos de prueba 10%
Porcentaje de validación 10%
Tamaño del lote por iteración 82
Número de épocas 20
Función de activación LeakyReLU
Capas de abandono añadidas Si
Capas de reducción MaxPooling
Parada temprana Si
Puntos de control Si
Número de parámetros 2’862.530
Números de parámetros entrenados 2’862.530
Función de pérdida Entropía cruzada
Optimizador ADAM
Tipo de entrenamiento Keras model.fit()
Número de bloques de trabajo (capas) 17
Número de capas congeladas 0
63
En el proceso de probar cual sería el tamaño de lote a escoger, se probarían varias opciones,
teniendo como indicador la similitud de datos de validación y entrenamiento. Dichas pruebas fueron
realizadas sobre la primera época y teniendo como base de partida una red pre-entrenada como
Inception ResNet v2. Dichas pruebas arrojaron los resultados mostrados en la Tabla 10.
Tabla 10. Prueba para establecer el tamaño de lotes después de la primera época en red neuronal
InceptionResNet v2.
Tamaño de lote Pérdida Rendimiento de Pérdida de Rendimiento de

entrenamiento validación validación (%)
(%)
41 0.33 86.65 1.15 70.22
64 0.32 87.11 0.53 79.57
82 0.31 90.62 0.43 81.81
164 0.35 89.99 1.33 73.03
656 0.46 85.25 4.73 61.69
De acuerdo a las pruebas obtenidas experimentalmente se escoge trabajar con un tamaño de lote de
82. Se escogió una red como lo es InceptionResNet v2 para hacer esta prueba. Con las demás redes
se tenía un comportamiento similar.
De acuerdo a la tabla anterior, al usar un tamaño de lote de 82, se tiene un mayor rendimiento de
entrenamiento y se experimenta un mejor sobreajuste que con los demás lotes.
Antes de proceder con el entrenamiento, se muestra la configuración para establecer puntos de
control y parada temprana, como se muestra en las siguientes secciones.
5.2.2 Efecto de usar capas de abandono
Para conocer si el adicionar capas de abandono resulta ser bueno, se muestran los resultados de una
sesión de entrenamiento sin la adición de capas de abandono y luego se las agrega. Las diferencias
se muestran así:
a) Red neuronal sin agregar capas de abandono:
Las Figuras 40 y 41 representan la pérdida y rendimiento del conjunto de entrenamiento y
validación. Estas figuras muestran un comportamiento de sobreajuste. Si bien, el rendimiento de
entrenamiento alcanza el 100%, tiene fluctuaciones al igual que el rendimiento de validación, el
cual llega a un rendimiento de 95% en la época 8, sin embargo, decae a 85% en la etapa 15, lo cual
es una muestra clara que no se lleva un aprendizaje correcto. En la Figura de pérdida (Figura 41) se
puede observar el sobreajuste en los puntos en los que la pérdida no decrece sino que aumenta
desmedidamente en época 5 y a partir de la época 10.
64
Figura 40. Rendimiento de entreno y validación de la red sin agregar capas de abandono
Fuente: Autor
Figura 41. Pérdida de entreno y validación sin agregar capas de abandono

Fuente: Autor
b) Red neuronal agregando capas de abandono (dropout):

Las capas de abandono se introdujeron en la red neuronal en seguida de capas de convolución,
activación y anterior a la capa final de softmax.
Es importante resaltar que para esta red se utilizó la activación LeakyReLU, si bien la más utilizada
a nivel mundial en redes neuronales es la función de activación ReLU, esta función de activación
tiene el problema de llevar todos los valores negativos a 0, lo cual disminuye la capacidad del
modelo para ajustarse o entrenarse con los datos correctamente [35]. Por tal razón, se usa la función
LeakyReLU (ReLU con fugas) la cual soluciona el problema de ReLU dando una salida a los
valores negativos mediante la función f (y)=ay donde a tiene un valor de 0.01 o menor [35].
65
La optimización usada en estas redes fue el modelo adaptativo “ADAM” con el cual se tienen
mejores resultados con respecto a los demás optimizadores. El entrenamiento se realiza durante 20
épocas y un tamaño de lote de 82 imágenes por iteración.
Figura 42. Rendimiento de entrenamiento y validación al agregar capas de abandono

Fuente: Autor
Como se puede observar en la Figura 42, la adición de abandono permite mejorar el rendimiento en
validación, en este caso tan solo se produjo un descenso en la época 5, y para las demás épocas se
presentó un buen comportamiento en el aprendizaje de la red
Figura 43. Pérdida en conjunto de datos de entreno y validación con capas de abandono añadidas
Fuente: Autor
En este caso, la adición de capas de abandono mejoró el entrenamiento y solventaron el problema

de sobreajuste que se mostraba con la red sin abandono. Los resultados de pérdida (Figura 43)
pueden mejorar con la adición de capas de regularización, la cual permite ingresar penalizaciones a
las ponderaciones con valores muy grandes.
66
c) Red neuronal añadiendo capas de abandono y regularización:
Se demostró anteriormente que las capas de abandono son herramientas útiles para combatir el
sobreajuste, sin embargo se puede mejorar el proceso de generalización y uno de ellos es la
regularización. Para este caso se usará la regularización L2, mostrando mejores resultados que la
regularización L1 para este conjunto de datos. Con la regularización L1, el error mostró valores
muy grandes del orden de los cientos lo cual muestra un error excesivo. Los resultados de añadir
regularización y capas de abandono se presentan en las Figuras 44 y 45.
Figura 44. Rendimiento de entrenamiento con conjunto de datos de validación y entrenamiento con
adición de abandono y regularización L2
Fuente: Autor
Figura 45. Pérdida del conjunto de entrenamiento y validación con regularización L2 añadida
Fuente: Autor
67
Con la regularización L2 se presenta un buen comportamiento de aprendizaje. Solamente en la
época 12 se presenta una disminución en el rendimiento pero no es muy significativo. En las demás
épocas, se muestra un rendimiento muy cercano al de entrenamiento, el cual asciende
progresivamente, muestra de un buen ajuste de los datos.
El efecto de la regularización L2 disminuye el error en la búsqueda del óptimo global. Como se
muestra en la figura de pérdida, se presenta un comportamiento similar entre la pérdida de
entrenamiento y validación, lo cual es lo ideal en el proceso de aprendizaje.
Figura 46. Resultado de rendimiento y pérdida en época 20

Fuente: Autor
En la Figura 46 Se puede observar un mensaje al finalizar el entrenamiento en donde se informa que
dicho modelo fue guardado por ser el mejor puntaje durante todo el entrenamiento. Este es el efecto
de ingresar el parámetro llamado Checkpoint en el ajuste de datos.
Tabla 11. Rendimiento y pérdida del conjunto de entrenamiento y conjunto de validación del
modelo con dropout
Pérdidas con el Rendimiento Pérdidas con el Rendimiento
conjunto de de la red con el conjunto de de la red con el
Época entrenamiento conjunto de validación conjunto de
(error) entrenamiento (error) validación
(%) (%)
1 3.7436 51.50 2.6028 50.81
2 2.2239 66.83 1.8126 77.64
3 1.6108 80.18 1.4932 77.03
4 1.2743 83.28 1.2260 80.59
5 1.0855 84.32 1.0140 85.47
6 0.9543 85.05 0.9355 83.43
7 0.8529 85.57 0.8563 84.55
8 0.7684 85.99 0.7690 85.77
9 0.7116 86.47 0.7011 87.50
10 0.6531 87.46 0.6683 87.09
11 0.6013 87.98 0.6191 88.82
12 0.5688 88.77 0.5878 86.89
13 0.5428 88.95 0.5901 84.55
14 0.5076 89.19 0.5808 84.35
15 0.4900 89.57 0.5007 88.31
16 0.4617 90.08 0.4588 89.53
17 0.4533 89.52 0.4568 90.75
18 0.4256 90.41 0.4363 89.43
19 0.4077 90.98 0.4229 89.63
20 0.3953 90.83 0.4012 91.26
68
En la Tabla 11 se muestra todo el historial de entrenamiento de validación y capacitación de la red,
en donde se muestran los resultados obtenidos desde la primera época hasta la 20, en donde se
muestra una buena generalización de datos y un buen comportamiento de aprendizaje. Este proceso
no tuvo ninguna parada temprana debido a tener un buen comportamiento de validación de datos. El
mejor rendimiento de validación fue el registrado en la época final (época 20) el cual se terminaría
guardando su actualización de pesos.
Figura 47. Pérdida y rendimiento de la red con el conjunto de prueba

Fuente: Autor
En la Figura 47 se muestra el resultado de pérdida y rendimiento con los datos de prueba, en donde
tiene el mismo valor del último dato de validación con un error de 0.4 y un rendimiento del 91%, el
rendimiento de entrenamiento tuvo un rendimiento de 91% con un error de 0.39.
Una vez finalizado el proceso de entrenamiento, se puede guardar el modelo con el fin de utilizarlo
para el problema de clasificación de imagen del cultivo de caña de azúcar con o sin roya.
Al ingresar una nueva imagen la red es capaz de mostrar su clasificación, elegirá “0” para la clase
de hojas enfermas con la roya, y elegirá “1” para la clasificación realizada a imágenes sanas. Un
ejemplo de ello se puede mostrar en la Figura 48.
Figura 48. Predicción realizada por la red mediante la adición de una nueva imagen afectada por
la roya
Fuente: Autor
69
Como se observa en la Figura 48, la predicción de la red es correcta y corresponde a un “0” el cual
dice mostrar ser de una imagen de caña de azúcar afectada por la roya.
En el conjunto de datos de prueba, como se había mostrado anteriormente, se tuvo un rendimiento
de 91.26% en donde se realiza la predicción con estos conjuntos de datos y se muestra el resultado
de la Figura 49.
Figura 49. Número de imágenes predichas con éxito y sin éxito por el modelo
Fuente: Autor
5.2.3 Medidas de dispersión de la red entrenada desde 0
En esta sección se hará énfasis en mostrar con mayor precisión los resultados del modelo
entrenado desde 0, utilizando la varianza y desviación estándar, siendo estos unos
indicadores estadísticos que determinan que tan dispersa puede llegar a estar la red en
cuanto al porcentaje de precisión con el conjunto de entrenamiento, validación y prueba.
Para poder mostrar estos cálculos fue necesario realizar una serie de entrenamientos. En
este caso, se realizaron 10 entrenamientos en donde no se cambiaron los hiperparámetros de
la red.
Los resultados de precisión y pérdida de los diferentes conjuntos de datos con media y
desviación estándar se pueden observar en la Tabla 12
Tabla 12. Valores de precisión y perdida con desviación estándar del modelo entrenado desde cero
Precisión de Precisión de Pérdidas de Precisión de Pérdidas de

Pérdidas de
entrenamiento validación validación prueba (%) prueba
entrenamiento
(%) (%)
91.590±0.335 0.290±0.031 92.640±1.392 0.280±0.043 91.720±1.200 0.290±0.040
Con los resultados obtenidos se puede afirmar que la red tiene un comportamiento de distribución
homogéneo en las diferentes precisiones lo cual es una muestra de confiabilidad para el modelo
entrenado desde 0.
70
5.3 RESULTADOS PARA COMBATIR EL SOBREAJUSTE CON
TRANSFERENCIA DE APRENDIZAJE DE LA RED INCEPTION
V3
El procedimiento con respecto a la red anterior es el mismo en las etapas iniciales del programa en
Python, en donde se recolectan los datos, se hace la partición de entrenamiento, prueba y
validación. Sin embargo, el procedimiento cambia en el momento de la obtención del modelo como
tal. Mientras que en la primera parte se daría la estructura de la red, en la transferencia de
aprendizaje se cargará la red ya entrenada con un conjunto de datos muy grande. Finalmente, lo que
se debe realizar es la transferencia de aprendizaje, es decir que la red tenga la capacidad de tener un
nuevo conjunto de datos con el que será capacitado y pueda clasificar las nuevas clases.
Ahora nuevamente se debe hacer esto pero con el mismo objetivo anterior: “evitar el sobreajuste”.
Las tácticas usadas están basadas en criterios generales de aprendizaje profundo. A pesar de esto,
gran parte del trabajo estuvo sometido a pruebas y experimentos en donde se deseaba encontrar un
buen equilibrio según la base de datos que se recolectó. Primeramente, se procede a mostrar en la
Tabla 13 las principales características de este modelo de red Inception v3.
Tabla 13. Principales características de la red entrenada mediante la transferencia de aprendizaje de
la red Inception V3
Numero de clases 2
Función de activación ReLU
Capas de reducción AveragePooling y MaxPooling
Parada temprana Si
Optimizador ADAM
Tipo de entrenamiento Keras model.fit_generator()
La transferencia de aprendizaje es un proceso en donde se congelan algunas capas si se desea, para

así no permitir que durante el proceso de entrenamiento se actualicen los pesos de las primeras
capas encargadas de la extracción de características simples. Por lo cual, para esta red se desea
71
actualizar solamente las capas finales e intermedias, dependiendo de la similitud que tengan los
datos con los datos pre-entrenados.
En el proceso de transferencia de aprendizaje debe tenerse en cuenta otro paso importante y es el de
eliminar las últimas dos capas del modelo original, que tienen como función la de clasificar de
acuerdo al número de clases obtenidas.
La red Inception v3 fue entrenada con el fin de clasificar 1000 imágenes de diferentes categorías.
Ahora, el proceso será la eliminación de las capas finales y la adición de nuevas capas de
clasificación que contenga como en este caso solo las dos clases que se necesitan.
Se desea agregar 3 capas densas con el fin de añadir junto con ellas la regularización L2 que resultó
ser muy importante para combatir el sobreajuste como se mostró en secciones anteriores. Las
últimas capas de la red se muestran distribuidas de la siguiente manera:
Global AVERAGE
POOLING
ABANDONO (50%)
CAPA DENSA(128 NERURONAS)

CON REGULARIZACIÓN L2
ABANDONO (50%)
CAPA DENSA (128 NEURONAS)

CON REGULARIZACIÓN L2
ABANDONO (50%)
CAPA DENSA (32 NEURONAS) CON

REGULARIZACIÓN
ABANDONO (50%)
CAPA DE SALIDA (ACTIVACIÓN

SOFTMAX, CON DOS CLASES)
Una vez realizada la concatenación del modelo base de Inception v3 y las nuevas capas añadidas se
procede a realizar el entrenamiento de la red. El proceso de entrenamiento inicialmente se realizó
con el comando model.fit, sin embargo se mostraron resultados no satisfactorios al observar las
72
gráficas de rendimiento y pérdida. A continuación se muestra un caso en donde ser realizó un
entrenamiento con 229 capas congeladas.
Figura 50. Rendimiento de validación y entrenamiento con 229 capas congeladas (izquierda),
pérdida de validación y entrenamiento con 229 capas congeladas (derecha)
Fuente: Autor
En la Figura 50 se muestran los resultados del entrenamiento por transferencia bajo el
congelamiento de 229 capas. Estos resultados muestran un comportamiento en donde se observa
que la red tiene un buen aprendizaje de entrenamiento, pero no de generalización, porque se puede
notar que existen muchas fluctuaciones en el rendimiento de validación alcanzando valores del 90%
en algunas épocas y regresa bruscamente al 80%, no estabilizándose en un valor. En la pérdida se
muestra un comportamiento desfavorable en donde el error aumenta y disminuye iterativamente
siendo este un síntoma de sobreajuste.
Dicho desde un principio, el entrenamiento de redes neuronales está sometido a la realización de
múltiples pruebas debido a la gran cantidad de parámetros que se deben tener en cuenta, uno de
ellos es el número correcto de capas que se deben congelar. En este proceso, se realizaron varios
entrenamientos con diferentes capas congeladas y se escogió aquel que tuviera una mejor
generalización de datos como se muestra en la Tabla 14.
Tabla 14. Prueba de congelamiento de capas
NÚMERO DE CAPAS CONGELADAS DESCRIPCIÓN DE ENTRENAMIENTO

DE VALIDACIÓN
160 No generaliza
216 Generaliza bien
229 No generaliza
258 No generaliza
294 No generaliza
Al observar que el modelo con diferentes entrenamientos realizados no generalizaba al tener un mal
comportamiento en el rendimiento de validación, se tomó la decisión de realizar un aumento en el
conjunto de datos mediante otra opción que ofrece la biblioteca de Keras, denominada
73
IMAGE.DATA_GENERATOR, la cual permite la multiplicación de los datos mediante la
generación de nuevas imágenes a partir de las imágenes con las que se entrena.
Con esta opción se tiene la generación de nuevas imágenes mediante recortes de la imagen, zoom,
desplazamiento vertical y horizontal, entre otros, realizándose este proceso de aumento en el mismo
momento que la red empieza a entrenarse.
La generación de datos se realizó mediante 5 métricas:
 Rango de rotación de 20° aleatoria
 Rango de zoom de 0.15 (significa que se elegirá un rango de zoom entre [0.85 -1.15])
aleatoriamente en donde acercara o alejara la imagen dependiendo del valor escogido.
 Rango de corte de cizallamiento es de 0.15 (ángulo de en sentido anti horario de 15°)
 Desplazamiento horizontal 0.2 (desplazamiento en un 20% en dirección horizontal)
 Desplazamiento vertical 0.2 (desplazamiento vertical en un 20% en dirección vertical)
Al aplicar este generador de datos y congelando las capas correctas que en este caso fue un total de
216 los resultados mejoraron como se muestra a continuación:
Figura 51. Rendimiento de entreno y validación con 216 capas congeladas (izquierda), pérdida de
rendimiento y validación con 216 capas congeladas (derecha)
Fuente: Autor
La Figura 51 muestra un mejor comportamiento en el rendimiento de validación de los datos, lo
cual significa una mejor generalización de aprendizaje. Esto pudo conseguirse mediante la
experimentación, congelando diferente número de capas y con la generación de imágenes, el cual
fue un recurso que permitió mejorar los resultados finales.
Durante el entrenamiento no se dio la parada temprana debido a que el rendimiento crecía y la
pérdida descendía gradualmente en cada época.
Figura 40. Rendimiento y pérdida con el conjunto de pruebas

Fuente: Autor
Figura 52. Pérdidas y precisión con el conjunto de prueba
Fuente: Autor
74
En el momento de realizar la prueba se obtuvo un 91.76% de rendimiento y 0.2820 de pérdida como
se muestra en la Figura 52.
Una vez guardado el modelo, se puede probarlo con cualquier imagen que contenga hojas de caña
de azúcar y así clasificarla.
Figura 53. Predicción realizada por la red con hoja de caña de azúcar sana
Fuente: Autor
Como se muestra en la Figura 53 se realiza con éxito la predicción de la hoja de caña sana
mostrando una probabilidad de 99.79%.
75
Tabla 15. Rendimiento y pérdida del conjunto de entrenamiento y validación con la transferencia
de aprendizaje Inception v3.
Pérdidas con el Rendimiento de la Pérdidas con el Rendimiento de la

conjunto de red con el conjunto conjunto de red con el conjunto
Época entrenamiento de entrenamiento validación de validación
(error) (%) (error) (%)
1 3.0602 51.04 1.9737 54.78
2 1.6391 57.57 1.2210 70.93
3 1.0227 85.75 0.7778 85.98
4 0.6842 91.03 0.6369 89.74
5 0.5446 93.01 0.5363 90.85
6 0.4826 94.14 0.5700 88.31
7 0.3741 95.35 0.3812 92.17
8 0.3507 95.58 0.4140 90.96
9 0.2820 96.21 0.3631 92.28
10 0.3001 96.07 0.3593 91.57
11 0.2891 96.00 0.3463 91.06
12 0.2172 97.09 0.3174 91.87
13 0.2067 96.61 0.2681 93.29
14 0.1711 96.93 0.2873 93.50
15 0.1647 97.35 0.2794 92.58
En la Tabla 15 se muestra los resultados correspondientes al rendimiento y pérdida de

entrenamiento y validación de la red por transferencia de aprendizaje en Inception v3, en donde se
puede apreciar que el modelo que tuvo el mejor resultado de rendimiento de validación fue el que se
muestra en la época 14. Este modelo fue el que finalmente se guardó usando los puntos de control.
5.3.1 Medidas de dispersión de la red con transferencia de aprendizaje Inception v3
Con una serie de 10 entrenamientos sin variación de hiperparámetros se obtienen los

resultados de media y desviación estándar de la precisión y pérdida de la red.
Los resultados con los diferentes conjuntos de datos se pueden observar en la Tabla 16
Tabla 16. Valores de precisión y pérdida con desviación estándar del modelo con transferencia de
aprendizaje Inception V3
Precisión de Precisión de Pérdidas de Precisión de Pérdidas de

Pérdidas de
entrenamiento validación validación prueba (%) prueba
entrenamiento
(%) (%)
97.530±0.878 0.140±0.015 91.910±2.485 0.330±0.084 92.070±2.975 0.330±0.338
76
5.4 RESULTADOS PARA COMBATIR EL SOBREAJUSTE CON
TRANSFERENCIA DE APRENDIZAJE DE LA RED
INCEPTIONRESNET V2
La siguiente red a transferir el aprendizaje es la llamada InceptionResNet v2, la cual es una

combinación entre redes Inception y redes residuales. Las características de la transferencia de
aprendizaje sobre esta red se resumen en la Tabla 17.
Tabla 17. Principales características de la red entrenada mediante transferencia de aprendizaje de la
red InceptionResNet v2
Numero de clases 2
Función de activación ReLU
Capas de reducción AveragePooling y MaxPooling
Parada temprana Si
Optimizador ADAM
Tipo de entrenamiento Keras model.fit_generator()
Para esta red se realiza la misma adición de capas finales para poder agregar regularización L2 y
capas de abandono.
Realizando nuevamente pruebas de congelamiento de 700, 768 y 777 capas, se encuentra que al
congelar 768 capas se muestran mejores resultados.
Los resultados obtenidos al congelar este número de capas se muestra en la Tabla 18.
77
Tabla 18. Resultados de pérdida y rendimiento de validación y entrenamiento con 768 capas
congeladas
Pérdidas con el Rendimiento Pérdidas con el Rendimiento

conjunto de de la red con el conjunto de de la red con el
Época entrenamiento conjunto de validación conjunto de
(error) entrenamiento (error) validación
(%) (%)
1 3.8479 61.59 2.6721 82.42
2 2.0829 75.03 1.4829 83.13
3 1.2370 81.59 0.9680 85.06
4 0.8473 84.21 0.6953 87.60
5 0.6496 85.06 0.5888 86.99
6 0.5200 86.12 0.5144 87.09
7 0.4547 87.03 0.4165 86.08
8 0.3951 88.11 0.3589 89.23
9 0.3723 88.19 0.3200 89.23
10 0.3506 88.07 0.2998 89.43
11 0.3121 88.95 0.2796 90.04
12 0.2965 89.57 0.2566 90.85
13 0.3070 88.19 0.2828 89.53
14 0.3037 88.77 0.2542 90.85
15 0.2916 89.53 0.2776 88.92
De acuerdo a los resultados de la tabla anterior con la acción de los puntos de control, el modelo se
guarda con los resultados obtenidos en la época número 12 la cual muestra el mejor porcentaje de
rendimiento de validación en donde se tiene un valor de rendimiento de entrenamiento de 89.57% y
un porcentaje de rendimiento de validación de 90.85%.
Los resultados de validación y pérdida en esta transferencia mostraron un buen comportamiento
finalmente al realizar la prueba de la red con datos no vistos tuvo el resultado de la Figura 54.
Figura 54. Rendimiento y pérdida de la red con el conjunto de prueba

Fuente: Autor
Finalizado el proceso de entrenamiento, las gráficas correspondientes al entrenamiento se muestran
de la Figura 5
78
Figura 55. Rendimiento de entrenamiento y validación con 768 capas congeladas (izquierda),
pérdida de rendimiento y validación con 768 capas congeladas (derecha)
Fuente: Autor
Finalmente, se muestra una demostración de predicción acertada que hace la red con el ingreso de
una imagen correspondiente a una hoja de caña de azúcar con roya como se muestra en la Figura 56
Figura 56. Predicción correcta de la red de transferencia de aprendizaje InceptionResNet v2 con

imagen de roya en caña de azúcar
Fuente: Autor
La predicción realizada por la red da como valor “0” debido a que le corresponde esa etiqueta al
conjunto de imágenes con roya, por tal razón fue una predicción acertada de la red.
79
5.4.1 Medidas de dispersión para la red InceptionResNet v2
Con una serie de 10 entrenamientos sin variación de hiperparámetros se obtienen los

resultados de media y desviación estándar de la precisión y pérdida de la red.
Los resultados con los diferentes conjuntos de datos se pueden observar en la Tabla 19
Tabla 19. Valores de precisión y pérdida con desviación estándar del modelo con transferencia de
aprendizaje InceptionResNet V3
Precisión de Precisión de
Pérdidas de Pérdidas de Precisión de Pérdidas de
entrenamiento validación
entrenamiento validación prueba (%) prueba
(%) (%)
89.685±0.317 0.290±0.004 87.876±1.763 0.343±0.042 87.701±1.407 0.358±0.030
5.5 COMPARACIÓN ENTRE MODELOS
Una vez finalizado el proceso de selección de los 3 mejores modelos, se puede observar su
rendimiento en las Figuras 57 y 58.
(a) Precisión con datos de entrenamiento (b) precisión con datos de validación
Figura 57. Comparación de precisión de red entrenada desde cero y redes con transferencia de
aprendizaje
Fuente: Autor
80
(a) Pérdida con datos de entrenamiento (b) Pérdida con datos de validación
Figura 58. Comparación de pérdidas entre redes entrenadas desde 0 y redes entrenadas con
transferencia de aprendizaje
Fuente: Autor
En cada uno de los modelos se obtuvieron resultados con respecto a la media aritmética y
desviación estándar de precisión de entrenamiento, validación y prueba con sus respectivas
pérdidas. Estos resultados se pueden ver unificados de la siguiente manera:
Tabla 20. Valores de precisión y pérdida con desviación estándar de los diferentes modelos de
aprendizaje profundo
Entreno Pérdidas Validación Pérdidas Prueba Pérdidas

Modelo
(%) Entreno (%) Validación (%) Prueba
Red desde 91.590± 0.290± 92.640± 0.280± 91.720± 0.290±
cero 0.335 0.031 1.392 0.043 1.200 0.040
Red
97.530± 0.140± 91.910± 0.330± 92.070± 0.330±
Inception
0.878 0.015 2.485 0.084 2.975 0.338
v3
Red
89.685± 0.290± 87.876± 0.343± 87.701± 0.358±
Inception
0.317 0.004 1.763 0.042 1.407 0.030
ResNet v2
Con respecto a la Tabla 20 todos los modelos muestran una desviación estándar pequeña,
verificando así que los resultados obtenidos a lo largo de cada uno de los 10 entrenamientos no son
muy dispersos con respecto a la media, sin embargo se puede resaltar que la red entrenada desde
cero y la red InceptionResNet v2 tienen menor dispersión con respecto a la red Inception v3.
81
Precisión de entrenamiento y validación
100,000%
97,530%
98,000%
96,000% 92,640%
Porcentaje de precisión
94,000%
91,910%
92,000% 91,590%
89,685%
90,000% 87,876%
88,000%
86,000%
84,000%
82,000%
80,000%
78,000%
RED DESDE CERO INCEPTION V3 INCEPTIONRESNET V2
Redes neuronales
PRECISIÓN DE ENTRENAMIENTO PRECISIÓN DE VALIDACIÓN
Figura 59. Valores de media de precisión de entrenamiento y validación para las 3 redes
neuronales
Fuente: Autor
Pérdidas de entrenamiento y validación

0,450
0,400
0,330 0,343
0,350
0,290 0,280 0,290
0,300
Pérdidas
0,250
0,200
0,140
0,150
0,100
0,050
0,000
RED DESDE CERO INCEPTION V3 INCEPTIONRESNET V2
Redes neuronales
PÉRDIDAS DE ENTRENAMIENTO PÉRDIDAS DE VALIDACIÓN
Figura 60. Valores de media de pérdidas de entrenamiento y validación para las 3 redes
Fuente: Autor
82
Las Figuras 59 y 60 muestran un mejor panorama de los datos de precisión y pérdidas de los 3
modelos de aprendizaje profundo analizados, a partir de las cuales se puede afirmar que la red con
mejor comportamiento, en cuanto a contrarrestar el sobreajuste, es la representada por el modelo
entrenado desde cero, debido a su similitud entre los valores de precisión y pérdida.
5.6 ROBUSTEZ ANTE LOS ATAQUES ADVERSARIOS
En esta sección se muestran resultados del ataque adversario que consisten en la

maximización de la función de coste mediante el proceso de optimización con ajuste del
gradiente que fue descrito en la Sección 4.8. Se escoge como muestra de imágenes del
conjunto de datos el conjunto de prueba para introducirles ruido. Se realiza la generación de
imágenes adversarias a los 3 modelos elegidos anteriormente.
5.6.1 Ataques adversarios mediante método de signo de gradiente rápido (FGSM)
El método del signo del gradiente rápido utiliza un valor pequeño llamado épsilon, el cual tiene la
función de limitar la adición de ruido en la generación de imágenes adversarias con el fin evitar que
dicha imagen no se vea evidentemente impostora.
A continuación se muestra el efecto que se tiene al usar diferentes valores de épsilon sobre algunas
imágenes originales en la precisión de la red entrenada desde cero.
Épsilon =0.2
Figura 61. Ataque adversario con método de signo de gradiente rápido a red desde cero con
épsilon = 0.2
En la Figura 61se observa la imagen original (izquierda), el ruido agregado por el método FGSM
(centro) y la imagen adversaria generada (derecha). También se muestran en la parte superior de la
imagen los resultados de pérdida y precisión con el conjunto de datos de prueba sin el ataque
83
adversario y luego con el ataque adversario. Este mismo procedimiento se realiza con los diferentes
valores de épsilon.
Épsilon=0.1
épsilon = 0.1
Épsilon=0.07
épsilon = 0.07
84
Épsilon =0.06
épsilon = 0.06
Épsilon =0.05
épsilon = 0.05
85
Épsilon =0.04
épsilon = 0.04
Épsilon = 0.03
épsilon = 0.03
86
Épsilon =0.02
épsilon = 0.02
Épsilon=0.01
épsilon = 0.01
Con los resultados obtenidos en las figuras se prueban diferentes valores de épsilon, apreciando que
a medida que aumenta el valor de épsilon, la precisión de la red disminuye, es decir muestra más
predicciones incorrectas en mayor porcentaje con pérdidas mayores, y esto es debido a que este
valor aumentará o disminuirá el ruido que se introduce a la imagen original. Sin embargo, es
importante en ataques adversarios que se pueda engañar la red en un alto porcentaje y que además
de esto el ruido de la imagen adversaria sea imperceptible para el humano. Mediante el anterior
87
criterio, se escoge 0.04 como valor de épsilon que cumple con estas dos características, en donde se
tiene un porcentaje alto de engaño y con pequeña visibilidad del ruido en la imagen adversaria.
5.6.2 Resultados de vulnerabilidad

En esta sección se incluirán los resultados que se presentaron al generar un conjunto de imágenes
adversarias a partir del conjunto de datos de prueba, siendo un total de 984 imágenes adversarias las
cuales fueron usadas para atacar cada uno de los modelos presentados anteriormente.
La Figuras 70, 71 y 72 presentan una pequeña muestra de 20 imágenes originales con sus ruidos e
imágenes adversarias efectuadas a la red entrenada desde cero, la red por transferencia de
aprendizaje Inception v3 y la red por transferencia de aprendizaje InceptionResNet respectivamente.
Estos resultados son presentados mediante un épsilon de 0,04 siendo este el mejor valor para
camuflar ataques adversarios con alta precision en este conjunto de imágenes como se demostró en
el apartado 5.6.1.
5.6.2.1 Red entrenada desde cero
Imágenes originales Ruido
88
Imágenes adversarias
Figura 70. Muestra de los primeros 20 ataques adversarios realizados a la red entrenada desde
cero con épsilon = 0.04
Fuente: Autor
5.6.2.2 Red con transferencia de aprendizaje Inception v3
a. Imágenes originales b. Ruido
89
c. Imágenes adversarias
Figura 71. Muestra de los primeros 20 ataques adversarios realizados a la red con transferencia
de aprendizaje Inception v3 con épsilon = 0.04
Fuente: Autor
5.6.2.3 Red con transferencia de aprendizaje InceptionResNet v2
Imágenes originales Ruido
90
Imágenes adversarias
Figura 72. Muestra de los primeros 20 ataques adversarios realizados a la red con transferencia
de aprendizaje InceptionResNet v2 con épsilon = 0.04
Fuente: Autor
Tabla 21. Resultados de entrenamiento con imágenes con ataque y sin ataque adversario a las 3
redes neuronales
Precisión de Pérdida de Precisión con Pérdida con

Modelo prueba sin prueba sin ataques ataques
ataque (%) ataque adversarios (%) adversarios
Red desde cero 87,623±2,685 0,264±0,053 9,948±1,768 4,502±0,3737
Inception v3 97.185±2.073 0.083±0.055 66.635±5.000 1.167±0.271
InceptionResNet
97.134±1.058 0.090±0.039 57.348±7.697 1.790±0.647
v2
La tabla 21 muestra un alto porcentaje de precisión en las redes por transferencia de aprendizaje y
perdidas menores, en cuanto a la robustez se puede observar que las redes por transferencia de
aprendizaje tienen mayor robustez debido a el porcentaje de engaño en ellas fue de un 33,365%
para la red Inception v3 y de un 42,652% para la red InceptionResNet v2, mientras que la red
entrenada desde cero presentó un 90,052% de engaño siendo la más vulnerable.
91
Precisión con ataques y sin ataques adversarios
120,000%
97,185% 97,134%
100,000%
Porcentaje de precisión
87,623%
80,000%
66,635%
57,348%
60,000%
40,000%
20,000% 9,948%
0,000%
Red desde cero Inception v3 InceptionResNet v2
Redes neuronales
Precisión sin ataque Precisión con ataque
Figura 73. Diagrama de precisión de los tres modelos con ataques y sin ataques adversarios con
un épsilon =0.04
Fuente: Autor
Pérdidas con ataques y sin ataques adversarios

6,000
5,000 4,502
Valor de pérdidas
4,000
3,000
2,000 1,790
1,167
1,000
0,264 0,090
0,083
0,000
Red desde cero Inception v3 InceptionResNet v2
Redes neuronales
Pérdida sin ataque Pérdida con ataque
Figura 74. Diagrama de pérdidas de los tres modelos con ataques y sin ataques adversarios con un
épsilon =0.04
92
Fuente: Autor
Las Figuras 73 y 74 muestran los diagramas correspondientes a la precisión y pérdida de los 3
modelos con presencia y ausencia de ataques adversarios al conjunto de datos de prueba, se puede
visualizar que la red entrenada desde cero presentó una mayor vulnerabilidad a los ataques teniendo
un bajo porcentaje de precisión con una media de 9,984% y una pérdida grande, con un valor de
4,503. Los modelos por transferencia de aprendizaje presentaron una mayor robustez ante este tipo
de ataque adversario.
De acuerdo con [37], algunas especulaciones que causan los ejemplos adversarios tienen que ver
con la no linealidad de las redes neuronales y la regularización insuficiente. Estas especulaciones se
pueden verificar en estos resultados, en donde se tiene mayor vulnerabilidad en las redes con menor
cantidad de parámetros entrenables, en este caso el número de parámetros representa la cantidad de
pesos entrenables de cada red. A continuación se mostrara una tabla en donde se presenta la
comparación de las tres redes neuronales con respecto a su precisión con los ataques adversarios y
su cantidad de parámetros.
Tabla 24. Comparación de cantidad de parámetros de los modelos con su precisión con ataques
CANTIDAD DE PRECISIÓN DE LA
CANTIDAD DE
MODELO PARÁMETROS RED CON ATAQUE
PARÁMETROS
ENTRENABLES (%)
Red desde cero 2’862.530 2’862.530 9,948±1,768
Inception v3 22’085.762 13’906.658 66.635±5,000
InceptionResNet v2 54’554.178 4’919.618 57.348±7,697
La Tabla 24 muestra los datos de precisión con ataques adversarios y el número de parámetros
entrenables de cada uno de los modelos, donde se aprecia que el grado de complejidad influye en la
robustez de los modelos de aprendizaje profundo.
93
6. CONCLUSIONES
En este proyecto de grado se exploró la detección de roya en caña de azúcar por medio de técnicas
de aprendizaje profundo, partiendo dos enfoques: la construcción desde cero de una red y
empleando transferencia de aprendizaje. Ambos enfoques mostraron un buen desempeño, con un
porcentaje de rendimiento para el conjunto de validación superior al 90% en los tres tipos de
modelos, encontrándose los siguientes comportamientos durante el proceso de entrenamiento y
validación:
 La obtención de un modelo que se ajuste bien y pueda generalizar se ve sometido a la

aplicación de criterios como lo son: la adición de capas de abandono, regularización,
generación de nuevos datos a partir de los existentes, entre otros, además de realizar diferentes
ensayos, realizando diferentes cambios como lo es el número de parámetros de la red, número
de capas congeladas, tamaño de lote para las diferentes iteraciones, y numero de épocas a usar.
 A partir de las 820 imágenes que se recolectaron de cultivos de caña de azúcar se alcanzaron
un total de 9840 bajo el tratamiento de aumento de datos, permitiendo tener una base de datos
con la que las redes neuronales podrían aprender mejor las características de la enfermedad de
roya y de hojas sanas en caña de azúcar, los resultados de generalización mejoraron aún más
cuando se generaron imágenes con la función de Keras “ImageDataGenerator” en el
momento de realizar el entrenamiento por transferencia de aprendizaje.
 Con la búsqueda del modelo que tenga mejores resultados con el entrenamiento desde cero, se
encontró que el modelo que tiene como hiperparámetros el optimizador Adam con funciones
de activación LeakyReLU y regularizaciones como abandono y L2 propone los mejores
resultados tanto con el conjunto de datos de entrenamiento como con el de validación, al
utilizar abandono y regularización L2 juntamente se controla acertadamente el sobreajuste
desactivando neuronas en el proceso de entrenamiento, mejorando así la convergencia del
modelo y disminuyendo ponderaciones de pesos con L2 sin llevarlas a 0. Con la función de
activación LeakyReLU se obtiene una pendiente que evita que el aprendizaje se bloquee
debido al problema de ReLU muerto para valores negativos en donde el gradiente seria 0.
 El número de capas que se debían congelar para la red Inception v3 y la red InceptionResNet
v2 fue determinante para evitar tanto el sobre-ajuste como el sub-ajuste (la red no aprende por
falta de complejidad), en donde se realizaron diferentes entrenamientos con diferentes capas
congeladas y de esta manera se determinó el número de parámetros con los que la red tiene un
mejor comportamiento de entrenamiento y validación.
 En la transferencia de aprendizaje se realiza la adición de algunas capas densas con el fin de
utilizar la regularización L2 y capas de abandono las cuales son dos herramientas que
benefician el proceso de generalización. Estas dos herramientas no se encuentran agregadas por
defecto en estas arquitecturas de aprendizaje profundo.
 La adición de paradas tempranas en el proceso de entrenamiento es una buena práctica que se
debería usar en todos los entrenamientos de redes neuronales, con esto se puede dar por
finalizado un aprendizaje cuando se presente un incremento en el error de validación y así
poder tener un diagnóstico rápido para conocer si realmente el modelo generaliza bien.
Añadido a esto el uso de puntos de control, otra gran herramienta disponible en Keras, se
guardará únicamente el modelo con la época de mejor desempeño en el entrenamiento y
validación.
94
 Todos los resultados mostraron un alto rendimiento en entrenamiento y validación, como
también una pérdida pequeña. Con esto se adquieren 3 modelos que pueden ser reutilizados
para la clasificación de hojas de caña de azúcar sana o con roya, y permite establecer una base
para poder ampliar aún más el conjunto de datos e ingresar nuevas clases de enfermedades de
caña de azúcar.
 Comparando los 3 modelos, se tiene que la red neuronal entrenada desde cero presenta menor
diferencia en los datos de precisión y pérdidas entre el conjunto de entrenamiento y validación,
mostrando así que esta red presentó menor sobreajuste que las redes entrenadas por
transferencia de aprendizaje, esto fue debido a la menor cantidad de parámetros de la red
entrenada desde cero, lo cual permitió con mayor facilidad controlar el sobreajuste.
 La realización de diferentes entrenamientos con los mismos hiperparámetros permite tener los
cálculos de medidas de dispersión teniendo como variable la precisión, se puede notar que se
tienen modelos con valores de precisión concentrados a la media aritmética, debido a sus
valores de varianza y desviación estándar pequeños y cercanos a cero.
 La cantidad de parámetros es una causa determinante de vulnerabilidad ante ataques
adversarios, siendo la red entrenada desde cero la más afectada debido a su menor cantidad de
estos y por ende mayor linealidad debido a su menor número de neuronas y pesos, la red por
transferencia de aprendizaje InceptionResNet ocupa el segundo lugar, la cual por causa del
congelamiento de capas llega a tener menos parámetros entrenables que la red Inception v3, de
acuerdo a lo anterior se dice que la linealidad depende de la cantidad de parámetros entrenables
de la red y es además uno de los factores determinantes que se pueden ajustar con el fin de
obtener un modelo más robusto ante ataques adversarios
Como trabajo futuro se propone clasificar un mayor número de enfermedades de importancia

económica mediante la observación de investigaciones realizadas principalmente por CENICAÑA
y aumentar la base de datos con visitas a diferentes cultivos de caña de azúcar, y el apoyo de
sistemas de vuelo no tripulado (DRONES) para tener un mayor número de imágenes recolectadas y
observar el funcionamiento de la red con una base de datos mucho más extensa, finalmente anexo a
esto se puede observar el comportamiento de redes generativas adversarias (RGAs) o en inglés
(GANs) para evitar que se puedan engañar las redes neuronales mediante los ataques adversarios.
95
7. REFERENCIAS
[1] Juan Carlos Angel Sanchez, Marcela Cadavid Ordonez, Jorge Ignacio Victoria Kafure. (2010).
Presencia de roya naranja en el Valle del Cauca y estrategias para su manejo, recuperado el 14 de
noviembre de 2018, de
http://www.cenicana.org/pdf_privado/documentos_de_trabajo/doc_trabajo_715.pdf.
[2] Camilo Andrés Cacerez Florez, Dario Amaya Hurtado, Olga Lucia Ramos Sandoval. (2015).
Procesamiento de imágenes para el reconocimiento de daños causados por plagas en el cultivo de
Begonia Semperflorens link & Otto (flor de azúcar). Revista acta agronómica, 273-279.
[3] Carlos Quintero, Fernando Merchán, Aydeé Cornejo y Javier Sánchez Galán. (2017). uso de
redes neuronales convolucionales para el reconocimiento automático de imágenes de macro
invertebrados para el biomonitoreo participativo. KnE Engineering, 585-596.
[4] Jonas Rauber, Wieland Brendel, Matthias Bethge. (2018). Foolbox: A Python toolbox to
benchmark the robustness of machine learning models. https://arxiv.org/pdf/1707.04131v3.pdfF
[5] CENICAÑA. (2013). Roya café, recuperado el 14 de noviembre de 2018, de
http://www.cenicana.org/investigacion/variedades/sanidad_vegetal.php?opcion=1&opcion2=2.
Métodos de diferenciación en campo y laboratorio de los agentes causales de la roya café y roya
naranja en la caña de azúcar, recuperado el 14 de noviembre de 2018, de
http://www.cenicana.org/publicaciones/carta_trimestral/ct2010/ct3y4_10/ct3y4_10_p30-36.php.
Presencia de roya naranja en el rio del Valle del Cauca, recuperado el 14 de noviembre de 2018 de
http://www.cenicana.org/pdf_privado/carta_trimestral/ct2010/ct3y4_10/ct3y4_10_p24-29.pdf
[8] INFANTE, Danay; MARTINEZ, B; GONZALEZ, E y GONZALEZ, Noyma. (2010). Puccinia
kuehnii (KRÜGER) BUTLER Y Puccinia melanocephala H. SYDOW Y P. SYDOW. EN EL
CULTIVO DE LA CAÑA DE AZÚCAR. Revista de Protección Vegetal
versión impresa ISSN 1010-2752
Presencia de roya naranja en el rio del Valle del Cauca, recuperado el 14 de noviembre de 2018.
http://www.cenicana.org/pdf_privado/documentos_de_trabajo/doc_trabajo_715.pdf
[10] MathWorks, (2018). Redes neuronales convolucionales, recuperado el 18 de abril de 2019, de
https://la.mathworks.com/solutions/deep-learning/convolutional-neural-network.html
[11] Alex Krizhevsky, Ilya Sutskever, Geoffrey E. Hinton. (2010). ImageNet Classification with
Deep Convolutional Neural Networks. http://papers.nips.cc/paper/4824-imagenet-classification-
with-deep-convolutional-neural-networks.pdf
[12] Patricia Perez Corrales (2016). Inteligencia artificial puede ser fácilmente engañada.
Recuperado el 15 de abril de 2019 de https://www.tendencias21.net/La-inteligencia-artificial-puede-
ser-facilmente-enganada_a42368.html.
96
[13] Katie Matho (2018). Un vistazo dentro de las redes neuronales. Recuperado el 06 de abril de
2019, de https://ml4a.github.io/ml4a/es/looking_inside_neural_nets/.
[14] Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil
Ozair, Aaron Courville, Yoshua Bengio. (2014). Generative Adversarial Nets.
https://arxiv.org/pdf/1406.2661.pdf
[15] Sunita Nayak. (2018). Entendiendo a AlexNet. Recuperado el 23 de diciembre de 2018, de
https://www.learnopencv.com/understanding-alexnet/.
[16] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens. (2015). Rethinking the
Inception Architecture for Computer Vision. https://arxiv.org/pdf/1512.00567.pdf
[17] Bharath Raj (2018). Una guía simple para las versiones de Inception. Recuperado el 15 de abril
de 2019 de https://towardsdatascience.com/a-simple-guide-to-the-versions-of-the-inception-
network-7fc52b863202
[18] Siladittya Manna (2019). Building Inception-Resnet-V2 in Keras from scratch. Recuperado el
15 de abril de 2019 de https://medium.com/@mannasiladittya/building-inception-resnet-v2-in-
keras-from-scratch-a3546c4d93f0
http://www.image-net.org/papers/imagenet_cvpr09.pdf
[19] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li and Li Fei-Fei. (2009).ImageNet: A
Large-Scale Hierarchical Image Database.
http://www.image-net.org/papers/imagenet_cvpr09.pdf
[20] Chigozie Enyinna Nwankpa, Winifred Ijomah, Anthony Gachagan, and Stephen Marshall
(2018). Activation Functions: Comparison of Trends in Practice and Research for Deep Learning.
[21] Nitish Srivastava, Geoffrey Hinton hintoN, Alex Krizhevsky, Ilya Sutskever, Ruslan
Salakhutdinov. (2014). Dropout: A Simple Way to Prevent Neural Networks from Overfitting.
https://www.cs.toronto.edu/~hinton/absps/JMLRdropout.pdf
[22] Sebastián Ruder. (2017). An overview of gradient descent optimization algorithms∗.
[23] Matthew D. Zeiler. (2012). ADADELTA: AN ADAPTIVE LEARNING RATE METHOD.
[24] Anaconda-Navigator (2019). Recuperado el 15 de abril de 2019 de
https://anaconda.org/anaconda/anaconda-navigator
[25] Bharath Raj (2018). Aumento de datos. Recuperado el 20 de abril de 2019 de
https://medium.com/nanonets/how-to-use-deep-learning-when-you-have-limited-data-part-2-data-
augmentation-c26971dc8ced
[26] Rich Caruana, Steve Lawrence, Lee Giles. (2001). Overfitting in Neural Nets:
Backpropagation, Conjugate Gradient, and Early Stopping https://papers.nips.cc/paper/1895-
overfitting-in-neural-nets-backpropagation-conjugate-gradient-and-early-stopping.pdf
97
[27] VILLA G., Fernán A .; VELASQUEZ H., Juan D. y SANCHEZ S., Paola A. (2015). Control
de sobreajuste dentro de redes neuronales de correlación en cascada aplicadas a la predicción del
precio del contrato de electricidad. Rev. ing. univ. Medellín. 2015, vol.14, n.26, pp.161-176. ISSN
1692-3324.
[28] ZongBen, ZHANG Hai1, WANG Yao1, CHANG XiangYu1 & LIANG Yong. (2010). L1/2
regularization.
http://gr.xjtu.edu.cn/LiferayFCKeditor/UserFiles/File/L%200.5%20regularization.pdf
[29] Glosario sobre aprendizaje automático (2018). Regularizaciones L1 y L2. Recuperado el 14 de
abril de 2019 de https://developers.google.com/machine-learning/crash-course/glossary?hl=es-
419#L1_regularization
[30] CREATIVE COMMONS (2018). Diferencia l1 y l2. Recuperado el 18 de abril de 2019 de
https://developers.google.com/machine-learning/crash-course/regularization-for-sparsity/l1-
regularization?hl=es-419
[31] Kevin Shen (2018). Efecto de Batch Size sobre entrenamiento de redes neuronales.
Recuperado el 3 de febrero de 2019 de https://medium.com/mini-distill/effect-of-batch-size-on-
training-dynamics-21c14f7a716e
[32] Lutz Prechelt. (1997). Early Stopping | but when?. https://page.mi.fu-
berlin.de/prechelt/Biblio/stop_tricks1997.pdf
[33] Hayit Greenspan, Bram van Ginneken, Ronald M. Summers. (2016). Deep Learning in
Medical Imaging: Overview and Future Promise of an Exciting New Technique, revista IEEE
Transactions on Medical Imaging , pp: 1285 – 1298.
[34] Pedro Marcelino (2018). Transferencia de aprendizaje a partir de modelos pre-entrenados.
Recuperado el 5 de mayo de 2018 de https://towardsdatascience.com/transfer-learning-from-pre-
trained-models-f2393f124751
[35] Bing Xu , Naiyan Wang , Tianqi Chen , Mu Li. (2015). Evaluación empírica de activaciones
rectificadas en red convolucional, recuperado el 5 de mayo de 2018 de
https://arxiv.org/abs/1505.00853
[36] Fabian Eitel. (2017). Adversarial Attack on Semantic Segmentation in the Physical world
http://oa.upm.es/55875/1/TFM_FABIAN_EITEL.pdf
[37] Ian J. Goodfellow, Jonathon Shlens & Christian Szegedy. (2015). EXPLAINING AND
HARNESSING ADVERSARIAL EXAMPLES. https://arxiv.org/abs/1412.6572
8. ANEXOS
98
A continuación se muestran los programas realizados en lenguaje Python para dar cumplimiento a
los objetivos que se tenían previstos:
PROGRAMA DE RED NEURONAL DESDE 0:
import os #funciones de sistema operativo
import re # biblioteca con expresiones de cadenas
import matplotlib.pyplot as plt # para graficar
#%matplotlib inline
from sklearn.model_selection import train_test_split # partir datos de entreno y
test con sus porcentajes
from sklearn.metrics import classification_report # para clasificacion de datos
import keras # libreria que contiene a tensorflow
from keras.utils import to_categorical # permite la clasificacion por
categorias
from keras.models import Sequential,Input,Model # para creacion de red neuronal
en secuencia, con entradas y modelos
from keras.layers import Dense, Dropout, Flatten # capas densas, dropout,
flatten (capas llanas)
from keras.layers import Conv2D, MaxPooling2D #capas convolucionales,
maxpooling
from keras.layers.normalization import BatchNormalization # capas de
normalizacion
from keras.layers.advanced_activations import LeakyReLU # capa de activacion
leakyReLU
import numpy as np # IMPORTA NUMPY (PAQUETE FUNDAMENTAL PARA COMPUTACION
CIENTIFICA)
import math
import tensorflow as tf
import sqlite3
from keras.callbacks import EarlyStopping
from keras.callbacks import ModelCheckpoint
from keras import regularizers
from keras.constraints import unit_norm #restriccion de pesos, tiene el efecto de
que todos los pesos entrantes son pequeños
# se aplican a cada capa pero se aplican por nodo en cada capa, en general no se
utilizan en los sesgos sino en pesos
#normalizar los pesos para que la norma sea igual a 1 (es una buena practica)
from keras.constraints import max_norm
# establecera una restriccion de peso maxima a una capa convolucional
from keras.regularizers import l2
from keras.utils import plot_model
dirname = os.path.join(os.getcwd(), './datos_totales/100x100(total)') # obtiene

la ruta completa de los datos y une los datos (concatena imagenes)
imgpath = dirname + os.sep # ruta donde se encuantran las imagenes (c:user......)
separa los componentes de ruta (\\)
images = []
directories = []
dircount = []
prevRoot=''
cant=0
print("leyendo imagenes de ",imgpath)
#root son las subcarpetas que puedan existir

for root, dirnames, filenames in os.walk(imgpath): # genera nombres de los
archivos, produce una tupla de 3 .(dirpath, dirnames,
for filename in filenames:
99
if re.search("\.(jpg|JPG|JPEG|jpeg|png|bmp|tiff)$", filename):#busca
todos los archivos con esas extensiones
cant=cant+1 # cantidad de arvhivos que lee en cada subcarpeta
filepath = os.path.join(root, filename) #une los archivos que
encuentre en la carperta de turno
image = plt.imread(filepath) # lee los datos (imagenes)
images.append(image) # combina imagenes horizontalmente
b = "Leyendo..." + str(cant)
print (b, end="\r") # mostraria los elementos que leyo en cada
subcarpeta
if prevRoot !=root: # condicional (si la subcarpeta anterior es
diferente a la actual)
print(root) #imprime la subcarpeta actual y con el numero que
comience (arriba-abajo)(abajo-arriba)
prevRoot=root #actualiza la subcarperta que sera la previa
directories.append(root) # concatena las subcarpetas (numero de
carpetas existentes)
dircount.append(cant) # concatena el numero de imagenes que lee
(numero de imagenes en carpetas existentes)
cant=0
dircount.append(cant) # concatena el total de imagenes en dircount de los
subdirectorios
dircount = dircount[1:]
calibracion=len(directories)-1
dircount[calibracion]=dircount[calibracion]+1 #corregir el error de conteo
#dircount[0]=dircount[0]+1 ##corregir linea de codigo (quitar)
print('Directorios leidos:',len(directories)) #cantidad de directorios leidos
print("Imagenes en cada directorio", dircount) # imagenes presentes en cada
directorio
print('suma Total de imagenes en subdirs:',sum(dircount)) # suma las imagenes en
todos los subdirectorios
labels=[]
indice=0
#LEER ETIQUETAS USANDO EL TAMAÑO de dircount (subdirectorios)
for cantidad in dircount: # ira hasta el total de imagenes existentes en sus

subcarpetas [820 820]
for i in range(cantidad):
labels.append(indice)
indice=indice+1
print("Cantidad etiquetas creadas: ",len(labels)) # lee el total de etiquetas

que son el mismo numero de imagenes totales
estado_cultivo=[]
indice=0
for directorio in directories:

name = directorio.split(os.sep)
print(indice , name[len(name)-1])
estado_cultivo.append(name[len(name)-1])
indice=indice+1
y = np.array(labels) #etiquetas totales

X = np.array(images, dtype=np.uint8) #convierto de lista a numpy # imagenes
totales
# encuentro los unicos numeros de las etiquetas de entrenamiento del conjunto de

datos
100
classes = np.unique(y)
nClasses = len(classes)
print('Total number of outputs : ', nClasses)
print('Output classes : ', classes)
#mostrar la imagen ejemplo de imagen sana y enferma con su etiqueta

ri=0
plt.subplot(121)
plt.imshow(X[ri])
plt.title(" ETIQUETA :{}".format(y[ri]))
an=4921
plt.subplot(122)
plt.imshow(X[an])
plt.title(" ETIQUETA :{}".format(y[an]))
plt.tight_layout()
#Mezclar todo y crear los grupos de entrenamiento y testing

train_X,test_X,train_Y,test_Y = train_test_split(X,y,test_size=0.1)
print('TAMAÑO DE LOS DATOS DE ENTRENAMIENTO : ', train_X.shape, train_Y.shape)
print('TAMAÑO DE LOS DATOS DE PRUEBA: ', test_X.shape, test_Y.shape)
train_X = train_X.astype('float32', copy=False)

test_X = test_X.astype('float32', copy=False)
train_X = train_X / 255.
test_X = test_X / 255.
#cambia las etiquetas de categoria a codificacion one-hot

train_Y_one_hot = to_categorical(train_Y)
test_Y_one_hot = to_categorical(test_Y)
#muestra el cambio de etiqueta de categoria usando codificacion one-hot

print('ETIQUETA ORIGINAL:', train_Y[0])
print('DESPUES DE LA CONVERSION A one-hot:', train_Y_one_hot[0])
train_X,valid_X,train_label,valid_label = train_test_split(train_X,
train_Y_one_hot, test_size=0.1111, random_state=13)
#print(train_X.shape,valid_X.shape,train_label.shape,valid_label.shape)
print("")
print("el tamaño del conjunto de entrenamiento es:",train_X.shape)
print("el tamaño del conjunto de validacion es: ",valid_X.shape)
print("el tamaño del conjunto de etiquetas de entrenamiento
es:",train_label.shape)
print("el conjunto de etiquetas de validacion es: ",valid_label.shape)
batch_size = 82
epochs = 20
num_classes = 2
model = Sequential()
model.add(Conv2D(32, kernel_size=(3,
3),activation='linear',padding='same',input_shape=(100,100,3)))
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D((2, 2),padding='same'))
model.add(Dropout(1-0.75)) #capa de abandono introducida
model.add(Conv2D(64, (3, 3),
activation='linear',padding='same',kernel_regularizer=regularizers.l2(0.01)))
101
model.add(MaxPooling2D(pool_size=(2, 2),padding='same'))
model.add(Flatten()) #aplanar la salida de la capa conv de 4-dim a 2-dim
model.add(Dense(128,
activation='linear',kernel_regularizer=regularizers.l2(0.01)))
model.add(Dropout(0.25)) #capa de abandono introducida
model.add(Dense(num_classes, activation='softmax'))
es = EarlyStopping(monitor='val_loss',
mode='min', verbose=1,
patience=15)
mc = ModelCheckpoint('mejor_modelo.h5',
monitor='val_acc',
mode='max',
verbose=1, save_best_only=True)
model.summary()
#compilacion del modelo

model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),metrics=['accuracy'])
plot_model(model, to_file='modelo_optimizado.png')
train = model.fit(train_X, train_label,

batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X,
valid_label),callbacks=[es,mc])
test_eval = model.evaluate(test_X, test_Y_one_hot, verbose=1)#evaluacion del

modelo en el conjunto de prueba
print('Test loss:', test_eval[0])

print('Test accuracy:', test_eval[1])
#graficos de entreno y validacion
#DESEMPEÑO A LO LARGO DEL TIEMPO DURANTE EL ENTRENAMIENTO

accuracy = train_dropout.history['acc'] #RENDIMIENTO DE ENTRENO
val_accuracy = train_dropout.history['val_acc'] #RENDIMIENTO DE VALIDACION
loss = train_dropout.history['loss'] # PERDIDAS DE ENTRENAMIENTO
val_loss = train_dropout.history['val_loss'] #PERDIDAS DE VALIDACION
epochs = range(len(accuracy))
plt.plot(epochs, accuracy, 'b', label='Training accuracy')# GRAFICA EL

RENDIMIENTO Y MUESTRA SU LEYENDA
plt.plot(epochs, val_accuracy, 'g', label='Validation accuracy')# GRAFICA
RENDIMIENTO EN VALIDACION Y MUESTRA LEYENDA
plt.legend()
102
plt.title('Training and validation accuracy') #TITULO
plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')# GRAFICA LA PERDIDA DE ENTRENO
Y MUESTRA LEYENDA
plt.plot(epochs, val_loss, 'g', label='Validation loss')# GRAFICA PERDIDA DE
VALIDACION Y MUESTRA LEYENDA
plt.legend()
plt.title('Training and validation loss') #TITULO
plt.show()
#predecir etiquetaS
#Podemos predecir la clasificación de nuevas imágenes. Para ello, simplemente
usaremos
#algunas imágenes del conjunto de prueba, Cargar sus propias imágenes en matrices
numpy y usarlas.
predicted_classes = model.predict(test_X)
CÓDIGO PARA LA TRANSFERENCIA DE APRENDIZAJE DE INCEPTION V3:
from keras.applications.inception_v3 import InceptionV3

from keras.preprocessing import image
from keras.models import Model
from keras.layers import Dense, GlobalAveragePooling2D
from keras import backend as K
import pandas as pd
import numpy as np
import os
import keras
import matplotlib.pyplot as plt
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import Adam

#%matplotlib inline
categorias
from keras.models import Sequential,Input # para creacion de red neuronal en
secuencia, con entradas y modelos
maxpooling
normalizacion
leakyReLU
import math
from keras.callbacks import EarlyStopping

from keras.callbacks import ModelCheckpoint
103
from keras import regularizers
from keras.preprocessing.image import ImageDataGenerator
dirname = os.path.join(os.getcwd(), './datos_totales/100x100(total)') # obtiene

la ruta completa de los datos y une los datos (concatena imagenes)
images = []
directories = []
dircount = []
prevRoot=''
cant=0

subcarpeta
cant=0
subdirectorios
directorio
104
labels=[]
indice=0

indice=indice+1

estado_cultivo=[]
indice=0

indice=indice+1

totales

datos

train_X = train_X.astype('float32')
test_X = test_X.astype('float32')
#cambia las etiquetas de categoria a codificacion one-hot

train_Y_one_hot = to_categorical(train_Y)
test_Y_one_hot = to_categorical(test_Y)
#muestra el cambio de etiqueta de categoria usando codificacion one-hot

print('ETIQUETA ORIGINAL:', train_Y[0])
print('DESPUES DE LA CONVERSION A one-hot:', train_Y_one_hot[0])
train_X,valid_X,train_label,valid_label = train_test_split(train_X,
train_Y_one_hot, test_size=0.1111, random_state=13)
#print(train_X.shape,valid_X.shape,train_label.shape,valid_label.shape)
print("")
print("el tamaño del conjunto de entrenamiento es:",train_X.shape)
print("el tamaño del conjunto de validacion es: ",valid_X.shape)
105
print("el tamaño del conjunto de etiquetas de entrenamiento
es:",train_label.shape)
print("el conjunto de etiquetas de validacion es: ",valid_label.shape)
# crear la base del modelo pre-entrenado

base_model = InceptionV3(weights='imagenet', include_top=False)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x= Dropout(1-0.5)(x)
x=Dense(128, activation='relu',kernel_regularizer=regularizers.l2(0.01))(x)
x=Dropout(1-0.5)(x)
x=Dropout(1-0.5)(x)
x=Dropout(1-0.5)(x)
# let's add a fully-connected layer
predictions = Dense(2, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
# es es el modelo que se entrenara

model = Model(inputs=base_model.input, outputs=predictions)
# visualizamos el modelo
for i,layer in enumerate(model.layers):
print(i,layer.name)
model.summary()
# congelar capas
LAYERS_TO_FREEZE=216
for layer in model.layers[:LAYERS_TO_FREEZE]:
layer.trainable = False
for layer in model.layers[LAYERS_TO_FREEZE:]:

layer.trainable = True
# optimizador=keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999,

epsilon=None, decay=0.0, amsgrad=False) # lr por defecto 0.001
# model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=optimizador,metrics=['accuracy'])
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),metrics=['accuracy'])
106
# visualizamos el modelo
for i,layer in enumerate(model.layers):
print(i,layer.name)
model.summary()
plot_model(model, to_file='inceptionv3.png')
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3)

mc = ModelCheckpoint('mejor_modelo_inceptionv3.h5', monitor='val_acc',
mode='max', verbose=1, save_best_only=True)
batch_size = 82
epochs = 15
num_classes = 2
# train= model.fit(train_X, train_label,

batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X,
valid_label),callbacks=[es,mc])
# construct the training image generator for data augmentation

aug = ImageDataGenerator(rotation_range=20, zoom_range=0.15,
width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15,
horizontal_flip=False, fill_mode="nearest")
#shear_range: Intensidad de corte (ángulo de corte en sentido antihorario en
grados)
#zoom_range: flotante o [inferior, superior]. Rango para zoom aleatorio.
#width_shift_range: fracción del ancho total, si es <1, o píxeles si> = 1 -----
desplazamiento aleatoria horizontal
#height_shift_range: fracción de la altura total, si es <1, o píxeles si> = 1 ---
-- desplazamiento aleatorio vertical
#fill_mode: puede ser {"constant", "nearest", "reflect" or "wrap"}
#El valor predeterminado es 'más cercano'. Los puntos fuera de los límites de la
entrada se llenan de acuerdo con el modo dado:
#'constante': kkkkkkkk | abcd | kkkkkkkk (cval = k)
#'más cercano': aaaaaaaa | abcd | dddddddd
#'reflejar': abcddcba | abcd | dcbaabcd
#'wrap': abcdabcd | abcd | abcdabcd
# train the network

train= model.fit_generator(aug.flow(train_X, train_label, batch_size=batch_size),
validation_data=(valid_X, valid_label), steps_per_epoch=len(train_X) //
batch_size,
epochs=epochs,callbacks=[es,mc])
test_eval = model.evaluate(test_X, test_Y_one_hot, verbose=1)#evaluacion del

modelo en el conjunto de prueba
print('Test loss:', test_eval[0])
print('Test accuracy:', test_eval[1])
#graficos de entreno y validacion
#DESEMPEÑO A LO LARGO DEL TIEMPO DURANTE EL ENTRENAMIENTO

accuracy = train.history['acc'] #RENDIMIENTO DE ENTRENO
val_accuracy = train.history['val_acc'] #RENDIMIENTO DE VALIDACION
loss = train.history['loss'] # PERDIDAS DE ENTRENAMIENTO
val_loss = train.history['val_loss'] #PERDIDAS DE VALIDACION
epochs = range(len(accuracy))
plt.plot(epochs, accuracy, 'b', label='Training accuracy')# GRAFICA EL

RENDIMIENTO Y MUESTRA SU LEYENDA
107
plt.plot(epochs, val_accuracy, 'g', label='Validation accuracy')# GRAFICA
RENDIMIENTO EN VALIDACION Y MUESTRA LEYENDA
#plt.axis([0, 10, 0, 1])
plt.legend()
plt.title('Training and validation accuracy') #TITULO
plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')# GRAFICA LA PERDIDA DE ENTRENO
Y MUESTRA LEYENDA
plt.plot(epochs, val_loss, 'g', label='Validation loss')# GRAFICA PERDIDA DE
VALIDACION Y MUESTRA LEYENDA
#plt.axis([0, 10, 0, 3])
plt.legend()
plt.title('Training and validation loss') #TITULO
plt.show()
#guardar el historial de entrenamiento

import pickle
with open('/INCEPTION_V3_history', 'wb') as file_pi:
pickle.dump(train.history, file_pi)
#predecir etiquetaS
#Podemos predecir la clasificación de nuevas imágenes. Para ello, simplemente
usaremos
#algunas imágenes del conjunto de prueba, Cargar sus propias imágenes en matrices
numpy y usarlas.
predicted_classes = model.predict(test_X)
predicted_classes = np.argmax(np.round(predicted_classes),axis=1)
print("tamaño de clases predichas:",predicted_classes.shape)
print("tamaño de las etiquetas del conjunto de prueba:", test_Y.shape)# TAMAÑO DE
LAS PREDICCIONES Y LAS ETIQUETAS DEL CONJUNTO DE TEST
#Etiquetas correctas
correct = np.where(predicted_classes==test_Y)[0] #es un condicional que devuelve
los elemtos que son igulaes
print("se encontraron ", len(correct),"etiquetas correctas")
#etiquetas incorrectas
incorrect = np.where(predicted_classes!=test_Y)[0] # es un condicional que
devuelve los elementos que son desiguales
print("Se encontraron " ,len(incorrect)," muestras incorrectas")
CÓDIGO PARA VERIFICACIÓN DE ROBUSTEZ DE LAS REDES NEURONALES
# CODIGO PRINCIPAL
import keras
# from keras.datasets import mnist
import numpy as np
from scipy import misc
from models.CNN_5 import build_model

from utils.graphs import build_training_functions, build_attack_function

108
#%matplotlib inline
categorias
maxpooling
normalizacion
leakyReLU
import math
import sqlite3 #gestiona base de datos
from keras.callbacks import EarlyStopping # devolucion de llamada de parada
temprana
from keras.callbacks import ModelCheckpoint # devolucion de llamada de puntos de
control
from keras import regularizers # importa la funcion de regularizacion
# train_batch_size = 128
train_batch_size = 82
test_batch_size = 82
num_classes = 2
epochs = 20
image_shape = (100, 100, 3)
dirname = os.path.join(os.getcwd(), './100x100(total)') # obtiene la ruta

completa de los datos y une los datos (concatena imagenes)
images = []
directories = []
dircount = []
prevRoot=''
cant=0

109
subcarpeta
cant=0
subdirectorios
directorio
labels=[]
indice=0

indice=indice+1

estado_cultivo=[]
indice=0

indice=indice+1

totales

datos
110

train_X = train_X.astype('float32', copy=False)

test_X = test_X.astype('float32', copy=False)
train_X = train_X.reshape((-1,)+ image_shape)

test_X = test_X.reshape((-1,) + image_shape)
# (x_train, y_train), (x_test, y_test) = mnist.load_data()

# x_train = x_train.astype('float32') / 255.0
# x_test = x_test.astype('float32') / 255.0
# x_train = x_train.reshape((-1,) + image_shape)

# x_test = x_test.reshape((-1,) + image_shape)
train_Y= keras.utils.to_categorical(train_Y, num_classes)

test_Y= keras.utils.to_categorical(test_Y, num_classes)
# y_train = keras.utils.to_categorical(y_train, num_classes)

# y_test = keras.utils.to_categorical(y_test, num_classes)
num_of_train_data = train_X.shape[0]
num_of_test_data = test_X.shape[0]
model = build_model(image_shape, num_classes)

train_func, test_func = build_training_functions(image_shape, num_classes, model)
attack_func = build_attack_function(image_shape, num_classes, model)
print ("============================== Training ==============================")
for e in range(epochs):
train_step_loss = []
train_step_acc = []
# random shuffle
rand_idx = np.random.permutation(num_of_train_data)
train_X = train_X[rand_idx]
train_Y = train_Y[rand_idx]
for i in range(0, num_of_train_data, train_batch_size):

j = min(i + train_batch_size, num_of_train_data)
batch_images = train_X[i:j]
batch_labels = train_Y[i:j]
loss, acc = train_func([batch_images, batch_labels, 1])

train_step_loss.append(loss)
train_step_acc.append(acc)
print ("\rEpoch:[{0}/{1}], Steps:[{2}/{3}] loss: {4:.4}, acc:

{5:.4}".format(
111
e+1, epochs, j, num_of_train_data, np.mean(train_step_loss),
np.mean(train_step_acc)
), end='')
print("")
print ("============================== Testing ==============================")
test_loss = []
test_acc = []
attack_loss = []
attack_acc = []
eps = 0.06 * np.ones(shape=(1,))
for i in range(0, num_of_test_data, test_batch_size):

j = min(i + test_batch_size, num_of_test_data)
batch_images = test_X[i:j]
batch_labels = test_Y[i:j]
loss, acc = test_func([batch_images, batch_labels, 0])

test_loss.append(loss)
test_acc.append(acc)
attack_images, = attack_func([batch_images, batch_labels, eps, 0])

loss, acc = test_func([attack_images, batch_labels, 0])
attack_loss.append(loss)
attack_acc.append(acc)
print ("\rtest_loss: {0:.4}, test_acc: {1:.4}, attack_loss: {2:.4}, attack_acc:

{3:.4}".format(
np.mean(test_loss), np.mean(test_acc),np.mean(attack_loss),
np.mean(attack_acc)
))
import matplotlib.gridspec as gridspec

from PIL import Image
from keras.preprocessing import image
for i in range(20):
plt.figure(i+1)
plt.imshow(test_X[i+903])
im=image.array_to_img(test_X[i+903])
im.save("./eps=0.06/imagenes de prueba/ imagen{}.png".format(i+1))
plt.axis('off')
for i in range(20):
plt.figure(i+1)
plt.imshow(attack_images[i+1])
im=image.array_to_img(attack_images[i+1])
im.save("./eps=0.06/adversarias/ adversaria{}.png".format(i+1))
plt.axis('off')
for i in range(20):
plt.figure(i+1)
diferencia=test_X[i+903]-attack_images[i+1]
normalizada= diferencia/abs(diferencia)
plt.imshow(normalizada)
im=image.array_to_img(test_X[i+903]-attack_images[i+1])
im.save("./eps=0.06/ruido/ ruido{}.png".format(i+1))
112
plt.axis('off')
# FUNCIONES INTERNAS QUE DEBEN ESTAR EN LA MISMA CARPETA DE TRABAJO
## CARPETA DE MODELO DE LA RED NEURONAL
from keras.layers import Activation, GlobalAvgPool2D

#%matplotlib inline
import keras # libreria que contiene a tensorflow
categorias
maxpooling
leakyReLU
import numpy as np # IMPORTA NUMPY (PAQUETE FUNDAMENTAL PARA COMPUTACION
CIENTIFICA)
import math
import sqlite3 #gestiona base de datos
from keras.callbacks import EarlyStopping # devolucion de llamada de parada
temprana
from keras.callbacks import ModelCheckpoint # devolucion de llamada de puntos de
control
from keras import regularizers # importa la funcion de regularizacion
def build_model(input_shape, num_classes):

model = Sequential()
model.add(Conv2D(32, kernel_size=(3,
3),activation='linear',padding='same',input_shape=(100,100,3)))
model.add(MaxPooling2D((2, 2),padding='same'))
113
model.add(Flatten()) #aplanar la salida de la capa conv de 4-dim a 2-dim
model.add(Dense(128,
activation='linear',kernel_regularizer=regularizers.l2(0.01)))
model.add(Dropout(0.25)) #capa de abandono introducida
model.add(Dense(num_classes, activation='softmax'))
return model
## CARPETA CON EL ENTRENAMIENTO, LA PRUEBA Y ATAQUES ADVERSARIOS

from keras.optimizers import Adam
import keras.backend as K
def build_training_functions(input_shape, num_classes, model):
images = K.placeholder((None,) + input_shape)

y_true = K.placeholder((None, num_classes))
y_pred = model(images)
loss = K.mean(K.categorical_crossentropy(y_true, y_pred))

acc = K.mean(K.cast(K.equal(K.argmax(y_true, axis=-1), K.argmax(y_pred,
axis=-1)), K.floatx()))
# get updates of untrainable updates.

# e.g. mean and variance in BatchNormalization
untrainable_updates = model.get_updates_for([images])
# get updates of trainable updates.

trainable_updates = Adam(lr=0.0001).get_updates(loss,
model.trainable_weights)
# K.learning_phase() is required if model has different behavior during train

and test.
# e.g. BatchNormalization, Dropout
train_func = K.function([images, y_true, K.learning_phase()], [loss, acc],
untrainable_updates + trainable_updates)
test_func = K.function([images, y_true, K.learning_phase()], [loss, acc])
return train_func, test_func
def build_attack_function(input_shape, num_classes, model):
images = K.placeholder((None,) + input_shape)

y_true = K.placeholder((None, num_classes))
y_pred = model(images)
loss = K.mean(K.categorical_crossentropy(y_true, y_pred))
eps = K.placeholder((1,))
grad = K.gradients(loss, [images])[0]
r_adv = eps * K.sign(grad)
attack_images = K.clip(images + r_adv, 0.0, 1.0)
attack_function = K.function([images, y_true, eps,

K.learning_phase()],[attack_images])
return attack_function
114

Detección de roya en caña de azúcar con aprendizaje profundo

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Detección de roya en caña de azúcar con aprendizaje profundo

Cargado por

Copyright:

Formatos disponibles

TRABAJO DE FIN DE GRADO PREVIO AL TÍTULO DE INGENIERO

UNIVERSIDAD DEL QUINDÍO

UNIVERSIDAD DEL QUINDÍO

Figura 1. Síntomas de roya de café y roya naranja en la lámina foliar de la caña de 14

Tabla 1. Hiperparámetros utilizados en los diferentes entrenamientos para elección 46

En la agricultura, la detección de plagas y enfermedades es una de las principales

Otro de los retos a cumplir en la clasificación de imágenes es la capacidad de

Infortunadamente encontrar perturbaciones adversas mínimas es casi imposible en

Evaluar modelos de aprendizaje profundo mediante el uso de entrenamiento desde cero y

3.1 LA ROYA EN LA CAÑA DE AZÚCAR

3.1.1 Roya naranja de la caña de azúcar

3.1.2 Roya parda de la caña de azúcar

3.1.4 Diferencias entre roya naranja y roya parda en caña de azúcar

3.2 REDES NEURONALES CONVOLUCIONALES (CNN)

 Eliminan la necesidad de extracción de características.

 Los resultados obtenidos son buenos en comparación a otros tipos de algoritmos.

 Se puede utilizar un nuevo entrenamiento a partir de una red ya existente.

Figura 5. Ejemplo de arquitectura de red neuronal convolucional [11]

3.2.2 Visualización de pesos

Figura 7. Pesos de red neuronal con base de datos MNIST

3.2.3 Redes generativas adversarias (GANs)

𝑚𝑖𝑛𝐺 𝑚𝑎𝑥𝐷 𝑉(𝐺, 𝐷) = 𝔼𝑥~𝑝𝑑𝑎𝑡𝑎(𝑥) [log(𝐷(𝑥))] + 𝔼𝑧~𝑝𝑧(𝑧) [log (1 − 𝐷(𝐺(𝑧)))] (1)

Figura 9. Arquitectura de AlexNet

Inception v3 es una arquitectura que está compuesta de 42 capas. Existen 4 versiones de la

La Figura 11 muestra de manera resumida la arquitectura de la red Inception v3 en donde se pueden

En la Figura 12 se tiene la representación resumida de la red InceptionResNet v2, en la cual se

3.4.1 Función Sigmoide

3.4.2 Función unidad lineal rectificada (ReLU)

3.4.3 Función de activación LeakyReLU

3.5 DROPOUT (Abandono)

3.5.1 Descripción del modelo de dropout

𝑧𝑖 (𝑙+1) = 𝑤𝑖 (𝑙+1) 𝑦 𝑙 + 𝑏𝑖 (𝑙+1)

𝑦𝑖 (𝑙+1) = 𝑓(𝑧𝑖 (𝑙+1) ) (5)

𝑦̃ (𝑙) = 𝑟 (𝑙) ∗ 𝑦 (𝑙)

𝑧𝑖 (𝑙+1) = 𝑤𝑖 (𝑙+1) 𝑦̃ 𝑙 + 𝑏𝑖 (𝑙+1)

𝑦𝑖 (𝑙+1) = 𝑓(𝑧𝑖 (𝑙+1) ) (6)

(a) Red estándar (b) Red con Abandono

3.6 DESCENSO DE GRADIENTE Y SUS VARIANTES

3.6.1 Descenso de gradiente por lote

3.6.2 Descenso de gradiente estocástico

𝜃 = 𝜃 − 𝜂 · 𝛻𝜃 𝐽(𝜃; 𝑥 (𝑖) ; 𝑦 (𝑖) ) (8)

3.6.3 Descenso de gradiente por mini-lotes

𝜃 = 𝜃 − 𝜂 · 𝛻𝜃 𝐽(𝜃; 𝑥 (𝑖:𝑖+𝑛) ; 𝑦 (𝑖:𝑖+𝑛) ) (9)

3.7 Algoritmos de optimización del descenso de gradiente

𝑔𝑡,𝑖 = 𝛻θ𝑡 𝐽(𝜃 𝑡,𝑖 ) (10)

𝜃𝑡+1,𝑖 = 𝜃 𝑡,𝑖 − 𝜂 · 𝑔𝑡,𝑖 (11)

𝐸[𝑔]2 𝑡 = 𝛾𝐸[𝑔]2 𝑡−1 + (1 − 𝛾) 𝑔2 𝑡 (14)

El vector de actualización de parámetros de AdaGrad derivado anteriormente toma la forma:

𝐸[∆𝜃 2 ]𝑡 = 𝛾𝐸[∆𝜃 2 ]𝑡−1 + (1 − 𝛾)∆𝑡𝜃 2 𝑡 (19)

El error cuadrático medio de las actualizaciones de parámetros es:

𝑅𝑀𝑆[∆𝜃]𝑡 = √𝐸 [∆𝜃 2 ]𝑡 + 𝜖 (20)

Entonces 𝑅𝑀𝑆[∆𝜃]𝑡 es desconocido, aproximamos esto con la RMS de parámetros actualizados

𝜃𝑡+1 = 𝜃𝑡 + ∆𝜃𝑡 (22)

𝐸[𝑔2 ]𝑡 = 0.9𝐸[𝑔2 ]𝑡−1 + 0.1𝑔2 𝑡 (23)

𝜈𝑡 = 𝛽2 𝜈𝑡−1 + (1 − 𝛽2 )𝑔2 𝑡 (25)

4.1 PREPARACIÓN DE ENTORNO DE TRABAJO Y CREACIÓN DE

En la preparación del entorno de trabajo se emplearon 3 importantes herramientas de trabajo que

Figura 16. Herramientas de programación usada

4.2 RECOLECCIÓN DE BASE DE DATOS

4.3 AUMENTO DE BASE DE DATOS

Hojas sanas Hojas con roya

Aumento por Aumento por

Aumento de datos Aumento de datos