WEBVTT

00:00.120 --> 00:02.720
こんにちは､ このPythonチュートリアルへようこそ｡ 

00:02.730 --> 00:08.010
このチュートリアルでは､ ディープラーニングモデルを実装するための最初の一歩を踏み出します｡ 

00:08.010 --> 00:13.560
つまり､ 基本的にはディープラーニングアルゴリズムの全工程を実装するところなんです｡ 

00:13.560 --> 00:16.530
で､ 前に作ったものを使うわけです｡ 

00:16.560 --> 00:23.520
それが､ 記憶を再生するニューラルネットワークのアーキテクチャであり､ これをディープラーニング全体のプロセスに統合することです｡

00:23.880 --> 00:28.200
そして､ このディープラーニングのアルゴリズム全体は､ 1つのクラスに収まることになります｡ 

00:28.200 --> 00:32.070
人工知能を実装するために作っている最後の授業なんですね｡ 

00:32.070 --> 00:35.520
そして､ このクラスには､ 異なる機能が含まれるだけです｡ 

00:35.520 --> 00:41.730
init関数は､ 深層学習モデル自身を表す将来の深層学習オブジェクトに付随するすべての変数を作成し､

00:41.730 --> 00:48.300
初期化するもので､ 他にもいくつかの関数があります｡

00:48.300 --> 00:52.650
そのひとつは､ もちろん､ その都度､ 適切な行動を選択することでしょう｡ 

00:52.650 --> 00:59.730
また､ アップデート機能､ スコアを取得し､ 学習状況を把握するためのスコア機能も用意する予定です｡

00:59.730 --> 01:05.640
探査がうまくいって､ エクスプロージョンに移れるようなら､ モデルを保存する機能､

01:05.640 --> 01:12.180
つまり車の頭脳を保存する機能､ そして最終的にはロード機能を持たせることになります｡

01:12.180 --> 01:14.400
そこで､ いくつかの機能を作っています｡ 

01:14.400 --> 01:22.740
各チュートリアルで1つの関数を作っていきますが､ 今日はクラスを作るときのいつものようにinit関数から始めてみましょう｡

01:22.740 --> 01:33.270
しかし､ 最初にクラスを紹介することを忘れないでください｡ D､ Q､ Nはdeep

01:33.270 --> 01:38.700
Q networkと呼びます｡

01:39.300 --> 01:47.790
では､ このdefの中にダブルアンダースコアを入れて､ またダブルアンダースコアを入れて､ 括弧をつけましょう｡ 

01:47.880 --> 01:53.400
そこで､ このinit関数でご理解いただいたように､ オブジェクトに付属する変数を導入していきます｡

01:53.400 --> 01:59.190
これから数行が単独で始まり､ 基本的にディープQネットワークを実装するために必要なすべての変数を作成し､

01:59.190 --> 02:03.270
初期化します｡

02:03.270 --> 02:09.150
例えば､ ディープニューラルネットワークが必要なので､ ネットワークのオブジェクトを作成し､

02:09.150 --> 02:12.150
次にメモリが必要です｡

02:12.150 --> 02:14.490
メモリ用に別の変数を作成することにします｡ 

02:14.490 --> 02:17.610
そこで､ そのメモリに別の変数selfを用意します｡ 

02:17.610 --> 02:20.280
しかし､ そうなると､ 私たちが作らなければならないのは､ それだけではありません｡ 

02:20.280 --> 02:24.660
最後の状態､ 最後のセクション､ 最後の報酬のためのいくつかの変数｡ 

02:24.690 --> 02:30.150
それはもちろん､ ディープラーニングのアルゴリズムに見られるような変数のことですね｡ 

02:30.630 --> 02:31.710
それから､ 他には？

02:31.710 --> 02:44.190
さらに､ AIがミスをしたときに､ そのミスにどれだけ貢献するかに応じて重みを更新する確率的勾配降下法を実行するオプティマイザーが必要になりますね｡

02:44.190 --> 02:50.220
そして､ 基本的にはこれで初期化するための変数ができたと思います｡ 

02:50.220 --> 02:54.270
しかし､ このinit関数では､ いくつかの引数を入力することになります｡ 

02:54.270 --> 02:59.910
まず､ いつものようにself､ これは我々のオブジェクトを参照する引数である｡ 

02:59.940 --> 03:05.130
そして､ ご存知の通り､ ネットワーク・クラスのオブジェクトを作成することになります｡ 

