Chrome 瀏覽器里面有一個小彩蛋，當你沒有網(wǎng)絡時，打開任意的 URL 都會出現(xiàn)一個恐龍小游戲（Dino Run），按空格鍵就可以跳躍。當然，直接打開 chrome://dino 也可以玩這個小游戲。近期，一名來自東北大學（美國）的研究生 Ravi Munde 利用強化學習，實現(xiàn)了對 Dino Run 的控制。

以下內容來自 Ravi Munde 博客，人工智能頭條編譯：

本文將從強化學習的基礎開始，并詳細介紹以下幾個步驟：

在瀏覽器（JavaScript）和模型（Python）之間構建雙向接口

捕獲和預處理圖像

訓練模型

評估

▌強化學習

對許多人來說，強化學習可能是一個新詞，但其實小孩學步利用的就是強化學習（RL）的概念，這也是我們的大腦仍然工作的方式。獎勵系統(tǒng)是任何 RL 算法的基礎，就像小孩學步的階段，積極的獎勵將是來自父母的鼓掌或糖果，而負面獎勵則是沒有糖果。孩子在開始走路之前首先學會站起來。就人工智能而言，智能體（Agent）的主要目標（在我們的案例中是 Dino）是通過在環(huán)境中執(zhí)行特定的操作序列來最大化某個數(shù)字獎勵。RL 中最大的挑戰(zhàn)是缺乏監(jiān)督（標記數(shù)據(jù)）來指導智能體，它必須自己探索和學習。智能體從隨機行動開始，觀察每個行動帶來的回報，并學習如何在面臨類似環(huán)境狀況時預測最佳行動。

圖注：vanilla 強化學習框架

▌Q-learning

我們使用 Q-Learning（RL 中的一種）來嘗試逼近一個特殊函數(shù)，這個函數(shù)可以驅動任何環(huán)境狀態(tài)序列的動作選擇策略。Q-Learning 是 RL 的一種無模型實現(xiàn)，針對每個狀態(tài)、采取的行動和得到的獎勵來更新 Q-table，它能讓我們了解數(shù)據(jù)的結構。在我們的例子中，狀態(tài)是游戲的截圖、行動、不動、跳[0,1]。

我們通過回歸方法來解決這個問題，并選擇具有最高預測 Q 值的動作。

圖注：Q-table 樣本

▌設置

首先設置環(huán)境：

1、選擇虛擬機

我們需要一個完整的桌面環(huán)境，在這里我們可以捕獲和利用屏幕截圖對模型進行訓練。我選擇了 Paperspace ML-in-a-box（MLIAB）Ubuntu 鏡像。MLIAB 的優(yōu)勢在于它預裝了Anaconda 和許多其他 ML 庫。

2、設置和安裝 Keras 以使用GPU

Paperspace 的虛擬機已經預先安裝了，如果沒有的話，可以按照下面的方式：

pip install keraspip install tensorflow

另外，為了確保 GPU 可以被設置識別，執(zhí)行下面的 python 代碼，你應該看到可用的 GPU 設備：

from keras import backend as KK.tensorflow_backend._get_available_gpus()

3、安裝 Dependencies

Selenium:

pip install selenium

OpenCV:

pip install opencv-python

下載 Chromedrive：

http://chromedriver.chromium.org

▌游戲框架

打開 chrome://dino，按空格鍵就可以玩這個游戲了。如果需要修改游戲代碼，就要 chromium 的開源庫中提取游戲了。

由于這個游戲是用 JavaScript 寫的，而我們的模型是用 Python 寫的，因此我們需要運用到一些接口工具。

Selenium 是一個比較流行的瀏覽器自動化工具，用于向瀏覽器發(fā)送操作，并獲取當前分數(shù)等不同的游戲參數(shù)。

在有了發(fā)送操作的接口之后，我們還需要一種捕獲游戲畫面的機制：

Selenium 和 OpenCV 分別為屏幕捕獲和圖像預處理提供了最佳性能，可實現(xiàn) 6-7 fps 的幀率。

游戲模塊

