用Tensorflow基于Deep Q Learning DQN 玩Flappy Bird
前言
2013年DeepMind 在NIPS上发表Playing Atari with Deep Reinforcement Learning 一文,提出了DQN(Deep Q Network)算法,实现端到端学习玩Atari游戏,即只有像素输入,看着屏幕玩游戏。Deep Mind就凭借这个应用以6亿美元被Google收购。由于DQN的开源,在github上涌现了大量各种版本的DQN程序。但大多是复现Atari的游戏,代码量很大,也不好理解。
Flappy Bird是个极其简单又困难的游戏,风靡一时。在很早之前,就有人使用Q-Learning 算法来实现完Flappy Bird。http://sarvagyavaish.github.io/FlappyBirdRL/
但是这个的实现是通过获取小鸟的具体位置信息来实现的。
能否使用DQN来实现通过屏幕学习玩Flappy Bird是一个有意思的挑战。(话说本人和朋友在去年年底也考虑了这个idea,但当时由于不知道如何截取游戏屏幕只能使用具体位置来学习,不过其实也成功了)
最近,github上有人放出使用DQN玩Flappy Bird的代码,https://github.com/yenchenlin1994/DeepLearningFlappyBird【1】
该repo通过结合之前的repo成功实现了这个想法。这个repo对整个实现过程进行了较详细的分析,但是由于其DQN算法的代码基本采用别人的repo,代码较为混乱,不易理解。
为此,本人改写了一个版本https://github.com/songrotek/DRL-FlappyBird
对DQN代码进行了重新改写。本质上对其做了类的封装,从而使代码更具通用性。可以方便移植到其他应用。
当然,本文的目的是借Flappy Bird DQN这个代码来详细分析一下DQN算法极其使用。
DQN 伪代码
这个是NIPS13版本的伪代码:
Initialize replay memory D to size N
Initialize action-value function Q with random weights
for episode = 1, M doInitialize state s_1for t = 1, T doWith probability ϵ select random action a_totherwise select a_t=max_a Q($s_t$,a; $θ_i$)Execute action a_t in emulator and observe r_t and s_(t+1)Store transition (s_t,a_t,r_t,s_(t+1)) in DSample a minibatch of transitions (s_j,a_j,r_j,s_(j+1)) from DSet y_j:=r_j for terminal s_(j+1)r_j+γ*max_(a^' ) Q(s_(j+1),a'; θ_i) for non-terminal s_(j+1)Perform a gradient step on (y_j-Q(s_j,a_j; θ_i))^2 with respect to θend for
end for
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
基本的分析详见Paper Reading 1 - Playing Atari with Deep Reinforcement Learning
基础知识详见Deep Reinforcement Learning 基础知识(DQN方面)
本文主要从代码实现的角度来分析如何编写Flappy Bird DQN的代码
编写FlappyBirdDQN.py
首先,FlappyBird的游戏已经编写好,是现成的。提供了很简单的接口:
nextObservation,reward,terminal = game.frame_step(action)
- 1
- 1
即输入动作,输出执行完动作的屏幕截图,得到的反馈reward,以及游戏是否结束。
那么,现在先把DQN想象为一个大脑,这里我们也用BrainDQN类来表示,这个类只需获取感知信息也就是上面说的观察(截图),反馈以及是否结束,然后输出动作即可。
完美的代码封装应该是这样。具体DQN里面如何存储。如何训练是外部不关心的。
因此,我们的FlappyBirdDQN代码只有如下这么短:
# -------------------------
# Project: Deep Q-Learning on Flappy Bird
# Author: Flood Sung
# Date: 2016.3.21
# -------------------------import cv2
import sys
sys.path.append("game/")
import wrapped_flappy_bird as game
from BrainDQN import BrainDQN
import numpy as np# preprocess raw image to 80*80 gray image
def preprocess(observation):observation = cv2.cvtColor(cv2.resize(observation, (80, 80)), cv2.COLOR_BGR2GRAY)ret, observation = cv2.threshold(observation,1,255,cv2.THRESH_BINARY)return np.reshape(observation,(80,80,1))def playFlappyBird():# Step 1: init BrainDQNbrain = BrainDQN()# Step 2: init Flappy Bird GameflappyBird = game.GameState()# Step 3: play game# Step 3.1: obtain init stateaction0 = np.array([1,0]) # do nothingobservation0, reward0, terminal = flappyBird.frame_step(action0)observation0 = cv2.cvtColor(cv2.resize(observation0, (80, 80)), cv2.COLOR_BGR2GRAY)ret, observation0 = cv2.threshold(observation0,1,255,cv2.THRESH_BINARY)brain.setInitState(observation0)# Step 3.2: run the gamewhile 1!= 0:action = brain.getAction()nextObservation,reward,terminal = flappyBird.frame_step(action)nextObservation = preprocess(nextObservation)brain.setPerception(nextObservation,action,reward,terminal)def main():playFlappyBird()if __name__ == '__main__':main()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
核心部分就在while循环里面,由于要讲图像转换为80x80的灰度图,因此,加了一个preprocess预处理函数。
这里,显然只有有游戏引擎,换一个游戏是一样的写法,非常方便。
接下来就是编写BrainDQN.py 我们的游戏大脑
编写BrainDQN
基本架构:
class BrainDQN:def __init__(self):# init replay memoryself.replayMemory = deque()# init Q networkself.createQNetwork()def createQNetwork(self):def trainQNetwork(self):def setPerception(self,nextObservation,action,reward,terminal):def getAction(self):def setInitState(self,observation):
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
基本的架构也就只需要上面这几个函数,其他的都是多余了,接下来就是编写每一部分的代码。
CNN代码
也就是createQNetwork部分,这里采用如下图的结构(转自【1】):
这里就不讲解整个流程了。主要是针对具体的输入类型和输出设计卷积和全连接层。
代码如下:
def createQNetwork(self):# network weightsW_conv1 = self.weight_variable([8,8,4,32])b_conv1 = self.bias_variable([32])W_conv2 = self.weight_variable([4,4,32,64])b_conv2 = self.bias_variable([64])W_conv3 = self.weight_variable([3,3,64,64])b_conv3 = self.bias_variable([64])W_fc1 = self.weight_variable([1600,512])b_fc1 = self.bias_variable([512])W_fc2 = self.weight_variable([512,self.ACTION])b_fc2 = self.bias_variable([self.ACTION])# input layerself.stateInput = tf.placeholder("float",[None,80,80,4])# hidden layersh_conv1 = tf.nn.relu(self.conv2d(self.stateInput,W_conv1,4) + b_conv1)h_pool1 = self.max_pool_2x2(h_conv1)h_conv2 = tf.nn.relu(self.conv2d(h_pool1,W_conv2,2) + b_conv2)h_conv3 = tf.nn.relu(self.conv2d(h_conv2,W_conv3,1) + b_conv3)h_conv3_flat = tf.reshape(h_conv3,[-1,1600])h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat,W_fc1) + b_fc1)# Q Value layerself.QValue = tf.matmul(h_fc1,W_fc2) + b_fc2self.actionInput = tf.placeholder("float",[None,self.ACTION])self.yInput = tf.placeholder("float", [None]) Q_action = tf.reduce_sum(tf.mul(self.QValue, self.actionInput), reduction_indices = 1)self.cost = tf.reduce_mean(tf.square(self.yInput - Q_action))self.trainStep = tf.train.AdamOptimizer(1e-6).minimize(self.cost)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
记住输出是Q值,关键要计算出cost,里面关键是计算Q_action的值,即该state和action下的Q值。由于actionInput是one hot vector的形式,因此tf.mul(self.QValue, self.actionInput)正好就是该action下的Q值。
training 部分。
这部分是代码的关键部分,主要是要计算y值,也就是target Q值。
def trainQNetwork(self):# Step 1: obtain random minibatch from replay memoryminibatch = random.sample(self.replayMemory,self.BATCH_SIZE)state_batch = [data[0] for data in minibatch]action_batch = [data[1] for data in minibatch]reward_batch = [data[2] for data in minibatch]nextState_batch = [data[3] for data in minibatch]# Step 2: calculate y y_batch = []QValue_batch = self.QValue.eval(feed_dict={self.stateInput:nextState_batch})for i in range(0,self.BATCH_SIZE):terminal = minibatch[i][4]if terminal:y_batch.append(reward_batch[i])else:y_batch.append(reward_batch[i] + GAMMA * np.max(QValue_batch[i]))self.trainStep.run(feed_dict={self.yInput : y_batch,self.actionInput : action_batch,self.stateInput : state_batch})
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
其他部分
其他部分就比较容易了,这里直接贴出完整的代码:
# -----------------------------
# File: Deep Q-Learning Algorithm
# Author: Flood Sung
# Date: 2016.3.21
# -----------------------------import tensorflow as tf
import numpy as np
import random
from collections import deque class BrainDQN:# Hyper Parameters:ACTION = 2FRAME_PER_ACTION = 1GAMMA = 0.99 # decay rate of past observationsOBSERVE = 100000. # timesteps to observe before trainingEXPLORE = 150000. # frames over which to anneal epsilonFINAL_EPSILON = 0.0 # final value of epsilonINITIAL_EPSILON = 0.0 # starting value of epsilonREPLAY_MEMORY = 50000 # number of previous transitions to rememberBATCH_SIZE = 32 # size of minibatchdef __init__(self):# init replay memoryself.replayMemory = deque()# init Q networkself.createQNetwork()# init some parametersself.timeStep = 0self.epsilon = self.INITIAL_EPSILONdef createQNetwork(self):# network weightsW_conv1 = self.weight_variable([8,8,4,32])b_conv1 = self.bias_variable([32])W_conv2 = self.weight_variable([4,4,32,64])b_conv2 = self.bias_variable([64])W_conv3 = self.weight_variable([3,3,64,64])b_conv3 = self.bias_variable([64])W_fc1 = self.weight_variable([1600,512])b_fc1 = self.bias_variable([512])W_fc2 = self.weight_variable([512,self.ACTION])b_fc2 = self.bias_variable([self.ACTION])# input layerself.stateInput = tf.placeholder("float",[None,80,80,4])# hidden layersh_conv1 = tf.nn.relu(self.conv2d(self.stateInput,W_conv1,4) + b_conv1)h_pool1 = self.max_pool_2x2(h_conv1)h_conv2 = tf.nn.relu(self.conv2d(h_pool1,W_conv2,2) + b_conv2)h_conv3 = tf.nn.relu(self.conv2d(h_conv2,W_conv3,1) + b_conv3)h_conv3_flat = tf.reshape(h_conv3,[-1,1600])h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat,W_fc1) + b_fc1)# Q Value layerself.QValue = tf.matmul(h_fc1,W_fc2) + b_fc2self.actionInput = tf.placeholder("float",[None,self.ACTION])self.yInput = tf.placeholder("float", [None]) Q_action = tf.reduce_sum(tf.mul(self.QValue, self.actionInput), reduction_indices = 1)self.cost = tf.reduce_mean(tf.square(self.yInput - Q_action))self.trainStep = tf.train.AdamOptimizer(1e-6).minimize(self.cost)# saving and loading networkssaver = tf.train.Saver()self.session = tf.InteractiveSession()self.session.run(tf.initialize_all_variables())checkpoint = tf.train.get_checkpoint_state("saved_networks")if checkpoint and checkpoint.model_checkpoint_path:saver.restore(self.session, checkpoint.model_checkpoint_path)print "Successfully loaded:", checkpoint.model_checkpoint_pathelse:print "Could not find old network weights"def trainQNetwork(self):# Step 1: obtain random minibatch from replay memoryminibatch = random.sample(self.replayMemory,self.BATCH_SIZE)state_batch = [data[0] for data in minibatch]action_batch = [data[1] for data in minibatch]reward_batch = [data[2] for data in minibatch]nextState_batch = [data[3] for data in minibatch]# Step 2: calculate y y_batch = []QValue_batch = self.QValue.eval(feed_dict={self.stateInput:nextState_batch})for i in range(0,self.BATCH_SIZE):terminal = minibatch[i][4]if terminal:y_batch.append(reward_batch[i])else:y_batch.append(reward_batch[i] + GAMMA * np.max(QValue_batch[i]))self.trainStep.run(feed_dict={self.yInput : y_batch,self.actionInput : action_batch,self.stateInput : state_batch})# save network every 100000 iterationif self.timeStep % 10000 == 0:saver.save(self.session, 'saved_networks/' + 'network' + '-dqn', global_step = self.timeStep)def setPerception(self,nextObservation,action,reward,terminal):newState = np.append(nextObservation,self.currentState[:,:,1:],axis = 2)self.replayMemory.append((self.currentState,action,reward,newState,terminal))if len(self.replayMemory) > self.REPLAY_MEMORY:self.replayMemory.popleft()if self.timeStep > self.OBSERVE:# Train the networkself.trainQNetwork()self.currentState = newStateself.timeStep += 1def getAction(self):QValue = self.QValue.eval(feed_dict= {self.stateInput:[self.currentState]})[0]action = np.zeros(self.ACTION)action_index = 0if self.timeStep % self.FRAME_PER_ACTION == 0:if random.random() <= self.epsilon:action_index = random.randrange(self.ACTION)action[action_index] = 1else:action_index = np.argmax(QValue)action[action_index] = 1else:action[0] = 1 # do nothing# change episilonif self.epsilon > self.FINAL_EPSILON and self.timeStep > self.OBSERVE:self.epsilon -= (self.INITIAL_EPSILON - self.FINAL_EPSILON)/self.EXPLOREreturn actiondef setInitState(self,observation):self.currentState = np.stack((observation, observation, observation, observation), axis = 2)def weight_variable(self,shape):initial = tf.truncated_normal(shape, stddev = 0.01)return tf.Variable(initial)def bias_variable(self,shape):initial = tf.constant(0.01, shape = shape)return tf.Variable(initial)def conv2d(self,x, W, stride):return tf.nn.conv2d(x, W, strides = [1, stride, stride, 1], padding = "SAME")def max_pool_2x2(self,x):return tf.nn.max_pool(x, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
一共也只有160代码。
如果这个任务不使用深度学习,而是人工的从图像中找到小鸟,然后计算小鸟的轨迹,然后计算出应该怎么按键,那么代码没有好几千行是不可能的。深度学习大大减少了代码工作。
小结
本文从代码角度对于DQN做了一定的分析,对于DQN的应用,大家可以在此基础上做各种尝试。
用Tensorflow基于Deep Q Learning DQN 玩Flappy Bird相关推荐
- Deep Q learning: DQN及其改进
Deep Q Learning Generalization Deep Reinforcement Learning 使用深度神经网络来表示 价值函数 策略 模型 使用随机梯度下降(SGD)优化los ...
- 零基础10分钟运行DQN图文教程 Playing Flappy Bird Using Deep Reinforcement Learning (Based on Deep Q Learning DQN
文件下载 链接:http://pan.baidu.com/s/1jH9ItTW 密码:0pmq 文件列表 Anaconda3-4.2.0-Windows-x86_64.exe (python3.5 ...
- 【Pytorch】第 9 章 :Capstone 项目——用 DQN 玩 Flappy Bird
- CNNs and Deep Q Learning
前面的一篇博文介绍了函数价值近似,是以简单的线性函数来做的,这篇博文介绍使用深度神经网络来做函数近似,也就是Deep RL.这篇博文前半部分介绍DNN.CNN,熟悉这些的读者可以跳过,直接看后半部分的 ...
- 一步步分析AI如何玩Flappy Bird
一.Flappy Bird 游戏展示 在介绍模型.算法前先来直接看下效果,上图是刚开始训练的时候,画面中的小鸟就像无头苍蝇一样乱飞,下图展示的是在本机(后面会给出配置)训练超过10小时后(训练步数超过 ...
- 程序员带你一步步分析AI如何玩Flappy Bird
以下内容来源于一次部门内部的分享,主要针对AI初学者,介绍包括CNN.Deep Q Network以及TensorFlow平台等内容.由于笔者并非深度学习算法研究者,因此以下更多从应用的角度对整个系统 ...
- 程序员带你一步步分析AI如何玩Flappy Bird
以下内容来源于一次部门内部的分享,主要针对AI初学者,介绍包括CNN.Deep Q Network以及TensorFlow平台等内容.由于笔者并非深度学习算法研究者,因此以下更多从应用的角度对整个系统 ...
- Python详细了解强化学习算法并基于强化学习Q_learning让电脑玩flappy bird游戏
完整代码:https://github.com/Connor666/flappy_bird-RL 首先,如果你是为了追求一个非常高的强化学习效果,也就是flappy bird的分数,那么建议出门右拐选 ...
- Deep Q Learning伪代码分析及翻译
伪代码 代码翻译及分析 初始化记忆体D中的记忆N 初始化随机权重θaction值的函数Q(Q估计) 初始化权重θ-=θ target-action值的函数^Q(Q现实) 循环:初始化第一个场景s1=x ...
- 深度强化学习 Deep Reinforcement Learning 学习整理
这学期的一门机器学习课程中突发奇想,既然卷积神经网络可以识别一副图片,解决分类问题,那如果用神经网络去控制'自动驾驶',在一个虚拟的环境中不停的给网络输入车周围环境的图片,让它去选择前后左右中的一个操 ...
最新文章
- shell中引号的使用方法
- 后端码农谈前端(CSS篇)第一课:CSS概述
- lodash 工具库
- python爬虫实例-10个python爬虫入门实例
- python怎么安装requests库-小白安装python的第三方库:requests库
- 2018.07.30 巴别时代
- 《C++必知必会》读书笔记2
- 基于Xilinx FPGA生态,加速提升视频处理质量
- 通过ABAP代码判断当前系统类型,BYD还是S4 OP还是S4 Cloud
- 在上司面前硬不起来?教你如何快速将字符串转换为可执行代码
- linux无法下载ftp,linux 不能下载怎么办
- Linux下计算进程的CPU占用和内存占用的编程方法[转]
- Andoid Activity.getWindowManager().getDefaultDisplay().getWidth()已被废弃
- python-unicode十进制数字转中文
- 递归函数的例子python卖鸭子_递归算法实现卖鸭子
- 0.1+0.2 等于 0.3 吗?(数字相加结果有无限小数的原因及解决方式)
- 微信小程序 购物车简单实例
- 拼多多:item_search-根据关键词取商品列表接口,拼多多关键词搜索API接口,拼多多上货API接口,拼多多API接口
- oracle 日志 性能,Oracle日志的性能介绍及原理剖析-Oracle
- Java(老白再次入门) - 数组
热门文章
- 那些年陪伴我的老师+我期待的师生关系
- Debian Gnu/Linux8.5安装GOLANG环境笔记
- Android UI系列-----Dialog对话框
- 小米6 twrp_小米手机刷国际版欧版 MIUI 的详细教程
- pyqt5 tablewidget 设置行高_Python+PyQt5基础开发(10)
- linux怎么编译python_linux 编译安装python3
- android 隐藏系统音量的接口_Android9.0 系统默认配置清单
- java spite截取_Java內功心法,行為型設計模式
- steam服务器维护6月28,绝地求生6月28日维护更新公告 绝地求生6月28日更新内容汇总...
- C/C++[算法入门]续