03:05.130 --> 03:12.000
さて､ ネットワーククラスは､ init関数の引数として､ input､ size､ end actionを取ります｡ 

03:12.000 --> 03:13.560
まあ､ それはこちらも同じなんですけどね｡ 

03:13.560 --> 03:19.860
ネットワーククラスのオブジェクトを作成するときに､ NBアクションの引数で入力サイズの引数を選択する必要があります｡

03:19.890 --> 03:22.290
ですから､ コピーすればいいのです｡ 

03:23.740 --> 03:24.400
と｡ 

03:25.450 --> 03:26.380
ここで向き合う｡ 

03:26.500 --> 03:27.470
そして､ ここからが本番です｡ 

03:27.490 --> 03:32.950
つまり､ これらの引数は､ 今度は別のクラスのいくつかの引数にもなるのです｡ 

03:32.950 --> 03:39.130
現在のクラスの将来のオブジェクトを作るときはいつでも､ 将来の深層学習モデルで､

03:39.130 --> 03:44.800
入力サイズを指定する必要があります｡ これは､ 状態をエンコードするベクトルの次元数､

03:44.800 --> 03:52.890
入力状態､ アクション数､ つまり車が取りうるアクションの数です｡

03:52.900 --> 03:57.610
だから､ これらは左へ行くか､ まっすぐ行くか､ 右へ行くかと念を押しているんです｡ 

03:58.030 --> 03:59.050
よし､ 完璧だ｡ 

03:59.050 --> 04:07.090
それから､ トランジションの記憶を得るためのメモリオブジェクトを作成するために､ リプレイメモリクラスのオブジェクトを作成することになりますね｡

04:07.240 --> 04:13.390
init関数の中で､ 容量の引数がありますが､ これは一度だけ､ 実際にはメモリを作成するときに使うだけで､

04:13.390 --> 04:19.780
その後はどこにも使わないので､ まあ､ 容量の引数を指定する必要はないでしょう｡

04:19.780 --> 04:25.330
このようにすることもできますが､ ここではメモリに持たせたい遷移の数を直接入力することにします｡ 

04:26.020 --> 04:32.230
しかし､ そうなると必要な引数は1つ少なくなり､ 深層学習モデルのガンマパラメータになります｡ 

04:32.260 --> 04:36.110
このガンマパラメータは遅延係数であることを忘れないでください｡ 

04:36.130 --> 04:38.020
それが方程式のパラメータです｡ 

04:38.020 --> 04:42.830
それゆえ､ この後何度か使うことになるので､ ここに書いておきます｡ 

04:42.850 --> 04:44.770
では､ ここに書いておきましょう｡ 

04:44.800 --> 04:46.690
ガンマと呼ぶことにする｡ 

04:46.960 --> 04:53.520
これが引数の名前です｡ これで､ このinit関数に必要なすべての引数が揃いました｡

04:53.530 --> 04:59.980
つまり､ 深層学習モデルを作成するときはいつでも､ 現在のクラスの新しいオブジェクトを作成するときはいつでも､

04:59.980 --> 05:01.270
ということです｡

05:01.270 --> 05:10.330
さて､ 引数として入力サイズ､ アクション数､ ガンマパラメータを指定する必要がありますが､ それらの実数値は近日中に入力する予定です｡

05:11.020 --> 05:11.410
わかりました｡ 

05:11.410 --> 05:13.810
それでは､ init関数の中に入ってみましょう｡ 

05:14.050 --> 05:14.320
なるほど｡ 

05:14.320 --> 05:16.330
だから今､ 基本的にこれは簡単なことなんだ｡ 

05:16.330 --> 05:20.920
これから初期化､ 必要な変数をすべて作成するところです｡ 

05:20.920 --> 05:22.710
というわけで､ まずは1つ目から｡ 

05:22.720 --> 05:26.010
まず､ ガンマは実際に遅延係数から始めてみましょう｡ 

05:26.020 --> 05:31.680
これは変数なので､ オブジェクトにアタッチしたいのですが､ selfから始めます｡ 

05:31.690 --> 05:35.860
つまり､ ガンマは我々の現在のモデルの変数になるわけです｡ 

05:35.890 --> 05:42.760
つまり､ このクラスのオブジェクトを作成するときに入力される引数がガンマに等しいと自己判断してください｡ 

