WEBVTT

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

00:02.730 --> 00:08.370
そこで次は､ そのカウントニューロンを機能させることで､ 私たちが望むものを得られるようにします｡ 

00:08.370 --> 00:14.040
つまり､ コンボリューションを適用した後のこの巨大なベクトルにおけるニューロンの数である｡ 

00:14.070 --> 00:19.260
それが今必要な唯一の欠落した情報であり､ 関数でそれを得ようとしているのです｡ 

00:19.410 --> 00:21.570
では､ この関数を作ってみましょう｡ 

00:21.570 --> 00:27.390
ここでは､ 非常にシンプルにカウント､ アンダースコア・ニューロンと呼ぶことにします｡ 

00:27.540 --> 00:29.550
そして､ このカウントは何でしょうか？

00:29.580 --> 00:32.070
ニューロン機能は､ 引数として取るつもりですか？

00:32.220 --> 00:38.340
まあ､ 物体そのものを取ることになるのですが､ その後､ 他のものを取ることになります｡ なぜなら､

00:38.340 --> 00:44.350
この平坦化層の出力ニューロンの数は､ 実際には1つのものにしか依存しないからです｡

00:44.370 --> 00:51.750
これは､ ニューラルネットワークの一番最初に入る､ オリジナルの入力画像の寸法に依存します｡

00:51.930 --> 00:57.930
つまり､ 今必要なのは､ 入力画像の寸法だけなのです｡

00:58.170 --> 01:03.540
そこで､ この入力画像の寸法を表す引数に名前をつけて､ image

01:03.540 --> 01:06.590
dimと呼ぶことにしよう｡

01:07.050 --> 01:07.620
わかりました｡ 

01:07.620 --> 01:16.500
そして､ 今言えることは､ doomから送られてくる入力画像の実際の寸法は､ 80×80になるということです｡

01:16.590 --> 01:25.970
元画像のサイズを80×80に縮小し､ これがニューラルネットワークに入る画像のフォーマットになります｡

01:25.980 --> 01:35.220
画像STEMは188になり､ 1は白黒画像､ つまり1チャンネルしかない画像を扱うことに対応します｡

01:35.220 --> 01:40.440
つまり､ イメージのそれらは､ 後でタプルの1､ 80､ 80と等しくなるわけです｡ 

01:41.160 --> 01:41.460
わかりました｡ 

01:41.460 --> 01:43.470
だから､ それだけが必要な議論なのです｡ 

01:43.470 --> 01:45.620
そして､ 今度はニューロンを数えてみましょう｡ 

01:45.630 --> 01:47.220
では､ どうすればいいのか？

01:47.250 --> 01:51.030
さて､ まず､ 実は今､ 入力ダメージがないんです｡ 

01:51.030 --> 01:53.910
取り込めるドゥーム画像がないんです｡ 

01:53.910 --> 01:55.220
それは後でやることにしています｡ 

01:55.230 --> 02:00.210
そこで､ まず最初に偽の画像を作成するのですが､ その画像は寸法が80です｡ 

02:00.210 --> 02:05.700
80では､ 偽のピクセルで偽の画像を作成することになりますが､ それでも最終的には欲しい数値が得られます｡

02:05.700 --> 02:13.050
この数値は寸法にのみ依存し､ 画像内のピクセルには依存しないからです｡

02:13.050 --> 02:18.120
そこで､ 手始めに偽の画像を作って､ 必要なニューロン数を計算してみましょう｡ 

02:18.300 --> 02:25.230
偽の画像を作るトリックは､ そう､ まずXと呼ぶことにします｡ そして､ torchのランダム関数であるrun関数を使っているので､

02:25.230 --> 02:36.810
この画像にランダムなピクセルを置くことになりますから rendを使います｡

02:36.930 --> 02:44.300
そして､ 内部には､ ご覧のように､ 188の画像の寸法を入力します｡ 

02:44.340 --> 02:50.130
しかし､ この画像をニューラルネットワークに入力するわけですが､ 覚えているように､ ニューラルネットワークは入力状態のバッチ､

02:50.130 --> 02:55.110
つまりここにある入力画像のバッチしか受け付けないのです｡

02:55.110 --> 03:00.420
このrun関数で直接できるように､ 偽の次元を作成するつもりです｡ 

