I.

REDES NEURONALES
MULTICAPA CON
CONEXIONES
FEEDFORWARD
 PERCEPTRON MULTICAPA
Es una red neuronal multicapa con 3 o más capas, con conexiones hacia
adelante.
TOPOLOGÍA:
La capa de entrada tiene N neuronas, con función de transferencia identidad.
1 o más capas ocultas con función de transferencia sigmoidal o tangente
hiperbólica.
La capa de salida tiene M neuronas, con función de transferencia sigmoidal o
tangente hiperbólica o identidad.
 EJEMPLO: FUNCION XOR
X1 X2 Y
0 0 0 B
0 1 1A
1 0 1A
1 1 0B

x2
(0,1) (1,1)
A B

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

El perceptron multicapa con 3 capas aprende la función XOR

 EJEMPLO: FUNCION XOR
X1 X2 Y
0 0 0 B
0 1 1A
1 0 1A
1 1 0B

x2
(0,1) (1,1)
A B
A

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

El perceptron multicapa con 4 capas aprende la función XOR

 FUNCIONAMIENTO
Como se ve en el ejemplo de XOR, el perceptron multicapa
con 3 capas aprende de manera más simple que el de 4
capas.
En general, se debe intentar utilizar el perceptron multicapa
de 3 capas, en casos muy complejos utilizar el de 4 capas y
excepcionalmente de más capas.
Algoritmo Backpropagation
1.Leer los parámetros de aprendizaje:
N = número de variables de entrada
M = número de variables de salida
L = número de neuronas de la capa oculta
npe = número de parámetros 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, con 1<= p <= npe
3.Inicializar los pesos en 0 o en valores aleatorios próximos a 0
Wji=0 (capa oculta), Wkj= 0 (capa de salida)
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
# CAPA OCULTA
NETj= X0PWj0+X1pWj1+…+XNPWjN # Entrada neta
Algoritmo Backpropagation
# CAPA DE SALIDA
NETK= Y0PWK0+YKpWK1+…+YLPWKL # Entrada neta
yK = F(NETK ), para 1<= k <= M
9. # Calcular el error
# CAPA DE SALIDA
k = (dk – yk) F’(NETk) para 1<= k <= m
# CAPA OCULTA
J = F’(NETj)  (wkj * k) , con 1 <= j <= L
10. # Regla de aprendizaje (ACTUALIZAR PESOS)
# CAPA OCULTA
wJI = wJI +  (J ) X0P
# CAPA DE SALIDA
wKJ = wKJ +  (K )YJP
11. # CALCULAR EL ERROR PROMEDIO
12. Ep = (1/M)*  (k)^2, con 1<= k <= M
13. p= p + 1
14. end-while
Algoritmo Backpropagation

15. if Ep <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
 APRENDIZAJE SUPERVISADO POR ENSAYO Y ERROR

TOPOLOGIA

EJEMPLOS DE TRAIN TRAIN

SI
PESOS Etrain<emax

NO
EJEMPLOS DE
TEST
TEST

SI
Etest<emax

NO

QUERY (SIMULATION)
ENTRADA SALIDA
 COEFICIENTE (RAZÓN) DE APRENDIZAJE

En la regla de aprendizaje: wji = wji + (p )xj.

El cambio en el peso es proporcional al gradiente del error,
siendo α (razón de aprendizaje: valor entre 0 y 1) la constante
de proporcionalidad
–Si α es grande, los desplazamientos son más bruscos y el
error puede oscilar alrededor del mínimo. La convergencia
generalmente es más rápida, aunque con el riesgo de saltar
un buen mínimo
–Si α es pequeña, los desplazamientos son más suaves,
implicando una convergencia más lenta del algoritmo.
–Es un parámetro del aprendizaje que se determinará
experimentalmente
 CAPACIDAD DE GENERALIZACIÓN

No sólo es importante saber si la red se adapta a los patrones

