MULTIPERCEPTRÓN Y EL

ALGORITMO BACKPROPAGATION
 Multiperceptrón - Arquitectura
2
 Redes multicapa
3

 Con una sola neurona no se

puede resolver el problema del
XOR porque no es linealmente
separable.
 XOR

OR  p1+p2-0.5=0

AND I1- 1.5 * I2 - 0.5=0

p1+p2-1.5=0

w11=1 w12=1 b1=-0.5 ; w21=1 w22=1 b2=-1.5 ; w31=1 w32=-1.5 b3=-0.5 4

 I1 I2
XOR p1 p2
(or) (AND)
a

1 0 1 0 1
5
1 1 1 1 0

OR  p1+p2-0.5=0 0 0 0 0 0
0 1 1 0 1

AND I1 - 1.5 * I2 - 0.5=0

p1+p2-1.5=0
 Neurona artificial
6

Función de
x0 k  1 transferencia
w0
x1k w1
 n 
yk  f   xik .wi 
n

x2 k
w2 x ik .wi
i 0  i 0 
wn
xnk n
netak   xik .wi
i 0
 Perceptrón 1 si x  0
f ( x)  
0 si x  0
7

x0 k  1
w0
 n
x1k w1
n 1 si x ik .wi  0
x2 k
w2  xik .wi yk   i 0
n
i 0 0 si
 x
i 0
ik .wi  0

wn
xnk
 Actualiza el vector 𝑊 modificando el ángulo
que forma con cada ejemplo 𝑋𝑘
 Combinador lineal
8
f ( x)  x

x0 k  1
w0
x1k w1 n
yk   xik .wi
n

x2 k
w2 x
i 0
ik .wi
i 0

wn
xnk
 Utiliza descenso por gradiente para actualizar
el vector de pesos.
 Neurona no lineal (logsig) f ( x) 
1
1  ex
9

x0 k  1
w0
x1k w1
1
yk 
n

x2 k
w2 x
i 0
ik .wi n
  xik . wi
1 e i 0

wn
xnk
 Utiliza descenso por gradiente para actualizar
el vector de pesos.
 Neurona no lineal (tansig) f ( x) 
2
1 e 2 x
1
10

x0 k  1
w0
x1k w1
2
yk  1
n

x2 k
w2 x
i 0
ik .wi n
 2  xik . wi
1 e i 0

wn
xnk
 Utiliza descenso por gradiente para actualizar
el vector de pesos.
 Neurona no lineal (Relu) f ( x)  max(0, x)
11

x0 k  1
w0
x1k w1
 
n n
x2 k
w2 x ik .wi yk  max 0,  xik .wi 
i 0
 i 0 
wn
xnk
 Utiliza descenso por gradiente para actualizar
el vector de pesos.
 Problema no separable linealmente
12

 Se busca obtener un algoritmo más general que permita integrar el aprendizaje

entre las dos capas.
Animación de una RN
Tinker With a Neural Network Right Here in Your Browser
 Problema no separable linealmente
14

entrada oculta salida

X2
X1 A

X2 B

X1

 ¿Cuál es el tamaño de cada capa?

 Problema no separable linealmente
15

 La idea es aplicar un descenso en la dirección del gradiente sobre

la superficie de error expresada como una función de los pesos.
 Deberán tenerse en cuenta los pesos de los arcos que unen AMBAS
capas.
 Dado que el aprendizaje es supervisado, para los nodos de salida
se conoce la respuesta esperada a cada entrada. Por lo tanto,
puede aplicarse la regla delta vista para el Combinador Lineal y la
Neurona No Lineal.
 Multiperceptrón - Arquitectura
16
 Algoritmo backpropagation
17

Dado el siguiente conjunto de vectores

{( x1 , y1 ), ..., ( x p , y p )}

que son ejemplos de correspondencia funcional

y   (x) x  RN , y  RM

se busca entrenar la red para que aprenda una aproximación

y '   ' ( x)
 Backpropagation. Capa Oculta
18

 Ejemplo de entrada
x p  ( x p1 , x p 2 ,..., x pN ) t

 Entrada neta de la j-ésima neurona de la capa oculta

n
netahpj   whji x pi   hj
i 1
 Salida de la j-ésima neurona de la capa oculta
i pj  f (neta )
j
h h
pj
 Backpropagation. Capa de Salida
