back to index

ML Lecture 23-3: Reinforcement Learning (including Q-learning)


link |
00:00.000
機器學習和環境做互動
link |
00:30.000
機器學習和環境做互動
link |
01:00.000
一般分類問題
link |
01:30.000
機器學習和環境做互動
link |
02:01.000
AlphaGo
link |
02:10.000
AlphaGo的輸入就是棋盤的盤勢
link |
02:14.000
黑子和白子的位置
link |
02:16.000
輸出就是接下來應該要落子的位置
link |
02:23.000
機器學習和環境做互動的過程中
link |
02:25.000
最重要的特色就是
link |
02:27.000
你所採取的行為會影響往後的發展
link |
02:31.000
在圍棋裡面顯然是這樣子
link |
02:33.000
你落子的位置當然會影響對手落子的位置
link |
02:37.000
你今天出手下在天元對方的硬手
link |
02:39.000
跟你出手下在五之五對方的硬手
link |
02:42.000
顯然是會不一樣的
link |
02:46.000
在做這種環境互動的時候
link |
02:48.000
你通常會定一個目標
link |
02:50.000
告訴機器說要達成什麼樣的目的
link |
02:53.000
舉例來說
link |
02:54.000
在下圍棋裡面要達成的目的
link |
02:56.000
當然就是要贏棋
link |
02:58.000
在讓機器和環境做互動的文獻上
link |
03:01.000
常常看到一個字眼叫做State
link |
03:04.000
這個是什麼意思呢
link |
03:05.000
在過去我們通常覺得說
link |
03:09.000
外界來的資訊太過複雜
link |
03:11.000
我們會需要有另外一個model幫我們
link |
03:14.000
把外界的資訊做一些摘要
link |
03:16.000
做完摘要以後再丟給machine
link |
03:19.000
所以外界輸入的資訊沒有處理的叫做Observation
link |
03:23.000
但是把它summarize處理以後
link |
03:26.000
叫做State
link |
03:27.000
但是今天隨著deep learning技術的發展
link |
03:30.000
model的能力已經越來越強
link |
03:32.000
我們不太需要幫model
link |
03:34.000
另外再去做資訊的summarization
link |
03:37.000
反正他自己有那麼多個layer
link |
03:39.000
他自己會決定說
link |
03:40.000
input的這個role的feature
link |
03:41.000
observation哪些資訊是可以用的
link |
03:43.000
哪些資訊是他不要的
link |
03:45.000
所以這個observation跟state
link |
03:47.000
現在這兩個詞彙
link |
03:48.000
基本上是混著用的
link |
03:50.000
所以當我講state跟observation的時候
link |
03:52.000
其實我指的是一樣的東西
link |
03:55.000
讓機器下圍棋是一個和環境互動的例子
link |
03:58.000
舉例來說
link |
03:59.000
讓機器學會玩電玩
link |
04:01.000
也是一個和環境互動的例子
link |
04:04.000
在機器學會玩電玩的時候
link |
04:06.000
他有一個另外一個AI
link |
04:08.000
另外一個主機當作對手
link |
04:10.000
機器採取的行為
link |
04:11.000
當然會影響對方的回應
link |
04:14.000
如果你想做一些video game playing的話
link |
04:16.000
你可以參考下面這兩個連結
link |
04:19.000
OpenAI他們提供了一些平台
link |
04:22.000
讓你的機器可以練習去玩一些遊戲
link |
04:25.000
比如說GTA之類的
link |
04:27.000
真的有GTA可以玩
link |
04:33.000
有人可能會問說
link |
04:34.000
讓機器學習玩遊戲
link |
04:36.000
好像還沒有什麼特別的
link |
04:37.000
因為本來遊戲主機裡面就有一個AI
link |
04:40.000
他也會玩遊戲
link |
04:42.000
但是讓機器學會自己玩遊戲
link |
04:44.000
跟遊戲主機裡面的AI是不同的
link |
04:46.000
當機器學習玩遊戲的時候
link |
04:48.000
他看到的遊戲畫面
link |
04:50.000
跟人看到的遊戲畫面
link |
04:52.000
是一模一樣
link |
04:54.000
再來他並沒有handcrafted
link |
04:56.000
如果我告訴他說
link |
04:57.000
什麼樣的行為是好的
link |
04:59.000
什麼樣的行為是不好的
link |
05:00.000
如果是遊戲主機裡面那個AI
link |
05:02.000
他是handcrafted的
link |
05:04.000
他是人告訴他說
link |
05:06.000
看到這樣的畫面
link |
05:07.000
看到這樣的狀況
link |
05:08.000
你就採取這樣的行為
link |
05:10.000
但是當我們讓機器自己學習的時候
link |
05:12.000
沒有人告訴機器說
link |
05:13.000
應該要採取什麼樣的行為
link |
05:15.000
他必須要自己figure out
link |
05:16.000
什麼樣的行為是好的
link |
05:18.000
什麼樣的行為是不好的
link |
05:20.000
那和環境做互動還有很多例子
link |
05:22.000
比如說自駕車也是一個例子
link |
05:24.000
如果你今天要坐一台自駕車的話
link |
05:27.000
那簡單來說
link |
05:29.000
就是輸入一個以下
link |
05:31.000
然後呢
link |
05:32.000
機器決定說看到這個畫面
link |
05:34.000
他要採取什麼樣的行為
link |
05:36.000
比如說看到一個紅燈
link |
05:37.000
然後他就決定說
link |
05:39.000
現在要踩個煞車
link |
05:41.000
那當然我們剛剛講
link |
05:43.000
用自駕車的例子都講過說
link |
05:45.000
機器採取不同的行為
link |
05:46.000
就會影響他接下來看到的畫面
link |
05:49.000
隨著採取的行為不同
link |
05:50.000
接下來他看到的observation
link |
05:52.000
就會不一樣
link |
05:54.000
或者是說
link |
05:55.000
假設你想要做一個checkbox
link |
05:57.000
也是一樣
link |
05:58.000
你想要做一個訂票系統
link |
06:00.000
你說
link |
06:01.000
你想要訂11月5號到台北機票
link |
06:04.000
然後我們去回答說
link |
06:05.000
你要從
link |
06:06.000
你希望從哪裡出發
link |
06:08.000
那這個輸入和輸出
link |
06:12.000
這個東西你可以想成是
link |
06:14.000
一個巨大的network
link |
06:15.000
然後輸入一個input
link |
06:17.000
那你就可以回一個輸出
link |
06:19.000
但是今天你的這個dialog system
link |
06:21.000
他的輸出
link |
06:22.000
會影響接下來他看到的input
link |
06:24.000
假設今天dialog system
link |
06:26.000
是問說
link |
06:27.000
你要從哪裡出發呢
link |
06:29.000
那他接下來看到的input可能就是
link |
06:31.000
我要從波士頓出發
link |
06:33.000
但是假如今天這個dialog system
link |
06:36.000
輸出是
link |
06:37.000
比如說你要幾點出發呢
link |
06:38.000
他看到輸入可能就是
link |
06:39.000
我要六點出發
link |
06:41.000
所以跟其他的互動的這個test一樣
link |
06:43.000
今天你要訓練一個對話系統的時候
link |
06:45.000
他是一個機器和環境互動的問題
link |
06:47.000
當然這邊環境就是指你的
link |
06:49.000
假設你是客服系統的話
link |
06:50.000
環境就是指你的那個客人啦
link |
06:53.000
但是你今天採取的行為
link |
06:55.000
會影響你客人的回應
link |
06:59.000
好那要怎麼解這種
link |
07:00.000
和環境互動的問題呢
link |
07:02.000
你當然可以說
link |
07:03.000
和環境互動問題
link |
07:04.000
我們就直接把它想成
link |
07:06.000
是一個分類的問題
link |
07:08.000
我們就直接把它當成
link |
07:09.000
是一個分類的問題
link |
07:10.000
而直接把它當作
link |
07:12.000
是一個超級分類的問題
link |
07:14.000
用超級分類的方法
link |
07:16.000
去學一個給我
link |
07:18.000
怎麼說
link |
07:19.000
假設是圍棋的話
link |
07:20.000
我們就教Machine說
link |
07:21.000
看到這個盤勢
link |
07:23.000
你就下33
link |
07:24.000
你去收集很多人類的棋譜
link |
07:26.000
告訴機器說
link |
07:27.000
人呢
link |
07:28.000
看到這個盤勢就會下33
link |
07:29.000
那你就跟人做的一樣
link |
07:31.000
那這其實就是一個
link |
07:32.000
超級分類的方法
link |
07:33.000
看到這個盤勢
link |
07:34.000
輸出呢
link |
07:35.000
33的機率
link |
07:36.000
要越大越好
link |
07:37.000
好那如果是自駕車
link |
07:38.000
你就教機器說
link |
07:40.000
看到這個畫面
link |
07:42.000
你就踩煞車
link |
07:43.000
那你說
link |
07:44.000
怎麼收集這種Data呢
link |
07:45.000
你就connect每一個
link |
07:47.000
人在開車的時候
link |
07:49.000
的那個行車紀錄器的畫面
link |
07:51.000
還有人的動作
link |
07:52.000
那就可以知道說
link |
07:53.000
行車紀錄器
link |
07:54.000
看到這個畫面的時候
link |
07:55.000
人會踩煞車
link |
07:56.000
所以機器要學到說
link |
07:57.000
看到這個畫面的時候
link |
07:59.000
你要調這個Layout參數
link |
08:01.000
讓他的Output是踩煞車
link |
08:03.000
或者是如果是對話系統的話
link |
08:05.000
你就收集很多
link |
08:07.000
真人的客服
link |
08:08.000
跟那個顧客的對話
link |
08:09.000
那你知道真人的顧客說
link |
08:11.000
我想訂10月5號到台北機票的時候
link |
08:13.000
真人會問說
link |
08:14.000
你要從哪裡出發
link |
08:15.000
那你就告訴Network說
link |
08:17.000
今天人告訴你這句話的時候
link |
08:19.000
你要回答的
link |
08:20.000
跟真人客服越像越好
link |
08:22.000
你就這樣輸出
link |
08:23.000
那當我們用這種方式
link |
08:25.000
讓機器做學習的時候
link |
08:27.000
這個叫做
link |
08:28.000
Behavior Coding
link |
08:30.000
就是複製行為
link |
08:32.000
就是複製Expert的行為
link |
08:34.000
我們可以告訴機器說
link |
08:36.000
真人的駕駛
link |
08:37.000
看到這個畫面
link |
08:38.000
就採取什麼樣的行為
link |
08:39.000
真人的客服
link |
08:40.000
聽到顧客說這句話
link |
08:42.000
就這樣回答
link |
08:43.000
你就跟你的老師
link |
08:45.000
也就是你的Expert
link |
08:46.000
做的一模一樣就好了
link |
08:48.000
就希望你可以學的
link |
08:49.000
跟Expert一樣的厲害
link |
08:51.000
這麼做
link |
08:52.000
會有什麼樣的問題呢
link |
08:54.000
以下是一個
link |
08:55.000
Behavior Coding的例子
link |
08:57.000
跟Machine Learning沒什麼關係
link |
09:28.000
Well it's not
link |
09:45.000
所以機器在學的時候
link |
09:47.000
他就跟修人是一樣的困惑
link |
09:50.000
當他有一個人類的老師的時候
link |
09:52.000
人類的老師
link |
09:53.000
採取的一些行為
link |
09:55.000
機器能夠做的事情
link |
09:56.000
就是相信他的老師
link |
09:57.000
全然是對的
link |
09:58.000
然後完全的去模仿他的老師
link |
10:01.000
事實上
link |
10:02.000
假設機器
link |
10:03.000
可以完全模仿他的老師
link |
10:05.000
也許問題並沒有很大
link |
10:07.000
機器只是學了一些
link |
10:09.000
不該學的東西而已
link |
10:11.000
但是真正害怕的case是什麼呢
link |
10:13.000
真正害怕的case是
link |
10:14.000
機器沒有辦法
link |
10:16.000
完全模仿他的老師
link |
10:18.000
而他不得不有所取捨
link |
10:20.000
就有些東西該學
link |
10:21.000
有些東西不該學的時候
link |
10:23.000
到底哪些東西該學
link |
10:25.000
哪些東西不該學
link |
10:27.000
就變成是一個問題了
link |
10:29.000
所以Behaviour Coding
link |
10:30.000
我覺得最大的問題就是
link |
10:32.000
如果是只有Behaviour Coding的話
link |
10:34.000
你沒有告訴Machine說
link |
10:36.000
什麼樣的行為是重要的
link |
10:38.000
什麼樣的行為是不重要的
link |
10:40.000
舉例來說
link |
10:41.000
修人在學中文的時候
link |
10:42.000
他不知道語音是重要的
link |
10:45.000
而手勢是不重要的
link |
10:46.000
對機器來說
link |
10:47.000
你今天就給他一個示範
link |
10:49.000
他不知道到底是語音重要
link |
10:51.000
還是手勢重要
link |
10:52.000
如果他自己胡亂決定說
link |
10:54.000
也許手勢比較重要
link |
10:55.000
那整個結果就會壞掉
link |
10:57.000
所以Behaviour Coding
link |
10:58.000
最大的問題就是
link |
10:59.000
機器不知道說
link |
11:00.000
什麼是重要的
link |
11:01.000
什麼是不重要
link |
11:02.000
他只能夠做照單全收這件事
link |
11:04.000
就好像是有一個人說
link |
11:05.000
他想要成為成功的人物
link |
11:07.000
比如說他想要跟賈伯斯一樣
link |
11:09.000
他就列出了賈伯斯的
link |
11:10.000
20個人格特質
link |
11:12.000
可能包括勤奮、創造力
link |
11:14.000
還有壞脾氣這樣
link |
11:15.000
他就覺得說他能力很差
link |
11:17.000
三項裡面他學一樣就好了
link |
11:19.000
他就決定我就只學壞脾氣
link |
11:20.000
然後就一無是處這樣子
link |
11:22.000
所以Behaviour Coding的問題
link |
11:24.000
就是這個樣子
link |
11:25.000
在這種和環境做互動的情況下
link |
11:29.000
我們剛才就有講說
link |
11:31.000
有些行為是重要的
link |
11:32.000
有些行為是不重要的
link |
11:34.000
為什麼有些行為是重要的
link |
11:36.000
有些行為是不重要的呢
link |
11:37.000
因為現在你能夠去採取的行為
link |
11:40.000
會影響接下來的發展
link |
11:42.000
所以有一些行為非常的關鍵
link |
11:44.000
有一些行為也許沒有那麼關鍵
link |
11:47.000
如果只有Behaviour Coding
link |
11:48.000
機器學不到這件事
link |
11:51.000
那要怎麼讓機器真的可以
link |
11:53.000
在和環境互動的情況下學好呢
link |
11:56.000
你就不能夠單純的考慮每一個step
link |
12:01.000
你不能夠只是告訴機器說
link |
12:03.000
在看到這個盤式的時候
link |
12:05.000
你就下載這個位置
link |
12:07.000
你不能只是把它當作一個
link |
12:08.000
簡單的一般的supervised learning來看待
link |
12:11.000
當作一個supervised learning來看待
link |
12:12.000
機器是沒有辦法學好的
link |
12:14.000
你要讓機器把所有的action
link |
12:17.000
都當作整體來看待
link |
12:19.000
那怎麼做到這件事呢
link |
12:20.000
有兩個方向
link |
12:23.000
一個方向就是大家都知道的
link |
12:25.000
reinforcement learning
link |
12:27.000
那在reinforcement learning裡面
link |
12:29.000
機器會去跟環境互動
link |
12:31.000
它自己去跟環境互動
link |
12:32.000
它在跟環境互動的過程中
link |
12:34.000
它會得到一些reward
link |
12:36.000
告訴它說
link |
12:37.000
什麼樣的行為是好的
link |
12:39.000
什麼樣的行為是不好的
link |
12:40.000
接下來機器要自己去學習說
link |
12:42.000
怎麼樣可以得到比較好的reward
link |
12:45.000
怎麼樣多採取好的行為
link |
12:46.000
避免採取會得到negative
link |
12:48.000
你reward會得到差的評價的行為
link |
12:51.000
另外一個也許大家比較沒有那麼熟悉的
link |
12:53.000
叫做learning by demonstration
link |
12:55.000
learning by demonstration又叫做
link |
12:57.000
imitation learning
link |
12:58.000
或者是apprenticeship learning
link |
13:00.000
那在這種task裡面
link |
13:01.000
機器呢
link |
13:02.000
它有一些expert的demo
link |
13:06.000
但是它現在學習expert的行為的時候
link |
13:09.000
它必須要有特別的學習方式
link |
13:11.000
而不是使用
link |
13:13.000
照單全收behavior coding的方式
link |
13:16.000
所以learning by demonstration
link |
13:17.000
它並不是一般的supervised learning的問題
link |
13:19.000
機器不是複製expert的行為
link |
13:21.000
而是用其他的方法
link |
13:23.000
來讓它可以學得跟expert一樣好
link |
13:27.000
那我們就先來講reinforcement learning
link |
13:30.000
其實我們等一下除了講reinforcement learning
link |
13:32.000
等一下會講inverse reinforcement learning的技術
link |
13:34.000
所謂inverse reinforcement learning的技術
link |
13:37.000
就是learning by demonstration
link |
13:40.000
inverse reinforcement learning的技術
link |
13:42.000
就是learning by demonstration的其中一種
link |
13:46.000
那我們先來看一下reinforcement learning
link |
13:49.000
那等一下呢
link |
13:50.000
如果時間夠的話
link |
13:51.000
我們就會先介紹actor
link |
13:53.000
再介紹query
link |
13:54.000
然後再介紹actor加query的方法
link |
13:57.000
先來講reinforcement learning
link |
13:59.000
那在reinforcement learning裡面
link |
14:01.000
我們有三個component
link |
14:03.000
第一個component呢
link |
14:05.000
是一個actor
link |
14:06.000
第二個component是一個environment
link |
14:08.000
第三個component是一個reward function
link |
14:11.000
那我們分別以電玩和價為洗為利
link |
14:14.000
來說明這三個東西分別是什麼
link |
14:16.000
如果在電玩裡面
link |
14:19.000
你的actor要做的事情
link |
14:21.000
就是去操控那個搖桿
link |
14:23.000
決定要向左向右還是開火
link |
14:25.000
如果是在價為洗的時候
link |
14:27.000
他就決定說
link |
14:28.000
現在落子要落在哪一個位置
link |
14:31.000
那至於環境呢
link |
14:32.000
在video game裡面
link |
14:34.000
你的環境就是主機
link |
14:38.000
你那個machine現在要去玩遊戲
link |
14:41.000
總是要有個主機跟遊戲玩
link |
14:42.000
你的主機就是環境
link |
14:44.000
那在下為期裡面呢
link |
14:46.000
你的環境就是machine的對手
link |
14:48.000
就是另外一個人類的對手
link |
14:50.000
那reward function呢
link |
14:52.000
在遊戲裡面你會先訂好說
link |
14:54.000
比如說殺一隻怪就得20分等等
link |
14:57.000
這個就是reward function
link |
14:58.000
那在為期裡面
link |
14:59.000
reward function是很明確的
link |
15:01.000
就是為期的規則
link |
15:02.000
下到這個地方就贏了
link |
15:04.000
就得1分
link |
15:05.000
下到這個地方輸了就得出1分
link |
15:08.000
那在reinforcement learning的test
link |
15:09.000
你要注意environment跟reward function
link |
15:12.000
是訂好的
link |
15:13.000
是訂實的
link |
15:14.000
你不能夠去動它
link |
15:16.000
你不能去動為期的規則
link |
15:18.000
你不能夠去動你的對手
link |
15:21.000
那都是你無法控制的
link |
15:22.000
我們要做的事情是什麼
link |
15:24.000
我們唯一能夠控制的
link |
15:26.000
就是actor他採取的行為
link |
15:28.000
我們要做的事情是
link |
15:29.000
調整actor採取的行為
link |
15:31.000
使得他可以得到最大的reward
link |
15:34.000
那我們以電玩為例來說明一下
link |
15:38.000
這個環境還有actor
link |
15:41.000
還有reward他們互動的情形
link |
15:44.000
假設我們現在要讓機器去玩電玩
link |
15:46.000
那是什麼樣的狀況呢
link |
15:48.000
首先機器會先看到一個遊戲畫面
link |
15:50.000
這個遊戲畫面呢
link |
15:51.000
我們就叫做F1
link |
15:52.000
看到一個遊戲畫面
link |
15:54.000
這個遊戲畫面就輸給machine
link |
15:56.000
就輸給這個actor
link |
15:57.000
就輸給這個actor
link |
15:59.000
那actor就要做一個決定
link |
16:01.000
決定說現在要做什麼
link |
16:03.000
決定說看到這個畫面
link |
16:05.000
看到這個畫面叫做F1
link |
16:07.000
那我要採取的行為叫做A1
link |
16:09.000
而A1就是向右移動
link |
16:12.000
那他向右移動以後
link |
16:14.000
他會得到一個reward
link |
16:16.000
在每一個time step
link |
16:17.000
在每一個互動的過程中
link |
16:19.000
在每一步互動的過程中
link |
16:21.000
reward function都會給machine一個reward
link |
16:25.000
那在這一步只是採取向右
link |
16:27.000
所以得到的reward是0
link |
16:28.000
只是採取向右
link |
16:29.000
不會得到任何的分數
link |
16:30.000
所以R1是0
link |
16:32.000
那機器採取這個行為之後
link |
16:34.000
他就會看到新的遊戲畫面
link |
16:36.000
至少他看到自己往右移了
link |
16:38.000
這個畫面是我從真實的遊戲截下來的
link |
16:42.000
他擺在這個地方
link |
16:43.000
然後他就往右移了
link |
16:45.000
然後往右移以後
link |
16:47.000
看到新的遊戲畫面
link |
16:49.000
機器就會決定要採取新的行為
link |
16:51.000
舉例來說
link |
16:52.000
他可能看到新的畫面
link |
16:54.000
這次他決定說看到畫面S2
link |
16:56.000
他要採取A2這個行為
link |
16:58.000
A2這個行為就是開火
link |
17:00.000
他決定要開火
link |
17:03.000
假設他開火以後
link |
17:05.000
他殺了一隻怪
link |
17:08.000
假設他開火以後
link |
17:09.000
他殺了一隻怪
link |
17:10.000
根據reward function的定義
link |
17:11.000
就會告訴他說你殺了一隻怪
link |
17:13.000
那假設殺那隻怪是5分
link |
17:15.000
那你就得到5分
link |
17:16.000
R2就得5分
link |
17:17.000
那看到新的遊戲畫面
link |
17:18.000
就S3
link |
17:19.000
那這個互動的過程
link |
17:21.000
就反覆的繼續下去
link |
17:23.000
直到說現在呢
link |
17:24.000
在某一個遊戲畫面
link |
17:26.000
機器決定採取action
link |
17:27.000
AT得到reward RT
link |
17:30.000
然後進入了terminal state
link |
17:32.000
按照這個主機的設定
link |
17:35.000
走到這邊遊戲就結束了
link |
17:36.000
那這個互動的過程就結束了
link |
17:38.000
那每一場遊戲啊
link |
17:40.000
叫做一個episode
link |
17:41.000
每一個互動
link |
17:42.000
從頭到尾
link |
17:44.000
在文獻上我們就會叫它一個episode
link |
17:46.000
那軟體玩裡面
link |
17:47.000
每一場遊戲叫episode
link |
17:49.000
在圍棋裡面
link |
17:50.000
每一局棋
link |
17:51.000
叫一個episode
link |
17:52.000
那在一個episode中
link |
17:54.000
我們把每一個step
link |
17:56.000
得到的reward
link |
17:57.000
R1 R2 R3到R大T
link |
17:59.000
通通加起來
link |
18:00.000
就叫做total reward
link |
18:01.000
那total reward呢
link |
18:03.000
我們就寫成大R
link |
18:06.000
那現在機器要做的事情是
link |
18:09.000
我們希望大R
link |
18:12.000
就是total reward的值
link |
18:13.000
在互動的過程中
link |
18:15.000
越大越好
link |
18:16.000
我們希望total reward的值
link |
18:17.000
在互動的過程中
link |
18:19.000
越大越好
link |
18:21.000
那我們再用另外一個簡化的圖
link |
18:23.000
來說明一下environment
link |
18:24.000
actor還有reward function之間的關係
link |
18:27.000
environment輸出一個step
link |
18:30.000
其實就是遊戲的畫面
link |
18:32.000
輸出或者可以說是
link |
18:33.000
state of approximation
link |
18:34.000
我剛才講過
link |
18:35.000
state of approximation
link |
18:36.000
在我心裡是一樣的東西
link |
18:37.000
輸出一個遊戲畫面S1
link |
18:39.000
S1輸入給actor
link |
18:41.000
actor就輸出說
link |
18:42.000
那我要執行A1
link |
18:44.000
那再把A1輸給environment
link |
18:46.000
environment就說
link |
18:47.000
我要執行S2
link |
18:48.000
那S2輸給actor
link |
18:49.000
actor就說
link |
18:50.000
我要執行A2
link |
18:51.000
然後environment
link |
18:52.000
在看你執行A2以後
link |
18:53.000
它再說現在有新的畫面S3
link |
18:55.000
就這樣反覆繼續下去
link |
18:57.000
那reward怎麼計算呢
link |
18:58.000
你有一個reward function
link |
18:59.000
這是這個遊戲的規則
link |
19:01.000
就reward function告訴我們說
link |
19:03.000
在state S1採取A1
link |
19:05.000
你把state S1跟A1
link |
19:06.000
丟到reward function
link |
19:07.000
那你得到的東西
link |
19:09.000
數字是R1
link |
19:10.000
得到的分數是R1
link |
19:12.000
在S2、A2
link |
19:13.000
在S2這個state
link |
19:14.000
你採取A2這個行為得到
link |
19:16.000
如果是R2
link |
19:17.000
這樣一次類推
link |
19:19.000
那我們如果把這個
link |
19:21.000
state跟action的這個序列
link |
19:23.000
就是在state S1採取action
link |
19:25.000
A1在state S2採取action
link |
19:27.000
A2的這個序列
link |
19:28.000
加起來叫做一個trajectory
link |
19:31.000
叫做一個trajectory
link |
19:34.000
那在這個trajectory
link |
19:36.000
在這個trajectory裡面呢
link |
19:39.000
這個A1跟這個S跟A的序列
link |
19:42.000
叫做trajectory
link |
19:44.000
那你把這些reward
link |
19:45.000
通通都加起來
link |
19:47.000
你就得到total reward大分
link |
19:49.000
也就是說
link |
19:50.000
你得到某一個
link |
19:51.000
跟trajectory套的reward
link |
19:53.000
R的套
link |
19:54.000
那我們現在說我們的目標
link |
19:56.000
就是希望可以調整這個actor
link |
19:59.000
使得你最後可以得到的reward
link |
20:03.000
越大越好
link |
20:05.000
好
link |
20:07.000
那接下來就是要講說
link |
20:08.000
怎麼調整這個actor
link |
20:10.000
在講調整actor之前
link |
20:11.000
我們當然需要先來看一下
link |
20:13.000
這個actor長什麼樣子
link |
20:15.000
那actor長什麼樣子呢
link |
20:17.000
actor也是一個neural network
link |
20:20.000
那其實這個reinforced learning
link |
20:22.000
從來都不是一個特別新的題目
link |
20:25.000
那現在我們講的這些技術
link |
20:27.000
其實在80年代
link |
20:28.000
就已經有相當完整的版本
link |
20:31.000
那近年來
link |
20:32.000
deep reinforcement learning
link |
20:33.000
又突然變得很紅
link |
20:34.000
到底有什麼不一樣的地方呢
link |
20:36.000
其他最不一樣的地方就是
link |
20:38.000
我們現在使用的neural network
link |
20:41.000
過去的actor
link |
20:42.000
它其實就是
link |
20:43.000
通常就是X標
link |
20:44.000
而不是neural network
link |
20:46.000
長久以來
link |
20:47.000
多數人都相信說
link |
20:49.000
當我們把這個actor
link |
20:51.000
換成一個nonlinear network的時候
link |
20:54.000
是無法train的
link |
20:55.000
它沒有辦法收斂
link |
20:56.000
沒有辦法證明它會收斂
link |
20:58.000
那怎麼辦
link |
20:59.000
就不要用它
link |
21:01.000
可是後來就是
link |
21:03.000
Google他們的貢獻就是
link |
21:05.000
他們想了一大堆的tips
link |
21:07.000
讓這個training
link |
21:08.000
能夠真的work起來
link |
21:10.000
所以現在
link |
21:11.000
當我們講actor的時候
link |
21:12.000
它其實都是一個neural network
link |
21:16.000
那這個neural network
link |
21:17.000
它的輸入輸出分別是什麼呢
link |
21:19.000
這個actor
link |
21:21.000
這個neural network
link |
21:22.000
它的輸入就是一個遊戲的畫面
link |
21:24.000
那這個遊戲的畫面
link |
21:25.000
就是由pixel所組成的嘛
link |
21:27.000
那你要處理影像
link |
21:28.000
通常就是需要用到CNN
link |
21:30.000
所以這個actor
link |
21:31.000
它的前幾個layer
link |
21:32.000
可能都是CNN
link |
21:34.000
為了要處理這個影像的遊戲的畫面
link |
21:37.000
又按到了
link |
21:39.000
那這個輸出呢
link |
21:41.000
這個輸出
link |
21:42.000
就是看你有幾個action
link |
21:45.000
輸出的每一個neural
link |
21:47.000
就對應到一個action
link |
21:49.000
就假設說
link |
21:50.000
現在你可以採取的action
link |
21:51.000
就是向左向右跟開火
link |
21:53.000
你可以做的事情就是
link |
21:54.000
向左向右跟開火
link |
21:56.000
那你的這個network
link |
21:58.000
它的output呢
link |
21:59.000
就有
link |
22:00.000
output layer就有三個neural
link |
22:01.000
分別對應到
link |
22:02.000
向左向右跟開火
link |
22:04.000
分別對應到
link |
22:05.000
向左向右跟開火
link |
22:07.000
好那假設
link |
22:08.000
現在輸入這個遊戲畫面
link |
22:10.000
向左的分數是0.7
link |
22:12.000
向右的分數是0.2
link |
22:13.000
開火的分數是0.1
link |
22:15.000
那最後
link |
22:16.000
actor會決定採取哪一個action呢
link |
22:18.000
通常你會做一個sampling
link |
22:20.000
你就根據這一個數值
link |
22:22.000
產生一個probability distribution
link |
22:24.000
有70%的機率向左
link |
22:26.000
20%的機率向右
link |
22:28.000
10%的機率開火
link |
22:30.000
那當然你也可以說
link |
22:31.000
我不想要這個stochastic的actor
link |
22:34.000
就我們剛剛說
link |
22:35.000
有70%的機率向左
link |
22:36.000
20%的機率向右
link |
22:37.000
10%的機率開火
link |
22:38.000
意味著說
link |
22:39.000
你的actor在同一個畫面下
link |
22:40.000
它會採取不同的行為
link |
22:42.000
像它是stochastic的
link |
22:43.000
它每次採取的行為都不一樣
link |
22:45.000
那這樣子當然有好處
link |
22:46.000
有好處就是
link |
22:47.000
比如說你的對手
link |
22:48.000
比較不容易識破你要做的事情
link |
22:50.000
那如果你不喜歡這樣的話
link |
22:51.000
你也可以說
link |
22:52.000
反正我就是
link |
22:53.000
看哪一個action
link |
22:55.000
得到分數最高
link |
22:56.000
我們就採取那個action
link |
22:57.000
這樣也可以
link |
22:58.000
反正就你可以想必要
link |
22:59.000
怎麼設計你的actor
link |
23:01.000
都是可以的
link |
23:03.000
好那過去其實
link |
23:05.000
會用一個這個lookup table
link |
23:07.000
來當作你的actor
link |
23:09.000
那用lookup table有什麼壞處呢
link |
23:11.000
有人會說
link |
23:12.000
如果用nevo是參數比較多
link |
23:15.000
然後用lookup table參數比較少
link |
23:16.000
其實不是用lookup table的參數太多
link |
23:18.000
用lookup table
link |
23:19.000
如果你一部是遊戲畫面
link |
23:20.000
你根本無法處理
link |
23:21.000
對不對
link |
23:22.000
如果用
link |
23:23.000
因為遊戲畫面是無窮無盡的
link |
23:25.000
你根本無法重舉
link |
23:26.000
所有可能發生的遊戲畫面
link |
23:28.000
你用lookup table就過了
link |
23:30.000
但是如果你說
link |
23:31.000
nevo就算是
link |
23:32.000
從來沒有看過的遊戲畫面
link |
23:33.000
你也可以把這個遊戲畫面
link |
23:34.000
丟進去看看
link |
23:35.000
會得到什麼樣的結果
link |
23:36.000
假設你這個nevo
link |
23:37.000
配得夠好
link |
23:38.000
它有generalization的能力
link |
23:40.000
那你可能也可以得到
link |
23:41.000
好的回應
link |
23:43.000
好那我們回到
link |
23:44.000
我們剛才要說的事情
link |
23:45.000
我們說
link |
23:46.000
actor environment
link |
23:47.000
跟reward function
link |
23:48.000
它們中間的互動
link |
23:49.000
就是這個樣
link |
23:50.000
那我們最想要做的事情是什麼
link |
23:52.000
我們想要做的事情是
link |
23:54.000
希望調整actor的參數
link |
23:56.000
注意一下我們不是都講過
link |
23:57.000
actor就是一個neural network嗎
link |
23:59.000
neural network就是
link |
24:00.000
輸入一個遊戲畫面
link |
24:01.000
就是state
link |
24:02.000
output就是
link |
24:03.000
現在要採取的action a
link |
24:04.000
輸入遊戲畫面
link |
24:05.000
採取一個action a
link |
24:07.000
actor是一個neural network
link |
24:09.000
ok是一個neural network
link |
24:11.000
好那我們希望說
link |
24:12.000
現在能夠達成的目標
link |
24:14.000
是希望整個episode
link |
24:16.000
所有的reward合起來
link |
24:17.000
它得到的total reward大法的值
link |
24:19.000
越大越好
link |
24:21.000
你如果看這個圖
link |
24:23.000
你知道怎麼解這個問題嗎
link |
24:27.000
仔細想想其實
link |
24:28.000
這個問題並沒有那麼難
link |
24:30.000
對不對
link |
24:31.000
因為你可以說
link |
24:32.000
你現在看喔
link |
24:33.000
你現在看
link |
24:34.000
假設
link |
24:37.000
reward function
link |
24:39.000
也是一個neural network
link |
24:41.000
假設reward function
link |
24:43.000
也是一個neural network
link |
24:44.000
這個neural network就是
link |
24:45.000
輸入state跟action
link |
24:46.000
給你一個分數
link |
24:48.000
假設environment
link |
24:49.000
也是一個neural network
link |
24:51.000
給它一個action
link |
24:52.000
它就輸出一個state
link |
24:54.000
這一整個畫面上
link |
24:56.000
這三個neural network串起來
link |
24:58.000
不就只是一個巨大的
link |
25:00.000
neural network而已嗎
link |
25:02.000
它可能在這邊
link |
25:03.000
有一個類似隨機的
link |
25:05.000
那個random seed當中
link |
25:07.000
你會去決定
link |
25:08.000
初始的畫面是什麼
link |
25:09.000
然後最後output
link |
25:11.000
就是一個數字
link |
25:12.000
那我說你們現在的目標
link |
25:14.000
就是希望這個數字
link |
25:16.000
越大越好
link |
25:18.000
大家可以想像嗎
link |
25:19.000
這是一個巨大的
link |
25:20.000
你假設
link |
25:21.000
這些東西都是neural
link |
25:22.000
假設這些東西都是neural
link |
25:24.000
把它們通通串起來
link |
25:25.000
你不就只是有一個
link |
25:26.000
巨大的neural
link |
25:27.000
然後你希望它的輸出
link |
25:29.000
越大越好
link |
25:31.000
那我們剛才有講說
link |
25:32.000
reward跟environment
link |
25:34.000
你是動不了的
link |
25:35.000
那是別人的東西
link |
25:36.000
你動不了
link |
25:37.000
你唯一能夠調
link |
25:38.000
只有actor的參數
link |
25:40.000
那在這個巨大的network裡面
link |
25:42.000
只有藍色的部分的參數
link |
25:44.000
你是可以調的
link |
25:45.000
你要調藍色的
link |
25:47.000
這個部分的參數
link |
25:49.000
使得最終的輸出的值
link |
25:51.000
越大越好
link |
25:52.000
這個你會做嗎
link |
25:54.000
這不就只是規定了set而已嗎
link |
25:56.000
對不對
link |
25:57.000
你現在看
link |
25:58.000
你想要讓這個R越大越好
link |
26:01.000
然後你從這個地方
link |
26:02.000
一路backup給回來
link |
26:05.000
你從這個地方
link |
26:06.000
一路backup給回來
link |
26:08.000
然後你就可以調
link |
26:09.000
actor的參數
link |
26:10.000
希望讓最終的output
link |
26:12.000
越大越好
link |
26:13.000
這樣大家可以
link |
26:14.000
接受這個想法嗎
link |
26:16.000
你自己想想看
link |
26:17.000
這個東西聽起來
link |
26:18.000
跟gain也蠻像的
link |
26:19.000
剛才講gain的時候
link |
26:20.000
我們說有一個generator
link |
26:22.000
然後generator
link |
26:23.000
會把它的輸出
link |
26:24.000
接給discriminator
link |
26:25.000
那generator調整它的參數
link |
26:27.000
讓discriminator輸出的值
link |
26:28.000
越大越好
link |
26:29.000
那現在
link |
26:30.000
我們有environment
link |
26:31.000
有reward有actor
link |
26:32.000
這個environment跟reward
link |
26:33.000
就可以想成是discriminator
link |
26:36.000
我們要調actor的參數
link |
26:37.000
actor你就想成是generator
link |
26:38.000
我們要調actor的參數
link |
26:40.000
讓它輸出的東西
link |
26:41.000
通過reward function
link |
26:42.000
以後output的值
link |
26:44.000
越大越好
link |
26:45.000
這個不是跟
link |
26:46.000
前面gain做的事情
link |
26:47.000
非常的像嗎
link |
26:50.000
對不對
link |
26:51.000
那這個東西你會不會做呢
link |
26:52.000
假設reward是個network
link |
26:54.000
environment是一個network
link |
26:56.000
用backup gauge
link |
26:57.000
一路backup回去
link |
26:58.000
就可以調actor的參數
link |
26:59.000
去maximize最終的output
link |
27:00.000
這個你是
link |
27:02.000
我假設你是會做的
link |
27:03.000
好那現在難點是什麼
link |
27:05.000
現在的難點是
link |
27:07.000
這個environment跟reward
link |
27:09.000
就不是neural network
link |
27:10.000
它是個黑盒子
link |
27:11.000
好嗎
link |
27:12.000
它是個黑盒子
link |
27:13.000
你根本不知道它是什麼東西
link |
27:15.000
如果下圍棋的話
link |
27:16.000
你的environment是一個對手
link |
27:17.000
它其實也是一個neural network
link |
27:19.000
不過你沒辦法把它
link |
27:20.000
剖開來看就是了
link |
27:21.000
如果是下圍棋的話
link |
27:23.000
你的reward就是圍棋的規則
link |
27:25.000
那很複雜
link |
27:26.000
你可能也不知道
link |
27:27.000
怎麼把它用成neural network
link |
27:28.000
來表示它
link |
27:29.000
好那
link |
27:30.000
現在真正遇到的問題是
link |
27:32.000
我們想要maximize這個R
link |
27:35.000
但是reward的function
link |
27:37.000
它的參數我們不知道
link |
27:39.000
environment的function
link |
27:40.000
它的參數
link |
27:41.000
我們也不知道
link |
27:43.000
怎麼辦
link |
27:44.000
怎麼辦
link |
27:45.000
本來如果這兩個東西
link |
27:46.000
它就是neural network
link |
27:47.000
它是我知道
link |
27:48.000
我們知道怎麼調參數
link |
27:49.000
去maximize它
link |
27:50.000
但實際上不知道
link |
27:51.000
好那怎麼辦呢
link |
27:52.000
這邊你只要記得一個口訣
link |
27:54.000
這個口訣就是
link |
27:55.000
如果你今天發現你要
link |
27:57.000
optimize的function
link |
27:58.000
不能微分的話
link |
27:59.000
就用%c歸零這個技術
link |
28:01.000
硬勸一發就結束了
link |
28:03.000
這樣子
link |
28:04.000
如果你要知道%c歸零是什麼的話
link |
28:06.000
請參看下面這個
link |
28:08.000
這個連結
link |
28:09.000
我放了一個我上課的
link |
28:10.000
這個推導給大家
link |
28:12.000
給大家參考
link |
28:13.000
但今天只要記得說
link |
28:15.000
如果
link |
28:16.000
有叫你maximize一個東西
link |
28:17.000
比如說我們要maximize這個R
link |
28:19.000
但是問題就是這個東西
link |
28:21.000
有這個environment的reward
link |
28:23.000
導致我們無法微分
link |
28:24.000
那怎麼辦
link |
28:25.000
反正就是有一招
link |
28:26.000
叫做%c歸零
link |
28:28.000
它可以去調這個
link |
28:29.000
app的參數
link |
28:30.000
讓我們最終可以去out這個R
link |
28:32.000
就結束了
link |
28:33.000
就是reinforcement learning
link |
28:35.000
做的事情
link |
28:37.000
這個就是reinforcement learning
link |
28:38.000
做的事情
link |
28:41.000
好
link |
28:42.000
講到這邊也許
link |
28:43.000
我知道說這個跟
link |
28:44.000
一般你平常聽到的
link |
28:46.000
reinforcement learning的講法
link |
28:47.000
也許不太一樣
link |
28:48.000
通常如果你看
link |
28:49.000
有David Silver的video的話
link |
28:51.000
通常先從
link |
28:52.000
這個Markov decision process
link |
28:54.000
開始講
link |
28:55.000
然後等你去完Markov decision process
link |
28:57.000
以為自己聽懂了
link |
28:58.000
你就開始想睡了
link |
28:59.000
然後剩下的東西你都聽不懂了
link |
29:00.000
這樣子
link |
29:01.000
然後再講一次一樣的東西
link |
29:02.000
其實你也是聽不懂
link |
29:03.000
所以這邊是採取一個
link |
29:04.000
不太一樣的講法
link |
29:05.000
告訴你
link |
29:06.000
其實reinforcement learning
link |
29:08.000
做的事情就是這個樣子
link |
29:11.000
我們可以停下來幾秒鐘
link |
29:12.000
看有沒有問題要問的
link |
29:14.000
如果沒有也沒關係
link |
29:20.000
有嗎
link |
29:21.000
如果沒有就算了
link |
29:22.000
有嗎
link |
29:23.000
有同學要問問題的嗎
link |
29:28.000
有嗎
link |
29:29.000
沒有的話我們就繼續
link |
29:31.000
那我們就不要講
link |
29:32.000
policy gradient的部分
link |
29:33.000
你只要記得這個口訣
link |
29:35.000
就是發現
link |
29:36.000
只要是不能違憤的東西
link |
29:37.000
policy gradient就可以
link |
29:38.000
反正可以幫你optimize就是了
link |
29:42.000
policy gradient
link |
29:43.000
這邊其實也不是推導
link |
29:44.000
這邊只是想要講
link |
29:45.000
實作是怎麼做的
link |
29:47.000
推導的部分
link |
29:48.000
其實還有實作具體的
link |
29:49.000
怎麼做你永遠可以看
link |
29:51.000
以下我線上課程的錄影
link |
29:55.000
這個部分
link |
29:56.000
這個部分就
link |
29:59.000
這個部分就把它跳過
link |
30:01.000
好那我們剛才講了
link |
30:04.000
actor怎麼稱
link |
30:06.000
接下來我們要講另外一個東西
link |
30:08.000
這個東西叫做credit
link |
30:10.000
credit做的事情是什麼
link |
30:12.000
credit本身並沒有辦法決定
link |
30:15.000
要採取哪一個action
link |
30:17.000
credit本身
link |
30:19.000
並沒有辦法決定
link |
30:21.000
要採取哪一個action
link |
30:23.000
那credit可以做的事情是什麼呢
link |
30:25.000
credit可以做的事情是
link |
30:27.000
給它一個actor pi
link |
30:29.000
它可以告訴你說
link |
30:30.000
這一個actor pi
link |
30:32.000
它有多好
link |
30:33.000
什麼叫做這個actor pi有多好呢
link |
30:35.000
這個credit其實有很多種
link |
30:37.000
我們先介紹一個
link |
30:38.000
state value的這個function
link |
30:40.000
state value function
link |
30:41.000
這邊寫成v pi of x
link |
30:43.000
它做的事情就是
link |
30:44.000
給它一個actor pi
link |
30:46.000
它告訴你說
link |
30:47.000
現在在給一個actor pi的前提之下
link |
30:50.000
假設我們看到一個
link |
30:52.000
observation或者是state x
link |
30:54.000
那接下來
link |
30:56.000
一直到遊戲結束的時候
link |
30:58.000
會得到的reward
link |
31:00.000
總和的期望值
link |
31:02.000
有多大
link |
31:03.000
那注意一下
link |
31:04.000
今天我們算的
link |
31:05.000
並不是看到這個state之後
link |
31:07.000
下一秒會得到reward
link |
31:09.000
而是看到這個state之後
link |
31:12.000
所有accumulated reward的期望值
link |
31:16.000
或者是舉例來說
link |
31:17.000
如果以下圍棋為例的話
link |
31:19.000
這個v pi of x的意思就是說
link |
31:21.000
假設你已經有一個下圍棋的agent
link |
31:24.000
叫做pi
link |
31:25.000
那你現在給它一個
link |
31:27.000
observation就是棋盤的盤勢
link |
31:29.000
比如說出手天元
link |
31:31.000
出手後的一個
link |
31:32.000
出手下在天元
link |
31:33.000
那接下來
link |
31:34.000
v pi of x的意思就是說
link |
31:36.000
從出手下到天元
link |
31:38.000
一直到遊戲結束為止
link |
31:40.000
假設今天在圍棋裡面
link |
31:42.000
遊戲結束贏了就得到分數1
link |
31:44.000
輸了就得到分數負1
link |
31:46.000
在其他的狀況下
link |
31:47.000
你都不會得到
link |
31:48.000
任何分數得到的分數都是0
link |
31:50.000
那v pi of x
link |
31:52.000
x是出手天元
link |
31:53.000
假設x是出手天元的話
link |
31:55.000
v pi of x就是
link |
31:56.000
假設出手下在天元
link |
31:58.000
你接下來勝
link |
31:59.000
獲勝的機率有多大
link |
32:01.000
就是v pi of x
link |
32:02.000
假設出手下在天元
link |
32:04.000
然後你的x是pi
link |
32:06.000
那你獲勝的機率有多大
link |
32:08.000
這個就是v pi of x
link |
32:10.000
那如果圖像化的方式來畫它的話
link |
32:12.000
就是有一個function叫做v pi
link |
32:14.000
給它一個state
link |
32:16.000
然後它就會發出一個數值
link |
32:18.000
叫做v pi of x
link |
32:20.000
那這個數值代表什麼
link |
32:21.000
這個數值就代表了說
link |
32:23.000
這個actor
link |
32:24.000
假設我們用pi這個actor
link |
32:27.000
在state x的時候
link |
32:28.000
接下來
link |
32:29.000
看到state x
link |
32:30.000
接下來它會得到的
link |
32:31.000
reward的期望值有多大
link |
32:34.000
舉例來說
link |
32:35.000
這邊這個
link |
32:36.000
假設你有一個很強的actor
link |
32:38.000
然後呢
link |
32:39.000
它看到這個遊戲的畫面
link |
32:40.000
接下來很多怪
link |
32:41.000
因為它很多怪可以殺
link |
32:42.000
所以接下來它可以得到很高的分數
link |
32:44.000
所以v pi of x就很大
link |
32:46.000
這邊一樣
link |
32:47.000
這邊舉另外一個例子
link |
32:48.000
如果看到這個遊戲畫面
link |
32:49.000
剩下的怪已經很少了
link |
32:50.000
那v pi of x呢
link |
32:52.000
就會比較小
link |
32:53.000
因為它到遊戲結束的時候
link |
32:54.000
可以得到的分數已經比較少了
link |
32:56.000
因為其他怪都已經被殺完了
link |
32:58.000
剩下的怪呢
link |
32:59.000
已經很少了
link |
33:01.000
那這邊有一件事
link |
33:02.000
你要特別注意就是
link |
33:03.000
當你看到這種critic的時候啊
link |
33:06.000
critic都是depend on actor的
link |
33:08.000
給不同的actor
link |
33:09.000
就算是同樣的state
link |
33:11.000
critic的output也是不一樣
link |
33:13.000
因為我們說critic的工作
link |
33:14.000
就是衡量一個actor
link |
33:16.000
這樣衡量一個actor好不好
link |
33:18.000
所以給它不同的actor
link |
33:21.000
就算是同一個state
link |
33:23.000
它得到的分數也是不一樣
link |
33:26.000
我們舉一個麒麟王的例子
link |
33:28.000
我不知道大家有沒有看過麒麟王
link |
33:29.000
假設你有看過好了
link |
33:30.000
這個例子是這樣子
link |
33:32.000
這個應該是在打洛斯之戰前後
link |
33:34.000
我忘了是在打洛斯之戰之前
link |
33:36.000
還是打洛斯之戰之後
link |
33:37.000
這個是佐維
link |
33:39.000
阿光跟佐維下集
link |
33:41.000
佐維說
link |
33:42.000
阿光這個時候不要下小馬不飛
link |
33:44.000
要下大馬不飛
link |
33:46.000
那這是佐維
link |
33:47.000
佐維這樣說
link |
33:48.000
阿光說大馬
link |
33:49.000
我覺得小馬也不錯啊
link |
33:51.000
那佐維說
link |
33:52.000
要是大馬不飛有一百首的話
link |
33:54.000
小馬不飛就只有九十六首
link |
33:56.000
我們不要把這首回去
link |
33:57.000
擔心這首回去
link |
33:58.000
好那重要是這個
link |
34:00.000
佐維說
link |
34:01.000
之前走小馬不飛是對的
link |
34:03.000
因為小馬不飛的後續
link |
34:05.000
比較容易預測
link |
34:06.000
也比較不容易出錯
link |
34:08.000
但是現在因為阿光比較強了
link |
34:10.000
所以應該要下大馬不飛
link |
34:12.000
所以如果把它對應到critic的話
link |
34:14.000
佐維這個critic
link |
34:15.000
他說的意思就是說
link |
34:17.000
如果X是以前的阿光
link |
34:19.000
那你不應該下大馬不飛
link |
34:22.000
以前的阿光
link |
34:23.000
如果類似下大馬不飛的話
link |
34:25.000
是壞的
link |
34:26.000
因為以前的阿光比較弱
link |
34:28.000
下大馬不飛的話
link |
34:29.000
就比較複雜
link |
34:30.000
比較吃臭
link |
34:31.000
會下得不好
link |
34:32.000
但是因為阿光他後來變強了
link |
34:34.000
所以如果是要evaluate
link |
34:36.000
變強的阿光這個X的話
link |
34:38.000
下大馬不飛
link |
34:39.000
就會變成好
link |
34:40.000
所以這個圖要強調的意思就是說
link |
34:42.000
今天你的critic
link |
34:44.000
其實會隨著X的不同
link |
34:46.000
而得到不同的分數
link |
34:49.000
好那再來要講的就是
link |
34:53.000
怎麼算這個critic
link |
34:55.000
怎麼評估這個critic呢
link |
34:58.000
有兩個方法
link |
34:59.000
一個是multicolor的方法
link |
35:01.000
另外一個是temporal difference的方法
link |
35:04.000
那multicolor的方法
link |
35:05.000
其實非常的直觀
link |
35:06.000
multicolor的方法就是說
link |
35:08.000
今天critic怎麼衡量一個actor好不好
link |
35:11.000
他就去看那個actor玩遊戲
link |
35:13.000
假設你玩遊戲為例子
link |
35:15.000
你打電玩為例子
link |
35:16.000
我們就critic就去看那個actor
link |
35:18.000
拍完遊戲
link |
35:19.000
看actor拍的
link |
35:20.000
玩的
link |
35:21.000
玩的怎麼樣
link |
35:23.000
那假設現在critic觀察到說
link |
35:26.000
actor拍在經過這個state SA以後
link |
35:30.000
他會得到的
link |
35:32.000
accumulated reward
link |
35:33.000
就從state SA之後
link |
35:35.000
這個actor拍他會得到reward是GA
link |
35:39.000
那這個critic就要學說
link |
35:42.000
如果input state SA
link |
35:44.000
那我的output要跟GA越接近越好
link |
35:47.000
這個就是一個regression的問題
link |
35:49.000
就看到state A
link |
35:51.000
那這個actor要調他的參數
link |
35:54.000
讓他的output跟GA越接近越好
link |
35:56.000
那假設要觀察到說
link |
35:58.000
現在actor跑到state B
link |
36:00.000
玩到遊戲結束的時候
link |
36:02.000
會得到accumulated reward GB
link |
36:04.000
那現在輸入state B
link |
36:06.000
我們就一直按照
link |
36:08.000
試驗輸入state B
link |
36:11.000
那他的output就要跟GB越接近越好
link |
36:16.000
那這個很直觀
link |
36:18.000
這個就是Monte Carlo的方法
link |
36:20.000
另外一個比較不直觀的方法
link |
36:22.000
叫做temporal difference的方法
link |
36:24.000
那temporal difference的方法是說
link |
36:26.000
我們現在一樣讓actor去看
link |
36:28.000
一樣讓critic去看那個actor玩遊戲
link |
36:31.000
那讓critic看到actor在做什麼呢
link |
36:33.000
他看到actor在state SP
link |
36:36.000
採取action AT
link |
36:38.000
接下來呢
link |
36:39.000
得到reward RT
link |
36:40.000
然後跳到state SP加E
link |
36:42.000
光看到這樣一個data
link |
36:45.000
一筆data
link |
36:46.000
之前我們那個
link |
36:47.000
在前一頁做Monte Carlo的時候
link |
36:49.000
看到某一個state
link |
36:50.000
必須要一直玩到遊戲結束
link |
36:51.000
我們才知道accumulated reward是多少
link |
36:54.000
但是在temporal difference的時候
link |
36:56.000
只要看這樣一筆data
link |
36:58.000
那個critic就可以學了
link |
37:00.000
actor只要在某一個state
link |
37:02.000
採取某一個行為
link |
37:03.000
critic就可以學了
link |
37:04.000
為什麼critic可以學呢
link |
37:06.000
他就是備戰這個時機
link |
37:08.000
因為我們現在這個VPILOT的state
link |
37:11.000
是要衡量在ST這個state
link |
37:13.000
會得到的accumulated reward
link |
37:15.000
VPILOT ST加E
link |
37:17.000
是要衡量在ST加E這個state
link |
37:19.000
會得到的accumulated reward
link |
37:21.000
今天如果我們觀察到
link |
37:23.000
在ST這個state
link |
37:24.000
會得到reward RT
link |
37:26.000
跳到ST加E
link |
37:28.000
意味著說
link |
37:29.000
在ST加E跟ST中間
link |
37:32.000
他們差的reward就是RT
link |
37:35.000
這一下你會得到
link |
37:37.000
accumulated reward是這一下
link |
37:39.000
然後
link |
37:41.000
這一下你得到
link |
37:42.000
accumulated reward是這一下
link |
37:44.000
他們中間經過了
link |
37:45.000
得到reward RT這件事
link |
37:47.000
所以他們中間的差異
link |
37:49.000
就是RT
link |
37:51.000
那在訓練network的時候
link |
37:53.000
怎麼辦呢
link |
37:54.000
訓練network的時候
link |
37:55.000
你就說
link |
37:56.000
現在把ST丟進去
link |
37:58.000
你會得到一個分數
link |
38:00.000
把ST加E丟進去
link |
38:02.000
你會得到另外一個分數
link |
38:04.000
我們希望
link |
38:05.000
這兩個分數的差
link |
38:07.000
跟RT越接近越好
link |
38:09.000
所以現在訓練的目標
link |
38:10.000
你不知道這個實際上的值是多少
link |
38:12.000
你知道這個實際上的值是多少
link |
38:14.000
不知道
link |
38:15.000
因為還沒有玩到遊戲結束
link |
38:16.000
所以你不知道
link |
38:17.000
accumulated reward是多少
link |
38:18.000
但你學到一件事
link |
38:19.000
你學到的事情是
link |
38:21.000
雖然我不知道他們的值是多少
link |
38:23.000
但我知道一件事
link |
38:24.000
就是他們差了RT
link |
38:25.000
所以就告訴我們
link |
38:26.000
就是說看到ST的時候你輸出的值
link |
38:28.000
跟看到ST加E的時候輸出的值
link |
38:30.000
中間又差了RT
link |
38:31.000
然後熱下去
link |
38:33.000
就結束了
link |
38:34.000
那因為Temporal Difference
link |
38:35.000
也會非常明確的好處就是
link |
38:38.000
今天當遊戲還沒有結束
link |
38:40.000
玩到一半的時候
link |
38:42.000
你就可以開始update你的network
link |
38:45.000
那有時候有一些遊戲非常的長
link |
38:47.000
如果你沒有辦法一邊玩遊戲
link |
38:49.000
一邊update你的network的話
link |
38:51.000
那你會搞太久
link |
38:53.000
所以在Temporal Difference呢
link |
38:55.000
是有它的好處的
link |
38:57.000
這邊是比較Temporal Difference跟DD
link |
39:02.000
我們可以把這幾頁投影片略過
link |
39:07.000
那其實這個也是從Saturn的文書
link |
39:09.000
copy出來的而已
link |
39:11.000
所以你可以自己去看一下
link |
39:12.000
Saturn寫的教科書
link |
39:14.000
好那接下來
link |
39:16.000
我們剛才講了一個critic
link |
39:18.000
這個critic是給他一個state
link |
39:20.000
他會衡量說
link |
39:21.000
這個state到遊戲結束的時候
link |
39:24.000
他會得到多少的reward
link |
39:26.000
那一種critic沒有辦法拿來決定action
link |
39:30.000
但是有另外一種critic
link |
39:32.000
他可以拿來決定action
link |
39:34.000
這種critic我們叫做Q-function
link |
39:38.000
這種Q-function
link |
39:42.000
它的input就是一個state跟一個action
link |
39:46.000
那他到底在量什麼
link |
39:48.000
他量的都是
link |
39:49.000
給我一個actor pi
link |
39:53.000
他會衡量說
link |
39:54.000
在給我一個actor pi的前提之下
link |
39:56.000
在observation的state S
link |
40:00.000
在observation S採取了action A
link |
40:03.000
在這一個state採取了這個action A的話
link |
40:07.000
到遊戲結束的時候
link |
40:08.000
會得到多少interrelated的reward
link |
40:11.000
之前B他只量在S的時候
link |
40:14.000
會得到多少的reward
link |
40:16.000
現在是量在S採取了A
link |
40:19.000
會得到多少的reward
link |
40:21.000
當你採取的action不同
link |
40:22.000
非常直觀的採取的action不同
link |
40:24.000
你得到的reward就不一樣了
link |
40:26.000
那之前B他沒量這件事
link |
40:28.000
他沒有量說你會採取哪一個action
link |
40:30.000
那今天Q會量說
link |
40:32.000
在state S採取action A的時候
link |
40:34.000
會得到多少的reward
link |
40:36.000
那所以Q呢
link |
40:38.000
理論上他有兩個input
link |
40:40.000
S跟A
link |
40:41.000
那吃S跟A
link |
40:42.000
決定說他要得到多少的分數
link |
40:46.000
那有時候我們會改寫這個Q-function
link |
40:49.000
假設你的A是可以窮取的
link |
40:51.000
舉例來說在玩遊戲的時候
link |
40:53.000
A只有向左向右跟開火三個選擇
link |
40:56.000
那你就可以說
link |
40:57.000
我們現在能認一個Q-function
link |
41:00.000
我們的Q-function是input一個state S
link |
41:02.000
他的output分別就是
link |
41:04.000
Q-pilot S A等於left
link |
41:07.000
Q-pilot S A等於right
link |
41:09.000
跟Q-pilot S A等於find
link |
41:11.000
這樣的好處就是
link |
41:12.000
你只要輸入一個state S
link |
41:13.000
你就可以知道說
link |
41:15.000
S配上向左的時候分數是多少
link |
41:18.000
S配上向右的時候分數是多少
link |
41:20.000
S配上開火的時候分數是多少
link |
41:22.000
那在這個case
link |
41:23.000
你必須要把不同的A跟A的代進去
link |
41:25.000
你才可以算出他們的Q-function
link |
41:27.000
那在這個case
link |
41:28.000
你只要S代進去
link |
41:29.000
就可以一次把所有的分數呢
link |
41:31.000
或不同的action呢
link |
41:33.000
他的分數都算出來
link |
41:35.000
那有了這個Q有什麼用咧
link |
41:38.000
有了這個Q有什麼用咧
link |
41:39.000
他的妙用是這個樣子
link |
41:41.000
你可以用Q-function
link |
41:44.000
找出一個比較好的actor
link |
41:47.000
這一招就叫做Q-learning
link |
41:50.000
所以這個Q-learning的整個process是這樣
link |
41:53.000
你有一個你初始的actor pi
link |
41:56.000
你用一個初始的actor pi
link |
41:58.000
然後這個actor pi去玩
link |
42:00.000
跟這個環境互動
link |
42:02.000
然後我們說Q-learning的工作
link |
42:04.000
就是去觀察這個actor pi
link |
42:06.000
他跟環境的互動
link |
42:07.000
那他可以透過TD或某其他的方法
link |
42:10.000
去學出這個Q-function
link |
42:12.000
他可以去估測說
link |
42:14.000
根據這個pi跟環境互動的資料
link |
42:16.000
用TD或某其他的方法
link |
42:18.000
你可以估測說
link |
42:19.000
現在給定這個actor的前提之下
link |
42:22.000
在某一個state開去某一個action
link |
42:24.000
得到的Q-value是多少
link |
42:26.000
假設估測出這種Q-function以後
link |
42:30.000
估測出這種query以後
link |
42:32.000
可以保證一件事
link |
42:33.000
這個我們仔細給我們
link |
42:34.000
等一下葉同學再講
link |
42:36.000
可以保證什麼事
link |
42:37.000
可以保證我們說
link |
42:38.000
我們一定能夠找到一個新的actor pi
link |
42:41.000
他比原來的pi更好
link |
42:44.000
我們本來有一個actor pi
link |
42:46.000
我們就觀察他
link |
42:47.000
去跟環境的互動的狀況
link |
42:49.000
然後我們估測出
link |
42:51.000
我們認出一個query
link |
42:52.000
他估測actor pi
link |
42:54.000
在某一個state開去某一個action的時候
link |
42:57.000
會得到的分數
link |
42:59.000
然後接下來
link |
43:01.000
有了這個Q以後
link |
43:02.000
保證我們可以找到一個
link |
43:04.000
另外一個新的actor pi
link |
43:06.000
他比原來的pi還要好
link |
43:08.000
這樣我們是不是就找到一個
link |
43:09.000
比較好的actor了
link |
43:11.000
所以你有這個比較好的actor pi
link |
43:13.000
pi以後你就把這個pi
link |
43:14.000
用pi prime取代掉
link |
43:15.000
你就把這個pi
link |
43:16.000
用pi prime取代掉
link |
43:17.000
你有新的actor
link |
43:18.000
觀察一下量出新的actor的Q function
link |
43:22.000
再找到一個更好的actor
link |
43:24.000
本來是pi prime
link |
43:25.000
那現在就變成pi double prime
link |
43:26.000
然後再重新來一次
link |
43:28.000
那你的actor是不是就越早越好
link |
43:30.000
那這就是我們要的嘛
link |
43:31.000
你就可以找到越來越好的問題
link |
43:33.000
所以Q function的這個精神就是這樣
link |
43:36.000
它最重點的地方就是這一步
link |
43:38.000
就是這個打問號這一步
link |
43:40.000
只要量得出Q function
link |
43:42.000
接下來就可以
link |
43:43.000
一定可以找到一個
link |
43:44.000
更好的actor pi prime
link |
43:47.000
好那什麼
link |
43:48.000
聖傑克先生到底是怎麼說的呢
link |
43:50.000
他的這個理論就是這個樣子
link |
43:52.000
他的理論是說
link |
43:53.000
證明在下一頁啦
link |
43:54.000
證明在下一頁
link |
43:56.000
那證明我們就不要講這樣子
link |
43:58.000
那個理論是這樣
link |
43:59.000
理論上是說
link |
44:00.000
什麼叫做pi prime一定比pi好
link |
44:03.000
pi prime比pi好的定義是說
link |
44:06.000
給所有可能的state s
link |
44:09.000
給所有可能的state s
link |
44:12.000
如果你用pi去玩這個遊戲
link |
44:14.000
得到的reward
link |
44:16.000
用pi去玩遊戲
link |
44:17.000
得到的accumulated reward
link |
44:19.000
一定會小
link |
44:20.000
我們已經定義過V了嘛
link |
44:21.000
這是為什麼前面要講V
link |
44:22.000
就是為了要講這個啦
link |
44:23.000
所以你V的定義
link |
44:25.000
大家應該已經知道了
link |
44:26.000
就是給所有可能state s
link |
44:28.000
如果你採取pi這個actor
link |
44:30.000
跟你採取pi prime這個actor
link |
44:32.000
pi prime這個actor
link |
44:33.000
得到的accumulated reward
link |
44:35.000
一定會大過pi這個actor
link |
44:37.000
所以pi prime會得到reward
link |
44:38.000
一定比pi大
link |
44:39.000
不管是哪一個state
link |
44:40.000
那就代表pi prime
link |
44:41.000
是一個比較好的actor
link |
44:44.000
好 那怎麼根據這個Q
link |
44:47.000
找到一個比較好的actor
link |
44:49.000
pi prime呢
link |
44:50.000
它的原理就是
link |
44:51.000
就是只有下面這條式子
link |
44:53.000
這個比較好的actor
link |
44:55.000
pi prime怎麼來啊
link |
44:56.000
這個pi prime就是
link |
44:59.000
給你一個Q function
link |
45:01.000
這個Q function是拿來衡量
link |
45:03.000
pi這個actor的Q function
link |
45:06.000
然後我們說
link |
45:08.000
給某一個state的時候
link |
45:10.000
窮取所有可能的action
link |
45:12.000
看看哪一個action的Q value最大
link |
45:14.000
把那個action當作新的actor
link |
45:17.000
pi prime的輸出
link |
45:18.000
就我們一個新的actor pi prime
link |
45:20.000
但它其實是空的
link |
45:21.000
它其實不太會做決定
link |
45:22.000
它怎麼做決定
link |
45:23.000
它都聽Q的
link |
45:24.000
它自己其實沒有參數
link |
45:25.000
它根本沒有參數
link |
45:26.000
它都聽Q的
link |
45:27.000
所以你不說
link |
45:28.000
給你一個state s
link |
45:29.000
pi prime你想要做什麼樣的行為呢
link |
45:31.000
它就說
link |
45:32.000
那我們把Q找出來
link |
45:33.000
Q其實只看過pi
link |
45:35.000
它是看pi的
link |
45:36.000
它看pi的
link |
45:37.000
Q是說
link |
45:38.000
它之前看過pi做的事情
link |
45:40.000
它知道說
link |
45:41.000
pi這個actor
link |
45:42.000
在s採取a的時候
link |
45:44.000
會得到多少的reward
link |
45:46.000
然後它說窮取所有可能的a
link |
45:48.000
看看哪一個a
link |
45:49.000
可以讓這個function最大
link |
45:50.000
然後這個a
link |
45:51.000
pi prime就說
link |
45:52.000
這個a就是它的輸出了
link |
45:53.000
然後就結束了
link |
45:55.000
然後這個pi prime
link |
45:56.000
就一定會比pi還要好
link |
45:59.000
好
link |
46:01.000
那這邊有一個顯然的問題
link |
46:03.000
是什麼問題
link |
46:04.000
我們不能夠解這個
link |
46:05.000
Argmax的花紋
link |
46:06.000
如果a是discrete的
link |
46:07.000
只是說只有向左向右開火
link |
46:09.000
你就只需要把
link |
46:10.000
向左向右開火
link |
46:11.000
分別帶到Q function裡面
link |
46:12.000
看你會得到什麼樣的結果
link |
46:14.000
但是比較慘的地方是
link |
46:16.000
Q learning
link |
46:17.000
雖然好像聽起來很厲害
link |
46:19.000
但是如果你今天
link |
46:20.000
你的actions無法窮取
link |
46:22.000
它是continuous的一個爆炸
link |
46:24.000
你就不能夠解這個
link |
46:25.000
Argmax的花紋
link |
46:27.000
那至於這個理論的證明
link |
46:30.000
就其實還蠻簡單
link |
46:32.000
第二段影片就可以講了
link |
46:33.000
但是我們就不要講這個了
link |
46:36.000
那Q怎麼量
link |
46:37.000
你就可以用TDE來量
link |
46:40.000
好那其實Q learning
link |
46:42.000
有非常非常多的trick
link |
46:44.000
那你要怎麼找那些trick呢
link |
46:46.000
你就去google一篇paper
link |
46:47.000
叫做Rainbow
link |
46:48.000
就是彩虹的意思
link |
46:50.000
你就去google一篇paper
link |
46:51.000
叫做Rainbow
link |
46:52.000
然後裡面就講了
link |
46:54.000
七種不同的DQN的tip
link |
46:58.000
這樣子
link |
46:59.000
因為正好七種
link |
47:00.000
就對到彩虹的七個顏色
link |
47:02.000
他在做圖的時候
link |
47:03.000
每一個方法
link |
47:04.000
就對應到彩虹的一個顏色
link |
47:06.000
所以他把這個方法呢
link |
47:08.000
他把他的paper就取做Rainbow
link |
47:11.000
那我們的細節
link |
47:13.000
也許就不需要講
link |
47:15.000
那裡面有很多的技術
link |
47:17.000
舉例來說一個Double
link |
47:18.000
我覺得比較好實作的是
link |
47:20.000
Double DQN跟During DQN
link |
47:23.000
那細節如果你自己要
link |
47:24.000
implement DQN的時候
link |
47:26.000
你再去看看那些paper
link |
47:27.000
總之DQN有很多的tip
link |
47:30.000
可以讓他做得比較好
link |
47:32.000
那這些都整理在Rainbow
link |
47:35.000
那一篇paper裡面了
link |
47:37.000
那最後我們要講這個
link |
47:40.000
Actor加上Critic
link |
47:42.000
同時使用的技術
link |
47:44.000
就我們剛才有講說
link |
47:45.000
怎麼認一個Actor
link |
47:46.000
我們也講說
link |
47:47.000
怎麼認一個Critic
link |
47:49.000
那我們也講說其實
link |
47:50.000
Critic也有辦法告訴我們說
link |
47:52.000
怎麼樣排序
link |
47:53.000
什麼樣的action才是對的
link |
47:54.000
那接下來我們要講的是
link |
47:57.000
Actor加Critic的技術
link |
48:01.000
那什麼是Actor加Critic的技術呢
link |
48:04.000
有一個非常知名的方法
link |
48:07.000
叫做A3C
link |
48:09.000
也許大家都有聽過
link |
48:10.000
那A3C就是這三個A
link |
48:13.000
而且是什麼呢
link |
48:14.000
它的前兩個A
link |
48:15.000
就是Advantage的Actor Critic
link |
48:18.000
所以它這個是A2C
link |
48:20.000
等一下再講第三個A是什麼
link |
48:23.000
好那這個Advantage的Actor Critic
link |
48:25.000
它是什麼意思呢
link |
48:26.000
它是說
link |
48:28.000
這邊我就沒有把細節說出來
link |
48:30.000
它的概念其實很簡單
link |
48:33.000
我們之前在認這個Actor的時候
link |
48:36.000
我們是看reward function的output
link |
48:40.000
來決定Actor
link |
48:41.000
需要怎麼樣update
link |
48:43.000
才可以得到最好的reward
link |
48:47.000
那是因為今天實際上
link |
48:48.000
在這個互動的過程中
link |
48:51.000
實際上在這個互動的過程中
link |
48:54.000
有非常大的隨機性
link |
48:56.000
所以直接根據互動的過程學
link |
48:59.000
可能沒有辦法學得很好
link |
49:01.000
所以Actor Critic這種方法
link |
49:03.000
它的精神就是
link |
49:04.000
細節我們就不要講
link |
49:05.000
它的精神是什麼
link |
49:08.000
它的精神就是
link |
49:09.000
今天Actor不要真的去看環境的reward
link |
49:13.000
因為環境的reward的變化太大
link |
49:15.000
因為中間有隨機性變化太大
link |
49:17.000
那如果不要跟環境的reward學
link |
49:20.000
我們只跟Critic學
link |
49:22.000
那這個方法就叫Actor Critic
link |
49:25.000
那怎麼跟Critic學呢
link |
49:26.000
其實有非常多不同的方法
link |
49:29.000
Advantage的Actor Critic
link |
49:31.000
只是眾多的方法的其中一種而已
link |
49:34.000
那它之所以變得比較有名
link |
49:35.000
是因為它的performance是比較好的
link |
49:38.000
那當然還有很多其他的方法
link |
49:40.000
可以讓Actor跟著Critic學
link |
49:43.000
那總之只要是Actor
link |
49:45.000
不是去真的看環境的reward
link |
49:47.000
而是看Critic的評價來學習的
link |
49:49.000
就叫做Actor Critic
link |
49:51.000
那如果有其中的某一種方法
link |
49:53.000
叫做Advantage的Actor Critic
link |
50:00.000
那我們要講A3C
link |
50:01.000
我們剛才是講了
link |
50:02.000
Advantage跟Actor Critic都兩個A
link |
50:04.000
第三個A是什麼呢
link |
50:05.000
第三個A是Asynchronous
link |
50:07.000
所以A3C完整的名字叫做
link |
50:09.000
Asynchronous的Actor Critic
link |
50:12.000
Asynchronous的意思是什麼呢
link |
50:14.000
Asynchronous的意思是說
link |
50:16.000
你有一個Global的Network
link |
50:21.000
你本來有一個Global的Actor
link |
50:24.000
跟Global的Critic
link |
50:26.000
那現在要去學習的時候
link |
50:28.000
每次要學習的時候
link |
50:30.000
你就去跟Global的Actor和Critic
link |
50:33.000
Copy一組參數過來
link |
50:35.000
那你有
link |
50:36.000
你如果要拼
link |
50:37.000
你如果可以開分身
link |
50:38.000
假設你要開N個分身的話
link |
50:40.000
就是CopyN組參數
link |
50:42.000
那把參數Copy完以後
link |
50:44.000
就讓這個Actor
link |
50:46.000
去實際跟環境互動
link |
50:48.000
那有N個Actor
link |
50:49.000
他們就用N個Actor
link |
50:50.000
各自去跟環境的互動
link |
50:52.000
那互動完以後
link |
50:53.000
就會知道說要怎麼樣
link |
50:55.000
Critic就會告訴Actor
link |
50:56.000
說要怎麼樣Update參數
link |
50:58.000
那把這個Update的參數
link |
51:00.000
傳回去這個Global的Network
link |
51:03.000
所以每一個分身
link |
51:06.000
都會傳一組
link |
51:08.000
傳一個Update的方向
link |
51:09.000
那把所有Update的方向合起來
link |
51:11.000
可以一起做Update
link |
51:13.000
一個人就是做平行的運算
link |
51:16.000
一個人就是
link |
51:17.000
平行的開N個分身學習
link |
51:19.000
所以可以學得比較快
link |
51:21.000
這讓我想到
link |
51:22.000
火影忍者的其中一段
link |
51:24.000
跟火影忍者其中一段
link |
51:25.000
概念是一樣的
link |
51:26.000
我不知道大家記不記得這樣
link |
51:28.000
就有一次
link |
51:29.000
名人想要加快他修練的速度
link |
51:32.000
他的老師卡卡西呢
link |
51:34.000
就告訴他說
link |
51:35.000
如果你要用
link |
51:36.000
頂分身來修行的話
link |
51:38.000
你用兩個人一起修行
link |
51:40.000
經驗值就會變成兩倍
link |
51:42.000
Asynchronous的Activated的方法
link |
51:44.000
就是一模一樣的
link |
51:45.000
你開越多的分身
link |
51:47.000
學習的速度就越快
link |
51:48.000
所以名人就開很多很多的分身
link |
51:50.000
一起學
link |
51:51.000
就可以加速學習的速度
link |
51:53.000
不過當然在實作上
link |
51:54.000
你要做Asynchronous這一招
link |
51:56.000
前提就是
link |
51:57.000
你要有很多很多的Machine
link |
51:59.000
你像要開八個分身
link |
52:01.000
你只要八個Machine
link |
52:02.000
開千個分身
link |
52:03.000
你只要一千個Machine
link |
52:04.000
如果你只有一台Machine
link |
52:05.000
你就只能降到A2C
link |
52:06.000
你其實也沒辦法做A3C就是了
link |
52:09.000
這邊有一些同學
link |
52:12.000
實作這個Activated
link |
52:13.000
在一些遊戲上的結果
link |
52:15.000
這個是做了這個
link |
52:19.000
讓Machine玩
link |
52:21.000
叫做Sleeper IO
link |
52:23.000
Sleeper IO不知道大家知不知道
link |
52:25.000
Sleeper IO呢
link |
52:26.000
就是一個線上的遊戲
link |
52:29.000
那在這個遊戲裡面呢
link |
52:31.000
你是一隻蛇
link |
52:32.000
你要控制牠是蛇
link |
52:33.000
在一個聊天室裡面走來走去
link |
52:35.000
只要撞到別人呢
link |
52:37.000
那理論上
link |
52:38.000
其他人都是真的
link |
52:40.000
只有我們控制的那一條蛇
link |
52:42.000
是屬於控制的
link |
52:44.000
那理論上
link |
52:45.000
別人都是
link |
52:47.000
理論上
link |
52:48.000
別人都是真的
link |
52:50.000
好
link |
52:51.000
就是這個
link |
52:52.000
可以控制一條蛇走來走去
link |
52:54.000
那牠避免撞到別人
link |
52:56.000
所以你會發現說
link |
52:57.000
牠如果會靠近其他蛇的話
link |
52:58.000
就會受到迫害
link |
53:00.000
那你用這個
link |
53:02.000
你去看到的遊戲畫面
link |
53:03.000
跟人看到的遊戲畫面
link |
53:05.000
是一模一樣的
link |
53:07.000
你會發現說
link |
53:08.000
這個一定是機器在撞我們
link |
53:10.000
因為滑鼠
link |
53:11.000
飛快的單手
link |
53:13.000
你會看到
link |
53:14.000
這絕對不是人做的出來的手勢
link |
53:16.000
這是機器在控制的
link |
53:18.000
然後看到人家蛇
link |
53:20.000
就會離開這樣子
link |
53:31.000
然後牠就很明顯地走
link |
53:32.000
從牠的中間穿過去
link |
53:34.000
然後又穿過去
link |
53:36.000
其實後來
link |
53:37.000
牠也沒有辦法直發地了解
link |
53:39.000
直到後來就開始死了
link |
53:41.000
然後這邊有一個
link |
53:42.000
在網路上找到的是
link |
53:44.000
這個盾的比賽
link |
53:46.000
這個其實也蠻知名的
link |
53:47.000
就有一個用機器
link |
53:48.000
去玩盾的比賽
link |
53:54.000
在這個比賽裡面
link |
53:55.000
這些都是黑圈
link |
53:57.000
都是黑圈
link |
53:59.000
可以仔細看一下
link |
54:00.000
可以發現說
link |
54:01.000
牠們確實是機器
link |
54:02.000
比如說這一個
link |
54:03.000
牠有點慘這樣子
link |
54:05.000
牠就爬在角落
link |
54:07.000
牠爬在角落
link |
54:09.000
有點轉不出去
link |
54:11.000
有點慘
link |
54:12.000
所以牠顯然是一個
link |
54:13.000
是一個機器
link |
54:15.000
這個影片其實非常長
link |
54:17.000
它是一個長達兩小時的
link |
54:19.000
史詩級戰鬥
link |
54:21.000
所以就不要把它看完
link |
54:23.000
把它跳過
link |
54:29.000
那還有另外一個技術
link |
54:31.000
這個技術是
link |
54:33.000
Activistic的一個變形
link |
54:35.000
那我之所以要把它提出來
link |
54:36.000
是因為它非常的像是電
link |
54:39.000
我們剛才有講說
link |
54:41.000
在做Q-learning的時候
link |
54:42.000
我們遇到的一個問題就是
link |
54:44.000
我們要解一個
link |
54:45.000
ARG Max的花紋
link |
54:47.000
我們要找一個action
link |
54:48.000
它讓Q-function最大
link |
54:51.000
但是今天你常常會遇到的
link |
54:53.000
一個問題就是
link |
54:54.000
你沒有辦法窮舉所有的A
link |
54:56.000
你沒有辦法窮舉所有的A
link |
54:58.000
今天如果尤其是A
link |
54:59.000
如果是continuous的一個vector
link |
55:01.000
舉例來說什麼時候
link |
55:02.000
你的action的output會是continuous
link |
55:04.000
舉例來說你想要控制機器手臂
link |
55:06.000
那你output的是關節的角度
link |
55:08.000
那它就是continuous
link |
55:10.000
一般的Q-learning
link |
55:12.000
只能夠處理discrete的case
link |
55:14.000
那如果要處理continuous的話
link |
55:15.000
怎麼辦呢
link |
55:16.000
你就認一個actor
link |
55:19.000
那這個actor做的事情就是
link |
55:21.000
給它一個state
link |
55:22.000
那它output的那個A
link |
55:24.000
會是讓Q-function的值
link |
55:27.000
最大的那一個A
link |
55:29.000
那大家懂嗎
link |
55:30.000
我們有一個Q-function
link |
55:31.000
然後actor它output的A
link |
55:33.000
actor要去學習
link |
55:35.000
它學習的目標就是
link |
55:36.000
希望它output的A
link |
55:37.000
會讓Q-function的值呢
link |
55:40.000
越大越好
link |
55:41.000
那你如果仔細想想
link |
55:42.000
這個不就跟片一樣了嗎
link |
55:44.000
如果這個東西
link |
55:45.000
把它當作是discriminator
link |
55:47.000
這個東西當作是generator
link |
55:49.000
generator做的事情就是
link |
55:51.000
產生一個image discriminator
link |
55:53.000
你覺得分數好
link |
55:54.000
那這邊是actor要產生一個action
link |
55:56.000
這個action是Q-function
link |
55:58.000
覺得分數好的
link |
56:00.000
那這個叫做
link |
56:01.000
這個pathwise derivative
link |
56:03.000
這個policy規定
link |
56:05.000
但是有比較著名的方法呢
link |
56:06.000
就是DEPG
link |
56:07.000
那這個我們就跳過
link |
56:10.000
只要告訴大家有這個技術而已
link |
56:13.000
那剩下的時間呢
link |
56:14.000
我想要講一下
link |
56:16.000
inverse reinforcement learning
link |
56:18.000
inverse reinforcement learning
link |
56:19.000
它是什麼呢
link |
56:20.000
它是imitation learning的一種
link |
56:23.000
這個inverse
link |
56:24.000
在inverse reinforcement learning裡面
link |
56:25.000
你只有environment跟actor
link |
56:27.000
我們剛才講說environment跟actor
link |
56:29.000
它們的互動關係是長這個樣子
link |
56:32.000
但是在inverse reinforcement learning裡面
link |
56:35.000
我們沒有reward function
link |
56:37.000
我們有的東西是什麼
link |
56:39.000
我們有的東西就只有
link |
56:41.000
這個expert demo的trajectory
link |
56:44.000
就如果是遊戲的話
link |
56:45.000
就是有專家
link |
56:46.000
有高手去把這個遊戲玩了N遍
link |
56:48.000
給machine看
link |
56:50.000
告訴machine說
link |
56:51.000
哇這個遊戲看起來是什麼樣子
link |
56:52.000
但是沒有reward function
link |
56:55.000
那你們會說
link |
56:56.000
什麼樣的狀況會沒有reward function呢
link |
56:59.000
事實上多數現實生活中的case
link |
57:02.000
我們都是沒有reward function
link |
57:04.000
今天下圍棋配用reinforcement learning
link |
57:07.000
是因為圍棋的規則是明確的
link |
57:09.000
輸就是輸贏就是贏
link |
57:11.000
今天玩電玩配用reinforcement learning
link |
57:13.000
就玩電玩的規則是明確的
link |
57:15.000
殺一隻怪得到幾分是另好
link |
57:17.000
但是在多數的case
link |
57:19.000
其實我們根本就不知道
link |
57:20.000
reward function是什麼
link |
57:21.000
比如說自駕車
link |
57:22.000
撞到一個人要扣一萬分嗎
link |
57:24.000
那撞到一個狗要扣多少分呢
link |
57:27.000
或者是說
link |
57:28.000
今天如果你拿reinforcement learning的技術
link |
57:31.000
去學一個checkbox
link |
57:32.000
那checkbox要做到什麼樣的事情
link |
57:34.000
才能得到分數呢
link |
57:35.000
舉例來說
link |
57:36.000
他把人激怒會扣一百分嗎
link |
57:38.000
那人掛掉電話會扣五十分嗎
link |
57:40.000
這個東西你怎麼定
link |
57:41.000
都是定不清楚的
link |
57:42.000
而且有時候
link |
57:43.000
你用一些自己定出來的reward
link |
57:46.000
那如果他跟現實的狀況差很多
link |
57:48.000
machine會學出很奇怪的東西
link |
57:50.000
舉例來說
link |
57:51.000
其中一個例子就是機械攻敵
link |
57:53.000
機械攻敵那部電影裡面說
link |
57:55.000
創造機器的人
link |
57:57.000
他定了三大法則
link |
57:58.000
這三大法則
link |
57:59.000
你就可以想成是
link |
58:00.000
只要違反這三大法則
link |
58:02.000
就會得到非常negative的reward
link |
58:04.000
遵守這三大法則
link |
58:05.000
就會得到positive的reward
link |
58:07.000
那機器自己想辦法
link |
58:08.000
根據這個規則
link |
58:09.000
根據這個reward function
link |
58:11.000
去找出最好的action
link |
58:13.000
然後他就有一個神邏輯
link |
58:14.000
他決定說
link |
58:15.000
最好的action就是
link |
58:16.000
為了保護人類
link |
58:17.000
應該把人類監禁起來的
link |
58:19.000
那這個可能是一個
link |
58:21.000
比較極端的例子
link |
58:22.000
但是在真實的研究上
link |
58:24.000
確實有這樣子的例子
link |
58:25.000
舉例來說
link |
58:26.000
你想讓機器學習收盤子
link |
58:28.000
然後又把盤子放到櫃子裡
link |
58:30.000
也就是說
link |
58:31.000
盤子放到櫃子裡面
link |
58:32.000
你就得到1分
link |
58:34.000
那機器確實可以學到
link |
58:36.000
為了要得到分數
link |
58:37.000
他會把盤子放到櫃子裡面
link |
58:39.000
但是他可能都摔了
link |
58:41.000
然後盤子通通被打破了
link |
58:42.000
因為你就告訴他說
link |
58:43.000
盤子打破要扣分啊
link |
58:45.000
那你會變成說
link |
58:46.000
等盤子都打破以後
link |
58:47.000
你才發現說
link |
58:48.000
你只好再加上新的reward
link |
58:50.000
就是打破盤子要扣分
link |
58:52.000
那盤子都已經被打破了
link |
58:54.000
好所以
link |
58:56.000
今天我們有很多現實的任務
link |
58:59.000
是我們根本就不知道
link |
59:01.000
reward function長什麼樣
link |
59:02.000
所以我們需要
link |
59:03.000
inverse reinforcement learning
link |
59:05.000
這個技術
link |
59:06.000
inverse reinforcement learning
link |
59:07.000
這個技術
link |
59:08.000
他做的事情就是
link |
59:09.000
在原來的reinforcement learning裡面
link |
59:11.000
我們有reward function
link |
59:13.000
有environment
link |
59:14.000
根據reward function
link |
59:15.000
然後environment
link |
59:16.000
透過reinforcement learning的技術
link |
59:18.000
找出最好的actor
link |
59:19.000
inverse reinforcement learning的技術
link |
59:20.000
剛好是反過來了
link |
59:21.000
我們有actor
link |
59:23.000
我們雖然不知道
link |
59:24.000
最好的actor是什麼
link |
59:25.000
但是我們有專家
link |
59:26.000
專家去玩了N場遊戲
link |
59:28.000
告訴我們說
link |
59:29.000
厲害的人玩這個遊戲
link |
59:30.000
看起來就是什麼樣
link |
59:32.000
根據專家的demo
link |
59:34.000
還有environment
link |
59:36.000
透過一個叫做
link |
59:37.000
inverse reinforcement learning的技術
link |
59:39.000
我們可以推出reward function
link |
59:41.000
應該長什麼樣
link |
59:43.000
把reward function推出來以後
link |
59:45.000
你就可以根據你推導出的reward function
link |
59:48.000
再去找一個
link |
59:50.000
再去apply
link |
59:51.000
reinforcement learning的方法
link |
59:53.000
去找出最好的actor
link |
59:55.000
所以就是用inverse reinforcement learning的方法
link |
59:57.000
去推出reward function
link |
59:58.000
再去找出最好的
link |
01:00:00.000
這個actor
link |
01:00:02.000
叫reinforcement learning的方法
link |
01:00:03.000
去找出最好的actor
link |
01:00:05.000
那inverse reinforcement learning
link |
01:00:06.000
怎麼做的呢
link |
01:00:07.000
他的原則就是
link |
01:00:09.000
你的老師
link |
01:00:10.000
也就是那些expert
link |
01:00:11.000
他永遠是對的
link |
01:00:13.000
什麼意思
link |
01:00:14.000
就是說
link |
01:00:15.000
現在你一開始
link |
01:00:16.000
你有一個actor
link |
01:00:17.000
你先隨機的
link |
01:00:18.000
找一個初始化一個actor出來
link |
01:00:20.000
然後用這個actor去跟環境做互動
link |
01:00:23.000
這個actor會得到很多的trajectory
link |
01:00:26.000
會得到很多的遊戲的紀錄
link |
01:00:29.000
然後接下來
link |
01:00:30.000
你比較actor的遊戲紀錄
link |
01:00:32.000
跟老師的遊戲紀錄
link |
01:00:34.000
然後你定一個reward function
link |
01:00:36.000
一定要讓老師得到的分數
link |
01:00:39.000
比actor得到的分數高
link |
01:00:41.000
就是先射箭再畫馬的概念
link |
01:00:43.000
就是expert去玩一堆遊戲
link |
01:00:45.000
他有一堆遊戲的紀錄
link |
01:00:47.000
然後actor也去玩遊戲
link |
01:00:48.000
也有遊戲的紀錄
link |
01:00:49.000
那我不知道reward function是什麼
link |
01:00:51.000
那等他們都玩完以後
link |
01:00:52.000
再定一個reward function
link |
01:00:54.000
定的標準就是
link |
01:00:55.000
老師
link |
01:00:56.000
就那個expert得到的分數
link |
01:00:58.000
一定要比學生還要高這樣
link |
01:01:00.000
先射箭再畫馬的概念
link |
01:01:02.000
那把馬畫完以後
link |
01:01:04.000
學生說好吧
link |
01:01:05.000
雖然因為根據這個新的reward
link |
01:01:07.000
我是比較弱的
link |
01:01:08.000
沒關係
link |
01:01:09.000
那我就再去學習
link |
01:01:10.000
我想要maximize新的reward function
link |
01:01:14.000
actor學到maximize新的reward function以後
link |
01:01:17.000
他就再去跟環境互動
link |
01:01:19.000
他就會得到新的trajectory
link |
01:01:20.000
他得到新的trajectory以後
link |
01:01:22.000
他本來以為他跟老師一樣厲害
link |
01:01:24.000
但是不幸的就是
link |
01:01:26.000
那個規則是會一直改的
link |
01:01:27.000
當他變得跟老師一樣厲害以後
link |
01:01:30.000
我們再改一下規則
link |
01:01:31.000
讓老師算出來的分數還是比較高
link |
01:01:33.000
然後actor就只好很生氣的
link |
01:01:35.000
再去想辦法學
link |
01:01:37.000
想要跟老師做的一樣
link |
01:01:39.000
就反覆反覆進行這個花繩
link |
01:01:41.000
最後你就可以找到一個reward function
link |
01:01:44.000
那這整個花繩
link |
01:01:45.000
我們就圖示化方式來表示一下
link |
01:01:47.000
你有一個expert
link |
01:01:48.000
他有n筆遊戲紀錄
link |
01:01:50.000
然後你有一個actor
link |
01:01:51.000
他也有n筆遊戲紀錄
link |
01:01:54.000
然後你要定一個reward function
link |
01:01:56.000
讓expert得到的分數
link |
01:01:58.000
永遠贏過actor
link |
01:02:00.000
然後你去找一個reward
link |
01:02:02.000
然後你接下來去找一個reward
link |
01:02:04.000
反正你去找一個reward function
link |
01:02:05.000
老師一定是好的
link |
01:02:06.000
他一定是不好
link |
01:02:08.000
接下來根據這個reward function
link |
01:02:10.000
你可以去學這個actor
link |
01:02:12.000
根據這個reward function
link |
01:02:14.000
你可以去學這個actor
link |
01:02:16.000
讓這個actor得到的分數
link |
01:02:18.000
根據這個reward function
link |
01:02:20.000
可以得到最好的分數
link |
01:02:22.000
但等這個actor他做得比較好之後
link |
01:02:24.000
這個規則又變了
link |
01:02:25.000
然後這個花繩就反覆的循環
link |
01:02:29.000
這個花繩你有沒有覺得很熟悉呢
link |
01:02:31.000
他跟game的花繩其實是一模一樣
link |
01:02:35.000
怎麼說
link |
01:02:36.000
在game裡面有一堆expert畫的圖
link |
01:02:39.000
generator會產生一堆圖
link |
01:02:42.000
discriminator說
link |
01:02:43.000
只要expert畫的都是好的
link |
01:02:45.000
這些就是高分
link |
01:02:46.000
這些就是低分
link |
01:02:47.000
你認出一個discriminator
link |
01:02:49.000
generator要做的事情是
link |
01:02:50.000
調整他的畫出來的圖
link |
01:02:52.000
使得discriminator覺得他是高分
link |
01:02:54.000
但是generator以為他畫的圖
link |
01:02:56.000
discriminator給他高分
link |
01:02:57.000
但是discriminator會update參數
link |
01:02:59.000
在使得generator畫的圖得到低分
link |
01:03:03.000
然後就反覆的不斷的循環
link |
01:03:05.000
事實上在inverse reinforcement learning裡面
link |
01:03:09.000
我們只是把generator
link |
01:03:10.000
換個名字叫做actor
link |
01:03:12.000
把discriminator換個名字叫做reward function
link |
01:03:15.000
我們說generator
link |
01:03:16.000
我們只有actor會產生一大堆遊戲的紀錄
link |
01:03:19.000
但是我們要定一個reward function
link |
01:03:20.000
反正就是要讓actor輸
link |
01:03:22.000
讓老師贏
link |
01:03:23.000
然後actor就會修改他做的事情
link |
01:03:26.000
希望可以得到比較好的分數
link |
01:03:28.000
在actor修改以後
link |
01:03:29.000
reward function也會跟著修改
link |
01:03:31.000
然後就這樣子反覆的進行這個process
link |
01:03:34.000
在這個結束之前
link |
01:03:38.000
我就給大家看一個
link |
01:03:40.000
是Berkley做的
link |
01:03:43.000
用inverse reinforcement learning的技術
link |
01:03:45.000
來教機器人做一些行為
link |
01:03:49.000
在inverse reinforcement learning的技術裡面
link |
01:03:53.000
你就需要先示範給機器看
link |
01:03:55.000
比如示範給機器看怎麼擺盤子
link |
01:03:58.000
希望他高分自己就學會擺盤子
link |
01:04:00.000
要教他demo20次給他看
link |
01:04:07.000
接下來機器就自己學了
link |
01:04:09.000
有不同的方法細節我們就不講了
link |
01:04:26.000
這個是學習幫客人倒水
link |
01:04:29.000
來教機器倒水
link |
01:04:30.000
先示範給他看怎麼倒水
link |
01:04:40.000
然後每次杯子擺的位置都不一樣
link |
01:04:44.000
他自己來動
link |
01:05:11.000
很驚險的倒進去
link |
01:05:18.000
這個就是用inverse reinforcement learning來教機器
link |
01:05:21.000
因為時間關係我們今天就講到這邊
link |
01:05:25.000
謝謝大家