DQN 自主学习玩转 AI 俄罗斯方块

作者 | 李秋键

责编 | Elle

出品 | CSDN(ID:CSDNnews)

自从20世纪80年代以来,游戏AI产生巨大的变化,诞生了“自主思考型AI”,游戏中的NPC会在游戏中观察及分析,根据玩家的行为做出针对性的应对,不再只是按照一个目标一直走下去,而是更加灵活多样。

自主思考性的AI是基于有限状态机与行为树,也就是多个if-else的组合。有限状态机是以电脑AI的当前状态为主体,通过编写不同的状态之间的转换条件来控制电脑AI,不同的状态下拥有不同的目标、策略与行动。

行为树则是以目前的行为作为主题,通过条件判断,得出接下来应该采取的行为策略和行为内容。其中最为典型的便为吃豆人游戏的应用:

而近几年来人工智能发展的迅速,直接推动了AI游戏领域的发展,其中最为代表性的算法便是DQN自主学习,即通过计算机自己尝试去游戏,从失败中总结经验达到高水平AI的效果。

其中就包括王者荣耀等游戏的AI机制。今天我们就将利用DQN去教会计算机玩转俄罗斯方块。

其中训练的部分效果见如图所示:

开始之前我们有必要去了解下DQN算法的基础知识。

基本原理

1. 什么是DQN?

DQN(Deep Q-Learning)可谓是深度强化学习(Deep Reinforcement Learning,DRL)的开山之作,是将深度学习与强化学习结合起来从而实现从感知(Perception)到动作( Action )的端对端(End-to-end)学习的一种全新的算法。

2. DQN是如何运算的?

(1)通过Q-Learning使用reward来构造标签

(2)通过experience replay(经验池)的方法来解决相关性及非静态分布问题

(3)使用一个CNN(MainNet)产生当前Q值,使用另外一个CNN(Target)产生Target Q值

3、DQN的网络模型?

下面是代码部分的讲解,我将在关键代码处进行注释说明。

代码实现

1、所使用的模块的导入:

#!/usr/bin/env python

from __future__ import print_function

import tensorflow as tf

import cv2

import sys

import random

import numpy as np

from collections import deque#导入双端队列

sys.path.append("game/")#添加Game目录到系统环境变量

import dummy_game

import tetris_fun as game

2、训练前的定义及初始化:

GAME = 'fangkuai' # 设置游戏名称

ACTIONS = 5 # 设置游戏动作数目

GAMMA = 0.99 # 设置增强学习更新公式中的累计折扣因子

OBSERVE = 100000. # 设置观察期的迭代次数

EXPLORE = 2000000. # 设置探索期的观察次数

FINAL_EPSILON = 0.0001 # 设置 ε的最终最小值

INITIAL_EPSILON = 0.0001 # 设置 ε的初始值

REPLAY_MEMORY = 50000 # 设置replay memory的容量

BATCH = 32 # 设置每次网络参数更新世用的样本数目

FRAME_PER_ACTION = 1#设置几帧图像进行一次动作

3. 神经网络调用函数参数的定义:

#设置w参数的函数,分布符合正太分布,且方差为0.01

def weight_variable(shape):

   initial = tf.truncated_normal(shape, stddev = 0.01)

   return tf.Variable(initial)

#设置B参数的函数,为偏执项,初始值为0.01

def bias_variable(shape):

   initial = tf.constant(0.01, shape = shape)

   return tf.Variable(initial)

#定义卷积操作,实现卷积核w在数据x卷积操作

def conv2d(x, W, stride):

   return tf.nn.conv2d(x, W, strides = [1, stride, stride, 1], padding = "SAME")

#定义池化函数,大小为2*2,步长为2