de entrenamiento, sino que hay que conocer cómo se
comportará ante patrones no utilizados en el entrenamiento
Hay que evaluar la capacidad de generalización con un
conjunto de datos diferente al utilizado para el entrenamiento
A veces, es necesario exigir menor ajuste a los datos de
entrenamiento para obtener mejor generalización
Para poder hacer esto, es necesario evaluar la capacidad de
generalización a la vez que se realiza el entrenamiento, no sólo
al final del proceso de entrenamiento
Cada cierto número de ciclos de entrenamiento se pasa el
conjunto de test o (validación) (sin ajustar pesos) para medir la
capacidad de generalización
Así puede medirse tanto la evolución del error de
entrenamiento como la de test (o validación)
 CAPACIDAD DE GENERALIZACIÓN
Se cumple: Error total = Error de train + Error de test
Es la suma de los errores de entrenamiento y de validación.
Debe buscarse que el Error total sea mínimo.
Como se dijo, con el error de entrenamiento se determina el
aprendizaje de la red neuronal de los ejemplos de train.
Con el error de validación, se determina la capacidad de
generalizar de la red, es decir, con los pesos obtenidos en train se
determina el error para ejemplos de test, que son distintos a los
de train.
Así, la generalización es la capacidad de la red neuronal de
obtener salidas correctas para ejemplos de test, distintos de los
ejemplos de train, con los que se obtuvieron los pesos de las
conexiones, que no son modificados en test.
Entonces el test es la validación de los pesos de las conexiones.
En las figuras a) y b) siguientes, se muestran los dos casos que
pueden presentarse.
CAPACIDAD DE GENERALIZACIÓN
 CAPACIDAD DE GENERALIZACIÓN
En la figura a) ambos errores, de entrenamiento y validación,
permanecen estables después de un cierto número de
iteraciones. En este caso, el aprendizaje ha acabado con éxito,
pues la red ha sido capaz de extraer las características del
problema, alcanzando un buen nivel de generalización.
En la figura b), a partir de un cierto número de iteraciones, el error
de validación comienza a aumentar. En este caso, el número de
ciclos total (2300) es adecuado para encontrar un mínimo error de
entrenamiento, pero se ha perdido la capacidad de generalizar de
la red (el error total es muy alto). Entonces se ha producido un
sobreaprendizaje de los ejemplos de entrenamiento, la red los ha
memorizado y no resuelve correctamente otros ejemplos. Esto se
puede deber al excesivo número de iteraciones o al elevado
número de neuronas en las capas ocultas.
Se trata entonces de encontrar el número de iteraciones para el
que el error total es mínimo. Luego se obtendrán los pesos,
volviendo a entrenar a la red con ese número de iteraciones.
 CAPACIDAD DE GENERALIZACIÓN
Sin embargo, puede suceder que se encuentre un error total que
sea mínimo local y no el mínimo global. En este caso se debe
aumentar el número de neuronas ocultas y/o partir de pesos
iniciales aleatorios próximos a cero.
En la figura, se obtienen errores mínimos locales en las
iteraciones 2, 7 y 12. El mínimo global está en la iteración 16.
 RELACIÓN ERROR, NÚMERO DE PESOS Y NÚMERO
DE EJEMPLOS DE ENTRENAMIENTO

Para problemas complejos, en los que el aprendizaje puede

demorar mucho tiempo, se ha establecido la siguiente
relación experimental:
E = error
W = número de pesos (conexiones)
P = número de ejemplos (patrones) de entrenamiento
P = W/E
Ejm. con E=0,1 (10%), W= 60, se tiene P= 60/0,1 = 600
 TIPOS DE INFORMACIÓN DE ENTRADA Y
SALIDA
Como se vio antes, se tienen los tipos de información siguientes:

1) INFORMACIÓN DISCRETA
Se usa una neurona para representarla.
a) Binaria
0 y 1 ó -1 y 1

b) No binaria
0 , 0.5, 1
-1, -0.5, 0, 0.5, 1
 
2) INFORMACIÓN CONTINUA
Se usa una neurona para representarla
[ -∞ , ∞ ]
[ -1 , 1 ]
[0,1]
C. TIPOS DE INFORMACIÓN DE ENTRADA
Y SALIDA
3) INFORMACIÓN SIMBÓLICA
 Si son símbolos ordenables se usa una neurona para
representarla.
 Si son símbolos no ordenables se usa N neuronas para
