MODELOS DE REDES

NEURONALES
 CÁLCULOS EN UNA NEURONA
NETj es la suma de las salidas de las neuronas
conectadas a la entrada de la neurona j multiplicadas
por los pesos de las conexiones. - se toma como X0W0j
con X0=1 la salida de una neurona ficticia (biass)
conectada a la entrada de la neurona u y W0j = - el
peso de la conexión NETj = X0W0j+…+XNWNj

1 si  Net  0 1 X1
yj  f ( Net j )  0 si  Net  0 .. W1j
. Xk Wkj
k j
.. Yj
. Xn Wnj
W0j= -
n X0 =1 (biass)
I. REDES NEURONALES
MULTICAPA CON
CONEXIONES
FEEDFORWARD
 1. PERCEPTRON
ROSENBLAT 1962
TOPOLOGIA: 2 CAPAS:
CAPA DE ENTRADA: N NEURONAS CON FUNCIÓN DE TRANSFERENCIA
IDENTIDAD
CAPA DE SALIDA: 1 NEURONA CON FUNCIÓN DE TRANSFERENCIA
ESCALÓN.

X1 1
.. W1
. Wk
Xk k
.. Y
. Wn
W0= -
Xn n X0 =1
 PERCEPTRON
CAPA DE ENTRADA:
Entrada neta: NETi = Xi
Función de transferencia Xi Yi
identidad: Yi = NETi
Entonces: Yi = Xi

CAPA DE SALIDA:
1 X1
Entrada neta: .. W1
NET= X0W0+X1W1+…+XNWN . Xk Wk
k _
Función de transferencia .. Y
escalón: y = F(NETi) . Xn
Wn
W0= -
y = A, si NET  0 n X0 =1
y = B, si NET  0
Con A=1, B=0 o -1
 EJM. FUNCIÓN OR
X1 X2 Y X1 1 W1
0 0 0B
0 1 1A W2
1 0 1A
Y
1 1 1A X2 2
W0= -

NET= X0W0+ X1W1 +X2W2 X0 =1

y = F(NET)
(0,1) (1,1)
y = A, si NET  0 1 1
y = B, si NET  0
El límite entre la salida 1 y 0 es
NET=0 = W0+ X1W1 +X2W2 (1) A
(ecuación de una recta)
Con W0=1, W1=2, W2=2 en (1): 0 1
X1=0, X2=-1/2 y X1=-1/2, X2=0 (0,0) (1,0)

-> El Perceptron no aprende B

 EJM. FUNCIÓN OR
X1 1 W1
X1 X2 Y
0 0 0B W2 Y
0 1 1A X2 2
1 0 1A W0= -
1 1 1A
X0 =1

(0,1) (1,1)
Se modifican los pesos: 1 1
W0=-1, W1=2, W2=2 en (1):
X1=0, X2=1/2 y X1=1/2, X2=0 A
-> El Perceptron SI aprende
0 1
(0,0) (1,0)
B
 SEPARABILIDAD LINEAL

• Con 2 entradas, se forman 2 regiones clases a y b en

el plano, separadas por una recta NET=0.
• Con 3 entradas, se forman 2 regiones clases a y b en
el espacio, separadas por un plano NET=0.
• Con n entradas, se forman 2 regiones clases a y b en
el plano n-dimensional, separadas por un hiperplano.
El perceptron tiene la capacidad de clasificar
vectores de entrada dividiendo el espacio de entrada en
dos regiones mediante un hiperplano. Si los patrones
de entrada no es linealmente separable, un perceptron
no encontrará solución.
 APRENDIZAJE DEL PERCEPTRON
Es aprendizaje supervisado, por ensayo y error.
Se dispone de ejemplos de aprendizaje con entradas y
salidas deseadas.
Para cada patrón de entrada, se calcula la salida del
Perceptron y se compara con la salida deseada para
obtener el error:
=d-y, d=salida deseada, y=salida obtenida
Si el error es distinto de cero, se modifican los pesos
con la regla de aprendizaje Delta:
w = w + (d-y)x
0<<1, es la razón de aprendizaje.
Algoritmo de aprendizaje del Perceptron
1.Leer los parámetros de aprendizaje:
A=1 o B=0 o -1
N = número de variables de entrada
npe = número de patrones de entrada
alfa, emax=error máximo, itmax=No. máximo de iteraciones
2. Leer los patrones de entrada y la salida deseada
Xp=(X1p, X2p, … , Xnp) , dp, 1<= p <= npe
3.Inicializar los pesos en 0 o en valores aleatorios próximos a 0
W0=W1= … = WN= 0
4. t= 1 # iteración 1
5. sw = 0
5. while t<=itmax and sw==0 do
6. p= 1 # patrón de entrada 1
7. while p<=npe do
8. # calcular la salida
NET= NET= X0PW0+X1PW1+…+XNPWN # Entrada neta
yp = A, si NET  0 # Salida
Algoritmo de aprendizaje del Perceptron
9. # Calcular el error
 p = dp - y p