def max_pool_2x2(x):

   return tf.nn.max_pool(x, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

#定义神经网络参数值函数,目的是用来判断状态带来的结果

def createNetwork():

   # 卷积层参数

   W_conv1 = weight_variable([8, 8, 4, 32])

   b_conv1 = bias_variable([32])

   W_conv2 = weight_variable([4, 4, 32, 64])

   b_conv2 = bias_variable([64])

   W_conv3 = weight_variable([3, 3, 64, 64])

   b_conv3 = bias_variable([64])

   W_fc1 = weight_variable([1600, 512])

   b_fc1 = bias_variable([512])

   W_fc2 = weight_variable([512, ACTIONS])

   b_fc2 = bias_variable([ACTIONS])

   # 输入层

   s = tf.placeholder("float", [None, 80, 80, 4])

   # 隐藏层,用relu激活函数

   h_conv1 = tf.nn.relu(conv2d(s, W_conv1, 4) + b_conv1)

   h_pool1 = max_pool_2x2(h_conv1)

   h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2, 2) + b_conv2)

   #h_pool2 = max_pool_2x2(h_conv2)

   h_conv3 = tf.nn.relu(conv2d(h_conv2, W_conv3, 1) + b_conv3)

   #h_pool3 = max_pool_2x2(h_conv3)

   #h_pool3_flat = tf.reshape(h_pool3, [-1, 256])

   h_conv3_flat = tf.reshape(h_conv3, [-1, 1600])

   h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat, W_fc1) + b_fc1)

   #输出层

   readout = tf.matmul(h_fc1, W_fc2) + b_fc2

return s, readout, h_fc1

4. 训练部分的代码:

#定义训练神经网络函数,目的由执行的动作判断结果