representarla.
Edad Ordenable No Ordenable
Bebe -1 00001
Niño -0.5 00010
Joven 0 00100
Adulto 0.5 01000
Anciano 1 10000
 NORMALIZACIÓN DE LA INFORMACIÓN
CONTINUA
En el caso de la información continua:
Si en la capa de salida se tiene la función de transferencia sigmoidal
(devuelve valores entre [ 0,1 ]) o tanh (devuelve valores entre [-1,1] )
entonces los datos de los ejemplos de aprendizaje, que toman valores
entre [-∞ , ∞] tienen que ser normalizados.
Es decir, si la salida deseada varía entre [10, 100], nunca va a
coincidir con la salida obtenida que varía entre [0,1] si la red tiene
función sigmoidal en la capa de salida y la red neuronal no va a
aprender. Para que coincida hay que normalizar los ejemplos de
aprendizaje.
Vemos el caso en que se normalizan los datos que varían entre [a,b]
al intervalo [0,1] (algo similar es cuando se normalizan a [-1,1])
 NORMALIZACIÓN DE LA INFORMACIÓN
CONTINUA
NORMALIZADO

0.9

Y
ɸ
0.1

A X B SIN
NORMALIZAR

Los ejemplos de entrenamiento están en el intervalo [A, B]

Se hace A equivalente a 0.1 y no a 0, por si se presentaran datos
menores que A. B equivale a 0.9 y no a 1, por si se presentaron datos
mayores a B.
X es el dato sin normalizar, Y es el normalizado
tan ɸ = (Y – 0,1) / (X - A) = (0.9 – 0.1) / (B - A)
Y = 0.1 + (0.9 – 0.1) * (X - A)/ (B - A) PARA NORMALIZAR
X = A + (B – A)*(Y -0.1) / (0.9 – 0.1) PARA DESNORMALIZAR
 Scikit-Learn
Scikit-Learn implementa el perceptrón multicapa para clasificación y
regresión en las clases sklearn.neural_network.MLPClassifier y
sklearn.neural_network.MLPRegressor
EJEMPLO 1:
 EJEMPLO 1
import pandas as pd
# dataset para un ejemplo sencillo
df = pd.DataFrame({
"x0": [0.3, 0.1, 0.4, 0.5],
"x1": [0.7, 0.2, 0.3, 0.8],
"y": [1, 0, 0, 1]
})
# datos para train:
y_train = df.pop("y")
X_train = df
print(X_train, y_train)
# Importar la clase MLPClassifier:
from sklearn.neural_network import MLPClassifier
# Crear el modelo e instanciar con tasa de aprendizaje de 0.1,
# función de activación en la capa oculta: la función logística.
model = MLPClassifier((2, ), random_state = 0,
learning_rate_init = 0.1, activation = "logistic")
 EJEMPLO
# Entrenar el modelo
model.fit(X_train, y_train)
# Predicción para los valores con los que se ha entrenado:
print('predicción para X_train:')
print(model.predict(X_train))
# Precisión media:
print('precisión media:')
print(model.score(X_train, y_train))
# El atributo coefs_ da un array con tantos elementos como
# capas (sin la de entrada), estando formado cada elemento
# por una matriz de coeficientes (de pesos)
print('matriz de pesos:')
print(model.coefs_)
# El atributo intercepts_ da un array con cada elemento
# vector de bias de cada capa
print('vectores de bias')
print(model.intercepts_)
 PARAMETROS DEL PERCEPTRON
1.
MULTICAPA
hidden_layer_sizes: número de neuronas en cada capa
oculta: (5, ) una capa oculta de 5 neuronas y (50, 20, 10) 3
capas ocultas de 50, 20 y 10 neuronas artificiales.
2. activation: Función de activación para neuronas de las
capas ocultas (no pueden ser distintas para cada capa):
• identity, función identidad: f(x) = x
• logistic, función logística: f(x) = 1 / (1 + exp(-x))
• tanh, función tangente hiperbólica: f(x) = tanh(x)
• relu, (por defecto) función "rectified linear unit": f(x) =
max(0, x)
3. solver: Algoritmo optimizador de los pesos a utilizar para
el cálculo del mínimo de la función de coste:
• lbfgs, optimizador de la familia de métodos casi-Newton
• sgd, descenso de gradiente estocástico
• adam (opción por defecto) gradiente estocástico
4. max_iter: número máximo de epochs, por defecto 200. Si
converge antes de este número, se detiene el aprendizaje.
 EJM. PREDICCION DEMANDA
