Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Former et évaluer les DeepRacer modèles AWS
Lorsque votre DeepRacer véhicule AWS se déplace tout seul sur une piste, il capture l'état de l'environnement à l'aide de la caméra montée à l'avant et prend des mesures en réponse aux observations. Votre DeepRacer modèle AWS est une fonction qui associe les observations et les actions à la récompense attendue. Former votre modèle consiste à rechercher ou découvrir la fonction qui optimise la récompense prévue afin que le modèle optimisé préconise les actions (paires vitesse-angle de direction) que votre véhicule peut effectuer pour se déplacer de manière autonome de la ligne de départ à la ligne d'arrivée.
En pratique, la fonction est représentée par un réseau neuronal. La formation du réseau implique de trouver les influences réseau optimales en fonction de séquences d'états de l'environnement observées et des actions du véhicule en réponse à ces états. Les critères d'optimalité sous-jacents sont décrits par la fonction de récompense du modèle, qui encourage le véhicule à effectuer des déplacements autorisés et efficaces sans provoquer d'accidents ni d'infractions. Une fonction de récompense simple peut renvoyer une récompense de 0 si le véhicule est sur la piste, de -1 s'il est hors piste et de \$11 s'il franchit la ligne d'arrivée. Avec cette fonction de récompense, le véhicule est pénalisé en cas de sortie de piste et récompensé s'il atteint la destination. Cette fonction de récompense peut être satisfaisante si le temps et la vitesse ne sont pas un problème.
Supposons que vous souhaitiez faire rouler le véhicule aussi vite que possible sans sortir d'une piste rectiligne. Au fur et à mesure que le véhicule accélère et ralentit, il peut se diriger vers la gauche ou vers la droite afin d'éviter des obstacles ou pour rester dans les limites. Prendre un virage trop prononcé à grande vitesse peut facilement entraîner le véhicule en dehors de la piste. Prendre un virage trop serré peut ne pas permettre d'éviter une collision avec un obstacle ou un autre véhicule. En règle générale, les actions optimales consistent à prendre un virage plus large en réduisant la vitesse ou à moins braquer dans un virage plus serré. Pour encourager ce comportement, votre fonction de récompense doit attribuer un score positif pour récompenser les petits virages à une vitesse plus élevée, and/or un score négatif pour punir les virages plus importants à une vitesse plus élevée. La fonction de récompense peut également attribuer une récompense positive pour une accélération dans une ligne plus droite ou un ralentissement à proximité d'un obstacle.
La fonction de récompense est un élément important de votre DeepRacer modèle AWS. Vous devez le fournir lors de la formation de votre DeepRacer modèle AWS. La formation implique une répétition d'épisodes de la ligne de départ à la ligne d'arrivée de la piste. Au cours d'un épisode, l'agent interagit avec la piste afin de déduire la suite d'actions optimale, en exploitant qu maximum la récompense cumulée attendue. Au final, la formation produit un modèle d'apprentissage par renforcement. Après la formation, l'agent exécute un pilotage autonome en exécutant l'inférence sur le modèle afin de réagir de manière optimale quelle que soit la situation. Cela peut être fait dans un environnement simulé avec un agent virtuel ou dans un environnement réel avec un agent physique, tel qu'un véhicule à l' DeepRacer échelle AWS.
Dans la pratique, pour former un modèle d'apprentissage par renforcement, vous devez choisir un algorithme d'apprentissage. Actuellement, la DeepRacer console AWS prend uniquement en charge les algorithmes d'optimisation des politiques proximales ([PPO](https://arxiv.org/pdf/1707.06347.pdf)) et de critique des acteurs souples (SAC). Vous pouvez ensuite choisir un framework d'apprentissage profond supportant l'algorithme choisi, sauf si vous souhaitez en écrire un à partir de zéro. AWS DeepRacer s'intègre à l' SageMaker IA pour rendre certains frameworks d'apprentissage en profondeur populaires, tels que [TensorFlow](https://www.tensorflow.org/), facilement disponibles dans la DeepRacer console AWS. L'utilisation d'une infrastructure simplifie la configuration et l'exécution des tâches de formation et vous permet de vous concentrer sur la création et l'amélioration de fonctions de récompense qui répondent à vos problèmes.
La formation d'un modèle d'apprentissage par renforcement est un processus itératif. Tout d'abord, il est difficile de définir une fonction de récompense couvrant simultanément tous les comportements importants d'un agent au sein d'un environnement. Ensuite, les hyperparamètres sont souvent ajustés pour garantir des performances de formation satisfaisantes. Dans les deux cas, l'expérimentation est nécessaire. Une approche prudente consiste à commencer par une fonction de récompense simple, puis à l'améliorer progressivement. AWS DeepRacer facilite ce processus itératif en vous permettant de cloner un modèle entraîné, puis de l'utiliser pour démarrer le cycle de formation suivant. À chaque itération, vous pouvez introduire un ou plusieurs traitements plus sophistiqués dans la fonction de récompense de façon à gérer des variables qui étaient précédemment ignorées, ou vous pouvez ajuster systématiquement les hyperparamètres jusqu'à ce que le résultat converge.
Comme il est d'usage de le faire dans le domaine du Machine Learning, vous devez évaluer un modèle d'apprentissage par renforcement formé pour vérifier son efficacité avant de le déployer sur un agent physique pour exécuter l'inférence dans une situation réelle. Dans le contexte du pilotage autonome, l'évaluation peut être basée sur le temps pendant lequel un véhicule reste sur une piste donnée entre le départ et l'arrivée ou sur le temps qu'il lui faut pour terminer le parcours sans quitter la piste. La DeepRacer simulation AWS vous permet d'exécuter l'évaluation et de publier les indicateurs de performance à des fins de comparaison avec les modèles entraînés par d'autres DeepRacer utilisateurs d'AWS [dans un classement](deepracer-racing-series.md).
**Topics**
+ [
# Comprendre les types de courses et activer les capteurs pris en charge par AWS DeepRacer
](deepracer-choose-race-type.md)
+ [
# Formez et évaluez DeepRacer des modèles AWS à l'aide de la DeepRacer console AWS
](deepracer-console-train-evaluate-models.md)
+ [
# Référence de la fonction de DeepRacer récompense AWS
](deepracer-reward-function-reference.md)
# Comprendre les types de courses et activer les capteurs pris en charge par AWS DeepRacer
Dans AWS DeepRacer League, vous pouvez participer aux types d'événements de course suivants :
+ **Contre la montre** : faites la course contre la montre sur une piste dégagée avec comme but le temps au tour le plus rapide possible.
+ **Évitement d'objets** : faites la course contre la montre sur une piste avec des obstacles immobiles avec comme but le temps au tour le plus rapide possible.
+ **Head-to-bot course** : affrontez un ou plusieurs autres véhicules sur le même circuit et visez à franchir la ligne d'arrivée avant les autres véhicules.
Les courses DeepRacer communautaires AWS ne prennent actuellement en charge que les contre-la-montre.
Vous devez tester différents capteurs sur votre DeepRacer véhicule AWS afin de le doter de capacités suffisantes pour observer son environnement pour un type de course donné. La section suivante décrit les [capteurs DeepRacer compatibles avec AWS](#deepracer-how-it-works-autonomous-driving-sensors) qui peuvent activer les types d'événements de course autonomes pris en charge.
**Topics**
+ [
## Choisissez des capteurs adaptés aux types DeepRacer de courses AWS
](#deepracer-how-it-works-autonomous-driving-sensors)
+ [
## Configuration de l'agent pour la formation DeepRacer des modèles AWS
](#deepracer-configure-agent)
+ [
## Personnalisez la DeepRacer formation AWS pour les contre-la-montre
](#deepracer-get-started-training-simple-time-trial)
+ [
## Personnalisez la DeepRacer formation AWS pour les courses d'évitement d'objets
](#deepracer-get-started-training-object-avoidance)
+ [
## Personnalisez l' DeepRacer entraînement AWS pour les head-to-bot courses
](#deepracer-get-started-training-h2h-racing)
## Choisissez des capteurs adaptés aux types DeepRacer de courses AWS
Votre DeepRacer véhicule AWS est équipé d'une caméra monoculaire orientée vers l'avant comme capteur par défaut. Vous pouvez ajouter une autre caméra monoculaire frontale pour créer un jeu de caméras stéréo frontales, ou compléter la caméra monoculaire ou les caméras stéréo avec une unité LiDAR.
La liste suivante résume les fonctionnalités des capteurs DeepRacer compatibles avec AWS, ainsi que de brèves cost-and-benefit analyses :
**Caméra frontale**
Une caméra frontale mono-objectif peut capturer des images de l'environnement à l'avant du véhicule hôte, y compris les limites et les formes de la piste. Il s'agit du capteur le moins cher qui convient aux tâches de conduite autonome simples, telles que les courses contre la montre sans obstacle sur des pistes bien balisées. Avec une formation appropriée, ce capteur peut éviter des obstacles immobiles à des emplacements fixes sur la piste. Toutefois, les informations sur l'emplacement des obstacles sont intégrées au modèle formé. Par conséquent, le modèle sera probablement surajusté et ne pourra pas être généralisé à d'autres positionnements d'obstacle. Avec des objets immobiles placés à des endroits aléatoires ou d'autres véhicules en mouvement sur la piste, il est peu probable que le modèle converge.
Dans le monde réel, le DeepRacer véhicule AWS est équipé d'une caméra frontale à objectif unique comme capteur par défaut. La caméra a un objectif grand angle de 120 degrés et capture des images RVB qui sont ensuite converties en images en niveaux de gris de 160 x 120 pixels à 15 images par seconde (fps). Ces propriétés de capteur sont préservées dans le simulateur afin d'optimiser les chances que le modèle formé puisse être transféré correctement de la simulation au monde réel.
**Caméra stéréo frontale**
Une caméra stéréo comporte au moins deux objectifs qui capturent des images avec la même résolution et la même fréquence. Les images des deux objectifs permettent de déterminer la profondeur des objets observés. Les informations sur la profondeur provenant d'une caméra stéréo sont précieuses pour que le véhicule hôte évite de percuter les obstacles ou d'autres véhicules devant lui, en particulier dans un environnement plus dynamique. Cependant, avec l'ajout d'informations de profondeur, les formations convergent plus lentement.
Sur le véhicule DeepRacer physique AWS, la caméra stéréo à double objectif est construite en ajoutant une autre caméra à objectif unique et en installant chaque caméra sur les côtés gauche et droit du véhicule. Le DeepRacer logiciel AWS synchronise les captures d'images des deux caméras. Les images capturées sont converties en niveaux de gris, empilées et introduites dans le réseau neuronal pour inférence. Le même mécanisme est dupliqué dans le simulateur afin de former le modèle pour qu'il soit généralisé correctement dans un environnement réel.
**Capteur LiDAR**
Un capteur LiDAR utilise des lasers rotatifs pour envoyer des impulsions lumineuses en dehors du spectre visible et mesurer le temps de retour de chaque impulsion. La direction des objets et la distance aux objets atteints par une impulsion spécifique sont enregistrées en tant que point dans une grande carte 3D centrée autour de l'unité LiDAR.
Par exemple, LiDAR permet de détecter les angles morts du véhicule hôte afin d'éviter les collisions pendant que le véhicule change de voie. En combinant LiDAR avec des caméras mono ou stéréo, vous permettez au véhicule hôte de capturer suffisamment d'informations pour exécuter les actions appropriées. Par contre, un capteur LiDAR coûte plus cher que des caméras. Le réseau neuronal doit apprendre à interpréter les données LiDAR. Les formations prennent donc plus de temps pour converger.
Sur le véhicule DeepRacer physique AWS, un capteur LiDAR est monté à l'arrière et incliné de 6 degrés vers le bas. Il tourne à la vitesse angulaire de 10 rotations par seconde et a une portée de 15 cm à 2 m. Il peut détecter des objets à l'arrière et à côté du véhicule hôte ainsi que des objets en hauteur non masqués par les composants du véhicule à l'avant. L'angle et la portée sont choisis pour rendre l'unité LiDAR moins sensible au bruit ambiant.
Vous pouvez configurer votre DeepRacer véhicule AWS avec la combinaison suivante de capteurs pris en charge :
+ Caméra mono-objectif frontale uniquement.
Cette configuration convient aux courses contre la montre et à l'évitement d'obstacles avec des objets à des emplacements fixes.
+ Caméra stéréo frontale uniquement.
Cette configuration est idéale pour éviter les obstacles avec des objets situés à des endroits fixes ou aléatoires.
+ Caméra mono-objectif frontale avec LiDAR.
Cette configuration est idéale pour éviter les obstacles ou pour les head-to-bot courses.
+ Caméra stéréo frontale avec LiDAR.
Cette configuration est idéale pour éviter les obstacles ou pour les head-to-bot courses, mais elle n'est probablement pas très économique pour les contre-la-montre.
Au fur et à mesure que vous ajoutez de nouveaux capteurs pour permettre à votre DeepRacer véhicule AWS de passer des contre-la-montre à l'évitement d'objets ou aux head-to-bot courses, le véhicule collecte davantage de données sur l'environnement pour alimenter le réseau neuronal sous-jacent lors de l'entraînement. Cela rend la formation plus difficile, car le modèle doit traiter des complexités croissantes. Au final, vos tâches d'apprentissage pour former les modèles deviennent plus exigeantes.
Pour apprendre progressivement, vous devez d'abord commencer à vous entraîner pour les contre-la-montre avant de passer à l'évitement d'objets, puis à la head-to-bot course. Vous trouverez des recommandations plus détaillées dans la section suivante.
## Configuration de l'agent pour la formation DeepRacer des modèles AWS
Pour entraîner un modèle d'apprentissage par renforcement destiné au DeepRacer véhicule AWS en vue de l'évitement d'obstacles ou de la head-to-bot course, vous devez configurer l'agent avec les capteurs appropriés. Pour les courses contre la montre simples, vous pouvez utiliser l'agent par défaut configuré avec une caméra mono-objectif. Lors de la configuration de l'agent, vous pouvez personnaliser l'espace d'action et choisir une topologie de réseau neuronal pour que ceux-ci fonctionnent mieux avec les capteurs sélectionnés afin de répondre aux exigences de pilotage visés. En outre, vous pouvez modifier l'apparence de l'agent pour mieux l'identifier visuellement pendant la formation.
Une fois l'agent configuré, sa configuration est enregistrée dans le cadre des métadonnées du modèle pour la formation et l'évaluation. Pour l'évaluation, l'agent récupère automatiquement la configuration enregistrée pour utiliser les capteurs, l'espace d'action et la technologie de réseau neuronal spécifiés.
Cette section explique les étapes de configuration d'un agent dans la DeepRacer console AWS.
**Pour configurer un DeepRacer agent AWS dans la DeepRacer console AWS**
1. Connectez-vous à la [ DeepRacerconsole AWS](https://console.aws.amazon.com/deepracer).
1. Dans le panneau de navigation principal, choisissez **Garage**.
1. La première fois que vous utilisez **Garage**, la boîte de dialogue **WELCOME TO THE GARAGE (BIENVENUE DANS LE GARAGE)** apparaît. Choisissez **>** ou **<**, parcourez l'introduction aux différents capteurs compatibles avec le DeepRacer véhicule AWS ou choisissez **X** pour fermer la boîte de dialogue. Vous trouverez ces informations de présentation dans le panneau d'aide de **Garage**.
1. Sur la page **Garage**, choisissez **Build new vehicle (Créer un nouveau véhicule)**.
1. Sur la page **Mod your own vehicle (Modéliser votre propre véhicule)**, sous **Mod specifications (Spécifications de modélisation)**, choisissez un ou plusieurs capteurs pour essayer de découvrir la meilleure combinaison pouvant répondre à vos types de course visés.
Pour vous entraîner en vue des essais contre la montre de votre DeepRacer véhicule AWS, choisissez **Camera**. Pour éviter les obstacles ou faire des head-to-bot courses, vous devez utiliser d'autres types de capteurs. Pour choisir un **appareil photo stéréo**, assurez-vous d'avoir acheté un appareil photo mono-objectif supplémentaire. AWS DeepRacer fabrique la caméra stéréo à partir de deux caméras à objectif unique. Vous pouvez disposer d'une caméra mono-objectif ou d'une caméra stéréo double objectif sur un véhicule. Dans les deux cas, vous pouvez ajouter un capteur LiDAR à l'agent si vous souhaitez simplement que le modèle entraîné soit capable de détecter et d'éviter les angles morts lors de l'évitement d'obstacles ou head-to-bot de la course.
1. Sur la page **Garage** et sous **Neural network topologies (Topologies de réseau neuronal)**, choisissez une topologie de réseau prise en charge.
En général, un réseau neuronal plus profond (avec plus de couches) est plus approprié pour rouler sur des pistes plus compliquées avec des courbes serrées et de nombreux virages, pour piloter en évitant des obstacles immobiles, ou pour faire la course avec d'autres véhicules en mouvement. Mais un réseau neuronal plus profond est plus coûteux à former et le modèle prend plus de temps à converger. Par contre, un réseau moins profond (avec moins de couches) coûte moins cher et prend moins de temps à former. Le modèle formé est capable de gérer des conditions de piste ou des exigences de conduite plus simples, comme les courses contre la montre sur une piste sans obstacles et sans concurrents.
Plus précisément, AWS DeepRacer prend en charge le CNN **à 3 couches ou le CNN** **à 5 couches**.
1. Sur la page **Garage**, choisissez **Next (Suivant)** pour procéder à la configuration de l'espace d'action de l'agent.
1. Sur la page **Action space (Espace d'action)**, conservez les paramètres par défaut pour votre première formation. Pour les formations ultérieures, testez différents paramètres pour l'angle de braquage, la vitesse maximale et les granularités correspondantes. Ensuite, choisissez **Suivant**.
1. Sur la page **Colorez votre véhicule pour qu'il se démarque dans la foule**, entrez un **nom dans Nommez votre** véhicule, DeepRacer puis choisissez une couleur pour l'agent dans la liste des **couleurs du véhicule**. Ensuite, choisissez **Submit (Soumettre)**.
1. Sur la page **Garage**, examinez les paramètres du nouvel agent. Pour apporter d'autres modifications, choisissez **Mod vehicle (Modéliser un véhicule)** et répétez les étapes précédentes à partir de l'**étape 4**.
Votre agent est maintenant prêt pour la formation.
## Personnalisez la DeepRacer formation AWS pour les contre-la-montre
Si c'est la première fois que vous utilisez AWS DeepRacer, vous devriez commencer par un simple contre-la-montre pour vous familiariser avec la façon de former des DeepRacer modèles AWS à la conduite de votre véhicule. Vous apprenez ainsi plus en douceur les concepts de base de fonction de récompense, d'agent, d'environnement, etc. Votre objectif est de former un modèle pour que le véhicule reste sur la piste et termine un tour aussi vite que possible. Vous pouvez ensuite déployer le modèle entraîné sur votre DeepRacer véhicule AWS pour tester la conduite sur une piste physique sans capteurs supplémentaires.
Pour entraîner un modèle adapté à ce scénario, vous pouvez choisir l'agent par défaut dans **Garage** sur la DeepRacer console AWS. L'agent par défaut a été configuré avec une seule caméra frontale, un espace d'action par défaut et une topologie de réseau neuronal par défaut. Il est utile de commencer à entraîner un DeepRacer modèle AWS avec l'agent par défaut avant de passer à des modèles plus sophistiqués.
Pour former votre modèle avec l'agent par défaut, suivez les recommandations ci-dessous.
1. Commencez à former votre modèle avec une piste simple avec des formes plus régulières et des virages moins serrés. Utilisez la fonction de récompense par défaut. Et formez le modèle pendant 30 minutes. Une fois la tâche de formation terminée, évaluez votre modèle sur la même piste pour voir si l'agent peut terminer un tour.
1. Lisez les informations sur [les paramètres de la fonction de récompense](deepracer-reward-function-input.md). Continuez la formation avec différentes incitations afin de récompenser l'agent pour le faire aller plus vite. Allongez le temps de formation pour le modèle suivant à 1 à 2 heures. Comparez le graphe de récompense entre la première formation et la seconde. Continuez à expérimenter jusqu'à ce que le graphe de récompense cesse de s'améliorer.
1. Lisez les informations sur l'['espace d'action](deepracer-how-it-works-action-space.md). Entraînez le modèle pour la troisième fois en augmentant la vitesse maximale (par exemple 1 m/s). Pour modifier l'espace d'action, vous devez créer dans **Garage** un nouvel agent lorsque vous avez la possibilité d'effectuer la modification. Lorsque vous mettez à jour la vitesse maximale de votre agent, sachez que plus la vitesse maximale est élevée, plus l'agent peut terminer rapidement la piste en cours d'évaluation et plus vite votre DeepRacer véhicule AWS peut terminer un tour sur une piste physique. Cependant, une vitesse maximale plus élevée signifie souvent un temps plus long pour la convergence de la formation, car l'agent est plus enclin à aller trop vite sur une courbe et donc à sortir de la piste. Vous souhaiterez peut-être diminuer les granularités pour donner à l'agent plus d'espace pour accélérer ou décélérer et ajuster davantage la fonction de récompense d'autres façons pour que la formation converge plus rapidement. Une fois que la formation converge, évaluez le 3e modèle pour voir si le temps au tour s'améliore. Continuez à explorer jusqu'à ce qu'il n'y ait plus d'amélioration.
1. Choisissez une piste plus compliquée et répétez l'**étape 1** à l'**étape 3**. Évaluez votre modèle sur une piste différente de celle que vous avez utilisée pour la formation afin de voir comment le modèle peut être généralisé à différentes pistes virtuelles, puis être [généralisé à des environnements réels](deepracer-how-it-works-virtual-to-physical.md).
1. (Facultatif) Testez différentes valeurs des [hyperparamètres](deepracer-console-train-evaluate-models.md#deepracer-iteratively-adjust-hyperparameters) pour améliorer le processus de formation et répétez l'**étape 1** à l'**étape 3**.
1. (Facultatif) Examinez et analysez les DeepRacer journaux AWS. Pour un exemple de code que vous pouvez utiliser pour analyser les journaux, voir [https://github.com/aws-samples/aws-deepracer-workshops/tree/master/log-analysis](https://github.com/aws-samples/aws-deepracer-workshops/tree/master/log-analysis).
## Personnalisez la DeepRacer formation AWS pour les courses d'évitement d'objets
Après vous être familiarisé avec les courses contre la montre et avoir formé quelques modèles convergés, passez au prochain défi plus exigeant : l'évitement d'obstacles. Là, votre objectif est de former un modèle capable de terminer un tour aussi vite que possible sans quitter la piste, tout en évitant de percuter les objets placés sur la piste. Il s'agit évidemment d'un problème plus difficile pour l'apprentissage de l'agent et la formation prend plus de temps pour converger.
La DeepRacer console AWS prend en charge deux types d'entraînement à l'évitement d'obstacles : les obstacles peuvent être placés à des endroits fixes ou aléatoires le long de la piste. Avec des emplacements fixes, les obstacles restent positionnés au même endroit tout au long de la tâche de formation. Avec des emplacements aléatoires, les obstacles changent de place de façon aléatoire d'un épisode à un autre.
Les formations peuvent plus facilement converger pour l'évitement d'obstacles à des emplacements fixes, car le système dispose de moins de degrés de liberté. Toutefois, les modèles peuvent être surajustés lorsque les informations de localisation sont intégrées aux modèles formés. De ce fait, ils risquent de ne pas être généralisés correctement. Pour l'évitement d'obstacles placés à des endroits aléatoires, Les formations peuvent plus difficilement converger, car l'agent doit continuer à apprendre à éviter de percuter des obstacles à des emplacements qu'il n'a pas vus auparavant. Par contre, les modèles formés avec cette option ont tendance à mieux se généraliser et à être transféré correctement aux courses du monde réel. Pour commencer, placez les obstacles à des endroits fixes, familiarisez-vous avec les comportements, puis attaquez-vous aux emplacements aléatoires.
Dans le DeepRacer simulateur AWS, les obstacles sont des boîtes cuboïdes aux mêmes dimensions (9,5 pouces (L) x 15,25 pouces (L) x 10/5 pouces (H)) que la boîte d'emballage du véhicule AWS. DeepRacer Il est ainsi plus simple de transférer le modèle formé du simulateur vers le monde réel si vous placez la boîte d'emballage en tant qu'obstacle sur la piste physique.
Pour vous entraîner à l'évitement d'obstacle, suivez la pratique recommandée décrite dans les étapes ci-dessous :
1. Utilisez l'agent par défaut ou testez avec de nouveaux capteurs et espaces d'action en personnalisant un agent existant ou en créant un nouveau. Vous devez limiter la vitesse maximale à moins de 0,8 m/s et la granularité de la vitesse à 1 ou 2 niveaux.
Commencez à former un modèle pendant environ 3 heures avec 2 objets à des emplacements fixes. Utilisez l'exemple de fonction de récompense et formez le modèle sur la piste sur laquelle vous allez courir, ou sur une piste qui y ressemble beaucoup. Le circuit **AWS DeepRacer Smile Speedway (intermédiaire)** est un circuit simple, ce qui en fait un bon choix pour la préparation des courses au sommet. Évaluez le modèle sur la même piste avec le même nombre d'obstacles. Regardez comment la récompense totale attendue converge, le cas échéant.
1. Lisez les informations sur [les paramètres de la fonction de récompense](deepracer-reward-function-input.md). Testez des variations de votre fonction de récompense. Augmentez le nombre d'obstacles à 4. Formez l'agent pour voir si la formation converge dans la même durée de formation. Si ce n'est pas le cas, modifiez à nouveau votre fonction de récompense, diminuez la vitesse maximale ou réduisez le nombre d'obstacles, puis formez à nouveau l'agent. Répétez l'expérimentation jusqu'à ce qu'il n'y ait plus d'amélioration significative.
1. Ensuite, passez à la formation à l'évitement d'obstacles à des emplacements aléatoires. Vous devrez configurer l'agent à l'aide de capteurs supplémentaires, disponibles auprès de **Garage** dans la DeepRacer console AWS. Vous pouvez utiliser une caméra stéréo. Vous pouvez également combiner une unité LiDAR avec une caméra mono-objectif ou une caméra stéréo, mais vous devez vous attendre à un temps de formation plus long. Réglez l'espace d'action avec une vitesse maximale relativement faible (par exemple 2 m/s) pour que l'entraînement converge plus rapidement. Pour l'architecture de réseau, utilisez un réseau neuronal peu profond, qui s'est avéré suffisant pour éviter les obstacles.
1. Commencez à former le nouvel agent à l'évitement d'obstacles pendant 4 heures avec 4 objets placés de façon aléatoire sur une piste simple. Ensuite, évaluez votre modèle sur la même piste pour voir s'il peut terminer des tours avec des obstacles positionnés de façon aléatoire. Si ce n'est pas le cas, vous pouvez peaufiner votre fonction de récompense, essayer différents capteurs et allonger la durée de formation. Un autre conseil, vous pouvez essayer de cloner un modèle existant pour continuer la formation en tirant parti de l'expérience acquise précédemment.
1. (Facultatif) Choisissez une vitesse maximale plus élevée pour l'espace d'action ou placez plus d'obstacles de façon aléatoire sur la piste. Testez différentes combinaisons de capteurs, et ajustez les fonctions de récompense et les valeurs des hyperparamètres. Testez la topologie de réseau **CNN à 5 couches**. Ensuite, formez à nouveau le modèle pour déterminer comment ces paramètres affectent la convergence de la formation.
## Personnalisez l' DeepRacer entraînement AWS pour les head-to-bot courses
Après avoir suivi l'entraînement pour éviter les obstacles, vous êtes maintenant prêt à relever le défi suivant : les modèles d'entraînement pour les head-to-bot courses. Contrairement aux épreuves d'évitement d'obstacles, les head-to-bot courses se déroulent dans un environnement dynamique avec des véhicules en mouvement. Votre objectif est d'entraîner des modèles pour votre DeepRacer véhicule AWS afin qu'ils puissent affronter d'autres véhicules en mouvement afin d'atteindre la ligne d'arrivée en premier sans sortir de la piste ni percuter un autre véhicule. Dans la DeepRacer console AWS, vous pouvez entraîner un modèle de head-to-bot course en demandant à votre agent d'affronter 1 à 4 véhicules robots. Généralement, vous devriez avoir plus d'obstacles placés sur une piste plus longue.
Chaque véhicule bot suit une trajectoire prédéfinie à vitesse constante. Vous pouvez lui permettre de changer de voie ou de rester sur sa voie de départ. Comme pour la formation à l'évitement d'obstacles, vous pouvez répartir uniformément les véhicules bots sur la piste dans les deux voies. La console vous limite à 4 véhicules robots sur la piste. En ayant plus de véhicules sur la piste, vous offrez à l'agent d'apprentissage plus d'occasions de se confronter à des situations plus variées avec les autres véhicules. De cette façon, il apprend plus en une tâche de formation et il se forme plus rapidement. Cependant, chaque formation risque de prendre plus de temps pour converger.
Pour former un agent avec des véhicules bots, vous devez définir la vitesse maximale de l'espace d'action de l'agent à une valeur plus élevée que la vitesse (constante) des véhicules bots afin que l'agent ait plus d'occasions de dépassement lors de la formation. Comme bon point de départ, vous devez régler la vitesse maximale de l'agent à 0,8 m/s et la vitesse de déplacement du véhicule robot à 0,4 m/s. Si vous permettez aux bots de changer de voie, la formation devient plus difficile, car l'agent doit apprendre non seulement à éviter de percuter un véhicule en mouvement devant lui sur la même voie, mais aussi à éviter de heurter un autre véhicule en mouvement devant lui sur l'autre voie. Vous pouvez définir les bots de sorte qu'ils changent de voie à intervalles aléatoires. La durée d'un intervalle est sélectionnée de manière aléatoire dans une plage de temps (par exemple 1 à 5 s) que vous spécifiez avant de commencer le travail de formation. Ce comportement de changement de voie est plus similaire aux comportements de head-to-bot course réels et l'agent entraîné devrait mieux générer. Cependant, il faut plus de temps pour former le modèle à converger.
Suivez ces étapes suggérées pour améliorer votre entraînement en vue de la head-to-bot course :
1. Dans le **garage** de la DeepRacer console AWS, créez un nouvel agent de formation configuré à la fois avec des caméras stéréo et une unité LiDAR. Il est possible de former un modèle relativement correct en utilisant uniquement une caméra stéréo avec des véhicules bots. LiDAR aide à réduire les angles morts lorsque l'agent change de voie. Ne définissez pas une vitesse maximale trop élevée. 1 m/s constitue un bon point de départ.
1. Pour vous entraîner en head-to-bot vue de la course, commencez avec deux véhicules robots. Réglez la vitesse de déplacement du bot à une vitesse inférieure à la vitesse maximale de votre agent (par exemple 0,5 m/s si la vitesse maximale de l'agent est de 1 m/s). Désactivez l'option de changement de voie, puis choisissez l'agent de formation que vous venez de créer. Utilisez l'un des exemples de fonction de récompense ou apportez les modifications minimales nécessaires, puis formez le modèle pendant 3 heures. Utilisez la piste sur laquelle vous allez courir, ou une piste qui y ressemble beaucoup. Le circuit **AWS DeepRacer Smile Speedway (intermédiaire)** est un circuit simple, ce qui en fait un bon choix pour la préparation des courses au sommet. Une fois la formation terminée, évaluez le modèle formé sur la même piste.
1. Pour les tâches plus difficiles, clonez votre modèle entraîné pour en faire un deuxième modèle de head-to-bot course. Continuez à expérimenter avec plus de véhicules bots ou activez des options de changement de voie. Commencez par des opérations de changement de voie lentes à des intervalles aléatoires de plus de 2 secondes. Vous pouvez également tester des fonctions de récompense personnalisées. En général, votre logique de fonction de récompense personnalisée peut être similaire à celle pour l'évitement d'obstacles, si vous ne cherchez pas à trouver un équilibre entre dépasser d'autres véhicules et rester sur la piste. Selon la qualité de votre modèle précédent, vous devrez peut-être vous former encore pendant 3 à 6 heures. Évaluez vos modèles et voyez comment le modèle fonctionne.
# Formez et évaluez DeepRacer des modèles AWS à l'aide de la DeepRacer console AWS
Pour entraîner un modèle d'apprentissage par renforcement, vous pouvez utiliser la DeepRacer console AWS. Dans la console, créez une tâche de formation, choisissez une infrastructure prise en charge et un algorithme disponible, ajoutez une fonction de récompense et configurez les paramètres de formation. Vous pouvez également observer l'exécution de la formation dans un simulateur. Vous trouverez les step-by-step instructions dans[Formez votre premier DeepRacer modèle AWS](deepracer-get-started-training-model.md).
Cette section explique comment former et évaluer un DeepRacer modèle AWS. Elle explique également la création et l'amélioration d'une fonction de récompense, l'impact de l'espace d'action sur les performances d'un modèle ainsi que l'impact des hyperparamètres sur l'efficacité de la formation. Vous pouvez également apprendre à cloner un modèle de formation afin d'étendre une session de formation, à utiliser le simulateur pour évaluer les performances de la formation et à adapter la simulation aux défis des situations réelles.
**Topics**
+ [
## Créez votre fonction de récompense
](#deepracer-train-models-define-reward-function)
+ [
## Explorez l'espace d'action pour former un modèle robuste
](#deepracer-define-action-space-for-training)
+ [
## Régler systématiquement les hyperparamètres
](#deepracer-iteratively-adjust-hyperparameters)
+ [
## Examiner l'avancement DeepRacer des tâches de formation AWS
](#deepracer-examine-training-progress)
+ [
## Clonez un modèle entraîné pour commencer une nouvelle passe d'entraînement
](#deepracer-clone-trained-model)
+ [
## Évaluer les DeepRacer modèles AWS dans le cadre de simulations
](#deepracer-evaluate-models-in-simulator)
+ [
## Optimisez les DeepRacer modèles AWS de formation pour les environnements réels
](#deepracer-evaluate-model-test-approaches)
## Créez votre fonction de récompense
Une [fonction de récompense](deepracer-reward-function-reference.md) décrit un feedback immédiat (sous forme de récompense ou de score de pénalité) lorsque votre DeepRacer véhicule AWS passe d'une position sur la piste à une nouvelle position. La fonction vise à encourager le véhicule à se déplacer le long de la piste pour atteindre une destination rapidement, sans accident ni infraction. Un déplacement préféré entraîne un score plus élevé pour l'action ou son état cible. Un déplacement illégal ou inefficace entraîne un score inférieur. Lors de la formation d'un DeepRacer modèle AWS, la fonction de récompense est le seul élément spécifique à l'application.
En général, vous concevez votre fonction de récompense comme un programme incitatif. Les différentes stratégies incitatives peuvent entraîner différents comportements du véhicule. Pour que le véhicule aille plus vite, la fonction doit accorder une récompense lorsque le véhicule suit la piste. La fonction doit donner des pénalités lorsque le véhicule effectue un tour trop lentement ou sort de la piste. Pour éviter les zig-zags, la fonction peut récompenser le véhicule s'il effectue moins de changements de direction sur les lignes les plus droites de la piste. La fonction de récompense peut accorder des scores positifs lorsque le véhicule atteint des points intermédiaires, mesurés par les [`waypoints`](deepracer-reward-function-input.md). Cela permet de réduire l'attente ou d'éviter de prendre la mauvaise direction. Il est également possible de modifier la fonction de récompense pour tenir compte des conditions de la piste. Cependant, plus votre fonction de récompense prend en compte les informations spécifiques à l'environnement, plus votre modèle formé est trop spécialisé et précis. Pour que votre modèle soit plus généralement applicable, vous pouvez explorer la notion d'[espace d'action](#deepracer-define-action-space-for-training).
S'il n'est pas soigneusement réfléchi, un programme incitatif peut entraîner [un effet inverse à celui souhaité et des conséquences inattendues](https://en.wikipedia.org/wiki/Cobra_effect). En effet, les retombées immédiates constituent une condition nécessaire, mais qui n'est pas suffisante pour l'apprentissage par renforcement. En soi, une récompense immédiate individuelle ne permet pas non plus de déterminer si le déplacement est un déplacement préféré. À une position donnée, un déplacement peut entraîner une récompense, mais provoquer une sortie de piste lors du déplacement suivant, ce qui entraîne un score faible. Dans ce cas, le véhicule doit éviter le déplacement entraînant une récompense à cette position. Un déplacement doit être considéré comme préféré seulement lorsque tous les déplacements futurs à partir d'une position donné permettent d'obtenir une récompense moyenne élevée. Les retombées futures font l'objet d'une remise qui autorise de prendre en compte uniquement un petit nombre de positions ou de déplacements futurs dans le calcul de la récompense moyenne.
Pour créer une [fonction de récompense](deepracer-reward-function-reference.md), une bonne pratique consiste à commencer par une fonction simple qui couvre des scénarios élémentaires. Vous pouvez perfectionner la fonction afin de prendre en charge un plus grand nombre d'actions. Examinons maintenant quelques fonctions de récompense simples.
**Topics**
+ [
### Exemples simples de fonctions de récompense
](#deepracer-reward-function-simple-examples)
+ [
### Améliorez votre fonction de récompense
](#deepracer-iteratively-enhance-reward-functions)
### Exemples simples de fonctions de récompense
Nous pouvons commencer à créer la fonction de récompense à partir de la situation la plus élémentaire possible : piloter une sur piste rectiligne de la ligne de départ à la ligne d'arrivée, sans sortir de la piste. Dans ce scénario, la logique de la fonction de récompense dépend uniquement de `on_track` et de `progress`. À titre d'expérimentation, vous pouvez commencer avec la logique suivante :
```
def reward_function(params):
if not params["all_wheels_on_track"]:
reward = -1
else if params["progress"] == 1 :
reward = 10
return reward
```
Cette logique pénalise l'agent lorsqu'il sort de la piste. Elle récompense l'agent lorsqu'il passe la ligne d'arrivée. Compte tenu de l'objectif défini, cette logique est acceptable. Toutefois, l'agent erre librement entre la ligne de départ et la ligne d'arrivée, par exemple en roulant en sens inverse. Cela signifie non seulement que la formation risque de prendre beaucoup de temps, mais aussi que le modèle formé limitera l'efficacité de la conduite une fois qu'il aura été déployé sur un véhicule réel.
Dans la pratique, un agent apprend plus efficacement s'il peut le faire bit-by-bit tout au long de la formation. Cela signifie qu'une fonction de récompense doit distribuer des récompenses plus petites, étape par étape, tout le long du parcours. Pour permettre à l'agent d'évoluer sur la piste rectiligne, nous pouvons améliorer la fonction de récompense comme suit :
```
def reward_function(params):
if not params["all_wheels_on_track"]:
reward = -1
else:
reward = params["progress"]
return reward
```
Avec cette fonction, plus l'agent se rapproche de la ligne d'arrivée, plus il reçoit de récompenses. Cela vise à réduire ou à éliminer les essais improductifs de déplacement en sens inverse. En général, la fonction de récompense doit mieux répartir les récompenses dans l'espace d'action. Créer une fonction de récompense efficace peut être une tâche ardue. Vous devez commencer par une fonction simple que vous améliorerez et perfectionnerez progressivement. En procédant à une expérimentation systématique, la fonction peut devenir plus fiable et efficace.
### Améliorez votre fonction de récompense
Une fois que vous avez entraîné avec succès votre DeepRacer modèle AWS à la voie simple, le DeepRacer véhicule AWS (virtuel ou physique) peut se déplacer tout seul sans quitter la piste. Si vous faites circuler le véhicule sur une piste en anneau, il ne restera pas sur la piste. La fonction de récompense a ignoré les actions permettant de prendre les virages et de suivre la piste.
Pour que votre véhicule gère ces actions, vous devez perfectionner la fonction de récompense. La fonction doit accorder une récompense lorsque l'agent effectue un virage autorisé et donner une pénalité si l'agent effectue un changement de direction interdit. Vous êtes ensuite prêt à démarrer une autre phase de formation. Pour mettre à profit la formation précédente, vous pouvez démarrer la nouvelle formation en clonant le modèle précédemment entraîné, ce qui permet de transmettre les connaissances acquises précédemment. Vous pouvez suivre ce modèle pour ajouter progressivement de nouvelles fonctionnalités à la fonction de récompense afin d'entraîner votre DeepRacer véhicule AWS à conduire dans des environnements de plus en plus complexes.
Pour des fonctions de récompense plus avancées, veuillez consulter les exemples suivants :
+ [Exemple 1 : suivre la ligne centrale dans les contre-la-montre](deepracer-reward-function-examples.md#deepracer-reward-function-example-0)
+ [Exemple 2 : rester à l'intérieur des deux frontières pendant les contre-la-montre](deepracer-reward-function-examples.md#deepracer-reward-function-example-1)
+ [Exemple 3 : éviter le zig-zag dans les contre-la-montre](deepracer-reward-function-examples.md#deepracer-reward-function-example-2)
+ [Exemple 4 : restez sur une voie sans percuter des obstacles immobiles ou des véhicules en mouvement](deepracer-reward-function-examples.md#deepracer-reward-function-example-3)
## Explorez l'espace d'action pour former un modèle robuste
En règle générale, vous devez former votre modèle afin qu'il soit le plus fiable possible pour que vous puissiez l'appliquer au plus grand nombre d'environnements possibles. Un modèle fiable est un modèle qui peut être appliqué à un large éventail de formes et de conditions de piste. En règle générale, un modèle fiable n'est pas « intelligent », car sa fonction de récompense n'est pas en mesure de contenir des connaissances explicites spécifiques à l'environnement. Sinon, votre modèle serait alors susceptible d'être applicable uniquement à un environnement similaire à celui de la formation.
L'intégration d'informations spécifiques à l'environnement explicitement dans la fonction de récompense s'apparente à l'ingénierie de fonctionnalité. L'ingénierie de fonctionnalité contribue à réduire le temps de formation et peut s'avérer utile dans des solutions adaptées à un environnement spécifique. Mais pour former un modèle généralement applicable, vous devez éviter de trop y recourir.
Par exemple, lorsque vous formez un modèle sur une piste en anneau, vous ne pouvez pas espérer obtenir un modèle formé applicable à n'importe quelle piste non circulaire si ces propriétés géométriques sont explicitement intégrées dans la fonction de récompense.
Comment est-il possible de former le modèle le plus fiable possible, tout en préservant une fonction de récompense la plus simple possible ? L'une des solutions consiste à explorer l'espace d'action qui couvre les actions pouvant être effectuées par votre agent. Une autre solution consiste à tester les [hyperparamètres](#deepracer-iteratively-adjust-hyperparameters) de l'algorithme de formation sous-jacent. Vous optez souvent pour les deux solutions. Ici, nous nous concentrons sur la manière d'explorer l'espace d'action pour créer un modèle robuste pour votre DeepRacer véhicule AWS.
Lors de l'entraînement d'un DeepRacer modèle AWS, une action (`a`) est une combinaison de vitesse (`t`mètres par seconde) et d'angle de braquage (`s`en degrés). L'espace d'action de l'agent définit les plages de vitesse et d'angle de direction que l'agent peut utiliser. Pour un espace d'action distinct d'un nombre de vitesses `m` `(v1, .., vn)` et d'un nombre d'angles de direction `n`, `(s1, .., sm)`, il existe `m*n` actions possibles dans l'espace d'action :
```
a1: (v1, s1)
...
an: (v1, sn)
...
a(i-1)*n+j: (vi, sj)
...
a(m-1)*n+1: (vm, s1)
...
am*n: (vm, sn)
```
Les valeurs réelles de `(vi, sj)` dépendent des plages de `vmax` et de `|smax|` et ne sont pas réparties uniformément.
Chaque fois que vous commencez à entraîner ou à itérer votre DeepRacer modèle AWS, vous devez d'abord spécifier `vmax` les `n``m`, `|smax|` et/ou accepter d'utiliser leurs valeurs par défaut. En fonction de votre choix, le DeepRacer service AWS génère les actions disponibles que votre agent peut choisir pendant la formation. Les actions générées ne sont pas réparties uniformément sur l'espace d'action.
En général, lorsque votre agent dispose d'un plus grand nombre d'actions et de plages d'action plus larges, il bénéficie d'un plus grand espace ou de plus d'options qui lui permettent de réagir à des conditions de piste plus variées, par exemple une piste courbe avec des directions ou des angles de virage irréguliers. Plus l'agent dispose d'options, plus il peut être réactif pour gérer les variations d'une piste. Le modèle formé sera alors plus largement applicable, même si vous utilisez une fonction de récompense simple.
Votre agent peut par exemple apprendre rapidement à gérer une piste linéaire à l'aide d'un espace d'action approximatif avec petit nombre de vitesses et d'angles de direction. Dans une piste courbe, l'agent risque d'aller trop loin et de sortir de la piste dans un virage si l'espace d'action est approximatif. Il dispose en effet de trop peu d'options pour ajuster la vitesse ou la direction. Si vous augmentez le nombre de vitesses ou le nombre d'angles de direction, ou les deux, l'agent sera plus à même de gérer les courbes tout en restant sur la piste. De la même façon, si votre agent se met à se déplacer en zig-zag, vous pouvez essayer d'augmenter le nombre de plages de direction pour limiter les virages serrés répétés.
Lorsque l'espace d'action est trop grand, les performances de la formation peuvent en pâtir : il faut en effet plus de temps pour l'explorer. Veillez à trouver l'équilibre entre les avantages d'un modèle applicable généralement et les exigences en matière de performances de la formation du modèle. Cette optimisation implique de procéder à une expérimentation systématique.
## Régler systématiquement les hyperparamètres
Pour améliorer les performances de votre modèle, vous pouvez adopter un processus de formation plus efficace ou de meilleure qualité. Par exemple, pour obtenir un modèle fiable, la formation doit proposer à votre agent un échantillonnage réparti assez uniformément sur l'espace d'action de l'agent. Pour cela, l'exploration et l'exploitation doivent être suffisantes. Les variables qui ont un impact sont notamment la quantité de données de formation utilisées (`number of episodes between each training` et `batch size`), la vitesse d'apprentissage de l'agent (`learning rate`), la portion de l'exploration (`entropy`). Pour que la formation soit pratique, il peut être judicieux d'accélérer le processus d'apprentissage. Les variables ayant un impact sont notamment `learning rate`, `batch size`, `number of epochs` et `discount factor`.
Les variables ayant un impact sur le processus de formation sont appelées les hyperparamètres de la formation. Ces attributs d'algorithme ne sont pas des propriétés du modèle sous-jacent. Malheureusement, par nature, les hyperparamètres sont empiriques. Leurs valeurs optimales ne sont pas connues pour tous les usages pratiques et doivent faire l'objet d'une expérimentation systématique pour être dérivées.
Avant de discuter des hyperparamètres qui peuvent être ajustés pour optimiser les performances de formation de votre DeepRacer modèle AWS, définissons la terminologie suivante.
Point de données
Un point de données, également connu sous le nom d'*expérience*, est un tuple de (*s,a,r,s’*), où *s* représente une observation (ou état) capturée par la caméra, *a* une action effectuée par le véhicule, *r* la récompense prévue liée à l'action concernée et *s’* la nouvelle observation après l'action.
Épisode
Un épisode est une période pendant laquelle le véhicule démarre d'un point de départ et termine soit après avoir parcouru toute la piste, soit à cause d'une sortie de piste. Il représente une suite d'expériences. Différents épisodes peuvent avoir des longueurs différentes.
Tampon d'expérience
Un tampon d'expérience se compose d'un certain nombre de points de données triés collectés pendant un nombre d'épisodes fixe de différentes longueurs pendant la formation. Pour AWS DeepRacer, il correspond aux images capturées par la caméra montée sur votre DeepRacer véhicule AWS et aux actions entreprises par le véhicule. Il sert de source à partir de laquelle les données sont tirées pour mettre à jour les réseaux neuronaux sous-jacents (politiques et valeurs).
Par lots
Un lot est une liste triée d'expériences, qui représente une partie d'une simulation sur une période donnée, utilisée pour mettre à jour les pondérations du réseau de politique. C'est un sous-ensemble du tampon d'expérience.
Données d'entraînement
Une donnée de formation est un ensemble de lots de données échantillonnés de façon aléatoire à partir d'un tampon d'expérience et utilisé pour la former les pondérations du réseau de politique.
**Hyperparamètres algorithmiques et leurs effets**
| Hyperparamètres | Description |
| --- | --- |
| **Gradient descent batch size (Taille de lot pour la descente de gradient)** | Nombre d'expériences de véhicules récentes échantillonnées de façon aléatoire à partir d'un tampon d'expérience et utilisées pour mettre à jour les pondérations du réseau neuronal de deep learning sous-jacents. L'échantillonnage aléatoire contribue à réduire les corrélations inhérentes dans les données d'entrée. Utilisez une taille de lot plus grande pour promouvoir des mises à jour plus stables et fluides des pondérations du réseau neuronal, mais sachez que cela peut ralentir et allonger la formation.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| **Number of epochs (Nombre d'époques) ** | Nombre de transmissions des données de formation pour mettre à jour les pondérations du réseau neuronal pendant la descente de gradient. Les données de formation correspondent à des échantillons aléatoires du tampon d'expérience. Utilisez un plus grand nombre d'époques pour promouvoir des mises à jour plus stables, mais sachez que cela peut ralentir la formation. Lorsque le lot est de petite taille, vous pouvez utiliser un nombre d'époques inférieur[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| **Learning rate (Taux d'apprentissage) ** | À chaque mise à jour, une partie de la nouvelle pondération peut provenir de la descente (ou ascension) de gradient et le reste de la valeur de pondération existante. Le taux d'apprentissage contrôle dans quelle mesure la mise à jour d'une descente (ou ascension) de gradient contribue aux pondérations du réseau. Utilisez un taux d'apprentissage plus élevé pour inclure plus de contributions de descente de gradient afin d'accélérer la formation, mais sachez que la récompense prévue peut ne pas converger si le taux d'apprentissage est trop élevé. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| Entropy | Degré d'incertitude utilisé pour déterminer quand ajouter un caractère aléatoire à la distribution de la politique. L'incertitude ajoutée aide le DeepRacer véhicule AWS à explorer l'espace d'action de manière plus large. Une valeur d'entropie plus élevée encourage le véhicule à explorer plus minutieusement l'espace d'action. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| Discount factor (Facteur d'actualisation) | Facteur précisant l'importance de la contribution de la future récompense à la récompense attendue. Plus la valeur de **Discount factor (Facteur d'actualisation)** est élevée, plus le véhicule prend en compte les contributions les plus éloignées pour effectuer un déplacement, et plus la formation est lente. Avec un facteur d'actualisation de 0,9, le véhicule inclut les récompenses de 10 étapes futures pour effectuer un déplacement. Avec un facteur d'actualisation de 0,999, le véhicule inclut les récompenses de 1 000 étapes futures pour effectuer un déplacement. Les valeurs de facteur d'actualisation recommandées sont 0,99, 0,999 et 0,9999. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| Loss type (Type de perte) | Type de la fonction objective utilisée pour mettre à jour les pondérations de réseau. Un bon algorithme de formation doit apporter des modifications incrémentielles à la stratégie de l'agent de sorte que les actions aléatoires cèdent progressivement la place à des actions stratégiques pour accroître la récompense. Mais si la modification est trop importante, la formation devient instable et l'agent n'apprend plus. Les types [https://en.wikipedia.org/wiki/Huber_loss](https://en.wikipedia.org/wiki/Huber_loss) et [https://en.wikipedia.org/wiki/Mean_squared_error](https://en.wikipedia.org/wiki/Mean_squared_error) affichent un comportement similaire pour les petites mises à jour. Mais à mesure que les mises à jour gagnent en importance, le type **Huber loss (Perte Huber)** prend des incréments plus petits comparé à **Mean squared error loss (Perte d'erreur quadratique moyenne)**. En cas de problèmes de convergence, utilisez le type **Huber loss (Perte Huber)**. Lorsque la convergence est bonne et que vous voulez former plus rapidement, utilisez le type **Mean squared error loss (Perte d'erreur quadratique moyenne)**. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| Nombre d'épisodes d'expérience entre chaque itération de mise à jour de politique | Taille du tampon d'expérience utilisé pour extraire les données de formation pour les pondérations du réseau de politique d'apprentissage. Un épisode d'expérience est une période pendant laquelle l'agent démarre d'un point de départ et termine soit après avoir parcouru toute la piste, soit à cause d'une sortie de piste. Il se compose d'une suite d'expériences. Différents épisodes peuvent avoir des longueurs différentes. Pour les problèmes d'apprentissage par renforcement simples, un petit tampon d'expérience peut être suffisant et l'apprentissage est rapide. Pour les problèmes plus complexes qui ont plus de maximum local, un tampon d'expérience plus grand est nécessaire pour fournir plus de points de données indépendants. Dans ce cas, la formation est plus lente, mais plus stable. Les valeurs recommandées sont 10, 20 et 40.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
## Examiner l'avancement DeepRacer des tâches de formation AWS
Après avoir démarré votre tâche de formation, vous pouvez examiner les métriques de formation des récompenses et l’achèvement des pistes par épisode pour vérifier les performances de votre modèle au niveau de la tâche de formation. Sur la DeepRacer console AWS, les métriques sont affichées dans le **graphique des récompenses**, comme le montre l'illustration suivante.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/best-model-bar-reward-graph2.png)
Vous pouvez choisir d'afficher la récompense obtenue par épisode, la moyenne de récompenses par itération, la progression par épisode, la progression moyenne par itération ou toute combinaison de ces éléments. Pour ce faire, basculez les commutateurs **Récompense (Épisode, Moyenne)** ou **Progression (Épisode, Moyenne)** en bas du **graphique des récompenses**. La récompense et la progression par épisode s'affichent sous la forme de diagrammes de dispersion dans différentes couleurs. Les moyennes des récompenses et d’achèvement des pistes sont affichées par graphique linéaire et commencent après la première itération.
La plage de récompenses est affichée sur le côté gauche du graphique et la plage de progression (0-100) est sur le côté droit. Pour lire la valeur exacte d'une métrique de formation, déplacez la souris près du point de données sur le graphique.
Les graphiques sont automatiquement mis à jour toutes les 10 secondes pendant que la formation est en cours. Vous pouvez cliquer sur le bouton d'actualisation pour mettre à jour manuellement l'affichage des métriques.
Une tâche de formation est bonne si les moyennes des récompenses et d’achèvement des pistes montrent des tendances convergentes. Ainsi, le modèle a probablement convergé si la progression par épisode atteint continuellement 100 % et que les récompenses s'épuisent. Si ce n'est pas le cas, clonez le modèle et reformez-le.
## Clonez un modèle entraîné pour commencer une nouvelle passe d'entraînement
Si vous clonez un modèle précédemment formé en tant que point de départ d'un nouveau cycle de formation, vous pouvez améliorer l'efficacité de la formation. Pour ce faire, modifiez les hyperparamètres pour utiliser les connaissances déjà acquises.
Dans cette section, vous apprendrez à cloner un modèle entraîné à l'aide de la DeepRacer console AWS.
**Pour itérer l'entraînement, le modèle d'apprentissage par renforcement à l'aide de la console AWS DeepRacer**
1. Connectez-vous à la DeepRacer console AWS, si ce n'est pas déjà fait.
1. Sur la page **Models (Modèles)**, choisissez un modèle formé, puis sélectionnez **Clone (Cloner)** dans la liste du menu déroulant **Action (Action)**.
1. Pour **Model details (Détails du modèle)**, effectuez les opérations suivantes :
1. Entrez `RL_model_1` dans **Model name (Nom du modèle)** si vous ne voulez pas qu'un nom soit généré pour le modèle cloné.
1. Vous pouvez éventuellement donner une description du to-be-cloned modèle dans **Description du modèle - facultatif**.
1. Pour la **simulation de l'environnement**, choisissez une autre option de piste.
1. Pour **Reward function (Fonction de récompense)**, choisissez l'un des exemples de fonctions de récompense disponibles. Modifiez la fonction de récompense. Examinez par exemple la direction.
1. Développez **Algorithm settings (Paramètres d'algorithme)** et essayez différentes options. Passez par exemple la valeur de **Gradient descent batch size (Taille de lot pour la descente de gradient)** de 32 à 64 ou augmentez la valeur de **Learning rate (Taux d'apprentissage)** pour accélérer la formation.
1. Testez les différentes options de **Stop conditions (Conditions d'arrêt)**.
1. Choisissez **Start training (Démarrer la formation)** pour débuter une nouvelle phase de formation.
Comme c'est généralement le cas lorsqu'il s'agit de former un modèle de Machine Learning fiable, il est important de procéder à des expérimentations systématiques pour trouver la meilleure solution.
## Évaluer les DeepRacer modèles AWS dans le cadre de simulations
Évaluer un modèle consiste à tester l'efficacité d'un modèle formé. Dans AWS DeepRacer, l'indicateur de performance standard est le temps moyen passé à terminer trois tours consécutifs. En utilisant cette métrique, pour deux modèles, l'un est meilleur que l'autre s'il permet à l'agent d'aller plus vite sur la même piste.
En général, l'évaluation d'un modèle comprend les tâches suivantes :
1. Configurer et lancer une tâche d'évaluation.
1. Observer l'évaluation en cours pendant que la tâche s'exécute. Cela peut être fait dans le DeepRacer simulateur AWS.
1. Examiner le récapitulatif d'évaluation à l'issue de la tâche d'évaluation. Vous pouvez à tout moment mettre fin à une tâche d'évaluation en cours.
**Note**
La durée de l'évaluation dépend des critères que vous sélectionnez. Si votre modèle ne répond pas aux critères d'évaluation, l'évaluation se poursuivra jusqu'à ce que le délai maximal de 20 minutes soit atteint.
1. Vous pouvez éventuellement soumettre le résultat de l'évaluation à un [ DeepRacer classement AWS](deepracer-racing-series.md) éligible. La place sur le tableau des scores vous permet de comparer les performances de votre modèle à celles des autres participants.
Testez un DeepRacer modèle AWS avec un DeepRacer véhicule AWS roulant sur une piste physique, voir[Gérez votre DeepRacer véhicule AWS](operate-deepracer-vehicle.md).
## Optimisez les DeepRacer modèles AWS de formation pour les environnements réels
De nombreux facteurs influencent les performances d'un modèle formé dans un environnement réel, notamment l'[espace d'action](#deepracer-define-action-space-for-training) choisi, la [fonction de récompense](#deepracer-train-models-define-reward-function), les [hyperparamètres](#deepracer-iteratively-adjust-hyperparameters) utilisés dans la formation, le [calibrage du véhicule](deepracer-calibrate-vehicle.md) ainsi que les conditions de la [piste réelle](deepracer-build-your-track.md). La simulation est en outre uniquement une approximation (souvent sommaire) des conditions réelles. Sous l'influence de ces facteurs, la formation d'un modèle en simulation, son application aux conditions réelles et l'obtention de performances satisfaisantes représentent un réel défi.
Former un modèle pour obtenir de bonnes performances dans les conditions réelles implique de nombreuses itérations afin d'explorer la [fonction de récompense](#deepracer-train-models-define-reward-function), les [espaces d'action](#deepracer-define-action-space-for-training), les [hyperparamètres](#deepracer-iteratively-adjust-hyperparameters) ainsi que l'[évaluation](#deepracer-evaluate-models-in-simulator) en simulation et les [tests](deepracer-drive-your-vehicle.md) dans un environnement réel. La dernière étape implique ce que l'on appelle le transfert *simulation-to-real mondial* (*sim2real*) et peut sembler fastidieuse.
Pour vous aider à relever les défis du transfert *sim2real*, prenez en compte les considérations suivantes :
+ Assurez-vous que le véhicule est bien calibré.
Le calibrage est important, car l'environnement simulé est probablement une représentation partielle de l'environnement réel. En outre, l'agent effectue une action en fonction de l'état actuel de la piste, tel que capturé par la caméra à chaque étape. Il ne voit pas assez loin pour planifier son itinéraire à grande vitesse. Pour palier à cela, la simulation impose des limites de vitesse et de direction. Pour garantir que le modèle formé fonctionne en conditions réelles, le véhicule doit être correctement calibré en fonction de ces limites et d'autres paramètres de simulation. Pour de plus amples informations sur le calibrage de votre véhicule, veuillez consulter [Calibrez votre véhicule AWS DeepRacer](deepracer-calibrate-vehicle.md).
+ Commencez par tester votre véhicule avec le modèle par défaut.
Votre DeepRacer véhicule AWS est livré avec un modèle préentraîné chargé dans son moteur d'inférence. Avant de tester votre propre modèle en conditions réelles, vérifiez que le véhicule fonctionne assez bien avec le modèle par défaut. Si ce n'est pas le cas, vérifiez la configuration de la piste physique. Si vous testez un modèle sur une piste physique qui n'a pas été correctement conçue, vous risquez d'obtenir de mauvaises performances. Dans ce cas, reconfigurez ou réparez votre piste avant de lancer ou de reprendre la phase de test.
**Note**
Lorsque vous utilisez votre DeepRacer véhicule AWS, les actions sont déduites conformément au réseau de politiques formé sans invoquer la fonction de récompense.
+ Vérifiez que le modèle fonctionne en simulation.
Si votre modèle ne fonctionne pas correctement en conditions réelles, il est possible que le modèle ou la piste soit défectueux. Pour identifier les causes premières, vous devez d'abord [évaluer le modèle en simulation](#deepracer-evaluate-models-in-simulator) afin de vérifier si l'agent simulé peut effectuer au moins une boucle sans sortir de la piste. Pour cela, vous pouvez inspecter la convergence des récompenses tout en observant la trajectoire de l'agent dans le simulateur. Si la récompense atteint le maximum lorsque l'agent simulé termine une boucle sans hésitation, le modèle est susceptible d'être performant.
+ Ne forcez pas la formation du modèle.
Si vous continuez la formation alors que le modèle effectue correctement et de façon cohérente les tours de piste en simulation, vous risquez d'obtenir un modèle trop précis. Un modèle formé de manière excessive ne fonctionnera pas correctement en conditions réelles, car il ne pourra pas gérer les différences, même mineures, entre la piste simulée et l'environnement réel.
+ Utilisez plusieurs modèles de différentes itérations.
Une session de formation standard génère différents modèles, allant de modèles manquant de précision à des modèles trop précis. Étant donné qu'il n'y a pas de critère de priorité pour déterminer le modèle idéal, vous devez choisir quelques modèles à partir du moment où l'agent termine un tour de piste dans le simulateur et effectue les tours de manière cohérente.
+ Commencez lentement et augmentez la vitesse progressivement pendant le test.
Lorsque vous testez le modèle déployé sur votre véhicule, commencez avec une faible valeur de vitesse maximale. Par exemple, vous pouvez définir la limite de la vitesse de test à moins de 10 % de la limite de la vitesse de formation. Augmentez ensuite progressivement la vitesse de test jusqu'à ce que le véhicule commence à se déplacer. La limite de la vitesse de test est définie lorsque vous calibrez le véhicule à l'aide de la console de commande de l'appareil. Si le véhicule va trop vite, par exemple si la vitesse dépasse celles observées lors de l'entraînement sur simulateur, le modèle ne fonctionnera probablement pas bien sur la piste réelle.
+ Testez un modèle en positionnant votre véhicule à différents points de départ.
Le modèle apprend à suivre un certain chemin en simulation et peut être sensible à sa position sur la piste. Il est conseillé de commencer les tests du véhicule avec différentes positions sur la piste, dans les limites de la piste (de la gauche au centre à la droite), afin de vérifier les performances du modèle à partir de certaines positions. La plupart des modèles ont tendance à garder le véhicule à proximité de l'un des côtés des lignes blanches. Pour vous aider à analyser la trajectoire du véhicule, tracez les positions du véhicule (x, y) étape par étape à partir de la simulation afin d'identifier les trajectoires pouvant être suivies par votre véhicule dans un environnement réel.
+ Commencez à tester sur une piste rectiligne.
Il est beaucoup plus facile de piloter sur une piste rectiligne que sur une piste courbe. Une piste rectiligne vous permettra d'éliminer rapidement les mauvais modèles. Si un véhicule ne peut pas suivre une piste rectiligne, cela signifie qu'il ne sera pas performant non plus sur une piste courbe.
+ Faites attention au comportement dans lequel le véhicule effectue un seul type d'actions.
Lorsque votre véhicule parvient à effectuer un seul type d'action, par exemple pour le diriger uniquement vers la gauche, le modèle est probablement suréquipé ou sous-équipé. Avec des paramètres de modèle donnés, un trop grand nombre d'itérations de la formation peut entraîner un réglage trop précis. Un manque d'itérations peu générer un modèle manquant de précision.
+ Soyez attentif à la capacité du véhicule de corriger sa trajectoire le long de la bordure d'une piste.
Un modèle efficace permet au véhicule de s'auto-corriger lorsqu'il s'approche des bordures d'une piste. Les modèles les mieux formés ont cette capacité. Si le véhicule peut s'auto-corriger sur les deux bordures de la piste, le modèle est considéré plus fiable et de meilleure qualité.
+ Soyez attentifs aux comportements incohérents du véhicule.
Un modèle de politique représente une distribution de probabilité pour effectuer une action dans un état donné. Lorsque le modèle formé est chargé dans son moteur d'inférence, un véhicule choisit l'action la plus probable, étape par étape, en fonction des prescriptions du modèle. Si les probabilités d'action sont réparties uniformément, le véhicule peut effectuer toutes les actions dont la probabilité est égale ou très similaire. Cela entraîne un comportement de conduite erratique. Par exemple, lorsque le véhicule suit parfois une trajectoire rectiligne (par exemple, la moitié du temps) et qu'il effectue des virages inutiles à d'autres moments, le modèle est soit sous-équipé, soit surmonté.
+ Faites attention à un seul type de virage (à gauche ou à droite) effectué par le véhicule.
Si le véhicule effectue parfaitement les virages vers la gauche, mais ne parvient pas effectuer des virages vers la droite, ou s'il effectue uniquement des virages vers la droite et jamais de virages vers la gauche, vous devez calibrer ou recalibrer la direction de votre véhicule. Vous pouvez également essayer d'utiliser un modèle formé avec les paramètres proches des paramètres physiques testés.
+ Faites attention au véhicule qui fait des virages brusques et qui sort de la piste.
Si le véhicule suit correctement la trajectoire sur une grande partie de la piste, mais sort soudainement de la piste, cela est sans doute dû à des distractions dans l'environnement. Les distractions les plus courantes sont des reflets lumineux imprévus ou inattendus. Dans ce cas, utilisez des barrières autour de la piste ou d'autres solutions pour réduire les lumières éblouissantes.
# Référence de la fonction de DeepRacer récompense AWS
Vous trouverez ci-dessous la référence technique de la fonction de DeepRacer récompense AWS.
**Topics**
+ [
# Paramètres d'entrée de la fonction de DeepRacer récompense AWS
](deepracer-reward-function-input.md)
+ [
# Exemples de fonctions de DeepRacer récompense AWS
](deepracer-reward-function-examples.md)
# Paramètres d'entrée de la fonction de DeepRacer récompense AWS
La fonction de DeepRacer récompense AWS prend un objet de dictionnaire en entrée.
```
def reward_function(params) :
reward = ...
return float(reward)
```
L'objet de dictionnaire `params` contient les paires clé-valeur suivantes :
```
{
"all_wheels_on_track": Boolean, # flag to indicate if the agent is on the track
"x": float, # agent's x-coordinate in meters
"y": float, # agent's y-coordinate in meters
"closest_objects": [int, int], # zero-based indices of the two closest objects to the agent's current position of (x, y).
"closest_waypoints": [int, int], # indices of the two nearest waypoints.
"distance_from_center": float, # distance in meters from the track center
"is_crashed": Boolean, # Boolean flag to indicate whether the agent has crashed.
"is_left_of_center": Boolean, # Flag to indicate if the agent is on the left side to the track center or not.
"is_offtrack": Boolean, # Boolean flag to indicate whether the agent has gone off track.
"is_reversed": Boolean, # flag to indicate if the agent is driving clockwise (True) or counter clockwise (False).
"heading": float, # agent's yaw in degrees
"objects_distance": [float, ], # list of the objects' distances in meters between 0 and track_length in relation to the starting line.
"objects_heading": [float, ], # list of the objects' headings in degrees between -180 and 180.
"objects_left_of_center": [Boolean, ], # list of Boolean flags indicating whether elements' objects are left of the center (True) or not (False).
"objects_location": [(float, float),], # list of object locations [(x,y), ...].
"objects_speed": [float, ], # list of the objects' speeds in meters per second.
"progress": float, # percentage of track completed
"speed": float, # agent's speed in meters per second (m/s)
"steering_angle": float, # agent's steering angle in degrees
"steps": int, # number steps completed
"track_length": float, # track length in meters.
"track_width": float, # width of the track
"waypoints": [(float, float), ] # list of (x,y) as milestones along the track center
}
```
La référence technique plus détaillée pour les paramètres d'entrée est expliquée ci-après.
## all\$1wheels\$1on\$1track
**Type : ** `Boolean`
**Plage : ** `(True:False)`
Indicateur `Boolean` qui spécifie si l'agent est sur la piste ou hors piste. Il est hors piste (`False`) si l'une de ses roues est en dehors des limites de la piste. Il est sur la piste (`True`) si toutes les roues sont à l'intérieur des limites de la piste. L'illustration suivante montre que l'agent est sur la piste.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-true.png)
L'illustration suivante montre que l'agent est hors piste.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-false.png)
**Exemple : ** *Fonction de récompense utilisant le paramètre `all_wheels_on_track`*
```
def reward_function(params):
#############################################################################
'''
Example of using all_wheels_on_track and speed
'''
# Read input variables
all_wheels_on_track = params['all_wheels_on_track']
speed = params['speed']
# Set the speed threshold based your action space
SPEED_THRESHOLD = 1.0
if not all_wheels_on_track:
# Penalize if the car goes off track
reward = 1e-3
elif speed < SPEED_THRESHOLD:
# Penalize if the car goes too slow
reward = 0.5
else:
# High reward if the car stays on track and goes fast
reward = 1.0
return float(reward)
```
## closest\$1waypoints
**Type :** `[int, int]`
**Plage** : `[(0:Max-1),(1:Max-1)]`
Index de base zéro des deux éléments `waypoint`s les plus proches de la position actuelle de l'agent `(x, y)`. La distance est mesurée par la distance euclidienne par rapport au centre de l'agent. Le premier élément fait référence au point de route le plus proche à l'arrière de l'agent et le second élément fait référence au point de route le plus proche à l'avant de l'agent. `Max` est la longueur de la liste des points de route. Dans l'illustration illustrée dans [waypoints](#reward-function-input-waypoints), la `closest_waypoints` serait `[16, 17]`.
**Exemple** : Fonction de récompense utilisant le paramètre `closest_waypoints`.
L'exemple de fonction de récompense suivant illustre l'utilisation de `waypoints`, `closest_waypoints` et `heading` pour calculer les récompenses immédiates.
AWS DeepRacer prend en charge les bibliothèques suivantes : math NumPy SciPy, random et Shapely. Pour en utiliser une, ajoutez une instruction d'importation`import supported library`, au-dessus de la définition de votre fonction,`def function_name(parameters)`.
```
# Place import statement outside of function (supported libraries: math, random, numpy, scipy, and shapely)
# Example imports of available libraries
#
# import math
# import random
# import numpy
# import scipy
# import shapely
import math
def reward_function(params):
###############################################################################
'''
Example of using waypoints and heading to make the car point in the right direction
'''
# Read input variables
waypoints = params['waypoints']
closest_waypoints = params['closest_waypoints']
heading = params['heading']
# Initialize the reward with typical value
reward = 1.0
# Calculate the direction of the center line based on the closest waypoints
next_point = waypoints[closest_waypoints[1]]
prev_point = waypoints[closest_waypoints[0]]
# Calculate the direction in radius, arctan2(dy, dx), the result is (-pi, pi) in radians
track_direction = math.atan2(next_point[1] - prev_point[1], next_point[0] - prev_point[0])
# Convert to degree
track_direction = math.degrees(track_direction)
# Calculate the difference between the track direction and the heading direction of the car
direction_diff = abs(track_direction - heading)
if direction_diff > 180:
direction_diff = 360 - direction_diff
# Penalize the reward if the difference is too large
DIRECTION_THRESHOLD = 10.0
if direction_diff > DIRECTION_THRESHOLD:
reward *= 0.5
return float(reward)
```
## closest\$1objects
**Type :** `[int, int]`
**Plage** : `[(0:len(objects_location)-1), (0:len(objects_location)-1)]`
Index de base zéro des deux objets les plus proches de la position actuelle de l'agent (x, y). Le premier index fait référence à l'objet le plus proche derrière l'agent, et le second index fait référence à l'objet le plus proche devant l'agent. S'il n'y a qu'un seul objet, les deux index sont 0.
## distance\$1from\$1center
**Type :** `float`
**Plage** : `0:~track_width/2`
Écart, en mètres, entre le centre de l'agent et le centre de la piste. L'écart maximum pouvant être observé se produit lorsque l'une des roues de l'agent est au-delà d'une limite de la piste et, en fonction de la largeur de la bordure de la piste, peut être légèrement inférieure ou supérieure à la moitié de la valeur de `track_width`.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-distance_from_center.png)
**Exemple :** *Fonction de récompense utilisant le paramètre `distance_from_center`*
```
def reward_function(params):
#################################################################################
'''
Example of using distance from the center
'''
# Read input variable
track_width = params['track_width']
distance_from_center = params['distance_from_center']
# Penalize if the car is too far away from the center
marker_1 = 0.1 * track_width
marker_2 = 0.5 * track_width
if distance_from_center <= marker_1:
reward = 1.0
elif distance_from_center <= marker_2:
reward = 0.5
else:
reward = 1e-3 # likely crashed/ close to off track
return float(reward)
```
## heading
**Type :** `float`
**Plage** : `-180:+180`
Direction, en degrés, de l'agent par rapport à l'axe des X du système de coordonnées.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-heading.png)
**Exemple :** *Fonction de récompense utilisant le paramètre `heading`*
Pour de plus amples informations, veuillez consulter [`closest_waypoints`](#reward-function-input-closest_waypoints).
## is\$1crashed
**Type :** `Boolean`
**Plage** : `(True:False)`
Indicateur booléen pour indiquer si l'agent a percuté un autre objet (`True`) ou non (`False`) en tant que statut d'achèvement.
## is\$1left\$1of\$1center
**Type :** `Boolean`
**Plage** : `[True : False]`
Indicateur `Boolean` qui indique si l'agent est sur le côté gauche de la piste (`True`) ou sur le côté droit de la piste (`False`) par rapport au centre de la piste.
## is\$1offtrack
**Type :** `Boolean`
**Plage** : `(True:False)`
Indicateur booléen pour indiquer si l'agent a quitté la piste (True) ou non (False) comme statut d'achèvement.
## is\$1reversed
**Type :** `Boolean`
**Plage** : `[True:False]`
Indicateur booléen pour indiquer si l'agent roule dans le sens des aiguilles d'une montre (True) ou dans le sens inverse des aiguilles d'une montre (False).
Il est utilisé lorsque vous activez un changement de direction pour chaque épisode.
## objects\$1distance
**Type :** `[float, … ]`
**Plage** : `[(0:track_length), … ]`
Liste des distances entre les objets de l'environnement par rapport à la ligne de départ. Le ie élément mesure la distance en mètres entre le ie objet et la ligne de départ le long de la ligne centrale de la piste.
**Note**
abs \$1 (var1) - (var2) \$1 = à quelle distance la voiture se trouve d'un objet, QUAND var1 = ["objects\$1distance"] [index] et var2 = params ["progress"] \$1params ["track\$1length"]
Pour obtenir un index de l'objet le plus proche devant le véhicule et de l'objet le plus proche derrière le véhicule, utilisez le paramètre « closest\$1objects ».
## objects\$1heading
**Type :** `[float, … ]`
**Plage** : `[(-180:180), … ]`
Liste des caps des objets en degrés. Le ie élément mesure le cap du ie objet. Pour les objets immobiles, les caps sont égaux à 0. Pour un véhicule bot, la valeur de l'élément correspondant est l'angle de cap du véhicule.
## objects\$1left\$1of\$1center
**Type :** `[Boolean, … ]`
**Plage** : `[True|False, … ]`
Liste d'indicateurs booléens. La valeur du ie élément i indique si le ie objet se trouve à gauche (True) ou à droite (False) du centre de la piste.
## objects\$1location
**Type :** `[(x,y), … ]`
**Plage** : `[(0:N,0:N), … ]`
Liste de tous les emplacements d'objets, chaque emplacement étant un tuple de ([x, y](#reward-function-input-x_y)).
La taille de la liste est égale au nombre d'objets sur la piste. Notez que des objets peuvent être les obstacles immobiles et des véhicules en mouvement.
## objects\$1speed
**Type :** `[float, … ]`
**Plage** : `[(0:12.0), … ]`
Liste de vitesses (mètres par seconde) pour les objets sur la piste. Pour les objets immobiles, les vitesses sont égales à 0. Pour un véhicule robot, la valeur est la vitesse que vous avez définie lors de l'entraînement.
## progress
**Type :** `float`
**Plage** : `0:100`
Pourcentage de piste parcouru.
**Exemple :** *Fonction de récompense utilisant le paramètre `progress`*
Pour de plus amples informations, veuillez consulter [steps](#reward-function-input-steps).
## speed
**Type :** `float`
**Plage** : `0.0:5.0`
Vitesse observée de l'agent, en mètres par seconde (m/s).
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-speed.png)
**Exemple :** *Fonction de récompense utilisant le paramètre `speed`*
Pour de plus amples informations, veuillez consulter [all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track).
## steering\$1angle
**Type :** `float`
**Plage** : `-30:30`
Angle de direction, en degrés, des roues avant par rapport à l'axe central de l'agent. Le signe moins (-) indique une direction vers la droite et le signe plus (\$1) indique une direction vers la gauche. L'axe central de l'agent n'est pas nécessairement parallèle à la ligne centrale de la piste, comme illustré ci-après.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-steering.png)
**Exemple :** *Fonction de récompense utilisant le paramètre `steering_angle`*
```
def reward_function(params):
'''
Example of using steering angle
'''
# Read input variable
abs_steering = abs(params['steering_angle']) # We don't care whether it is left or right steering
# Initialize the reward with typical value
reward = 1.0
# Penalize if car steer too much to prevent zigzag
ABS_STEERING_THRESHOLD = 20.0
if abs_steering > ABS_STEERING_THRESHOLD:
reward *= 0.8
return float(reward)
```
## steps
**Type :** `int`
**Plage** : `0:Nstep`
Nombre d'étapes effectuées. Une étape correspond à une action effectuée par l'agent selon la politique actuelle.
**Exemple :** *Fonction de récompense utilisant le paramètre `steps`*
```
def reward_function(params):
#############################################################################
'''
Example of using steps and progress
'''
# Read input variable
steps = params['steps']
progress = params['progress']
# Total num of steps we want the car to finish the lap, it will vary depends on the track length
TOTAL_NUM_STEPS = 300
# Initialize the reward with typical value
reward = 1.0
# Give additional reward if the car pass every 100 steps faster than expected
if (steps % 100) == 0 and progress > (steps / TOTAL_NUM_STEPS) * 100 :
reward += 10.0
return float(reward)
```
## track\$1length
**Type :** `float`
**Plage** : `[0:Lmax]`
La longueur de la piste en mètres. `Lmax is track-dependent.`
## track\$1width
**Type :** `float`
**Plage** : `0:Dtrack`
Largeur de la piste, en mètres.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-track_width.png)
**Exemple :** *Fonction de récompense utilisant le paramètre `track_width`*
```
def reward_function(params):
#############################################################################
'''
Example of using track width
'''
# Read input variable
track_width = params['track_width']
distance_from_center = params['distance_from_center']
# Calculate the distance from each border
distance_from_border = 0.5 * track_width - distance_from_center
# Reward higher if the car stays inside the track borders
if distance_from_border >= 0.05:
reward = 1.0
else:
reward = 1e-3 # Low reward if too close to the border or goes off the track
return float(reward)
```
## x, y
**Type :** `float`
**Plage** : `0:N`
Emplacement, en mètres, du centre de l'agent le long des axes X et Y de l'environnement simulé contenant la piste. L'origine se trouve dans l'angle inférieur gauche de l'environnement simulé.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-x-y.png)
## waypoints
**Type** : `list` de `[float, float]`
**Plage** : `[[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]`
Liste ordonnée des jalons `Max` dépendants des pistes le long du centre de la piste. Chaque jalon est décrit par une coordonnée de (xw,i, yw,i). Pour une piste en anneau, le premier et le dernier points de route sont identiques. Pour une piste rectiligne ou autre piste sans anneau, le premier et le dernier points de route sont différents.
![\[\]](http://docs.aws.amazon.com/fr_fr/deepracer/latest/developerguide/images/deepracer-reward-function-input-waypoints.png)
**Exemple :** *Fonction de récompense utilisant le paramètre `waypoints`*
Pour de plus amples informations, veuillez consulter [`closest_waypoints`](#reward-function-input-closest_waypoints).
# Exemples de fonctions de DeepRacer récompense AWS
Vous trouverez ci-dessous quelques exemples de la fonction de DeepRacer récompense AWS.
**Topics**
+ [
## Exemple 1 : suivre la ligne centrale dans les contre-la-montre
](#deepracer-reward-function-example-0)
+ [
## Exemple 2 : rester à l'intérieur des deux frontières pendant les contre-la-montre
](#deepracer-reward-function-example-1)
+ [
## Exemple 3 : éviter le zig-zag dans les contre-la-montre
](#deepracer-reward-function-example-2)
+ [
## Exemple 4 : restez sur une voie sans percuter des obstacles immobiles ou des véhicules en mouvement
](#deepracer-reward-function-example-3)
## Exemple 1 : suivre la ligne centrale dans les contre-la-montre
Cet exemple détermine à quelle distance l'agent se trouve de la ligne centrale et donne une récompense plus élevée si celui-ci est plus proche du centre de la piste, en encourageant l'agent à suivre de près la ligne centrale.
```
def reward_function(params):
'''
Example of rewarding the agent to follow center line
'''
# Read input parameters
track_width = params['track_width']
distance_from_center = params['distance_from_center']
# Calculate 3 markers that are increasingly further away from the center line
marker_1 = 0.1 * track_width
marker_2 = 0.25 * track_width
marker_3 = 0.5 * track_width
# Give higher reward if the car is closer to center line and vice versa
if distance_from_center <= marker_1:
reward = 1
elif distance_from_center <= marker_2:
reward = 0.5
elif distance_from_center <= marker_3:
reward = 0.1
else:
reward = 1e-3 # likely crashed/ close to off track
return reward
```
## Exemple 2 : rester à l'intérieur des deux frontières pendant les contre-la-montre
Cet exemple donne simplement des récompenses élevées si l'agent reste à l'intérieur des frontières, et lui permet de trouver le meilleur chemin pour terminer un tour. Il est facile à programmer et à comprendre, mais sa convergence prend probablement plus de temps.
```
def reward_function(params):
'''
Example of rewarding the agent to stay inside the two borders of the track
'''
# Read input parameters
all_wheels_on_track = params['all_wheels_on_track']
distance_from_center = params['distance_from_center']
track_width = params['track_width']
# Give a very low reward by default
reward = 1e-3
# Give a high reward if no wheels go off the track and
# the car is somewhere in between the track borders
if all_wheels_on_track and (0.5*track_width - distance_from_center) >= 0.05:
reward = 1.0
# Always return a float value
return reward
```
## Exemple 3 : éviter le zig-zag dans les contre-la-montre
Cet exemple incite l'agent à suivre la ligne centrale, mais le pénalise avec une récompense plus faible s'il change trop souvent de direction, ce qui permet d'éviter le comportement de zigzag. L'agent apprend à conduire en douceur dans le simulateur et conserve probablement le même comportement lorsqu'il est déployé sur le véhicule physique.
```
def reward_function(params):
'''
Example of penalize steering, which helps mitigate zig-zag behaviors
'''
# Read input parameters
distance_from_center = params['distance_from_center']
track_width = params['track_width']
abs_steering = abs(params['steering_angle']) # Only need the absolute steering angle
# Calculate 3 marks that are farther and father away from the center line
marker_1 = 0.1 * track_width
marker_2 = 0.25 * track_width
marker_3 = 0.5 * track_width
# Give higher reward if the car is closer to center line and vice versa
if distance_from_center <= marker_1:
reward = 1.0
elif distance_from_center <= marker_2:
reward = 0.5
elif distance_from_center <= marker_3:
reward = 0.1
else:
reward = 1e-3 # likely crashed/ close to off track
# Steering penality threshold, change the number based on your action space setting
ABS_STEERING_THRESHOLD = 15
# Penalize reward if the car is steering too much
if abs_steering > ABS_STEERING_THRESHOLD:
reward *= 0.8
return float(reward)
```
## Exemple 4 : restez sur une voie sans percuter des obstacles immobiles ou des véhicules en mouvement
Cette fonction de récompense récompense l'agent qui reste à l'intérieur des limites de la piste et le pénalise s'il s'approche trop près des objets situés devant lui. L'agent peut passer d'une voie à l'autre pour éviter les accidents. La récompense totale est une somme pondérée de la récompense et de la pénalité. L'exemple donne plus de poids à la pénalité afin d'éviter les accidents. Expérimentez avec différents poids moyens pour vous entraîner en fonction de différents résultats comportementaux.
```
import math
def reward_function(params):
'''
Example of rewarding the agent to stay inside two borders
and penalizing getting too close to the objects in front
'''
all_wheels_on_track = params['all_wheels_on_track']
distance_from_center = params['distance_from_center']
track_width = params['track_width']
objects_location = params['objects_location']
agent_x = params['x']
agent_y = params['y']
_, next_object_index = params['closest_objects']
objects_left_of_center = params['objects_left_of_center']
is_left_of_center = params['is_left_of_center']
# Initialize reward with a small number but not zero
# because zero means off-track or crashed
reward = 1e-3
# Reward if the agent stays inside the two borders of the track
if all_wheels_on_track and (0.5 * track_width - distance_from_center) >= 0.05:
reward_lane = 1.0
else:
reward_lane = 1e-3
# Penalize if the agent is too close to the next object
reward_avoid = 1.0
# Distance to the next object
next_object_loc = objects_location[next_object_index]
distance_closest_object = math.sqrt((agent_x - next_object_loc[0])**2 + (agent_y - next_object_loc[1])**2)
# Decide if the agent and the next object is on the same lane
is_same_lane = objects_left_of_center[next_object_index] == is_left_of_center
if is_same_lane:
if 0.5 <= distance_closest_object < 0.8:
reward_avoid *= 0.5
elif 0.3 <= distance_closest_object < 0.5:
reward_avoid *= 0.2
elif distance_closest_object < 0.3:
reward_avoid = 1e-3 # Likely crashed
# Calculate reward by putting different weights on
# the two aspects above
reward += 1.0 * reward_lane + 4.0 * reward_avoid
return reward
```