19

 Entrada neta de la k-ésima neurona de la capa de salida

L
netaopk   wkjo i pj   ko
j 1

 Salida de la k-ésima neurona de la capa de salida

o pk  f ko (netaopk )
 Actualización de pesos
20

 Error en una sola unidad de la capa de salida

 pk  ( y pk  o pk )
donde
y es la salida deseada
 o es la salida real.

 p se refiere al p-ésimo vector de entrada

 k se refiere a la k-ésima unidad de salida

 Actualización de pesos
21

 Se busca minimizar
M
1
E p    2pk
2 k 1

1 M
E p   ( y pk  o pk ) 2

2 k 1

se tomará el valor negativo del gradiente

Actualización de pesos

E p f o
 (neta ) o

 ( y pk  o pk ) k pk

wkj
o
 (neta pk ) wkj
o o

  L o 
o   kj pj
o
f ' (neta ) o w i  hk   i pj
o
k pk wkj  j 1 
Salida de la
E p neurona oculta j
 ( y pk  o pk ) f k ' (neta pk )i pj
o o

wkj
o

Peso del arco que une la neurona j de la capa

oculta y la neurona k de la capa de salida
Actualización de pesos
 Por lo tanto, para la capa de salida se tiene

 o
pk  ( y pk  o pk ) f ' (neta )
k
o o
pk

w (t  1)  w (t )    i
o
kj
o
kj
o
pk pj
Actualización de pesos

 Corrección para los pesos de los arcos entre la capa de entrada y la

oculta

 p w (t )    x pi
h
ji
h
pj

serán de la forma:

  f ' (neta )  w
h
pj j
h h
pj
o
pk
o
kj
k
 Backpropagation. Entrenamiento
25

 Aplicar un vector de entrada y calcular su salida.

 Calcular el error.
 Determinar en qué dirección (+ o -) debe cambiarse los pesos para reducir
el error.
 Determinar la cantidad en que es preciso cambiar cada peso.
 Corregir los pesos de las conexiones.
 Repetir los pasos anteriores para todos los ejemplos hasta reducir el error
a un valor aceptable.
  Propagar el ejemplo de entrada a través de la capa oculta
26
n
netahpj   whji x pi   hj
i 1

i pj  f jh (netahpj )
  Propagar las salidas de la capa oculta hacia la capa de salida
27

L
neta   w i  
o
pk
o
kj pj
o
k
j 1

o pk  f (neta )
k
o o
pk
  Se obtienen los valores de salida
28
  Se calcula la corrección que se realizará al vector de pesos que llega a
cada neurona de salida
29

 o
pk  ( y pk  o pk ) f ' (neta )
k
o o
pk
  Se calcula la corrección que se realizará al vector de pesos que llega a
cada neurona oculta
30

 pjh  f jh ' (netahpj )  pk

o
wkjo
k
  Se calcula la corrección que se realizará al vector de pesos que llega a
cada neurona de la capa oculta
31

  f ' (neta )  w
h
p1 1
h h
p1
o
pk
o
k1
k
  Se actualizan ambas matrices de pesos
33

whji (t  1)  whji (t )    pjh xi

w (t  1)  w (t )    i
o
kj
o
kj
o
pk pj
 Backpropagation. Resumen
34

 Aplicar el vector de entrada

x p  ( x p1 , x p 2 ,..., x pN ) t
 Calcular los valores netos de las unidades de la capa oculta
n
netahpj   whji x pi   hj
i 1
 Calcular las salidas de la capa oculta

i pj  f (neta )
j
h h
pj
 Backpropagation. Resumen
35

 Calcular los valores netos de las unidades de la capa de salida

L
neta   w i  
o
pk
o
kj pj
o
k
j 1
 Calcular las salidas

o pk  f (neta )
k
o o
pk
 Backpropagation. Resumen
36

 Calcular los términos de error para las unidades de salida

 o
pk  ( y pk  o pk ) f ' (neta )
k
o o
pk

 Calcular los términos de error para las unidades ocultas

 pjh  f jh ' (netahpj )  pk

o
wkjo
k
 Backpropagation. Resumen
37

 Se actualizan los pesos de la capa de salida

w (t  1)  w (t )    i pj
o
kj
o
kj
o
pk

 Se actualizan los pesos de la capa oculta

whji (t  1)  whji (t )    pjh xi

 Repetir hasta que el error resulte aceptable

 XOR p1 p2