我們使用這個模塊實現(xiàn)了 Python 和 JavaScript 之間的接口，下面的代碼可以讓你知道模塊的實現(xiàn)原理：

class Game: def __init__(self): self._driver = webdriver.Chrome(executable_path = chrome_driver_path) self._driver.set_window_position(x=-10,y=0) self._driver.get(game_url) def restart(self): self._driver.execute_script("Runner.instance_.restart()") def press_up(self): self._driver.find_element_by_tag_name("body").send_keys(Keys.ARROW_UP) def get_score(self): score_array = self._driver.execute_script("return Runner.instance_.distanceMeter.digits") score = ''.join(score_array). return int(score)

智能體模塊

我們使用智能體模塊來封裝所有接口。我們使用此模塊控制 Dino，并獲取智能體在環(huán)境中的狀態(tài)。

class DinoAgent: def __init__(self,game): #takes game as input for taking actions self._game = game; self.jump(); #to start the game, we need to jump once def is_crashed(self): return self._game.get_crashed() def jump(self): self._game.press_up()

游戲狀態(tài)模塊

為了將動作發(fā)送到模塊并獲得相應的結果狀態(tài)，我們使用了 Game-State 模塊。它通過接收和執(zhí)行操作來簡化流程，決定獎勵并返回經驗元組。

class Game_sate: def __init__(self,agent,game): self._agent = agent self._game = game def get_state(self,actions): score = self._game.get_score() reward = 0.1 #survival reward is_over = False #game over if actions[1] == 1: #else do nothing self._agent.jump() image = grab_screen(self._game._driver) if self._agent.is_crashed(): self._game.restart() reward = -1 is_over = True return image, reward, is_over #return the Experience tuple

▌圖像通道

圖像捕捉

我們可以通過多種方式捕獲游戲畫面，例如使用 PIL 和 MSS python 庫截取整個屏幕，并裁剪感興趣區(qū)域（RegionofInterest, ROI）。然而，這個方法最大的缺點是對屏幕分辨率和窗口位置的敏感度問題。幸運的是，該游戲使用了 HTML Canvas，我們可以使用 JavaScript 輕松獲得 base64 格式的圖像?，F(xiàn)在，我們使用 selenium 來運行這個腳本。

#javascript code to get the image data from canvasvar canvas = document.getElementsByClassName('runner-canvas')[0];var img_data = canvas.toDataURL()return img_data

def grab_screen(_driver = None): image_b64 = _driver.execute_script(getbase64Script) screen = np.array(Image.open(BytesIO(base64.b64decode(image_b64)))) image = process_img(screen)#processing image as required return image

圖像處理

捕捉到的原始圖像的分辨率為 600x150，具有 3 通道（RGB）。我們打算使用 4 個連續(xù)的屏幕截圖作為模型的單個輸入，這使得我們單個輸入的尺寸為 600x150x3x4。輸入太大，需要消耗大量的計算力，而且并不是所有的特征都是有用的，所以我們使用 OpenCV 庫來調整、裁剪和處理圖像。最終處理后的輸入僅為 80x80 像素，而且是單通道（灰度，grey scale）。

def process_img(image): image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) image = image[:300, :500] return image

圖注：圖像處理

模型架構

現(xiàn)在讓我們看看模型架構。我們使用一系列的三個卷積層，然后將它們展平為密集層和輸出層。針對 CPU 的模型不包括池化層，因為我已經刪除了許多特征，添加池化層會導致本已稀疏的特征大量丟失。但有了 GPU 之后，我們的模型可以容納更多的特征，而不用降低幀率。

最大池化圖層顯著改善了密集要素集的處理過程。

圖注：模型架構

輸出層由兩個神經元組成，每個神經元代表每個動作的最大預測回報。然后我們選擇具有最大回報( Q值)的動作。

def buildmodel():

print("Now we build the model")

model = Sequential()

model.add(Conv2D(32, (8, 8), padding='same',strides=(4, 4),input_shape=(img_cols,img_rows,img_channels))) #80*80*4

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Activation('relu'))

model.add(Conv2D(64, (4, 4),strides=(2, 2), padding='same'))

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Activation('relu'))

