海遊旅人　遊行編

基本モーション
JetBotのブラウザベースのプログラミングインターフェースへようこそ！ 
この文書はJupyter Notebookと呼ばれ、テキスト、コード、およびグラフィック表示を1つにまとめたものです。
このノートでは、JetBotを制御するための基本について説明します。

Robotクラスのインポート
JetBotのプログラミングを始めるには、Robotクラスをインポートする必要があります。 
このクラスでは、ロボットのモーターを簡単に制御できます。 
これはjetbotパッケージに入っています。

Pythonを使い慣れていない場合、パッケージは基本的にコードファイルを含むフォルダです。
これらのコードファイルはモジュールと呼ばれます。

Robotクラスをインポートするには、下のセルを強調表示してCtrl + Enterキーまたは上の再生アイコンを押します。 
これはセルに含まれるコードを実行します。
from jetbot import Robot
Robotクラスをインポートしたので、次のようにクラスインスタンスを初期化できます。
robot = Robot()

ロボットを指揮する
"robot"という名前のRobotインスタンスを作成したので、このインスタンスを使用してロボットを制御できます。 
ロボットを最大速度の30％で反時計回りに回転させるには、次のように呼びます。
警告：この次のコマンドはロボットを動かします！ ロボットに隙間があることを確認してください。
robot.left(speed=0.3)
クール、あなたはロボットが反時計回りに回転するのを見るべきです！

あなたのロボットが左に曲がらなかったならば、それはモーターの1つが逆に配線されていることを意味します！
 ロボットの電源を切って、不適切なモーターの赤と黒のケーブルの端子を交換してみてください。
注意：配線を確認するときは常に注意してください。実行中のシステムの配線を変更しないでください。
ロボットを停止するには、stopメソッドを呼び出します。
robot.stop()
ロボットを一定期間だけ走らせたいだけかもしれません。 そのためには、Pythonタイムパッケージを使うことができます。
import time
このパッケージは、次のコマンドを実行する前に、指定された秒数の間コードの実行をブロックするスリープ機能を定義
します。 
次のことを試して、ロボットを0.5秒だけ左に回転させてください。
robot.left(0.3)
time.sleep(0.5)
robot.stop()
すばらしいです。 ロボットが少し左に曲がって停止するのを確認する必要があります。
左の方法の中で、速度はどうなったのでしょうか。 
Pythonでは、名前、または定義されている順序で（名前を指定せずに）関数パラメーターを設定できます。
BasicJetbotクラスには、right、forward、およびbackwardのメソッドもあります。 
ロボットを50％の速度で1秒間前進させるために、独自のセルを作成してみてください。
既存のセルを強調表示してbまたは上の+アイコンを押して、新しいセルを作成します。 
それが終わったら、ロボットが50％の速度で1秒間前進するようにすると思うコードを入力します。

上記のように、左右などのコマンドを使用してロボットを制御する方法を説明しました。
しかし、各モーターの速度を個別に設定したい場合はどうすればよいでしょうか。 
これを行うには2つの方法があります。
最初の方法はset_motorsメソッドを呼び出すことです。 
たとえば、左のアーチを1秒間回転させるには、次のように左のモーターを30％、右のモーターを60％に設定します。
robot.set_motors(0.3, 0.6)
time.sleep(1.0)
robot.stop()
すばらしいです！ あなたはロボットが左のアーチに沿って動くのを見るべきです。 
しかし実際には、私たちが同じことを成し遂げることができるもう一つの方法があります。

Robotクラスには、それぞれのモーターを個別に表すleft_motorおよびright_motorという2つの属性があります。 
これらの属性はMotorクラスのインスタンスで、それぞれに値属性が含まれています。 
この値属性は、新しい値が割り当てられたときにイベントを生成する特性です。 
モータークラスでは、値が変わるたびにモーターコマンドを更新する関数を添付しています。

したがって、上記とまったく同じことを達成するために、次のことを実行できます。
robot.left_motor.value = 0.3
robot.right_motor.value = 0.6
time.sleep(1.0)
robot.left_motor.value = 0.0
robot.right_motor.value = 0.0
あなたはロボットが同じように動くのを見るべきです！

これらのトレイトレットについての本当に素晴らしい機能は、それらを他のトレイトレットにリンクさせることができると
いうことです！ 
Jupyter Notebooksは私達がボンネットの下でトレイトレットを使うグラフィカルなウィジェットを作ることを可能にする
のでこれはとても便利です。 
つまり、ブラウザからそれらを制御するためにウィジェットにモーターを接続するか、単に値を視覚化することができます。

これを行う方法を示すために、モーターを制御するために使用する2つのスライダーを作成して表示しましょう。
import ipywidgets.widgets as widgets
from IPython.display import display

# create two sliders with range [-1.0, 1.0]
left_slider = widgets.FloatSlider(description='left', min=-1.0, max=1.0, step=0.01, orientation='vertical')
right_slider = widgets.FloatSlider(description='right', min=-1.0, max=1.0, step=0.01, orientation='vertical')

# create a horizontal box container to place the sliders next to eachother
slider_container = widgets.HBox([left_slider, right_slider])

# display the container in this cell's output
display(slider_container)
2つの垂直スライダが上に表示されているはずです。

役立つヒント：Jupyter Labでは、セルの出力を実際にはまったく別のウィンドウに「ポップ」することができます。 
それでもノートブックに接続されますが、別々に表示されます。 
これは、他の場所で実行したコードの出力を固定したい場合に役立ちます。
 これを行うには、セルの出力を右クリックして、「出力用に新しいビューを作成」を選択します。 
その後、新しいウィンドウを好きな場所にドラッグします。

スライダーをクリックして上下にドラッグしてみてください。
現在スライダを動かしても何も起こらないことに注意してください。 
それはまだモーターに接続していないからです。
traitletsパッケージのlink関数を使ってそれを行います。
import traitlets

left_link = traitlets.link((left_slider, 'value'), (robot.left_motor, 'value'))
right_link = traitlets.link((right_slider, 'value'), (robot.right_motor, 'value'))
それでは（最初はゆっくりと）スライダをドラッグしてみてください。 
あなたはそれぞれのモーター回転を見るべきです！

上記で作成したリンク機能は、実際には双方向リンクを作成します。 
つまり、モーターの値を他の場所に設定すると、スライダーは更新されます。 
以下のコードブロックを実行してみてください
robot.forward(0.3)
time.sleep(1.0)
robot.stop()
スライダーがモーターのコマンドに反応するのが見えるはずです。 
この接続を削除したい場合は、各リンクのunlinkメソッドを呼び出すことができます。
left_link.unlink()
right_link.unlink()
しかし、双方向のリンクが必要ない場合は、スライダを使用してモータの値を表示し、制御することはしないとしましょう。 
そのためには、dlink関数を使うことができます。 左の入力がソースで、右の入力がターゲットです
left_link = traitlets.dlink((robot.left_motor, 'value'), (left_slider, 'value'))
right_link = traitlets.dlink((robot.right_motor, 'value'), (right_slider, 'value'))
スライダーを動かしてみましょう。 ロボットが反応しないことがわかります。 
しかし、別の方法でモーターを設定すると、スライダーは値を更新して表示します。

トレイトレットを使用するもう1つの方法は、イベントに関数（forwardなど）を添付することです。 
これらの関数は、オブジェクトへの変更が発生するたびに呼び出され、古い値や新しい値など、その変更に関する情報が渡
されます。

ロボットを制御するために使用するボタンをいくつか作成して表示しましょう。
# create buttons
button_layout = widgets.Layout(width='100px', height='80px', align_self='center')
stop_button = widgets.Button(description='stop', button_style='danger', layout=button_layout)
forward_button = widgets.Button(description='forward', layout=button_layout)
backward_button = widgets.Button(description='backward', layout=button_layout)
left_button = widgets.Button(description='left', layout=button_layout)
right_button = widgets.Button(description='right', layout=button_layout)