I1 I2 a
38
(or) (AND)
1 0 1 0 1
1 1 1 1 0
0 0 0 0 0
0 1 1 0 1
 MLP_XOR.ipynb
Problema del XOR
39

import numpy as np
from graficaMLP import dibuPtos_y_2Rectas
from Funciones import evaluar, evaluarDerivada

X = [Link]([ [-1, -1], [-1, 1], [1, -1], [1, 1]])

Y = [Link]([-1, 1, 1, -1]).reshape(-1,1)
entradas = [Link][1]
ocultas = 2 X Y

salidas = [Link][1]
 MLP_XOR.ipynb
Pesos iniciales
40

W1 = [Link](-0.5,0.5,[ocultas, entradas])
b1 = [Link](-0.5,0.5, [ocultas,1])
W2 = [Link](-0.5,0.5,[salidas, ocultas])
b2 = [Link](-0.5,0.5, [salidas,1])
 MLP_XOR.ipynb
Graficar W1 y b1
41

ph = dibuPtos_y_2Rectas(X,Y, W1, b1, ph)

 MLP_XOR.ipynb
alfa = 0.15
CotaError = 0.001
MAX_ITERA = 300
ite = 0
while ( abs(ErrorAVG–ErrorAnt)>Cota) and ( ite < MAX_ITERA ):
for p in range(len(P)): #para cada ejemplo
# propagar el ejemplo hacia adelante
# calcular los errores en ambas capas
# corregir los todos los pesos

# Recalcular AVGError
ite = ite + 1
print(ite, AVGError)
# Graficar las rectas
Calcular la salida para el ejemplo p

# funciones de activación de cada capa

FunH = 'sigmoid'
FunO = 'tanh'

# propagar el ejemplo hacia adelante

netasH = W1 @ X[p:p+1,:].T + b1
salidasH = evaluar(FunH, netasH)
netasO = W2 @ salidasH + b2
salidasO = evaluar(FunO, netasO)
alfa = 0.15 MLP_XOR.ipynb
CotaError = 0.001
MAX_ITERA = 300
ite = 0
while ( AVGError > CotaError ) and ( ite < MAX_ITERA ):
for p in range(len(X)): #para cada ejemplo
# propagar el ejemplo hacia adelante
# calcular los errores en ambas capas
# corregir los todos los pesos

# Recalcular AVGError
ite = ite + 1
print(ite, AVGError)
# Graficar las rectas
Términos de error

 Calcular los términos de error para las unidades de salida

 o
pk  ( y pk  o pk ) f ' (neta )
k
o o
pk

 Calcular los términos de error para las unidades ocultas

  f ' (neta )  w
h
pj j
h h
pj
o
pk
o
kj
k
Funciones de Activación

Fun = 'sigmoid‘
1
f (neta) 
1  e  neta
netas = W1 @ X.T + b1
i = evaluar(FunH, netas)
f ' (neta)  f (neta) * (1  f (neta)) derivH = evaluarDerivada(FunH,i)

2 Fun = 'tanh'
f (neta)   2*neta
1
1 e netas = W1 @ X.T + b1
i = evaluar(FunH, netas)
f ' (neta)  1  f (neta) 2 derivH = evaluarDerivada(FunH,i)
 MLP_XOR.ipynb
Calcular errores de cada capa
# calcular los errores en ambas capas
ErrorSalida = Y[p:p+1,:].T - salidasO
deltaO = ErrorSalida * evaluarDerivada(FunO,salidasO)
deltaH = evaluarDerivada(FunH,salidasH)*(W2.T @ deltaO)
 MLP_XOR.ipynb
Actualización de los pesos

# corregir todos los pesos

W1 = W1 + alfa * deltaH @ X[p:p+1,:]
b1 = b1 + alfa * deltaH
W2 = W2 + alfa * deltaO @ salidasH.T
b2 = b2 + alfa * deltaO
Ejemplo: Clasificación de flores de Iris

Id sepallength sepalwidth petallength petalwidth class

1 5,1 3,5 1,4 0,2 Iris-setosa
2 4,9 3,0 1,4 0,2 Iris-setosa
… … … … … …
95 5,6 2,7 4,2 1,3 Iris-versicolor
96 5,7 3,0 4,2 1,2 Iris-versicolor
97 5,7 2,9 4,2 1,3 Iris-versicolor
… … … … … …
149 6,2 3,4 5,4 2,3 Iris-virginica
150 5,9 3,0 5,1 1,8 Iris-virginica

