Download Clase_2_perceptron_back_hopfield

Redes Neuronales
Perceptron, Backpropagation, Adaline,
Hopfield.
Algoritmos y ejemplos. Parte 2
M.C. Ernesto Cortés Pérez.
Apuntes de la materia
Similitudes entre una neurona biológica y una artificial
Las
pesos
Wi X
son
representan
la intensidad
deseñales
la sinápsis
quesobrepasar
provienen
que
Los
esentradas
la función
que la las
neurona
debe
iumbral
para
de
conecta
otras
activarse;
dos
neuronas
neuronas;
este
y que
proceso
tanto
son capturadas
X
ocurre
Wi por
son las
valores en
i comobiológicamente
dendritas
reales.
el
cuerpo de la célula.
2
Neurona Artificial
Cada
señal
de
entrada
pasa
a todas
través
de una
ganancia
o peso,
La nodo
El
entrada
sumatorio
neta
a cada
acumula
unidad
puede
las
señales
escribirse
de entradas
de
la
Las
señales
de
entrada
a una
neurona
artificial
X1,función
Xa2la
,..,
llamado
peso
sináptico
fortaleza
de la conexión
multiplicadas
siguiente
manera:
por
los opesos
o ponderadas
y lascuya
pasa
n
 discretos,
es
análoga
a la dede
la
función
sináptica
de
neurona
biológica.
X
continuas
en lugar
dela
salida
través
una
función
umbral
opulsos
función
de
n son avariables
neta

x
w

X
W
Los
pesos
pueden seren
positivos
(excitatorios),
o negativos
ibiológica.
i
como
se presentan
unaj neurona
transferencia.
(inhibitorios).

i 1
3
Neurona Artificial
Cada neurona calcula
El valor
su entrada
de salida (único) se
n
Cada entrada
multiplicada
por
neta es
como:
obtiene
como
neta j   xi wi
y

f
(neta
)
el peso de arco correspondiente.
4
i 1
Funciones de Transferencia

Hardlim (limitador fuerte)
Esta función crea neuronas que clasifican las
entradas en dos categorías diferentes.
5
Funciones de Transferencia

Hardlims (limitador fuerte simétrico)
Esta función crea neuronas que clasifican las
entradas en dos categorías diferentes.
6
Funciones de Transferencia

Purelin (Lineal)
A diferencia de las anteriores, esta
función no es acotada.
7
Funciones de Transferencia

Logsig (Sigmoide)
Es acotada y derivable
8
Funciones de Transferencia
2
a
1
(1  exp( 2 * n))
9
Arquitecturas formadas por una
neurona

Comenzaremos trabajando con arquitecturas
simples formadas por un único elemento de
procesamiento.

La neurona trabaja
discriminante lineal.
como
una
función
10
Perceptrón
1 si neta  
y
0 si neta  
11
Ejemplo

Verifique si la siguiente neurona se
comporta como la función lógica AND
12
AND
Graficar la función discriminante
(recta)
13
Entrenamiento del perceptrón

Se busca una estrategia iterativa que
permita adaptar los valores de las
conexiones a medida que se presentan
los datos de entrada.

Ver que el estímulo de entrada se
corresponde con el producto interior de los
vectors X y W.
14
Ajuste del vector de pesos con taza de
aprendizaje (Learning rate)

Recordemos que la salida del perceptrón es
hardlim
1 si W . X  
y
0 si W . X  

En general, si llamamos



t al valor esperado
y al valor obtenido
Utilizando la siguiente expresión para cálcular W
wnuevo = w +  (t - y) x
15
While epoch produces an error
Present network with next inputs from
epoch
Err = t – y
If Err <> 0 then
Wj = Wj + LR * Err * Ij
End If
End While
16
Entrenamiento del Perceptrón

Seleccionar el valor de  y 

Inicializar los pesos de las conexiones con
valores random (vector W)

Mientras no se clasifiquen todos los
patrones correctamente
 Ingresar
 Si

un patrón a la red.
fue clasificado incorrectamente
Wnuevo = W +  (t - y) x
17
Ejemplo 1

Entrenar un perceptrón para que se
comporte como la función lógica AND.
Utilice
 = 0.3
 = 1.5
W1 = 0
W2 = 0.25
18
AND
El proceso
repitenew
hasta
comprobar que
Si YY =se
W1 + 0.3 (T-Y) X1
Si
T, W W1
no se =actualiza
todos los patrones son clasificados
Wnewcorrectamente
=W
+new
 (T-Y)
