MATLAB Aprendizaje por refuerzo de combate (3) utilizando computación paralela para entrenar al agente DQN para la asistencia de mantenimiento de carril (LKA)

Este ejemplo muestra cómo utilizar el entrenamiento paralelo para entrenar a un agente de deep Q-learning network (DQN) en Simulink® para mantener la asistencia de carril (LKA). Para ver un ejemplo que muestra cómo capacitar a un agente sin utilizar el entrenamiento paralelo, consulte Capacitar al agente de DQN para el asistente de mantenimiento de carril .

matlab versión 2020b.

Descripción general del entrenamiento paralelo DQN

En el agente DQN, cada trabajador genera una nueva experiencia a partir de su copia del agente y el entorno. Cada N pasos, el personal enviará la experiencia al agente anfitrión. El agente anfitrión actualiza sus parámetros de la siguiente manera.

1. Para la capacitación asincrónica , el agente anfitrión puede aprender de la experiencia recibida sin esperar a que todo el personal envíe la experiencia, y luego enviar los parámetros actualizados al personal que proporcionó la experiencia. Luego, el personal continúa utilizando los parámetros actualizados para generar experiencia en su entorno.

2. Para la capacitación sincrónica , el agente anfitrión espera recibir la experiencia de todos los trabajadores y aprender de estas experiencias. Luego, el anfitrión envía los parámetros actualizados a todos los programas de trabajo al mismo tiempo. Todo el personal continuará utilizando los parámetros actualizados para generar experiencia.

Modelo Simulink de Ego Car

El entorno de aprendizaje por refuerzo para este ejemplo es un modelo de bicicleta simple para la dinámica del vehículo. El objetivo del entrenamiento es mantener la bicicleta conduciendo a lo largo de la línea central del carril ajustando el ángulo de dirección delantero. Este ejemplo utiliza el mismo modelo de vehículo que Train DQN Agent for Lane Keeping Assist .

m = 1575;   % total vehicle mass (kg)
Iz = 2875;  % yaw moment of inertia (mNs^2)
lf = 1.2;   % longitudinal distance from center of gravity to front tires (m)
lr = 1.6;   % longitudinal distance from center of gravity to rear tires (m)
Cf = 19000; % cornering stiffness of front tires (N/rad)
Cr = 33000; % cornering stiffness of rear tires (N/rad)
Vx = 15;    % longitudinal velocity (m/s)

Defina el tiempo de muestreo Ts y la duración de la simulación T en segundos.

Ts = 0.1;
T = 15;

La salida del sistema LKA es el ángulo de dirección delantero de la bicicleta. Para simular el límite de dirección físico de una bicicleta, limite el ángulo de dirección dentro de [–0,5,0,5] rad.

u_min = -0.5;
u_max = 0.5;

La curvatura de la carretera se define como una constante $0.001\left(m^{-1}\right)$. El valor inicial de la desviación lateral es de 0,2 my el valor inicial del ángulo de guiñada relativo es de 0,1 rad.

rho = 0.001;
e1_initial = 0.2;
e2_initial = -0.1;

Abra el modelo

mdl = 'rlLKAMdl';
open_system(mdl)
agentblk = [mdl '/RL Agent'];

haga clic para entrar.

Para este modelo:

1. La señal de acción del ángulo del timón del agente al medio ambiente es de 15 a 15 grados.
2. Lo que se observa del entorno es la desviación lateral ${mi}_1$, El ángulo de guiñada relativo ${mi}_2$, Su derivada $\dot{{mi}_1}$Y $\dot{{mi}_2}$, Y su integral $\int {mi}_1$Y $\int {mi}_2$。
3. Cuando el desplazamiento lateral $|e_1|$ > 1, la simulación finaliza.
4. La recompensa proporcionada por cada paso t $r_t$Por
   
   donde $u$ es del paso de tiempo anterior$t-1$ entrada de control.

Crear interfaz de entorno

Cree una interfaz de entorno de aprendizaje reforzado para el vehículo ego.