[Link]
Ejemplo: Clasificación de flores de Iris

SepalLength
Iris-setosa
SepalWidth
Iris-versicolor
PetalLength
Iris-virginica
PetalWidth

MLP_IRIS.ipynb
 Clasificación de flores de Iris
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Clasificación de flores de Iris
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

[[ 0.66, -1.49, 2.95, 3.34], [[-2.94],

[ 0.37, -1.2 , 0.27, -0.47]] [-0.49]]

W1 b1
 Clasificación de flores de Iris
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

[[-4.79, -0.99], [[ 1.39],

[ 0.3 , 0.9 ], [-0.26],
[ 4.67, -0.91]] [-2.88]]

W2 b2
 Clasificación de flores de Iris
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

FunH='tanh' ; FunO='sigmoid'

Ingresar el primer ejemplo a la red y

calcular su salida
 Calculando la salida de la capa oculta
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Salida de la capa oculta

FunH='tanh' ; FunO='sigmoid'
netasH = W1 * xT + b1 xT
[[-1.73],
[[0.66, -1.49, 2.95, 3.34], [-0.05], [[-2.94], [[-12.4537]
[0.37, -1.2 , 0.27, -0.47]] * [-1.38], + = [ -0.827 ]]
[-0.49]]
[-1.31]]
W1 b1
 Calculando la salida de la capa oculta
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Salida de la capa oculta

FunH='tanh' ; FunO='sigmoid'
netasH = W1 * xT + b1 xT
[[-1.73],
[[0.66, -1.49, 2.95, 3.34], [-0.05], [[-2.94], [[-12.4537]
[0.37, -1.2 , 0.27, -0.47]] * [-1.38], + = [ -0.827 ]]
[-0.49]]
[-1.31]]
W1 b1

[[-0.99999219]
salidasH = 2 / (1+[Link](-netasH))- 1 =
[-0.39144044]]
 Calculando la salida de la red (capa de salida)
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Salida de red
FunH='tanh' ; FunO='sigmoid'
netasO = W2 * salidasH + b2
salidasH
[[-4.79, -0.99], [[-0.99999219] [[ 1.39], [[ 6.56748865]
[ 0.3 , 0.9 ], * + = [-0.91229406]
[-0.39144044]] [-0.26],
[ 4.67, -0.91]] [-2.88]] [-7.19375274]]

W2
b2
 Calculando la salida de la red (capa de salida)
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Salida de red
FunH='tanh' ; FunO='sigmoid'
netasO = W2 * salidasH + b2
salidasH netasO
[[-4.79, -0.99], [[-0.99999219] [[ 1.39], [[ 6.56748865]
[ 0.3 , 0.9 ], * + = [-0.91229406]
[-0.39144044]] [-0.26],
[ 4.67, -0.91]] [-2.88]] [-7.19375274]]

W2 b2
[[9.98596651e-01]
salidasO = 1 / (1+[Link](-netasO)) = [2.81401722e-01]
[7.50700367e-04]]
 Error de la capa de salida
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Error en la respuesta de la red para este ejemplo

FunH='tanh' ; FunO='sigmoid'
ErrorSalida = yT - salidasO

[[1.0] [[9.98596651e-01] [[ 0.00140335]

ErrorSalida = [0.0] - [2.81401722e-01] = [-0.28653063]
[0.0]] [7.50700367e-04]] [-0.0007507 ]]

salidasO
 Factores de corrección de los pesos
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Factores para corregir W2 y b2

salidasO*(1-salidasO)
FunH='tanh' ; FunO='sigmoid'
deltaO = ErrorSalida .* derivada_FunO
[[ 0.00140335] [[0.00140138] [[ 1.96662772e-06]
deltaO = [-0.28653063] .* [0.20443083] = [-5.85756944e-02]
[-0.0007507 ]] [0.00075014]] [-5.63128256e-07]]
 Factores de corrección de los pesos
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Factores para corregir W1 y b1

(1-salidasH**2) FunH='tanh' ; FunO='sigmoid'
deltaH = deriv_FunH .* (W2.T @ deltaO)
[[ 1.96662772e-06]
[[1.56128940e-05] [[-4.79 0.31 4.67] @ [-5.85756944e-02]
deltaH = [8.46774379e-01]] .* [-0.99 0.9 -0.91]] [-5.63128256e-07]]