W2
= W2X + 0.3 (T-Y) X2
X1
X2
T
W1
W2
Y
W1new
W2new
------------------------------------------------------------0
0
0
0.00
0.25
0
0.00
0.25
1
0
0
0.00
0.25
0
0.00
0.25
0
1
0
0.00
0.25
0
0.00
0.25
1
1
1
0.00
0.25
0
0.30
0.55
------------------------------------------------------------0
0
0
0.30
0.55
0
0.30
0.55
1
0
0
0.30
0.55
0
0.30
0.55
0
1
0
0.30
0.55
0
0.30
0.55
1
1
1
0.30
0.55
0
0.60
0.85
------------------------------------------------------------0
0
0
0.60
0.85
0
0.60
0.85
1
0
0
0.60
0.85
0
0.60
0.85
0
1
0
0.60
0.85
0
0.60
0.85
1
1
1
0.60
0.85
0
0.90
1.15
------------------------------------------------------------0
0
0
0.90
1.15
0
0.90
1.15
1
0
0
0.90
1.15
0
0.90
1.15
0
1
0
0.90
1.15
0
0.90
1.15
1
1
1
0.90
1.15
1
0.90
1.15
19
Perceptrón

Hardlim
1 si neta  0
y
0 si neta  0
20
Ejercicio

Entrenar un perceptrón para que se
comporte como la función lógica AND.
Utilice
 = 0.3
W0 = 0
W1 = 0
W2 = 0.25
21
Ejercicio
X0
X1
X2
T
W0
W1
W2
Salida
NewW0
NewW1
NewW2
-----------------------------------------------------------------------------------1
0
0
0
1
1
0
0
1
0
1
0
1
1
1
1
------------------------------------------------------------------------------------
22
Solución
X0
X1
X2
T
W0
W1
W2
Salida
NewW0
NewW1
NewW2
-----------------------------------------------------------------------------------1
0
0
0
0.00
0.00
0.25
1
-0.30
0.00
0.25
1
1
0
0
-0.30
0.00
0.25
0
-0.30
0.00
0.25
1
0
1
0
-0.30
0.00
0.25
0
-0.30
0.00
0.25
1
1
1
1
-0.30
0.00
0.25
0
0.00
0.30
0.55
-----------------------------------------------------------------------------------1
0
0
0
0.00
0.30
0.55
1
-0.30
0.30
0.55
1
1
0
0
-0.30
0.30
0.55
1
-0.60
0.00
0.55
1
0
1
0
-0.60
0.00
0.55
0
-0.60
0.00
0.55
1
1
1
1
-0.60
0.00
0.55
0
-0.30
0.30
0.85
-----------------------------------------------------------------------------------1
0
0
0
-0.30
0.30
0.85
0
-0.30
0.30
0.85
1
1
0
0
-0.30
0.30
0.85
1
-0.60
0.00
0.85
1
0
1
0
-0.60
0.00
0.85
1
-0.90
0.00
0.55
1
1
1
1
-0.90
0.00
0.55
0
-0.60
0.30
0.85
-----------------------------------------------------------------------------------1
0
0
0
-0.60
0.30
0.85
0
-0.60
0.30
0.85
1
1
0
0
-0.60
0.30
0.85
0
-0.60
0.30
0.85
1
0
1
0
-0.60
0.30
0.85
1
-0.90
0.30
0.55
1
1
1
1
-0.90
0.30
0.55
0
-0.60
0.60
0.85
-----------------------------------------------------------------------------------1
0
0
0
-0.60
0.60
0.85
0
-0.60
0.60
0.85
1
1
0
0
-0.60
0.60
0.85
1
-0.90
0.30
0.85
1
0
1
0
-0.90
0.30
0.85
0
-0.90
0.30
0.85
1
1
1
1
-0.90
0.30
0.85
1
-0.90
0.30
0.85
-----------------------------------------------------------------------------------1
0
0
0
-0.90
0.30
0.85
0
-0.90
0.30
0.85
1
1
0
0
-0.90
0.30
0.85
0
-0.90
0.30
0.85
1
0
1
0
-0.90
0.30
0.85
0
-0.90
0.30
0.85
1
1
1
1
-0.90
0.30
0.85
1
-0.90
0.30
0.85
23
Red Neurona Artificial,
Representación con ganancia (bias)
la nueva entrada b es una ganancia que
refuerza la salida del sumador n, la cual
es la salida neta de la red.
24
Regla de aprendizaje del Perceptron
con ganancia
There are three conditions that can occur for a single neuron once an input
vector p is presented and the network’s response a is calculated:

CASE 1. If an input vector is presented and the output of the neuron is
correct (a = t, and e = t – a = 0), then the weight vector w is not altered.

CASE 2. If the neuron output is 0 and should have been 1 (a = 0 and t = 1,
and e = t – a = 1) the input vector p is added to the weight vector w.

CASE 3. If the neuron output is 1 and should have been 0 (a = 1 and t = 0,
and e = t – a = –1) the input vector p is subtracted from the weight vector w.
25
The perceptron learning rule can be
written in terms of the error:
 e=t–a


And the change will be made to the
weight vector Δw
26

CASE 1. If e = 0, then make a change Δw equal to 0.

CASE 2. If e = 1, then make a change Δw equal to pT.

CASE 3. If e = –1, then make a change Δw equal to –pT.

All three cases can then be written with a single expression:
27

We can get the expression for changes in a neuron’s
bias, which always has an input of 1:

For the case of a layer of neurons we have:
28

