Professional Documents
Culture Documents
FACULTAD DE INGENIERIAS
SEDE QUITO – CAMPUS SUR
Tema:
DIRECTOR:
ING. NAVAS RUILOVA GUSTAVO
Octubre 2007
Quito-Ecuador
1
DECLARACIÓN
Yo, Danny Anael López Loaiza, declaro bajo juramento que el trabajo aquí
descrito es de mi autoría; que no ha sido previamente presentado para ningún
grado o calificación profesional; y, que hemos consultado las referencias
bibliográficas que se incluyen en este documento.
_______________________
CERTIFICACIÓN
Certifico que el presente trabajo fue desarrollado por Danny Anael López Loaiza,
bajo mi dirección.
_______________________
Ing. Navas Ruilova Gustavo
3
DEDICATORIA
Dedicado a todas aquellas personas que en lugar de ver una nota, un pago o un
premio; vieron la necesidad y gusto de aprender algo, imaginarlo y verlo
funcionar.
AGRADECIMIENTOS
Así que para hacer un breve resumen puedo agradecer a mis padres por su
cariño, por todas las oportunidades que me regalan, por hacerme ver el mundo de
otra forma, por solo mencionar unas pocas razones.
Entre muchas, muchas más a quienes no creo que hago justicia en este
agradecimiento; como al viejo pichirilo que entre atentados físicos y velocidades
nunca vistas, me llevo sano y salvo a mi casa todas las noches durante algunos
años.
5
ÍNDICE DE CONTENIDO
Indice :
. DECLARACIÓN................................................................................................................. 1
. CERTIFICACIÓN............................................................................................................... 2
. DEDICATORIA...................................................................................................................3
. AGRADECIMIENTOS....................................................................................................... 4
. ÍNDICE DE CONTENIDO .................................................................................................5
. RESUMEN.........................................................................................................................13
. PRESENTACIÓN.............................................................................................................. 14
1. CAPITULO I: Introducción al Tema de Tesis................................................................. 15
1.1. Titulo:....................................................................................................................... 15
1.2. Planteamiento del problema: ................................................................................... 15
1.3. Objetivos...................................................................................................................17
1.3.1. Objetivo General...............................................................................................17
1.3.2. Objetivos específicos........................................................................................ 17
1.4. Alcance..................................................................................................................... 18
1.5. Importancia y Justificación.......................................................................................19
1.5.1. Importancia....................................................................................................... 19
1.5.2. Justificación...................................................................................................... 19
2. CAPITULO II: Tecnología DotNET................................................................................20
2.1. Introducción: ............................................................................................................20
2.2. .NET Framework:..................................................................................................... 21
2.2.1. CLI (Common Language Infrastructure).......................................................... 23
2.2.2. BCL (Base Class Library):................................................................................25
2.2.3. CLR (Common Language Runtime).................................................................27
2.2.4. RESUMEN....................................................................................................... 29
2.3. IDE (Integrated Development Environment) para .NET:........................................ 31
2.4. Versiones del .NET Framework:.............................................................................. 34
2.4.1. .NET Framework v1.0: .................................................................................... 34
2.4.2. .NET Framework v1.1: .................................................................................... 34
2.4.3. .NET Framework v2.0: .................................................................................... 35
2.4.4. .NET Framework v3.0: .................................................................................... 35
6
Dibujos
. Dibujo 1: .NET FrameWork - ORIGEN: Propia del autor.................................................21
. Dibujo 2: Estructura del FrameWork - ORIGEN: Propia del autor................................... 30
. Dibujo 3: IDE Visual Studio.NET - ORIGEN: Microsoft Visual Studio .NET 2005...... 32
. Dibujo 4: IDE SharpDevelop - ORIGEN: SharpDevelop v2.0..........................................33
. Dibujo 5: Habilitar Código No Seguro - ORIGEN: Visual Studio.NET 2005.................. 47
. Dibujo 6: Flujo de Hilos - ORIGEN: Propia del autor.......................................................50
. Dibujo 7: Nuevo Proyecto Class Library - ORIGEN: Visual Studio.NET 2005............... 52
. Dibujo 8: Nuevos componentes o controles - ORIGEN: Visual Studio.NET 2005...........53
. Dibujo 9: Propiedades en el código - ORIGEN: Propia del autor......................................58
. Dibujo 10: Neurona Biológica - ORIGEN: Propia del autor............................................. 63
. Dibujo 11: Neurona Artificial - ORIGEN: Propia del autor.............................................. 65
. Dibujo 12: Problema de Oscilación - ORIGEN: Propia del autor..................................... 68
. Dibujo 13: Solución Linealidad - ORIGEN: Propia del autor........................................... 69
. Dibujo 14: Compuerta AND - ORIGEN: Propia del autor................................................ 71
. Dibujo 15: Solución C. AND - ORIGEN: Propia del autor............................................... 72
. Dibujo 16: Problema Lineal - ORIGEN: Propia del autor................................................. 73
. Dibujo 17: Compuerta XOR - ORIGEN: Propia del autor................................................ 74
. Dibujo 18: Problema No Lineal - ORIGEN: Propia del autor........................................... 75
. Dibujo 19: Interconexión de capas - ORIGEN: Propia del autor.......................................76
. Dibujo 20: Estructura de una RNA - ORIGEN: Propia del autor...................................... 77
. Dibujo 21: Solución de la C. XOR - ORIGEN: Propia del autor......................................78
. Dibujo 22: Neurona BIAS - ORIGEN: Propia del autor...................................................79
. Dibujo 23: Propagación de errores hacia atrás - ORIGEN: Propia del Autor....................81
. Dibujo 24: David E. Rumelhart - ORIGEN:
http://www.grawemeyer.com/psychology/previous/02.htm................................................ 83
. Dibujo 25: James L McClelland - ORIGEN:
http://www.grawemeyer.com/psychology/previous/02.htm................................................ 83
. Dibujo 26: Caso de uso Nº 1 - ORIGEN: Propia del Autor.............................................. 98
. Dibujo 27: Caso de uso Nº 2 - ORIGEN: Propia del Autor.............................................. 99
. Dibujo 28: Caso de uso Nº 3 - ORIGEN: Propia del Autor............................................ 100
. Dibujo 29: Caso de uso Nº 4 - ORIGEN: Propia del Autor............................................ 101
10
Códigos
Código 1: Ejemplo de código escrito en C# - ORIGEN: Propia del Autor..........................37
Código 2: Ejemplo del uso de punteros - ORIGEN: Propia del Autor................................ 48
Código 3: AssemblyInfo - ORIGEN: Propia del autor........................................................ 53
Código 4: Crear una Propiedad - ORIGEN: Propia del autor.............................................. 54
Código 5: Método PAINT - ORIGEN: Propia del autor......................................................54
Código 6: Control sencillo - ORIGEN: Propia del autor..................................................... 55
Código 7: Crear un Evento - ORIGEN: Propia del autor....................................................56
Código 8: Comentarios XML - ORIGEN: Propia del autor................................................57
Código 9: Argumentos documentados - ORIGEN: Propia del autor................................... 58
Código 10: Ejem de entrenamiento - ORIGEN: Propia del autor......................................146
Código 11: Ejem del evento iteración - ORIGEN: Propia del autor.................................. 147
Código 12: Detener el entrenamiento - ORIGEN: Propia del autor...................................147
Código 13: Ejemplo de uso con BDD - ORIGEN: Propia del autor..................................148
Código 14: Ejemplo del uso de fichero - ORIGEN: Propia del autor................................148
Código 15: Ejem de consulta - ORIGEN: Propia del autor............................................... 149
13
RESUMEN
***
14
PRESENTACIÓN
Por esta razón, creo que el uso de software abierto o libre es la mejor alternativa a
la hora de desarrollar una aplicación. En cuanto a sistemas inteligentes, a la hora
de desarrollar el presente trabajo, no existen proyectos de software abierto para
inteligencia artificial. De modo que el diseño y construcción de nuestras propias
herramientas se convierte en un eje indispensable; y así es que el presente
trabajo muestra, no solo como programar una herramienta inteligente que en este
caso es una red neuronal, sino que muestra como crear una herramienta, un
control para ser usado en cualquier aplicación y enfocándola al programador y no
a un usuario final.
***
15
Dada esta realidad social y económica que hace prácticamente imposible que
una pequeña empresa financie una herramienta de programación de tal
elevados costos, nos encontramos hoy en día con ingenieros que han pasado
a formar parte de otros sectores como operarios, realizando funciones
impropias a las de un ingeniero, que son la investigación y desarrollo de
soluciones; convergiendo en uno de los tantos problemas que nos sitúan como
un país consumista y tercermundista.
17
1.3 Objetivos
Diseñar y construir una red neuronal artificial de propósito general que pueda ser
usada en cualquier lenguaje de programación que soporte la tecnología DotNET
v2. (Microsoft FrameWork 2.0)
1.4 Alcance
Así mismo el software esta sujeto a las limitaciones y alcance que posee la
plataforma FrameWork 2.
19
1.5.1 Importancia.
1.5.2 Justificación.
Por otro lado, dará una alternativa al ofrecer una herramienta que permita estudiar
las RNA de una forma práctica y no solo teórica.
2.1 Introducción:
Como era de esperarse, Microsoft copio la idea que tan bien le estaba
funcionando a la empresa Sun Microsystems con su lenguaje JAVA, y decidió
usar un compilador JIT así como un lenguaje hibridado entre C++ y Basic ( C# )6.
5 http://www.microsoft.com/Presspass/press/2000/jul00/pdcgateskeynotepr.mspx
6 Conclusion propia del autor
21
Un dato muy importante que cabe recalcar es que muchos de los elementos
de la tecnología DotNET fueron estandarizados bajo normativas internacionales, y
por lo tanto abiertas a todo el mundo. La normativa que rige al .NET framework es
22
7 http://www.microsoft.com/Presspass/press/2000/jul00/pdcgateskeynotepr.mspx
8http://www.mono-project.com
23
Están definidas como archivos DLL lo que significa que están en código MSIL y
por lo tanto pueden ser usadas de forma transparente por cualquier lenguaje .NET
Aquí una lista de las principales funcionalidades que se pueden encontrar en esta
biblioteca de clases:
● Administración de memoria
● Operaciones aritméticas
● Serialización
26
● Generación de código
● Manejo de idiomas
• Motor de seguridad
• Motor de depuración
• Compilador JIT
2.2.4 RESUMEN
Para simplificar las cosas, podemos decir que el framework es el motor que
corre entre el usuario y el sistema operativo, siendo claramente indispensable
tenerlo instalado en la computadora donde se quiera ejecutar cualquier programa
bajo la tecnología .NET
C# VB.NET
MSIL MSIL
100101101101101110
SISTEMA OPERATIVO
Pero hay que estar consientes que esto involucra escribir nuestro código en
algún editor de texto que ya dispongamos como el Bloc de Notas, y hacer la
respectiva compilación desde un entorno de consola de comandos (DOS). Así
como no disponer de diseñadores gráficos para las aplicaciones con formularios
lo que resulta un dolor de cabeza.
Pero cabe recalcar que el paquete Microsoft Visual Studio.NET es tan solo
un IDE de la tecnología .NET y no el motor indispensable. De ahí que no es el
único IDE existente en el mercado, aunque si el mejor y por lo tanto el más
costoso.
Hace varios años ya, un grupo de personas empezaron la tarea de ofrecer a los
programadores de .NET un IDE freeware y de ahí que hoy podemos descargar de
forma gratuita el tan famoso SharpDevelop
(www.icsharpcode.net/OpenSource/SD) que por menos de 10MB (versión 2.0) ,
podemos tener un IDE de altísimo nivel, igualando en casi todos los aspectos al
IDE de Microsoft.
aparece indicando los métodos y variables que posee una clase), depuración,
entre otros. No obstante cabe señalar que según mi apreciación personal, la
versión de Microsoft es un poco más rápida y consta de mejores herramientas
que el SD, aunque se debe tomar muy en cuenta que el Visual Studio viene en 2
CDs en comparación a los 10MB del SharpDevelop.
Su primera versión vio la luz a finales del 2001 y vino de la mano con la salida de
Visual Studio.NET 2002 o v7.0, la que incluía claro la versión 7 de Visual Basic y
la primera versión de C#, este nuevo lenguaje que más adelante le dedicaremos
principal atención.
Para el 2005, la llegada de la segunda versión rompió todos los esquemas, dando
completa integración a los programas desarrollados en las versiones anteriores,
acompañada por el Microsoft Visual Studio.NET 2005, la que incluía claro la
versión 8 de Visual Basic y la tan esperada segunda versión de C#. Las mejores
son muy considerables a todo nivel y es actualmente la versión más usada en el
mundo para las aplicaciones .NET, integrando cientos de programas escritos en
esta tecnología, por mencionar alguno al propio AutoCAD 2007 de la firma
AutoDesk. SharpDevelop claro, lanzó su segunda versión con este nuevo .NET
Framework.
El lenguaje más usado de todos los tiempos sin duda es el C++ por su gran
alcance, sin embargo su inminente dificultad hizo que lenguajes tan “superficiales”
como el Basic llegaran a las manos de todos por su sencillez y sobretodo por su
velocidad de desarrollo.
Su sintaxis se apega a una derivación del C, como casi todos los lenguajes
lo han hecho, formando poco a poco en lo que algún día, creo yo, será un
estándar. Esto es la utilización de “;” para el fin de instrucción, el uso de llaves
“{ }”, la distinción entre mayúsculas y minúsculas, por mencionar algunas.
10 http://es.wikipedia.org/wiki/Anders_Hejlsberg
37
public Form1()
{
InitializeComponent();
}
El uso de punteros que era una tarea casi exclusiva para C++, ahora se
puede hacer desde C#, claro, usando ciertas protecciones para combinar el
código administrado por el motor de la tecnología DotNET (código seguro) y el
código en el que usamos punteros (código no seguro).
11 http://www.microsoft.com/whdc/archive/GDInext.mspx
40
Graphics g = Graphics.FromImage(imagen);
Graphics g = control.CreateGraphics();
Existen varias formas más de conseguir un lienzo, pero estas son las más
usadas. Cabe recalcar que cuando se extrae el lienzo de una imagen, todos los
dibujos se quedan intrínsecamente en la imagen y por lo tanto mantiene sus
modificaciones. Pero cuando se extrae el lienzo desde un control directamente,
los dibujos realizados sobre este se ejecutan una única vez, y esto se refleja al
minimizar por ejemplo el formulario, los dibujos se habrán borrado al restaurar el
formulario. Para lograr que el control mantenga sus dibujos siempre, se usa el
evento PAINT, así se dibujara cada vez que se lo solicite.
41
Los lápices son clases que representan el estilo con el que se quiere
dibujar la silueta o contorno de algo. Por ejemplo, para crear un lápiz de color Azul
y de un grosor de 3 se usaría el siguiente código:
Esta clase es muy completa, puesto que permite crear lapices con distintos
colores, texturas, formas de empezar como una flecha por ejemplo, etc.
Las brochas son clases que sirven para rellenar un dibujo. Principalmente se
puede tener:
pb1.CenterColor = Color.LightYellow;
pb1.SurroundColors = new Color[] { Color.LightGreen, Color.LightGreen,
Color.Green, Color.DarkGreen };
● TextureBrush : Con esta brocha podemos usar una imagen como papel
tapiz de nuestro relleno.
Los DRAW están basados en lápices, por lo tanto solo dibuja siluetas o
contornos. Así se puede tener los siguientes códigos:
Todos los métodos del tipo DRAW dentro de la clase Graphics son::
DrawArc DrawLine
DrawBezier DrawLines
DrawClosedCurve DrawPath
DrawCurve DrawPie
DrawEllipse DrawPolygon
DrawIcon DrawRectangle
DrawImage DrawRectangles
DrawImageUnscaled DrawString
Por otro lado, cuando usamos los métodos FILL, estos están dirigidos a rellenar
las formas, así tenemos lo siguiente:
Como se ve, en los ejemplos usamos las distintas brochas que creamos
anteriormente.
44
FillRegion
FillRectangle
FillRectangles
FillPolygon
FillPie
FillPath
FillEllipse
FillClosedCurve
BITMAP: Esta clase también contiene una imagen pero está enfocada al trato de los
pixeles de la imagen. Es decir, en cuanto a modificar los pixeles se trata, este objeto es el
que lo permite hacer. Además, esta calse permite instanciarse a diferencia de la IMAGE,
creando así una nueva imagen.
Estas dos clases funcionan casi siempre a la par, puesto que cada una contiene
funcionalidades requeridas a lo largo de un trabajo de procesamiento de
imágenes. Y son 100% compatibles en cuanto a intercambiabilidad se refiere. Es
decir, si se requiere pasar una imagen para que sea un objeto BITMAP o IMAGE,
basta con hacer el debido casting:
imagen1 = (Image)bm1;
bm1 = (Bitmap)imagen1;
Para tratar con cada uno de los pixeles, es necesario tener la imagen en un objeto
BITMAP y usar los métodos:
bm1.GetPixel(x, y);
bm1.SetPixel(x, y, Color.Red);
Donde X,Y son las coordenadas del pixel que se quiere leer o escribir. El pixel
esta representado por un color que es toda una clase que brinda facilidades para
el trato de colores.
46
2.6.3 Punteros:
2. Declarar los métodos que van a contener el código con punteros como
UNSAFE
4. Usar los punteros de la misma forma que se hace en C++, esto es, usar el
puntero para indicar la dirección en la memoria RAM. Usar el prefijo
asterisco ( * ) para indicar lo “Especificado por”, es decir, para indicar el
contenido de esa dirección de la RAM.
*Puntero = 55; //Escribir en la dirección indicada por el
puntero el valor de 55
Puntero++; //Auemntar la dirección de la memoria RAM
48
Ejemplo: Método que dado un vector de entrada, rellene todo el vector con el
valor de 100.
Para aclarar mejor la idea, es muy común usar los controles TIMER en nuestros
programas. Estos pueden ser muy fácilmente programados, basta un contador
que llame a un método cuando el tiempo establecido haya finalizado, sin embargo
si lo programáramos de la forma tradicional, mientras el programa realiza el
conteo del timer, no podríamos hacer nada más. Es así que un Timer esta
programado en otro hilo. Esto significa que se ha creado otro proceso
independiente para que realice el conteo, y este está muy aparte del proceso
normal de nuestro programa.
50
Programa Principal
Hilo 1
Hilo 2
Los controles de usuario nos brindan varias ventajas, entre las más
importantes consta la compatibilidad de ser usada sin problema desde cualquier
lenguaje soportado por DotNET; así un control desarrollado en C# puede ser
usado desde VisualBasic.NET por ejemplo. Además nos brinda protección al
código, puesto que se encuentra compilado y encapsulado en un DLL. Por otro
lado se puede programar el control pensando en una programación de usuario,
esto es, dejando comentarios en XML para que el motor de Visual Studio
encargado de las facilidades de programación como listas, comentarios de
argumentos, entre otros, pueda usar nuestros propios comentarios; además el
uso correcto de propiedades y diseño gráfico nos da la posibilidad de usar nuestro
control en la plantilla de diseño.
2. Agregar un nuevo Control de Usuario. Para esto basta hacer clic derecho
encima del proyecto en el explorador de soluciones y elegir la opción: “Add
>> New Item” y seleccionar la plantilla: “User Control” para crear un control
y “Component Class” para un componente.
53
[assembly: AssemblyTitle("MisControles")]
[assembly: AssemblyDescription("Controles propios")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("SILTTEC")]
[assembly: AssemblyProduct("MisControles")]
[assembly: AssemblyCopyright("Danny López-Copyright © 2007")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
12 http://msdn2.microsoft.com/en-us/library/ms173038(VS.80).aspx
55
/// <summary>
/// Es el color que va a tener el borde del rectángulo
/// </summary>
[DescriptionAttribute("Es el color que va a tener el borde del
rectángulo")]
[BindableAttribute(true)]
[CategoryAttribute("Colores")]
public Color ColorRectangulo
{
.............
En el caso de los métodos se puede usar más indicativos como por ejemplo:
/// <summary>
/// Método que suma dos valores
/// </summary>
/// <param name="sumando1">Valor del primer número a sumar</param>
/// <param name="sumando2">Valor del segundo número a sumar</param>
/// <returns>Respuesta de la suma</returns>
public double Sumar(double sumando1, double sumando2)
{
return sumando1 + sumando2;
}
3.1 Introducción:
13 http://www.fil.ion.ucl.ac.uk/~asaygin/tt/ttest.html
14 http://web.media.mit.edu/~papert/
62
Y sus aplicaciones hoy están en muchos de los artefactos que usamos a diario.
Entre ellos los más conocidos son: todos los OCR (reconocimiento óptico de
caracteres), reconocedores de voz, TTS16 (Text To Speech) , Reconocedores de
huellas digitales, Controladores Biométricos de personal, correctores de gramática
de procesadores de palabras, etc
15 http://web.mit.edu/
16 http://en.wikipedia.org/wiki/Speech_synthesis
63
3.3.1 Dendritas
Son capilares que permiten el ingreso de los impulsos neuronales hacia el núcleo
o SOMA de la neurona. Es decir, las dendritas constituyen las “Entradas” de la
neurona biológica.
3.3.2 Sinapsis
3.3.3 Soma.
Función de Transferencia.- Obtenida la señal sumada, esta pasa por una función
de transferencia propia de cada tipo de neuronas, y genera una señal resultado.
3.3.4 Axón.
n
I= ∑i= 1
X i ⋅ Wi
Y = f (I )
3.5 Perceptrón:
n X1
I= ∑ X i ⋅ Wi W1
∑
i= 1 X2 W2
Y
W3
If I > u : Y = 1 X3
Wn
Else Y = 0 Xn
67
E = Yd − Yo
∆ Wi = X i ⋅ E
Wi( t + 1) = Wit + ∆ W
Donde:
Yd : Salida Deseada
Yo : Salida Obtenida
Wi : Hace referencia al valor del nuevo peso, por eso el (t + 1), que significa
( t + 1)
(Tiempo+1)
Ahora tomamos un segundo juego de entradas y volvemos a aplicar los pasos 2,3
y 4. Esto lo hacemos para todos los conjuntos de entradas.
Respuesta Obtenida
Respuesta Deseada
Iteraciones
La solución de este problema no es más que atenuar el cambio de los pesos, para
que no cambien tan bruscamente y así pueda converger más rápido. Así nace el
parámetro conocido como Taza de aprendizaje, en inglés Learning Rate
expresado normalmente con las siglas LR o como una constante o coeficiente, es
decir con una letra griega como alpha (α).
Respuesta Obtenida
Respuesta Deseada
Iteraciones
P Y
Ahora, vamos a entrenar a nuestra neurona para que se comporte como una
compuerta lógica AND, es decir, que responda de acuerdo a la siguiente tabla:
a b Y
0 0 0
0 1 0
1 0 0
1 1 1
Y= 1
1
Y= 0
a
0
0 1
n
I= ∑i= 1
X i ⋅ Wi If I > 0 : Y = 1 :Else Y = 0
I = a ⋅ W1 + b ⋅ W2
Pues bien, está formula es correspondiente a la ecuación de una recta, en donde:
r = AX + BY + C I = a ⋅ W1 + b ⋅ W2 + 1
A = W1 : B = W2 : X = a : Y=b :C=1
Como sabemos, las constantes que dan forma a una recta son A y B,
correlacionadas a nuestra neurona, vendrían a ser los pesos de la misma. Así es
72
b
r
Y= 1
1
Y= 0
a
0
0 1
De esta forma, los valores constantes que representan a esta recta, serán los
valores de los pesos de nuestra neurona al llegar a la respuesta de este
problema.
73
Visto desde este punto, al inicializar los pesos de forma aleatoria, estamos
colocando una recta cualquiera en el plano, y esta empieza a moverse a medida
que nuestra neurona se entrena, hasta llegar a separar un conjunto de otro.
Por ejemplo:
Y= 1
a
Y= 0
Si trabajamos con una sola entrada, podemos graficar los valores como puntos
sobre un solo eje, y la “recta” solucionadora quedaría expresada solo como un
punto que separe los do grupos a clasificar.
Si trabajamos con tres entradas nos tocaría graficar los valores en un plano en
tres dimensiones, y la “recta” solucionadora debería ser ahora un plano que
separe un grupo de otro.
Ya sea con una, dos o “n” entradas, el Perceptrón solo responde a una respuesta
“lineal” siéndole imposible resolver problemas donde sus respuestas requeridas
no puedan ser separadas por una línea. Y es así que Marvin Minsky y Seymour
Papera del MIT en 1969 mostraban la imposibilidad del perceptrón al tratar de
resolver la operación binaria XOR. Dado que, la tabla de verdad de la XOR y su
respuesta debería ser:
a b Y
0 0 0
0 1 1
1 0 1
1 1 0
Como se puede apreciar, una recta no podría nunca dar resultado a este
problema. Además, argumentando que los problemas en la naturaleza responden
75
más a una solución desordenada que a una ordenada que demanda una
respuesta no lineal de los sistemas, por ejemplo:
Y= 1
a
Y= 0
En 1982 de se muestra una investigación realizada por el mismo MIT que años
atrás había sepultado al perceptrón, la posibilidad de armar una red con
perceptrones, es decir combinar un conjunto de neuronas artificiales y hacerlas
funcionar a la par para resolver un mismo problema. A esta combinación de
neuronas artificiales se le conoció como Perceptrón Multicapa, y es aquí donde
nace la idea propiamente dicho de Redes Neutrales Artificiales.
En este ejemplo, se ve una red neuronal con 3 capas ocultas, además de la capa
de entrada y salida.
Como podemos ver gráficamente, las salidas de una neurona vienen a ser las
entradas para cada neurona de la capa siguiente, de la misma forma para la capa
subsiguiente hasta llegar a la capa de salida que ofrece los resultados finales de
la red. Todas las neuronas de las capas ocultas y de salida responden bajo la
misma expresión matemática vista con el perceptrón, en cuanto a la capa de
entrada, esta no efectúa ningún cálculo interno, solo sirve como soporte para la
distribución de las entradas hacia todas las neuronas de la capa subsiguiente. Es
decir, las neuronas de la capa de entrada responden simplemente a una
expresión de paso (Lo que entra, sale).
● Aprendizaje Supervisado
● Aprendizaje NO-Supervisado
Siendo la primera aquella que necesita saber la salida deseada antes de empezar
el proceso de aprendizaje. Se le conoce como supervisada por el mismo hecho de
tener que ofrecerle las salidas que se buscan, lo que implica inevitablemente
saber las salidas que se quieren, lo cual no siempre es un dato al que tenemos
acceso. En este sistema, se encuentran varios algoritmos teniendo el más usado
y popular al Back-Propagation el cual se explicará en detalle más adelante.
3.7.1 Introducción:
Para usar la regla delta se necesita saber los valores de salida deseados y
compararlos con los valores obtenidos por la red neuronal, sin embargo al tener
una o varias capas ocultas, necesitaríamos conocer los valores que quisiéramos
que dicha capa oculta saque, y esto no es posible. No obstante las salidas
deseadas de la capa de salida si se los tiene, al ser un aprendizaje supervisado y
podemos saber el error general de la red neuronal y en base a este error,
distribuirlo hacia las capas ocultas usando una modificación o generalización de la
regla delta, conocida mejor como algoritmo BackPropagation haciendo énfasis
en la idea de capturar el error en la capa de salida y propagar el error hacia atrás,
llegando a todas las capas ocultas.
Dibujo 23: Propagación de errores hacia atrás - ORIGEN: Propia del Autor
82
Doce años después de esto (1986), dos trabajos realizados al mismo tiempo por
David E. Rumelhart, Geoffrey E. Hinton y Ronald J. Williams, David Parker y
Yann Le Cun, mostraban un algoritmo backpropagation mucho más concreto,
estable y dedicado a las redes neuronales; recibiendo mucha acogida por la
comunidad de desarrolladores.
Sin embargo fue gracias al libro que el mismo año publicaron David E Rumelhart y
James L McClelland de la Universidad de California con el título de “Parallel
distributed processing” que hizo del algoritmo uno de los más populares y
usados métodos de aprendizaje hasta nuestros días.
83
Wt + 1 = Wt − α ∇ E 2
Donde:
Entonces la diferencia entre el nuevo y el actual valor del peso esta dado por la
gradiente negativa del error medio cuadrático, atenuado por el LR
∂ E2
−∇E = − 2
∂W
85
Para este ejemplo demostrativo, solo veremos una red neuronal con una capa
oculta.
Así:
Wij = Peso que conecta a la neurona “i” de la capa de entrada y la neurona “j”
de la capa oculta.
86
Wjk = Peso que conecta a la neurona “j” de la capa oculta y la neurona “k”
de la capa de salida.
1 k
E = ∑ ( Dn − S n ) 2
2
2 n= 1
Donde:
Puesto que en estos momentos no tenemos idea de los valores que tienen
los pesos, por muchos motivos, empezando con que se inicializan con valores
aleatorio; no es posible sacar una derivada numérica del error medio cuadrático
con respecto a los pesos, así que debemos operar la derivada hasta llegar a
expresarla en otro dominio.
18 http://ohm.utp.edu.co/neuronales/Capitulo2/Backpropagation/ReglaB.htm
87
Siendo:
∂ E2
−
∂ W jk
La gradiente inversa del error con respecto a los pesos que corresponden a las
conexiones entre la capa oculta y la capa de salida ( j k ).
Tenemos:
∂ E2 ∂ 1 k ∂ Sk
− = − ∑ ( Dn − S n ) 2 = ( Dn − S n ) ×
∂ W jk ∂ W jk 2 n= 1 ∂ W jk
Ahora tenemos a la derivada de las señales de salida con respecto a los pesos.
∂ Sk ∂ Sk ∂ I k
= ×
∂ W jk ∂ I k ∂ W jk
Entonces, reemplazando esta ecuación con la anterior tenemos que:
∂ E2 ∂S ∂ Ik
− = ( Dk − S k ) × k ×
∂ W jk ∂ I k ∂ W jk
88
∂ E2 ∂ I Sk
− = ( Dk − S k ) × f ' ( I Sk ) ×
∂ W jk ∂ W jk
j
Y recordando también que: Ik = ∑ (X
n= 1
n ⋅ Wnk ) tenemos:
∂ E2
− = ( Dk − S k ) × f ' ( I Sk ) × O j
∂ W jk
W jk ( t + 1) = W jk ( t ) + α × ( Dk − S k ) × f ' ( I Sk ) × O j
Teniendo a mejor expresar como:
∆ W jk = ( Dk − S k ) × f ' ( I Sk ) × O j
W jk( t + 1) = W jk( t ) + α × ∆ W jk
Donde:
En cuanto a los pesos de la capa oculta, basta con proyectar la misma fórmula
teniendo en cuenta que ahora la derivada del error a desarrollar y su respectiva
regla de la cadena quedarían así:
∂ Sk ∂ S k ∂ I Sk ∂ O j ∂ I Oj
= × × ×
∂ Wij ∂ I Sk ∂ O j ∂ I Oj ∂ Wij
∑ (( D − S k ) × f ' ( I Sk ) × W jk ) × Ei
k
∆ Wij = f ' ( I Oj ) × k
n= 1
Donde:
Así, la capa oculta “i”, empezará siendo la última capa, la que se encuentra más
cercana a la capa de salida, donde la capa “i+1” será la capa de salida y la capa
”i-1” la penúltima capa. Luego la capa “i” pasará a ser la que muestra el gráfico y
que antes era la capa “i-1” y la capa “i+1” pasará a ser la que antes era la capa “i”
y así sucesivamente hasta cubrir todas las capas ocultas.
δ S
k = ( Dk − S k ) × f ' ( I Sk )
Esta sensitividad es la única diferencia a partir de ahora entre una capa de salida
y una capa oculta, siendo la sensitividad de una capa oculta:
(δ )
n
δ Oi
m = f ' ( I Oi m ) × ∑
j= 1
O ( i + 1)
j × Wmj
i
Oi
∆Wo lm =δ m × O ( i − 1) l
i i i
Wo lm( t + 1 ) = Wo lm( t ) + α × ∆Wo lm
92
4.1 Introducción
4.2 Limitaciones
Dejando a un lado las limitaciones propias del hardware y software que actúan
como plataforma, en cuanto al sistema se refiere, este tendrá únicamente el
algoritmo de aprendizaje por Backpropagation, usando las fórmulas matemáticas
que se muestran con detalle en el capítulo 3.
93
4.3 Requisitos
● Crear un componente que permita usar una red neuronal artificial, teniendo
las siguientes características:
■ Escalón
■ Lineal
■ Sigmoide Logarítmica
■ Sigmoide Tangencial
■ Gauss
URL: http://www.codeproject.com/cs/algorithms/NeuralNetwork_1.asp
URL: http://franck.fleurey.free.fr/NeuralNetwork
98
Actores: Programador
Descripción: La etapa de consulta es el uso como tal del sistema, una vez
entrenada la red, está lista para ser consultada o usada.
Actores: Programador
5 CAPITULO V: Diseño
5.1 Introducción
Actores: Programador
Actores: Programador
Actores: Programador
Actores: Programador
Actores: Programador
Dibujo 40: Uso del Visor de la RNA - ORIGEN: Propia del Autor
113
Así mismo, se probó abrir y ejecutar el proyecto desde el IDE de Microsoft Visual
Studio 2005 con todo éxito, ya sea en su versión gratuita (Express) como en la
profesional.
Además, para la creación del control que muestra una representación gráfica, se
uso el motor GDI+ propio de DotNET. Así mismo se usaron punteros y manejo de
hilos. Todos estas herramientas explicadas en el capítulo 2.
114
En este gráfico se puede apreciar la organización que nos brinda los REGIONs,
así como un comentario XML, que siempre comienzan con un triple símbolo de
dividido (slash “/” ). En el ejemplo, se muestra un resumen (sumary) de lo que va
a hacer esa clase.
Dibujo 42: Propiedades del RNA - ORIGEN: Ayuda Generada con Document!X 5.0
Del mismo modo, estos comentarios XML pueden brindar más información, como
por ejemplo en los métodos, se puede describir los argumentos de entrada, la
salida, e incluso colocar un ejemplo de aplicación. Todo esto exportado al
documento de ayuda.
Dibujo 44: Ayuda: Método Evaluar - ORIGEN: Ayuda Generada con Document!X 5.0
118
La capa clase contiene todas las funcionalidades de una capa de la red neuronal,
y esta maneja todas las neuronas de una forma global. Es decir, en primera
instancia se piensa en crear una clase NEURONA que contenga el algoritmo de
proceso y aprendizaje, y que un vector de objetos de tipo NEURONA sea una
capa. No obstante en el presente trabajo se decidió usar una clase CAPA que
maneje todas las funcionalidades de proceso y aprendizaje de todas las neuronas
de dicha capa; desapareciendo de cierta forma la individualidad de la neurona.
Esta capa nace de la necesidad de poder manifestar las capas ocultas, puesto
que estas pueden estar entre 0 o un número alto. Así es que se crea una clase
que, con la ayuda de la clase Collection del BCL del FrameWork, administra todo
lo referente a una lista o colección dinámica, es decir, tener los métodos Add,
Clear, etc.
Cabe recalcar que esta estructura de herencia es nueva, y que al menos hasta
ahora, no se ha visto en otro lenguaje de programación. Y es que no solo se
hereda la clase Collection, sino en la misma declaración de clase, se indica la
clase de la cual se va a hacer la colección, siendo en este caso la clase CAPA.
Gracias a esta clase que permite evaluar como código un String, se puede crear
una función virtual donde se deje espacio para que el Usuario Programador cree
una función matemática a gusto y la ingrese dentro de la propiedad
formula_Custom de la clase CAPA.
7.1 Introducción
Para una demostración simple, este OCR va a reconocer las cinco vocales del
alfabeto español, es decir: A, E, I, O, U. De una muestra gráfica al carácter ASCII
correspondiente a la letra.
124
Una vez tenida la imagen, se debe separar la letra de entre toda la imagen
capturada.
Los pasos a seguir para entrenar una red neuronal para el reconocimiento de
vocales es el siguiente:
Letra A:
01110100011000111111100011000110001
Letra E:
11111100001000011100100001000011111
Letra I:
11111001000010000100001000010011111
Letra O:
01110100011000110001100011000101110
Letra U:
10001100011000110001100011000101110
● Fijar como número de entradas de la red 35, puesto que son 35 los
números de la matriz 7x5 resultante de la parametrización.
127
● No fijar ninguna capa oculta, puesto que se debe siempre empezar sin
ninguna capa oculta, y en caso de ser necesarias, ir aumentándolas.
LR = 0,1
Momento = 0,9
● El uso de una capa oculta no fue necesario, puesto que la red neuronal
logro converger a una solución con tan solo dos capas. Y esto resulta
lógico, puesto que cada neurona de salida se especializa en un solo patrón
de entradas (letra), sin interferir con las demás.
8.1 Conclusiones
● Encapsular los distintos códigos probados en una DLL nos brinda muchas
facilidades como son: protección de código, compatibilidad entre lenguajes,
velocidad de compilación, etc.
● El uso del motor gráfico GDI+ que nos brinda la tecnología DotNET resultó
ser muy liviana y rápida, siendo la mejor forma de mostrar una interfaz
gráfica para nuestros controles. Y así facilitar el uso y comunicación entre
el programador y las herramientas.
● Usar una estructura XML como el objeto DataSet propio de DotNET para
ser de puente universal con todo tipo de almacenamiento de datos, es de
vital importancia cuando se crea una herramienta de propósito general.
Puesto que la tecnología XML se ha convertido en un estándar en cuanto a
portabilidad de datos se refiere.
130
ayudas que nos brinda nuestro IDE favorito, nos van mostrando la
documentación de forma dinámica, facilitando significativamente el
desarrollo de un sistema.
8.2 Recomendaciones
9 BIBLIOGRAFÍA
Libros:
● Nikola K. Kasabov, “Foundations of Neural Networks, Fuzzy Systems, and
Knowledge Engineering”, Segunda Edición, 1998, Massachusetts Institute
of Technology, [ ISBN 0585038767 ]
URLs:
● http://www.microsoft.com/Presspass/press/2000/jul00/pdcgateskeynotepr.mspx
● http://msdn2.microsoft.com/es-es/netframework/aa569283(en-us).aspx
● http://es.wikipedia.org/wiki/.NET
● http://en.wikipedia.org/wiki/Microsoft_.NET_Framework
● http://www.monografias.com/trabajos12/redneuro/redneuro.shtml
● http://es.wikipedia.org/wiki/Redes_neuronales_artificiales
● http://ohm.utp.edu.co/neuronales/Capitulo2/Backpropagation/ReglaB.htm
● http://es.wikipedia.org/wiki/Red_neuronal
● http://es.wikipedia.org/wiki/Neurona
● http://en.wikipedia.org/wiki/Graphics_Device_Interface
● http://msdn.microsoft.com/library/default.asp?url=/library/en-
us/gdicpp/GDIPlus/aboutGDIPlus.asp
● http://www.elguille.info/colabora/puntoNET/tutGDI/indice.htm
135
10.1 Introducción:
Dibujo 51: Barra de Herramientas - ORIGEN: Propia del Autor, extraído de MS. Visual
Studio 2005
137
Dibujo 55: Propiedad Ocultas - ORIGEN: Propia del Autor, extraído de MS.
Visual Studio 2005
CapaSalida_FormulaCustom = “Math.Sin(I)”
10.4.1 Capas
En este grupo se establecen los colores de las neuronas que van a verse
en cada capa.
10.4.2 Pesos
10.4.3 Tamaños
10.5 Entrenamiento
Una vez teniendo una RNA configurada, sea que esta tenga o no un control
RNA_Visor asociado, se puede empezar con el proceso de entrenamiento.
● Muestras de entrada
● Muestras de salida
Donde cada muestra va a ser un vector de tipo DOUBLE, y todas las muestras,
tanto de entradas como de salidas van a estar representadas por un vector de los
vectores de entrada, es decir un doble vector.
● Momento es un valor que define una tendencia hacia una dirección, este
valor ayuda a que la red neuronal no caiga en un oscilamiento perpetuo.
145
//Enlazar el evento
rna1.evento_Iteracion += new RNA.delegado_iteracion(this.rna1_evento_Iteracion);
//Evento Iteración
private void rna1_evento_Iteracion(int interac, double error)
{
...........................................
}
Código 11: Ejem del evento iteración - ORIGEN: Propia del autor
Código 13: Ejemplo de uso con BDD - ORIGEN: Propia del autor
10.6 Consulta
//Vector de entrada
double[ ] Entrada = new double[3] {2, 5, 7};
//Evaluar
rna1.Evaluar(Entrada);
//Neurona ganadora
int Gandora = rna1.IndexMaxSalida;
Adicionalmente, es posible hacer una consulta directa por medio del control visor
de redes neuronales, y la consulta se efectúa en tiempo de ejecución en la
interfaz gráfica del visor.
149
Para cambiar los valores de entrada de la red en este modo gráfico, basta en
hacer clic con el ratón encima del valor de entrada y aparecerá un cuadro de
edición donde se puede alterar el valor. Para salir de este modo de edición, basta
con hacer clic fuera del cuadro.
Una vez cambiados los valores de entrada, se puede acceder al menú contextual
del visor haciendo clic secundario (típicamente derecho) encima del control y
seleccionar la primera opción que dice: “Procesar”. Cabe resaltar que desde este
menú es posible ejecutar varias tareas, como fijar pesos aleatorios, guardar y
restaurar desde un fichero la estructura y pesos de la red asociada al visor, etc.
150
Dibujo 63: Menú contextual del visor - ORIGEN: Propia del autor