# display buttons
middle_box = widgets.HBox([left_button, stop_button, right_button], layout=widgets.Layout(align_self='center'))
controls_box = widgets.VBox([forward_button, middle_box, backward_button])
display(controls_box)
上に表示された一連のロボットコントロールが表示されます。
しかし今、彼らは何もしません。 
そのためには、ボタンのon_clickイベントにアタッチする関数をいくつか作成する必要があります。
def stop(change):
    robot.stop()
    
def step_forward(change):
    robot.forward(0.4)
    time.sleep(0.5)
    robot.stop()

def step_backward(change):
    robot.backward(0.4)
    time.sleep(0.5)
    robot.stop()

def step_left(change):
    robot.left(0.3)
    time.sleep(0.5)
    robot.stop()

def step_right(change):
    robot.right(0.3)
    time.sleep(0.5)
    robot.stop()
関数を定義したので、それを各ボタンのクリックイベントに追加しましょう。
# link buttons to actions
stop_button.on_click(stop)
forward_button.on_click(step_forward)
backward_button.on_click(step_backward)
left_button.on_click(step_left)
right_button.on_click(step_right)
各ボタンをクリックすると、ロボットが動くのがわかります。

ここでは、ロボットの動きを止めるために「ハートビート」を接続する方法を示します。 
これは、ロボット接続が有効かどうかを検出するための簡単な方法です。 
下のスライダを下げると、ハートビートの期間（秒単位）を減らすことができます。 
2つのハートビート内で仲介者間の往復通信を確立できない場合、ハートビートの「ステータス」属性は無効に設定されます。 
接続が回復するとすぐに、status属性はaliveに戻ります。
from jetbot import Heartbeat

heartbeat = Heartbeat()

# this function will be called when heartbeat 'alive' status changes
def handle_heartbeat_status(change):
    if change['new'] == Heartbeat.Status.dead:
        robot.stop()
        
heartbeat.observe(handle_heartbeat_status, names='status')

period_slider = widgets.FloatSlider(description='period', min=0.001, max=0.5, step=0.01, value=0.5)
traitlets.dlink((period_slider, 'value'), (heartbeat, 'period'))

display(period_slider, heartbeat.pulseout)
以下のコードを実行してモーターを始動し、次にスライダーを下げて何が起こるかを確認してください。 
ロボットやPCを切断してみることもできます。
robot.left(0.2) 

# now lower the `period` slider above until the network heartbeat can't be satisfied

結論¶
このノートブックの例はこれで終わりです。 
うまくいけば、あなたは今すぐ動き回るようにロボットをプログラムできると自信を持って感じます:)

衝突回避 - ライブデモ¶
このノートブックでは、ロボットの衝突回避動作を可能にするために、訓練したモデルを使用して、ロボットがフ
リーか
ブロックかを検出します。

衝突回避 - データ収集
基本的なモーションノートブックを見たことがあるなら、Jetbotを動かすのがいかに簡単かを楽しんでいることを願
います。
とってもかっこいい！しかし、もっとクールなのは、JetBotをそれ自体で動かすことです。

これは非常に困難な作業で、さまざまなアプローチがありますが、問題全体は通常、より簡単な副問題に分割されま
す。
解決すべき最も重要な副次的問題の1つは、ロボットが危険な状況に入るのを防ぐという問題です。
私たちはこの衝突回避を呼びます。

このノートブックでは、ディープラーニングと単一の非常に用途の広いセンサー（カメラ）を使用して問題を解決し
ようとしています。
ニューラルネットワーク、カメラ、そしてNVIDIA Jetson Nanoを使えば、ロボットに非常に便利な行動を教えることが
できるでしょう。

衝突を回避するために私たちがとるアプローチは、ロボットの周りに仮想の「安全バブル」を作成することです。
この安全バブルの範囲内で、ロボットは何のオブジェクト（または棚から落ちるなどの他の危険な状況）にぶつかるこ
となく円を描くように回転できます。

もちろん、ロボットはその視野内にあるものによって制限されており、オブジェクトがロボットの後ろなどに配置され
るのを防ぐことはできません。
しかし、ロボットがこれらのシナリオ自体に入るのを防ぐことはできます。

これを行う方法はとても簡単です。

まず、「安全バブル」に違反しているシナリオに手動でロボットを配置し、これらのシナリオにブロックのラベルを付
けます。
このラベルと共に、ロボットが見るもののスナップショットを保存します。

次に、少し前進しても安全なシナリオに手動でロボットを配置し、これらのシナリオには自由のラベルを付けます。
同様に、このラベルと一緒にスナップショットを保存します。

このノートブックでやることはこれだけです。
データ収集。たくさんの画像やラベルを作成したら、このデータをGPU対応のマシンにアップロードし、そこでニュー
ラルネットワークを訓練して、ロボットの安全バブルが違反しているかどうかを予測します。
最後にこれを使用して、単純な衝突回避動作を実装します。

重要な注意：JetBotが正しい位置に回転すると、実際にはロボットのシャーシ自体の中心ではなく、2つの車輪の間の
中心を中心に回転します。
これは、ロボットの安全バブルが侵害されているかどうかを推定しようとしているときに覚えておくべき重要な詳細
です。
しかし、心配しないでください、あなたは正確である必要はありません。
疑問がある場合は、慎重な面に傾ける方が良いでしょう（大きな安全バブル）。
我々はJetBotがその場で向きを変えることによって抜け出すことができないというシナリオに入らないようにしたい。

ライブカメラフィードを表示する
それでは始めましょう。 
まず、テレオペレーションノートブックで行ったようにカメラを初期化して表示しましょう。

私たちのニューラルネットワークは224 x 224ピクセルの画像を入力として受け取ります。 
データセットのファイルサイズを最小にするために、カメラをそのサイズに設定します（このタスクで機能することを
テスト済みです）。 
シナリオによっては、大きい画像サイズでデータを収集し、後で目的のサイズに縮小することをお勧めします。
import traitlets
import ipywidgets.widgets as widgets
from IPython.display import display
from jetbot import Camera, bgr8_to_jpeg

camera = Camera.instance(width=224, height=224)

image = widgets.Image(format='jpeg', width=224, height=224)  # this width and height doesn't necessarily have to match the camera

camera_link = traitlets.dlink((camera, 'value'), (image, 'value'), transform=bgr8_to_jpeg)

display(image)
素晴らしい、次に、すべてのデータを格納するディレクトリをいくつか作成しましょう。 
2つのサブフォルダを無料でブロックするフォルダデータセットを作成します。
ここに各シナリオの画像を配置します。
import os

blocked_dir = 'dataset/blocked'
free_dir = 'dataset/free'

# we have this "try/except" statement because these next functions can throw an error if the directories exist already
try:
    os.makedirs(free_dir)
    os.makedirs(blocked_dir)
except FileExistsError:
    print('Directories not created becasue they already exist')
左側のJupyterファイルブラウザを更新すると、これらのディレクトリが表示されるはずです。
次に、各クラスラベルのスナップショットを保存するために使用するボタンをいくつか作成して表示しましょう。 
また、これまでに収集した各カテゴリの画像の数を表示するテキストボックスをいくつか追加します。 
ブロックされた画像と同じくらい多くの無料画像を確実に収集したいので、これは便利です。
また、全体的に収集した画像の数を知るのにも役立ちます。
button_layout = widgets.Layout(width='128px', height='64px')
free_button = widgets.Button(description='add free', button_style='success', layout=button_layout)
blocked_button = widgets.Button(description='add blocked', button_style='danger', layout=button_layout)
free_count = widgets.IntText(layout=button_layout, value=len(os.listdir(free_dir)))
blocked_count = widgets.IntText(layout=button_layout, value=len(os.listdir(blocked_dir)))

display(widgets.HBox([free_count, free_button]))
display(widgets.HBox([blocked_count, blocked_button]))
今のところ、これらのボタンは何もしません。 
各カテゴリの画像をボタンのon_clickイベントに保存する関数を追加する必要があります。 
Imageウィジェットの値は（カメラではなく）保存します。
すでに圧縮されたJPEG形式になっているからです。

