深度强化学习入门:用TensorFlow构建你的第一个游戏AI

作者: Medium 2017-11-21 09:20:06

深度强化学习入门:用TensorFlow构建你的第一个游戏AI

去年,DeepMind 的 AlphaGo 以 4-1 的比分打败了世界围棋冠军李世?h。超过 2 亿的观众就这样看着强化学习(reinforce learning)走上了世界舞台。几年前,DeepMind 制作了一个可以玩 Atari 游戏的机器人,引发轩然大波。此后这个公司很快被谷歌收购。

很多研究者相信,强化学习是我们创造通用人工智能(Artificial General Intelligence)的最佳手段。这是一个令人兴奋的领域,有着许多未解决的挑战和巨大的潜能。

强化学习起初看似非常有挑战性,但其实要入门并不困难。在这篇文章中,我们将创造一个基于 Keras 的简单机器人,使它能玩 Catch 游戏。

Catch 游戏

原始的 Catch 游戏界面

Catch 是一个非常简单的街机游戏,你可能在孩提时代玩过它。游戏规则如下:水果从屏幕的顶部落下,玩家必须用一个篮子抓住它们;每抓住一个水果,玩家得一分;每漏掉一个水果,玩家会被扣除一分。这里的目标是让电脑自己玩 Catch 游戏。不过,我们不会使用这么漂亮的游戏界面。相反,我们会使用一个简单的游戏版本来简化任务:

简化的 Catch 游戏界面

玩 Catch 游戏时,玩家要决定三种可能的行为。玩家可以将篮子左移、右移或保持不动。这个决定取决于游戏的当前状态。也就是说,取决于果子掉落的位置和篮子的位置。我们的目标是创造这样一个模型:它能在给定游戏屏幕内容的情况下,选择导致得分最高的动作。

这个任务可以被看做一个简单的分类问题。我们可以让游戏专家多次玩这个游戏,并记录他们的行为。然后,可以通过选择类似于游戏专家的「正确」动作来训练模型。

但这实际上并不是人类学习的方式。人类可以在无指导的情况下,自学像 Catch 这样的游戏。这非常有用。想象一下,你如果每次想学习像 Catch 一样简单的东西,就必须雇佣一批专家玩这个游戏上千次!这必然非常昂贵而缓慢。

而在强化学习中,模型不会根据标记的数据训练,而是通过以往的经历。

深度强化学习

强化学习受行为心理学启发。我们并不为模型提供「正确的」行为,而是给予奖励和惩罚。该模型接受关于当前环境状态的信息(例如计算机游戏屏幕)。然后,它将输出一个动作,就像游戏手柄一样。环境将对这个动作做出回应,并提供下一个状态和奖惩行为。

据此,模型学习并寻找最大化奖励的行为。

实际上,有很多方式能够做到这一点。下面,让我们了解一下 Q-Learning。利用 Q-Learning 训练计算机玩 Atari 游戏的时候,Q-Learning 曾引起了轰动。现在,Q-Learning 依然是一个有重大意义的概念。大多数现代的强化学习算法,都是 Q-Learning 的一些改进。

理解 Q-Learning

了解 Q-Learning 的一个好方法,就是将 Catch 游戏和下象棋进行比较。

在这两种游戏中,你都会得到一个状态 S。在象棋中,这代表棋盘上棋子的位置。在 Catch 游戏中,这代表水果和篮子的位置。

然后,玩家要采取一个动作,称作 A。在象棋中,玩家要移动一个棋子。而在 Catch 游戏中,这代表着将篮子向左、向右移动,或是保持在当前位置。据此,会得到一些奖励 R 和一个新状态 S’。

Catch 游戏和象棋的一个共同点在于,奖励并不会立即出现在动作之后。

在 Catch 游戏中,只有在水果掉到篮子里或是撞到地板上时你才会获得奖励。而在象棋中,只有在整盘棋赢了或输了之后,才会获得奖励。这也就是说,奖励是稀疏分布的(sparsely distributed)。大多数时候,R 保持为零。

产生的奖励并不总是前一个动作的结果。也许,很早之前采取的某些动作才是获胜的关键。要弄清楚哪个动作对最终的奖励负责,这通常被称为信度分配问题(credit assignment problem)。

由于奖励的延迟性,优秀的象棋选手并不会仅通过最直接可见的奖励来选择他们的落子方式。相反,他们会考虑预期未来奖励(expected future reward),并据此进行选择。例如,他们不仅要考虑下一步是否能够消灭对手的一个棋子。他们也会考虑那些从长远的角度有益的行为。

