WEBVTT

00:00.210 --> 00:02.220
こんにちは､ このチュートリアルにようこそ｡ 

00:02.370 --> 00:09.440
さて､ これまでのチュートリアルで､ a3cの脳を作りましたが､ この脳をトレーニングする必要があります｡

00:09.450 --> 00:12.900
しかし､ このような頭脳を鍛えるためには､ オプティマイザーが必要なのです｡ 

00:12.930 --> 00:17.670
この2つは確率的勾配降下法で､ 予測値と目標値の誤差にどれだけ寄与したかに応じて重みを更新していくわけですが､

00:17.670 --> 00:30.630
これまで第1モジュールと第2モジュールでは､ 学習時にtorchによる原子最適化器を使いました｡

00:30.630 --> 00:41.310
しかし､ 先ほどお話したように､ 私たちはブレイクアウトという非常に難しい問題を扱っており､ a3cアルゴリズム単体ではこの問題を解決することはできないのです｡

00:41.310 --> 00:49.290
この問題を解決するためには､ カスタマイズされたオプティマイザーや様々なトリックが必要で､ 何時間も待たされることはありません｡

00:49.290 --> 00:56.730
そのため､ アトム・オプティマイザをベースにしたカスタム・オプティマイザを別途用意し､

00:56.730 --> 01:01.110
この共有アトム・クラスの中に入れているわけです｡

01:01.110 --> 01:02.670
そして､ なぜシェアードアトムなのか？

01:02.670 --> 01:07.980
実はアトムオプティマイザだからなのですが､ これだと共有状態でも動いてしまいます｡ 

01:07.980 --> 01:11.130
そこで､ このチュートリアルでは､ その仕組みについて説明します｡ 

01:11.130 --> 01:18.480
次の実装のためにエネルギーを残しておきたいので､ ここではコーディングせずにさまざまな機能を見ていきます｡

01:18.480 --> 01:22.950
それが電車で､ 100行以上のコードがかかるあのPIファイルです｡ 

01:22.950 --> 01:24.330
だから､ そのための準備をする｡ 

01:24.330 --> 01:30.210
そこで､ このチュートリアルでは､ 1つのチュートリアルで何が起こっているのかを説明しようと思います｡ 

01:30.210 --> 01:31.920
そして､ 今すぐにでも始めましょう｡ 

01:32.650 --> 01:33.040
わかりました｡ 

01:33.040 --> 01:40.750
このクラスは､ init関数､ 共有メモリ関数､ ステップ関数という3つの関数を含んでいます｡

01:40.960 --> 01:52.010
まず最初にすることは､ atomを継承することです｡ atomはもちろんatomオプティマイザで､ torchライブラリのOptimモジュールから取得します｡

01:52.030 --> 01:57.000
そこで､ ここでは､ アトム・オプティマイザに関連するすべてのツールを取得するために､ 継承を適用しています｡ 

01:57.010 --> 01:59.080
そして､ init機能からスタートします｡ 

01:59.080 --> 02:00.340
では､ ここで何が起こるのか？

02:01.040 --> 02:09.020
まず､ スーパー関数を使って､ すべてのツールとすべての基本パラメータをatomクラスから継承しました｡

02:09.020 --> 02:16.000
そして､ これらの基本パラメータは､ ここでは､ params､ 学習率､ ベータ､ イプシロン､ ウェイト減衰である｡ 

02:16.010 --> 02:20.360
そして､ この最初のforループをselfのgroupのために開始します｡ 

02:20.660 --> 02:21.610
Paramsのグループ｡ 

02:21.620 --> 02:23.940
ではまず､ paramsグループとは何でしょうか？

02:23.960 --> 02:28.280
paramsグループにはオプティマイザのすべての属性が含まれていることを自己紹介｡ 

02:28.280 --> 02:32.480
そして､ その属性の中に､ 最適化しなければならないパラメータがあるのです｡ 

02:32.480 --> 02:40.730
この最適化したいパラメータは､ self dot params groups paramsに含まれるネットワークの重みである｡

02:40.730 --> 02:42.100
そうそう､ そうなんです｡ 

02:42.110 --> 02:44.690
groups を指定した self に属するグループ｡ 

02:44.690 --> 02:50.840
そして､ 2つ目のforループで､ self dot parameter groups paramsに含まれる､

02:50.840 --> 02:54.560
最適化したいパラメータを取得します｡

02:54.650 --> 03:00.980
つまり､ 基本的にはすべてのパラメータを含むself that params groupsを通り､ self dot

03:00.980 --> 03:07.280
parameter groupsの各パラメータ群について､ 最適化したいパラメータを調べていくことになる｡

03:07.310 --> 03:14.210
したがって､ ここでいうgroup paramsのpは､ 最適化したい重みの各センサーを意味する｡ 

03:14.210 --> 03:16.940
そこで､ 最適化したい重みのテンソルごとに

03:16.940 --> 03:21.350
そして､ この4行のコードで構成されるループの中では何が起こっているのでしょうか？

03:21.650 --> 03:30.800
基本的には､ Atom Optimizerが行う更新は､ 勾配の指数移動平均に基づいて行われます｡

03:31.160 --> 03:32.810
それが､ こちらのコードラインです｡ 

03:32.810 --> 03:38.210
それは､ モーメントの勾配の指数移動平均で､ 1次である｡ 

03:38.210 --> 03:46.790
しかし､ Atomが行う更新はそれだけでなく､ グラデーションの平方根の指数移動平均に基づいている｡

03:47.000 --> 03:51.650
それは､ 移動2の勾配を指数関数的に移動平均したものである｡ 

