Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Redes Neuronales PDF
Redes Neuronales PDF
Redes Neuronales PDF
Una red neuronal artificial es, básicamente, el resultado de los intentos por
reproducir mediante computadores el funcionamiento del cerebro humano. Su
principal aplicación es en torno a las tareas en que los seres humanos
fácilmente superan a los computadores tradicionales, como en procesamiento
de señales, procesamiento de imágenes, procesamiento de voz, en robótica y
otros.
X2
W 2j
Yj
.: Zj= W ij Xi F ( Zj )
:
Xn
W nj
:
:
: :
:
:
Las capacidades del Perceptron con dos tres y cuatro niveles o capas y con
una única neurona en el nivel de salida, se muestra en la figura 4.8.
Figura 4.8 Distintas formas de las regiones generadas por un perceptron multinivel
• Ahora necesitamos una red neuronal que permita tomar los patrones de
entrada y de salida para el entrenamiento, tal como se muestra en la figura
4.9.
Para esta ejecución se tiene que el valor devuelto por la red neuronal es muy
cercano a 1, tal como se dio en el entrenamiento (la red neuronal aprendió).
1 1 0 0 0 0 1
0 1 1 0 0 0 1
0 1 0 0 0 1 1
0 0 1 1 1 1 0
0 0 1 1 1 0 0
0 0 0 1 1 0 0
Salida
Figura 4.9 Red neuronal que permite tomar los patrones de la tabla 4.2.
Figura 4.10 Resultado que muestra un programa que contiene a la red neuronal entrenada de la
figura 4.9.
Figura 4.11 Resultados que muestra otra ejecución del programa que contiene a la red neuronal
entrenada de la figura 4.9.
6
Hilera J, Martinez V. Redes Neuronales Artificiales: Fundamentos, modelos y
Aplicaciones. España: Editorial RA-MA; 1995.
codificados.
Optimizaci de
ón. patrones.
Brain-Estate-in-a-
Box. 1977 Extracción de Posiblement Realización y James
redes de totalmente.
Hopfield.
Pellionez.
y TPM.
y se en VLSI.
optimización. Fácil de
conceptuali
zar
Neocognitron 1978- Reconocimient Insensible Requiere K.
84 o de a la muchos Fukushima
caracteres Translación elementos de
manuscritos , rotación proceso,
y escala. niveles y
conexiones.
Perceptron 1957 Reconocimient La red más No puede Frank
o de antigua. reconocer Rosenblatt
caracteres Construida caracteres
impresos en HW. complejos.
Hay muchos tipos diferentes de redes neuronales, cada uno de los cuales tiene
una aplicación particular más apropiada. Relacionamos ejemplos de algunas
aplicaciones comerciales separándolas en grupos según las distintas
disciplinas:
Biología
Empresa
Finanzas
• Identificación de falsificaciones.
• Interpretación de firmas.
Manufacturación
• Inspecci6n de la calidad.
Medicina
• Monitorización en cirugía.
• Lectores de rayos X.
Militares
La regla propuesta por Widrow en 1960 (regla delta) ha sido extendida a redes
con capas intermedias (regla delta generalizada) con conexiones hacia
adelante (feedforward) y cuyas células tienen funciones de activación
continuas (lineales o sigmoidales), dando lugar al algoritmo de
retropropagación (backpropagation). Estas funciones continuas son no
decrecientes y derivables. La función sigmoidal pertenece a este tipo de
funciones, a diferencia de la función escalón que se utiliza en el Perceptron, ya
que esta última no es derivable en el punto en el que se encuentra la
discontinuidad.
El método que sigue la regla delta generalizada para ajustar los pesos es
exactamente el mismo que el de la regla delta utilizada en el Perceptron y,
ADALINE; es decir, los pesos se actualizan de forma proporcional a la delta, o
diferencia entre la salida deseada y la obtenida (∂ = sal. deseada - sal.
obtenida).
Dada una neurona (unidad Ui) y la salida que produce, yi (Figura 4.13), el
cambio que se produce en el peso de la conexión que une la salida de dicha
neurona con la unidad Uj (wji) para un patrón de aprendizaje p determinado es:
∆w ji (t + 1) = α ∂ pj y pi
Figura 4.13 Conexión entre una neurona de una capa oculta con una neurona de salida.
∂ pj = (d pj − y pj )⋅ f 1 (net j )
donde dpj es la salida deseada de la neurona j para el patrón p y netj es la
entrada neta que recibe la neurona j.
Según esto, en el caso de que Uj no sea una neurona de salida (ver Figura
4.14), el error que se produce está en función del error que se comete en las
neuronas que reciben como entrada la salida de Uj:
Figura 4.14 Conexiones entre neuronas de la capa oculta con la capa de salida.
= ∆w ji (t + 1) = α ∂ pj y pi + β ∆w ji (t )
[
w ji (t + 1) = w ji (t ) + ∆w ji (t + 1)]
∆w ji (t + 1) = w ji (t ) + α ∂ pj y pi + β ∆w ji (t )
donde:
∂ pj = (d pj − y pj ) ⋅ f 1 (net j )
si Uj es una neurona de salida y
∂ pj = ∑ ∂ pk ⋅ wkj ⋅ f 1 (net j )
k
si Uj no es una neurona de salida.
En una red backpropagation existe una capa de entrada con n neuronas y una
capa de salida con m neuronas y al menos una capa oculta de neuronas
internas. Cada neurona de una capa (excepto las de entrada) recibe entradas
de todas las neuronas de la capa anterior y envía su salida a todas las
Paso 1
Paso 2
Paso 3
Calcular la salida actual de la red, para ello presentamos las entradas a la red
y vamos calculando la salida que presenta capa hasta llegar a la capa de
salida ésta será la salida de la red y1, y2,...,yM. Los pasos son los siguientes:
N
net = ∑ whji
h
pj x pi + θ jh
i =1
Figura 4.15 Modelo de arquitectura de una red backpropagation. Pueden existir neuronas ficticias
de salida y pesos umbral θ de entrada al resto de las neuronas de cada capa.
(
y pj = f jh net hpj )
• Se realizan los mismos cálculos para obtener las salidas de las neuronas
de salida (capa o: output)
L
net o
pk = ∑ wkjo ⋅ y pj + θ ko
j =1
(
y pk = f ko net opk )
Paso 4
1
f k (net jk ) = − net
1 + e jk
( )
f ko = f ko 1 − f ko = y pk (1 − y pk )
1
por lo que los términos de error para las neuronas de salida quedan:
∂ opk = (d pk − y pk )
para la salida lineal, y
∂ opk = (d pk − y pk )⋅ y pk (1 − y pk )
Paso 5
∆wkjo (t + 1) = α ⋅ ∂ opk ⋅ y pj
y para los pesos de las neuronas de la capa oculta:
∆w hji (t + 1) = α ⋅ ∂ hpj ⋅ x pi
Paso 6
M
Ep = 1
2 ∑ pk
∂ 2
k =1
resulta aceptablemente pequeño para cada uno de los patrones aprendidos.
7
Universidad Tecnológica de Pereira. Colombia.
S1 S2 S3 S4 M1 M2
1 1 1 1 -1 -1
-1 1 1 1 -1 1
1 1 -1 -1 1 -1
-1 -1 -1 -1 1 1
1 -1 1 1 1 -1
1 1 -1 1 -1 1
1 1 1 -1 1 -1
IMPLEMENTACION EN NEUROSHELL
Luego del ingreso elija FILE, NEW e ingrese un nombre de archivo, como en la
figura 4.19 (no escriba ninguna extensión para el archivo).
Figura 4.19.
Seleccione Data Entry (figura 4.21) e ingrese los datos de la tabla 4.4, para
entrenar la red neuronal (figura 4.22). Se sugiere para el entrenamiento
duplicar estos datos dos veces salvo el titulo de cada columna.
Figura 4.21
Luego de ingresar los datos cierre la ventana después de haber grabado estos
con File, Save File.
En la figura 4.26 elija examinar datos para analizar los datos y los errores
generados a la salida.
Figura 4.24
Figura 4.26
Figura 4.28
' inarray(1) is S1
' inarray(2) is S2
' inarray(3) is S3
' inarray(4) is S4
' outarray(1) is M1
' outarray(2) is M2
netsum = -.7532668
netsum = netsum + inarray(1) * 7.551737
netsum = netsum + inarray(2) * .2998328
netsum = netsum + inarray(3) * 7.341322
netsum = netsum + inarray(4) * -6.852577
feature2(1) = 1 / (1 + exp(-netsum))
netsum = -2.495483
netsum = netsum + inarray(1) * -5.648689
netsum = netsum + inarray(2) * 1.05053
netsum = netsum + inarray(3) * -5.979871
netsum = netsum + inarray(4) * 6.870361
feature2(2) = 1 / (1 + exp(-netsum))
netsum = -4.198974E-02
netsum = netsum + inarray(1) * 4.999131
netsum = netsum + inarray(2) * -3.897346
netsum = netsum + inarray(3) * 2.603323E-05
netsum = netsum + inarray(4) * -3.897321
feature2(3) = 1 / (1 + exp(-netsum))
netsum = .1287855
netsum = netsum + feature2(1) * -2.675452
netsum = netsum + feature2(2) * -2.65109
netsum = netsum + feature2(3) * 6.387748
outarray(1) = 1 / (1 + exp(-netsum))
netsum = 3.821959
netsum = netsum + feature2(1) * -6.030695
netsum = netsum + feature2(2) * 3.957484
netsum = netsum + feature2(3) * 8.61486E-03
outarray(2) = 1 / (1 + exp(-netsum))
End Sub
Figura 4.30. Formulario en Visual Basic que manipula las entradas y salidas de la red neuronal.
' inarray(1) is S1
' inarray(2) is S2
' inarray(3) is S3
' inarray(4) is S4
' outarray(1) is M1
' outarray(2) is M2
netsum = -0.7532668
netsum = netsum + inarray(1) * 7.551737
netsum = netsum + inarray(2) * 0.2998328
netsum = netsum + inarray(3) * 7.341322
netsum = netsum + inarray(4) * -6.852577
feature2(1) = 1 / (1 + Exp(-netsum))
netsum = -2.495483
netsum = netsum + inarray(1) * -5.648689
netsum = netsum + inarray(2) * 1.05053
netsum = netsum + inarray(3) * -5.979871
netsum = netsum + inarray(4) * 6.870361
feature2(2) = 1 / (1 + Exp(-netsum))
netsum = -0.04198974
netsum = netsum + inarray(1) * 4.999131
netsum = netsum + inarray(2) * -3.897346
netsum = netsum + inarray(3) * 0.00002603323
netsum = netsum + inarray(4) * -3.897321
feature2(3) = 1 / (1 + Exp(-netsum))
netsum = 0.1287855
netsum = 3.821959
netsum = netsum + feature2(1) * -6.030695
netsum = netsum + feature2(2) * 3.957484
netsum = netsum + feature2(3) * 0.00861486
outarray(2) = 1 / (1 + Exp(-netsum))
End Sub
Private Sub Command2_Click()
End
End Sub
• No hace nada: no pasa nada cuando se hace girar la llave del contacto.
Tabla 4.5. Para el problema de diagnósticos del automóvil, se hacen corresponder los síntomas con
las causas.
Causas probables
Síntomas Batería Bobina Motor de Cables Distribuidor Bomba de
arranque gasolina
No hace nada X
Clics X X X
Molinillo X X X X
Gira X X X
Sin chispa X X
Cable caliente X X
Sin gasolina X
La solución
Empleando los datos de nuestro ejemplo, será necesaria una red con siete
unidades de entrada y seis unidades de salida. Esto deja únicamente sin
determinar el número de unidades internas (ocultas). En este caso, no hay
nada que indique cuántas unidades ocultas se van a necesitar para resolver el
problema, y no hay consideraciones de interfaz externa que vayan a limitar el
número de unidades ocultas.
M 2*M
<n<
2* N N
donde:
Lo único que queda ahora es entrenar a la red con estos pares de datos. Una
vez que está entrenada, la red producirá una salida que identifique a la causa
probable indicada por el mapa de síntomas de entrada. La red hará esto
cuando la entrada sea equivalente a una de las entradas de entrenamiento, tal
como se esperaba, y además producirá una salida, indicando la causa
probable del problema, cuando la entrada sea parecida a alguna de las
entradas de entrenamiento, pero distinta de todas ellas. Esta aplicación ilustra
la capacidad de la red para realizar la "mejor suposición" (generalización) y
pone de manifiesto la capacidad de la red para enfrentarse a entradas de datos
con ruido o incompletas.
8
1. Sierra Molina, Guillermo y otros (1995). “Sistemas Expertos en Contabilidad y
Administración de Empresas”. Editorial Addison Wesley. USA.
Bomba de gasolina
Motor de arranque
Cable caliente
No hace nada
Sin gasolina
Distribuidor
Sin chispa
Molinillo
Batería
Bobina
Cables
Clics
Gira
1 0 0 0 0 0 0 1 0 0 0 0 0
0 1 0 0 0 0 0 1 1 1 0 0 0
0 0 1 0 0 0 0 0 0 1 1 1 1
0 0 0 1 0 0 0 0 0 0 1 1 1
0 0 0 0 1 0 0 0 0 0 1 1 0
0 0 0 0 0 1 0 0 1 1 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 1
Se puede utilizar el Neuroshell, para entrenar a la red neuronal con los datos
de la tabla 4.6 y se debe obtener también el codigo fuente en Visual Basic. La
implementacion se encuentra en el CD que se adjunta al libro.
Figura 4.32. Ejecución del programa en Visual Basic 6.0, teniendo en cuenta el 4 patron de
entrenamiento de la tabla 4.6.
e(1) = Val(Text1.Text)
e(2) = Val(Text2.Text)
e(3) = Val(Text3.Text)
e(4) = Val(Text4.Text)
e(5) = Val(Text5.Text)
e(6) = Val(Text6.Text)
e(7) = Val(Text7.Text)
Call Fire_DIAGNOST(e, s)
netsum = -0.3115481
netsum = netsum + inarray(1) * 0.7032344
netsum = netsum + inarray(2) * 0.1466639
netsum = netsum + inarray(3) * 2.036957
netsum = netsum + inarray(4) * -0.4733835
netsum = netsum + inarray(5) * -0.4653012
netsum = netsum + inarray(6) * -1.454124
netsum = netsum + inarray(7) * -0.7716009
netsum = -0.007483043
netsum = netsum + inarray(1) * -0.7950581
netsum = netsum + inarray(2) * -1.6701
netsum = netsum + inarray(3) * 1.082342
netsum = netsum + inarray(4) * 0.8707346
netsum = netsum + inarray(5) * -0.3615806
netsum = netsum + inarray(6) * -0.6289499
netsum = netsum + inarray(7) * 0.9206671
feature2(2) = 1 / (1 + Exp(-netsum))
netsum = 0.3411922
netsum = netsum + inarray(1) * 1.407685
netsum = netsum + inarray(2) * 1.998027
netsum = netsum + inarray(3) * -1.747856
netsum = netsum + inarray(4) * -1.269704
netsum = netsum + inarray(5) * -2.329731
netsum = netsum + inarray(6) * 1.356552
netsum = netsum + inarray(7) * 1.647663
feature2(3) = 1 / (1 + Exp(-netsum))
netsum = -0.2768248
netsum = netsum + inarray(1) * 2.065744
netsum = netsum + inarray(2) * -1.146601
netsum = netsum + inarray(3) * -0.9325874
netsum = netsum + inarray(4) * -1.517177
netsum = netsum + inarray(5) * 0.2812504
netsum = netsum + inarray(6) * -0.6556798
netsum = netsum + inarray(7) * 1.173773
feature2(4) = 1 / (1 + Exp(-netsum))
netsum = -0.1239126
netsum = netsum + inarray(1) * -1.830723
netsum = netsum + inarray(2) * 0.8275196
netsum = netsum + inarray(3) * 0.2012251
netsum = netsum + inarray(4) * -0.7351373
netsum = netsum + inarray(5) * 0.5414248
netsum = netsum + inarray(6) * 2.384689
netsum = netsum + inarray(7) * -1.566727
feature2(5) = 1 / (1 + Exp(-netsum))
netsum = 0.0145554
netsum = netsum + inarray(1) * -0.4000922
netsum = netsum + inarray(2) * -1.257582
netsum = netsum + inarray(3) * 0.8750437
netsum = netsum + inarray(4) * 1.78116
netsum = netsum + inarray(5) * 1.741183
netsum = netsum + inarray(6) * -2.168171
netsum = netsum + inarray(7) * -0.9200088
feature2(6) = 1 / (1 + Exp(-netsum))
netsum = 0.3624522
netsum = netsum + inarray(1) * -1.666589
netsum = netsum + inarray(2) * -2.92119
netsum = netsum + inarray(3) * 1.415627
netsum = netsum + inarray(4) * 0.1193302
netsum = netsum + inarray(5) * 0.3643235
netsum = netsum + inarray(6) * 1.332756
netsum = netsum + inarray(7) * 1.651392
netsum = -0.08557819
netsum = netsum + inarray(1) * 0.3886256
netsum = netsum + inarray(2) * -2.094244
netsum = netsum + inarray(3) * -1.564476
netsum = netsum + inarray(4) * 1.770092
netsum = netsum + inarray(5) * 0.9950833
netsum = netsum + inarray(6) * -1.562377
netsum = netsum + inarray(7) * 1.671334
feature2(8) = 1 / (1 + Exp(-netsum))
netsum = -0.2997127
netsum = netsum + inarray(1) * 1.399435
netsum = netsum + inarray(2) * -0.1395936
netsum = netsum + inarray(3) * -1.913407
netsum = netsum + inarray(4) * -0.9458458
netsum = netsum + inarray(5) * 2.404087
netsum = netsum + inarray(6) * 0.6442617
netsum = netsum + inarray(7) * -1.377198
feature2(9) = 1 / (1 + Exp(-netsum))
netsum = 0.8538765
netsum = netsum + feature2(1) * 1.642975
netsum = netsum + feature2(2) * -1.08525
netsum = netsum + feature2(3) * 1.692052
netsum = netsum + feature2(4) * 0.5226364
netsum = netsum + feature2(5) * -1.016138
netsum = netsum + feature2(6) * 0.3381723
netsum = netsum + feature2(7) * -4.312466
netsum = netsum + feature2(8) * -0.8845294
netsum = netsum + feature2(9) * 0.3042739
outarray(1) = 1 / (1 + Exp(-netsum))
netsum = 0.6356097
netsum = netsum + feature2(1) * -1.699543
netsum = netsum + feature2(2) * -0.8347372
netsum = netsum + feature2(3) * 1.740408
netsum = netsum + feature2(4) * -2.244962
netsum = netsum + feature2(5) * 2.778615
netsum = netsum + feature2(6) * -1.380548
netsum = netsum + feature2(7) * -1.0302
netsum = netsum + feature2(8) * -1.023457
netsum = netsum + feature2(9) * -0.1288214
outarray(2) = 1 / (1 + Exp(-netsum))
netsum = 0.8881556
netsum = netsum + feature2(1) * 1.621511
netsum = netsum + feature2(2) * -0.03661929
netsum = netsum + feature2(3) * 0.1688382
netsum = netsum + feature2(4) * -1.013181
netsum = netsum + feature2(5) * 2.699184
netsum = netsum + feature2(6) * -1.219513
netsum = netsum + feature2(7) * 0.4337809
netsum = netsum + feature2(8) * -3.760823
netsum = netsum + feature2(9) * -1.450161
outarray(3) = 1 / (1 + Exp(-netsum))
netsum = -0.1752312
netsum = netsum + feature2(1) * 0.7248147
netsum = -0.2363798
netsum = netsum + feature2(1) * 0.8358494
netsum = netsum + feature2(2) * 0.6256061
netsum = netsum + feature2(3) * -3.400938
netsum = netsum + feature2(4) * -1.574203
netsum = netsum + feature2(5) * 0.3605849
netsum = netsum + feature2(6) * 2.502021
netsum = netsum + feature2(7) * 0.2546888
netsum = netsum + feature2(8) * 0.5457298
netsum = netsum + feature2(9) * 0.2242781
outarray(5) = 1 / (1 + Exp(-netsum))
netsum = -0.1454982
netsum = netsum + feature2(1) * 0.7328083
netsum = netsum + feature2(2) * 1.886714
netsum = netsum + feature2(3) * 0.05207601
netsum = netsum + feature2(4) * -1.110788
netsum = netsum + feature2(5) * -1.82287
netsum = netsum + feature2(6) * 0.5481207
netsum = netsum + feature2(7) * 1.574738
netsum = netsum + feature2(8) * 1.149344
netsum = netsum + feature2(9) * -4.210217
outarray(6) = 1 / (1 + Exp(-netsum))
End Sub
• antigüedad en la empresa.
Figura 4.33. Ejecución del programa en Visual Basic 6.0, teniendo en cuenta el 16 avo patrón de
entrenamiento de la tabla 4.7.
En el CD se encuentra la implementación
del reconocimiento de los caracteres A y
B, utilizando Neuroshell y Visual Basic
.NET.