在 Q-Learning 中,我们根据最高的预期未来奖励选行动。我们使用 Q 函数进行计算。这个数学函数有两个变量:游戏的当前状态和给定的动作。因此,我们可以将其记为 Q(state,action)。在 S 状态下,我们将估计每个可能的动作 A 所带来的的回报。我们假定在采取行动 A 且进入下一个状态 S’ 以后,一切都很完美。

对于给定状态 S 和动作 A,预期未来奖励 Q(S,A)被计算为即时奖励 R 加上其后的预期未来奖励 Q(S’,A’)。我们假设下一个动作 A’ 是最优的。

由于未来的不确定性,我们用 γ 因子乘以 Q(S’,A’)表示折扣:

Q(S,A) = R + γ * max Q(S’,A’)

象棋高手擅长在心里估算未来回报。换句话说,他们的 Q 函数 Q(S,A)非常精确。大多数象棋训练都是围绕着发展更好的 Q 函数进行的。玩家使用棋谱学习,从而了解特定动作如何发生,以及给定的动作有多大可能会导致胜利。但是,机器如何评估一个 Q 函数的好坏呢?这就是神经网络大展身手的地方了。

最终回归

玩游戏的时候,我们会产生很多「经历」,包括以下几个部分:

  • 初始状态,S
  • 采取的动作,A
  • 获得的奖励,R
  • 下一状态,S’

这些经历就是我们的训练数据。我们可以将估算 Q(S,A)的问题定义为回归问题。为了解决这个问题,我们可以使用神经网络。给定一个由 S 和 A 组成的输入向量,神经网络需要能预测 Q(S,A)的值等于目标:R + γ * max Q(S’,A’)。

如果我们能很好地预测不同状态 S 和不同行为 A 的 Q(S,A),我们就能很好地逼近 Q 函数。请注意,我们通过与 Q(S,A)相同的神经网络估算 Q(S’,A’)。

训练过程

给定一批经历 <S,A,R,S’>,其训练过程如下:

  1. 对于每个可能的动作 A’(向左、向右、不动),使用神经网络预测预期未来奖励 Q(S’,A’);
  2. 选择 3 个预期未来奖励中的最大值,作为 max Q(S’,A’);
  3. 计算 r + γ * max Q(S’,A’),这就是神经网络的目标值;
  4. 使用损失函数(loss function)训练神经网络。损失函数可以计算预测值离目标值的距离。此处,我们使用 0.5 * (predicted_Q(S,A)—target)² 作为损失函数。

在游戏过程中,所有的经历都会被存储在回放存储器(replay memory)中。这就像一个存储 <S,A,R,S’> 对的简单缓存。这些经历回放类同样能用于准备训练数据。让我们看看下面的代码:

  1. class ExperienceReplay(object): 
  2.     ""
  3.     During gameplay all the experiences < s, a, r, s’ > are stored in a replay memory.  
  4.     In training, batches of randomly drawn experiences are used to generate the input and target for training. 
  5.     ""
  6.     def __init__(self, max_memory=100, discount=.9): 
  7.         ""
  8.         Setup 
  9.         max_memory: the maximum number of experiences we want to store 
  10.         memory: a list of experiences 
  11.         discount: the discount factor for future experience 
  12.          
  13.         In the memory the information whether the game ended at the state is stored seperately in a nested array 
  14.         [... 
  15.         [experience, game_over] 
  16.         [experience, game_over] 
  17.         ...] 
  18.         ""
  19.         self.max_memory = max_memory 
  20.         self.memory = list() 
  21.         self.discount = discount 
  22.  
  23.     def remember(self, states, game_over): 
  24.         #Save a state to memory 
  25.         self.memory.append([states, game_over]) 
  26.         #We don't want to store infinite memories, so if we have too many, we just delete the oldest one 
  27.         if len(self.memory) > self.max_memory: 
  28.             del self.memory[0] 
  29.  
  30.     def get_batch(self, model, batch_size=10): 
  31.          
  32.         #How many experiences do we have? 
  33.         len_memory = len(self.memory) 
  34.          
  35.         #Calculate the number of actions that can possibly be taken in the game 
  36.         num_actions = model.output_shape[-1] 
  37.          
  38.         #Dimensions of the game field 
  39.         env_dim = self.memory[0][0][0].shape[1] 
  40.          
  41.         #We want to return an input and target vector with inputs from an observed state... 
  42.         inputs = np.zeros((min(len_memory, batch_size), env_dim)) 
  43.          
  44.         #...and the target r + gamma * max Q(s’,a’) 
  45.         #Note that our target is a matrix, with possible fields not only for the action taken but also 
  46.         #for the other possible actions. The actions not take the same value as the prediction to not affect them 
  47.         targets = np.zeros((inputs.shape[0], num_actions)) 
  48.          
  49.         #We draw states to learn from randomly 
  50.         for i, idx in enumerate(np.random.randint(0, len_memory, 
  51.                                                   size=inputs.shape[0])): 
  52.             ""
  53.             Here we load one transition <s, a, r, s’> from memory 
  54.             state_t: initial state s 
  55.             action_t: action taken a 
  56.             reward_t: reward earned r 
  57.             state_tp1: the state that followed s’ 
  58.             ""
  59.             state_t, action_t, reward_t, state_tp1 = self.memory[idx][0] 
  60.              
  61.             #We also need to know whether the game ended at this state 
  62.             game_over = self.memory[idx][1] 
  63.  
  64.             #add the state s to the input 
  65.             inputs[i:i+1] = state_t 
  66.              
  67.             # First we fill the target values with the predictions of the model. 
  68.             # They will not be affected by training (since the training loss for them is 0) 
  69.             targets[i] = model.predict(state_t)[0] 
  70.              
  71.             ""
  72.             If the game ended, the expected reward Q(s,a) should be the final reward r. 
  73.             Otherwise the target value is r + gamma * max Q(s’,a’) 
  74.             ""
  75.             #  Here Q_sa is max_a'Q(s', a') 
  76.             Q_sa = np.max(model.predict(state_tp1)[0]) 
  77.              
  78.             #if the game ended, the reward is the final reward 
  79.             if game_over:  # if game_over is True 
  80.                 targets[i, action_t] = reward_t 
  81.             else
  82.                 # r + gamma * max Q(s’,a’) 
  83.                 targets[i, action_t] = reward_t + self.discount * Q_sa 
  84.         return inputs, targets 

