WEBVTT

00:00.150 --> 00:02.370
こんにちは､ このPythonチュートリアルへようこそ｡ 

00:02.400 --> 00:06.150
さて､ このinit関数の5つの変数を定義する必要があります｡ 

00:06.150 --> 00:09.420
それが､ 3つのコンボリューションと2つのフル・コネクションです｡ 

00:09.510 --> 00:11.040
では､ まず1つ目から｡ 

00:11.070 --> 00:15.960
コンボリューションは､ 入力画像にコンボリューションを適用するものである｡ 

00:15.960 --> 00:17.970
それが原画なんですね｡ 

00:17.970 --> 00:22.580
そして､ このコンボリューションを作ることで､ すべてがとてもシンプルになることがおわかりいただけると思います｡ 

00:22.590 --> 00:29.010
さて､ 私たちがしなければならないことは､ 実際にある特定のクラスのオブジェクトを作ることです｡ このクラスはRNから取られ､

00:29.010 --> 00:32.400
そしてクラスはできます｡

00:33.000 --> 00:34.260
DHに｡ 

00:34.380 --> 00:34.830
DHに｡ 

00:34.830 --> 00:37.260
なぜなら､ 2つのDH画像を扱っているからです｡ 

00:37.620 --> 00:40.670
そして今度は､ ご覧のように､ いくつかの引数を入力する必要があります｡ 

00:40.680 --> 00:45.450
1つ目はチャンネルに入れましょう｡ 

00:45.870 --> 00:48.810
2本目はチャンネルを外しました｡ 

00:49.200 --> 00:56.910
3つ目はカーネルサイズ､ 残りは破壊してダイレーション群とバイアスを水増しする｡ 

00:56.910 --> 00:59.040
そして､ これら全てにデフォルト値を設けています｡ 

00:59.040 --> 01:00.450
だから､ 入力はしない｡ 

01:00.450 --> 01:02.220
初期値のままにしておきます｡ 

01:02.220 --> 01:07.560
しかし､ 重要なのは､ チャンネル､ オルトチャンネル､ コルサイズ､ この3つの引数です｡ 

01:07.560 --> 01:09.660
ということで､ 何に対応しているかわかりますか？

01:09.690 --> 01:17.670
簡単に言うと､ inチャンネルがコンボリューションの入力に､ altチャンネルがコンボリューションの出力に対応します｡

01:17.670 --> 01:19.850
では､ チャンネルでは､ どうなっているのでしょうか？

01:19.860 --> 01:24.330
まあ､ 簡単に言うと､ 画像のチャンネル数になりますね｡ 

01:24.330 --> 01:31.230
また､ 基本的にモンスターを認識するために色は必要ないので､ 実際には白黒の画像で作業することになります｡

01:31.260 --> 01:36.780
AIは白黒でもモンスターを認識する能力が全然あるので､ 色は必要ないんです｡ 

01:36.780 --> 01:41.550
形状で認識されるだけなので､ 1チャンネルで使用します｡ 

01:41.550 --> 01:46.650
つまり､ 1チャンネルは白黒画像のとき､ 3チャンネルはカラー画像のときです｡ 

01:46.650 --> 01:51.720
したがって､ モノクロの画像を扱うので､ チャンネルは1に等しくなります｡

01:52.580 --> 01:54.010
それから､ 私たちのチャンネル｡ 

01:54.020 --> 02:02.750
つまり､ チャンネルは､ この畳み込み層の出力である畳み込み層に入れたい画像と同じになるわけです｡

02:02.750 --> 02:08.960
これは､ 元画像から検出したい特徴の数と同じです｡ 検出したい特徴ごとに1枚の画像を作成するので､

02:08.960 --> 02:14.870
基本的にどのように機能するかはご存知の通りです｡

02:14.870 --> 02:23.000
入力画像に1つの特徴検出器を適用して､ 入力画像中の特定の特徴を検出するため､ 出力画像の数が少なくなるのです｡

02:23.000 --> 02:25.970
ここには､ 検出したい特徴の数が書かれています｡ 

02:26.210 --> 02:29.990
そこで今度は､ いくつの特徴を検出するかが問題になります｡ 

02:30.020 --> 02:34.640
まあ､ 一般的には32個の特徴量検出器から始めるのが普通でしょう｡ 

02:34.850 --> 02:41.240
そして､ この最初の畳み込み層で32枚の画像を処理することになるのです｡ 