The Perceptron Learning Rule can be summarized as
follows:
29
Soluciones obtenidas con la ganancia “b”, a
las funciones “and” y “or”
30
El algoritmo de entrenamiento del
Perceptrón con bias (ganancia)
1.
Se inicializa la matriz de pesos y el valor de la
ganancia, por lo general se asignan valores
aleatorios a cada uno de los pesos wi y al valor b
2.
Se presenta el primer patrón a la red, junto con la
salida esperada en forma de pares entrada/salida
3.
Se calcula la salida de la red por medio de:
puede ser la función hardlim o hardlims
31

Bias: por lo general se le asigna un valor
inicial de 1 y se ajusta durante la etapa de
aprendizaje de la red.
32
4.- Cuando la red no retorna la salida
correcta, es necesario alterar el valor de
los pesos y el bias, tratando de aumentar
las posibilidades de que la clasificación
sea correcta.
33
Ejemplo




2
0
-2
0
1 -> 1
-1 -> 1
1 -> -1
2 -> -1
En este caso las salidas toman valores bipolares
de 1 o –1
34

Los valores iniciales asignados aleatoriamente a
los parámetros de la red son:
35
Iteración 0

Interceptos con los ejes:
36
Iteración 1
37
Iteración 1

De la iteración 1 p1 esta mal clasificado, la actualización
de pesos permite que este patrón sea clasificado
correctamente.
38
Iteración 1

La iteración 1 lleva a la característica de decisión
39
Iteración 2

Se presenta p2 a la red, y es clasificado
correctamente, como se observo gráficamente.
40
Iteración 2

Este patrón ha sido clasificado correctamente y por lo tanto no hay
actualización del conjunto de entrenamiento:
41
Iteración 3

Se presenta p3 a la red y es clasificado correctamente,
como se observó gráficamente
42
Iteración 3

Como se esperaba, no hubo error en la clasificación de este patrón,
y esto lleva a que no haya actualización de los pesos de la red
43
Iteración 4

Se presenta a la red p4
44
Iteración 4

La red ha clasificado incorrectamente este patrón y por lo tanto
deben modificarse pesos y ganancias
45
Iteración 4

En esta iteración la red se comportara de acuerdo a la
característica de decisión
46

La red ha clasificado correctamente los patrones
de entrenamiento, después de entrenada la red
con los pesos y ganancias finales, cualquier otro
valor de entrada será clasificado según la
característica de decisión mostrada.

Ejercicio: verificar a que clase pertenecen los
siguientes patrones:
[-2 3] [ 3 3] [ 1 1] [-1 -1] [3 2] [ 5 -2]

47
Ejercicio 1
48
The output a does not equal the target value t1, so we
use the perceptron rule to find the incremental changes
to the weights and biases based on the error.
49

You can calculate the new weights and bias using the Perceptron
update rules shown previously.
50
51
52
Ejercicio 2

Sobre una cinta transportadora circulan naranjas y melones. Se busca
obtener un clasificador de frutas que facilite su almacenamiento. Para
cada fruta se conoce su diámetro en centímetros, su intensidad de color
naranja, medida entre 0 y 255, y su peso en gramos.

Ejemplos:
Naranjas = { (10,200,150), (8,150,100), (7,170,200), (15,250,180)}
Melón = {(20,30,500), (26,30,780), (24,32,900), (19,31,500)}

Entrenar un perceptrón que permita resolver el problema. Utilice como W
inicial (0,0,0), y b =0.

Nota: etiqueta naranjas =1, Melón =0.

Una vez entrenado el perceptron verificar la clase a la que pertenecen los
siguientes patrones desconocidos:

(14,210,150)

(180,199,23)
53
Ejercicio 3
Una
agencia de modelos publicó los resultados de la última
selección de postulantes. En ella se habían presentado seis
mujeres. Cada una de ellas ha sido caracterizada sólo por su peso
y altura.
El resultado fue el siguiente:
Aceptadas = {(52,1.79), (53,1.81), (55,1.75)}
Rechazadas ={(65,1.70), (68,1.65),(58,1.71)}
A) Represente el criterio de selección a través de una RN formada
por un único perceptrón.
B) Cuál sería la respuesta del perceptrón si se presentaran estas
postulantes:
{(56,1.73), (70,1.60), (45,1.80)}
Resuelva el problema anterior en un programa en matlab
54
Ejercicio 4

Se cree que los niños aprenden mediante un proceso
llamado razonamiento por analogías, en el que intentan
asociar objetos parecidos a otros que ya conocen, y los
intentan agrupar por categorías. Supón que un niño ha
visto alguna vez un león en el zoológico y que sabe que
es peligroso, y lo ha representado internamente por el
patrón (1 1 0 1 0) Un día va por la calle y se encuentra a
un gato, que representaremos por el patrón (1 1 1 0 1),
despues se encuentra con animal parecido a los dos
anteriores y lo asocia con el siguiente patrón (1 1 1 0 0)
¿Debe salir corriendo el niño porque cree al verlo que se
parece demasiado a un león? Modela ésta situación
mediante un perceptrón.
55
56
57
58
59
60
Perceptrón con Matlab
(etapa de aprendizaje)

