def __init__(self):
    if not hasattr(self,'IMAGES'):
        print('InitGame!')
        self.beforeInit()
    self.score = self.playerIndex = self.loopIter = 0
    self.playerx = int(SCREENWIDTH * 0.3)
    self.playery = int((SCREENHEIGHT - self.PLAYER_HEIGHT) / 2.25)
    self.baseShift = self.IMAGES['base'].get_width() - self.BACKGROUND_WIDTH
    newPipe1 = getRandomPipe(self.PIPE_HEIGHT)
    newPipe2 = getRandomPipe(self.PIPE_HEIGHT)
    #...other code

def step(self, input_action=0):
    pygame.event.pump()
    reward = 0.1
    terminal = False
    if input_action == 1:
        if self.playery > -2 * self.PLAYER_HEIGHT:
            self.playerVelY = self.playerFlapAcc
            self.playerFlapped = True
   #...other code

   image_data=self.render()
   return image_data, reward, terminal,{}

#飛行一段距離,獎勵+0.1
reward = 0.1
#...other code

playerMidPos = self.playerx + self.PLAYER_WIDTH / 2
for pipe in self.upperPipes:
    pipeMidPos = pipe['x'] + self.PIPE_WIDTH / 2
    #穿過一個柱子獎勵加1
    if pipeMidPos <= playerMidPos < pipeMidPos + 4:             
        self.score += 1
        reward = self.reward(1)
#...other code

if isCrash:
    #撞到邊緣或者撞到柱子,結束,並且獎勵為-1
    terminal = True
    reward = self.reward(-1)

def reward(self,r):
    return r

def reset(self,mode='train'):
    self.__init__()
    self.mode=mode
    action0 = 1
    observation, reward, isOver,_ = self.step(action0)
    return observation,reward,isOver

def render(self):
    image_data = pygame.surfarray.array3d(pygame.display.get_surface())
    pygame.display.update()
    self.FPSCLOCK.tick(FPS)
    return image_data

