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



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.

http://www.heatonresearch.com/book/programming-redes neuronales-encog-cs.html

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 ............................................... .................................. 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


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 ................................................ ............................... 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


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.



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


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,



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


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



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 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.



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:

adalinedigitsart1 de clasificarbampunto de referenciacpnbosque

Pgina 11


Hopfield-asociado-Hopfield sencillaimagenlunar



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


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.



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 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



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


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 neuronalescreado 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 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.



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 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



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 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




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


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 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


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.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


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:



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


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]);



}

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


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;



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;}

}/// /// 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:"



Pgina 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




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 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


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{


}

IList Siguiente{

conseguir;}

ICollection NextLayers{

conseguir;}

doble [] Umbral{


}

int X{


Pgina 29


}

int Y{


}

int ID{


}

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

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));



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


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



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.

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.



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{


}

int FromNeuronCount{

conseguir;}

Matrix.Matrix WeightMatrix{


}

int MatrixSize{

conseguir;}

ILayer ToLayer{


}

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. 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


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);



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


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, 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


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.



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


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.



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


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.



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 cdig

Introducción a Encog 2

Documents

Transcript of Introducción a Encog 2