MATLAB Reinforcement Learning Toolbox (7) Modélisation du modèle de pendule et formation DQN

Cet exemple montre comment créer un modèle pendulaire et l'entraîner avec un réseau d'apprentissage Q profond (DQN).

Modèle de pendule

L'environnement d'apprentissage par renforcement pour cet exemple est un simple pendule sans frottement, initialement suspendu dans une position vers le bas. Le but de l'entraînement est d'utiliser un effort de contrôle minimal pour que le pendule se tienne droit sans tomber.

Ouvrez le modèle

mdl = 'rlSimplePendulumModel';
open_system(mdl)

Pour ce modèle:

1. La position ascendante du pendule d'équilibre est de 0 radians et la position de suspension descendante est $\pi$ radians.
2. Le signal d'action de couple de l'agent vers l'environnement est de –2 à 2 N · m.
3. Le sinus de l'angle du pendule, le cosinus de l'angle du pendule et la dérivée de l'angle du pendule sont observés à partir de l'environnement.
4. Chaque étape fournira une récompense $r_t$

c'est ici:

1. ${\theta }_t$Est l'angle de déplacement par rapport à la position verticale.
2. $\dot{{\theta }_t}$Est la dérivée de l'angle de déplacement.
3. $u_{t-1}$C'est le travail de contrôle du pas de temps précédent.

Créer une interface d'environnement

Créez une interface d'environnement prédéfinie pour le pendule.

env = rlPredefinedEnv('SimplePendulumModel-Discrete')

L'interface a un espace de fonctionnement discret dans lequel l'agent peut appliquer l'une des trois valeurs de couple possibles au pendule: -2, 0 ou 2 N · m.
Pour définir la condition initiale du pendule comme suspendu vers le bas, utilisez la poignée de fonction anonyme pour spécifier la fonction de réinitialisation de l'environnement. Cette fonction de réinitialisation changera la variable d'espace de travail du modèle theta $\theta \; est$ mis à pi.

env.ResetFcn = @(in)setVariable(in,'theta0',pi,'Workspace',mdl);

Obtenir des informations d'observation et de spécification d'action à partir de l'environnement

obsInfo = getObservationInfo(env)

actInfo = getActionInfo(env)

Spécifiez le temps de simulation Tf et le temps d'échantillonnage de l'agent Ts en secondes.

Ts = 0.05;
Tf = 20;

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

rng(0)

Créer un agent DQN

L'agent DQN utilise une fonction de valeur comme commentateur pour estimer les récompenses à long terme basées sur des observations et des actions.

Étant donné que DQN a un espace d'action discret, il peut s'appuyer sur un approximateur critique à sorties multiples, qui est généralement plus efficace que de s'appuyer sur un approximateur à sortie unique comparable. L'approximateur multi-sorties ne prend que les observations en entrée, tandis que le vecteur de sortie a autant d'éléments que possible d'opérandes discrets. Lorsque l'opération discrète correspondante est effectuée, chaque élément de sortie représente la récompense cumulative à long terme attendue dérivée de l'observation d'entrée.

Pour créer un commentateur, créez d'abord un réseau de neurones profond avec un vecteur d'entrée à trois éléments (sinus, cosinus et dérivé pour l'angle de rotation) et un vecteur de sortie avec trois éléments (action –2, 0 ou 2 Nm). Pour plus d'informations sur la création de représentations de fonction de valeur de réseau neuronal profond, consultez Création de représentations de fonction de stratégie et de valeur .

dnn = [
    featureInputLayer(3,'Normalization','none','Name','state')
    fullyConnectedLayer(24,'Name','CriticStateFC1')
    reluLayer('Name','CriticRelu1')
    fullyConnectedLayer(48,'Name','CriticStateFC2')
    reluLayer('Name','CriticCommonRelu')
    fullyConnectedLayer(3,'Name','output')];

Vérifiez la configuration réseau du commentateur.

figure
plot(layerGraph(dnn))

Utilisez rlRepresentationOptions pour spécifier les options représentées par le réviseur.

criticOpts = rlRepresentationOptions('LearnRate',0.001,'GradientThreshold',1);

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

critic = rlQValueRepresentation(dnn,obsInfo,actInfo,'Observation',{
    
    'state'},criticOpts);

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

agentOptions = rlDQNAgentOptions(...
    'SampleTime',Ts,...
    'TargetSmoothFactor',1e-3,...
    'ExperienceBufferLength',3000,... 
    'UseDoubleDQN',false,...
    'DiscountFactor',0.9,...
    'MiniBatchSize',64);

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

agent = rlDQNAgent(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. Un maximum de 1000 épisodes peut être exécuté par entraînement, et chaque épisode peut durer jusqu'à 500 fois.

2. Affichez la progression de la formation dans la boîte de dialogue "Gestionnaire de tracés" (définissez l'option Tracés) 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 pour cinq épisodes consécutifs est supérieure à –1100, veuillez arrêter la formation. À ce stade, l'agent peut rapidement mettre le pendule en position verticale avec une force de contrôle minimale.

4. Enregistrez une copie de l'agent pour chaque épisode avec une récompense cumulée supérieure à –1100.

trainingOptions = rlTrainingOptions(...
    'MaxEpisodes',1000,...
    'MaxStepsPerEpisode',500,...
    'ScoreAveragingWindowLength',5,...
    'Verbose',false,...
    'Plots','training-progress',...
    'StopTrainingCriteria','AverageReward',...
    'StopTrainingValue',-1100,...
    'SaveAgentCriteria','EpisodeReward',...
    'SaveAgentValue',-1100);

Utilisez la fonction de formation pour former l'agent. La formation de cet agent est un processus intensif en calculs qui prend plusieurs minutes. 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('SimulinkPendulumDQNMulti.mat','agent');
end

Simulation d'agent

Pour vérifier les performances d'un agent bien formé, veuillez le simuler dans un environnement pendulaire. Pour plus d'informations sur la simulation d'agent, consultez rlSimulationOptions et sim .

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