03:00.420 --> 03:05.270
実際にはバッチに対応するものから始めて､ 入力画像の寸法に対応するApple

03:05.280 --> 03:10.860
188につければいいだけなんですけどね｡

03:10.860 --> 03:16.950
そして､ あなたが理解したように､ これらの寸法は､ そのテーブルを表すこのimage dim引数に含まれています

03:16.950 --> 03:26.640
188 だから､ 今､ 私たちはimage dimを追加する必要がありますが､ 寺院の要素を渡すために､ 今はimage themは関数の引数のリストとしてタプルであるので､

03:26.640 --> 03:36.260
ここに追加する必要があります image themの前に､ つまりテーブルの前に｡

03:36.330 --> 03:43.920
ストアは､ image dim タプルの要素を関数の引数のリストとして渡すことができるようにします｡

03:43.920 --> 03:49.380
そして､ ご覧のように､ まさにここに星と寸法が指定されているのです｡ 

03:49.740 --> 03:50.130
わかりました｡ 

03:50.130 --> 03:53.940
そうすると､ 偽のピクセルの画像が出来上がるわけです｡ 

03:54.000 --> 03:56.550
だから､ それはドゥーム画像とは関係ないでしょう｡ 

03:56.550 --> 04:00.000
しかし､ やはり最終的なニューロン数は確保できるだろう｡ 

04:00.300 --> 04:12.270
そして最後に､ この入力バッチベクトルをトーチ変数に変換することを忘れないでください｡

04:12.870 --> 04:13.320
わかりました｡ 

04:13.320 --> 04:20.070
つまり､ これは今､ トーチ変数に変換されたランダムピクセルの入力画像を表しているのです｡ 

04:20.070 --> 04:26.490
そして､ それが今度はニューラルネットワークに､ より具体的にはニューラルネットワークの畳み込み層に入ることになるのです｡

04:26.490 --> 04:33.990
なぜなら､ コンボリューションをかけた後のニューロン数だけが必要なので､ コンボリューション3までで済ませるからです｡

04:33.990 --> 04:39.390
3つ目の畳み込み層の直後で､ ここでは完全な接続には踏み込まないことにします｡ 

04:39.600 --> 04:44.970
そして､ 欲しいニューロン数は､ コンボリューション3とFC1の間だからです｡ 

04:45.360 --> 04:45.660
わかりました｡ 

04:45.660 --> 04:52.710
さて､ これで正しい寸法の入力画像が1枚できたので､ いよいよこの画像をニューラルネットワークに伝搬させて､

04:52.710 --> 04:55.980
平坦化層に到達させることにします｡

04:56.070 --> 05:01.650
そして､ 平坦化層のニューロンを取得し､ 欲しい情報を得るだけです｡

05:01.650 --> 05:04.710
それが､ この平坦化層のニューロン数である｡ 

05:04.710 --> 05:08.670
つまり､ 今やらなければならないことは､ フォワード関数でやっていることと全く同じなのです｡ 

05:08.670 --> 05:16.050
信号をニューラルネットワークに伝搬させる必要があるが､ 平坦化層に到達するまでは畳み込み層にしか伝搬しない｡

05:16.050 --> 05:17.130
では､ こうしてみましょう｡ 

05:17.130 --> 05:19.680
xを更新する予定です｡ 

05:19.680 --> 05:26.850
ここで､ xは入力画像であり､ 2番目のxでxはよく第1畳み込み層になります｡ 

05:27.030 --> 05:29.970
そして今､ 私たちがやらなければならないことは､ 3つのステップを踏むことです｡ 

05:29.970 --> 05:33.600
まず最初に､ 入力画像に畳み込みをかける｡ 

05:33.600 --> 05:38.370
次に第2段階として､ 得られた畳み込み画像に対して最大刈り込みを行う｡ 

05:38.370 --> 05:44.250
そして第3段階として､ このプールされた畳み込み画像のニューロンを活性化させるのです｡ 

05:44.250 --> 05:50.370
そして､ Xは､ これらのプールされた複雑な画像で構成される最初の畳み込み層になります｡ 

05:50.790 --> 05:56.760
それでは､ 最初のステップとして､ 最初のコンボリューション､ コンボリューション1を入力画像に適用してみましょう｡ 

