MATLAB Reinforcement Learning Toolbox (11) Formation du corps intelligent DDPG pour contrôler le robot volant

Cet exemple montre comment entraîner un agent DDPG (Deep Deterministic Policy Gradient) et générer une trajectoire pour un robot volant.

Modèle de robot volant

L'environnement d'apprentissage par renforcement pour cet exemple est un robot volant dont les conditions initiales sont randomisées autour d'un cercle d'un rayon de 15 m. La direction du robot est également aléatoire. Le robot a deux propulseurs montés sur le côté du corps principal pour pousser et manipuler le robot. Le but de la formation est de conduire le robot de son état initial à son origine face à l'est.

Ouvrez le modèle

mdl = 'rlFlyingRobotEnv';
open_system(mdl)

cliquez pour entrer.

Définissez les variables initiales du modèle.

theta0 = 0;
x0 = -15;
y0 = 0;

Définissez le temps d'échantillonnage Ts et la durée de simulation Tf.

Ts = 0.4;
Tf = 30;

Pour ce modèle:

1. La direction cible est $\theta$ degrés (le robot fait face à l'est).

2. La plage de poussée de chaque actionneur est de -1 à 1 N.

3. On observe depuis l'environnement la position, la direction (sinus et cosinus de la direction), la vitesse et la vitesse angulaire du robot.

4. Récompense $r_t$Ce que chaque pas de temps fournit est
   

Où:
5. $X_t$Est la position du robot le long de l'axe x.
6. ${Oui}_t$Est la position du robot le long de l'axe y.
7. ${\theta }_t$Est la direction du robot.
8. $L_{t-1}$C'est la force de commande du propulseur gauche.
9. $R_{t-1}$C'est la force de commande du propulseur droit.
10. $r_1$C'est la récompense lorsque le robot s'approche de la cible.
11. $r_2$C'est une pénalité pour le robot de parcourir plus de 20 mètres dans la direction x ou y. Lorsque $r_2<A\; 0$ , la simulation est terminée.
12.$r_3$C'est la pénalité QR, qui pénalise la distance par rapport à la cible et l'effet de contrôle.

Créer un modèle intégré

Pour former un agent au modèle FlyingRobotEnv, utilisez la fonction createIntegratedEnv pour générer automatiquement un modèle intégré avec le bloc d'agent RL prêt pour la formation.

integratedMdl = 'IntegratedFlyingRobot';
[~,agentBlk,observationInfo,actionInfo] = createIntegratedEnv(mdl,integratedMdl);

Action et observation

Avant de créer l'objet d'environnement, spécifiez le nom de l'observation et de la spécification d'action, et limitez l'action de poussée entre -1 et 1.

Le signal d'observation de cet environnement est

numObs = prod(observationInfo.Dimension);
observationInfo.Name = 'observations';

Le signal d'action de cet environnement est

numAct = prod(actionInfo.Dimension);
actionInfo.LowerLimit = -ones(numAct,1);
actionInfo.UpperLimit =  ones(numAct,1);
actionInfo.Name = 'thrusts';

Créer une interface d'environnement

Utilisez le modèle intégré pour créer une interface environnementale pour le robot volant.

env = rlSimulinkEnv(integratedMdl,agentBlk,observationInfo,actionInfo);

Fonction de réinitialisation

Créez une fonction de réinitialisation personnalisée qui randomisera la position initiale du robot le long d'un anneau de 15 m de rayon et de la direction initiale. Pour plus d'informations sur la fonction de réinitialisation, consultez flyingRobotResetFcn.

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

Correction de la graine du générateur aléatoire pour améliorer la répétabilité.

rng(0)

Créer un agent DDPG

L'agent DDPG se rapproche de la récompense à long terme pour une observation et une opération données en utilisant la représentation de la fonction de valeur critique. Pour créer un commentateur, vous devez d'abord créer un réseau de neurones profond avec deux entrées (observation et action) et une sortie. Pour plus d'informations sur la création de représentations de fonction de valeur de réseau neuronal, consultez Création de stratégies et de fonctions de valeur .

% Specify the number of outputs for the hidden layers.
hiddenLayerSize = 100; 

observationPath = [
    featureInputLayer(numObs,'Normalization','none','Name','observation')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc1')
    reluLayer('Name','relu1')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc2')
    additionLayer(2,'Name','add')
    reluLayer('Name','relu2')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc3')
    reluLayer('Name','relu3')
    fullyConnectedLayer(1,'Name','fc4')];
actionPath = [
    featureInputLayer(numAct,'Normalization','none','Name','action')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc5')];

% Create the layer graph.
criticNetwork = layerGraph(observationPath);
criticNetwork = addLayers(criticNetwork,actionPath);

% Connect actionPath to observationPath.
criticNetwork = connectLayers(criticNetwork,'fc5','add/in2');

Utilisez rlRepresentationOptions pour spécifier les options du réviseur.

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

Créez une représentation de commentateur à l'aide du réseau de neurones et des options spécifiés. Vous devez également spécifier des spécifications d'exploitation et d'observation pour le réviseur. Pour plus d'informations, consultez rlQValueRepresentation .

critic = rlQValueRepresentation(criticNetwork,observationInfo,actionInfo,...
    'Observation',{
    
    'observation'},'Action',{
    
    'action'},criticOptions);

L'agent DDPG utilise des acteurs pour décider de l'action à entreprendre. Pour créer un personnage, vous devez d'abord créer un réseau de neurones profond avec une entrée (observation) et une sortie (action).

Similaire aux commentateurs, construisez des acteurs. Pour plus d'informations, consultez rlDeterministicActorRepresentation .

actorNetwork = [
    featureInputLayer(numObs,'Normalization','none','Name','observation')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc1')
    reluLayer('Name','relu1')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc2')
    reluLayer('Name','relu2')
    fullyConnectedLayer(hiddenLayerSize,'Name','fc3')
    reluLayer('Name','relu3')
    fullyConnectedLayer(numAct,'Name','fc4')
    tanhLayer('Name','tanh1')];

actorOptions = rlRepresentationOptions('LearnRate',1e-04,'GradientThreshold',1);

actor = rlDeterministicActorRepresentation(actorNetwork,observationInfo,actionInfo,...
    'Observation',{
    
    'observation'},'Action',{
    
    'tanh1'},actorOptions);

Pour créer un agent DDPG, utilisez d'abord rlDDPGAgentOptions pour spécifier les options de l'agent DDPG.

agentOptions = rlDDPGAgentOptions(...
    'SampleTime',Ts,...
    'TargetSmoothFactor',1e-3,...
    'ExperienceBufferLength',1e6 ,...
    'DiscountFactor',0.99,...
    'MiniBatchSize',256);
agentOptions.NoiseOptions.Variance = 1e-1;
agentOptions.NoiseOptions.VarianceDecayRate = 1e-6;

Ensuite, utilisez la représentation d'acteur, la représentation du commentateur et les options d'agent spécifiées pour créer un agent. Pour plus d'informations, consultez rlDDPGAgent .

agent = rlDDPGAgent(actor,critic,agentOptions);

Agent de formation

Pour former l'agent, spécifiez d'abord les options de formation. Pour cet exemple, utilisez les options suivantes:

1. Chaque entraînement est effectué au plus 20 000 tours, et chaque tour dure au maximum des pas de temps ceil (Tf / Ts).

2. Affichez la progression de l'entraînement dans la boîte de dialogue "Gestionnaire d'épisodes" (définissez l'option "Épisode") et désactivez l'affichage de la ligne de commande (définissez l'option "Verbose" sur false).

3. Lorsque la récompense cumulative moyenne obtenue par l'agent au cours de 10 épisodes consécutifs est supérieure à 415, veuillez arrêter la formation. À ce stade, l'agent peut conduire le robot volant vers la position cible.

4. Enregistrez une copie de l'agent pour chaque épisode où la récompense cumulée est supérieure à 415.

maxepisodes = 20000;
maxsteps = ceil(Tf/Ts);
trainingOptions = rlTrainingOptions(...
    'MaxEpisodes',maxepisodes,...
    'MaxStepsPerEpisode',maxsteps,...
    'StopOnError',"on",...
    'Verbose',false,...
    'Plots',"training-progress",...
    'StopTrainingCriteria',"AverageReward",...
    'StopTrainingValue',415,...
    'ScoreAveragingWindowLength',10,...
    'SaveAgentCriteria',"EpisodeReward",...
    'SaveAgentValue',415); 

Utilisez la fonction de formation pour former l'agent. La formation est un processus intensif en calculs qui prend plusieurs heures. Pour gagner du temps en exécutant cet exemple, veuillez charger l'agent pré-entraîné en définissant doTraining sur false. Pour former l'agent vous-même, définissez doTraining sur true.

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

Simulation d'agent DDPG

Pour vérifier les performances de l'agent formé, simulez l'agent dans l'environnement. Pour plus d'informations sur la simulation d'agent, consultez rlSimulationOptions et sim .

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