Algoritmo genético para optimizar el ajuste de funciones no lineales de red neuronal de BP

% Borrar variables de entorno
clc
borrar
% 
%% Establecimiento de estructura de red
% leer datos
cargar datos entrada salida

%
Número de nodos inputnum = 2;
hiddennum = 5;
outputnum = 1;

% Datos de entrenamiento y datos de predicción
input_train = input (1: 1900, :) ';
input_test = input (1901: 2000, :)';
output_train = output (1: 1900) ';
output_test = output (1901: 2000)';

% Normalización de los datos de entrada y salida de muestra seleccionados
[inputn, inputps] = mapminmax (input_train);
[outputn, outputps] = mapminmax (output_train);

% Construye una red
net = newff (inputn, outputn, hiddennum);

%% inicialización del parámetro del algoritmo genético
maxgen = 10;% álgebra de evolución, es decir, el número de iteraciones
sizepop = 10;% tamaño de la población
pcross = [0.3];% selección de probabilidad de cruce, entre 0 y 1
mutación = [0.1];% selección de probabilidad de mutación, entre 0 y 1

% 节点 总数
numsum = inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum;

lenchrom = ones (1, numsum);        
bound = [- 3 * ones (numsum, 1) 3 * ones (numsum, 1)];% rango de datos

% ------------------------------------------------- ----- Inicialización de población ------------------------------------------- -------------
persons = struct ('fitness', zeros (1, sizepop), 'chrom', []);% Definir la información de la población como una estructura
avgfitness = [];% La aptitud media de cada generación de la población
bestfitness = [];% La mejor aptitud de cada generación de la población
bestchrom = [];% La mejor aptitud del cromosoma
% Inicializar la población
para i = 1: sizepop
    % Generar aleatoriamente un población de
    individuos. chrom (i,:) = Código (lenchrom, encuadernado);% de codificación (el resultado de codificación de binario y gris es un número real, y el resultado de codificación de float es un vector de número real)
    x = individuos.chrom (i, :);
    % de adaptación de cálculo de
    individuos fitness (i) = diversión (x , inputnum, hiddennum, outputnum, net, inputn, outputn); fitness% cromosoma
final

% Encuentre el mejor cromosoma
[bestfitness bestindex] = min (individuos.fitness);
bestchrom = individuos.chrom (bestindex, :);% El mejor cromosoma
avgfitness = sum (individuos.fitness) / sizepop;% El promedio de aptitud del cromosoma Grados
% Registre la mejor condición física y la condición física promedio en cada generación de evolución
trace = [avgfitness bestfitness];
 
%% Resuelva  iterativamente el mejor umbral inicial y
% de peso La evolución comienza
para i = 1: maxgen
    i
    % Seleccionar
    individuos = Seleccionar (individuos, tamañopop ); 
    avgfitness = suma (individuos.fitness) / sizepop;
    % cruzado
    individuos.chrom = Cruzado (pcross, lenchrom, individuos.chrom, sizepop, unido);
    % mutación
    individuos.chrom = Mutación (pmutación, lenchrom, individuos.chrom, sizepop, i, maxgen, bound);
    
    % calcular la aptitud 
    para j = 1: sizepop
        x = individuos.chrom (j, :);% decodificación de
        individuos.fitness (j) = diversión (x, inputnum, hiddennum, outputnum, net, inputn, outputn);   
    end
    
  % Encuentra los cromosomas con menor y mayor aptitud y dónde son Posición en la población
    [newbestfitness, newbestindex] = min (individuos.fitness);
    [worestfitness, worestindex] = max (individuos.fitness);
    % Reemplazar el mejor cromosoma en la última evolución
    si bestfitness> newbestfitness
        bestfitness = newbestfitness;
        mejor = individuos.chrom (newbestindex, :);
    end
    individuales.chrom (worestindex,:) = bestchrom;
    individuos.fitness (worestindex) = bestfitness;
    
    avgfitness = sum (individuales.fitness) / sizepop;
    
    trace = [trace; avgfitness bestfitness] ;% Registra la mejor condición física y la condición física promedio en cada generación de evolución

end
%%
 Figura del análisis del resultado del algoritmo genético  (1)
[rc] = tamaño (traza);
plot ([1: r] ', trace (:, 2),' b-- ');
title ([' curva de aptitud ' 'Álgebra terminal =' num2str (maxgen)]);
xlabel ('álgebra evolutiva'); ylabel ('aptitud');
leyenda ('aptitud media', 'aptitud óptima');
disp ('Variable de aptitud');
x = bestchrom;

%% Asignar el peso de umbral inicial óptimo a la predicción de la red %%
Usar la red BP optimizada por algoritmo genético para la predicción del valor
w1 = x (1: inputnum * hiddennum);
B1 = x (inputnum * hiddennum + 1: inputnum * hiddennum + hiddennum);
w2 = x (inputnum * hiddennum + hiddennum + 1: inputnum * hiddennum + hiddennum + hiddennum * outputnum);
B2 = x (inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1: inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum );

net.iw {1,1} = remodelar (w1, hiddennum, inputnum);
net.lw {2,1} = remodelar (w2, outputnum, hiddennum);
net.b {1} = remodelar (B1, hiddennum, 1);
net.b {2} = B2;

%% BP Network Training
% parámetros de evolución de la red
net.trainParam.epochs = 100;
net.trainParam.lr = 0.1;
% net.trainParam.goal = 0.00001;

% Entrenamiento de la
red [net, per2] = train (net, inputn, outputn);

%% BP predicción de red
% normalización de datos
inputn_test = mapminmax ('aplicar', input_test, inputps);
an = sim (net, inputn_test);
test_simu = mapminmax ('reverse', an, outputps);
error = test_simu-output_test;