WEBVTT

00:00.570 --> 00:03.340
こんにちは､ 人工知能のコースにようこそ｡ 

00:03.360 --> 00:06.300
今日のチュートリアルでは､ そのアドオンについてお話します｡ 

00:06.300 --> 00:08.610
3つのC言語アルゴリズムのために実装することになります｡ 

00:08.610 --> 00:12.690
長短期記憶､ 略して長短と呼ばれるものです｡ 

00:12.690 --> 00:21.000
では､ これまでの内容を確認した上で､ なぜLSTが必要なのか､ LSMとは何なのかについて説明しましょう｡

00:21.000 --> 00:24.480
これまで､ 3つのCアルゴリズムについて説明してきました｡ 

00:24.480 --> 00:33.300
A3 Cの3つのAの文字すべてについてお話しましたが､ もちろん､ 実際にはもう少し複雑で､ この画像にあるものよりもずっと複雑であることはおわかりいただけたと思います｡

00:33.300 --> 00:39.570
実際には3つ以上の複数のエージェントが環境内を行き来し､ お互いに通信し合ったりしています｡

00:39.570 --> 00:45.570
でも､ 今日のお話では､ わかりやすくするために､ このエージェント1つですべてを説明することにしましょう｡

00:45.570 --> 00:47.520
最後に､ この俳優の部分､ 評論家の部分があります｡ 

00:47.520 --> 00:52.770
つまり､ 基本的には､ 状態が決まると､ その状態は畳み込み層を経て､ プーリング層を経て､

00:52.770 --> 00:55.290
平坦化層へと進みます｡

00:55.290 --> 01:03.960
そして､ この時点では､ 値や数値がネットワークを通じて伝搬され､ 隠れ層に入ることになります｡

01:03.960 --> 01:12.600
そして､ 出力として､ 私たちはポリシーやアクターの部分を得て､ 彼らは状態の値を得て､ 私たちは評論家の部分を得ます｡

01:12.600 --> 01:16.530
そして､ 今日はこの隠れた部分についてお話します｡ 

01:16.530 --> 01:21.600
そこで､ 隠れ層では､ 実際に次のレベルまで持っていき､ 修正を加えることができます｡ 

01:21.600 --> 01:25.560
そして､ このアルゴリズムには複数の改変が存在することも､ すでに確認されています｡ 

01:25.560 --> 01:26.250
そのうちの1つを見たことがあります｡ 

01:26.250 --> 01:35.700
このように､ ネットワークの主要な部分を各エージェントが個別に持つ場合と､ ネットワークの主要な部分を共有する場合があることが分かっています｡

01:35.700 --> 01:42.000
これまでの直感的な実験でも､ ネットワークの一部を共有していることがわかりました｡ 

01:42.000 --> 01:44.100
このネットワークは､ 代理店の間で共有されていた｡ 

01:44.100 --> 01:50.580
アドロンが実践的なチュートリアルで詳しく説明しますが､ これはブレイクアウトの挑戦に本当に役立ちます｡

01:50.580 --> 01:59.670
また､ アルゴリズムを修正する方法は他にもたくさんあり､ 実装可能な追加機能もたくさんあります｡

01:59.670 --> 02:03.120
そのうちの1つについて説明します｡ 実際にチュートリアルの実践セットで､

02:03.120 --> 02:09.720
レイヤーに当たる前に､ 追加できるのは､ lshtmレイヤー､ ニューラルネットワークレイヤーで､

02:09.720 --> 02:18.810
アルゴリズムに記憶を持たせ､ 前に起こったことを記憶させることができるようにします｡

02:18.810 --> 02:20.940
そして､ たった今､ Lshtmについて､ より詳しくお話します｡ 

02:20.940 --> 02:27.870
しかし､ 基本的にはここにリストレイヤーを追加して､ 別の機能のためにメモリを追加してアルゴリズムを強化することができます｡

02:27.870 --> 02:32.610
そして､ 実際にフラクタル素材を見るとわかるのですが､ 最後のレイヤー以降は隠しレイヤーも必要なかったということで､

02:32.610 --> 02:36.030
事前の実装で確認することができます｡

02:36.030 --> 02:38.760
すぐに平坦化層ができたそうです｡ 

02:38.760 --> 02:40.350
その後､ システムレイヤーを持っている｡ 

02:40.350 --> 02:43.380
つまり､ 基本的にはこのボックスがlshtmレイヤーを表しています｡ 