Definir información de observación.

observationInfo = rlNumericSpec([6 1],'LowerLimit',-inf*ones(6,1),'UpperLimit',inf*ones(6,1));
observationInfo.Name = 'observations';
observationInfo.Description = 'information on lateral deviation and relative yaw angle';

Defina la información de la acción.

actionInfo = rlFiniteSetSpec((-15:15)*pi/180);
actionInfo.Name = 'steering';

Crea una interfaz ambiental.

env = rlSimulinkEnv(mdl,agentblk,observationInfo,actionInfo);

La interfaz tiene un espacio de acción discreto en el que el agente puede aplicar uno de los 31 ángulos de dirección posibles de -15 grados a 15 grados. El valor observado es un vector de seis dimensiones que contiene la desviación lateral, el ángulo de guiñada relativo y su derivada e integral con respecto al tiempo .

Para definir las condiciones iniciales para la desviación lateral y el ángulo de guiñada relativo, use el identificador de función anónima para especificar la función de restablecimiento del entorno. El localResetFcn definido al final de este ejemplo aleatoriza el sesgo lateral inicial y el ángulo de guiñada relativo.

env.ResetFcn = @(in)localResetFcn(in);

La reproducibilidad de la semilla generadora aleatoria fija.

rng(0)

Crear agente DQN

El agente DQN puede usar el aproximador de comentaristas Q de múltiples salidas, que es generalmente más efectivo. Un aproximador de múltiples salidas toma las observaciones como entrada y los valores de acción del estado como salida . Cada elemento de salida representa la recompensa acumulada esperada a largo plazo por tomar las acciones discretas correspondientes del estado indicado por la entrada de observación.

Para crear un comentarista, primero cree una red neuronal profunda con una entrada (un estado de observación de seis dimensiones) y un vector de salida con 31 elementos (ángulos de dirección espaciados uniformemente de -15 grados a 15 grados) . Para obtener más información sobre la creación de representaciones de funciones de valor de redes neuronales profundas, consulte Creación de representaciones de funciones de valor y estrategia .

nI = observationInfo.Dimension(1);  % number of inputs (6)
nL = 120;                           % number of neurons
nO = numel(actionInfo.Elements);    % number of outputs (31)

dnn = [
    featureInputLayer(nI,'Normalization','none','Name','state')
    fullyConnectedLayer(nL,'Name','fc1')
    reluLayer('Name','relu1')
    fullyConnectedLayer(nL,'Name','fc2')
    reluLayer('Name','relu2')
    fullyConnectedLayer(nO,'Name','fc3')];

Verifique la configuración de la red.

figure
plot(layerGraph(dnn))

Utilice rlRepresentationOptions para especificar las opciones representadas por el revisor.

criticOptions = rlRepresentationOptions('LearnRate',1e-4,'GradientThreshold',1,'L2RegularizationFactor',1e-4);

Cree una representación de comentarista utilizando la red neuronal profunda y las opciones especificadas. También debe especificar la operación y la información de observación del revisor, que se obtiene de la interfaz del entorno. Para obtener más información, consulte rlQValueRepresentation .

critic = rlQValueRepresentation(dnn,observationInfo,actionInfo,'Observation',{
    
    'state'},criticOptions);

Para crear un agente DQN, primero use rlDQNAgentOptions para especificar las opciones del agente DQN.

agentOpts = rlDQNAgentOptions(...
    'SampleTime',Ts,...
    'UseDoubleDQN',true,...
    'TargetSmoothFactor',1e-3,...
    'DiscountFactor',0.99,...
    'ExperienceBufferLength',1e6,...
    'MiniBatchSize',256);

agentOpts.EpsilonGreedyExploration.EpsilonDecay = 1e-4;

Luego, use la representación del comentarista especificada y las opciones de agente para crear un agente DQN. Para obtener más información, consulte rlDQNAgent .

agent = rlDQNAgent(critic,agentOpts);

Opciones de entrenamiento

