Universidad Nacional de Ingeniera

FACULTAD DE INGENIERIA MECANICA

REDES NEURONALES MULTICAPA

TERCER INFORME

Curso:

Inteligencia Artificial MT616

Profesor:

Ricardo Bustinza

Alumnos:

Morales Luna, Giorgio

Lima 2014

(20104509A)

Tabla de contenido
1.

2.

3.

PRIMER PROBLEMA PROPUESTO ................................................................................................ 3

1.1.

Modelo ARX ......................................................................................................................... 3

1.2.

Generacin de data ............................................................................................................. 4

1.3.

Entrenamiento de la red neuronal sin TRN ......................................................................... 5

1.4.

Evaluacin sin TRN .............................................................................................................. 7

1.5.

Entrenamiento de la red neuronal con TRN ....................................................................... 9

1.6.

Evaluacin con TRN ............................................................................................................. 9

SEGUNDO PROBLEMA PROPUESTO .......................................................................................... 11

2.1.

Modelamiento ................................................................................................................... 11

2.2.

Algoritmo de aprendizaje .................................................................................................. 12

2.3.

Algoritmo de aprendizaje .................................................................................................. 13

TERCER PROBLEMA PROPUESTO .............................................................................................. 15

3.1.

Enunciado .......................................................................................................................... 15

3.2.

Adquisicin de datos ......................................................................................................... 15

3.3.

Relacin R-T ....................................................................................................................... 16

3.4.

Algoritmo de aprendizaje .................................................................................................. 17

3.4.1.

Sin TRN .......................................................................................................................... 18

3.4.2.

Evaluacin sin TRN ........................................................................................................ 20

3.4.3.

Comentario a la evaluacin sin TRN .............................................................................. 21

3.4.4.

Algoritmo con TRN ........................................................................................................ 24

REDES NEURONALES MULTICAPA

1. PRIMER PROBLEMA PROPUESTO
En base al esquema de Simulink de la Figura 1.1 se ha de obtener una data que
involucre los datos de entrada, salida y tiempo del sistema de control en lazo abierto:

Figura 1.1.

1.1.

Modelo ARX

Un sistema de control de segundo orden tiene la forma siguiente:

( )
( )
A partir de dicha funcin de transferencia se calcula la ecuacin diferencial
equivalente:

Usando la discretizacin backward se tienen las relaciones:

( )

( )

Reemplazando las relaciones en la ecuacin anterior se obtiene el modelo deseado,

el cual puede tomar dos formas:

Modelo Estndar I:

( )

Modelo Estndar II:

( )

En el problema propuesto se har uso de Modelo Estndar II, de modo que las
constantes K1,K2,K3 y K4 sern desconocidas, y(n) ser la salida de la red y los dems
trminos pertenecern al vector de entrada del sistema.

1.2.

Generacin de data

La data se genera mediante el diagrama de bloques de Simulink mostrado en la

Figura 1.1. Toda la data generada se guarda en el vector Salidas, cuya primera columna
equivale a los datos de salida (y al vector Salida); la segunda equivale a los datos de
entrada (y al vector Entrada) y la tercera, a los datos de tiempo. El siguiente cdigo
ilustra lo antes mencionado:
y=Salidas(:,1);
u=Salidas(:,2);
t=Salidas(:,3);
plot(t,u,t,y)

Figura 1.2.
Ahora, para separar las entradas del sistema como se mencion en la seccin
anterior, se crean vectores a partir de los ya existentes con intercalamiento distinto para
representar una determinada variable en uno o dos tiempos anteriores, esto es:

y=length(Salida(:,1));
e1=Entrada(2:1:(y-1));
e2=Entrada(1:1:(y-2));
s1=Salida(2:1:(y-1));
s2=Salida(1:1:(y-2));
s3=Salida(3:1:(y));
Inp=[ e1 e2 s1 s2];
entradas=Inp';

