翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS DeepRacer モデルのトレーニングと評価
AWS DeepRacer 車両がトラックで自動走行するとき、前面にマウントされたカメラで環境状態をキャプチャし、観察データに応じてアクションを実行します。AWS DeepRacer モデルは、観察データとアクションを想定される報酬に マッピングする関数です。モデルをトレーニングすることは、想定される報酬を最大化する関数を見つける、または学習することであり、最適化されたモデルによって車両が最初から最後までトラックで走行するためにどのようなアクション (速度とステアリング角度のペア) を取れるかを規定します。
実際には、関数はニューラルネットワークで表され、ネットワークのトレーニングには、一連の観察された環境状態と対応する車両のアクションに与えられた最適なネットワークの重み付けを見つけることが関係しています。最適性の基盤となる基準は、車両が交通事故または違反を発生させることなく正しく効果的な動きをするように勧める、モデルの報酬関数によって記述されます。シンプルな報酬関数は、車両がトラックにある場合は 0、トラックから外れた場合は -1、ゴールに到達した場合は \$11 の報酬を返すようにすることができます。この報酬関数では、車両がトラックから外れると罰を受け、ゴールに到達すると報酬が与えられます。時間やスピードが問題ではない場合、これは適切な報酬関数になり得ます。
直線のトラックから外れることなく、できるだけ速く車両を走行させたいと思っているとします。車両の加速や減速に合わせて、車両は障害物を避け、トラック内に留まっているように、左右にステアリングを操作します。高速でのターンが大きすぎると、簡単に車両がトラックから外れてしまいます。ターンが小さすぎる障害物や別の車両との衝突を回避できない可能性があります。一般的に、最適なアクションは、大きなターンは低速で曲がり、きついカーブではステアリングを少なくすることです。この動作を奨励するため、報酬関数では、高速での小さいターンには正のスコアを割り当てて報酬を与え、高速での大きいターンには負のスコアを割り当てて罰を与える必要があります。同様に、報酬関数では、直線コースでの加速や障害物の近くでの減速に正の報酬を返すことができます。
報酬関数は、AWS DeepRacer モデルの重要な部分です。AWS DeepRacer モデルをトレーニングするときは報酬関数を指定する必要があります。トレーニングでは、最初から最後までトラックでのエピソードが繰り返えされます。あるエピソードでは、予想される累積報酬を最大化することで最適な一連のアクションを学習するためにエージェントがトラックを操作します。最後に、トレーニングは強化学習モデルを生成します。トレーニングの後、どのような状態でも最適なアクションができるように、エージェントがモデルで推論を行い、自動運転を実行します。これは、仮想エージェントによるシミュレートされた環境、または AWS DeepRacer スケール車両などの物理的エージェントによる実際の環境下で実行できます。
実際には、強化学習モデルをトレーニングするには、学習アルゴリズムを選択する必要があります。現在、AWS DeepRacer コンソールは、近位ポリシー最適化 ([PPO](https://arxiv.org/pdf/1707.06347.pdf)) と Soft Actor Critic (SAC) アルゴリズムのみをサポートしています。その後、最初から記述する場合を除き、選択したアルゴリズムをサポートするディープラーニングフレームワークを選択できます。AWS DeepRacer は SageMaker AI と統合され、[TensorFlow](https://www.tensorflow.org/) などの一般的な深層学習フレームワークを AWS DeepRacer コンソールですぐに使用できます。フレームワークを使用すると、トレーニングジョブの設定および実行を簡素化し、ユーザーの問題に固有の報酬関数の作成および強化に集中することができます。
トレーニング強化学習モデルは反復プロセスです。まず、ある環境でのエージェントのすべての重要な動作をカバーする報酬関数を一度に定義するのは 困難です。次に、ハイパーパラメータは、多くの場合、十分なトレーニングパフォーマンスを実現するために調整されます。どちらも実験が必要です。賢明なアプローチは、単純な報酬機能から始めて、徐々に強化していくことです。AWS DeepRacer は、トレーニングされたモデルをクローンし、それを駆使して次の の トレーニングで活性化させることで、この反復プロセスを容易にします。各反復で報酬関数に 1 つまたは少数のより洗練された処理を導入して、 前に無視された変数を処理するか、結果がコンバージするまでハイパーパラメータを体系的に調整することができます。
機械学習で通常行われるのと同じように、物理エージェントにデプロイして実際の状況での推論を実行する前に、トレーニング済みの強化学習モデルを評価してその有効性を調べる必要があります。自動運転の場合、評価は、車両が最初から最後まで特定のトラックに留まっている頻度やトラックから外れずにコースを完了する速さに基づくことができます。AWS DeepRacer シミュレーションは、評価を実行して、[リーダーボード](deepracer-racing-series.md)上の他の AWS DeepRacer ユーザーによってトレーニングされたモデルと比較するため、パフォーマンスのメトリクスを投稿できるようにします。
**Topics**
+ [AWS DeepRacer によるレースの種類の理解とセンサーの有効化](deepracer-choose-race-type.md)
+ [AWS DeepRacer コンソールを使用した AWS DeepRacer モデルのトレーニングと評価](deepracer-console-train-evaluate-models.md)
+ [AWS DeepRacer 報酬関数のリファレンス](deepracer-reward-function-reference.md)
# AWS DeepRacer によるレースの種類の理解とセンサーの有効化
AWS DeepRacer Leagueでは、以下のタイプのレーシングイベントに参加することができます。
+ **タイムトライアル**: 遮るもののないトラックでタイムを競い合い、可能な限り速いラップタイムを目指します。
+ **オブジェクト回避**: 静止した障害物のあるトラックでタイムを競い合い、可能な限り速いラップタイムを目指します。
+ **Head-to-bot レース**: 同じトラック上の 1 台または複数の他の車両とレースを行い、他の車両よりも前にフィニッシュラインを越えることを目指します。
AWS DeepRacer のコミュニティレースでは現在、タイムトライアルのみをサポートしています。
AWS DeepRacer の車両に搭載する異なったセンサーを実験し、与えられたレースの種類に応じて、周囲を観戦するのに十分な能力を持たせる必要があります。次のセクションでは、[ AWS DeepRacer がサポートするセンサー](#deepracer-how-it-works-autonomous-driving-sensors)について説明します。これにより、サポートされているタイプの自律型レースイベントを有効化できます。
**Topics**
+ [AWS DeepRacer レーシングタイプのセンサーを選択](#deepracer-how-it-works-autonomous-driving-sensors)
+ [AWS DeepRacer モデルのトレーニング用にエージェントを設定](#deepracer-configure-agent)
+ [タイムトライアル用に AWS DeepRacer トレーニングのカスタマイズする](#deepracer-get-started-training-simple-time-trial)
+ [オブジェクト回避レース向けの AWS DeepRacer トレーニングをカスタマイズする](#deepracer-get-started-training-object-avoidance)
+ [head-to-bot レース向けの AWS DeepRacer トレーニングをカスタマイズします。](#deepracer-get-started-training-h2h-racing)
## AWS DeepRacer レーシングタイプのセンサーを選択
お客様の AWS DeepRacer の車両には、デフォルトのセンサーとして単眼の前面カメラが付属しています。単眼の前面カメラをもう 1 つ追加して、前面立体視カメラを作成したり、単眼カメラまたは立体視カメラに LiDAR ユニットを追加できます。
以下のリストでは、AWS DeepRacer でサポートされているセンサーの機能と、簡単な費用対効果の分析をまとめています。
**前面カメラ**
一眼レンズ前面カメラは、トラックボーダーや形状など、ホスト車両前面の環境のイメージをキャプチャできます。最も安価なセンサーで、よくマークされたトラックでの障害物のないタイムトライアルなど、より簡単な自律運転タスクを処理するのに適しています。適切なトレーニングにより、トラック上の固定位置に配置された静止障害物を避けることができます。ただし、障害物の位置情報はトレーニングされたモデルに組み込まれ、その結果、そのモデルが過剰適合され、他の障害物の配置に一般化されない可能性があります。トラック上のランダムな位置に配置された静止オブジェクトまたは他の移動車両では、モデルが収束する可能性は低くなります。
実世界では、AWS DeepRacer の車両にはデフォルトのセンサーとして単眼の前面カメラが搭載されています。カメラには 120 度の広角レンズがあり、RGB イメージをキャプチャし、15 フレーム/秒（fps） で 160 × 120 ピクセルのグレースケールイメージに変換します。これらのセンサーのプロパティはシミュレーターに保存され、訓練されたモデルがシミュレーションから現実の世界にうまく移行する可能性を最大限に高めます。
**前面立体視カメラ**
立体視カメラには、同じ解像度と周波数でイメージをキャプチャする複数のレンズがあります。両方のレンズからのイメージは、観察対象のオブジェクトの深度を決定するために使用されます。立体視カメラからの深度情報は、特に動的な環境下で、障害物や前面の他の車両に衝突することを避けるために、ホスト車両にとって役に立ちます。ただし、深度情報が追加されると、トレーニングの収束が遅くなります。
AWS DeepRacer の実車両では、単眼カメラをもう一台追加し、それぞれのカメラを車両の左右に搭載することで、双眼のステレオカメラが構築されています。AWS DeepRacer ソフトウェアは、両方のカメラからの画像キャプチャを同期させます。キャプチャされたイメージは、グレースケールに変換され、積み重ねられ、推論のためにニューラルネットワークに供給されます。シミュレーターでも同じメカニズムが複製され、モデルを実際の環境に一般化するようにトレーニングされます。
**LiDAR センサー**
LiDAR センサーは、回転レーザーを使用して、可視スペクトル外の光パルスを送信し、各パルスが戻るまでの時間を測定します。特定のパルスが当たるオブジェクトの方向と距離は、LiDAR ユニットを中心とした大きな 3D マップのポイントとして記録されます。
たとえば、LiDAR はホスト車両の死角を検出し、車両の車線変更時の衝突を回避します。LiDAR を単眼カメラまた立体視カメラと組み合わせることで、ホスト車両が適切なアクションを実行するのに十分な情報をキャプチャできるようになります。しかし、LiDAR センサーはカメラに比べてコストが高くなります。ニューラルネットワークは、LiDAR データの解釈方法を学習する必要があります。したがって、トレーニングは収束に時間がかかります。
AWS DeepRacer の実車両では、LiDAR センサーが後部に取り付けられ、6 度傾いています。これは、毎秒 10 回転の角速度で回転し、15cm から 2m の範囲です。ホスト車両の後ろや横にあるオブジェクトだけでなく、前面の車両部品によって遮られていない背の高い物体を検出できます。LiDAR 単位が環境ノイズの影響を受けにくくなるように、角度と範囲が選択されています。
AWS DeepRacer の車両には、対応するセンサーを以下の組み合わせで構成することができます。
+ 前面単眼レフカメラのみ。
この設定は、タイムトライアルや固定位置にあるオブジェクトによる障害物の回避に適しています。
+ 前面立体視カメラのみ。
この設定は、固定またはランダムな位置にあるオブジェクトとの障害物回避に適しています。
+ LiDAR 付き前面一眼カメラ。
この設定は、障害物回避や head-to-bot レースに適しています。
+ LiDAR 付き前面立体視カメラ。
この設定は、障害物回避や head-to-bot レースには適していますが、タイムトライアルではおそらく最も経済的ではありません。
AWS DeepRacer 車両がタイムトライアルからオブジェクト回避、head-to-bot レースに移行するようにするセンサーを追加することにより車両は環境に関するより多くのデータを収集し、トレーニングの基礎となるニューラルネットワークに供給します。これにより、モデルは複雑さの増加に対処する必要があるため、トレーニングがより困難になります。結局、モデルのトレーニングを学習するタスクはより厳しくなります。
徐々に学習するには、まずタイムトライアルのトレーニングを開始してから、オブジェクト回避に進み、次に head-to-bot レースに進む必要があります。推奨事項の詳細については、次のセクションを参照してください。
## AWS DeepRacer モデルのトレーニング用にエージェントを設定
AWS DeepRacer 車両が障害物回避や head-to-bot レースを行うための強化学習モデルをトレーニングするために、適切なセンサーでエージェントを構成する必要があります。簡単なタイムトライアルでは、一眼カメラで設定されたデフォルトのエージェントを使用できます。エージェントの設定では、アクションスペースをカスタマイズし、ニューラルネットワークトポロジを選択することで、意図した運転要件を満たすために、選択したセンサーとの連携が向上します。さらに、トレーニング中に視覚的な識別のためにエージェントの外観を変更することもできます。
設定後、エージェント設定は、トレーニングと評価のためにモデルのメタデータの一部として記録されます。評価のために、エージェントは、指定されたセンサー、アクションスペース、ニューラルネットワーク技術を使用するように、記録された設定を自動的に取得します。
このセクションでは、 AWS DeepRacer コンソールの中にエージェントを設定するステップについて説明します。
**AWS DeepRacer コンソールで AWS DeepRacer エージェントを設定する方法**
1. [AWS DeepRacer コンソール](https://console.aws.amazon.com/deepracer)にサインインします。
1. プライマリナビゲーションペインで、[**ガレージ**] を選択します。
1. [**ガレージ**] を初めて使用する場合は、[**ガレージにようこそ**] ダイアログボックスが表示されます。AWS DeepRacer 車両でサポートされている各種センサーの概要を参照すして [**>**] または [**<**] を選択するか [**X**] を選択してダイアログボックスを閉じます。この入門情報は、[**ガレージ**] のヘルプパネルで確認できます。
1. [**ガレージ**] ページで、[**新しい車両を構築**] を選択します。
1. [**自分の車両の修正**] ページの [**仕様の修正**] で、1 つ以上のセンサーを選択して、目的のレーシングタイプに合った最適な組み合わせを試してみてください。
AWS DeepRacer 車両のタイムトライアルをトレーニングするには、[**カメラ**] を選択します。障害物回避や head-to-bot レースでは、他のタイプのセンサーを使用します。**Stereo カメラ**を選択するために、追加の単眼カメラを取得していることを確認します。AWS DeepRacer は、立体視カメラを 2 つの単眼レフカメラで作成しています。1 台の車両で、単眼カメラまたは二眼ステレオカメラを使用できます。どちらの場合でも、トレーニングされたモデルで障害物回避または head-to-bot レースで死角を検出して回避できるようにする場合は、LiDAR センサーをエージェントに追加できます。
1. [**ガレージ**] ページの、[**ニューラルネットワークトポロジ)**] で、サポートされているネットワークトポロジを選択します。
一般に、より深いニューラルネットワーク（より多くのレイヤーを持つ）は、急なカーブと多数の曲がり角があるより複雑なトラックを運転や、静止障害物を避けるためにレース、他の移動車両との競争に適しています。しかし、より深いニューラルネットワークはトレーニングにコストがかかり、モデルの収束に時間がかかります。一方、より浅いネットワーク（レイヤーが少ない）では、コストが削減され、トレーニングに要する時間が短縮されます。トレーニングされたモデルは、競争相手がなくても障害のないトラックでのタイムトライアルなど、より単純なトラック条件や運転要件を処理することができます。
具体的には、AWS DeepRacer は、[**3-layer CNN**] または [**5-layer CNN**] をサポートしています。
1. [**ガレージ**] ページで、[**次へ**] を選択して、エージェントのアクションスペースの設定に進みます。
1. [**アクションスペース**] ページで、最初のトレーニングのデフォルト設定のままにします。その後のトレーニングでは、ステアリング角度、最高速度、およびそれらの詳細度についてさまざまな設定を試してください。次に、**[次へ]** を選択します。
1. [**群集で目立つように車両を色付け**] ページで、[**DeepRacer に名前を付ける**] に名前を入力し、[**車両の色**] リストからエージェントの色を選択します。その後で、[**送信**] を選択します。
1. [**ガレージ**] ページで、新しいエージェントの設定を確認します。さらに変更を加えるには、[**車両の修正**] を選択し、[**ステップ 4**] から前の手順を繰り返します。
これで、エージェントはトレーニングの準備ができました。
## タイムトライアル用に AWS DeepRacer トレーニングのカスタマイズする
初めて AWS DeepRacer を使う場合は、まず簡単なタイムトライアルからスタートし、AWS DeepRacer のモデルを学習させて車両を運転する方法に慣れておきます。このようにして、報酬関数、エージェント、環境などの基本的な概念をゆっくり理解することができます。目標は、モデルをトレーニングして車両がトラック上に留まり、できるだけ早くラップを完了するようにすることです。その後、トレーニングしたモデルを AWS DeepRacer 車両にデプロイして、追加のセンサーなしで物理トラックでの走行をテストすることができます。
このシナリオのためにモデルをトレーニングするには、AWS DeepRacerコンソール上の **Garage** の中からデフォルトエージェントを選択できます。デフォルトのエージェントは、単一の前面カメラ、デフォルトのアクションスペース、およびデフォルトのニューラルネットワークトポロジで設定されています。より高度なレースに移行する前に、AWS DeepRacer のデフォルトのエージェントを使用してモデルのトレーニングを開始すると有効です。
デフォルトのエージェントを使用してモデルをトレーニングするには、以下の推奨事項に従ってください。
1. より規則的な形状を持ち、急な曲がり角の少ない単純なトラックで、モデルのトレーニングを開始します。デフォルトの報酬関数を使用します。モデルを 30 分間訓練してください。トレーニングジョブが完了したら、同じトラックでモデルを評価し、エージェントがラップを終えることができるかどうかを確認します。
1. [報酬関数のパラメータ](deepracer-reward-function-input.md)についてお読みください。さまざまなインセンティブを使用してトレーニングを継続し、エージェントに報酬を与えてより速く進みます。次のモデルのトレーニング時間を 1 〜 2 時間に延長します。最初のトレーニングと 2 番目のトレーニングの報酬グラフを比較します。報酬グラフが改善されなくなるまで実験を続けてください。
1. [アクションスペース](deepracer-how-it-works-action-space.md)の詳細については、こちらをご覧ください。最高速度（例: 1 m/s）を上げて、3 番目の モデルをトレーニングします。アクションスペースを変更するには、変更を行う機会を得たときに、新しいエージェントを [**ガレージ**] に構築する必要があります。エージェントの最高速度を更新する場合、最高速度が高いほど、エージェントが評価中のトラックを早く完了でき、AWS DeepRacer 車両が物理トラックでのラップを早く完了できることに注意してください。ただし、最高速度を高くすると、エージェントがカーブ上でオーバーシュートしてトラックから外れてしまう可能性が高くなるため、トレーニングが収束するまでの時間が長くなることがよくあります。精度を低くして、エージェントが加速または減速するための余地を増やし、他の方法で報酬関数を微調整して、トレーニングをより速く収束させることもできます。トレーニングが収束した後、3 番目のモデルを評価して、ラップタイムが改善されるかどうかを確認します。改善されなくなるまで、探索を続けてください。
1. より複雑なトラックを選択し、[**ステップ 1**] から [**ステップ 3**] を繰り返します。トレーニングに使用したトラックとは異なるトラックでモデルを評価して、モデルが[実際の環境に一般化する](deepracer-how-it-works-virtual-to-physical.md)さまざまな仮想トラックに一般化できる方法を確認します。
1. （オプション）[ハイパーパラメータ](deepracer-console-train-evaluate-models.md#deepracer-iteratively-adjust-hyperparameters)のさまざまな値を試してトレーニングプロセスを改善し、[**ステップ 1**] から [**ステップ 3**] を繰り返します。
1. （オプション） AWS DeepRacer ログを調べて分析します。ログの分析に使用できるサンプルコードについては、「[https://github.com/aws-samples/aws-deepracer-workshops/tree/master/log-analysis](https://github.com/aws-samples/aws-deepracer-workshops/tree/master/log-analysis)」を参照してください。
## オブジェクト回避レース向けの AWS DeepRacer トレーニングをカスタマイズする
タイムトライアルに慣れ、いくつかのコンバージドモデルのトレーニングを終えたら、次に厳しい課題である障害物回避に進んでください。ここでは、トラック上に配置されたオブジェクトへのクラッシュを回避しながら、トラックから外れることなく、できるだけ早くラップを完了できるモデルをトレーニングすることを目標としています。これは明らかにエージェントが学習するには難しい問題であり、トレーニングは収束に時間がかかります。
AWS DeepRacer コンソールは、2 種類の障害物回避トレーニングをサポートしています。障害物は、トラック上の固定位置またはランダムな位置に配置できます。固定位置では、障害物はトレーニングジョブ全体を通して同じ場所に固定されたままです。ランダムな場所では、障害物はエピソードごとにそれぞれの場所をランダムに変更されます。
システムの自由度が低いため、位置固定障害物を回避するためにトレーニングが収束しやすくなります。ただし、トレーニングを受けたモデルに位置情報が組み込まれていると、モデルが過剰適合する可能性があります。その結果、モデルが過剰適合し、一般化されないことがあります。ランダムに配置された障害物回避の場合、トレーニングが収束するのが難しくなります。これは、エージェントはこれまでに見たことのない場所で障害物に衝突しないように学習し続ける必要があるためです。ただし、このオプションでトレーニングされたモデルは、より一般化され、実際のレースにうまく移行する傾向があります。まず、障害物を固定位置に配置し、動作に慣れてから、ランダムな位置に取り組みます。
AWS DeepRacer シミュレーターでは、障害物は AWS DeepRacer 車両のパッケージボックスと同じ寸法（9.5 インチ（長さ）x 15.25 インチ（幅）x 10/5 インチ（高さ））の直方体ボックスです。これにより、パッケージボックスを物理トラックに障害物として配置すると、訓練されたモデルをシミュレーターから現実の世界へ簡単に移行できます。
障害物回避を試すには、以下のステップで概説されている推奨プラクティスに従ってください。
1. デフォルトのエージェントを使用するか、既存のエージェントをカスタマイズするか、新しいセンサーとアクションスペースを試してみてください。最高速度は 0.8 m/s 以下に、速度の詳細度は 1 または 2 レベルに制限する必要があります。
2 つのオブジェクトを固定したで、約 3 時間のモデルのトレーニングを開始します。報酬機能の例を使用して、レースするトラック、またはそのトラックに非常によく似たトラックでモデルをトレーニングします。「**AWS DeepRacer Smile Speedway (中級)**」トラックはシンプルなトラックで、サミットレースの準備に適しています。同じ数の障害物がある同じトラックでモデルを評価します。合計予想報酬がどのように収束するかを見てください。
1. [報酬関数のパラメータ](deepracer-reward-function-input.md)についてお読みください。報酬関数のバリエーションを試してみてください。障害物の数を 4 つに増やします。エージェントをトレーニングして、トレーニングが同じトレーニング時間内に収束するかどうかを調べます。収束しない場合は、報酬関数をもう一度微調整し、最高速度を下げるか、障害物の数を減らして、エージェントを再びトレーニングします。大幅な改善がなくなるまで実験を繰り返します。
1. 今度は、ランダムな場所で障害物を回避するトレーニングに進みます。エージェントには、AWS DeepRacer コンソール中の**ガレージ**から利用できる追加のセンサーを設定する必要があります。立体視カメラを使用できます。または、LiDAR ユニットを単眼カメラまたは立体視カメラと組み合わせることもできますが、トレーニング時間が長くなります。トレーニングをより速く収束するために、アクションスペースを、比較的低いトップスピード（例: 2 m/s）に設定します。ネットワークアーキテクチャーでは、障害物の回避に十分であることが判明した浅いニューラルネットワークを使用します。
1. 障害物回避のための新しいエージェントで、単純なトラック上にランダムに配置された 4 つのオブジェクトを使用して 4 時間のトレーニングを開始します。次に、同じトラック上でモデルを評価して、ランダムに配置された障害物でラップを終了できるかどうかを確認します。できない場合は、報酬関数を調整し、別のセンサーを試して、トレーニング時間を長くすることができます。別のヒントとして、既存のモデルのクローン作成を試して、以前に学習した経験を活用するためのトレーニングを継続することができます。
1. （オプション）アクションスペースの最高速度を選択するか、トラックに沿ってランダムに配置する障害物を増やします。さまざまなセンサーの組み合わせを試し、報酬関数とハイパーパラメータ値を微調整します。[**5 レイヤーの CNN**] ネットワークトポロジを試してみてください。次に、モデルを再トレーニングして、トレーニングの収束にどのような影響を与えるかを判断します。
## head-to-bot レース向けの AWS DeepRacer トレーニングをカスタマイズします。
障害物回避のトレーニングを終えたので、次のレベルの課題に取り組む準備ができました。head-to-bot レースのトレーニングモデルです。障害物回避イベントとは異なり、head-to-bot レースは動く車両との動的な環境を持っています。あなたの目標は AWS DeepRacer の車両モデルをトレーニングして、他の移動車両と競争し、トラックから外れたり、他の車両のいずれかと衝突することなく、最初にフィニッシュラインに到達することです。AWS DeepRacer コンソールでは、エージェントに 1-4 ボットの車両と競争させることで、head-to-bot レースモデルのトレーニングすることができます。一般的に言えば、より長いトラックにより多くの障害物を配置する必要があります。
各ボット車両は、一定の速度で事前に定義された経路をたどります。車線を変更したり、開始車線に残ったりすることができます。障害物回避のトレーニングと同様に、ボット車両を両車線のトラック全体に均等に分散させることができます。コンソールでは、トラック上のボット車両を、最大 4 台までと制限しています。トラック上により多くの競合車両を置くことにより、学習エージェントは、他の車両との多様な状況に遭遇する機会が増えます。この方法では、1 つのトレーニングジョブでより多くの学習を行われ、エージェントはより速くトレーニングを受けることができます。ただし、各トレーニングは収束に時間がかかる可能性があります。
ボット車両を持つエージェントをトレーニングするには、エージェントのアクションスペースの最高速度をボット車両の（一定の）速度よりも高く設定して、エージェントがトレーニング中に通過する機会を増やす必要があります。まず、エージェントの最高速度を 0.8 m/s に設定し、ボット車両の移動速度を 0.4 m/s に設定してください。ボットが車線を変更できるようにすると、エージェントは同じ車線の前面の移動車両に衝突しないようにする方法だけでなく、他のレーンの前面の別の移動車両に衝突しないようにする方法も学習する必要があるため、トレーニングはより困難になります。ボットは、ランダムな間隔で車線を変更するように設定できます。インターバルの長さは、トレーニングジョブを開始する前に指定した時間の範囲（例： 1 秒～5 秒）からランダムに選択されます。この車線変更の動作は、現実世界の head-to-bot レースの動作に似ており、トレーニングを受けたエージェントはより良く生成するはずです。ただし、モデルのトレーニングの収束には時間がかかります。
次の推奨ステップに従って、head-to-bot レースのトレーニングを繰り返してください。
1. AWS DeepRacer コンソールの**ガレージ**に、ステレオカメラと LiDAR 単位の両方で構成された新しいトレーニングエージェントを構築します。ボット車両に対して立体視カメラのみを使用して、比較的優れたモデルをトレーニングすることができます。LiDAR は、エージェントが車線を変更したときに死角を減らすのに役立ちます。最高速度を高く設定しすぎないでください。最良な開始ポイントは、1 m/s です。
1. Head-to-bot レースをトレーニングするには、2 台のボット車から始めます。ボットの移動速度をエージェントの最高速度よりも低く設定します (例: エージェントの最高速度が 1 m/s の場合、0.5 m/s に設定)。車線変更オプションを無効にし、先ほど作成したトレーニングエージェントを選択します。報酬関数の例の 1 つを使用するか、最小限の修正を行い、3 時間トレーニングします。レースに参加するトラック、またはそのトラックに非常によく似たトラックを使用します。「**AWS DeepRacer Smile Speedway (中級)**」トラックはシンプルなトラックで、サミットレースの準備に適しています。トレーニングが完了したら、トレーニングされたモデルを同じトラックで評価します。
1. より困難なタスクに備えて、2 番目の Head-to-bot レースモデル向けにトレーニングされたモデルをクローンします。さらに多くのボット車両を試すか、車線変更オプションを有効にしてください。2 秒以上のランダムな間隔で遅い車線変更オペレーションを開始します。また、カスタム報酬関数を試してみたいかもしれません。一般に、カスタムの報酬関数のロジックは、他の車両を上回って軌道に乗っている間のバランスを考慮しない場合、障害物回避のロジックと似ています。以前のモデルがどれほど良いかによって、さらに 3 〜 6 時間をトレーニングする必要があるかもしれません。モデルを評価し、モデルの実行方法を確認します。
# AWS DeepRacer コンソールを使用した AWS DeepRacer モデルのトレーニングと評価
強化学習モデルをトレーニングするには AWS DeepRacer コンソールを使用できます。コンソールで、トレーニングジョブを作成し、サポートされているフレームワークと利用可能なアルゴリズムを選択し、報酬関数を追加して、トレーニング設定を設定します。シミュレーターでトレーニングの進捗状況を確認することもできます。詳細な手順については、「[最初の AWS DeepRacer モデルのトレーニング](deepracer-get-started-training-model.md)」を参照してください。
このセクションでは、AWS DeepRacer モデルの学習方法と評価方法について説明します また、報酬関数の作成方法と改善方法、アクションスペースがモデルのパフォーマンスに与える影響、ハイパーパラメータがトレーニングのパフォーマンスに与える影響についても説明します。また、トレーニングモデルのクローンを作成してトレーニングセッションを延長する方法、シミュレーターを使用してトレーニングのパフォーマンスを評価する方法、およびシミュレーションの一部を実世界の課題に対処させる方法についても学習できます。
**Topics**
+ [報酬関数を作成する](#deepracer-train-models-define-reward-function)
+ [堅牢なモデルをトレーニングするためのアクションスペースを探す](#deepracer-define-action-space-for-training)
+ [ハイパーパラメータを体系的に調整する](#deepracer-iteratively-adjust-hyperparameters)
+ [AWS DeepRacer Trainingトレーニングジョブの進行状況を調べる](#deepracer-examine-training-progress)
+ [トレーニングモデルを複製して新しいトレーニングパスを開始する](#deepracer-clone-trained-model)
+ [シミュレーションでの AWS DeepRacer モデルを評価します](#deepracer-evaluate-models-in-simulator)
+ [実環境に合わせた AWS DeepRacer モデルのトレーニングを最適化する](#deepracer-evaluate-model-test-approaches)
## 報酬関数を作成する
[報酬関数](deepracer-reward-function-reference.md)とは、AWS DeepRacer の車両がトラック上のある位置から新しい位置に移動したときの、即座のフィードバック (報酬またはペナルティスコアとして) を表します。この関数の目的は、事故や違反なく、目的の場所にすばやく到着するために車両をトラックに沿って移動させることです。望ましい動きはそのアクションまたはその目標状態に対してより高い得点を得ることができます。違法な動きまたは無駄な動きをするとより低いスコアになります。AWS DeepRacer モデルをトレーニングする場合、報酬関数は唯一のアプリケーション固有の部分になります。
一般的に、報酬関数はインセンティブプランのように機能するように設計します。インセンティブ戦略が異なると、車両の動作が異なる可能性があります。車両をより速く走らせるために、この関数が車両がトラックに沿って走行することに対して報酬を与える必要があります。この関数は、車両がラップを終了するのに時間がかかりすぎたり、トラックから外れたときにペナルティを課す必要があります。ジグザグな運転パターンを避けるために、トラックのまっすぐな部分ではあまりステアリングを使用しない車両に報酬を与える場合があります。によって測定されるように、車両が特定のマイルストーンを通過すると、報酬関数はプラスのスコアを与える場合があります。[`waypoints`](deepracer-reward-function-input.md)これは待機や間違った方向への運転を軽減する可能性があります。また、トラックのコンディションを考慮して報酬関数を変更する場合もあります。ただし、報酬関数が環境固有の情報を考慮に入れるほど、トレーニングされたモデルが過適合となり、汎用性が失われます。モデルをより一般的に適用可能にするために、[アクションスペース](#deepracer-define-action-space-for-training)を探索することができます。
インセンティブプランは慎重に考慮されない場合、[意図しない反対の結果](https://en.wikipedia.org/wiki/Cobra_effect)につながる可能性があります。これは強化学習にとっては即時のフィードバックが必要ですが、条件が十分ではないために可能性があります。個々の即時報酬自体も、その移動が必要なものであるかどうかを判断できません。指定された位置で、移動は高い報酬を獲得します。その後の移動によってトラックから外れ、低得点になる可能性があります。そのような場合、車両はその位置でのハイスコアの移動を避ける必要があります。任意の位置からの今後のすべての移動が平均して高いスコアを生み出すと見込まれる場合に限り、次の位置への移動が望ましいと見なされます。今後のフィードバックは、今後の少数の移動または平均報酬計算に含まれる位置を許容するレートで割り引かれます。
[報酬関数](deepracer-reward-function-reference.md)を作成する際は、基本的なシナリオをカバーした簡単なものから始めることをお勧めします。より多くのアクションを処理するように関数を拡張することができます。それでは、いくつかの簡単な報酬関数を見てみましょう。
**Topics**
+ [報酬関数の簡単な例](#deepracer-reward-function-simple-examples)
+ [自分の報酬関数を強化する](#deepracer-iteratively-enhance-reward-functions)
### 報酬関数の簡単な例
最も基本的な状況を最初に検討することによって、報酬関数の構築を開始することができます。トラックから外れることなく最初から最後まで直線的なトラックを運転しているという状況です。このシナリオでは、報酬関数ロジックは `on_track` と `progress` のみに依存します。トライアルとして、次のロジックから始めることができます。
```
def reward_function(params):
if not params["all_wheels_on_track"]:
reward = -1
else if params["progress"] == 1 :
reward = 10
return reward
```
このロジックでは、エージェントがトラックから外れるとエージェントにペナルティが課されます。エージェントが終了地点に到達すると報酬が与えられます。指定された目標を達成するために合理的です。ただし、エージェントは、トラックを逆方向に進むことも含め、開始地点と終了地点の間を自由に移動します。トレーニングを完了するのに長い時間がかかるだけでなく、トレーニングされたモデルでも、実世界の車両にデプロイした場合に運転効率が低下する可能性があります。
実際には、エージェントは、トレーニングのコースを通して少しずつ学習できれば、より効果的に学習します。これは、報酬関数がトラックに沿って段階的に小さい報酬を与える必要があることを意味します。エージェントが直線的なトラックを走るためには、次のように報酬関数を改善することができます。
```
def reward_function(params):
if not params["all_wheels_on_track"]:
reward = -1
else:
reward = params["progress"]
return reward
```
この関数では、エージェントはフィニッシュラインに近づくほど報酬が増えます。これによっては非生産的な逆方向への運転の試行を減らすか排除するはずです。一般的に、私たちは報酬関数がアクション空間により均一に報酬を分配することを望みます。効果的な報酬関数を作成することは、困難な仕事です。簡単な関数から始めて、徐々に強化または改善してください。体系的な実験により、関数はより堅牢で効率的になります。
### 自分の報酬関数を強化する
AWS DeepRacer モデルをシンプルな直線的なトラック用に正常にトレーニングすると、AWS DeepRacer 車両 (仮想または物理的) がトラックから外れることなく走行できるようになります。ループされたトラック車両で走らせると、トラック上にとどまりません。報酬関数はトラックをたどるためにターンをするアクションを無視しました。
車両にこれらのアクションに対応させるためには、報酬関数を強化する必要があります。エージェントが許容されるターンを行った場合にはその関数は報酬を与え、エージェントが違法なターンを行った場合にはペナルティを課す必要があります。別のラウンドのトレーニングを開始する準備が整いました。以前のトレーニングを活用するには、以前にトレーニングされたモデルをクローンして、以前に学習した知識を引き継いで新しいトレーニングを開始できます。このパターンに従って、ますます複雑な環境で運転する AWS DeepRacer 車両をトレーニングするために、報酬関数にさらに機能を追加することができるようになります。
より高度な報酬関数については、以下の例を参照してください。
+ [例 1: タイムトライアルでセンターラインに従う](deepracer-reward-function-examples.md#deepracer-reward-function-example-0)
+ [例 2: タイムトライアルで 2 つの境界内に留まる](deepracer-reward-function-examples.md#deepracer-reward-function-example-1)
+ [例 3: タイムトライアルでのジグザグ運転の防止](deepracer-reward-function-examples.md#deepracer-reward-function-example-2)
+ [例 4: 静止している障害物や走行中の車両に衝突することなく、1 つの車線に留まること。](deepracer-reward-function-examples.md#deepracer-reward-function-example-3)
## 堅牢なモデルをトレーニングするためのアクションスペースを探す
原則として、できるだけ多くの環境に適用できるように、モデルをできる限り堅牢になるようにトレーニングしてください。堅牢なモデルは、広範囲のトラックの形状や条件に適用できるものです。一般的に、堅牢なモデルはその報酬関数が明示的な環境特有の知識を含む能力を持っていないので「スマート」ではありません。そうでなければ、モデルはトレーニングされた環境に似た環境にのみ適用可能である可能性があります。
環境固有の情報を報酬関数に明示的に組み込むことは、特徴量エンジニアリングに相当します。特徴量エンジニアリングはトレーニング時間を短縮するのに役立ち、特定の環境に合わせて作られたソリューションに役立ちます。ただし、一般的な適用性のモデルをトレーニングするには、多くの特徴量エンジニアリングを試みることを控える必要があります。
たとえば、循環トラックでモデルをトレーニングする場合、そのような幾何学的プロパティを明示的に報酬関数に組み込んでいる場合は、循環以外のトラックに適用可能なトレーニング済みモデルを入手することは期待できません。
報酬関数を可能な限りシンプルに保ちながら、モデルをできる限り頑健にトレーニングする方法について教えてください。1 つの方法はエージェントが取ることができるアクションにまたがるアクションスペースを探すことです。もう 1 つの方法は、基礎となるトレーニングアルゴリズムの[ハイパーパラメータ](#deepracer-iteratively-adjust-hyperparameters)で実験することです。多くの場合、両方を使用します。ここでは、アクションスペースを探索して、AWS DeepRacer 車両の堅牢なモデルをトレーニングする方法に焦点を当てます。
AWS DeepRacer モデルのトレーニングでは、アクション (`a`)は 速度 (`t` メートル/秒) とステアリング角度 (`s` 度) の組み合わせになります。エージェントのアクションスペースは、エージェントが取り得る速度とステアリングの範囲を定義します。速度の `m` 数、`(v1, .., vn)` およびステアリングの `n` 数、`(s1, .., sm)` の個別のアクションスペースの場合、アクションスペースには `m*n` の可能なアクションがあります。
```
a1: (v1, s1)
...
an: (v1, sn)
...
a(i-1)*n+j: (vi, sj)
...
a(m-1)*n+1: (vm, s1)
...
am*n: (vm, sn)
```
`(vi, sj)` の実際の値は `vmax` と `|smax|` の範囲によって異なり、均一に分布しているわけではありません。
お客様の AWS DeepRacer モデルのトレーニングを開始するかまたは反復するたびに、まず`n`、`m`、`vmax`、および `|smax|` を指定するか、それらのデフォルト値を使用することに同意する必要があります。選択に基づいて、AWS DeepRacer サービスはエージェントがトレーニングで選択できる利用可能なアクションを生成します。生成されたアクションは、アクションスペース全体に均一に分布しているわけではありません。
一般的に、より多くのアクションとより大きなアクション範囲は、不規則な回転角や方向を持つ曲線トラックなど、より多様なトラック条件に対応するためのより多くのスペースまたはオプションをエージェントに提供します。エージェントが利用できるオプションが多ければ多いほど、トラックのバリエーションをより簡単に処理できます。その結果、単純な報酬関数を使用している場合でも、トレーニング済みモデルがより広く適用可能になることが期待できます。
たとえば、エージェントは、わずかな速度とステアリング角で荒削りなアクションスペースを使用した直線トラックに対応することを素早く学習することができます。曲線トラックでは、この荒削りなアクションスペースのために、エージェントは行き過ぎて、ターンする際にトラックから外れる可能性があります。これは、速度やステアリングを調整するためのオプションが十分にないためです。速度またはステアリングの数、あるいはその両方を増やすことにより、エージェントは、トラックに沿いながらカーブに対応できるようになります。同様に、エージェントがジグザグに動く場合は、任意のステップでステアリング範囲の数を増やすことを試みることで急激なターンを減らすことができます。
アクションスペースが大きすぎると、アクションスペースを探索するのにより長い時間がかかるため、トレーニングのパフォーマンスが低下する可能性があります。モデルの一般的な適用性のメリットとトレーニングのパフォーマンス要件とのバランスをとるようにしてください。この最適化には体系的な実験が含まれています。
## ハイパーパラメータを体系的に調整する
モデルのパフォーマンスを向上させる 1 つの方法は、より優れた、またはより効果的なトレーニングプロセスを実行することです。たとえば、堅牢なモデルを取得するには、トレーニングによって、エージェントのアクションスペース全体にわたって、エージェントが多かれ少なかれ均等に分散したサンプリングを提供する必要があります。これには、探査と搾取の十分な組み合わせが必要です。これに影響を与える変数には、使用されるトレーニングデータの量 (`number of episodes between each training` および `batch size`)、エージェントがどれだけ早く学習できるか (`learning rate`)、探索の一部 (`entropy`) が含まれます。実用的なトレーニングを行うには、学習プロセスを高速化する必要があります。これに影響を与える変数には、`learning rate`、`batch size`、`number of epochs`、`discount factor` があります。
トレーニングプロセスに影響を与える変数は、トレーニングのハイパーパラメータとして知られています。これらのアルゴリズムの属性は、基盤となるモデルのプロパティではありません。残念ながら、ハイパーパラメータは本質的に経験的なものです。これらの最適値は、すべての実用的な目的に対して知られているわけではなく、導き出すために体系的な実験を必要とします。
AWS DeepRacer モデルのトレーニングのパフォーマンスを調整するために調整できるハイパーパラメータについて説明する前に、次の用語を定義しましょう。
データポイント
データポイントは、*経験*としても知られており、(*s,a,r,s’*) の連符です。ここで、*s* はカメラによってキャプチャされた模様 (または状態)、*a* は車両によって実行されたアクションを表します。*r*は、その行動によってもたらされる予想される報酬のためのものであり、そして *s’* はその行動がとられた後の新しい模様のためのものです。
エピソード
エピソードとは、車両が任意の出発点から出発し、最終的にトラックを完走するかまたはトラックから外れるまでの期間です。これにより一連のエクスペリエンスが具体化されます。エピソードごとに長さが異なる場合があります。
エクスペリエンスバッファ
エクスペリエンスバッファは、トレーニング中にさまざまな長さの一定数のエピソードにわたって収集された多数の順序付けられたデータ点から構成されています。AWS DeepRacer の場合、それは AWS DeepRacer 車両に搭載されたカメラによって捉えられた画像と車両によって取られたアクションに対応し、基盤となる (ポリシーと値) ニューラルネットワークを更新するための入力が引き出される情報源として機能します。
バッチ
バッチは、ポリシーネットワークの重みを更新するために使用される、一定期間にわたるシミュレーションの一部を表すエクスペリエンスの順序付きリストです。これはエクスペリエンスバッファのサブセットです。
トレーニングデータ
トレーニングデータは、エクスペリエンスバッファからランダムにサンプリングされ、ポリシーネットワークの重みをトレーニングするために使用されるバッチのセットです。
**アルゴリズムハイパーパラメータとその効果**
| ハイパーパラメータ | 説明 |
| --- | --- |
| **勾配降下のバッチサイズ** | 最近の車両エクスペリエンスの数はエクスペリエンスバッファから無作為に抽出され、基盤となる深層学習ニューラルネットワークの重みを更新するために使用されます。無作為抽出は、入力データに内在する相関関係を低減するのに役立ちます。より大きなバッチサイズを使用して、ニューラルネットワークの重みをより安定してスムーズに更新するようにしますが、トレーニングが長くなったり遅くなったりする可能性があるので注意してください。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| [**エポック数**] | 勾配降下中にニューラルネットワークの重みを更新するためにトレーニングデータを通過する回数。トレーニングデータはエクスペリエンスバッファからの無作為抽出に対応します。より安定した更新を促進するために多数のエポックを使用しますが、トレーニングが遅くなることが予想されます。バッチサイズが小さい場合は、少数のエポックを使用できます。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| [**学習レート**] | 各更新中に、新しい重みの一部は勾配降下 (または上昇) の寄与から得られ、残りは既存の重みの値から得られます。学習レートは、勾配降下 (または上昇) の更新がネットワークの重みにどれだけ寄与するかを制御します。より高い学習レートを使用してより速いトレーニングのための勾配降下寄与をより多く含めますが、学習レートが大きすぎると予想される報酬が収束しない可能性があることに注意してください。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| Entropy | ポリシー配布に無作為性を追加するタイミングを決定するために使用されるある程度の不確実性。不確実性が増したことで、AWS DeepRacer 車両はアクションスペースをより広く探索することができます。エントロピー値が大きいほど、車両はアクションスペースをより徹底的に探索します。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| [割引係数] | 係数は、将来の報酬が期待される報酬にどのくらい寄与するかを指定します。**割引係数**の値が大きいほど、車両がアクションを実行するとみなしている寄与の範囲が広くなり、トレーニングが遅くなります 割引係数が 0.9 の場合、移動のために将来の 10 ステップのオーダーからの報酬が含まれます。0.999 の割引係数で、車両は移動をするために将来の 1000 ステップのオーダーからの報酬を考慮します。推奨される割引係数値は、0.99、0.999 および 0.9999 です。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| [損失タイプ] | ネットワークの重みを更新するために使用される目標関数のタイプ。優れたトレーニングアルゴリズムは、エージェントの戦略を徐々に変化させて、ランダムなアクションをとることから、報酬を増やすための戦略的なアクションをとることへと徐々に移行するべきです。しかし、それがあまりにも大きな変化をするならば、トレーニングは不安定になりエージェントは学習しません。[[https://en.wikipedia.org/wiki/Huber_loss](https://en.wikipedia.org/wiki/Huber_loss)] と [[https://en.wikipedia.org/wiki/Mean_squared_error](https://en.wikipedia.org/wiki/Mean_squared_error)] のタイプは、小規模な更新でも同様に動作します。しかし、アップデートが大きくなるにつれ、[**Huber 損失**]と [**平均二乗誤差損失**] に比べて増分が小さくなります。収束の問題がある場合は、[**Huber 損失**] タイプを使用してください。収束性が良く、より早くトレーニングする場合は、[**平均二乗誤差**] タイプを使用してください。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
| [各ポリシー更新反復間のエクスペリエンスエピソードの数] | ポリシーネットワークの重み付けを学習するためのトレーニングデータを取得するために使用されるエクスペリエンスバッファのサイズ。エピソードとは、エージェントが任意の出発点から出発し、最終的にトラックを完走するかまたはトラックから外れるまでの期間です。一連のエクスペリエンスで構成されます。エピソードごとに長さが異なる場合があります。単純な強化学習問題では、エクスペリエンスバッファが少なくて済み、学習は速いです。より多くのローカル最大値のあるより複雑な問題では、より多くの相関性のないデータポイントを提供するためにより大きなエクスペリエンスバッファが必要です。この場合、トレーニングは遅くなりますが、安定しています。推奨される値は 10、20 および 40 です。[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/deepracer-console-train-evaluate-models.html) |
## AWS DeepRacer Trainingトレーニングジョブの進行状況を調べる
トレーニングジョブを開始した後、エピソードごとの報酬とトラック完走状況のトレーニングメトリクスを調べ、モデルのトレーニングジョブのパフォーマンスを確認できます。AWS DeepRacer コンソールでは、メトリクスは以下の図に示すように [**報酬グラフ**」に表示されます。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/best-model-bar-reward-graph2.png)
エピソードごとに獲得した報酬、反復ごとの平均報酬、エピソードごとの進行状況、反復ごとの平均進行状況、またはそれらの任意の組み合わせを表示することを選択できます。これを行うには、[**報酬（エピソード、平均)**] または [**報酬グラフ**] の最下部にある [**進行状況 (エピソード、平均)**] スイッチを切り替えます。エピソードごとの報酬と進行状況は、異なる色の散布図として表示されます。平均の報酬とトラック完走状況は、ラインプロットで表示され、最初の反復後に開始されます。
報酬の範囲はグラフの左側に表示され、進行状況の範囲 (0 〜 100) は右側に表示されます。トレーニングメトリクスの正確な値を読み取るには、グラフ上のデータポイントの近くまでマウスを移動します。
トレーニングの進行中、グラフは 10 秒ごとに自動的に更新されます。更新ボタンを選択して、メトリクス表示を手動で更新できます。
トレーニングジョブは、平均の報酬とトラック完走状況が収束する傾向を示している場合に適しています。特に、エピソードごとの進行状況が継続的に 100% に達し、報酬レベルが横ばいになる場合、モデルが収束している可能性があります。それ以外の場合は、モデルを複製して再トレーニングします。
## トレーニングモデルを複製して新しいトレーニングパスを開始する
トレーニングの新しいラウンドの開始点として、以前にトレーニングしたモデルを複製すると、トレーニングの効率を向上させることができます。これを行うには、すでに学んだ知識を利用するようにハイパーパラメータを変更します。
このセクションでは、AWS DeepRacer コンソールを使用してトレーニング済みモデルを複製する方法を学びます。
**AWS DeepRacer コンソールを使用して強化学習モデルのトレーニングを繰り返すには**
1. まだサインインしていない場合は、AWS DeepRacer コンソールにサインインします。
1. [**モデル**] ページで、トレーニングされたモデルを選択し、次に [**アクション**] ドロップダウンメニューリストから [**クローン**] を選択します。
1. [**モデルの詳細**] で、以下の操作を行います。
1. クローンモデルに対して名前を生成したくない場合は、[**モデル名**] に `RL_model_1` をタイプします。
1. 必要に応じて、[**モデルの説明 - オプション**] に複製したモデルの説明を入力します。
1. **環境シミュレーション**のために、別のトラックのオプションを選択します。
1. [**報酬関数**] で、利用可能な報酬関数の例の 1 つを選択してください。報酬関数を変更します。たとえば、ステアリングを検討してください。
1. [**アルゴリズム設定**] を展開し、さまざまなオプションを試してください。たとえば、[**勾配降下バッチサイズ**] の値を 32 から 64 に変更するか、[**学習レート**] を上げてトレーニングをスピードアップします。
1. [**条件の停止**] のさまざまな選択を試してください。
1. [**トレーニングの開始**] を選択して、新しいトレーニングを開始します。
一般的な堅牢な機械学習モデルのトレーニングと同様に、最良の解決策を見つけるために体系的な実験を行うことが重要です。
## シミュレーションでの AWS DeepRacer モデルを評価します
モデルを評価するには、トレーニング済みのモデルのパフォーマンスをテストします。AWS DeepRacer では、標準的なパフォーマンスメトリクスは、3 回の連続ラップを終えた平均時間になります。任意の 2 つのモデルについて、このメトリクスを使用すると、エージェントが同じトラックで他のモデルより速く走行できる場合、一方のモデルが優れています。
一般的に、モデルの評価には次の作業が含まれます。
1. 評価ジョブを設定し、起動します。
1. ジョブの実行中に進行中の評価を確認してください。AWS DeepRacer シミュレーターでこれを行うことができます。
1. 評価ジョブが完了したら、評価の概要を確認してください。進行中の評価ジョブはいつでも終了できます。
**注記**
評価時間は、選択した基準によって異なります。モデルが評価基準を満たさない場合、評価は 20 分の上限に達するまで継続されます。
1. 必要に応じて、評価結果を適格な [AWS DeepRacer リーダーボード](deepracer-racing-series.md)に送信してください。リーダーボードでのランキングによって、自分のモデルが他の参加者に対してどの程度うまく機能しているかがわかります。
物理的なトラックで走行している AWS DeepRacer 車両で AWS DeepRacer モデルをテストしてください。「[AWS DeepRacer 車両を運転する](operate-deepracer-vehicle.md)」を参照してください。
## 実環境に合わせた AWS DeepRacer モデルのトレーニングを最適化する
[アクションスペースの選択](#deepracer-define-action-space-for-training)、[報酬関数](#deepracer-train-models-define-reward-function)、トレーニングで使用される[ハイパーパラメータ](#deepracer-iteratively-adjust-hyperparameters)、[車両のキャリブレーション](deepracer-calibrate-vehicle.md)、さらには[実際のトラック](deepracer-build-your-track.md)状態を含め、トレーニングされたモデルの実世界でのパフォーマンスには多くの要因が影響します。また、シミュレーションは実世界の (しばしば未処理の) 近似にすぎません。課題となるのは、シミュレーションでモデルをトレーニングし、それを実世界に適用し、そして満足のいく性能を達成することです。
実世界での堅実なパフォーマンスを得るためにモデルをトレーニングするには、多くの場合、[報酬関数](#deepracer-train-models-define-reward-function)、[アクションスペース](#deepracer-define-action-space-for-training)、[ハイパーパラメータ](#deepracer-iteratively-adjust-hyperparameters)、およびシミュレーションでの[評価](#deepracer-evaluate-models-in-simulator)および実環境での[テスト](deepracer-drive-your-vehicle.md)という反復作業が多数必要になります。最後のステップは、いわゆる*シミュレーションから実社会への移行* (*sim2real*) であり、扱いにくいと感じることがあります。
*sim2real* の課題に取り組むためには、次の考慮事項に注意してください。
+ 車両が適切にキャリブレートされていることを確認します。
シミュレーション環境は実環境を部分的に表現したものであるため、これは重要です。また、エージェントは、各ステップで、カメラのイメージによってキャプチャされた現在のトラック状態に基づいてアクションを実行します。高速ではルートを計画するのに十分遠くまで見ることができません。これに対応するために、シミュレーションは速度とステアリングに制限を課します。トレーニングされたモデルが実世界で機能するために、車両はこれと他のシミュレーション設定に合うように適切にキャリブレートされなければなりません。車体のキャリブレーションの詳細については、「[AWS DeepRacer 車両をキャリブレートする](deepracer-calibrate-vehicle.md)」を参照してください。
+ 最初にデフォルトのモデルで車両をテストします。
お客様の AWS DeepRacer 車両には、その推理エンジンにロードされたトレーニング済みモデルが付属しています。実世界で自身のモデルをテストする前に、車両がデフォルトのモデルで合理的にうまく機能することを確認してください。そうでない場合は、物理的なトラックセットアップを確認します。正しく構築されていない物理トラックでモデルをテストすると、パフォーマンスが低下する可能性があります。このような場合は、テストを開始または再開する前にトラックを再設定または修復します。
**注記**
AWS DeepRacer 車両を走行させる際、報酬機能を呼び出すことなくトレーニングされたポリシーネットワークに従ってアクションが推論されます。
+ モデルがシミュレーションで機能することを確認します。
モデルが実世界でうまく機能しない場合は、モデルかトラックのどちらかに欠陥がある可能性があります。根本原因を整理するには、まず[シミュレーションでモデルを評価して](#deepracer-evaluate-models-in-simulator)、シミュレーションされたエージェントがトラックから外れることなく少なくとも 1 回のループを終了できるかどうかを確認する必要があります。シミュレーターでエージェントの軌跡を観察しながら、報酬の集約を調べることでこれを実行できます。シミュレーションされたエージェントが失敗することなくループを完了したときに報酬が最大に達する場合、そのモデルが適切である可能性があります。
+ モデルを過剰にトレーニングしないでください。
モデルが一貫してシミュレーションでトラックを完了した後でトレーニングを続けると、モデルに過剰適合が発生します。シミュレーションされたトラックと実環境との間のわずかな違いでさえも処理できないため、過剰にトレーニングされたモデルは実世界ではうまく機能しません。
+ さまざまな反復から複数のモデルを使用します。
一般的なトレーニングセッションでは、過小適合と過剰適合の間にあるさまざまなモデルが作成されます。正しいモデルを決定するための先験的な基準がないため、エージェントがシミュレーターで 1 回のループを完走してからループを一貫して実行されるまでの間に、いくつかのモデル候補を選択する必要があります。
+ テストではゆっくりと走り始め、徐々に走行速度を上げます。
車両にデプロイされたモデルをテストする場合は、小さい最大速度値から開始します。たとえば、テストの制限速度をトレーニングの制限速度の 10％ 未満に設定できます。その後、車両が動き始めるまで、テストの制限速度を徐々に上げます。装置制御コンソールを使用して車両をキャリブレーションするときに、テストの制限速度を設定します。車両の速度が速すぎる場合、たとえば、速度がシミュレーターでのトレーニング中に見られる速度を超える場合、モデルは実際のトラックでうまく機能する可能性は低くなります。
+ さまざまな開始位置で車両をテストします。
モデルはシミュレーションで特定の経路をたどることを学習し、トラック内の位置に敏感に反応できるようになります。モデルが特定の位置からうまく機能するかどうかを確認するには、トラック境界内のさまざまな位置 (左から中央、右) から車両テストを開始する必要があります。ほとんどのモデルは、車両を白線のどちらかの側に近づける傾向があります。車両の経路を分析するために、シミュレーションからステップごとに車両の位置 (x、y) をプロットして、実環境で車両がたどる可能性のある経路を特定します。
+ 直線トラックでテストを開始します。
直線トラックは、曲線トラックに比べて移動がはるかに簡単です。まっすぐなトラックでテストを開始すると、パフォーマンスの低いモデルをすばやく取り除くことができます。ほとんどの場合、車両が直線トラックに沿って走行できない場合、そのモデルは曲線トラックでもうまく機能しません。
+ 車両が 1 種類のアクションしかとらない行動に注意します。
車両が 1 種類のアクションのみを実行できる場合、たとえば、車両を左方向にのみハンドルを切る場合、モデルは過剰適合か過小適合の可能性があります。指定されたモデルパラメータでは、トレーニングの反復が多すぎるとモデルが過剰適合になる可能性があります。反復回数が少なすぎると、過小適合になる可能性があります。
+ トラックの境界線に沿って進路を修正する車両の能力に注意します。
良いモデルは、トラックの境界に近づいたときに車両が自身を修正するします。適切にトレーニングされたモデルのほとんどが、この機能を備えています。車両がトラックと境界の両方で適切な動作をする場合は、モデルはより頑強でより高品質であると見なされます。
+ 車両が示す矛盾した行動に注意します。
ポリシーモデルは、任意の状態で行動をとる確率分布を表します。トレーニングされたモデルが推論エンジンにロードされると、車両はモデルの処方に従って、最も可能性の高い行動を 1 ステップずつ選択します。行動確率が均等に分布している場合、車両は等しいまたは非常に類似した確率の行動のいずれかをとる可能性があります。これは不安定な運転行動につながります。たとえば、車両が時々は (たとえば、しばしば) 直線経路をたどり、他の時には不必要な方向転換をする場合は、モデルは過小適合又は過剰適合のいずれかです。
+ 車両によって行われる 1 種類のターン (左または右) のみに注意してください。
車両が左には非常にうまく曲がるが、右へのステアリングを管理できない場合、または同様に、右にはうまく曲がれるが左にはうまく曲がれない場合は、車両のステアリングをキャリブレートするか、再キャリブレートします。あるいは、テスト中の物理的設定に近い設定でトレーニングされたモデルを使用してみることもできます。
+ 急なターンを行ってトラックから外れる車両に注意します。
車両がほとんどの場合正しい経路をたどるが、突然トラックから外れる場合は、おそらく環境にある集中力をそらすものが原因の可能性がありあます。集中力をそらすものの多くには、予期しないまたは意図しないライトの反射が含まれます。そのような場合は、トラックのまわりに障壁を使用するかその他の方法でまぶしい光を低減します。
# AWS DeepRacer 報酬関数のリファレンス
AWS DeepRacerの報酬関数に関する技術的なリファレンスは以下の通りです。
**Topics**
+ [AWS DeepRacer 報酬関数の入力パラメータ](deepracer-reward-function-input.md)
+ [AWS DeepRacer 報酬関数の例](deepracer-reward-function-examples.md)
# AWS DeepRacer 報酬関数の入力パラメータ
AWS DeepRacer の報酬関数は、辞書オブジェクトを入力として取ります。
```
def reward_function(params) :
reward = ...
return float(reward)
```
`params` 辞書オブジェクトには、次のキーと値のペアが含まれています。
```
{
"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
}
```
入力パラメータに関するより詳細な技術リファレンスは以下のとおりです。
## all\$1wheels\$1on\$1track
**タイプ: ** `Boolean`
**範囲: ** `(True:False)`
エージェントがトラック内にあるのかトラック外にあるのかを示す `Boolean` フラグ。ホイールのいずれかがトラックの境界線の外側にある場合は、トラック外 (`False`) です。すべてのホイールが 2 つのトラック境界の内側にある場合はトラック内 (`True`) です。次の図は、エージェントがトラック上にあることを示しています。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-true.png)
次の図は、エージェントがトラックから外れていることを示しています。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-false.png)
**例: ** *`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
**タイプ**: `[int, int]`
**範囲**: `[(0:Max-1),(1:Max-1)]`
`(x, y)` のエージェントの現在位置に最も近い 2 つが隣接する `waypoint` のゼロベースのインデックス。距離は、エージェントの中心からのユークリッド距離によって測定されます。最初の要素は、エージェントの背後に最も近いウェイポイントを指し、2 番目の要素は、エージェントの前面にある最も近いウェイポイントを指します。`Max` は、ウェイポイントリストの長さです。[ウェイポイント](#reward-function-input-waypoints) で示している図では、`closest_waypoints` は `[16, 17]` になります。
**例**: `closest_waypoints` パラメータを使用する報酬関数。
次の例の報酬関数は、`waypoints` と`closest_waypoints`、および `heading` を使用して即時報酬を計算する方法を示しています。
AWS DeepRacer は、数学、ランダム、NumPy、SciPy、Shapely のライブラリをサポートしています。1 つを使用するには、関数定義の上に、`import supported library`、インポートステートメントを追加します: `def function_name(parameters)`。
```
# Place import statement outside of function (supported libraries: math, random, numpy, scipy, and shapely)
# Example imports of available libraries
#
# import math
# import random
# import numpy
# import scipy
# import shapely
import math
def reward_function(params):
###############################################################################
'''
Example of using waypoints and heading to make the car point in the right direction
'''
# Read input variables
waypoints = params['waypoints']
closest_waypoints = params['closest_waypoints']
heading = params['heading']
# Initialize the reward with typical value
reward = 1.0
# Calculate the direction of the center line based on the closest waypoints
next_point = waypoints[closest_waypoints[1]]
prev_point = waypoints[closest_waypoints[0]]
# Calculate the direction in radius, arctan2(dy, dx), the result is (-pi, pi) in radians
track_direction = math.atan2(next_point[1] - prev_point[1], next_point[0] - prev_point[0])
# Convert to degree
track_direction = math.degrees(track_direction)
# Calculate the difference between the track direction and the heading direction of the car
direction_diff = abs(track_direction - heading)
if direction_diff > 180:
direction_diff = 360 - direction_diff
# Penalize the reward if the difference is too large
DIRECTION_THRESHOLD = 10.0
if direction_diff > DIRECTION_THRESHOLD:
reward *= 0.5
return float(reward)
```
## closest\$1objects
**タイプ**: `[int, int]`
**範囲**: `[(0:len(objects_location)-1), (0:len(objects_location)-1)]`
エージェントの現在の位置（x、y）に最も近い 2 つのオブジェクトのゼロから始まるインデックス。最初のインデックスは、エージェントの背後にある最も近いオブジェクトを参照し、2 番目のインデックスは、エージェントの前にある最も近いオブジェクトを参照します。オブジェクトが 1 つしかない場合、両方のインデックスは 0 です。
## distance\$1from\$1center
**タイプ**: `float`
**範囲**: `0:~track_width/2`
エージェントの中心とトラックの中心との間のメートル単位の変位。観察可能な最大変位は、エージェントのいずれかの車輪がトラックの境界線の外側にあるときに発生し、トラックの境界線の幅に応じて、`track_width` の半分よりわずかに小さいまたは大きい場合があります。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-distance_from_center.png)
**例:** *`distance_from_center` パラメータを使用する報酬関数*
```
def reward_function(params):
#################################################################################
'''
Example of using distance from the center
'''
# Read input variable
track_width = params['track_width']
distance_from_center = params['distance_from_center']
# Penalize if the car is too far away from the center
marker_1 = 0.1 * track_width
marker_2 = 0.5 * track_width
if distance_from_center <= marker_1:
reward = 1.0
elif distance_from_center <= marker_2:
reward = 0.5
else:
reward = 1e-3 # likely crashed/ close to off track
return float(reward)
```
## heading
**タイプ**: `float`
**範囲**: `-180:+180`
座標系の x 軸に対するエージェントの進行方向（度単位）。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-heading.png)
**例:** *`heading` パラメータを使用する報酬関数*
詳細については、「[`closest_waypoints`](#reward-function-input-closest_waypoints)」を参照してください。
## is\$1crashed
**タイプ**: `Boolean`
**範囲**: `(True:False)`
エージェントが終了ステータスとして別のオブジェクトにクラッシュしたか (`True`)、否か (`False`) を示すブール型フラグ。
## is\$1left\$1of\$1center
**タイプ**: `Boolean`
**範囲**: `[True : False]`
エージェントがトラックの中心より左側 (`True`) にあるのか右側 (`False`) にあるのかを示す `Boolean` フラグ。
## is\$1offtrack
**タイプ**: `Boolean`
**範囲**: `(True:False)`
エージェントが終了ステータスとしてトラック外 (True) であるのかどうか (False) を示すブール型フラグ。
## is\$1reversed
**タイプ**: `Boolean`
**範囲**: `[True:False]`
エージェントが時計回り (True) であるのか反時計回り (False) であるのかを示すブール型フラグ。
これは、エピソードごとに方向変更を有効にする場合に使用されます。
## objects\$1distance
**タイプ**: `[float, … ]`
**範囲**: `[(0:track_length), … ]`
開始ラインに対する環境内のオブジェクト間の距離のリスト。i 番目の要素は、i 番目のオブジェクトと、トラックの中心線に沿った開始線間の距離をメートルで測定します。
**注記**
abs \$1 (var1) - (var2)\$1 = how close the car is to an object, WHEN var1 = ["objects\$1distance"][index] and var2 = params["progress"]\$1params["track\$1length"]
車両の前面に最も近いオブジェクトと車両の背後に最も近いオブジェクトのインデックスを取得するには、"closest\$1objects" パラメータを使用します。
## objects\$1heading
**タイプ**: `[float, … ]`
**範囲**: `[(-180:180), … ]`
オブジェクトの見出しのリスト（度単位）。i番目の 要素は、i番目の オブジェクトの見出しを測定します。静止オブジェクトの場合、見出しは 0 です。ボット車両の場合、対応する要素の値は車両の見出し角度です。
## objects\$1left\$1of\$1center
**タイプ**: `[Boolean, … ]`
**範囲**: `[True|False, … ]`
ブール型フラグのリスト。i番目の 要素の値は、i番目の オブジェクトがトラックセンターの左側 (True) か右側 (False) かを示します。
## objects\$1location
**タイプ**: `[(x,y), … ]`
**範囲**: `[(0:N,0:N), … ]`
すべてのオブジェクトの場所のリスト。各場所は ([x, y](#reward-function-input-x_y)) のタプルです。
リストのサイズは、トラック上のオブジェクトの数と同じです。オブジェクトは、固定障害物、移動ボット車両である可能性があることに注意してください。
## objects\$1speed
**タイプ**: `[float, … ]`
**範囲**: `[(0:12.0), … ]`
トラック上のオブジェクトの速度（メートル/秒）のリスト。静止オブジェクトの場合、速度は 0 です。ボット車両の場合、値はトレーニングで設定した速度です。
## プログレス
**タイプ**: `float`
**範囲**: `0:100`
トラック完走の割合。
**例:** *`progress` パラメータを使用する報酬関数*
詳細については、「[ステップ](#reward-function-input-steps)」を参照してください。
## speed
**タイプ**: `float`
**範囲**: `0.0:5.0`
エージェントの観測速度（メートル/秒）。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-speed.png)
**例:** *`speed` パラメータを使用する報酬関数*
詳細については、「[all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track)」を参照してください。
## steering\$1angle
**タイプ**: `float`
**範囲**: `-30:30`
エージェントの中心線からの前輪のステアリング角（度単位）。負の記号 (-) は右へのステアリングを意味し、正の (\$1) 記号は左へのステアリングを意味します。次の図に示すように、エージェントの中心線はトラックの中心線と必ずしも平行ではありません。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-steering.png)
**例:** *`steering_angle` パラメータを使用する報酬関数*
```
def reward_function(params):
'''
Example of using steering angle
'''
# Read input variable
abs_steering = abs(params['steering_angle']) # We don't care whether it is left or right steering
# Initialize the reward with typical value
reward = 1.0
# Penalize if car steer too much to prevent zigzag
ABS_STEERING_THRESHOLD = 20.0
if abs_steering > ABS_STEERING_THRESHOLD:
reward *= 0.8
return float(reward)
```
## ステップ
**タイプ**: `int`
**範囲**: `0:Nstep`
完了したステップ数。ステップは、現在のポリシーに従ってエージェントがとるアクションに対応します。
**例:** *`steps` パラメータを使用する報酬関数*
```
def reward_function(params):
#############################################################################
'''
Example of using steps and progress
'''
# Read input variable
steps = params['steps']
progress = params['progress']
# Total num of steps we want the car to finish the lap, it will vary depends on the track length
TOTAL_NUM_STEPS = 300
# Initialize the reward with typical value
reward = 1.0
# Give additional reward if the car pass every 100 steps faster than expected
if (steps % 100) == 0 and progress > (steps / TOTAL_NUM_STEPS) * 100 :
reward += 10.0
return float(reward)
```
## track\$1length
**タイプ**: `float`
**範囲**: `[0:Lmax]`
トラックの長さ（メートル単位）。`Lmax is track-dependent.`
## track\$1width
**タイプ**: `float`
**範囲**: `0:Dtrack`
トラックの幅 (メートル)。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-track_width.png)
**例:** *`track_width` パラメータを使用する報酬関数*
```
def reward_function(params):
#############################################################################
'''
Example of using track width
'''
# Read input variable
track_width = params['track_width']
distance_from_center = params['distance_from_center']
# Calculate the distance from each border
distance_from_border = 0.5 * track_width - distance_from_center
# Reward higher if the car stays inside the track borders
if distance_from_border >= 0.05:
reward = 1.0
else:
reward = 1e-3 # Low reward if too close to the border or goes off the track
return float(reward)
```
## x、y
**タイプ**: `float`
**範囲**: `0:N`
トラックを含むシミュレーション環境の x 軸と y 軸に沿ったエージェント中心の位置（メートル単位）。原点は、シミュレーション環境の左下隅にあります。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-x-y.png)
## ウェイポイント
**タイプ**: `[float, float]` の `list`
**範囲**: `[[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]`
トラックの中心に沿ったトラック依存 `Max` マイルストーンの順序付きリスト。各マイルストーンは、(x w,i、y w,i) の座標で表されます。ループされたトラックの場合、最初と最後のウェイポイントは同じです。直線のトラックなどループされないトラックの場合、最初と最後のウェイポイントは異なります。
![\[\]](http://docs.aws.amazon.com/ja_jp/deepracer/latest/developerguide/images/deepracer-reward-function-input-waypoints.png)
**例** *`waypoints` パラメータを使用する報酬関数*
詳細については、「[`closest_waypoints`](#reward-function-input-closest_waypoints)」を参照してください。
# AWS DeepRacer 報酬関数の例
以下に AWS DeepRacer の報酬関数のいくつかの例を示します。
**Topics**
+ [例 1: タイムトライアルでセンターラインに従う](#deepracer-reward-function-example-0)
+ [例 2: タイムトライアルで 2 つの境界内に留まる](#deepracer-reward-function-example-1)
+ [例 3: タイムトライアルでのジグザグ運転の防止](#deepracer-reward-function-example-2)
+ [例 4: 静止している障害物や走行中の車両に衝突することなく、1 つの車線に留まること。](#deepracer-reward-function-example-3)
## 例 1: タイムトライアルでセンターラインに従う
この例では、エージェントがセンターラインからどれだけ離れているかを調べ、トラックの中央に近いと高い報酬を与え、エージェントがセンターラインに密接に従うように促します。
```
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
```
## 例 2: タイムトライアルで 2 つの境界内に留まる
この例では、エージェントが境界内に留まる場合に高い報酬を与え、エージェントがラップを完了するための最良の経路を把握させます。プログラミングと理解は簡単ですが、収束に時間がかかる可能性があります。
```
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
```
## 例 3: タイムトライアルでのジグザグ運転の防止
この例では、エージェントがセンターラインに従うようにインセンティブを与えますが、操作が大きすぎると報酬が低くなり、ジグザグ運転を防ぐのに役立ちます。エージェントはシミュレーターでスムーズに運転することを学習すれば、実際の車両にデプロイされたときに同じ動作を維持できる可能性があります。
```
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)
```
## 例 4: 静止している障害物や走行中の車両に衝突することなく、1 つの車線に留まること。
この報酬関数は、トラック境界の間に留まるエージェントに報酬を与え、前方のオブジェクトに近づきすぎたエージェントにペナルティを与えます。エージェントは、クラッシュを回避するために、車線から車線に移動することができます。報酬総額は、報酬とペナルティの加重合計です。この例では、衝突を回避するために、ペナルティをより重視しました。平均化の重みを変えて実験し、様々な行動の結果に対応できるようにトレーニングします。
```
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
```