02:41.240 --> 02:45.710
つまり､ 入力は1枚の白黒画像､ 実画像なのです｡ 

02:45.710 --> 02:51.200
そして､ 第1畳み込み層の出力は､ 32枚の処理済み画像である｡ 

02:51.200 --> 02:59.510
処理とは､ もちろん､ 入力画像に畳み込みをかけ､ 検出された特徴を持つ32枚の新しい画像を得ることです｡

02:59.960 --> 03:09.350
そして､ カーネルサイズを指定する必要がある｡ これは､ 元画像を貫く正方形の寸法にほかならない｡

03:09.350 --> 03:20.720
そして､ 一般的には2×2､ 3×3､ 5×5のいずれかを使用しますが､ 最初の1つは5×5の特徴量検出器を使用することにします｡

03:20.840 --> 03:24.410
それが､ 5×5次元になる特徴検出器です｡ 

03:24.560 --> 03:28.910
そして､ 次の畳み込み層のために､ このカーネルのサイズを小さくするのです｡ 

03:29.090 --> 03:32.150
といえば､ まさにこれからです｡ 

03:32.150 --> 03:37.490
これをコピーして2つ目のコンボリューションを定義することになる｡ 

03:37.790 --> 03:40.820
それゆえ､ 今ここでそれを基本としています｡ 

03:40.820 --> 03:42.080
とても面白くて､ とても簡単です｡ 

03:42.080 --> 03:43.280
ドミノ倒しのようなものです｡ 

03:43.310 --> 03:49.700
第二畳み込み層の入力チャンネルは､ 第一畳み込み層の出力チャンネルである｡

03:49.700 --> 03:55.250
つまり､ ここの出力数32は､ ここの入力数32と同じ数なのです｡ 

03:55.250 --> 04:01.160
そして､ この2回目の畳み込みの入力畳み込み層に32枚の画像を入れているからです｡ 

04:01.160 --> 04:10.280
そして､ この第2畳み込み層に第2畳み込みを適用して､ 第3畳み込み層を返す｡

04:10.280 --> 04:15.860
で､ 今度は､ 同じように新しい画像をいくつ作るかということですが､ 32枚の画像を新たに作りましょう｡ 

04:15.860 --> 04:19.760
32は､ 実は畳み込みニューラルネットワークでは非常によく使われる数字です｡ 

04:19.760 --> 04:23.630
アーキテクチャを見ると､ 32が多く見受けられます｡ 

04:23.780 --> 04:30.530
そして､ カーネル側では､ カーネルサイズ､ つまり､ 特徴検出器の寸法を小さくする必要があります｡

04:30.530 --> 04:37.400
そして､ 今度は5つの目から4つの目､ あるいは3つの目になり､ さらに小さくなっていくわけです｡ 

04:37.700 --> 04:38.090
わかりました｡ 

04:38.090 --> 04:40.520
これで2回目の畳み込みは完了です｡ 

04:40.580 --> 04:48.350
入力として､ 32枚の処理画像を受け取り､ それぞれが元の入力画像の最初の特徴を検出する｡

04:48.350 --> 04:54.650
そして､ この特徴検出器の小型化により､ 32枚の画像を新たに作成することができます｡ 

04:54.890 --> 04:57.140
そして､ 今度はこれをさらに推し進めましょう｡ 

04:57.140 --> 05:05.120
そこで､ これをコピーしてここに貼り付け､ 3つ目のコンボリューションを作成して､ いくつかの特徴を検出することにします｡ 

05:05.210 --> 05:07.940
これで､ 入力チャンネルは同じになりました｡ 

05:07.940 --> 05:17.570
ここで､ 畳み込み接続の左側にある入力画像の数と､ その前の畳み込み接続の右側にあった処理画像の数である｡

05:17.580 --> 05:18.620
それが32歳なんですね｡ 

05:18.620 --> 05:19.970
だから､ 私たちは32をここに置いているのです｡ 

05:19.970 --> 05:20.900
それは完璧だ｡ 

05:20.900 --> 05:24.950
そして今度は､ やはり新しい画像を何枚検出するかということです｡ 

05:25.040 --> 05:30.980
64枚の出力､ 処理された画像に対して､ 今64枚をそこに取り込もうとしているのです｡ 

05:30.980 --> 05:36.170
もちろん､ 今度はカーネルサイズを小さくして､ 2つ取るんです｡ 

