Cet article est partagé par la communauté Huawei Cloud « MindSpore Reinforcement Learning : Training using PPO with the environnement HalfCheetah-v2 », auteur : irrationnel.
Half Cheetah est un environnement d'apprentissage par renforcement basé sur MuJoCo, proposé par P. Wawrzyński dans "A Cat-Like Robot Real-Time Learning to Run". Le demi-guépard de cet environnement est un robot 2D composé de 9 maillons et 8 articulations (dont deux griffes). Dans cet environnement, le but est de faire avancer le guépard (vers la droite) le plus vite possible en appliquant un couple sur les articulations, avec des récompenses positives basées sur la distance parcourue et des récompenses négatives pour le recul. Le torse et la tête du guépard sont fixes et le couple ne peut être exercé que sur les cuisses, les mollets et les pieds avant et arrière.
Un espace d'action est un espace Box(-1, 1, (6,), float32)où chaque action représente un couple entre les liens. L'espace d'observation contient les valeurs de position et de vitesse des différentes parties du corps du guépard, où toutes les valeurs de position viennent en premier et toutes les valeurs de vitesse suivent. Par défaut, l'observation n'inclut pas la coordonnée x du centre de masse du guépard, elle peut être exclude_current_positions_from_observation=Falseincluse en la transmettant au moment de la construction. S'il était inclus, l'espace d'observation aurait 18 dimensions, la première dimension représentant la coordonnée x du centre de masse du guépard.
Les récompenses sont divisées en deux parties : les récompenses à terme et les coûts maîtrisés. La récompense à terme est calculée en fonction du changement de la coordonnée x avant et après l'action, et le coût de contrôle est le coût pour punir le guépard pour avoir pris des mesures excessives. La récompense totale est la récompense à terme moins le coût de contrôle.
Chaque état commence par ajouter du bruit à l'état (0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,) pour augmenter le caractère aléatoire du sexe. Les 8 premières valeurs sont des valeurs de position et les 9 dernières valeurs sont des valeurs de vitesse. Les valeurs de position ajoutent un bruit uniforme, tandis que les valeurs de vitesse initiales (toutes des zéros) ajoutent un bruit normal standard.
Lorsque la durée d’un épisode dépasse 1 000, l’épisode sera tronqué.
Des informations détaillées sur cet environnement peuvent être trouvées sur : https://www.gymlibrary.dev/environments/mujoco/half_cheetah/
C’est plus complexe que de nombreux environnements.
Mais peu importe, nous avons l’algorithme ppo, qui peut exécuter un apprentissage par renforcement et même de grands modèles de langage.
L'algorithme PPO (Proximal Policy Optimization) est une méthode d'optimisation de politique pour l'apprentissage par renforcement. Il est conçu pour résoudre le problème de région de confiance dans les méthodes traditionnelles de gradient de politique (telles que TRPO, Trust Region Policy Optimization).
L'algorithme PPO introduit des techniques d'écrêtage et des techniques d'échantillonnage d'importance pour réduire la variance lors du calcul des gradients, améliorant ainsi la vitesse de convergence et la stabilité de l'algorithme.
Dans l’algorithme PPO, il existe deux concepts clés :
- Politique : Une politique est une fonction qui définit la distribution de probabilité d'agir dans un état donné.
- Fonction de valeur : La fonction de valeur estime le retour attendu qui peut être obtenu en partant de l'état s et en atteignant un état ou un terminal spécifique dans le cadre d'une stratégie donnée.
Les principales étapes de l'algorithme PPO comprennent :
- Échantillonnage : échantillonnage des données de la stratégie actuelle, y compris l'état, l'action, la récompense et l'état suivant.
- Calcul des cibles : utilisez la stratégie cible pour calculer la fonction de valeur cible et calculer la divergence KL de la stratégie cible.
- Politique de mise à jour : mettez à jour la politique à l'aide de techniques d'échantillonnage par importance et de techniques de découpage.
- Mise à jour de la fonction de valeur : mettez à jour la fonction de valeur à l'aide de la méthode du gradient de politique.
L'idée centrale de l'algorithme PPO est de mettre à jour alternativement la fonction de stratégie et de valeur pour parvenir à une optimisation conjointe de la stratégie et de la valeur. Cette méthode peut réduire efficacement la variance lors du calcul des gradients et améliorer la vitesse de convergence et la stabilité de l'algorithme.
Ce qui suit est une formule Markdown simplifiée pour l'algorithme PPO :
# Algorithme d'optimisation de politique proximale (PPO) ## 1. Échantillonnage Échantillonnez les données de la politique actuelle, y compris l'état $s$, l'action $a$, la récompense $r$ et l'état suivant $s'$. ## 2. Calcul des objectifs Calculez la fonction de valeur objective en utilisant la politique objective et calculez la divergence KL de la politique objective. ## 3. Mise à jour de la politique Mettre à jour les stratégies à l’aide de techniques d’échantillonnage par importance et de techniques de découpage. ## 4. Mise à jour de la fonction de valeur Mise à jour de la fonction de valeur à l'aide des méthodes de gradient de politique. ## Répétez les étapes 1 à 4 pour parvenir à une optimisation conjointe de la stratégie et de la valeur.
Cette formule est une version simplifiée. En fait, l'algorithme PPO inclut également de nombreux autres détails et techniques, tels que la lecture d'expérience, l'ajustement dynamique du taux d'apprentissage, etc.
importer l'argparse
importez-nous
à partir du contexte d'importation de mindspore
depuis Mindspore importer le type en tant que mstype
depuis mindspore.communication import get_rank, init
importer mindspore_rl.distribution.distribution_policies en tant que DP
à partir de la configuration d'importation mindspore_rl.algorithm.ppo
depuis mindspore_rl.algorithm.ppo.ppo_session importer PPOSession
depuis mindspore_rl.algorithm.ppo.ppo_trainer importer PPOTrainer
parser = argparse.ArgumentParser(description="PPO de renforcement MindSpore")
parser.add_argument("--episode", type=int, default=650, help="numéro total d'épisodes.")
analyseur.add_argument(
"--device_target",
tapez = chaîne,
par défaut="Auto",
choix=["Ascend", "CPU", "GPU", "Auto"],
help="Choisissez un appareil pour exécuter l'exemple ppo (par défaut : Auto).",
)
analyseur.add_argument(
"--precision_mode",
tapez = chaîne,
par défaut="fp32",
choix=["fp32", "fp16"],
help="Mode Précision",
)
analyseur.add_argument(
"--env_yaml",
tapez = chaîne,
par défaut="../env_yaml/HalfCheetah-v2.yaml",
help="Choisissez un environnement yaml pour mettre à jour l'exemple ppo (par défaut : HalfCheetah-v2.yaml).",
)
analyseur.add_argument(
"--algo_yaml",
tapez = chaîne,
par défaut = Aucun,
help="Choisissez un algo yaml pour mettre à jour l'exemple ppo (par défaut : aucun).",
)
analyseur.add_argument(
"--enable_distribute",
tapez = booléen,
par défaut=Faux,
help="Train en mode distribué (Par défaut : False).",
)
analyseur.add_argument(
"--worker_num", type=int, default=2, help="Worker num (par défaut : 2)."
)
analyseur.add_argument(
"--graph_op_run", type=int, default=1, help="Exécuter noyau par noyau (par défaut : 1)."
)
options, _ = parser.parse_known_args()`
wget https://www.roboti.us/download/mujoco200_linux.zip mv mujoco200_linux ~/.mujoco/mujoco200 wget https://www.roboti.us/file/mjkey.txt cp mjkey.txt /home/kewei/.mujoco/mjkey.txt wget https://download-ib01.fedoraproject.org/pub/epel/7/x86_64/Packages/p/patchelf-0.12-1.el7.x86_64.rpm miam localinstall patchelf-0.12-1.el7.x86_64.rpm pip install 'mujoco_py==2.0.2.13'
Il faudra un certain temps pour compiler mujoco pour la première fois.
Ajoutez le contenu suivant à bashrc :
exporter LD_LIBRARY_PATH=$LD_LIBRARY_PATH:~/.mujoco/mujoco200/bin
exporter MUJOCO_KEY_PATH=~/.mujoco${MUJOCO_KEY_PATH}
exporter LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/kewei/.mujoco/mujoco210/bin
exporter LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
Ensuite, vous pouvez commencer la formation. Utilisez with de la section précédente pour conserver l’entrée.
# dqn_session.run(class_type=DQNTrainer, épisode=épisode)
avec RealTimeCaptureAndDisplayOutput() comme capturé_new :
ppo_session.run(class_type=PPOTrainer, épisode=épisode, durée=durée)
Cliquez pour suivre et découvrir les nouvelles technologies de Huawei Cloud dès que possible~
J'ai décidé d'abandonner les logiciels industriels open source. OGG 1.0 est sorti, Huawei a contribué à tout le code source. Ubuntu 24.04 LTS a été officiellement publié. L'équipe de Google Python Foundation a été tuée par la "montagne de merde de code" . ". Fedora Linux 40 a été officiellement lancé. Une société de jeux bien connue a publié de nouvelles réglementations : les cadeaux de mariage des employés ne doivent pas dépasser 100 000 yuans. China Unicom lance la première version chinoise Llama3 8B au monde du modèle open source. Pinduoduo est condamné à compenser 5 millions de yuans pour concurrence déloyale Méthode de saisie dans le cloud domestique - seul Huawei n'a aucun problème de sécurité de téléchargement de données dans le cloud.