PRODUCTO
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split
datos=pd.read_csv("bater001.csv")
x= datos['Mes']
y= datos['Demanda']
print (x)
print (y)
# convertir las entradas en una matriz Ejm [ [1], [2], ...]
X=x[:,np.newaxis]
i=0
plt.figure(figsize=(20,10))
plt.rc('font',size=16)
 EJM. PREDICCION DEMANDA
while True: PRODUCTO
i=i+1
# Particion para los datos de entrenamiento y de prueba
X_train, X_test, y_train, y_test = train_test_Split(X,y,
test_size = 0.30)
mlr=MLPRegressor(solver='lbfgs', alpha=1e-1,
hidden_layer_sizes=(24,12),random_state=1)
# train
mlr.fit(X_train,y_train)
print (mlr.score(X_train,y_train))
if mlr.score(X_train,y_train) > 0.8:
plt.scatter(X_train,y_train,color=‘blue',label="Train set")
plt.scatter(X_test,y_test,color='green', label="Test set")
plt.xlabel('Mes')
plt.ylabel('Demanda')
plt.show()
break
print ("Prediccion en Mes=29 ",mlr.predict([[29]]))
 EJM. RECONOCIMIENTO DE
DÍGITOS
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
import matplotlib.pyplot as plt
import numpy as np
# Con load_digits() se carga el dataset de sklearn para
clasificar dígitos numéricos
digitos = datasets.load_digits()
# El dataset tiene imágenes de los dígitos y sus etiquetas
asociadas, que se guardan por separado:
imagenes = digitos.images
etiquetas = digitos.target
# El dataset tiene 1797 ejemplos. Cada etiqueta es un valor
# numérico entre 0 y 9. Las imágenes son matrices de 8×8
# enteros que son intensidad de un pixel (entre 0 y 16):
print(imagenes.shape)
print(etiquetas.shape)
 EJM. RECONOCIMIENTO DE
# Un ejemplo es: DÍGITOS
plt.gray()
print(imagenes[6])
img = plt.imshow(imagenes[6])
plt.show()
# Para pasar cada imagen a la red neuronal se ordena los
píxeles en un array de 1x64 enteros:
print("Tamaño antes: ", imagenes[0].shape)
imagenes = imagenes.reshape((imagenes.shape[0], -1))
print("Tamaño después: ", imagenes[0].shape)
# La función train_test_split() crea conjuntos de train (70%)
y test (30%) del dataset
X_train, X_test, y_train, y_test = train_test_split(imagenes,
etiquetas, test_size = 0.3, random_state = 1)
# La función MLPClassifier() crea un perceptrón multicapa:
clasificador = MLPClassifier(solver='lbfgs', alpha = 1e-
1,hidden_layer_sizes=(128,128), random_state=1)
 EJM. RECONOCIMIENTO DE
DÍGITOS
# Se entrena la red neuronal con conjunto de entrenamiento:
clasificador.fit(X_train, y_train)
# La precisión para los ejemplos de X_test: más del 95% de
salidas coinciden con y_test
print("Precisión = " , clasificador.score(X_test, y_test))
# Predicción de uno de los valores del conjunto de prueba:
import random
# Se selecciona un elemento al azar del conjunto X_test:
indice = random.choice(range(0,len(X_test)-1))
imagen_digito = X_test[indice]
# Se muestra la imagen del dígito:
plt.gray()
img = plt.imshow(imagen_digito.reshape(8,8))
plt.show()
# Se muestra el valor real de la imagen y la predicción:
print("Valor real:", y_test[indice])
print("Predicción:",
clasificador.predict(imagen_digito.reshape(1, -1)))
 PROBLEMA
1. RESUMEN DE LAS DIAPOSITIVAS
2. PROBAR LOS EJEMPLOS
GRACIAS