WEBVTT

00:00.360 --> 00:02.490
こんにちは､ このPythonチュートリアルへようこそ｡ 

00:02.520 --> 00:07.530
これから､ 入力映像の最初から出力まで､ 脳全体に信号を順伝播させる順関数を作りますが､

00:07.530 --> 00:17.920
その中には､ 俳優のキュー値と､ 評論家のV関数がとる値であるV値が含まれます｡

00:17.940 --> 00:23.720
だから､ 『Doom』でやったこととよく似ているのですが､ 今回は何かが変わるんです｡ 

00:23.730 --> 00:29.040
これから大きく変わるのは､ 今は脳の中にATMがあるので､ 信号を伝播させるために､ みんながもっと何かしなければならないし､

00:29.040 --> 00:32.280
そのことに気をつけなければならないということです｡

00:32.580 --> 00:38.220
もうひとつは､ あまり重要ではありませんが､ 非線形活性化関数としてループ活性化関数を使うのではなく､

00:38.220 --> 00:48.770
より洗練された関数であるループを使うということです｡

00:48.780 --> 00:51.210
Pythonのドキュメントで確認することになります｡ 

00:51.630 --> 00:52.770
では､ こうしてみましょう｡ 

00:52.770 --> 00:54.180
この機能を作ってみましょう｡ 

00:54.180 --> 00:55.800
まずはデフから｡ 

00:55.890 --> 00:58.980
それが実は､ このアクティブクラスの最後の機能なんです｡ 

00:58.980 --> 01:02.400
そこで､ 前回同様､ 前倒しで呼び出すことにした｡ 

01:02.400 --> 01:09.930
そして､ この4番目の関数は､ オブジェクトと入力を使用するため､ オブジェクトを自己に取り込むことになります｡

01:09.930 --> 01:13.320
そのため､ これらの入力がどうなるかを理解することが重要です｡ 

01:13.350 --> 01:20.810
これは入力画像だけでなく､ これらの入力にはチームの隠れノードとセルノードも含まれる｡

01:20.850 --> 01:24.300
だからこそ､ 変わるものがあることを強調したかったのです｡ 

01:24.300 --> 01:30.720
さて､ 基本的には､ STMのセルノードの中の隠れノードを順関数で考えています｡

01:30.930 --> 01:41.440
そして､ これから行うことは､ この引数の2つの入力､ 前進関数の入力を分離することです｡ そして､ どのように分離するのでしょうか？

01:41.460 --> 01:46.050
さて､ 新しい変数を呼び出せば､ それが入力画像となります｡ 

01:46.050 --> 01:55.110
つまり､ 今回は入力画像をH, X, C xというタプルで分離しています｡ これは､ lsg mの隠れ状態とセルの状態のカップルなので､

01:55.110 --> 02:03.720
h xが隠れ状態､ c xがセルの状態です｡

02:04.440 --> 02:04.800
わかりました｡ 

02:04.800 --> 02:07.470
そしてそれは､ 入力とイコールになる｡ 

02:07.470 --> 02:09.030
それがここでの主張です｡ 

02:09.420 --> 02:15.000
そこで､ この分離を行うことで､ 脳全体に信号を伝播させることができるようになりました｡ 

02:15.000 --> 02:21.030
そのために､ コンボリューション､ LSHTM接続､ 線形接続､

02:21.030 --> 02:30.060
フル接続を使用して､ 最初の層から最後の層まで､ 異なる層を連続的に取得するつもりです｡

02:30.210 --> 02:31.650
では､ 今からやってみましょう｡ 

02:31.650 --> 02:33.470
今までと同じになるんです｡ 

02:33.480 --> 02:39.060
これからXと呼ぶ最初のレイヤーを得ます｡ この最初のレイヤーを得るためには､ 入力からこの最初のレイヤーに信号を伝播させる必要があります｡

02:39.060 --> 02:51.660
したがって､ 最初の畳み込みを使う必要があります｡ この最初の畳み込みが､ 入力画像から最初のレイヤーに信号を伝播させるからです｡

02:51.840 --> 02:58.020
これから行うのは､ これをコピーして､ 最初のコンボリューションをここにペーストし､

02:58.020 --> 03:04.710
この最初のコンボリューションを入力画像に適用することで､ 正しい入力になります｡

03:04.710 --> 03:05.640
そして､ そこに行く｡ 