[[-2.74548968e-07]
deltaH = [-4.46415722e-02]]
 Corrigiendo de los pesos
Capa de entrada Capa de
X Y Capa salida
sepallength oculta
[[-1.73,-0.05,-1.38,-1.31], [[1,0,0],
[-0.37,-1.62, 0.22, 0.18], [0,1,0], sepalwidth
Iris-Setosa

[ 1.11,-0.05, 0.93, 1.54], [0,0,1], Iris-Versicolor

[-0.99, 0.39,-1.44,-1.31], [1,0,0], petallength

[ 1.73, 1.29, 1.46, 1.81]] [0,0,1]] petalwidth Iris-Virginica

 Modificación de W2 y b2
FunH='tanh' ; FunO='sigmoid'
W2 = W2 + alfa * deltaO @ salidasH.T

[[-4.79, -0.99], [[ 1.96662439e-06] [[-4.79 -0.99]

W2 = [ 0.31, 0.9 ], + alfa * [-5.69035911e-02] @ [[-0.999, -0.39144]] = [ 0.31 0.9 ]
[ 4.67, -0.91]] [-5.63127983e-07]] [ 4.67 -0.91]]

[[ 1.39], [[ 1.96662439e-06] [[ 1.39],

b2 = b2 + alfa * deltaO = [-0.26], + alfa * [-5.69035911e-02] = [-0.26],
[-2.88]] [-5.63127983e-07]] [-2.88]]
 MLP_IRIS_RN.ipynb
Multiperceptrón en Python
from sklearn.neural_network import MLPClassifier
clf = MLPClassifier( solver='sgd',
learning_rate_init=0.15,
hidden_layer_sizes=(5),
max_iter=700, verbose=False,
tol=1.0e-09, activation = 'tanh')
[Link](X_train,T_train)
y_pred= [Link](X_train)
Matriz de Confusión
Predice Clase 1 Predice Clase 2 Recall
True Clase 1 A B A/(A+B)
True Clase 2 C D D/(C+D)
Precision A/(A+C) D/(B+D) (A+D)/(A+B+C+D)
accuracy

 Los aciertos del modelo están sobre la diagonal de la matriz.

 Precision: la proporción de predicciones correctas sobre una clase.
 Recall: la proporción de ejemplos de una clase que son correctamente clasificados.
 Accuracy: la performance general del modelo, sobre todas las clases. Es la
cantidad de aciertos sobre el total de ejemplos.
 sklearn_metrics.ipynb
[Link].accuracy_score
from sklearn import metrics
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]

aciertos = metrics.accuracy_score(Y_train,Y_pred)
print("%% accuracy = %.3f" % aciertos)
 sklearn_metrics.ipynb
[Link].accuracy_score
from sklearn import metrics Rtas esperadas
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]
Rtas obtenidas
aciertos = metrics.accuracy_score(Y_train,Y_pred)
print("%% accuracy = %.3f" % aciertos)

 De los 12 valores sólo 9 fueron identificados correctamente.

 La tasa de aciertos es 9/12 = 0.75
 sklearn_metrics.ipynb
[Link].confusion_matrix
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]

MM = metrics.confusion_matrix(Y_train,Y_pred)
print("Matriz de confusión:\n%s" % MM)

0
Esperaba obtener 1
1
TRUE

como respuesta pero

2 la red respondió 2
3
0 1 2 3
PREDICE
 sklearn_metrics.ipynb
[Link].confusion_matrix
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]

MM = metrics.confusion_matrix(Y_train,Y_pred)
print("Matriz de confusión:\n%s" % MM)

0
La respuesta correcta
1
TRUE

es 2 pero la red
2 respondió 1
3
0 1 2 3
PREDICE
 sklearn_metrics.ipynb
[Link].confusion_matrix
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]

MM = metrics.confusion_matrix(Y_train,Y_pred)
print("Matriz de confusión:\n%s" % MM)

0
Esperaba un 3 pero la
1
TRUE

red respondió 0
2
3
0 1 2 3
PREDICE
 sklearn_metrics.ipynb
[Link].confusion_matrix
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]

MM = metrics.confusion_matrix(Y_train,Y_pred)
print("Matriz de confusión:\n%s" % MM)