ファイル名が重複しないようにするために（異なるマシン間でも）、一意の識別子を生成するためのuuid1メソッドを
定義する、pythonのuuidパッケージを使用します。 
この一意の識別子は、現在時刻やマシンアドレスなどの情報から生成されます。
from uuid import uuid1

def save_snapshot(directory):
    image_path = os.path.join(directory, str(uuid1()) + '.jpg')
    with open(image_path, 'wb') as f:
        f.write(image.value)

def save_free():
    global free_dir, free_count
    save_snapshot(free_dir)
    free_count.value = len(os.listdir(free_dir))
    
def save_blocked():
    global blocked_dir, blocked_count
    save_snapshot(blocked_dir)
    blocked_count.value = len(os.listdir(blocked_dir))
    
# attach the callbacks, we use a 'lambda' function to ignore the
# parameter that the on_click event would provide to our function
# because we don't need it.
free_button.on_click(lambda x: save_free())
blocked_button.on_click(lambda x: save_blocked())
すばらしいです！今すぐ上のボタンは、空きディレクトリとブロックされたディレクトリにイメージを保存する必要が
あります。
 Jupyter Labのファイルブラウザを使ってこれらのファイルを見ることができます。

それでは先に進んでデータを集めてください

ブロックされているシナリオにロボットを配置し、ブロックされた追加を押します
ロボットを無料のシナリオに配置し、[無料で追加]をクリックします。
1、2を繰り返す
注意：セルを右クリックして[出力用に新しいビューを作成]をクリックすると、ウィジェットを新しいウィンドウに
移動できます。
または、以下のようにそれらを一緒に再表示することもできます。

データにラベルを付けるためのいくつかのヒントがあります

さまざまな向きを試してください
別の照明を試す
さまざまなオブジェクト/衝突タイプを試してください。壁、棚、オブジェクト
さまざまな質感のある床/オブジェクトを試してください。模様入り、滑らか、ガラスなど
最終的には、ロボットが実世界で遭遇するシナリオに関するデータが多ければ多いほど、衝突回避行動は良くなりま
す。
大量のデータだけでなく、さまざまなデータ（上記のヒントで説明）を取得することが重要ですが、おそらく各クラス
について少なくとも100枚の画像が必要です（これは科学ではなく、ここでは役立つヒントです）。
でも心配しないでください、うまくいったらすぐに動きます:)
display(image)
display(widgets.HBox([free_count, free_button]))
display(widgets.HBox([blocked_count, blocked_button]))

次
十分なデータを収集したら、トレーニングのためにそのデータをGPUデスクトップまたはクラウドマシンにコピーする
必要があります。 まず、次の端末コマンドを呼び出して、データセットフォルダを単一のzipファイルに圧縮できます。

です！ 接頭辞は、セルをシェル（または端末）コマンドとして実行したいことを示します。

下記のzipコマンドの-rフラグは再帰的であることを示しているので、入れ子になったすべてのファイルが含まれます。
-qフラグは静かであることを示し、zipコマンドは出力を表示しません。
!zip -r -q dataset.zip dataset
Jupyter Labのファイルブラウザにdataset.zipという名前のファイルが表示されます。 
Jupyter Labのファイルブラウザを使用して右クリックし、[ダウンロード]を選択してzipファイルをダウンロードする
必要があります。

次に、衝突回避ニューラルネットワークをトレーニングするために、このデータをGPUデスクトップまたはクラウド
マシン（これをホストと呼びます）にアップロードする必要があります。
 JetBot WiKiで説明されているようにトレーニングマシンをセットアップしたと仮定します。 
ある場合は、http：//<host_ip_address>：8888に移動して、ホスト上で実行されているJupyterラボ環境を開くこと
ができます。
ここで開く必要があるノートブックはcollision_avoidance/train_model.ipynbという名前です。

だからあなたのトレーニングマシンに向かい、そこにある指示に従ってください！ 
あなたのモデルが訓練されたら、ライブデモにモデルを使うためにロボットJupyter Lab環境に戻ります！

衝突回避 - ライブデモ
このノートブックでは、ロボットの衝突回避動作を可能にするために、訓練したモデルを使用して、ロボットがフリー
かブロックかを検出します。

訓練したモデルを読み込む¶
トレーニングノートの指示に従って、すでにbest_model.pthがワークステーションにダウンロードされているものとし
ます。 
さて、あなたはJupyter Labアップロードツールを使ってこのモデルをこのノートブックのディレクトリにアップロー
ドするべきです。 
それが終わったら、このノートブックのディレクトリにbest_model.pthという名前のファイルがあるはずです。

次のセルを呼び出す前に、ファイルが完全にアップロードされていることを確認してください

以下のコードを実行してPyTorchモデルを初期化してください。 
これはトレーニングノートから非常によく知られているはずです。
import torch
import torchvision
model = torchvision.models.alexnet(pretrained=False)
model.classifier[6] = torch.nn.Linear(model.classifier[6].in_features, 2)
次に、アップロードしたbest_model.pthファイルからトレーニング済みの重みをロードします。
model.load_state_dict(torch.load('best_model.pth'))
現在、モデルの重みはCPUメモリ上にあり、GPUデバイスに転送するために以下のコードを実行します。
device = torch.device('cuda')
model = model.to(device)

前処理機能を作成する
モデルをロードしましたが、わずかな問題があります。 
モデルをトレーニングしたフォーマットは、カメラのフォーマットと完全には一致しません。
 そのためには、いくつかの前処理をする必要があります。 これには以下のステップが含まれます

BGRからRGBに変換
HWCレイアウトからCHWレイアウトへの変換
トレーニング中に行ったのと同じパラメータを使用して正規化します（このカメラは[0、255]の範囲の値と[0、1]の範
囲のロード済み画像をトレーニングするので、255.0で拡大縮小する必要があります）
CPUメモリからGPUメモリにデータを転送する
バッチディメンションを追加する
import cv2
import numpy as np

mean = 255.0 * np.array([0.485, 0.456, 0.406])
stdev = 255.0 * np.array([0.229, 0.224, 0.225])

normalize = torchvision.transforms.Normalize(mean, stdev)

def preprocess(camera_value):
    global device, normalize
    x = camera_value
    x = cv2.cvtColor(x, cv2.COLOR_BGR2RGB)
    x = x.transpose((2, 0, 1))
    x = torch.from_numpy(x).float()
    x = normalize(x)
    x = x.to(device)
    x = x[None, ...]
    return x
すばらしいです！ 画像をカメラ形式からニューラルネットワーク入力形式に変換することができる前処理関数を定義
しました。

それでは、カメラを起動して表示しましょう。 もうこれでかなり慣れているはずです。 
ロボットがブロックされている可能性を表示するスライダーも作成します。
import traitlets
from IPython.display import display
import ipywidgets.widgets as widgets
from jetbot import Camera, bgr8_to_jpeg

camera = Camera.instance(width=224, height=224)
image = widgets.Image(format='jpeg', width=224, height=224)
blocked_slider = widgets.FloatSlider(description='blocked', min=0.0, max=1.0, orientation='vertical')

camera_link = traitlets.dlink((camera, 'value'), (image, 'value'), transform=bgr8_to_jpeg)

display(widgets.HBox([image, blocked_slider]))
モーターを駆動するために必要なロボットインスタンスも作成します。
from jetbot import Robot
robot = Robot()
次に、カメラの値が変わるたびに呼び出される関数を作成します。 この関数は以下のステップを実行します。
　カメラ画像を前処理する
　ニューラルネットワークを実行する
　ニューラルネットワークの出力がブロックされていることを示している間は、左に曲がります。それ以外の場合は前
進します。
import torch.nn.functional as F
import time