03:05.640 --> 03:09.480
それが､ 入力画像からの信号を第1層に伝搬させる｡ 

03:09.600 --> 03:20.040
しかし､ ここで思い出してほしいのは､ 画像内部の非線形関係を学習できるようにするためには､ 非線形活性化関数を用いて線形性を崩す必要があるということです｡

03:20.040 --> 03:27.990
そのために､ PyTorchのドキュメントで今から紹介するALU活性化関数を使うことにします｡

03:27.990 --> 03:29.940
でも､ その前に｡ 

03:29.940 --> 03:36.450
つまり､ 機能モジュールには短いクリップF､ ドット､ Aluがあり､

03:36.450 --> 03:50.730
これらをすべて括弧で囲みます｡ これは､ 入力に最初の畳み込みを適用して得た､ この第1層のニューロンを非線形に活性化したいからです｡

03:50.970 --> 03:55.050
では次に､ ALUとは何かを理解するために､ PyTorchのDougに会いに行ってみましょう｡ 

03:55.080 --> 04:02.130
ここにあるので､ pytorch dot org slash doug slash rn dot htmlにアクセスすることができます｡ 

04:02.130 --> 04:04.860
そして､ ノンリニアなアクティベーションを見つけなければならない｡ 

04:05.310 --> 04:10.470
非線形活性化関数では､ ルー､ これは私たちが知っている古典的なものです｡ 

04:10.470 --> 04:17.100
つまり､ 0とxの最大値だけで､ グラフは頭に入っていて､ 次にリリース6､ これがあるわけです｡

04:17.100 --> 04:19.260
だから､ もう少し洗練されたものを｡ 

04:19.260 --> 04:20.040
そして､ そこに行く｡ 

04:20.040 --> 04:21.060
ルーがあるんです｡ 

04:21.330 --> 04:26.400
そして､ お分かりのように､ ループは､ ループに追加要素を加えたものです｡ 

04:26.400 --> 04:29.130
つまり､ より洗練された価値観のようなものですね｡ 

04:29.130 --> 04:33.960
これは､ 異なる層のニューロンを非直線的に活性化させるために使用するものです｡ 

04:33.960 --> 04:39.030
ちなみに､ このループ活性化関数は指数線形ユニットと呼ばれているんだ｡ 

04:39.300 --> 04:40.170
そうそう､ そうなんです｡ 

04:40.170 --> 04:46.170
最初の畳み込み層にループを適用し､ これで物事は簡単に進むようになった｡ 

04:46.170 --> 04:52.230
次の4番目の信号の伝播に進みます｡ それは最初の畳み込み層から2番目の畳み込み層までで､

04:52.230 --> 04:58.980
ここではXと呼ぶことにします｡ 基本的にはXを更新するだけなので､ 現在xは最初の畳み込み層で､

04:58.980 --> 05:09.060
最初の畳み込み層から次の層に信号を伝播することによって､ xは次の畳み込み層となるのです｡

05:09.270 --> 05:15.120
そして､ 最初の畳み込み層から2番目の畳み込み層に信号を伝播させるには､ これをコピーしてここに貼り付け､

05:15.120 --> 05:20.310
conf 1をconf 2に置き換えるだけでよいのです｡

05:20.310 --> 05:25.920
そして今､ 当然ながら2回目の畳み込みは入力画像にではなく､ xに適用されます｡ 

05:25.920 --> 05:29.400
これが最初の畳み込み層で､ ちょうどここにあります｡ 

05:29.670 --> 05:30.630
よし､ 完璧だ｡ 

05:30.630 --> 05:37.950
さて､ 2番目の畳み込み層ができたので､ 今度は2番目の畳み込み層から3番目の畳み込み層に再び信号を伝播させましょう｡

05:37.950 --> 05:45.660
したがって､ これをそのままコピーして､ ここをベースにして､ 2を3に置き換えればいいわけです｡ 

05:45.810 --> 05:46.710
これでよしとしよう｡ 

05:46.710 --> 05:58.620
そして最後の1つは､ 3番目の畳み込み層から4番目の畳み込み層に信号を伝播させるためのものです｡

05:58.650 --> 05:59.460
これでよしとしよう｡ 

06:00.000 --> 06:01.560
では､ おさらいをしましょう｡ 

06:01.590 --> 06:03.240
まずはインプットから｡ 