05:42.760 --> 05:46.680
そこでγと､ 2つ目の引数になります｡ 

05:46.690 --> 05:50.440
つまり､ 第2引数はリワードウィンドウになるわけです｡ 

05:50.590 --> 05:52.240
では､ このリワードウィンドウとは何でしょうか？

05:52.270 --> 06:00.910
これは､ 過去100回の報酬の平均値のスライディングウィンドウで､ AIのパフォーマンスの進化を評価するために使用されます｡

06:00.910 --> 06:06.190
この報酬ウィンドウに報酬の平均値を入れて､ 時間と共にスライドさせるんだ｡ 

06:06.190 --> 06:11.620
そして､ 私たちが観測したいのは､ 時間とともに増加する過去100回の報酬の平均値です｡ 

06:11.650 --> 06:18.070
そこで､ self dot reward, underscore windowで初期化してみましょう｡ 

06:18.430 --> 06:25.150
そして､ これは過去100件の報酬の平均をスライディングウィンドウにするものなので､

06:25.150 --> 06:31.660
空のリストとして初期化し､ 時間の経過とともに報酬の平均を追加することにします｡

06:32.770 --> 06:35.190
よし､ じゃあ､ もっと盛り上げよう｡ 

06:35.200 --> 06:37.420
それでは､ ニューラルネットワークを作成してみましょう｡ 

06:37.420 --> 06:43.600
そこで､ 基本的にそれがモデルの中心であることから､ セルフドットモデルと呼ぶことにしました｡ 

06:43.600 --> 06:44.980
だから､ モデルということにしているんです｡ 

06:45.770 --> 06:51.290
そしてこのモデルは､ ネットワーク・クラスのオブジェクトにほかならないだろう｡ 

06:51.290 --> 07:01.610
そして､ このようなオブジェクトを作成するために､ クラスnetwork､ 次に括弧を取り､ ここではネットワーククラスの引数を入力するだけです｡

07:01.610 --> 07:12.410
しかし､ これらの引数はinit関数の引数に入れたので､ ここでコピーしてネットワーク・クラスに貼り付けるだけでいいのです｡

07:12.980 --> 07:13.850
そして､ そこに行く｡ 

07:13.850 --> 07:19.280
このコードで､ 深層学習モデル用のニューラルネットワークを1つ作成します｡ 

07:20.020 --> 07:20.760
完璧です｡ 

07:20.770 --> 07:22.620
それなら､ 思い出を作ろう｡ 

07:22.630 --> 07:28.930
そこで再び､ self dot memoryと呼ぶ新しい変数を作成します｡ 

07:29.710 --> 07:34.090
これもリプレイメモリークラスのオブジェクトになります｡ 

07:34.090 --> 07:40.210
では､ クラスの名前をコピーして､ ここにペーストしてみましょう｡ 

07:40.210 --> 07:49.660
そして､ いくつかの括弧の中に､ 容量を入力する必要があります｡ 容量とは､ init関数の引数であり､ ここで入力する必要がある唯一の引数だからです｡

07:49.990 --> 07:51.910
では､ どのような容量を選べばいいのでしょうか｡ 

07:51.910 --> 07:59.320
それは､ 遷移の数､ イベントの数､ 状態の少なさ､ 新しい状態､ 行動の少なさ､ 報酬の少なさに対応することを覚えておいてください｡

07:59.620 --> 08:08.710
前のチュートリアルで述べたように､ 10万個の遷移をメモリに取り込み､ このメモリからサンプリングして少数のランダムな遷移を取得し､

08:08.710 --> 08:17.350
それを基にモデルが学習します｡

08:18.080 --> 08:18.500
なるほど｡ 

08:18.590 --> 08:20.170
だから､ 今､ 私たちは記憶しているのです｡ 

08:20.180 --> 08:20.960
完璧です｡ 

08:20.990 --> 08:23.090
では､ オプティマイザーを手に入れましょう｡ 

08:23.180 --> 08:28.700
そこで､ 再びselfで､ optimizerと呼ぶ新しい変数を作成します｡ 

08:29.480 --> 08:35.200
だから､ オプティマイザーは､ 私たちの将来のGQのオブジェクトの別の変数なので､ その自己オプティマイザー｡ 

08:35.210 --> 08:46.940
さて､ 上に戻ってみると､ 確率的勾配降下を実行するためのすべてのツールを含むtorchのモジュールであるOptimをインポートしていることがわかります｡

