Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # DeepRacer AWS-Modelle trainieren und auswerten Wenn Ihr DeepRacer AWS-Fahrzeug selbstständig auf einer Strecke fährt, erfasst es die Umgebungsbedingungen mit der an der Vorderseite montierten Kamera und reagiert auf die Beobachtungen. Ihr DeepRacer AWS-Modell ist eine Funktion, die die Beobachtungen und Aktionen der erwarteten Belohnung zuordnet. Ihr Modell zu trainieren bedeutet, die Funktion zu suchen oder zu erlernen, die die erwartete Belohnung maximiert, sodass das optimierte Modell vorgibt, welche Aktionen (Kombinationen aus Geschwindigkeit und Lenkwinkel) Ihr Fahrzeug ausführen kann, um sich vom Anfang bis zum Ende entlang der Strecke zu bewegen. In der Praxis ist diese Funktion ein neuronales Netz. Das Training des Netzes umfasst das Finden der optimalen Netzwerkgewichtungen anhand von Sequenzen beobachteter Umgebungszustände und der Aktionen des reagierenden Fahrzeugs. Die zugrunde liegenden Optimalitätskriterien werden durch die Belohnungsfunktion des Modells beschrieben. Diese fördert das korrekte und produktive Fahren des Fahrzeugs, ohne dass es zu Unfällen oder Regelverletzungen kommt. Eine einfache Belohnungsfunktion könnte eine Belohnung von 0 zurückgeben, wenn sich das Fahrzeug auf der Strecke befindet. Sie könnte -1 zurückgeben, wenn es sich außerhalb der Strecke befindet. Sie könnte außerdem \$11 zurückgeben, wenn es die Ziellinie erreicht. Mit dieser Belohnungsfunktion wird das Fahrzeug für das Verlassen der Strecke bestraft und für das Erreichen des Ziels belohnt. Dies kann eine gute Belohnungsfunktion sein, wenn Zeit oder Geschwindigkeit kein Thema ist. Angenommen, Sie sind daran interessiert, das Fahrzeug so schnell wie möglich zu fahren, ohne von einer geraden Spur zu kommen. Während das Fahrzeug beschleunigt und bremst, kann es nach links oder rechts lenken, um Hindernisse zu umgehen oder auf der Strecke zu bleiben. Eine Kurve bei hoher Geschwindigkeit zu weit zu nehmen, könnte das Fahrzeug leicht von der Strecke abbringen. Eine zu enge Kurve führt jedoch möglicherweise zur Kollision mit einem Hindernis oder einem anderen Fahrzeug. Im Allgemeinen wäre eine optimale Aktion, eine größere Kurve bei geringerer Geschwindigkeit zu machen oder in einer schärferen Kurve weniger zu lenken. Um dieses Verhalten zu fördern, muss Ihre Belohnungsfunktion eine positive Punktzahl zuweisen, um kleinere Züge bei höherer Geschwindigkeit zu belohnen, und and/or eine negative Punktzahl, um größere Züge mit höherer Geschwindigkeit zu bestrafen. Ebenso kann die Belohnungsfunktion eine positive Belohnung für die Beschleunigung auf einer geradlinigeren Strecke oder das Abbremsen in der Nähe eines Hindernisses zurückgeben. Die Prämienfunktion ist ein wichtiger Bestandteil Ihres DeepRacer AWS-Modells. Sie müssen es beim Training Ihres DeepRacer AWS-Modells angeben. Das Training umfasst wiederholte Episoden entlang der Strecke, von deren Anfang bis zu deren Ende. In einer Episode interagiert der Agent mit der Strecke, um die optimalen Aktionen zu erlernen, indem er die erwartete kumulative Belohnung maximiert. Am Ende des Trainings wird ein Verstärkungs-Lernmodell erstellt. Nach dem Training kann der Agent autonom fahren, indem er Inferenzen über das Modell ausführt, um in jedem beliebigen Zustand eine optimale Aktion durchzuführen. Dies kann entweder in der simulierten Umgebung mit einem virtuellen Agenten oder in einer realen Umgebung mit einem physischen Agenten, z. B. einem Fahrzeug im DeepRacer AWS-Maßstab, erfolgen. Um ein Reinforcement-Learning-Modell in der Praxis zu trainieren, müssen Sie einen Lernalgorithmus auswählen. Derzeit unterstützt die DeepRacer AWS-Konsole nur die Algorithmen Proximal Policy Optimization ([PPO](https://arxiv.org/pdf/1707.06347.pdf)) und Soft Actor Critic (SAC). Sie können dann ein Deep-Learning-Framework wählen, das den ausgewählten Algorithmus unterstützt, es sei denn, Sie möchten eines von Grund auf neu schreiben. AWS ist in SageMaker KI DeepRacer integriert, um einige beliebte Deep-Learning-Frameworks, wie [TensorFlow](https://www.tensorflow.org/)z. B., sofort in der DeepRacer AWS-Konsole verfügbar zu machen. Die Verwendung eines Frameworks vereinfacht die Konfiguration und Ausführung von Trainingsjobs und ermöglicht es Ihnen, sich auf die Erstellung und Erweiterung von Belohnungsfunktionen zu konzentrieren, die speziell auf Ihre Probleme zugeschnitten sind. Das Training eines Reinforcement-Learning-Modells ist ein iterativer Prozess. Erstens ist es eine Herausforderung, eine Belohnungsfunktion zu definieren, die alle wichtigen Verhaltensweisen eines Agenten in einer Umgebung auf einmal abdeckt. Zweitens werden Hyperparameter oft so eingestellt, dass eine zufriedenstellende Trainingsleistung gewährleistet ist. Beides erfordert Experimente. Ein umsichtiger Ansatz besteht darin, mit einer einfachen Belohnungsfunktion zu beginnen und diese dann schrittweise zu verbessern. AWS DeepRacer erleichtert diesen iterativen Prozess, indem es Ihnen ermöglicht, ein trainiertes Modell zu klonen und es dann als Starthilfe für die nächste Schulungsrunde zu verwenden. Bei jeder Iteration können Sie eine oder mehrere komplexere Behandlungen in die Belohnungsfunktion einführen, um mit zuvor ignorierten Variablen umzugehen, oder Sie können Hyperparameter systematisch anpassen, bis das Ergebnis konvergiert. Genau wie bei allen Verfahren maschinellen Lernens müssen Sie ein trainiertes Reinforcement-Learning-Modell evaluieren, um seine Wirksamkeit zu überprüfen, bevor Sie es an einen physischen Agenten weitergeben, der Inferenzen in einer realen Situation nutzt. Bei autonomen Fahrten kann die Evaluierung darauf basieren, wie oft ein Fahrzeug von Anfang bis Ende auf einer bestimmten Strecke bleibt oder wie schnell es die Strecke beenden kann, ohne von der Strecke abzukommen. Mit der DeepRacer AWS-Simulation können Sie die Bewertung durchführen und die Leistungskennzahlen zum Vergleich mit Modellen veröffentlichen, die von anderen DeepRacer AWS-Benutzern trainiert wurden, auf einer [Bestenliste](deepracer-racing-series.md). **Topics** + [Renntypen verstehen und von AWS unterstützte Sensoren aktivieren DeepRacer](deepracer-choose-race-type.md) + [Trainieren und evaluieren Sie DeepRacer AWS-Modelle mit der DeepRacer AWS-Konsole](deepracer-console-train-evaluate-models.md) + [Referenz zur DeepRacer AWS-Prämienfunktion](deepracer-reward-function-reference.md) # Renntypen verstehen und von AWS unterstützte Sensoren aktivieren DeepRacer In der AWS DeepRacer League können Sie an den folgenden Arten von Rennveranstaltungen teilnehmen: + **Time Trial**: Rennen gegen die Uhr auf einer Strecke ohne Hindernisse mit dem Ziel, eine Runde möglichst schnell zu absolvieren. + **Objektvermeidung**: Rennen gegen die Uhr auf einer Strecke mit stationären Hindernissen und dem Ziel, eine Runde möglichst schnell zu absolvieren. + **Head-to-bot Rennen**: Tritt gegen ein oder mehrere andere Fahrzeuge auf derselben Strecke an und versuche, die Ziellinie vor anderen Fahrzeugen zu überqueren. AWS DeepRacer Community Races unterstützt derzeit nur Zeitfahren. Sie sollten mit verschiedenen Sensoren an Ihrem DeepRacer AWS-Fahrzeug experimentieren, damit es die Umgebung für einen bestimmten Renntyp ausreichend beobachten kann. Im nächsten Abschnitt werden die von [AWS DeepRacer unterstützten Sensoren](#deepracer-how-it-works-autonomous-driving-sensors) beschrieben, die die unterstützten Typen von autonomen Rennveranstaltungen ermöglichen können. **Topics** + [Wählen Sie Sensoren für DeepRacer AWS-Renntypen](#deepracer-how-it-works-autonomous-driving-sensors) + [Agenten für das Training von DeepRacer AWS-Modellen konfigurieren](#deepracer-configure-agent) + [Maßgeschneiderte DeepRacer AWS-Schulungen für Zeitfahren](#deepracer-get-started-training-simple-time-trial) + [Maßgeschneiderte DeepRacer AWS-Schulungen für Rennen zur Objektvermeidung](#deepracer-get-started-training-object-avoidance) + [Maßgeschneiderte DeepRacer AWS-Schulungen für head-to-bot Rennen](#deepracer-get-started-training-h2h-racing) ## Wählen Sie Sensoren für DeepRacer AWS-Renntypen Ihr DeepRacer AWS-Fahrzeug ist mit einer nach vorne gerichteten monokularen Kamera als Standardsensor ausgestattet. Sie können eine weitere nach vorne gerichtete Monokularkamera hinzufügen, um nach vorne gerichtete Stereokameras zu erhalten oder um die Monokular- oder Stereokameras mit einer LiDAR-Einheit zu ergänzen. Die folgende Liste fasst die Funktionsfähigkeit der von AWS DeepRacer unterstützten Sensoren zusammen mit kurzen cost-and-benefit Analysen zusammen: **Nach vorne gerichtete Kamera** Eine nach vorne gerichtete Kamera mit einem Objektiv kann Bilder der Umgebung vor dem Hostfahrzeug aufnehmen, einschließlich Streckenbegrenzungen und -formen. Dies ist der kostengünstigste Sensor, der sich für einfachere autonome Fahraufgaben wie Time Trials ohne Hindernisse auf gut markierten Strecken eignet. Bei richtiger Schulung kann es stationäre Hindernisse an festen Stellen auf der Strecke vermeiden. Die Informationen zur Positionen von Hindernissen sind jedoch in das geschulte Modell integriert, weshalb das Modell wahrscheinlich übermäßig ausgestattet ist und möglicherweise keine Generalisierungen für andere Hindernisorte durchführen kann. Bei stationären Objekten an zufälligen Stellen oder anderen sich bewegenden Fahrzeugen auf der Strecke, ist es unwahrscheinlich, dass das Modell konvergiert. In der realen Welt ist das DeepRacer AWS-Fahrzeug mit einer Frontkamera mit einem Objektiv als Standardsensor ausgestattet. Die Kamera verfügt über ein 120-Grad-Weitwinkelobjektiv und erfasst RGB-Bilder, die dann in Graustufenbilder von 160 x 120 Pixeln bei 15 Bildern pro Sekunde (fps) konvertiert werden. Diese Sensoreigenschaften bleiben im Simulator erhalten, um die Möglichkeit zu maximieren, dass das geschulte Modell gut von der Simulation in die reale Welt übertragen werden kann. **Nach vorne gerichtete Stereokamera** Eine Stereokamera hat zwei oder mehr Objektive, die Bilder mit der gleichen Auflösung und Frequenz aufnehmen. Bilder von beiden Objektiven werden verwendet, um die Tiefe der beobachteten Objekte festzustellen. Die Tiefeninformationen von einer Stereokamera sind wertvoll für das Hostfahrzeug, um Kollisionen mit Hindernissen oder anderen Fahrzeugen nach vorn zu vermeiden, besonders in dynamischeren Umgebungen. Zusätzliche Tiefeninformationen führen jedoch zu einer langsameren Konvergenz bei der Schulung. Auf dem DeepRacer physischen AWS-Fahrzeug wird die Stereokamera mit doppelter Linse konstruiert, indem eine weitere Einzelobjektivkamera hinzugefügt und jede Kamera an der linken und rechten Seite des Fahrzeugs montiert wird. Die DeepRacer AWS-Software synchronisiert Bildaufnahmen von beiden Kameras. Die erfassten Bilder werden in Graustufen umgewandelt, gestapelt und zu Inferenzzwecken in das neuronale Netzwerk eingespeist. Der gleiche Mechanismus wird im Simulator dupliziert, um das Modell zu schulen, damit es brauchbare Generalisierungen für eine reale Umgebung leisten kann. **LiDAR-Sensor** Ein LiDAR-Sensor verwendet rotierende Laser, um Lichtimpulse außerhalb des sichtbaren Spektrums auszusenden, wobei die Zeit bis zur Rückkehr des Impulses gemessen wird. Die Richtung und Entfernung zu den Objekten, auf die ein bestimmter Impuls trifft, werden als Punkt in einer großen 3D-Karte aufgezeichnet, die um die LiDAR-Einheit zentriert ist. LiDAR hilft beispielsweise bei der Erkennung von toten Winkeln des Hostfahrzeugs, um Kollisionen zu vermeiden, während das Fahrzeug die Fahrspur wechselt. Durch die Kombination von LiDAR mit Mono- oder Stereokameras können Sie dem Hostfahrzeug ermöglichen, genügend Informationen erfassen, um geeignete Maßnahmen zu ergreifen. Ein LiDAR-Sensor kostet jedoch mehr im Vergleich zu Kameras. Das neuronale Netzwerk muss lernen, die LiDAR-Daten zu interpretieren. Dadurch dauert die Schulung länger bis zur Konvergierung. Am DeepRacer physischen AWS-Fahrzeug ist ein LiDAR-Sensor an der Rückseite montiert und um 6 Grad nach unten geneigt. Er dreht sich mit einer Winkelgeschwindigkeit von 10 Umdrehungen pro Sekunde und hat einen Bereich von 15 cm bis 2 m. Er kann Objekte hinter und neben dem Hostfahrzeug sowie hohe Objekte erkennen, die von den Fahrzeugteilen an der Vorderseite nicht behindert werden. Der Winkel und die Reichweite sind so gewählt, dass die LiDAR-Einheit weniger anfällig für Umgebungsgeräusche ist. Sie können Ihr DeepRacer AWS-Fahrzeug mit der folgenden Kombination der unterstützten Sensoren konfigurieren: + Nur nach vorne gerichtete Kamera mit einem Objektiv Diese Konfiguration eignet sich sowohl für Time Trials, als auch für die Hindernisvermeidung mit Objekten an festen Standorten. + Nur nach vorne gerichtete Stereokamera Diese Konfiguration eignet sich gut zur Vermeidung von Hindernissen bei Objekten an festen oder zufälligen Orten. + Nach vorne gerichtete Kamera mit einem Objektiv und LiDAR. Diese Konfiguration eignet sich gut zur Hindernisvermeidung oder head-to-bot für Rennen. + Nach vorne gerichtete Stereokamera mit LiDAR. Diese Konfiguration eignet sich gut für die Vermeidung von Hindernissen oder für head-to-bot Rennen, aber wahrscheinlich nicht die wirtschaftlichste Lösung für Zeitfahren. Wenn Sie weitere Sensoren hinzufügen, damit Ihr DeepRacer AWS-Fahrzeug von Zeitfahren über Objektvermeidung bis hin zu head-to-bot Rennen durchläuft, sammelt das Fahrzeug mehr Daten über die Umgebung, die beim Training in das zugrunde liegende neuronale Netzwerk eingespeist werden. Dies macht die Schulung anspruchsvoller, da das Modell mit mehr Komplexität umgehen muss. Für Sie wird es dadurch anspruchsvoller, Modelle zu schulen. Um schrittweise zu lernen, sollten Sie zunächst mit dem Training für Zeitfahren beginnen, bevor Sie zur Objektvermeidung und dann zum Rennen übergehen. head-to-bot Ausführlichere Empfehlungen finden Sie im nächsten Abschnitt. ## Agenten für das Training von DeepRacer AWS-Modellen konfigurieren Um ein Reinforcement-Learning-Modell für das DeepRacer AWS-Fahrzeug zu trainieren, damit es bei Hindernisvermeidung oder head-to-bot Rennen Rennen fahren kann, müssen Sie den Agenten mit den entsprechenden Sensoren konfigurieren. Für einfache Time Trials können Sie den Standardagenten verwenden, der mit einer Kamera mit einem Objektiv konfiguriert ist. Bei der Konfiguration des Agenten können Sie den Aktionsbereich anpassen und eine neuronale Netzwerktopologie auswählen, damit diese besser mit den ausgewählten Sensoren arbeiten, um die jeweiligen Fahranforderungen zu erfüllen. Darüber hinaus können Sie das Erscheinungsbild des Agenten zur visuellen Identifizierung während der Schulung ändern. Nach der Konfiguration wird die Agentenkonfiguration als Teil der Metadaten des Modells für Schulung und Evaluierung aufgezeichnet. Zur Auswertung ruft der Agent automatisch die aufgezeichnete Konfiguration ab, um die angegebenen Sensoren, den Aktionsbereich und die neuronale Netzwerktechnologie zu verwenden. In diesem Abschnitt werden Sie durch die Schritte zur Konfiguration eines Agenten in der DeepRacer AWS-Konsole geführt. **So konfigurieren Sie einen DeepRacer AWS-Agenten in der DeepRacer AWS-Konsole** 1. Melden Sie sich bei der [ DeepRacerAWS-Konsole](https://console.aws.amazon.com/deepracer) an. 1. Wählen Sie im primären Navigationsbereich die Option **Garage** aus. 1. Wenn Sie **Garage** zum ersten Mal verwenden, wird Ihnen das Dialogfeld **WELCOME TO THE GARAGE (WILLKOMMEN IN DER GARAGE)** angezeigt. Wählen Sie **>** oder **<**, durchsuchen Sie die Einführung zu verschiedenen Sensoren, die für das DeepRacer AWS-Fahrzeug unterstützt werden, oder wählen Sie **X**, um das Dialogfeld zu schließen. Diese einleitenden Informationen finden Sie im Hilfebereich in **Garage**. 1. Wählen Sie auf der Seite **Garage** die Option **Build new vehicle (Neues Fahrzeug bauen)**. 1. Wählen Sie auf der Seite **Mod your own vehicle (Eigenes Fahrzeug modifizieren)** unter **Mod specifications (Mod-Spezifikationen)** einen oder mehrere Sensoren aus, um die beste Kombination zu erlernen, die Ihren beabsichtigten Renntypen entspricht. Um für Ihre DeepRacer AWS-Fahrzeugzeittests zu trainieren, wählen Sie **Kamera**. Für die Vermeidung von Hindernissen oder head-to-bot Rennen möchten Sie andere Sensortypen verwenden. Um sich für eine **Stereokamera** zu entscheiden, stellen Sie sicher, dass Sie eine zusätzliche Einzelobjektivkamera erworben haben. AWS DeepRacer stellt die Stereokamera aus zwei Einlinsenkameras her. Sie können entweder eine Kamera mit einem Objektiv oder eine Stereokamera mit zwei Objektiven an einem Fahrzeug haben. In beiden Fällen können Sie dem Agenten einen LiDAR-Sensor hinzufügen, wenn Sie nur möchten, dass das trainierte Modell blinde Winkel bei der Hindernisvermeidung oder head-to-bot bei Rennen erkennen und vermeiden kann. 1. Wählen Sie auf der Seite **Garage** und unter **Neural network topologies (Neuronale Netzwerktopologien)** eine unterstützte Netzwerktopologie aus. Im Allgemeinen ist ein tieferes neuronales Netzwerk (mit mehr Ebenen) besser geeignet, um auf komplizierteren Strecken mit zahlreichen und scharfen Kurven zu fahren, um stationäre Hindernisse zu vermeiden oder um gegen andere fahrende Fahrzeuge zu konkurrieren. Die Schulung eines tieferen neuronalen Netzwerks ist jedoch teurer und es dauert länger, bis das Modell konvergiert. Andererseits kostet ein flacheres Netzwerk (mit weniger Ebenen) weniger und benötigt eine kürzere Zeit für die Schulung. Das geschulte Modell ist in der Lage, einfachere Streckenbedingungen oder Fahranforderungen zu bewältigen, wie Time Trials auf einer hindernisfreien Strecke ohne Konkurrenten. Insbesondere DeepRacer unterstützt AWS **3-Layer-CNN oder **5-Layer-CNN****. 1. Wählen Sie auf der Seite **Garage** die Option **Next (Weiter)**, um mit der Einrichtung des Aktionsbereichs des Agenten fortzufahren. 1. Lassen Sie auf der Seite **Action space (Aktionsbereich)** die Standardeinstellungen für Ihre erste Schulung unverändert. Experimentieren Sie für nachfolgende Schulungen mit verschiedenen Einstellungen für Lenkwinkel, Höchstgeschwindigkeit und ihre Granularitäten. Wählen Sie anschließend **Weiter**. 1. **Geben Sie auf der Seite **Farbe Ihr Fahrzeug ein, um sich von der Masse abzuheben**, einen Namen in das Feld **Name your** ein DeepRacer und wählen Sie dann aus der Liste der Fahrzeugfarben eine Farbe für den Agenten aus.** Wählen Sie dann **Submit (Senden)**. 1. Überprüfen Sie auf der Seite **Garage** die Einstellungen des neuen Agenten. Um weitere Änderungen vorzunehmen, wählen Sie **Mod vehicle (Fahrzeug modifizieren)** und wiederholen Sie die vorherigen Schritte ab **Schritt 4**. Jetzt ist Ihr Agent bereit zur Schulung. ## Maßgeschneiderte DeepRacer AWS-Schulungen für Zeitfahren Wenn Sie AWS zum ersten Mal verwenden DeepRacer, sollten Sie mit einem einfachen Zeitfahren beginnen, um sich mit der Schulung von DeepRacer AWS-Modellen für das Fahren Ihres Fahrzeugs vertraut zu machen. Auf diese Weise erhalten Sie eine behutsame Einführung in grundlegende Konzepte der Belohnungsfunktion sowie zu den Begriffen Agent, Umgebung usw. Ihr Ziel ist es, ein Modell zu schulen, um das Fahrzeug auf der Strecke zu halten und eine Runde so schnell wie möglich zu absolvieren. Anschließend können Sie das trainierte Modell auf Ihrem DeepRacer AWS-Fahrzeug einsetzen, um Testfahrten auf einer physischen Strecke ohne zusätzliche Sensoren zu testen. Um ein Modell für dieses Szenario zu trainieren, können Sie den Standard-Agenten aus **Garage** auf der DeepRacer AWS-Konsole auswählen. Der Standard-Agent wurde mit einer einzigen nach vorne gerichteten Kamera, einem Standard-Aktionsbereich und einer standardmäßigen neuronalen Netzwerktopologie konfiguriert. Es ist hilfreich, mit dem Training eines DeepRacer AWS-Modells mit dem Standard-Agenten zu beginnen, bevor Sie zu anspruchsvolleren Agents übergehen. Befolgen Sie die folgenden Empfehlungen, um Ihr Modell mit dem Standard-Agenten zu schulen. 1. Beginnen Sie die Schulung Ihres Modells mit einer einfachen Strecke mit regelmäßigeren Formen und weniger scharfen Kurven. Verwenden Sie die Standard-Belohnungsfunktion. Schulen Sie das Modell für 30 Minuten. Evaluieren Sie Ihr Modell nach dem Schulungsauftrag auf derselben Strecke, um zu sehen, ob der Agent eine Runde beenden kann. 1. Lesen Sie mehr über [die Belohnungsfunktionsparameter](deepracer-reward-function-input.md). Setzen Sie die Schulung mit verschiedenen Anreizen fort, um den Agenten dafür zu belohnen, schneller zu fahren. Verlängern Sie die Schulungszeit für das nächste Modell auf 1 bis 2 Stunden. Vergleichen Sie die Belohnungsgrafik zwischen der ersten Schulung und dieser zweiten Schulung. Experimentieren Sie weiter, bis sich das Belohnungsdiagramm nicht mehr verbessert. 1. Lesen Sie mehr über den [Aktionsbereich](deepracer-how-it-works-action-space.md). Trainieren Sie das Modell zum dritten Mal, indem Sie die Höchstgeschwindigkeit erhöhen (z. B. 1 m/s). Um den Aktionsbereich zu ändern, müssen Sie unter **Garage** einen neuen Agenten erstellen, wenn Sie die Möglichkeit haben, die Änderung vorzunehmen. Beachten Sie bei der Aktualisierung der Höchstgeschwindigkeit Ihres Agenten Folgendes: Je höher die Höchstgeschwindigkeit, desto schneller kann der Agent die zu bewertende Strecke abschließen und desto schneller kann Ihr DeepRacer AWS-Fahrzeug eine Runde auf einer physischen Strecke beenden. Eine höhere Höchstgeschwindigkeit bedeutet jedoch oft eine längere Zeit bis zur Konvergierung der Schulung, da der Agent dabei eher in einer Kurve überschießt und von der Strecke abkommt. Möglicherweise möchten Sie die Granularitäten verringern, um dem Agenten mehr Raum zum Beschleunigen und Abbremsen zu geben oder die Belohnungsfunktion in anderer Weise zu ändern, damit die Schulung schneller konvergiert. Nachdem die Schulung konvergiert ist, evaluieren Sie das 3. Modell, um zu sehen, ob sich die Rundenzeit verbessert. Fahren Sie so fort, bis es keine Verbesserung mehr gibt. 1. Wählen Sie eine kompliziertere Strecke und wiederholen Sie **Schritt 1** bis **Schritt 3**. Evaluieren Sie Ihr Modell auf einer Strecke, die sich von der Schulungsstrecke unterscheidet, um zu sehen, wie das Modell auf verschiedene virtuelle Strecken verallgemeinert werden kann, um [Generalisierungen für reale Umgebungen durchzuführen](deepracer-how-it-works-virtual-to-physical.md). 1. (Optional) Experimentieren Sie mit unterschiedlichen Werten der [Hyperparameter](deepracer-console-train-evaluate-models.md#deepracer-iteratively-adjust-hyperparameters), um den Schulungsprozess zu verbessern, und wiederholen Sie **Schritt 1** bis **Schritt 3**. 1. (Optional) Untersuchen und analysieren Sie die DeepRacer AWS-Protokolle. Beispielcode, den Sie zur Analyse der Protokolle verwenden können, finden Sie unter [https://github.com/aws-samples/aws-deepracer-workshops/tree/master/log-analysis](https://github.com/aws-samples/aws-deepracer-workshops/tree/master/log-analysis). ## Maßgeschneiderte DeepRacer AWS-Schulungen für Rennen zur Objektvermeidung Nachdem Sie sich mit Time Trials vertraut gemacht und einige konvergierte Modelle geschult haben, gehen Sie zur nächsten anspruchsvolleren Herausforderung über: zur Hindernisvermeidung. Hier ist Ihr Ziel, ein Modell zu schulen, das eine Runde so schnell wie möglich absolvieren kann, ohne von der Strecke zu geraten, und dabei Kollisionen mit Objekten auf der Strecke zu vermeiden. Dies ist offensichtlich ein schwierigeres Problem für den Agenten und die Schulung dauert länger bis zur Konvergenz. Die DeepRacer AWS-Konsole unterstützt zwei Arten von Hindernisvermeidungstrainings: Hindernisse können an festen oder zufälligen Stellen entlang der Strecke platziert werden. Bei festen Standorten bleiben die Hindernisse während des Schulungsauftrags an der gleichen Stelle fixiert. Bei zufälligen Standorten ändern die Hindernisse ihre jeweiligen Orte zufällig von Episode zu Episode. Es ist einfacher für die Schulung, ortsfeste Hindernisse zu vermeiden, da das System dabei einen niedrigeren Freiheitsgrad hat. Modelle können jedoch übermäßig angepasst werden, wenn die Standortinformationen in die geschulten Modelle integriert sind. Infolgedessen können die Modelle übermäßig angepasst sein und möglicherweise schlechter generalisieren. Bei der Vermeidung zufällig positionierter Hindernisse ist die Konvergenz schwieriger zu erreichen, da der Agent weiterhin lernen muss, an Orten, die er noch nicht gesehen hat, Kollisionen mit Hindernissen zu vermeiden. Modelle, die mit dieser Option geschult wurden, neigen jedoch dazu, besser zu generalisieren, und können gut auf reale Rennen übertragen werden. Platzieren Sie zu Beginn Hindernisse an festen Standorten, machen Sie sich mit den Verhaltensweisen vertraut und gehen Sie dann zu zufälligen Standorten über. Im DeepRacer AWS-Simulator sind die Hindernisse quaderförmige Boxen mit den gleichen Abmessungen (9,5" (L) x 15,25" (B) x 10/5" (H)) wie die Paketbox des AWS-Fahrzeugs. DeepRacer Dies macht es einfacher, das geschulte Modell vom Simulator in die reale Welt zu übertragen, wenn Sie die Verpackungsbox als Hindernis auf der physischen Spur platzieren. Um mit der Hindernisvermeidung zu experimentieren, befolgen Sie die empfohlene Vorgehensweise, die in den folgenden Schritten beschrieben wird: 1. Verwenden Sie den Standard-Agenten oder experimentieren Sie mit neuen Sensoren und Aktionsbereichen, indem Sie einen vorhandenen Agenten anpassen oder einen neuen erstellen. Sie sollten die Höchstgeschwindigkeit auf unter 0,8 m/s und die Geschwindigkeitsgranularität auf 1 oder 2 Stufen begrenzen. Beginnen Sie mit der Schulung eines Modells für ca. 3 Stunden mit zwei Objekten an festen Standorten. Verwenden Sie die Beispiel-Belohnungsfunktion und schulen Sie das Modell auf der Strecke, auf der Sie fahren werden, oder auf einer Strecke, die dieser ähnelt. Der **AWS DeepRacer Smile Speedway (Intermediate)** ist eine einfache Strecke, weshalb er sich hervorragend für die Vorbereitung von Gipfelrennen eignet. Evaluieren Sie das Modell auf der gleichen Strecke mit der gleichen Anzahl von Hindernissen. Beobachten Sie, wie die gesamte erwartete Belohnung konvergiert, wenn überhaupt. 1. Lesen Sie mehr über [die Belohnungsfunktionsparameter](deepracer-reward-function-input.md). Experimentieren Sie mit Variationen Ihrer Belohnungsfunktion. Erhöhen Sie die Zahl der Hindernisse auf vier. Schulen Sie den Agenten, um zu sehen, ob die Schulung in der gleichen Schulungszeit konvergiert. Wenn dies nicht der Fall ist, optimieren Sie Ihre Belohnungsfunktion erneut, senken Sie die Höchstgeschwindigkeit oder reduzieren Sie die Anzahl der Hindernisse und schulen Sie den Agenten erneut. Wiederholen Sie die Experimente, bis es keine signifikante Verbesserung mehr gibt. 1. Gehen Sie nun zur Schulung zur Vermeidung von Hindernissen an zufälligen Orten über. Sie müssen den Agenten mit zusätzlichen Sensoren konfigurieren, die in **Garage** in der DeepRacer AWS-Konsole verfügbar sind. Sie können eine Stereokamera verwenden. Oder Sie können eine LiDAR-Einheit entweder mit einer Kamera mit einem Objektiv oder einer Stereokamera kombinieren. Sie sollten dabei jedoch eine längere Schulungszeit einkalkulieren. Stellen Sie den Aktionsbereich auf eine relativ niedrige Höchstgeschwindigkeit (z. B. 2 m/s) ein, damit das Training schneller zusammenläuft. Verwenden Sie für die Netzwerkarchitektur ein flaches neuronales Netzwerk, das als für die Vermeidung von Hindernissen ausreichend befunden wurde. 1. Beginnen Sie die Schulung mit vier Stunden für den neuen Agenten zur Hindernisvermeidung mit vier zufällig platzierten Objekten auf einer einfachen Strecke. Evaluieren Sie dann Ihr Modell auf der gleichen Strecke, um zu sehen, ob es Runden mit zufällig positionierten Hindernissen absolvieren kann. Wenn dies nicht der Fall ist, können Sie Ihre Belohnungsfunktion optimieren, andere Sensoren ausprobieren und längere Schulungszeiten verwenden. Ein weiterer Tipp: Sie können versuchen, ein bestehendes Modell zu klonen, um die Schulung fortzusetzen und dafür zuvor erlernte Erfahrungen zu nutzen. 1. (Optional) Wählen Sie eine höhere Höchstgeschwindigkeit für den Aktionsbereich oder lassen Sie mehr Hindernisse zufällig auf der Strecke platzieren. Experimentieren Sie mit verschiedenen Sensoren und optimieren Sie die Belohnungsfunktionen und Hyperparameterwerte. Experimentieren Sie mit der **5-layer CNN**-Netzwerktopologie. Schulen Sie das Modell anschließend neu, um zu bestimmen, wie sich dies auf die Konvergenz der Schulung auswirkt. ## Maßgeschneiderte DeepRacer AWS-Schulungen für head-to-bot Rennen Nachdem du Trainingshindernisse gemeistert hast, bist du nun bereit, dich der nächsten Herausforderung zu stellen: Trainingsmodelle für head-to-bot Rennen. Im Gegensatz zu Veranstaltungen zur Hindernisvermeidung herrscht im head-to-bot Rennsport ein dynamisches Umfeld mit sich bewegenden Fahrzeugen. Ihr Ziel ist es, Modelle für Ihr DeepRacer AWS-Fahrzeug so zu trainieren, dass sie gegen andere fahrende Fahrzeuge antreten, um als Erster die Ziellinie zu erreichen, ohne von der Strecke abzukommen oder mit anderen Fahrzeugen zu kollidieren. In der DeepRacer AWS-Konsole können Sie ein head-to-bot Rennmodell trainieren, indem Sie Ihren Agenten gegen 1—4 Bot-Fahrzeuge antreten lassen. Allgemein sollten Sie dabei mehr Hindernisse auf einer längeren Strecke platzieren. Jedes Bot-Fahrzeug folgt einem vordefinierten Weg mit konstanter Geschwindigkeit. Sie können Ihrem Fahrzeug möglichen, Fahrspuren zu wechseln oder es auf seiner Startspur bleiben lassen. Ähnlich wie bei der Schulung zur Vermeidung von Hindernissen können Sie die Bot-Fahrzeuge gleichmäßig über die Strecke auf beiden Spuren verteilen. Die Konsole beschränkt Sie auf bis zu 4 Bot-Fahrzeuge auf der Strecke. Mehr konkurrierende Fahrzeuge auf der Strecke geben dem Lernagenten mehr Möglichkeiten, unterschiedlichen Situationen mit anderen Fahrzeugen zu begegnen. Auf diese Weise lernt es mehr in einem Schulungsauftrag und der Agent wird schneller geschult. Allerdings wird jede Schulung wahrscheinlich länger dauern, bis Konvergenz erreicht ist. Um einen Agenten mit Bot-Fahrzeugen zu schulen, sollten Sie die Höchstgeschwindigkeit des Aktionsbereichs des Agenten höher einstellen als die (konstante) Geschwindigkeit der Bot-Fahrzeuge, so dass der Agent während der Schulung mehr Überholmöglichkeiten hat. Als guten Ausgangspunkt sollten Sie die Höchstgeschwindigkeit des Agenten auf 0,8 m/s und die Geschwindigkeit des Bot-Fahrzeugs auf 0,4 m/s einstellen. Wenn Sie es den Bots ermöglichen, die Fahrspuren zu wechseln, wird die Schulung schwieriger, weil der Agent nicht nur lernen muss, wie man eine Kollision mit einem fahrenden Fahrzeug vorne auf der gleichen Spur vermeiden kann, sondern auch, wie man eine Kollision mit einem anderen fahrenden Fahrzeug vorne auf der anderen Spur vermeiden kann. Sie können die Bots so einstellen, dass sie die Spuren in zufälligen Intervallen ändern. Die Länge eines Intervalls wird nach dem Zufallsprinzip aus einem Zeitraum (z. B. 1 bis 5 Sekunden) ausgewählt, den Sie vor Beginn des Trainingsjobs angeben. Dieses Verhalten beim Spurwechsel ähnelt eher dem realen head-to-bot Rennverhalten, und der geschulte Agent sollte bessere Ergebnisse erzielen. Es dauert jedoch länger, bis das Modell zur Konvergenz kommt. Befolge diese empfohlenen Schritte, um dein Training für den Rennsport zu wiederholen: head-to-bot 1. Erstellen Sie in der **Garage** der DeepRacer AWS-Konsole einen neuen Trainingsagenten, der sowohl mit Stereokameras als auch mit einer LiDAR-Einheit konfiguriert ist. Es ist möglich, ein relativ gutes Modell nur mit einer Stereokamera gegen Bot-Fahrzeuge zu schulen. LiDAR hilft dabei, blinde Flecken zu reduzieren, wenn der Agent die Fahrspuren wechselt. Stellen Sie die Höchstgeschwindigkeit nicht zu hoch ein. Ein guter Ausgangspunkt ist 1 m/s. 1. Beginnen Sie mit zwei Bot-Fahrzeugen, um für den head-to-bot Rennsport zu trainieren. Stellen Sie die Bewegungsgeschwindigkeit des Bots niedriger als die Höchstgeschwindigkeit Ihres Agenten ein (z. B. 0,5, m/s wenn die Höchstgeschwindigkeit des Agenten 1 m/s beträgt). Deaktivieren Sie die Option „Spurwechsel“ und wählen Sie dann den gerade erstellten Schulungsagent aus. Verwenden Sie eines der Beispiele für Belohnungsfunktionen oder nehmen Sie die minimal notwendigen Änderungen vor und schulen Sie dann für drei Stunden. Verwenden Sie die Strecke, auf der Sie fahren werden, oder eine Strecke, die genau dieser Strecke entspricht. Der **AWS DeepRacer Smile Speedway (Intermediate)** ist eine einfache Strecke, weshalb er sich hervorragend für die Vorbereitung von Gipfelrennen eignet. Nachdem die Schulung abgeschlossen ist, evaluieren Sie das geschulte Modell auf derselben Strecke. 1. Für anspruchsvollere Aufgaben können Sie Ihr trainiertes Modell für ein zweites head-to-bot Rennmodell klonen. Experimentieren Sie entweder mit mehr Bot-Fahrzeugen oder aktivieren Sie die Spurwechseloptionen. Beginnen Sie mit langsamen Spurwechselvorgängen in zufälligen Intervallen, die länger als zwei Sekunden sind. Sie können auch mit benutzerdefinierten Belohnungsfunktionen experimentieren. Im Allgemeinen kann Ihre benutzerdefinierte Belohnungsfunktionslogik mit der zur Vermeidung von Hindernissen vergleichbar sein, wenn Sie nicht den Ausgleich zwischen dem Überholen anderer Fahrzeuge und dem Verbleiben auf der Strecke berücksichtigen. Je nachdem, wie gut das vorherige Modell ist, müssen Sie möglicherweise weitere drei bis sechs Stunden schulen. Evaluieren Sie Ihre Modelle und prüfen Sie, wie gut das Modell funktioniert. # Trainieren und evaluieren Sie DeepRacer AWS-Modelle mit der DeepRacer AWS-Konsole Um ein Reinforcement-Learning-Modell zu trainieren, können Sie die DeepRacer AWS-Konsole verwenden. Erstellen Sie in der Konsole einen Trainingsjob, wählen Sie ein unterstütztes Framework und einen verfügbaren Algorithmus aus, fügen Sie eine Belohnungsfunktion hinzu und konfigurieren Sie die Trainingseinstellungen. Sie können das Training in einem Simulator beobachten. Die step-by-step Anweisungen finden Sie unter[Trainieren Sie Ihr erstes DeepRacer AWS-Modell](deepracer-get-started-training-model.md). In diesem Abschnitt wird erklärt, wie ein DeepRacer AWS-Modell trainiert und evaluiert wird. Er zeigt außerdem, wie man eine Belohnungsfunktion erstellt und verbessert, wie ein Aktionsraum die Modellleistung beeinflusst und wie Hyperparameter die Trainingsleistung beeinflussen. Sie erfahren zudem, wie Sie ein Trainingsmodell klonen können, um eine Trainingseinheit zu erweitern, wie Sie den Simulator zur Evaluierung der Trainingsleistung verwenden und wie Sie einige der Simulationen an die Herausforderungen der realen Welt anpassen können. **Topics** + [Erstellen Sie Ihre Prämienfunktion](#deepracer-train-models-define-reward-function) + [Erkunden Sie den Aktionsraum, um ein robustes Modell zu trainieren](#deepracer-define-action-space-for-training) + [Passen Sie Hyperparameter systematisch an](#deepracer-iteratively-adjust-hyperparameters) + [Untersuchen Sie den Fortschritt der DeepRacer AWS-Schulungen](#deepracer-examine-training-progress) + [Klonen Sie ein trainiertes Modell, um einen neuen Trainingspass zu starten](#deepracer-clone-trained-model) + [Evaluieren Sie DeepRacer AWS-Modelle in Simulationen](#deepracer-evaluate-models-in-simulator) + [Optimieren Sie DeepRacer AWS-Schulungsmodelle für reale Umgebungen](#deepracer-evaluate-model-test-approaches) ## Erstellen Sie Ihre Prämienfunktion Eine [Prämienfunktion](deepracer-reward-function-reference.md) beschreibt sofortiges Feedback (als Prämien- oder Strafpunktzahl), wenn sich Ihr DeepRacer AWS-Fahrzeug von einer Position auf der Strecke zu einer neuen Position bewegt. Der Zweck der Funktion ist es, das Fahrzeug dazu zu bringen, ein Ziel durch Bewegungen entlang der Strecke schnell und ohne Unfall oder Regelverstöße zu erreichen. Eine wünschenswerte Bewegung bringt eine bessere Bewertung für die entsprechende Aktion oder den Zielstatus. Eine illegale oder unnötige Bewegung führt zu einer niedrigeren Bewertung. Beim Training eines DeepRacer AWS-Modells ist die Prämienfunktion der einzige anwendungsspezifische Teil. Im Allgemeinen gestalten Sie Ihre Belohnungsfunktion so, dass sie wie ein Incentive-Plan funktioniert. Verschiedene Incentive-Strategien können zu einem unterschiedlichen Fahrzeugverhalten führen. Um die Fahrt des Fahrzeugs zu beschleunigen, sollte die Funktion das Folgen der Strecke belohnen. Die Funktion sollte Strafen verteilen, wenn das Fahrzeug zum Beenden einer Runde zu lange braucht oder die Strecke verlässt. Um Zickzack-Fahrmuster zu vermeiden, könnte das Fahrzeug dafür belohnt werden, auf geraden Abschnitten der Strecke weniger zu lenken. Die Belohnungsfunktion kann positive Werte liefern, wenn das Fahrzeug bestimmte Meilensteine passiert (über [`waypoints`](deepracer-reward-function-input.md)). Dies könnte verhindern, dass das Fahrzeug abwartet oder in die falsche Richtung fährt. Vermutlich werden Sie die Belohnungsfunktion verändern, um die Streckenbedingungen zu berücksichtigen. Je stärker Ihre Belohnungsfunktion umgebungsspezifische Informationen berücksichtigt, desto wahrscheinlicher ist es jedoch, dass Ihr trainiertes Modell zu stark angepasst und weniger universell einsatzbar ist. Um Ihr Modell universeller einsetzbar zu gestalten, können Sie [Aktionsräume](#deepracer-define-action-space-for-training) ausprobieren. Wenn ein Incentive-Plan nicht sorgfältig geprüft wird, kann er zu [unbeabsichtigten Folgen mit gegenteiliger Wirkung](https://en.wikipedia.org/wiki/Cobra_effect) führen. Dies liegt daran, dass das direkte Feedback eine notwendige, aber nicht ausreichende Voraussetzung für das Reinforcement Learning ist. Eine individuelle direkte Belohnung allein zeigt nicht, ob eine Aktion wünschenswert ist. An einer bestimmten Position kann eine Aktion beispielsweise eine hohe Belohnung erzielen. Eine nachfolgende Aktion könnte das Fahrzeug von der Strecke führen und eine niedrige Bewertung erzielen. In diesem Fall sollte das Fahrzeug die Bewegung mit der höchsten Bewertung an dieser Position vermeiden. Erst wenn alle zukünftigen Bewegungen von einer bestimmten Position zu einer hohen Durchschnittsbewertung führen, sollte der Wechsel zur nächsten Position als wünschenswert erachtet werden. Das zukünftige Feedback wird niedriger bewertet. So werden weniger zukünftige Bewegungen oder Positionen in die Berechnung der durchschnittlichen Belohnung einbezogen. Zum Erstellen einer [Belohnungsfunktion](deepracer-reward-function-reference.md) empfiehlt es sich, mit einer einfachen Funktion zu beginnen, die grundlegende Szenarien abdeckt. Sie können die Funktion erweitern, um mehr Aktionen zu verarbeiten. Schauen wir uns nun einige einfache Belohnungsfunktionen an. **Topics** + [Einfache Beispiele für Belohnungsfunktionen](#deepracer-reward-function-simple-examples) + [Verbessern Sie Ihre Belohnungsfunktion](#deepracer-iteratively-enhance-reward-functions) ### Einfache Beispiele für Belohnungsfunktionen Wir können mit der Erstellung der Belohnungsfunktion beginnen, indem wir zuerst die grundlegendste Situation berücksichtigen. Das ist eine Situation, in der von Anfang bis Ende auf einer geraden Strecke gefahren wird, ohne die Strecke zu verlassen. In diesem Szenario hängt die Logik der Belohnungsfunktion nur von `on_track` und `progress` ab. Als Versuch könnten Sie mit der folgenden Logik beginnen: ``` def reward_function(params): if not params["all_wheels_on_track"]: reward = -1 else if params["progress"] == 1 : reward = 10 return reward ``` Diese Logik bestraft den Agenten, wenn er die Strecke verlässt. Sie belohnt den Agenten, wenn er zur Ziellinie fährt. Es ist sinnvoll, das gesteckte Ziel zu erreichen. Der Agent bewegt sich jedoch frei zwischen dem Startpunkt und der Ziellinie (einschließlich der Rückwärtsfahrt auf der Strecke). Das Training könnte nicht nur lange dauern, sondern das trainierte Modell würde beim Einsatz in einem realen Fahrzeug auch zu einer weniger effizienten Fahrweise führen. In der Praxis lernt ein Mitarbeiter effektiver, wenn er dies bit-by-bit im Laufe der Schulung tun kann. Dies bedeutet, dass eine Belohnungsfunktion Schritt für Schritt auf der Strecke kleinere Belohnungen ausgeben sollte. Damit der Agent auf der geraden Strecke fährt, können wir die Belohnungsfunktion wie folgt verbessern: ``` def reward_function(params): if not params["all_wheels_on_track"]: reward = -1 else: reward = params["progress"] return reward ``` Mit dieser Funktion erhält der Agent umso mehr Belohnung, je näher er die Ziellinie erreicht. Dies sollte unproduktive Versuche der Rückwärtsfahrt reduzieren oder beseitigen. Im Allgemeinen wollen wir, dass die Belohnungsfunktion die Belohnung gleichmäßiger über den Aktionsraum verteilt. Das Entwickeln einer effektiven Belohnungsfunktion kann eine Herausforderung sein. Sie sollten mit einer einfachen Funktion beginnen und diese schrittweise erweitern oder verbessern. Durch systematisches Experimentieren kann die Funktion stabiler und effizienter werden. ### Verbessern Sie Ihre Belohnungsfunktion Nachdem Sie Ihr DeepRacer AWS-Modell erfolgreich für die einfache gerade Strecke trainiert haben, kann das DeepRacer AWS-Fahrzeug (virtuell oder physisch) selbstständig fahren, ohne von der Strecke abzukommen. Wenn Sie das Fahrzeug auf einer Ringstrecke fahren lassen, bleibt es nicht auf der Strecke. Die Belohnungsfunktion hat die Aktionen ignoriert, um Kurven zu lenken und so der Strecke zu folgen. Damit Ihr Fahrzeug diese Aktionen ausführen kann, müssen Sie die Belohnungsfunktion erweitern. Die Funktion muss eine Belohnung gewähren, wenn der Agent eine zulässige Drehung macht, und eine Strafe vorsehen, wenn der Agent eine unzulässige Drehung macht. Dann sind Sie bereit, eine weitere Trainingsrunde zu beginnen. Um die Vorteile des vorherigen Trainings zu nutzen, können Sie das neue Training beginnen, indem Sie das vorher trainierte Modell klonen und so das zuvor erlernte Wissen weitergeben. Sie können diesem Muster folgen, um die Prämienfunktion schrittweise um weitere Funktionen zu erweitern und Ihr DeepRacer AWS-Fahrzeug darauf vorzubereiten, in immer komplexeren Umgebungen zu fahren. Weitere erweiterte Belohnungsfunktionen finden Sie in den folgenden Beispielen: + [Beispiel 1: Folgen Sie beim Zeitfahren der Mittellinie](deepracer-reward-function-examples.md#deepracer-reward-function-example-0) + [Beispiel 2: Bleiben Sie beim Zeitfahren innerhalb der beiden Grenzen](deepracer-reward-function-examples.md#deepracer-reward-function-example-1) + [Beispiel 3: Vermeiden Sie Zick-Zack-Bewegungen bei Zeitfahren](deepracer-reward-function-examples.md#deepracer-reward-function-example-2) + [Beispiel 4: Bleiben Sie auf einer Spur, ohne gegen stehende Hindernisse oder fahrende Fahrzeuge zu stoßen](deepracer-reward-function-examples.md#deepracer-reward-function-example-3) ## Erkunden Sie den Aktionsraum, um ein robustes Modell zu trainieren In der Regel sollten Sie Ihr Modell so zuverlässig wie möglich trainieren. Nur so können Sie es in möglichst vielen Umgebungen einsetzen. Ein zuverlässiges Modell ist ein Modell, das in einer Vielzahl von Streckenformen und -bedingungen eingesetzt werden kann. Ein zuverlässiges Modell ist grundsätzlich nicht "intelligent", denn seine Belohnungsfunktion deckt kein explizites, umgebungsspezifisches Wissen ab. Wenn dies der Fall wäre, würde Ihr Modell wahrscheinlich nur in einer Umgebung anwendbar sein, die der trainierten Umgebung ähnlich ist. Die explizite Einbeziehung umgebungsspezifischer Informationen in die Belohnungsfunktion wird als Feature-Engineering (Funktionalitätsentwicklung) bezeichnet. Mit dem Feature-Engineering können Sie die Trainingszeit verkürzen. Sie können es für Lösungen einsetzen, die auf eine bestimmte Umgebung zugeschnitten sind. Um ein allgemein einsetzbares Modell zu trainieren, sollten Sie jedoch auf den großzügigen Einsatz von Feature-Engineering verzichten. Wenn Sie beispielsweise ein Modell auf einer Rundstrecke trainieren, können Sie kein trainiertes Modell erwarten, das auf einer nicht kreisförmige Strecke einsetzbar ist (sofern Sie entsprechende geometrische Eigenschaften in die Belohnungsfunktion integriert haben). Wie würden Sie ein Modell so zuverlässig wie möglich trainieren und gleichzeitig die Belohnungsfunktion so einfach wie möglich halten? Eine Methode besteht darin, den Aktionsraum mit den möglichen, vom Agenten durchführbaren Aktionen zu analysieren. Eine weitere ist das Experimentieren mit [Hyperparametern](#deepracer-iteratively-adjust-hyperparameters) für den zugrunde liegenden Trainingsalgorithmus. Meistens kommen beide Methoden zur Anwendung. Hier konzentrieren wir uns darauf, wie Sie den Aktionsraum erkunden können, um ein robustes Modell für Ihr DeepRacer AWS-Fahrzeug zu trainieren. Beim Training eines DeepRacer AWS-Modells ist eine Aktion (`a`) eine Kombination aus Geschwindigkeit (`t`Meter pro Sekunde) und Lenkwinkel (`s`in Grad). Der Aktionsraum des Agenten definiert die möglichen Geschwindigkeitsbereiche und Lenkwinkel des Agenten. Für einen diskreten Aktionsraum von `m` Geschwindigkeiten (`(v1, .., vn)`) und `n` Lenkwinkeln (`(s1, .., sm)`) umfasst der Aktionsraum `m*n` mögliche Aktionen: ``` a1: (v1, s1) ... an: (v1, sn) ... a(i-1)*n+j: (vi, sj) ... a(m-1)*n+1: (vm, s1) ... am*n: (vm, sn) ``` Die tatsächlichen Werte von `(vi, sj)` hängen von den Bereichen von `vmax` und `|smax|` ab und sind nicht einheitlich verteilt. Jedes Mal, wenn Sie mit dem Training oder der Iteration Ihres DeepRacer AWS-Modells beginnen, müssen Sie zunächst die `n``m`, `vmax` und `|smax|` oder angeben, dass deren Standardwerte verwendet werden. Basierend auf Ihrer Wahl generiert der DeepRacer AWS-Service die verfügbaren Aktionen, die Ihr Agent in der Schulung auswählen kann. Die erzeugten Aktionen sind nicht gleichmäßig über den Aktionsraum verteilt. Im Allgemeinen geben eine größere Anzahl von Aktionen und größere Aktionsbereiche Ihrem Agenten mehr Raum oder Möglichkeiten, um auf unterschiedlichste Streckenbedingungen zu reagieren (z. B. eine Kurvenstrecke mit unregelmäßigen Kurvenwinkeln oder -richtungen). Je mehr Optionen dem Agenten zur Verfügung stehen, desto besser kann er mit Streckenvariationen umgehen. Infolgedessen können Sie erwarten, dass das trainierte Modell auch mit einer einfachen Belohnungsfunktion umfassender einsetzbar ist. So kann Ihr Agent mithilfe eines grob eingeteilten Aktionsraums mit wenigen Geschwindigkeiten und Lenkwinkeln beispielsweise den Umgang mit einer geradlinigen Strecke schnell erlernen. Bei einer Strecke mit Kurven wird dieser grob eingeteilte Aktionsraum jedoch vermutlich dazu führen, dass der Agent bei Kurvenfahrten über die Streckenbegrenzung hinausfährt. Dies liegt daran, dass ihm nicht genügend Möglichkeiten zur Verfügung stehen, um die Geschwindigkeit oder die Lenkung zu ändern. Wenn Sie die Anzahl der Geschwindigkeiten oder der Lenkwinkel bzw. beides erhöhen, sollte der Agent in der Lage sein, durch Kurven zu manövrieren und innerhalb der Begrenzungen zu bleiben. Wenn sich Ihr Agent im Zickzack bewegt, können Sie außerdem versuchen, die Anzahl der Lenkbereiche zu erhöhen. So können Sie das Auftreten extremer Drehungen bei einem einzelnen Schritt reduzieren. Wenn der Aktionsraum zu groß ist, kann die Trainingsleistung leiden. Denn in diesem Fall kann die Erkundung des Aktionsraums länger dauern. Stellen Sie sicher, dass Sie die Vorteile der allgemeinen Einsetzbarkeit eines Modells mit den Anforderungen an die Trainingsleistung in Einklang bringen. Diese Optimierung umfasst systematisches Experimentieren. ## Passen Sie Hyperparameter systematisch an Eine Möglichkeit zur Verbesserung der Leistung Ihres Modells besteht darin, einen besseren oder effektiveren Trainingsprozess zu implementieren. Um ein zuverlässiges Modell zu erhalten, muss das Training beispielsweise mehr oder weniger gleichmäßig über den Aktionsraum des Agenten verteilte Stichproben generieren. Dies erfordert eine ausreichende Mischung aus Erkundung und Förderung. Zu den diesbezüglichen Variablen gehören die Menge der verwendeten Trainingsdaten (`number of episodes between each training` und `batch size`), die Lerngeschwindigkeit des Agenten (`learning rate`) und der Erkundungsanteil (`entropy`). Um das Training praxisnah zu gestalten, können Sie den Lernprozess beschleunigen. Zu den entsprechenden Variablen gehören `learning rate`, `batch size`, `number of epochs` und `discount factor`. Die Variablen mit Einfluss auf den Trainingsprozess werden als Hyperparameter des Trainings bezeichnet. Diese Algorithmusattribute stellen keine Eigenschaften des zugrunde liegenden Modells dar. Leider sind Hyperparameter empirischer Natur. Ihre optimalen Werte sind nicht für alle Anwendungszwecke bekannt und erfordern systematisches Experimentieren. Bevor wir uns mit den Hyperparametern befassen, die angepasst werden können, um die Leistung beim Training Ihres DeepRacer AWS-Modells zu optimieren, wollen wir die folgende Terminologie definieren. Datenpunkt Ein Datenpunkt (auch *Erfahrung*) ist ein Tupel von (*s,a,r,s'*), wobei *s* für eine Beobachtung (oder einen Zustand) steht, die von der Kamera erfasst wird. *a* steht für eine vom Fahrzeug durchgeführte Aktion. *r* steht für die erwartete Belohnung, die durch die Aktion ausgelöst wird. *s'* steht für die neue Beobachtung, nachdem die Aktion durchgeführt wurde. Episode Eine Episode ist ein Zeitraum, in dem das Fahrzeug von einem bestimmten Ausgangspunkt aus startet und die Strecke an deren Ende abschließt bzw. die Strecke verlässt. Sie stellt eine Abfolge von Erfahrungen dar. Episoden können unterschiedliche Längen haben. Erfahrungspuffer Ein Erfahrungspuffer besteht aus einer Reihe von geordneten Datenpunkten, die über eine feste Anzahl von Episoden unterschiedlicher Länge während des Trainings gesammelt werden. Für AWS entspricht es den Bildern DeepRacer, die von der an Ihrem DeepRacer AWS-Fahrzeug montierten Kamera aufgenommen wurden, und den vom Fahrzeug ausgeführten Aktionen. Es dient als Quelle, aus der Eingaben für die Aktualisierung der zugrunde liegenden (Richtlinien- und Wert-) neuronalen Netzwerke gezogen werden. Batch Ein Batch ist eine geordnete Liste von Erfahrungen, die einen Teil der Simulation über einen bestimmten Zeitraum darstellen und zur Aktualisierung der Gewichtung der Strategienetzwerke verwendet werden. Es handelt sich um eine Teilmenge des Erfahrungspuffers. Trainingsdaten Trainingsdaten sind eine Reihe von Batches, die nach dem Zufallsprinzip aus einem Erfahrungspuffer entnommen und für das Training der Gewichtung der Strategienetzwerke verwendet werden. **Algorithmische Hyperparameter und ihre Auswirkungen** | Hyperparameter | Description | | --- | --- | | **Gradientenabstieg-Batchgröße** | Die Anzahl der letzten Fahrzeugerfahrungen, die zufällig aus einem Erfahrungspuffer entnommen und zur Aktualisierung der zugrunde liegenden Gewichtung der neuronalen Deep-Learning-Netze verwendet wurden. Zufallsstichproben helfen, die in den Eingangsdaten enthaltenen Korrelationen zu reduzieren. Verwenden Sie eine größere Batchgröße, um stabilere und reibungslosere Aktualisierungen der Gewichtungen der neuronalen Netze zu fördern. Bedenken Sie jedoch, dass das Training länger dauern bzw. langsamer sein kann.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | | **Number of epochs (Anzahl der Epochen) ** | Die Anzahl der Durchläufe durch die Trainingsdaten zur Aktualisierung der Gewichtungen des neuronalen Netzes während des Gradientenabstiegs. Die Trainingsdaten entsprechen Stichproben aus dem Erfahrungspuffer. Verwenden Sie eine größere Anzahl von Epochen, um zuverlässigere Aktualisierungen zu fördern. Bedenken Sie jedoch, dass das Training länger dauern bzw. langsamer sein kann. Wenn die Batchgröße klein ist, können Sie eine kleinere Epochenanzahl verwenden.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | | **Learning rate (Lernrate) ** | Bei jeder Aktualisierung kann ein Teil der neuen Gewichtung aus dem Gradientenabstieg (oder Aufstieg) stammen. Der Rest kann dem vorhandenen Gewichtungswert entnommen werden. Die Lernrate steuert, wie stark ein Gradientenabstieg (oder Aufstieg) zur Gewichtung der Netze beiträgt. Verwenden Sie eine höhere Lernrate, um mehr Daten aus dem Gradientenabstieg einzubeziehen. So wird das Training schneller. Bedenken Sie jedoch, dass sich die erwartete Belohnung möglicherweise nicht annähert, wenn die Lernrate zu hoch ist. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | | Entropy | Ein gewisses Maß an Unsicherheit, das für einen Zufallsfaktor in der Strategieverteilung verwendet wird. Die zusätzliche Unsicherheit hilft dem DeepRacer AWS-Fahrzeug, den Aktionsraum umfassender zu erkunden. Ein größerer Entropiewert veranlasst das Fahrzeug, den Aktionsraum gründlicher zu erforschen. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | | Discount factor (Rabattfaktor) | Ein Faktor gibt an, wie viele der zukünftigen Belohnungen zu der erwarteten Belohnung beitragen. Je größer der **Discount factor (Abschlagfaktor)**-Wert ist, desto weiter entfernt liegen die Beiträge, die das Fahrzeug für eine Bewegung berücksichtigt, und desto langsamer ist das Training. Mit dem Abschlagfaktor 0,9 berücksichtigt das Fahrzeug Belohnungen aus einer Schrittlänge von 10 für zukünftige Bewegungen. Mit dem Abschlagfaktor 0,999 berücksichtigt das Fahrzeug Belohnungen aus einer Schrittlänge von 1000 für zukünftige Bewegungen. Die empfohlenen Werte für den Abschlagfaktor sind 0,99, 0,999 und 0,9999. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | | Loss type (Schadensart) | Typ der Zielfunktion, mit der die Netzwerkgewichte aktualisiert werden. Ein guter Trainingsalgorithmus sollte schrittweise Änderungen an der Strategie des Agenten vornehmen, sodass er allmählich von zufälligen Aktionen zu strategischen Aktionen übergeht, um die Belohnung zu erhöhen. Aber wenn es eine zu große Veränderung bewirkt, dann wird das Training instabil und der Agent lernt am Ende nicht. Die Typen [https://en.wikipedia.org/wiki/Huber_loss](https://en.wikipedia.org/wiki/Huber_loss) und [https://en.wikipedia.org/wiki/Mean_squared_error](https://en.wikipedia.org/wiki/Mean_squared_error) verhalten sich für kleine Updates ähnlich. Aber wenn die Updates größer werden, nimmt **Huber loss (Huber-Verlust)** kleinere Inkremente im Vergleich zu **Mean squared error loss (Mittlerer quadratischer Fehlerverlust)** vor. Wenn Sie Konvergenzprobleme haben, verwenden Sie den Typ **Huber loss (Huber-Verlust)**. Wenn die Konvergenz gut ist und Sie schneller trainieren wollen, verwenden Sie den Typ **Mean squared error loss (Mittlerer quadratischer Fehlerverlust)**. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | | Anzahl der Erfahrungsepisoden zwischen den einzelnen Iterationen zur Strategieaktualisierung | Die Größe des Erfahrungspuffers, aus dem Trainingsdaten zum Lernen der Gewichtung der Strategienetzwerke entnommen werden. Eine Episode ist ein Zeitraum, in dem der Agent von einem bestimmten Ausgangspunkt aus startet und die Strecke an deren Ende abschließt bzw. die Strecke verlässt. Sie besteht aus einer Reihe von Erfahrungen. Episoden können unterschiedliche Längen haben. Bei einfachen Reinforcement-Learning-Problemen kann ein kleiner Erfahrungspuffer ausreichen. Der Lernprozess ist schnell. Bei komplexeren Problemen mit mehr lokalen Maximallösungen ist ein größerer Erfahrungspuffer erforderlich, um mehr unkorrelierte Datenpunkte bereitzustellen. In diesem Fall ist das Training langsamer, aber stabiler. Die empfohlenen Werte sind 10, 20 und 40.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) | ## Untersuchen Sie den Fortschritt der DeepRacer AWS-Schulungen Nachdem Sie Ihren Trainingsauftrag gestartet haben, können Sie die Trainingsmetriken der Belohnungen und des Streckenabschlusses pro Episode prüfen, um die Leistung des Trainingsauftrags Ihres Modells zu ermitteln. Auf der DeepRacer AWS-Konsole werden die Metriken im **Prämiendiagramm** angezeigt, wie in der folgenden Abbildung dargestellt. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/best-model-bar-reward-graph2.png) Sie können die pro Episode erworbene Belohnung, die gemittelte Belohnung pro Iteration, den Fortschritt pro Episode, den gemittelten Fortschritt pro Iteration oder eine beliebige Kombination hiervon anzeigen. Schalten Sie dazu die Schalter **Reward (Episode, Average) (Belohnung (Episode, Durchschnitt))** oder **Progress (Episode, Average) (Fortschritt (Episode, Durchschnitt))** unten im **Reward graph (Belohnungsdiagramm)**um. Die Belohnung und der Fortschritt pro Episode werden als Streudiagramme in verschiedenen Farben angezeigt. Die gemittelte Belohnung und der Streckenabschluss werden in Liniendiagrammen angezeigt und beginnen nach der ersten Iteration. Der Belohnungsbereich wird auf der linken Seite des Diagramms angezeigt und der Fortschrittsbereich (0 - 100) auf der rechten Seite. Um den genauen Wert einer Trainingsmetrik zu lesen, bewegen Sie den Mauszeiger in die Nähe des Datenpunkts auf dem Diagramm. Die Diagramme werden während des Trainings automatisch alle 10 Sekunden aktualisiert. Sie können die Schaltfläche „Refresh (Aktualisieren)” auswählen, um die Metrikanzeige manuell zu aktualisieren. Ein Trainingsauftrag ist gut, wenn die gemittelte Belohnung und der Streckenabschluss die Tendenz zeigen, zu konvergieren. Insbesondere ist das Modell wahrscheinlich konvergiert, wenn der Fortschritt pro Episode kontinuierlich 100 % erreicht und die Belohnung ausgeglichen ist. Wenn dies nicht der Fall ist, klonen Sie das Modell und trainieren Sie es neu. ## Klonen Sie ein trainiertes Modell, um einen neuen Trainingspass zu starten Wenn Sie ein zuvor trainiertes Modell als Ausgangspunkt für eine neue Trainingsrunde klonen, können Sie die Trainingseffizienz verbessern. Modifizieren Sie dazu die Hyperparameter, um das bereits erlernte Wissen zu nutzen. In diesem Abschnitt erfahren Sie, wie Sie ein trainiertes Modell mithilfe der DeepRacer AWS-Konsole klonen. **Um das Reinforcement-Learning-Modell mithilfe der DeepRacer AWS-Konsole zu trainieren** 1. Melden Sie sich bei der DeepRacer AWS-Konsole an, falls Sie noch nicht angemeldet sind. 1. Wählen Sie auf der Seite **Modelle** ein trainiertes Modell aus und wählen Sie dann in der Drop-down-Menüliste **Aktion** die Option **Clone** aus. 1. Gehen Sie für **Model details (Modelldetails)** wie folgt vor: 1. Geben Sie `RL_model_1` als **Model name (Modellname)** ein, wenn Sie nicht möchten, dass ein Name für das geklonte Modell generiert wird. 1. Geben Sie optional im Feld to-be-cloned Modellbeschreibung **— optional eine Beschreibung für das Modell** ein. 1. Wählen Sie für die **Umgebungssimulation** eine andere Spuroption. 1. Wählen Sie für die **Reward function (Belohnungsfunktion)** eines der verfügbaren Beispiele für Belohnungsfunktionen aus. Modifizieren Sie die Belohnungsfunktion. Berücksichtigen Sie zum Beispiel das Lenken. 1. Erweitern Sie **Algorithm settings (Algorithmeneinstellungen)** und probieren Sie verschiedene Optionen aus. Ändern Sie beispielsweise den Wert **Gradient descent batch size (Gradientenabstieg-Batchgröße)** von 32 auf 64 oder erhöhen Sie die **Learning Rate (Lernrate)**, um das Training zu beschleunigen. 1. Experimentieren Sie mit verschiedenen Einstellungen der **Stop conditions (Stoppbedingungen)**. 1. Wählen Sie **Start training (Training starten)** aus, um eine neue Runde des Trainings zu beginnen. Wie beim Training eines robusten Machine-Learning-Modells im Allgemeinen ist es wichtig, dass Sie systematische Experimente durchführen, um die beste Lösung zu finden. ## Evaluieren Sie DeepRacer AWS-Modelle in Simulationen Ein Modell auszuwerten bedeutet, die Leistung eines trainierten Modells zu testen. In AWS DeepRacer ist die Standard-Leistungskennzahl die durchschnittliche Zeit, in der drei aufeinanderfolgende Runden beendet wurden. Bei Verwendung dieser Metrik ist für zwei beliebige Modelle ein Modell besser als das andere, wenn es den Agenten auf derselben Strecke schneller voranbringen kann. Im Allgemeinen umfasst die Bewertung eines Modells die folgenden Aufgaben: 1. Konfigurieren und starten Sie einen Auswertungsauftrag. 1. Beobachten Sie die laufende Auswertung, während der Auftrag läuft. Dies kann im DeepRacer AWS-Simulator erfolgen. 1. Überprüfen Sie die Auswertungszusammenfassung, nachdem der Auswertungsauftrag abgeschlossen ist. Sie können einen laufenden Auswertungsauftrag jederzeit abbrechen. **Anmerkung** Die Testzeit hängt von den von Ihnen ausgewählten Kriterien ab. Wenn Ihr Modell die Bewertungskriterien nicht erfüllt, wird die Bewertung fortgesetzt, bis die Obergrenze von 20 Minuten erreicht ist. 1. Reichen Sie das Bewertungsergebnis optional bei einer qualifizierten [ DeepRacer AWS-Bestenliste](deepracer-racing-series.md) ein. Das Ranglistenergebnis auf der Rangliste zeigt Ihnen, wie gut sich Ihr Modell im Vergleich zu anderen Teilnehmern schlägt. Testen Sie ein DeepRacer AWS-Modell mit einem DeepRacer AWS-Fahrzeug, das auf einer physischen Strecke fährt, siehe[Betreiben Sie Ihr DeepRacer AWS-Fahrzeug](operate-deepracer-vehicle.md). ## Optimieren Sie DeepRacer AWS-Schulungsmodelle für reale Umgebungen Viele Faktoren beeinflussen die praktische Leistung eines trainierten Modells. Dazu gehören beispielsweise der [Aktionsraum](#deepracer-define-action-space-for-training), die [Belohnungsfunktion](#deepracer-train-models-define-reward-function) und die [Hyperparameter](#deepracer-iteratively-adjust-hyperparameters) im Training, die [Fahrzeugkalibrierung](deepracer-calibrate-vehicle.md) und die Bedingungen der [Strecke in der echten Welt](deepracer-build-your-track.md). Darüber hinaus ist die Simulation nur eine (oft grobe) Annäherung an die Praxis. Diese Faktoren sorgen dafür, dass das Training eines Modells in der Simulation und dessen späterer Einsatz in der echten Welt mit einer zufriedenstellenden Leistung schwierig ist. Das Trainieren eines Modells für eine solide Leistung in der Praxis erfordert oft zahlreiche Iterationen zur Erforschung der [Belohnungsfunktion](#deepracer-train-models-define-reward-function), [Aktionsräume](#deepracer-define-action-space-for-training), [Hyperparameter](#deepracer-iteratively-adjust-hyperparameters) und [Bewertungen](#deepracer-evaluate-models-in-simulator) in der Simulation sowie dem [Testen](deepracer-drive-your-vehicle.md) in einer realen Umgebung. Der letzte Schritt beinhaltet den sogenannten *simulation-to-real Welttransfer* (*sim2real*) und kann sich unhandlich anfühlen. Berücksichtigen Sie die folgenden Punkte, um den *sim2real*-Vorgang einfacher zu gestalten: + Stellen Sie sicher, dass Ihr Fahrzeug sauber kalibriert ist. Dies ist wichtig, da die simulierte Umgebung höchstwahrscheinlich eine teilweise Darstellung der realen Umgebung ist. Außerdem führt der Agent bei jedem Schritt eine Aktion durch, die auf der aktuellen von der Kamera aufgenommenen Streckenbedingung basiert. Es kann nicht weit genug sehen, um seine Route mit hoher Geschwindigkeit zu planen. Um dies zu berücksichtigen, setzt die Simulation Grenzen für die Geschwindigkeit und Lenkung. Um sicherzustellen, dass das trainierte Modell in der realen Welt funktioniert, muss das Fahrzeug entsprechend diesen und anderen Simulationseinstellungen kalibriert sein. Weitere Informationen zur Kalibrierung Ihres Fahrzeugs finden Sie unter [Kalibrieren Sie Ihr AWS-Fahrzeug DeepRacer](deepracer-calibrate-vehicle.md). + Testen Sie Ihr Fahrzeug zunächst mit dem Standardmodell. Ihr DeepRacer AWS-Fahrzeug wird mit einem vortrainierten Modell geliefert, das in die Inferenz-Engine geladen ist. Bevor Sie Ihr eigenes Modell in der realen Welt testen, vergewissern Sie sich, dass das Fahrzeug mit dem Standardmodell recht gut funktioniert. Wenn nicht, überprüfen Sie das physische Strecken-Setup. Das Testen eines Modells in einer falsch gebauten physischen Strecke führt wahrscheinlich zu einer schlechten Leistung. In solchen Fällen sollten Sie Ihre Strecke neu konfigurieren oder reparieren, bevor Sie mit dem Testen beginnen oder den Test fortsetzen. **Anmerkung** Beim Betrieb Ihres DeepRacer AWS-Fahrzeugs werden Aktionen gemäß dem trainierten Policy-Netzwerk abgeleitet, ohne dass die Belohnungsfunktion aufgerufen wird. + Stellen Sie sicher, dass das Modell in der Simulation funktioniert. Wenn Ihr Modell in der realen Welt nicht gut funktioniert, könnten das Modell oder die Strecke fehlerhaft sein. Zur Klärung der Ursachen sollten Sie zunächst [das Modell in Simulationen](#deepracer-evaluate-models-in-simulator) evaluieren, um zu prüfen, ob der simulierte Agent mindestens eine Runde beenden kann, ohne von der Strecke abzukommen. Sie können dies tun, indem Sie die Konvergenz der Belohnungen überprüfen, während Sie die Bewegungsbahn des Agenten im Simulator beobachten. Wenn die Belohnung das Maximum erreicht und wenn die simulierten Agenten ohne Unterbrechung eine Runde beenden, ist das Modell wahrscheinlich in Ordnung. + Trainieren Sie das Modell nicht zu stark. Das Fortfahren mit dem Training, nachdem das Modell die Strecke in der Simulation konsequent absolviert hat, führt zu einer Überanpassung des Modells. Ein übertrainiertes Modell funktioniert in der realen Welt nicht besonders gut. Es kann selbst geringe Abweichungen zwischen der simulierten Strecke und der realen Umgebung nicht bewältigen. + Verwenden Sie mehrere Modelle aus verschiedenen Iterationen. Eine typische Trainingseinheit produziert eine Reihe von Modellen, die irgendwo zwischen Unter- und Überanpassung liegen. Da es keine standardmäßigen Kriterien zur Bestimmung eines genau passenden Modells gibt, sollten Sie einige Modellkandidaten zwischen dem Zeitpunkt auswählen, an dem der Agent eine einzelne Runde im Simulator beendet, und dem Zeitpunkt, an dem er die Runde konsistent absolviert. + Beginnen Sie langsam und erhöhen Sie die Fahrgeschwindigkeit im Test schrittweise. Wenn Sie das in Ihrem Fahrzeug eingesetzte Modell testen, beginnen Sie mit einem niedrigen Höchstgeschwindigkeitswert. Beispielsweise können Sie die Testgeschwindigkeit auf weniger als 10 % der Trainingsgeschwindigkeit festlegen. Erhöhen Sie dann schrittweise die Testgeschwindigkeitsbegrenzung, bis sich das Fahrzeug in Bewegung setzt. Die Testgeschwindigkeitsbegrenzung legen Sie bei der Kalibrierung des Fahrzeugs über die Gerätesteuerkonsole fest. Wenn das Fahrzeug zu schnell fährt, beispielsweise wenn die Geschwindigkeit die Geschwindigkeit übersteigt, die während des Trainings im Simulator gemessen wurde, ist es unwahrscheinlich, dass das Modell auf der realen Strecke gut abschneidet. + Testen Sie ein Modell mit Ihrem Fahrzeug in verschiedenen Ausgangspositionen. Das Modell lernt, einen bestimmten Weg in der Simulation zu nehmen, und kann auf seine Position innerhalb der Strecke reagieren. Sie sollten die Fahrzeugtests mit verschiedenen Positionen innerhalb der Streckenbegrenzungen (links, Mitte, rechts) starten, um zu sehen, ob das Modell von bestimmten Positionen aus gut funktioniert. Die meisten Modelle neigen dazu, das Fahrzeug nahe an der Seite einer der weißen Linien zu halten. Um den Weg des Fahrzeugs zu analysieren, zeichnen Sie Schritt für Schritt die Positionen des Fahrzeugs (x, y) aus der Simulation auf. So können Sie mögliche Wege identifizieren, die Ihr Fahrzeug in einer realen Umgebung zurücklegen muss. + Beginnen Sie die Tests mit einer geraden Strecke. Eine gerade Strecke ist viel einfacher zu bewältigen als eine kurvige Strecke. Mit einer geraden Strecke zu beginnen bietet die Möglichkeit, schlechte Modelle schnell auszusortieren. Wenn ein Fahrzeug meistens daran scheitert, einer geraden Strecke zu folgen, wird das Modell auch auf kurvenreichen Strecken nicht gut funktionieren. + Achten Sie auf Verhaltensweisen, bei denen das Fahrzeug nur eine Art von Aktionen ausführt. Wenn Ihr Fahrzeug nur eine Art von Maßnahmen ergreifen kann, z. B. das Fahrzeug nur nach links zu lenken, ist das Modell wahrscheinlich über- oder unterausgestattet. Zu viele Trainings-Iterationen bei gegebenen Modellparametern können dazu führen, dass das Modell übermäßig angepasst wird. Zu wenig Iterationen können dazu führen, dass es nicht richtig angepasst ist. + Achten Sie auf die Fähigkeit des Fahrzeugs, seinen Weg entlang einer Streckenbegrenzung zu korrigieren. Ein gutes Modell bewirkt, dass sich das Fahrzeug bei Annäherung an die Streckenbegrenzungen selbst korrigiert. Die meisten gut trainierten Modelle verfügen über diese Fähigkeit. Wenn sich das Fahrzeug an beiden Streckenbegrenzungen selbst korrigieren kann, gilt das Modell als stabiler und hochwertiger. + Achten Sie auf ein inkonsistentes Verhalten des Fahrzeugs. Ein Strategiemodell stellt eine Wahrscheinlichkeitsverteilung für das Ergreifen einer Aktion in einem bestimmten Zustand dar. Wenn das trainierte Modell in die Inferenz-Engine geladen wird, wählt ein Fahrzeug schrittweise entsprechend den Vorgaben des Modells die wahrscheinlichste Aktion aus. Wenn die Aktionswahrscheinlichkeiten gleichmäßig verteilt sind, kann das Fahrzeug alle Aktionen mit identischen oder sehr ähnlichen Wahrscheinlichkeiten durchführen. Dies führt zu einem unregelmäßigen Fahrverhalten. Wenn das Fahrzeug beispielsweise manchmal (z. B. die Hälfte der Zeit) einem geraden Weg folgt und zu anderen Zeiten unnötig abbiegt, ist das Modell entweder zu wenig oder zu stark ausgestattet. + Achten Sie darauf, dass das Fahrzeug nur einmal abbiegt (links oder rechts). Wenn das Fahrzeug sehr gut nach links abbiegt, aber nicht nach rechts lenkt (oder andersrum), müssen Sie die Lenkung Ihres Fahrzeugs sorgfältig kalibrieren oder neu kalibrieren. Alternativ können Sie versuchen, ein Modell zu verwenden, das mit Einstellungen trainiert wurde, die den zu testenden physischen Einstellungen entsprechen. + Achten Sie darauf, dass das Fahrzeug plötzlich abbiegt und von der Strecke abkommt. Wenn das Fahrzeug den größten Teil des Weges korrekt zurücklegt, aber plötzlich von der Strecke abkommt, liegt dies wahrscheinlich an Ablenkungen in der Umgebung. Zu den häufigsten Ablenkungen gehören unerwartete oder unbeabsichtigte Lichtreflexionen. Verwenden Sie in solchen Fällen Barrieren um die Strecke herum oder andere Mittel, um grelles Licht zu reduzieren. # Referenz zur DeepRacer AWS-Prämienfunktion Im Folgenden finden Sie die technische Referenz der DeepRacer AWS-Prämienfunktion. **Topics** + [Eingabeparameter der DeepRacer AWS-Belohnungsfunktion](deepracer-reward-function-input.md) + [Beispiele AWS DeepRacer AWS-Prämienfunktionen](deepracer-reward-function-examples.md) # Eingabeparameter der DeepRacer AWS-Belohnungsfunktion Die DeepRacer AWS-Belohnungsfunktion verwendet ein Wörterbuchobjekt als Eingabe. ``` def reward_function(params) : reward = ... return float(reward) ``` Das `params`-Dictionary-Objekt enthält die folgenden Schlüssel/Werte-Paare: ``` { "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 } ``` Es folgt eine detaillierte technische Referenz der Eingangsparameter. ## all\$1wheels\$1on\$1track **Typ: ** `Boolean` **Bereich ** `(True:False)` Ein `Boolean`-Flag, das anzeigt, ob sich der Agent auf der Strecke oder außerhalb der Strecke befindet. Es ist außerhalb der Strecke (`False`), wenn sich eines seiner Räder außerhalb der Streckenbegrenzungen befindet. Es ist auf der Strecke (`True`), wenn sich alle Räder innerhalb der beiden Streckenbegrenzungen befinden. Die folgende Abbildung zeigt, dass sich der Agent auf der Strecke befindet. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-true.png) Die folgende Abbildung zeigt, dass sich der Agent außerhalb der Strecke befindet. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-false.png) **Beispiel: ** *Eine Belohnungsfunktion mit dem Parameter `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 **Typ:** `[int, int]` **Bereich**: `[(0:Max-1),(1:Max-1)]` Die nullbasierten Indizes der beiden benachbarten `waypoint`s, die der aktuellen Position `(x, y)` des Agenten am nächsten liegen. Die Entfernung wird über den euklidischen Abstand von der Mitte des Fahrzeugs aus gemessen. Das erste Element bezieht sich auf den nächsten Wegpunkt hinter dem Agenten und das zweite Element bezieht sich auf den nächsten Wegpunkt vor dem Agenten. `Max` ist die Länge der Wegpunktliste. In der in [waypoints](#reward-function-input-waypoints) gezeigten Abbildung wären die `closest_waypoints` `[16, 17]`. **Beispiel**: Eine Belohnungsfunktion mit dem Parameter `closest_waypoints`. Die folgende exemplarische Belohnungsfunktion zeigt, wie man mit `waypoints` und `closest_waypoints` sowie `heading` direkte Belohnungen berechnet. AWS DeepRacer unterstützt die folgenden Bibliotheken: math, random, NumPy SciPy, und Shapely. Um eine zu verwenden, fügen Sie über Ihrer Funktionsdefinition eine Importanweisung hinzu`def function_name(parameters)`. `import supported library` ``` # 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 **Typ:** `[int, int]` **Bereich**: `[(0:len(objects_location)-1), (0:len(objects_location)-1)]` Die nullbasierten Indizes der beiden Objekte, die der aktuellen Position des Agenten (x, y) am nächsten liegen. Der erste Index bezieht sich auf das nächste Objekt hinter dem Agenten und der zweite Index bezieht sich auf das nächste Objekt vor dem Agenten. Wenn nur ein Objekt vorhanden ist, sind beide Indizes 0. ## distanz\$1from\$1center **Typ:** `float` **Bereich**: `0:~track_width/2` Verschiebung zwischen der Mitte des Agenten und der Streckenmitte in Metern. Die feststellbare maximale Verschiebung tritt auf, wenn sich eines der Räder des Agenten außerhalb einer Streckenbegrenzung befindet. Je nach Breite der Streckenbegrenzung kann sie etwas kleiner oder größer als die Hälfte von `track_width` sein. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-distance_from_center.png) **Beispiel:** *Eine Belohnungsfunktion mit dem `distance_from_center`-Parameter*. ``` 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 **Typ:** `float` **Bereich**: `-180:+180` Fahrtrichtung des Agenten in Grad in Bezug auf die x-Achse des Koordinatensystems. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-heading.png) **Beispiel:** *Eine Belohnungsfunktion mit dem `heading`-Parameter*. Weitere Informationen finden Sie unter [`closest_waypoints`](#reward-function-input-closest_waypoints). ## is\$1crashed **Typ:** `Boolean` **Bereich**: `(True:False)` Ein boolesches Flag, das angibt, ob der Agent als Abschlussstatus mit einem anderen Objekt kollidiert ist (`True`) oder nicht ist (`False`). ## is\$1left\$1of\$1center **Typ:** `Boolean` **Bereich**: `[True : False]` Ein `Boolean`-Flag, das anzeigt, ob sich der Agent auf der linken Seite (`True`) oder rechten Seite (`False`) der Streckenmitte befindet. ## is\$1offtrack **Typ:** `Boolean` **Bereich**: `(True:False)` Ein boolesches Flag, das angibt, ob sich der Agent als Abschlussstatus außerhalb der Spur (True) oder nicht (False) befindet. ## is\$1reversed **Typ:** `Boolean` **Bereich**: `[True:False]` Ein boolesches Flag, das anzeigt, ob der Agent im Uhrzeigersinn (True) oder gegen den Uhrzeigersinn (False) fährt. Es wird verwendet, wenn Sie die Richtungsänderung für jede Episode aktivieren. ## objects\$1distance **Typ:** `[float, … ]` **Bereich**: `[(0:track_length), … ]` Eine Liste der Abstände zwischen Objekten in der Umgebung in Bezug auf die Startlinie. Das i-te Element misst den Abstand in Metern zwischen dem i-ten Objekt und der Startlinie entlang der Streckenmittellinie. **Anmerkung** abs \$1 (var1) - (var2) \$1 = how close the car is to an object , WENN var1 = ["objects\$1distance"] [index] und var2 = params ["progress"] \$1params ["track\$1length"] Mit dem Parameter „closest\$1objects“ erhalten Sie einen Index des nächstgelegenen Objekts vor dem Fahrzeug und des nächstgelegenen Objekts hinter dem Fahrzeug. ## objects\$1heading **Typ:** `[float, … ]` **Bereich**: `[(-180:180), … ]` Liste der Fahrkurse von Objekten in Grad. Das i-te Element misst den Fahrkurs des i-ten Objekts. Bei stationären Objekten sind ihre Fahrkurse 0. Bei einem Bot-Fahrzeug ist der Wert des entsprechenden Elements der Kurswinkel des Fahrzeugs. ## objects\$1left\$1of\$1center **Typ:** `[Boolean, … ]` **Bereich**: `[True|False, … ]` Liste der booleschen Flags. Der i-te Elementwert gibt an, ob sich das i-te Objekt links (True) oder rechts (False) von der Streckenmitte befindet. ## objects\$1location **Typ:** `[(x,y), … ]` **Bereich**: `[(0:N,0:N), … ]` Liste aller Objektpositionen, jede Position ist ein n-Tupel von ([x, y](#reward-function-input-x_y)). Die Größe der Liste entspricht der Anzahl der Objekte auf der Strecke. Beachten Sie, dass das Objekt ein stationäres Hindernis oder ein sich bewegendes Bot-Fahrzeug sein könnte. ## objects\$1speed **Typ:** `[float, … ]` **Bereich**: `[(0:12.0), … ]` Liste der Geschwindigkeiten (Meter pro Sekunde) für die Objekte auf der Strecke. Bei stationären Objekten sind ihre Geschwindigkeiten 0. Bei einem Bot-Fahrzeug entspricht der Wert der Geschwindigkeit, die Sie im Training festgelegt haben. ## progress **Typ:** `float` **Bereich**: `0:100` Prozentsatz der abgeschlossenen Strecke. **Beispiel:** *Eine Belohnungsfunktion mit dem `progress`-Parameter*. Weitere Informationen finden Sie unter [Schritte](#reward-function-input-steps). ## speed **Typ:** `float` **Bereich**: `0.0:5.0` Die beobachtete Geschwindigkeit des Agenten in Metern pro Sekunde (m/s). ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-speed.png) **Beispiel:** *Eine Belohnungsfunktion mit dem `speed`-Parameter*. Weitere Informationen finden Sie unter [all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track). ## steering\$1angle **Typ:** `float` **Bereich**: `-30:30` Lenkwinkel der Vorderräder in Grad von der Mittellinie des Agenten aus. Das negative Vorzeichen (-) steht für eine Lenkung nach rechts. Das positive (\$1) Vorzeichen steht für eine Lenkung nach links. Die Mittellinie des Agenten ist nicht unbedingt parallel zur Streckenmittellinie, wie in der folgenden Abbildung dargestellt. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-steering.png) **Beispiel:** *Eine Belohnungsfunktion mit dem `steering_angle`-Parameter*. ``` 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 **Typ:** `int` **Bereich**: `0:Nstep` Anzahl der abgeschlossenen Schritte. Ein Schritt entspricht einer Aktion, die der Agent gemäß der aktuellen Richtlinie durchführt. **Beispiel:** *Eine Belohnungsfunktion mit dem `steps`-Parameter*. ``` 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 **Typ:** `float` **Bereich**: `[0:Lmax]` Die Streckenlänge in Metern. `Lmax is track-dependent.` ## track\$1width **Typ:** `float` **Bereich**: `0:Dtrack` Streckenbreite in Metern. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-track_width.png) **Beispiel**: *Eine Belohnungsfunktion mit dem `track_width`-Parameter*. ``` 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 **Typ:** `float` **Bereich**: `0:N` Position der Mitte des Agenten zur x- und y-Achse der simulierten Umgebung mit der Strecke in Metern. Der Nullpunkt liegt in der unteren linken Ecke der simulierten Umgebung. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-x-y.png) ## waypoints **Typ**: `list` mit `[float, float]` **Bereich**: `[[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]` Eine sortierte Liste von streckenabhängigen `Max`-Meilensteinen entlang der Streckenmitte. Jeder Meilenstein wird durch eine Koordinate von (xw,i, yw,i) beschrieben. Bei einer Schleife sind die ersten und die letzte Zwischenposition identisch. Bei einer geraden Strecke oder einer Strecke, die keine Schleife bildet, unterscheiden sich die erste und die letzte Zwischenposition. ![\[\]](http://docs.aws.amazon.com/de_de/deepracer/latest/developerguide/images/deepracer-reward-function-input-waypoints.png) **Beispiel** *Eine Belohnungsfunktion mit dem Parameter `waypoints`*. Weitere Informationen finden Sie unter [`closest_waypoints`](#reward-function-input-closest_waypoints). # Beispiele AWS DeepRacer AWS-Prämienfunktionen Im Folgenden sind einige Beispiele für die DeepRacer AWS-Prämienfunktion aufgeführt. **Topics** + [Beispiel 1: Folgen Sie beim Zeitfahren der Mittellinie](#deepracer-reward-function-example-0) + [Beispiel 2: Bleiben Sie beim Zeitfahren innerhalb der beiden Grenzen](#deepracer-reward-function-example-1) + [Beispiel 3: Vermeiden Sie Zick-Zack-Bewegungen bei Zeitfahren](#deepracer-reward-function-example-2) + [Beispiel 4: Bleiben Sie auf einer Spur, ohne gegen stehende Hindernisse oder fahrende Fahrzeuge zu stoßen](#deepracer-reward-function-example-3) ## Beispiel 1: Folgen Sie beim Zeitfahren der Mittellinie In diesem Beispiel wird festgestellt, wie weit der Agent von der Mittellinie entfernt ist, und er erhält eine höhere Belohnung, wenn er näher an der Mitte der Spur liegt; dadurch wird er veranlasst, der Mittellinie möglichst genau zu folgen. ``` 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 ``` ## Beispiel 2: Bleiben Sie beim Zeitfahren innerhalb der beiden Grenzen Dieses Beispiel bietet einfach hohe Belohnungen, wenn der Agent innerhalb der Grenzen bleibt, und lässt den Agenten herausfinden, wie er eine Runde am besten beenden kann. Es ist einfach zu programmieren und zu verstehen, aber die Konvergenz dauert wahrscheinlich länger. ``` 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 ``` ## Beispiel 3: Vermeiden Sie Zick-Zack-Bewegungen bei Zeitfahren In diesem Beispiel wird der Agent belohnt, wenn er der Mittellinie folgt, bei zu vielen Lenkbewegungen wird er jedoch bestraft, wodurch Zick-Zack-Bewegungen vermieden werden sollen. Der Agent lernt, im Simulator reibungslos zu fahren, und behält wahrscheinlich dasselbe Verhalten bei, wenn er auf dem physischen Fahrzeug eingesetzt wird. ``` 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) ``` ## Beispiel 4: Bleiben Sie auf einer Spur, ohne gegen stehende Hindernisse oder fahrende Fahrzeuge zu stoßen Diese Belohnungsfunktion belohnt den Agenten dafür, dass er sich innerhalb der Streckengrenzen aufhält, und bestraft den Agenten, wenn er Objekten vor der Strecke zu nahe kommt. Der Agent kann sich von Spur zu Spur bewegen, um Kollisionen zu vermeiden. Die Gesamtbelohnung ist eine gewichtete Summe aus den Belohnungen und Bestrafungen. In diesem Beispiel wird der Strafe mehr Gewicht beigemessen, um Abstürze zu vermeiden. Experimentieren Sie mit unterschiedlichen Gewichten zur Mittelwertbildung, um für unterschiedliche Verhaltensergebnisse zu trainieren. ``` 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 ```