def update(change):
    global blocked_slider, robot
    x = change['new'] 
    x = preprocess(x)
    y = model(x)
    
    # we apply the `softmax` function to normalize the output vector so it sums to 1 (which makes it a probability distribution)
    y = F.softmax(y, dim=1)
    
    prob_blocked = float(y.flatten()[0])
    
    blocked_slider.value = prob_blocked
    
    if prob_blocked < 0.5:
        robot.forward(0.4)
    else:
        robot.left(0.4)
    
    time.sleep(0.001)
        
update({'new': camera.value})  # we call the function once to intialize
クール！ ニューラルネットワーク実行関数を作成しましたが、今度はそれをカメラに取り付けて処理する必要があり
ます。
それを観察関数で達成します。
警告：このコードはロボットを動かします！ ロボットに隙間があることを確認してください。
 衝突回避は機能するはずですが、ニューラルネットワークはそれが訓練されたデータと同じくらい良いだけです！
camera.observe(update, names='value')  # this attaches the 'update' function to the 'value' traitlet of our camera
驚くばかり！ ロボットが接続されていれば、新しいカメラフレームごとに新しいコマンドが生成されます。 
おそらくあなたのロボットを地面に置き、それが障害物に到達したときに何をするのかを見ることから始めます。

この動作を止めたい場合は、以下のコードを実行してこのコールバックを解除することができます。
camera.unobserve(update, names='value')
robot.stop()
ブラウザにビデオをストリーミングせずにロボットを動かしたいと思うかもしれません。
 以下のようにカメラのリンクを解除することができます。
camera_link.unlink()  # don't stream to browser (will still run camera)
ストリーミングを続けるには、以下を呼び出します。
camera_link.link()  # stream to browser (wont run camera)

結論
このライブデモは以上です。 
うまくいけば、あなたはいくつかの楽しみを持っていて、あなたのロボットは知的に衝突を避けました！

あなたのロボットが衝突をうまく回避していなかった場合は、それが失敗する場所を見つけるようにしてください。 
美しさは、これらの失敗シナリオについてより多くのデータを集めることができ、ロボットがさらに良くなることです

衝突回避 - 電車モデル
このホストサイドのJupyter Notebookへようこそ！ ロボットで動くノートブックを見たことがあるなら、これはおなじ
みのはずです。
このノートブックでは、衝突を避けるために使用する2つのクラスがフリーでブロックされていることを検出するよう
に画像分類子をトレーニングします。 
このために、私たちは人気のあるディープラーニングライブラリであるPyTorchを使います。
import torch
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.datasets as datasets
import torchvision.models as models
import torchvision.transforms as transforms
データセットのアップロードと抽出
始める前に、ロボットのdata_collection.ipynbノートブックで作成したdataset.zipファイルをアップロードする必要
があります。
その後、以下のコマンドを呼び出してこのデータセットを抽出する必要があります。
!unzip -q dataset.zip
ファイルブラウザにdatasetという名前のフォルダが表示されます。