08:46.940 --> 08:54.200
このモジュールにはもちろんいくつかのオプティマイザが含まれていて､ optimというショートカットをつけています｡

08:54.200 --> 09:02.990
そこで､ これから行うのは､ Optimというモデルを取り出し､ このモジュールからオプティマイザの一つを取り出すということです｡

09:02.990 --> 09:05.510
というわけで､ ご覧の通り､ ここにずらりと並んでいます｡ 

09:05.630 --> 09:07.280
優秀なものが多い｡ 

09:07.280 --> 09:10.400
例えば､ アームスプロップは優れたオプティマイザーです｡ 

09:10.430 --> 09:15.860
それは例えば､ 通常のニューラルネットワークや教師なしディープラーニングに強く推奨されるものです｡ 

09:15.980 --> 09:22.040
しかし､ もう一つ優れていて､ 私たちが選ぶのは､ アトムオプティマイザです｡ 

09:22.310 --> 09:26.330
これがあれば､ いい自動運転車ができあがるということですね｡ 

09:26.330 --> 09:29.120
でもまた､ 他のものを試してみるのも全然OKです｡ 

09:29.120 --> 09:32.600
アームスプロップも試せますが､ 今回のモデルではアトムを選択します｡ 

09:32.600 --> 09:37.100
エンターキーを押していますが､ 実はここに大文字のAがあることにお気づきでしょうか｡ 

09:37.100 --> 09:40.340
それは､ atomクラスのオブジェクトを作成しているからです｡ 

09:40.340 --> 09:44.780
これはクラスですが､ オブジェクトはアトムオプティマイザそのものになります｡ 

09:44.780 --> 09:47.930
しかし､ これはクラスなので､ いくつかの引数を入力する必要があります｡ 

09:47.930 --> 09:55.130
アトムクラスの引数と引数は､ アトムオプティマイザーをカスタマイズできるすべてのパラメータです｡

09:55.130 --> 10:00.230
例えば､ 学習率や減衰率などのパラメータが典型的ですね｡ 

10:00.230 --> 10:05.510
そして､ モデルのすべてのパラメータを取る他に､ 学習率を指定する｡ 

10:05.720 --> 10:12.650
そこで､ 私たちのモデルのパラメータといえば､ セルフドットモデルで得ることができます｡ 

10:12.650 --> 10:17.330
これが､ 私たちが作ったモデルです｡ ネットワークの授業で作った独習モデルです｡ 

10:17.330 --> 10:18.800
だから独学モデル｡ 

10:18.800 --> 10:27.770
そして､ モデルのパラメータを評価するために､ もう1つのドットと､ いくつかの括弧を付けてパラメータを非常に簡単に追加します｡

10:27.980 --> 10:34.880
つまり､ アトムオプティマイザーと､ ここで作成したニューラルネットワークを接続するだけです｡ 

10:35.720 --> 10:42.130
そして､ 先ほど述べたように､ 学習速度を追加します｡ この引数はl

10:42.140 --> 10:49.130
rで､ 学習が速くなりすぎないような値に設定します｡

10:49.160 --> 10:53.630
学習率を大きくしすぎると､ AIがちゃんと学習しないんです｡ 

10:53.630 --> 10:58.730
AIに探索の時間を与え､ 失敗から学ばせたいのです｡ 

10:58.730 --> 11:04.100
例えば､ 砂の上に乗ったり､ 壁に近づきすぎたりといったミスをしたとき､

11:04.100 --> 11:08.690
私たちはAIに学習させる時間を与えたいと思っています｡

11:08.690 --> 11:11.930
ニューラルネットワークが正しく更新されるのを待ちたい｡ 

11:11.930 --> 11:20.480
それで､ いくつか試してみて行き着いた学習率の良い値が「0」です｡  01.

11:21.050 --> 11:21.410
わかりました｡ 

11:21.410 --> 11:24.500
そして､ これだけで､ オプティマイザーを作ることができるのです｡ 

11:24.500 --> 11:28.130
つまり､ 基本的にはatomクラスのオブジェクトを作成していることになります｡ 

11:28.400 --> 11:28.910
素晴らしい｡ 

11:28.910 --> 11:35.750
そして､ 最後に必要な3つの変数は､ 遷移イベントを構成する変数である｡ 

11:35.930 --> 11:39.920
それが最後の州であり､ 最後のセクションであり､ 最後の報酬なのですね｡ 