#define maxEpisode=65535 //定義最大迭代輪數
#define maxStep=1024 //定義每一輪最多走多少步
initialize Q_table[|S|,|A|] //初始化Q矩陣
for i in range(0,maxEpisode):
    s=env.reset()  //初始化狀態s
    for j in range(0,maxStep):
        //用ε-greedy策略在s行選一個動作a
        choose action a using ε-greedy from Q_table[s] 
        s',R,terminal,_=env.step(a) //執行動作a,得到下一個狀態s',獎勵R，是否結束terminal
        max_s_prime_action=np.max(Q_table[s',:]) //選s'對應的最大行為值函式
        td=R+γ*max_s_prime_action //計算TD目標
        Q_table[s,a]= Q_table[s,a]+α*(td-Q_table[s,a]) //學習Q(s,a)的值
        s=s' //更新s，注意，和sarsa演算法不同，這裡的a不用更新
        if terminal:
            break

#Deep-Q-Network,Nature 2015 version

#定義為一個雙端佇列D，作為經驗回放區域，最大長度為max_size
Initialize replay_memory D as a deque,mas_size=50000

#初始化狀態-行為值函式Q的神經網路，權值隨機
Initialize action-value function Q(s,a|θ) as Neural Network with random-weights-initializer

#初始化TD目標網路，初始權值和θ相等
Initialize target action-value function Q(s,a|θ) with weights θ'=θ

#迭代max_episode個輪次
for episode in range(0,max_episode=65535):

    #重置環境env，得到初始狀態s
    s=env.reset()

    #迴圈事件的每一步，最多迭代max_step_limit個step
    for step in range(0,max_step_limit=1024):

        #通過ε-greedy的方式選出一個動作action
        With probability ε select a random action a or select a=argmax(Q(s,θ))

        #在env中執行動作a，得到下一個狀態s'，獎勵R,是否終止terminal
        s',R,terminal,_=env.step(a)

        #將五元組(s,a,s',R,terminal)壓進隊尾
        D.addLast(s,a,s',R,terminal)

        #如果佇列滿，彈出隊頭元素
        if D.isFull():
            D.removeFirst()

        #更新狀態s
        s=s'

        #從佇列中進行隨機取樣
        batch_experience[s,a,s',R,terminal]=random_select(D,batch_size=32)

        #計算TD目標
        target = R + γ*(1- terminal) * np.max(Q(s',θ'))

        #對loss函式執行Gradient-decent，訓練引數θ
        θ=θ+α*(target-Q(s,a|θ))▽Q(s,a|θ)

        #每隔C步，同步θ與θ'的權值
        Every C steps set θ'=θ

        #是否結束
        if terminal：
           break 

class BirdModel(Model):
    def __init__(self, act_dim):
        self.act_dim = act_dim
        #padding方式為valid
        p_valid=0
        self.conv1 = layers.conv2d(
            num_filters=32, filter_size=8, stride=4, padding=p_valid, act='relu')
        self.conv2 = layers.conv2d(
            num_filters=64, filter_size=4, stride=2, padding=p_valid, act='relu')
        self.conv3 = layers.conv2d(
            num_filters=64, filter_size=3, stride=1, padding=p_valid, act='relu')
        self.fc0=layers.fc(size=512)
        self.fc1 = layers.fc(size=act_dim)

    def value(self, obs):
        #輸入歸一化
        obs = obs / 255.0
        out = self.conv1(obs)
        out = self.conv2(out)
        out = self.conv3(out)
        out = layers.flatten(out, axis=1)
        out = self.fc0(out)
        out = self.fc1(out)
        return out

#根據obs以及引數θ計算狀態-行為值函式pred_value，對應虛擬碼中的Q(s,θ)
pred_value = self.model.value(obs)

#根據next_obs以及引數θ'計算目標網路的狀態-行為值函式next_pred_value，對應虛擬碼中的Q(s',θ')
next_pred_value = self.target_model.value(next_obs)

#選出next_pred_value的最大值best_v，對應虛擬碼中的np.max(Q(s',θ'))；注意θ'不參與訓練，所以要stop_gradient
best_v = layers.reduce_max(next_pred_value, dim=1)
best_v.stop_gradient = True

#計算TD目標
target = reward + (1.0 - layers.cast(terminal, dtype='float32')) * self.gamma * best_v

#輸入的動作action與pred_value作哈達瑪積，選出要評估的狀態-行為值函式pred_action_value，對應虛擬碼中的 Q(s,a|θ)
action_onehot = layers.one_hot(action, self.action_dim)
action_onehot = layers.cast(action_onehot, dtype='float32')
pred_action_value = layers.reduce_sum(layers.elementwise_mul(action_onehot, pred_value), dim=1)

#mse以及梯度下降，對應虛擬碼中的θ=θ+α*(target-Q(s,a|θ))▽Q(s,a|θ)
cost = layers.square_error_cost(pred_action_value, target)
cost = layers.reduce_mean(cost)
optimizer = fluid.optimizer.Adam(self.lr, epsilon=1e-3)
optimizer.minimize(cost)

def sync_target(self, gpu_id):
    """ sync parameters of self.target_model with self.model
    """
    self.model.sync_params_to(self.target_model, gpu_id=gpu_id)

#儲存模型
def save_params(self, learnDir,predictDir):
    fluid.io.save_params(
        executor=self.fluid_executor,
        dirname=learnDir,
        main_program=self.learn_programs[0])   
    fluid.io.save_params(
        executor=self.fluid_executor,
        dirname=predictDir,
        main_program=self.predict_programs[0])     

#載入模型
def load_params(self, learnDir,predictDir): 
    fluid.io.load_params(
        executor=self.fluid_executor,
        dirname=learnDir,
        main_program=self.learn_programs[0])  
    fluid.io.load_params(
        executor=self.fluid_executor,
        dirname=predictDir,
        main_program=self.predict_programs[0]) 

#每訓練多少步更新target網路,超引數可調
self.update_target_steps = 5000

#初始探索概率ε,超引數可微調
self.exploration = 0.8

#每步探索的衰減程度,超引數可微調
self.exploration_dacay=1e-6

#最小探索概率,超引數可微調
self.min_exploration=0.05

self.state = np.zeros((self.max_size, ) + state_shape, dtype='int32')
self.action = np.zeros((self.max_size, ), dtype='int32')
self.reward = np.zeros((self.max_size, ), dtype='float32')
self.isOver = np.zeros((self.max_size, ), dtype='bool')
#_context是一個滑動視窗,長度永遠保持3
self._context = deque(maxlen=context_len - 1)

 #訓練一個episode
def run_train_episode(env, agent, rpm):
    global trainEpisode
    global meanReward
    total_reward = 0
    all_cost = []
    #重置環境
    state,_, __ = env.reset()
    step = 0
    #迴圈每一步
    while True:
        context = rpm.recent_state()
        context.append(resizeBirdrToAtari(state))
        context = np.stack(context, axis=0)
        #用ε-greedy的方式選一個動作
        action = agent.sample(context)
        #執行動作
        next_state, reward, isOver,_ = env.step(action)
        step += 1
        #存入replay_buffer
        rpm.append(Experience(resizeBirdrToAtari(state), action, reward, isOver))
        if rpm.size() > MEMORY_WARMUP_SIZE:
            if step % UPDATE_FREQ == 0:
                #從replay_buffer中隨機取樣
                batch_all_state, batch_action, batch_reward, batch_isOver = rpm.sample_batch(batchSize)
                batch_state = batch_all_state[:, :CONTEXT_LEN, :, :]
                batch_next_state = batch_all_state[:, 1:, :, :]
                #執行SGD,訓練引數θ
                cost=agent.learn(batch_state,batch_action, batch_reward,batch_next_state, batch_isOver)
                all_cost.append(float(cost))
        total_reward += reward
        state = next_state
        if isOver or step>=MAX_Step_Limit:
            break
    if all_cost:
        trainEpisode+=1
        #以滑動平均的方式列印平均獎勵
        meanReward=meanReward+(total_reward-meanReward)/trainEpisode
        print('\n trainEpisode:{},total_reward:{:.2f}, meanReward:{:.2f} mean_cost:{:.3f}'\
              .format(trainEpisode,total_reward, meanReward,np.mean(all_cost)))
    return total_reward, step

#充滿replay-memory,使其達到warm-up-size才開始訓練
MEMORY_WARMUP_SIZE = MEMORY_SIZE//20

##一輪episode最多執行多少次step，不然小鳥會無限制的飛下去,相當於gym.env中的_max_episode_steps屬性
MAX_Step_Limit=int(1<<12)

#用一個雙端佇列記錄最近16次episode的平均獎勵
avgQueue=deque(maxlen=16)

#衰減因子
GAMMA = 0.99

#學習率
LEARNING_RATE = 1e-3 * 0.5

#記錄日誌的頻率
log_freq=10

if __name__ == '__main__':
    print("train or test ?")
    mode=input()
    print(mode)
    if mode=='train':
        train()
    elif mode=='test':
        test()
    else:
        print('Invalid input!')