p =[2
1
t =[1

plotpv(p, t)

0
-1
1
-2
1
0
0;
2]
0]
61
Perceptrón con Matlab
(etapa de aprendizaje)

p={[2;1], [0;-1], [-2;1] ,[0;2]};

t={1 1 -1 -1};

net=newp([-2 2;-2 2],1,'hardlims','learnp');

net.adaptParam.passes = 1;

net.iw{1,1}= [-0.7 0.2];

net.b{1} = [0.5];
62
Iteración 1

[net,a,e]=adapt(net,p{1},t{1});
a
e
 pesos=net.iw{1,1}
 bias=net.b{1}

63
Resultados iteración 1



a=
-1
e=

2

pesos =



3.3000
2.2000
bias =
2.5000
64
Iteración 2

net.iw{1,1}= pesos;

net.b{1} = bias;

[net,a,e]=adapt(net,p{2},t{2});
65
Resultados iteración 2



a=
1
e=

0

pesos =



3.3000
2.2000
bias =
2.5000
66
Iteración 3

net.iw{1,1}= pesos;

net.b{1} = bias;

[net,a,e]=adapt(net,p{3},t{3});
67
Resultados iteración 3



a=
-1
e=

0

pesos =



3.3000
2.2000
bias =
2.5000
68
Iteración 4

net.iw{1,1}= pesos;

net.b{1} = bias;

[net,a,e]=adapt(net,p{4},t{4});
69
Resultados iteración 4



a=
1
e=

-2

pesos =



3.3000 -1.8000
bias =
0.5000
70
Aprendizaje completo
Perceptrón con Matlab (1 época)
p={[2;1] [0;-1] [-2;1] [0;2]};
t={1 1 -1 -1};
net=newp([-2 2;-2 2],1,'hardlims','learnp');
net.adaptParam.passes = 1;
net.iw{1,1}= [-0.7 0.2];
net.b{1} = [0.5];
[net,a,e]=adapt(net,p,t);
71
1era época



a=
[-1]
[1]
[2]

pesos =


[1]
e=


[-1]
[0]
[0]
[-2]
3.3000 -1.8000
bias =
0.5000
72
Resultado en 2 épocas

net.adaptParam.passes = 2;

t=




[1]
[1]
[-1]
[-1]
[1]
[-1]
[-1]
[0]
[0]
a=
[1]
e=

[0]

pesos =



[0]
3.3000 -1.8000
bias =
0.5000
73
Patrones ya clasificados

plotpc(pesos, bias)
74
Etapa de reconocimiento

p1={[-1;-1]};
a1=sim(net,p1)

a1 =

-1

75
Perceptrón Multicapa

Un Perceptrón multicapa es una red con
alimentación hacia delante, compuesta de
varias capas de neuronas entre la entrada
y la salida de la misma, esta red permite
establecer regiones de decisión mucho
más complejas.
76
Esquema
77
Un esquema simplificado del
modelo del Perceptrón Multicapa




Donde
W: Matriz o vector de pesos asignada a cada una de las
entradas de la red de dimensiones SxR, con S igual al número
de neuronas, y R la dimensión del vector de entrada
p: Vector de entradas a la red de dimensiones Rx1
b: Vector de ganancias de la red de dimensiones Sx1
78
Las capacidades del Perceptrón multicapa con dos y tres
capas y con una única neurona en la capa de salida
79
Redes multicapa

Ver que el perceptrón no puede
resolver el problema del XOR porque
no es linealmente separable.
-1 -1 -> 0
-1 1 -> 1
1 -1 -> 1
1 1 -> 0
80
XOR usando mas de un
perceptrón
w11=1 w12=1;
w21=1 w22=1; w31=1 w32=-1.5
b1=-0.5 b2=-1.5 b3=-0.5
81
Función de
activación en la capa
oculta
-0.9866
a = tansig(n) =
2/(1+exp(-2*n))-1
0.0107
purelin en la capa de
salida
-0.9982
Capa oculta
f(((-1  1) + (-1  1))+(-0.5)) = f(-2 + (-0.5)) = f(-2.5)= -0.9866
f(((-1  1) + (-1  1))+(-1.5)) = f(-2 + (-1.5)) = f(-3.5)= -0.9982
Capa de salida
f(((-0.9866  1) + (-0.9982  -1.5))+(-0.5)) = f(0.5107+ (-0.5)) = f(0.0107)= 0.0107
82
Adaline

Al mismo tiempo que Frank Rosenblatt
trabajaba en el modelo del Perceptrón
Bernard Widrow y su estudiante Marcian
Hoff introdujeron el modelo de la red
Adaline.
83
Adaline

La red Adaline es similar al Perceptrón,
excepto en su función de transferencia,
la cual es una función de tipo lineal en
lugar de un limitador fuerte como en el
caso del Perceptrón.
84
Adaline

La red Adaline presenta la misma
limitación del Perceptrón en cuanto al tipo
de problemas que pueden resolver,
ambas redes pueden solo resolver
problemas linealmente separables.
85
Adaline

