3 - Encog3CS-UserTraduc13032017A

Programación de
redes neuronales
con Ecog3 en C#
Jeff Heaton
Heaton Research, Inc.

St. Louis, MO, USA
v
Publisher: Heaton Research, Inc
Programming Neural Networks with Encog 3 in
C# First printing
October, 2011 Author:
Jeff Heaton Editor:
WordsRU.com Cover
Art: Carrie Spear
ISBN’s for all Editions:
978-1-60439-026-1, PAPER
978-1-60439-027-8, PDF
978-1-60439-029-2, NOOK
978-1-60439-030-8, KINDLE
Copyright © 2011 por Heaton Research Inc., 1734 Clarkson Rd. # 107,
Chester-field, MO 63017-4976. Derechos del mundo reservados. El autor (es) ha
creado un código reutilizable en esta publicación expresamente para ser
reutilizado por los lectores. Heaton Research, Inc. otorga a los lectores el
permiso para reutilizar el código encontrado en esta publicación o descargado
desde nuestro sitio web siempre y cuando (autor (s)) se atribuyan en cualquier
aplicación que contenga el código reutilizable y el código fuente en sí nunca se
redistribuye, Publicado en línea por transmisión electrónica, vendido o explotado
comercialmente como un producto independiente. Aparte de esta excepción
específica relativa al código reutilizable, ninguna parte de esta publicación puede
ser almacenada en un sistema de recuperación, transmitida o reproducida de
ninguna manera, incluyendo, pero no limitado a copia fotográfica, fotografía,
registro magnético u otro registro, sin Acuerdo previo y permiso por escrito del
editor.
Heaton Research, Encog, el logotipo de Encog y el logo de Heaton Research
son marcas registradas de Heaton Research, Inc., en los Estados Unidos y / o
en otros países.
MARCAS COMERCIALES: Heaton Research ha intentado a lo largo de este
libro distinguir marcas comerciales propietarias de términos descriptivos
siguiendo el estilo de capitalización utilizado por el fabricante.
El autor y el editor han hecho sus mejores esfuerzos para preparar este libro,
por lo que el contenido se basa en la versión final del software siempre que sea
posible. Partes del manuscrito pueden estar basadas en versiones de pre-
lanzamiento Suministrado por el (los) fabricante (s) de software. El autor y el
editor no hacen declaraciones ni garantías de ningún tipo con respecto a la
integridad o exactitud de los contenidos de este documento y no aceptan
ninguna responsabilidad de ningún tipo incluyendo, pero no limitado a
rendimiento, comerciabilidad, idoneidad para cualquier propósito particular o
cualquier pérdida o Daños y perjuicios de cualquier tipo causados o
presuntamente causados directa o indirectamente por este libro.
vii
CONTRATO DE LICENCIA DE SOFTWARE: TERMINOS Y

CONDICIONES
Los medios de comunicación y / o los materiales en línea que acompañan
a este libro que están disponibles ahora o en el futuro contienen programas y
/ o archivos de texto (el "software") que se utilizarán en relación con el libro.
Heaton Research, Inc. otorga por este medio una licencia para usar y
distribuir programas de software que hacen uso de la forma binaria
compilada del código fuente de este libro. Usted no puede redis-tributo el
código fuente contenido en este libro, sin el permiso por escrito de Heaton
Research, Inc. Su compra, aceptación o uso del Software constituirá su
aceptación de dichos términos.
La compilación del Software es propiedad de Heaton Research, Inc. a

menos que se indique lo contrario y está protegida por derechos de autor de
Heaton Research, Inc. u otros propietarios de derechos de autor como se
indica en los archivos multimedia (el "propietario (s)"). Por la presente se le
otorga una licencia para usar y distribuir el Software para su uso personal, no
comercial. Usted no puede reproducir, vender, distribuir, publicar, circular o
explotar comercialmente el Software, ni ninguna porción de los mismos, sin
el consentimiento por escrito de Heaton Research, Inc. y el propietario
específico de los derechos de autor de cualquier componente de software
incluido en este medio.
En el caso de que el Software o los componentes incluyan requisitos

específicos de licencia o acuerdos de usuario final, declaraciones de
condición, renuncias, limitaciones o garantías ("Licencia de Usuario Final"),
dichas Licencias de Usuario Final súper sede los términos Y las condiciones
de la presente en cuanto a ese componente particular de Software. Su
compra, aceptación o uso del Software constituirá su aceptación de dichas
Licencias de Usuario Final.
Mediante la compra, uso o aceptación del Software, usted acepta además

cumplir con todas las leyes y reglamentos de exportación de los Estados
Unidos, ya que dichas leyes y regulaciones pueden existir de vez en cuando.
viii
SOFTWARE APOYO
Los componentes del Software complementario y los que estén asociados

con ellos pueden ser apoyados por el propietario específico de ese material,
pero no son compatibles con Heaton Research, Inc. Puede obtenerse
información sobre cualquier soporte disponible del (de los) Propietario (s)
Utilizando la información proporcionada en los archivos README apropiados
o enumerados en otra parte del medio.
Si el (los) fabricante (s) u otro (s) Propietario (s) deja de apoyar o se niega
a cumplir con cualquier otro, Heaton Research, Inc. no asume ninguna
responsabilidad. Este aviso relativo al soporte del Software se proporciona
únicamente para su información. Heaton Research, Inc. no es el agente o
principal de los Propietarios, y Heaton Research, Inc. no es en modo alguno
responsable de proporcionar ningún soporte para el Software, ni es
responsable ni responsable de ningún soporte proporcionado o no Siempre,
por el (los) Propietario (s).
GARANTÍA
Heaton Research, Inc. garantiza que los medios adjuntos estarán libres
de defectos físicos por un período de noventa (90) días después de la
compra. El Software no está disponible en Heaton Research, Inc. en
ninguna otra forma o medio que el aquí adjunto o publicado en
www.heatonresearch.com. Si descubre un defecto en el soporte durante
este período de garantía, puede obtener un reemplazo del formato
idéntico sin costo alguno enviando los medios defectuosos, franqueo
prepagado, con comprobante de compra a:
Departamento de Soporte al Cliente de Heaton Research, Inc. 1734

Clarkson Rd # 107 Chesterfield, MO 63017-4976 Web:
www.heatonresearch.com
E-Mail: support@heatonresearch.com
RENUNCIA
Heaton Research, Inc. no ofrece ninguna garantía ni representación,
expresa ni implícita, con respecto al Software o su contenido, calidad,
rendimiento, comerciabilidad o idoneidad para un propósito en particular. En
ningún caso
ix
Heaton Research, Inc., sus distribuidores o distribuidores serán

responsables ante usted o cualquier otra parte por daños directos,
indirectos, especiales, incidentales, consecuentes u otros que surjan del
uso o incapacidad de usar el Software o sus contenidos incluso si
Advertido de la posibilidad de tal daño. En caso de que el Software
incluya una función de actualización en línea, Heaton Research, Inc.
renuncia a cualquier obligación de proporcionar esta característica
durante cualquier duración específica que no sea la contabilización inicial.
La exclusión de garantías implícitas no está permitida por algunos

estados. Por lo tanto, la exclusión anterior puede no aplicarse a usted.
Esta garantía le otorga derechos legales específicos; Puede haber otros
derechos que usted pueda tener que varían de un estado a otro. El precio
del libro con el Software por Heaton Research, Inc. refleja la asignación
del riesgo y las limitaciones de responsabilidad contenidas en este
acuerdo de Términos y Condiciones.
DISTRIBUCIÓN DE SHAREWARE
Este software puede utilizar varios programas y bibliotecas que se

distribuyen como shareware. Las leyes de derechos de autor se aplican tanto
al shareware como al software comercial ordinario, y los propietarios del
copyright conservan todos sus derechos. Si intenta un programa de
shareware y continúa usándolo, se espera que lo registre. Los programas
individuales difieren en los detalles de los períodos de prueba, el registro y el
pago. Por favor, observe los requisitos establecidos en los archivos
apropiados.
xi
Este libro está dedicado a mi

maravillosa
Esposa, Tracy y nuestros dos

cockatiels
Críquet y Wynton.
xiii
Contenido
Introducción xxi
0.1 La historia de Encog . . . . . . . . . . . . . . . . . . . . . . . xxi
0.2 Introducción a las redes neuronales. . . . . . . . . . . . . . . . xxii
0.2.1 Estructura de Red Neural . . . . . . . . . . . . . . . . xxiv
0.2.2 Un ejemplo simple . . . . . . . . . . . . . . . . . . . . xxvi
0.3 Cuándo utilizar redes neuronales . . . . . . . . . . . . . . . . . . xxvi
0.3.1 Problemas no adaptados a una solución de red neuronal . .
xxvii
0.3.2 Problemas adecuados para una red neuronal . . . . . . . xxvii
0.4 Estructura del libro . . . . . . . . . . . . . . . . . . . . . . . xxviii
1 Regresión, clasificación y agrupación 1

1.1 Clasificación de datos . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Análisis de regresión . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Estructuración de una red neuronal. . . . . . . . . . . . . . . . . . 4
1.4.1 Descripción de la capa de entrada . . . . . . . . . . . . . 5
1.4.2 Descripción de la capa de salida . . . . . . . . . . . . 6
1.4.3 Capas ocultas . . . . . . . . . . . . . . . . . . . . . . . 7
1.5 Uso de una red neuronal . . . . . . . . . . . . . . . . . . . . . 8
1.5.1 El Operador XOR y las Redes Neuronales . . . . . . . . 8
1.5.2 Estructuración de una red neuronal para XOR . . . . . . . 9
xiv Contenido
1.5.3 Formación de una red neuronal . . . . . . . . . . . . . . . . 13

1.5.4 Ejecutar una red neuronal . . . . . . . . . . . . . . . 15
1.6 Resumen del capítulo . . . . . . . . . . . . . . . . . . . . . . . . 16
2 Obtención de datos para Encog 19

2.1 Dónde obtener datos para redes neuronales . . . . . . . . . . . . 19
2.2 Normalización de datos . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.1 Normalización de valores numéricos. . . . . . . . . . . . . . 21
2.2.2 Normalización de valores nominales. . . . . . . . . . . . . . 23
2.2.3 Entendiendo uno-de-normalización . . . . . . . . . 23
2.2.4 Entendiendo la normalización equilateral . . . . . . . . 24
2.3 Normalización Programática . . . . . . . . . . . . . . . . . . 27
2.3.1 Normalización de números individuales . . . . . . . . . . . . 27
2.3.2 Normalización de matrices de memoria. . . . . . . . . . . . 28
2.4 Normalización de archivos CSV . . . . . . . . . . . . . . . . . . . . . . 29
2.4.1 Implementación de la normalización básica de archivos . . . .
30
2.4.2 Guardar la secuencia de comandos de normalización . . . .
. . . . . . . . . 31
2.4.3 Personalización de la normalización de archivos . . . . . . . .
. . . . . 31
2.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3 El Encog Workbench 35
3.1 Estructura del Workbench Encog . . . . . . . . . . . . . . . 36
3.1.1 Workbench archivos CSV . . . . . . . . . . . . . . . . . . 37
3.1.2 Archivos EG de Workbench . . . . . . . . . . . . . . . . . . . 37
3.1.3 Archivos EGA de Workbench . . . . . . . . . . . . . . . . . . 38
3.1.4 Archivos Workbench EGB . . . . . . . . . . . . . . . . . . 38
3.1.5 Archivos de imagen de Workbench 39
..................
3.1.6 Archivos de texto de Workbench . . . . . . . . . . . . . . . . . . 39
3.2 Un ejemplo simple XOR . . . . . . . . . . . . . . . . . . . . . 39
Contenido xv
3.2.1 Creación de un nuevo proyecto . . . . . . . . . . . . . . . . . 39

3.2.2 Generar datos de formación . . . . . . . . . . . . . . . . . 40
3.2.3 Crear una red neuronal . . . . . . . . . . . . . . . . . 41
3.2.4 Entrene la Red Neural . . . . . . . . . . . . . . . . 42
3.2.5 Evaluar la Red Neural . . . . . . . . . . . . . . 43
3.3 Usando el Analista Encog . . . . . . . . . . . . . . . . . . . . . 44
3.4 Informes de analistas de Encog . . . . . . . . . . . . . . . . . . . . . . 47
3.4.1 Informe de rango . . . . . . . . . . . . . . . . . . . . . . . 47
3.4.2 Gráfico de dispersión . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4 Construir redes neuronales en C # 51

4.1 Construyendo una red neuronal . . . . . . . . . . . . . . . . . 52
4.2 El papel de las funciones de activación . . . . . . . . . . . . . . . . 53
4.3 Encog Activación de funciones . . . . . . . . . . . . . . . . . . 54
4.3.1 ActivaciónBiPolar . . . . . . . . . . . . . . . . . . . . . 54
4.3.2 Activación Competitiva . . . . . . . . . . . . . . . . . . 55
4.3.3 ActivationLinear . . . . . . . . . . . . . . . . . . . . . 56
4.3.4 ActivationLOG . . . . . . . . . . . . . . . . . . . . . . 57
4.3.5 ActivationSigmoid . . . . . . . . . . . . . . . . . . . . 58
4.3.6 ActivationSoftMax . . . . . . . . . . . . . . . . . . . . 59
4.3.7 ActivationTANH . . . . . . . . . . . . . . . . . . . . . 60
4.4 Encog Persistencia . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.5 Uso de Encog EG Persistence . . . . . . . . . . . . . . . . . . . 61
4.5.1 Uso de Encog EG Persistence . . . . . . . . . . . . . . . 62
4.6 Uso de la serialización .Net . . . . . . . . . . . . . . . . . . . . . 63
4.7 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5 Formación de Propagación 67
xvi Contenido
5.1 Entendiendo el entrenamiento de propagación. . . . . . . . . . . . 68

5.1.1 Comprendiendo Backpropagation . . . . . . . . . . . . . 69
5.1.2 Descripción de la regla de actualización de Manhattan . . .
. . . 70
5.1.3 Entendiendo el entrenamiento de propagación rápida
...... 71
5.1.4 Entendiendo el entrenamiento de Propagación Resiliente .
. . . . 72
5.1.5 Entendiendo el entrenamiento de SCG . . . . . . . . . . . . . 73
5.1.6 Entendiendo el entrenamiento de LMA . . . . . . . . . . . . . .
74
5.2 Método Encog y Fábricas de Entrenamiento . . . . . . . . . . . . . . .
75
5.2.1 Creación de redes neuronales con fábricas . . . . . . . . 75
5.2.2 Creación de métodos de entrenamiento con fábricas . . . .
. . . 76
5.3 Cómo funciona la formación multiproceso . . . . . . . . . . . . . . . 76
5.4 Uso del entrenamiento multiproceso . . . . . . . . . . . . . . . . . . 78
5.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6 Más entrenamiento supervisado 83

6.1 Ejecución del ejemplo de Lander Lunar . . . . . . . . . . . . . . 85
6.2 Examen del Simulador de Lander Lunar . . . . . . . . . . . . . 90
6.2.1 Simular el Lander . . . . . . . . . . . . . . . . . . 91
6.2.2 Cálculo de la puntuación . . . . . . . . . . . . . . . . . . . 93
6.2.3 Volando la Nave Espacial . . . . . . . . . . . . . . . . . . . 95
6.3 Entrenamiento del Piloto Neural . . . . . . . . . . . . . . . . . . . . . 98
6.3.1 ¿Qué es un Algoritmo Genético? . . . . . . . . . . . . . . 99
6.3.2 Usando un Algoritmo Genético . . . . . . . . . . . . . . . . 100
6.3.3 ¿Qué es recocido simulado? . . . . . . . . . . . . . . 101
6.3.4 Utilización del recocido simulado . . . . . . . . . . . . . . . . 101
6.4 Uso de la clase de puntuación de conjunto de entrenamiento. 103
6.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7 Otros tipos de redes neuronales 107

CONTENIDO xvii
7.1 La Red Neural de Elman . . . . . . . . . . . . . . . . . . . 108

7.1.1 Creación de una red neuronal de Elman . . . . . . . . . . . 111
7.1.2 Entrenando una Red Neural de Elman . . . . . . . . . . . 111
7.2 La Red Neural de Jordania . . . . . . . . . . . . . . . . . . . 113
7.3 La Red Neural ART1 . . . . . . . . . . . . . . . . . . . . 114
7.3.1 Uso de la red neuronal ART1 . . . . . . . . . . . . 115
7.4 La Red Neural NEAT . . . . . . . . . . . . . . . . . . . 118
7.4.1 Creación de una población Encog NEAT . . . . . . . . . . 120
7.4.2 Entrenando una Red Neural de Encog NEAT . . . . . . . 121
7.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8 Uso de datos temporales 125

8.1 Cómo funciona una Red Neural Predictiva . . . . . . . . . . . . 126
8.2 Uso del conjunto de datos temporal Encog . . . . . . . . . . . . . . 127
8.3 Aplicación a Sunspots . . . . . . . . . . . . . . . . . . . . . 129
8.4 Uso del conjunto de datos Encog Market . . . . . . . . . . . . . . . 134
8.5 Aplicación a la Bolsa . . . . . . . . . . . . . . . . . 137
8.5.1 Generación de datos de entrenamiento . . . . . . . . . . . 137
8.5.2 Entrenamiento de la Red Neural . . . . . . . . . . . . . . . 139
8.5.3 Poda incremental . . . . . . . . . . . . . . . . . . . 141
8.5.4 Evaluación de la Red Neural . . . . . . . . . . . . . 143
8.6 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
9 Uso de datos de
imagen 151
9.1 Encontrando los límites . . . . . . . . . . . . . . . . . . . . . . . . 152
9.2 Downsampling una imagen . . . . . . . . . . . . . . . . . . . . . 154
9.2.1 Qué hacer con las neuronas de salida . . . . . . . . . 155
9.3 Utilización del conjunto de datos de imágenes Encog . . . . . . 155
9.4 Ejemplo de reconocimiento de imagen. . . . . . . . . . . . . . . . . 157
xviii CONTENTS
9.4.1 Creación del conjunto de entrenamiento . . . . . . . . . . . 159

9.4.2 Introducción de una imagen . . . . . . . . . . . . . . . . . . . . 160
9.4.3 Creación de la red . . . . . . . . . . . . . . . . . . . 161
9.4.4 Formación de la Red . . . . . . . . . . . . . . . . . . . 163
9.4.5 Reconocimiento de imágenes. . . . . . . . . . . . . . . . . . 165
9.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
10 Uso de un mapa de autoorganización 169

10.1 La Estructura y Formación de un SOM . . . . . . . . . . . . . . 171
10.1.1 Estructuración de una SOM . . . . . . . . . . . . . . . . . . . . 171
10.1.2 Formación de un SOM . . . . . . . . . . . . . . . . . . . . . . 172
10.1.3 Descripción de las funciones de vecindario . . . . . . . . 174
10.1.4 Obligar a un ganador . . . . . . . . . . . . . . . . . . . . . 176
10.1.5 Error de cálculo . . . . . . . . . . . . . . . . . . . . . 177
10.2 Implementación de los colores SOM en Encog . . . . . . . . . . . 177
10.2.1 Capacitación de la SOM de concordancia de colores . 179
10.3 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
A Instalar y usar Encog 185

A.1 Instalando Encog . . . . . . . . . . . . . . . . . . . . . . . . . . 186
A.2 Utilización de Encog Core y ejemplos . . . . . . . . . . . . . . . . 186
A.3 Utilizar el DLL Encog en su propia aplicación . . . . . . . . . 191
Glossary 195
CONTENTS xix
xxi
Introducción.
Encog es un framework de aprendizaje de máquina para Java y .NET.
Inicialmente, Encog fue creado para soportar solamente redes
neuronales. Versiones posteriores de Encog se expandieron más hacia el
aprendizaje general de máquinas. Sin embargo, este libro se centrará
principalmente en redes neuronales. Muchas de las técnicas aprendidas
en este libro pueden aplicarse a otras técnicas de aprendizaje automático.
Los libros subsecuentes se centrarán en algunas de estas áreas de
programación Encog.
Este libro se publica conjuntamente con la versión 3.0 de Encog y
debe permanecer muy compatible con versiones posteriores de Encog 3.
Versiones futuras en la serie 3.x intentarán agregar funcionalidad con la
interrupción mínima al código existente.
0.1 La historia de Encog
La primera versión de Encog, versión 0.5, fue lanzada el 10 de julio de
2008. Las fundaciones originales de Encog incluyen algún código usado
en la primera edición de "Introducción a las Redes Neuronales con Java",
publicado en 2005. Su segunda edición incluía una red neuronal
completamente rediseñada Motor de red, que se convirtió en Encog
versión 0.5. Las versiones Encog 1.0 a 2.0 mejoraron enormemente el
código de red neural mucho más allá de lo que puede ser cubierto en un
libro de introducción. Encog versión 3.0 agregó más apoyo formal para
métodos de aprendizaje de máquina más allá de redes neurales.
Este libro proporcionará una instrucción completa sobre cómo usar las
redes neu-ral con Encog. Para las complejidades de la implementación
real de las redes neuronales, consulte "Introducción a las redes
neuronales con Java" y "Introducción a redes neuronales con C #". Estos
libros exploran cómo implementar
xxii Introduction
redes neuronales básicas y ahora para crear los internos de una red
neuronal.
Estos dos libros se pueden leer en secuencia como nuevos conceptos

se introducen con muy poca repetición. Estos libros no son un requisito
previo para el otro. Este libro le equipará para comenzar con Encog si
tiene un lenguaje básico de C # de programación de programación. En
particular, debe estar familiarizado con lo siguiente:
• C# Generic Types
• Collections
• Object Oriented Programming
Antes de comenzar a examinar la forma de usar Encog, vamos a
identificar primero los problemas Encog adeptos a la solución. Las redes
neuronales son una técnica de programación. No son una solución de
plata para cada problema de programación, sin embargo, ofrecen
soluciones viables a ciertos problemas de programación. Por supuesto,
hay otros problemas para los cuales las redes neuronales son un ajuste
pobre.
0.2 Introducción a las redes neuronales
Este libro definirá una red neuronal y cómo se usa. La mayoría de las
personas, incluso los no programadores, han oído hablar de redes
neuronales. Hay muchos matices de ciencia ficción asociados con las
redes neuronales. Y, como muchas cosas, los escritores de ciencia ficción
han creado una vasta, pero algo imprecisa, idea pública de lo que es una
red neuronal.
La mayoría de los laicos piensan en las redes neuronales como una
especie de "cerebro artificial" que impulsa a los robots o mantiene
conversaciones inteligentes con los seres humanos. Esta noción es una
definición más cercana de la Inteligencia Artificial (AI) que las redes
neuronales. AI busca crear máquinas verdaderamente inteligentes. No
voy a desperdiciar varios párrafos explicando lo que es la verdadera
inteligencia humana, en comparación con el estado actual de las
computadoras. Cualquiera que haya pasado tiempo con seres humanos y
computadoras conoce la diferencia. Los ordenadores actuales no son
inteligentes.
0.2 Introducción a las redes neuronales xxiii
Las redes neuronales son una pequeña parte de la IA. Las redes
neuronales, por lo menos en la actualidad, llevan a cabo tareas muy
pequeñas y específicas. Las redes neuronales basadas en computadoras
no son dispositivos de computación de propósito general como el cerebro
humano. Es posible que la percepción de las redes neuronales esté
sesgada, ya que el propio cerebro es una red de neuronas, o una red
neuronal. Esto trae consigo una distinción importante.
El cerebro humano se describe más exactamente como una red neural
biológica (BNN). Este libro no trata de redes neuronales biológicas. Este
libro trata de redes neuronales artificiales (ANN). La mayoría de los textos
no hacen la distinción entre los dos. A lo largo de este texto, las
referencias a redes neuronales implican redes neuronales artificiales.
Existen algunas similitudes básicas entre las redes neuronales
biológicas y las redes neuronales artificiales. Las redes neuronales
artificiales son, en gran medida, construcciones matemáticas inspiradas
en redes neuronales biológicas. Un término importante que se utiliza a
menudo para describir varios algoritmos de red neuronal artificial es
"plausibilidad biológica". Este término define la proximidad de un
algoritmo de red neuronal artificial a una red neuronal biológica.
Como se dijo anteriormente, las redes neuronales están diseñadas
para realizar una pequeña tarea. Una aplicación completa probablemente
utiliza redes neuronales para lograr ciertas partes de sus objetivos. La
aplicación completa no se implementará como una red neuronal. La
aplicación puede hacerse de varias redes neuronales, cada una diseñada
para una tarea específica.
Las redes neuronales realizan tareas de reconocimiento de patrones
muy bien. Cuando se comunica un patrón, una red neural comunica ese
patrón de nuevo. En el nivel más alto, esto es todo lo que hace una red
neuronal típica. Algunas arquitecturas de red variarán esto, pero la gran
mayoría de redes neuronales funcionan de esta manera. La figura 1
ilustra una red neuronal a este nivel.
Figure 1: Una Red Neural Típica
Como puede ver, la red neural arriba está aceptando un patrón y

devolviendo un patrón. Las redes neuronales funcionan de forma
totalmente sincrónica. Una red neural sólo emitirá cuando se presente con
entrada. No es como un cerebro humano, que no funciona exactamente
de forma sincrónica. El cerebro humano responde a la entrada, pero
producirá salida en cualquier momento que desee!
xxiv Introduction
0.2.1 Estructura de redes neuronales

Las redes neuronales están formadas por capas de neuronas
similares. Como mínimo, la mayoría de las redes neuronales constan de
una capa de entrada y una capa de salida. El patrón de entrada se
presenta a la capa de entrada. A continuación, el patrón de salida se
devuelve desde la capa de salida. Lo que sucede entre las capas de
entrada y salida es un cuadro negro. En este punto del libro, la estructura
interna de la red neural no es todavía una preocupación. Hay muchas
arquitecturas que definen las interacciones entre la capa de entrada y
salida. Más adelante en este libro, estas arquitecturas son examinadas.
Los patrones de entrada y salida son ambos arrays de números de
coma flotante. Un ejemplo de estos patrones sigue.
Neural Network Input : [ −0.245 , . 2 8 3 , 0 . 0 ]
Neural Network Output : [ 0.782, 0.543 ]
La red neuronal anterior tiene tres neuronas en la capa de entrada y

dos neuronas en la capa de salida. El número de neuronas en las capas
de entrada y salida no cambia. Como resultado, el número de elementos
en los patrones de entrada y salida, para una red neuronal particular,
nunca puede cambiar.
Para hacer uso de la red neuronal, la entrada de problemas debe
expresarse como una matriz de números de coma flotante. Del mismo
modo, la solución del problema debe ser una matriz de números de coma
flotante. Este es el valor esencial y único de una red neuronal. Las redes
neuronales toman una matriz y la transforman en una segunda. Las redes
neuronales no hacen bucle, llaman a subrutinas, o realizan cualquiera de
las otras tareas asociadas con la programación tradicional. Las redes
neuronales reconocen patrones.
Una red neuronal es muy similar a una tabla hash en la programación
tradicional. Una tabla hash se utiliza para asignar claves a valores, algo
así como un diccionario. Lo siguiente podría ser pensado como una tabla
hash:
0.2 Introducción a las redes neuronales xxv
• “hear” -> “to perceive or apprehend by the ear”—“ Percibir o

aprehender por el oído”
• “run” -> “to go faster than a walk”---“ Ir más rápido que un paseo”
• “write” -> “to form (as characters or symbols) on a surface with an
instrument (as a pen)”---“ Para formar (como caracteres o símbolos)
en una superficie con un instrumento (como una pluma)”
Esto es un mapeo entre palabras y la definición de cada palabra, o una

tabla de hash como en cualquier lenguaje de programación. Utiliza una
clave de cadena para otro valor de una cadena. La entrada es el
diccionario con una clave y la salida es un valor. Así es como funciona la
mayoría de las redes neuronales. Una red neural llamada Memoria
Asociativa Bidireccional (BAM) permite al usuario pasar el valor y recibir
la clave.
Las tablas de hash utilizan claves y valores. Piense en el patrón enviado

a la capa de entrada de la red neuronal como la clave de la tabla hash.
Del mismo modo, piense en el valor devuelto de la tabla de hash como el
patrón devuelto de la capa de salida de la red neuronal. La comparación
entre una tabla hash y una red neuronal funciona bien; Sin embargo, la
red neuronal es mucho más que una tabla hash.
¿Qué pasaría con la tabla hash anterior si se pasó una palabra que no
era una clave de mapa? Por ejemplo, pase en la clave "escribió". Una
tabla hash devolverá null o indicará de alguna manera que no pudo
encontrar la clave especificada. Las redes neuronales no devuelven null,
sino que encuentran la coincidencia más cercana. No sólo encuentran la
coincidencia más cercana, las redes neuronales modifican la salida para
estimar el valor faltante. Así que si "escribió" se pasa a la red neural
arriba, la salida probablemente sería "escribir". No hay suficientes datos
para que la red neuronal haya modificado la respuesta, ya que sólo hay
tres muestras. Así que probablemente obtendrá la salida de una de las
otras claves.
El mapa anterior trae a colación un punto muy importante acerca de las

redes neurales. Recuerde que las redes neuronales aceptan una matriz
de números de punto flotante y devuelven otra matriz. ¿Cómo se
pondrían las cuerdas en la red neuronal como se ve arriba? Si bien hay
maneras de hacerlo, es mucho más fácil tratar los datos numéricos que
las cadenas.
Con un problema de red neuronal, las entradas deben ser matrices de

números de coma flotante. Este es uno de los aspectos más difíciles de
la programación de redes neuronales. ¿Cómo se traducen los problemas
a una matriz de longitud fija de números en coma flotante? La mejor
manera es por demostración. Se exploran ejemplos a lo largo del resto
de esta introducción.
xxvi Introduction
0.2.2 Un ejemplo simple
La mayoría de la literatura básica sobre redes neuronales proporciona
ejemplos con el operador XOR. El operador XOR es esencialmente el
"Hello World" de la programación de redes neuronales. Aunque este libro
describirá escenarios mucho más complejos que XOR, el operador XOR
es una gran introducción.
Para comenzar, vea el operador XOR como si se tratara de una tabla
hash. Los operadores XOR funcionan de forma similar a los operadores
AND y OR. Para que un Y sea verdadero, ambos lados deben ser
verdad. Para que un OR sea verdadero, cada lado debe ser verdadero.
Para que un XOR sea verdadero, ambos lados deben ser diferentes
entre sí. La tabla de verdad para un XOR es la siguiente.
F a l s e XOR F a l s e = F a l s e
True XOR F a l s e = True
F a l s e XOR True = True
True XOR True = F a l s e
Para continuar con el ejemplo de tabla de hash, la tabla de verdad

anterior se representará de la siguiente manera.
[ 0.0 , 0.0 ] −> [ 0 . 0 ]
[ 1.0 , 0.0 ] −> [ 1 . 0 ]
[ 0 . 0 , 1 . 0 ] −> [ 1.0 ]
[ 1 . 0 , 1 . 0 ] −> [ 0.0 ]
Estos mapas muestran la entrada y el resultado esperado ideal para la

red neural.
0.3 Cuándo utilizar redes neuronales

Con redes neuronales definidas, debe determinarse cuándo o cuándo no
utilizarlas. Saber cuándo no usar algo es tan importante como saber cómo
usarlo. Para entender estos objetivos, identificaremos qué tipo de
problemas Encog es capaz de resolver.
0.3 Cuándo utilizar redes neuronales xxvii
Un objetivo importante de este libro es explicar cómo construir redes

neuronales Encog y cuándo usarlas. Los programadores de redes
neuronales deben entender qué problemas son adecuados para las
soluciones de redes neuronales y cuáles no. Un programador de red
neuronal e fi ctiva también sabe qué estructura de red neural, si la hay, es
la más aplicable a un problema dado. Esta sección comienza
identificando qué problemas no son conducentes a una solución de red
neural.
0.3.1 Problemas no adecuados a una solución de red
neuronal
Los programas que se escriben fácilmente como diagramas de flujo no
son aplicaciones ideales para redes neuronales. Si su programa consiste
en pasos bien definidos, técnicas de programación normales serán
suficientes.
Otro criterio a considerar es si es probable que la lógica del programa
cambie. Una de las principales características de las redes neuronales es
la capacidad de aprender. Si el algoritmo utilizado para resolver su
problema es una regla de negocio inmutable, no hay razón para utilizar
una red neuronal. De hecho, una red neuronal podría ser perjudicial para
su aplicación si intenta encontrar una solución mejor y comienza a divergir
del proceso deseado. Es probable que se produzcan resultados
inesperados.
Por último, las redes neuronales a menudo no son adecuadas para
problemas que requieren un camino claramente trazable a la solución.
Una red neuronal puede ser muy útil para resolver el problema para el
cual fue entrenada, pero no puede explicar su razonamiento. La red
neuronal sabe algo porque fue entrenada para conocerla. Sin embargo,
una red neural no puede explicar la serie de pasos seguidos para obtener
la respuesta.
0.3.2 Problemas adecuados para una red neuronal
Aunque hay muchos problemas para los cuales las redes neurales no
son adecuadas, también hay muchos problemas para los cuales una
solución de red neural es bastante útil. Además, las redes neuronales
a menudo pueden resolver problemas con menos líneas de código
que los algoritmos de programación tradicionales. Es importante
entender qué problemas requieren un enfoque de redes neuronales.
Las redes neuronales son particularmente útiles para resolver problemas

que no pueden expresarse como una serie de pasos. Esto puede incluir
patrones de reconocimiento, clasificación, predicción en serie y minería
de datos.
El reconocimiento de patrones es quizás el uso más común para las
redes neuronales. Para este tipo de problema, la red neuronal se
presenta un patrón en forma de una imagen, un sonido u otros datos. La
red neural entonces intenta determinar si los datos de entrada coinciden
con un patrón que ha sido entrenado para reconocer. El resto de este libro
de texto examinará muchos ejemplos de cómo utilizar redes neuronales
para reconocer patrones.
La clasificación es un proceso que está estrechamente relacionado con el

reconocimiento de patrones. Una red neuronal entrenada para la
clasificación está diseñada para clasificar las muestras de entrada en
grupos. Estos grupos pueden ser difusos y carecen de límites claramente
definidos. Alternativamente, estos grupos pueden tener límites bastante
rígidos.
xxviii Introduction
0.4 Estructura del libro

Este libro comienza con el capítulo 1, "Regresión, clasificación y
agrupación". En este capítulo se presentan las principales tareas
realizadas con redes neuronales. Estas tareas no sólo son realizadas por
redes neuronales, sino también por muchos otros métodos de aprendizaje
automático.
Una de las principales tareas de las redes neuronales es reconocer y
proporcionar información sobre los datos. El capítulo 2, "Obtención de
datos y normalización", muestra cómo procesar estos datos antes de
utilizar una red neuronal. Este capítulo examinará algunos datos que
podrían utilizarse con una red neuronal y cómo normalizar y utilizar estos
datos con una red neuronal.
Encog incluye un editor de red neuronal GUI llamado Encog
Workbench. Capítulo 3, "Utilización de Encog Workbench", detalla los
mejores métodos y usos para esta aplicación. Encog Workbench
proporciona una herramienta GUI que puede editar los archivos de
datos .EG utilizados por Encog Framework. El poderoso Encog Analyst
también se puede utilizar para automatizar muchas tareas.
El siguiente paso es construir y salvar redes neuronales. El capítulo 4,
"Construyendo redes neuronales en C #", muestra cómo crear redes
neuronales usando capas y funciones de activación. También ilustrará
cómo guardar redes neurales para archivos independientes de la
plataforma .EG o serialización estándar de C #.
0.4 Estructura del libro xxix
Las redes neuronales deben ser entrenadas para la utilización efectiva

y existen varias formas de realizar esta capacitación. Capítulo 5,
"Formación de Propagación", muestra cómo utilizar los métodos de
propagación incorporados en Encog para entrenar redes neuronales.
Encog soporta backpropagation, propagación elástica, la regla de
actualización de Manhattan, Quick Propagation y SCG.
El Capítulo 6, "Otros métodos supervisados de entrenamiento",
muestra otros algoritmos de entrenamiento supervisados apoyados
por Encog. Este capítulo introduce el recocido simulado y los
algoritmos genéticos como técnicas de entrenamiento para redes
Encog. El Capítulo 6 también detalla cómo crear algoritmos de
entrenamiento híbridos.
Las redes neurales feedforward no son el único tipo soportado por
Encog. Capítulo 7, "Otros tipos de redes neuronales", proporciona una
breve introducción a varios otros tipos de redes neuronales que Encog
soporta bien. El Capítulo 7 describe cómo configurar las redes
neuronales NEAT, ART1 y Elman / Jordan.
Las redes neuronales se utilizan comúnmente para predecir futuros
cambios de datos. Un uso común para esto es predecir las tendencias
del mercado de valores. El Capítulo 8, "Uso de datos temporales",
mostrará cómo usar Encog para predecir tendencias.
Las imágenes se utilizan con frecuencia como una entrada para las
redes neuronales. Encog contiene clases que facilitan el uso de datos
de imagen para alimentar y entrenar redes neuronales. Capítulo 9,
"Utilización de datos de imagen", muestra cómo utilizar datos de
imagen con Encog.
Por último, el Capítulo 10, "Usando mapas de organización personal",
se expande más allá del entrenamiento supervisado para explicar
cómo usar el entrenamiento sin supervisión con Encog. Se puede
utilizar un mapa de organización personal (SOM) para agrupar datos.
A medida que lea este libro sin duda tendrá preguntas sobre el Encog
Framework. Sus mejores recursos son los foros de Encog en Heaton
Research, que se encuentran en la siguiente URL.
Http://www.heatonresearch.com/forum
Además, el Encog Wiki, ubicado en la siguiente URL.
Http://www.heatonresearch.com/wiki/Main_Page
1
Capitulo 1
Regresión, Clacificación &

Clustering
• Clasificación de datos
• Análisis de Regresión de Datos
• Datos de agrupación
• Cómo se estructuran los problemas de aprendizaje de la máquina
Mientras que hay otros modelos, la regresión, la clasificación y la

agrupación son las tres maneras primarias que los datos se evalúan para
los problemas de aprendizaje de la máquina. Estos tres modelos son los
más comunes y el enfoque de este libro. Las siguientes secciones le
presentarán a la clasificación, regresión y agrupación.
1.1 Clasificación de datos
La clasificación intenta determinar en qué clase caen los datos de
entrada. Clasificación es por lo general una operación de entrenamiento
supervisado, lo que significa que el usuario proporciona datos y
resultados esperados a la red neuronal. Para la clasificación de datos, el
resultado esperado es la identificación de la clase de datos.
2 Regresión, clasificación y agrupación
Las redes neuronales supervisadas siempre son

entrenadas con datos conocidos. Durante el
entrenamiento, las redes se evalúan en la forma
en que clasifican los datos conocidos. La
esperanza es que la red neural, una vez
entrenada, pueda clasificar los datos
desconocidos también.
Fisher's Iris Dataset es un ejemplo de
clasificación. Este es un conjunto de datos que
contiene mediciones de flores de iris. Este es
uno de los conjuntos de datos más famosos y se
utiliza a menudo para evaluar los métodos de
aprendizaje de la máquina. El conjunto de datos
completo está disponible en la siguiente URL.
Http://www.heatonresearch.com/wiki/Iris
Conjunto de datos A continuación se muestra un
pequeño muestreo del conjunto de datos Iris.
” S e p a l Length ” , ” S e p a l Width” , ” P e t a l Length ” , ” P e t a l Width” , ” S p e c i e s
”
5.1,3.5,1.4,0.2,”setosa”4.
9,3.0,1.4,0.2,”setosa”4.7,
3.2,1.3,0.2,”setosa”
...
7.0,3.2,4.7,1.4,”versicolor”
6.4,3.2,4.5,1.5,”versicolor”
6.9,3.1,4.9,1.5,”versicolor”
...
6.3,3.3,6.0,2.5,”virginica”
5.8,2.7,5.1,1.9,”virginica”
7.1,3.0,5.9,2.1,”virginica”
Los datos anteriores se muestran como un archivo CSV. CSV es un
formato de entrada muy común para una red neuronal. La primera fila
suele ser una definición para cada una de las columnas del archivo.
Como se puede ver, para cada una de las flores hay cinco piezas de
información que se proporcionan.
• Longitud Sepal
• Ancho de sepal
• Longitud de los pétalos
• Anchura de los pétalos
•Especies
1.2 Análisis de regresión 3
Para la clasificación, se indica a la red neural que, dada la longitud /

anchura del sepal y la longitud / anchura del pétalo, se puede determinar
la especie de la flor. La especie es la clase.
Una clase suele ser un atributo de datos no numéricos y, como tal, la
pertenencia a la clase debe estar bien definida. Para el conjunto de datos
Iris, hay tres tipos diferentes de iris. Si una red neuronal está entrenada en
tres tipos de iris, no se puede esperar que identifique una rosa. Todos los
miembros de la clase deben ser conocidos en el momento del
entrenamiento.
1.2 Análisis de regresión

En la última sección, aprendimos a usar los datos para clasificar los
datos. A menudo, la salida deseada no es simplemente una clase, sino un
número. Considere el cálculo de millas de un automóvil por galón (MPG).
Siempre que se proporcionen datos tales como el tamaño del motor y el
peso del automóvil, se puede calcular el MPG del vehículo especificado.
Considere los siguientes datos de muestra para cinco coches:
”mpg” , ” c y l i n d e r s ” , ” d i s p l a c e m e n t ” , ” horsepower ” , ” weight ” , ”
a c c e l e r a t i o n ” , ” model y e a r ” , ” o r i g i n ” , ” c a r name”
1 8 . 0 , 8 , 3 0 7 . 0 , 1 3 0 . 0 , 3 5 0 4 . , 1 2 . 0 , 7 0 , 1, ” c h e v r o l e t c h e v e l l e malibu ”
1 5 . 0 , 8 , 3 5 0 . 0 , 1 6 5 . 0 , 3 6 9 3 . , 1 1 . 5 , 7 0 , 1, ” b u i c k s k y l a r k 320 ”
1 8 . 0 , 8 , 3 1 8 . 0 , 1 5 0 . 0 , 3 4 3 6 . , 1 1 . 0 , 7 0 , 1, ” plymouth s a t e l l i t e ”
1 6 . 0 , 8 , 3 0 4 . 0 , 1 5 0 . 0 , 3 4 3 3 . , 1 2 . 0 , 7 0 , 1, ”amc r e b e l s s t ”
17.0,8,302.0,140.0,3449.,10.5,70,1,”for
dtorino” ...
Para obtener más información, la totalidad de este conjunto de datos

se puede encontrar en:
Http://www.heatonresearch.com/wiki/MPG_Data_Set
La idea de la regresión es entrenar la red neuronal con los datos de
entrada sobre el coche. Sin embargo, utilizando la regresión, la red no
producirá una clase. Se espera que la red neural proporcione las millas
por galón que probablemente el coche especificado obtendría.
También es importante tener en cuenta que no se utiliza cada pieza de
datos en el archivo anterior se utilizará. No se utilizan las columnas
"nombre del coche" y "origen". El nombre de un coche no tiene nada que
ver con su e fi cacia de combustible y por lo tanto está excluido. Del
mismo modo, el origen no contribuye a esta ecuación. El origen es un
valor numérico que especifica en qué región geográfica se produjo el
automóvil. Si bien algunas regiones se enfocan en la eficiencia del
combustible, este dato es demasiado amplio para ser útil.
4 Regresión, Clasificación & Clustering
1.3 Clustering
Otro tipo común de análisis es la agrupación. A diferencia de los dos
tipos de anal-ysis anteriores, el agrupamiento es normalmente sin
supervisión. Cualquiera de los conjuntos de datos de las dos secciones
anteriores podría utilizarse para la agrupación. La diferencia es que el
análisis de agrupamiento no requeriría que el usuario proporcionara la
especie en el caso del conjunto de datos Iris, o el número MPG para el
conjunto de datos MPG. Se espera que el algoritmo de agrupamiento
coloque los elementos de datos en grupos que correspondan a la especie
o MPG.
Para el agrupamiento, el método de aprendizaje de la máquina
simplemente mira los datos e intenta colocar esos datos en una serie de
clusters. El número de clusters esperados debe ser definido de antemano.
Si el número de clusters cambia, el método de aprendizaje de la máquina
de agrupación tendrá que volver a entrenarse.
Clustering es muy similar a la clasificación, con su salida es un clúster,
que es similar a una clase. Sin embargo, el agrupamiento diferencia a la
regresión ya que no proporciona un número. Por lo tanto, si el clustering
se utilizaba con el conjunto de datos MPG, la salida tendría que ser un
cluster en el que caiga el automóvil. Tal vez cada grupo especifique el
nivel variable de eficiencia de combustible para el vehículo. Quizás los
grupos agruparían los coches en racimos que demostraran una cierta
relación que todavía no se había notado.
1.4 Estructuración de una red neuronal

Ahora se identifican los tres principales modelos de problemas para
redes neuronales, es hora de examinar cómo los datos se presentan
realmente a la red neuronal. Esta sección se centra principalmente en
cómo la red neuronal está estructurada para aceptar elementos de
datos y proporcionar resultados. El siguiente capítulo detallará cómo
normalizar los datos antes de ser presentados a la red neuronal.
Las redes neuronales suelen estar en capas con una capa de entrada
y salida como
1.4 Estructuración de una red neuronal 5
mínimo. También puede haber capas ocultas. Algunos tipos de redes

neuronales no se dividen en capas formales más allá de la capa de
entrada y salida. Sin embargo, la capa de entrada y la capa de salida
estarán siempre presentes y se pueden incorporar en la misma capa.
Ahora examinaremos la capa de entrada, la capa de salida y las capas
ocultas.
1.4.1 Descripción de la capa de entrada
La capa de entrada es la primera capa de una red neuronal. Esta capa, como
todas las capas, contiene un número específico de neuronas. Las neuronas de
una capa contienen propiedades similares. Típicamente, la capa de entrada
tendrá una neurona para cada atributo que usará la red neuronal para la
clasificación, regresión o agrupación.
Considere los ejemplos anteriores. El conjunto de datos Iris tiene cuatro
neuronas de entrada. Estas neuronas representan la anchura / longitud del
pétalo y la anchura / longitud del sepal. El conjunto de datos MPG tiene más
neuronas de entrada. El número de neuronas de entrada no siempre
corresponde directamente al número de atributos y algunos atributos tomarán
más de una neurona para codificar. Este proceso de codificación, llamado
normalización, se tratará en el próximo capítulo.
El número de neuronas determina cómo se estructura la entrada de una
capa. Para cada neurona de entrada, se almacena un valor doble. Por ejemplo,
la matriz siguiente podría utilizarse como entrada a una capa que contenía cinco
neuronas.
double [ ] i n p u t = new double [ 5 ] ;
La entrada a una red neuronal es siempre una matriz del tipo double. El tamaño
de esta matriz corresponde directamente al número de neuronas en la capa de
entrada. Encog utiliza la interfaz IMLData para definir clases que contienen
estas matrices. La matriz anterior puede convertirse fácilmente en un objeto
IMLData con la siguiente línea de código.
IMLData data = new BasicMLData ( i n p u t ) ;

La interfaz IMLData define cualquier tipo de "matriz como" los datos que se pueden
presentar a Encog. La entrada siempre debe presentarse a la red neuronal dentro de un
objeto IMLData. La clase BasicMLData implementa la interfaz IMLData. Sin embargo, la
clase BasicMLData no es la única forma de proporcionar
6 Regression, Classification & Clustering
Encog con datos. Otras implementaciones de IMLData se utilizan para

tipos de datos más especializados.
La clase BasicMLData simplemente proporciona un soporte de datos
basado en memoria para los datos de red neuronal. Una vez que la red
neural procesa la entrada, una clase basada en IMLData será devuelta de
la capa de salida de la red neuronal. La capa de salida se analiza en la
siguiente sección.
1.4.2 Descripción de la capa de salida
La capa de salida es la capa final de una red neuronal. Esta capa
proporciona la salida después de que todas las capas anteriores hayan
procesado la entrada. La salida de la capa de salida está formateada de
forma muy similar a los datos que se proporcionaron a la capa de entrada. La
red neural produce una serie de dobles.
La red neural envuelve la salida en una clase basada en la interfaz
IMLData. La mayoría de los tipos de red neural incorporados devuelven una
clase BasicMLData como salida. Sin embargo, las clases de redes
neuronales futuras y de terceros pueden devolver clases diferentes basadas
en otras implementaciones de la interfaz IMLData.
Las redes neuronales están diseñadas para aceptar entrada (una matriz
de dobles) y luego producir salida (también una matriz de dobles).
Determinar cómo estructurar los datos de entrada y adjuntar significado a la
salida son los dos desafíos principales de adaptar un problema a una red
neuronal. El poder real de una red neuronal proviene de sus capacidades de
reconocimiento de patrones. La red neuronal debe ser capaz de producir la
salida deseada incluso si la entrada ha sido ligeramente distorsionada.Las
redes neuronales de regresión producen típicamente una única neurona de
salida que proporciona el valor numérico producido por la red neuronal.
Pueden existir múltiples neuronas de salida si se supone que la misma red
neuronal predice dos o más números para las entradas dadas.
La clasificación produce una o más neuronas de salida, dependiendo de

cómo se codificó la clase de salida. Hay varias maneras diferentes de
codificar las clases. Esto se discutirá con mayor detalle en el próximo
capítulo.
El agrupamiento se configura de forma similar a como las neuronas de
salida identifican qué datos pertenecen a qué grupo.
1.4 Estructuración de una red neuronal 7
1.4.3 Capas ocultas

Como se discutió anteriormente, las redes neuronales contienen y
capa de entrada y una capa de salida. A veces, la capa de entrada y la
capa de salida son las mismas, pero suelen ser dos capas separadas.
Además, pueden existir otras capas entre las capas de entrada y
salida y se denominan capas ocultas. Estas capas ocultas se insertan
simplemente entre las capas de entrada y salida. Las capas ocultas
también pueden asumir estructuras más complejas.
El único propósito de las capas ocultas es permitir que la red neural

produzca mejor la salida esperada para la entrada dada. La
programación de redes neuronales implica primero definir los
recuentos de neuronas de la capa de entrada y salida. Una vez que se
determina cómo traducir el problema de programación en los conteos
de neuronas de entrada y salida, es hora de definir las capas ocultas.
Las capas ocultas son en gran medida una "caja negra". El problema
se define en términos de los recuentos de neuronas para las capas
ocultas y de salida. Cuando la red neural produce la salida correcta se
realiza en parte por capas ocultas. Una vez que se define la estructura
de las capas de entrada y salida, también se debe definir la estructura
de capa oculta que aprende de forma óptima el problema.
El desafío es evitar crear una estructura oculta que sea demasiado

compleja o demasiado simple. Demasiado complejo de una estructura
oculta tomará demasiado tiempo para entrenar. Demasiado simple de
una estructura oculta no aprenderá el problema. Un buen punto de
partida es una sola capa oculta con un número de neuronas igual al
doble de la capa de entrada. Dependiendo del rendimiento de esta
red, el número de neuronas de la capa oculta aumenta o disminuye.
Los desarrolladores a menudo se preguntan cuántas capas ocultas

usar. Algunas investigaciones han indicado que una segunda capa
oculta rara vez es de cualquier valor. Encog es una excelente manera
de realizar una búsqueda de prueba y error para la configuración de
capa oculta más óptima. Para obtener más información, consulte la
siguiente URL:
Http://www.heatonresearch.com/wiki/Hidden_Layers
8 Regresióm, Clasificación & Clustering
Algunas redes neuronales no tienen capas ocultas, con la capa de

entrada directamente conectada a la capa de salida. Además, algunas redes
neuronales tienen sólo una sola capa en la que la capa única está auto-
conectada. Estas conexiones permiten que la red aprenda. Contenido en
estas conexiones, llamadas sinapsis, son matrices individuales de peso.
Estos valores se cambian a medida que la red neuronal aprende. El capítulo
siguiente profundiza en las matrices de peso.
1.5 Uso de una red neuronal

Esta sección detallará cómo estructurar una red neuronal para un
problema muy simple: diseñar una red neuronal que pueda funcionar
como un operador XOR. Aprender el operador XOR es un "primer
ejemplo" frecuente al demostrar la arquitectura de una nueva red
neuronal. Al igual que la mayoría de los nuevos lenguajes de
programación se demuestran por primera vez con un programa que
simplemente muestra "Hello World", las redes neuronales se demuestran
con frecuencia con el operador XOR. Aprender el operador XOR es una
especie de aplicación "Hello World" para redes neuronales.
1.5.1 El Operador XOR y las Redes Neuronales

El operador XOR es uno de los operadores lógicos Booleanos comunes.
Los otros dos son los operadores AND y OR. Para cada uno de estos
operadores lógicos, hay cuatro combinaciones diferentes. A continuación
se muestran todas las combinaciones posibles para el operador AND.
0 AND 0 = 0
1 AND 0 = 0
0 AND 1 = 0
1 AND 1 = 1
Esto debería ser coherente con la forma en que aprendió el operador
AND para la programación de computadoras. Como su nombre indica, el
operador AND sólo devolverá true, o uno, cuando ambas entradas son
verdaderas.
1.5 Uso de una red neuronal 9
El operador OR se comporta de la siguiente manera:

0 OR 0 = 0
1 OR 0 = 1
0 OR 1 = 1
1 OR 1 = 1
Esto también debería ser coherente con la forma en que aprendió el

operador OR para la programación de computadoras. Para que el
operador OR sea true, cualquiera de las entradas debe ser true.
El operador "exclusivo o" (XOR) es menos utilizado en la
programación de computadoras. XOR tiene la misma salida que el
operador OR, excepto en el caso en que ambas entradas son true. Aquí
se muestran las combinaciones posibles para el operador XOR.
0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0
Como puede ver, el operador XOR sólo devuelve true cuando ambas
entradas difieren. La siguiente sección explica cómo estructurar las capas
de entrada, salida y oculta para el operador XOR.
1.5.2 Estructuración de una red neuronal para XOR
Hay dos entradas para el operador XOR y una salida. Las capas de
entrada y salida se estructurarán en consecuencia. Las neuronas de
entrada se alimentan con los siguientes valores dobles:
0.0,0.0
1.0,0.0
0.0,1.0
1.0,1.0
Estos valores corresponden a las entradas del operador XOR, mostradas

anteriormente. Se espera que la única neurona de salida produzca los
siguientes valores double:
0 0
0 1
1.0
0.0
Esta es una forma en que la red neuronal puede ser estructurada. Este
método permite a una simple red neuronal feedforward aprender el
operador XOR. La red neuronal feedforward, también llamada perceptron,
es una de las primeras arquitecturas de redes neuronales que
aprenderemos.
Hay otras maneras en que los datos XOR podrían ser presentados a la
red neuronal. Más adelante en este libro, se explorarán dos ejemplos de
redes neuronales recurrentes, incluyendo los estilos Elman y Jordan de
redes neuronales. Estos meth-ods tratarían los datos XOR como una
secuencia larga, concatenando básicamente la tabla de verdad para XOR
juntos, resultando en una secuencia larga de XOR, como:
0.0,0.0,0.0,0
.0,1.0,1.0,1.
0,0.0,1.0,1.0
,1.0,0.0
Los saltos de línea son sólo para la legibilidad; La red neural trata
XOR como una secuencia larga. Usando los datos anteriores, la red tiene
una única neurona de entrada y una única neurona de salida. La neurona
de entrada recibe un valor de la lista anterior y se espera que la neurona
de salida devuelva el siguiente valor.
Esto demuestra que a menudo hay múltiples formas de modelar los
datos de una red neuronal. La forma en que se modelan los datos influirá
grandemente en el éxito de una red neuronal. Si un modelo en particular
no funciona, se debe considerar otro. El siguiente paso es dar formato a
los datos XOR para una red neuronal feedforward.
Debido a que el operador XOR tiene dos entradas y una salida, la red
neural sigue el ejemplo. Además, la red neuronal tiene una única capa
oculta con dos neuronas para ayudar a procesar los datos. La elección de
dos neuronas en la capa oculta es arbitraria ya menudo resulta en prueba
y error. El problema XOR es simple y dos neuronas ocultas son su fi
cientes para resolverlo. En la figura 1.1 se muestra un diagrama para esta
red.
Figure 1.1: Diagrama de neuronas para la red XOR
Hay cuatro tipos diferentes de neuronas en la red anterior. Se resumen

a continuación:
• Neuronas de entrada: I1, I2
• Neurona de salida: O1
• Neuronas Ocultas: H1, H2
• Neuronas polarizadas: B1, B2
La entrada, la salida y las neuronas ocultas fueron discutidos
previamente. El nuevo tipo de neurona visto en este diagrama es la
neurona de polarización. Una neurona de polarización siempre genera un
valor de 1 y nunca recibe la entrada de la capa anterior.
En pocas palabras, las neuronas de polarización permiten a la red
neuronal aprender patrones de forma más efectiva. Sirven una función
similar a las neuronas ocultas. Sin las neuronas de polarización, es muy
difícil para la red neural para emitir un valor de uno cuando la entrada es
cero. Esto no es tanto un problema para los datos XOR, sino que puede
ser para otros conjuntos de datos. Para obtener más información sobre su
función exacta, visite la siguiente URL:
Http://www.heatonresearch.com/wiki/Bias
Ahora mira el código usado para producir una red neuronal que
resuelve el operador XOR. El código completo se incluye con los
ejemplos Encog y se puede encontrar en la siguiente ubicación.
Encog . Examples .XOR. XORHelloWorld
Para ejecutar este ejemplo, utilice el comando siguiente.
ConsoleExamples xor
El ejemplo comienza creando la red neural vista en la Figura 1.1. El

código necesario para crear esta red es relativamente simple:
var network = new BasicNetwork ( ) ;
network . AddLayer (new B a s i c L a y e r ( null , true , 2) ) ;
network . AddLayer (new B a s i c L a y e r (new A c t i v a t i o n S i g m o i
d ( ) , true , 3) ) ;
network . AddLayer (new B a s i c L a y e r (new A c t i v a t i o n S i g m o i
d ( ) , false , 1) ) ;
network . S t r u c t u r e . F i n a l i z e S t r u c t u
r e ( ) ; network . Reset ( ) ;
En el código anterior, se está creando BasicNetwork. Se añaden tres

capas a esta red. La primera capa, que se convierte en la capa de
entrada, tiene dos neuronas. La capa oculta se agrega en segundo lugar
y tiene dos neuronas también. Por último, la capa de salida se añade y
tiene una sola neurona. Finalmente, se llama al método FinalizeStructure
para informar a la red que no se deben añadir más capas. La llamada a
Reset aleatoriza los pesos en las conexiones entre estas capas.
Las redes neuronales siempre comienzan con valores de peso al azar.
Un proceso llamado entrenamiento refina estos pesos a valores que
proporcionarán la salida deseada. Debido a que las redes neuronales
siempre comienzan con valores aleatorios, se producen resultados muy
diferentes a partir de dos ejecuciones del mismo programa. Algunos
pesos al azar proporcionan un mejor punto de partida que otros. A veces
los pesos aleatorios serán lo suficientemente lejos como para que la red
no aprenda. En este caso, los pesos se deben volver a asignar al azar y
el proceso se reiniciará.
También notará la clase ActivationSigmoid en el código anterior. Esto
especifica la red neuronal para utilizar la función de activación sigmoide.
Las funciones de activación se tratarán en el capítulo 4. Las funciones de
activación sólo se colocan en la capa oculta y de salida; La capa de
entrada no tiene una función de activación. Si se especificó una función
de activación para la capa de entrada, no tendría efecto.
Cada capa también especifica un valor bool. Este valor de bool especifica
si las neuronas de polarización están presentes en una capa o no. La capa
de salida, como se muestra en la Figura 1.1, no tiene una neurona de
polarización como entrada y las capas ocultas lo hacen. Esto se debe a que
una neurona de polarización sólo está conectada a la siguiente capa. La
capa de salida es la capa final, por lo que no hay necesidad de una neurona
de sesgo. Si se especificó una neurona de polarización en la capa de salida,
no tendría efecto.
Estos pesos constituyen la memoria a largo plazo de la red neuronal.
Algunas redes neuronales también contienen capas de contexto que dan a la
red neuronal una memoria a corto plazo también. La red neural aprende
modificando estos valores de peso. Esto también es cierto en las redes
neuronales de Elman y Jordan.
Ahora que la red neuronal ha sido creada, debe ser entrenada. La
formación es el proceso en el que los pesos aleatorios se refinan para
producir la producción más cerca de la salida deseada. La capacitación se
discute en la siguiente sección.
1.5.3 Formación de una red neuronal
Para formar la red neuronal, se construye un objeto IMLDataSet. Este
objeto contiene las entradas y los resultados esperados. Para construir
este objeto, se crean dos matrices. La primera matriz conservará los
valores de entrada para el operador XOR. La segunda matriz tendrá las
salidas ideales para cada uno de los cuatro valores de entrada
correspondientes. Éstos corresponderán a los valores posibles para XOR.
Para revisar, los cuatro valores posibles son los siguientes:
0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0
Primero, construya una matriz para mantener los cuatro valores de

entrada al operador XOR usando una matriz double bidimensional. Esta
matriz es la siguiente:
public s t a t i c double [ ] [ ] XORInput = {
new [ ] {0 . 0 , 0 . 0 } ,
new [ ] {1 . 0 , 0 . 0 } ,
new [ ] {0 . 0 , 1 . 0 } ,
new [ ] {1 . 0 , 1 . 0 }
};
Del mismo modo, se debe crear una matriz para las salidas esperadas
para cada uno de los valores de entrada. Esta matriz es la siguiente:
public s t a t i c double [ ] [ ] XORIdeal = {

new [ ] {0 . 0 } ,
new [ ] {1 . 0 } ,
new [ ] {1 . 0 } ,
new [ ] {0 . 0 }
};
Aunque sólo hay un valor de salida, se debe utilizar un arreglo

bidimensional para representar la salida. Si hay más de una neurona de
salida, se añaden columnas adicionales a la matriz.
Ahora que se construyen las dos matrices de entrada, se debe crear
un objeto IMLDataSet para contener el conjunto de entrenamiento. Este
objeto se crea de la siguiente manera:
IMLDataSet t r a i n i n g S e t = new BasicMLDataSet ( XORInput , XORIdeal ) ;
Ahora que el conjunto de entrenamiento ha sido creado, la red neural puede
ser entrenada. El entrenamiento es el proceso donde los pesos de la red neural
se ajustan para producir mejor la salida esperada. La formación continuará
durante muchas iteraciones hasta que la tasa de error de la red esté por debajo
de un nivel aceptable. Primero, se debe crear un objeto de entrenamiento.
Encog admite muchos tipos diferentes de entrenamiento.
Para este ejemplo se utiliza el entrenamiento de Resilient Propagation
(RPROP). RPROP es quizás el mejor algoritmo de entrenamiento de propósito
general apoyado por Encog. Se proporcionan otras técnicas de entrenamiento,
así como ciertos problemas se resuelven mejor con ciertas técnicas de
entrenamiento. El código siguiente crea un entrenador RPROP:
IMLTrain t r a i n = new R e s i l i e n t P r o p a g a t i o n ( network , t r a i n i n g S e t ) ;

Todas las clases de entrenamiento implementan la interfaz IMLTrain. El algoritmo
RPROP es implementado por la clase ResilientPropagation, la cual está estructurada
anteriormente.
Una vez que el entrenador es construido, la red neuronal debe ser entrenado. El
entrenamiento de la red neuronal implica llamar al método Iteration en la clase IMLTrain
hasta que el error esté por debajo de un valor específico. El error es el grado en que la
salida de la red neural coincide con la salida deseada.
do
{
1.5 Using a Neural Network 15
train.Iteration();
Console . WriteLine (@” Epoch #” + epoch + @” Error:”
+train.Error);
epoch++;
} while ( t r a i n . E r r o r > 0 . 0 1 ) ;
El código anterior loops a través de tantas iteraciones, o épocas, como se

tarda en obtener la tasa de error de la red neuronal por debajo del 1%.
Una vez que la red neuronal ha sido entrenada, está lista para su uso. La
siguiente sección explicará cómo usar una red neuronal.
1.5.4 Ejecución de una red neuronal

Hacer uso de la red neuronal implica llamar al método Compute en la
clase BasicNetwork. Aquí vamos a través de todos los valores de conjunto
de entrenamiento y mostrar la salida de la red neuronal:
Console . WriteLine (@” Neural Network R e s u l t s : ” ) ;
f o r e a c h ( IMLDataPair p a i r i n t r a i n i n g S e t )
{
IMLData output = network . Compute ( p a i r . Input ) ;
Console . WriteLine ( p a i r . Input [ 0 ] + @” , ” + p a i r . Input [ 1 ]
+ @” , a c t u a l=” + output [ 0 ] + @” , i d e a l=” + p a i r . I d e a l [ 0 ] ) ;
}
El método Compute acepta una clase IMLData y también devuelve otro

objeto IMLData. El objeto devuelto contiene la salida de la red neuronal, que
se muestra al usuario. Con el programa ejecutado, los resultados de la
formación se muestran por primera vez. Para cada época, se muestra la tasa
de error actual.
Epoch #1 E r r o r : 0 . 5 6 0 4 4 3 7 5 1 2 2 9 5 2 3 6
Epoch #2 E r r o r : 0 . 5 0 5 6 3 7 5 1 5 5 7 8 4 3 1 6
Epoch #3 E r r o r : 0 . 5 0 2 6 9 6 0 7 2 0 5 2 6 1 6 6
Epoch #4 E r r o r : 0 . 4 9 0 7 2 9 9 4 9 8 3 9 0 5 9 4
...
Epoch #104 E r r o r : 0 . 0 1 0 1 7 2 7 8 3 4 5 7 6 6 4 7 2
Epoch #105 E r r o r : 0 . 0 1 0 5 5 7 2 0 2 0 7 8 6 9 7 7 5 1
Epoch #106 E r r o r : 0 . 0 1 1 0 3 4 9 6 5 1 6 4 6 7 2 8 0 6
Epoch #107 E r r o r : 0 . 0 0 9 6 8 2 1 0 2 8 0 8 6 1 6 3 8 7
El error comienza en el 56% en la época 1. Por la época 107, el

entrenamiento cayó por debajo del 1% y el entrenamiento se detiene.
Debido a que la red neuronal se inicializó con pesos aleatorios, puede
tomar diferentes números de iteraciones para entrenar cada vez que se
ejecuta el programa. Además, aunque la tasa de error final puede ser
diferente, siempre debe terminar por debajo del 1%.
Por último, el programa muestra los resultados de cada uno de los
elementos de formación de la siguiente manera:
Neural Network R e s u l t s :
0 . 0 , 0 . 0 , a c t u a l =0.002782538818034049 , i d e a l =0.0
1 . 0 , 0 . 0 , a c t u a l =0.9903741937121177 , i d e a l =1.0
0 . 0 , 1 . 0 , a c t u a l =0.9836807956566187 , i d e a l =1.0
1 . 0 , 1 . 0 , a c t u a l =0.0011646072586172778 , i d e a l =0.0
Como puede ver, la red no ha sido entrenada para dar los resultados
exactos. Esto es normal. Debido a que la red fue entrenada al error del
1%, cada uno de los resultados también estará dentro de generalmente
1% del valor esperado.
Debido a que la red neural se inicializa a valores aleatorios, la salida
final será diferente en la segunda ejecución del programa.
0 . 0 , 0 . 0 , a c t u a l =0.005489822214926685 , i d e a l =0.0
1 . 0 , 0 . 0 , a c t u a l =0.985425090860287 , i d e a l =1.0
0 . 0 , 1 . 0 , a c t u a l =0.9888064742994463 , i d e a l =1.0
1 . 0 , 1 . 0 , a c t u a l =0.005923146369557053 , i d e a l =0.0
La salida de la segunda salida es ligeramente diferente. Esto es normal.

Este es el primer ejemplo Encog. Todos los ejemplos contenidos en este libro
también se incluyen con los ejemplos descargados con Encog. Para obtener
más información sobre cómo descargar estos ejemplos y dónde se encuentra
este ejemplo en particular, consulte el Apéndice A, "Instalación de Encog".
1.6 Resumen del capítulo
Encog es un avanzado marco de aprendizaje de la máquina utilizado para
crear redes neuronales. Este capítulo se centró en la regresión en la
clasificación y agrupación. Finalmente, este capítulo mostró cómo crear
una aplicación Encog que podría aprender el operador XOR.
1.6 Chapter Summary 17
La regresión es cuando una red neural acepta entrada y produce una salida
numérica. La clasificación es donde una red neural acepta entrada y predice en
qué clase estaba la entrada. El agrupamiento no requiere salidas ideales. Más
bien, el agrupamiento mira los datos de entrada y agrupa los casos de entrada
de la mejor manera posible.
Hay varios tipos de capas diferentes soportados por Encog. Sin embargo,
estas capas se dividen en tres grupos dependiendo de su ubicación en la red
neuronal. La capa de entrada acepta entradas desde el exterior. Las capas
ocultas aceptan datos de la capa de entrada para su posterior procesamiento. La
capa de salida toma datos, ya sea de la capa de entrada o final oculta, y la
presenta al mundo exterior.
El operador XOR se utilizó como ejemplo para este capítulo. El operador

XOR se utiliza con frecuencia como una simple aplicación "Hello World" para
redes neuronales. El operador XOR proporciona un patrón muy simple que la
mayoría de las redes neuronales pueden aprender fácilmente. Es importante
saber cómo estructurar los datos de una red neuronal. Las redes neuronales
aceptan y devuelven una matriz de números de coma flotante.
Finalmente, este capítulo detalló cómo enviar datos a una red neuronal. Los
datos para el ejemplo XOR se proporcionan fácilmente a una red neuronal. No
es necesario normalizar o codificar. Sin embargo, la mayoría de los datos del
mundo real necesitarán ser normalizados. La normalización se demuestra en el
próximo capítulo.
19
Capitulo 2
Obtención de datos para Encog

• Búsqueda de datos para redes neuronales
• ¿Por qué normalizar?
• Especificación de fuentes de normalización
• Especificación de objetivos de normalización
Las redes neuronales pueden proporcionar una visión profunda de los

datos que se les suministran. Sin embargo, no se puede alimentar
cualquier tipo de datos directamente en una red neuronal. Normalmente,
estos datos "crudos" deben normalizarse en una forma que la red neural
pueda procesar. Este capítulo mostrará cómo normalizar los datos
"crudos" para su uso por Encog.
Antes de que los datos puedan normalizarse, primero debemos tener

datos. Una vez que decida qué debe hacer la red neuronal, debe
encontrar datos para enseñar a la red neuronal cómo realizar una tarea.
Afortunadamente, Internet proporciona una gran cantidad de información
que se puede utilizar con redes neuronales.
2.1 Dónde obtener datos para redes neuronales
Internet puede ser una gran fuente de datos para la red neuronal. Los datos
que se encuentran en Internet pueden encontrarse en muchos formatos
diferentes. Uno de los formatos más convenientes
20 Obtaining Data for Encog
para los datos es el formato de valores separados por comas (CSV). Otras
veces puede ser necesario crear una araña o bot para obtener estos datos.
Una fuente muy útil para la red neuronal es el Repertorio de Aprendizaje de
la Máquina, que es dirigido por la Universidad de California en Irvine.
Http://kdd.ics.uci.edu/
El sitio del repositorio de Aprendizaje de la Máquina es un repositorio de
varios conjuntos de datos que han sido donados a la Universidad de California.
Varios de estos conjuntos de datos se utilizarán en este libro.
2.2 Normalización de datos

Los datos obtenidos de sitios, como los enumerados anteriormente, a
menudo no pueden ser directamente alimentados en redes neuronales.
Las redes neuronales pueden ser muy "inteligentes", pero no pueden
recibir cualquier clase de datos y producir un resultado significativo. A
menudo, los datos deben ser normalizados primero. Comenzaremos
definiendo la normalización.
Las redes neuronales están diseñadas para aceptar números de punto
flotante como su entrada. Por lo general, estos números de entrada
deben estar en el rango de -1 a +1 o de 0 a +1 para la máxima eficiencia.
La elección de la gama es a menudo dictada por la elección de la función
de activación, ya que ciertas funciones de activación tienen un rango
positivo y otras tienen un rango negativo y positivo.
La función de activación sigmoide, por ejemplo, tiene un rango de sólo
números positivos. Por el contrario, la función de activación tangente
hiperbólica tiene un rango de números positivos y negativos. El caso más
común es utilizar una función de activación tangente hiperbólica con un
rango de normalización de -1 a +1.
Recuerde del Capítulo 1 el conjunto de datos del iris. Este conjunto de
datos podría aplicarse a un problema de clasificación. Sin embargo, no
vimos cómo los datos necesarios para ser realmente procesados para
que sea útil a una red neuronal.
Un muestreo del conjunto de datos se muestra aquí:
” S e p a l Length ” , ” S e p a l Width” , ” P e t a l Length ” , ” P e t a l Width” , ” S p e c i e s
”
5.1,3.5,1.4,0.2,”setosa”4.
9,3.0,1.4,0.2,”setosa”4.7,
3.2,1.3,0.2,”setosa”
...
2.2 Normalizing Data 21
7.0,3.2,4.7,1.4,”versicolor
”6.4,3.2,4.5,1.5,”versicolo
r”6.9,3.1,4.9,1.5,”versicol
or”
...
6.3,3.3,6.0,2.5,”virginica”
5.8,2.7,5.1,1.9,”virginica”
7.1,3.0,5.9,2.1,”virginica”
Los campos de este conjunto de datos ahora deben representarse como

una matriz de números de coma flotante entre -1 y +1.
• Longitud Sepal - Numérico
• Ancho sepal - Numérico
• Longitud de los pétalos - Numérico
• Ancho de los pétalos - Numérico
• Especies - Clase
Hay realmente dos tipos de atributos diferentes a considerar. En primer
lugar, hay cuatro atributos numéricos. Cada uno de ellos simplemente se
asignará a una neurona de entrada. Los valores tendrán que ser escalados a -1
a +1.
Atributos de clase, a veces llamados atributos nominales, presentan un
desafío único. En el ejemplo, las especies de iris deben ser representadas como
uno o más números en coma flotante. El mapeo no será para una sola neurona.
Debido a que una clase de tres miembros está involucrada, el número de
neuronas utilizadas para representar la especie no será una sola neurona. El
número de neuronas utilizadas para representar la especie será dos o tres,
dependiendo del tipo de normalización utilizado.
Las dos secciones siguientes mostrarán cómo normalizar valores numéricos
y de clase, comenzando con valores numéricos.
2.2.1 Normalización de valores numéricos

Normalizar un valor numérico es esencialmente un proceso de asignar el valor
numérico existente a un rango numérico bien definido, como -1 a +1. La
normalización
hace que todos los atributos estén en el mismo rango sin atributo
alguno más potente que los demás.
Para normalizar, los rangos numéricos actuales deben ser conocidos
para todos los atributos. Aquí se muestran los rangos numéricos actuales
para cada uno de los atributos del iris.
• Longitud Sepal - Max: 7.9, Min: 4.3
• Ancho de sepal - Max: 4.4, Min: 2.0
• Longitud de los pétalos - Max: 6,9, Min: 1,0
• Anchura de los pétalos - Max: 2.5, Min: 0.1
Considere la "longitud del pétalo". La longitud del pétalo está en el rango de 1,0 a
6,9. Esto debe convertir esta longitud a -1 a +1. Para ello utilizamos la ecuación
2.1.
f(x) = (x−dL)(nH −nL) + nL (2.1)

(dH −dL)
La ecuación anterior normalizará un valor x, donde la variable d representa los

valores alto y bajo de los datos, la variable n representa el rango de normalización
alto y bajo deseado. Por ejemplo, para normalizar una longitud de pétalo de 3, en
el intervalo de -1 a +1, la ecuación anterior se convierte en:
f(x) = (6.9−1.0) + (−1.0) (2.2)
(3−1.0)(1.0−(−1.0))
Esto da como resultado un valor de 0,66. Este es el valor que se alimentará

a la red neuronal.
Para la regresión, la red neural devolverá valores. Estos valores serán normalizados.
Para desnormalizar un valor, se usa la Ecuación 2.2.
f(x) = (dL−dH )x−(nH ·dL)+dH ·nL (2.3)

(nL−nH )
Para desnormalizar el valor de 0.66, la ecuación 2.2 se
convierte en:
f(x) = (1.0−6.9)·0.32−(1.0·1.0)+6.9·−1 (2.4)

((−1)−(1.0))
2.2 Normalización de datos 23
Una vez desnormalizado, el valor de 0.66 vuelve a ser 2.0 nuevamente.

Es importante tener en cuenta que el valor 0.66 fue redondeado para el
cálculo aquí. Encog proporciona clases integradas para proporcionar
tanto la normalización como la desnormalización. Estas clases se
presentarán más adelante en este capítulo.
2.2.2 Normalización de valores nominales

Los valores nominales se usan para nombrar cosas. Un ejemplo muy
común de un valor nominal simple es el género. Algo es masculino o
femenino. Otro es cualquier tipo de pregunta booleana. Los valores
nominales también incluyen valores que son "sí / verdadero" o "no / falso".
Sin embargo, no todos los valores nominales tienen sólo dos valores.
Los valores nominales también se pueden utilizar para describir un
atributo de algo, como el color. Las redes neuronales se relacionan mejor
con los valores nominales en los que el conjunto es fijo. Para el conjunto
de datos del iris, el valor nominal a normalizar es la especie. Hay tres
especies diferentes a considerar para el conjunto de datos del iris y este
valor no puede cambiar. Si la red neuronal está entrenada con tres
especies, no se puede esperar que reconozca cinco especies.
Encog admite dos formas diferentes de codificar valores nominales. La
forma más sencilla de representar valores nominales se denomina
codificación "uno-de-n". Una codificación uno-de-n a menudo puede ser
difícil de entrenar, especialmente si hay más de unos pocos tipos
nominales para codificar. La codificación equilateral suele ser una mejor
opción que la codificación un-de-n más simple. Ambos tipos de
codificación se explorarán en las dos secciones siguientes.
2.2.3 Comprensión de uno-de-normalización

Uno-de-n es una forma muy simple de normalización. Para un ejemplo,
considere el conjunto de datos del iris de nuevo. La entrada a la red
neuronal es estadística sobre un iris individual. La salida significa qué
especies de iris evaluar. Las tres especies de iris se enumeran como
sigue:
• Setosa
• Versicolor
• Virginica
Si se utiliza la normalización one-of-n, la red neuronal tendría tres

neuronas out-put. Cada una de estas tres neuronas representaría una
especie de iris. La especie del iris predicha por la red neuronal
correspondería a la neurona de salida con la activación más alta.
Generar datos de entrenamiento para uno-de-n es relativamente fácil.
Simplemente asigne un +1 a la neurona que corresponde al iris elegido y
un -1 a las neuronas restantes. Por ejemplo, la especie Setosa iris se
codificaría de la siguiente manera:
1,−1,−1
Asimismo, el Versicolor sería codificado de la siguiente manera:
−1,1,−1
Finalmente, Virginica sería codificada como sigue.
−1,−1,1
Encog proporciona clases integradas para proporcionar esta
normalización. Estas clases se presentarán más adelante en este capítulo.
2.2.4 Comprensión de la normalización equilateral
Las neuronas de salida se comprueban constantemente frente a los valores de
salida ideales proporcionados en el conjunto de entrenamiento. El error entre la
salida real y la salida ideal está representado por un porcentaje. Esto puede causar
un problema para el método de normalización one-of-n. Considere si la red
neuronal había predicho un iris Versicolor cuando debería haber predicho un iris
Verginica. La salida y el ideal sería como sigue:
I d e a l Output : −1, −1, 1
Actual Output : −1, 1, −1
2.2 Normalización de datos 25
El problema es que sólo dos de las tres neuronas de salida son incorrectas.
Nos gustaría difundir la "culpa" de este error en un porcentaje mayor de las
neuronas. Para ello, debe determinarse un conjunto único de valores para cada
clase. Cada conjunto de valores debe tener una distancia euclídea igual a los
otros. La distancia igual asegura que la elección incorrecta del iris Setosa para
Versicolor tiene el mismo peso de error que la elección del iris Setosa para el iris
Virginica.
Esto se puede hacer usando la clase Equilateral. El siguiente segmento de
código muestra cómo utilizar la clase Equilateral para generar estos valores:
var eq = new E q u i l a t e r a l (3 , −1 ,1) ;
for ( var i = 0 ; i < 3 ; i ++)
{
var l i n e = new S t r i n g B u i l d e r ( ) ;
l i n e . Append ( i ) ;
l i n e . Append ( ’ : ’ ) ;
var d = eq . Encode ( i ) ;
for ( var j = 0 ; j < d . Length ; j ++)
{
i f ( j > 0)
l i n e . Append ( ’ , ’ ) ;
l i n e . Append ( Format . FormatDouble ( d [ j ] , 4) ) ;
}
Console . WriteLine ( l i n e . ToString ( ) ) ;
}
Las entradas a la clase Equilateral son el número de clases y el rango

normalizado. En el código anterior, hay tres clases que se normalizan en
el rango -1 a 1, produciendo la siguiente salida:
Listado 2.1: Clase calculada Valores Equilaterales 3 Clases
0: 0.8660 , 0.5000
1: −0.8660 , 0 . 5 0 0 0
2: 0.0000 , −1.0000
Observe que hay dos salidas para cada una de las tres clases. Esto disminuye el
número de neuronas necesarias por uno de la cantidad necesaria para la
codificación uno-de-n. La codificación equilateral requiere siempre una neurona
de salida menos que la codificación uno-de-n. La codificación equilateral nunca
se utiliza para menos de tres clases.
26 Obtención de datos para Encog
Mira el ejemplo anterior con la normalización equilátero. Igual que antes,

considere si la red neuronal había predicho un iris Versicolor, cuando debería
haber predicho un iris Verginica. La salida y el ideal son los siguientes:
I d e a l Output : 0.0000 , −1.0000
Actual Output : −0.8660 , 0 . 5 0 0 0
En este caso sólo hay dos neuronas, como es consistente con la

codificación equilátero. Ahora todas las neuronas están produciendo
valores incorrectos. Además, sólo hay dos neuronas de salida para
procesar, disminuyendo ligeramente la complejidad de la red neuronal.
Las redes neuronales rara vez darán salida que coincida exactamente
con cualquiera de sus valores de entrenamiento. Para hacer frente a esto
en la codificación "one-of-n", mire qué neurona out-put produjo la salida
más alta. Este método no funciona para la codificación equilateral. La
codificación equilateral muestra qué valor calculado de equiparación de
clase (listado 2.1) tiene la distancia más corta a la salida real de la red
neuronal.
¿Qué significa que cada uno de los conjuntos es igual en distancia uno
del otro? Significa que su distancia euclidiana es igual. La distancia
euclidiana se puede calcular usando la ecuación 2.3.
v n 2
d(p, q) = (pi qi) (2.5)
u
i=1 −
uX
t
En la ecuación anterior la variable "q" representa el valor de salida
ideal; La variable "p" representa el valor de salida real. Hay "n"
conjuntos de ideales y reales. La normalización euclidiana se
implementa utilizando la clase Equilateral en Encog. Por lo general, es
innecesario tratar directamente con la clase Equilateral en Encog. Por
el contrario, se utiliza uno de los métodos de normalización de nivel
superior descritos más adelante en este capítulo.
Si está interesado en los medios exactos por los cuales se calculan los
números equiláteros, visite la siguiente URL:
Http://www.heatonresearch.com/wiki/Equilateral
2.3 Normalización Programática 27
2.3 Normalización programática

Encog proporciona una serie de diferentes medios de normalización de
datos. Los medios exactos que usted utiliza serán determinados por
exactamente qué usted está intentando lograr. Los tres métodos para la
normalización se resumen aquí.
• Normalización de números individuales
• Normalización de archivos CSV
• Normalización de matrices de memoria
Las tres secciones siguientes examinarán las tres, comenzando con la
normalización de números individuales.
2.3.1 Normalización de números individuales

Muy a menudo, simplemente querrá normalizar o desnormalizar un
único número. El rango de valores en sus datos ya es conocido. Para
este caso, no es necesario pasar por la sobrecarga de tener Encog
descubrir automáticamente rangos para usted.
El programa "Lunar Lander" es un buen ejemplo de esto. Aquí puede
encontrar el ejemplo de "Lander Lunar".
ConsoleExamples l a n d e r
Para realizar la normalización, se crean varios objetos NormalizedField.
Aquí ves el objeto NormalizedField que fue creado para el combustible del
lander lunar.
var f u e l S t a t s =
new N o r m a l i z e d F i e l d (
NormalizationAction.
Normalize , ” f u e l ” ,
200 ,
0,
− 0.9 ,
0. 9 ) ;
Para el ejemplo anterior, el rango se normaliza a -0,9 a 0,9. Esto es muy

similar a la normalización entre -1 y 1, pero menos extrema. Esto puede producir
mejores resultados a veces. También se sabe que el intervalo aceptable para el
combustible está entre 0 y 200ºC.
Ahora que el objeto de campo ha sido creado, es fácil normalizar los
valores. Aquí el valor 100 se normaliza en la variable n.
double n = f u e l S t a t s . Normalize ( 1 0 0 ) ;
Para desnormalizar n de nuevo al valor original del combustible, utilice el

siguiente código:
double f = f u e l S t a t s . Denormalize ( n ) ;
El uso de las clases NormalizedField directamente es útil cuando los números

llegan a medida que se ejecuta el programa. Si ya se han establecido grandes
listas de números, como una matriz o un archivo CSV, este método no será tan
efectivo.
2.3.2 Normalizing Memory Arrays
Para normalizar rápidamente una matriz, la clase NormalizeArray puede ser útil.
Este objeto trabaja normalizando un atributo a la vez. En el ejemplo de
predicción de las manchas solares se muestra un ejemplo del funcionamiento
normalizado de la clase array. Este ejemplo se puede encontrar aquí:
Encog . Examples . P r e d i c t . P r e d i c t S u n s p o t
ConsoleExamples s u n s p o t
Para empezar, cree una instancia del objeto NormalizeArray. Establezca el rango
alto y bajo para la normalización.
var h i =1 ;
var l o =−1;
var norm = new NormalizeArray {NormalizedHigh = hi , NormalizedLow
= l o };
Ahora matriz de datos sin formato se puede normalizar en una
matriz normalizada.
2.4 Normalización de archivos CSV 29
n o r m a l i z e d S u n s p o t s = norm . P r o c e s s ( Sunspots ) ;
c l o s e d L o o p S u n s p o t s = EngineArray . ArrayCopy ( normalizedSunspots);
Si tiene una matriz completa para normalizar a la misma alta / baja, la

clase Nor-malizeArray funciona bien. Para un control más preciso, utilice
las mismas técnicas descritas en la sección anterior para valores
individuales. Sin embargo, todos los elementos de la matriz deben estar
en bucle.
2.4 Normalizing CSV Files
Si los datos a normalizar ya están almacenados en archivos CSV, Encog
Analyst debe utilizarse para normalizar los datos. Encog Analyst se puede utilizar
tanto a través de Encog Workbench como directamente desde Java y C #. Esta
sección explica cómo utilizarlo a través de C # para normalizar el conjunto de
datos Iris.
Para normalizar un archivo, busque el ejemplo de normalización de archivos
que se encuentra en la siguiente ubicación:
Encog . Examples . Normalize . N o r m a l i z e F i l e
ConsoleExamples n o r m a l i z e −f i l e [ raw ] [normalized]
Este ejemplo toma un archivo de entrada y salida. El archivo de entrada es el

conjunto de datos del iris. Las primeras líneas de este archivo se muestran aquí:
”sepall”,”sepalw”,”petall”,”petalw”,”speci
e s ” 5 . 1 , 3 . 5 , 1 . 4 , 0 . 2 , I r i s −s e t o s a
4 . 9 , 3 . 0 , 1 . 4 , 0 . 2 , I r i s −s e t o s a 4 .
7 , 3 . 2 , 1 . 3 , 0 . 2 , I r i s −s e t o s a 4 . 6 , 3 .
1 , 1 . 5 , 0 . 2 , I r i s −s e t o s a 5 . 0 , 3 . 6 , 1 .
4 , 0 . 2 , I r i s −s e t o s a 5 . 4 , 3 . 9 , 1 . 7 , 0 .
4 , I r i s −s e t o s a 4 . 6 , 3 . 4 , 1 . 4 , 0 . 3 , I r i
s −s e t o s a 5 . 0 , 3 . 4 , 1 . 5 , 0 . 2 , I r i s −s
etosa
La salida será una versión normalizada del archivo de entrada, como se
muestra a continuación:
” s e p a l l ” , ” s e p a l w ” , ” p e t a l l ” , ” p e t a l w ” , ” s p e c i e s ( p0 ) ” , ” s p e c i e s ( p1 )
”
− 0.55 ,0.24 , −0.86 , −0.91 , −0.86 , −0.5
− 0.66 , −0.16 , −0.86 , −0.91 , −0.86 , −0.5
− 0.77 ,0 , −0.89 , −0.91 , −0.86 , −0.5
− 0.83 , −0.08 , −0.83 , −0.91 , −0.86 , −0.5
− 0.61 ,0.33 , −0.86 , −0.91 , −0.86 , −0.5
− 0.38 ,0.58 , −0.76 , −0.75 , −0.86 , −0.5
− 0.83 ,0.16 , −0.86 , −0.83 , −0.86 , −0.5
−0.61 ,0.16 , −0.83 , −0.91 , −0.86 , −0.5
Los datos anteriores muestran que los valores numéricos han sido
normalizados entre -1 y 1. Además, el campo de especies se divide en dos
partes. Esto se debe a que se usó la normalización equilátera en la columna
de especies.
2.4.1 Implementación de la normalización básica de
archivos
En la última sección, usted vio cómo Encog Analyst normaliza un archivo.
En esta sección, aprenderá el código de programación necesario para
lograr esto. Empiece accediendo a los archivos de origen y de destino:
var s o u r c e F i l e = new F i l e I n f o ( app . Args [ 0 ] ) ;
var t a r g e t F i l e = new F i l e I n f o ( app . Args [ 1 ] ) ;
Ahora cree instancias de Encog Analyst y Analyst Wizard. El asistente

analizará el archivo de origen y generará todas las estadísticas de
normalización necesarias para realizar la normalización.
var a n a l y s t = new EncogAnalyst ( ) ;
var wizard = new AnalystWizard ( a n a l y s t ) ;
El asistente se puede iniciar ahora.
wizard . Wizard ( s o u r c e F i l e , true , A na l y st F i l eF o r ma t . DecpntComma ) ;
Ahora que el archivo de entrada ha sido analizado, es hora de crear un

objeto de normalización. Este objeto realizará la normalización real.
var norm = new AnalystNormalizeCSV ( ) ;
norm . Analyze ( s o u r c e F i l e , true , CSVFormat . E n g l i s h , analy
st);
2.4 Normalización de archivos CSV 31
Es necesario especificar el formato de salida para el CSV, en este caso,

use ENGLISH, que especifica un punto decimal. También es importante
producir cabeceras de salida para identificar fácilmente todos los
atributos.
norm . ProduceOutputHeaders = true ;
Finalmente, normalizamos el archivo.
norm . Normalize ( t a r g e t F i l e ) ;
Ahora que los datos están normalizados, las estadísticas de normalización

pueden guardarse para su uso posterior. Esto se trata en la siguiente
sección.
2.4.2 Guardar la secuencia de comandos de
normalización
Encog mantiene estadísticas sobre datos normalizados. Estos datos, llamados
las estadísticas de normalización, indican Encog los rangos numéricos para
cada atributo que fue normalizado. Estos datos se pueden guardar para que no
tenga que renormalized cada vez.
Para guardar un archivo de estadísticas, utilice el siguiente comando:
a n a l y s t . Save (new F i l e I n f o ( ” s t a t s . ega ” ) ) ;
El archivo se puede volver a cargar con el siguiente comando:
a n a l y s t . Load (new F i l e I n f o ( ” s t a t s . ega ” ) ) ;

La extensión EGA es común y significa "Encog Analyst".
2.4.3 Personalizar la normalización de archivos
El Encog Analyst contiene una colección de objetos AnalystField. Estos
objetos mantienen el tipo de normalización y los rangos de cada atributo. Esta
colección se puede acceder directamente para cambiar la forma en que se
normalizan los atributos. Además, los objetos AnalystField se pueden quitar y
excluir de la salida final.
El siguiente código muestra cómo acceder a cada uno de los campos
determinados por el asistente.
32 Obtención de datos para Encog
Console . WriteLine (@” F i e l d s found i n f i l e : ” ) ;

f o r e a c h ( A n a l y s t F i e l d f i e l d i n a n a l y s t . S c r i p t . Normalize .
NormalizedFields)
{
var l i n e = new S t r i n g B u i l d e r
( ) ; l i n e . Append ( f i e l d . Name) ;
l i n e . Append ( ” , a c t i o n=” ) ;
l i n e . Append ( f i e l d .
Action ) ; l i n e . Append ( ” ,
min=” ) ;
l i n e . Append ( f i e l d .
ActualLow ) ; l i n e . Append ( ”
,max=” ) ;
l i n e . Append ( f i e l d . ActualHigh ) ;
Console . WriteLine ( l i n e . ToString ( ) ) ;
}
Hay varios atributos importantes en cada uno de los objetos de AnalystField.

Por ejemplo, para cambiar el rango de normalización a 0 a 1, ejecute los
siguientes comandos:
f i e l d . NormalizedHigh = 1;
f i e l d . NormalizedLow = 0;
El modo de normalización también se puede cambiar. Para usar una de n

normalización en lugar de equilátero, simplemente use el siguiente comando:
f i e l d . Action = N o r m a l i z a t i o n A c t i o n . OneOf ;
Encog Analyst puede hacer mucho más que simplemente normalizar datos.
También realiza la normalización completa, el entrenamiento y la evaluación de
una red neuronal. Esto se tratará con mayor detalle en los capítulos 3 y 4. El
capítulo 3 mostrará cómo hacerlo desde el banco de trabajo, mientras que el
capítulo 4 mostrará cómo hacerlo a partir del código.
2.5 Resumen
En este capítulo se explica cómo obtener y normalizar los datos de Encog. Hay
muchas fuentes diferentes de datos. Uno de los mejores es el UCI Machine
Learning Repository, que proporciona muchos ejemplos de conjuntos de datos
en este libro.
2.5 Resumen 33
Existen dos clases amplias de datos para normalizar: datos numéricos y no

numéricos. Estas dos clases de datos tienen técnicas para la normalización.
Los datos numéricos se normalizan asignando valores a un rango específico,

a menudo de -1 a +1. Otro rango común está entre 0 y +1. Las fórmulas se
proporcionaron anteriormente en este capítulo para la normalización y
desnormalización.
Los datos no numéricos suelen ser un atributo que define una clase. Para el
caso del conjunto de datos del iris, la especie del iris es una clase no numérica.
Para normalizar estas clases, deben convertirse a una matriz de valores de
punto flotante, al igual que con los datos numéricos.
Encog admite dos tipos de normalización nominal. El primero se denomina

"uno-de-n". Uno-de-n crea un número de neuronas igual al número de elementos
de clase. El número de clase a codificar se da un valor de 1. Otros se dan ceros.
La codificación equilateral es otra forma de codificar una clase. Para la

codificación equilátero, se usa un número de neuronas que es igual a uno,
menos el número de elementos de clase. Se crea un código de números de
punto flotante para cada elemento de clase con una distancia equilárica uniforme
a los otros elementos de datos de clase. Esto permite que todas las neuronas de
salida jueguen una parte en cada elemento de clase y provoque un error para
afectar más neuronas que una codificación one-of-n.
Este capítulo presentó el Analista Encog y explicó su uso para normalizar los
datos. El Encog Analyst también se puede usar en Encog Workbench. El Encog
Workbench es una aplicación GUI que permite acceder a muchas de las
características de las redes neuronales sin necesidad de escribir código.
35
Capitulo 3
El Encog Workbench
• Estructura del Workbench Encog
• Un ejemplo XOR simple
• Uso del Analizador Encog
• Analizar informes de analistas
El Encog Workbench es una aplicación GUI que permite muchas

tareas de aprendizaje diferentes de la máquina sin escribir código Java o
C #. Encog Workbench está escrito en Java, pero genera archivos que se
pueden usar con cualquier framework Encog.
El Encog Workbench se distribuye como un solo archivo JAR

autoexecutivo. En la mayoría de los sistemas operativos, el archivo JAR
de Encog Workbench se inicia simplemente haciendo doble clic. Esto
incluye Microsoft Windows, Macintosh y algunas variantes de Linux. Para
iniciar desde la línea de comandos, se utiliza el siguiente comando.
j a v a âĂẞjar . / encog−workbench −3.0.0 − e x e c u t a b l e

Dependiendo de la versión de Encog, el archivo JAR anterior puede tener un
nombre diferente. No importa la versión, el archivo tendrá "encog-workbench"
y "ejecutable" en algún lugar en su nombre. No se necesitan otros archivos
JAR para el banco de trabajo, ya que todos los archivos JAR de terceros se
colocan dentro de este JAR.
36 El Encog Workbench
3.1 Estructura del Workbench de Encog

Antes de estudiar cómo se utiliza realmente el Encog Workbench,
aprenderemos sobre su estructura. El workbench funciona con un
directorio de proyecto que contiene todos los archivos necesarios para un
proyecto. El proyecto Encog Workbench no contiene subdirectorios.
Además, si un subdirectorio se agrega a un proyecto Encog Workbench,
simplemente se convierte en otro proyecto independiente.
También no hay "archivo de proyecto" principal dentro de un proyecto
Encog Workbench. A menudo un archivo readme.txt o readme.html se
coloca dentro de un proyecto Encog Workbench para explicar qué hacer
con el proyecto. Sin embargo, este archivo se incluye a discreción del
creador del proyecto.
Hay varios tipos de archivos diferentes que pueden colocarse en un
proyecto de Workbench Encog. Estos archivos están organizados por su
extensión de archivo. La extensión de un archivo es cómo el Encog
Workbench sabe qué hacer con ese archivo. Las siguientes extensiones
son reconocidas por Encog Workbench:
• .csv
• .eg
• .ega
• .egb
• .gif
• .html
• .jpg
• .png
• .txt
Las siguientes secciones discutirán el propósito de cada tipo de archivo.

3.1 Estructura del Workbench Encog 37
3.1.1 Archivos CSV de Workbench
Un acrónimo de "valores separados por comas", los archivos CSV contienen

datos tabulares. Sin embargo, los archivos CSV no siempre están separados por
comas. Esto es especialmente cierto en partes del mundo que usan una coma
decimal en lugar de un punto decimal. Los archivos CSV utilizados por Encog
pueden basarse en una coma decimal. En este caso, se debe utilizar un punto y
coma (;) como separador de campo.
Los archivos CSV también pueden tener encabezados para definir lo que
significa cada columna del archivo CSV. Los encabezados de columna son
opcionales, pero muy sugeridos. Los encabezados de columnas nombran los
atributos y proporcionan consistencia entre los archivos CSV creados por Encog
y proporcionados por el usuario.
Un archivo CSV define los datos utilizados por Encog. Cada fila en el archivo
CSV define un elemento de conjunto de entrenamiento y cada columna define
un atributo. Si un atributo particular no se conoce para un elemento de conjunto
de entrenamiento, entonces el carácter "?" Debe colocarse en esa fila / columna.
Encog trata de valores perdidos de varias maneras. Esto se discute más
adelante en este capítulo en la discusión del analista Encog.
Un archivo CSV no se puede utilizar para entrenar directamente una red
neuronal, pero primero debe convertirse en un archivo EGB. Para convertir un
archivo CSV en un archivo EGB, haga clic con el botón derecho del ratón en el
archivo CSV y seleccione "Export to Training (EGB)". Los archivos EGB definen
bien las columnas que se introducen y los datos ideales, mientras que los
archivos CSV no ofrecen ninguna distinción. Por el contrario, los archivos CSV
pueden representar datos brutos proporcionados por el usuario. Además,
algunos archivos CSV se generan mediante Encog a medida que se procesan
los datos de usuario sin procesar.
3.1.2 Workbench EG Files
Los archivos Encog EG almacenan una variedad de diferentes tipos de
objetos, pero en sí mismos son simplemente archivos de texto. Todos los
datos dentro de los archivos EG se almacenan con puntos decimales y
separador de comas, independientemente de la región geográfica en la que
se ejecuta Encog. Mientras que los archivos CSV pueden formatearse de
acuerdo con las reglas de formato de números locales, los archivos EG no
pueden. Esto es para mantener los archivos EG coherentes en todas las
plataformas Encog.
Los siguientes tipos de objeto se almacenan en archivos EG.
38 The Encog Workbench
• Métodos de Aprendizaje Automático (es decir, Redes Neuronales)

• NEAT Poblaciones
• Datos de Continuación del Entrenamiento
El banco de trabajo Encog mostrará el tipo de objeto de cualquier archivo EG
que se encuentre en el directorio del proyecto. Un archivo Encog EG sólo
almacena un objeto por archivo. Si se van a almacenar varios objetos, se
almacenaron en archivos.
3.1.3 Archivos EGA de Workbench
Los archivos de secuencia de comandos de Encog Analyst, o archivos
EGA, contienen instrucciones para el analizador Encog. Estos
archivos contienen información estadística sobre lo que un archivo
CSV está diseñado para analizar. Los archivos EGA también
contienen información de secuencia de comandos que describe cómo
procesar los datos sin procesar. Los archivos EGA son ejecutables por
el workbench.
Una discusión completa del archivo EGA y cada posible elemento de
configuración / script está fuera del alcance de este libro. Sin embargo,
un futuro libro será dedicado al Analista Encog. Puede encontrar
información de referencia adicional sobre el archivo de script de Encog
Analyst aquí:
Http://www.heatonresearch.com/wiki/EGA_File
Más adelante en este capítulo, crearemos un archivo EGA para
analizar el conjunto de datos del iris.
3.1.4 Archivos EGB de Workbench
Los archivos binarios Encog, o archivos EGB, contienen datos de entrenamiento.
Como se comentó anteriormente, los archivos CSV normalmente se convierten a
EGB para Encog. Estos datos se almacenan en un formato binario
independiente de la plataforma. Debido a esto, los archivos EGB se leen mucho
más rápido que un archivo CSV. Además, el archivo EGB contiene internamente
el número de entradas y columnas ideales presentes en el archivo. Los archivos
CSV deben convertirse en archivos EGB antes del entrenamiento. Para convertir
un archivo CSV en un archivo EGB, haga clic con el botón derecho en el archivo
CSV seleccionado y seleccione "Exportar a formación (EGB)".
3.2 A Simple XOR Example 39
3.1.5 Archivos de imagen de Workbench

El Workbench Encog no trabaja directamente con archivos de imagen en
este momento, pero puede mostrarse haciendo doble clic. El Workbench
Encog es capaz de mostrar archivos PNG, JPG y GIF.
3.1.6 Archivos de texto de Workbench
Encog Workbench no utiliza directamente archivos de texto. Sin embargo,

los archivos de texto son un medio de almacenar instrucciones para los
usuarios de archivos de proyecto. Por ejemplo, un archivo readme.txt se
puede agregar a un proyecto y mostrarse dentro del analista. El Encog
Workbench puede mostrar tanto texto como archivos HTML.
3.2 Un ejemplo simple de XOR
Hay muchas maneras diferentes que el Encog Workbench puede ser
usado. El Analista Encog puede utilizarse para crear proyectos que
incluyan normalización, capacitación y análisis. Sin embargo, todas las
partes de la red neuronal también pueden crearse y entrenarse
manualmente. Si los datos ya están normalizados, es posible que no se
necesite Encog Ana-lyst.
En esta sección veremos cómo usar el Encog Workbench sin el Encog
Analyst creando una simple red neuronal XOR. El conjunto de datos XOR
no requiere ninguna normalización ya que ya está en el rango de 0 a 1.
Comenzaremos por crear un nuevo proyecto.
3.2.1 Creación de un nuevo proyecto

En primer lugar, crear un nuevo proyecto mediante el lanzamiento de
Encog Workbench. Una vez que arranque el Encog Workbench,
aparecerán las opciones de crear un nuevo proyecto, abrir un proyecto
existente o dejarlo. Elija crear un nuevo proyecto y denomínelo "XOR".
Esto creará una nueva carpeta vacía denominada XOR. Ahora verá el
Encog Workbench en la Figura 3.1.
Figura 3.1:El Encog Workbench
Este es el diseño básico del Encog Workbench. Hay tres áreas

principales. El rectángulo alto de la izquierda es donde se muestran todos
los archivos del proyecto. Actualmente este proyecto no tiene archivos.
También puede ver la salida de registro y la información de estado. El
rectángulo justo encima de la salida del registro es donde se abren los
documentos. El aspecto del Encog Workbench es muy parecido al IDE y
debe ser familiar para los desarrolladores.
3.2.2 Generar datos de capacitación
El siguiente paso es obtener datos de entrenamiento. Hay varias formas de
hacer esto. En primer lugar, Encog Workbench admite arrastrar y soltar. Por
ejemplo, los CSV se pueden arrastrar desde el sistema operativo y quedar en el
proyecto como una copia, dejando el archivo original sin cambios. Estos archivos
aparecerán en el árbol del proyecto.
El Encog Workbench viene con una serie de conjuntos de entrenamiento
incorporados. Adicionalmente, puede descargar datos externos tales como
precios de las acciones e incluso información de manchas solares. La
información de las manchas solares puede utilizarse para experimentos de
predicción de series de tiempo.
El Encog Workbench también tiene un conjunto de entrenamiento XOR
incorporado. Para acceder a ella, elija Herramientas-> Generar datos de
formación. Esto abrirá el cuadro de diálogo "Crear datos de formación". Elija
"Conjunto de entrenamiento XOR" y llámelo "xor.csv". Su nuevo archivo CSV
aparecerá en el árbol del proyecto.
3.2 Un ejemplo simple XOR 41
Si hace doble clic en el archivo "xor.csv", verá los siguientes datos de

formación en el Listado 3.1:
Listado 3.1:Datos de Entrenamiento XOR
” op1 ” , ” op2 ” , ” r e s u l t ”
0 ,0,0
1,0,1
0 ,1,1
1,1,0
Es importante tener en cuenta que el archivo tiene encabezados. Esto se

debe especificar cuando se genera el archivo EGB.
3.2.3 Crear una red neuronal

Ahora que se han creado los datos de entrenamiento, se debe crear una
red neuronal para conocer los datos XOR. Para crear una red neuronal,
elija "Archivo-> Nuevo Archivo". A continuación, elija "Método de
Aprendizaje de la Máquina" y nombre la red neuronal "xor.eg." Elija "Red
Neural Feedforward". Esto mostrará el diálogo mostrado en la Figura 3.2:
Figura 3.2:Crear una red de feedforward
Asegúrese de rellenar el cuadro de diálogo exactamente como se

indica arriba. Debería haber dos neuronas de entrada, una neurona de
salida y una única capa oculta con dos neuronas. Elija ambas funciones
de activación para que sean sigmoides. Una vez creada la red neuronal,
aparecerá en el árbol del proyecto.
3.2.4 Train the Neural Network

Ahora es el momento de entrenar la red neuronal. La red neuronal que
usted ve actualmente no está entrenada. Para determinar fácilmente si la
red neuronal no está entrenada, haga doble clic en el archivo EG que
contiene la red neuronal. Esto mostrará la figura 3.3.
Figura 3.3:Edición de la red
Esta pantalla muestra algunas estadísticas básicas de la red neuronal.

Para ver más detalles, seleccione el botón "Visualizar" y elija "Estructura
de red". Esto mostrará la Figura 3.4.
Figura 3.4: Estructura de red
Las neuronas de entrada y salida se muestran desde la vista de

estructura. Todas las conexiones entre la capa oculta y las neuronas
diagonales también son
3.2 A Simple XOR Example 43
visibles. Las neuronas de sesgo, así como la capa oculta, ayudan a la red
neuronal a aprender.
Con esto completo, es hora de entrenar realmente la red neuronal. Comience
cerrando la visualización del histograma y la red neuronal. No debe haber
documentos abiertos dentro de la mesa de trabajo.
Haga clic con el botón derecho en los datos de formación "xor.csv". Elija
"Export to Training (EGB)". Rellene dos neuronas de entrada y una neurona de
salida en el cuadro de diálogo que aparece. En el siguiente diálogo, asegúrese
de especificar que hay encabezados. Una vez completado, se agregará un
archivo EGB al árbol del proyecto. Esto resultará en tres archivos: un archivo
EG, un archivo EGB y un archivo CSV.
Para entrenar la red neuronal, seleccione "Herramientas-> Tren". Esto abrirá
un diálogo para elegir el conjunto de entrenamiento y el método de aprendizaje
automático. Debido a que sólo hay un archivo EG y un archivo EGB, este cuadro
de diálogo debe predeterminar los valores correctos. Deje la casilla de
verificación "Cargar en memoria". Como este es un pequeño conjunto de
entrenamiento, no hay razón para no cargar en la memoria.
Hay muchos métodos de entrenamiento diferentes para elegir. Para este
ejemplo, seleccione "Propagación - Resiliente". Acepte todos los parámetros
predeterminados para este tipo de entrenamiento. Una vez que se haya
completado, aparecerá la pestaña de progreso de la formación. Haga clic en
"Inicio" para comenzar el entrenamiento.
El entrenamiento terminará generalmente en menos de un segundo. Sin
embargo, si el entrenamiento continúa durante varios segundos, es posible que
necesite restablecer el entrenamiento haciendo clic en la lista desplegable
titulada "Seleccionar opción". Elija restablecer la red. Debido a que una red
neuronal comienza con pesos aleatorios, los tiempos de entrenamiento variarán.
En una pequeña red neuronal como XOR, los pesos pueden potencialmente ser
lo suficientemente malo que la red nunca entrena. Si este es el caso,
simplemente reinicie la red mientras se entrena.
3.2.5 Evaluate the Neural Network
Hay dos maneras de evaluar la red neuronal. La primera es simplemente
calcular el error de red neural eligiendo "Herramientas-> Evaluar Red". Se
le pedirá que use el método de aprendizaje automático y los datos de
entrenamiento. Esto le mostrará el error de red neural cuando se evalúa
con respecto al conjunto de entrenamiento especificado.
Para este ejemplo, el error será un porcentaje. Cuando se evalúa este
porcentaje, cuanto menor sea el porcentaje, mejor. Otros métodos de
aprendizaje de la máquina pueden generar un error como un número u
otro valor.
Para una evaluación más avanzada, seleccione "Herramientas->
Gráfico de validación". Esto resultará en una salida similar a la Figura 3.5.
Figura 3.5:Gráfico de validación para XOR
Esto representa gráficamente cuán cerca el cálculo de la red neuronal

coincide con el valor ideal (validación). Como se muestra en este ejemplo,
están extremadamente cerca.
3.3 Uso del Encog Analyst
En la última sección usamos el Workbench con un conjunto de datos simple
que no necesitaba normalización. En esta sección usaremos el Encog Analyst
para trabajar con un conjunto de datos más complejo - el conjunto de datos del
iris que ya se ha demostrado varias veces. El procedimiento de normalización ya
se ha explorado. Sin embargo, esto proporcionará un ejemplo de cómo
normalizar y producir una red neuronal para ello utilizando el Encog Analyst
El conjunto de datos del iris está incorporado en el Workbench Encog, por lo
que es fácil crear un conjunto de datos para ello. Cree un nuevo proyecto Encog
Workbench como se describe en la sección anterior. Nombre este nuevo
proyecto "Iris". Para obtener el conjunto de datos del iris, elija "Herramientas->
Generar datos de entrenamiento". Elija el "Conjunto de datos Iris" y llámelo
"iris.csv".
Haga clic con el botón derecho en el archivo "iris.csv" y seleccione "Asistente
de analista". Esto mostrará un cuadro de diálogo como el de la Figura 3.6.
3.3 Usando el Analista Encog 45
Figura 3.6:Encog Asistente de analista
Puede aceptar la mayoría de los valores predeterminados. Sin

embargo, los campos "Target Field" y "CSV File Headers" deben ser
cambiados. Especifique "especie" como objetivo e indique que hay
cabeceras. Las otras dos pestañas deben permanecer sin cambios.
Haga clic en "Aceptar" y el asistente generará un archivo EGA.
Este ejercicio también dio la opción de mostrar cómo tratar con valores
perdidos. Si bien el conjunto de datos del iris no tiene valores
perdidos, no es el caso en todos los conjuntos de datos. La acción
predeterminada es descartarlos. Sin embargo, también puede elegir
entre ellos.
Haga doble clic en este archivo EGA para ver su contenido como en la
figura 3.7.
Figure 3.7: Edit an EGA File
Desde esta pestaña puede ejecutar el archivo EGA. Haga clic en

"Ejecutar" y se mostrará un diálogo de estado. Desde aquí, haga clic en
"Iniciar" para comenzar el proceso. La ejecución completa debe tomar menos
de un minuto en la mayoría de las computadoras.
46 El Encog Workbench
Paso 1: Randomize - Shu ffl el archivo en un orden aleatorio.
• Paso 2: Segregar - Crear un conjunto de datos de entrenamiento y

un conjunto de datos de evaluación.
• Paso 3: Normalizar - Normalizar los datos en una forma utilizable por
el Método de Aprendizaje Automático seleccionado.
• Paso 4: Generar - Genere los datos de entrenamiento en un archivo
EGB que se puede utilizar para entrenar.
• Paso 5: Crear - Genera el método de aprendizaje de la máquina
seleccionado.
• Paso 6: Entrenar - Entrenar el Método de Aprendizaje Automático
seleccionado.
• Paso 7: Evaluar - Evaluar el método de aprendizaje automático.
Este proceso también creará una serie de archivos. La lista completa
de archivos, en este proyecto es:
• iris.csv - Los datos sin procesar.
• iris.ega - El archivo EGA. Este es el script Encog Analyst.
• iris eval.csv - Los datos de evaluación.
• iris norm.csv - La versión normalizada de iris train.csv.
• iris output.csv - La salida de ejecutar el iris eval.csv.
• iris random.csv - La salida aleatoria de ejecutar iris.csv.
• iris train.csv - Los datos de entrenamiento.
• iris train.eg - El método de aprendizaje automático que fue
entrenado.
• iris train.egb - Los datos binarios de entrenamiento, creados a partir
del iris norm.egb.
Si cambia el archivo de script EGA o utiliza diferentes opciones para el
asistente, es posible que tenga diferentes pasos.
Para ver cómo se realiza la red, abra el archivo iris output.csv. Verá el
Listado 3.2.
3.4 Encog Analyst Reports 47
Listing 3.2: Evaluation of the Iris Data

” s e p a l l ” , ” s e p a l w ” , ” p e t a l l ” , ” p e t a l w ” , ” s p e c i e s ” , ” Output : s p e c i e s ”
6 . 5 , 3 . 0 , 5 . 8 , 2 . 2 , I r i s −v i r g i n i c a , I r i s −v i r g i n i c a 6 .
2 , 3 . 4 , 5 . 4 , 2 . 3 , I r i s −v i r g i n i c a , I r i s −v i r g i n i c a 7 . 7 ,
3 . 0 , 6 . 1 , 2 . 3 , I r i s −v i r g i n i c a , I r i s −v i r g i n i c a 6 . 8 , 3 .
0 , 5 . 5 , 2 . 1 , I r i s −v i r g i n i c a , I r i s −v i r g i n i c a 6 . 5 , 3 . 0 ,
5 . 5 , 1 . 8 , I r i s −v i r g i n i c a , I r i s −v i r g i n i c a
6 . 3 , 3 . 3 , 4 . 7 , 1 . 6 , I r i s −v e r s i c o l o r , I r i s −v e r s i c o l o r 5
. 6 , 2 . 9 , 3 . 6 , 1 . 3 , I r i s −v e r s i c o l o r , I r i s −v e r s i c o l o r
...
Esto ilustra cómo la red neural intenta predecir a qué especie de iris
pertenece cada fila. Como puede ver, es correcto para todas las filas que
se muestran aquí. Estos son los elementos de datos que la red neural no
fue originalmente entrenado con.
3.4 Encog informes de analistas

Esta sección discutirá cómo el Encog Workbench también puede producir
varios informes de Encog Analyst. Para producir estos informes, abra el
archivo EGA como se ve en la figura 3.7. Al hacer clic en el botón
"Visualizar" se obtienen varias opciones de visualización. Elija un "Informe
de rango" o "Diagrama de dispersión". Ambos se discuten en las
siguientes secciones.
3.4.1 Range Report
El informe de rango muestra los rangos de cada uno de los atributos que
se utilizan para llevar a cabo la normalización por el Encog Analyst. La
Figura 3.8 muestra el comienzo del informe de rango.
Figura 3.8:Informe de rango de analistas Encog
Esta es sólo la parte superior. Para obtener información adicional,

desplácese hacia abajo.
3.4.2 Diagrama de dispersión
También es posible mostrar un diagrama de dispersión para ver la
relación entre dos o más atributos. Al elegir mostrar un diagrama de
dispersión, Encog Analyst le pedirá que elija qué atributos se relacionan.
Si elige sólo dos, se muestra un gráfico de dispersión regular. Si elige los
cuatro, se le mostrará un diagrama de dispersión multivariante como se
ve en la Figura 3.9.
Figure 3.9: Encog Analyst Multivariate Scatter Plot Report
Esto ilustra cómo se relacionan cuatro variables. Para ver cómo se

relacionan las variables, elija dos cuadrados en la diagonal. Siga la fila y la
columna en cada uno y el cuadrado que intersecta es la relación entre esos
dos atributos.
3.5 Resumen 49
También es importante tener en cuenta que el triángulo formado por

encima de la diagonal es la imagen especular (reversa) del triángulo
debajo de la diagonal.
3.5 Resumen
Este capítulo presentó el Encog Workbench. El Encog Workbench es
una aplicación GUI que trabaja visualmente con redes neuronales y otros
métodos de aprendizaje automático. El workbench es una aplicación Java
que produce datos que funciona en todas las plataformas Encog.
Este capítulo también demostró cómo usar Encog Workbench para

crear y entrenar directamente una red neuronal. Para los casos en que los
datos ya están normalizados, esta es una buena forma de entrenar y
evaluar redes neuronales. El banco de trabajo crea y entrena redes
neuronales para lograr esto.
Para obtener datos más complejos, Encog Analyst es una valiosa

herramienta que realiza la normalización automática. También organiza
un proyecto de red neuronal como una serie de tareas a ejecutar. El
conjunto de datos del iris se utilizó para ilustrar cómo utilizar el Analizador
Encog.
Hasta ahora, este libro ha demostrado cómo normalizar y procesar los

datos utilizando el Analista Encog. El siguiente capítulo muestra cómo
construir redes neuronales con código utilizando el marco Encog
directamente con y sin Encog Analyst.
51
Capitulo 4
Construyendo Redes Neuronales

C#
• Construyendo una Red Neural
• Funciones de activación
• Admitir la persistencia
• Uso del Encog Analyst de Code
En este capítulo se mostrará cómo construir redes neuronales
recurrentes simples y recurrentes con Encog y cómo guardar estas redes
neuronales para su uso posterior. Ambos tipos de redes neuronales se
crean utilizando las clases BasicNetwork y BasicLayer. Además de estas
dos clases, también se utilizan funciones de activación. También se
discutirá el papel de las funciones de activación.
Las redes neuronales pueden tomar una cantidad considerable de

tiempo para entrenar. Debido a esto es importante guardar sus redes
neuronales. Las redes neuronales Encog pueden ser persistidas usando
la serialización integrada de .Net. Esta persistencia también puede
lograrse escribiendo la red neuronal en un archivo EG, un archivo de texto
entre plataformas. Este capítulo introducirá ambas formas de persistencia.
En el último capítulo, el Encog Analyst se utilizó para normalizar

automáticamente los datos. El Encog Analyst también puede crear
automáticamente redes neuronales basadas en datos CSV. Este capítulo
mostrará cómo usar el analista Encog para crear redes neuronales a
partir del código.
52 Construir redes neuronales en C#
4.1 Construcción de una red neuronal

Una simple red neuronal se puede crear rápidamente utilizando
BasicLayer y Ba-sicNetwork objetos. El código siguiente crea varios
objetos BasicLayer con una función de activación tangente hiperbólica
predeterminada.
BasicNetwork network = new BasicNetwork ( ) ;
network . AddLayer (new B a s i c L a y e r ( 2 ) ) ;
network . AddLayer (new B a s i c L a y e r ( 3 ) ) ;
network . AddLayer ( new B a s i c L a y e r ( 1 ) ) ;
network . S t r u c t u r e . F i n a l i z e S t r u c t u r e ( ) ;
network . Reset ( ) ;
Esta red tendrá una capa de entrada de dos neuronas, una capa oculta
con tres neuronas y una capa de salida con una sola neurona. Para
utilizar una función de activación que no sea la función tangente
hiperbólica, utilice código similar al siguiente:
BasicNetwork network = new BasicNetwork ( ) ; network .
AddLayer (new B a s i c L a y e r ( null , true , 2 ) ) ;
network . AddLayer (new B a s i c L a y e r (new A c t i v a t i o n S i g m o i d ( ) , true ,
3 ) ) ; network . AddLayer ( new B a s i c L a y e r ( new A c t i v a t i o n S i g m o i d ( ) ,
false , 1 ) ) ; network . S t r u c t u r e . F i n a l i z e S t r u c t u r e ( ) ;
network . Reset ( ) ;
La función de activación sigmoide se pasa a las llamadas AddLayer

para la capa oculta y de salida. El valor verdadero que también se
introdujo especifica que la BasicLayer debe tener una neurona de
sesgo. La capa de salida no tiene neuronas de sesgo, y la capa de
entrada no tiene una función de activación. Esto se debe a que la
neurona de polarización afecta a la capa siguiente, y la función de
activación a los datos que provienen de la capa anterior.
A menos que Encog se esté utilizando para algo muy experimental,
utilice siempre una neurona del sesgo. Las neuronas de sesgo
permiten que la función de activación cambie del origen de cero. Esto
permite que la red neural produzca un valor cero incluso cuando las
entradas no son cero. La siguiente URL proporciona una justificación
más matemática de la importancia de las neuronas de sesgo:
Http://www.heatonresearch.com/wiki/Bias
Las funciones de activación se unen a capas y se utilizan para escalar
datos de salida de una capa.
4.2 The Role of Activation Functions 53
Encog aplica la función de activación de una capa a los datos que la

capa está a punto de salir. Si no se especifica una función de activación
para BasicLayer, la activación tangencial hiperbólica será predeterminada.
También es posible crear capas de contexto. Una capa de contexto se
puede utilizar para crear un Elman o Jordania estilo redes neuronales. El
siguiente código podría ser utilizado para crear una red neuronal de
Elman.
B a s i c L a y e r input , hidden ;
network . AddLayer ( i n p u t = new B a s i c L a y e r
( 1 ) ) ; network . AddLayer ( hidden = new B a s i c L a y e r
( 2 ) ) ; network . AddLayer (new B a s i c L a y e r ( 1 ) ) ;
i n p u t . ContextFedBy = hidden ;
Observe la línea hidden.ContextFedBy? Esto crea un vínculo de

contexto desde la capa de salida a la capa oculta. La capa oculta siempre
se alimentará con la salida de la última iteración. Esto crea una red neural
de estilo Elman. Elman y Jordania se presentarán en el Capítulo 7.
4.2 Función de las funciones de activación
La última sección ilustró cómo asignar funciones de activación a
capas. Las funciones de activación son utilizadas por muchas
arquitecturas de redes neuronales para escalar la salida de capas. Encog
proporciona muchas funciones de activación diferentes que se pueden
utilizar para construir redes neuronales. Las siguientes secciones
introducirán estas funciones de activación.
Las funciones de activación se unen a capas y se utilizan para escalar
la salida de datos de una capa. Encog aplica la función de activación de
una capa a los datos que la capa está a punto de salir. Si no se especifica
una función de activación para Ba-sicLayer, la activación tangencial
hiperbólica será la predeterminada. Todas las clases que sirven como
funciones de activación deben implementar la interfaz
IActivationFunction.
54 Construir redes neuronales en C#
Las funciones de activación desempeñan un papel muy importante en el

entrenamiento de redes neuronales. El entrenamiento de propagación, que
será cubierto en el próximo capítulo, requiere que una función de activación
tenga una derivada válida. No todas las funciones de activación tienen
derivados válidos. Determinar si una función de activación tiene una derivada
puede ser un factor importante en la elección de una función de activación.
4.3 Encog las funciones de activación
Las siguientes secciones explicarán cada una de las funciones de activación
soportadas por Encog. Hay varios factores a considerar al elegir una función
de activación. En primer lugar, es importante considerar cómo el tipo de red
neural que se utiliza dicta la función de activación requerida. En segundo
lugar, considerar la necesidad de entrenar la red neural usando la
propagación. El entrenamiento de propagación requiere una función de
activación que proporciona un derivado. Por último, considere la gama de
números que se utilizarán. Algunas funciones de activación se ocupan sólo
de números positivos o números en un rango determinado.
4.3.1 ActivationBiPolar
La función ActivationBiPolar de activación se utiliza con redes
neuronales que requieren valores bipolares. Los valores bipolares son
verdaderos o falsos. Un valor verdadero se representa por un valor
bipolar de 1; Un valor falso se representa por un valor bipolar de -1. La
función de activación bipolar asegura que cualquier número que se pasa
a él es -1 o 1. La función ActivationBiPolar hace esto con el código
siguiente:
i f ( d [ i ] > 0) {
d[i] = 1 ;
} else {
d [ i ] = −1;
}
Como se muestra arriba, la salida de esta activación está limitada a -1 o 1.
Este tipo de función de activación se utiliza con redes neuronales que
requieren salida bipolar de una capa a la siguiente.
4.3 Encog Activación de funciones 55
No hay función derivada para bipolar, por lo que esta función de activación no
se puede utilizar con el entrenamiento de propagación.
4.3.2 Activación Competitiva
La función ActivationCompetitive se utiliza para forzar a un grupo
selecto de neuronas a ganar. El ganador es el grupo de neuronas con
mayor rendimiento. Las salidas de cada una de estas neuronas se
mantienen en la matriz pasada a esta función. El tamaño del grupo
neuronal ganador es definible. La función determinará primero a los
ganadores. Todas las neuronas no ganadoras se pondrán a cero. Los
ganadores tendrán el mismo valor, que es una división par de la suma de
los resultados ganadores.
Esta función comienza creando una matriz que rastreará si cada
neurona ya ha sido seleccionada como uno de los ganadores. El número
de ganadores también se cuenta.
var w i n n e r s = new b o o l [ x . Length ] ;
double sumWinners = 0 ;
En primer lugar, lazo maxWinners un número de veces para encontrar

ese número de ganadores.
for ( int i = 0 ; i < p a r a s [ 0 ] ; i ++)
{
double maxFound = Double . N e g a t i v e I n f i n i t y ;
int winner = −1;
Ahora, un ganador debe ser determinado. Bucle sobre todas las salidas
de la neurona y encontrar el que tiene la salida más alta.
for ( int j = s t a r t ; j < s t a r t + s i z e ; j ++)
{
Si esta neurona no ha ganado ya y tiene el máximo rendimiento, podría

ser un ganador si ninguna otra neurona tiene una mayor activación.
i f ( ! w i n n e r s [ j ] && ( x [ j ] > maxFound ) )
{
winner = j ;
maxFound = x [ j ] ;
}
}
56 Constructing Neural Networks in C#
Mantener la suma de los ganadores que fueron encontrados y marcar

esta neurona como un ganador. Marcarlo como ganador evitará que
vuelva a ser elegido. La suma de los resultados ganadores se dividirá en
última instancia entre los ganadores.
sumWinners += maxFound ;
w i n n e r s [ winner ] = true ;
Ahora que se determina el número correcto de ganadores, los valores

deben ser ajustados para ganadores y no ganadores. Los no ganadores
se pondrán a cero. Los ganadores compartirán la suma de los valores de
todos los ganadores.
for ( int i = s t a r t ; i < s t a r t + s i z e ; i ++)
{
if (winners[i])
{
x [ i ] = x [ i ] / sumWinners ;
}
else
{
x[i]=0.0d;
}
}
Este tipo de función de activación puede utilizarse con redes neuronales

competitivas de aprendizaje, como el mapa de auto-organización. Esta
función de activación no tiene derivada, por lo que no se puede utilizar
con el entrenamiento de propagación.
4.3.3 ActivationLinear
La función ActivationLinear no es en absoluto una función de activación.
Simplemente implementa la función lineal. La función lineal se puede ver
en la ecuación 4.1.
f(x) = x (4.1)
La gráfica de la función lineal es una línea simple, como se ve en la figura
4.1.
Figure 4.1: Gráfico de la función de activación lineal
La implementación de C # para la función de activación lineal es muy

simple. No hace nada. La entrada se devuelve al pasar
public v i r t u a l void A c t i v a t i o n F u n c t i o n ( double [ ] x , int s t a r t ,
int s i z e )
{
}
La función lineal se utiliza principalmente para tipos específicos de redes

neuronales que no tienen función de activación, como el mapa de auto-
organización. La función de activación lineal tiene una derivada constante
de uno, por lo que se puede utilizar con el entrenamiento de propagación.
A veces, las capas lineales son utilizadas por la capa de salida de una red
neural alimentada por propagación.
4.3.4 ActivationLOG
La función de activación ActivationLog utiliza un algoritmo basado en la
función de registro. A continuación, se muestra cómo se calcula esta
función de activación.
f(x) = log (1 + x)
log (1 x)
, x >= 0
, otherwise
(4.2)
−
Esto produce una curva similar a la función de activación tangente
hiperbólica, la cual será discutida más adelante en este capítulo. El
gráfico de la función de activación logarítmica se muestra en la figura 4.2.
Figura 4.2:Gráfico de la función de activación logarítmica
La función de activación logarítmica puede ser útil para prevenir la

saturación. Un nodo oculto de una red neuronal se considera saturado
cuando, en un conjunto dado de entradas, la salida es aproximadamente
1 o -1 en la mayoría de los casos. Esto puede disminuir el entrenamiento
significativamente. Esto hace que la función de activación logarítmica sea
una opción posible cuando el entrenamiento no tiene éxito usando la
función de activación tangencial hiperbólica.
Como se ilustra en la Figura 4.2, la función de activación logarítmica
abarca tanto números positivos como negativos. Esto significa que puede
usarse con redes neuronales donde se desea una salida de número
negativo. Algunas funciones de activación, como la función de activación
sigmoide, sólo producirán salida positiva. La función de activación
logarítmica tiene una derivada, por lo que puede utilizarse con el
entrenamiento de propagación.
4.3.5 ActivationSigmoid
La función de activación de ActivationSigmoid sólo debe utilizarse
cuando se espera una salida de número positiva porque la función
ActivationSigmoid sólo producirá salida positiva. La ecuación para la
función ActivationSigmoid se puede ver en la ecuación 4.2.
1
−x
f(x) = 1+e (4.3)
La activación de la función sigmoide moverá los números negativos al
rango positivo. Esto se puede ver en la figura 4.3, que muestra la gráfica
de la función sigmoide.
Figura 4.3: Gráfico de la función ActivationSigmoid
La función ActivationSigmoid es una opción muy común para las

redes neuronales recurrentes y simples. Sin embargo, es imprescindible
que los datos de entrenamiento no esperen números de salida negativos.
Si se requieren números negativos, la función de activación tangencial
hiperbólica puede ser una mejor solución.
4.3.6 ActivationSoftMax
La función de activación ActivationSoftMax escalará todos los
valores de entrada para que la suma sea igual a uno. La función de
activación ActivationSoftMax se utiliza a veces como una función de
activación de capa oculta.
La función de activación comienza por sumar el exponente natural de
todas las salidas de las neuronas.
double sum = 0 ;
{
x [ i ] = BoundMath . Exp ( x [ i ] ) ;
sum += x [ i ] ;
}
La salida de cada una de las neuronas se escala entonces según esta

suma. Esto produce resultados que sumarán 1.
{
x[i]= x [ i ] / sum ;
El ActivationSoftMax se utiliza típicamente en la capa de salida de una red

neuronal para su clasificación.
4.3.7 ActivationTANH
La función ActivationTANH de activación utiliza la función tangente
hiperbólica. La función de activación de la tangente hiperbólica es
probablemente la función de activación más comúnmente utilizada, ya
que funciona con números negativos y positivos. La función tangente
hiperbólica es la función de activación por defecto para Encog. La
ecuación para la función de activación tangente hiperbólica puede verse
en la ecuación 4.3.
2x
e −1
f(x) = 2x (4.4)
e +1
El hecho de que la función de activación de la tangente hiperbólica acepte tanto
números positivos como negativos se puede ver en la Figura 4.4, que muestra la
gráfica de la función tangente hiperbólica.
Figura 4.4: Gráfico de la función de activación tangencial hiperbólica
La función de la tangente hiperbólica es una opción muy común para

las redes neuronales recurrentes simples y recurrentes. La función
tangente hiperbólica tiene una derivada para que pueda usarse con el
entrenamiento de propagación.
4.4 Encog Persistencia 61
4.4 Encogimiento de la persistencia

Puede tomar un tiempo considerable para entrenar una red neuronal y es
importante tomar medidas para garantizar que su trabajo se salve una vez que la
red ha sido entrenada. Encog proporciona varios medios para guardar estos
datos, con dos maneras principales de almacenar objetos de datos Encog. Sigue
la persistencia basada en archivos o la propia persistencia de .Net.
.Net proporciona sus propios medios para serializar objetos y se denomina
serialización .Net. La serialización .Net permite que muchos tipos de objetos
diferentes se escriban en una secuencia, como un archivo de disco. La
serialización .Net para Encog funciona de la misma manera que con cualquier
objeto C # usando la serialización .Net. Cada objeto Encog importante que debe
soportar la serialización incluye la anotación C # [Serializable]. Esto hace que el
objeto sea compatible con la serialización .Net.
La serialización .Net es una forma rápida de almacenar un objeto Encog. Sin
embargo, tiene algunas limitaciones importantes. Los archivos creados con la
serialización .Net sólo pueden ser utilizados por Encog para .Net; Serán
incompatibles con Encog para Java o Encog para Silverlight. Además, la
serialización .Net está directamente vinculada a los objetos subyacentes. Como
resultado, las versiones futuras de Encog pueden no ser compatibles con sus
archivos serializados.
Para crear archivos universales que funcionen con todas las plataformas
Encog, considere el formato Encog EG. El formato EG almacena las redes
neuronales como archivos de texto plano que terminan en la extensión .EG.
Este capítulo introducirá ambos métodos de persistencia Encog,
comenzando con la persistencia Encog EG. El capítulo terminará explorando
cómo se guarda una red neuronal en un archivo de persistencia Encog.
4.5 Uso de Encog EG Persistencia

Los archivos de persistencia Encog EG son el formato de archivo nativo para
Encog y se almacenan con la extensión .EG. Encog Workbench utiliza Encog EG
para procesar archivos. Este formato se puede intercambiar a través de
diferentes sistemas operativos y plataformas Encog, lo que la convierte en la
elección de formato de elección para una aplicación Encog.
Esta sección comienza mirando un ejemplo XOR que hace uso de los
archivos EG de Encog. Posteriormente, este mismo ejemplo se utilizará para la
serialización .Net. Comenzaremos con el ejemplo de persistencia Encog EG.
4.5.1 Uso de Encog EG Persistence
La persistencia de Encog EG es muy fácil de usar. La clase
EncogDirectoryPersistence se utiliza para cargar y guardar objetos de un archivo
EG de Encog. El siguiente es un buen ejemplo de la persistencia de Encog EG:
Encog . Examples . P e r s i s t . P e r s i s t E n c o g
ConsoleExamples p e r s i s t −encog
El método Execute realiza este ejemplo completo. Se crea un conjunto de
entrenamiento que contiene las salidas y entradas esperadas para el
operador XOR.
this . app = app ;
IMLDataSet t r a i n i n g S e t = new BasicMLDataSet (XOR INPUT, XOR IDEAL) ;
Este método comienza creando una red neural básica para ser entrenada
con el operador XOR. Es una red neuronal simple de tres capas. Hay dos
neuronas de entrada, seis ocultas y una salida. El valor de false
especifica una función de activación sigmoide. Un valor de true habría
especificado una función de activación tangente hiperbólica.
BasicNetwork network = E n c o g U t i l i t y . SimpleFeedForward ( 2 , 6 , 0 , 1 ,
false);
Esta red neural será entrenada usando propagación elástica (RPROP).
E n c o g U t i l i t y . TrainToError ( network , trainingSet, 0.01);
El error final se guarda para ser comparado después de recargar.
double e r r o r = network . C a l c u l a t e E r r o r ( t r a i n i n g S e t ) ;
La red neuronal se guarda, utilizando una llamada a SaveObject. La red se
vuelve a cargar con una llamada a LoadObject. Ambos métodos están
contenidos en
La clase EncogDirectoryPersistence.
4.6 Uso de la serialización .Net 63
E n c o g D i r e c t o r y P e r s i s t e n c e . SaveObject (new F i l e I n f o (FILENAME) ,

network ) ;
network = ( BasicNetwork ) E n c o g D i r e c t o r y P e r s i s t e n c e . LoadObject
(new F i l e I n f o (FILENAME) ) ;
En este punto, la red simplemente se ha guardado y recargado. El error

debe ser el mismo que antes. Se comprueba el error.
double e r r o r 2 = network . C a l c u l a t e E r r o r ( t r a i n i n g S e t ) ;
app . WriteLine ( ” E r r o r b e f o r e s a v e to EG: ” + Format . FormatPercent (
error));
app . WriteLine ( ” E r r o r b e f o r e a f t e r to EG: ” + Format . FormatPercent (
error2));
Este error se muestra y debe ser el mismo que antes de la red se guardó.
4.6 Uso de la serialización .Net
También es posible usar serialización .Net estándar con redes neuronales
Encog y conjuntos de entrenamiento. La persistencia de Encog EG es
mucho más flexible que la serialización .Net. Sin embargo, hay casos en
que una red neuronal puede simplemente ser guardada en un archivo
binario dependiente de la plataforma. El siguiente es un buen ejemplo de
persistencia .Net:
Encog . Examples . P e r s i s t . P e r s i s t S e r i a l
ConsoleExamples p e r s i s t −s e r i a l
Este ejemplo muestra cómo utilizar la serialización .Net con Encog. El
ejemplo es casi idéntico al ejemplo de serialización Encog que acabamos
de ver. La principal diferencia es que la carga / ahorro se realiza con la
serialización .Net. Esto se puede ver aquí.
S e r i a l i z e O b j e c t . Save ( ” encog . s e r ” , network ) ;
network = ( BasicNetwork ) S e r i a l i z e O b j e c t . Load ( ” encog . s e r ” ) ;
64 Construir redes neuronales en C #
Los métodos Load y Save de la clase SerializeObject se utilizan para

guardar y cargar el objeto. Una vez que la red ha sido recargada, el error
se evalúa. Este nivel de error debe coincidir con el nivel de error en el
momento en que la red fue entrenada originalmente.
4.7 Resumen
Feedforward y redes neuronales recurrentes simples se crean utilizando las
clases BasicNetwork y BasicLayer. Usando estos objetos, se pueden crear
redes neuronales. Las capas también pueden conectarse mediante enlaces
de contexto, así como redes neuronales recurrentes simples, como la red
neuronal de Elman, se crean.
Encog utiliza funciones de activación para escalar la salida de las capas de

red neuronal. Por defecto, Encog utilizará una función tangente hiperbólica,
que es una buena función de activación de propósitos generales. Cualquier
clase que actúe como una función de activación debe implementar la interfaz
IActivationFunction. Si la función de activación se va a utilizar con el
entrenamiento de propagación, la función de activación debe ser capaz de
calcular para su derivada.
La clase de función de activación ActivationBiPolar se utiliza cuando una red

sólo acepta números bipolares. La clase de activación ActivationCompetitive
se utiliza para redes neuronales competitivas, como el mapa de auto-
organización. La clase de activación ActivationLinear se utiliza cuando no se
desea ninguna función de activación. La clase de activación ActivationLOG
funciona de manera similar a la clase de activación ActivationTANH, excepto
que no siempre satura como capa oculta. La clase de función de activación
ActivationSigmoid es similar a la clase de activación ActivationTANH, excepto
que sólo se devuelven números positivos. La clase de función de activación
ActivationSoftMax escala la salida para que la suma sea una.
En este capítulo se ilustró cómo persistir Encog objetos utilizando dos

métodos. Los objetos se pueden persistir utilizando el formato Encog EG o
mediante la serialización .Net.
El formato Encog EG es el medio preferido para guardar Encog neural net-
works. A estos objetos se accede utilizando su nombre de recurso. El archivo
EG puede intercambiarse entre cualquier plataforma que soporte Encog.
Encog también permite la serialización .Net para almacenar objetos en un
disco o una secuencia.
4.7 Resumen 65
La serialización .Net es más restrictiva que los archivos Encog EG.

Dado que los archivos binarios se almacenan automáticamente
directamente desde los objetos, incluso el cambio más pequeño en un
objeto Encog puede dar lugar a archivos incompatibles. Además, otras
plataformas no podrán utilizar el archivo.
En el próximo capítulo se introduce el concepto de formación en redes

neuronales. El entrenamiento es el proceso en el que los pesos de una
red neuronal se modifican para producir la salida deseada. Hay varias
maneras en que las redes neuronales pueden ser entrenadas. El
siguiente capítulo introducirá el entrenamiento de propagación.
67
Capitulo 5
Formación de programación
• Cómo funciona el entrenamiento de propagación

• Tipos de entrenamiento de propagación
• Fábricas de entrenamiento y método
• Entrenamiento multiproceso
El entrenamiento es el medio por el cual los pesos de la red neural se

ajustan para dar salidas deseables. Este libro cubrirá el entrenamiento
supervisado y no supervisado. Este capítulo discutirá el entrenamiento de
propagación, una forma de entrenamiento supervisado donde la salida
esperada se da al algoritmo de entrenamiento.
Encog también admite el entrenamiento sin supervisión. Con el
entrenamiento sin supervisión, la red neural no recibe la salida esperada.
Por el contrario, la red neuronal aprende y hace ideas sobre los datos con
dirección limitada. En el capítulo 10 se discutirá la capacitación no
supervisada.
El entrenamiento de la propagación puede ser una forma muy eficaz
de entrenamiento para redes de alimentación simple, recurrente simple y
otros tipos de redes neuronales. Si bien existen varias formas diferentes
de entrenamiento de propagación, este capítulo se enfocará en las formas
de propagación actualmente soportadas por Encog. Estos seis
formularios se enumeran a continuación:
68 Propagation Training
• Entrenamiento Backpropagation
• Entrenamiento de Propagación Rápida (QPROP)
• Regla de actualización de Manhattan
• Entrenamiento de Propagación Resiliente (RPROP)
• Gradiente de conjugado escalado (SCG)
• Levenberg Marquardt (LMA)
Los seis de estos métodos funcionan de manera similar. Sin embargo,

hay algunas diferencias importantes. La siguiente sección explorará el
entrenamiento de propagación en general.
5.1 Entendiendo el entrenamiento de
propagación
Los algoritmos de entrenamiento de propagación utilizan entrenamiento
supervisado. Esto significa que al algoritmo de entrenamiento se le da un
conjunto de entrenamiento de entradas y la salida ideal para cada entrada. El
algoritmo de entrenamiento de propagación pasará por una serie de
iteraciones que probablemente mejorarán la tasa de error de la red neuronal
en algún grado. La tasa de error es el porcentaje de diferencia entre la salida
real de la red neural y la salida ideal proporcionada por los datos de
entrenamiento.
Cada iteración recorrerá completamente los datos de entrenamiento. Para
cada elemento de datos de entrenamiento, se calculará algún cambio en la
matriz de pesos. Estos cambios se aplicarán en lotes utilizando el
entrenamiento por lotes de Encog. Por lo tanto, Encog actualiza los valores
de la matriz de pesos al final de una iteración.
Cada iteración de entrenamiento comienza haciendo un bucle sobre
todos los elementos de entrenamiento en el conjunto de entrenamiento. Para
cada uno de estos elementos de entrenamiento, se ejecuta un proceso de
dos pasadas: un paso hacia adelante y un paso hacia atrás.El pase hacia
adelante simplemente presenta datos a la red neuronal como lo haría
normalmente si no hubiera habido entrenamiento. Los datos de entrada se
presentan y el algoritmo calcula el error, es decir, la diferencia entre las
salidas real e ideal. La salida de cada una de las capas se mantiene también
en este paso.
5.1 Entendiendo el entrenamiento de propagación 69
Esto permite que los algoritmos de entrenamiento vean la salida de
cada una de las capas de la red neuronal.
El pase hacia atrás comienza en la capa de salida y regresa a la capa
de entrada. El paso hacia atrás comienza examinando la diferencia entre
cada una de las salidas ideal y real de cada una de las neuronas. A
continuación se calcula el gradiente de este error. Para calcular este
gradiente, la salida real de la red neural se aplica a la derivada de la
función de activación utilizada para este nivel. Este valor se multiplica
entonces por el error.
Debido a que el algoritmo utiliza la función derivada de la función de
activación, el entrenamiento de propagación sólo puede usarse con
funciones de activación que realmente tienen una función derivada. Esta
derivada calcula el gradiente de error para cada conexión en la red
neuronal. El uso exacto de este valor depende del algoritmo de
entrenamiento utilizado.
5.1.1 Comprensión de la retropropagación
Backpropagation es uno de los métodos de entrenamiento más antiguos
para las redes neuronales feedforward. La retropropagación utiliza dos
parámetros en conjunto con el descenso gra-dient calculado en la sección
anterior. El primer parámetro es la tasa de aprendizaje que es esencialmente
un porcentaje que determina cómo directamente el descenso de gradiente
debe aplicarse a la matriz de peso. El gradiente es multiplicado por la
velocidad de aprendizaje y luego se añade a la matriz de peso. Esto
lentamente optimiza los pesos a valores que producirán un error menor.
Uno de los problemas con el algoritmo de retropropagación es que el
algoritmo de descenso gra-dient buscará mínimos locales. Estos mínimos
locales son puntos de error bajo, pero pueden no ser un mínimo global. El
segundo parámetro proporcionado al algoritmo backpropagation ayuda a la
retropropagación fuera de los mínimos locales. El segundo parámetro se
llama impulso. Momentum especifica hasta qué punto los cambios de peso
de iteración anteriores deben aplicarse a la iteración actual.
El parámetro momento es esencialmente un porcentaje, al igual que la
tasa de aprendizaje. Para utilizar el momento, el algoritmo de
retropropagación debe realizar un seguimiento de los cambios que se
aplicaron a la matriz de pesos a partir de la iteración anterior. Estos cambios
se volverán a aplicar a la iteración actual, excepto
los parámetros de momentum. Por lo general, el parámetro momentum será

menor que uno, por lo que los cambios de peso desde la iteración de
entrenamiento anterior son menos significativos que los cambios calculados para
la iteración actual. Por ejemplo, si se establece el momento en 0,5, se aplicará el
50% de los cambios de la formación previa a los pesos de la matriz de pesos
actual.
El siguiente código configurará un entrenador de retropropagación, dado un
conjunto de entrenamiento y una red neuronal.
var t r a i n = new Backpropagation ( network , trainingSet, 0.7,
0.3);
El código anterior crearía un entrenador de retropropagación con una tasa de

aprendizaje de 0,7 y un impulso de 0,3. Una vez configurado el objeto de
entrenamiento está listo para el entrenamiento de iteración. Para obtener un
ejemplo de entrenamiento de repetición, consulte:

ConsoleExamples xor
El ejemplo anterior se puede modificar fácilmente para utilizar entrenamiento de

retropropagación reemplazando la línea de entrenamiento de propagación
elástica con la línea de entrenamiento anterior.
5.1.2 Descripción de la regla de actualización de
Manhattan
Uno de los problemas con el algoritmo de entrenamiento de retropropagación
es el grado en el que se cambian los pesos. El descenso del gradiente puede
aplicar a menudo demasiado grande de un cambio a la matriz del peso. La regla
de actualización de Manhattan y los algoritmos de entrenamiento de
propagación resiliente sólo utilizan el signo del degradado. La magnitud es
descartada. Esto significa que sólo es importante si el gradiente es positivo,
negativo o cercano a cero.
Para la regla de actualización de Manhattan, esta magnitud se utiliza para
determinar cómo actualizar el valor de la matriz de peso. Si la magnitud es
cercana a cero, entonces no se hace ningún cambio al valor de peso. Si la
magnitud es positiva, entonces el valor de peso se incrementa en una cantidad
específica. Si la magnitud es negativa, entonces el valor de peso disminuye en
una cantidad específica. The amount by which
5.1 Entendiendo el entrenamiento de propagación 71
específica. Si la magnitud es negativa, entonces el valor de peso disminuye
en una cantidad específica. La cantidad por la que se cambia el valor de peso se
define como una constante. Debe proporcionar esta constante al algoritmo de la
regla de actualización de Manhattan.
El siguiente código configurará un entrenador de actualización de Manhattan
dado un conjunto de entrenamiento y una red neuronal.
var t r a i n =
new ManhattanPropagation ( network , t r a i n i n g S e t , 0 . 0 0 0 0 1 ) ;
El código anterior crearía un entrenador de la regla de actualización de

Manhattan con una tasa de aprendizaje de 0.00001. La propagación de
Manhattan generalmente requiere una pequeña tasa de aprendizaje. Una vez
finalizada la configuración, el objeto de entrenamiento está listo para el
entrenamiento de iteración. Para obtener un ejemplo de entrenamiento de
repetición, consulte:
El ejemplo anterior se puede modificar fácilmente para utilizar el entrenamiento

de propagación de Manhattan reemplazando la línea de entrenamiento de
propagación resiliente con la línea de entrenamiento anterior.
5.1.3 Entendiendo el entrenamiento de propagación
rápida
La propagación rápida (QPROP) es otra variante del entrenamiento de
propagación. La propagación rápida se basa en el método de Newton, que es un
medio para encontrar las raíces de una función. Esto se puede adaptar a la tarea
de minimizar el error de una red neuronal. Normalmente, QPROP realiza mucho
mejor que backpropaga-tion. El usuario debe proporcionar QPROP con un
parámetro de velocidad de aprendizaje. Sin embargo, no existe un parámetro de
momento, ya que el QPROP suele ser más tolerante con las tasas de
aprendizaje más altas. Una tasa de aprendizaje de 2.0 es generalmente un buen
punto de partida. El siguiente código configurará un entrenador de Propagación
Rápida, dado un conjunto de entrenamiento y una red neuronal.
var t r a i n =
new QuickPropagation ( network , t r a i n i n g S e t , 2 . 0 ) ;
El código anterior crearía un entrenador QPROP con una tasa de aprendizaje de
2.0. QPROP generalmente puede tener una tasa de aprendizaje más alta. Una
vez configurado, el objeto de entrenamiento está listo para el entrenamiento de
iteración. Para obtener un ejemplo de entrenamiento de repetición, consulte:
El ejemplo anterior se puede modificar fácilmente para usar el

entrenamiento QPROP reemplazando la línea de entrenamiento de
propagación elástica con la línea de entrenamiento anterior.
5.1.4 Entendiendo el entrenamiento de propagación
resiliente
El algoritmo de entrenamiento de propagación resiliente (RPROP) es a
menudo el algoritmo de entrenamiento más eficiente proporcionado por Encog
para redes neuronales de feedforward supervisadas. Una ventaja particular del
algoritmo RPROP es que no requiere ningún ajuste de parámetros antes de
usarlo. No hay tasas de aprendizaje, valores de impulso o constantes de
actualización que deba determinarse. Esto es bueno porque puede ser difícil
determinar la tasa de aprendizaje óptima exacta.
Los algoritmos RPROP funcionan de manera similar a la Regla de
Actualización de Manhattan en que solo se usa la magnitud del descenso. Sin
embargo, en lugar de utilizar una constante fija para actualizar los valores de
peso, se utiliza un enfoque mucho más granular. Estos deltas no permanecerán
fijos como en la regla de actualización de Manhattan o el algoritmo de
retropropagación. Más bien, estos valores delta cambiarán a medida que
progrese el entrenamiento.
El algoritmo RPROP no mantiene un valor de actualización global, o delta.
Por el contrario, los deltas individuales se mantienen para cada valor de matriz
de peso. Estos deltas primero se inicializan a un número muy pequeño. Cada
iteración a través del algoritmo RPROP actualizará los valores de peso de
acuerdo con estos valores delta. Sin embargo, como se mencionó
anteriormente, estos valores delta no permanecen fijos. El gradiente se usa para
determinar cómo deben cambiar usando la magnitud para determinar cómo los
deltas deben ser modificados aún más.
5.1 Understanding Propagation Training 73
Esto permite que cada valor individual de la matriz de pesos sea entrenado
individualmente, una ventaja no proporcionada por el algoritmo de
retropropagación o la Regla de actualización de Manhattan.
El siguiente código configurará un entrenador de Propagación Resiliente, dado
un conjunto de entrenamiento y una red neuronal
var t r a i n =
new R e s i l i e n t P r o p a g a t i o n ( network , t r a i n i n g S e t ) ;
El código anterior crearía un entrenador RPROP. RPROP no requiere

parámetros para comenzar a entrenar. Esta es una de las principales
ventajas del algoritmo de entrenamiento RPROP. Una vez configurado, el
objeto de entrenamiento está listo para el entrenamiento de iteración.
Para obtener un ejemplo de entrenamiento de repetición, consulte:
El ejemplo anterior ya usa entrenamiento RPROP.

Existen cuatro variantes principales del algoritmo RPROP que son
soportadas por Encog:
• RPROP +
• RPROP-
• iRPROP +
• iPROP-
De forma predeterminada, Encog utiliza RPROP +, el RPROP más
estándar. Algunas investigaciones indican que iRPROP + es el algoritmo
RPROP más eficiente. Para configurar Encog para utilizar iRPROP +
utilice el siguiente comando.
t r a i n . setRPROPType (RPROPType . iRPROPp) ;
5.1.5 Entendiendo el entrenamiento de SCG

Scaled Conjugate Gradient (SCG) es un entrenamiento rápido y eficiente
para Encog. SCG se basa en una clase de algoritmos de optimización
denominados Conjugate Gra-dient Methods (CGM). SCG no es aplicable a todos
los conjuntos de datos. Cuando se utiliza dentro de su aplicabilidad, es bastante
ffi ciente. Al igual que RPROP, SCG está en una ventaja ya que no hay
parámetros que se deben establecer.
El siguiente código configurará un entrenador SCG, dado un conjunto de
entrenamiento y una red neuronal.
74 Formación de Propagación
var t r a i n
= new S c a l e d C o n j u g a t e G r a d i e n t ( network , t r a i n i n g S e t ) ;
El código anterior crearía un entrenador SCG. Una vez configurado, el objeto

de entrenamiento está listo para el entrenamiento de iteración. Para obtener
un ejemplo de entrenamiento de repetición, consulte:
El ejemplo anterior se puede modificar fácilmente para utilizar el

entrenamiento de SCG reemplazando la línea de entrenamiento de
5.1.6 Understanding LMA Training
El algoritmo de Levenberg Marquardt (LMA) es un método de entrenamiento
muy efectivo para redes neuronales. En muchos casos, LMA superará a
Resilient Propagation. LMA es un algoritmo híbrido basado en el método de
Newton y el descenso gradiente (backpropagation), integrando las fortalezas de
ambos. Se garantiza que el descenso de gradiente converge a un mínimo local,
aunque con lentitud. GNA es bastante rápido pero a menudo falla en converger.
Mediante el uso de un factor de amortiguación para interpolar entre los dos, se
crea un método híbrido.
El siguiente código muestra cómo utilizar Levenberg-Marquardt con Encog
para C #.
var t r a i n = new LevenbergMarquardtTraining ( network , trainingSet);
El código anterior crearía un LMA con parámetros predeterminados que

probablemente no requieran ajustes. Una vez configurado, el objeto de
entrenamiento está listo para el entrenamiento de iteración. Para obtener
un ejemplo de entrenamiento de repetición, consulte:
5.2 Encog Method & Training Factories 75
El ejemplo anterior se puede modificar fácilmente para utilizar el

entrenamiento LMA reemplazando la línea de entrenamiento de
5.2 Encog Method y Fábricas de Entrenamiento

Este capítulo ilustró cómo instanciar a los instructores para muchos
métodos de entrenamiento diferentes usando objetos tales como
Backpropagation, ScaledConjugateGradi-ent o ResilientPropagation. En los
capítulos anteriores, aprendimos a crear diferentes tipos de redes neuronales
usando BasicNetwork y BasicLayer. También podemos crear métodos de
entrenamiento y redes neuronales usando fábricas.
Las fábricas crean redes neuronales y métodos de entrenamiento a partir
de cadenas de texto, ahorrando tiempo eliminando la necesidad de instanciar
todos los objetos de otra manera necesarios. Para un ejemplo de uso de
fábrica, consulte:
El ejemplo anterior utiliza fábricas para crear redes neuronales y métodos

de entrenamiento. Esta sección mostrará cómo crear redes neuronales y
métodos de entrenamiento usando fábricas.
5.2.1 Creating Neural Networks with Factories
El código siguiente utiliza una fábrica para crear una red neuronal de
feedforward:
var methodFactory = new MLMethodFactory ( ) ; var
method = methodFactory . Create (
MLMethodFactory .TYPE
FEEDFORWARD, ” ? :
B−>SIGMOID−>4:B−>SIGMOID−>?” , 2 ,
1) ;
El código anterior crea una red neuronal con dos neuronas de entrada
y una neurona de salida. Hay cuatro neuronas ocultas. Las neuronas de
polarización se colocan en las capas de entrada y ocultas. Como es típico
para las redes neuronales, no hay neuronas de sesgo en la capa de
salida. La función de activación sigmoide se utiliza entre la entrada y la
neurona oculta, así como entre la capa oculta y la capa de salida.
Puede observar los dos signos de interrogación en la cadena de
arquitectura de red neural. Estos serán rellenados por los tamaños de
capa de entrada y salida especificados en el método create y son
opcionales. Puede codificar los tamaños de entrada y salida. En este
caso, los números especificados en la llamada de creación serán
ignorados.
5.2.2 Creación de métodos de entrenamiento con fábricas

También es posible crear un método de entrenamiento usando una
fábrica. El siguiente código crea un entrenador de backpropagation
usando una fábrica.
var t r a i n F a c t o r y = new MLTrainFactory ( ) ; var
t r a i n = t r a i n F a c t o r y . Create (
network ,
dataSet ,
MLTrainFactory .TYPE BACKPROP,
”LR=0.7 ,MOM=0.3 ”
);
El código anterior crea un entrenador de retropropagación usando una tasa

de aprendizaje de 0,7 y un impulso de 0,3.
5.3 Cómo funciona la formación multiproceso
El entrenamiento multiproceso funciona particularmente bien con conjuntos
de entrenamiento más grandes y máquinas múltiples núcleos. Si Encog no
detecta que ambos están presentes, volverá a single-threaded. Cuando hay más
de un núcleo de procesamiento y suficientes elementos de conjunto de
entrenamiento para mantener ocupados, el entrenamiento multiproceso
funcionará significativamente más rápido que un solo subproceso.
Este capítulo ya ha introducido tres técnicas de entrenamiento de
propagación, todas las cuales funcionan de manera similar. Ya sea la
retropropagación, la propulsión resiliente o la Regla de Actualización de
Manhattan, la técnica es similar. Hay tres pasos distintos:
1 . Perform a r e g u l a r f e e d forw ard p a s s .
2 . P r o c e s s the l e v e l s backwards and d e t e r m i n e the e r r o r s at each
level.
3 . Apply the changes to the w e i g h t s .
En primer lugar, se realiza un pase de alimentación regular. La salida de

cada nivel se mantiene para que el error de cada nivel pueda ser evaluado
independientemente. En segundo lugar, los errores se calculan en cada nivel
y los derivados de cada función de activación se utilizan para calcular
descensos de gradiente. Estos gradientes muestran la
5.3 Cómo funciona la formación multiproceso 77
dirección que el peso debe ser modificado para mejorar el error de la
red. Estos gradientes se utilizarán en el tercer paso.
El tercer paso es lo que varía entre los diferentes algoritmos de
entrenamiento. Backpropagation simplemente escalas los descensos de
gradiente por una tasa de aprendizaje. Los descensos escalonados de
gradiente se aplican entonces directamente a los pesos. La Regla de
Actualización de Man-hattan sólo usa el signo de gradiente para decidir
en qué dirección se va a ver el peso. El peso se cambia entonces en la
dirección positiva o negativa por una constante fija.
RPROP mantiene un valor delta individual para cada peso y sólo
utiliza el signo de la pendiente de gradiente para aumentar o disminuir las
cantidades de delta. Las cantidades delta se aplican entonces a los
pesos.
El algoritmo multihilo utiliza subprocesos para realizar los pasos 1 y 2.
Los datos de formación se dividen en paquetes que se distribuyen entre
los subprocesos. Al comienzo de cada iteración, se inician hilos para
manejar cada uno de estos paquetes. Una vez que todos los hilos se han
completado, un solo hilo agrega todos los resultados y los aplica a la red
neuronal. Al final de la iteración, hay una cantidad de tiempo muy breve
en la que sólo se ejecuta un subproceso. Esto se puede ver en la Figura
5.1.
Figura 5.1:Entrenamiento Encog en un cuádruple de Hyperthreaded
Como se muestra en la imagen anterior, el i7 se está ejecutando

actualmente al 100%. El final de cada iteración se identifica claramente por
donde cada uno de los procesadores cae brevemente. Afortunadamente,
este es un tiempo muy breve y no tiene un gran impacto en la e fi cacia
general de la capacitación. Al intentar superar esto, varias implementaciones
probaron no obligar a los hilos a esperar al final de la iteración para
una resincronización. Este método no proporcionó entrenamiento eficiente
porque los algoritmos del entrenamiento de la propagación necesitan
todos los cambios aplicados antes de que comience la iteración siguiente.
5.4 Uso del entrenamiento multiproceso
Para ver el entrenamiento multihilo realmente brillar, se necesita un
conjunto de entrenamiento más grande. En el próximo capítulo veremos
cómo recopilar información para Encog usando conjuntos de
entrenamiento más grandes. Sin embargo, por ahora, vamos a mirar un
ejemplo de benchmarking simple que genera un conjunto de
entrenamiento aleatorio y compara multithreaded y single-threaded
tiempos de entrenamiento.
Se muestra un punto de referencia simple que hace uso de una capa
de entrada de 40 neuronas, una capa oculta de 60 neuronas y una capa
de salida de 20 neuronas. Un conjunto de entrenamiento de 50.000
elementos se utiliza. Este ejemplo se puede encontrar en la siguiente
ubicación.
Encog . Examples . Benchmark . MultiThreadBenchmark

ConsoleExamples multibench
Ejecutar este programa en un Quadcore i7 con Hyperthreading produjo el

siguiente resultado:
T r a i n i n g 20 I t e r a t i o n s with S i n g l e −t h r e a d e d
I t e r a t i o n #1 E r r o r : 1 . 0 5 9 4 4 5 3 7 8 4 0 7 5 1 4 8
I t e r a t i o n #2 E r r o r : 1 . 0 5 9 4 4 5 3 7 8 4 0 7 5 1 4 8
I t e r a t i o n #3 E r r o r : 1 . 0 0 5 9 7 9 1 0 5 9 0 8 6 3 8 5
I t e r a t i o n #4 E r r o r : 0 . 9 5 5 8 4 5 3 7 5 5 8 7 1 2 4
I t e r a t i o n #5 E r r o r : 0 . 9 3 4 1 6 9 8 0 3 8 7 0 4 5 4
I t e r a t i o n #6 E r r o r : 0 . 9 1 4 0 4 1 8 7 9 3 3 3 6 8 0 4
I t e r a t i o n #7 E r r o r : 0 . 8 9 5 0 8 8 0 4 7 3 4 2 2 7 4 7
I t e r a t i o n #8 E r r o r : 0 . 8 7 5 9 1 5 0 2 2 8 2 1 9 4 5 6
I t e r a t i o n #9 E r r o r : 0 . 8 5 9 6 6 9 3 5 2 3 9 3 0 3 7 1
I t e r a t i o n #10 E r r o r : 0 . 8 4 3 5 7 8 4 8 3 6 2 9 4 1 2
I t e r a t i o n #11 E r r o r : 0 . 8 2 3 9 6 8 8 4 1 5 3 8 9 1 0 7
I t e r a t i o n #12 E r r o r : 0 . 8 0 7 6 1 6 0 4 5 8 1 4 5 5 2 3
I t e r a t i o n #13 E r r o r : 0 . 7 9 2 8 4 4 2 4 3 1 4 4 2 1 3 3
I t e r a t i o n #14 E r r o r : 0 . 7 7 7 2 5 8 5 6 9 9 9 7 2 1 4 4
5.4 Uso del entrenamiento multi procesos 79
I t e r a t i o n #15 E r r o r : 0 . 7 6 3 4 5 3 3 2 8 3 6 1 0 7 9 3
I t e r a t i o n #16 E r r o r : 0 . 7 5 0 0 4 0 1 6 6 6 5 0 9 9 3 7
I t e r a t i o n #17 E r r o r : 0 . 7 3 7 6 1 5 8 1 1 6 0 4 5 2 4 2
I t e r a t i o n #18 E r r o r : 0 . 7 2 6 8 9 5 4 1 1 3 0 6 8 2 4 6
I t e r a t i o n #19 E r r o r : 0 . 7 1 5 5 7 8 4 6 6 7 6 2 8 0 9 3
I t e r a t i o n #20 E r r o r : 0 . 7 0 5 5 3 7 1 6 6 1 1 8 0 3 8
RPROP R e s u l t : 3 5 . 1 3 4 s e c o n d s .
F i n a l RPROP e r r o r : 0 . 6 9 5 2 1 4 1 6 8 4 7 1 6 6 3 2
T r a i n i n g 20 I t e r a t i o n s with M u l t i t h r e a d i n g
I t e r a t i o n #1 E r r o r : 0 . 6 9 5 2 1 2 6 3 1 5 7 0 7 9 9 2
I t e r a t i o n #2 E r r o r : 0 . 6 9 5 2 1 2 6 3 1 5 7 0 7 9 9 2
I t e r a t i o n #3 E r r o r : 0 . 9 0 9 1 5 2 4 9 2 4 8 7 8 8
I t e r a t i o n #4 E r r o r : 0 . 8 7 9 7 0 6 1 6 7 5 2 5 8 8 3 5
I t e r a t i o n #5 E r r o r : 0 . 8 5 6 1 1 6 9 6 7 3 0 3 3 4 3 1
I t e r a t i o n #6 E r r o r : 0 . 7 9 0 9 5 0 9 6 9 4 0 5 6 1 7 7
I t e r a t i o n #7 E r r o r : 0 . 7 7 0 9 5 3 9 4 1 5 0 6 5 7 3 7
I t e r a t i o n #8 E r r o r : 0 . 7 5 4 1 9 7 1 1 7 2 6 1 8 3 5 8
I t e r a t i o n #9 E r r o r : 0 . 7 2 8 7 0 9 4 4 1 2 8 8 6 5 0 7
I t e r a t i o n #10 E r r o r : 0 . 7 1 5 8 1 4 9 1 4 4 3 8 9 3 5
I t e r a t i o n #11 E r r o r : 0 . 7 0 3 7 7 3 0 8 0 8 7 0 5 0 1 6
I t e r a t i o n #12 E r r o r : 0 . 6 9 2 5 9 0 2 5 8 5 0 5 5 8 8 6
I t e r a t i o n #13 E r r o r : 0 . 6 7 8 4 0 3 8 1 8 1 0 0 7 8 2 3
I t e r a t i o n #14 E r r o r : 0 . 6 6 7 3 3 1 0 3 2 3 0 7 8 6 6 7
I t e r a t i o n #15 E r r o r : 0 . 6 5 8 5 2 0 9 1 5 0 7 4 9 2 9 4
I t e r a t i o n #16 E r r o r : 0 . 6 5 0 3 7 1 0 8 6 7 1 4 8 9 8 6
I t e r a t i o n #17 E r r o r : 0 . 6 4 2 9 4 7 3 7 8 4 8 9 7 7 9 7
I t e r a t i o n #18 E r r o r : 0 . 6 3 7 0 9 6 2 0 7 5 6 1 4 4 7 8
I t e r a t i o n #19 E r r o r : 0 . 6 3 1 4 4 7 8 7 9 2 7 0 5 9 6 1
I t e r a t i o n #20 E r r o r : 0 . 6 2 6 5 7 2 4 2 9 6 5 8 7 2 3 7
Multi−Threaded R e s u l t : 8 . 7 9 3 s e c o n d s .
F i n a l Multi−t h r e a d e r r o r : 0 . 6 2 1 9 7 0 4 3 0 0 8 5 1 0 7 4
Factor improvement : 4 . 0 1 0 6 7 8 3 8 0 5 2 9 9 6 7 4
Como se muestra por los resultados anteriores, el algoritmo RPROP de

un solo hilo terminó en 128 segundos y el algoritmo RPROP multiproceso
terminó en sólo 31 segundos. Multithreading mejora el rendimiento por un
factor de cuatro. Sus resultados que ejecutan el ejemplo anterior
dependerán del número de núcleos que tenga su computadora. Si su
computadora es un solo núcleo sin hyperthreading, entonces el factor
será cercano a uno. Esto se debe a que el segundo entrenamiento multi-
subprocesos volverá a un solo hilo.
5.5 Resumen
Este capítulo exploró cómo usar varios algoritmos de entrenamiento de
propagación con Encog. El entrenamiento de propagación es una clase muy
común de algoritmos de entrenamiento supervisados. El entrenamiento de
propagación resistente es generalmente la mejor opción; Sin embargo, la Regla
de actualización de Manhattan y la retropropagación pueden ser útiles para
ciertas situaciones. SCG y QPROP son también sólidos algoritmos de
entrenamiento.
Backpropagation fue uno de los algoritmos de entrenamiento original para las
redes neuronales feedforward. Aunque Encog lo soporta principalmente con
fines históricos, a veces puede usarse para refinar aún más una red neuronal
después de que se haya utilizado la propagación elástica. Backpropagation
utiliza una tasa de aprendizaje y el impulso. La velocidad de aprendizaje define
la rapidez con que la red neuronal aprenderá; El impulso ayuda a la red a salir
de los mínimos locales.
La regla de actualización de Manhattan utiliza un valor delta para actualizar
los valores de peso. Puede ser difícil elegir este valor delta correctamente; Un
valor demasiado alto hará que la red no aprenda nada.
Propagación Resiliente (RPROP) es uno de los mejores algoritmos de
entrenamiento ofrecidos por Encog. No requiere que proporcione parámetros de
entrenamiento, como los otros dos algoritmos de entrenamiento de propagación.
Esto hace que sea mucho más fácil de usar. Además, la propagación elástica es
considerablemente más eficiente que la Regla de actualización de Manhattan o
la retropropagación.
SCG y QPROP son también métodos de entrenamiento muy eficaces. SCG
no funciona bien para todos los métodos de entrenamiento, pero es muy efectivo
cuando funciona. QPROP funciona de forma similar a RPROP. Puede ser un
método de entrenamiento efectivo. Sin embargo, QPROP requiere que el
usuario elija una tasa de aprendizaje.
El entrenamiento multiproceso es una técnica de entrenamiento que adapta
el entrenamiento de propagación para que funcione más rápido con
computadoras multinúcleo. Dada una computadora con varios núcleos y un
conjunto de entrenamiento lo suficientemente grande, el entrenamiento
multiproceso es considerablemente más rápido que el entrenamiento de un solo
hilo. Encog puede establecer automáticamente un número óptimo de
subprocesos. Si estas condiciones no están presentes, Encog volverá a la
formación de un solo hilo.
5.5 Resumen 81
El entrenamiento de propagación no es el único tipo de entrenamiento

supervisado que se puede usar con Encog. El siguiente capítulo presenta
algunos otros tipos de algoritmos de entrenamiento utilizados para el
entrenamiento supervisado. También explorará cómo utilizar técnicas de
entrenamiento tales como recocido simulado y algoritmos genéticos.
83
Capitulo 6
Más entrenamiento supervisado
• Introducción al ejemplo de Lander Lunar
• Entrenamiento supervisado sin conjuntos de entrenamiento
• Uso de Algoritmos Genéticos
• Uso de recocido simulado
• Algoritmos Genéticos y Recocido Simulado con Conjuntos de
Entrenamiento
Hasta ahora, este libro sólo ha explorado el entrenamiento de una red
neuronal utilizando los métodos supervisados de entrenamiento de
propagación. Este capítulo examinará algunas técnicas de entrenamiento
que no son de propagación. La red neural de este capítulo será entrenada
sin un conjunto de entrenamiento. Todavía se supervisa en que la
regeneración de la salida de la red neural se utiliza constantemente para
ayudar a entrenar la red neuronal. Simplemente no suministraremos los
datos de formación antes de tiempo.
Dos técnicas comunes para este tipo de entrenamiento son el recocido
simulado y los algoritmos genéticos. Encog proporciona soporte integrado
para ambos. El ejemplo de este capítulo puede ser entrenado con
cualquiera de los dos algoritmos, los cuales serán discutidos más
adelante en este capítulo.
El ejemplo de este capítulo presenta el clásico juego "Lunar Lander".
Este juego se ha implementado muchas veces y es casi tan viejo como
las computadoras mismas. Puedes leer más sobre el juego Lunar Lander
en Wikipedia.
84 Más entrenamiento supervisado
Http://en.wikipedia.org/wiki/Lunar_Lander_%28computer_game%29
La idea detrás de la mayoría de las variantes del juego Lunar Lander es muy
similar y el programa de ejemplo funciona de la siguiente manera: La nave
espacial lander lunar comenzará a caer. Cuando cae, se acelera. Hay una
velocidad máxima que el aterrizador puede alcanzar, que se llama la "velocidad
terminal." Los propulsores pueden ser aplicados al lander para retardar su
descenso. Sin embargo, hay una cantidad limitada de combustible. Una vez que
el combustible está agotado, el aterrizador caerá simplemente, y nada se puede
hacer.
Este capítulo enseñará una red neuronal para pilotar el módulo de aterrizaje.
Esta es una simulación de texto muy simple. La red neural tendrá sólo una
opción a su disposición. Puede decidir o no disparar los propulsores o no
disparar los propulsores. No se crearán datos de entrenamiento antes de tiempo
y no se harán suposiciones acerca de cómo la red neuronal debe pilotar la nave.
Si se usan conjuntos de entrenamiento, se proporcionará entrada de antemano
con respecto a lo que la red neuronal debe hacer en ciertas situaciones. Para
este ejemplo, la red neuronal aprenderá todo por sí misma.
A pesar de que la red neuronal aprenderá todo por su cuenta, esto sigue siendo
la formación supervisada. La red neural no será totalmente dejada a sus propios
dispositivos. Recibirá una manera de anotar la red neuronal. Para anotar la red
neuronal, debemos darle algunas metas y luego calcular un valor numérico que
determine qué tan bien la red neural alcanzó sus metas.
Estos objetivos son arbitrarios y simplemente reflejan lo que se escogió para
anotar la red. Los objetivos se resumen aquí:
• Terrenos lo más suaves posible
• Cubra la mayor distancia posible
• Conserve el combustible
El primer objetivo es no estrellarse, sino tratar de golpear la superficie lunar

tan suavemente como sea posible. Por lo tanto, cualquier velocidad en el
momento del impacto es una puntuación negativa muy grande. El segundo
objetivo de la red neuronal es intentar cubrir la mayor distancia posible
mientras cae. Para ello, tiene que permanecer en lo alto el mayor tiempo
posible y puntos adicionales se otorgan para permanecer en el aire por más
tiempo.
6.1 Ejecución del ejemplo de Lander Lunar 85
Finalmente, los puntos de bonificación se dan para tener combustible una

vez que las tierras de la artesanía. El cálculo de puntuación se puede ver en
la ecuación 6.1.
Puntuación = (combustible · 10) + (velocidad · 1000) + combustible (6.1)
En la siguiente sección ejecutaremos el ejemplo del Lander lunar y
observaremos cómo aprende a aterrizar una nave espacial.
6.1 Ejecución del ejemplo de Lander Lunar

Para ejecutar el juego Lunar Lander debe ejecutar la clase LunarLander.
Esta clase se encuentra en la siguiente ubicación.
Encog . Examples . Lunar . LunarLander
ConsoleExamples l a n d e r [genetic/anneal]
Esta clase no requiere argumentos, por defecto se aplicará el

entrenamiento genético. El recocido simulado se puede especificar
usando el argumento de comando de recocido. Una vez que el programa
comienza, la red neuronal comienza inmediatamente a entrenar.
Cambiará a través de 50 épocas, o iteraciones de entrenamiento, antes
de que se haga. Cuando comienza por primera vez, la puntuación es un
número negativo. Estos primeros intentos de la red neuronal no entrenada
están golpeando la Luna a alta velocidad y no están cubriendo mucha
distancia.
Epoch #1 S c o r e : −299.0
Epoch #2 S c o r e : −299.0
Epoch #3 S c o r e : −299.0
Epoch #4 S c o r e : −299.0
Epoch #5 S c o r e : −299.0
Epoch #6 S c o r e : −299.0
Epoch #7 S c o r e : −299.0
Después de la séptima época, la puntuación comienza a aumentar.

Epoch #8 S c o r e : −96.0
Epoch #9 S c o r e : 5 7 6 0 . 0
Epoch #10 S c o r e : 5 7 6 0 . 0
Epoch #11 Score:5760.0

La puntuación se mantendrá en 6,196 por un tiempo, pero mejorará en una época posterior.
Epoch #45 S c o r e : 6 2 7 5 . 0
Epoch #46 S c o r e : 6 2 7 5 . 0
Epoch #47 S c o r e : 7 3 4 7 . 0
Epoch #48 S c o r e : 7 3 4 7 . 0
Epoch #49 S c o r e : 7 4 6 0 . 0
Epoch #50 S c o r e : 7 4 6 0 . 0
Para la 50 ª época, se ha alcanzado una puntuación de 7.460. Las técnicas de

entrenamiento utilizadas en este capítulo hacen uso extensivo de números
aleatorios. Como resultado, ejecutar este ejemplo varias veces puede resultar en
puntuaciones enteramente diferentes.
Más épocas pueden haber producido una red neuronal mejor entrenada; Sin
embargo, el programa lo limita a 50. Este número generalmente produce un piloto
neural bastante cualificado. Una vez que la red está entrenada, ejecute la simulación
con el piloto ganador. La telemetría se muestra a cada segundo.
El piloto neural mantuvo la nave en alto durante 911 segundos. Por lo tanto, no
mostraremos todos los informes de telemetría. Sin embargo, algunas de las acciones
interesantes que este piloto neural aprendido se destacan. La red neuronal aprendió que era
mejor dejar que la nave cayera libremente por un tiempo.
How the winning network landed :
Elapsed : 1 s , Fuel : 200 l , Velocity: −1.6200 m/ s , 9998 m
Elapsed : 3 s , Fuel : 200 l , V e l o c i t y : −4.8600 m/ s , 9990 m
6.1 Ejecución del ejemplo de Lander Lunar 87

Elapsed : 24 s , Fuel : 200 l, Velocity: −38.8800 m/ s , 9514 m

Se puede ver que 27 segundos en y 9.390 metros sobre el suelo, la velocidad
terminal de -40 m / s se ha alcanzado. No hay ciencia real detrás de -40 m / s siendo
la velocidad terminal; Fue elegido simplemente como un número arbitrario. Tener
una velocidad terminal es interesante porque las redes neurales aprenden que una
vez que esto se alcanza, la nave no acelerará. Utilizan la velocidad terminal para
ahorrar combustible y "romper su caída" cuando se acercan a la superficie. La caída
libre a velocidad terminal continúa por algún tiempo.
Finalmente, a 6.102 metros sobre el suelo, los propulsores son disparados por
primera vez.
THRUST
THRUST
88 More Supervised Training

La velocidad se reduce gradualmente, ya que la red neural decide

disparar los propulsores cada seis segundos. Esto mantiene la velocidad
alrededor de -35 m / s.
THRUST
Elapsed : 118 s, Fuel : 197 l, Velocity: −29.4400 m/ s , 5655 m
THRUST
THRUST
A medida que el arte se acerca a la superficie lunar, esta velocidad máxima

permitida comienza a disminuir. El piloto está ralentizando el arte, a medida que
se acerca a la superficie lunar. A unos 4.274 metros sobre la superficie, la red
neural decide que debe empujar cada cinco segundos. Esto disminuye el
descenso a unos -28 m / s.
THRUST
THRUST
THRUST
6.1 Running the Lunar Lander Example 89
Al utilizar ocasionalmente ciclos más cortos, el piloto neural lo reduce aún

más cuando llega a 906 metros por encima de la superficie. La
embarcación se ha reducido a -14 metros por segundo.
THRUST
Elapsed : 322 s, Fuel : 162 l, V e l o c i t y : −9.9200 m/ s , 945 m
THRUST
THRUST
Este ciclo corto continúa hasta que el arte ha disminuido su velocidad

considerablemente. Incluso empuja hasta el punto de aumentar su altitud
hacia los segundos finales del vuelo.
Elapsed : 899 s, Fuel : 67 l, Velocity: 5 . 3 4 0 0 m/ s , 2 m
THRUST
THRUST
Elapsed : 911 s , Fuel : 65 l , V e l o c i t y : 5 . 9 0 0 0 m/ s , 0 m
Finalmente, la nave aterriza, con una velocidad muy suave de 5.9

positivo.Usted se pregunta por qué aterriza el aterrizador con una velocidad de
5.9. Esto se debe a un pequeño fallo en el programa. Este "fallo" se deja porque
ilustra un
punto importante: cuando se permite que las redes neuronales aprendan,

son totalmente independientes y aprovecharán todo lo que puedan
encontrar.
La velocidad positiva final es porque el programa decide si quiere empujar
como la última parte de un ciclo de simulación. El programa ya ha
decidido que la altitud de la embarcación está por debajo de cero, y ha
aterrizado. Pero la red neuronal "se mete en" ese empuje final, aunque el
arte ya está aterrizado y este empuje no sirve de nada. Sin embargo, el
empuje final aumenta la puntuación de la red neuronal.
Recuérdese la ecuación 6.1. Por cada metro negativo de velocidad en el
aterrizaje, la puntuación del programa se reduce en 1.000. El programa
concluyó que lo contrario también es cierto. Por cada metro positivo por
segundo de velocidad, también gana 1.000 puntos. Al aprender acerca de
este pequeño capricho en el programa, el piloto neural puede obtener
puntuaciones aún más altas.
El piloto neuronal aprendió algunas cosas muy interesantes sin ser
alimentado con una estrategia preestablecida. La red aprendió lo que
quería hacer. Concretamente, este piloto decidió lo siguiente:
• Caída libre durante algún tiempo para aprovechar la velocidad del
terminal.
• En un determinado punto, romper la caída libre y ralentizar la nave.
• Lentamente pierda velocidad a medida que se aproxima a la superficie.
• Dar un empuje final, después del aterrizaje, para maximizar la
puntuación.
El piloto neural en este ejemplo fue entrenado usando un algoritmo
genético. Los algoritmos genéticos y el recocido simulado se discutirán
más adelante en este capítulo. En primer lugar, veremos cómo se simuló
el Lander y cómo se calcula su puntaje.
6.2 Examen del Simulador de Lander Lunar

Examinaremos ahora cómo el ejemplo de Lander lunar fue creado por la
simulación física y cómo la red neuronal realmente pilotea la nave espacial.
Por último, veremos cómo la red neuronal aprende a ser un piloto mejor.
6.2 Examen del Simulador de Lander Lunar 91
6.2.1 Simulación del Lander

Primero, necesitamos una clase que simule la "física" del aterrizaje lunar. El
término "física" se utiliza muy libremente. El propósito de este ejemplo es más
sobre cómo una red neural se adapta a un entorno artificial que cualquier tipo de
simulación física realista.
Todo el código de simulación física está contenido en la clase
LanderSimulator. Esta clase se puede encontrar en la siguiente ubicación.
Encog . Examples . Lunar . LanderSimulator

Esta clase comienza definiendo algunas constantes que serán importantes para
la simulación.
public const double Gravity = 1 . 6 2 ; public
const double Thrust = 1 0 ;
public const double T e r m i n a l V e l o c i t y = 4 0 ;
La constante GRAVITY define la aceleración en la Luna que se debe a la

gravedad. Se establece en 1,62 y se mide en metros por segundo. La constante
THRUST especifica como el número de metros por segundo por el cual la
aceleración por gravedad será contrarrestada. La VELOCIDAD TERMINAL es la
velocidad más rápida que la nave espacial puede recorrer hacia arriba o hacia
abajo.
Además de estas constantes, el programa del simulador necesitará varias variables de
instancia para mantener el estado. Estas variables se enumeran a continuación como
sigue:
public int Fuel { g e t ; s e t ; }
public int Seconds { g e t ; s e t ; }
public double A l t i t u d e { g e t ; s e t ; }
public double Velocity { get; set; }
La variable de combustible mantiene la cantidad de combustible restante. La

variable segundos mantiene el número de segundos en alto. La variable Altitud
contiene la altitud actual en metros. La variable velocidad mantiene la velocidad
actual. Los números positivos indican que la embarcación se está moviendo
hacia arriba. Los números negativos indican que la embarcación se está
moviendo hacia abajo.
El simulador establece los valores en valores iniciales razonables en el
constructor siguiente:
public LanderSimulator ( )
{
Fuel = 2 0 0 ;
Seconds = 0 ;
Altitude=10000;
Velocity=0;
}
La embarcación comienza con 200 litros y la altitud se establece a 10.000

metros sobre el suelo.
El método de turno procesa cada "giro". Un giro es un segundo en el simulador.
El parámetro de empuje indica si la nave espacial desea empujar durante este giro.
public void turn ( boolean t h r u s t ) {

Primero, aumente el número de segundos transcurridos en uno.
Disminuya la velocidad por la constante de GRAVEDAD para simular la
caída.
Seconds++;
V e l o c i t y −= Gravity ;
La velocidad actual aumenta la altitud. Por supuesto, si la velocidad es

negativa, la altitud disminuirá.
A l t i t u d e += V e l o c i t y ;
Si se aplica empuje durante este turno, entonces disminuir el combustible

por uno y aumentar la velocidad por la constante de empuje.
i f ( t h r u s t && Fuel > 0)
{
Fuel −−;
V e l o c i t y += Thrust ;
}
La velocidad terminal debe imponerse ya que no puede caer ni ascender más

rápido que la velocidad terminal. La línea siguiente asegura que el módulo de
aterrizaje no esté ascendiendo más rápido que la velocidad terminal.
V e l o c i t y = Math . Max(−T e r m i n a l V e l o c i t y , V e l o c i t
y);
6.2 Examining the Lunar Lander Simulator 93
La línea siguiente asegura que no estamos descendiendo más rápido que

la velocidad terminal.
V e l o c i t y = Math . Min ( T e r m i n a l V e l o c i t y , Velocity);
La siguiente línea asegura que la altitud no caiga por debajo de cero. Es

importante evitar que la simulación de la nave golpee tan fuertemente que
se vaya a la clandestinidad.
i f ( A l t i t u d e < 0)
Altitude=0;
Además del código de simulación, el LanderSimulator también

proporciona dos funciones de utilidad. El primero calcula la puntuación y
sólo debe ser llamado después de que aterrice la nave espacial. Este
método se muestra aquí.
public int S c o r e
{
g e t { return ( int ) ( ( Fuel ∗ 10) + Seconds + ( V e l o c i t y ∗ 1000) ) ; }
}
El método de puntuación implementa la ecuación 6.1. Como puede ver,

utiliza combustible, segundos y velocidad para calcular el puntaje de acuerdo
con la ecuación anterior.
Además, se proporciona un método para determinar si la nave
espacial sigue volando. Si la altitud es mayor que cero, sigue volando.
public bool Flying
{
g e t { return A l t i t u d e > 0 ; }
}
En la siguiente sección, veremos cómo la red neuronal vuela en realidad la

nave espacial y se le da una puntuación.
6.2.2 Cálculo de la puntuación
La clase PilotScore implementa el código necesario para que la red
neuronal pueda volar la nave espacial. Esta clase también calcula la
puntuación final después de que la embarcación haya aterrizado. Esta
clase se muestra en el Listado 6.1.
Listado 6.1: Cálculo de la puntuación de Lander

using System ;
using System . C o l l e c t i o n s . G e n e r
i c ; using System . Linq ;
using System . Text ;
using Encog .ML;
using Encog . Neural . Networks ;
using Encog . Neural . Networks . T r a i n i n g ;
namespace Encog . Examples . Lunar
{
public c l a s s P i l o t S c o r e : I C a l c u l a t e S c o r e
{
public double C a l c u l a t e S c o r e ( IMLRegression network )
{
NeuralPilot pilot
= new N e u r a l P i l o t ( ( BasicNetwork ) network , f a l s e ) ;
return p i l o t . S c o r e P i l o t ( ) ;
}
public bool ShouldMinimize
{
g e t { return f a l s e ; }
}
}
}
Como se puede ver en la siguiente línea, la clase PilotScore implementa el

Interfaz ICalculateScore.
public c l a s s P i l o t S c o r e : I C a l c u l a t e S c o r e
La interfaz ICalculateScore es utilizada por los algoritmos de

recolección simulada y algoritmos genéticos para determinar la eficacia
de una red neuronal en la resolución del problema dado. Una puntuación
baja podría ser mala o buena dependiendo del problema.
La interfaz ICalculateScore requiere dos métodos. Este primer método
se denomina CalculateScore. Este método acepta una red neuronal y
devuelve un doble que representa la puntuación de la red.
public double C a l c u l a t e S c o r e ( IMLRegression network )
{
NeuralPilot pilot
= new N e u r a l P i l o t ( ( BasicNetwork ) network , f a l s e ) ;
return p i l o t . S c o r e P i l o t ( ) ;
}
El segundo método devuelve un valor para indicar si la puntuación debe ser

minimizada.
public b o o l ShouldMinimize
{
g e t { return f a l s e ; }
}
Para este ejemplo nos gustaría maximizar la puntuación. Como resultado

el método Should-Minimize devuelve false.
6.2.3 Flying the Spacecraft
Esta sección muestra cómo la red neuronal vuela en realidad la nave
espacial. La red neural será alimentada con información ambiental como
el combustible restante, la altitud y la velocidad de la corriente. La red
neural emitirá entonces un valor único que indicará si la red neural desea
empujar. La clase Neu-ralPilot realiza este vuelo. Puede ver la clase
NeuralPilot en la siguiente ubicación:
Encog . Examples . Lunar . N e u r a l P i l o t
El constructor de NeuralPilot establece el piloto para volar la nave

espacial. El constructor pasa una red para volar la nave espacial, así
como un booleano que indica si la telemetría debe ser rastreada a la
pantalla.
public N e u r a l P i l o t ( BasicNetwork network , b o o l t r a c k )
{
El lander lunar debe alimentar el nivel del combustible, la altitud y la

velocidad de la corriente a la red neural. Estos valores deben
normalizarse como se describió en el Capítulo 2. Para realizar esta
normalización, el constructor comienza estableciendo varios campos de
normalización.
private r e a d o n l y N o r m a l i z e d F i e l d f u e l S t a t s ;
private r e a d o n l y BasicNetwork network ;
private readonly bool track;
private r e a d o n l y N o r m a l i z e d F i e l d a l t i t u d e S t a t s ;
private r e a d o n l y N o r m a l i z e d F i e l d v e l o c i t y S t a t s ;
In addition to the normalized fields, we will also save the operating

parameters. The track variable is saved to the instance level so that the
program will later know if it should display telemetry.
track=track;
network = network ;
El piloto neural tendrá tres neuronas de entrada y una neurona de

salida. Estas tres neuronas de entrada comunicarán los siguientes tres
campos a la red neuronal.
• Nivel de combustible actual
• Altitud actual
• Velocidad actual
Estos tres campos de entrada producirán un campo de salida que
indica si el piloto neuronal desea disparar los propulsores.
Para normalizar estos tres campos, defínelos como tres objetos
NormalizedField. En primer lugar, configurar el combustible.
f u e l S t a t s = new N o r m a l i z e d F i e l d (
N o r m a l i z a t i o n A c t i o n . Normalize , ” f u e l ” , 200 , 0 , −0.9 , 0 . 9 ) ;
Sabemos que el rango está entre 0 y 200 para el combustible. Vamos a

normalizar esto a la gama de -0,9 a 10,9. Esto es muy similar al rango -1 a 1,
excepto que no toma los valores hasta el extremo. Esto a veces ayudará a la
red neuronal a aprender mejor. Especialmente cuando se conoce el rango
completo.
Se configuran la velocidad y la altitud siguientes.
altitudeStats
= new N o r m a l i z e d F i e l d (
N o r m a l i z a t i o n A c t i o n . Normalize ,
” a l t i t u d e ” , 10000 , 0 , −0.9 , 0 . 9 ) ;
La velocidad y la altitud ambos tienen gamas sabidas apenas como
combustible. Como resultado, la velocidad se establece de forma similar
al combustible y la altitud.
v e l o c i t y S t a t s = new N o r m a l i z e d F i e l d (
N o r m a l i z a t i o n A c t i o n . Normalize , ” v e l o c i
t y ” , LanderSimulator . T e r m i n a l V e l o c i t y , −
LanderSimulator . T e r m i n a l V e l o c i t y ,
−0.9 , 0 . 9 ) ;
Debido a que no tenemos datos de entrenamiento, es muy importante que
conozcamos los rangos. Esto es diferente a los ejemplos del Capítulo 2
que proporcionaron datos de muestra para determinar valores mínimos y
máximos.
Para este ejemplo, el objetivo principal de volar la nave espacial es
recibir una puntuación. El método ScorePilot calcula esta puntuación.
Simulará un vuelo desde el punto en el que la nave espacial cae desde la
órbita hasta el punto en que aterriza. El método ScorePilot calcula esta
puntuación:
public int S c o r e P i l o t ( )
{
Este método comienza creando un objeto Lander Simulator para simular

la física muy simple utilizada por este programa. var sim = new
LanderSimulator ( ) ;
Ahora entramos en el bucle principal del método ScorePilot. Continuará

haciendo bucle mientras la nave espacial siga volando. La nave espacial
sigue volando mientras su altitud sea mayor que cero.
while ( sim . F l y i n g )
{
Comience creando una matriz para contener los datos brutos que se
obtienen directamente desde el simulador.
IMLData i n p u t = new BasicMLData ( 3 ) ;
i n p u t [ 0 ] = f u e l S t a t s . Normalize ( sim . Fuel ) ;
i n p u t [ 1 ] = a l t i t u d e S t a t s . Normalize ( sim . A l t i t u d e ) ;
i n p u t [ 2 ] = v e l o c i t y S t a t s . Normalize ( sim . V e l o c i t y ) ;
El método Normalize del objeto NormalizedField se utiliza para
normalizar realmente los archivos de combustible, altitud y velocidad.
IMLData output = network . Compute ( i n p u t ) ;
Esta única neurona de salida determinará si los propulsores deben

dispararse.
double v a l u e = output [ 0 ] ; b
oolthrust;
Si el valor es mayor que cero, los propulsores se dispararán. Si la nave

espacial está rastreando, también muestra que los propulsores fueron
disparados.
if (value > 0)
{
thrust = true ;
if ( track)
Console . WriteLine (@”THRUST” ) ;
}
else
thrust=false;
Procese el siguiente "giro" en el simulador y empuje si es necesario.

También muestra la telemetría si la nave espacial está rastreando.
sim . Turn ( t h r u s t )
;if(track)
Console . WriteLine ( sim . Telemetry ( ) ) ;
La nave espacial ha aterrizado ahora. Devuelva la puntuación en función

de los criterios previamente discutidos.
return ( sim . S c o r e ) ;
Ahora veremos cómo entrenar al piloto neuronal.

6.3 Training the Neural Pilot
Este ejemplo puede entrenar al piloto neural utilizando un algoritmo genético o
un recocido simulado. Encog trata tanto los algoritmos genéticos como los
simulados de manera muy similar. Por un lado, puede simplemente proporcionar
un conjunto de entrenamiento y utilizar recocido simulado o puede utilizar un
algoritmo genético como en una red de propagación. Veremos un ejemplo de
esto más adelante en el capítulo
6.3 Training the Neural Pilot 99
cuando aplicamos estas dos técnicas al problema XOR. Esto demostrará
cómo pueden ser similares al entrenamiento de la propagación.
Por otro lado, los algoritmos genéticos y el recocido simulado pueden hacer
algo que el entrenamiento de propagación no puede. Pueden permitirte entrenar
sin un conjunto de entrenamiento. Todavía es un entrenamiento supervisado ya
que se usa una clase de puntuación, como se desarrolló anteriormente en este
capítulo. Sin embargo, todavía no necesita entrenar la entrada de datos. Por el
contrario, la red neural necesita información sobre lo bueno de un trabajo que
está haciendo. Si puede proporcionar esta función de puntuación, recocido
simulado o un algoritmo genético puede entrenar la red neuronal. Ambos
métodos serán discutidos en las próximas secciones, comenzando con un
algoritmo genético.
6.3.1 ¿Qué es un Algoritmo Genético?
Los algoritmos genéticos intentan simular la evolución darwiniana para crear una
mejor red neuronal. La red neural se reduce a una matriz de variables dobles. Esta
matriz se convierte en la secuencia genética.
El algoritmo genético comienza por crear una población de redes neuronales
aleatorias. Todas las redes neuronales de esta población tienen la misma estructura, lo
que significa que tienen el mismo número de neuronas y capas. Sin embargo, todos
tienen diferentes pesos al azar.
Estas redes neuronales se clasifican de acuerdo a sus "puntuaciones". Sus
puntuaciones son proporcionadas por el método de puntuación como se discutió en la
última sección. En el caso del piloto neural, esta puntuación indica lo suave que el barco
aterrizó.
Las redes neuronales superiores se seleccionan para "reproducirse". Las redes
neurales inferiores "mueren". Cuando dos redes se reproducen, la naturaleza se simula
uniendo su ADN. En este caso, los empalmes se toman de la matriz doble de cada red y
empalmados juntos para crear una nueva red neural de primavera. Las redes neurales
primaverales ocupan los lugares desocupados por las redes neuronales moribundas.
Algunas de las fuentes de la primavera serán "mutadas". Es decir, parte del material
genético será aleatorio y no de los padres. Esto introduce la variedad necesaria en el
grupo genético y simula el proceso natural de mutación.
La población se clasifica y el proceso comienza de nuevo. Cada iteración
proporciona un ciclo. Como puede ver, no hay necesidad de un conjunto de
entrenamiento. Todo lo que se necesita es un objeto para anotar cada red neuronal. Por
su puesto, puede
utilizar conjuntos de entrenamiento simplemente proporcionando un

objeto de puntuación que utiliza un conjunto de entrenamiento para anotar
cada red.
6.3.2 Uso de un algoritmo genético
Using the genetic algorithm is very easy and uses the
NeuralGeneticAlgo-rithm class to do this. The NeuralGeneticAlgorithm
class implements the IMLTrain interface. Therefore, once constructed, it is
used in the same way as any other Encog training class.
The following code creates a new NeuralGeneticAlgorithm to train
the neural pilot.
t r a i n = new N e u r a l G e n e t i c A l g o r i t h m
( network , new NguyenWidrowRandomizer ( ) ,
new P i l o t S c o r e ( ) , 5 0 0 , 0 . 1 , 0 . 2 5 ) ;
La red de base se proporciona para comunicar la estructura de la red

neuronal al algoritmo genético. El algoritmo genético no tendrá en cuenta los
pesos establecidos actualmente por la red neuronal.
El aleatorizador se proporciona para que la red neural pueda crear una
nueva población aleatoria. El NguyenWidrowRandomizer intenta producir pesos
iniciales que son menos extremos y más entrenables que el RangeRandomizer
regular que se suele usar. Sin embargo, se podría utilizar cualquiera de los
aleatorizadores.
El valor de 500 especifica el tamaño de la población. Las poblaciones más
grandes se entrenarán mejor, pero tomarán más memoria y tiempo de
procesamiento. El 0,1 se utiliza para mutar el 10% del resorte. El valor 0.25 se
utiliza para elegir la población de apareamiento del 25% superior de la
población.
int epoch = 1 ;
Ahora que el entrenador está configurado, la red neuronal es entrenada

como cualquier objeto de entrenamiento Encog. Aquí sólo itera 50 veces.
Esto suele ser suficiente para producir un experto neural piloto.
int epoch = 1 ;
for ( int i = 0 ; i < 5 0 ; i ++)
{
6.3 Entrenamiento del Piloto Neural 101
train.Iteration();
Console . WriteLine (@” Epoch #” + epoch +
@” S c o r e : ” + t r a i n . E r r o r ) ;
epoch++;
}
Esta red neuronal también podría haber sido entrenada usando la clase
EncogUtility, como en el capítulo anterior. Simplemente para el
entrenamiento simple, el EncogUtility es generalmente el método preferido.
Sin embargo, si su programa necesita hacer algo después de cada iteración,
el enfoque más manual mostrado arriba puede ser preferible.
6.3.3 What is Simulated Annealing
El recocido simulado también se puede utilizar para entrenar al piloto neural.
El recocido simulado es similar a un algoritmo genético en el sentido de que
necesita un objeto de puntuación. Sin embargo, funciona muy dife- rentemente
internamente. El recocido simulado simula el proceso metalúrgico de recocido.
El recocido es el proceso mediante el cual se enfría lentamente un metal
fundido muy caliente. Este lento proceso de enfriamiento hace que el metal
produzca una estructura molecular fuerte y consistente. El recocido es un
proceso que produce metales menos propensos a fracturarse o romperse.
Un proceso similar se puede realizar en redes neuronales. Para implementar
el recocido simulado, la red neural se convierte en una matriz de valores dobles.
Este es exactamente el mismo proceso que se hizo para el algoritmo genético.
La aleatoriedad se utiliza para simular el calor y el enfriamiento. Mientras
que la red neural es todavía realmente "caliente", los pesos existentes de la red
neural aumentan en velocidad. A medida que la red se enfría, esta aleatoriedad
se ralentiza. Sólo se mantienen los cambios que producen un efecto positivo en
la puntuación de la red.
6.3.4 Uso del recocido simulado
Para utilizar el recocido simulado para entrenar el piloto neural, pase el
argumento recocido en la línea de comandos cuando se ejecuta este ejemplo.
Es muy sencillo para el ejemplo usar recocido en lugar de un algoritmo genético.
Ambos utilizan la
misma función de puntuación y son intercambiables. Las siguientes líneas

de código hacen uso del algoritmo de recocido simulado para este
ejemplo.
i f ( app . Args . Length > 0 && S t r i n g . Compare ( app . Args [ 0 ] ,
” a n n e a l ” , true ) == 0)
{
t r a i n = new N e u r a l S i m u l a t e d A n n e a l i n g (
network , new P i l o t S c o r e ( ) , 10 , 2 , 100) ;
}
El objeto de recocido simulado NeuralSimulatedAnnealing se utiliza

para entrenar el piloto neural. La red neuronal se pasa junto con el mismo
objeto de puntuación que se utilizó para entrenar utilizando un algoritmo
genético.
Los valores de 10 y 2 son las temperaturas de arranque y parada,
respectivamente. No son temperaturas verdaderas, en términos de
Fahrenheit o Celsius. Un número más alto producirá más aleatoriedad; Un
número menor produce menos aleatoriedad. El siguiente código muestra
cómo se aplica esta temperatura o factor.
public void Randomize ( )
{
double [ ] a r r a y = NetworkCODEC
. NetworkToArray ( network ) ;
for ( int i = 0 ; i < a r r a y . Length ; i ++)
{
double add = Cut − ThreadSafeRandom . NextDouble ( ) ;
add /= a n n e a l . StartTemperature ;
add ∗= a n n e a l . Temperature ;
a r r a y [ i ] = a r r a y [ i ] + add ;
}
NetworkCODEC . ArrayToNetwork ( array , network ) ;
}
El número 100 especifica cuántos ciclos, por iteración, debe tomar

para pasar de la temperatura más alta a la temperatura más baja.
Generalmente, cuanto más ciclos, más precisos serán los resultados. Sin
embargo, cuanto mayor es el número, más tiempo se tarda en entrenar.
No hay reglas sencillas para establecer estos valores. Generalmente,
es mejor experimentar con diferentes valores para ver qué entrena su red
neuronal particular el mejor.
6.4 Uso de la clase de puntuación de conjunto de
entrenamiento 103
6.4Uso de la clase de puntuación de
conjunto de entrenamiento
Los conjuntos de entrenamiento también pueden usarse con algoritmos
genéticos y recocido simulado. Usado de esta manera, el recocido simulado
y los algoritmos genéticos son un poco diferentes al entrenamiento de
propagación basado en el uso. No hay función de puntuación cuando se
utiliza de esta manera. Simplemente utiliza el objeto TrainingSetScore, que
toma el conjunto de entrenamiento y lo utiliza para anotar la red neuronal.
Generalmente, la propagación elástica superará a los algoritmos
genéticos o el recocido simulado cuando se utilice de esta manera.
Algoritmos genéticos o recocido simulado realmente sobresalen cuando se
utiliza un método de puntuación en lugar de un conjunto de formación.
Además, el recocido simulado puede, a veces, empujar la retropropagación
fuera de un mínimo local.
La aplicación Hello World, que se encuentra en la siguiente ubicación,
podría modificarse fácilmente para utilizar un algoritmo genético o un
recocido simulado:
Para cambiar el ejemplo anterior para usar un algoritmo genético, se

deben añadir unas pocas líneas. Las líneas siguientes crean un algoritmo
genético basado en conjuntos de entrenamiento. En primer lugar, cree un
objeto TrainingSetScore.
ICalculateScore s c o r e = new T r a i n i n g S e t S c o r e ( t r a i n i n g S e t ) ;
Este objeto puede usarse entonces con un algoritmo genético o un recocido

simulado. El siguiente código muestra que se utiliza con un algoritmo
genético:
IMLTrain t r a i n = new N e u r a l G e n e t i c A l g o r i t h m (
network , new NguyenWidrowRandomizer ( ) , s c o r e , 5000 , 0 . 1 , 0.25);
Para utilizar el objeto TrainingSetScore con recocido simulado,
simplemente pase al constructor de recocido simulado, como se hizo
anteriormente.
6.5 Resumen
Este capítulo explicó cómo usar algoritmos genéticos y recocido
simulado para entrenar una red neuronal. Ambas técnicas pueden utilizar
un objeto de puntuación,
En lugar de conjuntos de entrenamiento. Sin embargo, ambos
algoritmos también pueden usar un conjunto de entrenamiento si se
desea.
Los algoritmos genéticos intentan simular la evolución darwiniana. Las

redes neurales se clasifican según la aptitud física. Las mejores redes
neuronales pueden reproducirse; Las redes inferiores mueren. La próxima
generación toma material genético de las redes neuronales más aptas.
El recocido simulado simula el proceso metalúrgico de recocido. Los

pesos de red se toman de una temperatura alta a una baja. A medida que
baja la temperatura, se eligen las mejores redes. Esto produce una red
neuronal que es adecuada para obtener mejores puntuaciones.
Hasta ahora, este libro sólo ha discutido cómo usar una red neuronal
feedforward. Esta red fue entrenada usando el entrenamiento de la
propagación, el anilingüe simulado o un algoritmo genético. Las redes
neuronales de feedforward son los tipos de redes neuronales más
comunes. Simplemente porque son los más comunes, esto no significa
que siempre son la mejor solución. En el próximo capítulo, veremos
algunas otras arquitecturas de redes neuronales.
6.5 Summary 105
107
Capitulo 7
Otros tipos de redes neuronales

• Comprender la Red Neural de Elman
• Entendiendo la Red Neural de Jordania
• La red neuronal ART1
• Evolucionando con NEAT
Hasta ahora, hemos estudiado las redes neuronales de feedforward en
este libro. Todas las conexiones en una red neuronal no necesitan ser
hacia adelante. También es posible crear conexiones recurrentes. Este
capítulo introducirá redes neuronales que se les permite formar
conexiones recurrentes.
Aunque no es una red neuronal recurrente, también veremos la red

neuronal ART1. Este tipo de red es interesante porque no tiene una fase
de aprendizaje distinta como la mayoría de las redes neuronales. La red
neuronal ART1 aprende a medida que reconoce patrones. De esta
manera siempre está aprendiendo, al igual que el cerebro humano.
Este capítulo comenzará mirando las redes neuronales de Elman y

Jordan. Estas redes se denominan frecuentemente redes neuronales
recurrentes simples (SRN).
108 Otros tipos de redes neuronales
7.1 La Red Neural de Elman

Las redes neuronales de Elman y Jordan son redes neuronales
recurrentes que tienen capas adicionales y funcionan de forma muy
similar a las redes feedforward en capítulos anteriores. Utilizan
técnicas de entrenamiento similares a las redes neuronales de
feedforward también.
La Figura 7.1 muestra una red neuronal de Elman.
Figura 7.1: La red neuronal de Elman
Como se muestra, la red neuronal de Elman utiliza neuronas de contexto. Se

clasifican como C1 y C2. Las neuronas de contexto permiten retroalimentación.
La retroalimentación es cuando la salida de una iteración anterior se utiliza como
entrada para sucesivas iteraciones. Observe que las neuronas del contexto se
alimentan de la salida de la neurona ocultada. No hay pesos en estas
conexiones. Son simplemente una salida con-duit de las neuronas ocultas a las
neuronas del contexto. Las neuronas de contexto recuerdan esta salida y luego
la devuelven a las neuronas ocultas en la siguiente iteración. Por lo tanto, la
capa de contexto siempre está alimentando la capa oculta su propia salida de la
iteración anterior.
Se pondera la conexión desde la capa de contexto a la capa oculta. Esta
sinapsis aprenderá a medida que la red se entrena. Las capas de contexto
permiten que una red neuronal reconozca el contexto.
Para ver qué tan importante es el contexto de una red neuronal,
considere cómo se formaron las redes anteriores. El orden de los elementos
del conjunto de entrenamiento realmente no importaba. El conjunto de
entrenamiento podría ser confundido en cualquier forma necesaria y la red
aún entrenar de la misma manera. Con una red neuronal de Elman o Jordan,
7.1 The Elman Neural Network 109
el orden se vuelve muy importante. El elemento de conjunto de

entrenamiento previamente soportado sigue siendo un ff ecting la red neuronal.
Esto se vuelve muy importante para las redes neuronales predictivas y hace que
las redes neuronales de Elman sean muy útiles para las redes neuronales
temporales.
El capítulo 8 profundizará más en las redes neurales temporales. Las redes
temporales intentan ver las tendencias de los datos y predecir los valores de los
datos futuros. Las redes de avance también pueden usarse para la predicción,
pero las neuronas de entrada están estructuradas de manera diferente. Este
capítulo se enfocará en cómo las neuronas están estructuradas para redes
neurales recurrentes simples.
El Dr. Jef rey Elman creó la red neural Elman. El doctor Elman usó un patrón
XOR para probar su red neuronal. Sin embargo, no utilizó un patrón XOR típico
como hemos visto en capítulos anteriores. Utilizó un patrón XOR colapsado a
una sola neurona de entrada. Considere la siguiente tabla de verdad XOR.
1 . 0 XOR 0 . 0 = 1 . 0
0 . 0 XOR 0 . 0 = 0 . 0
0 . 0 XOR 1 . 0 = 1 . 0
1 . 0 XOR 1 . 0 = 0 . 0
Ahora, colapsar esto a una cadena de números. Para ello, simplemente lea los
números de izquierda a derecha, línea por línea. Esto produce lo siguiente:
1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0
Vamos a crear una red neuronal que acepte un número de la lista anterior y
debe predecir el próximo número. Estos mismos datos se utilizarán con una red
neural de Jordan más adelante en este capítulo. La entrada de la muestra a esta
red neuronal sería la siguiente:
Input Neurons : 1 . 0 ==> Output Neurons : 0.0
Sería imposible entrenar una red neural típica feedforward para esto. La información
del entrenamiento sería contradictoria. A veces una entrada de 0 resulta en un 1;
Otras veces resulta en 0. Una entrada de 1 tiene problemas similares.
La red neuronal necesita contexto; Debe mirar lo que viene antes. Vamos
a revisar un ejemplo que utiliza un Elman y una red feedforward para
intentar predecir la salida. Un ejemplo de la red neuronal de Elman se
puede encontrar en la siguiente ubicación.
Encog . Examples . ElmanNetwork . ElmanExample
ConsoleExamples xor−elman
Cuando se ejecuta, este programa produce la salida siguiente:
T r a i n i n g Elman , Epoch #0 E r r o r : 0 . 3 2 5 9 9 4 1 1 6 1 1 9 7 2 6 7 3
T r a i n i n g Elman , Epoch #1 E r r o r : 0 . 3 2 5 9 9 1 7 3 8 5 9 9 7 0 9 7
...
T r a i n i n g Feedforward , Epoch #0 E r r o r : 0 . 3 2 5 9 9 4 1 1 6 1 1 9 7 2 6 7 3
T r a i n i n g Feedforward , Epoch #1 E r r o r : 0 . 3 2 5 9 9 1 7 3 8 5 9 9 7 0 9 7
...
Best e r r o r r a t e with Elman Network : 0 . 0 7 1 4 1 4 5 2 8 3 3 1 2 3 2 2
Best e r r o r r a t e with Feedforward Network : 0 . 2 5 0 0 0 0 1 2 1 9 0 0 1 4 8 7
7.1 The Elman Neural Network 111
Elman s h o u l d be a b l e to g e t i n t o the 10% range ,

f e e d f o r w a r d s h o u l d not go below 25%.
The r e c u r r e n t Elment net can l e a r n b e t t e r i n this case .
I f your r e s u l t s a r e not as good , try r e r u n n i n g , or perhaps
training longer.
Como puede ver, el programa intenta entrenar una red neuronal de

feedforward y una de Elman con los datos XOR temporales. La red neural
de feedforward no aprende bien los datos, pero el Elman aprende mejor.
En este caso, la red neuronal feedforward llega al 49,9% y la red neuronal
Elman llega al 7%. La capa de contexto ayuda considerablemente.
Este programa utiliza pesos aleatorios para inicializar la red neuronal.
Si la primera ejecución no produce buenos resultados, intente volver a
ejecutar. Un mejor conjunto de pesos iniciales puede ayudar.
7.1.1 Creación de una red neuronal de Elman
Al llamar al método CreateElmanNetwork se crea la red neural Elman en
este ejemplo. Este método se muestra aquí.
var p a t t e r n = new ElmanPattern
{
A c t i v a t i o n F u n c t i o n = new A c t i v a t i o n S i g m o i d ( ) ,
InputNeurons = 1
};
p a t t e r n . AddHiddenLayer ( 6 ) ;
p a t t e r n . OutputNeurons = 1 ;
return p a t t e r n . Generate ( ) ;
Como se puede ver en el código anterior, el ElmanPattern se usa para

crear la red neuronal de Elman. Esto proporciona una manera rápida de
construir una red neuronal de Elman.
7.1.2 Training an Elman Neural Network

Las redes neuronales de Elman tienden a ser particularmente susceptibles a
los mínimos locales. Un mínimo local es un punto donde el entrenamiento se
estanca. Visualice la matriz de pesos y umbrales como un paisaje con
montañas y valles. Para llegar al
error más bajo, usted quiere encontrar el valle más bajo. A veces el
entrenamiento encuentra un valle bajo y busca cerca de este valle por un punto
inferior. Puede fallar en encontrar un valle aún más bajo a varios kilómetros de
distancia.
El entrenamiento de este ejemplo utiliza varias estrategias de entrenamiento
para ayudar a evitar esta situación. El código de entrenamiento para este
ejemplo se muestra a continuación. La misma rutina de entrenamiento se usa
tanto para las redes feedforward como para Elman y usa backpropagation con
una tasa de aprendizaje muy pequeña. Sin embargo, la adición de algunas
estrategias de entrenamiento ayuda en gran medida. El método TrainNetwork
se utiliza para entrenar la red neuronal. Este método se muestra aquí.
private double TrainNetwork ( S t r i n g what , BasicNetwork network ,
IMLDataSet t r a i n i n g S e t )
Una de las estrategias empleadas por este programa es la HybridStrategy. Esto

permite utilizar una técnica alternativa de entrenamiento si la principal técnica de
entrenamiento se estanca. Utilizaremos el recocido simulado como la estrategia
de entrenamiento alternativo.
I C a l c u l a t e S c o r e s c o r e = new T r a i n i n g S e t S c o r e ( t r a i n i n g S e t ) ;
IMLTrain t r a i n A l t = new N e u r a l S i m u l a t e d A n n e a l i n g (
network , s c o r e , 10 , 2 , 100) ;
As you can see, we use a training set-based scoring object. For more in-
formation about simulated annealing, refer to Chapter 6, “More Supervised
Training.” The primary training technique is back propagation.
IMLTrain trainMain =
new Backpropagation ( network , t r a i n i n g S e t , 0 . 0 0 0 0 1 , 0 . 0 ) ;
Utilizaremos un StopTrainingStrategy para decirnos cuándo dejar de entrenar.

StopTrainingStrategy detendrá el entrenamiento cuando la tasa de error se
estanque. Por defecto, el estancamiento se define como menos de un 0,00001%
de mejora sobre 100 iteraciones.
var s t o p = new S t o p T r a i n i n g S t r a t e g y ( ) ;
These strategies are added to the main training technique.

trainMain . AddStrategy (new Greedy ( ) ) ;
trainMain . AddStrategy (new H y b r i d S t r a t e g y ( t r a i n A l t ) ) ;
trainMain . AddStrategy ( s t o p ) ;
7.2 La Red Neural de Jordania 113
También hacemos uso de una estrategia codiciosa. Esta estrategia sólo

permitirá iteraciones para mejorar la tasa de error de la red neuronal.
int epoch = 0 ;
while ( ! s t o p . ShouldStop ( ) )
{
trainMain . I t e r a t i o n ( ) ;
app . WriteLine ( ” T r a i n i n g ” + what + ” , Epoch #”
+ epoch + ” E r r o r : ” + trainMain . E r r o r ) ;
epoch++;
}
return trainMain . E r r o r ;
El bucle continúa hasta que la estrategia de parada indica que es el

momento de detenerse.
7.2 La Red Neural de Jordania
Encog también contiene un patrón para una red neural de Jordania. La
red neural de Jordania es muy similar a la red neural de Elman. La Figura
7.2 muestra una red neural de Jordan.
Figura 7.2: La red neuronal de Jordan
Como se puede ver, una neurona de contexto se utiliza y se etiqueta

C1, similar a la red de Elman. Sin embargo, la salida de la capa de salida
se devuelve a la capa de contexto, en lugar de la capa oculta. Este
pequeño cambio en la arquitectura puede hacer que la red neural de
Jordania sea mejor para ciertas tareas de predicción temporal.
114 Otros tipos de redes
neuronales
La red neural de Jordania tiene el mismo número de neuronas de
contexto que las neuronas de salida. Esto se debe a que las neuronas de
contexto son alimentadas desde las neuronas de salida. El operador XOR
sólo tiene neurona de salida. Esto le deja con una sola neurona del contexto
al usar la red de los nervios de Jordania para XOR. Las redes de Jordania
funcionan mejor con un número mayor de neuronas de salida.
Para construir una red neural de Jordania, el JordanPattern debe ser
utilizado. El código siguiente lo demuestra.
var p a t t e r n = new JordanPattern
{
A c t i v a t i o n F u n c t i o n = new A c t i v a t i o n S i g m o i d ( )
};
p a t t e r n . InputNeurons = 1 ; p
a t t e r n . AddHiddenLayer ( 2 ) ;
p a t t e r n . OutputNeurons = 1 ;
return p a t t e r n . Generate ( ) ;
El código anterior crearía una red neuronal de Jordan similar a la Figura

7.2.
Encog incluye un ejemplo de red XOR que utiliza la red neural de
Jordania. Este ejemplo se incluye principalmente para completar la
comparación de Elman y Jordan en el operador XOR. Como se mencionó
anteriormente, Jordan tiende a hacer mejor cuando hay un mayor número de
neuronas de salida. El ejemplo de Encor XOR para Jordania no será capaz
de entrenar a una velocidad er-ror muy baja y no funciona notablemente
mejor que una red neuronal feedforward. El ejemplo de Jordan se puede
encontrar en la siguiente ubicación.
Encog . Examples . JordanNetwork
ConsoleExamples xor−j o r d a n
Cuando se ejecuta, el ejemplo anterior comparará un feedforward con un
Jordan, de manera similar al ejemplo anterior.
7.3 La red neuronal ART1
La red neuronal ART1 es un tipo de red neuronal de Teoría de

Resonancia Adaptativa (ART). ART1, desarrollado por Stephen Grossberg
y Gail Carpenter, sólo admite entrada bipolar. La red neuronal ART1 se
capacita según se utiliza y se utiliza para la clasificación. Nuevos patrones
se presentan a la red ART1 y se clasifican en clases nuevas o existentes.
Una vez que se ha utilizado el número máximo de clases, la red informará
que está fuera de clases.
Una red ART1 aparece como una simple red neuronal de dos capas. Sin
embargo, a diferencia de una red neuronal feedforward, hay pesos en
ambas direcciones entre las capas de entrada y salida. Las neuronas de
entrada se utilizan para presentar patrones a la red ART1. ART1 utiliza
números bipolares, por lo que cada entrada neu-ron está en o o ff. Un
valor de uno representa on, y un valor de uno negativo representa o ff.
Las neuronas de salida definen los grupos que la red neuronal ART1
reconocerá. Cada neurona de salida representa un grupo.
7.3 La Red Neural ART1 115
7.3.1 Uso de la red neuronal ART1
Ahora vamos a ver cómo hacer uso de una red ART1. El ejemplo presentado
aquí creará una red a la que se le dará una serie de patrones para aprender
a reconocer. Este ejemplo se puede encontrar en la siguiente ubicación.
Encog . Examples . ARTExample . ClassifyART1
ConsoleExamples art1−c l a s s i f y
Este ejemplo construye una red ART1. Esta red se presentará nuevos
patrones para reconocer y aprender. Si un nuevo patrón es similar a un
patrón anterior, entonces el nuevo patrón se identifica como perteneciente
al mismo grupo que el patrón original. Si el patrón no es similar a un
patrón anterior, entonces se crea un nuevo grupo. Si ya existe un grupo
por neurona de salida, entonces la red neural informa que no puede
aprender más patrones.
La salida de este ejemplo se puede ver aquí.
O −0
OO−1
O−1
OO−2
116 Other Neural Network Types
O−1
OO−2
O−1
OO O − 3
OO −3
OO O − 4
OO −3
OOO − 5
OO − 5
O −5
OO −6
OOO −7
OOOO − 8
OOOOO − 9
O −5
O −3
O −2
O −0
O−1
O O − 4
OO O − 9
OO − 7
OOO − 8
OO − 6
OOOO − new Input and a l l C l a s s e s exhausted
OOOOO − new Input and a l l C l a s s e s exhausted

La salida anterior muestra que la red neural se presenta con patrones. El
número a la derecha indica en qué grupo la red ART1 colocó el patrón. Algunos
patrones se agrupan con patrones previos mientras que otros patrones forman
nuevos grupos. Una vez que todas las neuronas de salida se han asignado a un
grupo, la red neural no puede aprender más patrones. Una vez que esto sucede,
la red informa que todas las clases se han agotado.
Primero, se debe crear una red neuronal ART1. Esto se puede hacer con el
siguiente código.
var p a t t e r n = new ART1Pattern ( ) ;
p a t t e r n . InputNeurons = INPUT NEURONS;
p a t t e r n . OutputNeurons = OUTPUT NEURONS;
var network = (ART1) p a t t e r n . Generate ( ) ;
7.3 La Red Neural ART1 117
Esto crea una nueva red ART1 con el número especificado de
neuronas de entrada y neuronas de salida. Aquí creamos una red
neuronal con 5 neuronas de entrada y 10 neuronas de salida. Esta red
neuronal será capaz de agrupar la entrada en 10 clusters.
Debido a que los patrones de entrada se almacenan como matrices de
cadenas, deben ser convertidos a una matriz de bool que se puede
presentar a la red neuronal. Debido a que la red ART1 es bipolar, sólo
acepta valores booleanos. El código siguiente convierte cada una de las
cadenas de patrón en una matriz de valores booleanos.
public void SetupInput ( )
{
i n p u t = new b o o l [PATTERN. Length ] [ ] ;
for ( int n = 0 ; n < PATTERN. Length ; n++)
{
i n p u t [ n ] = new b o o l [INPUT NEURONS ] ;
for ( int i= 0 ; i < INPUT NEURONS; i ++)
{
i n p u t [ n ] [ i ] = (PATTERN[ n ] [ i ] == ’O ’ ) ;
}
}
}
Los patrones se almacenan en la matriz PATTERN. Los patrones

convertidos se almacenarán en la matriz de entrada bool.
Ahora que una matriz bool representa los patrones de entrada,
podemos presentar cada patrón a la red neuronal que se agrupará. Esto
se hace con el código siguiente, comenzando por un bucle a través de
cada uno de los patrones:
for ( int i = 0 ; i < PATTERN. Length ; i ++)
{
En primer lugar, creamos un objeto BiPolar Neural Data que mantendrá el

patrón de entrada. Se crea un segundo objeto para contener la salida de la
red neuronal.
var d a t a I n = new BiPolarMLData ( i n p u t [ i ] ) ;

var dataOut = new BiPolarMLData (OUTPUT NEURONS) ;
Using the input, we compute the output.
network . Compute ( dataIn , dataOut ) ;
Determine si hay una neurona de salida ganadora. Si existe, este es el

clúster al que pertenece la entrada.
i f ( network . HasWinner )
{
app . WriteLine (PATTERN[ i ] + ” − ” + network . Winner ) ;
}
else
{
Si no hay neurona ganadora, se informa al usuario de que se han

utilizado todas las clases.
app . WriteLine (PATTERN[ i ] + ”
− new Input and a l l C l a s s e s exhausted ” ) ;
El ART1 es una red que se puede utilizar para agrupar datos sobre la
marcha. No hay una fase de aprendizaje distinta; Agrupará los datos a
medida que se reciban.
7.4 La Red Neural NEAT
NeuroEvolution de Topologías Aumentadoras (NEAT) es un Algoritmo
Genético para la evolución de la estructura y pesos de una red neuronal.
NEAT fue desarrollado por Ken Stanley en la Universidad de Texas en
Austin. NEAT libera al programador de redes neuronales de la tediosa
tarea de determinar la estructura óptima de la capa oculta de una red
neuronal.
Una red neural NEAT tiene una capa de entrada y salida, al igual que las
redes neuronales feedforward más comunes. Una red NEAT comienza con
sólo una capa de entrada y una capa de salida. El resto se desarrolla a
medida que progresa el entrenamiento. Las conexiones dentro de una red
neural NEAT pueden ser feedforward, recurrentes o auto-conectadas. Todos
estos tipos de conexión serán probados por NEAT, ya que intenta desarrollar
una red neuronal capaz de la tarea dada.
7.4 La Red Neural NEAT 119
Figura 7.3: Una red NEAT antes de evolucionar
Como se puede ver, la red anterior sólo tiene una entrada y capas
ocultas. Esto no es suficiente para aprender XOR. Estas redes
evolucionan agregando neuronas y conexiones. La figura 7.4 muestra una
red neural que ha evolucionado para procesar el operador XOR.
Figura 7.4: Una red NEAT después de evolucionar
La red anterior evolucionó de la red anterior. Se añadió una neurona hid-

den adicional entre la primera neurona de entrada y la neurona de salida.
Además, se realizó una conexión recurrente desde la neurona de salida de
nuevo a la primera neurona oculta. Estas pequeñas adiciones permiten a la
red neuronal aprender el operador XOR. Las conexiones y las neuronas no
son las únicas cosas que están evolucionando. Los pesos entre estas
neuronas se desarrollaron también.
Como se muestra en la Figura 7.4, una red NEAT no tiene capas
claramente definidas como las redes tradicionales de alimentación
anticipada. Hay una neurona oculta, pero no realmente una capa oculta. Si
se tratara de una capa oculta tradicional, ambas neuronas de entrada
estarían conectadas a la neurona oculta.
NEAT es un tipo de red neuronal complejo y método de entrenamiento.
Adicionalmente, hay una nueva versión de NEAT, llamada HyperNEAT.
120 Other Neural Network Types
La cobertura completa de NEAT está fuera del alcance de este libro.

Probablemente lanzaré un futuro libro centrado en la aplicación Encog de
NEAT y HyperNEAT. Esta sección se centrará en cómo utilizar NEAT como
un reemplazo potencial para una red neuronal feedforward,
proporcionándole toda la información crítica para usar NEAT con Encog.
7.4.1 Creación de una población
Esta sección mostrará cómo utilizar una red NEAT para aprender el operador
XOR. Hay muy poca diferencia entre el código en este ejemplo que se utiliza
para una red neuronal feedforward para aprender el operador XOR. Uno de
los objetivos principales de Encog es hacer que los métodos de aprendizaje
automático sean lo más intercambiables posible.
Puede ver este ejemplo en la siguiente ubicación.
Encog . Examples .XOR.XORNEAT
ConsoleExamples xor−neat
Este ejemplo comienza creando un conjunto de entrenamiento XOR para
proporcionar las entradas XOR y las salidas esperadas a la red neuronal.
Para revisar las entradas y salidas esperadas para el operador XOR,
consulte el Capítulo 3.
IMLDataSet t r a i n i n g S e t = new BasicMLDataSet ( XORInput , XORIdeal ) ;
A continuación se crea una población NEAT. Anteriormente, crearíamos

una única red neural para ser entrenados. NEAT requiere la creación de
toda una población de redes. Esta población pasará por generaciones
generando mejores redes neuronales. Sólo los miembros aptos de la
población podrán reproducir nuevas redes neuronales.
var pop = new NEATPopulation ( 2 , 1 , 1000) ;
La población anterior se crea con dos neuronas de entrada, una neurona

de salida y un tamaño de población de 1.000. Cuanto mayor sea la
población, mejor se entrenarán las redes. Sin embargo, las poblaciones
más grandes correrán más lentamente y consumirán más memoria.
7.4 The NEAT Neural Network 121
Anteriormente dijimos que sólo los miembros aptos de la población

pueden reproducirse para crear las próximas generaciones.
ICalculateScore s c o r e = new T r a i n i n g S e t S c o r e ( t r a i n i n g S e t ) ;
Un paso final requerido es establecer una función de activación de

salida para la red NEAT. Esto es diferente de la "función de activación
NEAT", que suele ser sigmoide o TANH. Más bien, esta función de
activación se aplica a todos los datos que se leen de la red neuronal.
Tratar cualquier salida de la red neuronal por debajo de 0,5 como cero,
y cualquiera de arriba como una. Esto se puede hacer con una función de
activación de pasos, como sigue.
var s t e p = new A c t i v a t i o n S t e p ( )
; s t e p . Center = 0 . 5 ;
pop . O u t p u t A c t i v a t i o n F u n c t i o n = s t e p ;
Ahora que la población ha sido creada, debe ser entrenada.

7.4.2 Formación de una Red Neural de Encog NEAT
La formación de una red neural NEAT es muy similar a la formación de
cualquier otra red neuronal en Encog: crear un objeto de formación y
comenzar a realizar bucle a través de iteraciones. A medida que estas
iteraciones progresan, la calidad de las redes neuronales en la población
debería aumentar.
Una red NEAT neural es entrenada con la clase NEATTraining. Aquí
puede ver un objeto NEATTraining que se está creando.
var t r a i n = new NEATTraining ( s c o r e , pop ) ;
Este objeto entrena a la población a una tasa de error del 1%.
E n c o g U t i l i t y . TrainToError ( t r a i n , 0.01);
Una vez que la población ha sido entrenada, extraiga la mejor red

neuronal.
var network = (NEATNetwork) t r a i n . Method ;

Con una red neural establecida, su rendimiento debe ser probado. Ahora,
muestre los resultados de la red neuronal.
Console . WriteLine (@” Neural Network Results:”);

E n c o g U t i l i t y . Evaluate ( network , t r a i n i n g S e t ) ;
Esto producirá la siguiente salida.

Beginning training...
I t e r a t i o n #1 E r r o r :25.000000% Target E r r o r : 1.000000%
I t e r a t i o n #2 E r r o r :0.000000% Target E r r o r : 1.000000%
Input = 0 . 0 0 0 0 , 0 . 0 0 0 0 , Actual =0.0000 , I d e a l =0.0000
La red neural sólo tomó dos iteraciones para producir una red neuronal que
sabía funcionar como un operador XOR. La red ha aprendido el operador
XOR de los resultados anteriores. XOR producirá una salida de 1,0 sólo
cuando las dos entradas no son del mismo valor.
7.5 Resumen
Mientras que los capítulos anteriores se centraron principalmente en
las redes neuronales feedforward, este capítulo explora algunos de los
otros tipos de red Encog-apoyado, incluyendo el Elman, Jordania, ART1 y
NEAT redes neuronales.
En este capítulo aprendiste sobre redes neuronales recurrentes, que
contienen conexiones hacia atrás a capas anteriores. Las redes
neuronales de Elman y Jordan hacen uso de una capa de contexto. Esta
capa de contexto les permite aprender patrones que abarcan varios
elementos de datos de entrenamiento. Esto los hace muy útiles para las
redes neurales temporales.
7.5 Summary 123
La red neuronal ART1 se puede utilizar para aprender patrones

binarios. Una diferencia de otras redes neuronales, no existe un estado
de aprendizaje y uso distinto. La red neuronal ART1 aprende como se
utiliza y no requiere ninguna etapa de entrenamiento. Esto imita al
cerebro humano en que los humanos aprendieron una tarea mientras que
realizan esa tarea.
Este capítulo concluyó con la neuronal roja NEAT. El NET-trabajo de
NEAT no tiene capas ocultas como una típica red neuronal feedforward.
Una red NEAT comienza con solo una capa de entrada y salida. La
estructura de las neuronas ocultas evoluciona a medida que la red NEAT
es entrenada usando un algoritmo genético.
En el próximo capítulo veremos las redes neurales temporales. Se

utiliza una red neural temporal para intentar predecir el futuro. Este tipo de
red neural puede ser muy útil en una variedad de campos tales como
finanzas, procesamiento de señales y negocios en general. El siguiente
capítulo mostrará cómo estructurar los datos de entrada para las
consultas de red neural para hacer una predicción futura.
125
Capitulo 8
Uso de datos termporales

• Cómo funciona una Red Neural Predictiva
• Uso del conjunto de datos temporal Encog
• Intentando Predecir Sunspots
• Uso del conjunto de datos Encog Market
• Intentando Predecir el Mercado de Valores
La predicción es otro uso común para las redes neuronales. Una red
neural predictiva intentará predecir valores futuros basados en valores
presentes y pasados. Estas redes neuronales se denominan redes
neurales temporales porque operan con el tiempo. Este capítulo
presentará las redes neuronales temporales y las clases de soporte que
Encog les proporciona.
En este capítulo, verá dos aplicaciones de Encog redes neuronales
temporales. En primer lugar, vamos a ver cómo usar Encog para predecir
las manchas solares. Las manchas solares son razonablemente
predecibles y la red neuronal debe ser capaz de aprender patrones
futuros analizando datos pasados. A continuación, vamos a examinar un
caso simple de la aplicación de una red neuronal para hacer las
predicciones del mercado de valores.
Antes de mirar a cualquiera de los ejemplos, debemos ver cómo
funciona realmente una red neural temporal. Una red neuronal temporal
suele ser un feedfor-ward o red recurrente simple .
126 Uso de datos temporales
Las redes mostradas hasta ahora podrían estructurarse como una red
neural temporal asignando ciertas neuronas de entrada y salida.
8.1 Cómo funciona una Red Neural Predictiva
Una red neuronal predictiva utiliza sus entradas para aceptar información
sobre los datos actuales y utiliza sus salidas para predecir datos futuros.
Utiliza dos "ventanas", una ventana futura y una ventana pasada. Ambas
ventanas deben tener un tamaño de ventana, que es la cantidad de datos
que se predice o es necesario para predecir. Para ver las dos ventanas en
acción, considere los siguientes datos.
Day 1 : 100
Day 2 : 102
Day 3 : 104
Day 4 : 110
Day 5 : 99
Day 6 : 100
Day 7 : 105
Day 8 : 106
Day 9 : 110
Day 1 0 : 120
Considere una red neural temporal con un tamaño de ventana pasado de

cinco y un tamaño de ventana futuro de dos. Esta red neuronal tendría
cinco neuronas de entrada y dos neuronas de salida. Romperíamos los
datos anteriores entre estas ventanas para producir datos de
entrenamiento. Los siguientes datos muestran un elemento de este tipo
de datos de entrenamiento.
Input 1 : Day 1 : 100 (input neuron )
I d e a l 1 : Day 6 : 100 ( output neuron )
Por supuesto, los datos anteriores deben normalizarse de alguna manera
antes de que puedan ser alimentados a la red neuronal. La ilustración
anterior muestra simplemente cómo las neuronas de entrada y salida se
asignan a los datos reales. Para obtener
8.2 Uso del conjunto de datos temporal Encog 127
datos adicionales, ambas ventanas se deslizan hacia adelante. El

siguiente elemento de los datos de entrenamiento sería el siguiente.
Seguiría deslizando las ventanas pasadas y futuras hacia adelante a

medida que genera más datos de entrenamiento. Encog contiene clases
especializadas para preparar los datos en este formato. Simplemente
especifique el tamaño del pasado, o entrada, ventana y el futuro, o salida,
ventana. Estas clases especializadas serán discutidas en la siguiente
sección.
8.2 Uso del conjunto de datos temporal Encog
El dataset temporal Encog está contenido en el siguiente paquete:
Encog .ML. Data . Temporal

Hay un total de cuatro clases que componen el conjunto de datos temporal
Encog. Estas clases son las siguientes:
• TemporalDataDescription
• TemporalError
• TemporalMLDataSet
• TemporalPoint
La clase TemporalDataDescription describe una unidad de datos que se

utiliza para la predicción o la salida. La clase TemporalError es una
excepción que se activa si hay un error al procesar los datos temporales. La
clase TemporalMLDataSet funciona igual que cualquier conjunto de datos
Encog y permite
que los datos temporales se utilicen para el entrenamiento. La clase

TemporalPoint representa un punto de datos temporales.
Para empezar a usar un TemporalMLDataSet debemos instanciarlo de la
siguiente manera:
TemporalMLDataSet result =
new TemporalMLDataSet (
[ p a s t window s i z e ] , [ f u t u r e window s i z e ] ) ;
La instanciación anterior especifica el tamaño de las ventanas anteriores

y futuras. También debe definir uno o más objetos
TemporalDataDescription. Estos definen los elementos individuales
dentro de las ventanas pasadas y futuras. Un único objeto
TemporalDataDescription puede funcionar tanto como un elemento de
ventana pasado y un futuro como se ilustra en el código siguiente.
TemporalDataDescription d e s c = new
TemporalDataDescription (
[ c a l c u l a t i o n type ] , [ use for p a s t ] , [ use for f u t u r e ] ) ; r e s u l
t . AddDescription ( d e s c ) ;
Para especificar que un objeto TemporalDataDescription funciona como

un elemento pasado y futuro, utilice el valor true para los dos últimos
parámetros. Hay varios tipos de cálculo que puede especificar para cada
descripción de datos. Estos tipos se resumen aquí.
• Type.Raw,
• Type.PercentChange,
• Type.DeltaChange,
El tipo Raw especifica que los puntos de datos deben ser pasados a la red
neuronal sin modificar. El PercentChange especifica que cada punto se debe
pasar como un cambio de porcentaje. DeltaChange especifica que cada punto
debe ser pasado como el cambio real entre los dos valores. Si está
normalizando los datos por sí mismo, debería usar el tipo RAW. De lo contrario,
es muy probable que utilice el tipo PercentChange.
A continuación, proporcione los datos sin procesar para entrenar la red

temporal desde. Para ello, cree objetos TemporalPoint y añádalos al dataset
temporal.
8.3 Aplicación a Sunspots 129
Cada objeto TemporalPoint puede contener varios valores, es decir,

tener el mismo número de valores en cada punto de datos temporales
que en los objetos TemporalDataDe-scription. El código siguiente
muestra cómo definir un punto de datos temporal.
var p o i n t = new TemporalPoint ( [ number o f v a l u e s ] ) ;
p o i n t . Sequence = [ a s e q u e n c e number ] ;
p o i n t . Data [ 0 ] = [ v a l u e 1 ] ;
p o i n t . Data [ 1 ] = [ v a l u e 2 ] ;
r e s u l t . P o i n t s . Add( p o i n t ) ;
Cada punto de datos debe tener un número de secuencia para

clasificar los puntos de datos. La propiedad Data permite que los valores
individuales se establezcan y deben coincidir con el número de valores
especificado en el constructor.
Finalmente, llame al método Generate. Este método toma todos los
puntos temporales y crea el conjunto de entrenamiento. Después de
haber llamado Generate, el objeto TemportalMLDataSet puede utilizarse
para el entrenamiento.
r e s u l t . Generate ( ) ;
La siguiente sección utilizará un objeto TemportalMLDataSet para predecir

manchas solares.
8.3 Application to Sunspots
En esta sección veremos cómo usar Encog para predecir las manchas solares,
que son bastante periódicas y predecibles. Una red neuronal puede aprender
este patrón y predecir el número de manchas solares con una precisión
razonable. La salida del programa de predicción de manchas solares se muestra
a continuación. Por supuesto, la red neural primero comienza a entrenar y se
entrenará hasta que la tasa de error cae por debajo del seis por ciento.
Epoch #1 E r r o r : 0 . 3 9 1 6 5 4 1 1 3 9 0 4 8 0 6 6 4
Epoch #2 E r r o r : 1 . 2 9 0 7 8 9 8 5 1 8 1 1 6 0 0 8
Epoch #3 E r r o r : 1 . 2 7 5 6 7 9 8 5 3 9 8 2 2 1 4
Epoch #4 E r r o r : 0 . 8 0 2 6 9 5 4 6 1 5 0 9 5 1 6 3
Epoch #5 E r r o r : 0 . 4 9 9 9 3 0 5 5 1 4 1 4 5 0 9 5
Epoch #6 E r r o r : 0 . 4 6 8 2 2 3 4 5 0 1 6 4 2 0 9
Epoch #7 E r r o r : 0 . 2 2 0 3 4 2 8 9 9 3 8 5 4 0 6 7 7
Epoch #8 E r r o r : 0 . 2 4 0 6 7 7 6 6 3 0 6 9 9 8 7 9
...
Epoch #128 E r r o r : 0 . 0 6 0 2 5 6 1 3 8 0 3 0 1
1 3 2 6 Epoch #129 E r r o r : 0 . 0 6 0 0 2 0 6 9 5
7 9 3 5 1 9 0 1 Epoch #130 E r r o r : 0 . 0 5 9 8 3
0 227 113 598 734Ye arAc t ualPred i
c t C l o s e d Loop P r e d i c t 1 9 6 0 0 . 5 7 2 3 0
.55470.554719610.32670.4075
0.391819620.25770.18370.2672
19630.21730.11900.073919640.
14290.17380.113519650.16350.
26310.365019660.29770.23270.
420319670.49460.28700.134219
680.54550.61670.353319690.54
380.51110.641519700.53950.38
300.401119710.38010.40720.24
6919720.38980.21480.23421973
0.25980.25330.178819740.2451
0.16860.216319750.16520.1968
0.206419760.15300.14700.2032
19770.21480.15330.1751 1978
0.48910.35790.1014
Una vez que la red ha sido entrenada, trata de predecir el número de

manchas solares entre 1960 y 1978. Lo hace con al menos cierto grado de
precisión. El número mostrado es normalizado y simplemente proporciona
una idea del número relativo de manchas solares. Un número mayor indica
más actividad de manchas solares; Un número más bajo indica menos
actividad de la mancha solar.
Hay dos números de predicción dado: la predicción regular y la predicción
de lazo cerrado. Ambos tipos de predicción usan una ventana anterior de 30
y una ventana futura de 1. La predicción regular simplemente usa los últimos
30 valores de datos reales. El bucle cerrado comienza de esta manera y, a
medida que avanza, sus propias predicciones se convierten en la entrada a
medida que la ventana se desliza hacia delante. Esto suele dar lugar a una
predicción menos precisa, ya que los errores que la red neural hace se
agravan.
Ahora examinaremos cómo se implementó este programa. Este programa
se puede encontrar en la siguiente ubicación.
Encog . Examples . P r e d i c t . P r e d i c t S u n s p o t
Como puede ver, el programa tiene datos de manchas solares codificados en

la parte superior del archivo. Estos datos se tomaron de un programa de ejemplo
de red neural basada en C. Puede encontrar la aplicación original en la siguiente
URL:
Http://www.neural-networks-at-your-fingertips.com/bpn.html
El antiguo ejemplo de red neural basado en C fue modificado para hacer uso
de Encog. Notará que la versión Encog es mucho más corta que la versión
basada en C. Esto se debe a que gran parte de lo que el ejemplo ya estaba
implementado en Encog. Además, la versión de Encog entrena la red más
rápidamente porque hace uso de la propagación elástica, mientras que el
ejemplo basado en C hace uso de backpropagation.
Este ejemplo pasa por un proceso de dos pasos para usar los datos. En
primer lugar, los datos en bruto se normalizan. A continuación, estos datos
normalizados se cargan en un objeto Tem-portalMLDataSet para el
entrenamiento temporal. El método NormalizeSunspots se llama para normalizar
las manchas solares. Este método se muestra a continuación.
public void No rm al iz eS uns po ts ( double l o , double h i )
{
Los parámetros hi y lo especifican el rango alto y bajo al cual deben

normalizarse las manchas solares. Esto especifica el rango de manchas solares
normalizado. La normalización se discutió en el capítulo 2. Para este ejemplo, el
valor de lo es 0,1 y el valor alto es 0,9.
Para normalizar estas matrices, cree una instancia de la clase
NormalizeArray. Este objeto le permitirá normalizar rápidamente una matriz. Para
utilizar este objeto, simplemente establezca los valores normalizados altos y
bajos, como se indica a continuación.
var norm = new NormalizeArray
{NormalizedHigh = hi , NormalizedLow = l o };
La matriz ahora puede normalizarse a este rango llamando al método Process.

n o r m a l i z e d S u n s p o t s = norm . P r o c e s s ( Sunspots ) ;
Ahora copie las manchas solares normalizadas a las manchas
solares de lazo cerrado.
closedLoopSunspots=
EngineArray . ArrayCopy ( n o r m a l i z e d S u n s p o t s ) ;
Inicialmente, la matriz de bucle cerrado comienza de la misma manera

que la predicción regular. Sin embargo, sus predicciones se utilizan para
llenar esta matriz.
Ahora que los datos de las manchas solares han sido normalizados,
deben ser convertidos a datos temporales. Esto se hace llamando al
método GenerateTraining, que se muestra a continuación.
public IMLDataSet G e n e r a t e T r a i n i n g ( )
{
Este método devolverá un conjunto de datos Encog que se puede utilizar

para el entrenamiento. Primero se crea un TemporalMLDataSet y se
especifican los tamaños de ventana pasados y futuros.
var r e s u l t = new TemporalMLDataSet ( WindowSize , 1) ;
Tendremos una única descripción de los datos. Como los datos ya están
normalizados, usaremos datos RAW. Esta descripción de datos se
utilizará tanto para la entrada como para la predicción, como especifican
los dos últimos parámetros. Finalmente, agregamos esta descripción al
conjunto de datos.
var d e s c = new TemporalDataDescription
( TemporalDataDescription . Type . Raw, true , true ) ;
r e s u l t . AddDescription ( d e s c ) ;
Ahora es necesario crear todos los puntos de datos. Vamos a anudar entre el
año de inicio y final, que son los años utilizados para entrenar la red neuronal.
Otros años serán usados para probar la capacidad predictiva de la red neuronal.
for ( int y e a r = T r a i n S t a r t ; y e a r < TrainEnd ; y e a r++)
{
Cada punto de datos tendrá sólo un valor para predecir las manchas
solares. La secuencia es el año, porque sólo hay una muestra de
manchas solares por año.
var p o i n t = new TemporalPoint ( 1 ) {Sequence = y e a r };
El único valor que estamos usando es el número normalizado de

manchas solares. Este número es tanto lo que usamos para predecir los
valores pasados como lo que esperamos predecir en el futuro.
p o i n t . Data [ 0 ] = n o r m a l i z e d S u n s p o t s [ y e a r ] ;
r e s u l t . P o i n t s . Add( p o i n t ) ;
}
Finalmente, generamos el conjunto de entrenamiento y lo devolvemos.

r e s u l t . Generate
( ) ; return r e s u l t ;
Los datos están listos para el entrenamiento. Este conjunto de datos es

entrenado usando la propagación elástica. Este proceso es el mismo que el
utilizado muchas veces antes en este libro. Una vez finalizado el
entrenamiento, intentaremos predecir las manchas solares usando la
aplicación. Esto se hace con el método Predict, que se muestra aquí.
public void P r e d i c t ( BasicNetwork network )

{
Mostramos el encabezado de la tabla y comenzamos a recorrer los años

de evaluación.
Console . WriteLine (@” Year Actual P r e d i c t Closed Loop
Predict”);
for ( int y e a r = E v a l u a t e S t a r t ; y e a r < EvaluateEnd ; y e a r++)
{
Creamos la entrada en la red neural basada en datos reales, que será la

predicción real. Extraemos 30 años de datos para la ventana anterior.
IMLData i n p u t = new BasicMLData ( WindowSize ) ; for
( var i = 0 ; i < i n p u t . Count ; i ++)
{
i n p u t . Data [ i ] = n o r m a l i z e d S u n s p o t s [ ( y e a r − WindowSize ) + i ] ;
}
La red neural se presenta con los datos y recuperamos la predicción.

IMLData output = network . Compute ( i n p u t ) ;

double p r e d i c t i o n = output . Data [ 0 ] ;
La predicción se guarda en la matriz de bucle cerrado para su uso con

predicciones futuras.
closedLoopSunspots[year]=prediction;
Ahora calcularemos el valor de lazo cerrado. El cálculo es esencialmente

el mismo excepto que se utilizan los datos de bucle cerrado, que se
modifican continuamente. Al igual que antes, usamos 30 años de datos.
for ( var i = 0 ; i < i n p u t . Count ; i ++)
{
i n p u t . Data [ i ] = c l o s e d L o o p S u n s p o t s [ ( y e a r − WindowSize ) + i
];
}
Calculamos la salida.
output = network . Compute ( i n p u t ) ;
double c l o s e d L o o p P r e d i c t i o n = output . Data [ 0 ] ;
Finalmente, mostramos la predicción de lazo cerrado, la predicción

regular y el valor real.
Console . WriteLine ( ( S t a r t i n g Y e a r + y e a r )
+ @” ” + Format . FormatDouble ( n o r m a l i z e d S u n s p o t s [ y e a r ] , 2)
+ @” ” + Format . FormatDouble ( p r e d i c t i o n , 2)
+ @” ” + Format . FormatDouble ( c l o s e d L o o p P r e d i c t i o n , 2) ) ;
}
}
Esto mostrará una lista de todas las predicciones de las manchas solares
hechas por Encog. En la siguiente sección veremos cómo Encog puede
extraer automáticamente la información actual del mercado y tratar de
predecir las direcciones del mercado de valores.
8.4 Utilización del conjunto de datos Encog Market
Encog también incluye un conjunto de datos específicamente diseñado
para los datos del mercado de valores. Este conjunto de datos es capaz
de descargar datos de fuentes externas. Actualmente, la única fuente
externa incluida en Encog es Yahoo Finance. El dataset de mercado
Encog está construido sobre el dataset temporal y la mayoría de las
clases en el dataset de mercado Encog descienden directamente de las
clases correspondientes en el conjunto de datos temporales.
Las siguientes clases forman el paquete Encog Market DataSet:

8.4 Uso del conjunto de datos Encog Market 135
• MarketDataDescription
• MarketDataType
• MarketError
• MarketMLDataSet
• MarketPoint
• Símbolo ticker
La clase MarketDataDescription representa una pieza de datos de

mercado que forma parte de la ventana pasada o futura.
Desciende de la clase Temporal-DataDescription. Consiste
principalmente en un objeto TickerSymbol y una enumeración
MarketDataType. El símbolo ticker especifica la seguridad a
incluir y el MarketDataType especifica qué tipo de datos de esta
seguridad utilizar. A continuación se enumeran los tipos de
datos disponibles.
• Abierto - El mercado abierto para el día.
• Cerrar - El cierre del mercado para el día.
• Volumen - El volumen del día.
• AdjustedClose - El cierre ajustado. Ajustado por divisiones y

dividendos.
• Alto - El máximo para el día.
• Bajo - El mínimo para el día.

Estos son los criterios de tipos de datos de mercado actualmente

soportados por Encog. Todos ellos están representados dentro de la
enumeración MarketDataType.
La clase MarketMLDataSet desciende del TemporalML-DataSet. Ésta
es la clase principal cuando se crean datos de formación basados en el
mercado para Encog. Esta clase es un conjunto de datos Encog y puede
ser entrenada. Si se producen errores, se lanzará la excepción
MarketError.
La clase MarketPoint desciende desde el punto temporal. Por lo
general, no se ocupará directamente de este objeto, ya que Encog suele
descargar datos de mercado de Yahoo Finance. El código siguiente
muestra el formato general para utilizar la clase MarketMLDataSet.
Primero, crea un cargador. Actualmente, YahooFinanceLoader es el único
cargador público disponible para Encog.
var l o a d e r = new YahooFinanceLoader ( ) ;
A continuación, creamos el conjunto de datos del mercado. Pasamos el

cargador, así como el tamaño de las ventanas pasadas y futuras.
var market = new MarketMLDataSet ( l o a
der,
[ p a s t window s i z e ] ,
[ f u t u r e window s i z e ] ) ;
A continuación, crear un objeto MarketDataDescription. Para ello,

especifique el símbolo de ticker y el tipo de datos necesarios. Los últimos
dos valores verdaderos al final especifican que este elemento se usa
tanto para fines pasados como predictivos.
var d e s c = new MarketDataDescription (
[ t i c k e r ] , [ data type needed ] , true , true ) ;
Añadimos esta descripción de datos al conjunto de datos.
market . AddDescription ( d e s c ) ;
Podemos agregar descripciones adicionales según sea necesario. A

continuación, cargue los datos de mercado y genere los datos de
formación.
market . Load ( [ b e g i n date ] , [ end date ] ) ;
market . Generate ( ) ;
Como se muestra en el código, las fechas de inicio y finalización deben
especificarse. Esto indica a Encog el rango desde el cual generar datos
de entrenamiento.
8.5 Aplicación al Mercado de Valores 137
8.5 Aplicación al Mercado de Valores

Ahora vamos a ver un ejemplo de aplicación de Encog a la predicción del
mercado de valores. Este programa intenta predecir la dirección de un
solo stock basado en el rendimiento pasado. Este es un ejemplo muy
simple del mercado de valores y no está destinado a ofrecer ningún tipo
de asesoramiento de inversión.
En primer lugar, vamos a explicar cómo ejecutar este ejemplo. Hay cuatro
modos distintos en los que se puede ejecutar este ejemplo, dependiendo
del argumento de la línea de comandos que se pasó. Estos argumentos
se resumen a continuación.
• generar - descargar datos financieros y generar archivos de formación.
• tren - Entrenar la red neuronal.
• evaluar - Evaluar la red neuronal.
• prune - Evalúa probar varias arquitecturas diferentes para determinar la
mejor configuración.
Para comenzar el ejemplo debe ejecutar la clase principal, que se
denomina Market-Predict. Las siguientes secciones mostrarán cómo este
ejemplo genera datos, entrena y luego evalúa la red neuronal resultante.
Esta aplicación se encuentra en la siguiente ubicación.
Encog . Examples . Market . MarketPredict
ConsoleExamples market [ mode ]

Las siguientes secciones describen cómo se implementa cada modo.
8.5.1 Generación de datos de formación

El primer paso es generar los datos de entrenamiento. El ejemplo va a bajar
cerca de ocho años de información financiera para entrenar con. Toma un
tiempo para descargar y procesar esta información. Los datos se descargan
y se escriben en un archivo Encog EG. La clase MarketBuildTraining

proporciona esta funcionalidad.
Todo el trabajo realizado por esta clase se encuentra en el método
estático denominado Generate. Este método se muestra a continuación.
public s t a t i c void Generate ( F i l e I n f o dataDir )
{
Este método comienza creando un YahooFinanceLoader que cargará

los datos financieros solicitados.
IMarketLoader l o a d e r = new YahooFinanceLoader ( ) ;
Se crea un nuevo objeto MarketMLDataSet que utilizará el cargador y un

tamaño especificado para las ventanas pasadas y futuras. De forma
predeterminada, el programa utiliza un tamaño de ventana futuro de uno y un
tamaño de ventana anterior de 10. Estas constantes están todas definidas en
la clase Config. Esta es la manera de controlar cómo se estructura y entrena
la red cambiando cualquiera de los valores de la clase Config.
var market = new MarketMLDataSet ( l o a d e r ,
C o n f i g .INPUT WINDOW, C o n f i g .PREDICT WINDOW) ;
El programa utiliza un único valor de mercado para hacer predicciones.

Utilizará el precio de cierre ajustado del valor especificado. La seguridad
que el programa intenta predecir se especifica en la clase Config.
var d e s c = new MarketDataDescription (
C o n f i g . TICKER, MarketDataType . AdjustedClose , true , true ) ;
market . AddDescription ( d e s c ) ;
Los datos de mercado están cargados desde hace dos años y terminan
dos meses antes de hoy. Los dos últimos meses se utilizarán para evaluar
el rendimiento de la red neural.
var end = DateTime . Now ; // end t o d a y
var b e g i n = new DateTime ( end . T i c k s ) ; // b e g i n 30 days ago b e g
i n = b e g i n . AddDays( −60) ;
end = end . AddDays( −60) ;
b e g i n = b e g i n . AddYears ( −2)
; market . Load ( begin , end ) ;
market . Generate ( ) ;
8.5 Aplicación a la Bolsa 139
Ahora guardamos los datos de entrenamiento en un archivo EGB binario.

Es importante tener en cuenta que TemporalDataSet o cualquiera de sus
clases derivadas mantendrá los datos numéricos en bruto, al igual que
BasicMLDataSet. Sólo se guardarán los datos generados, no los otros
objetos de soporte, como los objetos MarketDataDescription.
E n c o g U t i l i t y . SaveEGB ( F i l e U t i l . CombinePath ( dataDir ,
C o n f i g . TRAINING FILE) , market ) ;
Crearemos una red para guardar en un archivo EG. Esta red es una
simple red neuronal feedforward que puede tener una o dos capas
ocultas. Los tamaños de las capas ocultas se especifican en la clase
Config.
BasicNetwork network = E n c o g U t i l i t y . SimpleFeedForward
( market . I n p u t S i z e ,
C o n f i g . HIDDEN1
COUNT, C o n f i g .
HIDDEN2 COUNT, market . I
d e a l S i z e , true ) ;
Ahora creamos el archivo EG y almacenamos la red en un archivo EG.

E n c o g D i r e c t o r y P e r s i s t e n c e . SaveObject (
F i l e U t i l . CombinePath ( dataDir , C o n f i g .NETWORK FILE) , network ) ;
Las fases posteriores del programa, como las fases de capacitación y

evaluación, usarán este archivo.
8.5.2 Formación de la red neuronal
La formación de la red neuronal es muy simple. La red y los datos de
entrenamiento ya están creados y almacenados en un archivo EG. Todo lo
que la clase de entrenamiento necesita hacer es cargar estos dos recursos
del archivo EG y comenzar el entrenamiento. La clase MarketTrain lo hace.
El método estático Train realiza todo el entrenamiento. Este método se
muestra aquí.
public s t a t i c void Train ( F i l e I n f o dataDir )

{
El método comienza verificando si el archivo Encog EG está presente. La
red se cargará desde aquí.
F i l e I n f o n e t w o r k F i l e = F i l e U t i l . CombinePath ( dataDir , C o n f i g .
NETWORK FILE) ;
F i l e I n f o t r a i n i n g F i l e = F i l e U t i l . CombinePath ( dataDir , C o n f i g .
TRAINING FILE) ;
// n e t w o r k f i l e i
f(!networkFile.Exists)
{
Console . WriteLine (@”Can ’ t read f i l e : ” + n e t w o r k F i l e ) ;
return ;
}
A continuación, utilice el objeto EncogDirectoryPersistence para cargar

el archivo EG. Extraeremos una red del archivo EG.
var network =
( BasicNetwork ) E n c o g D i r e c t o r y P e r s i s t e n c e .
LoadObject ( n e t w o r k F i l e ) ;
A continuación, cargue la red desde el archivo EG. Esta red se utilizará para
la formación.
if (!trainingFile.Exists)
{
Console . WriteLine (@”Can ’ t read f i l e : ” + t r a i n i n g F i l e ) ;
return ;
}
IMLDataSet t r a i n i n g S e t =
E n c o g U t i l i t y . LoadEGB2Memory( t r a i n i n g F i l e ) ;
La red neuronal está ahora lista para entrenar. Utilizaremos el entrenamiento de

EncogUtility y realizaremos bucle para el número de minutos especificado en la
clase Config. Esto es lo mismo que crear un objeto de entrenamiento y usar
iteraciones, como se hizo anteriormente en este libro. El método TrainConsole
es simplemente un acceso directo para ejecutar las iteraciones durante un
número especificado de minutos.
E n c o g U t i l i t y . Tr ai nC ons ol e ( network , trainingSet,
C o n f i g . TRAINING MINUTES) ;
Finalmente, la red neuronal se guarda nuevamente en el
archivo EG.
Console . WriteLine (@” F i n a l E r r o r : ”
+ network . C a l c u l a t e E r r o r ( t r a i n i n g S e t ) ) ;
Console . WriteLine (@” T r a i n i n g complete , s a v i n g network . ” ) ; E n c
o g D i r e c t o r y P e r s i s t e n c e . SaveObject ( n e t w o r k F i l e ,
network ) ; Console . WriteLine (@” Network saved . ” ) ;
EncogFramework . I n s t a n c e . Shutdown ( ) ;
En este punto, la red neuronal es entrenada. Para seguir entrenando la

red neuronal de trabajo, ejecutar el entrenamiento de nuevo o pasar a la
evaluación de la red neuronal. Si entrena la misma red neuronal
nuevamente usando propagación elástica, la tasa de error inicialmente
aumentará. Esto se debe a que el algoritmo de propagación resiliente
debe restablecer los valores delta apropiados para el entrenamiento.
8.5.3 Poda incremental

Un reto con las redes neuronales es determinar la arquitectura óptima
para las capas ocultas. ¿Debería haber una o dos capas ocultas?
¿Cuántas neuronas deben estar en cada una de las capas ocultas?
No hay respuestas fáciles a estas preguntas.
En general, lo mejor es comenzar con una red neuronal con una capa
oculta y duplicar el número de neuronas ocultas como neuronas de
entrada. Hay algunos informes que sugieren que la segunda capa
oculta no tiene ventajas, aunque esto es a menudo debatido. Otros
informes sugieren que una segunda capa oculta puede algunas veces
conducir a una convergencia más rápida. Para obtener más
información, consulte la página de capa oculta en el wiki de Heaton
Research.
Http://www.heatonresearch.com/wiki/Hidden_Layers
Una utilidad proporcionada por Encog es la clase incremental de poda.
Esta clase le permite usar una técnica de fuerza bruta para determinar
una configuración de capa oculta óptima. Llamar al ejemplo de
mercado con el argumento de poda llevará a cabo una poda
incremental. Esto intentará una serie de diferentes configuraciones de
capas ocultas para intentar encontrar la mejor.
Este comando comienza cargando un conjunto de entrenamiento en la
memoria.
F i l e I n f o f i l e = F i l e U t i l . CombinePath ( dataDir , C o n f i g . TRAINING FILE ) ;
if (!file.Exists)
{
Console . WriteLine (@”Can ’ t read file: ”+ file);
return ;
}
IMLDataSet t r a i n i n g = E n c o g U t i l i t y . LoadEGB2Memory( f i l e ) ;
A continuación se crea un patrón para especificar el tipo de red neuronal que

se va a crear.
var p a t t e r n = new FeedForwardPattern
{
InputNeurons = t r a i n i n g . I n p u t S i z e ,
OutputNeurons = t r a i n i n g . I d e a l S i z e ,
A c t i v a t i o n F u n c t i o n = new ActivationTANH ( )
};
The above code specifies the creation of feedforward neural networks using
the hyperbolic tangent activation function. Next, the pruning object is created.
El código anterior especifica la creación de redes neuronales feedforward
utilizando la función de activación tangente hiperbólica. A continuación, se
crea el objeto de poda.
var prune = new Pr une In cre me nta l ( t r a i n i n g , p a t t e r n , 100 , 1 , 1 0 ,
new C o n s o l e S t a t u s R e p o r t a b l e ( ) ) ;
El objeto realizará 100 iteraciones de entrenamiento, probará un peso

para cada uno, y tendrá 10 redes superiores. El objeto tomará las 10
mejores redes después de 100 iteraciones de entrenamiento. El mejor de
estos 10 se elige para ser la red con el menor número de enlaces.
El usuario también puede especificar el número y el tamaño de las
capas ocultas para intentarlo. Cada llamada a AddHiddenLayer especifica
el límite inferior y superior para intentar. La primera llamada a
AddHiddenLayer especifica el rango para la primera capa oculta. Aquí se
especifica para intentar ocultos tamaños de la capa uno de 5 a 50. Debido
a que el punto inferior no es cero, se requiere que tengamos una primera
capa oculta.
prune . AddHiddenLayer ( 5 , 50) ;
Next we specify the size for the second hidden layer. Here we are trying
hidden layers between 0 and 50 neurons. Because the low point is zero,
we will also try neural networks with no second layer.
prune . AddHiddenLayer ( 0 , 50) ;
Now that the object has been setup we are ready to search. Calling the
process method will begin the search.
prune . P r o c e s s ( ) ;
Una vez completada la búsqueda, puede utilizar la propiedad

BestNetwork para obtener la mejor red de rendimiento. El código
siguiente obtiene esta red y la guarda.
E n c o g D i r e c t o r y P e r s i s t e n c e . SaveObject ( f i l e , prune . BestNetwork ) ;
Ahora tenemos una red neuronal salvada con una buena combinación de
capas ocultas y neuronas. El objeto de poda no entrena particularmente
bien a cada red, ya que está tratando de buscar un gran número de
redes. En este punto, usted querrá seguir entrenando esta mejor red.
8.5.4 Evaluating the Neural Network
Ahora estamos listos para evaluar la red neuronal utilizando la red
neural entrenada de la última sección y medir su desempeño en los datos
actuales del mercado de valores actuales. La clase MarketEvaluate
contiene todo el código de evaluación.
Hay dos métodos importantes utilizados durante el proceso de
evaluación. La primera es la clase DetermineDirection. No estamos
tratando de determinar el cambio porcentual real para una seguridad, sino
más bien, en qué dirección se moverá al día siguiente.
public s t a t i c D i r e c t i o n D e t e r m i n e D i r e c t i o n ( double d )
{
return d < 0 ? D i r e c t i o n . Down : D i r e c t i o n . Up ;
}
Este método simplemente devuelve una enumeración que especifica si

el precio de las acciones se ha movido hacia arriba o hacia abajo.
Necesitaremos algunos datos de mercado actuales para evaluar en
contra. El método Grab-Data obtiene los datos de mercado necesarios.
Hace uso de un Mar-ketMLDataSet, al igual que la formación, para
obtener algunos datos de mercado. Este método se muestra aquí.
public s t a t i c MarketMLDataSet GrabData ( )
{
Al igual que la generación de datos de formación, los datos de mercado se cargan desde un
objeto de Yahoo FinanceLoader.
IMarketLoader l o a d e r = new YahooFinanceLoader ( ) ;
var r e s u l t = new MarketMLDataSet ( l o a d e r ,
C o n f i g .INPUT WINDOW, C o n f i g .PREDICT WINDOW) ;
Creamos exactamente la misma descripción de datos que se utilizó para

el entrenamiento: el cierre ajustado para el símbolo de ticker especificado.
También se desean datos pasados y futuros. Alimentando los datos
pasados a la red neuronal, veremos qué tan bien la salida coincide con
los datos futuros.
var d e s c = new MarketDataDescription ( C o n f i g . TICKER,
MarketDataType . AdjustedClose , true , true ) ; r e s u l

t . AddDescription ( d e s c ) ;
Elija el intervalo de fechas para evaluar la red. Aprovecharemos los

últimos 60 días de datos.
var end = DateTime . Now ; // end t o d a y
var b e g i n = new DateTime ( end . T i c k s ) ; // b e g i n 30 days ago
b e g i n = b e g i n . AddDays( −60) ;
Los datos de mercado ahora se cargan y se generan mediante la llamada al

método Load.
r e s u l t . Load ( begin , end ) ;

r e s u l t . Generate ( ) ; return
result;
}
Los datos resultantes se devuelven al método llamante. Ahora que hemos

cubierto los métodos de apoyo, es hora de aprender cómo se produce la
formación real. El método estático Evaluar realiza la evaluación real. Este
método se muestra a continuación.
public s t a t i c void Evaluate ( F i l e I n f o dataDir )
{
Primero, asegúrese de que existe el archivo Encog EG.

F i l e I n f of i l e = F i l e U t i l . CombinePath ( dataDir ,
C o n f i g . NETWORK
FILE) ; i f ( ! f i l e . E x i s t s )
{
Console . WriteLine (@”Can ’ t read f i l e : ” + f i l e ) ; return ;
Luego, cargamos la red neuronal del archivo EG. Utilice la red neuronal
que fue entrenada en la sección anterior.
var network = ( BasicNetwork )
E n c o g D i r e c t o r y P e r s i s t e n c e . LoadObject ( f i l e ) ;
Cargue los datos de mercado que se utilizarán para la evaluación de la

red. Esto se hace usando el método GrabData discutido anteriormente en
esta sección.
MarketMLDataSet data = GrabData ( ) ;
Durante la evaluación, cuente el número de casos examinados y cuántos fueron correctos.

int count = 0;
int correct =0;
Loop over all of the loaded market data.

f o r e a c h ( IMLDataPair p a i r i n data )
{
Recuperar un par de formación y obtener los datos reales, así como lo que se
predijo. Los datos predichos se determinan ejecutando la red usando el
Método de cálculo.
IMLData i n p u t = p a i r . Input ;
IMLData actualData=p air. Id eal;
IMLData p r e d i c t D a t a = network . Compute ( i n p u t ) ;
Ahora recupere los datos reales y predichos y calcule la diferencia. Esto establece la precisión de
la red neuronal que predice el cambio de precio real.
double a c t u a l = a c t u a l D a t a [ 0 ] ;
double p r e d i c t = p r e d i c t D a t a [ 0 ] ;
double d i f f = Math . Abs ( p r e d i c t − a c t u a l ) ;
También calcular la dirección que la red predijo seguridad toma frente a la
dirección que la seguridad realmente tomó.
Direction actualDirection=DetermineDirection(actual);
Direction predictDirection=DetermineDirection(predict);
Si la dirección es correcta, incremente la cuenta correcta en uno. De cualquier

manera, incrementar el recuento total por uno.
i f ( a c t u a l D i r e c t i o n == p r e d i c t D i r e c t i
o n ) c o r r e c t ++;
count++;
Muestre los resultados para cada caso examinado.

Console . WriteLine (@”Day ” + count + @” : a c t u a l=” +
Format . FormatDouble ( a c t u a l , 4)
+ @” ( ” + a c t u a l D i r e c t i o n + @” ) ”
+ @” , p r e d i c t=” + Format . FormatDouble ( p r e d i c t , 4) +
@” ( ”
+ p r e d i c t D i r e c t i o n + @” ) ” + @” , d i f f=” + d i f f ) ;
}
Por último, mostrar estadísticas sobre la precisión general de la red

neuronal.
double p e r c e n t = c o r r e c t /( double ) count ;
Console . WriteLine (@” D i r e c t i o n c o r r e c t : ” + c o r r e c
t + @” / ” + count ) ;
Console . WriteLine (@” D i r e c t i o n a l Accuracy : ” +
Format . FormatPercent ( p e r c e n t ) ) ;
}
El fragmento de código siguiente muestra la salida de esta aplicación cuando se

inicia una vez. Dado que utiliza datos anteriores a la fecha actual, los resultados
serán diferentes cuando se ejecuten. Estos resultados se producen porque el
programa está intentando predecir el movimiento porcentual en el precio de las
acciones de Apple Computer.
Day 1: a c t u a l =0.05( up ) , p r e d i c t =−0.09(up ) , d i f f =0.1331431391626865
Day 2: a c t u a l =−0.02(down ) , p r e d i c t =0.15( down ) , d i f f
=0.1752316137707985
Day 3: a c t u a l =−0.04(down ) , p r e d i c t =−0.08(down ) , d i f f
=0.04318588896364293
Day 4: a c t u a l =0.04( up ) , p r e d i c t =−0.13(up ) , d i f f =0.167230163960771
Day 5: a c t u a l =0.04( up ) , p r e d i c t =0.08( up ) , d i f f =0.041364210497886064
Day 6 : a c t u a l =−0.05(down ) , p r e d i c t =−0.15(down ) , d i f f

=0.09856291235302134
Day 7 : a c t u a l =0.03( up ) , p r e d i c t =0.02( up ) , d i f f =0.0121349208067498
Day 8 : a c t u a l =0.06( up ) , p r e d i c t =0.14( up ) , d i f f =0.07873950162422072
Day 9 : a c t u a l =0.00( up ) , p r e d i c t =−0.04(up ) , d i f f =0.044884229765456175
Day 1 0 : a c t u a l =−0.02(down ) , p r e d i c t =−0.11(down ) , d i f f
=0.08800357702537594
Day 1 1 : a c t u a l =−0.03(down ) , p r e d i c t =0.10( down ) , d i f f
=0.1304932331559785
Day 1 2 : a c t u a l =0.03( up ) , p r e d i c t =−0.00(up ) , d i f f =0.03830226924277358
=0.006017023124087514
=0.1634993352860712
Day 1 6 : a c t u a l =0.00( up ) , p r e d i c t =0.09( up ) , d i f f =0.08529079398874763
=0.14462998342498684
=0.17692298105888082
=0.05856519756505361
=0.0031913517175624975
=0.06931714317358993
=0.019323500655091908
=0 .036886336426948246 D
irectioncorrect:18/30
D i r e c t i o n a l Accuracy :60.00%
Aquí, el programa tenía una precisión del 60%, lo cual es muy bueno para
esta simple red neuronal. Las tasas de precisión generalmente varían
entre 30 y 40% cuando este programa se ejecuta a intervalos diferentes.
Este es un predictor muy simple del mercado de valores y no se debe

utilizar para ninguna inversión real. Muestra cómo estructurar una red
neuronal para predecir la dirección del mercado.
8.6 Resumen
En este capítulo, aprendimos cómo Encog podría procesar las redes
neuronales temporales. Las redes temporales se usan para predecir lo
que ocurrirá en el futuro. El primer ejemplo de este capítulo mostró cómo
usar Encog para predecir las manchas solares. El segundo ejemplo
mostró cómo usar Encog para intentar predecir los movimientos de
precios de las acciones.
El ejemplo de la mancha solar hizo uso del TemporalDataSet. Se trata

de un conjunto de datos temporales de bajo nivel diseñado para modelar
cualquier red neuronal de predicción basada en "ventana". Una ventana
pasada se utiliza para proporcionar varios valores a la red neural de la
cual hacer predicciones. Una ventana futura especifica el número de
elementos que la red neural debe predecir en el futuro.
El ejemplo del mercado de valores utilizó la clase MarketMLDataSet.

Esta clase se basa en TemporalDataSet para descargar automáticamente
información financiera de Yahoo Finance. Este es un ejemplo muy simple
para mostrar la base de la aplicación de redes neuronales al mercado de
valores. Las decisiones de inversión no deben basarse en esta red.
El siguiente capítulo mostrará cómo usar imágenes con redes

neuronales. Pre-enviar imágenes a una red neuronal es una cuestión de
convertir la imagen en una matriz numérica de modo que una red
neuronal lo considere como entrada. Esto es cierto para cualquier
información que se presente a una red neuronal. Es una cuestión de
convertir esos datos en una matriz de valores en coma flotante.
8.6 Summary 149
151
Capitulo 9
Uso de datos de imagen

• Procesamiento de imágenes
• Encontrar los límites
• Downsampling
• Uso del conjunto de datos de imagen
El uso de redes neuronales para reconocer imágenes es una tarea
muy común. Este capítulo explorará cómo usar imágenes con Encog.
Mediante el uso de las mismas redes neuronales de feedforward como se
vio en capítulos anteriores, redes neuronales pueden ser diseñados para
reconocer ciertas imágenes. Los conjuntos de datos especializados
facilitan el proceso de obtención de datos de imagen en la red neuronal.
Este capítulo presentará ImageMLDataSet. Esta clase puede aceptar

una lista de imágenes que se cargarán y procesarán en un formulario
Encog-friendly. ImageMLDataSet se basa en el BasicMLDataSet, que es
realmente sólo una matriz de valores dobles para la entrada y la idea.
ImageMLDataSet simplemente agrega funciones especiales para cargar
imágenes en matrices de dobles.
Existen varias cuestiones importantes a tener en cuenta al cargar

datos de imagen en una red neuronal. ImageMLDataSet se encarga de
dos aspectos importantes de esto. El primer aspecto es la detección de
límites sobre lo que se debe reconocer. El segundo es el downsampling
donde las imágenes suelen ser formateadas en alta resolución y deben
ser downsampled a una resolución inferior consistente para ser
alimentado a la red neuronal.
152 Uso de datos de imagen
9.1 Encontrar los límites

Una imagen es una región rectangular que representa los datos
importantes para la red neuronal. Sólo una parte de la imagen puede ser
útil. Idealmente, la imagen real que la red neuronal debe reconocer es
igual a toda la imagen física - en lugar de sólo una parte de la imagen
original. Tal es el caso de la figura 9.1
Figure 9.1: An X Drawn Over the Entire Drawing Area
Como se puede ver en la figura anterior, la letra "X" fue dibujada sobre
casi toda la imagen física. Esta imagen requeriría una detección de límites
mínima, si es que existe alguna.
Las imágenes no siempre serán tan perfectamente creadas. Considere
la imagen representada en la figura 9.2.
9.1 Encontrando los límites 153
Figura 9.2: Un O ff-Centro, O ff-Escala X
En este caso, la letra "X" es escalada dife- rentemente de la imagen

anterior y también está en el centro. Para reconocerlo correctamente,
debemos encontrar los límites de la segunda letra "X". La figura 9.3
muestra un cuadro delimitador alrededor de la letra "X". Sólo los datos
dentro del cuadro delimitador se utilizarán para reconocer la imagen.
Figura 9.3: La X con sus Límites Detectados
Como puede ver, los límites se han detectado para la letra "X". El
cuadro delimitador significa que solo se reconocerán los datos dentro de
ese recuadro. Ahora la "X" está aproximadamente en la misma
orientación que la Figura 9.1.
154 Using Image Data
9.2 Downsampling de una imagen

Incluso con cuadros delimitadores, las imágenes pueden no tener un
tamaño constante. La letra "X" en la Figura 9.3 es considerablemente menor
que la Figura 9.1. Al reconocer la imagen, dibujaremos una rejilla sobre la
imagen y alinearemos cada celda de rejilla con una neurona de entrada. Para
ello, las imágenes deben tener un tamaño constante. Además, la mayoría de
las imágenes tienen una resolución demasiado alta para usarse con una red
neuronal.
El downsampling resuelve ambos problemas reduciendo la resolución de
la imagen y escalando todas las imágenes a un tamaño consistente. Para ver
esto en acción, considere la Figura 9.4. Esta figura muestra el logotipo de
Encog en la resolución completa.
Figura 9.4: El logotipo de Encog en resolución completa
La Figura 9.5 muestra esta misma imagen con muestreo.

Figura 9.5: El logotipo de Encog Downsampled
¿Se nota el patrón de rejilla? Se ha reducido a 32 x 32 píxeles. Estos

píxeles formarían la entrada a una red neuronal. Esta red neuronal
requeriría 1.024 neuronas de entrada, si la red sólo mirara la intensidad
de cada cuadrado. Mirar la intensidad limita la red neuronal para ver en
"blanco y negro".
9.3 Uso del conjunto de datos de imágenes Encog 155
Si desea que la red neural se vea en color, entonces es necesario

proporcionar valores de rojo, verde y azul (RGB) para cada uno de estos
píxeles. Esto significaría tres neuronas de entrada para cada píxel, lo que
empujaría el conteo de neuronas de entrada a 3.072.
El conjunto de datos de imagen Encog proporciona tanto la detección de
límites, como el RGB y el muestreo de intensidad. En la siguiente sección,
se introducirá el conjunto de datos de imagen Encog.
9.2.1 Qué hacer con las neuronas de salida
Las neuronas de salida deben representar los grupos en los que
caerán estas imágenes. Por ejemplo, si está escribiendo una aplicación
de OCR, utilice una neurona de salida para que cada carácter sea
reconocido. La codificación equilateral también es útil a este respecto,
como se analiza en el capítulo 2 "Obtención de datos para Encog".
La formación supervisada también requiere datos de salida ideales
para cada imagen. Para un OCR simple, puede haber 26 neuronas de
salida, una para cada letra del alfabeto. Estas salidas ideales forman la
red neuronal para lo que la imagen es en realidad. Si el entrenamiento es
un entrenamiento supervisado o no supervisado, las neuronas de salida
retransmitirán cómo la red neuronal interpretó cada imagen.
9.3 Using the Encog Image Dataset
Antes de instanciar un objeto ImageMLDataSet, se debe crear un objeto
downsampled. Este objeto es una herramienta para Encog a utilizar para
realizar el down-sample. Todos los objetos Encog downsample deben
implementar la interfaz ID-ownsample. Encog soporta actualmente dos
clases de downsample, que se enumeran a continuación:
• RGBDownsample
• SimpleIntensityDownsample
El SimpleIntensityDownsample no toma el color en consideración.

Simplemente calcula el brillo o la oscuridad de un píxel.
El número de neuronas de entrada será la altura multiplicada por el

ancho, ya que sólo hay una neurona de entrada necesaria por píxel.
RGBDownsample es más avanzado que SimpleIntensityDown-sample.
Este objeto de downsample se convierte en la resolución que especifica y
convierte cada píxel en una entrada de tres colores (RGB). El número total
de valores de neuronas de entrada producidos por este objeto será la altura
veces la anchura veces tres. El siguiente código instancia un Objeto
SimpleIntensityDownsample. Este objeto se usará para crear el conjunto de
entrenamiento.
downsample = new SimpleIntensityDownsample ( ) ;
Ahora que se crea un objeto downsample, es hora de utilizar una clase

ImageML-DataSet. Debe ser instanciado con varios parámetros. El código
siguiente lo hace.
t r a i n i n g = new ImageMLDataSet ( downsample , false , 1 , −1) ;

Los parámetros 1 y -1 especifican el rango al que los colores serán
normalizados, ya sea por el color de intensidad o por los tres colores RGB
individuales. El valor falso significa que el conjunto de datos no debe
intentar detectar los bordes. Si este valor es verdadero, Encog intentará
detectar los bordes.
La detección de bordes Encog actual no es muy avanzada. Busca un
color consistente alrededor de los lados de una imagen e intenta quitar
tanto de esa región como puede. La detección de bordes más avanzada
probablemente se construirá en futuras versiones de Encog. Si es
necesaria una detección avanzada de bordes, lo mejor es recortar las
imágenes antes de enviarlas al objeto ImageMLDataSet.
Ahora que se ha creado el objeto ImageNeuralDataSet, debemos
añadirle algunas imágenes. Para agregar imágenes a este conjunto de
datos se debe crear un objeto ImageNeuralData para cada imagen. Las
siguientes líneas de código agregarán una imagen de un archivo.
Bitmap bitmap = new Bitmap ( [ f i l e n a m e o f image ] ) ;
ImageNeuralData data = new ImageNeuralData ( bitmap ) ; this . t r a i
n i n g . add ( data , [ i d e a l output ] ) ;
The image is loaded from a file using the .Net Bitmap class. This class is
provided by .Net to read images from files. Any valid .Net Bitmap image
object can be used by the dataset.
9.4 Ejemplo de reconocimiento de imagen 157
La salida ideal debe ser especificada cuando se usa entrenamiento
supervisado. Con el entrenamiento sin supervisión, este parámetro puede
omitirse. Una vez instanciado el objeto ImageML-Data, se agrega al conjunto de
datos. Estos pasos se vuelven a repetir para cada imagen que se agregue.
Una vez que todas las imágenes se cargan, están listas para ser sometidas a
muestreo. Para hacer una simulación de las imágenes, llame al método
Downsample.
this . t r a i n i n g . Downsample ( [ downsample h e i g h t ] ,
[ downsample width ] ) ;
Especificar la altura y la anchura de disminuir la resolución. Todas las

imágenes se downsam-se declaró a este tamaño. Después de llamar al
método Downsample, se generan los datos de entrenamiento y puede
entrenar una red neuronal.
9.4 Image Recognition Example
Ahora veremos cómo vincular todas las clases de imagen Encog en un ejemplo.
Un programa genérico de reconocimiento de imágenes servirá como ejemplo y
podría fácilmente convertirse en el fundamento de un programa de
reconocimiento de imágenes mucho más complejo. Este ejemplo se dirige desde
un archivo de script. El Listado 9.1 muestra el tipo de archivo de script que
puede conducir este programa.
Listado 9.1: Script de reconocimiento de imágenes
C r e a t e T r a i n i n g : width : 1 6 , h e i g h t : 1 6 , type :RGB
Input : image : . / c o i n s / dime . png , i d e n t i t y : dime
Input : image : . / c o i n s / d o l l a r . png , i d e n t i t y : d o l l a r
Input : image : . / c o i n s / h a l f . png , i d e n t i t y : h a l f d o l l a r
Input : image : . / c o i n s / n i c k l e . png , i d e n t i t y : n i c k l e
Input : image : . / c o i n s / penny . png , i d e n t i t y : penny
Input : image : . / c o i n s / q u a r t e r . png , i d e n t i t y : q u a r t e r
Network : hidden1 : 1 0 0 , hidden2 : 0
Train : Mode : c o n s o l e , Minutes : 1 , S t r a t e g y E r r o r : 0 . 2 5 , S t r a t e g y C y c l e s
:50
Whatis : image : . / c o i n s / dime . png
Whatis : image : . / c o i n s / h a l f . png
Whatis : image : . / c o i n s / t e s t c o i n . png
La sintaxis utilizada por este archivo de script es muy simple. Hay un comando
seguido de dos puntos. Este comando es seguido por una lista de parámetros
separados por comas.
Cada parámetro es un par nombre-valor que también está separado por
dos puntos. Hay cinco comandos en todos: CreateTraining, Input, Network,
Train y Que es.
El comando CreateTraining crea un nuevo conjunto de formación. Para
ello, especifique la altura, el ancho y el tipo de downsample - RGB o Brillo.
El comando Input ingresa una nueva imagen para el entrenamiento. Cada
comando de entrada especifica la imagen, así como la identidad de la
imagen. Varias imágenes pueden tener la misma identidad. Por ejemplo, el
script anterior podría haber proporcionado una segunda imagen de una
moneda de diez centavos haciendo que el segundo comando de entrada
también tenga la identidad de "centavo".
El comando Red crea una nueva red neuronal para el entrenamiento y el
reconocimiento. Dos parámetros especifican el tamaño de las capas ocultas
primera y segunda. Si no desea tener una segunda capa oculta, especifique
cero para el parámetro hidden2.
El tren capacita la red neuronal y el modo especifica la consola o el
entrenamiento de la GUI. El parámetro minutes especifica cuántos minutos
se requieren para entrenar la red. Este parámetro sólo se utiliza con el
entrenamiento de la consola; Para el entrenamiento de GUI, este parámetro
debe ser puesto a cero. La estrategia indica al algoritmo de entrenamiento
cuántos ciclos debe esperar para restablecer la red neuronal si el nivel de
error no ha caído por debajo de la cantidad especificada.
El comando WhatIs acepta una imagen e intenta reconocerla. El ejemplo
imprimirá la identidad de la imagen que consideró más similar.
Vamos a echar un vistazo al ejemplo de reconocimiento de imagen. Este
ejemplo se puede encontrar en la siguiente ubicación.
Encog . Examples . Image . ImageNeuralNetwork
Parte del código del ejemplo anterior trata de analizar el archivo de script
y los argumentos. Dado que el análisis de cadenas no es realmente el
foco de este libro, nos centraremos en cómo se lleva a cabo cada
comando y cómo se construye la red neuronal. En las secciones
siguientes se explica cómo se implementa cada uno de estos comandos.
9.4.1 Creación del conjunto de entrenamiento

El comando CreateTraining se implementa mediante el método
ProcessCreateTrain-ing. Este método se muestra aquí.
private void P r o c e s s C r e a t e T r a i n i n g ( ) {
El comando CreateTraining toma tres parámetros. Las siguientes líneas leen estos parámetros.
S t r i n g strWidth = GetArg ( ” width ” ) ;
S t r i n g s t r H e i g h t = GetArg ( ” h e i g h t ” ) ;
S t r i n g strType = GetArg ( ” type ” ) ;
Los parámetros width y height son enteros y necesitan ser analizados.
downsampleHeight = int . Parse ( strWidth ) ;

downsampleWidth = int . Parse ( s t r H e i g h t ) ;
Ahora debemos crear el objeto downsample. Si el modo es RGB, use

RGB-Downsample. De lo contrario, utilice SimpleIntensityDownsample.
i f ( strType . Equals ( ”RGB” ) )
{
downsample = new RGBDownsample ( ) ;
}
else
{
downsample = new SimpleIntensityDownsample ( ) ;
}
Ahora se puede crear ImageMLDataSet.

t r a i n i n g = new ImageMLDataSet ( downsample , false , 1 , −1) ; app .
WriteLine ( ” T r a i n i n g s e t c r e a t e d ” ) ;
Ahora que el conjunto de entrenamiento es creado, podemos ingresar
imágenes. La siguiente sección describe cómo se hace esto.
9.4.2 Introducción de una imagen

El comando Input se implementa mediante el método ProcessInput. Este
private void P r o c e s s I n p u t ( )
{
El comando Input toma dos parámetros. Las siguientes líneas leen estos parámetros.
S t r i n g image = GetArg ( ” image ” ) ;
S t r i n g i d e n t i t y = GetArg ( ” i d e n t i t y ” ) ;
La identidad es una cadena de texto que representa lo que es la imagen.

Seguimos el número de identidades únicas y asignamos un número cada
vez mayor a cada uno. Estas identidades únicas formarán la capa de
salida de la red neuronal. A cada identidad única se le asignará una
neurona de salida. Cuando las imágenes se presentan a la red neuronal
más adelante, la neurona de salida con la salida más alta representará la
identidad de la imagen a la red. El método AssignIdentity es un método
simple que asigna este recuento creciente y asigna las cadenas de
identidad a su índice de neuronas.
int i d x = A s s i g n I d e n t i t y ( i d e n t i t y ) ;
En este punto no queremos cargar las imágenes individuales.

Simplemente tomaremos nota de la imagen guardando un objeto
ImagePair. El objeto ImagePair vincula la imagen a su número de índice
de neuronas de salida. La clase ImagePair no está incorporada en Encog.
Más bien, es una estructura usada por este ejemplo para mapear las
imágenes.
i m a g e L i s t . Add(new ImagePair ( image , i d x ) ) ;
Finalmente, mostramos un mensaje que nos dice que la imagen ha sido

agregada.
app . WriteLine ( ”Added i n p u t image : ” + image ) ;
Una vez que todas las imágenes se agregan, el número de neuronas de
salida es aparente y podemos crear la red neuronal real. La creación de la
red neuronal se explica en la siguiente sección.
9.4.3 Creación de la red

El comando Network se implementa mediante el método ProcessInput.
Este método se muestra aquí.
private void ProcessNetwork ( )
{
Empiece por reducir el tamaño de las imágenes. Loop sobre cada

ImagePair creado previamente.
app . WriteLine ( ” Downsampling images . . . ” ) ; f o r
e a c h ( ImagePair p a i r i n i m a g e L i s t )
{
Cree un nuevo BasicMLData para mantener la salida ideal para cada

neurona de salida.
IMLData i d e a l = new BasicMLData ( outputCount ) ;
La neurona de salida que corresponde a la identidad de la imagen que se

está formando actualmente se establecerá en 1. Todas las demás
neuronas de salida se establecerán en -1.
int i d x = pair.Identity;
for ( int i = 0 ; i < outputCount ; i ++)
{
if (i == i d x )
{
i d e a l . Data [ i ] = 1 ;
}
else
{
i d e a l . Data [ i ] = −1;
}
}
Los datos de entrada para este elemento del conjunto de entrenamiento

serán la imagen con muestreo. Primero, cargamos la imagen en un objeto
Bitmap .Net. A continuación, creamos un objeto ImageMLData para
contener esta imagen y añadirla al conjunto de entrenamiento.
try
{
var img = new Bitmap ( p a i r . F i l e ) ;
var data = new ImageMLData ( img ) ;

t r a i n i n g . Add( data , i d e a l ) ;
}
catch ( Exception e )
{
app . WriteLine ( ” E r r o r l o a d i n g : ” + p a i r . F i l e
+ ” : ” + e . Message ) ;
}
Hay dos parámetros proporcionados al comando de red que especifican

el número de neuronas en cada una de las dos capas ocultas. Si la
segunda capa oculta no tiene neuronas, hay una sola capa oculta.
S t r i n g s t r H i d d e n 1 = GetArg ( ” hidden1 ” ) ;
S t r i n g s t r H i d d e n 2 = GetArg ( ” hidden2 ” ) ;
i f ( t r a i n i n g . Count == 0)
{
app . WriteLine ( ”No images to c r e a t e network f o r . ” ) ; return
;
}
int hidden1 = int . Parse ( s t r H i d d e n 1 ) ;
int hidden2 = int . Parse ( s t r H i d d e n 2 ) ;
Ahora estamos listos para downsample todas las imágenes.

t r a i n i n g . Downsample ( downsampleHeight , downsampleWidth ) ;
Por último, la nueva red neuronal se crea de acuerdo con los parámetros
especificados. El parámetro final verdadero especifica que nos gustaría
utilizar una función de activación tangente hiperbólica.
network = E n c o g U t i l i t y . SimpleFeedForward ( t r a i n i n g
. I n p u t S i z e , hidden1 , hidden2 ,
t r a i n i n g . I d e a l S i z e , true ) ;
Una vez que se crea la red, informe de su finalización imprimiendo un

mensaje.
app . WriteLine ( ” Created network : ” + network ) ;
Ahora que la red ha sido creada, puede ser entrenada. El entrenamiento
se trata en la siguiente sección.
9.4.4 Capacitación de la Red
El comando Train se implementa mediante el método ProcessTrain. Este
private void P r o c e s s T r a i n ( )
{
El comando de tren toma cuatro parámetros. Las siguientes líneas leen estos parámetros.
i f ( network == null )
return ;
S t r i n g strMode = GetArg ( ”mode” ) ;
S t r i n g s t r M i n u t e s = GetArg ( ” minutes ” ) ;
S t r i n g s t r S t r a t e g y E r r o r = GetArg ( ” s t r a t e g y e r r o r ” ) ;
S t r i n g s t r S t r a t e g y C y c l e s = GetArg ( ” s t r a t e g y c y c l e s ” ) ;
Una vez que se leen los parámetros, muestre un mensaje indicando que
el entrenamiento ha comenzado.
app . WriteLine ( ” T r a i n i n g Beginning . . . Output p a t t e r n s=” +
outputCount ) ;
Analice los dos parámetros de estrategia.

double s t r a t e g y E r r o r = double . Parse ( s t r S t r a t e g y E r r o r ) ;
int s t r a t e g y C y c l e s = int . Parse ( s t r S t r a t e g y C y c l e s ) ;
La red neural se inicializa a valores de peso y umbral aleatorios. Algunas

veces el conjunto aleatorio de pesos y umbrales hará que el entrenamiento de la
red neuronal se estanque. En esta situación, restablezca un nuevo conjunto de
valores aleatorios y comience a entrenar de nuevo.
La formación se inicia creando un nuevo entrenador ResilientPropagation.
El entrenamiento de RPROP fue cubierto en el Capítulo 5 "Entrenamiento de
Propagación".
var t r a i n = new R e s i l i e n t P r o p a g a t i o n ( network , training);
Encog permite agregar estrategias de entrenamiento para manejar situaciones

como esta. Una estrategia de formación particularmente útil es la ResetStrategy,
que toma dos parámetros. El primero indica el error mínimo que debe alcanzar la
red antes de que se restablezca automáticamente a nuevos valores aleatorios.
El segundo parámetro especifica el número de ciclos que la red puede alcanzar

esta tasa de error. Si se alcanza el número de ciclos especificado y la red no
está a la tasa de error requerida, los pesos y umbrales se asignarán al azar.
Encog apoya una serie de diferentes estrategias de entrenamiento.

Estrategias de capacitación mejoran cualquier método de entrenamiento en
uso. Ellos permiten ajustes menores a medida que avanza el entrenamiento.
Encog admite las siguientes estrategias:
Codicioso
• HybridStrategy
• ResetStrategy
• SmartLearningRate
• SmartMomentum
• StopTrainingStrategy
La estrategia Greedy solo permite que una iteración de entrenamiento

ahorre su peso y cambios de umbral si la tasa de error fue mejorada.
La HybridStrategy permite un método de entrenamiento de copia de
seguridad que se utilizará si el método de formación primaria se
estanca. La estrategia híbrida se explicó en el Capítulo 7 "Otros tipos
de redes neuronales". ResetStrategy restablece la red si se estanca.
Las estrategias SmartLearningRate y SmartMomentum se usan con el
entrenamiento de retropropagación para intentar ajustar
automáticamente el ímpetu y la velocidad de aprendizaje.
StopTrainingStrategy detiene el entrenamiento si ha alcanzado cierto
nivel.
Las siguientes líneas de código agregan una estrategia de

restablecimiento.
t r a i n . AddStrategy (new R e s e t S t r a t e g y ( s t r a t e g y E r r o r ,
strategyCycles));
Si estamos usando el GUI, entonces debemos usar TrainDialog, de lo
contrario deberíamos usar TrainConsole.
9.4 Ejemplo de reconocimiento de
imagen 165
i f ( S t r i n g . Compare ( strMode , ” g u i ” , true ) == 0)

{
E n c o g U t i l i t y . T r a i n D i a l o g ( t r a i n , network , training);
}
else
{
int minutes = int . Parse ( s t r M i n u t e s ) ;
E n c o g U t i l i t y . Tr ai nC on sol e ( t r a i n , network , t r a i n i n g ,
minutes ) ;
}
El programa indicará que el entrenamiento se ha detenido mostrando un

mensaje como el que se muestra a continuación. El proceso de formación se
detiene cuando se cancela mediante el diálogo o, en el caso del modo GUI,
se ha cancelado.
app . WriteLine ( ” T r a i n i n g Stopped . . . ” ) ;
Una vez entrenada la red neuronal, está lista para reconocer las imágenes.
Esto se discute en la siguiente sección.
9.4.5 Reconocimiento de imágenes
El comando WhatIs se implementa mediante el método ProcessWhatIs.
Este método se muestra aquí.
public void ProcessWhatIs ( )
{
El comando WhatIs toma un parámetro. Las siguientes líneas leen este

parámetro.
S t r i n g f i l e n a m e = GetArg ( ” image ” ) ;
La imagen se carga a continuación en un objeto ImageMLData.

try
{
var img = new Bitmap ( f i l e n a m e ) ; var
i n p u t = new ImageMLData ( img ) ;
La imagen se muestra por debajo de las dimensiones
correctas.
i n p u t . Downsample ( downsample , false , downsampleHeight ,

downsampleWidth , 1 , −1) ;
La imagen reducida es presentada a la red neuronal, que elige la neurona

"ganadora". La neurona ganadora es la neurona con mayor rendimiento
para el patrón que se presentó. Esto es simple "uno-de" la normalización
como se describe en el capítulo 2. El capítulo 2 también introdujo la
normalización equilátero, que también podría ser utilizado.
int winner = network . Winner ( i n p u t ) ;
app . WriteLine ( ”What i s : ” + f i l e n a m e + ” , i t seems to be : ” + n e u r o
n 2 i d e n t i t y [ winner ] ) ;
}
Finalmente, mostramos el patrón reconocido por la red neuronal.

Este ejemplo demostró un programa de reconocimiento de imágenes
basado en guiones. Esta aplicación podría utilizarse fácilmente como
punto de partida para otras aplicaciones de reconocimiento de imágenes
más avanzadas. Una extensión muy útil para esta aplicación puede ser la
capacidad de cargar y guardar la red neural entrenada.
9.5 Resumen
Este capítulo demostró cómo usar imágenes como entrada en Encog.
Casi cualquiera de los tipos de red neural discutidos en este libro puede
ser usado para reconocer imágenes. Las clases proporcionadas por
Encog procesan principalmente los datos de imagen en una forma que es
utilizable para una red neuronal, en lugar de definir la estructura real de la
red neuronal.
Las clases proporcionadas por Encog para el manejo de imágenes
proporcionan varias funciones muy importantes, incluyendo la detección
de límites y el muestreo.
La detección de límites es el proceso que recorta partes sin importancia
de una imagen. Encog admite verificación de límites simples donde se puede
eliminar un fondo de un color coherente.
9.5 Resumen 167
Esto evita que un objeto dentro de la imagen de entrada impida la
capacidad de la red neural para reconocer la imagen. Si se utiliza la
detección de límites, no debería importar si la imagen a reconocer está en la
esquina superior izquierda o inferior derecha.
El downsampling es el proceso donde la resolución de una imagen es
disminuida. Las imágenes pueden ser muy de alta resolución ya menudo
consisten en una gran cantidad de color. Encog proporciona un
downsampling para tratar ambos problemas. Las imágenes pueden reducirse
a una resolución mucho menor para reducir el número de neuronas de
entrada. El downsampling también puede descartar la información de color y
tratar sólo con la intensidad.
En este libro hemos examinado una serie de diferentes tipos de redes
neuronales. Este capítulo mostró cómo las redes neuronales de feedforward
se pueden aplicar a las imágenes. El mapa de auto-organización (SOM) es
otro tipo de red neural frecuentemente usado con imágenes. En el próximo
capítulo veremos el SOM.
169
Capitulo 10
Uso de un mapa de
autoorganización
• ¿Qué es un mapa de auto-organización (SOM)?
• Mapeo de colores con un SOM
• Formación de un SOM
• Aplicación del SOM a los datos de la cubierta forestal
Este capítulo se centra en el uso de Encog para implementar un mapa de

auto-organización (SOM). Un SOM es un tipo especial de red neuronal
que clasifica los datos. Normalmente, un SOM asignará datos de mayor
resolución a una salida única o multidimensional. Esto puede ayudar a
una red neuronal a ver las similitudes entre sus datos de entrada. El Dr.
Teuvo Kohonen de la Academia de Finlandia creó el SOM. Debido a esto,
la SOM a veces se llama una red neural de Kohonen.
Encog proporciona dos medios diferentes para la formación de redes SOM:

• Entrenamiento Competitivo de Vecindario
• Copia de clúster
Ambos tipos de entrenamiento son sin supervisión. Esto significa que no se

proporcionan datos ideales. La red se da simplemente los datos y el número
de categorías
170 Using a Self-Organizing Map
en las que los datos deben agruparse. Durante el entrenamiento, el SOM

agrupará todos los datos de entrenamiento. Además, el SOM será capaz de
agrupar nuevos datos sin recapacitación.
El método de entrenamiento competitivo del vecindario implementa el
modelo de entrenamiento SOM clásico. El SOM es entrenado usando un
algoritmo de entrenamiento competitivo, sin supervisión. Encog implementa este
algoritmo de entrenamiento utilizando la clase Ba-sicTrainSOM. Este es un tipo
completamente diferente de entrenamiento, entonces aquellos usados
anteriormente en este libro. El SOM no utiliza un conjunto de entrenamiento ni
un objeto de puntuación. No hay objetivos claramente definidos proporcionados
a la red neuronal en absoluto. El único tipo de "objetivo" que tiene la SOM es
agrupar entradas similares.
El segundo tipo de formación proporcionado por Encog es una copia en
clúster. Este es un método de entrenamiento muy simple que simplemente
establece los pesos en un patrón para acelerar el entrenamiento competitivo del
vecindario. Este método de entrenamiento también puede ser útil con un
pequeño conjunto de entrenamiento donde el número de elementos del conjunto
de entrenamiento coincide exactamente con el número de grupos. El método de
formación de copias de clúster se implementa en la clase
SOMClusterCopyTraining.
El primer ejemplo de este capítulo tomará los colores como entrada y
correlacionará colores similares. Este programa de ejemplo GUI mostrará
visualmente cómo los colores similares se agrupan por el mapa de auto-
organización.
La salida de un mapa de auto-organización es topológica. Esta salida se
suele ver de una manera n-dimensional. A menudo, la salida es de una sola
dimensión, pero también puede ser bidimensional, tridimensional, incluso de
cuatro dimensiones o superior. Esto significa que la "posición" de las neuronas
de salida es importante. Si dos neuronas de salida están más cerca unas de
otras, serán entrenadas juntas más que dos neuronas que no están tan cerca.
Todas las redes neurales que se examinaron hasta ahora en este libro no
han sido topológicas. En los ejemplos anteriores de este libro, la distancia entre
las neuronas no era importante. La neurona de salida número dos fue tan
significativa para la salida de la neurona número uno como la neurona de salida
número 100.
10.1 La Estructura y Formación de un SOM 171
10.1 La Estructura y Formación de un SOM

Un Encog SOM se implementa como una red neuronal de dos capas. El
SOM simplemente tiene una capa de entrada y una capa de salida. La capa
de entrada asigna los datos a la capa de salida. A medida que los patrones
se presentan a la capa de entrada, la neurona de salida con los pesos más
similares a la entrada se considera el ganador. Esta semejanza se calcula
comparando la distancia euclidiana entre ocho conjuntos de pesos y las
neuronas de entrada. La distancia euclidiana más corta gana. El cálculo de la
distancia euclidiana se trata en la siguiente sección.
No hay valores de sesgo en la SOM como en la red neuronal feedforward.

Por el contrario, sólo hay pesos de la capa de entrada a la capa de salida.
Además, sólo se utiliza una función de activación lineal.
10.1.1 Estructuración de una SOM

Estudiaremos cómo estructurar una SOM. Este SOM se dará varios
colores para entrenar. Estos colores se expresarán como vectores RGB.
Los valores individuales rojo, verde y azul pueden variar entre -1 y +1.
Donde -1 no es de color, o negro, y +1 es la intensidad total de rojo, verde
o azul. Estos componentes de tres colores comprenden la entrada de red
neuronal.
La salida es una red de 2.500 neuronas dispuestas en 50 filas por 50

columnas. Este SOM organizará colores similares cerca de cada uno en
esta rejilla de salida. La figura 10.1 muestra esta salida.
172 Uso de un mapa de autoorganización
Figura 10.1: La cuadrícula de salida
La figura anterior puede no ser tan clara en las ediciones en blanco y

negro de este libro como lo es en color. Sin embargo, puede ver colores
similares agrupados cerca uno del otro. Un solo SOM basado en color es
un ejemplo muy simple que le permite visualizar las capacidades de
agrupación de la SOM.
10.1.2 Capacitación de un SOM

¿Cómo se entrena una SOM? El proceso de entrenamiento actualizará
la matriz de pesos, que es de 3 x 2.500. Inicializar la matriz de pesos a
valores aleatorios para comenzar. Entonces 15 colores de entrenamiento
son elegidos al azar.
Al igual que en los ejemplos anteriores, el entrenamiento progresará a

través de una serie de iteraciones. Sin embargo, a diferencia de las redes
neuronales feedforward, las redes SOM suelen estar entrenadas con un
número fijo de iteraciones. Para el ejemplo de colores en este capítulo,
utilizaremos 1.000 iteraciones.
Comienza a entrenar la muestra de color que deseamos entrenar
eligiendo una muestra de color aleatoria por iteración. Elija una neurona
de salida cuyos pesos coincidan más estrechamente con el color de
entrenamiento base. El patrón de entrenamiento es un vector de tres
números. Los pesos entre cada una de las 2.500 neuronas de salida y las
tres neuronas de entrada son también un vector de tres números.
Calcular la distancia euclidiana entre el peso y el patrón de
entrenamiento. Ambos son un vector de tres números. Esto se hace con
la ecuación 10.1.
10.1 La Estructura y Formación de un SOM 173
v n 2
d(p, w) = (pi − wi) (10.1)
u
i=1
X
u
t
Esto es muy similar a la Ecuación 2.3, mostrada en el Capítulo 2. En la
ecuación anterior la variable p representa el patrón de entrada. La
variable w representa el vector de pesos. Al cuadrar las diferencias entre
cada componente vectorial y tomar la raíz cuadrada de la suma
resultante, realizamos la distancia euclidiana. Esto mide cómo diferente
cada vector de peso es del patrón de entrenamiento de entrada.
Esta distancia se calcula para cada neurona de salida. La neurona de
salida con la distancia más corta se denomina la mejor unidad de
coincidencia (BMU). La BMU es la neurona que aprenderá más del patrón
de entrenamiento. Los vecinos del BMU aprenderán menos. Ahora que se
determina una BMU, haga un bucle sobre todos los pesos de la matriz.
Actualizar cada peso de acuerdo con la ecuación 10.2.
Wv (t + 1) = Wv (t) + θ (v, t) α (t) (D (t) - Wv (t)) (10.2)
En la ecuación anterior, la variable t representa el tiempo, o el número
de iteración. El propósito de la ecuación es calcular el vector de peso
resultante Wv (t + 1). El siguiente peso se calculará sumando al peso
actual, que es Wv (t). El objetivo final es calcular cuán diferente es el peso
actual del vector de entrada. La cláusula D (T) -Wv (t) logra esto. Si
simplemente añadimos este valor al peso, el peso coincidiría exactamente
con el vector de entrada. No queremos hacer esto. Como resultado, lo
escalamos multiplicándolo por dos razones. La primera razón,
representada por theta, es la función de vecindad. La segunda razón es
una tasa de aprendizaje que disminuye monotónicamente.
La función de vecindad considera la proximidad de la neurona de

salida que estamos formando con la BMU. Para las neuronas más
cercanas, la función de vecindad estará próxima a una. Para vecinos
lejanos, la función de vecindad devolverá cero. Esto controla cómo los
vecinos cercanos y lejanos son entrenados. Veremos cómo la función de
vecindad lo determina en la siguiente sección.
La tasa de aprendizaje también escala cuánto aprenderá la neurona de

salida. Esta tasa de aprendizaje es similar a la tasa de aprendizaje utilizada
en el entrenamiento de backpropagation. Sin embargo, la tasa de
aprendizaje debe disminuir a medida que progresa la capacitación. Esta tasa
de aprendizaje debe disminuir monótonamente, lo que significa que la
función de salida sólo disminuye o permanece igual que el tiempo avanza. La
salida de la función nunca aumentará en ningún intervalo con el tiempo.
10.1.3 Descripción de las funciones de vecindario
La función de vecindad determina en qué grado cada neurona de salida
debe recibir entrenamiento a partir del patrón de entrenamiento actual. La
función de vecindad devolverá un valor de uno para la BMU. Esto indica
que debería recibir la mayor cantidad de entrenamiento de cualquier
neurona. Las neuronas más alejadas de la BMU recibirán menos
entrenamiento. La función de vecindad determina este porcentaje.
Si la salida está dispuesta en una sola dimensión, debe usarse una
función de vecindad unidimensional simple. Un mapa de auto-
organización de una sola dimensión trata la salida como una larga serie
de números. Por ejemplo, una red de una sola dimensión puede tener
100 neuronas de salida que se tratan simplemente como una matriz de
dimensión única larga de 100 valores.
Una SOM bidimensional puede tomar estos mismos 100 valores y
tratarlos como una cuadrícula, tal vez de 10 filas y 10 columnas. La
estructura actual sigue siendo la misma; La red neuronal tiene 100
neuronas de salida. La única diferencia es la función de vecindad. La
primera utilizaría una función de vecindad unidimensional; El segundo
utilizaría una función de vecindad bidimensional. La función debe
considerar esta dimensión adicional y factorizarla en la distancia devuelta.
También es posible tener tres, cuatro y aún más funciones dimensionales
para la función de vecindad. Dos dimensiones es la opción más popular.
Las funciones de vecindad unidimensional también son algo comunes.
Tres o más dimensiones son más inusuales. Realmente se reduce a
calcular cuántas maneras una neurona de salida puede estar cerca de
otra. Encog admite cualquier número de dimensiones, aunque cada
dimensión adicional agrega mucho a la cantidad de memoria y potencia
de procesamiento necesaria.
La función gaussiana es una opción popular para una función de
vecindario.
10.1 The Structure and Training of a SOM 175
La función gaussiana tiene formas únicas y multidimensionales.
La función de Gauss de la dimensión se muestra en la ecuación The single-
10.3.
2
(x−b)
−
f(x) = ae 2c2 (10.3)
La gráfica de la función gaussiana se muestra en la figura
10.2.
Figura 10.2: Función Gaussiana Unidimensional
La figura anterior muestra por qué la función gaussiana es una opción

popular para una función de vecindario. Si la neurona de salida actual es
la BMU, entonces su distancia (eje x) será cero. Como resultado, el
porcentaje de entrenamiento (eje y) es 100%. A medida que la distancia
aumenta ya sea positiva o negativamente, el porcentaje de entrenamiento
disminuye. Una vez que la distancia es lo suficientemente grande, el
porcentaje de entrenamiento es cercano a cero.
Hay varias constantes en la ecuación 10.3 que gobiernan la forma de

la función gaussiana. Las constantes a son la altura del pico de la curva, b
es la posición del centro del pico, yc constantes el ancho de la
"campana". La variable x representa la distancia que la neurona actual es
de la BMU.
La función gaussiana anterior sólo es útil para una matriz de salida

unidimensional. Si se utiliza una rejilla de salida bidimensional, es
importante utilizar la forma bidimensional de la función gaussiana. La
ecuación 10.4 muestra esto.
−
f(x, y) = Ae 2σx 2σy (10.4)
2 2
(x−xo) + (y−yo)
2 2
La forma gráfica de la forma bidimensional de la función gaussiana se

muestra en la figura 10.3.
Figura 10.3: Función gaussiana bidimensional
La forma bidimensional de la función Gaussiana toma una sola variable

de pico, pero permite al usuario especificar valores separados para la
posición y el ancho de la curva. La ecuación no necesita ser simétrica.
¿Cómo se utilizan las constantes gaussianas con una red neuronal? El
pico es casi siempre uno. Para disminuir unilateralmente la eficacia de la
formación, el pico debe fijarse por debajo de uno. Sin embargo, esto es más
el papel de la tasa de aprendizaje. El centro es casi siempre cero para
centrar la curva en el origen. Si el centro es cambiado, entonces una neurona
que no sea la BMU recibiría el aprendizaje completo. Es poco probable que
alguna vez quieras hacer esto. Para un Gaussian multidimensional, fije todos
los centros a cero para realmente centrar la curva en el origen.
Esto deja la anchura de la función gaussiana. El ancho debe establecerse
en algo ligeramente menor que el ancho completo de la cuadrícula o matriz.
Entonces la anchura debe ser disminuida gradualmente. La anchura se debe
disminuir monotonically apenas como la tarifa de aprendizaje .
10.1.4 Forzar a un ganador
Una característica opcional para Encog SOM entrenamiento competitivo
es la capacidad de forzar a un ganador. De forma predeterminada, Encog
no obliga a un ganador. Sin embargo, esta característica puede habilitarse
para el entrenamiento de SOM. Forzar a un ganador tratará de asegurar
que cada neurona de salida esté ganando por lo menos una de las
muestras de entrenamiento. Esto puede causar una distribución más
uniforme de los ganadores. Sin embargo, también puede sesgar los datos
como algo "ingenieros" de la red neuronal. Debido a esto, se deshabilita
de forma predeterminada.
10.2 Implementación de los colores SOM en Encog 177
10.1.5 Calcular el error
En el entrenamiento de la propagación podríamos medir el éxito de
nuestro entrenamiento ex-amining el error actual de la red neuronal. En un
SOM no hay ningún error directo porque no hay salida esperada. Sin
embargo, la interfaz Encog IMLTrain ex-plantea una propiedad de error.
Esta propiedad devuelve una estimación del error SOM.
El error se define como la "peor" o la distancia euclídea más larga de
cualquier BMU. Este valor debe ser minimizado a medida que avanza el
aprendizaje. Esto da una aproximación general de lo bien que la SOM ha
sido entrenada.
10.2 Implementación de los colores SOM en
Encog
Ahora veremos cómo se implementa el SOM de color coincidente. El
formulario principal dibuja la pantalla GUI para el SOM a medida que
avanza. Esta clase relativamente simple puede ser como un proyecto
llamado SOMColors. Este ejemplo está contenido en la descarga del
núcleo Encog.
La función ConvertColor es muy importante. Convierte un doble que
contiene un rango de -1 a +1 en el intervalo de 0 a 255 que requiere un
componente RGB. Una red neural funciona mucho mejor con -1 a +1 que
0 a 255. Como resultado, esta normalización es necesaria. El método
ConvertColor se muestra aquí.
private int ConvertColor ( double d )
{
double r e s u l t = 128 ∗ d ;
r e s u l t += 1 2 8 ;
r e s u l t = Math . Min ( r e s u l t , 255) ;
r e s u l t = Math . Max( r e s u l t , 0) ;
return ( int ) r e s u l t ;
}
El número 128 es el punto medio entre 0 y 255. Multiplicamos el resultado
por 128 para llegar al rango correcto y luego sumamos 128 para divergir
desde el punto medio. Esto asegura que el resultado esté en el rango
apropiado.Utilizar el método ConvertColor es llamado por un temporizador
para pintar la pantalla.
La salida de esta función será un mapa de color de todos los pesos de
la red neuronal. Cada una de las 2.500 neuronas de salida se muestra
en una cuadrícula. Su color está determinado por el peso entre esa
neurona de salida y las tres neuronas de entrada. Estos tres pesos se
tratan como componentes de color RGB.
Comience haciendo un bucle a través de las 50 filas y columnas.
Graphics g = this . C r e a t e G r a p h i c s
( ) ; for ( int y = 0 ; y< HEIGHT; y++)
{
for ( int x = 0 ; x< WIDTH; x++)
{
Mientras que las neuronas de salida se muestran como una rejilla

bidimensional, todas ellas se almacenan como una matriz unidimensional.
Debemos calcular el índice unidimensional actual a partir de los valores
bidimensionales xey.
int i n d e x = ( y∗WIDTH)+x ;
Obtenemos los tres valores de peso de la matriz y utilizamos el método ConvertColor para
convertirlos a componentes RGB.
int red = ConvertColor ( this . network . Weights [ 0 , index]);
int g r e e n = ConvertColor ( this . network . Weights [ 1, i n d e x ] ) ;
int b l u e =ConvertColor ( this . network . Weights [ 2 , index]);
Estos tres componentes se utilizan para crear un nuevo objeto Color.

Color c = Color . FromArgb ( red , green , blue);
Brush brush = new S o l i d B r u s h ( c ) ;
Se muestra un rectángulo relleno para mostrar la neurona.

g . F i l l R e c t a n g l e ( brush , x ∗ CELL SIZE , y ∗ CELL SIZE ,
CELL SIZE , CELL SIZE ) ;
}
}
g.Dispose();
Una vez que los bucles completos, la matriz de peso completo se ha
mostrado a la pantalla.
10.2.1 Capacitación de la SOM de concordancia de colores

La clase BasicTrainSOM debe estar configurada para que la red
neuronal se capacite. Para ello, se requiere una función de vecindario.
Para este ejemplo, utilice la función vecindad de NeighborhoodGaussian.
Esta función de vecindario puede soportar una función de vecindad
gaussiana multidimensional. La siguiente línea de código crea esta
función de vecindad.
this . g a u s s i a n = new NeighborhoodRBF (RBFEnum. Gaussian , MapPanel .
WIDTH,
MapPanel .HEIGHT) ;
Este constructor crea una función de vecindad gaussiana bidimensional.

Los dos primeros parámetros especifican la altura y el ancho de la
cuadrícula.
Hay otros constructores que pueden crear funciones Gaussianas de mayor
dimensión. Además, existen otras funciones de barrio proporcionadas por
Encog. El más común es el NeighborhoodRBF. NeighborhoodRBF
puede utilizar una función gaussiana, u otras funciones de base radial.
A continuación se muestra la lista completa de funciones de vecindario.
• NeighborhoodBubble
• NeighborhoodRBF
• NeighborhoodRBF1D
• BarrioSingle
El NeighborhoodBubble sólo proporciona funciones de barrio
unidimensionales. Se especifica un radio y cualquier cosa dentro de ese
radio recibe entrenamiento completo. El NeighborhoodSingle funciona como
una función de vecindad unidimensional y sólo permite que la BMU reciba
entrenamiento.
La clase NeighborhoodRBF admite varias funciones RBF. Las "RBFs" del
sombrero mexicano y del gaussiano son opciones comunes. Sin embargo el
Multiquadric y el Multiquadric Inverso también están disponibles.
También debemos crear un objeto BasicTrainSOM para hacer uso de la
función de vecindario.
this . t r a i n = new BasicTrainSOM ( this . network , 0 . 0 1 , null , g a u s s i a n )

;
El primer parámetro especifica la red a entrenar y el segundo parámetro es la

tasa de aprendizaje. Disminuya automáticamente la tasa de aprendizaje de un
valor máximo a un valor mínimo, por lo que la tasa de aprendizaje especificada
aquí no es importante. El tercer parámetro es el conjunto de entrenamiento.
Alimente de forma aleatoria colores a la red neuronal, eliminando así la
necesidad del conjunto de entrenamiento. Finalmente, el cuarto parámetro es la
función de barrio recién creada.
El entrenamiento SOM se proporciona para este ejemplo mediante un
temporizador. Esto permite que el entrenamiento progrese mientras el usuario
mira. El hilo de fondo se implementa en el constructor, como se muestra aquí.
El constructor comienza por crear los 15 colores aleatorios para entrenar la
red neuronal. Estas muestras aleatorias se almacenarán en la variable samples,
que es una Lista.
this . network = CreateNetwork ( ) ;
this . g a u s s i a n = new NeighborhoodRBF (RBFEnum. Gaussian , SOMColors .
WIDTH, SOMColors .HEIGHT) ;
this . t r a i n = new BasicTrainSOM ( this . network , 0 . 0 1 , null , g a u s
sian);
t r a i n . ForceWinner = f a l s e ;
samples = new L i s t <IMLData>() ;
Los colores aleatorios se generan y tienen números aleatorios para los

componentes RGB.
for ( int i = 0 ; i < 1 5 ; i ++)
{
IMLData data = new BasicMLData ( 3 ) ;
data . Data [ 0 ] = RangeRandomizer . Randomize ( −1 , 1) ;
samples . Add( data ) ;
}
La siguiente línea establece los parámetros para el decaimiento

automático de la tasa de aprendizaje y el radio.
this . t r a i n . SetAutoDecay ( 1 0 0 , 0 . 8 , 0 . 0 0 3 , 30 , 5) ;
Debemos proporcionar el número anticipado de iteraciones. Para este
ejemplo, la cantidad es 1.000. Para las redes neuronales SOM, es
necesario conocer el número de iteraciones de antemano. Esto difiere del
entrenamiento de propagación que se entrenó para una cantidad
específica de tiempo o hasta por debajo de una tasa de error específica.
Los parámetros 0.8 y 0.003 son las tasas de aprendizaje inicial y final. La
tasa de error se reducirá uniformemente de 0,8 a 0,003 en cada iteración.
Debe alcanzar cerca de 0.003 por la última iteración.
Del mismo modo, los parámetros 30 y 5 representan el principio y el final
de ra-dius. El radio comenzará a 30 y debe estar cerca de 5 por la
iteración final. Si se realizan más de 1.000 iteraciones planificadas, el
radio y la tasa de aprendizaje no caerán por debajo de sus mínimos. Para
cada iteración de aprendizaje competitivo, hay dos opciones. En primer
lugar, puede elegir simplemente proporcionar un MLDataSet que contiene
los datos de entrenamiento y llamar al método de iteración
BasicSOMTraining.
A continuación elegimos un índice de color aleatorio y obtenemos ese
color.
this . i t e r a t i o n ++;
i f ( this . i t e r a t i o n > 100)
this . updateTimer . Enabled = f a l s e ;
int i d x = ( int ) ( ThreadSafeRandom . NextDouble ( ) ∗ samples . Count ) ;
El método TrainPattern entrenará la red neuronal para este patrón de

color aleatorio. La BMU se ubicará y actualizará como se describió
anteriormente en este capítulo.
IMLData c = samples [ i d x ] ; this .
train.TrainPattern(c);
Como alternativa, los colores se podrían haber cargado en un objeto

IMLDataSet y el método de iteración podría haber sido utilizado. Sin
embargo, el entrenamiento de los patrones uno a la vez y usando un
patrón aleatorio se ve mejor cuando se muestra en la pantalla.
A continuación, llame al método AutoDecay para disminuir la
velocidad de aprendizaje y el radio de acuerdo con los parámetros
especificados anteriormente.
this . t r a i n . AutoDecay ( ) ;
Este proceso continúa durante 1.000 iteraciones. Por la iteración final, los
colores se agruparán.
10.3 Resumen
Hasta este punto en el libro, todas las redes neuronales han sido
entrenados utilizando un algoritmo de entrenamiento supervisado. Este
capítulo introdujo entrenamiento no supervisado. El entrenamiento no
supervisado no proporciona retroalimentación a la red neuronal como las
tasas de error previamente examinadas.
Un tipo de red neural muy común que se puede utilizar con el

entrenamiento sin supervisión es el mapa de auto-organización (SOM), o
la red neural de Kohonen. Este tipo de red neural sólo tiene una capa de
entrada y salida. Esta es una red neuronal competitiva; La neurona que
tiene el mayor rendimiento se considera la neurona ganadora.
Un SOM entrena tomando un patrón de entrada y viendo qué neurona

de salida tiene los valores de peso más cercanos a este patrón de
entrada. La neurona que coincide más cercana, llamada la mejor unidad
de adaptación (BMU) es entonces entrenada. Todas las neuronas vecinas
también son entrenadas. Las neuronas vecinas están determinadas por la
función de vecindad, así como el grado en que los vecinos son
entrenados. Las funciones de vecindario más utilizadas son variantes de
la función gaussiana.
Esto concluye este libro sobre la programación Encog. Encog es un

proyecto en constante evolución. Para obtener más información sobre los
proyectos Encog actuales y artículos adicionales sobre Encog, visite la
siguiente URL:
Http://www.encog.org/
Encog está muy formado por la entrada de sus usuarios. Nos

encantaría saber cómo está utilizando Encog y qué nuevas características
pueden ser beneficiosas también. Ningún producto de software, o libro, es
perfecto. Informes de errores también son muy. Hay un foro en la URL
anterior que se puede utilizar para la discusión de este libro y Encog.
10.3 Summary 183
185
Apendice A.
Instalación y uso de Encog
• Descargar Encog
• Ejemplos de Ejecución
• Ejecución del Workbench
Este apéndice muestra cómo instalar y usar Encog. Esto consiste en

descargar Encog desde el sitio Web Encog, instalar y luego ejecutar los
ejemplos. También se mostrará cómo ejecutar el Encog Workbench. Encog
se implementa en Microsoft Visual C #. Para hacer uso de Encog usted
tendrá que tener Microsoft Visual Studio instalado en su sistema. Una edición
gratuita de Microsoft Visual Studio está disponible en la siguiente URL.
Http://www.microsoft.com/visualstudio/en-us/products/2010-editions/ express
Los ejemplos de este libro se probaron con Microsoft Visual Studio 2010.
Estos ejemplos deberían ser compatibles con versiones anteriores. También
puede encontrar información útil sobre la configuración de Encog desde la
siguiente dirección web.
Http://www.heatonresearch.com/wiki/Encog_Examples
186 Instalación y uso de Encog
A.1 Instalando Encog

Siempre puede descargar la última versión de Encog desde la siguiente
URL:
Https://github.com/encog/encog-dotnet-core/downloads
En esta página, encontrará un enlace para descargar la última versión de

Encog y encontrar los siguientes archivos en el sitio de descarga de Encog:
• encog-dotnet-dll
• encog-dotnet-core
• encog-workbench
Para este libro, necesitará descargar los ejemplos y el workbench. El

banco de trabajo se distribuye como un JAR ejecutable universal. Debería
ser capaz de hacer doble clic en este archivo JAR en Windows, Linux o Mac.
Este archivo JAR, y algunos archivos de información, son todo lo que se
incluye con la versión de Workbench Encog.
Si sólo desea el Encog DLL, y no necesita el origen o ejemplos, puede

descargar el archivo encog-dotnet-dll. Sea cual sea la versión de Encog que
elijas, descarga y descomprime en un directorio.
Ahora que ha instalado Encog y Ant en su computadora, está listo para
compilar el núcleo y los ejemplos. Si sólo desea utilizar un IDE, puede
saltarse a esa sección en este apéndice.
A.2 Utilización de Encog Core y ejemplos

Esta sección le explicará qué hacer si decide descargar el paquete encog-
dotnet-core, que también incluye los ejemplos. La carpeta contenida en
este archivo contiene un espacio de trabajo completo de Visual Studio
2010. Simplemente haga doble clic en el archivo encog-core-cs.sln. Esto
abrirá el espacio de trabajo. Debería ver la Figura A.1.
A.2 Utilización de Encog Core y ejemplos 187
Figura A.1: Encog Core en Visual Studio
Lo primero que debe hacer es hacer clic con el botón derecho en la

solución, que es la raíz del árbol, y elegir "Rebuild Solution". Toda la
solución Encog debería reconstruirse sin errores. En este momento ya
está listo para ejecutar ejemplos.
Antes de ejecutar los ejemplos permite examinar los proyectos
contenidos en el espacio de trabajo anterior. Estos proyectos se
enumeran aquí.
• ConsoleExamples
• encog-core-cs
• encog-core-test
• EncogCmd
• OCR
• SOMColors
El proyecto principal se llama encog-core-cs. Aquí es donde reside el
actual framework Encog DLL. ConsoleExamples es una aplicación que
contiene todos los ejemplos de consola. Además, OCR y SOMColors son
ejemplos de GUI. El proyecto EncogCmd se utiliza para crear EncogCmd,
que es una interfaz de línea de comandos para Encog.
También debe notar en la Figura A.1 que uno de los proyectos está en
negrita. Este es el "Proyecto de Inicio".
Puede hacer clic con el botón secundario del mouse en cualquiera de los
proyectos y hacer que el proyecto "Inicio". Simplemente haga clic con el
botón derecho en un proyecto y seleccione "Establecer como proyecto de
inicio". Esto sólo puede hacerse en proyectos que sean ejecutables. No
puede establecer Encog Core como el proyecto de inicio, esto es porque
Encog Core es una DLL, y no se puede ejecutar por sí mismo.
Ahora vamos a dar un ejemplo. Asegúrese de que ConsoleExamples es
el "Proyecto de inicio". Para ejecutar uno de los ejemplos, debe ejecutar el
proyecto Con-soleExamples. Para ello, haga clic con el botón secundario en
ConsoleExamples y seleccione las propiedades del proyecto. Elija la ficha de
depuración de las propiedades del proyecto y verá la Figura A.2.
Figura A.2: Configuración de las propiedades del proyecto
Observe los argumentos de línea de comandos anteriores? En este

momento sólo la opción de la -pausa está allí. Es posible que su ajuste
sea diferente. Si lo es, escriba -pause para el argumento de la línea de
comandos. Esto le indica al ejemplo que haga una pausa antes de que
salga. Esto le permite ver la salida en la pantalla. Esto producirá la salida
vista en el Listado A.1.
Listado A.1: Ejemplos de consola
Must s p e c i f y the example to run as the f i r s t argument
The f o l l o w i n g commands a r e a v a i l a b l e :
adalinedigits : ADALINE D i g i t s
analyst : Encog Analyst
art1 −c l a s s i f y : C l a s s i f y P a t t e r n s with ART1
bam : B i d i r e c t i o n a l A s s o c i a t i v e Memory
benchmark : Perform an Encog benchmark .
benchmark−e l l i o t t : Perform a benchmark o f the E l l i o t t
activation function.
benchmark−s i m p l e : Perform a s i m p l e Encog benchmark .
A.2 Utilización de Encog Core y
ejemplos 189
cpn : Counter Pr opagat ion Neural Network (CPN)

CSVPredict : CSVPredict
encoder : A Fahlman e n c o d e r .
forest : F o r e s t Cover
h o p f i e l d −a s s o c i a t e : H o p f i e l d A s s o c i a t e s P a t t e r n s
h o p f i e l d −s i m p l e : H o p f i e l d R e c o g n i z e Simple P a t t e r n s
image : Image Neural Networks
lander : Train a n e u r a l network to land a s p a c e s h i p .
market : Simple Market P r e d i c t i o n
multibench : M u l t i t h r e a d i n g Benchmark
n o r m a l i z e −f i l e : Normalize a f i l e .
n o r m a l i z e −s i m p l e : Simple n o r m a l i z e example .
p e r s i s t −encog : P e r s i s t using . Net S e r i a l i z a t i o n
p e r s i s t −s e r i a l : P e r s i s t using . Net S e r i a l i z a t i o n
Prunate : Prunes network
r a d i a l −m u l t i : A RBF network example .
Range : Analyzes r a n g e s and p r e d i c t s them .
sunspot : Predict sunspots.
SVM : Random Makes a s m a l l SVM random t r a i n e r .
SVMCSV : SVMCSV
threadcount : Evaluate Thread Count Performance
tsp−a n n e a l : Annealing T r a v e l i n g Salesman
tsp−boltzmann : Boltzmann Machine for the T r a v e l i n g Salesman
(TSP)
tsp−g e n e t i c : G e n e t i c Algorithm T r a v e l i n g Salesman
weight−i n i t : weight I n i t i a l i z e r s
xor : Simple XOR with backprop , no f a c t o r i e s or
helper functions
.
xor−elman : Elman Temporal XOR
xor−f a c t o r y : Use XOR with many d i f f e r e n t t r a i n i n g and
network t y p e s .
xor−j o r d a n : Jordan Temporal XOR
xor−neat : Simple XOR with NEAT.
P r e s s ENTER to continue .
Es importante tener en cuenta que puede tener más ejemplos que los
enumerados anteriormente. Los ejemplos se agregan frecuentemente a Encog.
Ahora ejecutaremos uno de los ejemplos y observaremos la salida. Observe el
ejemplo XOR anterior? Lo ejecutaremos. Para ejecutar XOR, ejecutaremos el
siguiente comando.
ConsoleExamples −pause xor
190 Installing and Using Encog
Introduzca -párese xor en los argumentos de la línea de comandos

mostrados en la Figura A.2. No es necesario que entre en la parte
ConsoleExamples, como está implícito. Una vez que se ejecute el
ejemplo XOR, verá la salida en el listado A.2.
Listado A.2: El Ejemplo XOR
Epoch #1 E r r o r : 0 . 3 2 0 3 5 7 5 6 7 2 4 0 0 6 7
Epoch #2 E r r o r : 0 . 2 8 9 7 1 5 6 9 7 3 8 6 7 8
Epoch #3 E r r o r : 0 . 2 6 4 0 7 7 1 9 3 2 6 5 7 2
Epoch #4 E r r o r : 0 . 2 5 5 1 2 5 6 0 7 2 8 0 2 3 7
Epoch #5 E r r o r : 0 . 2 6 1 7 7 4 2 1 3 4 1 5 6 4 3
Epoch #6 E r r o r : 0 . 2 5 3 8 1 1 5 9 0 2 0 4 9 4 9
Epoch #7 E r r o r : 0 . 2 5 4 0 7 6 4 9 9 7 4 7 1 4 1
Epoch #8 E r r o r : 0 . 2 5 2 9 9 8 3 7 9 3 9 4 3 2 6
Epoch #9 E r r o r : 0 . 2 5 1 2 2 5 0 1 4 9 5 2 6 1 1
Epoch #10 E r r o r : 0 . 2 5 1 3 3 8 1 8 7 2 4 8 2 9 1
Epoch #11 E r r o r : 0 . 2 4 9 6 5 4 2 7 6 6 5 8 5 9 8
...
Epoch #70 E r r o r : 0 . 0 2 4 1 5 3 1 1 8 2 5 4 0 4 3
Epoch #71 E r r o r : 0 . 0 2 3 2 5 0 5 9 9 4 5 1 1 5 6 7
Epoch #72 E r r o r : 0 . 0 2 1 6 3 9 4 6 9 5 1 5 8 5 8 2
Epoch #73 E r r o r : 0 . 0 1 9 9 2 7 3 9 4 0 8 7 3 5 3 5
Epoch #74 E r r o r : 0 . 0 1 8 4 6 7 4 4 4 1 2 3 3 8 8 8
Epoch #75 E r r o r : 0 . 0 1 6 6 2 5 3 4 0 0 7 3 4 4 0 8
Epoch #76 E r r o r : 0 . 0 1 4 7 3 5 3 8 9 1 3 8 5 8 3 9
Epoch #77 E r r o r : 0 . 0 1 2 8 6 6 0 2 1 4 2 2 3 1 1
Epoch #78 E r r o r : 0 . 0 1 1 0 6 5 1 8 5 3 4 7 2 6 3 3
Epoch #79 E r r o r : 0 . 0 0 9 4 2 7 8 6 2 0 9 2 0 4 5 5 3
0 , 0 , a c t u a l =0.0720130552173676 , i d e a l =0
1 , 0 , a c t u a l =0.942075872671672 , i d e a l =1
0 , 1 , a c t u a l =0.936602583023402 , i d e a l =1
1 , 1 , a c t u a l =0.207851658452473 , i d e a l =0
P r e s s ENTER to continue .
Como puede ver, el ejemplo aprendió a reconocer la función XOR. Otras
partes del libro explicarán XOR y redes neuronales con mayor detalle. Por
ahora, sólo estamos asegurando que usted puede ejecutar el ejemplo.
A.3 Utilizar el DLL Encog en su propia aplicación 191
A.3 Utilizar el DLL Encog en su propia

aplicación
En esta última sección usted vio cómo hacer uso de los ejemplos de
Encog. Inusualmente, usted querrá crear su propia aplicación que hace uso
de Encog. Esto es muy fácil de hacer. Simplemente agregue el Encog DLL
como una referencia a su propia aplicación. En esta sección, veremos los
pasos para hacer precisamente eso. Verá cómo crear una aplicación XOR
similar a lo que vio en la última sección. Puede ver la aplicación "XOR Hello
World" en la siguiente URL.
Http://www.heatonresearch.com/wiki/Hello_World
Comience lanzando Visual Studio y elija crear una "aplicación de
consola". Puedes nombrar el proyecto como quieras, yo elijo HelloWorld.
Seleccione "Archivo-> Guardar todo" y guarde su proyecto, esto establecerá
la ubicación de su carpeta de proyecto. Vea la Figura A.3.
Figura A.3: Aplicación Hello World
Utilizando el Explorador de Windows, copie la DLL Encog en la misma

carpeta que su carpeta de proyecto. Este DLL tendrá un nombre de encog-
core-cs.dll, o similar. Una vez hecho esto, debe agregarlo como referencia.
Para ello, haga clic con el botón derecho en la carpeta Referencias que se
muestra en la Figura A.3. Elija "Agregar referencia ..." en el menú esplegable.
Elija la pestaña Examinar y busque la DLL que acaba de copiar. Esto
asociará Encog con su proyecto.
Copie el código del listado A.3 dentro del archivo Program1.cs que se
muestra en la figura A.3.
Listado A.3: Hello World XOR

using System ;
using System . C o l l e c t i o n s . G e n e r
i c ; using System . Linq ;
using System . Text ;
using Encog . Neural . Networks ;
using Encog . Neural . Networks . Layers ; using
Encog . Engine . Network . A c t i v a t i o n ; using
Encog .ML. Data ;
using Encog . Neural . Networks . T r a i n i n g . P ropaga tion . R e s i l i e n
t ; using Encog .ML. Train ;
using Encog .ML. Data . B a s i c ;
namespace C o n s o l e A p p l i c a t i o n 1
{
public c l a s s Program
{
/// <summary>
/// I n p u t f o r t h e XOR f u n c t i o n .
/// </summary>
public s t a t i c double [ ] [ ] XORInput = {
new [ ] {0 . 0 , 0 . 0 } ,
new [ ] {1 . 0 , 0 . 0 } ,
new [ ] {0 . 0 , 1 . 0 } ,
new [ ] {1 . 0 , 1 . 0 }
};
/// <summary>
/// I d e a l o u t p u t f o r t h e XOR f u n c t i o n .
/// </summary>
public s t a t i c double [ ] [ ] XORIdeal = {
new [ ] {0 . 0 } ,
new [ ] {1 . 0 } ,
new [ ] {1 . 0 } ,
new [ ] {0 . 0 }
};
s t a t i c void Main ( string [ ] args)
{
// c r e a t e a n e u r a l network , w i t h o u t u s i n g a f a c t o r y
network . AddLayer (new B a s i c L a y e r ( null , true , 2) ) ;
network . AddLayer (new B a s i c L a y e r (new A c t i v a t i o n S i g m o i d ( ) ,
A.3 Utilizar el DLL Encog en su propia aplicación 193
true , 3) ) ;
network . AddLayer (new B a s i c L a y e r (new A c t i v a t i o n S i g m o i d ( ) ,
false , 1) ) ;
// c r e a t e t r a i n i n g d a t a
IMLDataSet t r a i n i n g S e t = new BasicMLDataSet ( XORInput ,
XORIdeal ) ;
// t r a i n t h e n e u r a l network
IMLTrain t r a i n = new R e s i l i e n t P r o p a g a t i o n ( network ,
trainingSet);
int epoch = 1 ;
do
{
train.Iteration();
Console . WriteLine (@” Epoch #” + epoch + @” E r r o r : ” + t r a i n .
Error);
epoch++;
} while ( t r a i n . E r r o r > 0 . 0 1 ) ;
// t e s t t h e n e u r a l network
Console . WriteLine (@” Neural Network R e s u l t s : ” ) ;
foreach ( IMLDataPair p a i r in t r a i n i n g S e t )
{
IMLData output = network . Compute ( p a i r . Input ) ;
Console . WriteLine ( p a i r . Input [ 0 ] + @” , ” + p a i r . Input [ 1 ]
+ @” , a c t u a l=” + output [ 0 ] + @” , i d e a l=” + p a i r . I d e a l [ 0 ] ) ;
}
}
}
}
Porque agregó Encog como una referencia, que el código anterior no
debería producir ningún error. Puede ejecutar este programa de ejemplo
haciendo clic en el botón Ejecutar en Visual Studio.
195
Glosario
Función de activación: Función utilizada para escalar la salida de una

capa de red neuronal. Si esta función de activación tiene una derivada,
entonces el entrenamiento de propagación puede usarse en la red
neuronal.
Teoría de Resonancia Adaptativa (ART1): Una arquitectura de red
neural que aprende a clasificar los patrones a medida que se presentan.
Ciclos de recocido: El número de ciclos que usará el método de
entrenamiento de recocido simulado por iteración.
Inteligencia Artificial (IA): Una rama de la informática que busca dar a
las máquinas inteligencia humana. Las redes neuronales son una
herramienta utilizada en la IA.
Red Neural Artificial (ANN): Vea la red neural.
Autoassociación: Un medio de reconocimiento de patrones en el que
la salida de la red neural es el patrón completo que reconoce. La red
devuelve los mismos datos con los que fue entrenada.
Backpropagation: Un algoritmo de propagación donde los gradientes
de error se aplican directamente a la matriz de peso, escalado sólo por
una tasa de aprendizaje.
Backward Pass: Una de las dos pasadas en el entrenamiento de
propagación donde los gradientes de error se calculan y utilizan para
determinar los cambios que deben hacerse a la matriz de peso de una red
neuronal.
Capa básica: Un tipo de capa de red neuronal Encog muy versátil que
se utiliza en muchas redes neuronales diferentes. Tiene un número de
neuronas, una función de activación y valores de umbral opcionales.
Entrenamiento por lotes: La acumulación de los deltas de la matriz de
pesos de un número de elementos del conjunto de entrenamiento antes
de que estos deltas se apliquen realmente a la matriz de peso.
196 Glosario
La mejor unidad de concordancia (BMU): La neurona, en un mapa de

autoorganización (SOM), que tenía la distancia euclídea más corta al
elemento de datos de entrenamiento. (BMU)
Memoria asociativa bidireccional: Tipo de red neural que forma
asociaciones bidireccionales entre dos capas.
Red Neural Biológica: La red neural real contenida en seres humanos y
otros animales. Esto es lo que una red neural artificial intenta simular
hasta cierto punto.
BiPolar: Activación Función: Una función de activación para soportar
números bipolares. Esto asigna un valor verdadero a 1 y un valor falso a
-1.
Black Box: Un sistema informático donde las entradas y salidas son bien
comprendidas; Sin embargo, los medios para producir la salida no se
conocen.
Máquina de Boltzmann: Una simple red neuronal recurrente que añade
un elemento de temperatura que aleatoriza la salida de la red neuronal.
Bounding Box: Una caja que se dibuja alrededor de la parte relevante de
una imagen.
Función de activación competitiva: Una función de activación en la que
sólo se permite que un determinado número de neuronas disparen. Estas
neuronas ganadoras fueron las que tuvieron la mayor activación.
Entrenamiento Competitivo: Es un método de entrenamiento, usualmente
usado por un Mapa de Organización de Auto, que elige una unidad de mejor
adaptación (BMU) y fortalece aún más la activación de esa neurona para el
elemento de entrenamiento actual.
Capa de contexto: un tipo de capa Encog que recuerda los valores de
entrada de la última iteración y los utiliza como salida para la iteración actual.
Este tipo de capa se utiliza para tipos de redes neuronales simples y
recurrentes, como las redes neuronales Elman y Jordan.
Red Neural de Contra-Propagación: Una red neural híbrida que combina
elementos de una red neuronal de feedforward regular y un Mapa de
Auto-Organigrama. Las Redes Neuronales de Contra-Propagación usan
entrenamiento supervisado y no controlado, que se llaman outstar e instar
training respectivamente. (CPN)
Cultivo: Proceso en el que se eliminan porciones irrelevantes de una
imagen. Crossover:
197
Una simulación del proceso de apareamiento biológico en un Al-Gorithm

Genético donde los elementos de dos soluciones "originales" se
combinan para producir "soluciones de primavera" que comparten
características de ambos "padres".
Archivo CSV: un archivo de valores separados por comas. Éstos se
utilizan típicamente como entrada del entrenamiento para una red neural
de Encog.
Derivada: En el cálculo, una medida de cómo una función cambia a
medida que su entrada cambia. El entrenamiento de propagación usa la
derivada de la función de activación para calcular un gradiente de error.
Sinapsis directa: Una sinapsis Encog que conecta directamente dos
capas de neuronas. Este tipo de capa se usa típicamente en una red
neuronal de Función de Base Radial.
Downsample: Proceso en el que se reduce la resolución y la profundidad
de color de una imagen. Esto puede hacer que la imagen sea más fácil
de reconocer para una red neuronal.
Archivo EG: Archivo XML que Encog utiliza para almacenar redes
neuronales, datos de entrenamiento y otros objetos.
Elman Neural Network: Una simple red neuronal recurrente donde la
salida de la capa oculta es alimentada a una capa de contexto y luego
devuelta a la capa oculta. La Red Neural Elman puede ser útil para datos
temporales.
Encog: Un Framework de Inteligencia Artificial para Java, .Net y Silverlight
que se especializa en aplicaciones de redes neuronales.
Encog Benchmark: Un medio de calcular el rendimiento de Encog en una
máquina en particular. El punto de referencia se expresa como un
número; Un número más bajo indica una máquina más rápida. Este punto
de referencia utiliza entrenamiento multiproceso y anotará máquinas
multicore más altas.
Encog File: Vea el archivo EG.
Encog Workbench: Una aplicación GUI que permite editar archivos de

Encog EG.
Temperatura de finalización: La temperatura a la que debe finalizar una

iteración de recocido simulada. La temperatura define el grado en el que
los pesos son perturbados aleatoriamente en un ciclo de recocido
simulado.
Época: Véase la iteración.
Equilateral Normalization:
198 Glossary
Un medio por el cual los datos nominales son normalizados para una
red neuronal. A menudo proporciona mejores resultados que la
normalización competidora de uno-de-n.
Equilibrio: El punto en el cual las iteraciones adicionales a una red
neural térmica no producen ningún cambio significativo adicional.
Error Rate: El grado en que la salida de la red neural difiere de la
salida esperada.
Distancia euclidiana: La raíz cuadrada de los cuadrados de las
diferencias individuales en conjunto de datos. La distancia euclidiana se
utiliza a menudo para determinar qué vector es más similar a un vector de
comparación.
Evaluación: Es el proceso en el que se evalúa una red neuronal
entrenada en comparación con datos que no estaban en el grupo de
entrenamiento original.
Red neuronal Feedforward: Una red neuronal multicapa donde las
conexiones sólo fluyen hacia adelante.
Grupo de campos: Grupo de campos de salida de normalización que
dependen entre sí para calcular el valor de salida.
Forward Pass: Una de las dos pasadas en el entrenamiento de
propagación donde la salida de la red neuronal se calcula para un
elemento de entrenamiento.
Ventana del futuro: Los datos que una red neural temporal está
intentando predecir.
Gaussian Activation Function: Una activación basada en la función
gaussiana.
Función de vecindad gaussiana: función de vecindad, utilizada para un
mapa de autoorganización, basada en la función gaussiana.
Algoritmos Genéticos: Algoritmo de Inteligencia Artificial que intenta
derivar una solución simulando el proceso biológico de la selección
natural.
Error de gradiente: un valor que se calcula para conexiones
individuales en la red neuronal que puede proporcionar información sobre
cómo debe cambiarse el peso para reducir el error de la red neuronal.
Greedy Training: Una estrategia de entrenamiento donde se descartan
iteraciones que no disminuyen la tasa de error de una red neuronal.
Capa Oculta: Capas en una red neuronal que existe entre las capas de
entrada y salida.
199
Se utilizan para ayudar a la red neuronal en el reconocimiento de

patrones.
Red Neural de Hopfield: Una red neural termal que contiene una sola
capa autoconectada.
Entrenamiento híbrido: Formación de una red neuronal con más de un
algoritmo de entrenamiento.
Función de activación de la tangente hiperbólica: Función de
activación que hace uso de la función tangente hiperbólica. Esta función
de activación puede devolver tanto números positivos como negativos.
Salida Ideal: La salida esperada de una red neuronal.
Poda incremental: Un medio para determinar automáticamente un
número exacto de neuronas ocultas aumentando la capa oculta y
probando cada configuración potencial.
Campo de entrada: Un campo de normalización Encog que acepta
datos crudos no normalizados. Se proporcionan campos de entrada que
aceptan entradas de varias fuentes diferentes.
Capa de entrada: capa en una red neuronal que acepta entrada.
Instar Training: Técnica de entrenamiento no supervisada utilizada
para la red neural de contrapropagación.
Intensidad Downsample: Es una técnica de downsample donde se
descarta la información de color, y sólo se usa la intensidad o brillo de
color.
Iteración: La unidad básica de entrenamiento donde cada iteración
intenta mejorar la red neural de alguna manera.
Red Neural de Jordan: Red neuronal recurrente simple en la que la
salida de la capa de salida es alimentada a una capa de contexto y luego
devuelta a la capa oculta. La Red Neural de Jordania puede ser útil para
datos temporales.
Kohonen Neural Network: Otro nombre para el mapa de organización
personal (SOM).
Capa: Un grupo de neuronas similares en una red neuronal. Etiqueta
de capa: El medio por el cual Encog nombra capas.
Tasa de aprendizaje:
200 Glosario
El porcentaje de un cambio en la matriz de peso que se permite que

ocurra. Esto permite que los cambios que abruman la red neural sean
escalados a valores menos dramáticos.
Lesser GNU Public License (LGPL): Licencia bajo la cual Encog tiene
licencia.
Función de activación lineal: Función de activación basada en una

función lineal simple.
LOG Activación Función: Función de activación basada en logaritmos.

Memoria de largo plazo: Los pesos y valores de umbral de una red
neuronal.
Lunar Lander Juego: Un juego de ordenador clásico donde el usuario

dispara propulsores para producir un aterrizaje tan suave como sea
posible, sin quedarse sin combustible.
Regla de actualización de Manhattan: Técnica de entrenamiento de

propagación en la que sólo se utiliza el signo del gradiente de error para
determinar la dirección para cambiar los pesos de conexión. La magnitud
de los gradientes de error se descarta.
Recopilación de memoria: Encarga la persistencia donde se carga
todo el archivo EG en la memoria.
Momento: El grado en que los deltas de peso de la iteración

permeable se aplican a la iteración actual. Se utiliza en backpropagation
para ayudar a evitar mínimos locales.
Multicore: Una computadora capaz de ejecutar simultáneamente
múltiples subprocesos. El software debe escribirse para ser multiproceso
para utilizar estas máquinas a su máximo potencial.
Normalización Multiplicativa: Técnica de normalización para ajustar un
vector para sumar a uno. La normalización multiplicativa tiene el efecto de
sólo usar la magnitud del vector de entrada. Para utilizar el signo y la
magnitud, se debe considerar la normalización del eje z.
Multiproceso: Una técnica de programación en la que la tarea de

programación se divide entre múltiples subprocesos. Esto permite a una
máquina multinúcleo reducir en gran medida la cantidad de tiempo que un
programa puede tomar para ejecutarse.
Mutación: Una técnica utilizada en Algoritmos Genéticos donde la
primavera o ff se cambia al azar de alguna manera.
Función de barrio: Una función que escala el entrenamiento en un

mapa de organización de sí mismo a las neuronas cerca de la mejor
unidad de coincidencia.
201
Patrón de red: Un tipo de red neural común, como un mapa de

autoevaluación, una red de Elman o una red de Jordania. Encog
proporciona clases que ayudan en la creación de estos tipos de redes
neuronales.
Lógica Neural: Encog clases que muestran Encog cómo calcular la
salida de diversos tipos de redes neuronales.
Red Neural: Una simulación computarizada de una red neuronal

biológica real. A veces se denomina una Red Neural Artificial (ANN); Sin
embargo, se refiere típicamente como simplemente "una red neural".
Propiedades de Red Neural: Parámetros operativos que ciertos tipos
de redes neurales requieren que Encog se asocie a la red neuronal.
Valor nominal: Un valor que es un miembro de un conjunto, por

ejemplo, masculino o femenino.
Normalización: Proceso en el que los números se escalan para ser

entrada aceptable a una red neuronal.
Objetivo de normalización: donde las clases de normalización Encog

deben almacenar los resultados del valor de normalización.
Valor Numérico: Valor numérico que debe normalizarse y que tiene

significado como un número. Por ejemplo, la altitud sería un valor
numérico, pero un código postal no.
One-to-One Synapse: Una sinapsis Encog que conecta directamente
cada neurona en una capa con la neurona correspondiente en otra capa.
Una sinapsis de uno a uno se utiliza normalmente para conectar una capa
básica a una capa de contexto.
Normalización Uno-de-N: Un medio por el cual los datos nominales
son normalizados para una red neuronal. A menudo proporciona
resultados inferiores a los de la normalización equiparal.
Formación en línea: Entrenamiento donde los deltas de peso se
aplican tan pronto como se calculan.
Campo de salida: Campo de normalización que especifica cómo se

normaliza un campo de entrada o un grupo de campos de entrada.
Capa de salida: capa de una red neuronal que produce salida.
Formación Outstar: Técnica de entrenamiento supervisada utilizada

para la red neuronal de contrapropagación.
202 Glossary
Pasado Ventana: Los valores en los que una red neural temporal basa
las predicciones futuras.
Patrón: Datos que se alimentan en una red neuronal.
Persistencia: La capacidad de almacenar datos de forma permanente.

Encog utiliza archivos Encog EG para la persistencia.
Plasticidad: La capacidad de una red neuronal para cambiar a medida

que los datos se alimentan a ella.
Formación de Propagación: Un grupo de técnicas de entrenamiento

que usan grafos de error para proporcionar información sobre cómo
actualizar los pesos de una red neuronal para lograr tasas de error más
bajas. Las formas de entrenamiento de propagación incluyen backprop-
agation, resilient propagation, la Manhattan Update Rule, y otros.
Poda: Intenta optimizar el número de neuronas ocultas en una red

neuronal.
Función de activación de base radial: Función de activación basada en

una función de base radial.
Función Base Radial (RBF): Función con su valor máximo en su pico

que disminuye rápidamente.
Capa de Función de Base Radial: La capa, en una red de función de

base radial, que utiliza una función de base radial compuesta como su
función de activación.
Radial Basis Function Network: Un tipo especial de red neural que
hace uso de una capa de función base radial.
Red Neuronal Recurrente: Una red neuronal que tiene conexiones a

capas anteriores.
Propagación Resiliente (RPROP): Técnica de entrenamiento de

propagación que utiliza valores delta independientes para cada conexión
en la red. Este es uno de los algoritmos de entrenamiento más eficaces
que ofrece Encog.
RGB: Los valores de rojo, verde y azul que componen una imagen.
RGB Downsample: Un medio de downsampling que preserva los

valores de color de una imagen.
Escalado: Véase el muestreo.
Puntuación: Valor numérico utilizado para clasificar las soluciones

proporcionadas por Algo-ritmos Genéticos y Simulated Annealing.
203
Segregator: Un objeto de normalización Encog que excluye ciertos

elementos, basado en los criterios proporcionados.
Poda Selectiva: Método de poda donde las neuronas más débiles son
seleccionadas y eliminadas.
Self-Organizing Map (SOM): Estructura de red neuronal que organiza

patrones de entrada similares.
Capa autoconectada: capa en una red neuronal conectada a sí misma.
Serializable: Una clase que puede ser serializada.
Memoria de Corto Plazo: Una capa de contexto proporciona memoria

de corto plazo de la red neuronal.
Sigmoid Activation Function: Función de activación basada en la

función sigmoide. Esta función de activación sólo produce valores
positivos.
Red Neural Recurrente Simple (SRN): Una red neural que tiene una
conexión recurrente a través de una capa de contexto. Los tipos SRN
más típicos son las redes neuronales Elman y Jordan.
Simulated Annealing: Una técnica de entrenamiento que simula el
proceso de recocido metalúrgico.
Función de activación senoidal: función de activación basada en la

función senoidal trigonométrica.
Single Threaded: Una aplicación que no es multiproceso. Ver multihilo.

Función de activación de SoftMax: Función de activación que escala la
salida para que la suma sea una.
Temperatura de inicio: La temperatura para el primer ciclo de recocido

simulado. (8)
Entrenamiento supervisado: Entrenamiento donde se puede calcular la

aceptabilidad de la salida de la red neuronal.
Sinapsis: Una conexión Encog entre dos capas. Datos Temporales:

Datos que ocurren con el tiempo.
Red Neural Temporal: Una red neuronal diseñada para aceptar datos
temporales, y generalmente, para obtener una predicción.
204 Glossary
Velocidad terminal: La velocidad máxima que un objeto que cae puede

obtener antes de la fricción trae la aceleración a cero.
Red Neural Térmica: Una red neuronal que contiene una temperatura;
Ejemplos incluyen la red neuronal de Hopfield y la máquina de Boltzmann.
Valor Umbral: Valores mantenidos en las capas de redes. Junto con

los pesos, éstos se ajustan para entrenar la red.
Entrenamiento: El proceso de ajustar los pesos y umbrales de una red

neuronal para disminuir la tasa de error.
Training Set: Datos que se usan para entrenar una red neuronal.
Viajando vendedor Problema: Un problema de computadora donde un

vendedor ambulante-hombre debe encontrar la ruta más corta entre un
número de ciudades. (TSP)
Entrenamiento no supervisado: Entrenamiento donde no se da

dirección a la red neuronal hasta donde se espera.
Actualizar Delta: La cantidad que el entrenamiento ha determinado un

peso de conexión debe ser actualizado por.
Longitud del vector: La raíz cuadrada de la suma de los cuadrados de

un vector. Este es un medio de tomar el promedio de los números en un
vector.
Peso Matrix: La colección de pesos de conexión entre dos capas.

Sinapsis ponderada: An Encog sinapsis entre dos capas que contiene
pesos. Esta es la forma más común de Encog sinapsis.
Synapse sin peso: Una matriz de peso que no tiene pesos, sólo
conexiones.
Ventana: Un grupo de valores de datos temporales.
Archivo XML: Un archivo que está codificado en XML; Encog guarda

objetos en archivos XML.
Operador XOR: Un operador lógico que sólo es verdadero cuando sus

dos entradas no están de acuerdo.
205
Index
activation function, xxviii, 12, 20, 41, array, xxiv–xxvi, 5, 6, 13, 14, 17, 21,
51–60, 62, 64, 69, 75, 77, 121, 28, 29, 33, 55, 97, 99, 101, 117,
142, 162, 171, 195–197, 199, 131, 132, 134, 148, 151, 174–
200, 202, 203 176, 178
activation functions, xxix, 12, 20, 41, attribute, vi, 3, 5, 21–23, 28, 31–33,
51, 53, 54, 58, 64, 69 37, 47–49
actual, xxii, xxv, 4, 20, 24, 26, 30, 36,
43, 68, 69, 90, 93, 95, 97, 111, backpropagation, xxix, 69–72, 74, 76,
115, 126–128, 133, 134, 143– 80, 103, 112,131, 164,174,
200, 202
146, 148, 152, 155, 160, 166, bias, 11, 13, 43, 52, 75, 171
174, 187, 195, 196, 201
actual data, 127, 133, 145 bias neuron, 11, 13, 43, 52, 75
actual output, 24, 26, 68, 69 binary, vii, 38, 63, 65, 122, 139
algorithm, xxiii, xxvii, xxix, 4, 14, 57, biological, xxiii, 197, 198, 201
67–74, 77–81, 83, 90, 94, 99– bipolar, 54, 55, 64, 115, 117, 196
104, 123, 141, 158, 170, 182, bipolar activation, 54
195, 198, 199, 202 black box, xxiv, 7
analyst, 37–39, 51 bot, ix, xxii, xxiv, xxvi, 8, 9, 17, 20,
annealing, xxix, 81, 83, 85, 90, 94, 99, 23, 29, 33, 37, 39, 41, 51, 58,
101–104, 112, 195, 197, 203 60, 61, 67, 74–76, 83, 94,97,
ant, vi–ix, xxiii, xxv–xxvii, 4, 17, 23, 99, 102, 104, 111, 112, 115,
24, 26, 27, 31, 32, 35, 41, 49, 119, 122, 127, 128, 132,133,
51, 54, 57, 58, 61, 63, 68, 70– 136, 139, 154, 155, 159,167,
77, 83, 84, 90–93, 97, 109, 112, 187, 196, 197, 199
128, 137–139, 141, 143, 151, bounding box, 153, 154
152, 155–157, 166, 167, 170, bounds, 153, 166, 167
brain, xxii–xxiv, 107, 122
173, 175–177, 180–182, 186, 189,
191, 196 calculate, 3, 26, 43, 57, 64, 68–70, 77,
206 INDEX
195, 200, 200, 44, 45, 49,
201, 203 202– 204 127–129,
84, 90,
classification, context 132, 133,
93, 97,
xxviii, 1– neuron, 135, 136,
134,
5, 16, 20, 108, 113, 148, 151,
145,
60, 115 114 155–157
146, close copyright decimal
156, d- , vii, ix point,
171, loop, c 31, 37
173, 130, s denorm
178, 132, v, alize,
195, 134 4 22, 23,
197, 198, close 0 27, 28
201, 203 st , derivative, 54–58,
class, xxviii, xxix, 60, 64, 69, 77, 195,
match 4
1–6, 12,
, xxv, 1
14–17,
182 ,
20, 21,
cluste 4
23–26,
r 3
28, 29,
data, ,
33, 51,
xxix, 4
53, 60,
118 4
62, 64,
clustering, 1, ,
73, 80,
4, 5, 16, 17, 4
83, 85,
117, 170 color 6
91, 93–
matching, 177 c
95, 99–
competitive, 56, s
101, 115,
64, 170, 176, 181, v
116, 118,
182 competitive fil
121, 125,
training, 170, 176 e
127, 128,
configuration, 7, ,
131,
38, 141, 199 4
135–
connection, vii, 8, 6
141, 143,
12, 43, 69, 107, current error, 15,
148, 151, 177
108,
155–157,
118, 119,
160, 166, dataset, 2–5, 20,
122, 198,
169, 170, 21, 23, 32,
177, 179, 33, 38, 39,
27, 28, 30, encoding, 5,
37, 39, 41, 17, 23, 25,
197 43, 45, 47, 26, 33, 155
double, 5, 6, 9,
48, 55, epoch, 15,
13, 35,
58–62, 16, 85, 86
39, 41,
68–71, 73, equilateral, 26,
42, 94,
74, 77, 78, 30, 32, 33, 166,
99, 101,
84, 85, 88, 201 equilateral
141,
90–92, 95, encoding, 26, 33
151,
97, 99, equilateral
177,
100, 107, normalization,
186
112, 113, 26, 30, 166,
download, vi, 115, 117, 201
16, 40, 120, 121, error, 7, 10, 14–
135, 128–130, 16, 24,
136, 132– 134, 25, 33,
138, 136–142, 43, 44,
148, 152, 156, 62–64,
177, 158, 159, 68, 69,
185, 161, 163, 71, 77,
186 164, 170, 112–114,
downsampling, 173– 175, 121, 128,
151, 178, 180– 129, 136,
155, 182, 196– 141, 158,
161, 200, 203 164, 177,
ega, vii–ix, 20, 181, 182,
166,
37, 58– 187, 193,
167, 195, 197,
60, 70,
202 71, 77, 198, 200,
edge detection, 84, 85, 202, 204
156 90–92, error level, 64,
eg, vii–ix, xxii, 100, 158
xxvi– 115, error rate, 14–16,
xxviii, 1, 175, 68, 112–114,
3–6, 12, 199, 203 121,
14, 16, encode, 5, 6,
17, 20– 23, 24, 33,
22, 25, 204
INDEX 207
204 136
129, expor generation gradient, 69, 70,
141, , 104, 120, 72, 74,
t, vii
164, 121, 144 77, 195,
181, factory, 75, 76 genetic, xxix, 81, 197,
feedforward, 10, 83, 85,
182, 200, 202
51, 57, 90, 94,
198, gradient
59, 60, 99– 104,
202, 204 descent,
62, 67, 123
evaluate, 1, 2, 69, 70,
23, 43, 69, 72, genetic
49, 64, 75, 80, algorithm, 74, 77
77, 137, 104, 107, xxix, 81, greedy,
138, 108, 110– 83, 90, 113
143, 112, 114, 94, 99–
144, 198 115, 118, 104, 123 hidden layer, 5,
120, 122, genetic 7–10, 12,
evaluation, 32,
123, 126, 13, 17,
44, 133, 139, algorithm
139, 142, 41, 43,
143–145 s, xxix,
151, 167, 52, 53,
example, xxiv– 81, 83,
171, 172, 59, 64,
xxvi, xxviii, 2, 5,
196 94, 99, 75, 78,
8, 10– 12, 14,
file, vii–ix, xxviii, 103, 104 108, 113,
16, 17, 20–24,
xxix, 2, 4, 118, 119,
26–29, 32, 43,
28–31, 123, 139,
44, 62, 63, 70–
35–47, 51, 141–
75, 78, 79, 83–
61–65, 97, 143, 158,
86, 90, 91, 95,
131, 138– 162, 197,
97, 99, 102,
140, 144, 199
103, 110–112,
145, 156– hidden neuron,
114, 115, 120,
158, 186, 10, 11,
126, 131, 137,
191, 197, 75, 108,
138, 141, 148,
200, 202, 119, 123,
155, 157, 158,
204 141,
160, 166, 170,
floating point, 199, 202
172, 177, 179–
xxiv–xxvi, hyperbolic
181, 185–
1 17, 21, tangent,
91, 33, 148 20, 52,
193, 53, 57–
generate
201, training,
60, 62,
64, 162, 166, input layer, xxiv,
142, 167, 169– xxv, 5–
162, 171, 173, 8, 12,
174, 177,
199 179–182, 17, 52,
ide, vi, viii, ix, 187, 191, 69, 78,
xxii, 196, 198– 118,
xxvi– 203 171
xxix, 1– ideal, xxvi,
6, 10, xxvii,
12–14, 13, 17,
17, 19– 24, 26,
27, 31– 37, 38,
33, 35– 44, 68,
39, 43, 69, 155,
44, 51– 157,
54, 56, 161,
58, 61, 170
63, 67– ideal output,
69, 71, 13, 17,
72, 77, 24, 26,
78, 80, 68, 69,
83, 84, 155,
88–90, 157,
93, 97, 161
99, 100, image, xxviii, xxix,
109, 111, 39, 49,
115, 118, 78, 148,
120, 151–162,
125, 165–167,
126, 196, 197,
128– 202
130, image file, 39
136, images, 148,
138, 151, 154–
141, 162, 165–
148, 167
151– initialized,
158, 16, 72, 163
160–
208 INDEX
181, 182, 171
195–200 linear
input neuron, 5, lun
functio
9, 10, 21, layer, xxiv, xxv, ar
n, 56,
41, 43, xxix, 5– 57, lan
62, 75, 13, 17, 200 der
96, 109, 41, 43, lma, xxix, 10, 13,
115, 117, 52, 53, ,
53, 64,
119, 120, 55, 57, 27,
107–114,
126, 141, 59, 60, 122, 196, 84,
154–156, 62, 64, 197, 201, 95
167, 171, 69, 75, 203
173, 178 78, 99, lun
local
input neurons, 5, 108, 111, ar
minima,
9, 41, 43, 113, 115, sur
69, 80,
62, 75, 118, 119, 112, 200 fac
96, 109, 122, 123, logarithmi
115, 117, 139, 141– e,
c, 57, 58
119, 120, 143, 158, 85,
lower resolution,
126, 141, 160, 162, 88
151, 167
154–156, 171, 182,
167, 171, 195–199, machine
173, 178 201–204 learning,
input pattern, learning method, xxi, xxviii,
xxiv, 117, 173, xxi, xxviii, 1, 2, 4,
182, 203 iris, 20– 2, 4, 43, 16, 35,
26, 29, 33, 38, 44, 49, 43, 44,
44–47, 49 120 49, 120
iris data, 20, 23, learning rate, magnitude, 70–
29, 33, 38, 44, 69–72, 72, 200
45, 49 iris 76, 77, market, xxix,
dataset, 20, 23, 80, 112, 125,
33, 38, 44, 45, 164, 173, 134–138,
49 iteration, 14– 174, 176, 141,
16, 53, 68–74, 180, 181, 143–
77, 78, 85, 100– 195 145, 148
102, 108, 112, market data, 135,
license, vii, 200
113, 121, 122, linear 136, 138, 143–
140, 142, 164, activati 145 matrix, 8,
172, 173, on, 57, 68–72, 112, 172,
173, 178,
195, 200, 170, 173–175, 67– 75,
204 179, 180, 77, 80,
mean, 1, 6, 20, 18 83–88,
23, 26, 2, 198 90, 91,
27, 37, neighborh 93– 96,
39, 58, ood 99–104,
61, 64, competitiv
107–123,
67, 68, e, 170
125–133,
70, 71, neighborhood
99, 104, function,
137, 173–
155, 175,
156, 179,
169, 180,
170, 182, 198
174, network output,
195– 6, 14
199, network type,
201, xxix, 5,
202, 204 6, 51,
midpoint, 177 104,
momentum, 69– 107,
72, 76, 80, 164 120,
multi- 122,
dimensional, 166,
175, 176, 179 167,
multicore, 80, 182,
197, 200 196, 201
neural network,
multithreaded,
xxi–xxix,
76–80, 197, 200,
1–8, 10–
203
17, 19,
multithreaded
20, 22–
training, 76, 78,
24, 26,
80, 197
32, 33,
ne-dimensional
37, 39,
neighborhood,
41–44,
174, 179
47, 49,
neighborhood,
51–65,
INDEX 209
137–148, 151, 152, 154, 155, 126, 127, 155, 160, 161, 170,
157, 158, 160, 162, 163, 165– 171, 173–176, 178, 182
167, 169–172, 174, 176–182, 190,output neurons, 6, 24–26, 33, 43, 114–
195–204 117, 126, 127, 155, 160, 161,
neural pilot, 86, 89, 90, 96, 98–102 170, 173, 174, 178
neuron, xxiii, xxiv, 5–7, 9–14, 21, 24– output pattern, xxiv
26, 33, 41, 43, 52, 55, 56, 59,
62, 69, 75, 78, 96, 98, 99, 108, parameter, 43, 69–74, 80, 92, 96, 128,
109, 113–120, 123, 126, 127, 131, 132, 156–160, 162–165, 179–
141–143, 154–156, 160–162, 166, 181, 201
167, 170, 171, 173–176, 178, pattern, xxiii–xxv, xxviii, 6, 11, 17,
182, 195–197, 199–203 107, 109, 113, 115–117, 122,
neuron output, 55, 59, 108 125, 129, 142, 154, 166, 170,
non-numeric data, 3, 33 171, 173, 174, 181, 182, 195,
non-winners, 56 199, 203
normalization, 5, 17, 20–24, 26–33, 39, pattern recognition, xxiii, xxviii, 6, 195,
199
44, 47, 49, 95, 166, 177, 198– persist, 51, 61–64, 139, 200, 202
201, 203
normalize, xxviii, 4, 17, 19–23, 25, 27– persistence, 51, 61–63, 200, 202
33, 39, 44, 49, 51, 95–97, 127, physical, viii, 90, 91, 152
130–133, 156, 198, 199, 201 physical simulation, 90, 91
normalized, 17, 19, 20, 22, 23, 25, 28– pilot, 84, 86, 88–90, 95, 96, 98–102
31, 33, 39, 49, 95, 96, 127, 130– pixel, 154–156
133, 156, 198, 199, 201 pixels, 154, 155
plot, 48
null, xxv
population, 99, 100, 120, 121
offspring, 99, 100, 197,
200 predict, xxviii, xxix, 6, 17, 24, 26, 28,
one-dimensional, 174, 175, 178, 179 40, 47, 109, 110, 113, 123, 125,
one-of-n, 23–26, 32, 33, 198 126, 128–130, 132–134, 136–
operating system, 35, 40, 61 138, 145, 146, 148, 198, 202,
output layer, xxiv, xxv, 5–9, 12, 13, 203
17, 52, 53, 57, 60, 69, 75, 78, prediction, xxviii, 28, 40, 109, 113, 123,
113, 115, 118, 123, 160, 171, 125, 128–130, 132–134, 137, 138,
182, 199 148, 202, 203
output neuron, 6, 7, 9, 10, 14, 24–26, problem, xxii, xxiv, xxvi–xxviii, 1, 4,
33, 41, 43, 75, 96, 98, 114–120, 6–8, 10, 11, 14, 20, 24, 25, 69,
210 INDEX
70, 94, 99, 154, 204 202

programming language, xxii, xxv, 8
propagation, xxix, 54–58, 60, 62, 64, scatter plot, 48
65, 67–72, 74–78, 80, 83, score, 84–86, 90, 93–95, 97–101,
99, 103, 104, 112, 131, 133, 103, 104, 197
141, 164, 174, 177, 181, scoring function, 99, 102, 103
195, 198– 202 script, vi, vii, 38, 46, 128, 129, 132,
propagation training, 55–58, 60, 64, 135, 136, 139, 144, 157,
65, 67–72, 74, 76, 78, 80, 83, 158, 166
99, 103, 104, 164, 174, 177, script file, 38, 46, 157, 158 self-
181, 195, 198, 200, 202 organizing, 56, 57, 64, 167, 169,
prune, 141 170, 174, 182
pruning, 141–143, 203 self-organizing map, 56, 57, 64,
167, 169, 170, 174, 182
radial basis, 179, 202 serialization, xxviii, 51, 61–65
random, 12, 13, 16, 43, 78, 86, 99– short-term memory, 13, 203
102, 111, 163, 164, 172, 173, sigmoid, 12, 20, 41, 52, 58, 62, 75, 121
180, 181, 196, 197, 200 sigmoid activation, 12, 20, 52, 58, 62,
random weight, 12, 13, 16, 43, 99, 75
111, 163 similar color, 170–172
randomize, 12, 100, 164, 196 simple recurrent, 51, 59, 60, 64, 67,
range, 20, 22, 25, 27, 28, 31–33, 107, 109, 126, 196, 197, 199
39, 47, 54, 58, 96, 97, 131, simulated annealing, xxix, 81, 83,
136, 142, 144, 147, 156, 90, 94, 99, 101–104, 112,
171, 174, 177 195, 197, 203
raw, 19, 28, 37, 38, 97, 129, 131, single-threaded, 76, 78–80
139, 152, 154, 177, 196, 199 som, ix, xxi–xxviii, 4, 5, 8, 21, 23, 35,
recognition, xxiii, xxviii, 6, 157, 158, 37, 42, 52, 57, 59, 61, 68, 80,
166, 195, 199 81, 83, 84, 86, 87, 90, 91, 96,
recurrent, 10, 51, 59, 60, 64, 67, 99, 101, 103, 104, 122, 127,
107– 109, 118, 119, 122, 130, 138, 141, 143, 156, 169,
126, 196, 197, 199, 203 174, 176, 196, 199, 200
recurrent connection, 107, 119, sort, xxii, xxvi, 8, 19, 20, 23, 55, 56, 83,
203 reset, 43, 158, 163, 164 91, 99, 100, 104, 129, 137 species, 3,
resilient propagation, xxix, 62, 70–72, 4, 21, 23, 24, 30, 33, 45, 47 stock
74, 76, 80, 103, 131, 133, 141, market, xxix, 125, 134, 135, 137,
INDEX 211
143, 148 63, 68, 70–73, 76, 78, 80, 83,

strategy, 90, 112, 113, 158, 163, 164, 84, 99, 100, 103, 104, 109, 112,
198 120, 129, 133, 141, 156,158,
sunspot, 28, 40, 125, 129–134, 148 159, 161, 170, 180, 195, 198
sunspots, 125, 129–133, 148
unsupervised, xxix, 4, 67, 155, 157,
tangent activation, 20, 52, 53, 57–60, 170, 182, 196, 199
62, 142, 162 unsupervised training, xxix, 67, 155,
temperature, 102, 104, 196, 197, 203, 157, 170, 182, 196, 199
204 update, ix, xxix, 68, 71, 72, 80, 172,
temporal, 109, 111, 113, 122, 123, 125– 181, 202, 204
129, 131, 132, 135, 148, 197– update rule, xxix
199, 202–204
temporal data, 127–129, 132, 135, 148, velocity, 84, 85, 87–93, 95–97, 204
197, 199, 203, 204
text, vii, xxiii, xxviii, 13, 37, 39, 51, weight, 3, 8, 12–14, 16, 25, 43, 65, 67–
72, 77, 80, 99–101, 104, 108,
53, 61, 64, 75, 84, 108–111,
111, 112, 115, 118, 119,142,
113, 114, 122, 160, 196, 197, 163, 164, 170–173, 178,182,
199, 201, 203 195, 197, 198, 200–202, 204
thread, 76–80, 180, 197, 200, 203
training, xxix, 1–3, 12, 14–16, 24, 26, weight matrix, 8, 68–72, 112, 172, 178,
195, 200, 204
32, 37–41, 43, 54–60, 62–65, winner, 55, 56, 166, 171, 176
67–81, 83–86, 97, 99–101, 103, winning neuron, 55, 118, 166, 182, 196
104, 108–110, 112, 118, 120– wizard, 30, 31, 45, 46
122, 126–129, 131–133, 136, 138–
145, 155–159, 161, 163–165, 170,workbench, 32, 35, 36, 38, 39, 43, 49,
186
172–177, 179–182, 195–204
training algorithm, xxix, 14, 67–70, 72, workbench project, 36
73, 77, 78, 80, 81, 158, 170, xor, 40, 41, 43, 190
182, 199, 202
training data, 24, 38, 40, 41, 43, 59,
68, 77, 83, 84, 97, 99, 122, 126,
127, 136, 138, 139, 144, 157,
170, 181, 196, 197
training iteration, 68, 70, 85, 142, 164
training set, 14, 15, 24, 37, 40, 43, 62,

3 - Encog3CS-UserTraduc13032017A

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

3 - Encog3CS-UserTraduc13032017A

Hochgeladen von

Copyright:

Verfügbare Formate

Programación de

Heaton Research, Inc.

CONTRATO DE LICENCIA DE SOFTWARE: TERMINOS Y

La compilación del Software es propiedad de Heaton Research, Inc. a

En el caso de que el Software o los componentes incluyan requisitos

Mediante la compra, uso o aceptación del Software, usted acepta además

Los componentes del Software complementario y los que estén asociados

Departamento de Soporte al Cliente de Heaton Research, Inc. 1734

Heaton Research, Inc., sus distribuidores o distribuidores serán

La exclusión de garantías implícitas no está permitida por algunos

Este software puede utilizar varios programas y bibliotecas que se

Este libro está dedicado a mi

Esposa, Tracy y nuestros dos

1 Regresión, clasificación y agrupación 1

1.5.3 Formación de una red neuronal . . . . . . . . . . . . . . . . 13

2 Obtención de datos para Encog 19

3.2.1 Creación de un nuevo proyecto . . . . . . . . . . . . . . . . . 39

4 Construir redes neuronales en C # 51

5.1 Entendiendo el entrenamiento de propagación. . . . . . . . . . . . 68

6 Más entrenamiento supervisado 83

7 Otros tipos de redes neuronales 107

7.1 La Red Neural de Elman . . . . . . . . . . . . . . . . . . . 108

8 Uso de datos temporales 125

9.4.1 Creación del conjunto de entrenamiento . . . . . . . . . . . 159

10 Uso de un mapa de autoorganización 169

A Instalar y usar Encog 185

Estos dos libros se pueden leer en secuencia como nuevos conceptos

Como puede ver, la red neural arriba está aceptando un patrón y

0.2.1 Estructura de redes neuronales

La red neuronal anterior tiene tres neuronas en la capa de entrada y

• “hear” -> “to perceive or apprehend by the ear”—“ Percibir o

Esto es un mapeo entre palabras y la definición de cada palabra, o una

Las tablas de hash utilizan claves y valores. Piense en el patrón enviado

El mapa anterior trae a colación un punto muy importante acerca de las

Con un problema de red neuronal, las entradas deben ser matrices de

Para continuar con el ejemplo de tabla de hash, la tabla de verdad

Estos mapas muestran la entrada y el resultado esperado ideal para la

0.3 Cuándo utilizar redes neuronales

Un objetivo importante de este libro es explicar cómo construir redes

Las redes neuronales son particularmente útiles para resolver problemas

La clasificación es un proceso que está estrechamente relacionado con el

0.4 Estructura del libro

Las redes neuronales deben ser entrenadas para la utilización efectiva

Regresión, Clacificación &

• Análisis de Regresión de Datos

• Cómo se estructuran los problemas de aprendizaje de la máquina

Mientras que hay otros modelos, la regresión, la clasificación y la

Las redes neuronales supervisadas siempre son

• Longitud de los pétalos

• Anchura de los pétalos

Para la clasificación, se indica a la red neural que, dada la longitud /

1.2 Análisis de regresión

Para obtener más información, la totalidad de este conjunto de datos

1.4 Estructuración de una red neuronal

mínimo. También puede haber capas ocultas. Algunos tipos de redes

IMLData data = new BasicMLData ( i n p u t ) ;

Encog con datos. Otras implementaciones de IMLData se utilizan para

La clasificación produce una o más neuronas de salida, dependiendo de

1.4.3 Capas ocultas

El único propósito de las capas ocultas es permitir que la red neural

El desafío es evitar crear una estructura oculta que sea demasiado

Los desarrolladores a menudo se preguntan cuántas capas ocultas

Algunas redes neuronales no tienen capas ocultas, con la capa de

1.5 Uso de una red neuronal