11:39.920 --> 11:44.690
このように､ 基本的にはこれから作成するもので､ あとは初期化するだけです｡ 

11:45.050 --> 11:46.820
では､ まず最終日の様子から｡ 

11:46.820 --> 11:55.910
最後の日付は self dot, last underscore state と呼ぶことにして､ どのように初期化するのか？

11:55.910 --> 12:04.670
さて､ 最後の状態は､ 5次元のベクトルであり､ 環境の1つの状態をコード化しているベクトルであることを思い出してください｡

12:04.670 --> 12:10.640
そして､ この5つの次元は､ 念のために言っておくと､ 左・直・右の3つのセンサーの信号と､

12:10.640 --> 12:14.540
向きとマイナスの方向である｡

12:14.990 --> 12:20.990
つまり､ これは直感的にはベクトルなのですが､ PyTorchではベクトル以上のものである必要があるのです｡ 

12:21.020 --> 12:23.600
実際にはトーチテンソルである必要があります｡ 

12:23.600 --> 12:33.350
しかし､ トーチテンソルであるだけでなく､ もう1つ､ バッチに対応する偽次元と呼ぶべき次元を持つ必要があるのです｡

12:33.350 --> 12:38.270
そして､ 最後の状態がニューラルネットワークの入力になるからだ｡ 

12:38.270 --> 12:44.180
しかし､ 一般的にニューラルネットワークを扱う場合､ TensorFlowキャリーにしてもPyTorchにしても､ まあ､

12:44.180 --> 12:47.990
入力ベクトルが単体で単純なベクトルになることはありえないわけです｡

12:47.990 --> 12:49.490
バッチリでないとダメなんです｡ 

12:49.610 --> 12:57.650
ネットワークは入力観測のバッチしか受け付けないので､ 入力状態ベクトルのためのテンソルを作成するだけでなく､

12:57.650 --> 13:04.430
バッチに対応するこの偽の次元を作成することにする｡

13:05.000 --> 13:09.530
では､ これをやってみましょう｡ まず､ トーチテンソルを初期化します｡ 

13:09.530 --> 13:12.230
そのためには､ これほどシンプルなものはないわけです｡ 

13:12.230 --> 13:27.650
torchライブラリ､ そしてdot､ そしてtensorクラスを使います｡ なぜなら､ ご想像の通り､ これはtensorオブジェクトであるtensorクラスの新しいオブジェクトを作成するためです｡

13:27.980 --> 13:29.020
そして､ このテンソルクラスでは

13:29.180 --> 13:34.380
テンソルのサイズを指定する引数を一つ入力する必要がある｡ 

13:34.400 --> 13:38.620
テンソルは1つの型を持つ配列のようなものだと考えていただければよい｡ 

13:38.630 --> 13:45.590
しかし､ 基本的に今これが表すのは､ もちろんこの入力状態であり､ これはベクトルとして見ることができます｡ 

13:45.980 --> 13:49.290
そして､ このテンソルが持つべき要素数を指定することです｡ 

13:49.310 --> 13:57.140
もちろん､ 入力サイズを使う必要がある｡ 入力サイズとは､ まさに入力状態ベクトルの次元数のことだからだ｡

13:57.350 --> 13:58.940
今はセンサーと言うべきでしょう｡ 

13:58.940 --> 14:05.420
そして､ 私たちが単純にテンソルクラスに入力する必要があるのは､ テンソルオブジェクトを作成することである｡ 

14:05.810 --> 14:07.160
まあ､ 入力サイズなんですけどね｡ 

14:07.310 --> 14:10.340
そして､ 後に入力サイズは5となる｡ 

14:11.190 --> 14:12.220
よし､ これでいいんだ｡ 

14:12.240 --> 14:13.520
それがまず第一に行われます｡ 

14:13.530 --> 14:16.920
当然のことながら､ テンソルを初期化しただけです｡ 

14:17.310 --> 14:19.920
でも､ その時､ 忘れてはいけないのが､ もうひとつのことです｡ 

14:19.920 --> 14:26.010
偽の次元を作成する必要があります｡ なぜなら､ これがネットワークの入力として期待されるものであり､

14:26.010 --> 14:31.980
この1つのイチジク次元を作成する必要があります｡

14:31.980 --> 14:37.650
バッチに対応する偽の次元は､ この最後の変数の最初の次元になりますよね｡ 