Sin embargo el algoritmo LMS (Least
Mean Square) es más potente que la regla
de aprendizaje del Perceptrón ya que
minimiza el error medio cuadrático.
86
Perceptron vs Adaline
87
Regla «delta» de aprendizaje de Adaline
88
Regla «delta» de aprendizaje de Adaline
89
Algoritmo LMS (Least Mean squares)
w(k+1)=w(k) + alpha*error(k)*entrada
b(k+1)=b(k) + alpha*error(k)
90
Diferencias perceptron - adaline
• ADALINE calcula el error a partir de la entrada neta, y el
PERCEPTRON usa la salida.
• El error total del ADALINE nunca será nulo, por lo que la
condición de terminación del algoritlno LMS suele ser:
Error(t)- Error(t-1) < ξ
• Aparece el parámetro alpha=tasa de aprendizaje alpha debe
poseer en teoría valores infinitamente pequeños. Se obtienen
buenos resultados con valores en torno a 0.1.
• ADALINE garantiza no sólo una solución válida para problemas
linealmente separables sino la que produce un error mínimo.
91
Backpropagation (antecedentes)

El primer algoritmo de entrenamiento para
redes multicapa fue desarrollado por Paul
Werbos en 1974, Fue solo hasta
mediados de los años 80 cuando el
algoritmo Backpropagation o algoritmo de
propagación inversa fue re-descubierto.
92
Backpropagation

La importancia de esta red consiste en
que, las neuronas de las capas
intermedias se organizan a sí mismas de
tal modo que las distintas neuronas
aprenden
a
reconocer
distintas
características del espacio total de
entrada.
93
Backpropagation

Después del entrenamiento, cuando se les
presente un patrón arbitrario de entrada que
contenga ruido o que esté incompleto, las
neuronas de la capa oculta de la red
responderán con una salida activa si la nueva
entrada contiene un patrón que se asemeje a
aquella característica que las neuronas
individuales hayan aprendido a reconocer
durante su entrenamiento.
94
Backpropagation

Y a la inversa, las unidades de las capas
ocultas tienen una tendencia a inhibir su
salida si el patrón de entrada no contiene
la característica para reconocer, para la
cual han sido entrenadas.
95
Backpropagation

Varias investigaciones han demostrado
que, durante el proceso de entrenamiento,
la red Backpropagation tiende a
desarrollar relaciones internas entre
neuronas con el fin de organizar los datos
de entrenamiento en clases.
96
Arquitectura
97
Regla de Aprendizaje mediante
reducción del error

q: Equivale al número de componentes el vector
de entrada.
m: Número de neuronas de la capa oculta
l: Número de neuronas de la capa de salida
98

Para iniciar el entrenamiento se le presenta a la red un patrón de
entrenamiento, el cual tiene q componentes:
 p1 
 
 p2 
 
P . 
.
 
 . 
 pq 
99

Cuando se le presenta a la red una patrón de entrenamiento, este
se propaga a través de las conexiones existentes produciendo
una entrada neta n en cada una las neuronas de la siguiente
capa.

W: Peso que une la componente i de la entrada con la neurona j
de
la
capa
oculta
p: Componente i del vector p que contiene el patrón de
entrenamiento
de
q
componentes
b: Ganancia de la neurona j de la capa oculta
100
Compute the Sensitivities (Backpropagation)

Sensitivity
m  F̂
si  --------mni
m 1 T
ˆ
ˆ
F  n  Fˆ
m
m
m
m 1 T F


s  m  
 F n W 
m 
m 1
m 1
n

n

n

n


101
Backpropagation (Sensitivities)

The sensitivities are computed by starting at the last layer, and
then propagating backwards through the network to the first layer.
M
s s
M –1
2
1
s s
102
Initialization (Last Layer)
S
M
si
M
2
   tj – a j 
T
a
F̂
 t – a  t – a
= ---------- = -------------------------------------- = -----j--=----1------------------------ = – 2 t i – a i --------i-M
M
M
M
n i
ni
n i
ni
ai
aiM f M niM   M M
 M 
 f ni 
M
M
ni
ni
ni
siM  2ti  ai  f M niM 
sM  2F M n M t  a
103
Summary
Forward Propagation
0
a = p
m+1
a
=f
m+ 1
m+1 m
W
m+ 1
a +b
m = 0 2   M – 1

a = aM
Backpropagation
sM  2F M n M t  a
T
sm  F m nm Wm1  sm1
m  M  1,,2,1
Weight Update
m
m
m
W  k + 1 = W  k  – s a
m–1 T

m
m
m
b k + 1 = b k  – s
104
Example: Function Approximation with
logsig

g p = 1 + sin --- p
4
t
-
p
e
+
1-2-1
Network
a
105
Network
p
1-2-1
Network
a
106
Initial Conditions
1
W  0  = – 0.27
1
b  0  = – 0.48
– 0.41
2
W  0  = 0.09 – 0.17
– 0.13
2
b 0  = 0.48
∞=0.1
3
Network Response
Sine Wave
2
1
0
-1
-2
-1
0
1
2
107
Forward Propagation
0
a = p = 1
 –0.27

 – 0.75 