02:43.380 --> 02:45.960
そして､ その後にすぐに出力があります｡ 

02:45.960 --> 02:50.940
だから､ それ以降の隠れ層は必要なかったんです｡ Lshtm層がどれだけアルゴリズムに力を与えるか､

02:50.940 --> 02:53.160
それだけです｡

02:53.160 --> 02:58.980
また､ ニューラルネットワークのアルゴリズムやアーキテクチャは､ 非常に個別的なものです｡ 

02:58.980 --> 03:01.320
個人的な好みで､ とてもクリエイティブなことなんです｡ 

03:01.320 --> 03:08.730
そのため､ 2つのレイヤー､ 1つの分析者レイヤー､ そして5つの隠しレイヤーが必要かもしれません｡

03:08.910 --> 03:11.670
それは完全にあなた次第で､ あなたが実験し､ 探求するためです｡ 

03:11.670 --> 03:16.290
でも､ これは実践的なチュートリアルで思いついたことなんです｡ 

03:16.290 --> 03:24.240
フラット化､ フラットレイヤー､ そしてその後にldsd1レイヤー､ さらに出力があるのがわかると思います｡

03:24.240 --> 03:28.590
さて､ ここまでこのレイヤーの話をしてきましたが､ このリストレイヤーとは何なのでしょうか？

03:28.590 --> 03:36.810
さて､ lshtm層は記憶を追加することで､ ニューラルネットワークが以前の反復で何が起こったかを記憶できるようにするような機能を提供します｡

03:36.810 --> 03:43.170
そして､ それはしばしば次のようなシンボルで象徴されたり､ 示されたりします｡ 

03:43.170 --> 03:46.050
これは､ 私たちが始めたばかりで､ ここに載せているだけです｡ 

03:46.050 --> 03:51.630
非常に曲がっているように見えますが､ この画像についてさらに議論するときに､ 何が起こっているのかわかるように､

03:51.630 --> 03:52.830
ここに載せておきます｡

03:52.830 --> 04:01.500
このレイヤーの出力がここに入り､ これが私たちのレイヤー全体です｡ 

04:01.500 --> 04:02.970
つまり､ 値のベクトルなんですね｡ 

04:02.970 --> 04:04.920
Xは､ サンドイッチに入るベクトル値です｡ 

04:04.920 --> 04:12.150
出力として､ これらのストアを連結した別のベクトル､ あるいは何らかの形でネットワークと結びついたベクトルを得ることができます｡

04:12.150 --> 04:14.820
私たちの場合､ 出力として､ こうなって､ こうなるんです｡ 

04:14.820 --> 04:17.280
では､ もう少し詳しく見てみましょう｡ 

04:17.280 --> 04:18.810
だから､ この部分だけに注目するのです｡ 

04:18.940 --> 04:22.830
実は､ 文字がこの大きさになっていることでお気づきかと思いますが､

04:22.830 --> 04:24.270
横向きにするんです｡

04:24.270 --> 04:37.410
このように､ 全体がごちゃごちゃしているのは､ このように見えても､ 実際には値の層､ 値のベクトル全体がここに入ってきているという事実を再確認したのです｡

04:37.410 --> 04:39.780
何かが起きている､ このことを今更ながら議論してみる｡ 

04:39.780 --> 04:41.390
ベクトルバレーが丸ごと入っていますね｡ 

04:41.400 --> 04:43.170
これがレイヤーなんですね｡ 

04:43.170 --> 04:47.190
これは一つの要素だけでなく､ レイヤーそのものなんです｡ 

04:47.190 --> 04:49.320
では､ もう一度戻ってみましょう｡ 

04:49.320 --> 04:53.550
もう一度言いますが､ レイヤーはこのレイヤーに入ります｡ 

04:53.550 --> 04:55.530
何かが起こる､ 層が出る｡ 

04:55.530 --> 04:58.560
つまり､ それはシステムが味方してくれているだけなのです｡ 

04:58.560 --> 05:00.020
だから､ 議論しやすいだけなんです｡ 

05:00.490 --> 05:02.050
そして､ それが共通の表現です｡ 

05:02.170 --> 05:02.580
わかりました｡ 

05:02.590 --> 05:07.770
さて､ なぜこの画像が横向きだったのか､ そしてこれからどう進めていくのか､ 納得していただけたでしょうか｡ 

05:07.780 --> 05:11.430
この状況をもう少し掘り下げてみることにしよう｡ 