06:03.240 --> 06:06.930
最初の畳み込みを適用して､ 最初の畳み込み層を得る｡ 

06:07.080 --> 06:12.720
そして､ 第一畳み込み層に第二畳み込みを適用して､ 第二畳み込み層を得る｡

06:12.720 --> 06:18.300
そして､ 2番目の畳み込み層に3番目の畳み込みを適用して､ 3番目の畳み込み層を得ます｡

06:18.300 --> 06:24.570
そして最後に第3畳み込み層に第4畳み込みをかけて第4畳み込み層を得ます｡

06:24.570 --> 06:29.700
このようにして､ AIの目全体に信号が伝搬されるのです｡

06:29.820 --> 06:30.600
そうそう､ そうなんです｡ 

06:30.600 --> 06:35.550
これで4回の畳み込みの後の出力信号ができ､ 何をすべきかがわかりました｡ 

06:35.550 --> 06:40.710
この出力信号全体を1次元のベクトルに展開する必要がある｡ 

06:40.710 --> 06:42.570
それが平らにするステップです｡ 

06:42.630 --> 06:45.060
そこで､ 再びXを更新することになりました｡ 

06:45.090 --> 06:48.690
Xはこのように平坦化された1次元のベクトルになります｡ 

06:49.050 --> 06:57.180
そして､ これを行うには､ それは我々がXを取る必要があるのと同じで､ ここまでは4番目の畳み込み層xのドットである｡

06:57.330 --> 07:03.720
そして､ Vueの機能を使って､ まずマイナス1を入力し､ 「欲しい」と言います｡ 

07:03.800 --> 07:05.240
1次元のベクトル｡ 

07:05.240 --> 07:10.940
そして､ 第二引数として､ このベクトルの要素数を入力する必要があるのですが､ これは､

07:10.940 --> 07:16.280
32回､ 3回3回と覚えておいてください､ したがって､ ここに32と入力します｡

07:17.060 --> 07:19.670
回×3回×3回

07:20.120 --> 07:20.650
これでよしとしよう｡ 

07:20.660 --> 07:24.290
これで､ 平坦化されたベクトルができ､ 平坦化のステップは終了です｡ 

07:24.530 --> 07:25.290
完璧です｡ 

07:25.310 --> 07:27.980
では､ 最後の仕上げをしましょう｡ 

07:27.980 --> 07:31.610
つまり､ ご理解いただいたように､ Lshtmは私たちをインプットしてくれるのです｡ 

07:31.610 --> 07:36.830
平坦化されたベクトル､ この1次元のベクトルは､ 3､ 2倍､ 3倍の3つの要素からなる｡ 

07:36.950 --> 07:40.250
だから､ もうLshtmの準備は万端､ 万全なのです｡ 

07:40.250 --> 07:49.820
Lshtmはこの平坦化されたベクトルを入力として受け取ることができるようになったので､ Lshtmと入力を引数として受け取ることができるようになったのです｡

07:49.820 --> 07:55.820
最初のXは平坦化されたベクトルで､ 先ほど費やしたこのX線です｡ 

07:56.000 --> 08:00.620
しかし､ それと同時に､ このダブルが登場するのです｡ 

08:00.650 --> 08:12.230
H､ X､ C､ xを入力する必要がありますが､ ここでxを使ってxを見ることができるのは､ フォワード関数の元の入力引数からその分離を行ったからです｡

08:12.740 --> 08:19.940
そこで､ lshtm xは4つの畳み込みとこの隠れノードとセルノードのテーブルまで平坦化された出力ベクトルである｡

08:20.330 --> 08:21.230
そうそう､ そうなんです｡ 

08:21.230 --> 08:26.030
そして､ lshtmは終了関数の変数であるため､ selfを忘れてはならない｡ 

08:26.030 --> 08:37.670
つまり､ 変数はLCMという自己のオブジェクトにアタッチされ､ これは実際に2つの出力（出力ヘルスノードと出力セルノード）のテーブルを出力に返します｡

08:37.670 --> 08:48.920
つまり､ これはタプルであり､ したがって､ h×隠れノードとsee×セルノードを更新することができるのです｡

08:49.930 --> 08:50.380
素晴らしい｡ 

08:50.380 --> 08:52.660
だから､ もうほとんど完成しているんです｡ 