10. # Regla de aprendizaje
w0 = w0 + (p )x0
w1 = w1 + (p )x1
...
wN = w1 + (p )xN
11. p= p + 1
12. end-while
13. if p <emax para p=1, 2, … , npe then sw = 1
14. t = t + 1
15. end-while
16. if sw==1 then return W # retorna el vector de pesos
else return “no aprendió”
17. end
 FUNCION XOR
X1 X2 Y
0 0 0 B
0 1 1A
1 0 1A
1 1 0B

x2
(0,1) (1,1) Patron de entrada
A B clase B, no está en
su región correcta
A

B
B A x1
(0,0) (1,0)

La función XOR no la aprende un Perceptron, porque

sus patrones de entrada no son linealmente separables.
Separación lineal en perceptrones
Separación lineal en tres dimensiones
EJEMPLO 1. EN Python PERCEPTRON AND

X1 X2 Y
0 0 0 TRAIN
0 1 0 TRAIN
1 0 0 TRAIN
1 1 1 TRAIN
0.02 0.01 0 TEST
0.98 0.01 0 TEST
0.01 0.99 QUERY
0.99 0.98 QUERY
 Algoritmo de aprendizaje del Perceptron
from random import choice
from numpy import array, dot, random, poly1d
import pylab as plt
# Función de transferencia escalón:
A= 1
B= int(input("A=1, B<0 o -1> = "))
escalon = lambda x: B if x < 0 else A
# datos para train, entradas x1, x2, x0 (x0 siempre es 1)
# salida deseada d: (array[x1, x2, x0], d)
train_data = [
(array([0,0,1]), 0),
(array([0,1,1]), 1),
(array([1,0,1]), 1),
(array([1,1,1]), 1),
]
# pesos iniciales aleatorios: w0, w1, w2
w = random.rand(3)
 Algoritmo de aprendizaje del Perceptron
# lista de valores de error, inicializada
errores = []
# tasa de aprendizaje (alfa)
alfa = 0.2
# número máximo de iteraciones de aprendizaje
itmax = 100
# entrenamiento (calcula valores de los pesos)
for i in range(itmax):
# selecciona una fila de E/S de datos de train
x, d = choice(train_data)
# calcula la entrada neta net, producto escalar de w, x
net = dot(w, x)
# calcula la salida obtenida
y = escalon(net)
# calcula el error= salida deseada (d) - salida obtenida (y)
error = d - y
errores.append(error)
# actualiza pesos de las conexiones (regla de aprendizaje)
w = w + alfa * error * x
 Algoritmo de aprendizaje del Perceptron
print("errores: ",errores)
# calcula y muestra las salidas para datos de train = test
for x, _ in train_data:
net = dot(x, w)
print("{}: {} -> {}".format(x[:2], net, escalon(net)))

# calcula y muestra las salidas para una consulta

query_data = [
(array([0.02,1,1])),
(array([1,0.01,1])),
]
print("resultado de la consulta")
for xc in query_data:
net = dot(xc, w)
print("{} -> {}".format(xc[:2], escalon(net)))
 APRENDIZAJE SUPERVISADO POR ENSAYO Y ERROR

TOPOLOGIA

EJEMPLOS DE TRAIN TRAIN

NO
PESOS Etrain<emax

SI
EJEMPLOS DE
TEST
TEST

NO
Etest<emax

SI

QUERY (SIMULATION)
ENTRADA SALIDA
Ejm 2: Determinar si una PESO ESTATURA DECISION
postulante a modelo es aceptada 55 160 SI
o no, en función de su peso y 60 180 SI
estatura. 62 155 NO
Ejemplos de entrenamiento: 65 160 NO
CONSULTA: 67 160 NO
peso=61, estatura=151, d=no 65 179 SI

peso=60, estatura= 170 72 187 SI

decisión=si 75 155 NO
64 178 SI
77 170 NO
78 160 NO
70 185 SI

20 /73
 Algoritmo de aprendizaje del Perceptron