05:11.440 --> 05:14.010
では､ 蒸気層の内部では何が起こっているのでしょうか？

05:14.020 --> 05:15.330
というわけで､ こんな感じです｡ 

05:15.340 --> 05:17.920
そしてもちろん､ これは非常に複雑に見えます｡ 

05:17.920 --> 05:24.010
そして､ これらについて議論することは非常に多いので､ 今すぐすべてを説明することは絶対にありません｡

05:24.100 --> 05:32.050
ポイントは､ オペレーションはレイヤーワイズオペレーションであり､ 多くのことが行われている､

05:32.050 --> 05:37.300
あるいは多くの複雑な細部がある､ ということです｡

05:37.300 --> 05:40.480
そしてこれは､ ここでステムの話をすることが目的ではありません｡ 

05:40.480 --> 05:42.230
それぞれのエラストマーを活用するだけです｡ 

05:42.340 --> 05:49.960
タムズについてもっと知りたい方は､ こちらのクリストファー・オラスブログをご覧ください｡ 

05:50.410 --> 05:56.560
彼はすべてのステムをうまく説明していますし､ 私たちもディープラーニングの年代でLCMSについて話しています｡ 

05:56.560 --> 05:57.970
もちろん､ そこで確認することもできます｡ 

05:57.970 --> 06:01.300
リカレント・ニューラル・ネットワークやステムに関するセクションもありますよ｡ 

06:01.300 --> 06:09.160
これがLCMの内部で､ レイヤーを入れていくようなイメージです｡ 

06:09.160 --> 06:13.450
そこで､ 直感的なレベル､ 非常に基本的な内部レベルで話をすることになります｡ 

06:13.450 --> 06:18.310
ただ､ 何が起こるのか､ なぜメモリがあるのか､ また､ アランがこれを実装するときに何を話しているのかをよりよく理解するためには､

06:18.310 --> 06:23.260
何があれば十分なのでしょう｡

06:23.260 --> 06:28.390
つまり､ レイヤーはこのすべてに入るわけで､ 何か基本的なことが起こっています｡ 

06:28.420 --> 06:29.260
レイヤーが外れる

06:29.530 --> 06:37.390
実際に確認すべきは､ これらの部品､ このレイヤーへの追加入力があるということです｡

06:37.390 --> 06:43.480
通常､ 前のレイヤーからの入力があり､ 次にこのレイヤーがあり､ そして出力がある､ と覚えておいてください｡

06:43.480 --> 06:49.540
以前､ 私たちが持っていたイメージ､ 通常のネットワークを考えてみると､ それは､ 横からではなく､ 左から右へ､

06:49.540 --> 06:55.120
上から下へという感じですが､ バニラステムの場合は､ 実際にはもっと多くの入力があるんですね｡

06:55.120 --> 06:59.290
だから､ さらに複雑になっているのでしょうが､ 少なくともこういうことは理解できるのです｡ 

06:59.290 --> 07:06.640
これが記憶細胞で､ これが鍵で､ これがアドロンの話を聞くことになるわけです｡ 

07:06.640 --> 07:11.810
つまり､ メモリーセルはシステムの中に保存されているものなんですね｡ 

07:11.830 --> 07:15.730
つまり､ これらの入力と出力は､ 実際にここにあるのです｡ 

07:15.730 --> 07:18.130
見ているのは時間軸の方です｡ 

07:18.130 --> 07:20.200
これが時間差で解けるわけです｡ 

07:20.200 --> 07:28.780
つまり､ ある特定の繰り返しでこうなるのですが､ その後､ 過去からこの値が取り込まれ､ この値がこれらの値に渡されるのです｡

07:28.780 --> 07:35.350
これらの価値観は過去から受け継いだものであり､ その価値観は未来に受け継がれ､ LHSチームの働き方によってうまく受け継がれていくのです｡

07:35.350 --> 07:48.990
ここで何が起こっているかはあまり気にせず､ レイヤーが入り､ ここではすでに過去から来た値がlshtmの中に保存されていることだけを理解すればいいのです｡

07:49.000 --> 07:51.550
長短の記憶の中｡ 

07:51.880 --> 07:59.560
このメモリセルには､ 以前ここにあったどんな値もそのまま残っているのです｡ 

07:59.560 --> 08:00.010
ご覧の通りです｡ 