05:56.760 --> 06:04.380
そこで､ 畳み込み1自己のドット畳み込み1を取るのである｡ 

06:04.380 --> 06:05.250
これでよしとしよう｡ 

06:05.280 --> 06:11.130
これを入力画像に適用すると､ これまでのところXで表現されている｡ 

06:11.250 --> 06:12.480
それが最初の一歩なんですね｡ 

06:12.480 --> 06:13.590
第一段階完了｡ 

06:13.590 --> 06:23.550
さて､ 2番目のステップですが､ コンボリューション1 Xで返されたコンボリューション画像にマックスプーリングを適用し､ マックスプーリングを適用することにします｡

06:23.550 --> 06:29.850
では､ 関数モジュールから関数を取り出します｡ Fをショートカットしてドットとし､

06:29.850 --> 06:38.250
関数max pool to Dを使って､ max pool to defineのカッコの中にself convolution

06:38.250 --> 06:40.410
one Xを入れます｡

06:41.660 --> 06:45.080
畳み込み画像に最大プーリングを適用しているからです｡ 

06:45.500 --> 06:53.020
しかし､ この最大プーリング関数は､ 最初にカーネルサイズという追加の引数を取ります｡ 

06:53.030 --> 07:00.650
つまり､ 繰り返しになりますが､ これは画像をスライドさせるウィンドウのサイズで､ 各スライドのピクセルの最大値を取ることになります｡

07:00.690 --> 07:09.530
直感の講義で見たように､ 特徴は配列のピクセルの高い値に関連付けられているので､ それでも特徴を検出することができます｡

07:09.530 --> 07:15.500
この最初の引数はカーネルサイズで､ 3つ取ることになります｡ 

07:15.500 --> 07:17.630
カーネルサイズとしては一般的な選択ですね｡ 

07:17.630 --> 07:27.170
そして､ 画像の中で何ピクセル滑るかというストライドを入力する必要があるのですが､ ここではストライドを2としています｡

07:27.320 --> 07:29.120
繰り返しになりますが､ これはよくある選択です｡ 

07:29.630 --> 07:30.500
そうそう､ そうなんです｡ 

07:30.500 --> 07:32.390
これで第2段階は終了です｡ 

07:32.390 --> 07:41.210
そして､ 3番目のステップに進みましょう｡ この最初の畳み込み層で､ このプールされ畳み込まれた画像のすべてのニューロンを活性化するのです｡

07:41.240 --> 07:45.920
そして､ これを再び行うために､ これらすべてに関数を適用することになります｡ 

07:45.920 --> 07:51.500
ここでまたFをとっていますが､ これは別の関数をとるためです｡ ご想像のとおり､

07:51.500 --> 07:58.430
活性化関数になりますが､ いつものように整流器の活性化関数になります｡

07:58.610 --> 08:02.120
そして､ もしかしたらその名前が「Réélu」だと覚えているかもしれませんね｡ 

08:02.570 --> 08:03.320
これでよしとしよう｡ 

08:03.320 --> 08:04.130
それです｡ 

08:04.130 --> 08:10.190
そして､ プールされた複雑な画像に価値を適用するわけです｡ 

08:10.190 --> 08:11.630
それがこれだけです｡ 

08:12.380 --> 08:12.860
わかりました｡ 

08:12.860 --> 08:14.180
そして､ それだけです｡ 

08:14.180 --> 08:15.200
3ステップ完了｡ 

08:15.200 --> 08:16.280
とても早かったですね｡ 

08:16.280 --> 08:22.880
つまり､ まず入力画像にコンボリューションを適用し､ 次にコンボリューションで得られたコンボリューション画像にマックスプーリングを適用する､

08:22.910 --> 08:28.640
という方法を覚えておいてください｡

08:28.640 --> 08:36.260
そして､ このプールされた畳み込み層すべてのニューロンを整流器活性化関数で活性化するのです｡

08:37.030 --> 08:37.980
とても完璧です｡ 

08:37.990 --> 08:45.990
最初の畳み込み層は､ 最大プーリングが適用され､ ニューロンが活性化されたものである｡

08:46.000 --> 08:52.390
そして､ 基本的には､ 最初の畳み込み層から次の畳み込み層へと信号を伝播させるということです｡