定义模型

现在让我们定义这个利用 Q-Learning 学习 Catch 游戏的模型。我们使用 Keras 作为 Tensorflow 的前端。我们的基准模型是一个简单的三层密集网络。这个模型在简单版的 Catch 游戏当中表现很好。你可以在 GitHub 中找到它的完整实现过程。

你也可以尝试更加复杂的模型,测试其能否获得更好的性能。

  1. num_actions = 3  # [move_left, stay, move_right] 
  2. hidden_size = 100 # Size of the hidden layers 
  3. grid_size = 10 # Size of the playing field 
  4.  
  5. def baseline_model(grid_size,num_actions,hidden_size): 
  6.     #seting up the model with keras 
  7.     model = Sequential() 
  8.     model.add(Dense(hidden_size, input_shape=(grid_size**2,), activation='relu')) 
  9.     model.add(Dense(hidden_size, activation='relu')) 
  10.     model.add(Dense(num_actions)) 
  11.     model.compile(sgd(lr=.1), "mse"
  12.     return model 

探索

Q-Learning 的最后一种成分是探索。日常生活的经验告诉我们,有时候你得做点奇怪的事情或是随机的手段,才能发现是否有比日常动作更好的东西。

Q-Learning 也是如此。总是做最好的选择,意味着你可能会错过一些从未探索的道路。为了避免这种情况,学习者有时会添加一个随机项,而未必总是用最好的。我们可以将定义训练方法如下:

  1. def train(model,epochs): 
  2.     # Train 
  3.     #Reseting the win counter 
  4.     win_cnt = 0 
  5.     # We want to keep track of the progress of the AI over time, so we save its win count history 
  6.     win_hist = [] 
  7.     #Epochs is the number of games we play 
  8.     for e in range(epochs): 
  9.         loss = 0. 
  10.         #Resetting the game 
  11.         env.reset() 
  12.         game_over = False 
  13.         # get initial input 
  14.         input_t = env.observe() 
  15.          
  16.         while not game_over: 
  17.             #The learner is acting on the last observed game screen 
  18.             #input_t is a vector containing representing the game screen 
  19.             input_tm1 = input_t 
  20.              
  21.             #Take a random action with probability epsilon 
  22.             if np.random.rand() <= epsilon: 
  23.                 #Eat something random from the menu 
  24.                 action = np.random.randint(0, num_actions, size=1) 
  25.             else
  26.                 #Choose yourself 
  27.                 #q contains the expected rewards for the actions 
  28.                 q = model.predict(input_tm1) 
  29.                 #We pick the action with the highest expected reward 
  30.                 action = np.argmax(q[0]) 
  31.  
  32.             # apply action, get rewards and new state 
  33.             input_t, reward, game_over = env.act(action
  34.             #If we managed to catch the fruit we add 1 to our win counter 
  35.             if reward == 1: 
  36.                 win_cnt += 1         
  37.              
  38.             #Uncomment this to render the game here 
  39.             #display_screen(action,3000,inputs[0]) 
  40.              
  41.             ""
  42.             The experiences < s, a, r, s’ > we make during gameplay are our training data. 
  43.             Here we first save the last experience, and then load a batch of experiences to train our model 
  44.             ""
  45.              
  46.             # store experience 
  47.             exp_replay.remember([input_tm1, action, reward, input_t], game_over)     
  48.              
  49.             # Load batch of experiences 
  50.             inputs, targets = exp_replay.get_batch(model, batch_size=batch_size) 
  51.    
  52.             # train model on experiences 
  53.             batch_loss = model.train_on_batch(inputs, targets) 
  54.              
  55.             #sum up loss over all batches in an epoch 
  56.             loss += batch_loss 
  57.         win_hist.append(win_cnt) 
  58.     return win_hist 

我将这个游戏机器人训练了 5000 个 epoch,结果表现得很不错!

Catch 机器人的动作

正如你在上述动图中看到的那样,机器人可以抓住从天空中掉落的苹果。为了将这个模型学习的过程可视化,我绘制了每一个 epoch 的胜利移动平均线,结果如下:

接下来做什么?现在,你已经对强化学习有了初步的直觉了解。我建议仔细阅读该教程的完整代码。你也可以试验看看。

深度学习 TensorFlow 游戏AI
上一篇:刚毕业就能拿到56万年薪?对!看看Twitter机器学习大牛写给你的进阶手册吧 下一篇:AI研究生应届生年薪可达50万 没出校门已被\"抢光\"
评论
取消
暂无评论,快去成为第一个评论的人吧

更多资讯推荐

2019机器学习框架之争:与Tensorflow竞争白热化,进击的PyTorch赢在哪里?

2019年,机器学习框架之争进入了新阶段:PyTorch与TensorFlow成为最后两大玩家,PyTorch占据学术界领军地位,TensorFlow在工业界力量依然强大,两个框架都在向对方借鉴,但是都不太理想。

大数据文摘 ·  3天前
18个挑战项目带你快速入门深度学习

AlphaGo 大战李世?h之后,深度学习技术便在国内变得异常火。吸引了大批的技术人员争相学习,那么到底如何才能更快速的入门深度学习呢?下面给大家介绍的 18 个挑战项目,通过实践动手带你快速入门深度学习!

实验楼 ·  4天前
盘点 | 8个你可能不知道的深度学习应用案例

深度学习与传统机器学习系统的不同之处在于,它能够在分析大型数据集时进行自我学习和改进,因此能应用在许多不同的领域。

天极网 ·  4天前
2019年较热门的5大深度学习课程

今天,我们将和大家盘点一下,当下较流行的深度学习资源/课程,可以帮助你们提升深度学习技能。

猿哥 ·  2019-09-26 05:16:24
DeepMind一次性开源3个新框架!深度强化学习应用落地即将迎来春天?

深度强化学习(Deep Reinforcement Learning,DRL)一直是近年来人工智能的一些重大突破的核心。然而,尽管 DRL 有了很大的进步,但由于缺乏工具和库,DRL 方法在主流解决方案中仍然难以应用。

杨鲤萍 ·  2019-09-20 09:38:18
一步一步带你完成深度学习与对象检测之人脸识别

要进行人脸识别,就要搜集用户的人脸图片,我们从网站上搜集了几个明星的照片来进行本期文章的分享。此部分文章是人脸识别的第一部分,人脸数据的搜集与提取,后期我们分享人脸识别系统的神经网络训练与人脸识别。

人工智能研究所 ·  2019-09-18 07:20:34
看懂这十步,8岁的小朋友都能理解深度学习

如果对当今人工智能的主流技术——深度学习没有了解,可能真的会有人觉得,当前的科学家们在创造无所不能、无所不知的电影AI形象。那么,如何用最浅显的方式,给大众解释什么是深度学习呢?快来看看吧!

佚名 ·  2019-09-17 16:56:39
PyTorch版《动手学深度学习》开源了,最美DL书遇上超赞DL框架

李沐等人的开源中文书《动手学深度学习》现在有 PyTorch 版实现了。不论是原书中的示例代码,还是实战项目,原来的 MXNet 都可以无缝转化到 PyTorch 代码。

ShusenTang ·  2019-09-17 10:23:45
Copyright©2005-2019 51CTO.COM 版权所有 未经许可 请勿转载