08:00.010 --> 08:07.090
ただ､ 点的な操作の場合は､ それを閉じたり､ 何かを加えたりすることができますが､ それ以外は自由に通り抜けていくのです｡

08:07.090 --> 08:11.380
しかし､ それとは関係なく､ 自由に流れる何らかの価値観があるだけなのです｡ 

08:11.380 --> 08:14.860
つまり､ 基本的には次のポイントタイムに受け継がれるわけです｡ 

08:14.860 --> 08:21.310
つまり､ この細胞が持っているフラッシュドライブか何かのメモリのようなものだと思えばいいんです｡

08:21.310 --> 08:24.280
そして､ この中にあった以前の値を記憶しているだけなのです｡ 

08:24.280 --> 08:29.860
そして､ その値を使って､ その値に追加したり､ その値から読み出したりすることができるのです｡ 

08:30.160 --> 08:38.110
そして､ この値が隠された状態､ つまりHであり､ 隠された状態は基本的に過去から来た別の値であり､

08:38.110 --> 08:41.950
その後システムの内部で使われるのです｡

08:41.950 --> 08:49.240
そして､ 最後にご覧のように､ このようなことが起こった後､ レイヤーが出てくるのです｡

08:49.240 --> 08:52.930
つまり､ 出てきたこの値は､ 前方に渡されるのと同じ値なのです｡ 

08:52.930 --> 08:55.690
だから､ 基本的にLLSのチームは2つのことを記憶している｡ 

08:55.690 --> 09:01.370
lshtmの中にstayのような定数値があり､ このように変更することができます｡ 

09:01.420 --> 09:04.660
定価のようなフラッシュドライブがあります｡ 

09:04.660 --> 09:13.330
そのため､ メモリーセルは､ その空間､ メモリーに何かを保存することができ､ それが未来に受け継がれるという贅沢ができるのです｡

09:13.330 --> 09:20.470
だから､ 次の反復ではいつでも､ アルゴリズムがある環境にいるように､ 何かを見て､ 何かをする､ ということを繰り返すのです｡

09:20.470 --> 09:26.740
そして､ チーム内にある特定の値を保存しておけば､ 次の状態になったときでもこの値を覚えていてくれるのです｡

09:27.190 --> 09:33.640
そして､ もう一つの値は､ その前の出力を記憶して､ 自動的にその前の出力を記憶します｡

09:33.640 --> 09:35.290
だから､ 出力はここに行って､ ここに行くんです｡ 

09:35.290 --> 09:42.070
これがLSMで起こることの､ 基本的な､ とても､ とても､ とても高いレベルです｡ 

09:42.070 --> 09:46.060
もう一度言いますが､ もっと詳しく知りたい方は､ たくさんの資料がありますので､ そちらをご覧になってください｡ 

09:46.060 --> 09:50.920
そして､ 現段階では､ これらすべてについて､ そこまで詳しく説明する必要はないでしょう｡ 

09:50.920 --> 09:59.950
メモリーセルとは何か､ 隠れたメモリーセルとは何か､ 隠れた状態とは何か､ そしてそれらがどのように機能しているかを理解する必要があるのです｡

10:00.490 --> 10:01.810
リスト用メモリ｡ 

10:02.110 --> 10:09.520
そこで質問ですが､ この知識を補強したり､ 固めたりするために､ また､ この知識を得るための理由を示すために､

10:09.520 --> 10:19.090
これらすべての概要を把握したところで､ 「なぜメモリが必要なのか」という質問をしてみましょう｡

10:19.090 --> 10:22.960
なぜ､ a3cやその他のアルゴリズムにメモリが必要なのでしょうか？

10:22.960 --> 10:26.890
では､ このセクションで挑戦している､ 私たちの例を見てみましょう｡ 

10:26.890 --> 10:28.360
だから､ 課題はブレイクアウトなんです｡ 

10:28.360 --> 10:29.860
そして､ ブレイクアウトでは何が起こるのでしょうか？

10:29.860 --> 10:35.710
ブレイクアウトでは､ この環境と小さなブロックがあって､ この小さなボールで破壊する必要があるんです｡

10:35.710 --> 10:40.900
そして､ これがラケットやプラットフォームのようなもので､ 動き回っていることを確認する必要があります｡ 

10:40.900 --> 10:46.060
そして､ ボールが飛んでくるたびに､ ボールをキャッチして､ プラットフォームに跳ね返ってぶつけたり､ 壁にも跳ね返って戻って､