–
0.48
a = f W a + b  = l ogsig 
 = logsi g

1 +
 –0.41
– 0.13 
 – 0.54 
1
1
1 0
1
1
-------------------0.75
1
1
+
e
a =
= 0.321
1
0.368
-------------0.54
------1+ e
2
2
2 1
2
a = f W a + b  = purelin ( 0.09 – 0.17 0.321 + 0.48 ) = 0.446
0.368

  2 
 
e = t – a =  1 + sin  ---p  – a =  1 + sin --- 1   – 0.446 = 1.261
4 
4 


108
Transfer Function Derivatives
–n
1 
1  1 
d
e


=
--------=
-----------=
1
–
------------- ----------------- = 1 – a 1  a 1 


f n

2
d n 1 + e –n 
1 + e – n  1 + e –n 
 1 + e– n 
1
2
d  = 1
f n  =
n
dn
109
Backpropagation
2
s2 = – 2 F (n 2 ) t – a  = – 2 f 2 n2   1.261  = – 2 1  1.261  = –2.522
1
1
1)
1
2 T 2
s = F (n  W  s =
0
1
s = 1 – 0.321 0.321
0
1
s = 0.218
0
1
 1 – a 1  a 1 
0
0.09
– 2.522
1
1
–
0.17
 1 – a 2  a 2 
0
0.09
– 2.522
 1 – 0.368  0.368 – 0.17
0
– 0.227 = – 0.0495
0.233 0.429
0.0997
110
Weight Update
2
2
2
 = 0.1
1 T
W 1 = W 0  – s  a  = 0.09 –0.17 – 0.1 –2.522 0.321 0.368
2
W  1  = 0.171 – 0.0772
2
2
2
b  1 = b 0  – s = 0.48 – 0.1 –2.522 = 0.732
1
1
1 0 T
W  1  = W  0  – s a  = – 0.27 – 0.1 – 0.0495 1 = – 0.265
– 0.41
0.0997
– 0.420
1
1
1
b  1  = b 0  –  s = – 0.48 – 0.1 – 0.0495 = – 0.475
– 0.13
0.0997
– 0.140
111
Choice of Architecture

i
t  p  = 1 + sin --4--- p 
p = –2 –1.6 –1.2   1.6 2
1-3-1 Network
3
2
3
i=1
2
1
1
0
0
-1
-2
3
2
-1
0
1
2
-1
-2
3
i=4
2
1
1
0
0
-1
-2
-1
0
1
2
-1
-2
i=2
-1
0
1
2
1
2
i=8
-1
0
112
Choice of Network6 Architecture
-- p 
t  p  = 1 + sin ---4 
3
2
3
1-2-1
2
1
1
0
0
-1
-2
3
2
-1
0
1
2
-1
-2
3
1-4-1
2
1
1
0
0
-1
-2
-1
0
1
2
-1
-2
1-3-1
-1
0
1
2
1
2
1-5-1
-1
0
113
Convergence
t  p  = 1 + sin  p 
3
3
5
2
2
1
3
1
2
0
1
4
0
5
3
4
2
0
0
1
-1
-2
-1
0
1
2
-1
-2
-1
0
1
2
114
Generalization
p t
p
{ 1, 1}  {
2, t2 }
   {pQ, tQ}
 
t  p  = 1 + sin  -4-- p 
p = –2 –1.6 –1.2   1.6 2
3
3
1-2-1
1-9-1
2
2
1
1
0
0
-1
-2
-1
0
1
2
-1
-2
-1
0
1
2
115
Ejemplo con tangente sigmoidal

Tansig
exp( x)  exp(  x)
n
exp( x)  exp(  x)
ó
2
n
1
(1  exp( 2 * x))
116
Derivadas de tansig y purelin

TanSig
Purelin
117
Los valores de las derivadas del
error medio cuadrático son:

Los valores de las derivadas del error
medio cuadrático son:

tansig

purelin
118
119
Aproximar la siguiente función
120
Conjunto de entrenamiento
121
122
Valores iniciales función 1
123
Aproximar la siguiente función 2
124


p = -1:0.1:1;
t = [-.9602, -.5770, -.0729, .3771, .6405, .6600,
.4609, 0.1336 -.2013 -.4344 -.5000 -.3930 -.1647 .0988,
.3072, .3960, .3449, .1816, -.0312, -.2189, -.3201];
125

ρ=0.01;

w1 = [3.5000; 3.5000; 3.5000; 3.5000; 3.5000];
b1 = [-2.8562; 1.0774; -0.5880; 1.4083; 2.8722];
w2 = [0.2622, -0.2375, -0.4525, 0.2361, -0.1718];
b2 = [0.1326];



126
Función 3
127
Clasificador de vocales

Representación de letras
A=[1 1 1 1;
1 0 0 1;
1 1 1 1;
1 0 0 1];
128
A=[1 1 1 1;
1 0 0 1;
1 1 1 1;
1 0 0 1];
E=[1 1 1 1;
1 0 1 0;
1 0 1 0;
1 1 1 1];
O=[1 1 1 1;
1 0 0 1;
1 0 0 1;
1 1 1 1];
I=[1 1 1 1;
0 1 0 0;
0 1 0 0;
1 1 1 1];
U=[1 0 0 1;
1 0 0 1;
1 0 0 1;
1 1 1 1];
129
Matriz de patrones
A
E
1
1
1
1
1
0
0
1
1
1
1
1
1
0
0
1
1
1
1
1
1
0
1
0
1
0
1
0
1
1
1
1
I
1
1
1
1
0
1
0
0
0
1
0
0
1
1
1
1
O
U
1
1
1
1
1
0
0
1
1
0
0
1
1
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
1
1
1
0.1 0.2 0.3 0.4 0.5
130
Matriz de etiquetas
 0 .1

0

 0

 0
 0

0
0
0
0 .2
0
0
0
0 .3
0
0
0
0 .4
0
0
0
0 

0 
0 

0 
0.5
131
Patrón letra “A”
1
t
1
1
1
1
0
0.1
0.0
0
1
0.0
1
1
0.0
1
1
1
0.0
0
0
1
132
Aproximación de función con Newff
(matlab)
p=-2:0.8:2;
t=sin(pi*p/4);
%p=[-2 -1.2 -0.4 0.4 1.2 2];
%t=[-1 -0.81 -0.31 0.309 0.809 1];
net =newff(p, t ,[5 1],{'tansig','purelin'},'traingdx','learngdm','mse');
133
net.divideFcn = '';
 net.trainParam.show = 10;
 net.trainParam.epochs = 100;
 net.trainParam.lr = 0.01;
 net.trainparam.goal=0.001;

134
net = train(net,p,t);
 y2 = sim(net,p);
 plot(p,t,'-b',p,y2,'-r');

135
Clasificador de vocales
A=[1 1 1 1 1;
1 0 0 0 1;
1 1 1 1 1;
1 0 0 0 1;
1 0 0 0 1];
figure(1),imagesc(A)
AA=A(:); %Convierte la matriz a vector
136
Crea matriz de patrones

matriz=cat(2,AA,EE,II,OO,UU);
137
meta=[.1 0 0 0 0;
0 .2 0 0 0;
0 0 .3 0 0;
0 0 0 .4 0;
0 0 0 0 .5];
138







net = newff(matriz, meta,[50 5],{'tansig',
'purelin'},'trainscg');
net.divideFcn = '';
net.trainParam.show = 10;
net.trainParam.epochs = 200;
net.trainParam.lr = 0.001;
net.trainparam.min_grad=1e-20;
net.trainparam.goal=0.00001;
139
ENTRENA LA RED CON LAS CARACTERISTICAS
ANTES ESTABLECIDAS

[net,tr] = train(net,matriz,meta);
140
Patrón de prueba

X=[1 1 1 1 1;
1 0 0 0 1;
1 1 1 1 1;
1 0 1 0 1;
1 1 1 0 1];
figure(6),imagesc(X)

XX=X(:);

y=sim(net,XX)
[a, clase_obtenida]=max(y)






141
Clasificador alfabético
142
143
Hopfield

Uno de los principales responsables
desarrollo
que
ha
experimentado
computación neuronal ha sido J. Hopfield.
del
la

Este modelo consiste en una red monocapa con
N neuronas cuyos valores de salida son binarios
: 0/1 ó -1/+1
144

Las funciones de activación son del tipo escalón. Se
trata, por tanto, de una red discreta con entradas y
salidas binarias.
• f(x) = +1 si x > 0i
• f(x) = -1 si x < 0i
• f(x) = x si x = 0i
i
i
145

0i es el umbral de disparo de la neurona i, que
representa el desplazamiento de la función de
transferencia. En este modelo suele adoptar un valor
proporcional a la suma de los pesos de las conexiones
de cada neurona con el resto:
N
Oi  k
w
ij
j 1
donde :
∑ es la sumatoria desde j = 1 hasta N
k es la constante de proporcionalidad
146

Existen conexiones laterales (cada neurona se
encuentra conectada a todas las demás) pero
no autorrecurrentes (no consigo misma). Los
pesos asociados a las conexiones entre pares
de neuronas son simétricos (wij = wji)
147
Funcionamiento

Se trata de una red autoasociativa. Por tanto,
diferentes patrones pueden ser almacenados en
la red, como si de una memoria se tratase,
durante la etapa de aprendizaje.
148
Aprendizaje

El mecanismo de aprendizaje utilizado es
de tipo OFF LINE, por lo que existe una
etapa de aprendizaje y otra de
funcionamiento de la red. Utiliza
aprendizaje no supervisado.
149

Utilizando una notación matricial, para
representar los pesos de la red se puede utilizar
una matriz de dimensión NxN (N es el número
de neuronas de la red y por tanto de
componentes del vector de entrada). Esta matriz
es simétrica (wij = wji) y con la diagonal con
valores nulos (wii = 0) al no haber conexiones
autorecurrentes.
150

Utilizando esta notación, el aprendizaje consistiría en
la creación de la matriz de pesos W a partir de los k
vectores de entrada que se enseñan a la red.
N

W=
(T(Ek). Ek - I)
k 1
N
Donde

k 1
es la sumatoria para k igual a 1 hasta el número de
neuronas, N
T(Ek) es la transpuesta de la matriz Ek
I es la matriz identidad que anula los pesos de las conexiones
autorecurrentes wii
151
Ejemplo: Hopfield

El entrenamiento va a consistir en el aprendizaje de dos
patrones de cuatro pixeles cada una. Los pixeles se
representan mediante el valor -1 si es blanco y 1 si es
negro.
Patrón 1 Patrón 2
152

Los valores de los vectores de entrada que
representan cada patrón son:
E1= [1,1,-1,-1]

y
E2 = [-1,-1,1,1]
Por tanto, los patrones de entrada a la red van a
ser dos vectores (M=2) de 4 elementos (N=4)
conteniendo los valores de los píxeles.
153
Etapa de aprendizaje

El aprendizaje de estos dos patrones consiste en la obtención de
los pesos de la red (matriz W).

Para la entrada E1, la salida W1 es:
W1
1
TE1.E1-I =
1
1000
.
1 1 -1 -1
-
0100
=
0
1
-1
-1
1
0
-1
-1
-1
0010
-1
-1
0
1
-1
0001
-1
-1
1
0
154

Para la entrada E2, la salida W2 es:
W2
TE2.E2-I =
-1
-1 .
1
1
1000
-1 -1 1 1 - 0 1 0 0
0010
0001
=
0
1
1
0
-1 -1
-1 -1
-1 -1
-1 -1
0
1
155
1
0

Sumando W1 y W2 se obtiene la matriz de
pesos definitiva, W:
W=W1+W2 =
0
2
-2
-2
2
0
-2
-2
-2
-2
0
2
-2
-2
2
0
156
Etapa de funcionamiento

Si aplicamos a la red la entrada:
157

E = [1 -1 -1 -1] , el vector de salida seria:
158

Como suponemos una función de
activación de cada neurona de tipo
escalón con desplazamiento sobre el
origen, ß=0, la salida de la red después de
la primera iteración es:

S(t) = [1 1 -1 -1]
159

Repitiendo el proceso, tomando como
entrada la salida anterior, S
S(t)
160

Aplicando igualmente la función de activación la
salida obtenida es:

S(t+1) = [1 1 -1 -1]

Al repetirse la salida, la red se ha estabilizado,
generándose el patrón más parecido al que se
ha presentado como entrada.
161

Cálculo de energía para cada patrón
1 T
E   x Wx
2
162
Distancia de Hamming

En Teoría de la Información se denomina distancia de
Hamming a la efectividad de los códigos de bloque y
depende de la diferencia entre una palabra de código
válida y otra.

Por ejemplo:

La distancia Hamming entre 1011101 y 1001001 es 2.
La distancia Hamming entre 2143896 y 2233796 es 3.
La distancia Hamming entre "toned" y "roses" es 3.


163
Calculo de distancias


Hamming
Euclidea
k
k
i 0
i 0
d H   ai  bi , cuando _ ai  bi
M
D2  (  ( xi  yi ) 2 )
i 1


Distancia Minkowski, p=2
1/ p
M
D p (x, y )  (  ( xi  yi ) p )
Distancia Manhatan o City-Block
i 1
M
D1   | xi  yi |
i 1
164
Ejercicio 1

Patrones de entrada (7 X 6):

y comprobar su funcionamiento para la figura
distorsionada
165
Ejercicio 2

Distorsionar en 20% la letra A

Distorsionar en 40% la letra A

Distorsionar en 60% la letra A

Distorsionar en 80% la letra A
166
Ejercicio 3
167

Gracias!
168

Cada una de las neuronas de la capa oculta
tiene como salida a

f: Función de transferencia de las neuronas de
la capa oculta
169

La salida de la red de cada neurona a se compara con
la salida deseada t para calcular el error en cada
unidad de salida

e0  t0  a
s
0

170

El error medio cuadrático para patrón es:
s
1
2
emc   e0 
2 k 1
171

Calculo del error en la capa de salida:
 0  ti  ai * ai * 1  ai 

Calculo del error en la capa oculta:
 j

 i    wmj 0  * ai * 1  ai 
 m1

172


Actualización
de
los
pesos que conectan la
capa oculta con la capa
de salida:
Para
los
pesos
conectados de la capa
oculta con la entrada:
wij  wij  0ai
wij  wij  i pi
173
Backpropagation (sentividad)
174
Las sensitividades, empezando desde
la última hasta la primera capa.

tansig

purelin
175
Luego de encontrar el valor del gradiente del error se
procede a actualizar los pesos.

Para la actualización de los pesos que conectan la capa oculta
con la capa de salida:
wkj (t  1)  wkj (t )  s2 ai
bk (t  1)  bk (t )  s2

Para la actualización de los pesos que conectan la capa de
entrada con la capa oculta:
w ji (t  1)  w ji (t )  s1 pi
b j (t  1)  b j (t )  s1
176