model.add(Conv2D(64, (3, 3),strides=(1, 1), padding='same'))

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Activation('relu'))

model.add(Flatten())

model.add(Dense(512))

model.add(Activation('relu'))

model.add(Dense(ACTIONS))

adam = Adam(lr=LEARNING_RATE)

model.compile(loss='mse',optimizer=adam)

print("We finish building the model")

return model

▌訓練

以靜止開始，并獲得初始狀態(tài)（s_t）

觀察步驟數(shù)量

預測并執(zhí)行操作

在 Replay Memory 中存儲經驗

從 Replay Memory 中隨機選擇一個批次并在此基礎上訓練模型

游戲結束后重新開始

def trainNetwork(model,game_state):

# store the previous observations in replay memory

D = deque() #experience replay memory

# get the first state by doing nothing

do_nothing = np.zeros(ACTIONS)

do_nothing[0] =1 #0 => do nothing,

#1=> jump x_t, r_0, terminal = game_state.get_state(do_nothing) # get next step after performing the action

s_t = np.stack((x_t, x_t, x_t, x_t), axis=2).reshape(1,20,40,4) # stack 4 images to create placeholder input reshaped 1*20*40*4

OBSERVE = OBSERVATION epsilon = INITIAL_EPSILON t = 0 while (True): #endless running

loss = 0

Q_sa = 0

action_index = 0

r_t = 0 #reward at t

a_t = np.zeros([ACTIONS]) # action at t

q = model.predict(s_t)

#input a stack of 4 images, get the prediction

max_Q = np.argmax(q)

# chosing index with maximum q value

action_index = max_Q

a_t[action_index] = 1

# o=> do nothing, 1=> jump

#run the selected action and observed next state and reward

x_t1, r_t, terminal = game_state.get_state(a_t)

x_t1 = x_t1.reshape(1, x_t1.shape[0], x_t1.shape[1], 1) #1x20x40x1

s_t1 = np.append(x_t1, s_t[:, :, :, :3], axis=3) # append the new image to input stack and remove the first one

D.append((s_t, action_index, r_t, s_t1, terminal))# store the transition

#only train if done observing; sample a minibatch to train on

trainBatch(random.sample(D, BATCH)) if t > OBSERVE else 0

s_t = s_t1

t += 1

請注意，我們正在從 replay memory 中抽樣 32 個隨機經驗重放，并使用分批訓練的方法。這樣做的原因是游戲結構中的動作分布不平衡以及避免過度擬合。

def trainBatch(minibatch): for i in range(0, len(minibatch)):

loss = 0

inputs = np.zeros((BATCH, s_t.shape[1], s_t.shape[2], s_t.shape[3])) #32, 20, 40, 4

targets = np.zeros((inputs.shape[0], ACTIONS))

#32, 2

state_t = minibatch[i][0] # 4D stack of images

action_t = minibatch[i][1] #This is action index

reward_t = minibatch[i][2] #reward at state_t due to action_t

state_t1 = minibatch[i][3] #next state

terminal = minibatch[i][4] #wheather the agent died or survided due the action

inputs[i:i + 1] = state_t

targets[i] = model.predict(state_t) # predicted q values

Q_sa = model.predict(state_t1)

#predict q values for next step

if terminal:

targets[i, action_t] = reward_t # if terminated, only equals reward

else:

targets[i, action_t] = reward_t + GAMMA * np.max(Q_sa)

loss += model.train_on_batch(inputs, targets)

結果

我們通過使用這種架構獲得了良好的結果。下圖顯示了訓練開始時的平均分數(shù)，訓練結束時，每 10 場比賽的平均得分遠遠高于 1000 。

最高分數(shù)記錄是 4000 +，遠遠超過了之前模型的的 250 分（也遠遠超過了大多數(shù)人所能做到的?。?。下圖顯示了訓練期間比賽最高得分的進度。

Dino 的速度與分數(shù)成正比，這使得在更高的速度下檢測和決定一個動作更加困難。因此，整個游戲都是以恒定速度訓練的。