0
Los valores fuera de
1
TRUE

la diagonal principal
2 son errores
3
0 1 2 3
PREDICE
 sklearn_metrics.ipynb
[Link].classification_report
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]
report = metrics.classification_report(Y_train,Y_pred)
print("Resultado de la clasificación:\n%s" % report)
 sklearn_metrics.ipynb
[Link].classification_report
Y_train = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
Y_pred = [0, 2, 1, 3, 0, 1, 2, 0, 0, 1, 2, 3]
report = metrics.classification_report(Y_train,Y_pred)
print("Resultado de la clasificación:\n%s" % report)

F1-score
𝑝𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 ∗ 𝑟𝑒𝑐𝑎𝑙𝑙
𝐹1 = 2 ∗
𝑝𝑟𝑒𝑐𝑖𝑠𝑖ó𝑛 + 𝑟𝑒𝑐𝑎𝑙𝑙
Ejemplo: Clasificación de flores de Iris

SepalLength
Iris-setosa
SepalWidth
Iris-versicolor
PetalLength
Iris-virginica
PetalWidth

Ver
MLP_IRIS_RN.ipynb
Reconocedor de dígitos escritos a mano
 Se desea entrenar un multiperceptrón para reconocer dígitos escritos a
mano. Para ello se dispone de los mapas de bits correspondientes a
3823 dígitos escritos a mano por 30 personas diferentes en el archivo
“optdigits_train.csv”.

 El desempeño de la red será

probado con los dígitos del
archivo “optdigits_test.csv”
escritos por otras 13 personas.

[Link]
“optdigits_train.csv” y “optdigits_test.csv”
 Cada dígito está representado por una matriz numérica de 8x8
“optdigits_train.csv” y “optdigits_test.csv”
 Cada dígito está representado por una matriz numérica de 8x8
0 1 13 13 9 8 0 0

0 13 10 0 0 0 0 0

3 15 0 3 3 0 0 0

4 12 10 15 13 15 6 0

2 16 13 1 0 4 14 0

0 14 6 0 0 1 16 0

0 10 11 3 0 6 13 0

0 1 11 14 16 15 5 0

im_32x32_a_8x8.ipynb
RN para reconocer dígitos manuscritos

im_32x32_a_8x8.ipynb Entrenamiento
muy lento
¿Se puede
acelerar?

MLP_MNIST_8x8.ipynb
Descenso de gradiente en mini-lotes
 En lugar de ingresar los ejemplos de a uno, Total: 2000 ejemplos

200
ingresamos N a la red y buscaremos minimizar el
200
error cuadrático promedio del lote. 200
Tamaño de
Lote = 200
200
 La función de costo será 200
𝑁 10 iteraciones
1 200
2
𝐶 = ෍ 𝑑𝑖 − 𝑓(𝑛𝑒𝑡𝑎𝑖 ) 200
𝑁 200
𝑖=1
200
 N es la cantidad de ejemplos que conforman el lote. 200

MLP_MNIST_RN.ipynb 1 época
Descenso de gradiente

Batch Mini-batch Stochastic

Ingresa TODOS los ejemplos y luego Ingresa un LOTE de N ejemplos y luego Ingresa UN ejemplo y luego
actualiza los pesos. actualiza los pesos actualiza los pesos

Bueno para pocos ejemplos Bueno p/funciones de error convexas Bueno para data sets grandes
1 𝑀 2 1 𝑁 2 2
𝐶= σ 𝑑𝑖 − 𝑓(𝑛𝑒𝑡𝑎𝑖 ) 𝐶= σ 𝑑𝑖 − 𝑓(𝑛𝑒𝑡𝑎𝑖 ) 𝑁≪𝑀 𝐶 = 𝑑 − 𝑓(𝑛𝑒𝑡𝑎)
𝑀 𝑖=1 𝑁 𝑖=1
 MLP_MNIST_RN.ipynb
Multiperceptrón en Python
from sklearn.neural_network import MLPClassifier
clf = MLPClassifier(solver='sgd', learning_rate_init=0.05,
hidden_layer_sizes=(15,), random_state=1,
max_iter=2000,
verbose=False, tol=1.0e-05,
batch_size=200,
activation='logistic')
history = [Link](X_train,Y_train)
Usa
y_pred= [Link](X_train) Entropía cruzada
como función de costo
Problemas

 La capacidad de generalización de la red está relacionada con la