10:46.060 --> 10:49.480
ブロックにぶつかって戻ってこなければなりません｡

10:49.870 --> 10:54.100
というのが､ 達成すべき本質なんですね｡ 

10:54.100 --> 11:02.260
しかし､ このボールを見てみましょう｡ あなたがan, an, a3cアルゴリズムで､ a3cの中のエージェントの1つだと想像してみてください｡

11:02.260 --> 11:05.260
この絵が見えますか？

11:05.260 --> 11:07.480
ここから何を抽出するのですか？

11:07.480 --> 11:09.070
ここであなたはどのような行動をとりますか？

11:09.070 --> 11:09.490
ここから？

11:09.490 --> 11:11.740
だから､ ボールが飛んでいるのがわかるでしょ？

11:11.740 --> 11:13.540
だからまあ......飛んでるよね｡ 

11:13.540 --> 11:15.880
だから､ どこかに行ってしまうし､ もしかしたら自分に向かって飛んでくるかもしれない｡ 

11:15.880 --> 11:16.120
そうですね｡ 

11:16.120 --> 11:17.740
このような結論を出すことができるのでしょうか？

11:17.740 --> 11:20.050
自分に向かってくるのを予測することはできますか？

11:20.080 --> 11:21.160
おそらくできるはずです｡ 

11:21.160 --> 11:23.680
そして､ もしかしたらボールをキャッチするのに最適な場所にいるかもしれない｡ 

11:23.680 --> 11:26.590
しかし､ 実際にボールがそのように飛んでいない場合はどうでしょうか｡ 

11:26.590 --> 11:27.310
何を飛ばしているのでしょうか？

11:27.310 --> 11:28.480
そっちに飛んでいったらどうするんだ？

11:28.750 --> 11:36.340
この1枚の画像からは､ 前の瞬間にどこにいたか分からないので､ どちらに飛んでいるのか分からないということです｡

11:36.340 --> 11:39.060
だから､ ここにあったのなら､ これを飛ばしているのです｡ 

11:39.150 --> 11:43.690
だから､ もしあなたが前の瞬間に知っていたなら､ そのときあなたがここで知っていたなら､ 今あなたは知っている､

11:43.690 --> 11:45.400
ここでそれは人間としてある｡

11:45.400 --> 11:48.640
この2つから線を引くだけで､ ああ､ かっこいい､ こっちに行くんだな､ と｡ 

11:48.640 --> 11:52.270
でも､ ここにあると知ったら､ このスタンドはこっちに行くと線引きするんですね｡ 

11:52.270 --> 11:54.250
さらに､ これを見てください｡ 

11:54.250 --> 11:57.010
実はこっちのような場所だったのかもしれない｡ 

11:57.010 --> 11:59.500
もしかしたら､ 上がっているかもしれないし､ 実際にそうなっているかもしれない｡ 

11:59.500 --> 12:01.030
だから､ もしかしたらここにあって､ 私が登っていたのかもしれません｡ 

12:01.240 --> 12:04.540
だから､ その1枚の画像からだけでも､ とても難しい｡ 

12:04.540 --> 12:05.860
実は不可能なんです｡ 

12:05.860 --> 12:10.450
ボールがどっちに飛んでいくかなんて､ 幾何学的に不可能なのと同じですからね｡ 

12:10.450 --> 12:17.830
そのため､ 前回､ 記憶が本当に､ 本当に役立つアルゴリズムになりました｡ 記憶なしでも､

12:17.830 --> 12:27.640
いい仕事はできますが､ おそらく推測したり､ どこに行くべきか他の方法を見つけたりすることができます｡

12:27.640 --> 12:33.790
ですから､ その1つの値でも戻れば､ それは前の値の出力のようなもので､ あるいは､

12:34.150 --> 12:43.180
ここに保存したり､ この値に基づいて､ 前の時点から得た情報に基づいて､ 保存したりすることができるかもしれません｡

12:43.180 --> 12:47.980
ここで起こったことから､ あなたのボールが以前あった場所だとします｡ 

12:47.980 --> 12:54.100
つまり､ 前の時点の環境の情報をここを通して伝えることができ､ そして今､ それがあるわけです｡

12:54.100 --> 13:02.740
今は画像からの情報だけでなく､ さらにさかのぼれば､ 画像からの情報を記憶していることになります｡

13:02.740 --> 13:07.060
これは "破滅 "ですが､ 実際には画像のブレイクアウト情報を使って､ ここ､ ここ､

