Tarea - 7 - Gaudencio Grande

Luis Gerardo Chávez Covarrubias REDES NEURONALES ARTIFICIALES
TAREA 7
Ejercicio 1.
Utilizando los resultados que obtuvo en la tarea 6 elija la red en donde obtuvo la
máxima eficiencia y pruebe los siguientes algoritmos de entrenamiento, reporte No ite
Para ver en donde se obtienen la mayor eficiencia, se debe volver a correr el parte del
código de la tarea 6 con los datos del T2R1.
clc;
clear all;
Var = xlsread("Datos_Seg_Exp.xlsx", 3, 'B1:H2867');
% Para la obtención del 90% de datos --- Filas = 2865*0.90 = 2578
T_Avg = Var(1:2578,1);
RH = Var(1:2578, 2);
PAR_Avg = Var(1:2578, 3);
DO = Var(1:2578, 4);
pH1 = Var(1:2578, 5);
CE1 = Var(1:2578, 6);
T1 = Var(1:2578, 7);
%%
%% ------------------------------------------------------------------------
% 1.1.- Sin T_Avg
% -------------------------------------------------------------------------
% Matrices
p = [RH, PAR_Avg, pH1, CE1, T1]'; %T_Avg,
t = [DO]';
% Normalización de matrices
[pn ps] = mapminmax(p);
[tn ts] = mapminmax (t);
% Tamaño de las matrices

[R,Q] = size(pn);
[S,G] = size(tn);
% Asignación de datos para entrenar

[trainP, valP, testP, trainInd, valInd, testInd] = dividerand (pn, 0.5, 0.25,
0.25);
[trainT, valT, testT] = divideind(tn, trainInd, valInd, testInd);