05:36.560 --> 05:45.620
これは畳み込み層の非常に古典的なアーキテクチャで､ 画像内の特徴を高度に検出するのに非常に効率的です｡

05:46.070 --> 05:46.550
わかりました｡ 

05:46.550 --> 05:57.350
3つの畳み込み層ができたので､ 3つの畳み込み接続のおかげで､ 今度は私が思い出させた2つの完全な接続を得る時が来ました｡

05:57.350 --> 06:04.430
64回をすべて平らにして得たこの巨大なベクトルを､ 32回×32回にする｡ 

06:04.430 --> 06:07.910
繰り返しになりますが､ これらの畳み掛けから得たイメージです｡ 

06:07.910 --> 06:16.580
そこで､ これらの画像のすべてのピクセルを平坦化し､ 新しい完全連結ニューラルネットワークの入力となる1つの巨大なベクトルを作成したのです｡

06:16.580 --> 06:21.800
そこで､ まずこの巨大なベクトルと隠れ層の間を完全に接続し､ 次に隠れ層と､

06:21.800 --> 06:31.580
それぞれが可能な行動のq値に対応する出力ニューロンからなる出力層の間を完全に接続する必要があるのです｡

06:31.700 --> 06:33.830
そこで､ この2つを完全に結びつけてしまおうというわけです｡ 

06:33.830 --> 06:35.060
その方法を知っているんですね｡ 

06:35.060 --> 06:37.400
それこそ､ 自動運転車のためにやったようなものです｡ 

06:37.400 --> 06:38.720
では､ もう1度やってみましょう｡ 

06:38.720 --> 06:48.830
まず､ RNモジュール､ そしてリニアクラスです｡

06:49.040 --> 06:52.100
そして､ （ ）内は､ まあ､ 同じ最初なんですけどね｡ 

06:52.240 --> 06:58.210
入力特徴量､ つまりその数を入力し､ 次に出力特徴量を入力する｡ 

06:58.630 --> 07:03.060
それで､ 最初のフル接続のための入力機能､ それは何になるのでしょうか？

07:03.070 --> 07:09.610
これは､ 3つの畳み込み処理後の画像をすべて平坦化した後に得られるこの巨大なベクトルと､

07:09.610 --> 07:13.420
存在するピクセル数に等しくなるんだ｡

07:13.540 --> 07:14.970
それで､ この数字は何なのでしょうか？

07:14.980 --> 07:17.170
実は､ ここにトリックがあるんです｡ 

07:17.220 --> 07:19.390
この数字､ 実は難しいんです｡ 

07:19.420 --> 07:22.690
実際には､ その数値を計算するための関数を作る必要があります｡ 

07:22.690 --> 07:25.510
この数字を出すための変数がないんです｡ 

07:25.510 --> 07:26.680
計算する必要があるのです｡ 

07:26.680 --> 07:33.910
それゆえ､ これから何をするか､ 今､ 私たちが持たなければならないプログラミングの心構えを理解することが非常に重要です｡

07:33.910 --> 07:40.900
この障害を克服するためには､ 今､ 何を考えなければならないかというマインドセットに持ち込もうとしているのです｡

07:40.900 --> 07:46.450
というのも､ 最初に､ 「あれ､ フラット化したベクトルにこの数のニューロンがないんだけど､ どうしたらいい？

07:46.450 --> 07:47.500
抜け出せないでいる｡ 

07:47.500 --> 07:56.140
いやいや､ 実は今できることは､ このニューロン数を表す名前をここに入力するだけなんです｡

07:56.140 --> 07:58.180
だから､ ニューロンの数ということにしています｡ 

07:58.180 --> 07:59.320
ニューロンの数

07:59.320 --> 08:07.030
そして､ このニューロン数という変数に､ 探しているピクセル数を返す関数を作るだけです｡

08:07.120 --> 08:08.800
だから､ 全然できるんですよ｡ 

08:08.800 --> 08:10.540
この変数を完全に入れることができます｡ 

08:10.540 --> 08:15.970
まあ､ もちろんまだ存在しないので警告は出ますが､ その後に関数で作るので､

08:15.970 --> 08:20.920
関数が後から来ても全然OKです｡

08:20.920 --> 08:25.780
だから､ そういう障害が出たときに､ 典型的なプログラミングの考え方をしなければならないのです｡ 