03:51.800 --> 03:57.320
そこで､ ここに1次の指数移動平均と､ 2次の指数移動平均をそれぞれ､

03:57.320 --> 04:00.530
勾配のEMAを示します｡

04:00.530 --> 04:06.110
指数移動平均がどのように機能するのか､ もっと深く知りたい方は､

04:06.110 --> 04:12.260
この研究論文､ Adam a method for stochastic

04:12.260 --> 04:20.480
optimizationをぜひご覧ください｡

04:20.630 --> 04:27.380
ですから､ もしあなたが､ このアルゴリズムがどのように機能するのか､ もっと詳しく知りたいのであれば､ まあ､ この論文は間違いなく役に立つことでしょう｡

04:27.380 --> 04:32.600
そして､ アトムズアップデートルールによるアルゴリズムのさらなる解説がありますね｡ 

04:32.600 --> 04:38.990
それでね､ その後に作る大きな電車の機能を攻める前に､ これを攻めたい場合だけなんです｡

04:39.230 --> 04:45.740
さて､ それではPythonに戻り､ 2つ目の関数､ share memoryに移りましょう｡ 

04:46.010 --> 04:47.810
それでは､ 一言ずつ｡ 

04:47.810 --> 04:55.610
このシェアメモリー機能というのは､ Cuda､ つまりCUDAがGPUをベースにしたアクセラレータであることを示すテンソルのようなものです｡

04:55.640 --> 05:07.790
基本的にここで起こるのは､ メモリを共有する状態のセンサーがこことこことここにあり､ TensorやCudaのように少し振る舞うということです｡

05:07.970 --> 05:10.160
つまり､ 計算を高速化するんです｡ 

05:10.160 --> 05:21.950
しかし､ 違いは､ ここでテンソルは､ メモリを共有し､ GPUまたはすべての麻痺スレッドにアクセス可能なCPUの一部に計算を送信することです｡

05:21.950 --> 05:23.510
ここでは基本的にそうなっているわけです｡ 

05:23.510 --> 05:31.460
これはTensor Cudaと少し似ていますが､ 並列ラインのスレッドがアクセスできるGPUまたはCPUの一部にのみ送信されます｡

05:31.910 --> 05:32.390
わかりました｡ 

05:32.390 --> 05:34.940
そして､ 最後のファンクションステップです｡ 

05:34.940 --> 05:41.330
つまり､ この関数､ この講座ですでに使ったアトムオプティマイザーのステップメソッドみたいなものですね｡

05:41.630 --> 05:47.060
そして､ これもまた､ 以前見た同じ論文のアルゴリズムに基づいています｡ 

05:47.060 --> 05:48.500
だから､ このアルゴリズム｡ 

05:48.590 --> 05:57.170
ですから､ 次のコードの行を詳しく理解したい場合は､ もう一度､ この論文によるこのアルゴリズム1を見てもらうことをお勧めします｡

05:57.320 --> 06:04.280
しかも､ ここで行われているのは､ 実は最適化されたアトムクラスのステップメソッドのコピーペーストなので､

06:04.280 --> 06:06.980
全く強制されることはないのです｡

06:06.980 --> 06:09.470
では､ 基本的にここでは何が行われているのでしょうか｡ 

06:09.470 --> 06:15.350
ここでは最適化されたアトムから継承しているため､ 継承を利用することで実現できたのです｡ 

06:15.350 --> 06:22.640
そして､ 相続財産をうまく使うために､ こんなことをする代わりに何ができるかというと､ ここにコメントとして書くだけです｡

06:22.670 --> 06:27.530
共有に適用するスーパーファンクションを使うだけなんです｡ 

06:28.290 --> 06:31.410
Atom クラスの後､ 私たちのオブジェクト self.

06:31.410 --> 06:34.640
そして､ ここでは括弧でステップを追加しているだけです｡ 

06:34.650 --> 06:40.470
Stepは最適化されたアイテムクラスのメソッドで､ これは全く同じです｡ 

06:40.470 --> 06:46.410
だから､ ここはOptim atomクラスのstepメソッドをコピペしただけの話なんです｡ 

06:46.710 --> 06:55.920
だから､ これを全部､ 共有原子に適用したこのスーパー関数とステップ法に置き換えれば､ まあ､ まったく同じものができるかもしれないと思うんです｡

06:57.090 --> 06:57.450
わかりました｡ 

06:57.450 --> 06:59.720
だから､ ざっと見た感じでは面白かったですね｡ 

06:59.730 --> 07:02.670
基本的にはアトムオプティマイザーと捉えていただければと思います｡ 

07:02.700 --> 07:04.410
より深い見方ができたという感じです｡ 

07:04.410 --> 07:09.630
しかし､ もしあなたがこのことについてもっと詳しく知りたい､ 舞台裏で何が起こっているのかを理解したいと思うのであれば､

07:09.630 --> 07:13.950
私はこの研究論文を見ることをお勧めします｡

07:13.980 --> 07:15.900
こちらのコメントにリンクを貼っておきますね｡ 

07:15.900 --> 07:19.800
覚えておいてください､ すべてのコードが詳細にコメントされているはずです｡ 

07:19.800 --> 07:21.900
だから､ 見てもらえるとすごくいいんです｡ 

07:22.320 --> 07:37.440
このファイルには巨大な列車関数が含まれていて､ 基本的に脳をトレーニングすることになります｡

07:37.440 --> 07:40.080
では､ 今はゆっくり休んでください､ おやすみなさい｡ 

07:40.080 --> 07:43.980
そして､ 調子がいいと感じるたびに､ 次のステップに進みましょう｡ 

07:44.220 --> 07:45.420
それまではお楽しみに｡ 

07:45.420 --> 07:45.900
I.