net_1 = newff([trainP, valP, testP],[trainT, valT, testT],[13], {'tansig',
'purelin'}, 'trainscg', 'learngd');
%view(net_1)
% Entrenamiento y simulación
net_1.trainParam.show = 35;
net_1.trainParam.epochs = 1000;
net_1.trainParam.goal = 0.00001;
[net_1, tr] = train(net_1, pn, tn);
Ysim_1 = sim(net_1,pn);
Ynet_1 = mapminmax('reverse', Ysim_1, ts)
Iteraciones = tr.num_epochs;
% Medidas de ajuste
Media_1 = mean(DO)
MSE_1 = sum((DO - Ynet_1').^2)/length(DO)
EF_1 = 1 - ((sum((DO - Ynet_1').^2))/(sum((DO - Media_1).^2)))
R_1 = ((sum((Ynet_1' - Media_1).^2))/(sum((DO - Media_1).^2)))
RMSE_1 = sqrt(MSE_1)
MAE_1 = sum(abs((DO - Ynet_1')))/numel(DO)
%% ------------------------------------------------------------------------
% 1.2.- Sin RH
% -------------------------------------------------------------------------
% Matrices
p = [T_Avg, PAR_Avg, pH1, CE1, T1]';
t = [DO]';

[R,Q] = size(pn);
[S,G] = size(tn);

0.25);
%view(net_2)
% Medidas de ajuste
Media_2 = mean(DO)
%% --------------------------------------------------------------------------
% 1.3.- Sin PAR_Avg
% --------------------------------------------------------------------------
% Matrices
p = [T_Avg, RH, pH1, CE1, T1]';
t = [DO]';

[R,Q] = size(pn);
[S,G] = size(tn);

0.25);
%view(net_3)
% Medidas de ajuste
Media_3 = mean(DO)
%% --------------------------------------------------------------------------
% 1.4.- Sin pH1
% --------------------------------------------------------------------------
% Matrices
p = [T_Avg, RH, PAR_Avg, CE1, T1]';
t = [DO]';

[R,Q] = size(pn);
[S,G] = size(tn);

0.25);
%view(net_4)
% Medidas de ajuste
Media_4 = mean(DO)
%% --------------------------------------------------------------------------
% 1.5.- Sin CE1
% --------------------------------------------------------------------------
% Matrices
p = [T_Avg, RH, PAR_Avg, pH1, T1]';
t = [DO]';

[R,Q] = size(pn);
[S,G] = size(tn);

0.25);
%view(net_5)
% Medidas de ajuste
Media_5 = mean(DO)
%% --------------------------------------------------------------------------
% 1.6.- Sin T1
% --------------------------------------------------------------------------
% Matrices
p = [T_Avg, RH, PAR_Avg, pH1, CE1]';
t = [DO]';

[R,Q] = size(pn);
[S,G] = size(tn);

0.25);
%view(net_6)
% Medidas de ajuste
Media_6 = mean(DO)
%%
% % Tabla para determinar que variable excluir según su eficiencia
%Etiqueta = {'Variable excluida','Eficiencia'};
Variable_Excluida = {'T_Avg'; 'RH'; 'PAR_Avg'; 'pH1'; 'CE1'; 'T1'};
Eficiencia = [EF_1; EF_2; EF_3; EF_4; EF_5; EF_6];
Tabla = table(Variable_Excluida, Eficiencia)
A continuación, se muestran los resultados arrojados de las eficiencias obtenidas según la

variable excluida.
De acuerdo a la tabla anterior, las variables excluidas son el T_Avg y el PAR_Avg. Debido
que a son 10 combinaciones, se optó por reducir las líneas de código con ayuda de vectores
y y ciclos “for”. A continuación, se muestra el código usado en Matlab:
%% ========================================================================
% Ejercicio 1
% Utilizando los resultados que obtuvo en la tarea 6 elija la red en donde
% obtuvo la máxima eficiencia y pruebe los siguientes algoritmos de
entrenamiento,
%reporte No iteraciones, eficiencia y MAE.
% =========================================================================
% Utilizando las mejores cuatro variables
% Matrices
p = [RH, pH1, CE1, T1]';
t = [DO]';

[R,Q] = size(pn);
[S,G] = size(tn);
Vect_Entren = ["trainlm", "trainscg", "trainbfg", "traincgf", "traingd"];

Vect_Aprend = ["learngd", "learngdm"];
Contador = 1;
for i=1:2
for j=1:5
[trainP, valP, testP, trainInd, valInd, testInd] = dividerand (pn,
0.5, 0.25, 0.25);
net_mej = newff([trainP, valP, testP],[trainT, valT, testT],[13],
{'tansig', 'purelin'}, Vect_Entren(j), Vect_Aprend(i));
%view(net_1)
net_mej.trainParam.show = 35;
net_mej.trainParam.epochs = 1000;
net_mej.trainParam.goal = 0.00001;
[net_mej, tr] = train(net_mej, pn, tn);
Ysim_mej = sim(net_mej,pn);
Ynet_mej = mapminmax('reverse', Ysim_mej, ts)
%Iteraciones = tr.num_epochs;
% Guardar resultados de la red

Red = {'Red',num2str(j), num2str(i), '.mat'};
Nombre = cell2mat(join(Red, '_'));
save(Nombre, 'net_mej')
% Medidas de ajuste
Num_Iteraciones_mej(j,i) = tr.num_epochs;
Media_mej(j,i) = mean(DO);
MSE_mej(j,i) = sum((DO - Ynet_mej').^2)/length(DO);
EF_mej(j,i) = 1 - ((sum((DO - Ynet_mej').^2))/(sum((DO -
Media_mej(j,i)).^2)));
R_mej(j,i) = ((sum((Ynet_mej' - Media_mej(j,i)).^2))/(sum((DO -
Media_mej(j,i)).^2)));
RMSE_mej(j,i) = sqrt(MSE_mej(j,i));
MAE_mej(j,i) = sum(abs((DO - Ynet_mej')))/numel(DO);
% Para tabla
Num_Iteraciones_mej(j,i) = Num_Iteraciones_mej(j,i);
Media_mej(j,i) = Media_mej(j,i);
MSE_mej(j,i) = MSE_mej(j,i);
EF_mej(j,i) = EF_mej(j,i);
R_mej(j,i) = R_mej(j,i);
RMSE_mej(j,i) = RMSE_mej(j,i);
MAE_mej(j,i) = MAE_mej(j,i);
Contador = Contador + 1;
end
end
%% Tabla
Num_Iteraciones_mej = Num_Iteraciones_mej
Num_Iteraciones_1 = Num_Iteraciones_mej(:,1:1);
Num_Iteraciones_2 = Num_Iteraciones_mej(:,2:2);
Num_Iteraciones = [Num_Iteraciones_1; Num_Iteraciones_2]
EF_mej = EF_mej;
EF_1 = EF_mej(:,1:1);
EF_2 = EF_mej(:,2:2);
Eficiencia = [EF_1; EF_2];
MAE_mej = MAE_mej;
MAE_1 = MAE_mej(:,1:1);
MAE_2 = MAE_mej(:,2:2);
MAE = [MAE_1; MAE_2]
Tabla = table(Num_Iteraciones, Eficiencia, MAE)
% Datos complementarios
Media_mej = Media_mej;
Media_1 = Media_mej(:,1:1);
Media_2 = Media_mej(:,2:2);
Media = [Media_1; Media_2];
MSE_mej = MSE_mej;
MSE_1 = MSE_mej(:,1:1);
MSE_2 = MSE_mej(:,2:2);
MSE = [MSE_1; MSE_2];
R_mej = R_mej;
R_1 = R_mej(:,1:1);
R_2 = R_mej(:,2:2);
R = [R_1; R_2];
RMSE_mej = RMSE_mej;
RMSE_1 = RMSE_mej(:,1:1);
RMSE_2 = RMSE_mej(:,2:2);
RMSE = [RMSE_1; RMSE_2];
%%
%Se obtiene el mejor algoritmo de entrenamiento y aprendizaje según eficiencia
EF_m = Eficiencia
bb = [Media, MSE, Eficiencia, R, RMSE, MAE]
Ef_max = max(EF_m)
Ind_mayor = find(EF_m == Ef_max, 1)
BB = bb(Ind_mayor, :)
%%
% Creación de hoja en Excel
% De acuerdo a lo anterior, el algoritmo con mayor eficiencia es: Red_1_1
% Matriz de pesos entre la capa de entrada y oculta
load('Red_1_1_.mat')
IW = [cell2mat(net_mej.IW)]
% Matriz de pesos entre la capa oculta y capa de salida

LW = [cell2mat(net_mej.LW)]
% Sesgos
b = [cell2mat(net_mej.b)]
Variables = {'Media','MSE','EF','R','RMSE','MAE'};
B = BB%[Media, MSE, Eficiencia, R, RMSE, MAE];
% Con las 4 mejores variables

xlswrite('T2R1_Pesos.xlsx','Pesos IW', 1, 'A1');
xlswrite('T2R1_Pesos.xlsx', IW, 1, 'A2');
xlswrite('T2R1_Pesos.xlsx','Pesos LW', 1, 'A16');
xlswrite('T2R1_Pesos.xlsx', LW, 1, 'A17');
xlswrite('T2R1_Pesos.xlsx','Sesgos b', 1, 'A19');
xlswrite('T2R1_Pesos.xlsx', b, 1, 'A20');
xlswrite('T2R1_Pesos.xlsx','Ajuste', 1, 'A34');
xlswrite('T2R1_Pesos.xlsx', B, 1, 'A35');
Los resultados obtenidos se muestran en la siguiente tabla. Se pudo observar que en la

combinación “trainlm- learngd” se obtuvo la mayor eficiencia, sin embargo, la
combinación “trainlm- learngdm” se obtuvo una eficiencia cercana a la anterior, pero con la
mitad de iteraciones.
Ejercicio 2.
Con las matrices de pesos generadas con el mejor algoritmo de entrenamiento y

aprendizaje realice el análisis de sensibilidad por el método de Garson y la gráfica
correspondiente.
A continuación, se muestra el código usado en Matlab:
%% ========================================================================
% Ejercicio 2
% Con las matrices de pesos generadas con el mejor algoritmo de entrenamiento
% y aprendizaje realice el análisis de sensibilidad por el método de Garson
% y la gráfica correspondiente.
% =========================================================================
W_Entrada = IW';
W_Salida = LW';
[m n] = size(W_Entrada);
C = zeros(m,n);
for i = 1:n
for j = 1:m
C(j,i) = W_Entrada(j,i)*W_Salida(i,1);
end
end
C_1 = abs(C);
r = zeros(m,n);
for i=1:n
for j=1:m
Sumatoria = sum(C_1(:,i));
r(j,i)=C_1(j,i)/Sumatoria;
end
end
Suma = zeros(m,1);
for j = 1:m
Suma(j) = sum(r(j,:));
end
Suma_Total = sum(Suma);
RI = zeros(m,1);
for j = 1:m
RI(j) = Suma(j)/Suma_Total*100;
end
%--------------------------------------------------------------------------
% Gráfica
Etiquetas = {'RH', 'pH1', 'CE1', 'T1'}';
bar(Etiquetas, RI,'FaceColor',[0.6350 0.0780 0.1840], 'LineWidth', 0.5)
title('Datos filtrados');
grid on;
ylabel("Importancia relativa (%)");
Los resultados obtenidos son los siguientes:

Datos filtrados
35
30
25
Importancia relativa (%)
20
15
10
0
RH pH1 CE1 T1
Se puede observar que se tiene una mayor sensibilidad en el pH1 y la variable que tiene una
importancia relativa menor es la RH.
Conclusiones
De acuerdo a los resultados obtenidos, se pudo observar que con la combinación “trainlm-
learngd” se obtuvo la mayor eficiencia con 111 iteraciones, sin embargo, la combinación
“trainlm- learngdm” se obtuvo una eficiencia cercana a la anterior, pero con la mitad de
iteraciones. Por otro lado, los resultados del análisis de sensibilidad por el método de
Garson muestran que la variable con menor importancia es la RH y la que presenta mayor
relevancia es el pH1.

Tarea - 7 - Gaudencio Grande

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tarea - 7 - Gaudencio Grande

Cargado por

Copyright:

Formatos disponibles

Luis Gerardo Chávez Covarrubias REDES NEURONALES ARTIFICIALES

% Tamaño de las matrices

% Asignación de datos para entrenar

[trainT, valT, testT] = divideind(tn, trainInd, valInd, testInd);

% Tamaño de las matrices

% Asignación de datos para entrenar

% Tamaño de las matrices

% Asignación de datos para entrenar

% Tamaño de las matrices

% Asignación de datos para entrenar

% Tamaño de las matrices

% Asignación de datos para entrenar

% Tamaño de las matrices

% Asignación de datos para entrenar

A continuación, se muestran los resultados arrojados de las eficiencias obtenidas según la

% Tamaño de las matrices

Vect_Entren = ["trainlm", "trainscg", "trainbfg", "traincgf", "traingd"];

% Guardar resultados de la red

Tabla = table(Num_Iteraciones, Eficiencia, MAE)

% Matriz de pesos entre la capa oculta y capa de salida

% Con las 4 mejores variables

Los resultados obtenidos se muestran en la siguiente tabla. Se pudo observar que en la

Con las matrices de pesos generadas con el mejor algoritmo de entrenamiento y

A continuación, se muestra el código usado en Matlab:

Los resultados obtenidos son los siguientes:

También podría gustarte