14:38.040 --> 14:42.960
そのためには､ dot thenとsqueezeを追加するだけです｡ 

14:44.000 --> 14:49.400
そして､ いくつかの括弧の中に､ この曖昧な次元のインデックスを入力する必要がある｡ 

14:49.400 --> 14:54.380
そして､ 今言ったように､ この偽物の次元は国家の最初の次元でなければならないのです｡ 

14:54.650 --> 15:03.140
Pythonのインデックスは0から始まるので､ この新しい次元が最初の次元になるように､ 0を入力する必要があります｡

15:03.290 --> 15:13.280
つまり､ バッチに対応する最初の次元と､ テンソルに対応する次元があり､ そこには入力状態の5つの要素が含まれることになる｡

15:13.280 --> 15:16.820
信号の向きは3つ､ マイナスの向きもあります｡ 

15:17.120 --> 15:22.640
そして､ 入力状態を適切に初期化し､ 完璧な状態にします｡ 

15:23.060 --> 15:25.460
そして､ あと2つの変数｡ 

15:25.460 --> 15:31.730
そして､ 次の変数が最後のアクションになるので､ それはとても簡単なことになります｡ 

15:31.970 --> 15:36.110
つまり､ 最後のアクションでオブジェクトのために新しい変数を作成していたわけです｡ 

15:36.230 --> 15:43.430
このセクションの最初のチュートリアルで､ アクションはゼロ1か2のどちらかになるとお話しました｡

15:43.430 --> 15:51.230
そして､ アクション2の回転ベクトルを使って､ これらのアクションのインデックスを回転の角度に変換するのですが､

15:51.230 --> 15:57.830
ゼロ20または-20を思い出してください｡

15:57.830 --> 16:00.800
実際にそれで記憶をリフレッシュすることができます｡ 

16:00.950 --> 16:02.930
まあ､ まさにここなんですけどね｡ 

16:02.930 --> 16:04.370
回転によるアクション｡ 

16:04.640 --> 16:08.990
アクションがゼロの場合は､ まあ､ ここでの最初のインデックスに対応することになります｡ 

16:08.990 --> 16:14.240
つまり､ ゼロ､ アクションが1の場合､ これはこのベクトルのインデックス､ 1に対応することになります｡ 

16:14.240 --> 16:15.380
だから20度｡ 

16:15.380 --> 16:18.950
そして､ アクションが2つなら､ -20度になる｡ 

16:18.950 --> 16:22.700
これが､ アクションを再生したときのクルマの回転角度になるんです｡ 

16:23.380 --> 16:24.070
わかりました｡ 

16:24.070 --> 16:31.600
したがって､ アクションはゼロ1か2のどちらかになるので､ まあ､ アクションはしたがって単純な数字になります｡

16:31.600 --> 16:35.370
というわけで､ 非常にシンプルに､ ゼロに初期化することができるのです｡ 

16:35.380 --> 16:38.140
ここではテンソルも何も作成する必要はない｡ 

16:38.140 --> 16:40.750
それをゼロで初期化すればよいのです｡ 

16:41.170 --> 16:44.410
そして最後に､ まあ､ これが最後のご褒美ですね｡ 

16:44.410 --> 16:48.190
だから､ セルフドット最後のご褒美｡ 

16:48.700 --> 16:49.660
これでよしとしよう｡ 

16:49.660 --> 16:56.230
そしてまた､ 報酬はフロート数で､ マイナス1からプラス1の間だと記憶しています｡ 

16:56.230 --> 16:57.670
だから､ またこの数字なんです｡ 

16:57.670 --> 17:02.830
そして､ アクションについては､ 0に初期化して､ これで完了です｡ 

17:02.830 --> 17:06.070
おめでとうございます！init機能の準備が整いました｡ 

17:06.070 --> 17:08.740
さて､ ここからはワクワクするような話です｡ 

17:08.740 --> 17:16.210
そして､ 私にとって最も重要なことは､ その都度､ その都度､ どの行動をとるかを決めることです｡

17:16.210 --> 17:23.110
T そして､ 次のチュートリアルでは､ まさにそれを実現するために､ Select Action Methodを作成します｡ 

17:23.230 --> 17:25.240
では､ 次のチュートリアルでこれをやってみましょう｡ 

17:25.240 --> 17:27.250
そしてそれまで､ iを楽しんでください｡