好 那 我 們 來 上 課 吧 那 這 一 堂 課 啊 我 們 要 講 的 是 deep reinforcement learning 也 就 是 rl 那 我 想 這 個 rl 啊 reinforcement learning 啊 大 家 一 定 一 點 都 不 陌 生 因 為 你 知 道 很 多 很 潮 的 應 用 alphago 等 等 它 背 後 呢 用 的 就 是 rl 的 技 術 那 rl 可 以 講 的 技 術 啊 非 常 非 常 地 多 它 不 是 在 一 堂 課 裡 面 可 以 講 得 完 的 我 甚 至 覺 得 說 如 果 有 人 要 把 它 開 成 一 整 個 學 期 的 課 可 能 也 是 有 這 麼 多 東 西 可 以 講 所 以 今 天 啊 這 堂 課 的 目 的 並 不 是 要 告 訴 你 有 關 rl 的 一 切 而 是 讓 大 家 有 一 個 基 本 的 認 識 大 概 知 道 rl 是 什 麼 樣 的 東 西 那 rl 相 關 的 課 程 你 其 實 在 網 路 上 可 以 找 到 非 常 非 常 多 的 參 考 的 資 料 那 rl 如 果 要 講 得 非 常 地 艱 澀 其 實 也 是 可 以 講 得 非 常 地 艱 澀 的 可 是 今 天 這 一 堂 課 啊 我 們 儘 量 避 開 太 過 理 論 的 部 分 我 期 待 這 堂 課 可 以 讓 你 做 到 的 並 不 是 讓 你 聽 了 覺 得 哇 rl 很 困 難 啊 搞 不 清 楚 在 做 什 麼 而 是 期 待 讓 你 覺 得 說 啊 rl 原 來 就 只 是 這 樣 而 已 我 自 己 應 該 也 做 得 起 來 希 望 這 一 堂 課 可 以 達 到 這 一 個 目 的 好 那 什 麼 是 reinforcement learning 呢 到 目 前 為 止 啊 我 們 講 的 幾 乎 都 是 supervised learning 假 設 你 要 做 一 個 image 的 classifier 你 不 只 要 告 訴 機 器 它 的 input 是 什 麼 你 還 要 告 訴 機 器 它 應 該 輸 出 什 麼 樣 的 output 然 後 接 下 來 呢 你 就 可 以 train 一 個 image 的 classifier 那 在 多 數 這 門 課 講 到 目 前 為 止 的 技 術 基 本 上 都 是 基 於 supervised learning 的 方 法 就 算 是 我 們 在 講 self supervised learning 的 時 候 我 們 其 實 也 是 很 類 似 supervised learning 的 方 法 只 是 我 們 的 label 不 需 要 特 別 僱 用 人 力 去 標 記 它 可 以 自 動 產 生 或 者 是 我 們 在 講 auto-encoder 的 時 候 我 們 雖 然 說 它 是 一 個 unsupervised 的 方 法 我 們 沒 有 用 到 人 類 的 標 記 但 事 實 上 我 們 還 是 有 一 個 label 只 是 這 個 label 不 需 要 耗 費 人 類 的 力 量 來 產 生 而 已 好 但 是 rl 就 是 另 外 一 個 面 向 的 問 題 了 在 rl 裡 面 我 們 遇 到 的 問 題 是 這 樣 子 的 我 們 機 器 當 我 們 給 它 一 個 輸 入 的 時 候 我 們 不 知 道 最 佳 的 輸 出 應 該 是 什 麼 舉 例 來 說 假 設 你 要 叫 機 器 學 習 下 圍 棋 用 supervised learning 的 方 法 好 像 也 可 以 做 你 就 是 告 訴 機 器 說 看 到 現 在 的 盤 勢 長 這 個 樣 子 的 時 候 下 一 步 應 該 落 子 的 位 置 在 哪 裡 但 是 問 題 是 下 一 步 應 該 落 子 的 位 置 到 底 應 該 在 哪 裡 呢 哪 一 個 是 最 好 的 下 一 步 呢 哪 一 步 是 神 之 一 手 呢 可 能 人 類 根 本 就 不 知 道 當 然 你 可 以 說 讓 機 器 閱 讀 很 多 職 業 棋 士 的 棋 譜 讓 機 器 閱 讀 很 多 高 段 棋 士 的 棋 譜 也 許 這 些 棋 譜 裡 面 的 答 案 也 許 這 些 棋 譜 裡 面 給 某 一 個 盤 勢 人 類 下 的 下 一 步 就 是 一 個 很 好 的 答 案 但 它 是 不 是 最 好 的 答 案 呢 我 們 不 知 道 在 這 個 你 不 知 道 正 確 答 案 是 什 麼 的 情 況 下 往 往 就 是 rl 可 以 派 上 用 場 的 時 候 所 以 當 你 今 天 你 發 現 你 要 蒐 集 有 標 註 的 資 料 很 困 難 的 時 候 正 確 答 案 人 類 也 不 知 道 是 什 麼 的 時 候 也 許 就 是 你 可 以 考 慮 使 用 rl 的 時 候 但 是 rl 在 學 習 的 時 候 機 器 其 實 也 不 是 一 無 所 知 的 我 們 雖 然 不 知 道 正 確 的 答 案 是 什 麼 但 是 機 器 會 知 道 什 麼 是 好 什 麼 是 不 好 機 器 會 跟 環 境 去 做 互 動 得 到 一 個 叫 做 reward 的 東 西 這 我 們 等 一 下 都 還 會 再 細 講 所 以 機 器 會 知 道 它 現 在 的 輸 出 是 好 的 還 是 不 好 的 來 藉 由 跟 環 境 的 互 動 藉 由 知 道 什 麼 樣 的 輸 出 是 好 的 什 麼 樣 的 輸 出 是 不 好 的 機 器 還 是 可 以 學 出 一 個 模 型 好 那 接 下 來 呢 這 是 今 天 這 份 投 影 片 的 outline 首 先 呢 我 們 會 從 最 基 本 的 rl 的 概 念 開 始 那 在 介 紹 這 個 rl 概 念 的 時 候 有 很 多 不 同 的 切 入 點 啦 也 許 你 比 較 常 聽 過 的 切 入 點 是 這 樣 比 如 說 從 markov decision process 開 始 講 起 那 我 們 這 邊 選 擇 了 一 個 比 較 不 一 樣 的 切 入 點 我 要 告 訴 你 說 雖 然 如 果 你 自 己 讀 rl 的 文 獻 的 話 你 會 覺 得 哇 rl 很 複 雜 哦 跟 一 般 的 machine learning 好 像 不 太 一 樣 哦 但 是 我 這 邊 要 告 訴 你 說 rl 它 跟 我 們 這 一 門 課 學 的 machine learning 是 一 樣 的 框 架 我 們 在 今 天 這 個 這 學 期 一 開 始 的 第 一 堂 課 就 告 訴 你 說 machine learning 就 是 三 個 步 驟 那 rl 呢 rl 也 是 一 模 一 樣 的 三 個 步 驟 等 一 下 會 再 跟 大 家 說 明 好 在 今 天 在 這 個 本 學 期 這 一 門 課 的 第 一 開 始 就 告 訴 你 說 什 麼 是 機 器 學 習 機 器 學 習 就 是 找 一 個 function reinforcement learning rl 也 是 機 器 學 習 的 一 種 那 它 也 在 找 一 個 function 它 在 找 什 麼 樣 的 function 呢 那 reinforcement learning 裡 面 呢 我 們 會 有 一 個 actor 還 有 一 個 environment 那 這 個 actor 跟 environment 會 進 行 互 動 你 的 這 個 environment 你 的 這 個 環 境 啊 會 給 actor 一 個 observation 會 給 那 這 個 observation 呢 就 是 actor 的 輸 入 那 actor 呢 看 到 這 個 observation 以 後 呢 它 會 有 一 個 輸 出 這 個 輸 出 呢 叫 做 action 那 這 個 action 呢 會 去 影 響 environment 這 個 actor 採 取 action 以 後 呢 environment 就 會 給 予 新 的 observation 然 後 actor 呢 會 給 予 新 的 action 那 這 個 observation 是 actor 的 輸 入 那 這 個 action 呢 是 actor 的 輸 出 所 以 actor 本 身 啊 它 就 是 一 個 function 其 實 actor 它 就 是 我 們 要 找 的 function 這 個 function 它 的 輪 入 就 是 環 境 給 它 的 observation 輸 出 就 是 這 個 actor 要 採 取 的 action 而 今 天 在 這 個 互 動 的 過 程 中 呢 這 個 environment 會 不 斷 地 給 這 個 actor 一 些 reward 告 訴 它 說 你 現 在 採 取 的 這 個 action 它 是 好 的 還 是 不 好 的 而 我 們 今 天 要 找 的 這 個 actor 我 們 今 天 要 找 的 這 個 function 可 以 拿 observation 當 作 input action 當 作 output 的 function 這 個 function 的 目 標 是 要 去 maximizing 我 們 可 以 從 environment 獲 得 到 的 reward 的 總 和 我 們 希 望 呢 找 一 個 function 那 用 這 個 function 去 跟 環 境 做 互 動 用 observation 當 作 input 輸 出 action 最 終 得 到 的 reward 的 總 和 可 以 是 最 大 的 這 個 就 是 rl 要 找 的 function 那 我 知 道 這 樣 講 你 可 能 還 是 覺 得 有 些 抽 象 所 以 我 們 舉 更 具 體 的 例 子 那 等 一 下 舉 的 例 子 呢 都 是 用 space invader 當 作 例 子 啦 那 space invader 就 是 一 個 非 常 簡 單 的 小 遊 戲 那 rl 呢 最 早 的 幾 篇 論 文 也 都 是 玩 讓 那 個 機 器 呢 去 玩 這 個 space invader 這 個 遊 戲 在 space invader 裡 面 呢 你 要 操 控 的 是 下 面 這 個 綠 色 的 東 西 這 個 下 面 這 個 綠 色 的 東 西 呢 是 你 的 太 空 梭 你 可 以 採 取 的 行 為 也 就 是 action 呢 有 三 個 左 移 右 移 跟 開 火 就 這 三 個 行 為 然 後 你 現 在 要 做 的 事 情 啊 就 是 殺 掉 畫 面 上 的 這 些 外 星 人 畫 面 上 這 些 黃 色 的 東 西 也 就 是 外 星 人 啦 然 後 你 開 火 擊 中 那 些 外 星 人 的 話 那 外 星 人 就 死 掉 了 那 前 面 這 些 東 西 是 什 麼 呢 那 個 是 你 的 防 護 罩 如 果 你 不 小 心 打 到 自 己 的 防 護 罩 的 話 你 的 防 護 罩 呢 也 是 會 被 打 掉 的 那 你 可 以 躲 在 防 護 罩 後 面 你 就 可 以 擋 住 外 星 人 的 攻 擊 然 後 接 下 來 呢 會 有 分 數 那 在 螢 幕 畫 面 上 會 有 分 數 當 你 殺 死 外 星 人 的 時 候 你 會 得 到 分 數 或 者 是 在 有 些 版 本 的 space invader 裡 面 會 有 一 個 補 給 包 從 上 面 橫 過 去 飛 過 去 那 你 打 到 補 給 包 的 話 會 被 加 一 個 很 高 的 分 數 那 這 個 score 呢 就 是 reward 就 是 環 境 給 我 們 的 reward 好 那 這 個 遊 戲 呢 它 是 會 終 止 的 那 什 麼 時 候 終 止 呢 當 所 有 的 外 星 人 都 被 殺 光 的 時 候 就 終 止 或 者 是 呢 外 星 人 其 實 也 會 對 你 的 母 艦 開 火 啦 外 星 人 擊 中 你 的 母 艦 你 也 是 會 這 個 你 就 被 摧 毀 了 那 這 個 遊 戲 呢 也 就 終 止 了 好 那 這 個 是 介 紹 一 下 space invader 這 一 個 遊 戲 好 那 如 果 你 今 天 呢 要 用 actor 去 玩 space invader 大 概 會 像 是 什 麼 樣 子 呢 現 在 你 的 actor 啊 actor 雖 然 是 一 個 機 器 但 是 它 是 坐 在 人 的 這 一 個 位 置 它 是 站 在 人 這 一 個 角 度 去 操 控 搖 桿 去 控 制 那 個 母 艦 去 跟 外 星 人 對 抗 而 你 的 環 境 是 什 麼 你 的 環 境 呢 是 遊 戲 的 主 機 遊 戲 的 主 機 這 邊 去 操 控 那 些 外 星 人 外 星 人 去 攻 擊 你 的 母 艦 所 以 observation 是 遊 戲 的 畫 面 所 以 對 actor 來 說 它 看 到 的 其 實 就 跟 人 類 在 玩 遊 戲 的 時 候 看 到 的 東 西 是 一 樣 的 就 看 到 一 個 遊 戲 的 畫 面 那 輸 出 呢 就 是 actor 可 以 採 取 的 行 為 那 可 以 採 取 哪 些 行 為 通 常 是 事 先 定 義 好 的 在 這 個 遊 戲 裡 面 就 只 有 向 左 向 右 跟 開 火 三 種 可 能 的 行 為 而 已 好 那 當 你 的 actor 採 取 向 右 這 個 行 為 的 時 候 那 它 會 得 到 reward 那 因 為 在 這 個 遊 戲 裡 面 只 有 殺 掉 外 星 人 會 得 到 分 數 而 我 們 就 是 把 分 數 定 義 成 我 們 的 reward 那 向 左 向 右 其 實 並 不 會 不 可 能 殺 掉 任 何 的 外 星 人 所 以 你 得 到 的 reward 呢 就 是 0 分 好 那 你 採 取 一 個 action 以 後 呢 遊 戲 的 畫 面 就 變 了 遊 戲 的 畫 面 變 的 時 候 就 代 表 了 有 了 新 的 observation 進 來 有 了 新 的 observation 進 來 你 的 actor 就 會 決 定 採 取 新 的 action 你 的 actor 是 一 個 function 這 個 function 會 根 據 輸 入 的 observation 輸 出 對 應 的 action 那 新 的 畫 面 進 來 假 設 你 的 actor 現 在 它 採 取 的 行 為 是 開 火 而 開 火 這 個 行 為 正 好 殺 掉 一 隻 外 星 人 的 時 候 你 就 會 得 到 分 數 那 這 邊 假 設 得 到 的 分 數 是 5 分 殺 那 個 外 星 人 得 到 的 分 數 是 5 分 那 你 就 得 到 reward 等 於 5 那 這 個 呢 就 是 拿 actor 去 玩 玩 這 個 space invader 這 個 遊 戲 的 狀 況 好 那 這 個 actor 呢 它 想 要 學 習 的 是 什 麼 呢 我 們 在 玩 遊 戲 的 過 程 中 會 不 斷 地 得 到 reward 那 在 剛 才 例 子 裡 面 做 第 一 個 行 為 的 時 候 向 右 的 時 候 得 到 的 是 0 分 做 第 二 個 行 為 開 火 的 時 候 得 到 的 是 5 分 那 接 下 來 你 採 取 了 一 連 串 行 為 都 有 可 能 給 你 分 數 而 actor 要 做 的 事 情 我 們 要 學 習 的 目 標 我 們 要 找 的 這 個 actor 就 是 我 們 想 要 learn 出 一 個 actor 這 個 actor 這 個 function 我 們 使 用 它 在 這 個 遊 戲 裡 面 的 時 候 可 以 讓 我 們 得 到 的 reward 的 總 和 會 是 最 大 的 那 這 個 就 是 拿 actor 去 這 個 就 是 rl 用 在 玩 這 個 小 遊 戲 裡 面 的 時 候 做 的 事 情 好 那 其 實 如 果 把 rl 拿 來 玩 圍 棋 拿 來 下 圍 棋 其 實 做 的 事 情 跟 小 遊 戲 其 實 也 沒 有 那 麼 大 的 差 別 只 是 規 模 跟 問 題 的 複 雜 度 不 太 一 樣 而 已 那 如 果 今 天 你 要 讓 機 器 來 下 圍 棋 那 你 的 actor 就 是 就 是 alphago 那 你 的 環 境 是 什 麼 你 的 環 境 就 是 alphago 的 人 類 對 手 那 alphago 的 輸 入 是 什 麼 你 的 這 個 actor 的 輸 入 是 什 麼 你 的 actor 的 輸 入 就 是 棋 盤 棋 盤 上 黑 子 跟 白 子 的 位 置 那 如 果 是 在 遊 戲 的 一 開 始 棋 盤 上 就 空 空 的 空 空 如 也 上 面 什 麼 都 沒 有 沒 有 任 何 黑 子 跟 白 子 那 這 個 actor 呢 看 到 這 個 棋 盤 呢 它 就 要 產 生 輸 出 它 就 要 決 定 它 下 一 步 應 該 落 子 在 哪 裡 那 如 果 是 圍 棋 的 話 你 的 輸 出 的 可 能 性 就 是 有 19×19 個 可 能 性 那 這 19×19 個 可 能 性 每 一 個 可 能 性 就 對 應 到 棋 盤 上 的 一 個 位 置 好 那 假 設 現 在 你 的 actor 決 定 要 落 子 在 這 個 地 方 那 這 一 個 結 果 就 會 輸 入 給 你 的 環 境 那 其 實 就 是 一 個 棋 士 然 後 呢 這 個 環 境 呢 就 會 再 產 生 新 的 observation 因 為 這 個 李 世 石 這 個 棋 士 呢 也 會 再 落 一 子 那 現 在 看 到 的 環 境 又 不 一 樣 了 那 你 的 actor 看 到 這 個 新 的 observation 它 就 會 產 生 新 的 action 然 後 就 這 樣 反 覆 繼 續 下 去 你 就 可 以 讓 機 器 做 下 圍 棋 這 件 事 情 好 那 在 這 個 在 這 個 下 圍 棋 這 件 事 情 裡 面 的 reward 是 怎 麼 計 算 的 呢 在 下 圍 棋 裡 面 你 所 採 取 的 行 為 幾 乎 都 沒 有 辦 法 得 到 任 何 reward 在 下 圍 棋 這 個 遊 戲 裡 在 下 圍 棋 這 件 事 情 裡 面 呢 你 會 定 義 說 如 果 贏 了 就 得 到 1 分 如 果 輸 了 就 得 到 -1 分 也 就 是 說 在 下 圍 棋 這 整 個 這 個 你 的 actor 跟 環 境 互 動 的 過 程 中 其 實 只 有 遊 戲 結 束 只 有 整 場 圍 棋 結 束 的 最 後 一 子 你 才 能 夠 拿 到 reward 就 你 最 後 最 後 actor 下 一 子 下 去 贏 了 就 得 到 1 分 那 最 後 它 落 了 那 一 子 以 後 遊 戲 結 束 了 它 輸 了 那 就 得 到 -1 分 那 在 中 間 整 個 互 動 的 過 程 中 的 reward 就 都 算 是 0 分 沒 有 任 何 的 reward 那 這 個 actor 學 習 的 目 標 啊 就 是 要 去 最 大 化 它 可 能 可 以 得 到 的 reward 好 剛 才 講 的 也 許 你 都 已 經 聽 過 了 那 這 個 是 rl 最 常 見 的 一 種 解 說 方 式 那 接 下 來 要 告 訴 你 說 rl 跟 機 器 學 習 的 framework 它 們 之 間 的 關 係 是 什 麼 開 學 第 一 堂 課 就 告 訴 你 說 machine learning 就 是 三 個 步 驟 第 一 個 步 驟 你 有 一 個 function 那 個 function 裡 面 有 一 些 未 知 數 unknown 的 variable 這 些 未 知 數 是 要 被 找 出 來 的 第 二 步 訂 一 個 loss function 第 三 步 想 辦 法 找 出 未 知 數 去 最 小 化 你 的 loss 第 三 步 就 是 optimization 而 rl 其 實 也 是 一 模 一 樣 的 三 個 步 驟 我 們 先 來 看 第 一 個 步 驟 第 一 個 步 驟 我 們 現 在 有 未 知 數 的 這 個 function 到 底 是 什 麼 呢 這 個 有 未 知 數 的 function 就 是 我 們 的 actor 那 在 rl 裡 面 你 的 actor 呢 就 是 一 個 network 那 我 們 現 在 通 常 叫 它 policy 的 network 那 在 過 去 啊 在 還 沒 有 把 deep learning 用 到 rl 的 時 候 通 常 你 的 actor 是 比 較 簡 單 的 它 不 是 network 它 可 能 只 是 一 個 look-up-table 告 訴 你 說 看 到 什 麼 樣 的 輸 入 就 產 生 什 麼 樣 的 輸 出 那 今 天 我 們 都 知 道 要 用 network 來 當 做 這 個 actor 那 這 個 network 其 實 就 是 一 個 很 複 雜 的 function 這 個 複 雜 的 function 它 的 輸 入 是 什 麼 呢 它 的 輸 入 就 是 遊 戲 的 畫 面 就 是 遊 戲 的 畫 面 這 個 遊 戲 上 面 這 個 黑 子 跟 這 個 這 個 不 是 下 圍 棋 啦 所 以 沒 有 黑 子 跟 白 子 啊 那 這 裡 面 如 果 是 拿 這 個 玩 space invader 當 作 例 子 的 話 呢 這 個 遊 戲 畫 面 上 的 pixel 像 素 就 是 這 一 個 actor 的 輸 入 那 它 的 輸 出 是 什 麼 呢 它 的 輸 出 就 是 每 一 個 可 以 採 取 的 行 為 它 的 分 數 每 一 個 可 以 採 取 的 action 它 的 分 數 舉 例 來 說 輸 入 這 樣 的 畫 面 給 你 的 actor 你 的 actor 其 實 就 是 一 個 network 它 的 輸 出 可 能 就 是 給 向 左 0.7 分 向 右 0.2 分 開 火 0.1 分 那 事 實 上 啊 這 件 事 情 跟 分 類 是 沒 有 什 麼 兩 樣 的 你 知 道 分 類 就 是 輸 入 一 張 圖 片 輸 出 就 是 決 定 這 張 圖 片 是 哪 一 個 類 別 那 你 的 network 會 給 每 一 個 類 別 一 個 分 數 你 可 能 會 通 過 一 個 softmax layer 然 後 每 一 個 類 別 都 有 個 分 數 而 且 這 些 分 數 的 總 和 是 1 那 其 實 在 rl 裡 面 你 的 actor 你 的 policy network 跟 分 類 的 那 個 network 其 實 是 一 模 一 樣 的 你 就 是 輸 入 一 張 圖 片 輸 出 其 實 最 後 你 也 會 有 個 softmax layer 然 後 呢 你 就 會 left、right 跟 fire 三 個 action 各 給 一 個 分 數 那 這 些 分 數 的 總 和 你 也 會 讓 它 是 1 那 至 於 這 個 network 的 架 構 呢 那 你 就 可 以 自 己 設 計 了 要 設 計 怎 麼 樣 都 行 比 如 說 如 果 輸 入 是 一 張 圖 片 欸 也 許 你 就 會 想 要 用 cnn 來 處 理 不 過 在 助 教 的 程 式 裡 面 其 實 不 是 用 cnn 來 處 理 啦 因 為 在 我 們 的 作 業 裡 面 其 實 在 玩 遊 戲 的 時 候 不 是 直 接 讓 我 們 的 machine 去 看 遊 戲 的 畫 面 讓 它 直 接 去 看 遊 戲 的 讓 它 直 接 去 看 遊 戲 的 畫 面 比 較 難 做 啦 所 以 我 們 是 讓 看 這 個 跟 現 在 遊 戲 的 狀 況 有 關 的 一 些 參 數 而 已 所 以 在 這 個 助 教 的 在 這 個 作 業 的 這 個 sample code 裡 面 呢 還 沒 有 用 到 cnn 那 麼 複 雜 就 是 一 個 簡 單 的 fully connected network 但 是 假 設 你 要 讓 你 的 actor 它 的 輸 入 真 的 是 遊 戲 畫 面 欸 那 你 可 能 就 會 採 取 這 個 cnn 你 可 能 就 用 cnn 當 作 你 的 network 的 架 構 甚 至 你 可 能 說 我 不 要 只 看 現 在 這 一 個 時 間 點 的 遊 戲 畫 面 我 要 看 整 場 遊 戲 到 目 前 為 止 發 生 的 所 有 事 情 可 不 可 以 呢 可 以 那 過 去 你 可 能 會 用 rnn 考 慮 現 在 的 畫 面 跟 過 去 所 有 的 畫 面 那 現 在 你 可 能 會 想 要 用 transformer 考 慮 所 有 發 生 過 的 事 情 所 以 network 的 架 構 是 你 可 以 自 己 設 計 的 只 要 能 夠 輸 入 遊 戲 的 畫 面 輸 出 類 似 像 類 別 這 樣 的 action 就 可 以 了 那 最 後 機 器 會 決 定 採 取 哪 一 個 action 取 決 於 每 一 個 action 取 得 的 分 數 常 見 的 做 法 啊 是 直 接 把 這 個 分 數 就 當 做 一 個 機 率 然 後 按 照 這 個 機 率 去 sample 去 隨 機 決 定 要 採 取 哪 一 個 action 舉 例 來 說 在 這 個 例 子 裡 面 向 左 得 到 0.7 分 那 就 是 有 70% 的 機 率 會 採 取 向 左 20% 的 機 率 會 採 取 向 右 10% 的 機 率 會 採 取 開 火 那 你 可 能 會 問 說 為 什 麼 不 是 用 （00：18：47） 呢 為 什 麼 不 是 看 left 的 分 數 最 高 就 直 接 向 左 呢 你 也 可 以 這 麼 做 但 是 在 助 教 的 程 式 裡 面 還 有 多 數 rl 應 用 的 時 候 你 會 發 現 我 們 都 是 採 取 sample 採 取 sample 有 一 個 好 處 是 說 今 天 就 算 是 看 到 同 樣 的 遊 戲 畫 面 你 的 機 器 每 一 次 採 取 的 行 為 也 會 略 有 不 同 那 在 很 多 的 遊 戲 裡 面 這 種 隨 機 性 也 許 是 重 要 的 比 如 說 你 在 做 剪 刀 石 頭 布 的 時 候 如 果 你 總 是 會 出 石 頭 就 跟 小 叮 噹 一 樣 那 你 就 很 容 易 被 打 爆 如 果 你 有 一 些 隨 機 性 就 比 較 不 容 易 被 打 爆 那 其 實 之 所 以 今 天 的 輸 出 是 用 隨 機 sample 的 還 有 另 外 一 個 很 重 要 的 理 由 那 這 個 我 們 等 一 下 會 再 講 到 好 所 以 這 是 第 一 步 我 們 有 一 個 function 這 個 function 有 unknown 的 variable 我 們 有 一 個 network 那 裡 面 有 參 數 這 個 參 數 就 是 unknown 的 variable 就 是 要 被 學 出 來 的 東 西 這 是 第 一 步 然 後 接 下 來 第 二 步 我 們 要 定 義 loss 在 rl 裡 面 我 們 的 loss 長 得 是 什 麼 樣 子 呢 我 們 再 重 新 來 看 一 下 我 們 的 機 器 跟 環 境 互 動 的 過 程 那 只 是 現 在 用 不 一 樣 的 方 法 來 表 示 剛 才 說 過 的 事 情 好 首 先 有 一 個 初 始 的 遊 戲 畫 面 這 個 初 始 的 遊 戲 畫 面 被 作 為 你 的 actor 的 輸 入 你 的 actor 那 就 輸 出 了 一 個 action 比 如 說 向 右 輸 入 的 遊 戲 畫 面 呢 我 們 叫 它 s1 然 後 輸 出 的 action 呢 就 叫 它 a1 那 現 在 會 得 到 一 個 reward 這 邊 因 為 向 右 沒 有 做 任 何 事 情 沒 有 殺 死 任 何 的 外 星 人 所 以 得 到 的 reward 可 能 就 是 0 分 採 取 向 右 以 後 會 看 到 新 的 遊 戲 畫 面 這 個 叫 做 s2 根 據 新 的 遊 戲 畫 面 s2 你 的 actor 會 採 取 新 的 行 為 比 如 說 開 火 這 邊 用 a2 來 表 示 看 到 遊 戲 畫 面 s2 的 時 候 所 採 取 的 行 為 那 假 設 開 火 恰 好 殺 死 一 隻 外 星 人 那 你 的 actor 就 得 到 reward 這 個 reward 的 分 數 呢 是 5 分 然 後 採 取 開 火 這 個 行 為 以 後 接 下 來 你 會 看 到 新 的 遊 戲 畫 面 那 機 器 又 會 採 取 新 的 行 為 那 這 個 互 動 的 過 程 呢 就 會 反 覆 持 續 下 去 直 到 機 器 在 採 取 某 一 個 行 為 以 後 遊 戲 結 束 了 那 什 麼 時 候 遊 戲 結 束 呢 就 看 你 遊 戲 結 束 的 條 件 是 什 麼 嘛 舉 例 來 說 採 取 最 後 一 個 行 為 以 後 比 如 說 向 右 移 正 好 被 外 星 人 的 子 彈 打 中 那 你 的 飛 船 就 毀 了 那 遊 戲 就 結 束 了 或 者 是 最 後 一 個 行 為 是 開 火 把 最 後 一 隻 外 星 人 殺 掉 那 遊 戲 也 就 結 束 了 就 你 執 行 某 一 個 行 為 滿 足 遊 戲 結 束 的 條 件 以 後 遊 戲 就 結 束 了 那 從 遊 戲 開 始 到 結 束 的 這 整 個 過 程 啊 被 稱 之 為 一 個 episode 那 在 整 個 遊 戲 的 過 程 中 機 器 會 採 取 非 常 多 的 行 為 每 一 個 行 為 都 可 能 得 到 reward 把 所 有 的 reward 通 通 集 合 起 來 我 們 就 得 到 一 個 東 西 叫 做 整 場 遊 戲 的 total reward 好 那 這 個 total reward 呢 就 是 從 遊 戲 一 開 始 得 到 的 r1 一 直 得 一 直 加 累 加 到 遊 戲 最 後 結 束 的 時 候 得 到 的 rt 假 設 這 個 遊 戲 裡 面 會 互 動 t 次 那 麼 就 得 到 一 個 total reward 我 們 這 邊 用 r 來 表 示 total reward 其 實 這 個 total reward 又 有 另 外 一 個 名 字 啊 叫 做 return 啦 你 在 這 個 rl 的 文 獻 上 常 常 會 同 時 看 到 reward 跟 return 這 兩 個 詞 會 出 現 那 reward 跟 return 其 實 有 點 不 一 樣 reward 指 的 是 你 採 取 某 一 個 行 為 的 時 候 立 即 得 到 的 好 處 這 個 是 reward 把 整 場 遊 戲 裡 面 所 有 的 reward 通 通 加 起 來 這 個 叫 做 return 但 是 我 知 道 說 很 快 你 就 會 忘 記 reward 跟 return 的 差 別 了 所 以 我 們 等 一 下 就 不 要 再 用 return 這 個 詞 彙 我 們 直 接 告 訴 你 說 整 場 遊 戲 的 reward 的 總 和 就 是 total 的 reward 而 這 個 total 的 reward 啊 就 是 我 們 想 要 去 最 大 化 的 東 西 就 是 我 們 訓 練 的 目 標 那 你 可 能 會 說 欸 這 個 跟 loss 不 一 樣 啊 loss 是 要 越 小 越 好 啊 這 個 total reward 是 要 越 大 越 好 啊 所 以 有 點 不 一 樣 吧 但 是 我 們 可 以 說 在 rl 的 這 個 情 境 下 我 們 把 那 個 total reward 的 負 號 負 的 total reward 就 當 做 我 們 的 loss total reward 是 要 越 大 越 好 那 負 的 total reward 當 然 就 是 要 它 越 小 越 好 吧 就 我 們 完 全 可 以 說 負 的 total reward 就 是 我 們 的 loss 就 是 rl 裡 面 的 loss 好 那 在 進 入 第 三 步 之 前 也 許 我 們 可 以 看 一 下 怎 麼 回 答 同 學 們 有 沒 有 問 題 好 那 個 有 同 學 建 議 這 個 休 息 的 時 候 可 以 關 麥 好 那 個 這 個 我 研 究 一 下 怎 麼 關 麥 其 實 我 還 不 知 道 要 怎 麼 關 麥 好 講 理 論 不 好 嗎 講 理 論 沒 有 不 好 那 你 可 以 看 一 下 過 去 有 關 rl 這 個 部 分 的 錄 影 那 我 等 一 下 在 投 影 片 裡 面 其 實 也 有 附 上 相 關 的 錄 影 那 裡 面 是 有 講 到 比 較 多 理 論 的 地 方 那 我 這 今 天 呢 我 是 期 待 說 從 更 淺 顯 的 角 度 呢 來 跟 大 家 講 rl 這 件 事 情 那 你 永 遠 可 以 在 過 去 的 上 課 錄 影 找 到 比 較 偏 理 論 的 內 容 好 那 如 果 大 家 暫 時 還 沒 有 其 他 問 題 的 話 呢 我 們 就 繼 續 講 有 關 optimization 的 部 分 好 那 我 們 再 把 這 個 環 境 跟 agent 互 動 的 這 一 件 事 情 啊 再 用 不 一 樣 的 圖 示 再 顯 示 一 次 好 這 個 是 你 的 環 境 你 的 環 境 呢 輸 出 一 個 observation 叫 做 s1 這 個 s1 呢 會 變 成 你 的 actor 的 輸 入 你 的 actor 呢 接 下 來 就 是 輸 出 a1 然 後 這 個 a1 呢 又 變 成 環 境 的 輸 入 你 的 環 境 呢 看 到 a1 以 後 又 輸 出 s2 然 後 這 個 互 動 的 過 程 啊 就 會 繼 續 下 去 s2 又 輸 入 給 actor 它 就 輸 出 a2 a2 又 輸 入 給 environment 它 就 輸 出 給 它 就 產 生 s3 它 這 個 互 動 呢 一 直 下 去 直 到 滿 足 遊 戲 中 止 的 條 件 好 那 這 個 s 跟 a 所 形 成 的 這 個 sequence 就 是 s1 a1 s2 a2 s3 a3 這 個 sequence 又 叫 做 trajectory 那 我 們 用 τ 來 表 示 trajectory 好 那 根 據 這 個 互 動 的 過 程 machine 會 得 到 reward 你 其 實 可 以 把 reward 也 想 成 是 一 個 function 我 們 這 邊 用 一 個 綠 色 的 方 塊 來 代 表 這 個 reward 所 構 成 的 function 那 這 個 reward 這 個 function 有 不 同 的 表 示 方 法 啦 在 有 的 遊 戲 裡 面 也 許 你 的 reward 只 需 要 看 你 採 取 哪 一 個 action 就 可 以 決 定 不 過 通 常 我 們 在 決 定 reward 的 時 候 光 看 action 是 不 夠 的 你 還 要 看 現 在 的 observation 才 可 以 因 為 並 不 是 每 一 次 開 火 你 都 一 定 會 得 到 分 數 開 火 要 正 好 有 擊 到 外 星 人 外 星 人 正 好 在 你 前 面 你 開 火 才 有 分 數 所 以 通 常 reward function 在 定 義 的 時 候 不 是 只 看 action 它 還 需 要 看 observation 同 時 看 action 跟 observation 才 能 夠 知 道 現 在 有 沒 有 得 到 分 數 所 以 reward 是 一 個 function 這 個 reward 的 function 它 拿 a1 跟 s1 當 作 輸 入 然 後 它 產 生 r1 作 為 輸 出 它 拿 a2 跟 s2 當 作 輸 入 產 生 r2 作 為 輸 出 把 所 有 的 r 通 通 結 合 起 來 把 r1 加 r2 加 r3 一 直 加 到 rt 全 部 結 合 起 來 就 得 到 r 這 個 就 是 total reward 也 就 是 return 這 個 是 我 們 要 最 大 化 要 去 maximize 的 對 象 好 那 這 個 optimization 的 問 題 它 長 得 是 什 麼 樣 子 呢 這 個 optimization 的 問 題 是 這 個 樣 子 你 要 去 找 一 個 network 其 實 是 network 裡 面 的 參 數 你 要 去 learn 出 一 組 參 數 這 一 組 參 數 放 在 actor 的 裡 面 它 可 以 讓 這 個 r 的 數 值 越 大 越 好 就 這 樣 結 束 了 整 個 optimization 的 過 程 就 是 這 樣 你 要 去 找 一 個 network 的 參 數 讓 這 邊 產 生 出 來 的 r 越 大 越 好 那 乍 看 之 下 如 果 這 邊 的 這 個 environment actor 跟 reward 它 們 都 是 network 的 話 這 個 問 題 其 實 也 沒 有 什 麼 難 的 這 個 搞 不 好 你 現 在 都 可 以 解 它 看 起 來 就 有 點 像 是 一 個 recurrent network 這 是 一 個 recurrent network 然 後 你 的 loss 就 是 這 個 樣 子 那 只 是 這 邊 是 reward 不 是 loss 所 以 你 是 要 讓 它 越 大 越 好 你 就 去 learn 這 個 參 數 用 gradient descent 你 就 可 以 讓 它 越 大 越 好 但 是 rl 困 難 的 地 方 是 這 不 是 一 個 一 般 的 optimization 的 問 題 因 為 你 的 environment 這 邊 有 很 多 問 題 導 致 說 它 跟 一 般 的 network training 不 太 一 樣 第 一 個 問 題 是 你 的 actor 的 輸 出 是 有 隨 機 性 的 這 個 a1 它 是 用 sample 產 生 的 你 定 同 樣 的 s1 每 次 產 生 的 a1 不 一 定 會 一 樣 所 以 假 設 你 把 environment actor 跟 reward 合 起 來 當 做 是 一 個 巨 大 的 network 來 看 待 這 個 network 可 不 是 一 般 的 network 這 個 network 裡 面 是 有 隨 機 性 的 這 個 network 裡 面 的 某 一 個 layer 是 每 次 產 生 出 來 結 果 是 不 一 樣 的 這 個 network 裡 面 某 一 個 layer 是 它 的 輸 出 每 次 都 是 不 一 樣 的 另 外 還 有 一 個 更 大 的 問 題 就 是 你 的 environment 跟 reward 它 根 本 就 不 是 network 啊 它 只 是 一 個 黑 盒 子 而 已 你 根 本 不 知 道 裡 面 發 生 了 什 麼 事 情 environment 就 是 遊 戲 機 那 這 個 遊 戲 機 它 裡 面 發 生 什 麼 事 情 你 不 知 道 你 只 知 道 說 你 輸 入 一 個 東 西 會 輸 出 一 個 東 西 你 採 取 一 個 行 為 它 會 有 對 應 的 回 應 但 是 到 底 是 怎 麼 產 生 這 個 對 應 的 回 應 我 們 不 知 道 它 只 是 一 個 黑 盒 子 而 reward 呢 reward 可 能 比 較 明 確 但 它 也 不 是 一 個 network 它 就 是 一 條 規 則 嘛 它 就 是 一 個 規 則 說 看 到 這 樣 子 的 optimization 跟 這 樣 的 action 會 得 到 多 少 的 分 數 它 就 只 是 一 個 規 則 而 已 所 以 它 也 不 是 network 而 且 更 糟 而 且 更 麻 煩 的 地 方 是 往 往 reward 跟 environment 它 也 是 有 隨 機 性 的 如 果 是 在 電 玩 裡 面 通 常 reward 可 能 比 較 不 會 有 隨 機 性 因 為 規 則 是 定 好 的 對 有 一 些 rl 的 問 題 裡 面 reward 是 有 可 能 有 隨 機 性 的 但 是 在 environment 裡 面 就 算 是 在 電 玩 的 這 個 應 用 中 它 也 是 有 隨 機 性 的 你 給 定 同 樣 的 行 為 到 底 遊 戲 機 會 怎 麼 樣 回 應 它 裡 面 可 能 也 是 有 亂 數 的 它 可 能 每 次 的 回 應 也 都 是 不 一 樣 如 果 是 下 圍 棋 你 落 同 一 個 子 你 落 在 你 落 子 在 同 一 個 位 置 你 的 對 手 會 怎 麼 樣 回 應 每 次 可 能 也 是 不 一 樣 所 以 環 境 很 有 可 能 也 是 有 隨 機 性 的 所 以 這 不 是 一 個 一 般 的 optimization 的 問 題 你 可 能 不 能 夠 用 我 們 這 門 課 已 經 學 過 的 訓 練 network 的 方 法 來 找 出 這 個 actor 來 最 大 化 reward 所 以 rl 真 正 的 難 點 就 是 我 們 怎 麼 解 這 一 個 optimization 的 問 題 怎 麼 找 到 一 組 network 參 數 可 以 讓 r 越 大 越 好 其 實 你 再 仔 細 想 一 想 啊 這 整 個 問 題 跟 gan 其 實 有 異 曲 同 工 之 妙 它 們 有 一 樣 的 地 方 也 有 不 一 樣 的 地 方 先 說 它 們 一 樣 的 地 方 在 哪 裡 你 記 不 記 得 在 訓 練 gan 的 時 候 在 訓 練 generator 的 時 候 你 會 把 generator 跟 discriminator 接 在 一 起 然 後 你 希 望 去 調 整 generator 的 參 數 讓 discriminator 的 輸 出 越 大 越 好 今 天 在 rl 裡 面 我 們 也 可 以 說 這 個 actor 就 像 是 generator environment 跟 reward 就 像 是 discriminator 我 們 要 去 調 整 generator 的 參 數 讓 discriminator 的 輸 出 越 大 越 好 所 以 它 跟 gan 有 異 曲 同 工 之 妙 但 什 麼 地 方 不 一 樣 呢 在 gan 裡 面 你 的 discriminator 也 是 一 個 neural network 你 了 解 discriminator 裡 面 的 每 一 件 事 情 它 也 是 一 個 network 你 可 以 用 gradient descent 來 train 你 的 generator 讓 discriminator 得 到 最 大 的 輸 出 但 是 在 rl 的 問 題 裡 面 你 的 reward 跟 environment 你 可 以 把 它 們 當 discriminator 來 看 但 它 們 不 是 network 它 們 是 一 個 黑 盒 子 所 以 你 沒 有 辦 法 用 一 般 gradient descent 的 方 法 來 調 整 你 的 參 數 來 得 到 最 大 的 輸 出 所 以 這 是 rl 跟 一 般 machine learning 不 一 樣 的 地 方 但 是 我 們 還 是 可 以 把 rl 就 看 成 三 個 階 段 只 是 在 optimization 的 時 候 在 你 怎 麼 minimize loss 也 就 怎 麼 maximize reward 的 時 候 跟 之 前 我 們 學 到 的 方 法 是 不 太 一 樣 的 好 那 這 個 就 是 有 關 rl 跟 machine learning 三 個 步 驟 的 關 係 好 我 們 看 一 下 大 家 有 沒 有 問 題 問 好 有 一 位 同 學 問 說 為 什 麼 負 的 total reward 等 於 loss 好 為 什 麼 負 的 total reward 會 等 於 loss 呢 我 們 在 training 的 時 候 啊 在 我 們 之 前 講 過 的 所 有 的 deep learning 的 training 裡 面 我 們 都 是 定 義 了 一 個 loss 要 讓 這 個 loss 越 小 越 好 在 rl 裡 面 呢 我 們 是 定 義 了 一 個 total reward r 然 後 我 們 要 讓 那 個 r 越 大 越 好 但 是 要 讓 r 越 大 越 好 這 件 事 情 我 們 完 全 可 以 反 過 來 說 就 是 我 們 要 讓 負 的 r 就 是 r 乘 上 一 個 負 號 越 小 越 好 所 以 我 們 就 可 以 說 r 乘 上 一 個 負 號 就 是 rl 的 loss 如 果 以 前 學 的 模 型 沒 有 固 定 random seed 的 話 也 算 是 有 隨 機 性 嗎 嗯 這 兩 個 隨 機 性 是 不 一 樣 的 我 們 在 之 前 的 學 模 型 的 時 候 沒 有 固 定 random seed 你 是 training 的 時 候 有 隨 機 性 就 是 你 沒 有 固 定 random seed 你 可 能 initialize 的 parameter 不 一 樣 所 以 你 每 次 訓 練 出 來 的 結 果 不 一 樣 但 是 rl 是 在 testing 的 時 候 就 有 隨 機 性 也 就 是 說 不 是 training 的 時 候 有 隨 機 性 喔 是 測 試 的 時 候 就 已 經 有 隨 機 性 了 所 以 如 果 拿 一 般 的 training 來 比 喻 的 話 就 是 你 在 你 network train 好 以 後 你 拿 這 個 network 在 testing 的 時 候 你 想 要 使 用 它 你 把 你 要 把 這 個 network 使 用 在 testing 的 狀 況 下 但 發 現 說 你 給 同 樣 的 input 每 次 輸 出 都 不 一 樣 這 個 才 是 rl 的 隨 機 性 所 以 rl 是 說 你 train 好 一 個 actor actor 你 learn 好 了 actor 參 數 都 是 固 定 的 但 你 拿 這 個 actor 去 跟 環 境 互 動 的 時 候 每 次 的 結 果 都 是 不 一 樣 的 因 為 你 的 環 境 就 算 是 看 到 同 樣 的 輸 入 它 每 次 給 輸 出 也 可 能 是 不 一 樣 的 所 以 rl 是 一 個 隨 機 性 特 別 大 的 問 題 啦 所 以 你 可 以 想 見 這 個 作 業 有 可 能 是 也 確 實 是 特 別 困 難 的 不 過 我 覺 得 一 個 作 業 的 難 度 啊 有 時 候 不 好 說 因 為 rl 如 果 今 天 你 沒 有 任 何 網 路 上 參 考 資 料 的 話 它 可 能 是 最 難 的 但 另 外 一 方 面 rl 又 蠻 容 易 找 到 各 式 各 樣 的 github 上 的 code 所 以 好 像 又 沒 有 那 麼 難 但 是 rl 的 隨 機 性 是 會 非 常 非 常 大 的 就 算 是 同 樣 的 network 你 每 次 測 試 的 時 候 結 果 都 可 以 是 不 一 樣 a1 下 方 寫 argmax 是 寫 錯 了 嗎 這 個 我 投 影 片 後 來 有 可 能 是 有 改 了 一 下 如 果 你 有 不 清 楚 的 地 方 你 再 問 我 好 了 就 是 這 個 投 影 片 我 剛 才 在 上 課 前 改 了 一 下 之 後 會 把 新 的 投 影 片 再 釋 出 好 好 大 家 還 有 問 題 要 問 一 下 嗎 好 如 果 大 家 暫 時 沒 有 問 題 的 話 那 我 們 就 再 繼 續 那 我 們 就 是 在 講 到 一 個 段 落 呢 我 們 再 休 息 好 那 接 下 來 啊 我 們 就 要 講 一 個 拿 來 解 rl 拿 來 做 optimization 那 一 段 常 用 的 一 個 演 算 法 叫 做 policy gradient 那 如 果 你 真 的 想 知 道 policy gradient 是 哪 裡 來 的 你 可 以 參 見 過 去 上 課 的 錄 影 對 policy gradient 有 比 較 詳 詳 盡 的 推 導 那 今 天 我 們 是 從 另 外 一 個 角 度 來 講 policy gradient 這 件 事 情 好 那 在 講 policy gradient 之 前 我 們 先 來 想 想 看 我 們 要 怎 麼 操 控 一 個 actor 的 輸 出 我 們 要 怎 麼 讓 一 個 actor 在 看 到 某 一 個 特 定 的 observation 的 時 候 採 取 某 一 個 特 定 的 行 為 呢 我 們 怎 麼 讓 一 個 actor 它 的 輸 入 是 s 的 時 候 它 就 要 輸 出 action a^ 呢 那 你 其 實 完 全 可 以 把 它 想 成 一 個 分 類 的 問 題 也 就 是 說 假 設 你 要 讓 actor 輸 入 s 輸 出 就 是 a^ 假 設 a^ 就 是 向 左 好 了 假 設 你 要 讓 假 設 你 已 經 知 道 假 設 你 就 是 要 教 你 的 actor 說 看 到 這 個 遊 戲 畫 面 向 左 就 是 對 的 你 就 是 給 我 向 左 那 你 要 怎 麼 讓 你 的 actor 學 到 這 件 事 呢 那 也 就 說 s 是 actor 的 輸 入 a^ 就 是 我 們 的 label 就 是 我 們 的 ground truth 就 是 我 們 的 正 確 答 案 而 接 下 來 呢 你 就 可 以 計 算 你 的 actor 它 的 輸 出 跟 ground truth 之 間 的 cross-entropy 那 接 下 來 你 就 可 以 定 義 一 個 loss 假 設 你 希 望 你 的 actor 它 採 取 a^ 這 個 行 為 的 話 你 就 定 一 個 loss 這 個 loss 等 於 cross-entropy 然 後 呢 你 再 去 learn 一 個 θ 你 再 去 learn 一 個 θ 然 後 這 個 θ 可 以 讓 loss 最 小 那 你 就 可 以 讓 這 個 actor 的 輸 出 跟 你 的 ground truth 越 接 近 越 好 你 就 可 以 讓 你 的 actor 學 到 說 看 到 這 個 遊 戲 畫 面 的 時 候 它 就 是 要 向 左 這 個 是 要 讓 你 的 actor 採 取 某 一 個 行 為 的 時 候 的 做 法 但 是 假 設 你 想 要 讓 你 的 actor 不 要 採 取 某 一 個 行 為 的 話 那 要 怎 麼 做 呢 假 設 你 希 望 做 到 的 事 情 是 你 的 actor 看 到 某 一 個 observation s 的 時 候 我 就 千 萬 不 要 向 左 的 話 怎 麼 做 呢 其 實 很 容 易 你 只 需 要 把 loss 的 定 義 反 過 來 就 好 你 希 望 你 的 actor 採 取 a^ 這 個 行 為 你 就 定 義 你 的 大 l 等 於 cross-entropy 然 後 你 要 minimize cross-entropy 假 設 你 要 讓 你 的 actor 不 要 採 取 a^ 這 個 行 為 的 話 那 你 就 把 你 就 定 一 個 loss 叫 做 負 的 cross-entropy cross-entropy 乘 一 個 負 號 那 你 去 minimize 這 個 l 你 去 minimize 這 個 l 就 是 讓 cross-entropy 越 大 越 好 那 也 就 是 讓 a 跟 a^ 的 距 離 越 遠 越 好 那 你 就 可 以 避 免 你 的 actor 在 看 到 s 的 時 候 去 採 取 a^ 這 個 行 為 所 以 我 們 有 辦 法 控 制 我 們 的 actor 做 我 們 想 要 做 的 事 只 要 我 們 給 它 適 當 的 label 跟 適 當 的 loss 所 以 假 設 我 們 要 讓 我 們 的 actor 看 到 s 的 時 候 採 取 a^ 看 到 s' 的 時 候 不 要 採 取 a^' 的 話 要 怎 麼 做 呢 這 個 時 候 你 就 會 說 given s 這 個 observation 我 們 的 ground truth 叫 做 a^ given s' 這 個 observation 的 時 候 我 們 有 個 ground truth 叫 做 a^' 那 對 這 兩 個 ground truth 我 們 都 可 以 去 計 算 cross-entropy 好 我 們 都 可 以 去 計 算 cross-entropy e1 跟 e2 然 後 接 下 來 呢 我 們 就 定 義 說 我 們 的 loss 就 是 e1 減 e2 也 就 是 說 我 們 要 讓 這 個 case 它 的 cross-entropy 越 小 越 好 這 個 case 它 的 cross-entropy 越 大 越 好 然 後 呢 我 們 去 找 一 個 θ 去 minimize loss 得 到 θ⋆ 那 就 是 一 個 可 以 在 s 可 以 在 看 到 s 的 時 候 採 取 a^ 看 到 s' 的 時 候 採 取 a^' 的 actor 所 以 藉 由 很 像 是 在 train 一 個 classifier 的 這 種 行 為 藉 由 很 像 是 現 在 train 一 個 classifier 的 這 種 data 我 們 可 以 去 控 制 一 個 actor 的 行 為 好 我 剛 才 講 到 這 邊 有 沒 有 同 學 要 問 問 題 好 有 一 個 同 學 問 了 一 個 非 常 好 的 問 題 就 是 如 果 以 alien 的 遊 戲 來 說 的 話 因 為 只 有 射 中 alien 才 會 有 reward 這 樣 model 不 是 就 會 一 直 傾 向 於 射 擊 嗎 對 這 個 問 題 我 們 等 一 下 會 來 解 決 它 之 後 的 投 影 片 就 會 來 解 決 它 然 後 又 有 另 外 一 個 同 學 問 了 一 個 非 常 好 的 問 題 就 是 哇 這 樣 不 就 回 到 supervised learning 了 嘛 這 個 投 影 片 上 看 起 來 就 是 在 訓 練 一 個 classifier 而 已 啊 我 們 就 是 在 訓 練 classifier 你 只 是 告 訴 它 說 看 到 s 的 時 候 就 要 輸 出 a^ 看 到 s' 的 時 候 就 不 要 輸 出 a^ a^' 這 不 就 是 supervised learning 嗎 這 就 是 supervised learning 這 個 就 是 跟 supervised learning train 的 image classifier 是 一 模 一 樣 的 但 等 下 我 們 會 看 到 它 跟 一 般 的 supervised learning 不 一 樣 在 哪 裡 好 那 我 們 就 再 繼 續 再 稍 微 看 一 段 我 們 再 休 息 那 所 以 呢 如 果 我 們 要 訓 練 一 個 actor 我 們 其 實 就 需 要 蒐 集 一 些 訓 練 資 料 就 蒐 集 訓 練 資 料 說 我 希 望 在 s1 的 時 候 採 取 a^1 我 希 望 在 s2 的 時 候 不 要 採 取 a^2 但 可 能 會 問 說 欸 這 個 訓 練 資 料 哪 來 的 這 個 我 們 等 一 下 再 講 訓 練 資 料 哪 來 的 所 以 你 就 蒐 集 一 大 堆 的 資 料 這 個 跟 train 一 個 image 的 classifier 很 像 的 這 個 s 你 就 想 成 是 image 這 個 a^ 你 就 想 成 是 label 只 是 現 在 有 的 行 為 是 想 要 被 採 取 的 有 的 行 為 是 不 想 要 被 採 取 的 你 就 蒐 集 一 堆 這 種 資 料 你 就 可 以 去 定 義 一 個 loss function 有 了 這 個 loss function 以 後 你 就 可 以 去 訓 練 你 的 actor 去 minimize 這 個 loss function 就 結 束 了 你 就 可 以 訓 練 一 個 actor 期 待 它 執 行 我 們 的 行 為 期 待 它 執 行 的 行 為 是 我 們 想 要 的 而 你 甚 至 還 可 以 更 進 一 步 你 可 以 說 每 一 個 行 為 並 不 是 只 有 好 或 不 好 並 不 是 有 想 要 執 行 跟 不 想 要 執 行 而 已 它 是 有 程 度 的 差 別 的 有 執 行 的 非 常 好 的 有 nice to have 的 有 有 點 不 好 的 有 非 常 差 的 所 以 剛 才 啊 我 們 是 說 每 一 個 行 為 就 是 要 執 行 不 要 執 行 這 是 一 個 binary 的 問 題 這 是 我 們 就 用 ±1 來 表 示 但 是 現 在 啊 我 們 改 成 每 一 個 s 跟 a 的 pair 它 有 對 應 的 一 個 分 數 這 個 分 數 代 表 說 我 們 多 希 望 機 器 在 看 到 s1 的 時 候 執 行 a1^ 這 個 行 為 那 比 如 說 這 邊 第 一 筆 資 料 跟 第 三 筆 資 料 我 們 分 別 是 定 +1.5 跟 +0.5 就 代 表 說 我 們 期 待 機 器 看 到 s1 的 時 候 它 可 以 做 a1^ 看 到 s3 的 時 候 它 可 以 做 a3^ 但 是 我 們 期 待 它 看 到 s1 的 時 候 做 a1^ 的 這 個 期 待 更 強 烈 一 點 比 看 到 s3 做 a3^ 的 期 待 更 強 烈 一 點 那 我 們 希 望 它 在 看 到 s2 的 時 候 不 要 做 a2^ 我 們 期 待 它 看 到 sn 的 時 候 不 要 做 an^ 而 且 我 們 非 常 不 希 望 它 在 看 到 sn 的 時 候 做 an^ 有 了 這 些 資 訊 你 一 樣 可 以 定 義 一 個 loss function 你 只 是 在 你 的 原 來 的 cross-entropy 前 面 本 來 是 cross-entropy 前 面 要 嘛 是 +1 要 嘛 是 -1 現 在 改 成 乘 上 an 這 一 項 改 成 乘 上 an 這 一 項 告 訴 它 說 有 一 些 行 為 我 們 非 常 期 待 actor 去 執 行 有 一 些 行 為 我 們 非 常 不 期 待 actor 去 執 行 有 一 些 行 為 如 果 執 行 是 比 較 好 的 有 一 些 行 為 希 望 儘 量 不 要 執 行 比 較 好 但 就 算 執 行 了 也 許 傷 害 也 沒 有 那 麼 大 所 以 我 們 透 過 這 個 an 來 控 制 說 每 一 個 行 為 我 們 多 希 望 actor 去 執 行 然 後 接 下 來 有 這 個 loss 以 後 一 樣 train 一 個 θ train 下 去 你 就 找 一 個 θ⋆ 你 就 有 個 actor 它 的 行 為 是 符 合 我 們 期 待 的 那 接 下 來 的 難 點 就 是 要 怎 麼 定 出 這 一 個 a 呢 這 個 就 是 我 們 接 下 來 的 難 點 就 是 我 們 接 下 來 要 面 對 的 問 題 我 們 還 有 另 外 一 個 要 面 對 的 問 題 是 怎 麼 產 生 這 個 s 跟 a 的 pair 呢 怎 麼 知 道 在 s1 的 時 候 要 執 行 a1 或 在 s2 的 時 候 不 要 執 行 a2 呢 那 這 個 也 是 等 一 下 我 們 要 處 理 的 問 題 
Okay, let's start class So for this lesson What we will discuss is Deep Reinforcement Learning Which is also known as RL So I believe this RL Reinforcement Learning Everyone must be quite familiar Because you know a lot about trendy applications Such as AlphaGo and so on Behind it The technique used is RL The technology of RL that can be talked about Is really quite a lot It can't be fully explained in one lesson I even think that If someone wants to teach it as a semester-long course There might be that much content to cover So today, The purpose of this lesson Is not to tell you everything about RL But to provide a basic understanding for everyone To roughly know what RL is As for the RL related course You can actually find them online There are a wealth of reference materials If RL is explained in a very abstruse way It can indeed be  explained in a very abstruse way But for today's lesson We will try to avoid too much of the theoretical part What I expect this class can achieve for you It's not about making you feel like Wow, RL is really difficult Not sure what's going on Instead, I hope to make you feel like Ah, so that's all RL is I should be able to do it myself I hope this lesson can achieve this purpose So, what is Reinforcement Learning? Up to now, most of what we have discussed is Supervised Learning Suppose you want to create an image classifier You not only need to tell the machine What its input is You also need to instruct the machine What type of output it should produce And then next you can train an image classifier These techniques have been predominantly covered so far in this course Basically, the methods are based on Supervised Learning Even when we talk about Self Supervised Learning In fact, we are Using methods very similar to Supervised Learning Except that our Label Doesn't require special manpower for marking It can be generated automatically Or when we talk about Auto-encoder We say it's an Unsupervised method We don't use human annotations But in reality We still have a Label It's just that this Label Doesn't require human effort to generate Okay, but RL is a different aspect of the problem In RL The problem we encounter is like this We When we give the machine an input We don't know what the best output should be For instance Suppose you want a machine to learn to play Go Using a Supervised Learning method It seems to be feasible You just tell the machine When you see the current game situation look like this Where should the next move be? But the problem is Where should the next move be placed? Which is the best next step? Which move is the hand of God? Maybe humans don't know at all Of course, you can say Let the machine read the game records of many professional players Let the machine read the records of many high-ranked players Perhaps the answers are within these chess books, Maybe these chess books are providing solutions for a certain situation, The next move for humans, Could be a good answer, But is it the best answer? We don't know, In a situation where you don't know what the correct answer is, This is typically when RL can be put to use So when you today When you find it difficult to collect annotated data When humans don't know what the correct answer is This might be a time when you can consider using RL However, when RL is learning The machine is not entirely ignorant Although we don't know what the correct answer is but the machine will know what's good and what's not The machine will interact with the environment to get something called a reward We'll discuss this in more detail later So, the machine will know Is its current output good or not? Through interactions with the environment By knowing what kind of output is good What kind of output is not good The machine can still learn a model Okay, what's next? This is the outline of today's slides First of all, We'll start with the basic concept of RL, When we introduce the concept of RL, There are many different angles to approach from, Perhaps the angle you're more familiar with is like this, For instance, starting from Markov Decision Process, But we chose a rather different angle here. I want to tell you that although if you read the RL literature by yourself you might think Wow, RL is very complicated It seems a bit different from general Machine Learning but what I want to tell you here is RL is related to the Machine Learning that we learn in this course Is the same framework We are in this semester today The very first lesson tells you Machine Learning is three steps What about RL The process of RL also follows these three exact steps I will explain to everyone later Alright, for today. At the start of this course in this semester Let me tell you What is machine learning Machine learning is about finding a function Reinforcement Learning RL is also a type of machine learning So it's also looking for a Function What kind of function is it looking for What about Reinforcement Learning? we will have an Actor There's also one environment Then this Actor and Environment There will be interactions Your Environment In this environment of yours An Observation will be given to the actor Will give Then, what about this observation? It's the input of the Actor How about Actor? After seeing this Observation It will have an output This output It's called Action What about this action? It will affect the Environment After this Actor takes an Action, The Environment will provide a new Observation Then, the actor Will give a new Action This Observation is an input of Actor What about this Action? It's the output of the Actor So, the Actor itself It's a Function Actually, the Actor This is the Function we're looking for The input of this function Is the Observation given by the environment The output is the Action this Actor is supposed to take And today, in this process of interaction, This Environment Will constantly give this Actor some Reward Tell it to say The action you are taking now Whether it's good or bad, And the Actor we are looking for today The Function we are looking for today Observation can be used as the Input Action as an output function The goal of this function Aiming at Maximizing We can get from the environment The total sum of the Reward obtained What we hope is Find a Function This function is used to interact with the environment Uses Observation as Input Output Action The total Reward received at the end It could be the greatest This is the function that RL is looking for Well, I know when I say it like this You might still find it a bit abstract So we raise more specific examples What about the example to be discussed next They all use Space Invader as an example That Space Invader is a very simple game How about RL? The earliest few papers It's all just a game Where is that machine? Playing this game: Space Invader Inside Space Invader, What you need to control is this green thing below This thing below in green, It's your spaceship The actions you can take That is, there are three Actions Move left, move right and fire These three behaviors And what you need to do now is It's about killing these aliens on the screen These yellow things on the screen That is, the alien And then you fire. If we hit those aliens... Then the alien died What are all these things in the beginning That is your shield If you accidentally hit your own shield Where's your shield It might also get knocked down You can hide behind the shield You can fend off the alien attacks Then the score will follow Then there will be scores on the screen When you kill the alien You will earn points. Or in some versions of Space Invader There will be a supply package Fly over the top If you hit the supply drop Will be given a high score How about this Score? is the Reward It's the reward given by the environment Okay, now about this game It does terminate When does it terminate? It ends when all aliens are killed or Aliens will actually fire at your mothership too you would also be hit if aliens strike your mothership. Then you are destroyed Then this game Which also means the end Okay, this is a brief introduction This game called Space Invader Okay, so what about today We should use the Actor to play Space Invader What would it probably look like Your Actor right now Although Actor is a machine However, it is in the position of the human, It's from the perspective of a person To control the joystick Go control that mothership To fight against aliens And what is your environment What about your environment? Is the game console The game console is used to control those aliens Aliens attack your mothership So, Observation is the game screen So for the Actor What it sees It's just like when humans play games What you see is the same You can see a game screen What about the output? That is the actions that the actor can take What actions can be taken? It's usually predefined In this game To only move left, right, and fire There are only three possible actions Alright, when your actor adopts the behavior of moving right Then it will receive a Reward. Because in this game Only killing aliens gives you points We define the score as our Reward. Actually, going left or right doesn't really matter It's impossible to kill every single alien So the Reward you get It scores 0 Okay, so what happens after you take an action? The game screen has changed When the game screen changes It means that a new Observation has come in With a new Observation coming in, Your Actor will decide to take a new Action Your Actor is a Function this Function will depend on the observed input, Output the corresponding action That new scenario comes in Suppose your Actor The action it's taking now is firing Just when the action of opening fire kills an alien Then you will get the score Let's assume here that the score obtained is 5 points Kill that alien The score obtained is 5 points Then you would get a reward of 5 What about this one Is to play with the Actor Playing this game of Space Invader Okay, what about this Actor What does it want to learn During the process of playing the game Will continuously receive Rewards As in the example just now When you do the first action Scores 0 points when moving to the right Do the second behavior The score is 5 when firing Then you took a series of actions It could possibly give you points. What the Actor needs to do What we are aiming to learn The actor we are looking for is We want to learn an actor This Actor This function When we use it in this game Can give us the maximum total Reward This is where the Actor comes in This is when RL is used to play this mini game The things that are done Well, actually, if we use RL to play Go Use it to play Go In fact, what it does is similar to a small game Actually, there isn't much of a difference It's merely that the scale and complexity of the problem differ If you were to have a machine play Go today, So your Actor is AlphaGo What's your environment? your environment is AlphaGo's human opponent. What is the input for AlphaGo What is the input for your Actor? Your Actor's input is the chessboard The positions of black and white pieces on the chess board What if it’s at the beginning of the game? The chess board is empty It's completely empty There's nothing up there. There are no black or white pieces What about this Actor? Looking at this chessboard It needs to generate an output It has to decide its next move Where should I place my pieces If it's about Go game The possibilities of your output are 19x19 then these 19x19 possibilities, Each possibility It corresponds to a position on the chessboard. Okay, let's assume that your Actor Decide to place the piece here Then this outcome It will be input to your environment Actually, that is a chess player Then, for this environment And produce a new Observation. Because this Go player, Lee Sedol, Will also play another move The environment we see now is different Then your Actor will see this new Observation, It will generate a new Action then keep going like this, You can let the machine play Go Okay, then in this The reward in this game of Go how is it calculated? In the game of Go the actions you take, There's almost no way to get any reward In this Go game In the matter of playing Go You would define that If we win, You then receive 1 point. If you lose, you get -1 point In other words, in this whole game of Go This is the process where your Actor interacts with the environment In fact, only when the game ends Only the final move of the entire Go game, Only then can you get the Reward In the end, it's you Lastly, Actor makes the next move We won You get 1 point After it places that last piece The game has ended It lost Then you get -1 point The reward in the interaction process in the middle It's all considered as zero points There is no reward So, this is the goal for our Actor to learn It's about maximizing It could possibly earn the Reward. Okay, you might have heard what I just said This is one of the most common explanations in RL What I'm going to tell you next is The RL (Reinforcement Learning) and Machine Learning Framework What is the relationship between them you were told on the first day of school, and Machine Learning is a three-step process The first step You have a Function There are some unknowns within that function The Unknown Variable These unknowns need to be found out Second step Designate a Loss Function The third step Try to find the unknown to minimize your Loss The third step is Optimization And RL is actually the same three steps Let's first look at the first step The first step We now have an unknown function What exactly is it This function has unknowns. This is our Actor Then in RL As for your Actor It's a Network We usually call it the Policy Network now In the past Before Deep Learning was applied to RL Usually, your Actor is simpler It is not a Network It might just be a Look-Up-Table Tell you what kind of input you see What kind of output does it generate We all know today that we need to use Network act as this Actor Then this Network In fact, it's a very complex Function What is the input of this complex Function? Its input is the game screen which is the game's screen, On this game This black piece and this one This is not playing Go So there's no black or white pieces If it's about getting this from here Taking Space Invader as an example The Pixel on this game screen Pixel It's the input of an actor Then what would be its output? Its output is for each possible action, Its score The score of each possible action For example, if we input a screen like this To your Actor Your Actor is actually a Network. Its output might just be for Move 0.7 units to the left Shift to the right by 0.2 units Fire for 0.1 point Well, as a matter of fact this is no different from classification. You know classification is about inputting an image The output determines which category this image belongs to Your Network will assign something for each category A score You might pass through a Softmax Layer Then, each category has a score And the sum of these scores is 1 Actually, in RL Your actor, your Policy Network And the network for classification It's exactly the same actually You just input a picture The output will finally have a Softmax Layer, And then You will have Left, Right, and Fire Give a score to each of the three actions. This is the total of these scores You would also set it as 1 As for the architecture of this network Then you can design it yourself You can design it any way you want For example, if the input is an image Hey, maybe you'll want to use CNN to handle it However, in the teaching assistant's program Actually, we do not use CNN to process it Because in our homework Actually, when playing the game We don't just let our machine directly observe the game screen Let it look at the game directly It's more difficult to let it directly look at the game screen So what we are doing is Just letting this relate to some parameters of the current game situation So, in this teaching assistant's Inside this Sample Code of this task We haven't used the complexity of CNN yet It's a simple Fully Connected Network But suppose you want your Actor Its input is actually the game screen Hey, then you might adopt this CNN You might use CNN as the architecture of your network You might even say I don't just want to look at the game screen at this moment I need to observe everything that has happened throughout the game so far. Is it possible? Can In the past, you might have considered using RNNs Current screen compared to all past screens, Now you might want to use Transformer Consider all the things that have happened So the structure of the Network is something you can design yourself As long as it can input the game screen, Just need to output an action similar to a category In the end, the machine will decide which Action to take It depends on the score obtained by each Action That's a common approach, Directly assign this score Consider it as a probability And follow the probability accordingly Go sample Decide randomly which Action to take For instance, in this example Moving left scored 0.7 points There's a 70% chance of taking a left There is a 20% chance of taking the right action There's a 10% chance of opening fire Then you might be wondering Why not use (00:18:47)? Why don't we consider the highest score from 'Left' Just go straight to the left You can also do this But in the assistant's program And in most use cases of RL, you will find out We all take samples There is an advantage in taking a sample. Even if we see the same game screen today the behavior your machine takes every time, There will also be slight differences This type of randomness exists in many games Maybe it's important. For instance, when you are playing Rock, Paper, Scissors. What if you always throw rock? Just like Doraemon Then you can easily be smashed If you have some randomness, It's less likely to explode The reason why today's output It's done by using a random sample There is another very important reason We will talk about this in a moment, Okay, so this is the first step We have a Function This Function has Unknown Variables We have a Network It contains parameters This parameter is the Unknown Variable It's something that needs to be learned This is the first step And then the second step We need to define Loss Within RL What does our Loss look like? Let’s take a look again The process of interaction between our machine and the environment, It's just that we are using a different method now To represent what I just mentioned Alright, first we have an initial game screen. This starting game screen Used as the input of your Actor Your actor then produces an action For example, moving to the right The input game screen We call it s1 Then, the output will be an Action Let's call it a1 Then a Reward will be received now Because nothing is done when moving to the right here. Didn't kill any aliens So the Reward received may be 0 points. After taking the right action You will see a new game screen This is called s2 According to the new game screen s2 your Actor will adopt new behaviors, For instance, opening fire Here we use a2 When you see the game screen of s2 The actions you take, Assume that firing just happens to kill an alien Then your Actor receives the Reward As for the points of this Reward It's 5 points After taking the action to fire Next, you will see a new game screen Then the machine will take new actions So what about this interactive process? It will keep going on and on until the machine takes a certain action The game is over When does the game end? It depends on what the conditions of ending your game are. For instance, After adopting the last action For instance, moving to the right Just happened to be hit by an alien's bullet Then your spaceship is doomed And then the game ends. Or the last action is to open fire, Kill the last alien Then the game is over You perform a certain action After satisfying the conditions for ending the game The game will be over From the start to the end of the game, this entire process Referred to as an Episode During the whole game process, the machine will take many actions, Every action could possibly get a Reward Gather all the Rewards together We will get something It's called the Total Reward of the entire game Okay, what about this Total Reward? It's the r1 you got from the start of the game Keep getting Keep adding Accumulates until the end of the game The rt you got Assume that there will be interactions in this game T times Then you get a Total Reward. We use R on this side To denote the Total Reward Actually, this Total Reward has another name It's called Return You're in this RL literature We often see Reward and Return at the same time These two words will appear actually, Reward and Return are somewhat different Reward refers to when you take a certain action Immediate benefits received This is Reward Add up all the Rewards in the entire game This is called Return But I know that Soon you will forget the difference between Reward and Return So we won't use the term 'Return' any more later We'll tell you directly The sum of rewards in the entire game It is the total reward And this total reward It is something that we want to maximize which is our training goal, Then you might say Hey, this is different from Loss The smaller the loss, the better This Total Reward should be as large as possible. So it's a bit different But we can say in the context of RL We put a negative sign on the total reward Negative Total Reward Consider it as our Loss The bigger the Total Reward, the better Then the negative total reward Of course, the smaller it is, the better. We can definitely say the negative Total Reward, That's our Loss This is the Loss in RL Okay, before proceeding to the third step Perhaps we can look at how to respond Any questions from the students? Okay That one A classmate suggested turning off the microphone during breaks Okay that Let me research how to mute the mic Actually, I still don't know how to mute. Okay, isn't it good to talk about theory? Discussing theories There's nothing wrong You can look into the past The video about the RL part I will cover this in the following slides There is also related video footage attached It involves much theory As for today I am expecting to explain from a simpler perspective To talk about RL with everyone You can always refer to the past class recordings. Finding more theoretical content Well, if no one has any questions for now We will continue to talk about the part of optimization Okay, let's take this environment and The interaction of the agent is important Use a different icon again Show it again Okay, this is your environment. And your environment? It outputs an observation This is called s1 As for this s1 This will be your Actor's input Where is your Actor? Next is the output of a1 Then this a1 Becomes the input of the environment the environment of yours, After seeing 'a1' And output s2 And then, this process of interaction It will keep going s2 is once again input to the Actor It outputs a2 a2 is again input to the Environment It outputs to it generates s3 Its interaction Keep going Until the conditions to terminate the game are met Okay, this Sequence formed by s and a It is this sequence, S1 A1 S2 A2 S3 A3. Also called Trajectory We use τ to represent Trajectory Well, based on this interactive process The Machine will receive a Reward In fact, you can think of Reward as a function We use a green square to represent this side. The function composed by this reward This Reward, this function There are different ways to represent it In some games Perhaps your reward it all depends on which action you choose to take, However, when we usually decide on the Reward Just looking at the Action is not enough You need to see the current Observation first Because not every time you fire will you inevitably score To fire, you need to hit the alien accurately The alien is right in front of you You only score when you fire So usually when we define Reward Function, It's not just about watching the action It also needs to look at the Observation Simultaneously observe the action and observation. to determine whether a score has been achieved, So, Reward is a function This Reward Function it uses a1 and s1 as inputs, And then it produces r1 as the output it uses a2 and s2 as inputs, Generating r2 as an output Combining all the r together Add r1 plus r2 plus r3 and so on to rT Combine everything and you get R This is the Total Reward, That is, Return This is what we need to maximize well, this is an Optimization problem What does it look like? The Optimization problem is like this you need to find a Network, Is actually a parameter in the Network You need to learn a set of parameters These parameters are placed inside the Actor It can make the value of this R as large as possible Just like this It's over The whole optimization process is like this. You need to find a parameter of the Network The larger the R produced here, the better At first glance If this part is This Environment Actor and Reward If they are all in the network Actually, this problem is not difficult at all You might be able to solve this now It looks a bit like a Recurrent Network This is a Recurrent Network Then your Loss looks like this That's just here is Reward, not Loss So you want it to be as large as possible You go to Learn this parameter, With Gradient Descent, you can make it bigger and better But the difficulty with RL is This isn't a typical optimization problem, Because of your Environment There are many problems here It's not quite the same as general network training The first question is The output of your actor has randomness. this a1 is generated by Sample. The result a1 generated by the same s1 might not always be the same So, if you associate the Environment Actor with the Reward Consider it as a huge network This Network is not your ordinary Network There's randomness in this Network One of the layers in this Network is The results produced each time are different Within this Network, what is one Layer Its output is different every time Besides, there's an even bigger problem. Your Environment and Reward It's not even a Network. It's just a black box You have no idea what happened inside The environment is the game console You wouldn't know what's happening inside this game machine You only know that if you input something, something will be output The action you take will receive a corresponding response But how exactly is this corresponding response generated? We don't know It is just a black box And the Reward? The reward might be more obvious, But it's not a Network It's just a rule It's a system of rules When you see this kind of Optimization and such Action How many points will be obtained It's just a rule So it's not a Network And even worse And what's even more troublesome is Often, it's about the reward and environment There is also randomness involved If you are in a video game, Usually, the reward might not have randomness. Because the rules are set In some of the RL problems Reward might have randomness But within the Environment Even in the context of video games It also has randomness You ensure the same behavior How exactly will the gaming machine respond There could also be randomness inside it The response might be different every time If you are playing Go You dropped the same piece You land on You place a piece in the same position How will your opponent respond Each time it may also be different So, there's a good chance the environment also has randomness. So this is not a general Optimization problem You may not be able to use what we've learned in this course Using the method of training Network to find this Actor To maximize the Reward So the real difficulty of RL is How do we solve this Optimization problem? How can we find a set of Network parameters Can make R as large as possible Actually, if you think about it more carefully This entire problem actually shares similarities with GAN They have something in common There are also differences First, let's discuss where they're similar. Do you remember when training GAN? When training the Generator You will connect the Generator and Discriminator together Then you hope to adjust the parameters of the Generator Make the output of the Discriminator as large as possible, In RL today We can also say this Actor behaves like a Generator The environment and reward are like the discriminator We need to adjust the parameters of the Generator Make the output of the Discriminator as large as possible So it shares similarities with GAN But what is different here? The Discriminator in your GAN It's also a Neural Network You understand every detail inside the Discriminator It's also a Network You can use Gradient Descent To train your Generator Let the Discriminator obtain the maximum output But in RL problems Your reward and the environment You can consider them as Discriminators But they are not Network They are a black box So you can't use it Use the general Gradient Descent method to adjust your parameters To get the maximum output So, this is RL Which is different from general Machine Learning But we can still consider RL to be in three stages It's just during the Optimization How you Minimize Loss That's when it maximizes rewards It's not quite the same as what we've learned before Okay, this is related to The relationship between RL and Machine Learning in three steps Okay, let's see if anyone has any questions Okay, a student asked. Why negative Total Reward equals Loss Okay, why does a negative Total Reward equal to Loss? When we're doing Training As we mentioned before, In all the Deep Learning trainings We all defined a Loss We want this loss to be as small as possible In the context of RL We have defined a total reward R Then we want that R to be as big as possible But to make R as big as possible We can totally say it the other way around Is to let the negative R It is R times a negative sign. The smaller, the better So we can say R times a negative sign is the Loss in RL If the model learned previously was not set Would Random Seed also be considered random? Hmm, these two randomness are different. When we learned models before There is no fixed random seed There's randomness when you're training That is, you did not set a fixed Random Seed You may initialize the parameters differently So the result of your training is different each time But RL has randomness during Testing, That is to say, there's a randomness during non-Training time There was already randomness during the testing phase So if we compare it with general Training After you have trained well in your Network When you are testing this Network You want to use it You are going to deal with this network Use it in the situation of Testing However, it's found that you give the same Input The output is different each time This is the randomness of RL So RL means you train an Actor The actor you have learned The parameters for the Actor are all fixed But when you use this Actor to interact with the environment, The results are different every time Because even if you see the same input in your environment Its output may be different each time So, RL is a problem with particularly high randomness So you can imagine this task could be Indeed, it is especially difficult. However, I think the difficulty of a homework Sometimes it's hard to say Because of RL If you have no references on the internet today This could be the hardest On the other hand, RL is quite easy to find Various types of Code on GitHub So it doesn't seem that hard But the randomness of RL (Reinforcement Learning) is extremely high. even if it's the same Network, Every time you test The results can all be different Is it a mistake to write Argmax under a1 I have it in the slideshow later Maybe it has been slightly modified If there are parts that you don't understand, you can ask me I made some adjustments to this slide just before the class The new slide will be released afterwards okay, Okay, does anyone else have any questions? Okay, if there are no questions for now Then, let's continue. So we are talking about a paragraph. Let's take a break Okay, then moving on We will have to discuss about using this to solve RL A common algorithm used for optimization it's called Policy Gradient. If you really want to know Where did the Policy Gradient come from You can refer to the previously recorded lectures. A more detailed derivation of Policy Gradient Today, we are looking from a different perspective. Let's talk about Policy Gradient Well, before talking about Policy Gradient Let's think about this first How we control an Actor's output How can we make an Actor When seeing a specific Observation, Take a certain specific action How we control an Actor When its input is s It has to output Action a^ Then you can completely think of it as a classification problem That is, assuming you want the Actor to input s. The output is a^ Let's say a^ is to the left Assume that you want to make Assume you already know If you are teaching your actor, Turning to the left in this game screen is correct You just point me to the left So, how do you make your Actor learn this? That means s is the input of the Actor a^ is our label It's our ground truth That's our correct answer And next You can calculate your actor The cross-entropy between its output and the Ground Truth Next, you can define a Loss. Suppose you want your Actor If it takes action a^ You just define a Loss This Loss equals Cross-entropy And then You then learn a θ You go and learn another θ And this θ can minimize the Loss Then you can set this Actor's output The closer it is to your Ground Truth, the better, You can teach your Actor to say When looking at this game screen It wants to turn to the left This is meant to engage your Actor The approach when engaging in a particular action But suppose you want your Actor if you don't adopt a certain behavior, How to do it Assume what you hope to achieve is When your Actor sees a certain Observation If I absolutely must not go left, what should I do? Is actually quite easy All you need to do is to reverse the definition of Loss You want your Actor to take action 'a' You define your big L as Cross-entropy. and then you want to Minimize Cross-entropy, Assume you want to make your Actor If we don't choose to take action a^ Then you define a Loss This is called negative Cross-entropy. Cross-entropy multiplied by a negative sign Then you go to minimize this L You minimize this L The bigger the Cross-entropy, the better Which is to make the distance between a and a^ as far as possible So you can prevent your Actor from seeing 's' To take the action of a^ So we have the ability to control our Actor. To do what we want to do As long as we give it the appropriate label and loss So let's suppose we want to enable our Actor Take action a when you see s. If you see s', don't take action a^' How should it be done? At this time, you would say Given this observation as s Our Ground Truth is called 'a^' Given the observation of s' We have a Ground Truth called a^' This refers to these two Ground Truths We can all calculate Cross-entropy Okay, we can all compute Cross-entropy e1 and e2 Then what's next We define our Loss as such Is e1 minus e2 In other words, we need to apply this case The smaller the Cross-entropy, the better The larger the Cross-entropy of this Case, the better Then We are looking for a θ to Minimize Loss Acquiring θ⋆ It's something that can exist in s You can take action 'a^' when observing 's' Take the Actor of a^' when seeing s' So, it's as if The action of training a Classifier By training a classifier similar to the current one, with this kind of Data We can control an Actor's behavior Okay, I just talked about this part Does any student have a question? Good, one of the students asked a very good question That is, if we are talking about the Alien game Because only when you hit the Alien will you get a Reward. Wouldn't the model always lean toward shooting in this way? We will address this question later The subsequent slides will solve it And then there's another classmate You've asked a very good question, which is Wow, isn't this back to Supervised Learning? As seen on this slide It's just training a Classifier We are training the Classifier You just tell them Output a^ when you see s Don't output 'a^' when you see 's' a^' Isn't this just Supervised Learning This is Supervised Learning This is the same as what happens during Supervised Learning Training The Image Classifier is exactly the same But we will see its connection with How is general Supervised Learning different? Alright, let's continue and have a brief look at another section We will take a break. So what If we want to train an Actor We actually need to collect some training data Just gather training data I hope to adopt a^1 during s1 I hope not to adopt a^2 during s2 But you might ask Hey, where does this training data come from? Let's talk about where the training data comes from later. So you gather a bunch of data It's very similar to training an image classifier Think of this 's' as an Image Think of this 'a^' as a Label It's just that the behaviors that exist now are wanted to be adopted Some actions are not desired to be taken Then you collect a bunch of this kind of data You can then define a Loss Function After having this Loss Function You can then train your Actor. Minimize this Loss Function And that's the end You can train an actor Expect it to perform our actions We expect it to behave in the way we want And you can even go one step further You could say that every action is not just good or bad It's not just about wanting to execute or not wanting to execute There's a degree of difference There are some that performed very well There are some nice-to-have There is a slight disadvantage. It's very bad So, just now What we mean is whether to perform each action or not This is a binary problem We represent it with ±1 But now We change it to every pair of 's' and 'a' It has a corresponding score This score implies that We hope that the machine, when seeing s1 Executing the action a1^ For example, the first piece of data and the third one here We are respectively +1.5 and +0.5 It means that we expect the machine to It can do a1^ When you see s3, you can make a3^ But we expect it to react when it sees S1. Make the expectation of a1^ a bit stronger A little stronger expectation than seeing s3 doing a3^ We hope that when it sees s2, Don't do a2^ We look forward to when it sees sN. Do not perform 'aN^' And we really don't want It does aN^ when it sees sN With this information You can also define a Loss Function You are just in front of your original Cross-entropy It was originally in front of Cross-entropy It could be either +1 or -1 Now it is changed to include the term An Change it to multiply by this item 'An' Tell it that there are some behaviors We extremely look forward to the Actor performing There are some actions we really don't expect the Actor to perform There are some actions that are better if performed It's better to avoid certain behaviors as much as possible But even if it's executed,the damage may not be that big So we use this An to control saying We highly desire the Actor to perform each action And then, after this Loss, You train a θ in the same way Train down and you will find a θ⋆ You have an Actor whose behavior is in line with our expectations The next challenge is How should we determine this 'a'? This is the difficulty we will face next This is the problem we have to face next. Another problem we have to face is How do you generate this pair of s and a How do you know to execute a1 at s1 Or not to execute a2 during s2 This is also a problem we will address later 