13:07.060 --> 13:09.910
ここで､ 平坦化された値に変換しているのです｡

13:09.910 --> 13:13.240
というように､ 画像からの情報が入ってくるわけです｡ 

13:13.240 --> 13:21.220
そして今､ 突然､ どこからかではなく､ 前の時点から来たことを思い出したかのように｡

13:21.220 --> 13:24.490
そのため､ 実際にデモができるのは､ ボールからと左からと右からです｡

13:24.490 --> 13:28.300
実際には......lshtmレイヤーにとどまるだけなんです｡ 

13:28.300 --> 13:31.540
その情報は､ システムのアーキテクチャだけで持っているんですね｡ 

13:31.540 --> 13:33.790
以前起きたことの情報を持っているのですね｡ 

13:33.880 --> 13:41.920
そして､ この情報は､ あなたが何をすべきかの判断をするのに役立ち､ アルゴリズムが判断をするのに役立ち､ そして､

13:41.920 --> 13:45.420
突然､ 「ああ､ そうか」とわかるのです｡

13:45.430 --> 13:51.040
つまり､ ボールは､ 例えばこの方向に飛んでいるとか､ この方向に飛んでいるとか､ どちらかに転がっているわけです｡ 

13:51.040 --> 13:53.170
だから､ 私はこの辺にいた方がいいんです｡ 

13:53.170 --> 13:54.610
ボールは私の方に来るんです｡ 

13:54.610 --> 13:58.510
あるいは､ ボールがそこに飛んでいることに気づいたら､ もう少し待っていたら手遅れになってボールを取り逃がしてしまうので､

13:58.510 --> 14:01.690
左に移動し始めるはずです｡

14:01.690 --> 14:08.560
このように､ lshtmレイヤーはこのアルゴリズムにとても役立っており､ Adlandを使った実践的なチュートリアルを行う際にも､

14:08.560 --> 14:12.200
まさにそのようなことが言えると思います｡

14:12.220 --> 14:12.940
そうそう､ そうなんです｡ 

14:12.970 --> 14:14.260
それがこのチームのやり方です｡ 

14:14.260 --> 14:20.680
そして､ もうひとつだけ補足しておくと､ 冒頭で述べたように､ エリス・タイムズは100％必要なものではありません｡ 

14:20.680 --> 14:25.330
彼らは､ このアルゴリズムに完全に執着しているわけではないのです｡ 

14:25.330 --> 14:27.910
入れておいたほうがいいかもしれませんね､ a3cアルゴリズム｡ 

14:27.910 --> 14:31.030
選ぶアーキテクチャによって､ 状況によっては持たない方がいいかもしれません｡ 

14:31.030 --> 14:37.270
たくさんの追加があり､ ニューラルネットワークがアクター間で共有されるか､ エージェント間で共有されないか､

14:37.270 --> 14:40.750
といった追加や修正についてはすでに説明しました｡

14:40.750 --> 14:41.860
今はそれにもかかわらず｡ 

14:41.860 --> 14:47.830
Lshtm もうひとつ､ 実践的なチュートリアルで紹介される､ ポリシーロスの全体にわたって計算されるエントロピーを追加する方法がありますが､

14:47.830 --> 14:51.010
これについてはアドロンが説明します｡

14:51.010 --> 14:56.920
つまり､ アルゴリズムにはさまざまな変更が可能なのです｡ 

14:57.250 --> 14:59.230
によるということだけは覚えておいてください｡ 

14:59.380 --> 15:00.460
実現したいこと

15:00.460 --> 15:08.140
また､ 多くの実装を行い､ さまざまなアルゴリズムを試すのであれば､ ぜひとも検討していただきたい点です｡

15:08.890 --> 15:15.310
すでにいくつかご紹介しましたが､ もしかしたら､ さらにご興味のある改造が見つかるかもしれません｡

15:15.460 --> 15:21.250
あるいは､ チュートリアルを見ていると､ その頃にはもっと面白い改造がされているかもしれませんね｡

15:21.250 --> 15:27.310
人工知能やアルゴリズムの作り方に関する知識を深めるためにも､

15:27.310 --> 15:30.460
ぜひ調べてみてください｡

15:30.490 --> 15:34.030
というわけで､ 本日のチュートリアルを楽しんでいただけたら幸いです｡ 

15:34.060 --> 15:35.250
それまではお楽しみに｡ 

15:35.250 --> 15:35.650
I.