ファイルブラウザにdatasetという名前のフォルダが表示されます。
dataset = datasets.ImageFolder(
    'dataset',
    transforms.Compose([
        transforms.ColorJitter(0.1, 0.1, 0.1, 0.1),
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
)

次に、データセットをトレーニングセットとテストセットに分割しました。 
テストセットは、トレーニングしたモデルの精度を検証するために使用されます。
train_dataset, test_dataset = torch.utils.data.random_split(dataset, [len(dataset) - 50, 50])

2つのDataLoaderインスタンスを作成します。
これらのインスタンスは、データのシャッフル、イメージのバッチの作成、および複数のワーカーと並行してサンプル
のロードを行うためのユーティリティを提供します。
train_loader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=16,
    shuffle=True,
    num_workers=4
)

test_loader = torch.utils.data.DataLoader(
    test_dataset,
    batch_size=16,
    shuffle=True,
    num_workers=4
)

ニューラルネットワークを定義する
それでは、トレーニングするニューラルネットワークを定義します。 
torchvisionパッケージは私達が使用できる事前に訓練されたモデルのコレクションを提供します。

転送学習と呼ばれるプロセスでは、利用可能なデータがはるかに少ない新しいタスクのために、事前に訓練されたモデ
ル（何百万もの画像で訓練された）を再利用できます。

事前に訓練されたモデルの最初の訓練で学んだ重要な機能は、新しいタスクに再利用できます。
 alexnetモデルを使います。
model = models.alexnet(pretrained=True)
alexnetモデルはもともと1000のクラスラベルを持つデータセットのために訓練されました、しかし我々のデータセット
は2つのクラスラベルだけを持ちます！ 
最後のレイヤーを、出力が2つしかない新しい未トレーニングのレイヤーに置き換えます。
model.classifier[6] = torch.nn.Linear(model.classifier[6].in_features, 2)
最後に、GPUで実行するためにモデルを転送します
device = torch.device('cuda')
model = model.to(device)

以下のコードを使用して、30エポックについてニューラルネットワークをトレーニングし、各エポック後に最高のパフ
ォーマンスのモデルを保存します。

エポックは私たちのデータを完全に実行しています。
NUM_EPOCHS = 30
BEST_MODEL_PATH = 'best_model.pth'
best_accuracy = 0.0

optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

for epoch in range(NUM_EPOCHS):
    
    for images, labels in iter(train_loader):
        images = images.to(device)
        labels = labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = F.cross_entropy(outputs, labels)
        loss.backward()
        optimizer.step()
    
    test_error_count = 0.0
    for images, labels in iter(test_loader):
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        test_error_count += float(torch.sum(torch.abs(labels - outputs.argmax(1))))
    
    test_accuracy = 1.0 - float(test_error_count) / float(len(test_dataset))
    print('%d: %f' % (epoch, test_accuracy))
    if test_accuracy > best_accuracy:
        torch.save(model.state_dict(), BEST_MODEL_PATH)
        best_accuracy = test_accuracy
それが終わったら、Jupyter Labのファイルブラウザにbest_model.pthというファイルがあるはずです。 
右クリック - >ダウンロードを選択してモデルをワークステーションにダウンロードします。

オブジェクトフォロー - ライブデモ
このノートブックでは、JetBotでオブジェクトを追跡する方法を説明します。 
COCOデータセットでトレーニングされた、事前にトレーニングされたニューラルネットワークを使用して、90種類の一般
的なオブジェクトを検出します。 これらは含まれています
　人（インデックス0）
　カップ（インデックス47）
その他多くのもの（このファイルでクラスインデックスの完全なリストを確認できます）。 
このモデルはTensorFlowオブジェクト検出APIから供給されています。
これはカスタムタスク用のオブジェクト検出器をトレーニングするためのユーティリティも提供します。 
モデルが訓練されたら、Jetson NanoのNVIDIA TensorRTを使用して最適化します。
これにより、ネットワークが非常に高速になり、Jetson Nanoでリアルタイムに実行できるようになります。
ただし、このノートブックのトレーニングと最適化の手順をすべて実行するわけではありません。
とにかく、始めましょう。 
まず、トレーニング済みのSSDエンジンを使用するObjectDetectorクラスをインポートします。

1台のカメラ画像で検出を計算する
from jetbot import ObjectDetector

model = ObjectDetector('ssd_mobilenet_v2_coco.engine')
内部的には、ObjectDetectorクラスはTensorRT Python APIを使用して、提供されているエンジンを実行します。 
また、ニューラルネットワークへの入力を前処理し、検出されたオブジェクトを解析します。 
今のところそれはjetbot.ssd_tensorrtパッケージを使用して作成されたエンジンに対してのみ機能します。 
このパッケージには、モデルをTensorFlowオブジェクト検出APIから最適化されたTensorRTエンジンに変換するためのユー
ティリティがあります。

次に、カメラを初期化しましょう。 
私たちのディテクタは300 x 300ピクセルの入力を受け取るので、カメラを作るときにこれを設定します。

内部的には、CameraクラスはGStreamerを使用してJetson NanoのImage Signal Processor（ISP）を利用します。
 これは超高速で、CPUからのサイズ変更の計算の負荷を軽減します。
from jetbot import Camera

camera = Camera.instance(width=300, height=300)
それでは、カメラ入力を使ってネットワークを実行しましょう。 
デフォルトでは、ObjectDetectorクラスはカメラが生成するbgr8フォーマットを期待します。
 ただし、入力が別の形式の場合は、デフォルトの前処理機能をオーバーライドすることができます。
detections = model(camera.value)

print(detections)
カメラの視野内にCOCOオブジェクトがある場合、それらは今度はdetection変数に保存されます。

以下のコードを使用して、検出されたオブジェクトを印刷します。
from IPython.display import display
import ipywidgets.widgets as widgets

detections_widget = widgets.Textarea()

detections_widget.value = str(detections)

display(detections_widget)
各画像で検出された各オブジェクトのラベル、信頼度、および境界ボックスが表示されます。
この例には1つの画像（私たちのカメラ）しかありません。

最初の画像で検出された最初のオブジェクトだけを印刷するには、次のように呼び出します。

オブジェクトが検出されない場合、これはエラーをスローするかもしれません
image_number = 0
object_number = 0

print(detections[image_number][object_number])

中心物体を追従するように制御ロボット
今、私たちのロボットが指定されたクラスのオブジェクトをたどることを望みます
これを行うには、次のようにします。

指定したクラスに一致するオブジェクトを検出する
カメラの視野の中心に最も近いオブジェクトを選択してください。これが「ターゲット」オブジェクトです。
目標物体に向かってロボットを操縦し、そうでなければさまよう
私たちが障害物によってブロックされている場合は、左に曲がります
また、ターゲットオブジェクトのラベル、ロボットの速度、「ターゲットの中心からの中心までの距離に基づいてロボットが
回転する速度」を制御するために使用するウィジェットも作成します。 ロボットの視野。

まず、衝突検出モデルをロードしましょう。 
事前に訓練されたモデルは便宜上このディレクトリに格納されていますが、衝突回避の例に従えば、ロボットの環境に合
わせて調整されている場合はそのモデルを使用することをお勧めします。
import torch
import torchvision
import torch.nn.functional as F
import cv2
import numpy as np

collision_model = torchvision.models.alexnet(pretrained=False)
collision_model.classifier[6] = torch.nn.Linear(collision_model.classifier[6].in_features, 2)
collision_model.load_state_dict(torch.load('../collision_avoidance/best_model.pth'))
device = torch.device('cuda')
collision_model = collision_model.to(device)

mean = 255.0 * np.array([0.485, 0.456, 0.406])
stdev = 255.0 * np.array([0.229, 0.224, 0.225])

normalize = torchvision.transforms.Normalize(mean, stdev)

def preprocess(camera_value):
    global device, normalize
    x = camera_value
    x = cv2.resize(x, (224, 224))
    x = cv2.cvtColor(x, cv2.COLOR_BGR2RGB)
    x = x.transpose((2, 0, 1))
    x = torch.from_numpy(x).float()
    x = normalize(x)
    x = x.to(device)
    x = x[None, ...]
    return x
モーターを制御できるように、ロボットを初期化しましょう。
from jetbot import Robot

robot = Robot()
最後に、すべてのコントロールウィジェットを表示して、ネットワーク実行機能をカメラのアップデートに接続しましょう。
from jetbot import bgr8_to_jpeg

blocked_widget = widgets.FloatSlider(min=0.0, max=1.0, value=0.0, description='blocked')
image_widget = widgets.Image(format='jpeg', width=300, height=300)
label_widget = widgets.IntText(value=1, description='tracked label')
speed_widget = widgets.FloatSlider(value=0.4, min=0.0, max=1.0, description='speed')
turn_gain_widget = widgets.FloatSlider(value=0.8, min=0.0, max=2.0, description='turn gain')

display(widgets.VBox([
    widgets.HBox([image_widget, blocked_widget]),
    label_widget,
    speed_widget,
    turn_gain_widget
]))

width = int(image_widget.width)
height = int(image_widget.height)

def detection_center(detection):
    """Computes the center x, y coordinates of the object"""
    bbox = detection['bbox']
    center_x = (bbox[0] + bbox[2]) / 2.0 - 0.5
    center_y = (bbox[1] + bbox[3]) / 2.0 - 0.5
    return (center_x, center_y)
    
def norm(vec):
    """Computes the length of the 2D vector"""
    return np.sqrt(vec[0]**2 + vec[1]**2)

def closest_detection(detections):
    """Finds the detection closest to the image center"""
    closest_detection = None
    for det in detections:
        center = detection_center(det)
        if closest_detection is None:
            closest_detection = det
        elif norm(detection_center(det)) < norm(detection_center(closest_detection)):
            closest_detection = det
    return closest_detection
        
def execute(change):
    image = change['new']
    
    # execute collision model to determine if blocked
    collision_output = collision_model(preprocess(image)).detach().cpu()
    prob_blocked = float(F.softmax(collision_output.flatten(), dim=0)[0])
    blocked_widget.value = prob_blocked
    
    # turn left if blocked
    if prob_blocked > 0.5:
        robot.left(0.3)
        image_widget.value = bgr8_to_jpeg(image)
        return
        
    # compute all detected objects
    detections = model(image)
    
    # draw all detections on image
    for det in detections[0]:
        bbox = det['bbox']
        cv2.rectangle(image, (int(width * bbox[0]), int(height * bbox[1])), (int(width * bbox[2]), int(height * bbox[3])), (255, 0, 0), 2)
    
    # select detections that match selected class label
    matching_detections = [d for d in detections[0] if d['label'] == int(label_widget.value)]
    
    # get detection closest to center of field of view and draw it
    det = closest_detection(matching_detections)
    if det is not None:
        bbox = det['bbox']
        cv2.rectangle(image, (int(width * bbox[0]), int(height * bbox[1])), (int(width * bbox[2]), int(height * bbox[3])), (0, 255, 0), 5)
    
    
        
    # otherwise go forward if no target detected
    if det is None:
        robot.forward(float(speed_widget.value))
        
    # otherwsie steer towards target
    else:
        # move robot forward and steer proportional target's x-distance from center
        center = detection_center(det)
        robot.set_motors(
            float(speed_widget.value + turn_gain_widget.value * center[0]),
            float(speed_widget.value - turn_gain_widget.value * center[0])
        )
    
    # update image widget
    image_widget.value = bgr8_to_jpeg(image)
    
execute({'new': camera.value})
実行機能を各カメラフレームの更新に接続するには、以下のブロックを呼び出します。
camera.unobserve_all()
camera.observe(execute, names='value')
驚くばかり！ ロボットがブロックされていない場合は、検出されたオブジェクトの周囲に青い四角形のボックスが表示され
ます。 
（ロボットが追跡している）ターゲットオブジェクトは緑色で表示されます。

ロボットはターゲットが検出されたらターゲットに向かって操縦する必要があります。 それがオブジェクトによってブロ
ックされている場合は、単に左に曲がります。


以下のコードブロックを呼び出して、手動でカメラから処理を切断し、ロボットを停止することができます。
import time

camera.unobserve_all()
time.sleep(1.0)
robot.stop()

遠隔操作
この例では、Webブラウザマシンに接続されたゲームパッドコントローラを使ってJetbotをリモートで制御します。

ゲームパッドコントローラを作成する
最初にしたいことは、コントローラウィジェットのインスタンスを作成することです。
これを使ってロボットを動かします。 
コントローラウィジェットは、コントローラの番号を指定するインデックスパラメータを取ります。
これは、複数のコントローラが接続されている場合や、一部のゲームパッドが複数のコントローラとして表示されている場
合に便利です。 使用しているコントローラのインデックスを調べるには、
　http://html5gamepad.comをご覧ください。
使用しているゲームパッドのボタンを押す
ボタンを押したときに反応しているゲームパッドのインデックスを覚えておいてください
次に、そのインデックスを使ってコントローラを作成して表示します。
import ipywidgets.widgets as widgets
controller = widgets.Controller(index=1)  # replace with index of your controller
display(controller)
インデックスが正しい場合でも、「ゲームパッドの接続」というテキストが表示され、任意のボタンを押すことがあります。 
これは、ゲームパッドがこのノートブックにまだ登録されていないためです。 
ボタンを押すと、ゲームパッドウィジェットが上に表示されるはずです。

ゲームパッドコントローラーをロボットモーターに接続
これで、ゲームパッドを接続したにもかかわらず、ロボットにコントロールをまだ接続していません。 
私たちが最初に付けたいそして最も簡単なコントロールはモーターコントロールです。 
関数dlinkを使って、これを左右の垂直軸に接続します。 
関数linkとは異なり、関数dlinkを使用すると、ソースとターゲットの間にトランスフォームを追加できます。 
コントローラの軸は、モータ制御にとって直感的に理解できるものから反転しているため、値を無効にするために小さな
ラムダ関数を使用します。
警告：ゲームパッドコントローラの軸に触れると、この次のセルがロボットを動かします。
from jetbot import Robot
import traitlets

robot = Robot()

left_link = traitlets.dlink((controller.axes[1], 'value'), (robot.left_motor, 'value'), transform=lambda x: -x)
right_link = traitlets.dlink((controller.axes[3], 'value'), (robot.right_motor, 'value'), transform=lambda x: -x)
驚くばかり！ ロボットはゲームパッドコントローラの動きに反応するはずです。 
今度は私達はカメラからの生のビデオフィードを見たいです！

画像ウィジェットの作成と表示
まず、ライブカメラフィードを表示するために使用するImageウィジェットを表示しましょう。 
高さと幅を300ピクセルに設定して、スペースを取りすぎないようにします。

参考：高さと幅はブラウザ側でのレンダリングにのみ影響し、ロボットからブラウザへのネットワーク転送前のネイ
ティブ画像の解像度には影響しません。
image = widgets.Image(format='jpeg', width=300, height=300)

display(image)

カメラインスタンスを作成する
まだ値を設定していないため、画像は表示されていません。 
これを行うには、Cameraクラスを作成し、カメラのvalue属性を画像の `` value属性 'に添付します。
まず、カメラインスタンスを作成しましょう。
まだ作成されていない場合は新しいカメラを作成するインスタンスメソッドを呼び出します。 
すでに存在する場合、このメソッドは既存のカメラを返します。
from jetbot import Camera
camera = Camera.instance()

カメラを画像ウィジェットに接続¶
私たちのカメラクラスは現在BGR8（青、緑、赤、8ビット）フォーマットの値しか生成しませんが、私たちの画
像ウィジェットは圧縮されたJPEGの値を受け入れます。 
カメラを画像に接続するには、リンクに変換としてbgr8_to_jpeg関数を挿入する必要があります。
 これを以下にします
from jetbot import bgr8_to_jpeg
camera_link = traitlets.dlink((camera, 'value'), (image, 'value'), transform=bgr8_to_jpeg)
これでライブビデオフィードが上に表示されます。
注意：セルの出力を右クリックして[出力用に新しいビューを作成]を選択すると、セルを別のウィンドウに表示
できます。

ネットワークが切断したらロボットを停止する¶
あなたはビデオフィードを通して見ることによってあなたのロボットを動かすことができます。 
しかし、あなたのロボットがWifiから切断されたらどうしますか？ モーターは動き続け、ビデオやモーターのコマンドを
流そうとし続けます。 
切断が発生したときにロボットを停止し、カメラとモーターのリンクを解除するようにしましょう。
from jetbot import Heartbeat


def handle_heartbeat_status(change):
    if change['new'] == Heartbeat.Status.dead:
        camera_link.unlink()
        left_link.unlink()
        right_link.unlink()
        robot.stop()

heartbeat = Heartbeat(period=0.5)

# attach the callback function to heartbeat status
heartbeat.observe(handle_heartbeat_status, names='status')
ロボットがインターネットから切断されると、ロボットは停止します。 
下のセルにリンクを作成し直して、カメラとモーターを再接続します。
# only call this if your robot links were unlinked, otherwise we'll have redundant links which will double
# the commands transfered

left_link = traitlets.dlink((controller.axes[1], 'value'), (robot.left_motor, 'value'), transform=lambda x: -x)
right_link = traitlets.dlink((controller.axes[3], 'value'), (robot.right_motor, 'value'), transform=lambda x: -x)
camera_link = traitlets.dlink((camera, 'value'), (image, 'value'), transform=bgr8_to_jpeg)

ゲームパッドボタンでスナップショットを保存する
今、私たちはロボットからいくつかの画像を保存できるようにしたいです。 
正しいバンパー（インデックス5）が現在のライブ画像のスナップショットを保存するようにしましょう。 
uuid pythonパッケージを使用して一意であることが保証されている名前で、snapshots /ディレクトリに画像を保存します。 
uuid1識別子を使用します。
これは、後で使用する可能性がある日付とMACアドレスもエンコードするためです。
import uuid
import subprocess

subprocess.call(['mkdir', '-p', 'snapshots'])

snapshot_image = widgets.Image(format='jpeg', width=300, height=300)

def save_snapshot(change):
    # save snapshot when button is pressed down
    if change['new']:
        file_path = 'snapshots/' + str(uuid.uuid1()) + '.jpg'
        
        # write snapshot to file (we use image value instead of camera because it's already in JPEG format)
        with open(file_path, 'wb') as f:
            f.write(image.value)
            
        # display snapshot that was saved
        snapshot_image.value = image.value


controller.buttons[5].observe(save_snapshot, names='value')

display(widgets.HBox([image, snapshot_image]))
display(controller)

Conclusion
That's it for this example, have fun!

40pinのGPIOをはじめCSI、SDカードがそろっています。
後述するセットアップ方法も過去のJetsonシリーズより敷居が下が
っているので、Jetsonシリーズをはじめて使うのにはもってこいのモデルではないでしょうか？

今までArduinoやラズパイで電子工作をしてきたメイカーズの人々にDeep Leaningを使ったAI機能を使ってほしいという
本気度も伝わってくるように感じました。
これは廉価な価格設定にも表れています。

Isaac Sim GPUの最小値はNvidia GeForce GTX 1080およびGPU推奨はNvidia Titan XPです。
DGXは正常に動作します。

画像は「Jetson Nano を使ってみる!!」による

インストール完了時点でCUDAもCUDNNもOPENCV3.3もインストールされてる。
Nanoは最大能力 17.48sec PI3B+の約3.2倍

Nanoのオーバークロック　コマンド化された
USB電源から起動　事前に5V 4A電源（これが上限のようです）とジャンパーピンを取り付ける必要がある。
さらにFANを付け足すほうが安心
　最大の能力を引き出す　以下2つのコマンドを続けて実行する
　　sudo nvpmodel -m 0
　　sudo jetson_clocks
　nvpmodelはNanoの場合0か1の2者選択のみ？　0が最大で1が最小
　現在の設定値（CPU,GPUの周波数）を確認には  
　　sudo jetson_clocks --show  を実行

元々は、科学技術者たちがGPUの並列計算能力を何とか科学技術計算に使えないかと模索した結果、GPUにおける色の計算
（シェーダ機能）に目をつけ、計算プログラムにおける変数をダミーの色として与え、そのフィードバックを数値として写
像することで結果を得るという方法を生み出したのが、GPU汎用計算の始まりと言われています。
その後、NVIDIA社がCPUの進化に対抗して汎 用計算に対応したGPUを開発し、その統合開発環境としてCUDA（後述）を配信し
たことで、GPUコンピューティングがより普及するようになりました。

小型の最新AIコンピュータ「NVIDIA Jetson Nano」
レビュー(1) 開封の儀
 NVIDIA Jetson Nanoとは
 Jetson NANO開封の儀
レビュー(2) ベンチマーク編　AIエッジコンピューティングの新定番となるか?
 Jetson Nano Deep Stream SDK デモ
 ラズパイを意識した作り
 セットアップはマイクロSDカードにイメージを焼くだけ
 各種ベンチマーク
 実際に動かしてみた所感

Jetson XavierがProject Redtail、Ardurover SITL、AirSim、ROSを使用してUnreal Engineで車両を運転している様子を動
画にリンクしています。

車両は、UE4からの単一のカメラストリームのみを入力としてRedtailニューラルネットワークによって制御されている。
プロジェクトの試しに興味がある人には、wikiのドキュメントをセットアップと使用方法の指示に仕上げます。
 また、Redtail githubサイトの私のPRにプッシュするためのファイルがさらに2つあります。 
テストの準備が整ったら、後で更新する予定です。
＃1　Posted 09/24/2018 06:07 PM

今、霧を上げ、地平線の真ん中に太陽を置いてください！
シミュレートされた環境のクールなことは、あなたが簡単にそのようなことをすることができるということです。
悪いことは、歩行者、道路乗組員、壊れた信号灯、自転車道を横断するような実際のハードな行動のシミュレーションが
ほとんどの環境でないことです。
＃2　Posted 09/24/2018 08:18 PM 

これは素晴らしいです。 
あなたの努力に感謝します。 私はこのプロジェクトを私のドローンプラットフォームの1つに複製することを意味してき
ました。
＃3　Posted 09/24/2018 08:21 PM

ここでは、XavierとRedtailでそれを設定し始めることを望む誰のためのwikiの不完全な原案があります。 
私は今夜後にそれを完成させようとします。
https://github.com/TritonSailor/redtail/wiki/Getting-Started-with-Autonomous-Navigation-Training-and
-Testing-using-airsim_ros-package
＃4　Posted 09/24/2018 09:13 PM

このUE4環境にはいくつかの異なる手段があります。
それにはAirSim SUVとQuadcopter、さらにオフロードのバギーとゴールデンイーグルがあります。
フライング・ビークルは、ジョイスティックまたはAPI、キーパッド付きの陸上車またはAPIによって制御できます。
太陽の位置とその他の多くのものはAirSimのsettings.jsonファイルで設定できます
ここに、Win64用のRedtail環境へのリンクがあります。 
https://www.dropbox.com/s/7p55uwhaigohu4r/Redtail.zip?dl=0
Win64にはNvidia VXGIが搭載されており、RTX 2080で4Kで高いフレームレートを実行します。
1080p以上で1080p以上でOKです。
あなたがHTC ViveでVRで飛行またはドライブしたい場合は、SteamVRが最初に実行されていることを確認し、.exeを起動して
から、simがロードされた後、 "〜"を押してコンソールに行き、vr.bEnableStereo = 1
これはLinuxのバイナリです。遅く実行されます。高速GPUを使用しても、より低い解像度で実行する必要があります
https://www.dropbox.com/s/iuzh03fm76vinzq/Redtail.tgz?dl=0

Jetson Xavierが見ているビューが表示されていますか？
私はそれが違うことを望んでいます。なぜなら、人間の運転手でさえ見通しの中にバギーを持っているのは不公平だか
らです。

それはニューラルネットワークが見ているビューではありません。 画面に表示されるビューを切り替えたり、ROSノード
によって公開されているカメラパラメータを変更することもできます。
ゲーム中に「I」を押すと、フロントセンターカメラの表示が得られます。 それはニューラルネットワークが見ているもの
であり、それは通常私が運転や飛行のために好きなものです。
AirSimコマンドのリストを取得するには "F1"と入力します。
これは開発ビルドなので、 "〜"でコンソールにアクセスして、レンダー設定を変更するためのUE4コンソールコマンドに
入ることができます。
ビデオでは、屋外の環境で運転するためにフロントカメラが車上で低すぎます。 
私が上に掲示したバイナリでは、カメラは記録されたビデオよりも1メートル上に移動します。 
カメラをより高く動かすことは、ネットワークが訓練された高さ付近にあるので、ニューラルネットワークの運転性能を改
善した。 
以前はあまりにも多くの眺めが草や他の植物によって妨害されていました。
＃6　Posted 09/25/2018 12:23 AM

情報をお寄せいただきありがとうございます。 私はそれを試して待つことができません。
私はJetson-Hackチュートリアルを使って構築したRoverを持っています。
これは間違いなくネットワークでのトレーニングのために便利なものです。
現在TX2の周りに構築されていますが、私はそれをXavierに置き換える予定です。
＃7　Posted 09/25/2018 12:30 AM

cuDNN　198 Topics　532 Comments
TensorRT　1,040 Topics　3,945 Comments
Other Libraries　Discussions about NCCL, DIGITS and other Deep Learning SDK Components
　　　　　　　　80 Topics　107 Comments

NVIDIA®Jetson™プラットフォームは、AIアプリケーションの開発を始めるための迅速で簡単な方法を提供します。 
これには、新しく発売されたJetson Nanoが含まれています。
これは、NVIDIAだけが提供できる強力な機能を搭載した、小型で強力で手頃な価格のAIコンピュータです。
 NVIDIA Jetsonで何ができるかについてもっと知るために今日登録してください。

こんにちは、AIワールド。 Jetson Nanoに会いましょう。
Jetson Nanoの背後にあるハードウェアとソフトウェアについてもっと知るために、この魅力的で有益なウェビナーとライブ
のQ&Aセッションに登録する最後のチャンス。 
AIを搭載した自律型ロボットやスマートデバイスの構築とともに、独自のディープラーニングモデルを作成および展開する
方法をご覧ください。
ウェビナー詳細
日付：2019年5月2日木曜日
時間：午前10時 - 午後11時PT
ホスト：Dustin Fra

あなたの次のプロジェクトをAIで次のレベルに進めたいですか？答えが「はい」の場合、このウェビナーはあなたのためで
す。
私たちはあなたにすべての新しいJetson Nano™とその最新の機能を紹介します、それはそれが端で高性能AIプロジェクトを
作成するための理想的なプラットフォームになります。

あなたはJetson Nanoがどれほど簡単に使うことができるか、そしてそれが他のものから何を分離しているのかを発見するで
しょう。
 NVIDIA JetBot、Jetsonで新しいAIプロジェクトを構築することを可能にするオープンソースのDIYロボットキットで実際に
それを見てください。

このウェビナーに参加することで、以下の方法を学ぶことができます。
TensorFlow、PyTorch、Caffe、MxNetなどの一般的な機械学習フレームワークを使用して、さまざまなディープニューラルネ
ットワークモデルを実行します。
これらは、NVIDIA JetPack、cuDNN、およびTensorRTのサポートにより加速された、画像認識やオブジェクト検出などのタス
クを可能にします。
Jetson NanoのPython、C ++、CUDA X、OpenGL、およびROS（Robot OS）などの一般的なプログラミング言語およびライ
ブラリを使用して、フルデスクトップのUbuntu環境で開発します。
AI推論パフォーマンス用の最新のコンピューティングプラットフォームをベンチマークし、Hello AI WorldやTwo Days to 
a Demoのようなディープラーニングチュートリアルを始めましょう。
生のHDビデオをストリーミングし、GPIOでアクチュエータを制御するために、市販のセンサー、カメラ、周辺機器とNanoを
接続します。
NVIDIA JetBotやKayaなどのリファレンスロボットキットを作成します。
ライブQ&Aセッションのプレゼンテーションの後にご参加ください。

メーカーのためのAI。 JetBotで学びましょう。
あなたの次のプロジェクトをAIでまったく新しいレベルに引き上げたいですか？ JetBotは、Jetson Nanoを使用して新しい
AIプロジェクトを構築することがいかに簡単であるかを示す、オープンソースのDIYロボットキットです。
ウェビナー詳細
日付：2019年5月16日木曜日
時間：午前10時 - 午後11時PT
ホスト：NVIDIA開発技術エンジニアJohn Welsh氏

Isaac SDKを使用したインテリジェントマシンの作成
NVIDIA®Isaac SDKは、AI搭載ロボットの開発と展開を加速するための開発者ツールボックスです。
SDKには、ロボット開発者がJetson NanoやJetson AGX Xavier Developer Kitsのようなエッジデバイスにアプリケーション
をデプロイすることを可能にするフレームワークであるIsaac Robot Engineが含まれています。
ウェビナー詳細
日付：2019年5月30日木曜日
時間：午前10時 - 午後11時PT
ホスト：NVIDIAロボティクス担当ディレクター、David Weikersdorfer

NVIDIA Isaacのドキュメント
NVIDIA Isaacは、AI搭載ロボットの開発と展開を加速するための開発者ツールボックスです。 SDKには、Isaacアプリケー
ション、GEM（ロボット機能）、Robot Engine、およびIsaac Simが含まれています。
　NVIDIA Isaac SDK開発者ガイド
　NVIDIA Isaac Sim開発者ガイド

ＮＶＩＤＩＡ Jetson Nａｎｏ kit
Hello AI World
NVIDIA-AI-IOT/jetbot

Getting Started With Jetson Nano Developer Kit
　Included in the Box
　Items not Included
Prepare for Setup
　Items for Getting Started
　　microSD Card
　　Micro-USB Power Supply
　Optional Items
　　Wireless Networking Adapter
Write Image to the microSD Card
　INSTRUCTIONS FOR WINDOWS
　INSTRUCTIONS FOR MAC
　INSTRUCTIONS FOR LINUX
Setup and First Boot
　Setup Steps
　First Boot
　After Logging In
Next Steps
　Find Your Way Around
　Projects and Learning
Troubleshooting
　Power
　Display

 Jetson Nano では NVIDIA 社が公開しているOSイメージ・ファイルである Jetson Nano Developer Kit SD Card Image
をマイクロ SD カードに書き込むだけです。
Jetson Nano Developer Kit SD Card Image は Jetson Download Center からダウンロードできます。
ダウンロードには NVIDA 開発者プログラムの登録が必要です。

公式にUbuntuをサポートしている開発ボード

 機材の準備
  給電用Micro USBケーブル（5V2A以上）
  microSD
  HDMIもしくはDisplayPortのケーブルとディスプレイ
  USB接続のキーボードとマウス
  LANケーブル
 microSDカードの準備
 
初回起動（OEM Config）
 ログイン画面での注意事項
 日本語環境の構築
 Jetson Nanoのテスト
 CUDAのサンプルコード
 CUDAのサンプル：oceanFFT
 CUDAのサンプル：smorkeParticles
 CUDAのサンプル：nbody
 VisionWorksのサンプルコード
  VisionWorksのサンプル：ハフ変換
  VisionWorksのサンプル：移動予測

UARTへ接続する方法  

　pythonパッケージをグローバルにインストールするのではなく、仮想環境を使用する。 
異なるプロジェクトに異なるパッケージ構成を持たせる。 
異なる仮想環境のパッケージ分離により、異なるプロジェクト内で競合するパッケージを使用することもできます。
　Python仮想環境は専用パスに格納されます。
以下のガイドでは、このパスを<python-env>と呼んでいます。 
たとえば、パス<python-env>/tf_pythonを使用して、このPython環境でTensorflow（tf）が使用されていることを強調
表示します。
　まず、仮想環境を作成します。
python3 -m venv <python-env>
パス <python-env>/binにはactivateというスクリプトが含まれています。
これは仮想環境をアクティブにするために呼び出さなければなりません。
source <python-env>/bin/activate
最初のステップとして、PIPを最新バージョンに更新します。
pip install --upgrade pip

インストール
(tensorflow-with-gpu) $ pip install keras tensorflow-gpu
確認
(tensorflow-with-gpu) $ pip list --format=columns | grep -i -e keras -e tensorflow
Keras          1.2.2
tensorflow-gpu 1.0.1
以降はシェルのプレフィックスを表記しないけど Python 仮想環境上で実行している。

まえがき
CARLAは、自律走行システムの開発、トレーニング、および検証をサポートするためにゼロから開発されました。 
オープンソースのコードとプロトコルに加えて、CARLAはこの目的のために作成され、自由に使用できるオープンデジタル
アセット（都市のレイアウト、建物、自動車）を提供します。 
シミュレーションプラットフォームは、センサースイート、環境条件、すべての静的および動的アクターの完全制御、
マップ生成など、柔軟な仕様の指定をサポートします。

注目の機能
サーバーマルチクライアントアーキテクチャによるスケーラビリティ：同じノードまたは異なるノードにある複数のクライ
アントが、異なるアクターを制御できます。
柔軟なAPI：CARLAは、トラフィック生成、歩行者の行動、天気、センサーなど、シミュレーションに関連するすべての側面
をユーザーが制御できるようにする強力なAPIを公開しています。
自動運転センサースイート：ユーザーは、LIDAR、複数のカメラ、深度センサー、GPSなど、さまざまなセンサースイートを
構成できます。
計画および管理のための高速シミュレーション：このモードはレンダリングを無効にして、グラフィックが不要な交通シ
ミュレーションおよび道路の挙動を高速に実行します。
地図の生成：ユーザーは、RoadRunnerのようなツールを使ってOpenDrive標準に従って自分の地図を簡単に作成できます。
交通シナリオシミュレーション：私たちのエンジンScenarioRunnerは、モジュール式の振る舞いに基づいて様々な交通状況
を定義し実行することを可能にします。
ROS統合：CARLAは、ROSブリッジを介してROSと統合されています。
自動運転ベースライン：AutoWareエージェントおよび条件付き模倣学習エージェントを含む、CARLAの実行可能なエージェ
ントとして自動運転ベースラインを提供します。

現実的な運転条件の下で自己駆動技術をテストするために使用できるオープンソースの運転シミュレータを作成しました

CARLA（Car Learning to Act）と呼ばれるこのシステムは、さまざまな運転条件をシミュレートし、危険な状況を無限に繰り返し学習を支援します。チームは自律運転に関するいくつかの異なるアプローチのパフォーマンスを評価するために既にこのツールを使用しています。

運転シミュレータは新しいものではありません。多くの現実的なドライビングシミュレータとレーシングシミュレータがあります。多くの場合、ゲーム用に設計されています。様々な自律的な運転集団が彼らの技術をテストするためにそれらを使用しています。

しかし、これらのシミュレータのどれも、自律駆動システムが効果的に訓練する必要のある種類のフィードバックを提供していません。また、これらのシステムは、運転条件や他のエージェントの動作を大幅に制御することもできません。

レーシングシミュレータは通常、通行人や歩行者を持っていません。 Grand Theft Autoなどの都市シミュレータでは、天気、太陽の位置、他の車の動き、交通信号や歩行者、サイクリストなどを制御することはできません。

そして、これらの専用システムは、自律駆動システムが学ぶ必要のある種類の技術的フィードバックを与えません。

だからDosovitskiyと共同で独自のシミュレータを作成しました。 CARLAは様々な天気や照明の下で街に配置できる資産のライブラリを提供しています。図書館には40の異なる建物、16のアニメーション車両モデル、50人のアニメーターの歩行者が含まれています。

チームはこれらを使用して、数キロメートルの走行可能な道路を備えた2つの町を作成し、次に自己駆動システムをトレーニングするための3つの異なるアプローチをテストしました。 「このアプローチは、難しさが増すという制御されたシナリオで評価されます」とチームは言います。

結果は、システムが有用な役割を果たすことができることを示している。チームは、結果として得られる運転行動のビデオを公開しています。このシステムは、システムの性能をはっきりと示していますが、実際の道路ではこのような訓練ができない理由を示しています。他の車にヒットした、など。

もちろん、CARLAのようなシステムは、実際の道路で運転時間を交換することはできません。しかし、それは新しいアイデアのための有用で安全なテスト場を提供することができます。それが重要な理由です。

CARLAはオープンソースであり、非営利目的での使用は自由です。だから誰でもwww.carla.orgに行くことができます。 「CARLAが、幅広いコミュニティが自主的な運転研究に積極的に関与できるようになることを願っています。

参考文献：arxiv.org/abs/1711.03938：CARLA：オープン都市型運転シミュレータ