08:52.390 --> 08:56.260
そして､ 次といえば､ それこそ今､ 気をつけなければならないことがあります｡ 

08:56.290 --> 09:01.630
先ほど第1畳み込み層で行ったのと同じことを第2畳み込み層にも行い､ 第2畳み込み層のニューロンを活性化することで､

09:01.630 --> 09:09.610
再び信号をニューラルネットワークにさらに伝播させるのです｡

09:09.610 --> 09:12.820
しかし､ その前にこの畳み込みレイヤーを取得する必要があります｡ 

09:12.820 --> 09:16.330
そして､ xに対してコンボリューションを適用することになる｡ 

09:16.330 --> 09:21.610
これが最初の畳み込み層で､ これからXに畳み込みをかけ､ 2番目の畳み込み層を得る｡

09:21.610 --> 09:27.400
その後､ 最大限の引き込みを行い､ 最後にそのニューロンを活性化する｡

09:27.760 --> 09:28.930
では､ こうしてみましょう｡ 

09:28.930 --> 09:30.010
実はとても簡単なことなんです｡ 

09:30.010 --> 09:35.170
それをコピーして下に貼り付ければいいのです｡ 

09:35.200 --> 09:39.100
そして､ 当然ながら､ 畳み込み1を畳み込み2に置き換える必要がある｡ 

09:39.220 --> 09:40.360
そして､ そこに行く｡ 

09:40.360 --> 09:41.830
それが実はできているんです｡ 

09:41.830 --> 09:43.390
C とても簡単です｡ 

09:43.660 --> 09:52.450
この線で､ 2番目の畳み込み層から次の3番目の畳み込み層へと信号を伝播させます｡

09:52.450 --> 09:56.830
そして､ この3つ目の畳み込み層を作るには､ またそれを適用する必要があります｡ 

09:57.010 --> 10:03.460
そこで､ これをコピーして下に貼り付け､ コンボリューション2をコンボリューション3に置き換えているのです｡ 

10:03.700 --> 10:04.690
そして､ これで完成です｡ 

10:04.720 --> 10:06.130
とても実用的だと思いませんか？

10:06.130 --> 10:13.060
この素晴らしい構造のおかげで､ 3つの畳み込み層の信号と懐中電灯を伝搬させることができます｡ 

10:13.860 --> 10:14.220
わかりました｡ 

10:14.220 --> 10:15.190
とても完璧です｡ 

10:15.210 --> 10:25.890
さて､ 私たちの信号は第3畳み込み層まで伝搬し､ その後といえば､ 私たちが探しているもの､ 私たちが興味を持っているものにつながっています｡

10:25.890 --> 10:27.900
それが平坦化層です｡ 

10:28.290 --> 10:28.710
わかりました｡ 

10:28.710 --> 10:36.170
3つ目の畳み込みレイヤーができたので､ 最後のXは､ 平坦化レイヤーを作る時です｡

10:36.180 --> 10:38.250
そして､ それこそが､ これからやろうとしていることなのです｡ 

10:38.250 --> 10:42.990
この3番目の畳み込み層のすべてのピクセルを平らにするつもりです｡ 

10:42.990 --> 10:48.330
つまり､ 3番目の畳み込み層の全チャンネルの全ピクセルを取り出します｡ 

10:48.360 --> 10:51.840
巨大なベクターに次々と入れていくのです｡ 

10:51.840 --> 10:55.920
そしてもちろん､ この巨大なベクトルは平坦化レイヤー以外の何物でもないだろう｡ 

10:55.980 --> 11:01.890
そして同時に､ この平坦化層のニューロン数を求めるトリックを使うことになる｡ 

11:01.890 --> 11:03.510
それこそが､ 私たちが求めているものなのです｡ 

11:03.540 --> 11:05.520
それは､ 私たちが失っているニューロンの数です｡ 

11:05.520 --> 11:08.580
それゆえ､ 欲しいものを直接返そう｡ 

11:08.580 --> 11:16.200
そして今回のリターンでは､ 第3畳み込み層をフラット化すると同時に､ このフラット化した層のニューロン数を増やしています｡

11:16.350 --> 11:19.920
そこで､ 3番目の畳み込み層であるXを取り上げることにします｡ 