08:52.660 --> 08:58.780
LLSチームの出力が得られたので､ 有用な出力を得る必要があります｡ 実際にはHinduノートだけが有用なので､

08:58.780 --> 09:06.970
xを再び更新してそれを得ようとすると､ xは今やh xと等しくなります｡

09:07.270 --> 09:13.810
LSB xの出力カップルの最初の要素はh xに等しく､ ほぼ完了です｡ 

09:14.020 --> 09:18.580
私たちには2つの脳があることを忘れないでください｡ 1つは俳優の脳､ もう1つは批評家の脳です｡ 

09:18.580 --> 09:25.150
そのため､ 俳優の出力信号と評論家の出力信号を返すために､ 信号を出力しなければならないのです｡

09:25.330 --> 09:29.350
したがって､ これから行うのは､ これら2つの出力信号を返すことです｡ 

09:29.350 --> 09:30.640
そして､ どうすればいいのか？

09:30.640 --> 09:31.870
まあ､ それはとても簡単なことです｡ 

09:31.870 --> 09:35.230
私たちはただ､ 直線的なフル接続をするだけでいいのです｡ 

09:35.230 --> 09:40.660
しかし､ それとは別に､ 評論家の直線的な完全接続と､ 俳優の直線的な完全接続がある｡

09:40.960 --> 09:50.170
そして､ これらの接続をそれぞれ､ lshtmの有用な出力である出力xに適用すると､ それがすべて出力信号となるのです｡

09:50.170 --> 09:51.730
そこで､ やってみましょう｡ 

09:51.730 --> 09:58.990
まず self をオブジェクトとし､ critic underscore linear である critic の線形足接続を取得し､

09:59.140 --> 10:06.730
それを lshtm の出力信号である x に適用し､ 同じように self を再び取得し､ 次にそれを取得し､ そして actor

10:06.730 --> 10:16.090
underscore linear である actor の線形完全接続を取得して､ それを x に適用します｡

10:16.090 --> 10:17.020
これでよしとしよう｡ 

10:17.920 --> 10:19.520
だから､ それが一番必要なことなんです｡ 

10:19.540 --> 10:25.780
しかし､ その後にLSBシーンのレトロループで使用するため､ 隠されたノートをすべてトップに戻し､

10:25.780 --> 10:28.990
ノートを売るためにXを見ることになります｡

10:29.350 --> 10:30.340
よし､ 完璧だ｡ 

10:30.340 --> 10:37.950
というのも､ 実は俳優用と批評家用の2つの脳を作ったからです｡

10:37.960 --> 10:41.900
というわけで､ a3cの頭脳化おめでとうございます｡ 

10:41.920 --> 10:48.160
CNNとLCMの組み合わせに無理がなかったかとは思いますが､ 少なくとも､ 本当に最高・最強のモデルで仕事をしているということは､

10:48.160 --> 10:51.070
良いニュースです｡

10:51.070 --> 10:52.810
そうそう､ そうなんです｡ 

10:52.840 --> 10:56.590
実はこの最初のファイルモデル､ あのパイで終わっているんです｡ 

10:56.620 --> 11:03.010
それで､ 次のチュートリアルでは､ オプティマイザを別に作るので､ オプティマイザの面倒を見ることにします｡

11:03.040 --> 11:08.170
多くは研究論文からなので､ 一行一行のコードを書くつもりはありません｡ 

11:08.170 --> 11:10.270
そして､ これは実はかなり具体的な話なんです｡ 

11:10.270 --> 11:16.450
このオプティマイザで何が起こっているのかを深く掘り下げていくと､ 次に起こることとしては少し無理があるかもしれません｡

11:16.450 --> 11:26.750
なぜなら､ まだ作るべき列車関数があり､ それは巨大な関数になり､ リスクのアルゴリズムが含まれているのだからです｡

11:26.800 --> 11:32.260
そのためのエネルギーを残しておきたいので､ あまり時間をかけないようにします｡

11:32.260 --> 11:37.630
しかし､ それでも､ 私はコードを説明し､ あなたはこのオプティマイザの背後にある全体のアイデアを理解することができます｡ 

11:37.960 --> 11:44.470
また､ 次回のチュートリアルでは､ オプティマイザーを作るためにお会いしましょう｡

11:44.500 --> 11:45.670
それまではお楽しみに｡ 

11:45.670 --> 11:45.970
I.
