增强式学习：如何使用Q-Learning算法训练围棋机器人

class QAgent:
    def  __init(self, model, encoder):
        #参数model就是我们构造的神经网络
        self.model = model
        self.encoder = encoder  #对棋盘的编码
        self.temperature = 0  #对应epsilong参数
    def  set_temperature(self, temperature):
        self.temperature = temperature  #该参数的值越大，机器人胆子就越大，就越多的进行随机落子
    def set_collector(self, collector):
        #collector包含了机器人对弈时的棋盘数据
        self.collector = collector

def  select_move(self, game_state):
        board_tensor = self.encoder.encode(game_state) #对输入棋盘进行编码
        moves = []
        for move in game_state.legal_move():
            if not move.is_play:
                continue
            moves.append(self.encoder.encode_point(move.point)) #记录落子位置
            board_tensors.append(board_tensor) #将每个落子位置与当前棋盘对应起来
        if not moves:
            return goboard.Move.pass_turn()

        num_moves = len(moves)
        board_tensor = np.array(board_tensor)
        move_vectors = np.zeros((num_moves, self.encoder.num_points()))
        for i , move in enumerate(moves):
            move_vectors[i][move] = 1  #将落子位置转换为19*19的一维向量
        values = self.model.predict([board_tensors, move_vectors]) #让网络评判每个落子位置的优劣
        values = values.reshape(len(moves))  #转换为N*1二维矩阵,N是moves数组的长度
        ranked_moves = self.rank_moves_eps_greedy(values)  #将每一个落子位置按照网络给出的评分和相应策略进行调整
        for move_idx in ranked_moves:
            point = self.encoder.decode_point_index(moves[move_index])  #得到落子位置在二维棋盘上的对应位置
            if not is_point_an_eye(game_state.board,
                                  point, game_state.next_player):
                if self.collector is not None:
                    #将当前棋盘与相应的落子方式记录下来
                    self.collector.record_decision(state = board_tensor,
                                                  action = moves[move_idx])
                return goboard.Move.play(point)
        return go_board.Move.pass_turn()
    def  rank_moves_eps_greedy(self, values):
        if np.random.random() < self.temperature:  #如果生成随机数小于epsilong,那么随机选择一种可行的落子位置
            values = np.random.random(values.shape)
        ranked_moves = np.argsort(values)  #将网络对每一步落子给出的评分进行升序排列
        return ranked_moves[::-1]  #返回评分最高的落子方式

    def  train(self, experience, lr = 0.1, batch_size = 128):
        opt = SGD(lr = lr)
        self.model.compile(loss = 'mse', optimizer = opt)
        n = experience.states.shape[0]
        num_moves = self.encoder.num_points()
        y = np.zeros((n, ))
        for i in range(n):
            action = experience.actions[i]  #获得给定棋盘时对应的落子位置
            reward = experience.rewards[i] #如果模拟对弈中赢了，reward的值是1，如果输了值是-1
            y[i] = reward
        #如果最终结果是胜利，那么我们希望网络对落子位置的评分尽可能趋近与1，如果输了，我们希望网络对落子位置的评分尽可能接近-1
        self.model.fit([experience.states, actions], y , batch_size = batch_size,
                      epochs = 1)