08:25.780 --> 08:28.840
まあ､ 足りないものを関数で作ればいいんだけどね｡ 

08:29.560 --> 08:29.980
わかりました｡ 

08:29.980 --> 08:37.720
そして､ アウトフィーチャーとアウトフィーチャー､ これは隠れ層のニューロンの数で､ 今回はあなた次第ということです｡

08:37.720 --> 08:40.960
それは､ 作りたいニューラルネットワークのアーキテクチャに依存します｡ 

08:40.960 --> 08:44.050
そうすると､ 良い数字から小さい数字へと順番に変わっていきます｡ 

08:44.050 --> 08:46.900
ですから､ 例えば40ニューロンでもいいかもしれません｡ 

08:46.900 --> 08:48.610
増やすようにすればいいのです｡ 

08:48.610 --> 08:51.100
トレーニングのスピードが遅くないのであれば､ 増やしてみるのもよいでしょう｡ 

08:51.100 --> 08:53.560
そうすれば､ 予測も改善されるかもしれません｡ 

08:53.560 --> 08:54.760
でも､ まずは40から｡ 

08:54.760 --> 08:56.530
その後に増やしていくかもしれませんね｡ 

08:56.950 --> 08:57.280
わかりました｡ 

08:57.280 --> 08:59.800
というわけで､ 最初のフル接続はこれで終了です｡ 

08:59.800 --> 09:05.290
そして､ このページを下にコピーして､ 2回目の完全接続を行います｡ 

09:05.290 --> 09:09.040
それが､ 隠れ層と出力層の接続です｡ 

09:09.040 --> 09:15.610
そして､ この内側の特徴が前のレイヤーの外側の特徴になり､ それが40になるわけです｡ 

09:15.610 --> 09:17.830
そこで､ ここに40を入れた｡ 

09:18.010 --> 09:27.070
もちろん､ 隠れ層のニューロンの数は､ ニューラルネットワークの出力ニューロンの数と同じになります｡

09:27.070 --> 09:32.950
そして､ 各出力ニューロンが1つのキー値に対応し､ 1つのキー値が1つのアクションに対応するので､ まあ､

09:32.950 --> 09:36.730
ここでの出力ニューロンの数は､ もちろん､ アクションの数である｡

09:36.730 --> 09:39.820
そして､ そのための変数が1つあり､ それがナンバーアクションです｡ 

09:39.820 --> 09:42.970
そのため､ ここでは数字を入力しています｡ 

09:43.880 --> 09:44.750
行動する｡ 

09:44.840 --> 09:45.950
そして､ そこに行く｡ 

09:45.980 --> 09:47.160
おめでとうございます｡ 

09:47.180 --> 09:50.540
私たちはニューラルネットワークのアーキテクチャを定義しました｡ 

09:50.750 --> 09:55.880
私たちのニューラルネットワークは､ 3つの畳み込み層と1つの隠れ層で構成されています｡ 

09:55.910 --> 09:59.030
全部､ 大きなCNNとこれとで｡ 

09:59.030 --> 10:04.490
CNNは､ AIが何をしなければならないか､ どこに行かなければならないか､ どこにシュートを打たなければならないかを知るために､

10:04.490 --> 10:06.380
ゲーム内の特徴を検出します｡

10:06.650 --> 10:08.180
そこで､ このステップに入ります｡ 

10:08.180 --> 10:10.430
それが､ 最初に行われる非常に重要なステップです｡ 

10:10.460 --> 10:16.820
さて､ 次のステップに進みますが､ それはもちろん､ このまだ足りないニューロンの数を求めることです｡

10:16.820 --> 10:18.710
実は､ そのためにここで警告を発しているのです｡ 

10:18.710 --> 10:21.720
ニューロン数未定義名ですが､ 心配ありません｡ 

10:21.740 --> 10:26.720
では､ この巨大なベクトルに含まれるニューロンの数を返す関数を作り､ その数をnumber

10:26.720 --> 10:30.030
neuronsと呼ぶ変数に入れることにしましょう｡

10:30.050 --> 10:31.940
では､ 次のチュートリアルでこれをやってみましょう｡ 

10:31.940 --> 10:33.020
それが､ 私たちの次のステップです｡ 

10:33.020 --> 10:34.280
そしてそれまで､ お楽しみに｡ 

10:34.280 --> 10:34.640
I.
