%% Borrar variables de entorno
clc
borrar
cerrar todo
%% Inicialización de partículas
% Dos parámetros en el algoritmo de enjambre de partículas
c1 = 1.49445;
c2 = 1.49445;
% Pesos máximo y mínimo
wmax = 0.9;
wmin = 0.1;
% Velocidad máxima y mínima
Vmax = 0.03 ;
Vmin = -0.03;
%
popmax individual máximo y mínimo = 0.3;
popmin = -0.3;
maxgen = 50;% número de evoluciones
sizepop = 20;% tamaño de población
% Genere aleatoriamente una población
para i = 1: sizepop
pop (i, :) = 0.03 * rand (1,45);%
aptitud de codificación individual (i) = diversión (pop (i,:));% aptitud cromosómica
V ( i,:) = 0,003 * rands (1,45);%
final de velocidad de inicialización
%% Valor extremo de la población inicial
% Encuentra el mejor cromosoma
[bestfitness bestindex] = min (fitness);
zbest = pop (bestindex, :);% global best
gbest = pop;% individual best
fitnessgbest = fitness;% individual best Best fitness value
fitnesszbest = bestfitness;% Mejor valor fitness global
%% Optimización iterativa
para i = 1: maxgen
i
para j = 1: sizepop
w = (wmax-wmin) * (i-1) / (maxgen) + wmin;% de cambio lineal en peso
V (j,:) = w * V (j, :) + c1 * rand * (gbest (j,: ) -pop (j, :)) + c2 * rand * (zbest-pop (j,:));% actualización de velocidad
V (j, find (V (j,:)> Vmax)) = Vmax;% es menor que La velocidad máxima
V (j, find (V (j,:) <Vmin)) = Vmin;% es mayor que la velocidad mínima
% población actualización
pop (j,:) = pop (j,:) + 0.5 * V (j, :);
para k =
1:45 si rand> 0.95
pop (j, k) = 0.3 * rand;% de mutación adaptativa
end
end
pop (j, find (pop (j,:)> popmax)) = popmax ;% menos que individual El
pop máximo (j, find (pop (j,:) <popmin)) = popmin;% es mayor que el mínimo individual
% Fitness value
fitness (j) = fun (pop (j, :));
final
de j = 1: sizepop
% actualización de valor extremo individual
si fitness (j) <fitnessgbest (j)
gbest (j, :) = pop (j , :);
fitnessgbest (j) = fitness (j);
end
% Actualización del valor extremo global
si fitness (j) <fitnesszbest
zbest = pop (j, :);
fitnesszbest = fitness (j);
end
end
% Registrar el valor de aptitud óptima
yy (i) = fitnesszbest;
fin
%%
figura de control individual óptima (1)
plot (yy)
title ('proceso de evolución del algoritmo de enjambre de partículas');
xlabel ('álgebra evolutiva'); ylabel ('fitness');
individual = zbest;
w11 = remodelar (individual (1: 6), 3,2);
w12 = remodelar (individual (7:12), 3,2);
w13 = remodelar (individual (13:18), 3,2);
w21 = individuo (19:27);
w22 = individuo (28:36);
w23 = individuo (37:45);
tasa1 = 0.006; tasa2 = 0.001;% tasa de aprendizaje
k = 0.3; K = 3;
y_1 = ceros (3,1); y_2 = y_1; y_3 = y_2;% valor de salida
u_1 = ceros (3,1); u_2 = u_1; u_3 = u_2;% Tasa de control
h1i = ceros (3,1); h1i_1 = h1i;% La primera cantidad de control
h2i = ceros (3,1); h2i_1 = h2i;% La segunda cantidad de control
h3i = ceros (3 , 1); h3i_1 = h3i;% La tercera cantidad de vacantes
x1i = ceros (3,1); x2i = x1i; x3i = x2i; x1i_1 = x1i; x2i_1 = x2i; x3i_1 = x3i;% Salida de capa oculta
% De inicialización en peso
k0 = 0,03;
% Límite de valor
ynmax = 1; ynmin = -1;% límite de valor de salida del sistema
xpmax = 1; xpmin = -1;% P límite de salida del nodo
qimax = 1; qimin = -1;% I límite de salida del nodo
qdmax = 1; qdmin = -1;% D límite de salida del nodo
uhmax = 1; uhmin = -1;% límite de resultado de salida
para k = 1: 1: 200
% -------------------------------- Cálculo de reenvío de red ------------- - ------------
% Salida del sistema
y1 (k) = (0.4 * y_1 (1) + u_1 (1) / (1 + u_1 (1) ^ 2) + 0.2 * u_1 (1) ^ 3 + 0.5 * u_1 (2)) + 0.3 * y_1 (2);
y2 (k) = (0.2 * y_1 (2) + u_1 (2) / (1 + u_1 (2) ^ 2) + 0.4 * u_1 (2) ^ 3 + 0.2 * u_1 (1)) + 0.3 * y_1 (3);
y3 (k) = (0.3 * y_1 (3) + u_1 (3) / (1 + u_1 (3) ^ 2) + 0,4 * u_1 (3) ^ 3 + 0,4 * u_1 (2)) + 0,3 * y_1 (1);
r1 (k) = 0,1 + (0,01 * sin (2 * pi * k / 100));
r2 (k) = 0.3 + (0.03 * sin (2 * pi * k / 100));
r3 (k) = 0.5 + (0.05 * sin (2 * pi * k / 100));% objetivo de control
% límite de salida del sistema
yn = [ y1 (k), y2 (k), y3 (k)];
yn (encontrar (yn> ynmax)) = ynmax;
yn (encontrar (yn <ynmin)) = ynmin;
% de la capa de entrada salida
x1o = [r1 (k ); yn (1)]; x2o = [r2 (k); yn (2)]; x3o = [r3 (k); yn (3)];
% Capa oculta
x1i = w11 * x1o;
x2i = w12 * x2o;
x3i = w13 * x3o;
% Cálculo de neurona proporcional P
xp = (x1i (1), x2i (1), x3i (1)];
xp (encontrar (xp> xpmax)) = xpmax;
xp (encontrar (xp <xpmin)) = xpmin;
qp = xp;
h1i (1) = qp (1); h2i (1) = qp (2); h3i (1) = qp (3);
% Cálculo de neurona integral I
xi = [x1i (2), x2i (2), x3i (2)];
qi = [0,0,0]; qi_1 = [h1i (2), h2i (2), h3i (2 )];
qi = qi_1 + xi;
qi (encontrar (qi> qimax)) = qimax;
qi (encontrar (qi <qimin)) = qimin;
h1i (2) = qi (1); h2i (2) = qi ( 2); h3i (2) = qi (3);
% Cálculo diferencial de neurona D
xd = [x1i (3), x2i (3), x3i (3)];
qd = [0 0 0];
xd_1 = [x1i_1 (3), x2i_1 (3), x3i_1 (3)] ;
qd = xd-xd_1;
qd (encontrar (qd> qdmax)) = qdmax;
qd (encontrar (qd <qdmin)) = qdmin;
h1i (3) = qd (1); h2i (3) = qd (2) ; h3i (3) = qd (3);
% Cálculo de la capa de salida
wo = [w21; w22; w23];
qo = [h1i ', h2i', h3i ']; qo = qo';
uh = wo * qo;
uh (find (uh> uhmax)) = uhmax;
uh (encontrar (uh <uhmin)) = uhmin;
u1 (k) = uh (1); u2 (k) = uh (2); u3 (k) = uh (3);% ley de control
% ---- ---------------------------------- Corrección de retroalimentación de red ------------- ---------
% Error de cálculo error
= [r1 (k) -y1 (k); r2 (k) -y2 (k); r3 (k) -y3 (k)];
error1 (k) = error (1); error2 (k) = error (2); error3 (k) = error (3);
J (k) = 0.5 * (error (1) ^ 2 + error (2) ^ 2 + error ( 3) ^ 2);% Resize
ypc = [y1 (k) -y_1 (1); y2 (k) -y_1 (2); y3 (k) -y_1 (3)];
uhc = [u_1 (1) - u_2 (1); u_1 (2) -u_2 (2); u_1 (3) -u_2 (3)];
% Capa oculta y ajuste del peso de la capa de salida
% Ajustar w21
Sig1 = signo (ypc ./ (uhc (1) +0,00001));
dw21 = suma (error. * Sig1) * qo ';
w21 = w21 + tasa2 * dw21;
% Ajustar w22
Sig2 = signo (ypc. /(uh(2)+0.00001));
dw22 = sum (error. * Sig2) * qo ';
w22 = w22 + rate2 * dw22;
% ajuste w23
Sig3 = signo (ypc ./ (uh (3) +0.00001) );
dw23 = suma (error. * Sig3) * qo '; w23
= w23 + tasa2 * dw23;
% 输入 层 和 隐含 层 权 值 调整
delta2 = ceros (3,3);
wshi = [w21; w22; w23];
para t = 1: 1: 3
delta2 (1: 3, t) = error (1: 3). * signo (ypc (1: 3) ./ (uhc (t) +0,00000001));
final
para j = 1: 1: 3
sgn (j) = signo ((h1i (j) -h1i_1 (j)) / (x1i (j) -x1i_1 (j) +0,00001));
final
s1 = sgn '* [r1 (k), y1 (k)];
wshi2_1 = wshi (1: 3, 1: 3);
alterar = ceros (3,1);
dws1 = ceros (3,2);
para j = 1: 1: 3
para p = 1: 1: 3
alter (j) = alter (j) + delta2 (p,:) * wshi2_1 (:, j);
end
end
para p = 1: 1: 3
dws1 (p,:) = alter (p) * s1 (p, :);
final
w11 = w11 + rate1 * dws1;
% 调整 w12
para j = 1: 1: 3
sgn (j) = signo ((h2i (j) -h2i_1 (j)) / (x2i (j) -x2i_1 (j) +0,0000001));
final
s2 = sgn '* [r2 (k), y2 (k)];
wshi2_2 = wshi (:, 4: 6);
alter2 = ceros (3,1);
dws2 = ceros (3,2);
para j = 1: 1: 3
para p = 1: 1: 3
alter2 (j) = alter2 (j) + delta2 (p,:) * wshi2_2 (:, j);
end
end
para p = 1: 1: 3
dws2 (p,:) = alter2 (p) * s2 (p, :);
final
w12 = w12 + tasa1 * dws2;
% 调整 w13
para j = 1: 1: 3
sgn (j) = signo ((h3i (j) -h3i_1 (j)) / (x3i (j) -x3i_1 (j) +0,0000001));
final
s3 = sgn '* [r3 (k), y3 (k)];
wshi2_3 = wshi (:, 7: 9);
alter3 = ceros (3,1);
dws3 = ceros (3,2);
para j = 1: 1: 3
para p = 1: 1: 3
alter3 (j) = (alter3 (j) + delta2 (p,:) * wshi2_3 (:, j));
end
end
para p = 1: 1: 3
dws3 (p,:) = alter2 (p) * s3 (p, :);
final
w13 = w13 + rate1 * dws3;
% 参数 更新
u_3 = u_2; u_2 = u_1; u_1 = uh;
y_2 = y_1; y_1 = yn;
h1i_1 = h1i; h2i_1 = h2i; h3i_1 = h3i;
x1i_1 = x1i; x2i_1 = x2i; x3i_1 = x3i;
fin
time = 0.001 * (1: k);
figura (2)
subparcela (3,1,1)
plot (time, r1, 'r -', time, y1, 'b-');
title ('Control de red de neuronas PID ');
ylabel (' Cantidad controlada 1 ');
leyenda (' Destino de control ',' Salida real ','
tamaño de fuente ', 12); subplot (3,1,2)
plot (time, r2,' r- ', tiempo, y2, 'b-');
ylabel ('cantidad controlada 2');
leyenda ('objetivo de control', 'salida real', '
tamaño de fuente ', 12); eje ([0,0.2,0, 1])
subplot (3,1,3)
plot (time, r3, 'r -', time, y3, 'b-');
xlabel ('time / s');
ylabel ('cantidad controlada 3');
legend (' Control de destino ',' Salida real ',' tamaño de fuente ', 12);
figure (3)
plot (time, u1, 'r -', time, u2, 'g -', time, u3, 'b');
title ('Entrada de control proporcionada por la red neuronal PID al objeto');
xlabel ( 'Tiempo'), ylabel ('Ley de control');
leyenda ('u1', 'u2', 'u3'); cuadrícula
figura (4)
trama (tiempo, J, 'r-');
eje ([0,0.1,0,0,5]);
título de la cuadrícula ('Curva dinámica de la función objetivo de aprendizaje de red J');
etiqueta x ('时间'); ylabel ('Error de control');
% navegador web http://www.ilovematlab.cn/thread-62563-1-1.html