Enunciados.

PRÁCTICAS DE LABORATORIO
Redes Recurrentes y Autónomas
29-03-07
________________________________________________________________________
PRÁCTICA 1
Analiza la evolución de la red recurrente binaria cuya matriz de pesos sinápticos viene dada en la figura 1(a) y sus
valores umbrales son todos iguales a uno.
0
0.0582 -0.4839 0.1267 -0.5362
0.0582
0
-0.9408 0.2464 -1.0426
-0.4839 -0.9408
0
-2.0496 8.6721
0.1267 0.2464 -2.0496
0
-2.2713
-0.5362 -1.0426 8.6721 -2.2713
0
(a)
(b)
Figura 1. a) Matriz de pesos sinápticos. b) Imagen de la matriz.
Explica por qué una solución óptima debe ser la representada en la figura 2 en términos del consenso de los estados de
las neuronas según los valores de los pesos sinápticos de las conexiones.
Figura 2. Solución óptima.
PRÁCTICA 2
Construye una red recurrente y binaria de 100 unidades de proceso (neuronas), cuyos pesos sinápticos y umbrales sean
números aleatorios del intervalo [-1,1], siguiendo una dinámica de computación secuencial (asíncrona) con elección
aleatoria de las neuronas (figura 3). Analiza el comportamiento de la función de energía conforme aumenta el número
de actualizaciones (figura 4). ¿Cuántos ciclos (épocas) de actualizaciones neuronales han sido necesarios para la
estabilización de la red? Interpreta la configuración final de la red según los valores de los pesos sinápticos (figura 5).
Figura 3. Mapa de los pesos sinápticos. Figura 4. Evolución de la energía computacional.
Figura 5. Una configuración final para 100 neuronas.
PRÁCTICA 3
Construye una red recurrente y binaria de 100 unidades de proceso (neuronas), cuyos pesos sinápticos y umbrales sean
números aleatorios del intervalo [-1,1], siguiendo una dinámica de computación paralela (sincronizada). Analiza el
comportamiento de la función de energía conforme aumenta el número de actualizaciones (figura 6). ¿Se estabiliza la
red?
Figura 6. Evolución de la energía computacional.
PRÁCTICAS DE LABORATORIO
Redes Recurrentes y Autónomas
29-03-07
________________________________________________________________________
PRÁCTICA 4
Diseña una red de Hopfield que determine el menor de 100 números, x1 , x2 ,..., x100 , generados
aleatoriamente en el intervalo [0, 1]. Comprueba que los parámetros de la red pueden son: wij = −2λ , i ≠ j ,
siendo λ el parámetro de penalización, wii = 0, θ i = xi − λ , i, j=1,2,…,100. ¿Determina siempre la red el
valor menor (mínimo global)? ¿Por qué? ¿Cómo actualizarías las unidades de proceso para conseguir que la
red siempre alcance el valor mínimo?
PRÁCTICA 5
Se considera el siguiente Problema de localización: Dado un grafo con N vértices (puntos de demanda), se
trata de determinar el vértice (centro de servicio) que minimiza la suma total de las distancias a cada uno de
los vértices del grafo. Diseña una red de Hopfield para encontrar dicho vértice (llamado mediana del grafo).
¿Se puede utilizar la red anterior?
PRÁCTICA 6
Problema de video-vigilancia (cobertura): Una zona céntrica de una ciudad se representa por un grafo en
el que los cruces de calles constituyen sus vértices y las aristas son los tramos de calle entre dos cruces. Se
desea seleccionar el conjunto de vértices de menor tamaño que garantice que cualquier arista del grafo incide
sobre algún vértice de dicho conjunto. Diseña una red de Hopfield binaria para el grafo que viene en la
figura 7 junto a su matriz de adyacencia.
⎛0
⎜
⎜1
⎜0
⎜
⎜1
⎜0
⎜
⎜0
⎜0
⎜
⎜0
⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎜⎜
⎝0
13
11
12
10
9
8
7
6
3
5
4
2
1
1
0
1
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
1
0
0
1
0
0
0
0
0
0
0
0
1
0
1
0
0
1
0
0
0
0
0
1
0
0
1
0
1
0
0
1
0
0
0
0
0
1
0
0
1
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
1
0
0
1
0
0
0
0
0
1
0
0
1
0
1
0
1
0
0
0
0
0
0
1
0
0
1
0
1
0
1
0
0
0
0
0
0
1
0
0
1
0
0
1
0
0
0
0
0
0
0
1
1
0
0
0
1
0⎞
⎟
0⎟
0⎟
⎟
0⎟
0⎟
⎟
0⎟
0⎟
⎟
0⎟
⎟
0⎟
1⎟
⎟
1⎟
1⎟
⎟
0 ⎠⎟
Figura 7. Grafo y su matriz de adyacencia.
Comprueba que los parámetros de la red pueden son: wij = −2λ aij , ∀ i ≠ j , siendo λ el parámetro de
penalización y aij el elemento
θ i = 1 − 2λ ni , i, j = 1, 2,..., N .
(i,j)
de
la
matriz
de
adyacencia
del
grafo,
wii = 0,
PRÁCTICA 7
Diseño de un convertidor analógico-digital: Se trata de convertir (aproximar) cualquier valor de una señal
7
analógica (continua) z(t)∈ [0, 255] en la representación binaria de 8 bits, zˆ(t ) = ∑ 2i xi , con xi ∈ {0,1},
i =0
i=0,1,2,…,7, que mejor aproxima a z(t). Por lo tanto, el objetivo es minimizar el error de representación que
viene dado por la expresión:
2
7
⎛
⎞
E (t ) = ⎜ z − ∑ 2i xi ⎟
i =0
⎝
⎠
Diseña una red de Hopfield para encontrar los valores x0 , x1 ,..., x7 que conduce a la mejor aproximación de
z(t).
PRÁCTICAS DE LABORATORIO
El Perceptrón simple: neuronas binarias
19-04-2007
________________________________________________________________________
PRÁCTICA 1
Construcción de una neurona binaria
Se va a construir una red neuronal con una única neurona que tiene una función paso (escalón), como
función de transferencia, y dos sensores de entrada. Sus entradas van a ser números reales del intervalo
[−5,5]:
net=newp([-5 5;-5 5],1,’hardlim’)
% ([Matriz de valores mínimos y máximos de las entradas], Número de neuronas, Función de
•
transferencia)
Su matriz de pesos sinápticos va ser W=[2 -1] y el umbral b=1.5:
net.IW{1,1}=[2 -1];
net.b{1}=1.5;
•
Valores de salida de la neurona lineal para cada una de las entradas del conjunto
⎧⎪ ⎡1 ⎤ ⎡ −2 ⎤ ⎡3 ⎤ ⎡ −1⎤ ⎫⎪
C = ⎨⎢ ⎥ , ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎬ :
⎪⎩ ⎣3⎦ ⎣ 2 ⎦ ⎣ −4 ⎦ ⎣ −3⎦ ⎪⎭
P=[1 -2 3 -1; 3 2 -4 -3];
S=sim(net,P);
SOLUCIÓN:
________________________________________________________________________________
si 2 x1 − x2 ≥ −1.5
⎧1
y=⎨
si 2 x1 − x2 < −1.5
⎩0
Salidas de la red para cada uno de las entradas del conjunto C:
Función que define la neurona binaria:
⎡1 ⎤
⎡ −2 ⎤
⎡3 ⎤
⎡ −1 ⎤
⎢3⎥ → 1; ⎢ 2 ⎥ → 0; ⎢ −4 ⎥ → 1 ⎢ −3⎥ → 1
⎣ ⎦
⎣ ⎦
⎣ ⎦
⎣ ⎦
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 2
Construcción de una neurona bipolar
Se va a construir una red neuronal con una única neurona que tiene la función signo, como función de
transferencia, y dos sensores de entrada. Sus entradas van a ser números reales del intervalo [−5,5]:
net=newp([-5 5;-5 5],1,’hardlims’)
% ([Matriz de valores mínimos y máximos de las entradas], Número de neuronas, Función de
•
transferencia)
Su matriz de pesos sinápticos va ser W=[2 -1] y el umbral b=1.5:
net.IW{1,1}=[2 -1];
net.b{1}=1.5;
•
Valores de salida de la neurona lineal para cada una de las entradas del conjunto
⎧⎪ ⎡1 ⎤ ⎡ −2 ⎤ ⎡3 ⎤ ⎡ −1⎤ ⎫⎪
C = ⎨⎢ ⎥ , ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎬ :
⎩⎪ ⎣3⎦ ⎣ 2 ⎦ ⎣ −4 ⎦ ⎣ −3⎦ ⎭⎪
P=[1 -2 3 -1; 3 2 -4 -3];
S=sim(net,P)
SOLUCIÓN:
________________________________________________________________________________
si 2 x1 − x2 ≥ −1.5
⎧1
y=⎨
si 2 x1 − x2 < −1.5
⎩−1
Salidas de la red para cada uno de las entradas del conjunto C:
Función que define la neurona bipolar:
⎡1 ⎤
⎡ −2 ⎤
⎡3 ⎤
⎡ −1 ⎤
⎢3⎥ → 1; ⎢ 2 ⎥ → −1; ⎢ −4 ⎥ → 1 ⎢ −3⎥ → 1
⎣ ⎦
⎣ ⎦
⎣ ⎦
⎣ ⎦
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 3
Aprendizaje con el Perceptrón: Implementación de la Función lógica OR
Se va diseña un perceptrón simple que implemente la función lógica “OR” con dos entradas y una única
neurona de salida.
El conjunto de los 4 patrones de entrada (bidimensionales) viene dado la matriz
⎡1 1 0 0 ⎤
P=⎢
⎥ y sus correspondientes salidas deseadas vienen dadas por el vector
⎣1 0 1 0 ⎦
T =[ 1 1 1 0 ].
•
Construcción de la red inicial como un objeto estructurado:
net = newp([0,1;0 1], 1,’hardlim’,’learnp’); % No es necesario especificar
%'hardlim','learnp', las toma por defecto
% newp([matriz de valores mínimos y máximos de las entradas], Número de neuronas, ‘Función
%de Transferencia’, ‘Regla de Aprendizaje)
•
Valores iniciales aleatorios de los pesos y del umbral de la red
net.IW{1,1}=[rands(1) rands(1)];
net.b{1}=rands(1);
•
% También puede ser net=init(net);
Entrenamiento de la red:
net.trainParam.epochs = 20;
net.trainParam.goal = 0;
% Número máximo de épocas
% Error admisible
[net, tr, Y, E]= train(net, P, T)
•
Salidas Y de la red para las entradas P y el error E cometido :
S= sim(net, P)
•
Presentación de los parámetros de la red
net.IW{1}
net.b{1}
mae(S-T)
% se presentan los pesos sinápticos de la red
% se presenta el sesgo de la red
% se presenta el error absoluto medio. ‘mse’ nos da el error cuadrático medio
SOLUCIÓN:
________________________________________________________________________________
⎧1
y=⎨
⎩0
x1
si 1.35 x1 + 0.81x2 ≥ 0.52
si
1.35x1 + 0.81x2 < 0.52
1.35
y
x2
0.81
- 0.52
Figura 8. Patrones y recta de separación
Figura 9. Función implementada (OR)
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 4 Aprendizaje con el Perceptrón: Clasificación con datos de huracanes
Se dispone de un conjunto de datos correspondientes a la longitud y latitud de 37 puntos geográficos, junto
con el tipo de huracán que han padecido (baroclínico o tropical del Atlántico Norte). Se va a diseñar un
perceptrón con dos entradas y una neurona de salida para predecir el tipo de huracán según la longitud y
latitud de un punto geográfico.
• Conjunto de patrones de entrenamiento
load huracanes
•
Creación del Perceptrón de dos sensores de entrada y una neurona de salida.
net = newp(minmax(P),1,'hardlim','learnp');
%minmax(P) nos da el valor mínimo y el valor máximo de cada fila de P
net = init(net); % Valores aleatorios iniciales de los parámetros
•
Entrenamiento de la red
net.trainParam.epochs = 20;
net.trainParam.show = 5;
net.trainParam.goal = 0.1;
net.trainFcn='trainc';
% Número máximo de épocas de entrenamiento
% Se muestra resultado cada 5 épocas
% Error admisible
% Entrenamiento on line. También puede ser en lotes: 'trainb'
net = train(net,P,T);
•
Salidas de la
entrenamiento
red
cuando
las
entradas
corresponde
al
conjunto
de
S= sim(net,P)
•
Valores después del entrenamiento de los pesos sinápticos, del umbral y
del error absoluto medio por neurona
net.IW{1}
net.b{1}
mae(S-T)
% se presentan los pesos sinápticos de la red
% se presenta el sesgo de la red
% se presenta el error absoluto medio. ‘mse’ nos da el error cuadrático medio
SOLUCIÓN:
________________________________________________________________________________
⎧1
y=⎨
⎩0
x1
si
36x1 − 32 x2 ≥ 1
si
36x1 − 32 x2 < 1
36
y
x2
Fig. 10 Evolución del error (mse)
Fig. 11. Recta de separación
-32
Figura 12. Clasificador neuronal
Error absoluto medio = 0.4865 (inaceptable). Los datos no son linealmente separables.
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 5 Aprendizaje con el Perceptrón: Predicción de la diabetes (datos Pima)
Se trata de decidir si una persona tiene diabetes a partir de 7 datos personales. Para ello se dispone de las
siguientes características de 200 mujeres indias mayores de 21 años que vivían cerca de Phoenix (Arizona)
con el fin de estudiar la diabetes de acuerdo a los criterios de la Organización Mundial de la Salud: Nº de
embarazos, concentración de glucosa en plasma, presión sanguínea diastólica, insulina, índice de masa
corporal, función de antecedentes familiares diabéticos, edad y tipo (diabética o no). Se va a diseñar un
Perceptrón simple con el fin de diagnosticar, según estas características, si una mujer es, o no, diabética.
• Cargas los datos
load pima
• Creación del perceptrón con siete sensores de entrada y una salida:
net = newp([minmax(P)], 1,'hardlim','learnp')
• Inicializar la red:
net=init(net);
• Especificación de parámetros de entrenamiento:
net.trainFcn='trainc';
% Entrenamiento en línea. También puede poner
% por lotes: 'trainb’
net.trainParam.epochs=50; % Número total de épocas de entrenamiento
net.trainParam.goal=0.10; % Error máximo que se pretende alcanzar
net.trainParam.show=10;
% Frecuencia de presentación de los gráficos
• Entrenamiento de la red:
[net, tr,Y,E]= train(net, P, T);
• Salidas Y de la red para las entradas P y error E cometido:
Y= sim(net, P);
train_error=mae(Y-T);
• El mejor tiempo para parar de entrenar:
[mim_perf,min_epoch]=min(tr.perf)
• Presentación de los parámetros de la red
net.IW{1}
net.b{1}
mae(Y-T)
SOLUCIÓN:
________________________________________________________________________________
⎧1
y=⎨
⎩0
si
842x1 + 78 x2 − 467 x3 + 434 x4 − 201.4 x5 + 187 x6 + 211x7 ≥ 182
si
842x1 + 78 x2 − 467 x3 + 434 x4 − 201.4 x5 + 187 x6 + 211x7 < 182
Clasificador Neuronal
Fig. 13. Evolución del error (eam)
Fig. 14. Datos Proyectados
Error absoluto medio = 0.30 (inaceptable). Lo datos no son separables linealmente.
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
La ADALINA: neuronas lineales
10-05-2007
________________________________________________________________________
PRÁCTICA 1
Construcción de una neurona lineal
Se va a construir una red neuronal con una única neurona que tiene una función lineal, como función de
transferencia, y dos sensores de entrada. Sus entradas van a ser números reales del intervalo [−5,5]:
net=newlin([-5 5;-5 5],1);
•
% ([Matriz de valores mínimos y máximos de las entradas], Número de
% neuronas)
Su matriz de pesos sinápticos va a ser W=[2 -1] y el umbral b=1.5:
net.IW{1,1}=[2 -1];
net.b{1}=1.5;
•
Se trata de determinar los valores de salida de la neurona lineal para cada una de las entradas del
conjunto
⎪⎧ ⎡1 ⎤ ⎡ −2 ⎤ ⎡3 ⎤ ⎡ −1⎤ ⎫⎪
C = ⎨⎢ ⎥ , ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎬ :
⎩⎪ ⎣3⎦ ⎣ 2 ⎦ ⎣ −4 ⎦ ⎣ −3⎦ ⎭⎪
P=[1 -2 3 -1; 3 2 -4 -3];
S=sim(net,P)
SOLUCIÓN:
________________________________________________________________________________
Función que define la neurona lineal: y = 2 x1 − x2 + 1.5
Salidas de la red para cada uno de las entradas del conjunto C:
⎡1 ⎤
⎡ −2 ⎤
⎡3 ⎤
⎡ −1 ⎤
⎢3⎥ → 0.5; ⎢ 2 ⎥ → −4.5; ⎢ −4 ⎥ → 11.5 ⎢ −3⎥ → 2.5
⎣ ⎦
⎣ ⎦
⎣ ⎦
⎣ ⎦
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 2 La ADALINA: Aproximación lineal
Se va a determinar la función lineal que mejor representa la relación funcional entre el conjunto de patrones
de entrada dados por las columnas de la matriz
P=[-2 -1 0 0 1 2; 1 -2 1 -1 2 1] y el conjunto de salidas respectivas dadas por la matriz
T=[-2 3 2 4 3 6];
•
Construcción de la red inicial como un objeto estructurado:
net = newlin([-2,2;-2 2], 1,0,0.01);
% newlin([matriz de valores mínimos y máximos
% de las entradas], Número de neuronas, Retardo de la entrada, Tasa de Aprendizaje)
•
Entrenamiento de la Adalina:
net.trainParam.goal= 0.0001;
net.trainParam.epochs=200;
[net,TR,Y,E] = train(net,P,T); % TR : registro de entrenamiento ; Y: salida; E: errores
•
Simulación de las salidas Y de la red para las entradas P y errores medios cometidos :
S= sim(net,P)
ErrorMedioSalida=mae(T-S)
% sum(abs(T-S))/6
ErrorMedioclasif=(T-sign(S)) % Error medio del clasificador
•
Presentación de los parámetros de la red
net.IW{1}
net.b{1}
•
Representación gráfica de la función implementada
x=-1:0.2:1;
y=x;
[X,Y]=meshgrid(x,y);
Z=w(1)*X+w(2)*Y+b;
mesh(X,Y,Z)
hold on
plot3(P(1,:),P(2,:),T,'*k')
SOLUCIÓN:
______________________________________________________________________
Función lineal implementada: y = 2 x1 − x2 + 3
Fig. 15. Decrecimiento del error
Fig. 16. Gráfica de la función lineal
______________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 3 La ADALINA: Clasificación de patrones
Se va a diseñar una ADALINA que permita clasificar los 4 patrones dados por las columnas de la matriz de
entradas
⎡1 1 −1 −1⎤
P=⎢
⎥ , y sus correspondientes salidas deseadas (clases) vienen dadas por el vector
⎣1 −1 1 −1⎦
T = [ 1 1 1 −1 ] .
•
Construcción de la red inicial como un objeto estructurado:
net = newlin([-1,1;-1 1], 1,0,0.01); % newlin([matriz de valores mínimos y máximos
%de las entradas], Número de neuronas, Retardo de la entrada, ‘Tasa de Aprendizaje)
%También se puede poner newlin [mínmax(P)], size(T,1),..) para crear el Adaline directamente
•
Entrenamiento de la Adalina:
net.trainParam.epochs = 100;
net.trainParam.goal=0.1;
[net,TR,Y,E] = train(net,P,T);
•
Salidas Y de la red para las entradas P y el error E cometido :
S= sim(net,P)
•
Presentación de los parámetros de la red
net.IW{1}
net.b{1}
errorsalida=mae(T-S)
%sum(abs(T-S))/4
errorclasificacion=mae(T-sign(S));
•
Representación gráfica
x=-1:0.2:1;
y=x;
[X,Y]=meshgrid(x,y);
Z=w(1)*X+w(2)*Y+b;
mesh(X,Y,Z)
hold on
plot3(P(1,:),P(2,:),T,'*k')
SOLUCIÓN:
______________________________________________________________________
Función lineal implementada: y = 0.5 x1 + 0.5 x2 + 0.5
Salidas de la red para cada uno de las entradas (columnas de P):
⎡1⎤
⎢1⎥ → 1.5;
⎣ ⎦
⎡1 ⎤
⎢ −1⎥ → −0.5;
⎣ ⎦
⎡ −1⎤
⎢1 ⎥ → 0.5;
⎣ ⎦
⎡ −1⎤
⎢ −1⎥ → −0.5
⎣ ⎦
Salidas del clasificador:
⎡1⎤
⎡1 ⎤
⎡ −1⎤
⎡ −1⎤
⎢1⎥ → 1; ⎢ −1⎥ → 1; ⎢1 ⎥ → 1; ⎢ −1⎥ → −1
⎣ ⎦
⎣ ⎦
⎣ ⎦
⎣ ⎦
______________________________________________________________________
PRÁCTICAS DE LABORATORIO
El Perceptrón multicapa: neuronas sigmoideas
10-05-2007
________________________________________________________________________
PRÁCTICA 1
Construcción de una neurona logística
Se va a construir una red neuronal con una única neurona que tiene la función logística, como función de
transferencia, y dos sensores de entrada. Sus entradas van a ser números reales del intervalo [−5,5]:
net=newp([-5 5;-5 5],1,’logsig’)
% ([Matriz de valores mínimos y máximos de las entradas], Número de neuronas, Función de
•
transferencia)
Su matriz de pesos sinápticos va ser W=[2 -1] y el umbral b=1.5:
net.IW{1,1}=[2 -1];
net.b{1}=1.5;
•
Valores de salida de la neurona lineal para cada una de las entradas del conjunto
⎧⎪ ⎡1 ⎤ ⎡ −2 ⎤ ⎡3 ⎤ ⎡ −1⎤ ⎫⎪
C = ⎨⎢ ⎥ , ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎬ :
⎩⎪ ⎣3⎦ ⎣ 2 ⎦ ⎣ −4 ⎦ ⎣ −3⎦ ⎭⎪
P=[1 -2 3 -1; 3 2 -4 -3];
S=sim(net,P)
SOLUCIÓN:
________________________________________________________________________________
Función que define la neurona logística:
y=
1
− ( 2 x1 − x2 +1.5 )
1+ e
Salidas de la red para cada uno de las entradas del conjunto C:
⎡1 ⎤
⎡ −2 ⎤
⎡3 ⎤
⎡ −1⎤
⎢3⎥ → 0.6225; ⎢ 2 ⎥ → 0.0110; ⎢ −4 ⎥ → 1.000 ⎢ −3⎥ → 0.9241
⎣ ⎦
⎣ ⎦
⎣ ⎦
⎣ ⎦
________________________________________________________________________________
PRÁCTICA 2
Construcción de una neurona tangente hiperbólica
Se va a construir una red neuronal con una única neurona que tiene la función logística, como función de
transferencia, y dos sensores de entrada. Sus entradas van a ser números reales del intervalo [−5,5]:
net=newp([-5 5;-5 5],1,’tansig’)
% ([Matriz de valores mínimos y máximos de las entradas], Número de neuronas, Función de
•
Su matriz de pesos sinápticos va ser W=[2 -1] y el umbral b=1.5:
net.IW{1,1}=[2 -1];
net.b{1}=1.5;
•
Valores de salida de la neurona lineal para cada una de las entradas del conjunto
⎧⎪ ⎡1 ⎤ ⎡ −2 ⎤ ⎡3 ⎤ ⎡ −1⎤ ⎫⎪
C = ⎨⎢ ⎥ , ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎬
⎩⎪ ⎣3⎦ ⎣ 2 ⎦ ⎣ −4 ⎦ ⎣ −3⎦ ⎭⎪
P=[1 -2 3 -1; 3 2 -4 -3];
S=sim(net,P)
transferencia)
PRÁCTICAS DE LABORATORIO
SOLUCIÓN:
________________________________________________________________________________
Función que define la neurona tangente hiperbólica:
y=
e( 2 x1 − x2 +1.5) − e −( 2 x1 − x2 +1.5)
e( 2 x1 − x2 +1.5) + e −( 2 x1 − x2 +1.5)
Salidas de la red para cada uno de las entradas del conjunto C:
⎡1 ⎤
⎡ −2 ⎤
⎡3 ⎤
⎡ −1⎤
⎢3⎥ → 0.4621; ⎢ 2 ⎥ → −0.9998; ⎢ −4 ⎥ → 1.000; ⎢ −3⎥ → 0.9866
⎣ ⎦
⎣ ⎦
⎣ ⎦
⎣ ⎦
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 3
PERCEPTRÓN MULTICAPA: Predicción de la diabetes
Se va a diseñar un Perceptrón con una capa oculta de neuronas y una neurona de salida con el fin de
diagnosticar si una mujer es, o no, diabética, según las 7 primeras características de los datos Pima.
• Carga de datos
load pima
• Preprocesado de los datos
[pn,minp,maxp,tn,mint,maxt]=premnmx(P,T); % Se normalizan los datos en el intervalo [-1,1]
%[pn,meanp,stop,tn,meant,stdt]=prestd(P,T); Para tipificar los datos de entrada
• Creación del Perceptrón Multicapa con 7 sensores de entrada, 15 neuronas ocultas y una de salida
net=newff([minmax(pn))],[15 1],{'tansig’,’logsig’},’trainrp’);
% Tipos de aprendizaje: trainlm, trainbfg, trainrp, trainscg, traincbg, traincgf, traincgp, trainoss, traingdx
•
Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=20;
%Se muestran los resultados cada 50 iteraciones (épocas)
net.trainParam.lr=0.1;
%Tasa de aprendizaje
net.trainParam.epochs=500;
%Número máximo de iteraciones
net.trainParam.goal=0.05;
%Tolerancia de error como criterio de parada
net.trainParam.min_grad=0.0000001; %Valor mínimo del gradiente para parar
• Entrenamiento de la red
net1=train(net,pn,T);
• Salidas de la red
Sn=sim(net1,pn);
• Evaluación del error con los datos del conjunto de entrenamiento
ErrorAbsMedio=mae(T-Sn);
ErrorMaximo=max(max(T-Sn));
• Presentación de los parámetros de la red
W1=net.IW{1};W2=net.LW{2};b1=net.b{1};b2=net.b{2};
% S=postmnmx(Sn,mint,maxt): para recuperar la salida si la hubiéramos
% normalizado
SOLUCIÓN:
________________________________________________________________________________
Se obtiene una red con siete sensores de entrada, 15 neuronas en la capa oculta y una neurona de salida.
Se ha utilizado la regla de aprendizaje de retropropagación flexible. Se clasifican incorrectamente 4
patrones incorrectamente (2%).
Fig. Evolución del error durante el entrenamiento
Fig. 18. Datos proyectados en R
2
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 4
PERCEPTRÓN MULTICAPA: Clasificación de tres tipos de vino
Se va a diseñar un Perceptrón con una capa oculta de neuronas y tres neuronas de salida con el fin de
diagnosticar la clase de vino según 13 características que presenta, utilizando 59 patrones de
entrenamiento de vinos de la clase A, 71 de la clase B, y 48 de la clase C.
• Carga de datos
load pima
• Preprocesado de los datos
[pn,minp,maxp,tn,mint,maxt]=premnmx(P,T); % Normaliza los datos en [-1,1]
%[pn,meanp,stop,tn,meant,stdt]=prestd(P,T); Para tipificar los datos de entrada
• Creación del Perceptrón Multicapa con 13 sensores de entrada, 2 neuronas ocultas y 3 de salida:
net=newff([minmax(pn)],[2 3],{'tansig’,’logsig’},’trainlm’);
% Tipos de aprendizaje: trainlm, trainbfg, trainrp, trainscg, traincbg, traincgf, traincgp, trainoss, traingdx
• Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=20;
%Se muestran los resultados cada 50 iteraciones (épocas)
net.trainParam.lr=0.1;
%Tasa de aprendizaje
net.trainParam.epochs=300;
%Número máximo de iteraciones
net.trainParam.goal=0.001;
%Tolerancia de error como criterio de parada
net.trainParam.min_grad=0.00001; %Valor mínimo del gradiente para parar
• Entrenamiento de la red
net1=train(net,pn,T); % Utilizamos las mismas salidas T puesto que están normalizadas en el intervalo [0,1]
• Salidas de la red
Sn=sim(net1,pn);
• Evaluación del error con los datos del conjunto de entrenamiento
ErrorAbsMedio=mae(T-Sn);
ErrorMaximo=max(max(T-Sn));
• Presentación de los parámetros de la red y del error
W1=net.IW{1};W2=net.LW{2};b1=net.b{1};b2=net.b{2};
NúmClasifIncorrectas=sum(abs(round(Sn)-T));
SOLUCIÓN:
________________________________________________________________________________
Se obtiene una red con trece sensores de entrada, dos neuronas en la capa oculta y tres neurona de salida
(una para cada clase). Se ha utilizado la regla de aprendizaje de Levenverg-Marquardt y se han clasificado
correctamente los 178 patrones de entrenamiento.
Fig. 19. Evolución del error durante el entrenamiento
2
Fig. 20. Datos proyectados en R
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 5
PERCEPTRÓN MULTICAPA: Predicción de niveles de colesterol
Se va a diseñar un Perceptrón con una capa oculta de neuronas y tres neuronas de salida con el fin de
predecir los niveles de colesterol (ldl,hdl y vldl) según las medidas de 21 componentes espectrales.
• Carga de datos
load choles_all
• Preprocesado de los datos
[pn,minp,maxp,tn,mint,maxt]=premnmx(P,T); % Normaliza los datos en [-1,1]
%[pn,meanp,stop,tn,meant,stdt]=prestd(P,T); Para tipificar los datos de entrada
• Creación del Perceptrón Multicapa con 21 sensores de entrada, 15 neuronas ocultas y tres salida:
net=newff([minmax(pn)],[15 3],{'tansig’,’logsig’},’trainscg’);
• Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=50;
%Se muestran los resultados cada 50 iteraciones (épocas)
net.trainParam.lr=0.1;
%Tasa de aprendizaje
net.trainParam.epochs=1000;
%Número máximo de iteraciones
net.trainParam.goal=0.027;
%Tolerancia de error como criterio de parada
net.trainParam.min_grad=0.0000001; %Valor mínimo del gradiente para parar
• Entrenamiento de la red
net1=train(net,pn,tn);
• Salidas de la red
Sn=sim(net1,pn);
• Evaluación del error con los datos del conjunto de entrenamiento
ErrorAbsMedio=mae(tn-Sn); ErrorMaximo=max(max(tn-Sn));
• Presentación de los parámetros de la red, el error y las salidas sin normalizar
W1=net.IW{1};W2=net.LW{2};b1=net.b{1};b2=net.b{2};
mae(S-t); tasaerror=sum( abs( (tn-Sn)’) )/264
• Presentación de las salidas sin normalizar
S=postmnmx(Sn,mint,maxt):
• Análisis post-entrenamiento
[m,a,r]= postreg(Sn(3,:),tn(3,:)); % m=pendiente; a=término indep.; r=coef. correlación lineal
SOLUCIÓN:
________________________________________________________________________________
Se obtiene una red con 21 sensores de entrada, 15 neuronas en la capa oculta y 3 neuronas de salida (una
para cada clase). Se ha utilizado los datos normalizados y la regla de aprendizaje del gradiente conjugado
escalado. Los errores absolutos medios obtenidos para las tres neuronas de salida son 0.0837, 0.0938 y
0.1712, respectivamente. El coeficiente r vale sólo 0.635 para la tercera neurona de salida por lo que parece
que no está bien modelada.
Fig. 21. Evolución del error durante el entrenamiento
Fig. 22. Regresión lineal de la 3ª salida
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 6
PERCEPTRÓN MULTICAPA: Entrenamiento muestral y validación
Se va a diseñar un Perceptrón con una capa oculta de neuronas y tres neuronas de salida con el fin de
predecir lo mejor posible los niveles de colesterol (ldl,hdl y vldl) según las medidas de 21 componentes
espectrales, y evaluar su capacidad de generalización. Para ello se realiza una reducción de las variables
de entrada (algunas altamente correlacionadas entre sí) mediante el análisis de componentes principales,
de manera que las nuevas variables expliquen el 99.9% de la variación de los datos. Con las cuatro
primeras componentes principales se consigue dicho objetivo. Los valores de dichas componentes
(variables) constituyen las entradas del perceptrón multicapa que vamos a diseñar. Para evitar un
superajuste de los datos se va a utilizar el método de la parada temprana, es decir, dejaremos de entrenar
a la red tan pronto como el error de validación comience a incrementarse.
• Carga de datos
load choles_all
• Tipificación de los datos
[pn,meanp,stdp,tn,meant,stdt]=prestd(p,t); % Los nuevos datos tienen media cero y varianza uno
• Obtención de las Componentes Principales (CP) para eliminar redundancia
[ptrans,transMat]=prepca(pn,0.001); % Generación de la CP con el 99.9% de la variación total
[F,C]=size(ptrans);
• Partición de los datos en tres subconjuntos: Entrenamiento (50%), Validación (25%) y Prueba (25%)
ie=[1:4:C;3:4:C]; % Índice datos entrenamiento
iv=4:4:C;
% Índice datos validación
ip=2:4:C;
% Índice datos prueba
ptr=ptrans(:,ie);ttr=tn(:,ie);
val.P=ptrans(:,iv);val.T=tn(:,iv);
test.P=ptrans(:,ip);test.T=tn(:,ip);
• Creación de un Perceptrón Multicapa con 4 sensores de entrada, 10 neuronas ocultas y 3 de salida:
net=newff([minmax(ptr)],[10 3],{'tansig’,’purelin’},’trainlm’);
% Tipos de aprendizaje: trainlm, trainbfg, trainrp, trainscg, traincbg, traincgf, traincgp, trainoss, traingdx
• Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=50;
%Se muestran los resultados cada 50 iteraciones (épocas)
net.trainParam.lr=0.1;
%Tasa de aprendizaje
net.trainParam.epochs=1000;
%Número máximo de iteraciones
net.trainParam.goal=0.027;
%Tolerancia de error como criterio de parada
net.trainParam.min_grad=0.0000001; %Valor mínimo del gradiente para parar
• Entrenamiento de la red
[net,tr]=train(net,ptr,ttr,[],[],val,test);
• Trazado de los errores de entrenamiento, validación y prueba
plot(tr.epoch,tr.perf,tr.epoch,tr.vperf,tr.epoch,tr.tperf)
legend(‘Entrenamiento’,’Validación’,’Test’,-1);
ylabel(‘Error cuadratico’);xlabel(‘Epoca’)
• Análisis post-entrenamiento
Sn=sim(net,ptrans);
S=poststd(Sn,meant,stdt);
for i=1:3
figure(i)
[m(i),a(i),r(i)]= postreg(S(i,:),t(i,:));
% m=pendiente; a=término indep.; r=coef. correlación lineal
end
PRÁCTICAS DE LABORATORIO
SOLUCIÓN:
________________________________________________________________________________
Se obtiene un Perceptrón Multicapa con 4 sensores de entrada, 10 neuronas en la capa oculta y 3 neuronas
de salida (una para cada tipo de colesterol). Se han utilizado las 4 primeras componentes principales como
entradas, puesto que contienen el 99.9% de la variación de los datos, y la regla de aprendizaje de
Levenverg-Marquardt. El entrenamiento se ha parado después de 10 épocas puesto que el error cuadrático
para el conjunto de validación comenzaba a incrementarse (método de la parada temprana) y con ello se
trata de evitar un superajuste de la función.
Fig. 23. Evolución del error durante el entrenamiento
Con el análisis de la regresión lineal entre las respuestas (salidas) de la red y las salidas deseadas (metas)
se puede ver como las respuestas de las dos primeras neuronas de salida están altamente correlacionadas
con las salidas deseadas (r vale casi 0.9). Sin embargo, las respuestas de la tercera neurona de salida no
están altamente correlacionadas con las salidas deseadas, por lo que no están bien modelados los niveles
de colesterol vldl, bien porque se necesiten más neuronas en la capa oculta, porque se necesite utilizar otro
método diferente de parada, como los métodos de regularización, o porque no se pueden predecir bien
dichos niveles a partir de las variables de entrada.
Fig. 24. Regresión lineal de la 1ª salida
Fig. 25. Regresión lineal de la 2ª salida
Fig. 26. Regresión lineal de la 3ª salida
________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 7
PERCEPTRÓN MULTICAPA : Aproximación de funciones
Diseña un Perceptrón Multicapa con la regla de aprendizaje de Levenrg-Marquardt que aproxime la función
y = x 2 + 3 x en el intervalo [−4, 4]. Analiza los resultados estudiando el error del ajuste.
•
Conjunto de patrones de entrenamiento: Generación de datos
P=-4:0.5:4;
•
T=x.^2+3*x;
Representación gráfica de los datos
plot(P,T,’o’);title(‘Parábola’);hold on
•
Creación de un Perceptrón Multicapa con 3 neuronas en la primera capa oculta y una neurona de
salida con la regla de aprendizaje de Levenberg-Marquardt.
net=newff( [-4 4],[3 1], {'tansig','purelin'},'trainlm');
•
Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=10;
net.trainParam.lr=0.1;
net.trainParam.epochs=200;
net.trainParam.goal=0.0001;
net.trainParam.min_grad=0.00001;
•
%Se muestran los resultados cada 50 iteraciones (épocas)
%Tasa de aprendizaje
%Número máximo de iteraciones
%Tolerancia de error como criterio de parada
%Valor mínimo del gradiente para parar
Entrenamiento de la red
net1=train(net,P,T);
•
Salidas de la red
S=sim(net1,P);
•
Representaciones gráficas
plot(P,T);hold on;plot(P,s,’+g’);hold on
error=abs(T-S);plot(P,error);hold off
ErrorMaximo=max(max(T1-S))
•
Capacidad de generalización de la red
P1=-4:0.01:4; T1=P1.^2+3*P1; S1=sim(net1,P1);
plot(P1,S1);hold on; plot(P,T)
SOLUCIÓN:
_____________________________________________________________________________________
Se ha obtenido una red con un sensor de entrada, tres neuronas en la capa oculta y una neurona de salida.
Se ha utilizado la regla de aprendizaje de de Levenberg-Marquardt obteniéndose un error absoluto medio de
generalización igual a 0.009.
Fig. 27. Evolución del error
Fig. 28 . Salidas de la red
_____________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 8
PERCEPTRÓN MULTICAPA: Aproximación de funciones
Se va a aproximar la función humps de Matlab en el intervalo [0,2] mediante un Perceptrón Multicapa.
•
Conjunto de patrones de entrenamiento
P=0:0.05:2;
•
T=humps(P); % la función es y =
1
1
+
−6
2
( x − 3) + 0.01 (( x − 9) 2 + 0.04
Creación del Perceptrón Multicapa con una cada oculta de 9 neuronas y una neurona en la capa de
salida
net=newff( [0 2],[9 1], {'tansig','purelin'},'trainlm');
% Tipos de aprendizaje: trainlm, trainbfg, trainrp, trainscg, traincbg, traincgf, traincgp, trainoss, traingdx
•
Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=10;
net.trainParam.lr=0.01;
net.trainParam.epochs=200;
net.trainParam.goal=0.0001;
net.trainParam.min_grad=0.00001;
•
%Se muestran los resultados cada 50 iteraciones (épocas)
%Tasa de aprendizaje
%Número máximo de iteraciones
%Tolerancia de error como criterio de parada
%Valor mínimo del gradiente para parar
Entrenamiento de la red
net1=train(net,P,T);
•
Salidas de la red y comparación con las salidas deseadas
S=sim(net1,P);
error=abs(T-S);
•
Evaluación de la red con datos no usados en el entrenamiento
%Representación gráfica
plot(P,S,'+g',P,T,P,error); hold off
ErrorMaximo=max(max(T-S))
%Capacidad de generalización
P1=0:0.01:2; T1=P1.^2+3*P1;
S1=sim(net1,P1);
error=mae(T1-S1);
plot(P1,S1,P,T)
SOLUCIÓN:
______________________________________________________________________________________
Se ha obtenido una red con un sensor de entrada, nueve neuronas en la capa oculta y una neurona de
salida. Se ha utilizado la regla de aprendizaje de de Levenberg-Marquardt obteniéndose un error absoluto
máximo en el entrenamiento de 0.31 y un error medio de generalización igual a 0.09.
Fig. 29. Evolución del error
Fig. 30.Representación con datos P y T Fig. 31. Representación con datos P1 y T1
______________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 9
PERCEPTRÓN MULTICAPA: Aproximación de funciones
Se va a diseñar un Perceptrón Multicapa con la regla de aprendizaje de Levenberg-Marquardt que aproxima
la función z = cos( x) cos( y ) en el cuadrado [−2, 2]× [−2, 2]. Analiza los resultados estudiando el error del
ajuste.
•
Conjunto de patrones de entrenamiento: Generación de datos
x=-2:0.25:2; y=-2:0.25:2; z=cos(x)’*sin(y);
P=[x;y]; T=z;
•
Representación gráfica de los datos
mesh(x,y,z)
•
Creación de un Perceptrón Multicapa con 25 neuronas en la primera capa oculta y 17 en la
segunda con la regla de aprendizaje de Levenrg-Marquardt.
net=newff( [-2 2;-2 2],[25 17],{‘tansig’,’purelin’},’traingd’);
•
Especificación de los parámetros de aprendizaje de la red
net.trainParam.show=50;
net.trainParam.lr=0.05;
net.trainParam.epochs=300;
net.trainParam.goal=0.00001;
net.trainParam.min_grad=0.00001;
•
%Se muestran los resultados cada 50 iteraciones (épocas)
%Tasa de aprendizaje
%Número máximo de iteraciones
%Tolerancia de error como criterio de parada
%Valor mínimo del gradiente para parar
Entrenamiento de la red
net1=train(net,P,T);
gi=input(‘Pulse cualquier tecla …’);
•
Salidas de la red y representación gráfica con respecto a las entradas
S=sim(net1,P);
subplot(1,2,1); mesh(x,y,T);
subplot(1,2,2); mesh(x,y,S)
•
Evaluación del error con los datos del conjunto de entrenamiento
mesh(x,y,S-T)
xlabel('eje X');ylabel('eje Y');zlabel('Error')
title('Superficie de error')
SOLUCIÓN:
______________________________________________________________________________________
Se ha obtenido una red con dos sensores de entrada, 25 neuronas en la capa oculta y
diecisiete neuronas en la capa de salida. Se ha utilizado la regla de aprendizaje de de Levenberg-Marquardt
obteniéndose un error absoluto máximo en el entrenamiento igual a 0.009.
Fig. 32. Representación gráfica de z
Fig. 33. Evolución del error
Fig. 34. Superficie de error
_____________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
Redes neuronales con Funciones de Base Radial
17-05-2007
________________________________________________________________________
PRÁCTICA 1
Ajuste de funciones
Diseña un Red Neuronal con Funciones de Base Radial que aproxime la función y = x 2 + 3 x en el intervalo
[−4, 4]. Analiza los resultados estudiando el error del ajuste.
•
Conjunto de patrones de entrenamiento: Generación de datos
x=-4:0.1:4;
P=x; T=y;
•
y=x.^2+3*x;
Representación gráfica de los datos
plot(P,T,’o’)
grid,xlabel(‘eje X’);ylabel(‘eje Y’)
title(‘Parábola’);
•
Creación de una red neuronal con Funciones de Base Radial.
net1=newrb(P,T,0.01);
•
Salidas de la red y representación gráfica del error
a=sim(net1,P);
plot(P,a-T,P,T)
•
Evaluación del error con otro conjunto de datos
x1=-4:0.01:4;
y1=x.^2+3*x;
P1=x1;T1=y1 ;
a1=sim(net1,P1);
plot(P,a1-T1,P1,T1)
PRÁCTICAS DE LABORATORIO
PRÁCTICA 2
Ajuste de funciones
Ajusta la función humps de Matlab en el intervalo [0,2] mediante un Red con Funciones de Base Radial.
• Función de Base Radial
•
p=-3:0.01:3;
a=radbas(p);
plot(p,a)
•
Conjunto de patrones de entrenamiento
x=0:0.05:2; y=humps(x);
P=x; T=y;
plot(P,T,’x’)
grid; xlabel(‘Tiempo(s)’);ylabel(‘salida’);title(‘función humps’)
•
Creación de una red neuronal con funciones de base radial de la forma más simple
net1=newrb(P,T);
•
Salidas de la red y representación gráficas de los errores
a=sim(net1,P);
plot(P,T-a,P,T)
•
Evaluación de la red con datos no usados en el entrenamiento
x1=0:0.01:2; P1=x1; y1=humps(x1);T1=y1;
a1=sim(net1,P1);
plot(P1,a1,P1,T1,P,T)
•
Comentario: la aproximación no es buena. Los valores por defecto de los dos parámetros de la red
no son adecuados (objetivo del error = 0.0 y spread = 1.0)
•
Elección de parámetros
goal=0.02; spread=0.1;
net1=newrb(P,T,goal,spread);
•
Salidas de la red y representación gráfica de los errores
a=sim(net1,P);
plot(P,T-a,P,T)
xlabet(‘Tiempo(s)’) ;ylabel(‘Salidas de la red y errores’)
title(‘Aproximación de la Función Humps por Redes RBF)
PRÁCTICAS DE LABORATORIO
Redes Neuronales Autoorganizadas
31-05-2007
________________________________________________________________________
PRÁCTICA 1
Redes neuronales competitivas no supervisadas: Formación de grupos
Se va a diseñar una red neuronal competitiva para agrupar 38 virus en 4 clases de acuerdo al parecido que
según 18 características de los mismos, de manera que los patrones dentro de cada clase sean lo más
similares posible entre sí y se va a determinar el patrón prototipo de cada clase.
• Carga de datos
load virus
•
Creación de una red neuronal competitiva
net=newc([minmax(p)],4);
• Entrenamiento de la red
net.trainParam.epochs = 500 ;
net = train(net,p);
• Simulación de las salidas de las red
S=sim(net,p); % asigna cada patrón de entrada a su grupo
c=vec2ind(S); % vector de las neuronas activadas para cada patrón
• Pesos sinápticos de la red:
w=net.IW{1}
b=net.b{1}
SOLUCIÓN:
______________________________________________________________________________________
La red está constituida por 18 sensores de entrada y 4 neuronas de salida. Después del proceso de
entrenamiento no supervisado, basado en las 18 características de los 38 virus utilizados, se obtiene como
salida de la red para cada virus el grupo al que este pertenece, que viene especificado por la neurona de
salida que se ha activado. Las neuronas de salida activadas para cada uno de los 38 virus ha sido,
respectivamente,
4
4
2
4
3
3
3
3
1
3
1
3
2
1
4
1
2
1
2
1
4
1
4
1
2
1
3
3
3
3
3
3
2
2
3
2
2
4
Fig. 35. Representación de los datos de virus en sus dos primeras componentes principales
______________________________________________________________________________________
ver democ1
PRÁCTICAS DE LABORATORIO
PRÁCTICA 2
Redes neuronales Autoorganizadas: Representación espacial de datos
Los datos IRIS constan de 4 características de hojas de lirios (ancho y largo de sus pétalos y sépalos)
correspondientes a tres variedades de lirios: virginia, setosa y versicolor. Corresponden a 50 hojas de cada
variedad. Se va a diseñar una red autoorganizada que permita asociar cada hoja a una neurona (punto)
colocada sobre una cuadrícula de manera que las hojas más parecidas estén representadas por neuronas
próximas en la rejilla.
• Carga de datos
load iris
• Creación de una red autoorganizada
net = newsom([minmax(p)],[4 4],'gridtop','dist',0.9,200,0.1,1);
% crea una SOM sobre una cuadrícula [4×4] con forma 'griptop', ‘hextop’ o
%‘randtop’; distancia ('dist', 'linkdist','mandist'); tasa de aprendizaje
% en la fase de ordenación; Nº de épocas fase de ordenación; tasa de
% aprendizaje fase de ajuste; distancia de vecindad fase de ajuste
• Entrenamiento de la red
% net.trainParam.epochs = 400 ; % net.trainParam.order_steps = 200 ;
% net.trainParam.show = 50 ;
% net.trainParam.tune_nd=1;
% Distancia de vecindad en la fase de ajuste
% net.trainParam.order_lr=0.9;
% Tasa de aprendizaje en la fase de ordenación
% net.trainParam.tune_lr=0.1;
% Tasa de aprendizaje en la fase de ajuste
net = train(net,p);
• Pesos y Gráfico de la red entrenada
w = net.iw{1,1}; d = net.layers{1}.distances; % w= pesos y d = distancias entre neuronas
plotsom(w,d)
• Simulación de las salidas de las red
S=sim(net,p); % asigna cada patrón de entrada a una neurona
c=vec2ind(S); % vector de las neuronas activadas para cada patrón
SOLUCIÓN:
______________________________________________________________________________________
Se utiliza una cuadrícula 3×2 como espacio neuronal. Así, la red autoorganizada está constituida por 6
neuronas de salida y 4 sensores de entrada. Después del proceso de entrenamiento no supervisado se
obtienen los pesos sinápticos de la red. Las 50 primeras hojas (virginia) las asigna a la neurona 5; las 50
siguientes (setosa) las asigna mayoritariamente (26) a la neurona 4 (13 a la 2 y 11 a la 3). Las 50 últimas
hojas (versicolor) las asigna mayoritariamente (35) a la neurona 1 (14 a la 2 y sólo 1 a la 4). Así, las
neuronas 3 y 4 recogen 37 hojas de de la variedad setosa. La neurona 2 recoge 13 hojas de la variedad
setosa y 14 de la variedad versicolor (zona de solapamiento). A continuación se muestran los resultados
gráficos para una cuadrícula 3×2 y 4×4:
○5 A
○ 3B
○1C
○6
○4B
○ 2 BC
○13C
○14 B
○15 A
○15 A
○ 9C
○ 5C
○10C
○ 6 BC
○11
○7B
○12 A
○8
○1C
○ 2B
○3B
○ 4B
Fig. 36. Topología del espacio neuronal y representación gráfica de las neuronas según sus pesos
______________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 3
Redes neuronales Autoorganizadas: Representación de datos sobre curvas
Se van a proyectar puntos aleatorios del plano sobre una curva de manera que se conserve, dentro de lo
posible, la topología espacial. Es decir, que puntos próximos en el espacio tengan también próximas sus
proyecciones.
• Carga de datos
x=rand(1,20);
y=rand(1,20);
plot(x,y,'ok')
• Creación de una red autoorganizada
net = newsom([minmax(p)],[4 4],'hextop','dist',0.9,200,0.1,1);
% crea una SOM sobre una cuadrícula [4×4] con forma 'griptop', ‘hextop’ o
%‘randtop’; distancia ('dist', 'linkdist','mandist'); tasa de aprendizaje
% en la fase de ordenación; Nº de épocas fase de ordenación; tasa de
% aprendizaje fase de ajuste; distancia de vecindad fase de ajuste
• Entrenamiento de la red
% net.trainParam.epochs = 400 ; % net.trainParam.order_steps = 200 ;
% net.trainParam.show = 50 ;
% net.trainParam.tune_nd=1;
% Distancia de vecindad en la fase de ajuste
% net.trainParam.order_lr=0.9;
% Tasa de aprendizaje en la fase de ordenación
% net.trainParam.tune_lr=0.1;
% Tasa de aprendizaje en la fase de ajuste
net = train(net,p);
• Pesos y Gráfico de la red entrenada
w = net.iw{1,1}; d = net.layers{1}.distances; % w= pesos y d = distancias entre neuronas
plotsom(w,d)
• Simulación de las salidas de las red
S=sim(net,p); % asigna cada patrón de entrada a una neurona
c=vec2ind(S); % vector de las neuronas activadas para cada patrón
SOLUCIÓN:
______________________________________________________________________________________
Se ha utilizado una rejilla lineal 1×20 como espacio neuronal. Así, la red autoorganizada está constituida por
20 neuronas de salida y 2 sensores de entrada. Después del proceso de entrenamiento no supervisado se
obtienen los pesos sinápticos de la red que se representan por puntos rojos en la gráfica siguiente. Los
puntos aleatorios (patrones) se representan por el símbolo ‘×’. La forma que adopta la curva generada por
las neuronas nos da idea de cómo ha quedadon colocados los puntos aleatorios sobre el cuadrado unidad.
Cada punto generado (patrón) es asignado (proyectado) por la red a la neurona más próxima. Con la curva
generada se intenta conservar la topología de los puntos en R2.
Fig. 37. Representación gráfica de las neuronas según sus pesos sinápticos
______________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
PRÁCTICA 4
Redes neuronales competitivas no supervisadas: Clasificación
Se va construir una red neuronal competitiva con aprendizaje supervisado para predecir si una persona es
diabética a partir de 7 características personales (datos Pima).
• Carga de datos
load pima % Pasamos las salidas deseadas de 1 y 0
for i=1:200
if T(i)==0,
T(i)=2;
end
end
a 1 y 2;
T=ind2vec(T); % Transformamos los índices en vecotres
% salidas = full(T); %para ver los vectores en forma normal
• Creación de una red red competitiva con aprendizaje supervisado (LVQ)
net=newlvq([minmax(P)],60,[.34 .66],0.1,'learnlv1'); %Neuronas ocultas,
% poercentaje de neuronas ocultas asignadas 1ª clase;
net.IW{1,1}
• Entrenamiento de la red
net.trainParam.epochs = 300
net = train(net,P,T);
• Simulación de las salidas de las red y evaluación del error
S=sim(net,P);
Sc=vec2ind(S); %Transforma los vectores en índices
Tc=vec2ind(T);
error=sum(abs(Tc-Sc)) % Nº de clasificaciones incorrectas
SOLUCIÓN:
______________________________________________________________________________________
La red está constituida por 7 sensores de entrada, una capa oculta con 60 neuronas y dos neuronas de salida.
Después del proceso de entrenamiento de la red con 200 patrones (68 con diabetes y 132 sin diabetes), la red
clasifica incorrectamente a 15 de las no diabéticas y a 16 de las diabéticas.
Fig. 38. Representación gráfica de la evolución del error
______________________________________________________________________________________
PRÁCTICAS DE LABORATORIO
Redes Neuronales Recurrentes y Dinámicas: Red de Elman
31-05-2007
________________________________________________________________________
PRÁCTICA 1
Red de Elman: Predicción en el tiempo
Se va a diseñar una red neuronal de Elman que encuentra las respuestas correctas a una secuencia de 20
patrones que son cero o uno (binarios). La salida deseada es binaria y vale cero, excepto cuando la
entrada actual y la anterior son iguales a 1.
• Generación de datos
P = round(rand(1,20));
T = [0 (P(1:end-1)+P(2:end) == 2)];
• Conversión de los datos a un array celular
Pseq = con2seq(P);
Tseq = con2seq(T);
• Creación de la red de Elman
net=newelm([minmax(P)],[2 1],{'tansig','purelin'},'traingdx','learngdm','mae');
• Entrenamiento de la red
net.trainParam.epochs = 200;
net = train(net,Pseq,Tseq);
• Simulación de la red y evaluación del error
S=sim(net,Pseq);
Sq=seq2con(S);
% Convierte S a secuencia numérica
Y=Sq{1,1};
dife=T-Y
SOLUCIÓN:
______________________________________________________________________________________
Los patrones de entrenamiento son:
P =[ 0
T =[ 0
0
0
1
0
1
1
1
1
1
1
0
0
1
0
1
1
1
1
0
0
1
0
0
0
0
0
0
0
1
0
1
1
0
0
1
0
1 ]
1 ]
La red está constituida por un sensor de entrada, una capa oculta con 2 neuronas y una neurona de salida.
Después del proceso de entrenamiento de la red los errores de predicción en los 20 patrones son:
[ -0.0335
-0.0206 -0.5046 0.2065 0.1783 0.1833 -0.0486 -0.1675
-4
-0.0117 -0.1684 0.2083 -0.0572 -0.1675 0.2083 ] ×10
0.2083
0.1781 -0.0478 -0.1675 -0.0284 -0.1302
Fig. 39. Representación gráfica de la evolución del error
______________________________________________________________________________________