cantidad de neuronas de la capa oculta.

 El descenso por la técnica del gradiente tiene el problema de caer

en un mínimo local.
 Capacidad de generalización
82

 RN formada por una única

neurona.
 Los puntos sólidos corresponden
a los ejemplos de entrenamiento
y los demás a testeo.
 La clasificación es correcta.
 En este caso se dice que le red
ha generalizado la información
correctamente.
 Sobreajuste de la superficie de decisión
83

 RN que utiliza dos neuronas

ocultas.
 Cada hiperplano busca la mayor
proximidad a los ejemplos.
 Algunos ejemplos se clasifican
incorrectamente.
 En este caso se dice que le red
NO ha generalizado la
información correctamente.
Overfitting
 Sobreajuste de la superficie de decisión
84

 A mayor cantidad de neuronas en la capa oculta, la red puede variar

más rápido en respuesta a los cambios de la entrada.
Capacidad de generalización de la red

Underfitting Generalización Overfitting

(demasiado simple) correcta (demasiados
parámetros)
 Sobreajuste
 Parada temprana (early-stopping)

Datos de
Error
testeo

Datos de
entrenamiento

Pto de detención Epocas

temprana
Reducción del sobreajuste

 Si lo que se busca es reducir el sobreajuste puede probar

 Incrementar la cantidad de ejemplos de entrenamiento.
 Reducir la complejidad del modelo, es decir usar menos
pesos (menos capas o menos neuronas por capa).
 Aplicar una técnica de regularización
 Regularización L2 Tienen por objetivo que los pesos de la red
se mantengan pequeños
 Regularización L1
 Dropout
Sobreajuste - Regularización L2
 También conocida como técnica de decaimiento de pesos
𝜆
𝐶 = 𝐶𝑜 + ෍ 𝑤𝑘2
2
𝑘
donde 𝐶𝑜 es la función de costo original sin regularizar

 La derivada de la función de costo regularizada será

𝜕𝐶 𝜕𝐶0
= + 𝜆 𝑤𝑘
𝜕𝑤𝑘 𝜕𝑤𝑘
Sobreajuste - Regularización L2

𝜆
𝐶 = 𝐶𝑜 + ෍ 𝑤𝑘2
2
𝑘

 Actualización de los pesos

La regularización
𝜕𝐶0 no se aplica al
𝑤𝑘 = 𝑤𝑘 − α − 𝜆 𝑤𝑘
𝜕𝑤𝑘 bias.

𝜕𝐶0
𝑤𝑘 = 1 − 𝜆 𝑤𝑘 − α
𝜕𝑤𝑘
Sobreajuste - Regularización L1

𝐶 = 𝐶𝑜 + 𝜆 ෍ 𝑤𝑘 𝜕𝐶 𝜕𝐶0
= + 𝜆 𝑠𝑖𝑔𝑛(𝑤𝑘 )
𝑘 𝜕𝑤𝑘 𝜕𝑤𝑘

 Actualización de los pesos

𝜕𝐶0
𝑤𝑘 = 𝑤𝑘 − α − 𝜆 𝑠𝑖𝑔𝑛(𝑤𝑘 )
𝜕𝑤𝑘
Sobreajuste - Dropout
 No modifica la función de costo sino la
arquitectura de la de la red.
 Proceso
 Selecciona aleatoriamente las neuronas que
no participarán en la próxima iteración y las
“borra” temporalmente.
 Actualiza los pesos (del mini lote si
corresponde).
 Restaura las neuronas “borradas”.

 Repite hasta que se estabilice.

 ¿Mínimo local o global?
92

 El problema se resuelve utilizando la dirección del gradiente junto con un

componente aleatorio que permita salir de los mínimos locales.
Velocidad de aprendizaje

  maneja la velocidad de aprendizaje.

 Si su valor se incrementa demasiado, la red puede
desestabilizarse.
 Una forma de solucionar esto es incorporar, a la modificación de
los pesos, un término que incluya una proporción del último cambio
realizado. Este término se denomina momento.
Término de momento

 La modificación de los pesos se realizará de la siguiente forma:

𝑣 = 𝜇 𝑣 − 𝛼 𝛻𝐶

𝑤 = 𝑤+𝑣

 El parámetro 𝜇 representa la contribución del término de momento.