Upload
miguelgonzalezperez
View
162
Download
0
Embed Size (px)
DESCRIPTION
Introduccion a las redes neuronales
Citation preview
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 #
http://translate.googleusercontent.com/translate_f 2/88
Page 2
Introduccin a Encog 2.5 para C # 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.
http://www.heatonresearch.com/book/programming-redes neuronales-encog-cs.html
Page 3
Introduccin a Encog 2.5 para C # 3
Contenido
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 3/88
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
Introduccin a Encog 2.5 para C # 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 4/88
4.4.2 La Clase BAMLogic ............................................... .................................. 384.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
Introduccin a Encog 2.5 para C # 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 5/88
7.2.1 Usando Retropropagacin ................................................ ............................... 831.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
Introduccin a Encog 2.5 para C # 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 ningnAPI 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.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 6/88
He encontrado que muchas personas estaban usando el cdigo que figura en el libro como un neuralAPI 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 debecomprender 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
Introduccin a Encog 2.5 para C # 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 deseadoy 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,
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 7/88
tambin hay muchos problemas para los cuales una solucin de red neuronal es bastante til. EnAdems, 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
Introduccin a Encog 2.5 para C # 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 eneste 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 8/88
Page 9
Introduccin a Encog 2.5 para C # 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 captulose 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, yEjemplos 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.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 9/88
Pgina 10
Introduccin a Encog 2.5 para C # 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:
adalinedigitsart1 de clasificarbampunto de referenciacpnbosque
Pgina 11
Introduccin a Encog 2.5 para C # 11
Hopfield-asociado-Hopfield sencillaimagenlunar
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 10/88
mercadomultibenchOpenCL del ndice de referenciaOpenCL-comparar-OpenCL concurrenteOpenCL-info-OpenCL sencillaOpenCL-manchas solaresOpenCL-tuneOpenCL-xorpersistir-encogpersistir en serie-radial mltipleslas manchas solaresthreadcountcucharadita de recocidocucharadita-Boltzmann-cucharadita genticapeso-initxor-recocidoxor-Backpropxor-elman-xor gaussiano-xor genticaxor-jordanxor-lmaxor-manhattan-xor ordenadaxor-radialxor-RPropxor-SCGxor-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
Introduccin a Encog 2.5 para C # 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 porEncog Java. Los ltimos tres archivos DLL son utilizados por nUnit, que proporciona la unidad de pruebas para
Encog.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 11/88
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
Introduccin a Encog 2.5 para C # 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 ungua 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 12/88
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 Hopfieldredes 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 porel 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
Introduccin a Encog 2.5 para C # 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 13/88
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 neuronalescreado por Encog. El siguiente captulo se centra exclusivamente en las capas y las sinapsis.
Pgina 15
Introduccin a Encog 2.5 para C # 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 enla 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.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 14/88
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
Introduccin a Encog 2.5 para C # 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 esdiscutido 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 complejaestructuras.
El nico propsito de las capas ocultas es permitir que la red neuronal para productos de mejor
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 15/88
Pgina 17
Introduccin a Encog 2.5 para C # 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 detraducir 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 puedeaprender 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 permitenla 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 unnueva 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 Yoperador se muestran abajo.
0 Y 0 = 01 Y 0 = 00 Y 1 = 01 Y 1 = 1
Pgina 18
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 16/88
Introduccin a Encog 2.5 para C # 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 = 01 O 0 = 10 OR 1 = 11 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, exceptopara el caso donde ambas entradas son verdaderas. Las posibles combinaciones para el operador XOR
se muestran aqu.
0 XOR 0 = 01 XOR 0 = 10 XOR 1 = 11 XOR 1 = 0
Como se puede ver el operador XOR slo devuelve verdadero cuando ambas entradas son diferentes. En elsiguiente 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.00.0,1.01.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.01.00.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
Introduccin a Encog 2.5 para C # 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:
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 17/88
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 XORdatos.
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 Encogredes neuronales sobre una base capa por capa. La Figura 3.5 muestra cmo la red anterior es
representado en Encog.
Pgina 20
Introduccin a Encog 2.5 para C # 20
Figura 3.5: Diagrama Encog Capa de la Red XOR
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 18/88
El cdigo necesario para crear esta red es relativamente simple.
Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (2));network.AddLayer (nuevo BasicLayer (2));network.AddLayer (nuevo BasicLayer (1));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 demasiadoapagado. 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 esdiscutido en la siguiente seccin.
Pgina 21
Introduccin a Encog 2.5 para C # 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 = 10 XOR 1 = 11 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:
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 19/88
doble [] [] XOR_IDEAL public static = {Nuevo Doble [1] {0,0},Nuevo Doble [1] {1,0},Nuevo Doble [1] {1,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 lared 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 ciertatcnicas de entrenamiento. El cdigo siguiente construye un entrenador Rprop.
Pgina 22
Introduccin a Encog 2.5 para C # 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 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]);
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 20/88
}
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: ,5056375155784316Epoch # 3 Error: 0,5026960720526166Epoch # 4 Error: ,4907299498390594...Epoch # 104 Error: 0.01017278345766472Epoch # 105 Error: 0,010557202078697751Epoch # 106 Error: ,011034965164672806Epoch # 107 Error: ,009682102808616387
El error comienza en 56% en poca 1. poca 107 el entrenamiento se ha reducido por debajo del 1%
Pgina 23
Introduccin a Encog 2.5 para C # 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.01.0,0.0, real = 0.9903741937121177, ideales = 1.00.0,1.0, real = 0.9836807956566187, ideales = 1.01.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 habrgeneralmente 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.
Resultados de red neuronal:0.0,0.0, real = 0.005489822214926685, ideales = 0.01.0,0.0, real = 0.985425090860287, ideales = 1.00.0,1.0, real = 0.9888064742994463, ideales = 1.01.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;
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 21/88
utilizando Encog.Engine.Network.Activation;XORResilient clase pblica: IExample{
public static Info ExampleInfo{
conseguir{
Pgina 24
Introduccin a Encog 2.5 para C # 24
Info ExampleInfo = new ExampleInfo (typeof (XORResilient),"Xor-RProp","Operador XOR con Propagacin resilientes","Usar Rprop aprender el operador XOR.");
devolver informacin;}
}/// /// De entrada para la funcin XOR./// 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}};
/// /// Salida ideal para la funcin XOR./// doble [] [] XOR_IDEAL public static = {
Nuevo Doble [1] {0,0},Nuevo Doble [1] {1,0},Nuevo Doble [1] {1,0},nuevo doble [1] {0,0}};
/// /// Punto de entrada del programa./// /// No se utiliza. public void Execute (IExampleInterface app){
Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (
nueva ActivationSigmoid (), verdadera, 2));network.AddLayer (nuevo BasicLayer (
nueva ActivationSigmoid (), verdadera, 6));network.AddLayer (nuevo BasicLayer (
nueva ActivationSigmoid (), es cierto, 1));network.Structure.FinalizeStructure ();network.Reset ();
INeuralDataSet trainingSet =nueva BasicNeuralDataSet (XOR_INPUT, XOR_IDEAL);
// Entrenar la red neuronalITrain tren =
nueva ResilientPropagation (red, trainingSet);
int poca = 1;
hacer{
train.Iteration ();Console.WriteLine ("Epoch #" + + poca "Error:"
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 22/88
Pgina 25
Introduccin a Encog 2.5 para C # 25
+ Train.Error);poca ++;
} While ((poca 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 neuronalConsole.WriteLine ("Resultados de 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]);
}
}}
}
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 cmopara 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 lossu 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
Introduccin a Encog 2.5 para C # 26
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 23/88
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
Introduccin a Encog 2.5 para C # 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 24/88
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 paracrear 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 exactamentelas 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 unred 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
Introduccin a Encog 2.5 para C # 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{
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 25/88
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 Siguiente{
conseguir;}
ICollection NextLayers{
conseguir;}
doble [] Umbral{
conseguir;establecido;
}
int X{
conseguir;establecido;
Pgina 29
Introduccin a Encog 2.5 para C # 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 26/88
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
Introduccin a Encog 2.5 para C # 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
Red BasicNetwork = new BasicNetwork ();
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 activacinfuncin. Por ejemplo, el cdigo siguiente crea tres capas, con un nmero variable de
neuronas.
network.AddLayer (nuevo BasicLayer (2));network.AddLayer (nuevo BasicLayer (6));network.AddLayer (nuevo BasicLayer (1));network.Structure.FinalizeStructure ();network.Reset ();
Si desea ms control sobre la capa, puede utilizar una forma ms avanzadaconstructor. El siguiente constructor permite especificar la funcin de activacin, como
as como si se deben usar valores de umbral.
Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (nuevo ActivationSigmoid (), verdadera, 2));
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 27/88
network.AddLayer (nuevo BasicLayer (nuevo ActivationSigmoid (), verdadera, 6));network.AddLayer (nuevo BasicLayer (nuevo ActivationSigmoid (), es cierto, 1));network.Structure.FinalizeStructure ();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 umbralvalores, 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
Introduccin a Encog 2.5 para C # 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 neuralred 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);Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (1));network.AddLayer (oculto = new BasicLayer (2));hidden.AddNext (contexto, SynapseType.OneToOne);context.AddNext (oculto);
network.AddLayer (nuevo BasicLayer (1));network.Structure.FinalizeStructure ();
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 adicionalprocesamiento. 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 28/88
la opcin por defecto para el RadialBasisFunctionLayer clase. Usted puede ver el
Funcin de Gauss en la Figura 4.1.
Pgina 32
Introduccin a Encog 2.5 para C # 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.
Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (nuevo ActivationLinear (), falsa, 2));
network.AddLayer (rbfLayer = new RadialBasisFunctionLayer (4),SynapseType.Direct);network.AddLayer (nuevo BasicLayer (1));network.Structure.FinalizeStructure ();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 sinapsistipos. 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 tienensu 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.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 29/88
Pgina 33
Introduccin a Encog 2.5 para C # 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
Introduccin a Encog 2.5 para C # 34
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 30/88
{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. Acapa 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
Introduccin a Encog 2.5 para C # 35
Las siguientes lneas de cdigo crean estas sinapsis.
ISynapse synapseInputToHidden = newWeightedSynapse (inputLayer, hiddenLayer);ISynapse synapseHiddenToOutput = newWeightedSynapse (hiddenLayer, outputLayer);
Estas sinapsis continuacin, se pueden aadir a las dos capas que se originan a partir.
inputLayer.Next.Add (synapseInputToHidden);
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 31/88
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.Structure.FinalizeStructure ();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
Introduccin a Encog 2.5 para C # 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
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 32/88
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, perodesea 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 destinotener el mismo nmero de neuronas. La figura 4.4 muestra el de una sinapsis.
Pgina 37
Introduccin a Encog 2.5 para C # 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);Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (1));network.AddLayer (oculto = new BasicLayer (2));hidden.AddNext (contexto, SynapseType.OneToOne);context.AddNext (oculto);network.AddLayer (nuevo BasicLayer (1));network.Structure.FinalizeStructure ();
El de una sinapsis se utiliza generalmente para alimentar directamente los valores de la salida deuna 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.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 33/88
4.3.6 Uso de la sinapsis directaLa 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 unamatriz 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
Introduccin a Encog 2.5 para C # 38
RadialBasisFunctionLayer rbfLayer;Red BasicNetwork = new BasicNetwork ();network.AddLayer (nuevo BasicLayer (
nueva ActivationLinear (), falsa, 2));network.AddLayer (rbfLayer = new RadialBasisFunctionLayer (4),
SynapseType.Direct);network.AddLayer (nuevo BasicLayer (1));network.Structure.FinalizeStructure ();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 porStephen 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 laversin de ART se utiliza. Redes neuronales ART se utilizan para el reconocimiento de patrones y
prediccin. Encog actualmente soporta ART1.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 34/88
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 BartKosko 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
Introduccin a Encog 2.5 para C # 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 lasalida 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 elMquina 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 feedforwardde 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 ocapas 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 Hopfieldred 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 Hopfieldred 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.
27/8/2014 Introduccin a Encog 2.5 prrafo C #
http://translate.googleusercontent.com/translate_f 35/88
Pgina 40
Introduccin a Encog 2.5 para C # 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 cdig