11:20.070 --> 11:31.830
この第3畳み込み層のすべてのチャンネルを取り出し､ サイズ関数を使ってすべてのチャンネルのピクセルを1つの巨大なベクトルに平坦化するのです｡

11:31.950 --> 11:35.850
というわけで､ PyTorchのチュートリアルに載っているトリックを紹介します｡ 

11:35.850 --> 11:42.090
さて､ まずXのデータを取ります｡ Xは特殊な構造で､ トーチ変数だからです｡ 

11:42.090 --> 11:44.100
かなり複雑な構造になっているんですね｡ 

11:44.100 --> 11:51.840
しかし､ まずはここにあるデータでアクセスし､ その中身を見る必要があるのです｡ 

11:51.840 --> 11:57.630
そこで､ このビュー機能を使って､ 探しているものにアクセスする必要があるのですが､

11:57.630 --> 12:01.800
これは引数として1とマイナス1が与えられます｡

12:02.010 --> 12:08.790
構造の中身を理解しなくても､ 「こうやってこの数の神経細胞ができるんだ」と理解すればいいんです｡

12:08.790 --> 12:15.360
そして､ 最後にサイズ､ そして括弧を追加し､ その中に1つを入力する必要があります｡ 

12:15.600 --> 12:21.570
つまり､ ここでやっていることは､ 全チャンネルの全ピクセルを取り出して､

12:21.570 --> 12:26.610
この巨大なベクトルに次々と並べていくことです｡

12:26.940 --> 12:29.190
サイズ1は基本的にそうなっていますね｡ 

12:29.190 --> 12:33.480
そして､ これによって､ 求めているニューロン数を得ることができるのです｡ 

12:33.870 --> 12:34.260
わかりました｡ 

12:34.260 --> 12:36.270
だから今､ 私たちは欲しいものを手に入れることができるのです｡ 

12:36.270 --> 12:49.920
そして最後に､ この関数をドゥーム画像のフォーマットに適用したときに返される値､ つまり1×80×80でニューロン番号を置き換えることができます｡

12:49.920 --> 12:57.180
そこで､ 今度は､ 数ニューロンをカウントニューロンに置き換える必要があります｡ 

12:57.790 --> 13:05.830
ズーム画像のフォーマットに適用する関数で, タプルのものとなる｡ 

13:06.840 --> 13:08.820
80と80です｡ 

13:09.240 --> 13:10.340
そして､ そこに行く｡ 

13:10.350 --> 13:17.040
そしてもちろん､ count neuronは実際にはCNNクラスのメソッドであるから､ selfを忘れてはならない｡ 

13:17.040 --> 13:20.700
そこで､ selfを追加することで､ 警告が消えるはずです｡ 

13:20.970 --> 13:22.020
そして､ そこに行く｡ 

13:22.290 --> 13:23.720
今はすべてが順調です｡ 

13:23.730 --> 13:27.900
何も欠けることなく､ ニューラルネットワークのアーキテクチャを得ることができるのです｡ 

13:27.900 --> 13:29.060
そして､ このカウントがあります｡ 

13:29.070 --> 13:36.120
ニューロンは､ 他のアーキテクチャを試したいときに､ 手動でこの数のニューロンを数えたくないという場合に役立つ機能です｡

13:36.150 --> 13:42.000
この機能を使い､ 画像のフォーマットに適用するだけで､ 欲しいものが直接手に入るのです｡

13:42.000 --> 13:47.730
それは､ 何もしなくても､ どんなアーキテクチャであっても､ フラッディング層のニューロンの数である｡

13:48.240 --> 13:49.350
だから､ とてもクールなんです｡ 

13:49.350 --> 13:55.950
そして今､ 私たちが作っているこの脳の最初の大きな重要なステップを終えました｡ 

13:55.950 --> 14:02.340
そして､ 最後にもう一つ､ メインの前進関数となる関数を作ることになります｡

14:02.340 --> 14:09.720
そこで､ 脳の始まり､ つまりAIの目から出力層まで信号を伝播させることにします｡

14:09.720 --> 14:12.060
それは､ 2回目のフル接続の後です｡ 

14:12.180 --> 14:14.100
そこで､ 次のチュートリアルでそれを行うことにします｡ 

14:14.100 --> 14:15.870
そしてそれまで､ iを楽しんでください｡