Introducción A Encog 2

27/8/2014 Introduccin a Encog 2.
5 prrafo C #
http://translate.googleusercontent.com/translate_f 1/88
Pgina 1
Introduccin a Encog 2.5 para C # 1
Introduccin a Encog 2.5 para C #
Revisin 2 - Noviembre 2010
http://www.heatonresearch.com/encog
Una versin abreviada de:
"Programacin Redes Neuronales con Encog 2 en C #". ISBN 1604390107. Su
compra de todo el libro apoya el proyecto Encog! Para obtener ms informacin, visite.
http://www.heatonresearch.com/book/programming-redes neuronales-encog-cs.html
27/8/2014 Introduccin a Encog 2.5 prrafo C #
Page 2
Introduccin a Encog 2.5 para C #
Copyright 2010 por Heaton Research, Inc.
Este documento puede ser distribuido con la API Encog para C #.
http://www.heatonresearch.com
Encog y el logotipo son marcas comerciales de Encog Heaton Research, Inc.
Este documento sirve como la documentacin principal de la Encog Artificial
Marco Inteligencia para C #. Este documento muestra cmo instalar, configurar y usar
los fundamentos de Encog.
Para una ms avanzada, y largo, manual sobre Encog programando usted puede ser
interesado en mi libro "Programacin Redes Neuronales con Encog 2 en C #". ISBN
1604390107. Este libro est disponible tanto en formato de bolsillo y libros electrnicos. Este libro
aade muchos captulos y es cerca de 500 pginas de largo. Su compra de nuestros soportes de libros
el proyecto Encog! Para obtener ms informacin, visite.
Page 3
Contenido
1 Qu es Encog?........................................................................................................... 6
1.1 La historia de Encog .............................................. ............................................. 6
1.2 Resolucin de problemas con Redes Neuronales ............................................. ................. 7
1.2.1 Los problemas no se adapta a una solucin de red neuronal ..................................... 7
1.2.2 Problemas Adecuado para una red neuronal ............................................ .............. 7
2 Instalacin y uso de Encog .............................................. ........................................... 9
Instalacin Encog.............................................................................................................. 9
Compilar el Encog Core .............................................. .............................................. 10
Compilacin y ejecucin de Encog Ejemplos ............................................. .................... 10
Terceros libreras utilizadas por Encog ........................................... ............................. 11
Ejecucin de un ejemplo de la lnea de comandos ........................................... ............. 12
Operando Ejemplos Encog en Visual Studio ............................................ ...................... 12
3 Introduccin a Encog ............................................... ................................................ 13
3.1 Qu es una red neuronal? ............................................ .................................... 13
3.1.1 La comprensin de la capa de entrada .............................................. ..................... 15
3.1.2 La comprensin de la capa de salida .............................................. ................... 16
3.1.3 Capas ocultas ................................................ ............................................. 16
3.2 El uso de una red neuronal .............................................. ....................................... 17
3.2.1 El operador XOR y Redes Neuronales ............................................ ...... 17
3.2.2 Estructurar una red neuronal para XOR ............................................ .......... 18
3.2.3 El entrenamiento de un Red Neural .............................................. ........................... 21
3.2.4 Ejecucin de una red neuronal .............................................. ......................... 22
3.3 Captulo Summary............................................................................................... 25
4 Uso de las funciones de activacin ............................................... ........................................ 27
4.1 Cules son las capas y las sinapsis? ............................................ ............................. 27
4.2 Entender Capas Encog ............................................... .............................. 28
4.2.1 Uso de la interfaz de capa .............................................. .............................. 28
4.2.2 Usando la capa bsica .............................................. ................................... 30
4.2.3 Usando la capa de Contexto .............................................. ............................... 31
4.2.4 Uso de la Funcin de base radial Capa ............................................ .......... 31
4.3 Entender Encog sinapsis ............................................... .......................... 32
4.3.1 La interfaz de la sinapsis ............................................... .................................. 33
Pgina 4
4.3.2 La construccin de sinapsis ................................................ ................................ 34
4.3.3 Uso de la clase WeightedSynapse .............................................. ................ 35
4.3.4 Usando el Weightless Sinapsis .............................................. ...................... 36
4.3.5 Usando el OneToOne Sinapsis .............................................. ...................... 36
4.3.6 Uso de la sinapsis directa .............................................. .............................. 37
4.4 Entender Neural Lgica ............................................... ............................... 38
4.4.1 La Clase ART1Logic ............................................... .................................. 38
4.4.2 La Clase BAMLogic ............................................... .................................. 38
4.4.3 La Clase BoltzmannLogic ............................................... .......................... 39
4.4.4 La Clase FeedforwardLogic ............................................... ....................... 39
4.4.5 La Clase HopfieldLogic ............................................... ............................. 39
4.4.6 La Clase SimpleRecurrentLogic ............................................... ................ 40
4.4.7 La Clase SOMLogic ............................................... ................................... 40
4.5 Descripcin de las propiedades y Etiquetas .............................................. ...................... 40
4.6 Edificio con Capas y sinapsis ............................................. ...................... 41
4.6.1 Crear Feedforward Redes Neuronales .............................................. ....... 41
4.6.2 Creacin de Auto-Connected Redes Neuronales ............................................ .... 45
4.7 Captulo Summary............................................................................................... 54
5 Edificio Encog Redes Neuronales .............................................. ............................... 56
5.1 El papel de las funciones de activacin ............................................. ......................... 56
5.1.1 La interfaz ActivationFunction ............................................... ................ 56
5.1.2 Derivadas de funciones de activacin .............................................. ............. 57
5.2 Funciones Encog activacin ............................................... ................................ 58
5.2.1 ActivationBiPolar ................................................. ...................................... 58
5.2.2 Activacin Competitiva ................................................ ............................... 58
5.2.3 ActivationGaussian..................................................................................... 59
5.2.4 ActivationLinear......................................................................................... 60
5.2.5 ActivationLOG ................................................. .......................................... 61
5.2.6 ActivationSigmoid...................................................................................... 62
5.2.7 ActivationSIN ................................................. ............................................ 63
5.2.8 ActivationSoftMax...................................................................................... 64
5.2.9 ActivationTANH......................................................................................... 65
5.3 Resumen ............................................................................................................ 66
Pgina 5
6 Uso de la Encog Workbench .............................................. ....................................... 67
6.1 Creacin de un error de red neuronal .................................! Bookmark no definido.
6.2 Creacin de un conjunto de entrenamiento ........................................ Error! Bookmark no definido.
6.3 El entrenamiento de un red neuronal .................................. Error! Bookmark no definido.
6.4 Consulta de la Red Neuronal ............................. Error! Bookmark no definido.
6.5 Generacin de cdigo ................................................ .. Error! Bookmark no definido.
6.6 Resumen ............................................................................................................ 79
7 Propagacin Training................................................................................................. 80
7.1 La comprensin de Propagacin Formacin ............................................... .................. 80
7.1.1 Entender Retropropagacin ................................................ ................. 81
7.1.2 La comprensin de la actualizacin de la Regla Manhattan ............................................. ... 82
7.1.3 Entender Resilient Formacin Propagacin ........................................... 82
7.2 Formacin de propagacin con Encog .............................................. ......................... 82
7.2.1 Usando Retropropagacin ................................................ ............................... 83
1.1.1 Tabla de verdad Matriz ............................................ ................................................. 85
7.2.2 Usando la regla de actualizacin de Manhattan ............................................. ................. 88
7.2.3 Usando Propagacin Resilient ............................................... ........................ 91
7.3 Propagacin y subprocesos mltiples ............................................... .......................... 94
7.3.1 Cmo funciona el Entrenamiento multiproceso .............................................. ............. 95
7.3.2 La capacitacin multiproceso ............................................... ...................... 96
7.4 Resumen .......................................................................................................... 100
Pgina 6
1 Qu es Encog?
Encog una Inteligencia Artificial (AI) Marco de Java y NET. Aunque Encog
soporta varias reas de la IA fuera de las redes neuronales, el foco principal de la Encog
Versiones 2.x es la programacin de la red neuronal. Este libro fue publicado como Encog 2.4 fue
de ser liberado. Debe estar muy compatible con las ediciones posteriores de Encog 2. Futuro
versiones en la serie 2.x intentarn agregar funcionalidad con la mnima interrupcin a
cdigo existente.
1.1 La historia de Encog
La primera versin de Encog, la versin 0.5 fue lanzado el 10 de julio de 2008 Sin embargo, el
cdigo para Encog origina a partir de la primera edicin de "Introduccin a las redes neuronales con
Java ", que publiqu en 2005 Este libro se bas en gran medida en el Object Java
Motor Neural Orientada (Joone). Basando mi libro sobre Joone result ser
problemtico. Las primeras versiones de Joone eran bastante prometedor, pero Joone rpidamente
se hizo con errores, con futuras versiones introducir cambios errticos que lo hara con frecuencia
romper ejemplos en mi libro. A partir de 2010, con la redaccin de este libro, el Joone
proyecto parece casi muerto. El ltimo lanzamiento de Joone era un "release candidate", que
ocurrido en 2006, la fecha de redaccin de este documento, en 2010, no ha habido ms
Joone libera.
La segunda edicin de mi libro usa cdigo 100% original y no se basaba en ningn
API de red neural. Este fue un medio ambiente mejor para mi "Introduccin a Neural
Redes para Java / C # "libros, ya que poda dar ejemplos exactos de cmo poner en prctica la
redes neuronales, en lugar de cmo utilizar una API. Este libro fue publicado en 2008.
He encontrado que muchas personas estaban usando el cdigo que figura en el libro como un neural
API de red. Como resultado, decid empaquetarlo como tal. La versin 0.5 de Encog es
bsicamente todo el cdigo libro combinan en una estructura de paquete. Las versiones 1.0 a travs de
2.0 mejorada en gran medida el cdigo de red neuronal mucho ms all de lo que iba a cubrir en un
libro de introduccin.
El objetivo de mi "Introduccin a las redes neuronales con Java / C #" es ensear a alguien
cmo implementar redes neuronales bsicos propios. El objetivo de este libro es ensear
alguien use Encog para crear estructuras de redes neuronales ms complejas sin la necesidad
saber cmo funciona realmente el cdigo de red neural subyacente.
Estos dos libros son muy destinados a ser ledos en secuencia, como trato de no repetir demasiado
toda la informacin en este libro. Sin embargo, usted debe ser capaz de iniciar con Encog si
tener un conocimiento bsico de lo que las redes neuronales se utilizan. Tambin debe
comprender el lenguaje de programacin C #. En particular, usted debe estar familiarizado con el
siguiente:
Los medicamentos genricos de C #
Colecciones
Programacin Orientada a Objetos
Pgina 7
Antes de comenzar el examen de cmo utilizar Encog, primero vamos a echar un vistazo a qu tipo de
problemas Encog podra ser experto en resolver. Las redes neuronales son una programacin
tcnica. Ellos no son una solucin mgica para todos los problemas de programacin se quiere
encuentro. Hay algunos problemas de programacin que las redes neuronales son extremadamente
expertos en problemas. Hay otros problemas para los que las redes neuronales fracasarn miserablemente.
1.2 Resolucin de problemas con redes neuronales
Un objetivo importante de este libro es mostrar cmo construir Encog neural
redes y para ensearle cundo usarlos. Como programador de redes neuronales, que
debe entender que los problemas son muy adecuadas para soluciones de redes neuronales y que
no lo son. Un programador efectiva red neuronal tambin sabe que la red neural
estructura, si la hay, es ms aplicable a un problema dado. Esta seccin comienza con la primera
centrndose en aquellos problemas que no conducen a una solucin de redes neuronales.
1.2.1 Los problemas no se adapta a una solucin de red neuronal
Los programas que se escriben fcilmente como diagramas de flujo son ejemplos de problemas para
que las redes neuronales no son apropiados. Si su programa consiste en bien definido
pasos, tcnicas de programacin normales sern suficientes.
Otro criterio a considerar es si la lgica de su programa es probable que
cambiar. Una de las caractersticas principales de las redes neuronales es su capacidad para aprender. Si el
algoritmo utilizado para resolver su problema es una regla de negocio que no cambia, no hay razn
utilizar una red neural. De hecho, podra ser perjudicial para su aplicacin si el neural
red intenta encontrar una mejor solucin, y empieza a divergir del proceso deseado
y produce resultados inesperados.
Por ltimo, las redes neuronales a menudo no son adecuadas para los problemas en los que usted debe
sabe exactamente cmo se obtuvo la solucin. Una red neuronal puede ser muy til para
resolver el problema para el que fue entrenado, pero la red neuronal no puede explicar su
razonamiento. La red neuronal sabe algo porque fue entrenado para saberlo. El
red neuronal no puede explicar cmo se sigui una serie de pasos encaminados a obtener la respuesta.
1.2.2 Problemas Adecuado para una red neuronal
Aunque hay muchos problemas para los que las redes neuronales no son muy adecuadas,
tambin hay muchos problemas para los cuales una solucin de red neuronal es bastante til. En
Adems, las redes neuronales a menudo puede resolver los problemas con menos lneas de cdigo que un
algoritmo de programacin tradicional. Es importante entender que llaman problemas para
un enfoque de redes neuronales.
Las redes neuronales son particularmente tiles para la solucin de problemas que no pueden ser
expresada como una serie de pasos, tales como el reconocimiento de patrones, la clasificacin, la serie
prediccin, y la minera de datos.
El reconocimiento de patrones es quizs el uso ms comn de las redes neuronales. Para esto
tipo de problema, la red neuronal se presenta un patrn. Esto podra ser una imagen, una
Pgina 8
sonido, o cualquier otro dato. La red neuronal a continuacin, intenta determinar si los datos de entrada
coincide con un patrn que ha sido entrenado para reconocer. Habr muchos ejemplos en
este libro de la utilizacin de las redes neuronales para reconocer patrones.
La clasificacin es un proceso que est estrechamente relacionado con el reconocimiento de patrones. A neural
red entrenada para la clasificacin est diseada para tomar muestras de entrada y clasificarlos en
grupos. Estos grupos pueden ser borrosas, carente lmites claramente definidos. Alternativamente,
Estos grupos pueden tener lmites bastante rgidos.
A medida que lea, aunque este documento que, sin duda tiene preguntas acerca de la
Marco Encog. Uno de los mejores lugares para ir en busca de respuestas es los foros Encog en
Investigacin Heaton. Usted puede encontrar los foros de Heaton de investigacin en la siguiente URL:
http://www.heatonresearch.com/forum
Page 9
2 Instalacin y uso de Encog
Descarga Encog
Ejemplos de running
Ejecucin del Workbench
En este captulo se muestra cmo instalar y utilizar Encog. Esta consiste en la descarga Encog
desde el sitio Web Encog, instalar y luego ejecutar los ejemplos. Tambin ser
se muestra cmo ejecutar el Encog Workbench. Encog hace uso de Net. Este captulo
se supone que ya ha descargado e instalado el tiempo de ejecucin Net, as como
Visual Studio, o algn otro C # IDE.
Encog actualmente requiere NET Runtime 3.5 o superior. Se supone que est utilizando
Visual Studio 2008 o superior. Aunque Encog probablemente trabajar con otros IDEs C #, tales
como SharpDevelop, esta gua supone que est utilizando Visual Studio 2008 Puede
descargar una copia gratuita de Visual Studio, si cumple con ciertos requisitos, de la
siguiente URL.
Vamos a comenzar con la instalacin de Encog.
http://www.microsoft.com/exPress
Instalacin Encog
Siempre se puede descargar la ltima versin de Encog desde la siguiente URL:
En esta pgina, usted encontrar un enlace para descargar la ltima versin de Encog y encontrar el
siguientes archivos en el sitio de descarga Encog:
http://www.encog.org
El Encog Core
Los ejemplos Encog
El Encog Workbench
El Workbench Cdigo Fuente Encog
Para este documento, usted tendr que descargar los tres primeros archivos (Encog Core, y
Ejemplos Encog y Encog Workbench). Asegrese de seleccionar la versin Net / C # de
Encog, ya que tambin existe una versin Java de Encog.
Habr varias versiones de la mesa de trabajo disponibles. Usted puede descargar el
banco de trabajo como un ejecutable de Windows, un archivo script universal o una aplicacin de Macintosh.
Elija el sabor de la mesa de trabajo que ms se adapte a su ordenador. Tu no
necesita el cdigo fuente de mesa de trabajo para utilizar este documento.
Pgina 10
Compilar el Encog Core
A menos que usted desea modificar en s Encog, es poco probable que usted tendra que
compilar el ncleo Encog. Compilar el ncleo Encog ser recompilar y reconstruir el Encog
archivo core DLL. Es muy fcil volver a compilar el ncleo Encog utilizando Visual Studio. Busque
dentro del archivo central Encog y encontrar un archivo de Microsoft Solution (.sln)
llamado encog-core-cs.sln
Figura 2.1: Encog Core en Visual Studio
. Abra este archivo y ver Encog en Visual Studio,
como se ve en la Figura 2.1.
Para volver a compilar la DLL Encog, elija "Crear" y luego "Volver a generar solucin", como
usted desea reconstruir cualquier proyecto. Una vez que el proyecto ha sido reconstruido, se encuentra el nuevo
Archivo DLL ncleo Encog en el bin \ release
Compilar y ejecutar los ejemplos Encog
directorio de su proyecto.
Los ejemplos Encog se empaquetan como una solucin de Microsoft (.sln) enviar con una sola
Archivo de Microsoft Visual Studio Project (.csproj) para cada uno de los ejemplos. Puede ejecutar
estos proyectos individuales para ejecutar cada ejemplo.
La mayora de los ejemplos Encog son "modo de consola". Esto le permite ver cmo
crear redes neuronales sin una gran cantidad de "GUI de arriba." Para ejecutar una consola
ejemplo, usted debe ejecutar las ConsoleExamples
Debe especificar el ejemplo para funcionar como el primer argumento
proporcionado en el proyecto ejemplos.
Si lo ejecuta sin argumentos, ver la siguiente salida.
Los siguientes comandos estn disponibles:
adalinedigits
art1 de clasificar
bam
punto de referencia
cpn
bosque
Pgina 11
Hopfield-asociado
-Hopfield sencilla
imagen
lunar
mercado
multibench
OpenCL del ndice de referencia
OpenCL-comparar
-OpenCL concurrente
OpenCL-info
-OpenCL sencilla
OpenCL-manchas solares
OpenCL-tune
OpenCL-xor
persistir-encog
persistir en serie
-radial mltiples
las manchas solares
threadcount
cucharadita de recocido
cucharadita-Boltzmann
-cucharadita gentica
peso-init
xor-recocido
xor-Backprop
xor-elman
-xor gaussiano
-xor gentica
xor-jordan
xor-lma
xor-manhattan
-xor ordenada
xor-radial
xor-RProp
xor-SCG
xor-thresholdless
Esto le da a los comandos que puede utilizar para ejecutar los ejemplos individuales. Para
ejemplo, para ejecutar el ejemplo Rprop, utilice el siguiente comando.
ConsoleExamples -PAUSE xor-RProp
Tambin puede indicar el ejemplo para detener la salida. Esto puede ser muy til cuando se
ejecutar desde Visual Studio. De lo contrario no ver el ejemplo, ya que el
ventana se cierra a ayunar.
ConsoleExamples -PAUSE xor-RProp
Terceros libreras utilizadas por Encog
Slo hay dos archivos DLL externos necesarios para los ejemplos para correr. Ellos son
contenida en un directorio llamado dll. Estos archivos DLL se resumen aqu.
Pgina 12
encog-core-cs.dll
log4net.dll
nunit.core.dll
nunit.core.interfaces.dll
nunit.uikit.dll
La primera DLL es el ncleo Encog. Todos los proyectos que hacen uso de Encog utilizarn el
Ncleo Encog. El segundo DLL es log4net. Log4net es un paquete de registro utilizado por muchos
aplicaciones. Log4net se basa en un paquete similar, llamado LOG4J que es utilizado por
Encog Java. Los ltimos tres archivos DLL son utilizados por nUnit, que proporciona la unidad de pruebas para
Encog.
Ejecucin de un ejemplo de la lnea de comandos
Cualquiera de los ejemplos Encog se puede ejecutar desde la lnea de comandos. Simplemente navegue hasta
el directorio que contiene el archivo EXE del ejemplo. Una vez dentro de ese directorio ejecute
el ejemplo, como lo hara con cualquier aplicacin escribiendo su nombre y pulsando la tecla Intro.
Ejecucin de los ejemplos Encog en Visual Studio
Los ejemplos tambin se pueden ejecutar desde un IDE, como Visual Studio. Los ejemplos son
todos los proyectos individuales contenidos en un archivo de solucin nica. Dentro de los ejemplos
archivar se encuentra el archivo de solucin ejemplos, llamado EncogExamplesCS.sln
Ahora que ha seleccionado el proyecto, y lo hizo el proyecto de inicio, usted est listo
para ejecutar un ejemplo. Haga clic en la "flecha verde" en la barra de herramientas y ejecutar el ejemplo, como usted
sera ejecutar una aplicacin en Visual Studio.
.
Una vez que abra este archivo podrs ver las carpetas de proyectos individuales para toda la Encog
proyectos de ejemplo. Seleccione el proyecto que desea ejecutar y haga clic derecho en la carpeta.
En el men emergente del botn derecho, seleccione "Establecer como proyecto de inicio". Esto har que el
nombre de ese proyecto que aparezca en negrita.
Pgina 13
3 Introduccin a Encog
El Marco Encog
Qu es una red neuronal?
El uso de una red neuronal
Formacin de una Red Neuronal
Las redes neuronales artificiales estn programando tcnicas que tratan de emular el
redes neuronales biolgicas del cerebro humano. Las redes neuronales artificiales (RNAs) son slo una
rama de la inteligencia artificial (IA). Este documento se centra principalmente en neuronal artificial
redes, llamadas redes con frecuencia simplemente neuronales, y el uso de la Encog Artificial
Inteligencia Framework, por lo general slo se hace referencia como Encog. Encog es un cdigo abierto
proyecto que ofrece la red neural y HTTP funcionalidad bot.
Este documento explica cmo utilizar las redes neuronales con Encog y el C #
lenguaje de programacin. Aunque este documento se centra en C #, que podra ser utilizado como un
gua para otro idioma Net, como VB.Net. Obviamente, el cdigo contenido en este
tendra que ser traducido de C # para el idioma de su eleccin Net documento.
El nfasis de este documento es sobre el uso de las redes neuronales, en lugar de cmo
para crear el software necesario para implementar una red neural. Encog ofrece
todo el cdigo de bajo nivel necesario para construir diferentes tipos de redes neuronales.
Si usted est interesado en aprender a programar en realidad el funcionamiento interno de una red neuronal,
utilizando C #, usted puede estar interesado en el libro "Introduccin a las redes neuronales con C #"
(ISBN: 978-1604390094).
Encog proporciona las herramientas para crear muchos diferentes tipos de redes neuronales. Encog
apoya anticipativo, recurrente, la auto-organizacin de los mapas, la funcin de base radial y Hopfield
redes neuronales. Los tipos de bajo nivel proporcionadas por Encog pueden recombinarse y
extendido para soportar arquitecturas de red neural adicionales. El Encog
Marco se puede obtener en la siguiente direccin URL:
Encog se distribuye bajo la Licencia Pblica GNU Lesser (LGPL). Todo de la fuente
cdigo para Encog se proporciona en un repositorio Subversion (SVN) el cdigo fuente proporcionado por
el proyecto de Cdigo de Google. Encog tambin est disponible para las plataformas Java y Silverlight.
http://www.encog.org/
Redes neuronales Encog y datos relacionados, se pueden almacenar en archivos .eg. Estos archivos pueden ser
editado por un editor de interfaz grfica de usuario proporcionada con Encog. El Encog Workbench le permite editar,
capacitar y visualizar redes neuronales. El Encog Workbench puede generar cdigo en Java,
Visual Basic o C #. El Encog Workbench se puede descargar desde la URL anterior.
3.1 Qu es una red neuronal?
Comenzaremos examinando qu es exactamente una red neuronal es. Un simple feedforward
red neuronal se puede ver en la Figura 3.1. Este diagrama fue creado con la Encog
Workbench. No es slo un diagrama; esto es una red neuronal de funcionamiento real
Pgina 14
Encog como era en realidad editarlo.
Figura 3.1: Simple anticipativo Neural Network
Las redes tambin pueden llegar a ser ms complejo que la simple red anteriormente. Figura 3.2
muestra una red neuronal recurrente.
Figura 3.2: Simple recurrente Neural Network
En cuanto a las dos redes neuronales anteriores se dar cuenta de que estn compuestas de
capas, representadas por las cajas. Estas capas estn conectados por lneas, que representan
sinapsis. Sinapsis y capas son los bloques de construccin principales para redes neuronales
creado por Encog. El siguiente captulo se centra exclusivamente en las capas y las sinapsis.
Pgina 15
Antes de aprender a construir redes neuronales con capas y las sinapsis, primero vamos a ver
qu es exactamente una red neuronal es. Mira las Figuras 1.1 y 1.2. Son un poco
diferentes, pero comparten una caracterstica muy importante. Ambos contienen un solo
capa de entrada y una sola capa de salida. Lo que sucede entre estas dos capas es muy
diferentes, entre las dos redes. En este captulo, nos centraremos en lo que entra en
la capa de entrada y sale de la capa de salida. El resto del documento se enfocar en
lo que sucede entre estas dos capas.
Casi cada red neuronal se ve en este documento tendr, como mnimo, una entrada
y la capa de salida. En algunos casos, el mismo funcionar como capa de entrada y salida
capa. Usted puede pensar en el formato general de cualquier red neuronal que se encuentra en este documento
como se muestra en la Figura 3.3.
Figura 3.3: Forma genrica de una red neuronal
Para adaptar un problema a una red neural, debe determinar cmo alimentar el problema
en la capa de entrada de una red neuronal, y recibir la solucin a travs de la capa de salida
de una red neuronal. Vamos a ver las capas de entrada y de salida en este captulo. Lo haremos
luego determinar cmo estructurar la entrada e interpretar la salida. La capa de entrada es
donde vamos a empezar.
3.1.1 Comprensin de la capa de entrada
La capa de entrada es la primera capa en una red neuronal. Esta capa, al igual que todas las capas, tiene un
nmero especfico de neuronas en el mismo. Las neuronas en una capa contienen todas las propiedades similares.
El nmero de neuronas determina cmo se estructura la entrada a esa capa. Para cada
neurona de entrada, una doble
[] = new entrada doble doble [5];
valor se almacena. Por ejemplo, la siguiente matriz podra ser
utilizado como entrada a una capa que contena cinco neuronas.
Pgina 16
La entrada a una red neural es siempre una serie de dobles. El tamao de esta matriz
se corresponde directamente con el nmero de neuronas en esta capa. Encog utiliza la clase
INeuralData para sostener estas matrices. Usted puede fcilmente convertir la matriz anteriormente en un
INeuralData
Datos INeuralData = new BasicNeuralData (entrada);
objeto con la siguiente lnea de cdigo.
La interfaz INeuralData define cualquier "array como" datos que pueda ser presentado a
Encog. Siempre hay que presentar la entrada a la red neuronal en el interior de un
Objeto INeuralData. La clase implementa la BasicNeuralData
Interfaz INeuralData. El BasicNeuralData clase no es la nica manera de
proporcionar Encog con datos. Hay otras implementaciones de INeuralData
El
, Tambin.
Veremos otras implementaciones ms adelante en el documento.
Clase BasicNeuralData simplemente proporciona un soporte de datos basados en la memoria para la
red neuronal. Una vez que la red neuronal procesa la entrada, un INeuralData
3.1.2 Comprensin de la Capa de Salida
basado
clase se volvi de capa de salida de la red neuronal. La capa de salida es
discutido en la siguiente seccin.
La capa de salida es la capa final en una red neuronal. La capa de salida proporciona la
salida despus de todas las capas anteriores han tenido la oportunidad de procesar la entrada. La salida
de la capa de salida es muy similar en formato a los datos que se proporcionan a la entrada
capa. La red neuronal emite una serie de dobles.
La red neuronal envuelve la salida en una clase basada en la interfaz INeuralData.
La mayor parte de la construccin en los tipos de redes neuronales volver una clase BasicNeuralData como la
de salida. Sin embargo, el futuro, y el tercero, las clases de redes neuronales puede devolver otras clases
basados en otras implementaciones de la INeuralData
Las redes neuronales estn diseadas para aceptar la entrada, que es una matriz de dobles, y luego
producir una salida, que es tambin un conjunto de dobles. La determinacin de la forma de estructurar la
datos de entrada, y dar significado a la salida, son dos de los principales retos a
la adaptacin de un problema a una red neural. El verdadero poder de una red neuronal proviene de
sus capacidades de reconocimiento de patrones. La red neuronal debe ser capaz de producir el
salida deseada incluso si la entrada ha sido ligeramente distorsionada.
interfaz.
3.1.3 capas ocultas
Como se discuti previamente, las redes neuronales contienen y la capa de entrada y una capa de salida.
A veces la capa de entrada y la capa de salida son las mismas. A menudo, la capa de entrada y de salida
son dos capas separadas. Adems, pueden existir otras capas entre la entrada y la salida
capas. Estas capas se denominan capas ocultas. Estas capas ocultas pueden colocarse simplemente
entre las capas de entrada y salida. Las capas ocultas tambin pueden asumir ms compleja
estructuras.
El nico propsito de las capas ocultas es permitir que la red neuronal para productos de mejor
Pgina 17
la produccin prevista para la entrada dada. Programacin de la red neuronal implica en primer lugar
la definicin de los recuentos de neuronas capa de entrada y salida. Una vez que haya definido la forma de
traducir el problema de programacin en los recuentos de neuronas de entrada y salida, es el momento de
definir las capas ocultas.
Las capas ocultas son en gran medida un "recuadro negro". Se define el problema en trminos de
la neurona que cuenta para las capas ocultas y de salida. Cmo la red neuronal produce la
salida correcta se lleva a cabo, en parte, por las capas ocultas. Una vez que haya definido el
estructura de las capas de entrada y de salida debe definir una estructura de capas ocultas que
ptimamente aprende el problema. Si la estructura de la capa oculta es demasiado simple no puede
aprender el problema. Si la estructura es demasiado compleja, aprender el problema, pero ser
muy lento para entrenar y ejecutar.
En captulos posteriores de este documento discutirn muchos diferentes estructuras de capas ocultas.
Usted aprender cmo elegir una buena estructura, basado en el problema que usted est tratando de
resolver. Encog tambin contiene algunas funciones para determinar automticamente un potencialmente
ptima estructura de capa oculta. Adems, Encog tambin contiene funciones para podar espalda
una estructura demasiado compleja.
Algunas redes neuronales no tienen capas ocultas. La capa de entrada puede ser directamente
conectado a la capa de salida. Adems, algunas redes neuronales tienen slo una nica capa. A
red neuronal de una sola capa tiene la capa nica de auto-conexin. Estas conexiones permiten
la red para aprender. Contenido en estas conexiones, llamadas sinapsis, son individuales
matrices de peso. Estos valores se cambian como la red neural aprende. Aprenderemos
ms informacin sobre matrices de peso en el prximo captulo.
3.2 Uso de una red neuronal
Ahora vamos a buscar la forma de estructurar una red neuronal para un problema muy simple. Nosotros
se considere la creacin de una red neuronal que puede funcionar como un operador XOR. Aprendizaje
el operador XOR es una frecuente "primer ejemplo" al demostrar la arquitectura de un
nueva red neural. Al igual que la mayora de los nuevos lenguajes de programacin se demostr por primera vez
con un programa que simplemente muestra "Hello World", las redes neuronales son con frecuencia
demostrado con el operador XOR. Aprender el operador XOR es una especie de "Hola
Mundial "solicitud de las redes neuronales.
3.2.1 Las XOR Operador y Redes Neuronales
El operador XOR es uno de los tres operadores lgicos booleanos de uso comn. El
otros dos son el operadores AND y OR. Para cada uno de estos operadores lgicos, hay
cuatro combinaciones diferentes. Por ejemplo, todas las combinaciones posibles para la Y
operador se muestran abajo.
0 Y 0 = 0
1 Y 0 = 0
0 Y 1 = 0
1 Y 1 = 1
Pgina 18
Esto debe ser consistente con la forma en que aprendi el operador AND para ordenador
programacin. Como su nombre lo indica, el operador slo devolver verdadero, o uno, cuando
ambas entradas son verdaderas.
El operador OR se comporta de la siguiente manera.
0 O 0 = 0
1 O 0 = 1
0 OR 1 = 1
1 OR 1 = 1
Esto tambin debe ser coherente con la forma en que aprendi el operador OR para ordenador
programacin. Para el operador OR para ser verdad, cualquiera de las entradas debe ser verdad.
El (XOR) operador "exclusivo o" se usa con menos frecuencia en la programacin de computadoras,
por lo que puede no estar familiarizado con l. XOR tiene el mismo resultado que el operador OR, excepto
para el caso donde ambas entradas son verdaderas. Las posibles combinaciones para el operador XOR
se muestran aqu.
0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0
Como se puede ver el operador XOR slo devuelve verdadero cuando ambas entradas son diferentes. En el
siguiente seccin veremos cmo estructurar la entrada, salida y capas ocultas para el XOR
operador.
3.2.2 Estructuracin de una red neuronal para XOR
Hay dos entradas al operador XOR y una salida. Las capas de entrada y de salida
se estructurar en consecuencia. Vamos a alimentar a las neuronas de entrada el siguiente doble
0.0,0.0
valores:
1.0,0.0
0.0,1.0
1.0,1.0
Estos valores corresponden a las entradas al operador XOR, que se muestran arriba. Lo haremos
esperar la neurona una salida para producir la siguiente doble
0.0
valores:
1.0
1.0
0.0
Esta es una manera de que la red neural puede ser estructurado. Este mtodo permite una
sencilla red neuronal feedforward para aprender el operador XOR. El neuronal feedforward
red, tambin llamado un perceptrn, es uno de los primeros arquitecturas de redes neuronales que
aprendern.
Pgina 19
Hay otras maneras de que los datos XOR podran ser presentados a la red neural.
Ms adelante en este documento vamos a ver dos ejemplos de redes neuronales recurrentes. Lo haremos
examinar los estilos Elman y Jordania de las redes neuronales. Estos mtodos podran tratar el
Datos XOR como una secuencia larga. Bsicamente concatenar la tabla de verdad para el XOR juntos
y se obtiene una secuencia de XOR larga, tales 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 lnea son slo para facilitar su lectura. Esto es slo tratando XOR como una secuencia larga.
Mediante el uso de los datos anteriores, la red tendra una sola neurona de entrada y un nico
neurona de salida. La neurona de entrada se alimenta un valor de la lista anterior, y el
Sera de esperar neurona de salida para devolver el siguiente valor.
Esto demuestra que a menudo hay ms de una forma de modelar los datos para un neural
red. Cmo modelar los datos influirn en gran medida el xito de su neural
red. Si un modelo particular no funciona, puede que tenga que considerar otro. Para
los ejemplos de este documento vamos a considerar el primer modelo que miramos para el XOR
datos.
Debido a que el operador XOR tiene dos entradas y una salida, la red neuronal
seguir su ejemplo. Adems, la red neuronal tendr una sola capa oculta, con dos
neuronas para ayudar a procesar los datos. La eleccin de 2 neuronas en la capa oculta es
arbitraria, ya menudo se reduce a ensayo y error. El problema XOR es simple, y dos
neuronas ocultas son suficientes para resolverlo. Un diagrama para esta red se puede ver en
Figura 3.4.
Figura 3.4: Neurona Diagrama de la Red XOR
Por lo general, las neuronas individuales no se dibujan en diagramas de redes neuronales. Hay
menudo demasiados. Neuronas similares se agrupan en capas. Las pantallas del banco de trabajo Encog
redes neuronales sobre una base capa por capa. La Figura 3.5 muestra cmo la red anterior es
representado en Encog.
Pgina 20
Figura 3.5: Diagrama Encog Capa de la Red XOR
El cdigo necesario para crear esta red es relativamente simple.
Red BasicNetwork = new BasicNetwork ();
network.AddLayer (nuevo BasicLayer (2));
network.Structure.FinalizeStructure ();
network.Reset ();
En el cdigo anterior se puede ver un BasicNetwork est creando. Tres capas son
aadido a esta red. La primera capa, que se convierte en la capa de entrada, tiene dos neuronas.
La capa oculta se aade segundos, y tiene tambin dos neuronas. Por ltimo, la capa de salida es
aadido, que tiene una sola neurona. Finalmente, el FinalizeStructure mtodo debe ser
llamada para informar a la red que no hay ms capas se van a aadir. La llamada a Restablecer
Las redes neuronales con frecuencia comienzan con una matriz de pesos al azar. Esto proporciona una
punto de partida para los mtodos de entrenamiento. Estos valores aleatorios sern probados y refinados
en una solucin aceptable. Sin embargo, a veces los valores aleatorios iniciales son demasiado
apagado. A veces puede ser necesario volver a ajustar los pesos de nuevo, si la formacin es ineficaz.
aleatoriza los pesos en las conexiones entre estas capas.
Estos pesos constituyen la memoria a largo plazo de la red neuronal. Adems,
algunas capas tienen valores de umbral que tambin contribuyen a la memoria a largo plazo de la
red neuronal. Algunas redes neuronales tambin contienen capas de contexto, que dan la neural
red una memoria a corto plazo tambin. La red neuronal aprende mediante la modificacin de estos
valores de peso y umbral.
Ahora que la red neuronal ha sido creado, debe ser entrenado. La formacin es
discutido en la siguiente seccin.
Pgina 21
3.2.3 Formacin de una Red Neuronal
Para entrenar la red neuronal, debemos construir un INeuralDataSet
0 XOR 0 = 0
objeto. Este
objeto contiene las entradas y los resultados esperados. Para construir este objeto, debemos
crear dos arrays. La primera matriz que contenga los valores de entrada para el operador XOR. El
segunda matriz mantendr las salidas ideales para cada uno de 115 valores de entrada correspondientes.
Estos corresponden a los valores posibles para XOR. Para revisar, los cuatro posibles
valores son los siguientes:
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0
En primer lugar vamos a construir una matriz para que contenga los cuatro valores de entrada para el operador XOR.
Esto se hace utilizando una de dos dimensiones doble
doble [] [] XOR_INPUT public static = {
matriz. Esta matriz es la siguiente:
nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
Del mismo modo, una matriz debe ser creado para los productos previstos para cada una de la entrada
valores. Esta matriz es la siguiente:
doble [] [] XOR_IDEAL public static = {
Nuevo Doble [1] {0,0},
nuevo doble [1] {0,0}};
A pesar de que slo hay un valor de salida, todava tenemos que utilizamos una matriz bidimensional
para representar la salida. Si hubiera habido ms de una neurona de salida, tendra que
sido columnas adicionales en la matriz anterior.
Ahora que las dos matrices de entrada se han construido un INeuralDataSet
INeuralDataSet trainingSet = new BasicNeuralDataSet (XOR_INPUT,
XOR_IDEAL);
objeto
se debe crear para sostener el conjunto de entrenamiento. Este objeto se crea de la siguiente manera.
Ahora que el conjunto de entrenamiento se ha creado, la red neuronal puede ser entrenado. Entrenamiento
es el proceso donde los pesos de la red neuronal se ajustan para producir la mejor
resultado esperado. Formacin continuar por muchas iteraciones, hasta que la tasa de error de la
red est por debajo de un nivel aceptable. En primer lugar, un objeto de la formacin debe ser creado. Encog
compatible con muchos tipos diferentes de entrenamiento.
Para este ejemplo vamos a utilizar Propagacin Resiliente (Rprop). Rprop es
quizs el mejor algoritmo de entrenamiento de uso general con el apoyo de Encog. Otra formacin
tcnicas se proporcionan, as como ciertos problemas se resuelven mejor con cierta
tcnicas de entrenamiento. El cdigo siguiente construye un entrenador Rprop.
Pgina 22
ITrain tren = new ResilientPropagation (red, trainingSet);
Todas las clases de capacitacin apliquen la ITrain interfaz. El algoritmo es Rprop
implementado por el ResilientPropagation
Una vez que el entrenador se ha construido la red neuronal debe ser entrenado. Entrenamiento
la red neuronal consiste en llamar a la
clase, que est construido anteriormente.
Iteracin mtodo en la ITrain
int poca = 1;
clase hasta
el error est por debajo de un valor especfico.
hacer
{
train.Iteration ();
Console.WriteLine ("Epoch #" + + poca "Error:" + train.Error);
poca ++;
} While ((poca <5,000) && (train.Error> 0,01));
El cdigo anterior recorre tantas iteraciones, o pocas, como sea necesario para obtener el error
tarifa para la red neuronal a estar por debajo de 1%. Una vez que la red neuronal se ha entrenado,
est listo para su uso. La siguiente seccin le explicar cmo utilizar una red neuronal.
3.2.4 Ejecucin de una red neuronal
Haciendo uso de la red neuronal consiste en llamar a la Compute en el mtodo
BasicNetwork
Console.WriteLine ("Resultados de red neuronal:");
clase. Aqu bucle a travs de cada valor conjunto de entrenamiento y mostrar el
salida de la red neuronal.
foreach (par INeuralDataPair en trainingSet)
{
Salida INeuralData = network.Compute (pair.Input);
Console.WriteLine (pair.Input [0] + "," + pair.Input [1]
+ ", Real =" + salida [0] + ", ideales =" + pair.Ideal [0]);
}
El Compute mtodo acepta un INeuralData clase y tambin devuelve un
INeuralData
Epoch # 1 Error: 0,5604437512295236
objeto. Este contiene la salida de la red neural. Esta salida es
se muestra al usuario. Con la ejecucin del programa se muestran primero los resultados de la capacitacin. Para
Cada poca, se muestra la tasa de error actual.
Epoch # 2 Error: ,5056375155784316
Epoch # 3 Error: 0,5026960720526166
Epoch # 4 Error: ,4907299498390594
...
Epoch # 104 Error: 0.01017278345766472
Epoch # 105 Error: 0,010557202078697751
Epoch # 106 Error: ,011034965164672806
Epoch # 107 Error: ,009682102808616387
El error comienza en 56% en poca 1. poca 107 el entrenamiento se ha reducido por debajo del 1%
Pgina 23
y la formacin se detiene. Debido a que la red neural se ha inicializado con pesos aleatorios, puede
tener diferentes nmeros de iteraciones para entrenar cada vez que el programa se ejecuta. Adems,
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 formacin de la siguiente manera:
Resultados de red neuronal:
0.0,0.0, real = 0.002782538818034049, ideales = 0.0
1.0,0.0, real = 0.9903741937121177, ideales = 1.0
0.0,1.0, real = 0.9836807956566187, ideales = 1.0
1.0,1.0, real = ,0011646072586172778, ideales = 0.0
Como puede ver, la red no ha sido entrenado para dar los resultados exactos. Esto es
normal. Debido a que la red fue entrenada a un error del 1%, cada uno de los resultados tambin habr
generalmente dentro de 1% del valor esperado.
Debido a que la red neuronal se inicializa a valores aleatorios, el resultado final ser
diferente en segundos de ejecucin del programa.
0.0,0.0, real = 0.005489822214926685, ideales = 0.0
1.0,0.0, real = 0.985425090860287, ideales = 1.0
0.0,1.0, real = 0.9888064742994463, ideales = 1.0
1.0,1.0, real = ,005923146369557053, ideales = 0.0
Por encima, se ve una segunda carrera del programa. La salida es ligeramente diferente. Esto es
normal.
Este es el primer ejemplo Encog. Puedes ver el programa completo en el listado 1.1. Todos
de los ejemplos contenidos en este documento tambin se incluyen con los ejemplos
descargado con Encog.
Listing 1.1: Resolver XOR con Rprop
using System;
utilizando System.Collections.Generic;
utilizando System.Linq;
utilizando System.Text;
utilizando Encog.Neural.Networks;
utilizando Encog.Neural.Networks.Layers;
utilizando Encog.Neural.Data.Basic;
utilizando Encog.Neural.NeuralData;
utilizando Encog.Neural.Networks.Training;
utilizando Encog.Neural.Data;
utilizando Encog.Neural.Networks.Training.Propagation.Resilient;
utilizando ConsoleExamples.Examples;
utilizando Encog.Engine.Network.Activation;
XORResilient clase pblica: IExample
{
public static Info ExampleInfo
{
conseguir
{
Pgina 24
Info ExampleInfo = new ExampleInfo (
typeof (XORResilient),
"Xor-RProp",
"Operador XOR con Propagacin resilientes",
"Usar Rprop aprender el operador XOR.");
devolver informacin;
}
}
/// <Summary>
/// De entrada para la funcin XOR.
/// </ Summary>
nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
/// <Summary>
/// Salida ideal para la funcin XOR.
/// </ Summary>
/// <Summary>
/// Punto de entrada del programa.
/// </ Summary>
/// <Param name = "args"> No se utiliza. </ Param>
public void Execute (IExampleInterface app)
{
network.AddLayer (nuevo BasicLayer (
nueva ActivationSigmoid (), verdadera, 2));
nueva ActivationSigmoid (), es cierto, 1));
network.Reset ();
INeuralDataSet trainingSet =
nueva BasicNeuralDataSet (XOR_INPUT, XOR_IDEAL);
// Entrenar la red neuronal
ITrain tren =
nueva ResilientPropagation (red, trainingSet);
int poca = 1;
hacer
{
train.Iteration ();
Console.WriteLine ("Epoch #" + + poca "Error:"
Pgina 25
+ Train.Error);
poca ++;
} While ((poca <5,000) && (train.Error> 0.001));
doble [] inputArray = {0,0, 1,1};
INeuralData InputData = new BasicNeuralData (inputArray);
INeuralData datosSalida = network.Compute (datosEntrada);
Console.WriteLine ("salida de la red:"
+ OutputData.ToString ());
// Probar la red neuronal
{
+ ", Real =" + salida [0] + ", ideales ="
+ Pair.Ideal [0]);
}
}
}
}
3.3 Resumen del captulo
Encog es un marco que permite crear redes neuronales o aplicaciones bots.
Este documento se centra en el uso de Encog para crear aplicaciones de redes neuronales. Este
captulo se centr en el diseo general de una red neuronal. En este captulo, hemos visto cmo
para crear una aplicacin Encog que podra aprender el operador XOR.
Las redes neuronales se componen de capas. Estas capas estn conectadas por sinapsis. El
sinapsis contienen pesos que componen la memoria de la red neuronal. Algunas capas
tambin contienen valores de umbral que tambin contribuyen a la memoria de la red neuronal.
Juntos, los umbrales y pesos constituyen la memoria a largo plazo de la red neuronal.
Las redes tambin pueden contener capas de contexto. Capas de contexto se utilizan para formar un corto plazo
memoria.
Hay varios tipos de capas diferentes soportados por Encog. Sin embargo, estas capas caen
en tres grupos, dependiendo de dnde se colocan en la red neuronal. La entrada
capa acepta la entrada desde el exterior. Las capas ocultas aceptar datos de la capa de entrada para los
su posterior procesamiento. La capa de salida toma los datos, ya sea desde la entrada o final oculta
capa, y lo presenta en el mundo exterior.
El operador XOR se utiliza como ejemplo para este captulo. El operador XOR es
utilizado con frecuencia como una aplicacin "Hello World" simple para las redes neuronales. El XOR
operador proporciona un modelo muy simple que las redes neuronales pueden aprender ms fcilmente. Es
importante saber cmo estructurar los datos para una red neural. Las redes neuronales tanto
aceptar y devolver una matriz de nmeros de punto flotante.
Pgina 26
En este captulo se introdujo capas y sinapsis. Usted vio cmo se utilizan para construir
una red neuronal simple. El siguiente captulo se ampliar en gran medida de las capas y las sinapsis.
Ver cmo utilizar los distintos tipos de capas y sinapsis que ofrece Encog a
construir redes neuronales.
Pgina 27
4 Uso de las funciones de activacin
Cules son las capas y las sinapsis?
Tipos de capa Encog
Tipos Encog Synapse
Propiedades de red neuronal
Neural Network Lgica
Edificio con Capas y sinapsis
Redes neuronales Encog se componen de capas, sinapsis, propiedades y una lgica
definicin. En este captulo vamos a examinar los distintos tipos de capas y las sinapsis
apoyada por Encog. Usted ver cmo los tipos de capas y sinapsis se pueden combinar para
crear una variedad de tipos de redes neuronales.
4.1 Cules son las capas y las sinapsis?
Una capa es una coleccin de neuronas similares. Todas las neuronas en la capa deben compartir exactamente
las mismas caractersticas que otras neuronas en esta capa. Una capa acepta un parmetro que
especifica el nmero de neuronas de esa capa es tener. Capas tienen una serie de umbral
valores. Hay un valor umbral para cada una de las neuronas en la capa. El umbral
valores, junto con la matriz de peso forman la memoria a largo plazo de la red neuronal.
Algunas capas tambin tienen valores de contexto que componen la memoria a corto plazo de la neural
red.
Una sinapsis se utiliza para conectar una capa a otra. Las sinapsis contienen el peso
matrices utilizados por la red neuronal. Las matrices de peso tienen los valores de conexin
entre cada una de las neuronas en las dos capas que estn conectados por esta sinapsis.
Cada red neuronal Encog contiene una clase lgica neural. Esta clase define cmo un
red neuronal procesa sus capas y sinapsis. Una clase lgica neuronal debe implementar
la INeuralLogic interfaz. Cada red neuronal Encog debe tener una
INeuralLogic clase lgica basada. Sin una clase como la red no sera capaz
para procesar los datos entrantes. INeuralLogic
Algunos
clases permiten Encog para ser compatible con una
amplia gama de tipos de redes neuronales.
INeuralLogic clases requieren tipos de capas especficas. Para el
INeuralLogic
Propiedades de la red neural se almacenan en una coleccin de pares de nombre y valor. Ellos son
almacenado en un sencillo
clases para encontrar estas capas, las capas deben ser etiquetados. Tagging permite
un tipo que se asignar a cualquier capa de la red neuronal. No todas las capas deben ser etiquetados.
IDictionary estructura. Algunos INeuralLogic
Las redes neuronales son construidos de capas y las sinapsis. Hay varios diferentes
tipos de capas y las sinapsis, proporcionados por Encog. En este captulo se presentar toda la
Encog tipos de capas y tipos de sinapsis. Vamos a comenzar por examinar los tipos de capa Encog.
clases requieren
parmetros especficos que se establezcan para que funcionen. Estos parmetros se almacenan en la
propiedades de la red neural.
Pgina 28
4.2 Capas Encog Comprensin
Hay un total de tres tipos de capas diferentes utilizados por Encog. En esta seccin
examinar cada uno de estos tipos de capas. Los tres de estos tipos de capas aplicar la ilayer
interfaz. A medida que se aaden tipos de capas adicionales para Encog, apoyarn la iLayer
interfaz tambin. Vamos a comenzar por examinar el iLayer
4.2.1 Uso de la interfaz de capa
interfaz.
El iLayer interfaz define muchos mtodos importantes que todas las capas deben apoyar.
Adems, la mayora de las capas Encog implementar un constructor que inicializa ese tipo nico
de la capa. Listado 4.1 muestra la iLayer
Ficha 4.1: La interfaz de capa
interfaz.
iLayer interfaz pblica: ICloneable, IEncogPersistedObject
{
anular AddNext (iLayer siguiente);
anular AddNext (iLayer siguiente, tipo SynapseType);
void AddSynapse (ISynapse sinapsis);
INeuralData Compute (patrn INeuralData);
IActivationFunction ActivationFunction
{
conseguir;
establecido;
}
int NeuronCount
{
conseguir;
establecido;
}
IList <ISynapse> Siguiente
{
conseguir;
}
ICollection <iLayer> NextLayers
{
conseguir;
}
doble [] Umbral
{
conseguir;
establecido;
}
int X
{
conseguir;
establecido;
Pgina 29
}
int Y
{
conseguir;
establecido;
}
int ID
{
conseguir;
establecido;
}
HasThreshold bool
{
conseguir;
}
bool IsConnectedTo (capa iLayer);
Proceso de vaco (patrn INeuralData);
INeuralData Repetir ();
}
Como puede ver, hay una serie de mtodos que se deben implementar para crear un
capa. Ahora vamos a revisar algunos de los mtodos ms importantes.
El AddNext mtodo se utiliza para conectar otra capa a ste. La siguiente capa es
conectado con un ISynapse . Hay dos sobrecargas a la AddNext mtodo. El
primero le permite simplemente especifique la siguiente capa y un WeightedSynapse es
creado automticamente para conectar la nueva capa. La segunda permite especificar la
siguiente capa y utilizar la SynapseType enumeracin para especificar qu tipo de sinapsis que
le gustara conectar las dos capas. Adems, el AddSynapse mtodo permite
a pasar simplemente en una ya creada ISynapse
El
.
Siguiente propiedad se puede llamar para obtener una IList de las ISynapse objetos utilizados para
conectar a los prximos niveles. Adems, el NextLayers propiedad se puede utilizar para
determinar qu capas este iLayer est conectado. Para ver si esta capa est conectado
a otra especfica iLayer llamada la IsConnectedTo
El
mtodo.
Umbral propiedad permite el acceso a los valores de umbral para esta capa. El
valores umbrales son valores numricos que cambian como la red neuronal es entrenado, junto
con los valores de la matriz de peso; forman la memoria a largo plazo de la red neuronal.
No todas las capas tienen valores de umbral; la HasThreshold
El
propiedad se puede utilizar para
determinar si una capa tiene valores de umbral.
Activacin propiedad permite el acceso a la funcin de activacin. Activacin
funciones son funciones matemticas que escalan la salida de una capa de neuronas. Encog
soporta muchas funciones de activacin diferentes. Funciones de activacin se tratarn en
Pgina 30
con mucho ms detalle en el prximo captulo.
Finalmente, el Compute se proporciona mtodo que se aplica la funcin de activacin y hace
cualquier otro proceso interno necesario para Calcular la salida de esta capa. Vas a
No suele llamar Compute directamente, en lugar usted llame a la Compute mtodo en la
INetwork que esta capa est unida a, y llamar a la adecuada Compute
4.2.2 Uso de la capa bsica
funciones para sus diversas capas.
El BasicLayer implementa el ilayer interfaz. El BasicLayer clase tiene
dos propsitos principales. En primer lugar, muchos tipos de redes neuronales pueden ser construidos totalmente de
BasicLayer objetos, ya que es una capa muy til en su propio derecho. En segundo lugar, la
BasicLayer proporciona la funcionalidad bsica que algunas otras capas requieren. Como
En consecuencia, algunas de las otras capas en Encog subclase son la base sobre la BasicLayer
La forma ms bsica de la
clase.
BasicLayer
constructor acepta un nico entero
parmetro que especifica el nmero de neuronas de esta capa tendr. Este constructor crea
una capa que utiliza valores de umbral y la funcin tangente hiperblica como la activacin
funcin. Por ejemplo, el cdigo siguiente crea tres capas, con un nmero variable de
neuronas.
network.Reset ();
Si desea ms control sobre la capa, puede utilizar una forma ms avanzada
constructor. El siguiente constructor permite especificar la funcin de activacin, como
as como si se deben usar valores de umbral.
network.AddLayer (nuevo BasicLayer (nuevo ActivationSigmoid (), verdadera, 2));
network.AddLayer (nuevo BasicLayer (nuevo ActivationSigmoid (), es cierto, 1));
network.Reset ();
El cdigo anterior crea el mismo tipo de red que el segmento de cdigo anterior;
sin embargo, se utiliza una funcin de activacin sigmoide. La verdadera
El
parmetro significa que
deben utilizarse los valores de umbral. Algunas arquitecturas de redes neuronales no utilizan umbral
valores, mientras que otros lo hacen. A medida que avance a travs de este documento, ver tanto
redes que utilizan, as como aquellos que no utilizan valores de umbral.
BasicLayer clase se utiliza para muchos tipos de redes neuronales en este documento.
Pgina 31
4.2.3 Uso de la capa de Contexto
El ContextLayer
Capas de contexto se utilizan generalmente con una red neuronal recurrente. Neuronales recurrentes
las redes no se alimentan las capas justo delante. Capas estarn conectados de nuevo en el flujo
de la red neuronal.
clase implementa una capa contextual. Esta capa permite que el
red neuronal para tener una memoria a corto plazo. La capa de contexto siempre recuerda el
ltimos valores de entrada que fueron alimentados a la misma. Esto hace que la capa de contexto siempre que lo salida
originalmente recibido en la ejecucin previa de la red neuronal. Esto permite que el neural
red para recordar el ltimo dato que fue alimentado a l en la carrera anterior. El contexto
capa es siempre una iteracin atrs.
Contexto iLayer = new ContextLayer (2);
network.AddLayer (oculto = new BasicLayer (2));
hidden.AddNext (contexto, SynapseType.OneToOne);
context.AddNext (oculto);
El cdigo anterior muestra una ContextLayer utilizado con regulares BasicLayer objetos.
La salida de la capa oculta de la red neural anterior no slo va a la salida
capa. La salida de la capa oculta tambin se alimenta en el ContextLayer . A
OneToOneSynapse se utiliza para alimentar el ContextLayer . Simplemente queremos el contexto
la capa de recordar la salida de la capa oculta; no queremos ningn procesamiento. A
WeightedSynapse se alimenta de la ContextLayer porque queremos adicional
procesamiento. Queremos que la red neuronal que aprende de la salida del
ContextLayer
Estas caractersticas permiten que el
.
ContextLayer a ser muy til para reconocer
secuencias de datos de entrada. Los patrones ya no son mutuamente excluyentes cuando se utiliza un
ContextLayer
4.2.4 Usando la capa de Funcin de base radial
. Si "Modelo A" se presenta a la red neuronal, seguido por
"Modelo B", que es muy diferente a "Patrn B" se present por primera vez. Sin un contexto
capa, el orden no importa.
El RadialBasisFunctionLayer objeto implementa una funcin de base radial
Capa (RBF). Este tipo de capa se basa en una o ms funciones RBF. A base radial
funcin alcanza un pico y disminuye rpidamente en ambos lados de la grfica. Uno de los
mayora de las funciones de base radial comn es la funcin de Gauss. La funcin gaussiana es
la opcin por defecto para el RadialBasisFunctionLayer clase. Usted puede ver el
Funcin de Gauss en la Figura 4.1.
Pgina 32
Figura 4.1: La funcin de Gauss
La figura anterior muestra un grfico de la funcin de Gauss. Por lo general, varios de Gauss
funciones se combinan para crear un RadialBasisFunctionLayer . La siguiente
segmento de cdigo muestra el RadialBasisFunctionLayer
RadialBasisFunctionLayer rbfLayer;
como parte de un neuronal RBF
red.
network.AddLayer (nuevo BasicLayer (nuevo ActivationLinear (), falsa, 2));
network.AddLayer (rbfLayer = new RadialBasisFunctionLayer (4),
SynapseType.Direct);
network.Reset ();
rbfLayer.RandomizeGaussianCentersAndWidths (0, 1);
Como se puede ver en el cdigo anterior, la capa RBF se utiliza como una capa oculta entre
dos BasicLayer
4.3 Comprensin de sinapsis Encog
objetos.
En el apartado anterior hemos visto cmo las redes neuronales se compone de capas. Las sinapsis
se utilizan para conectar estas capas juntas. Encog soporta una variedad de diferentes sinapsis
tipos. Las sinapsis se utilizan para transportar informacin entre los niveles de una red neuronal.
Las sinapsis difieren principalmente en lo que el procesamiento de cmo las neuronas estn conectadas y
se debe hacer en la informacin a medida que fluye entre los niveles.
Algunos de los tipos de sinapsis apoyados por Encog hacen uso de matrices de peso. A
matriz de peso permite que las conexiones entre cada una de las neuronas de la capa de origen a tienen
su conexin pondera a la capa neurona diana. Mediante el ajuste de cada uno de estos pesos,
la red neuronal puede aprender.
En la siguiente seccin usted aprender acerca de los tipos de sinapsis que Encog apoya. Cualquier
sinapsis que Encog utiliza debe ser compatible con el ISynapse interfaz. Esta interfaz
se discute en la siguiente seccin.
Pgina 33
4.3.1 La interfaz de la sinapsis
El ISynapse interfaz define todos los mtodos esenciales que una clase debe apoyar
para funcionar como una sinapsis. El ISynapse
Ficha 4.2: La interfaz de la sinapsis
interfaz se muestra en el listado 4.2.
ISynapse interfaz pblica: IEncogPersistedObject
{
INeuralData Compute (entrada INeuralData);
ILayer FromLayer
{
conseguir;
establecido;
}
int FromNeuronCount
{
conseguir;
}
Matrix.Matrix WeightMatrix
{
conseguir;
establecido;
}
int MatrixSize
{
conseguir;
}
ILayer ToLayer
{
conseguir;
establecido;
}
int ToNeuronCount
{
conseguir;
}
SynapseType SynapseType
{
conseguir;
}
bool IsSelfConnected
{
conseguir;
}
bool IsTeachable
Pgina 34
{
conseguir;
}
}
Como puede ver, hay una serie de mtodos que se deben implementar para crear un
sinapsis. Ahora vamos a revisar algunos de los mtodos ms importantes.
Los FromLayer y ToLayer propiedades se pueden utilizar para encontrar el origen y el destino
capas para la sinapsis neuronal. El IsSelfConnected
El
tambin se puede utilizar para determinar si
la sinapsis crea una capa auto-conectada. Encog tambin soporta capas independientes conectados. A
capa es auto-conectado si tiene una sinapsis auto-conectado. Una sinapsis conectado consigo mismo es un
sinapsis, donde la "de capa" y "a la capa" son la misma capa.
WeightMatrix propiedad permite el acceso a la matriz de peso para el neural
red. Una red neuronal que tiene una matriz de peso es "enseanza", y el
IsTeachable mtodo devolver true . El MatrixSize
Por ltimo, la
la propiedad tambin puede ser
llamada para determinar el tamao de la matriz de peso.
Calcular mtodo se aplica a condicin de que cualquier sinapsis especfica
transformacin, tales como matrices de peso. No suele llamars Compute directamente,
ms bien se le llame a la Compute mtodo en la INetwork que esta capa est unida a,
y se llamar a la adecuada Compute
4.3.2 Las sinapsis Construyendo
funciones para sus diversas sinapsis.
A menudo, las sinapsis son simplemente creados en el fondo y el programador no es
realmente conscientes de qu tipo de sinapsis, incluso se est creando. El addLayer mtodo de
la BasicNetwork clase crea automticamente una nueva WeightedSynapse
El
cada vez
una nueva capa se aade a la red neural.
AddLayer mtodo de la BasicNetwork clase esconde un poco de complejidad.
Sin embargo, es til para ver lo que realmente est pasando, y cmo se crean las sinapsis.
Las siguientes lneas de cdigo se mostrar cmo crear una red neuronal "desde cero",
donde cada objeto que se necesita para crear la red neuronal se crea a mano. El
primer paso es crear un BasicNetwork
red = new BasicNetwork ();
oponerse a mantener las capas.
A continuacin, creamos tres capas. Capas ocultas, de entrada y salida se crean todo.
ILayer inputLayer = new BasicLayer (nuevo ActivationSigmoid (),
verdadera, 2);
ILayer hiddenLayer = new BasicLayer (
nueva ActivationSigmoid (), verdadera, 2);
ILayer outputLayer = new BasicLayer (
nueva ActivationSigmoid (), es cierto, 1);
Se necesitan dos sinapsis para conectar estas tres capas juntas. Una sinapsis tiene
la entrada a la capa oculta. La segunda sinapsis tiene el oculto a la capa de salida.
Pgina 35
Las siguientes lneas de cdigo crean estas sinapsis.
ISynapse synapseInputToHidden = new
WeightedSynapse (inputLayer, hiddenLayer);
ISynapse synapseHiddenToOutput = new
WeightedSynapse (hiddenLayer, outputLayer);
Estas sinapsis continuacin, se pueden aadir a las dos capas que se originan a partir.
inputLayer.Next.Add (synapseInputToHidden);
hiddenLayer.Next.Add (synapseHiddenToOutput);
El BasicNetwork
network.TagLayer (BasicNetwork.TAG_INPUT, inputLayer);
objeto debe ser informado lo que la entrada y la capa de salida.
Por ltimo, la estructura de la red debe ser finalizado y la matriz de pesos y el umbral
los valores volvern.
network.TagLayer (BasicNetwork.TAG_OUTPUT, outputLayer);
network.Reset ();
En esta seccin se discutirn los diferentes tipos de sinapsis apoyados por Encog. Lo haremos
comenzar con la sinapsis ponderado.
4.3.3 Uso de la clase WeightedSynapse
La sinapsis ponderado es quizs el tipo ms comnmente utilizado sinapsis en Encog.
El WeightedSynapse clase es utilizado por muchos diferentes arquitecturas de redes neuronales.
Cualquier lugar que se necesita una sinapsis de aprendizaje, la WeightedSynapse clase es una buena
candidato. El WeightedSynapse
Figura 4.2: La sinapsis ponderado
conecta cada neurona en la capa de origen con
cada neurona en la capa de destino. La Figura 4.2 muestra un diagrama de la sinapsis ponderado.
Este es el tipo de sinapsis por defecto para Encog. Para crear un objeto sinapsis ponderada
por lo general usted slo tiene que aadir una capa a la red. El tipo de sinapsis por defecto es el
sinapsis ponderado. Tambin puede construir un objeto de sinapsis ponderada con la siguiente
lnea de cdigo.
ISynapse sinapsis = new WeightedSynapse (from, to);
Pgina 36
Una vez que la sinapsis ponderada ha sido creado, puede ser aadido a la prxima coleccin en
El objetivo de la capa de origen.
4.3.4 Uso de la Weightless Sinapsis
La sinapsis ingravidez funciona muy similar a la sinapsis ponderado. La primaria
diferencia es que no hay pesos en la sinapsis de ingravidez. Proporciona una conexin
entre cada una de las neuronas en la capa de origen a cada otra neurona en la capa de destino.
La figura 4.3 muestra la sinapsis de ingravidez.
Figura 4.3: El Weightless Sinapsis
La sinapsis ingravidez se implementa dentro del WeightlessSynapse
ISynapse sinapsis = new WeightlessSynapse (from, to);
clase.
La siguiente lnea de cdigo construir una sinapsis de ingravidez.
La sinapsis sin peso se utiliza cuando se desea conectar completamente dos capas, pero
desea que la informacin pase a travs de la capa de destino sin tocar. La ingravidez
sinapsis es enseable.
4.3.5 Uso de la sinapsis OneToOne
El de una sinapsis funciona muy similar a la sinapsis peso. Al igual que el
sinapsis sin peso, el de una sinapsis no incluye los valores de peso. El
diferencia principal es que cada neurona en la capa de origen est conectado a la
neurona correspondiente en la capa de destino. Cada neurona est conectada a una sola otra
neurona. Debido a esto, el que una sinapsis requiere que las capas de origen y de destino
tener el mismo nmero de neuronas. La figura 4.4 muestra el de una sinapsis.
Pgina 37
Figura 4.4: El Uno a Uno de la sinapsis
El siguiente segmento de cdigo muestra cmo construir una red neuronal que hace uso
de una una a una capa. El de una capa se utiliza en conjuncin con una capa de contexto.
Contexto iLayer = new ContextLayer (2);
network.AddLayer (oculto = new BasicLayer (2));
hidden.AddNext (contexto, SynapseType.OneToOne);
context.AddNext (oculto);
El de una sinapsis se utiliza generalmente para alimentar directamente los valores de la salida de
una capa a una capa de contexto. Sin embargo, puede servir a cualquier propsito que usted desea
enviar una copia de la salida de una capa a otra capa de tamao similar.
4.3.6 Uso de la sinapsis directa
La sinapsis directa es til cuando se desea enviar una copia completa de la salida
desde la fuente a cada neurona en el objetivo. La mayora de las capas no estn diseados para aceptar una
matriz a partir de cada neurona fuente, por lo que el nmero de capas que la sinapsis directa se puede
usado con es limitado. Actualmente, el nico tipo de capa Encog que apoya la
DirectSynapse es la RadialBasisFunctionLayer
Figura 4.5: La sinapsis directa
clase. Figura 4.5 muestra
cmo funciona la sinapsis directa.
El siguiente segmento de cdigo muestra cmo utilizar el DirectSynapse .
Pgina 38
RadialBasisFunctionLayer rbfLayer;
nueva ActivationLinear (), falsa, 2));
network.AddLayer (rbfLayer = new RadialBasisFunctionLayer (4),
SynapseType.Direct);
network.Reset ();
rbfLayer.RandomizeGaussianCentersAndWidths (0, 1);
Como puede ver, la DirectSynapse se utiliza para alimentar a una
RadialBasisFunctionLayer
4.4 Entendimiento Neural Lgica
.
Cada red neuronal Encog debe contener una clase lgica neuronal. El INeuralLogic
clases definen cmo procesar una red neuronal sus capas y las sinapsis. Toda la lgica neuronal
clases deben implementar la INeuralLogic interfaz. Por defecto, un BasicNetwork
clase har uso de la SimpleRecurrentLogic clase lgica. Esta clase puede ser
utilizado tanto para las redes de alimentacin hacia delante y recurrentes simples. Debido a que estos son algunos de los
la mayora de los tipos de red neuronal comn en uso, el SimpleRecurrentLogic
Las siguientes secciones resumen las clases de lgica de red proporcionados por Encog.
clase era
elegido como el predeterminado.
4.4.1 La Clase ART1Logic
El ART1Logic
Para crear una red neuronal ART1 con Encog usted debe hacer uso de la
clase se utiliza para implementar un neural teora de la resonancia adaptativa
red. Teora de Resonancia Adaptativa (ART) es una forma de red neuronal desarrollada por
Stephen Grossberg y Gail Carpintero. Hay varias versiones de la neural ART
red, que estn numerados ART-1, ARTE-2 y ART-3. La red neuronal es ART
entrenado usando un algoritmo de aprendizaje supervisado o sin supervisin, dependiendo de la
versin de ART se utiliza. Redes neuronales ART se utilizan para el reconocimiento de patrones y
prediccin. Encog actualmente soporta ART1.
ART1Logic
4.4.2 La Clase BAMLogic
clase.
El BAMLogic clase se utiliza para implementar una memoria asociativa bidireccional
Red (BAM). La red de BAM es un tipo de red neuronal desarrollado por Bart
Kosko en 1988 El BAM es una red neuronal recurrente que funciona de manera similar a y
permite a los patrones de diferentes longitudes que se asignan de forma bidireccional con otros patrones. Este
le permite actuar casi como un mapa de hash de dos vas. Durante su formacin, la red de BAM es
pares de patrones alimentados. Las dos mitades de cada patrn no tienen que ser de la misma longitud.
Sin embargo, todos los patrones deben ser de la misma estructura general. La red puede ser BAM
alimentado un patrn distorsionado de cualquier lado y tratar de asignar al valor correcto.
Pgina 39
4.4.3 La Clase BoltzmannLogic
El BoltzmannLogic
Para crear una red neural mquina Boltzmann con Encog usted debe hacer uso de
la
clase se utiliza para implementar una mquina neural Boltzmann
red. Una mquina de Boltzmann es un tipo de red neuronal desarrollado por Geoffrey
Hinton y Terry Sejnowski. Parece idntica a una red neuronal Hopfield excepto que
contiene una naturaleza aleatoria a su salida. Un valor de temperatura est presente que influye en la
salida de la red neuronal. Como esta temperatura se incrementa el aleatoriedad.
Esto se llama recocido simulado. Redes Boltzmann suelen ser entrenados en una
el modo no supervisado. Sin embargo, la formacin supervisada puede ser utilizado para refinar lo que el
Mquina de Boltzmann reconoce.
BoltzmannLogic
4.4.4 La Clase FeedforwardLogic
clase.
Para crear un feedforward con Encog la FeedforwardLogic clase debe ser utilizado.
Tambin es posible utilizar el SimpleRecurrentLogic clase como en lugar de la
FeedforwardLogic clase; Sin embargo, la red funcionar ms lento. Si no hay
bucles recurrentes, ms sencilla FeedforwardLogic
La red neuronal feedforward, o perceptrn, es un tipo de red neuronal primera
descrito por Warren McCulloch y Walter Pitts en la dcada de 1940. El neuronal feedforward
de red, y sus variantes, es la forma ms ampliamente utilizada de la red neural. El
red neuronal feedforward menudo se entren con la tcnica de entrenamiento backpropagation,
aunque existen otras tcnicas de entrenamiento ms avanzadas, tales como la propagacin resistente.
La red neuronal feedforward utiliza conexiones ponderadas a partir de una capa de entrada a cero o
capas ms ocultas, y finalmente a una capa de salida. Es adecuado para muchos tipos de
problemas. Redes neuronales feedforward se utilizan con frecuencia en este documento.
clase debe ser utilizado.
4.4.5 La Clase HopfieldLogic
Para crear una red neuronal Hopfield con Encog, debe utilizar el
HopfieldLogic
Para crear una red neuronal Hopfield con Encog usted debe hacer uso de la
clase. Dr. John Hopfield desarroll la red neuronal Hopfield en
1979 La red de Hopfield es una red neuronal recurrente sola capa. El Hopfield
red siempre mantiene un "estado actual", que es la salida actual de la neural
red. La red neuronal Hopfield tambin tiene una propiedad de la energa, que se calcula
exactamente la misma que la propiedad temperatura de la mquina de Boltzmann. El Hopfield
red est capacitado para varios patrones. El estado de la red de Hopfield se mover
hacia el patrn ms cercano, por lo que "reconocer" ese patrn. Como la red de Hopfield
se mueve hacia uno de estos patrones, la energa disminuye.
HopfieldLogic clase.
Pgina 40
4.4.6 La Clase SimpleRecurrentLogic
Para crear una red neuronal, donde algunas capas estn conectados a las capas de contexto que
conectar de nuevo a las capas anteriores, debe utilizar el SimpleRecurrentLogic clase.
Las redes neuronales Elman y Jordania son ejemplos del tipo de redes en las que los
SimpleRecurrentLogic clase se puede utilizar. El SimpleRecurrentLogic clase
tambin se puede utilizar para implementar una red neuronal feedforward simple, sin embargo, la
FeedforwardLogic
Para crear ya sea un tipo de red neuronal Elman o Jordan con Encog que debiera
hacer uso de la
clase se ejecutar ms rpido.
SimpleRecurrentLogic
4.4.7 La Clase SOMLogic
clase.
Para crear un auto organizador Mapa con Encog la SOMLogic
Para crear una red neuronal SOM con Encog usted debe hacer uso de la
clase debe ser utilizado.
La auto-organizacin mapa (SOM) es un tipo de red neuronal introducido por Teuvo Kohonen.
SOM de se utilizan para clasificar los datos en grupos.
SOMLogic
4.5 Propiedades comprensin y Etiquetas
clase.
El BasicNetwork
El siguiente cdigo muestra varias propiedades que se establecen para una red ART1.
clase tambin proporciona propiedades y etiquetas para hacer frente a la nica
necesidades de los diferentes tipos de lgica de red neuronal. Propiedades proporcionan un conjunto de nombre-valor
pares que la lgica neuronal puede acceder. Esta es la forma de establecer las propiedades de cmo el
red neuronal debe funcionar. Las etiquetas permiten capas individuales que se identifiquen. Algunos de
los tipos lgica de la red neural afectarn capas diferente. Las etiquetas de capa permiten la
lgica de la red neuronal para saber qu capa es cul.
network.SetProperty (ARTLogic.PROPERTY_A1, 1);
network.SetProperty (ARTLogic.PROPERTY_B1, 2);
network.SetProperty (ARTLogic.PROPERTY_C1, 3);
network.SetProperty (ARTLogic.PROPERTY_D1, 4);
El primer parmetro especifica el nombre de la propiedad. La lgica de red neuronal
clases definir constantes para las propiedades que se requieren. El nombre de la propiedad es
una cadena.
El siguiente cdigo muestra dos capas de red que estn siendo etiquetados.
network.TagLayer (BasicNetwork.TAG_INPUT, layerF1);
network.TagLayer (BasicNetwork.TAG_OUTPUT, layerF2);
network.TagLayer (ART1Pattern.TAG_F1, layerF1);
network.TagLayer (ART1Pattern.TAG_F2, layerF2);
Pgina 41
Aqu varias etiquetas se estn aplicando a la layerF1 y layerF2
El
capas. Uno
capa puede tener mltiples etiquetas; Sin embargo, una sola etiqueta slo se puede aplicar a una capa.
BasicNetwork
4.6 Edificio con Capas y sinapsis
clase no mantiene una lista de capas. La nica manera de que las capas
realidad "unirse" a la red neuronal est ya sea por estar etiquetado, o vinculado a travs de una sinapsis
la conexin a una capa que ya est marcado.
Ahora ya est familiarizado con todos los tipos de capas y sinapsis apoyados por Encog. Usted
Se darn ahora una breve introduccin a la construccin de las redes neuronales con estos tipos de redes neuronales.
Ver cmo construir varios tipos de redes neuronales. Ellos se utilizan para resolver
problemas relacionados con el operador XOR. Por ahora, el operador XOR es lo suficientemente bueno
introduccin a varias arquitecturas de redes neuronales. Veremos ms interesante
ejemplos, como el documento avanza. Vamos a comenzar con la alimentacin directa de los nervios
red.
4.6.1 Creacin de Feedforward Redes Neuronales
La red neuronal feedforward es uno de los tipos ms antiguos de redes neuronales todava en
uso comn. La red neuronal feedforward es tambin conocido como el perceptrn. El
prealimentar obras de redes neuronales por tener una o ms capas ocultas intercalada
entre una entrada y la capa de salida. La Figura 4.6 muestra un diagrama Encog Workbench de un
prealimentar red neuronal.
Figura 4.6: La red neuronal anticipativo
Listado 4.3 muestra un ejemplo simple de una red neuronal feedforward aprender a
reconocer el operador XOR.
Pgina 42
Ficha 4.3: simple XOR anticipativo Neural Network
using System;
utilizando Encog.Neural.Networks.Training.Propagation.Back;
Encog.Examples.XOR.Backprop espacio de nombres
{
/// <Summary>
/// Aprenda a reconocer el patrn XOR utilizando un
/// Algoritmo de entrenamiento backpropagation.
/// </ Summary>
XorBackprop clase pblica: IExample
{
{
conseguir
{
typeof (XorBackprop),
"Xor-Backprop",
"Operador XOR con backpropagation",
"Usar backpropagation para aprender el operador XOR.");
}
}
/// <Summary>
/// </ Summary>
nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
/// <Summary>
/// </ Summary>
/// <Summary>
Pgina 43
/// </ Summary>
{
network.Structure.FinalizeStructure (); network.Reset ();
Tren ITrain = new retropropagacin (red, trainingSet,
0.7, 0.9);
int poca = 1;
hacer
{
train.Iteration ();
+ Train.Error);
poca ++;
{
+ Pair.Ideal [0]);
}
}
}
}
Como se puede ver en la lista anterior, es muy fcil de construir una de tres capas,
prealimentar red neuronal. En esencia, tres nuevos BasicLayer se crean objetos
y se aade a la red neuronal con llamadas a la addLayer mtodo. Debido a que no
se especifica el tipo de sinapsis, las tres capas estn conectadas entre s mediante el
WeightedSynapse
Usted se dar cuenta de que despus de construir la red neuronal, que es entrenado. Hay
bastantes maneras para entrenar una red neuronal en Encog. La formacin es el proceso en el que el
.
Pgina 44
pesos y umbrales se ajustan a los valores que va a producir la salida deseada de
la red neuronal. En este ejemplo se utiliza la formacin de propagacin elstica (Rprop). Rprop
es la mejor opcin para la mayora de las redes neuronales para ser capacitados con Encog. Por cierto especial
casos, algunos de los otros tipos de formacin pueden ser ms eficientes.
ITrain tren = new ResilientPropagation (
red, trainingSet);
Con la configuracin de entrenador ahora debemos pasar por un montn de iteraciones, o pocas.
Cada una de estas iteraciones de formacin debera disminuir el "error" de la red neuronal. El
error es la diferencia entre la salida real de la corriente de la red neuronal y el
salida deseada.
int poca = 1;
hacer
{
train.Iteration ();
Console.WriteLine ("Epoch #" + poca
+ "Error:" + train.Error);
poca ++
Continuar el entrenamiento de la red neuronal siempre y cuando la tasa de error es mayor que uno
por ciento.
Ahora que la red neuronal ha sido entrenado, hay que probarlo. Para ello, la misma
datos que la red neuronal se entren con que se presenta a la red neural. El
siguiente cdigo hace esto.
{
+ ", Real =" + salida [0] + ", ideales =" + pair.Ideal [0]);
}
Esto producir el siguiente resultado:
Epoch # 1 Error: 0,9902997764512583
Epoch # 2 Error: 0,6762359214192293
Epoch # 3 Error: 0,49572129129302844
Epoch # 4 Error: ,49279160045197135
Epoch # 5 Error: 0,5063357328001542
Epoch # 6 Error: 0.502484567412553
Epoch # 7 Error: ,4919515177527043
Epoch # 8 Error: 0,49157058621332506
Epoch # 9 Error: ,48883664423510526
Epoch # 10 Error: 0,48977067420698456
Epoch # 11 Error: 0,4895238942630234
Epoch # 12 Error: 0,4870271073515729
Pgina 45
Epoch # 13 Error: 0.48534672846811844
Epoch # 14 Error: ,4837776485977757
Epoch # 15 Error: 0.48184530627656685
Epoch # 16 Error: 0,47980242878514856
Epoch # 17 Error: ,47746641141708474
Epoch # 18 Error: ,4748474362926616
Epoch # 19 Error: ,47162728117571795
Epoch # 20 Error: 0.46807640808835427
...
Epoch # 495 Error: 0.010583637636670955
Epoch # 496 Error: 0,010748859630158925
Epoch # 497 Error: 0,010342203029249158
Epoch # 498 Error: ,00997945501479827
Resultados de red neuronal: 0.0,0.0, reales = ,005418223644461675, ideales = 0.0
1.0,0.0, real = 0.9873413174817033, ideales = 1.0 0.0,1.0,
real = 0.9863636878918781, ideales = 1.0 1.0,1.0,
real = 0.007650291171204077, ideales = 0.0
Como se puede ver la tasa de error comienza alto y constante disminuye. Por ltimo, la
patrones se presentan a la red neural. Como puede ver, la red neuronal puede
manejar el operador XOR. No produce la salida exacta que se entren con, pero
est muy cerca. Los valores de 0.0054 y 0.0076 son muy cercana a cero, tal como 0,987 y
0.986 estn muy cerca de uno.
Para esta red, estamos probando la red neuronal con exactamente los mismos datos que la
red neuronal fue entrenado con. En general, esta es una muy mala prctica. Quieres probar
la red neuronal en los datos que no se entren con. Esto le permite ver cmo el neural
la red est funcionando con nuevos datos que nunca se ha procesado antes. Sin embargo, la
Funcin XOR slo tiene cuatro combinaciones posibles, y todos ellos representan patrones nicos
que la red debe ser entrenado. Las redes neuronales presentada ms adelante en este documento
no va a usar la totalidad de sus datos para la formacin. Ms bien, se pondr a prueba en los datos nunca tiene
ha presentado antes.
4.6.2 Creacin de Auto-Connected Redes Neuronales
Ahora vamos a mirar a las redes neuronales auto-conectada. La red neuronal Hopfield es
un buen ejemplo de una red neuronal conectado consigo mismo. La red neuronal Hopfield
contiene una nica capa de neuronas. Esta capa est conectada a s mismo. Cada neurona en el
capa est conectada a cada neurona de otra en la misma capa. Sin embargo, no hay dos neuronas son
conectado a s mismos. La figura 4.7 muestra una red neuronal Hopfield diagramada en el
Encog Workbench.
Figura 4.7: La red neuronal Hopfield
Listado 4.4 muestra un ejemplo simple de una red neuronal Hopfield aprender a
Pgina 46
reconocer varios patrones.
Listing 4.4: Hopfield Neural Network
using System;
utilizando Encog.Neural.NeuralData.Bipolar;
utilizando Encog.Neural.Networks.Logic;
utilizando Encog.Neural.Networks.Pattern;
Encog.Examples.Hopfield.Associate espacio de nombres
{
HopfieldAssociate clase pblica: IExample
{
{
conseguir
{
typeof (HopfieldAssociate),
"Hopfield-asociado",
"Hopfield Asocia Patrones",
"Simple Network Hopfield neuronal que aprende a asociar patrones.");
}
}
public const int ALTURA = 10;
public const int ANCHO = 10;
aplicacin IExampleInterface privado;
String [] [] MODELO pblica = {
new String [ANCHO] {
"OOOOO",
"OOOO O",
"OOOOO",
"OOOO O",
"OOOOO",
"OOOO O",
"OOOOO",
"OOOO O",
"OOOOO",
"OOOO O"},
"OO OO OO",
"OO OO OO",
"OO OO",
"OO OO",
"OO OO OO",
Pgina 47
"OO OO OO",
"OO OO",
"OO OO",
"OO OO OO",
"OO OO OO"},
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO",
"OOOOO"},
"OOO O",
"OOO",
"OOO",
"OOO O",
"OOO",
"OOO",
"OOO O",
"OOO",
"OOO",
"OOO O"},
"Oooooooooo",
"O O",
"O OOOOOO O",
"OOO O",
"OO OO O O",
"OO OO O O",
"OOO O",
"O OOOOOO O",
"O O",
"Oooooooooo"}};
String [] [] = {PATTERN2 pblica
"",
"",
"",
"",
"",
"OOOO O",
"OOOOO",
"OOOO O",
"OOOOO",
"OOOO O"},
Pgina 48
"OOO O O",
"O OOO OO",
"OO OO O",
"OOO O",
"O OOO OO",
"O OOO O",
"O OO O O",
"OOO O",
"OO OOO O",
"OO OOO"},
"OOOOO",
"OOO OO",
"OOO OO",
"OOO OO",
"OOOOO",
"OOOOO",
"OOO O O",
"OOO O O",
"OOO O O",
"OOOOO"},
"O OOOO O",
"OOOO OO",
"OOOO OOO",
"OOOO OOOO",
"OOO OOOO",
"OO OOOO",
"O OOOO O",
"OOOO OO",
"OOOO OOO",
"OOOO OOOO"},
"Oooooooooo",
"O O",
"O O",
"O O",
"O OO O",
"O OO O",
"O O",
"O O",
"O O",
"Oooooooooo"}};
pblica BiPolarNeuralData ConvertPattern (
String [] [] datos, int index)
{
int resultIndex = 0;
BiPolarNeuralData resultado =
nueva BiPolarNeuralData (ancho * alto);
for (int fila = 0; fila <ALTURA; fila ++)
Pgina 49
{
for (int col = 0; col <ANCHO; col ++)
{
Char ch = datos [ndice] [fila] [columna];
result.SetBoolean (resultIndex ++, 'O' == ch);
}
}
return resultado;
}
public void Display (
BiPolarNeuralData patrn1, BiPolarNeuralData pattern2)
{
int index1 = 0;
int index2 = 0;
for (int fila = 0; fila <ALTURA; fila ++)
{
Lnea StringBuilder = new StringBuilder ();
{
if (pattern1.GetBoolean (index1 ++))
line.Append ('O');
dems
line.Append ('');
}
line.Append ("->");
{
if (pattern2.GetBoolean (index2 ++))
line.Append ('O');
dems
line.Append ('');
}
Console.WriteLine (line.ToString ());
}
}
public void Evaluar (BasicNetwork Hopfield,
String [] [] patrn)
{
HopfieldLogic hopfieldLogic =
(HopfieldLogic) hopfield.Logic;
for (int i = 0; i <pattern.Length; i ++)
{
BiPolarNeuralData patrn1 = ConvertPattern (patrn, i);
hopfieldLogic.CurrentState = patrn1;
ciclos int = hopfieldLogic.RunUntilStable (100);
BiPolarNeuralData pattern2 =
(BiPolarNeuralData) hopfieldLogic.CurrentState;
Pgina 50
Console.WriteLine ("Ciclos hasta que se estabilicen (max 100):"
+ + ciclos ", resultado =");
Display (patrn1, pattern2);
Console.WriteLine ("----------------------");
}
}
{
this.app = aplicacin;
HopfieldPattern patrn = new HopfieldPattern ();
pattern.InputNeurons = ancho * altura;
BasicNetwork Hopfield pattern.Generate = ();
for (int i = 0; i <PATTERN.Length; i ++)
{
hopfieldLogic.AddPattern (ConvertPattern (PATRN, i));
}
Evaluar (Hopfield, PATRN);
Evaluar (Hopfield, PATTERN2);
}
}
}
El ejemplo de Hopfield comienza creando una HopfieldPattern
HopfieldPattern patrn = new HopfieldPattern ();
clase. El patrn
clases permiten tipos comunes de las redes neuronales que se construir de forma automtica. Usted
simplemente proporcionar los parmetros sobre el tipo de red neuronal que desea crear, y
el patrn se encarga de la creacin de capas, las sinapsis, los parmetros y las etiquetas.
Esta red neuronal Hopfield va a reconocer los patrones grficos. Estos grfico
patrones se asignan a las redes. El nmero de neuronas de entrada ser el nmero total de
clulas en la cuadrcula. Este es el ancho por la altura.
pattern.InputNeurons = ancho * altura;
El patrn de Hopfield requiere muy poca participacin, slo el nmero de neuronas de entrada.
Otros patrones requerirn ms parmetros. Ahora que el HopfieldPattern tiene
ha dotado de todos los elementos necesarios, el Generar
BasicNetwork Hopfield pattern.Generate = ();
mtodo puede ser invocado para crear el
red neuronal.
El objeto de enlace se obtiene para la red de Hopfield.
La clase de lgica se utiliza para agregar los patrones que la red neuronal es para ser entrenados en.
Esto es similar a la formacin visto en la ltima seccin, excepto que ocurre mucho ms rpido para
Pgina 51
la red neuronal Hopfield simple.
for (int i = 0; i <PATTERN.length; i ++) {
hopfieldLogic.AddPattern (ConvertPattern (PATRN, i));
}
Ahora que la red se ha "entrenado" vamos a probarlo. Al igual que en la ltima seccin,
vamos a evaluar la red neuronal con los mismos datos con los que se entren.
Evaluar (Hopfield, PATRN);
Sin embargo, adems de los datos que la red ya se ha presentado con, nos
Tambin se presentarn nuevos datos. Estos nuevos datos son imgenes distorsionadas de los datos que el
la red se form en. La red debe ser capaz de reconocer los patrones todava, incluso
si estuvieran distorsionados.
Evaluar (Hopfield, PATTERN2);
A continuacin se muestra la salida de la red neuronal Hopfield. Como se puede ver la
Red neuronal Hopfield se present por primera vez con los patrones que se entren en. El
Red Hopfield simplemente se hace eco de estos patrones. A continuacin, la red neuronal Hopfield es
presentado con versiones distorsionadas de los patrones con los que se entren. Como se puede
ver en el fragmento de cdigo a continuacin, la red neuronal Hopfield an reconoce los valores.
Ciclos hasta que se estabilicen (max 100): 1, resultado =
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
----------------------
OO OO OO -> OO OO OO
OO OO -> OO OO
OO OO -> OO OO
OO OO -> OO OO
OO OO -> OO OO
----------------------
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
Pgina 52
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
----------------------
OOOO -> OOOO
OOO -> OOO
OOO -> OOO
OOOO -> OOOO
OOO -> OOO
OOO -> OOO
OOOO -> OOOO
OOO -> OOO
OOO -> OOO
OOOO -> OOOO
----------------------
Oooooooooo -> Oooooooooo
OO -> OO
O OOOOOO O -> O OOOOOO O
OOOO -> OOOO
OOOO -> OOOO
O OOOOOO O -> O OOOOOO O
OO -> OO
----------------------
-> OOOOO
-> OOOOO
-> OOOOO
-> OOOOO
-> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
----------------------
OOO OO -> OO OO OO
O OOO OO -> OO OO OO
OO OO O -> OO OO
OOO O -> OO OO
OO O OOO -> OO OO OO
O OOO O -> OO OO OO
OO O OO -> OO OO
O OOO -> OO OO
OO OOO O -> OO OO OO
OO OOO -> OO OO OO
----------------------
Pgina 53
OOOOO -> OOOOO
OO OOO -> OOOOO
OO OOO -> OOOOO
OO OOO -> OOOOO
OOOOO -> OOOOO
OOOOO -> OOOOO
OOO OO -> OOOOO
OOO OO -> OOOOO
OOO OO -> OOOOO
OOOOO -> OOOOO
----------------------
O OOOO O -> OOOO
OO OOOO -> OOO
OOO OOOO -> OOO
OOOO OOOO -> OOOO
OOOO OOO -> OOO
OOOO OO -> OOO
O OOOO O -> OOOO
OO OOOO -> OOO
OOO OOOO -> OOO
OOOO OOOO -> OOOO
----------------------
OO -> OO
OO -> O OOOOOO O
OO -> OOOO
O OO O -> OO OO OO
O OO O -> OO OO OO
OO -> OOOO
OO -> O OOOOOO O
OO -> OO
----------------------
Como puede ver, la red neuronal capaz de reconocer los valores distorsionados, as como los
valores con que fue entrenado. Esta es una prueba mucho ms completa que era
realizado en la seccin anterior. Esto es porque la red se evala con datos que
que nunca ha visto antes.
Cuando la red neuronal Hopfield reconoce un patrn, devuelve el patrn que se
fue entrenado con. Esto se llama autoasociacin.
El cdigo de programa para la Evaluar
public void Evaluar (BasicNetwork Hopfield,
mtodo ser examinada. Esto demuestra
cmo presentar un patrn a la red neural.
String [] [] patrn)
{
En primer lugar se obtiene el objeto de enlace.
Pgina 54
Bucle sobre todos los patrones y presentar cada uno a la red neural.
for (int i = 0; i <pattern.Length; i ++)
{
BiPolarNeuralData patrn1 = ConvertPattern (patrn, i);
El patrn se obtiene de la matriz y convertido a una forma que puede ser presentada a
la red neuronal. Los modelos grficos son binarios, ya sea el pxel est en o se va. Para
convertir la imagen todos los pxeles mostrados se convierten en los nmeros. Estamos utilizando
nmeros bipolares, por lo que un pxel es 1, un pixel oculta es -1.
La red neuronal Hopfield tiene un estado actual. Las neuronas estarn en ya sea 1 o -1
nivel. El estado actual de la red de Hopfield se ajusta al patrn que queremos
reconocer.
hopfieldLogic.CurrentState = patrn1;
La red de Hopfield se ejecutar hasta que se estabilice. Una red de Hopfield ajustar su
patrn hasta que ya no cambia. En este punto se ha estabilizado. El neuronal Hopfield
red se estabilizar en uno de los patrones que se entren en. El siguiente cdigo
se ejecutar la red de Hopfield hasta que se estabilice, hasta 100 iteraciones.
ciclos int = hopfieldLogic.RunUntilStable (100);
BiPolarNeuralData pattern2 =
(BiPolarNeuralData) hopfieldLogic.CurrentState;
Una vez que el estado de la red se ha estabilizado se muestra.
Console.WriteLine ("Ciclos hasta que se estabilicen (max 100):"
+ + ciclos ", resultado =");
Display (patrn1, pattern2);
Console.WriteLine ("----------------------");
Estos son slo algunos de los tipos de redes neuronales que se pueden construir con Encog.
Como el documento avanza, usted aprender muchos ms.
4.7 Resumen del captulo
Redes neuronales Encog se componen de capas, sinapsis, propiedades y una lgica neuronal
clase. En este captulo se revisa cada de ellas. Una capa es una coleccin de neuronas similares. A
sinapsis conecta una capa a otra. Propiedades definen cualidades nicas que uno de los nervios
tipo de red podra tener. La clase lgica neural define cmo la salida de la neural
red debe ser calculada.
Funciones de activacin son muy importantes para las redes neuronales. Escala de funciones de activacin
la salida de una capa antes de que llegue la siguiente capa. El siguiente captulo tratar
cmo Encog hace uso de funciones de activacin.
Pgina 55
Pgina 56
5 Edificios Encog Redes Neuronales
Funciones de activacin
Derivados y Propagacin de Entrenamiento
La eleccin de una funcin de activacin
Funciones de activacin son utilizados por muchas arquitecturas de red neuronal para escalar la salida
a partir de capas. Encog proporciona muchas funciones de activacin diferentes que pueden ser utilizados para
construir redes neuronales. En este captulo se le present a stos la activacin
funciones.
5.1 El papel de las funciones de activacin
Funciones de activacin estn unidos a capas. Se utilizan para escalar la salida de datos a partir de un
capa. Encog se aplica la funcin de activacin de una capa a la que la capa de datos est a punto de
de salida. Si no se especifica una funcin de activacin para BasicLayer , la hiperblica
activacin tangente ser la cesacin de pagos. El siguiente cdigo crea varios
BasicLayer
objetos con una funcin de activacin de tangente hiperblica defecto.
network.Reset ();
Si desea utilizar una funcin de activacin que no sea la tangente hiperblica
funcin, utilice cdigo similar al siguiente:
ActivationSigmoid a = new ActivationSigmoid ();
network.AddLayer (nuevo BasicLayer (a, cierto, 2));
network.Reset ();
La funcin de activacin tangente sigmoide se asigna a la variable de una y se pasa a
cada uno de los addLayer llama. El verdadero valor, que tambin fue presentado, se especifica que
la BasicLayer
5.1.1 La interfaz ActivationFunction
tambin debe tener valores de umbral.
Todas las clases que se van a servir como funciones de activacin deben implementar la
IActivationFunction
Ficha 3.1: La interfaz IActivationFunction
interfaz. Esta interfaz se muestra en el listado 3.1.
IActivationFunction interfaz pblica: IEncogPersistedObject
{
void ActivationFunction (double [] d);
Pgina 57
void DerivativeFunction (double [] d);
HasDerivative bool
{
conseguir;
}
}
La funcin de activacin real se implementa dentro de la ActivationFunction
mtodo. El ActivationSIN clase es una funcin de activacin muy simple que
implementa la onda sinusoidal. Usted puede ver el ActivationFunction
public override void ActivationFunction (double [] d)
aplicacin
a continuacin.
{
for (int i = 0; i <D.Longitud; i ++)
{
d [i] = BoundMath.Sin (d [i]);
}
}
Como puede ver, la activacin simplemente aplica la funcin seno a la matriz de siempre
valores. Esta matriz representa los valores neurona de salida que la funcin de activacin es a
escala. Es importante que la funcin se dar toda la matriz a la vez. Algunos de los
funciones de activacin realizar operaciones, como promedio, que requieren ver la totalidad
matriz de salida.
Tambin se dar cuenta de que el cdigo anterior que una clase especial, llamado BoundMath , es
utilizado para calcular el seno. Esto hace que "no es un nmero" y valores "infinito" para ser
eliminado. A veces, durante el entrenamiento, inusualmente nmeros grandes o pequeos pueden ser
generado. El BoundMath clase se utiliza para eliminar estos valores por ellos unin a
ya sea un muy grande o un nmero muy pequeo. La funcin seno no crear un Fuera de la
nmero de lmites, y BoundMath
Sin embargo, pronto veremos otras funciones que puedan producir sin nmeros encuadernados.
Exponente y funciones radicales pueden ser especialmente propensos a este. Una vez que un "no es un nmero"
(NaN) se introduce en la red neuronal, la red neuronal ya no producir
resultados tiles. Como resultado de ello, se debe realizar la comprobacin de lmites.
se utiliza principalmente para la integridad.
5.1.2 Derivadas de funciones de activacin
Si desea utilizar el entrenamiento de propagacin con su funcin de activacin, entonces el
funcin de activacin debe tener un derivado. El derivado se calcula mediante una funcin
llamado
public override void DerivativeFunction (double [] d)
DerivativeFunction.
{
{
d [i] = BoundMath.Cos (d [i]);
}
}
Pgina 58
El DerivativeFunction funciona muy similar a la ActivationFunction
5.2 Funciones Encog activacin
,
una matriz de valores se pasa a calcular.
Las siguientes secciones explican cada una de las funciones de activacin apoyados por Encog.
Hay varios factores a considerar al elegir una funcin de activacin. En primer lugar, la
tipo de red neuronal que est usando puede dictar la funcin de activacin debe utilizar.
En segundo lugar, usted debe considerar si usted desea para entrenar la red neuronal utilizando
propagacin. Propagacin de formacin requiere una funcin de activacin que proporciona una
derivado. Tambin debe considerar el rango de nmeros que se van a tratar. Este
se debe a que algunas funciones de activacin tratan slo nmeros positivos o nmeros en un
del rea de distribucin.
5.2.1 ActivationBiPolar
El ActivationBiPolar funcin de activacin se utiliza con redes neuronales que
requerir nmeros bipolares. Nmeros bipolares son ya sea verdadera o falsa . Un verdadero valor es
representada por un valor bipolar de 1; un falso valor est representado por un valor de bipolar -
1. La funcin de activacin bipolar asegura que cualquier nmero que se le pasan son o bien -1 o 1.
El ActivationBiPolar
if (d [i]> 0)
funcin no hace esto con el siguiente cdigo:
{
d [i] = 1;
}
dems
{
d [i] = -1;
}
Como se puede ver la salida de esta activacin se limita a cualquiera de -1 1 Este tipo de
funcin de activacin se utiliza con redes neuronales que requieren salida bipolar de un
capa a la siguiente. No hay ninguna funcin derivada de bipolar, por lo que esta funcin de activacin
no se puede utilizar con la formacin de propagacin.
5.2.2 Activacin Competitiva
El ActivationCompetitive
Esta funcin se inicia mediante la creacin de una matriz que har un seguimiento de si cada neurona tiene
ya sido seleccionado como uno de los ganadores. Contamos el nmero de ganadores hasta el momento.
funcin se utiliza a la fuerza slo un selecto grupo de
neuronas para ganar. El ganador es el grupo de neuronas que tiene la salida ms alta. El
salidas de cada una de estas neuronas se llevan a cabo en la matriz pasa a esta funcin. El tamao de
el grupo ganador de las neuronas es definible. La funcin ser determinar en primer lugar a los ganadores.
Todas las neuronas no premiadas sern puestos a cero. Los ganadores tendrn el mismo valor,
que es una divisin incluso de la suma de las salidas ganadoras.
bool [] ganadores = new int [D.Longitud];
Pgina 59
sumWinners dobles = 0;
Primero, tenemos bucle maxWinners
for (int i = 0; i <this.maxWinners; i ++)
un nmero de veces para encontrar ese nmero de ganadores.
{
doble maxFound = Double.MinValue;
int ganador = -1;
Ahora, tenemos que encontrar un ganador. Nosotros bucle sobre todas las salidas de la neurona y encontrar
la una con la salida ms alta.
for (int j = 0; j <D.Longitud; j ++)
{
Si esta neurona no lo ha ganado, y tiene la salida mximo, puede
potencialmente ser un ganador, si no hay otra neurona tiene una mayor activacin.
if (! ganadores [j] && d [j]> maxFound)
{
ganador = j;
maxFound = d [j];
}
}
Mantenga la suma de los ganadores que se encontraron, y marcar esta neurona como un ganador.
Marcando un ganador ser evitar que sea elegido de nuevo. La suma de la conquista
salidas en ltima instancia, se repartirn entre los ganadores.
sumWinners + = maxFound;
ganadores [ganador] = true;
Ahora que tenemos el nmero correcto de los ganadores, hay que ajustar los valores para
ganadores y no ganadores. Los no ganadores sern todos ponen a cero. Los ganadores
compartir la suma de los valores mantenidos por todos los ganadores.
{
if (ganadores [i])
{
d [i] = d [i] / sumWinners;
}
dems
{
d [i] = 0,0;
}
Este tipo de una funcin de activacin se puede utilizar con, neuronal de aprendizaje competitivo
redes, como el Ser organizador Mapa. Esta funcin de activacin no tiene derivado, por lo
no se puede utilizar con la formacin de propagacin.
5.2.3 ActivationGaussian
El ActivationGaussian funcin se basa en la funcin gaussiana. El
Pgina 60
Funcin gaussiana produce la curva en forma de campana familiar. La ecuacin para la
Funcin gaussiana se muestra en la Ecuacin 5.1.
Ecuacin 5.1: La funcin gaussiana
() =
-
(-)
2
2
2
Hay tres constantes diferentes que se introducen en la funcin gaussiana. El
constante una representa el pico de la curva. La constante b representa la posicin de la
curva. La constante c representa la anchura de la curva.
Figura 5.1: La grfica de la funcin de Gauss
La funcin gaussiana se implementa en C # como sigue.
volver this.peak
* BoundMath.Exp (-Math.Pow (x - this.center, 2)
/ (2.0 * this.width * this.width));
La funcin de activacin gaussiana no es una funcin de activacin de uso comn.
Sin embargo, se puede utilizar cuando se necesita un control ms preciso sobre el rango de activacin. El
curva puede ser alineado con un poco aproximados ciertas funciones.
La capa de funcin de base radial proporciona un grado incluso ms fino de control, como puede ser
utilizado con mltiples funciones gaussianas. No es un derivado vlida de la gaussiana
funcin; Por lo tanto, la funcin de Gauss se puede utilizar con la formacin de propagacin.
5.2.4 ActivationLinear
El ActivationLinear
Ecuacin 5.2: Activacin de la funcin lineal
() =
funcin es realmente ninguna funcin de activacin en absoluto. Simplemente
implementa la funcin lineal. La funcin lineal se puede ver en la Ecuacin 5.2.
La grfica de la funcin lineal es una lnea simple, como se ve en la Figura 5.2.
Pgina 61
Figura 5.2: Grfico de la funcin lineal de activacin
La aplicacin C # para la funcin de activacin lineal es muy simple. Lo hace
nada. La entrada es devuelto como fue aprobada.
public void ActivationFunction (double [] d)
{
}
La funcin lineal se usa principalmente para determinados tipos de redes neuronales que no tienen
funcin de activacin, tales como el mapa de auto-organizacin. La funcin de activacin lineal tiene un
derivado constante de uno, por lo que se puede utilizar con la formacin de propagacin. La capa de salida
de una red neuronal feedforward entrenado con la propagacin veces utiliza capas lineales.
5.2.5 ActivationLOG
El ActivationLog
if (d [i]> = 0)
funcin de activacin utiliza un algoritmo basado en el registro
funcin. El siguiente cdigo de C # muestra cmo se calcula.
{
d [i] = BoundMath.Log (1 + d [i]);
}
dems
{
d [i] = -BoundMath.Log (1 - d [i]);
}
Esto produce una curva similar a la funcin de activacin de tangente hiperblica, que lo har
se discutir ms adelante en este captulo. Usted puede ver el grfico de la activacin logartmica
funcin en la Figura 5.3.
Pgina 62
Figura 5.3: Grfico de la funcin logartmica de activacin
La funcin de activacin logartmica puede ser til para prevenir la saturacin. 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 mayora de los casos. Esto puede retrasar la formacin de manera significativa. Esto hace que el
activacin logartmica funciona una opcin posible cuando el entrenamiento no tiene xito usando la
funcin de activacin de tangente hiperblica.
Como se ilustra en la figura 5.3, la funcin de activacin logartmica abarca tanto positivos como
los nmeros negativos. Esto significa que se puede utilizar con redes neuronales donde negativo
salida nmero se desea. Algunas funciones de activacin, como la activacin sigmoide
funcin slo producir una salida positiva. La funcin de activacin logartmica hace
tener un derivado, por lo que se puede utilizar con la formacin de propagacin.
5.2.6 ActivationSigmoid
El ActivationSigmoid funcin de activacin slo se debe utilizar cuando es positiva
Se espera que la produccin nmero, porque el ActivationSigmoid funcin slo
producir una salida positiva. La ecuacin para la ActivationSigmoid
Ecuacin 5.3: La funcin ActivationSigmoid
() =
1
(1 +
-
)
funcin puede ser
visto en la Ecuacin 5.3.
El ActivationSigmoid
Figura 5.4: Grfico de la Funcin ActivationSigmoid
funcin se mover nmeros negativos en positivo
gama. Esto se puede ver en la Figura 5.4, que muestra la grfica de la funcin sigmoide.
Pgina 63
El ActivationSigmoid
5.2.7 ActivationSIN
funcin es una opcin muy comn para alimentacin directa y
redes neuronales recurrentes simples. Sin embargo, usted debe estar seguro de que los datos de entrenamiento hace
No espere que los nmeros de produccin negativas. Si se requieren nmeros negativos, considere el uso de la
funcin de activacin de tangente hiperblica.
El ActivationSIN funcin de activacin se basa en la funcin seno. No es una
comnmente utilizado funcin de activacin. Sin embargo, a veces es til para ciertos datos que
cambia peridicamente en el tiempo. El grfico de la ActivationSIN funcin se muestra
en la Figura 5.5.
Pgina 64
Figura 5.5: Grfico de la funcin SIN Activacin
El ActivationSIN funcin trabaja con ambos valores negativos y positivos.
Adems, el ActivationSIN
5.2.8 ActivationSoftMax
funcin tiene un derivado y se puede utilizar con
formacin de propagacin.
El ActivationSoftMax funcin de activacin es una activacin que escalar todos
los valores de entrada de modo que su suma ser igual a uno. El ActivationSoftMax
La funcin de activacin comienza sumando el exponente natural de toda la neurona
salidas.
funcin de activacin se utiliza a veces como una funcin de activacin capa oculta.
doble suma = 0;
{
d [i] = BoundMath.Exp (d [i]);
suma + = d [i];
}
La salida de cada una de las neuronas se escala entonces, de acuerdo a esta suma. Este
produce salidas que suman 1.
{
d [i] = d [i] / sum;
}
El ActivationSoftMax se utiliza generalmente en la capa oculta de una red neuronal
Pgina 65
o una red neural de clasificacin.
5.2.9 ActivationTANH
El ActivationTANH
Ecuacin 5.4: La funcin hiperblica tangente activacin
() =
2
- 1
2
+ 1
funcin de activacin es una funcin de activacin que utiliza el
funcin tangente hiperblica. La funcin de activacin de tangente hiperblica es probablemente el
ms utilizada la funcin de activacin, ya que funciona con tanto negativas como positivas
nmeros. La funcin tangente hiperblica es la funcin de activacin por defecto para Encog.
La ecuacin para la funcin de activacin de tangente hiperblica se puede ver en la Ecuacin 5.4.
El hecho de que la funcin de activacin tangente hiperblica acepta tanto positivos como
los nmeros negativos se pueden ver en la Figura 5.6, que muestra la grfica de la hiperblica
funcin tangente.
Figura 5.6: Grfico de la funcin hiperblica tangente activacin
La funcin tangente hiperblica que ves arriba llama a la funcin exponente natural,
dos veces. Esta es una llamada a la funcin caro. Realmente no necesitamos la hiperblica exacta
tangente. Una aproximacin es suficiente. El siguiente cdigo hace una aproximacin rpida de la
funcin tangente hiperblica.
doble ActivationFunction privado (double d)
{
devuelve -1 + (2 / (1 + BoundMath.Exp (-2 * d)));
}
Pgina 66
La funcin tangente hiperblica es una eleccin muy comn para feedforward y sencillo
redes neuronales recurrentes. La funcin tangente hiperblica tiene un derivado, por lo que puede ser
se utiliza con la formacin de propagacin.
5.3 Resumen
Encog utiliza funciones de activacin para escalar la salida a partir de capas de redes neuronales. Por
De forma predeterminada, Encog utilizar una funcin tangente hiperblica, que es un buen motivo generales
funcin de activacin. Cualquier clase que acta como una funcin de activacin debe implementar la
IActivationFunction interfaz. Esta interfaz requiere la implementacin de
varios mtodos. En primer lugar un ActivationFunction mtodo debe ser creado para realmente
realizar la funcin de activacin. En segundo lugar, un DerivativeFunction
El
mtodo debe
ser implementadas para devolver la derivada de la funcin de activacin. Si no hay manera de
tomar un derivado de la funcin de activacin, entonces se debe lanzar un error. Slo
funciones de activacin que tienen un derivado se pueden utilizar con la formacin de propagacin.
ActivationBiPolar clase funcin de activacin se utiliza cuando la red
slo acepta nmeros bipolares. El ActivationCompetitive funcin de activacin
clase se utiliza para las redes neuronales competitivas, como la auto-organizacin de mapas. El
ActivationGaussian clase funcin de activacin se utiliza cuando se desea una gaussiana
curva para representar la funcin de activacin. El ActivationLinear activacin
clase de funcin se utiliza cuando se quiere tener ninguna funcin de activacin en absoluto. El
ActivationLOG clase funcin de activacin funciona de manera similar a la ActivationTANH
activacin clase funcin, excepto que a veces no saturar como una capa oculta. El
ActivationSigmoid clase de funcin de activacin es similar a la ActivationTANH
clase funcin de activacin, excepto los nmeros positivos slo se devuelven. El
ActivationSIN clase de activacin se puede utilizar para datos peridicos. El
ActivationSoftMax
Hasta este momento hemos cubierto todos los principales componentes de las redes neuronales.
Capas contienen las neuronas y los valores umbral. Las sinapsis conectan las capas juntas.
Funciones de activacin se sientan dentro de las capas y la escala de la salida. Las etiquetas permiten capas especiales
ser identificado. Las propiedades permiten valores de configuracin que se asocian con la neural
red. El siguiente captulo se presentar la Encog Workbench. El Encog Workbench
Es una aplicacin con interfaz grfica que le permite construir redes neuronales compuestas de todos ellos
elementos.
clase funcin de activacin escala la salida de modo que la suma es
uno.
Pgina 67
6 Uso del Encog Workbench
Creacin de una red neuronal
Creacin de un conjunto de entrenamiento
Formacin de una Red Neuronal
Consulta de la Red Neural
Generacin de cdigo
Una parte importante del Marco Encog es la Encog Workbench. El Encog
Workbench es una aplicacin de interfaz grfica de usuario que se puede utilizar para crear y editar redes neuronales.
Encog puede persistir redes neuronales para archivos .eg. Estos archivos son una representacin XML de
las redes neuronales, y otra informacin en la que Encog utiliza para almacenar datos.
El banco de trabajo Encog se puede descargar de la siguiente URL:
http://www.encog.org
El Encog Workbench se empaqueta como una descarga para mltiples sistemas operativos.
El Encog Workbench est escrito en Java, por lo que debera funcionar en cualquier lugar que Java puede
ejecutar.
universal - Envasado como JAR auto-arranque. Basta con hacer doble clic en el
Archivo EncogWorkbenchStartable-2.5.0.jar. La mayora de los sistemas operativos (Windows y
Mac) se pondr en marcha el banco de trabajo.
UNIX - Empaquetado con workbench.sh, que comenzar el banco de trabajo. Hacer
asegrese que est marcado como ejecutable (chmod + x workbench.sh).
Aplicacin de Windows - Empaquetado con un lanzador de Windows. Simplemente haga doble
haga clic en el ejecutable de la aplicacin y la aplicacin se iniciar.
Aplicacin Macintosh - Just doble clic en el JAR de inicio automtico, como se describe para
universal.
En este captulo voy a suponer que usted est usando el paquete de aplicaciones de Windows de
Encog Workbench. Todos los dems funcionarn de manera muy similar. Una vez descargado el
Banco de trabajo Encog y descomprimirlo en un directorio, el directorio tendrn un aspecto similar a la Figura 6.1.
El Encog Workbench se implementa como una aplicacin Java. Sin embargo, es
compatible con las versiones de NET y Silverlight de Encog as. Java fue elegido como
el idioma para escribir el Workbench en debido a su capacidad para funcionar con muchos diferentes
plataformas de hardware.
Pgina 68
Figura 6.1: El Workbench carpeta Encog
Para poner en marcha el banco de trabajo Encog doble clic en el icono "Encog Workbench". Esta voluntad
iniciar la aplicacin Encog Workbench. Una vez que el banco de trabajo comienza, ver
algo similar a lo que se ilustra en la Figura 6.2.
Figura 6.2: Inicio de la Aplicacin Workbench Encog
Desde aqu se puede crear un nuevo proyecto o abrir un proyecto existente. Encog
Archivos de Workbench se suelen agrupar en directorios.
Si decide crear un nuevo proyecto Encog, podrs ver Figura 6.3.
Pgina 69
Figura 6.3: Crear nuevo Encog Proyecto
Debido a que un proyecto Encog consta de varios archivos, se le pedir que especifique una
direccin al crear un nuevo proyecto Encog. Una vez creado el proyecto, ver
Figura 6.4.
Figura 6.4: La aplicacin Workbench Encog
El Encog Workbench puede ejecutar en un referente para determinar qu tan rpido Encog se ejecutar en
esta mquina. Esto puede tardar varios minutos, ya que se ejecuta a travs de un Encog nmero de
diferentes operaciones de la red neuronal. El punto de referencia es tambin una buena manera de asegurarse de que
Encog est funcionando correctamente en un ordenador. Para realizar la prueba, haga clic en "Herramientas"
men y seleccione "Benchmark Encog". El ndice de referencia se ejecutar y mostrar un progreso
bar. Una vez que la prueba se ha hecho, usted ver el nmero de referencia final. Esto puede ser
visto en la Figura 6.5.
Pgina 70
Figura 6.5: Benchmarking Encog
Un nmero ms alto refleja un mejor resultado. El nmero da la cantidad de iteraciones
Encog podra completar de diversas tareas. Uso de Encog de los procesadores multincleo ser
reflejado en este nmero. Si el equipo ya est ejecutando otros procesos, esta voluntad
ralentizar el ndice de referencia. Debido a esto, usted no debe tener otras aplicaciones
marcha mientras se realiza un punto de referencia utilizando el Encog Workbench.
6.1 Creacin de una Red Neuronal
Vamos a empezar por la creacin de una red neuronal. El Encog Workbench comienza con una
archivo vaco. Una vez que los objetos se han aadido a este archivo vaco, que se puede guardar en un .eg
presentar. Este archivo .eg puede ser cargado por el banco de trabajo de nuevo o ser cargada con Java o Net
Aplicaciones Encog. Las versiones de Net y Java de Encog leer exactamente el mismo tipo de
Archivos .eg.
Para crear una red neural, seleccione "Crear Objeto en los" objetos de men ". Una pequea
ventana emergente aparecer que pide el tipo de objeto a crear. Elija "Neural
Red "para crear una nueva red neuronal. Con ello se abre una ventana que le permite
ver los tipos disponibles de las redes neuronales para crear. Estos son plantillas predefinidas
para muchos de los tipos de redes neuronales comunes soportados por Encog. Esta ventana puede ser
visto en la Figura 6.6.
Figura 6.6: Crear una red neuronal
Usted se dar cuenta de que la primera opcin es la creacin de una "Red Neural Empty". Cualquiera de
las redes neuronales que se muestran aqu podran ser creados de esta manera. Usted simplemente crear un
red y aadir las correspondientes capas, las sinapsis, las etiquetas y propiedades para crear el vaco
Pgina 71
tipo de red neuronal que desea crear. Sin embargo, si usted desea crear una de las
tipos comunes de redes neuronales, es mucho ms rpido usar simplemente uno de estos predefinido
plantillas. Elija la opcin "Red Neuronal anticipativo". Usted tendr que llenar algunos
informacin sobre el tipo de red neuronal feedforward que le gustara crear. Este
cuadro de dilogo se ve en la figura 6.7.
Figura 6.7: Crear una red neuronal anticipativo
Vamos a crear una red simple, neuronal que aprende el operador XOR. Tal
red neuronal se debe crear la siguiente manera:
Entrada Conde Neurona: 2
Oculto Capa 1 neurona de visitas: 2
Salida de Count Neurona: 1
Los dos neuronas de entrada son necesarios porque el operador XOR tiene dos entradas
parmetros. La neurona es necesaria una salida porque el operador XOR realiza una salida
parmetro. Esto se puede ver en la siguiente tabla de verdad para el operador XOR.
0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0
Como se puede ver en el cdigo anterior, el operador XOR toma dos parmetros y
produce un valor. El operador XOR slo devuelve true, o uno, cuando los dos de entrada
operadores son diferentes. Esto define los recuentos de neuronas de entrada y salida.
El recuento capa oculta es de dos. Las neuronas ocultas son necesarias para ayudar a la neural
red en el aprendizaje del operador XOR. Dos es el nmero mnimo de neuronas ocultas
que pueden ser proporcionados por el operador XOR. Usted se estar preguntando cmo sabamos utilizar
dos. Por lo general, esto es algo de un proceso de ensayo y error. Usted quiere elegir el
nmero mnimo de neuronas ocultas que todava suficientemente resuelve el problema.
Ahora que la red neuronal feedforward se ha creado, usted lo ver en la
banco de trabajo. La figura 6.8 muestra el banco de trabajo con una red neuronal aadi.
Pgina 72
Figura 6.8: Red Neuronal Agregado
Si hace doble clic en la red neuronal feedforward se muestra en la Figura 6.8, se abrir.
Esto le permite ver las capas y las sinapsis. La figura 6.9 muestra la neural feedforward
red que acaba de crear.
Figura 6.9: La Red Neural creados recientemente
La figura anterior muestra cmo las redes neuronales se edit con Encog. Puede aadir
capas y sinapsis adicionales. Tambin puede editar otros aspectos de la red neuronal,
tales como las propiedades y el tipo de lgica neuronal que utiliza.
Ahora que la red neuronal se ha creado, se debe crear un conjunto de entrenamiento. El
conjunto de entrenamiento se utiliza para entrenar la red neuronal.
6.2 Creacin de un conjunto de entrenamiento
Un conjunto de entrenamiento es una coleccin de datos que se utilizarn para entrenar la red neuronal. Hay
dos tipos de conjuntos de entrenamiento de uso comn con Encog.
Entrenamiento Supervisado
La formacin no supervisada
Datos de entrenamiento supervisado tiene tanto una entrada y salida esperada especificada para el neural
Pgina 73
red. Por ejemplo, una tabla de verdad anterior podra representarse como un conjunto de entrenamiento. Hay
sera cuatro filas, una para cada una de las combinaciones alimentados al operador XOR. Usted
tendra dos columnas de entrada y una columna de salida. Estos corresponden a la entrada
y las neuronas de salida. Los conjuntos de entrenamiento no se refieren a las capas ocultas. Ocultos
capas son simplemente presente para ayudar en el aprendizaje.
Datos de entrenamiento no supervisado slo tiene valores de entrada. No hay resultados previstos. El
red neuronal se entrenar, de forma no supervisada, y determinar por s mismo lo que el
salidas deberan ser. Entrenamiento no supervisado se utiliza a menudo para problemas de clasificacin donde
desea que la red neuronal para los datos de entrada de grupo.
En primer lugar, tenemos que crear un conjunto de entrenamiento. Seleccione "Crear Objeto" en el men "Objetos".
Seleccione "Data Training :. Se le pedir para qu tipo de un conjunto de entrenamiento que deseas
crear. Elija un "conjunto XOR Training". Una vez que el conjunto de entrenamiento se ha creado ser
aadido, junto con la red que se cre anteriormente.
Figura 6.10: El conjunto de entrenamiento creados recientemente
Doble clic en el conjunto de entrenamiento lo abrir. El conjunto de entrenamiento se abrir en una
ventana de una hoja de clculo, como se ve en la figura 6.11.
Figura 6.11: Edicin de la serie de entrenamiento
Pgina 74
Aqu se puede ver el conjunto de entrenamiento. De forma predeterminada, Encog crea un conjunto de entrenamiento para XOR.
Esto es slo el valor por defecto. Por lo general, usted desea crear ahora el nmero deseado de entrada y
columnas de salida. Sin embargo, porque estamos entrenando el operador XOR, los datos est bien como
es.
6.3 Formacin de una Red Neuronal
El entrenamiento de una red neuronal es un proceso en el que los pesos de la red neuronal y
umbrales se modifican para que la red neuronal producir una salida de acuerdo con la
datos de entrenamiento. Hay muchas formas diferentes de entrenar una red neuronal. La eleccin de los
mtodo de entrenamiento estar determinado en parte por el tipo de red neuronal que est creando.
No todos los tipos de redes neuronales funcionan con todos los mtodos de entrenamiento.
Para entrenar la red neuronal abrirlo como lo hizo para la Figura 6.9. Haga clic en el botn "Train"
en la parte superior de la ventana. Esto mostrar un cuadro de dilogo que le permite elegir un
mtodo de entrenamiento, como se ve en la figura 6.12.
Figura 6.12: Eleccin de un mtodo de formacin
Elija el mtodo de entrenamiento flexible, bajo la propagacin. Este suele ser el mejor
mtodo disponible para una red neuronal feedforward entrenamiento supervisado. Hay varios
parmetros que puede establecer para el mtodo de entrenamiento resistente. Para la formacin resiliente es muy
poco probable que alguna vez debe cambiar cualquiera de estas opciones, con excepcin quizs de la deseada
mximo de error, que por defecto es 1%. Usted puede ver este cuadro de dilogo en la Figura 6.13.
Pgina 75
Figura 6.13: Formacin Propagacin Resilient
Seleccin Aceptar se abrir una ventana que le permitir controlar el proceso de formacin,
como se ve en la figura 6.14.
Figura 6.14: A punto de comenzar el entrenamiento
Para comenzar el entrenamiento, haga clic en el botn "Inicio" en el cuadro de dilogo de entrenamiento. La red
se iniciar la capacitacin. Para las redes complejas, este proceso puede durar das. Esta es una
red muy simple que terminar en varios cientos de iteraciones. No es probable que
incluso ver la grfica comienza como la formacin se completar en cuestin de segundos. Una vez que el
formacin es completa, ver la siguiente pantalla.
Pgina 76
Figura 6.15: Completar la formacin
La formacin es completa debido a que el error actual cay por debajo del error mximo
permitido que se introdujo en la figura 6.11, que es el 1%. Ahora que la red ha sido
entrenado puede producir una salida significativa cuando se les pregunta. El entrenamiento termin muy
rpidamente. Como resultado de ello, no haba suficientes iteraciones para dibujar un grfico para mostrar la formacin
progreso.
6.4 Consulta de la Red Neural
Consulta de la red neuronal permite especificar valores para las entradas a la neural
la red y observar las salidas. Para consultar la red neuronal, haga clic en "Bsqueda" en la parte superior
del editor de la red se ve en la Figura 6.9. Esto abrir la ventana de consulta como se ve en
Figura 6.16.
Figura 6.16: Consultar la Red Neural
Como se puede ver en la ventana de arriba, se le permite introducir dos valores para el
neuronas de entrada. Al hacer clic en "Calcular", se mostrarn los valores de salida. En el
ejemplo anterior un uno y un cero se introdujeron, lo que result en 0.98. Esto es consistente
con el operador XOR, como 0,98 es cercano a uno. Para obtener un valor an ms cerca de cero, tren
la red neuronal a una menor tasa de error.
Tambin puede ver los pesos y los valores umbral que se generaron por la
entrenamiento. Desde el editor de la red, que se muestra en la Figura 6.7, haga clic derecho en la sinapsis y
Pgina 77
seleccione "Edit Matrix Peso" en el men emergente. Del mismo modo, se puede ver el
umbrales haciendo clic derecho y seleccionando "Editar capa" en el men emergente. Figura
6.17 muestra el dilogo que se utiliza para editar las propiedades de capa.
Figura 6.17: Vista de propiedades de capa
Tambin puede navegar por las funciones de activacin disponibles. Si decide cambiar la
funcin de activacin ver algo similar a la mostrada en la Figura 6.18.
Figura 6.18: Editar la funcin de activacin
En la figura 6.16 se puede ver que la funcin de activacin actual es la hiperblica
tangente. La grfica de la funcin tangente hiperblica tambin se muestra como referencia.
6.5 Generacin de cdigo
El banco de trabajo Encog ofrece dos maneras que usted puede hacer uso de su neural
red en cdigo Java. En primer lugar, puede guardar los datos de la red y de formacin neural a un .eg
presentar. Las aplicaciones Java pueden entonces cargar datos desde este archivo .eg.
Pgina 78
Otra forma de generar cdigo es utilizar el Workbench Encog. El banco de trabajo Encog
puede generar cdigo en los siguientes idiomas.
Java
C #
VB.Net
La generacin de cdigo simplemente genera el cdigo necesario para crear la red neuronal solamente.
No se genera ningn cdigo para entrenar o usar la red neuronal. Para el programa generado sea
de cualquier uso, tendr que aadir su propio cdigo de capacitacin. Listado 6.1 muestra la generada
C # cdigo de la XOR, red neuronal feedforward.
Listing 6.1: Generado C Cdigo #
utilizando Encog.Neural.Activation;
utilizando Encog.Neural.Networks.Synapse;
using System;
utilizando org.encog.neural.networks.synapse.WeightedSynapse;
// Archivo de red neuronal generada por Encog. Este archivo muestra slo // un
simple red neuronal generado para la estructura
// Diseado en el banco de trabajo.
// Ser necesario cdigo adicional para la formacin y el procesamiento.
//
// Http://www.encog.org
//
EncogSandbox espacio de nombres
{
public class Program {
vaco esttico pblico Principal ()
{
ILayer outputLayer = new BasicLayer (
nueva ActivationSigmoid (), es cierto, 1);
ILayer hiddenLayer1 = new BasicLayer (
ILayer inputLayer = new BasicLayer (
ISynapse synapse1 =
nueva WeightedSynapse (hiddenLayer1, outputLayer)
ISynapse synapse2 =
nueva WeightedSynapse (inputLayer, hiddenLayer1)
Pgina 79
hiddenLayer1.AddSynapse (synapse1);
inputLayer.AddSynapse (synapse2);
network.TagLayer ("Entrada", inputLayer);
network.TagLayer ("SALIDA", outputLayer);
network.Reset ();
}
}
}
La misma red tambin se podra haber generado en Java o VB.Net.
6.6 Resumen
En este captulo hemos visto cmo utilizar la Encog Workbench. El Encog Workbench
proporciona una manera de editar los archivos .eg producidos por el Marco Encog. Tambin hay
plantillas disponibles para ayudarle a crear rpidamente patrones comunes de redes neuronales. Ahi esta
tambin un editor de interfaz grfica de usuario de red que permite a las redes ser diseado usando arrastrar y soltar
funcionalidad.
La mesa de trabajo permite que los datos de entrenamiento que se creen as. Los datos de entrenamiento pueden ser
introducida manualmente o importados desde un archivo CSV. Datos de formacin incluye la entrada a la
red neuronal, as como la salida esperada. Los datos de entrenamiento que slo incluye la entrada
datos sern utilizados en la formacin sin supervisin. Los datos de entrenamiento que incluye la entrada y
resultado esperado ser utilizado en el entrenamiento supervisado.
La red neuronal puede ser entrenada usando muchos algoritmos de entrenamiento diferentes. Para una
red neuronal feedforward, una de las mejores opciones es la propagacin resiliente
algoritmo. El Encog Workbench le permite introducir parmetros para la formacin, y
a continuacin, ver el progreso de la formacin.
El Encog Workbench generar el cdigo necesario para producir una red neuronal
que fue diseado con ella. El banco de trabajo puede generar cdigo en Java, C # o VB.Net. Este
cdigo muestra cmo construir la red neuronal con las capas necesarias, sinapsis,
propiedades y etiquetas capa.
El cdigo generado en este captulo fue capaz de crear la red neuronal que era
diseado en el banco de trabajo. Sin embargo, lo necesario para aadir su propio cdigo de capacitacin para hacer
el programa funcional. El siguiente captulo presentar algunas de las maneras de entrenar a un
red neuronal.
Pgina 80
Entrenamiento 7 Propagacin
Cmo funciona el Entrenamiento de propagacin
Capacitacin Backpropagation
Actualizar regla Manhattan
Capacitacin Propagacin Resilient
La formacin es el medio por el que los pesos y los valores umbral de una red neuronal
se ajustan para dar salidas deseables. Este documento abarcar tanto supervisados y
entrenamiento no supervisado. Formacin de propagacin es una forma de entrenamiento supervisado, donde el
resultado esperado se da al algoritmo de entrenamiento.
Encog tambin apoya la formacin sin supervisin. Con el entrenamiento no supervisado no lo hace
proporcionar a la red neuronal con la salida esperada. Ms bien, la red neuronal se deja
aprender y hacer una visin de los datos con sentido limitado.
Formacin de propagacin puede ser una forma muy efectiva de entrenamiento para alimentacin directa, simple
recurrente y otros tipos de redes neuronales. Hay varias formas diferentes de
formacin de propagacin. En este captulo se centrar en las formas de propagacin en la actualidad
apoyada por Encog. Estas tres formas se enumeran como sigue:
Capacitacin Backpropagation
Actualizar regla Manhattan
Capacitacin Propagacin Resilient
Los tres de estos mtodos funcionan de manera muy similar. Sin embargo, hay algunas importantes
diferencias. En la siguiente seccin vamos a explorar la formacin de propagacin en general.
7.1 Formacin Propagacin Entendimiento
Algoritmos de entrenamiento Propagacin usan entrenamiento supervisado. Esto significa que la formacin
algoritmo se da un conjunto de entrenamiento de los insumos y la salida ideal para cada entrada. El
algoritmo de propagacin en la formacin pasar a travs de una serie de iteraciones. Cada iteracin
ms probable mejorar la tasa de error de la red neuronal por un cierto grado. La tasa de error es
la diferencia porcentual entre la salida real de la red neural y el ideal
de salida proporcionada por los datos de entrenamiento.
Cada iteracin ser completamente bucle a travs de los datos de entrenamiento. Para cada elemento de
capacitacin de los datos, se calcular un cambio a la matriz de ponderacin y umbrales. Estos
cambios se aplicarn en lotes. Encog utiliza el entrenamiento por lotes. Por lo tanto, las actualizaciones Encog
la matriz de valores de umbral de peso y al final de una iteracin.
Ahora vamos a examinar lo que sucede durante cada iteracin de entrenamiento. Cada entrenamiento
iteracin comienza haciendo un bucle sobre todos los elementos de formacin en el conjunto de entrenamiento. Para cada
de estos elementos de formacin se ejecuta un proceso de dos pasos: un paso hacia adelante y hacia atrs un
pasar.
El pase adelantado se limita a presentar los datos a la red neuronal como lo hara normalmente si no hay
Pgina 81
se haba producido la formacin. Los datos de entrada se presenta, y el algoritmo calcula el error,
que es la diferencia entre la salida real y la salida ideal. La salida desde
cada una de las capas tambin se mantiene en este paso. Esto permite que los algoritmos de entrenamiento para ver la
de salida de cada una de las capas de red neural.
El pase hacia atrs comienza en la capa de salida y trabaja su camino de regreso a la capa de entrada.
La pasada hacia atrs comienza mediante el examen de la diferencia entre cada una de las salidas ideales
y la salida real de cada una de las neuronas. El gradiente de este error es luego
calculado. Para el clculo de este gradiente, la red de la salida real de la red neuronal
se aplica a la derivada de la funcin de activacin utilizado para este nivel. Este valor es
a continuacin, multiplicado por el error.
Debido a que el algoritmo utiliza la funcin derivada de la funcin de activacin,
formacin de propagacin slo se puede utilizar con las funciones de activacin que en realidad tienen un
funcin derivada. Este derivado se utiliza para calcular el gradiente de error para cada
conexin en la red neural. Cmo exactamente se utiliza este valor depende de la formacin
algoritmo utilizado.
7.1.1 Entendimiento Backpropagation
Retropropagacin es uno de los mtodos de entrenamiento ms antiguas para neuronal feedforward
redes. Backpropagation utiliza dos parmetros en conjuncin con el descenso de gradiente
calculado en la seccin anterior. El primer parmetro es la tasa de aprendizaje. El aprendizaje
tasa es esencialmente un porcentaje que determina cmo debe ser directamente el descenso de gradiente
aplicada a la matriz de ponderacin y los valores de umbral. El gradiente se multiplica por el
tasa de aprendizaje y despus se aadi a la matriz de peso o valor de umbral. Esto lo har lentamente
optimizar los pesos a los valores que producir un error inferior.
Uno de los problemas con el algoritmo de retropropagacin es que el descenso de gradiente
algoritmo buscar mnimos locales. Estos mnimos locales son puntos de error bajo, pero
que pueden no ser de un mnimo global. El segundo parmetro proporcionado a la
algoritmo backpropagation busca ayudar a la propagacin hacia atrs de los mnimos locales. El
segundo parmetro se denomina impulso. Momentum especifica, en qu medida, el peso
cambios de la iteracin anterior se deben aplicar a la iteracin actual.
El parmetro de impulso es esencialmente un por ciento, al igual que la tasa de aprendizaje. Para utilizar
impulso, el algoritmo backpropagation debe llevar un registro de lo que fueron los cambios
aplicada a la matriz de peso de la iteracin anterior. Estos cambios se vuelven a aplicar
para la iteracin actual, excepto escalado por los parmetros de impulso. Por lo general, la
parmetro de impulso ser menor que uno, para que el peso cambia de la anterior
formacin iteracin son menos importantes que los cambios calculados para la iteracin actual.
Por ejemplo, establecer el impulso a 0,5 hara que el cincuenta por ciento de la anterior
cambios de formacin de iteracin que se aplicarn a los pesos de la matriz de peso actual.
Pgina 82
7.1.2 Comprensin de la Regla Manhattan actualizacin
Uno de los problemas con el algoritmo de entrenamiento de retropropagacin es el grado
que se cambian los pesos. El descenso de gradiente a menudo puede aplicar demasiado grande de una
cambiar a la matriz de peso. La regla de actualizacin de Manhattan y la propagacin elstica
algoritmos de entrenamiento slo utilizan el signo de la pendiente. La magnitud se descarta. Este
significa que es slo importante si el gradiente es positiva, negativa o cerca de cero.
Por la regla de actualizacin de Manhattan, esta magnitud se utiliza para determinar la forma de actualizar la
matriz de peso o un valor umbral. Si la magnitud es cercano a cero, entonces se realiza ningn cambio
al peso o al valor de umbral. Si la magnitud es positiva, entonces el peso o
valor umbral se aumenta en una cantidad especfica. Si la magnitud es negativa, entonces el
peso o valor umbral se reduce en una cantidad especfica. La cantidad por la que el
peso o valor umbral se cambia se define como una constante. Usted debe proporcionar esta
constante a la regla de actualizacin de algoritmo de Manhattan.
7.1.3 Entendimiento Entrenamiento Propagacin Resilient
La formacin de propagacin elstica (Rprop) algoritmo suele ser la ms eficiente
algoritmo de entrenamiento proporcionado por Encog para redes neuronales feedforward supervisadas. Uno
una ventaja particular al algoritmo Rprop es que no requiere ningn ajuste de los parmetros
antes de usarlo. No hay tasas de aprendizaje, valores de impulso o constantes de actualizacin que
necesitar ser determinado. Esto es bueno, ya que puede ser difcil determinar la exacta
tasa de aprendizaje que puede ser ptimo.
Los algoritmos Rprop funciona de forma similar a la regla de actualizacin de Manhattan, en el que slo el
se utiliza magnitud del descenso. Sin embargo, en lugar de utilizar una constante fija para actualizar
los pesos y los valores umbral, se utiliza un enfoque mucho ms granular. Estos deltas
No se mantendr fija, como en la regla de actualizacin de Manhattan o algoritmo backpropagation.
Ms bien estos valores delta cambiarn a medida que progresa el entrenamiento.
El algoritmo Rprop no mantiene un valor de actualizacin global, o delta. Ms bien,
deltas individuales se mantienen para cada valor de la matriz de umbral y peso. Estos deltas son
inicializado primero en un nmero muy pequeo. Cada iteracin a travs del algoritmo Rprop
actualizar los valores de peso y de umbral de acuerdo con estos valores delta. Sin embargo, como
se mencion anteriormente, estos valores delta no permanecen fijos. El gradiente se utiliza para
determinan cmo deben cambiar, utilizando la magnitud para determinar cmo los deltas
deberan modificarse ms. Esto permite que cada matriz de umbral y peso individual
valor que se entren individualmente. Esta es una ventaja que no se proporciona ya sea por el
algoritmo backpropagation o la regla de actualizacin de Manhattan.
7.2 Propagacin de Entrenamiento con Encog
Ahora que usted entiende las diferencias principales entre los tres tipos diferentes de
formacin de propagacin utilizado por Encog, vamos a ver cmo implementar realmente cada uno de ellos.
En las siguientes secciones se mostrarn ejemplos de C # que hacen uso de los tres. El XOR
operador, que se introdujo en el ltimo captulo, se utiliza como ejemplo. El XOR
Pgina 83
operador es trivial de implementar, por lo que es un buen ejemplo de un nuevo algoritmo de entrenamiento.
7.2.1 Uso de retropropagacin
En el captulo anterior vimos cmo utilizar el Encog Workbench para implementar una solucin
con el operador XOR utilizando una red neural. En este captulo veremos a continuacin cmo
hacer esto con un programa de C #. Listado 7.1 muestra un programa de C # sencillo que formar a un
red neuronal para reconocer el operador XOR.
Ficha 7.1: El uso de retropropagacin
using System;
{
{
conseguir
{
"Xor-RProp",
}
}
/// <Summary>
/// </ Summary>
nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
/// <Summary>
/// </ Summary>
Pgina 84
/// <Summary>
/// </ Summary>
{
network.Reset ();
ITrain tren =
int poca = 1;
hacer
{
train.Iteration ();
+ Train.Error);
poca ++;
{
+ Pair.Ideal [0]);
}
}
}
}
Pgina 85
Ahora vamos a examinar las partes del programa necesarios para aplicar el XOR
ejemplo backpropagation.
1.1.1 Tabla de verdad de matriz
Una tabla de verdad define las posibles entradas y salidas ideales para un operador matemtico.
La tabla de verdad de XOR se muestra a continuacin.
0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0
El XOR ejemplo de retropropagacin debe almacenar la tabla de verdad XOR como una matriz 2D.
Esto permitir que el grupo de aprendizaje que se construir. Comenzamos creando XOR_INPUT
,
que contendr los valores de entrada para cada una de las filas de la tabla de verdad XOR.
nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
A continuacin, creamos la matriz XOR_IDEAL
, Que celebrar la salida esperada para cada
de las entradas definido previamente.
Usted puede preguntarse por qu es necesario el uso de una matriz 2D para XOR_IDEAL
7.2.2 La construccin de la red neuronal
. En este caso
parece innecesario, ya que la red neural XOR tiene un valor de salida nica.
Sin embargo, las redes neuronales pueden tener muchas neuronas de salida. Debido a esto, una matriz 2D es
utilizado para permitir que cada fila tenga potencialmente mltiples salidas.
En primer lugar, la red neuronal ahora debe ser construida. Primero creamos un
BasicNetwork clase. El BasicNetwork clase es muy extensible. Es actualmente el
slo la aplicacin de la ms genrica INetwork
interfaz necesaria por Encog.
Esta red neural tendr tres capas. La capa de entrada tendr dos entradas
neuronas, la capa de salida tendrn una nica neurona de salida. Tambin habr un perodo de tres
neurona capa oculta para ayudar con el procesamiento. Los tres de estas capas puede utilizar el
BasicLayer clase. Esto implementa una red neuronal feedforward, o una multicapa
perceptrn. Cada una de estas capas hace uso de la ActivationSigmoid activacin
funcin. Sigmoide es una buena funcin de activacin para XOR porque la funcin sigmoide
Pgina 86
slo los procesos nmeros positivos. Finalmente, la verdadera
valor especifica que esta red
debe tener umbrales.
Por ltimo, la estructura de la red neuronal est finalizado. Esto construye estructuras temporales a
permite la red para tener acceso rpido. Es muy importante que
FinalizeStructure
siempre se llama despus de la red se ha construido.
network.Reset ();
Por ltimo, el restablecimiento
7.2.3 Construccin del Conjunto de Entrenamiento
mtodo se llama para inicializar los pesos y umbrales de azar
valores. El algoritmo de entrenamiento organizar estos valores aleatorios en sentido
pesos y umbrales que producen el resultado deseado.
Ahora que la red se ha creado, los datos de entrenamiento deben ser construidos. Nosotros
Ya vimos la entrada y matrices ideales creados anteriormente. Ahora, tenemos que tomar estas matrices
y representarlos como INeuralDataSet
INeuralDataSet trainingSet = new BasicNeuralDataSet (
. El siguiente cdigo hace esto.
XOR_INPUT, XOR_IDEAL);
Un BasicNeuralDataSet se utiliza; es uno de los varios tipos de conjuntos de entrenamiento que
aplicar el INeuralDataSet interfaz. Otras implementaciones de
INeuralDataSet
7.2.4 Formacin de la Red Neural
puede extraer datos de una variedad de fuentes abstractas, como SQL, HTTP
o archivos de imagen.
Ahora tenemos una BasicNetwork objeto y un INeuralDataSet objeto. Esto es todo
que se necesita para formar una red neuronal. Para implementar backpropagation que la formacin
instancias de un Backpropagation
Tren ITrain = new retropropagacin (red, trainingSet,
objeto, como sigue.
0.7, 0.8);
Como se discuti previamente, la formacin de retropropagacin hace uso de una tasa de aprendizaje y un
impulso. El valor 0,7 se utiliza para la tasa de aprendizaje, el valor 0.8 se utiliza para la
impulso. Recogiendo los valores adecuados para el tipo de aprendizaje y el impulso es algo as como un
proceso de ensayo y error. Demasiado alto de un ritmo de aprendizaje y la red ya no
disminuir su tasa de error. Demasiado baja de una tasa de aprendizaje se llevar demasiado tiempo para entrenar. Si el error
tasa se niega a bajar, incluso con una tasa de aprendizaje inferior, el impulso se debe aumentar
para ayudar a la red neuronal salir de un mnimo local.
Formacin de propagacin es mucho ms que un proceso iterativo. La iteracin mtodo es
Pgina 87
llamado una y otra; cada vez que la red se ajusta ligeramente para una mejor tasa de error.
El siguiente bucle voluntad loop y entrenar la red neuronal hasta que la tasa de error se ha reducido
por debajo de uno por ciento.
hacer
{
train.Iteration ();
+ Train.Error);
poca ++;
Cada viaje a travs del bucle se llama una poca, o una iteracin. La tasa de error es la
cantidad que la salida real de la red neural se diferencia de la salida ideales
proporcionado para el conjunto de entrenamiento.
7.2.5 Evaluacin de la Red Neural
Ahora que la red neuronal ha sido entrenado, hay que ejecutar para ver lo bien que
funciones. Comenzamos mostrando una partida que sigue :.
Ahora vamos a recorrer cada uno de los elementos de formacin establecidos. A INeuralDataSet es
compuestos de una coleccin de INeuralDataPair clases. Cada INeuralDataPair
clase contiene una entrada y una propiedad ideal. Cada una de estas dos propiedades es una
INeuralData objeto que contiene esencialmente una matriz. Esta es la forma Encog almacena el
datos de entrenamiento. Comenzamos haciendo un bucle sobre todos los INeuralDataPair objetos
contenida en el INeuralDataSet objeto.
{
Para cada uno de los INeuralDataPair objetos, calculamos la red de neural
salida utilizando la propiedad de entrada del INeuralDataPair
objeto.
Ahora mostramos la salida ideales, as como la salida real de la red neuronal.
Console.WriteLine (pair.Input [0] + ","
+ Pair.Input [1]
+ Pair.Ideal [0]);
}
La salida de esta red neural se muestra aqu.
Epoch # 1 Error: 0.504998283847474
Epoch # 2 Error: 0.504948046227928
Epoch # 3 Error: ,5028968616826613
Pgina 88
Epoch # 4 Error: ,5034596686580215
Epoch # 5 Error: 0,5042340438643891
Epoch # 6 Error: 0,5034282078077391
Epoch # 7 Error: 0.501995999394481
Epoch # 8 Error: ,5014532303103851
Epoch # 9 Error: 0,5016773751196401
Epoch # 10 Error: 0,5016348354128658
...
Epoch # 3340 Error: 0,01000800225100623
Epoch # 3341 Error: 0.010006374293649473
Epoch # 3342 Error: 0.01000474710532496
Epoch # 3343 Error: ,010003120685432222
Epoch # 3344 Error: 0.010001495033371149
Epoch # 3345 Error: ,009999870148542572
0.0,0.0, real = 0.010977229866756838, ideales = 0.0
1.0,0.0, real = 0.9905671966735671, ideales = 1.0
0.0,1.0, real = 0.989931152973507, ideales = 1.0
1.0,1.0, real = ,009434016119752921, ideales = 0.0
En primer lugar, usted ver las pocas de formacin contando hacia arriba y disminuir el error. El
error comienza en 0.50, que es justo por encima de 50%. En poca 3345, el error se ha reducido
por debajo del uno por ciento y la formacin pueden parar.
Entonces, el programa evala la red neuronal en bicicleta a travs de los datos de entrenamiento
y presentando cada elemento de formacin a la red neural. Usted se dar cuenta de la
por encima de los datos que los resultados no coinciden exactamente con los resultados ideales. Por ejemplo, el valor
0.0109 no coincide exactamente 0,0. Sin embargo, est cerca. Recuerde que la red
slo fue entrenado a un error de uno por ciento. Como resultado, los datos no se va a coincidir
con precisin.
En este ejemplo, estamos evaluando la red neuronal con el mismo los datos que era
entrenado con. Esto est bien para un ejemplo simple, donde slo tenemos cuatro de formacin
elementos. Sin embargo, es probable que desee para contener algunos de sus datos a la que
para validar la red neuronal. Validacin de la red con los mismos datos que era
entrenado con no demuestra mucho. Sin embargo, la validacin de buenos resultados con datos que no sean
lo que la red neuronal fue entrenado con prueba que la red neuronal ha ganado algo de
una especie de visin de los datos que est procesando.
Otra cosa que es interesante observar es el nmero de iteraciones que se tard en conseguir una
error aceptable. Backpropagation tom 3.345 iteraciones para llegar a un error aceptable.
Diferentes carreras de este ejemplo producen resultados diferentes, como partimos de azar
ponderaciones y mnimos generados. Sin embargo, el nmero 3345 es una indicacin bastante buena
de la eficiencia del algoritmo de backpropagation. Este nmero se compara con la
otros algoritmos de entrenamiento de propagacin.
7.2.6 Uso de la regla de actualizacin de Manhattan
A continuacin, vamos a buscar la forma de poner en prctica la regla de actualizacin de Manhattan. Hay muy
unos cambios que son necesarios para el ejemplo backpropagation para hacer que se utilice el
Pgina 89
Regla de actualizacin de Manhattan. Listado 7.2 muestra el ejemplo de regla de actualizacin de Manhattan completa.
Ficha 7.2: Uso de la actualizacin de la Regla Manhattan
using System;
utilizando Encog.Neural.Activation;
utilizando Encog.Neural.Networks.Training.Propagation.Manhattan;
Encog.Examples.XOR.Manhattan espacio de nombres
{
/// <Summary>
/// Aprenda a reconocer el patrn XOR utilizando un
/// Algoritmo de entrenamiento regla de actualizacin de Manhattan.
/// </ Summary>
public class XORManhattan: IExample
{
{
conseguir
{
typeof (XORManhattan),
"Xor-manhattan",
"Operador XOR con Manhattan Actualizar regla",
"Utilizar la Actualizacin Regla Manhattan para aprender el operador XOR.");
}
}
/// <Summary>
/// </ Summary>
nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
/// <Summary>
/// </ Summary>
Pgina 90
/// <Summary>
/// </ Summary>
{
network.AddLayer (
nueva BasicLayer (nuevo ActivationSigmoid (), verdadera, 2));
network.AddLayer (
nueva BasicLayer (nuevo ActivationSigmoid (), es cierto, 3));
network.AddLayer (
nueva BasicLayer (nuevo ActivationSigmoid (), es cierto, 1));
network.Reset ();
ITrain tren =
nueva ManhattanPropagation (red,
trainingSet, 0,0001);
int poca = 1;
hacer
{
train.Iteration ();
Console.WriteLine (
"Epoch #" + + poca "Error:" + train.Error);
poca ++;
} While (train.Error> 0,001);
{
Salida INeuralData =
network.Compute (pair.Input);
Console.WriteLine (pair.Input [0] + ","
+ Pair.Input [1]
+ ", Real =" + salida [0]
+ ", Ideales =" + pair.Ideal [0]);
}
}
}
}
En realidad slo hay una lnea que ha cambiado desde el ejemplo de propagacin hacia atrs.
Debido la ManhattanPropagation objeto usos la misma
ITrain interfaz, son muy pocos los cambios que se necesitan. Simplemente, crear un
Pgina 91
ManhattanPropagation objeto en lugar de la retropropagacin
ITrain tren =
clase que era
utilizado en la seccin anterior.
nueva ManhattanPropagation (red,
trainingSet, 0,0001);
Como se discuti previamente, la regla de actualizacin Manhattan funciona mediante el uso de una sola constante
valor para ajustar los pesos y los umbrales. Esto es por lo general un nmero muy pequeo de manera que no
para introducir rpida del cambio en la red. Para este ejemplo, el nmero 0.0001 era
elegido. Recogiendo este nmero por lo general se reduce a ensayo y error, como fue el caso de
backpropagation. Un valor demasiado alto provoca que la red cambie aleatoriamente y
nunca converger a un nmero.
La regla de actualizacin de Manhattan tender a comportarse un poco al azar al principio. El error
tasa se parecen mejorar y luego empeorar. Pero tender progresivamente menor. Despus
710.954 iteraciones la tasa de error es aceptable.
Epoch # 710941 Error: 0,011714647667850289
Epoch # 710942 Error: ,011573263349587842
Epoch # 710943 Error: 0,011431878106128258
Epoch # 710944 Error: 0.011290491948778713
Epoch # 710945 Error: 0,011149104888883382
Epoch # 710946 Error: ,011007716937768005
Epoch # 710947 Error: 0,010866328106765183
Epoch # 710948 Error: ,010724938407208937
Epoch # 710949 Error: ,010583547850435736
Epoch # 710950 Error: 0.010442156447783919
Epoch # 710951 Error: ,010300764210593727
Epoch # 710952 Error: ,01015937115020837
Epoch # 710953 Error: 0,010017977277972472
Epoch # 710954 Error: 0.009876582605234318
0.0,0.0, real = -0.013777528025884167, ideales = 0.0
1.0,0.0, real = 0.9999999999999925, ideales = 1.0
0.0,1.0, real = 0.9999961061923577, ideales = 1.0
1.0,1.0, real = -0,013757731687977337, ideales = 0.0
Como se puede ver la regla de actualizacin de Manhattan tom considerablemente ms iteraciones para encontrar una
solucin que la propagacin hacia atrs. Hay ciertos casos en los que la regla de Manhattan es
preferible backpropagation entrenamiento. Sin embargo, para un caso simple como el XOR
problema, backpropagation es una solucin mejor que la regla de Manhattan. Encontrar un mejor
valor delta puede mejorar la eficiencia de la regla de actualizacin de Manhattan.
7.2.7 Uso de Propagacin Resilient
Uno de los aspectos ms difciles de la propagacin hacia atrs y la actualizacin de Manhattan
aprendizaje de reglas es recoger los parmetros de entrenamiento correctos. Si una mala eleccin se hace por el
tasa de aprendizaje, la formacin de valores de impulso o delta no ser tan exitoso como podra
haber sido. Propagacin Resilient tiene parmetros de entrenamiento, pero es extremadamente raro
que es necesario cambiar los valores por defecto. Esto hace que la propagacin resiliente
Pgina 92
una manera muy fcil de usar un algoritmo de entrenamiento. Listado 7.3 muestra un ejemplo utilizando XOR
el algoritmo de propagacin resistente.
Ficha 7.3: El uso de Propagacin Resilient
using System;
{
{
conseguir
{
"Xor-RProp",
}
}
/// <Summary>
/// </ Summary>
doble [] [] XOR_INPUT public static = { nuevo doble [2] {0.0, 0.0},
nuevo doble [2] {1.0, 0.0},
nuevo doble [2] {0.0, 1.0},
nuevo doble [2] {1.0, 1.0}};
/// <Summary>
/// </ Summary>
/// <Summary>
/// </ Summary>
Pgina 93
{
network.Reset ();
ITrain tren =
int poca = 1;
hacer
{
train.Iteration ();
+ Train.Error);
poca ++;
{
+ Pair.Ideal [0]);
}
}
}
}
La siguiente lnea de cdigo crea un ResilientPropagation
ITrain tren =
objeto que ser
utilizado para entrenar la red neuronal.
Pgina 94
Como se puede ver no hay parmetros de formacin previstas para el
ResilientPropagation
Epoch # 1 Error: 0,5108505683309112
objeto. La ejecucin de este programa de ejemplo producir la
los siguientes resultados.
Epoch # 2 Error: ,5207537811846186
Epoch # 3 Error: ,5087933421445957
Epoch # 4 Error: ,5013907858935785
Epoch # 5 Error: ,5013907858935785
Epoch # 6 Error: 0,5000489677062201
Epoch # 7 Error: ,49941437656150733
Epoch # 8 Error: ,49798185395576444
Epoch # 9 Error: 0,4980795840636415
Epoch # 10 Error: 0,4973134271412919
...
Epoch # 270 Error: ,010865894525995278
Epoch # 271 Error: 0.010018272841993655
Epoch # 272 Error: ,010068462218315439
Epoch # 273 Error: 0.009971267210982099
0.0,0.0, real = ,00426845952539745, ideales = 0.0
1.0,0.0, real = 0.9849930511468161, ideales = 1.0
0.0,1.0, real = 0.9874048605752819, ideales = 1.0
1.0,1.0, real = ,0029321659866812233, ideales = 0.0
No slo es el algoritmo de propagacin elstica ms fcil de usar, tambin es considerablemente
ms eficiente que la propagacin hacia atrs o la regla de actualizacin de Manhattan.
7.3 Propagacin y subprocesos mltiples
A partir de la redaccin de este documento, los ordenadores de un solo ncleo se estn convirtiendo en mucho menos
comn que las computadoras de ncleo mltiple. Un equipo de doble ncleo tiene efectivamente dos completa
procesadores en un solo chip. Ordenadores Quadcore tienen cuatro procesadores en un solo chip.
La ltima generacin de Quadcores, el i7 de Intel, viene con hyperthreading tambin.
Hyperthreading permite que un procesador de ncleo para que aparezca como dos ejecutando simultneamente
mltiples instrucciones. Un equipo que utiliza la tecnologa hyperthreading har realidad
informar dos veces el nmero de ncleos que se instala en realidad.
Procesadores parecen haber llegado al mximo de su velocidad en torno al 3 gigahertz. El crecimiento en
potencia de clculo no estar en la velocidad de procesamiento de los procesadores individuales. Ms bien,
el crecimiento futuro estar en el nmero de ncleos de un equipo tiene. Sin embargo, aprovechando
de estos ncleos adicionales puede ser un desafo para el programador de computadoras. Para tomar
ventaja de estos ncleos se debe escribir software multiproceso.
Libros enteros se han escrito sobre la programacin multihilo, por lo que no sern cubiertos en
profundidad aqu. Sin embargo, la idea general es tener un gran problema y dividirlo en
pedazos manejables que pueden ejecutar de forma independiente por varios subprocesos. La solucin final
luego debe ser reconstruido de nuevo juntos de cada uno de los hilos. Este proceso se llama
agregacin.
Pgina 95
Encog hace uso de mltiples hilos en muchas reas clave. Una de ellas es la formacin. Por
por defecto la propagacin tcnicas de entrenamiento utilizarn multithreading si parece que
multithreading ayudar rendimiento. Especficamente, no debe haber ms de un ncleo
y datos de entrenamiento suficientes para multithreading a valer la pena. Si ambos de estos elementos
estn presentes, cualquiera de las tcnicas de propagacin har uso de multihilo.
Es posible decir Encog utilizar un nmero especfico de hilos, o deshabilitar roscado
por completo. Los NumThreads
Cuando se solicita Encog para determinar el nmero ptimo de subprocesos para utilizar, varios
se consideran las cosas. Encog considera el nmero de ncleos que estn disponibles. Encog
tambin considera el tamao de los datos de entrenamiento. Formacin multiproceso funciona mejor con mayor
conjuntos de formacin.
propiedad proporcionada por todo el entrenamiento de propagacin
algoritmos hace esto. Para ejecutar en modo de un solo subproceso, especifique un hilo. Para especificar un
nmero determinado de hilos especificar el nmero de hilos deseados. Finalmente, para permitir Encog
para determinar el nmero ptimo de hebras, especifique cero hilos. El cero es el valor por defecto
valor para el nmero de hilos.
7.3.1 Cmo funciona el Entrenamiento multiproceso
Formacin multiproceso funciona particularmente bien con grandes conjuntos de entrenamiento y mquinas
mltiples ncleos. Si Encog no detecta que ambos estn presentes, se recurrir a una sola
roscada. Cuando hay ms de un ncleo de procesamiento, y suficientes elementos de formacin establecidos a
mantener los dos ncleos ocupados, formacin multiproceso funcionar mucho ms rpido que un solo
roscada.
Ya vimos a tres tcnicas de propagacin de entrenamiento. Todo propagation-
tcnicas de entrenamiento funcionan de manera similar. Tanto si se trata de retropropagacin, propagacin resiliente
o la regla de actualizacin de Manhattan, la tcnica es similar. Hay dos tres pasos distintos:
1. Realizar una alimentacin regular Forward Pass.
2. Proceso de los niveles hacia atrs y determinar los errores en cada nivel.
3. Aplicar los cambios en las ponderaciones y mnimos.
En primer lugar, se realiza un pase hacia adelante de alimentacin regular. La salida de cada nivel se mantiene por lo
el error para cada nivel se puede evaluar de forma independiente. En segundo lugar, se calculan los errores
en cada nivel, y los derivados de cada una de las funciones de activacin se utilizan para calcular
descensos de gradiente. Estos gradientes muestran la direccin en la que el peso debe ser modificado para
mejorar el error de la red. Estos gradientes se utilizarn en el tercer paso.
El tercer paso es lo que vara entre los diferentes algoritmos de entrenamiento. Backpropagation
simplemente toma los descensos de degradado y los escala por un tipo de aprendizaje. El gradiente escalado
descensos son entonces aplicadas directamente a los pesos y umbrales. El Manhattan de actualizacin
Regla slo utiliza el signo de la pendiente de decidir en qu direccin para afectar el peso.
El peso se cambia a continuacin, ya sea en la direccin positiva o negativa por un fijo
constante.
Pgina 96
Rprop mantiene un valor delta individual para cada peso y umbrales y nicos usos
el signo del gradiente descendente para aumentar o disminuir las cantidades delta. El delta
cantidades se aplican entonces a los pesos y umbrales.
El algoritmo multiproceso utiliza hilos para llevar a cabo los pasos 1 y 2 los datos de entrenamiento
est dividida en paquetes que se distribuyen entre los hilos. Al comienzo de cada
iteracin, las discusiones se comenz a manejar cada uno de estos paquetes. Una vez que todos los temas tienen
completado, un solo hilo agregados de todos los resultados de las roscas y las aplica
a la red neural. Hay un muy breve perodo de tiempo en el que slo un hilo es
de ejecucin, al final de la iteracin. Esto puede verse en la Figura 7.1.
Figura 7.1: Encog Formacin en un Quadcore Hyperthreaded
Como se puede ver en la imagen de arriba, el i7 se est ejecutando actualmente en el 100%. Usted puede
ver claramente el final de cada iteracin, donde cada uno de los procesadores cae brevemente.
Afortunadamente, este es un tiempo muy breve, y no tiene un gran impacto en la formacin general
eficiencia. Yo prob implementaciones donde no fuerzo las roscas que esperar al final
de la iteracin para una resincronizacin. Sin embargo, stos no proporcionan una formacin eficiente
debido a que los algoritmos de entrenamiento propagacin necesitan todos los cambios aplicados antes de la prxima
comienza iteracin.
7.3.2 La capacitacin multiproceso
Para ver el entrenamiento multiproceso realmente brilla, se necesita un conjunto de entrenamiento ms grande. En la siguiente
captulo veremos cmo recopilar informacin para Encog, y las series de entrenamiento ms grandes seremos
utilizado. Sin embargo, por ahora, vamos a ver un ejemplo comparativo simple que genera un
conjunto de entrenamiento al azar y compara los tiempos de entrenamiento multiproceso y de un nico subproceso.
Un simple punto de referencia se muestra que hace uso de una capa de entrada de 40 neuronas, A Hidden
capa de 60 neuronas, y una capa de salida de las neuronas 20. Un conjunto de entrenamiento de 50,000 elementos
se utiliza. Este ejemplo se muestra en el listado 7.4.
Ficha 7.4: La capacitacin multiproceso
using System;
Pgina 97
utilizando Encog.Util.Banchmark;
utilizando Encog.Util.Logging;
Encog.Examples.MultiBench espacio de nombres
{
public class MultiThreadBenchmark: IExample
{
public const int contaje_entradas = 40;
public const int HIDDEN_COUNT = 60;
public const int OUTPUT_COUNT = 20;
aplicacin IExampleInterface privado;
{
conseguir
{
typeof (MultiThreadBenchmark),
"Multibench",
"Benchmark subprocesos mltiples",
"Ver los efectos que tiene sobre el rendimiento multihilo.");
}
}
pblica BasicNetwork generateNetwork ()
{
network.AddLayer (
nueva BasicLayer (MultiThreadBenchmark.INPUT_COUNT));
network.AddLayer (
nueva BasicLayer (MultiThreadBenchmark.HIDDEN_COUNT));
network.AddLayer (
nueva BasicLayer (MultiThreadBenchmark.OUTPUT_COUNT));
network.Reset ();
red de retorno;
}
pblica INeuralDataSet generateTraining ()
{
Formacin INeuralDataSet =
RandomTrainingFactory.Generate (1000,50000,
Contaje_entradas, OUTPUT_COUNT, -1, 1);
volver formacin;
Pgina 98
}
(red pblica doble evaluateRPROP BasicNetwork,
INeuralDataSet datos)
{
ResilientPropagation tren =
nueva ResilientPropagation (red, datos);
largo start = DateTime.Now.Ticks;
Console.WriteLine ("Training 20 iteraciones con Rprop");
for (int i = 1; i <= 1; i ++)
{
train.Iteration ();
Console.WriteLine ("Iteracin #" + i + "Error:"
+ Train.Error);
}
//train.FinishTraining ();
larga parada = DateTime.Now.Ticks; doble diff = new TimeSpan (parada - inicio) .Seconds;
Console.WriteLine ("Rprop Resultado:" + + "diff segundos.");
Console.WriteLine ("Error Rprop final:"
+ Network.CalculateError (datos));
volver diff;
}
(red pblica doble evaluateMPROP BasicNetwork,
INeuralDataSet datos)
{
ResilientPropagation tren =
nueva ResilientPropagation (red, datos);
largo start = DateTime.Now.Ticks;
Console.WriteLine ("Training 20 iteraciones con MPROP");
for (int i = 1; i <= 20; i ++)
{
train.Iteration ();
Console.WriteLine ("Iteracin #" + i + "Error:"
+ Train.Error);
}
//train.finishTraining ();
larga parada = DateTime.Now.Ticks;
doble diff = new TimeSpan (parada - inicio) .Seconds;
Console.WriteLine ("MPROP Resultado:" + + "diff segundos.");
Console.WriteLine ("Error MPROP final:"
+ Network.CalculateError (datos));
volver diff;
}
{
this.app = aplicacin;
Logging.StopConsoleLogging ();
Red BasicNetwork generateNetwork = ();
Datos INeuralDataSet = generateTraining ();
doble RProp = evaluateRPROP (red, datos);
Pgina 99
doble mprop = evaluateMPROP (red, datos);
doble = factor RProp / mprop;
Console.WriteLine ("mejora Factor:" + factores);
}
}
}
Ejecut este programa en un i7 Quadcore con Hyperthreading. El siguiente fue
el resultado.
Entrenamiento 20 iteraciones con una sola rosca
Iteracin # 1 Error: 1,0594453784075148
Iteracin # 2 Error: 1,0594453784075148
Iteracin # 3 Error: 1,0059791059086385
Iteracin # 4 Error: 0.955845375587124
Iteracin # 5 Error: 0.934169803870454
Iteracin # 6 Error: 0,9140418793336804
Iteracin # 7 Error: ,8950880473422747
Iteracin # 8 Error: 0,8759150228219456
Iteracin # 9 Error: 0,8596693523930371
Iteracin # 10 Error: 0.843578483629412
Iteracin # 11 Error: 0,8239688415389107
Iteracin # 12 Error: 0,8076160458145523
Iteracin # 13 Error: 0,7928442431442133
Iteracin # 14 Error: 0,7772585699972144
Iteracin # 15 Error: 0,7634533283610793
Iteracin # 16 Error: ,7500401666509937
Iteracin # 17 Error: 0,7376158116045242
Iteracin # 18 Error: 0,7268954113068246
Iteracin # 19 Error: ,7155784667628093
Iteracin # 20 Error: 0.705537166118038
Rprop Resultado: 35,134 segundos.
Error final Rprop: 0,6952141684716632
Entrenamiento 20 iteraciones con multithreading
Iteracin # 1 Error: ,6952126315707992
Iteracin # 2 Error: ,6952126315707992
Iteracin # 3 Error: 0.90915249248788
Iteracin # 4 Error: 0,8797061675258835
Iteracin # 5 Error: ,8561169673033431
Iteracin # 6 Error: 0,7909509694056177
Iteracin # 7 Error: ,7709539415065737
Iteracin # 8 Error: 0,7541971172618358
Iteracin # 9 Error: ,7287094412886507
Iteracin # 10 Error: 0.715814914438935
Iteracin # 11 Error: 0,7037730808705016
Iteracin # 12 Error: 0,6925902585055886
Iteracin # 13 Error: ,6784038181007823
Iteracin # 14 Error: ,6673310323078667
Iteracin # 15 Error: 0,6585209150749294
Iteracin # 16 Error: ,6503710867148986
Iteracin # 17 Error: 0,6429473784897797
Iteracin # 18 Error: 0,6370962075614478
Iteracin # 19 Error: ,6314478792705961
Pgina 100
Iteracin # 20 Error: 0,6265724296587237
Resultado multiproceso: 8,793 segundos.
Final de error Multi-thread: ,6219704300851074
Mejora Factor: 4,0106783805299674
Como se puede ver en los resultados anteriores, el algoritmo nico Rprop roscado terminado
en 128 segundos, el algoritmo Rprop multiproceso termin en slo 31 segundos.
Multithreading mejor el rendimiento en un factor de cuatro. Sus resultados se ejecutan las anteriores
ejemplo depender de cuntos ncleos tenga el equipo. Si su equipo es nico
ncleo, sin hyperthreading, entonces el factor ser cercano a uno. Esto es porque el
segundo entrenamiento multi-threading volver a caer a un solo hilo.
7.4 Resumen
En este captulo hemos visto cmo utilizar tres algoritmos de propagacin diferentes con Encog.
Formacin de propagacin es una clase muy comn de algoritmos de entrenamiento supervisadas. En este
captulo que vio cmo utilizar tres algoritmos de entrenamiento de propagacin diferentes. Resilient
formacin de propagacin es generalmente la mejor opcin; sin embargo; la regla de actualizacin de Manhattan y
backpropagation puede ser til para ciertas situaciones.
Backpropagation fue uno de los algoritmos de entrenamiento originales para neuronal feedforward
redes. Aunque Encog lo apoya en su mayora con fines histricos, a veces puede ser
utilizado para perfeccionar la una red neuronal despus de la propagacin elstica se ha utilizado.
Backpropagation utiliza una tasa de aprendizaje y el impulso. La tasa de aprendizaje define cmo
rpidamente la red neuronal aprender; el impulso de la red ayuda a salir de locales
mnimos.
La regla de actualizacin de Manhattan utiliza un valor delta para cambiar actualizar el peso y
valores de umbral. Puede ser difcil elegir correctamente este valor delta. Demasiado alto de un
valor har que la red para aprender nada en absoluto.
Propagacin Resiliente (Rprop) es uno de los mejores algoritmos de entrenamiento ofrecidos por
Encog. No requiere que usted proporcione los parmetros de entrenamiento, al igual que los otros dos
algoritmos de propagacin de entrenamiento. Esto hace que sea mucho ms fcil de utilizar. Adems, resistente
propagacin es considerablemente ms eficiente que regla de actualizacin de Manhattan o
backpropagation.
Formacin multiproceso es una tcnica de entrenamiento que se adapta a la formacin de propagacin
funcionar ms rpido con los ordenadores multincleo. Dado un equipo con varios ncleos y una
gran conjunto de entrenamiento suficiente, formacin multiproceso es considerablemente ms rpido que un solo
formacin roscada. Encog puede configurar automticamente un nmero ptimo de subprocesos. Si estos
condiciones no estn presentes, Encog caer de nuevo a la formacin de un solo subproceso.
Este documento proporciona una introduccin a la programacin Encog. Para una ms
avanzada, y largo, manual sobre programacin Encog usted puede estar interesado en mi libro
"Programacin Redes Neuronales con Encog 2 en C #". ISBN 1604390107. Este libro es
disponible tanto en formato de bolsillo y libros electrnicos. Este libro aade muchos captulos y es
Pgina 101
cerca de 500 pginas de largo. Su compra de nuestro libro apoya el proyecto Encog! Para obtener ms
informacin visite.

Introducción A Encog 2

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Introducción A Encog 2

Diunggah oleh

Hak Cipta:

Format Tersedia

27/8/2014 Introduccin a Encog 2.

Anda mungkin juga menyukai