%u(k-1)
%u(k-2)
%y(k-1)
%y(k-2)
%y(k)
%vector de datos de entrada (black box)

En simulink esto es representado haciendo uso de los Unit Delay (z^-1) y un periodo
de muestreo Ts=0.05, de modo que:
(

( )

( )

grficamente esto se representa como:

Figura 1.3.
Estos cuatro valores, para cada unidad de tiempo, sern una entrada para la red
neuronal.

1.3.

Entrenamiento de la red neuronal sin TRN

Se har uso de una red neuronal multicapa con 4 entradas, 10 neuronas en la capa
oculta y una neurona en la capa de salida. La estructura es similar a la mostrada en la
seccin 4.5. El primer paso es definir las condiciones iniciales para los pesos y bias de
cada capa:
%Condiciones iniciales
W=randn(1,10); %pesos 1ra capa
W0=randn(1,1);%bias 1ra capa
V=randn(10,4); %pesos 2da capa
V0=randn(10,1);%bias 2da capa

Luego, se define el coeficiente de aprendizaje alpha=0.04 y un nmero de pocas

igual a 200. Finalmente se ejecuta el algoritmo de aprendizaje de la misma manera que se
explicar en las secciones 4.4.1 y 4.4.3. Como alcance, se presenta el cdigo completo
del entrenamiento de la red:
for k=1:N %k:Nro de pasada
for i=1:length(P)
Z_inj=V*P(:,i)+V0; %salida capa oculta
Zj=purelin(Z_inj); %salida usando fcn purelin
Y_ink=W*Zj+W0; %salida capa final
Yk=purelin(Y_ink) %salida usando fcn purelin
T(:,i)
error=T(:,i)-Yk
%error de la red
%BACKPROPAGATION
%Clculo de los deltas
delta_1=error; %delta de la ltima capa
delta_inj=W*delta_1; %deltas de la capa oculta
delta_j=(delta_inj);
%Actualizacin de pesos y bias
dW=alpha*(Zj*delta_1)';
dW0=alpha*delta_1';
W=W+dW;
W0=W0+dW0;
dV=alpha*(P(:,i)*delta_j)';
dV0=alpha*delta_j';
V=V+dV;
V0=V0+dV0;
j=j+1;
E(1,j)=error;
end
end

El resultado final de los pesos y bias luego del entrenamiento es el siguiente:

W=
-0.2048 -0.4038 -0.1874 -1.2073

0.8662 -0.4523

0.1147

0.1092

W0 = -0.7879
V=

1.1813

-0.2045

1.9392 -1.8041 -0.6217

0.1547 -0.1981

0.6646

-0.1887 -0.5504

0.2941

1.6577

0.2771 -0.4985

0.1291 -0.5678

1.1188 -0.2848

0.6379 -0.8160

0.0207

0.2937

0.1084

1.3686 -0.8667 -0.0477

-0.8443

1.1970

-0.4258

0.4949 -1.0763

0.5728

-0.1960 -0.2891 -0.2448

2.1896

-0.5494

1.6229

1.7263 -0.5695

0.3061 -0.4561

V0' =
-0.6655 -0.9319

1.4.

0.2068

0.3153

1.2907

0.2778 -0.9633 -0.8849

1.1625 -0.3892

Evaluacin sin TRN

Ya se tiene entrenada la red, ahora se desea probar la respuesta ante una entrada
distinta, por ejemplo un step. En ese sentido se usa el mismo diagrama de bloques de la
Figura 1.1 unido al de la Figura 1.3, a este nuevo diagrama se le adicionar un cierto
nmero de operaciones matriciales que afectarn a las entradas del sistema con el fin de
obtener la salida correspondiente a la red neuronal entrenada. Pero primero se debe tener
en cuenta que para calcular la salida de la red neuronal, la operacin que se debe hacer
es la siguiente:
Z_inj=V*Entrada+V0; %salida capa oculta
Zj=purelin(Z_inj); %salida usando fcn purelin
Y_ink=W*Zj+W0; %salida capa final
Yk=purelin(Y_ink) %salida usando fcn purelin

El cdigo anterior se adiciona al diagrama de bloques y resulta:

Figura 1.4.
Por ltimo, el scope1 muestra la comparacin entre la salida real y la estimada segn
la red neuronal:

Figura 1.5. Respuesta real y estimada

Se puede notar un transitorio al inicio del step, ste puede ser explicado ya que al
analizar la evaluacin del error a lo largo del entrenamiento, existe un mayor valor de error
para los valores correspondientes a las primeras entradas entradas del sistema; o sea, en
los tiempos iniciales luego de ser aplicada algn escaln, como se observa en la Figura
1.6.

i=1

i=length(P)

Figura 1.5. Error vs N de pasada

1.5.

Entrenamiento de la red neuronal con TRN

Al utilizar el toolbox de redes neuronales de Matlab, slo se necesita crear la red con
el comando newff, especificar el nmero de neuronas en cada capa, la funcin de
activacin a usar (en este caso se har una variacin y se trabajarn con una funcin
tansig para la capa oculta y purelin, para la capa de salida), el nmero de pocas mximo,
la tasa de aprendizaje, etc:
NO=10; %neuronas en la capa oculta
NS=1;
%neuronas en la capa de salida
red=newff(minmax(entradas),[NO NS],{'tansig','purelin'},'trainlm');
red.trainParam.show=20;
red.trainParam.epochs=100;
red.trainParam.goal=0.0000001;
red.trainParam.lr=0.01;

Luego de creada la red sta puede ser entrenada especificando el vector target (s3
en este caso):
red=train(red,entradas,s3');
Ts=0.05;
gensim(red,Ts);

De esta manera se obtiene el bloque de Simulink de la red ya entrenada y con los

valores de pesos y bias finales.

1.6.

Evaluacin con TRN

Al igual que en la seccin 1.4 se aade la red neuronal al sistema, pero al contar con
el bloque compacto de dicha red neuronal ya no es necesario especificar todas las
operaciones matriciales que involucra el paso de capa a capa:

Figura 1.6.
El resultado del scope1 ser la comparacin entre la salida real y la estimada:

Figura 1.7.
Se puede decir que el caso de la Figura 1.5 (sin TRN) presenta mayor mimetismo que
el de la Figura 1.7 (con TRN) slo debido a la combinacin de funciones que se eligi. Por
lo tanto se concluye que para este problema en particular, la mejor opcin para ambas
funciones de activacin es purelin.

2. SEGUNDO PROBLEMA PROPUESTO

Considere el conjunto de patrones:
(

)(
(

)(
)(

)(
)(

)(

)(

)(

)(

)(
)(

)
)

Entrene la red MLP de modo que resuelva la clasificacin de los patrones para las
tres clases.

Clase 3

Clase 1

Clase 1

Clase 2

Clase 3

Figura 2.1.

2.1.

Modelamiento

Para el sistema se considerar como entrada a cada par de puntos, de modo que el
vector de entrada P es:
P=[-3 -2 -2 2 2 4 -1
0 -1 1 1 -1 0 0

0
0.5

0
-0.5

1 0 0
0 -2 -1

0
1

0
2];

Luego, para diferenciar las 3 clases propuestas se necesita de dos neuronas en la

capa de salida y dos neuronas en la capa oculta debido a la forma en que estn
separadas las clases; por ejemplo, la clase 1 necesita dos delimitadores, al igual que la
clase 3, en estos casos se puede hacer la analoga con el problema XOR para entender
por qu necesita dos neuronas en la capa oculta.

Como ya se decidi usar dos neuronas en la capa de salida, ahora se tiene que elegir
el tipo de salida que corresponde a cada clase, esto es elegir la combinacin de T1 y T2
(salidas) corresponde a cada clase. Para ello cabe resaltar que a la salida del sistema se
har uso de una funcin hardlim para normalizar los resultados. Entonces, las
combinaciones elegidas son:

Clase 1
Clase 2
Clase 3

2.2.

T1

T2

0
0

1
0

Algoritmo de aprendizaje

El algoritmo tendr el mismo principio que el usado en la seccin 1.3, con ciertas
modificaciones debidas al cambio en el nmero de salidas. Primero, se asignan
condiciones iniciales a los vectores de pesos y bias, considerando que sta vez el nmero
de filas del vector W ser igual a 2. Para el entrenamiento se eleigi un alpha igual a 0.02
y un nmero de pocas de 35000.
W=randn(2,2); %pesos 1ra capa
W0=randn(1);%bias 1ra capa
V=randn(2,2); %pesos 2da capa
V0=randn(2,1);%bias 2da capa

Como se dijo, el algoritmo ser esencialmente el mismo, pero es al momento de

calcular los gradientes que se necesita hacer algunos cambios. En primera instancia ya
no habr slo un gradiente (delta_1, debido a la primera salida Yk(1)) sino 2, para ello se
agrega la variable delta_2 en funcin a Yk(2), tal que:
%Clculo de los deltas
%delta de la ltima capa
delta_1=(error(1)).*((1+Yk(1)).*(1-Yk(1)))';
delta_2=(error(2)).*((1+Yk(2)).*(1-Yk(2)))';

El siguiente paso es la actualizacin de los deltas de la capa oculta. Recordando el

concepto, para cada neurona, su delta es calculado segn:

donde
es el delta para una neurona j, el nmero de neuronas en la capa de salida,
es el gradiente de la neurona k de la capa superior y w_jk el peso de dicha neurona de
ndice j.k.

Concluyendo, el delta y el gradiente asociado a una neurona en la capa oculta se

calculan con el siguiente cdigo:
%deltas de la capa oculta
delta_inj=W(1,:)*delta_1+W(2,:)*delta_2;
delta_j=((1+Zj).*(1-Zj))'.*(delta_inj);

Por ltimo, la actualizacin de los pesos de las neuronas de la ltima capa tambin
cambiar a la siguiente forma:
dW=alpha*(Zj*[delta_1 delta_2])';
dW0=alpha*[delta_1 delta_2]';

La actualizacin de los pesos y bias de la capa oculta mantendr su forma y el

algoritmo en general tambin.

2.3.

Algoritmo de aprendizaje

Luego de entrenada la red, se procede a ingresar algn dato para evaluar la clase a
la que pertenece. Para ello se usa el siguiente cdigo:
Z_inj=V*[resp1;resp2]+V0;
Zj=tanh(Z_inj);

%salida capa oculta

Y_ink=W*Zj+W0; %salida capa final

Yk=round(tanh(Y_ink)) %salida (tambien puede usarse HARDLIM)

Donde resp1 y resp2 son las coordenadas X e Y que el usuario ingresa desde un
input en la ventana de Matlab. Finalmente, teniendo los valores del vector de salida se
procede a evaluar la clase a la que corresponde dicha salida en base a la tabla mostrada
en la seccin 2.1. A continuacin se muestran algunos resultados:

Figura 2.2.
Cabe resaltar que el sistema no logra estabilizarse con un error en todas las
ejecuciones del algoritmo, por lo que el sistema no siempre clasifica del modo deseado,
ya que un error de 0.2 o 0.1 unido a la funcin hardlim (o round) es decisivo a la hora de
clasificar coordenadas que estn cerca del lmite. El desempeo del sistema depender
principalmente de los valores de los pesos iniciales; en caso de que se elijan valores
aleatorios, estos debern ser muy pequeos para un mejor desempeo.

3. TERCER PROBLEMA PROPUESTO

3.1. Enunciado
Se tiene un termistor NTC y una DAQ 6008 con los cuales se pretende realizar
una adquisicin de datos de temperatura. El objetivo es que la data adquirida sirva para
obtener pares de Resistencia-Temperatura, los cuales sern introducidos a una red
neuronal con el objetivo de que sta aprenda la relacin existente entre resistencia y
temperatura para que luego sea capaz de calcular la respuesta aproximada de
temperatura ante una entrada de resistencia distinta a los datos proporcionados
inicialmente.

Figura 4.1. Termistor Vishay NTCLE100E3

3.2. Adquisicin de datos

Para la experiencia se usa un termistor de 10Kohms a temperatura ambiente y el
circuito a usar tiene la siguiente forma:
2.5V

R1
10K

R
10K25C

Figura 4.2. Circuito para la adquisicin

Se leer el voltaje de la resistencia R usando la DAQ. Sin embargo, no es la
informacin de voltaje la que interesa, sino la resistencia, por lo que se usar la siguiente
ecuacin:

donde

. Despejando se obtiene:

Los datos se adquirirn mediante una interfaz de Labview, haciendo uso del
paquete DAQ-Assistant. Se tomarn 45 muestras de voltaje cada medio segundo, usando
la ecuacin anterior se calcular el correspondiente valor de resistencia; dicha data se
guardar en el archivo datantc3.lvm (R vs tiempo). Para que la lectura abarque la mayor
cantidad de valores de resistencia posibles se calentar lentamente el termistor con un
encendedor. Debido a la naturaleza del NTC, la resistencia inicial ser mayor a 10K
(11Kohms para precisar, ya que la temperatura ambiente estuvo por debajo de los 25 C)
y disminuir a medida que el termistor se caliente.

Figura 4.3. Interfaz de Labview

3.3. Relacin R-T

Una vez obtenida la relacin de R vs tiempo se procede a obtener la relacin entre
resistencia y temperatura, para ello se har uso de los datos proporcionados por el
fabricante del termistor en el datasheet y la ecuacin sugerida.

[ (

)]

donde, segn la tabla anterior,

Ahora se har uso de la data obtenida en la seccin anterior para calcular la

temperatura correspondiente a cada lectura. Para ello se utiliza el siguiente script de
Matlab y se guardar la nueva data en el archivo data_RTt.lvm:
load datantc3.lvm;
TR=298;
beta=3977;
R25=10;
V1=2.5;
for i=1:length(datantc3(:,2))
T(i,1)=(1/TR+(1/beta)*log(datantc3(i,2)/R25))^-1;
end
datos=[datantc3(:,2) T datantc3(:,1)];
save data_RTt.lvm datos -ascii -tabs

Con esta nueva data es posible obtener las grficas de RvsT, R vs tiempo y T vs
tiempo:

Figura 4.4.

3.4. Algoritmo de aprendizaje

Ya con la data R-T, se considerar como entrada al sistema a la temperatura y
como salida a la resistencia. Para el aprendizaje se usar una red neuronal multicapa (1
entrada, una capa oculta de 7 neuronas y una capa de salida de 1 neurona) y el algoritmo
de aprendizaje Backpropagation,

V0(1)
V(1)

V0(2)
V(2)

V0(3)
V(3)

W0

Yk

V0(4)

V(4)

W(1x7)

V0(5)
V(5)

V0(6)
V(6)

V0(7)
V(7)

Figura 4.5. Esquema de la red neuronal usada.

3.4.1. Sin TRN

Se procede ahora a escribir el cdigo de aprendizaje sin hacer uso del toolbox de
redes neuronales (TRN) de Matlab. En ese sentido, se declaran las condiciones iniciales
de los pesos (valores aleatorios pequeos): V(7x1) capa oculta- y W(1x7) capa final y
de los bias: V0(7x1) capa oculta- y W0(1) capa final. Adicionalmente se considerar un
factor de aprendizaje igual a 0.1 y nmero de pocas igual a 50000:
W=randn(1,7); %pesos 1ra capa
W0=randn(1);%bias 1ra capa
V=randn(7,1); %pesos 2da capa
V0=randn(7,1);%bias 2da capa
alpha=0.1;
%coef. de aprendizaje
N=50000;
%Nro. de pocas

En este punto cabe sealar que al haber elegido a la temperatura (T) como
entrada y a la funcin sigmoidal como su funcin de activacin, es necesario limitar el
vector de entrada (P) a valores entre 0 y 1, ya que de lo contrario la salida de la funcin
de activacin sera siempre igual a 1. En ese sentido, previamente se tuvo que haber
definido al vector como: P=T'/max(T), de modo que los valores de entrada no excedan a
1. Por otro lado, para la funcin de activacin de la capa de salida se eligi una funcin
purelin debido a que los valores de salida estn entre 0 y 12 y es ms fcil manejar ste
intervalo que uno limitado entre 0 y 1. De modo que para elegir el vector target (T1)
simplemente se lo defini como: T1=R'.

A continuacin se explica la lgica que sigue el algoritmo para cada pasada

(poca). Dadas las condiciones iniciales se elige una entrada (entrada i) para la cual se
calculan todas las salidas de cada neurona. Para cada capa dichas salidas (ordenadas en
un vector) son calculadas obedeciendo a la estructura mostrada en la Figura 4.5; a dicha
salida se deber aplicar la funcin de activacin correspondiente a la capa que pertenece,
mediante la relacin siguiente:
Z_inj=V*P(:,i)+V0;
Zj=1./(1+exp(-Z_inj));
Y_ink=W*Zj+W0;
Yk=purelin(Y_ink)

%salida capa oculta

%salida usando fcn sigmoidal
%salida capa final
%salida usando fcn sigmoidal

Adicionalmente se evala el error comparando la salida Yk y el target (T1(:,i))

correspondiente a la entrada que se eligi:
error=T1(:,i)-Yk

Una vez que se conoce el error se procede a calcular los gradientes (deltas)
correspondientes a cada neurona. Para la capa de salida (de una sola neurona) dicho
delta se calculara como:
(

pero en vista de que la funcin de activacin de la capa de salida es purelin, su derivada

sera igual a 1 y
sera igual a:

Del mismo modo se evala los gradientes de la capa oculta (almacenados en el

vector delta_inj), haciendo uso de los pesos sinpticos de la neurona de salida (W). De
igual forma que en el caso anterior se calcula los gradientes finales (delta_j) usando la
derivada de la funcin de activacin, la cual en el caso de una funcin sigmoidal se
( ) (
calcula como: ( )
( ( ))).
delta_inj=W*delta_1;
delta_j=(Zj.*(1-Zj))'.*(delta_inj);

Con esta informacin se calcula el cambio de pesos y bias usando el coeficiente

de aprendizaje segn:
(

)
(

donde
es el gradiente de la neurona en cuestin,
y el coeficiente de aprendizaje.

)
las salidas de la capa anterior

Finalmente, para la actualizacin de pesos y bias se toman las siguientes

ecuaciones:
( )

( )

Todo eso se traduce en el siguiente cdigo:

%Actualizacin de pesos y bias
dW=alpha*(Zj*delta_1)';
dW0=alpha*delta_1';
W=W+dW;
W0=W0+dW0;
dV=alpha*(P(:,i)*delta_j)';
dV0=alpha*delta_j';
V=V+dV;
V0=V0+dV0;

Los pasos anteriores se repetirn 50000 veces ms para tener un desempeo

ptimo de la red.

3.4.2. Evaluacin sin TRN

Luego del entrenamiento realizado en la seccin anterior se tienen los vectores
finales de pesos y bias para cada una de las neuronas. Para evaluar el desempeo de la
red se crea una entrada P que contenga valores desde el 297 hasta el 360 en intervalos
de 0.1. Dicha entrada ser usada en el sistema creado y se calcular la salida
correspondiente:
P=(297:0.1:360)/max(T);
for u=1:length(P)
Z_inj=V*P(:,u)+V0; %salida capa oculta
Zj=1./(1+exp(-Z_inj)); %salida usando fcn sigmoidal
Y_ink=W*Zj+W0; %salida capa final
Yk(u)=purelin(Y_ink); %salida usando fcn sigmoidal
end

Los resultados Yk vs P son ploteados (lnea roja) y comparados con la data

original (puntos azules).

Figura 4.6.

3.4.3. Comentario a la evaluacin sin TRN

Los pesos y bias finales obtenidos en el entrenamiento anterior son:
W=

3.2374

5.2930

6.3773
W0 =

3.6648

8.2911

3.7379 11.1209

0.6419

V' = -4.0568 -9.0672 -12.5649 -4.8292 -21.3490 -5.5817 -30.1025

V0' =

1.5626

6.7235 10.1993

2.3732 18.8483

3.2415 27.1780

Y el error en cada poca en ploteado y mostrado en la Figura 4.7.

Figura 4.7.

Cabe destacar que la entrada elegida en cada poca se eligi aleatoriamente

debido a que si se hubiera tomado las entradas secuencialmente (tal como se hizo en el
algoritmo de Perceptron Aprende la Regla) la tendencia de la grfica resultante era una
recta que slo cumpla para los valores finales, con mayor error en los valores iniciales, ya
que para datos contiguos (recordando que la mayor cantidad de datos adquiridos en la
experiencia son los que corresponden a resistencias bajas) la red tiende a memorizar el
estado anterior y suavizar su aprendizaje (
es menor), considerando una recta, la
cual cumple para esa vecindad pero no para los dems datos. Entonces, la cabecera del
cuble for de aprendizaje est dada por:
for k=1:N %k:Nro de pasada
i=1;
i=ceil(length(P)*rand),

siendo i el ndice del vector de entrada P escogido.

De lo contrario, el resultado (para 2000 pocas) sera el siguiente:

Figura 4.8.
Por otro lado resulta interesante obviar la data inicial por un momento y considerar
una data generada simplemente con la funcin que relaciona R-T; es decir:
R=(1:0.01:11.5)';
TR=298;
beta=3977;
R25=10;
V1=2.5;

for i=1:length(R)
T(i,1)=(1/TR+(1/beta)*log(R(i)/R25))^-1;
end
t=(1:0.01:11.5)' ,

debido a que al usar data con intervalos iguales, se tiene menos concentracin de
puntos en cierta zona de la grfica y se reduce el efecto de recta anteriormente descrito.
La Figura 4.9 muestra el resultado del mismo principio usado anteriormente (en la Figura
4.8) pero con la nueva data generada para 5000 pocas, como se puede ver hay una
significante mejora.

Figura 4.9.

Figura 4.10. Evolucion del Error

3.4.4. Algoritmo con TRN

Finalmente, para comprobar todos los procedimientos de las secciones anteriores
se har uso del toolbox de Matlab para resolver el problema de regresin usando una red
multicapa. Para tal propsito se considera esta vez a la resistencia como la entrada al
sistema y a la temperatura como la salida. Se usarn 6 neuronas en la capa oculta:
load data_RTt.lvm;
P=data_RTt(:,1)';
T=data_RTt(:,2)';
NS=6; %nueronas

Ahora se procede a crear la red con estos datos y considerando una funcin de
activacin tansig para la capa oculta y purelin para la capa de salida, debido a que el
rango de temperatura (salida) va desde 290 a 360K. Se entrenar la red con un mximo
de 8000 pocas:
net=newff(P,T,NS,{'tansig', 'purelin'},'trainlm');
net.trainParam.epochs=8000;
[net,tr]=train(net,P,T);

El resultado del entrenamiento es el siguiente:

Figura 4.11.
Como se observa, los resultados coinciden con la data original.

Figura 4.11.