from numpy import array, dot, random
A= 1
B= int(input("A=1, B<0 o -1> = "))
n=int(input("Nº variables entrada="))
# Función de transferencia escalón:
escalon = lambda z: B if z < 0 else A
# datos para train, entradas x1, x2, ..., xn, x0 (x0 siempre es 1)
# salida deseada d: (array[x1, x2, ..., xn, x0], d)
train_data = [
(array([0.55,1.68,1]), 1),
(array([0.60,1.80,1]), 1),
(array([0.62,1.55,1]), 0),
(array([0.67,1.60,1]), 0),
(array([0.65,1.79,1]), 1),
(array([0.75,1.55,1]), 0),
(array([0.64,1.78,1]), 1),
(array([0.77,1.70,1]), 0),
(array([0.78,1.60,1]), 0),
(array([0.70,1.85,1]), 1) ]
Algoritmo de aprendizaje del Perceptron
# pesos iniciales aleatorios: w0, w1, w2, ..., wn
w = random.rand(n+1)
# lista de valores de error, inicializada
errores = []
# tasa de aprendizaje (alfa)
alfa = 0.2
# número máximo de iteraciones de aprendizaje
itmax = 50
 Algoritmo de aprendizaje del Perceptron
# entrenamiento (calcula valores de los pesos)
for t in range(itmax):
nel = len(train_data)
for p in range(nel):
# selecciona una fila de E/S de datos de train
x, d = train_data[p]
# calcula la entrada neta net, producto escalar de w, x
net = dot(w, x)
# calcula la salida obtenida
y = escalon(net)
# calcula el error= salida deseada (d) - salida obtenida
(y)
error = d - y
errores.append(error)
# actualiza los pesos de las conexiones (regla de
aprendizaje)
if error !=0:
w = w + alfa * error * x
 Algoritmo de aprendizaje del Perceptron
# datos de test
test_data = [
(array([0.72,1.87,1]), 1),
(array([0.65,1.60,1]), 0),
]
# calcula y muestra las salidas para datos de test
print("resultado de test:")
for x, _ in test_data:
net = dot(x, w)
print("{}: {} -> {}".format(x[:2], net, escalon(net)))
# calcula y muestra las salidas para una consulta
query_data = [
(array([0.61,1.51,1])),
(array([0.60,1.70,1])),
]
print("resultado de la consulta:")
for xc in query_data:
net = dot(xc, w)
print("{} -> {}".format(xc[:n], escalon(net)))
 RECONOCIMIENTO DE PATRONES
El proceso de reconocimiento de patrones consiste
en clasificar un objeto o hecho (PATRON) en una
categoría determinada, basándose en
particularidades del objeto que son comunes a los
miembros de una misma CLASE.
Ejemplos de reconocimiento de patrones realizados
por humanos son: Reconocer a un amigo entre la
multitud, Leer un libro.
Matemáticamente, la clasificación consiste en la
partición del espacio n-dimensional definido por las
características de un objeto, en varias regiones. Cada
región corresponde a una clase.
 RECONOCIMIENTO DE PATRONES
Espacio de características

X2 =peso
Kg.

100 W2
90
O O
80 O O O
W1 O O
70
x
x
60 x x
x x
50 X1 =altura

1.50 1.60 1.70 1.80 1.90 2.0 2.10

Metros

2 clases: o Jugadores de basket ball, x Jockeys

DISEÑO DE CLASIFICADORES DE
PATRONES
Fases en un clasificador: (1) Entrenamiento y (2) Prueba de
reconocimiento
Después de seleccionar las características y de decidir el tipo de
reconocedor se deben recolectar datos para entrenamiento y para
prueba.
CLASIFICADORES DE PATRONES NEURONALES
La clasificación es un problema de decisión estadística.
• Los clasificadores Bayesianos conocen las funciones de
distribución probabilística.
• Las RNA son clasificadores no paramétricos, es decir, no se
conocen las funciones de distribución. Su flujo es:

Red Selección Salida: clase

Entrada: vector de
Neuronal de una clase
características
 PROBLEMAS
1. PROBAR EL EJEMPLO 1
2. PROBAR EL EJEMPLO 2
3. RESOLVER EN PYTHON OR
4. RESOLVER EN PYTHON XOR
5. RESOLVER EN PYTHON EL PROBLEMA: 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 y su intensidad de color naranja, medida
entre 0 y 255.
Ejemplos de aprendizaje (80% train, 20% test):
• Naranjas = { (10,200), (8,150), (7,170), (15,250)}
• Melón = {(20,30), (26,30), (24,32), (19,31)}
GRACIAS