Para entrenar al agente, primero especifique las opciones de entrenamiento. Para este ejemplo, use las siguientes opciones.

1. Cada entrenamiento se puede realizar como máximo 10000 episodios, y cada episodio dura como máximo pasos de tiempo ceil (T / Ts).

2. Solo muestre el progreso del entrenamiento en el cuadro de diálogo "Administrador de gráficos" (configure las opciones "Gráficos" y "Detallado" en consecuencia).

3. Cuando la recompensa de la trama llegue a -1, deja de entrenar.

4. Guarde una copia del agente para cada episodio en el que la recompensa acumulada sea superior a 100.

maxepisodes = 10000;
maxsteps = ceil(T/Ts);
trainOpts = rlTrainingOptions(...
    'MaxEpisodes',maxepisodes, ...
    'MaxStepsPerEpisode',maxsteps, ...
    'Verbose',false,...
    'Plots','training-progress',...
    'StopTrainingCriteria','EpisodeReward',...
    'StopTrainingValue', -1,...
    'SaveAgentCriteria','EpisodeReward',...
    'SaveAgentValue',100);

Opciones de computación paralela

Para entrenar al agente en paralelo, especifique las siguientes opciones de entrenamiento.

1. Establezca la opción UseParallel en true .

2. Al establecer la opción ParallelizationOptions.Mode en " async ", el agente se entrena de forma asincrónica y en paralelo.

3. Cada 30 pasos, cada miembro del personal enviará su experiencia al anfitrión.

4. El agente de DQN requiere que el personal envíe "experiencia" al anfitrión.

trainOpts.UseParallel = true;
trainOpts.ParallelizationOptions.Mode = "async";
trainOpts.ParallelizationOptions.DataToSendFromWorkers = "experiences";
trainOpts.ParallelizationOptions.StepsUntilDataIsSent = 32;

Agente de formación

Utilice la función de entrenamiento para entrenar al agente. La formación de un agente es un proceso computacionalmente intensivo que tarda unos minutos en completarse. Para ahorrar tiempo al ejecutar este ejemplo, cargue el agente previamente entrenado configurando doTraining en falso. Para capacitar al agente usted mismo, configure doTraining en verdadero . Debido a la aleatoriedad del entrenamiento paralelo , puede obtener diferentes resultados de entrenamiento del siguiente cuadro.

doTraining = false;

if doTraining
    % Train the agent.
    trainingStats = train(agent,env,trainOpts);
else
    % Load pretrained agent for the example.
    load('SimulinkLKADQNParallel.mat','agent')
end

Simulación de agente DQN

Para verificar el desempeño del agente capacitado, descomente las siguientes dos líneas y simule el agente en el entorno. Para obtener más información sobre la simulación de agentes, consulte rlSimulationOptions y sim .

% simOptions = rlSimulationOptions('MaxSteps',maxsteps);
% experience = sim(env,agent,simOptions);

Si se produce el error que se muestra en la figura anterior, cree la función localResetFcn.m en el directorio actual y pegue el siguiente código

function in = localResetFcn(in)
% reset
in = setVariable(in,'e1_initial', 0.5*(-1+2*rand)); % random value for lateral deviation
in = setVariable(in,'e2_initial', 0.1*(-1+2*rand)); % random value for relative yaw angle
end

Vuelva a ejecutar el comando de simulación.

Para demostrar el agente entrenado utilizando condiciones iniciales deterministas, simule el modelo en Simulink.

e1_initial = -0.4;
e2_initial = 0.2;
sim(mdl)

Como se muestra a continuación, tanto el error lateral (gráfico central) como el ángulo de guiñada relativo (gráfico inferior) se reducen a cero. El vehículo arranca desde la línea central (–0,4 m) y el error del ángulo de guiñada es distinto de cero (0,2 rad). LKA hace que la bicicleta se mueva a lo largo de la línea central después de 2,5 segundos. El ángulo de dirección (arriba) muestra que el controlador alcanzó un estado estable después de 2 segundos.