def trainNetwork(s, readout, h_fc1, sess):

   # 定义损失函数

   a = tf.placeholder("float", [None, ACTIONS])

   y = tf.placeholder("float", [None])

   readout_action = tf.reduce_sum(tf.multiply(readout, a), reduction_indices=1)

   cost = tf.reduce_mean(tf.square(y - readout_action))

   train_step = tf.train.AdamOptimizer(1e-6).minimize(cost)

   # 开启游戏模拟器,会打开一个模拟器窗口,实时显示游戏信息

   game_state = game.GameState()

   # 创建双端队列用来存放replay memory

   D = deque()

   # 参数保存在文档中

   a_file = open("logs_" + GAME + "/readout.txt", 'w')

   h_file = open("logs_" + GAME + "/hidden.txt", 'w')

   # 设置游戏的初始状态,设置初始动作为不执行,并将初始状态修改为80*80*4的大小

   do_nothing = np.zeros(ACTIONS)

   do_nothing[0] = 1

   x_t, r_0, terminal = game_state.frame_step(do_nothing)#frame_step是游戏程序中的参数

   x_t = cv2.cvtColor(cv2.resize(x_t, (80, 80)), cv2.COLOR_BGR2GRAY)

   ret, x_t = cv2.threshold(x_t,1,255,cv2.THRESH_BINARY)#图像转为黑白

   s_t = np.stack((x_t, x_t, x_t, x_t), axis=2)

   # 用于加载或保存网络参数

   saver = tf.train.Saver()

   sess.run(tf.initialize_all_variables())

   checkpoint = tf.train.get_checkpoint_state("saved_networks")

   if checkpoint and checkpoint.model_checkpoint_path:

       saver.restore(sess, checkpoint.model_checkpoint_path)#模型保存的文件夹名称

       print("Successfully loaded:", checkpoint.model_checkpoint_path)

   else:

       print("Could not find old network weights")

   # 开始训练

   epsilon = INITIAL_EPSILON#设置 ε的初始值

   t = 0#设置t为学习次数

   while "flappy bird" != "angry bird":

       #使用ε贪心策略选择一个动作

       readout_t = readout.eval(feed_dict={s : [s_t]})[0]

       a_t = np.zeros([ACTIONS])

       action_index = 0

       if t % FRAME_PER_ACTION == 0:

           #执行一个随机动作

           if random.random() <= epsilon:

               print("----------Random Action----------")

               action_index = random.randrange(ACTIONS)

               a_t[random.randrange(ACTIONS)] = 1

           #由神经网络计算的Q(s,a)值确定执行的动作

           else:

               action_index = np.argmax(readout_t)

               a_t[action_index] = 1

       else:

           a_t[0] = 1 # 不执行任何动作

       # 随着游戏的进行不断降低ε的值,减少随机动作

       if epsilon > FINAL_EPSILON and t > OBSERVE:

           epsilon -= (INITIAL_EPSILON - FINAL_EPSILON) / EXPLORE

       # 执行选择的动作,并获得下一状态及回报

       x_t1_colored, r_t, terminal = game_state.frame_step(a_t)#分别为执行动作,与模拟器交互获得奖励和下一帧图像以及游戏是否终止

       x_t1 = cv2.cvtColor(cv2.resize(x_t1_colored, (80, 80)), cv2.COLOR_BGR2GRAY)

       ret, x_t1 = cv2.threshold(x_t1, 1, 255, cv2.THRESH_BINARY)

       x_t1 = np.reshape(x_t1, (80, 80, 1))

       #s_t1 = np.append(x_t1, s_t[:,:,1:], axis = 2)

       s_t1 = np.append(x_t1, s_t[:, :, :3], axis=2)

       # 将状态转移过程存储到D中,用于更新参数时采样

       D.append((s_t, a_t, r_t, s_t1, terminal))

       if len(D) > REPLAY_MEMORY:

           D.popleft()

       # 过了观察期才会进行网络参数的更新

       if t > OBSERVE:

           # 从D中随机采样,用于参数更新

           minibatch = random.sample(D, BATCH)

           # 分别将当前的状态,采取的动作,获得的回报,下一状态分组存放

           s_j_batch = [d[0] for d in minibatch]

           a_batch = [d[1] for d in minibatch]

           r_batch = [d[2] for d in minibatch]

           s_j1_batch = [d[3] for d in minibatch]

           #计算Q(s,a)的新值

           y_batch = []

           readout_j1_batch = readout.eval(feed_dict = {s : s_j1_batch})

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

               terminal = minibatch[i][4]

               # 如果游戏结束则只有反馈值

               if terminal:

                   y_batch.append(r_batch[i])

               else:

                   y_batch.append(r_batch[i] + GAMMA * np.max(readout_j1_batch[i]))

           # 使用梯度下降更新网络参数

           train_step.run(feed_dict = {

               y : y_batch,

               a : a_batch,

               s : s_j_batch}

           )

       # 状态发生改变时用于下次循环

       s_t = s_t1

       t += 1

       # 每进行10000次迭代保留一下参数

       if t % 10000 == 0:

           saver.save(sess, 'saved_networks/' + GAME + '-dqn', global_step = t)

       # 打印游戏信息

       state = ""

       if t <= OBSERVE:

           state = "observe"

       elif t > OBSERVE and t <= OBSERVE + EXPLORE:

           state = "explore"

       else:

           state = "train"

       print("TIMESTEP", t, "/ STATE", state,

           "/ EPSILON", epsilon, "/ ACTION", action_index, "/ REWARD", r_t,

           "/ Q_MAX %e" % np.max(readout_t))

       # write info to files

       '''

       if t % 10000 <= 100:

           a_file.write(",".join([str(x) for x in readout_t]) + ' ')

           h_file.write(",".join([str(x) for x in h_fc1.eval(feed_dict={s:[s_t]})[0]]) + ' ')

           cv2.imwrite("logs_tetris/frame" + str(t) + ".png", x_t1)

       '''

总结

下面开始展示游戏训练效果:

训练5秒后得到的分数:

训练10秒后得到的分数:

由此可见随着计算机的学习,他对于俄罗斯方块的操作是越来越好。

作者:李秋键,CSDN 博客专家,CSDN达人课作者。硕士在读于中国矿业大学,开发有安卓武侠游戏一部,vip视频解析,文意转换写作机器人等项目,发表论文若干,多次高数竞赛获奖等等。

热 文 推 荐 

PHP 可能在未来十年内消失?

苹果官网以旧换新价格暴跌;戴威退出 ofo 法人代表及高管;TensorFlow 2.1.0 发布| 极客头条

鲲鹏之大,何止几千里?

铁打的春晚,流水的互联网公司

达摩院 2020 预测:模块化降低芯片设计门槛 | 问底中国 IT 技术演进

千万不要和程序员一起合租!

在调查过基于模型的强化学习方法后,我们得到这些结论

漫话:如何给女朋友解释为什么一到年底,部分网站就会出现日期混乱的现象?

你点的每个“在看”,我都认真当成了喜欢

发布了1648 篇原创文章 · 获赞 4万+ · 访问量 1368万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 代码科技 设计师: Amelia_0503

分享到微信朋友圈

×

扫一扫,手机浏览