百度强化学习7日打卡营-学习心得

好好学习！天天SOTA！

开始机器学习中的另一领域：强化学习的入门练习啦！

7天的打卡学习，收获满满，理论知识及上手实践同步进行，让我从零实践强化学习的魅力。我总结了如下知识点及实操Tips：

1、什么是强化学习：
强化学习（Reinforcement Learning, RL），又称再励学习、评价学习或增强学习，是机器学习的范式和方法论之一，用于描述和解决智能体（agent）在与环境的交互过程中通过学习策略以达成回报最大化或实现特定目标的问题。

核心思想：智能体 agent 在环境 environment 中学习，根据环境的状态 state（或观测到的observation），执行动作 action ，并根据环境的反馈 reward（奖励）来指导更好的动作。

2、强化学习与监督学习的区别：

• 强化学习、监督学习、非监督学习是机器学习里的三个不同的领域，都跟深度学习有交集。
• 监督学习寻找输入到输出之间的映射，比如分类和回归问题。
• 非监督学习主要寻找数据之间的隐藏关系，比如聚类问题。
• 强化学习则需要在与环境的交互中学习和寻找最佳决策方案。
• 监督学习处理认知问题，强化学习处理决策问题。

3、强化学习相关算法：

• 强化学习有两种学习方案：基于价值(value-based)、基于策略(policy-based)
• 环境分类：离散控制场景（输出动作可数）、连续控制场景（输出动作值不可数）
• 经典算法：Q-learning、Sarsa、DQN、Policy Gradient、A3C、DDPG、PPO

4、强化学习的训练环境及框架：

• 强化学习经典环境库GYM将环境交互接口规范化为：重置环境reset()、交互step()、渲染render()
• 强化学习框架库PARL，将强化学习框架抽象为Model、Algorithm、Agent三层，使得强化学习算法的实现和调试更方便和灵活。
• PARL强化学习框架开源地址：https://github.com/PaddlePaddle/PARL

使用PARL实现DDPG算法代码：
Agent把产生的数据传给algorithm，algorithm根据model的模型结构计算出Loss，使用SGD或者其他优化器不断的优化，PARL这种架构可以很方便的应用在各类深度强化学习问题中。

（1）Model
Model用来定义前向(Forward)网络，用户可以自由的定制自己的网络结构：

class Model(parl.Model):
    def __init__(self, act_dim):
        self.actor_model = ActorModel(act_dim)
        self.critic_model = CriticModel()

    def policy(self, obs):
        return self.actor_model.policy(obs)

    def value(self, obs, act):
        return self.critic_model.value(obs, act)

    def get_actor_params(self):
        return self.actor_model.parameters()


class ActorModel(parl.Model):
    def __init__(self, act_dim):
        hid_size = 100

        self.fc1 = layers.fc(size=hid_size, act='relu')
        self.fc2 = layers.fc(size=act_dim, act='tanh')

    def policy(self, obs):
        hid = self.fc1(obs)
        means = self.fc2(hid)
        return means


class CriticModel(parl.Model):
    def __init__(self):
        hid_size = 100

        self.fc1 = layers.fc(size=hid_size, act='relu')
        self.fc2 = layers.fc(size=1, act=None)

    def value(self, obs, act):
        concat = layers.concat([obs, act], axis=1)
        hid = self.fc1(concat)
        Q = self.fc2(hid)
        Q = layers.squeeze(Q, axes=[1])
        return Q

（2）Algorithm
Algorithm 定义了具体的算法来更新前向网络(Model)，也就是通过定义损失函数来更新Model，和算法相关的计算都放在algorithm中。

# from parl.algorithms import DDPG # 也可以直接从parl库中快速引入DDPG算法，无需自己重新写算法

class DDPG(parl.Algorithm):
    def __init__(self,
                 model,
                 gamma=None,
                 tau=None,
                 actor_lr=None,
                 critic_lr=None):
        """  DDPG algorithm
        
        Args:
            model (parl.Model): actor and critic 的前向网络.
                                model 必须实现 get_actor_params() 方法.
            gamma (float): reward的衰减因子.
            tau (float): self.target_model 跟 self.model 同步参数 的 软更新参数
            actor_lr (float): actor 的学习率
            critic_lr (float): critic 的学习率
        """
        assert isinstance(gamma, float)
        assert isinstance(tau, float)
        assert isinstance(actor_lr, float)
        assert isinstance(critic_lr, float)
        self.gamma = gamma
        self.tau = tau
        self.actor_lr = actor_lr
        self.critic_lr = critic_lr

        self.model = model
        self.target_model = deepcopy(model)

    def predict(self, obs):
        """ 使用 self.model 的 actor model 来预测动作
        """
        return self.model.policy(obs)

    def learn(self, obs, action, reward, next_obs, terminal):
        """ 用DDPG算法更新 actor 和 critic
        """
        actor_cost = self._actor_learn(obs)
        critic_cost = self._critic_learn(obs, action, reward, next_obs,
                                         terminal)
        return actor_cost, critic_cost

    def _actor_learn(self, obs):
        action = self.model.policy(obs)
        Q = self.model.value(obs, action)
        cost = layers.reduce_mean(-1.0 * Q)
        optimizer = fluid.optimizer.AdamOptimizer(self.actor_lr)
        optimizer.minimize(cost, parameter_list=self.model.get_actor_params())
        return cost

    def _critic_learn(self, obs, action, reward, next_obs, terminal):
        next_action = self.target_model.policy(next_obs)
        next_Q = self.target_model.value(next_obs, next_action)

        terminal = layers.cast(terminal, dtype='float32')
        target_Q = reward + (1.0 - terminal) * self.gamma * next_Q
        target_Q.stop_gradient = True

        Q = self.model.value(obs, action)
        cost = layers.square_error_cost(Q, target_Q)
        cost = layers.reduce_mean(cost)
        optimizer = fluid.optimizer.AdamOptimizer(self.critic_lr)
        optimizer.minimize(cost)
        return cost

    def sync_target(self, decay=None, share_vars_parallel_executor=None):
        """ self.target_model从self.model复制参数过来，可设置软更新参数
        """
        if decay is None:
            decay = 1.0 - self.tau
        self.model.sync_weights_to(
            self.target_model,
            decay=decay,
            share_vars_parallel_executor=share_vars_parallel_executor)

（3）Agent
Agent负责算法与环境的交互，在交互过程中把生成的数据提供给Algorithm来更新模型(Model)，数据的预处理流程也一般定义在这里。

class Agent(parl.Agent):
    def __init__(self, algorithm, obs_dim, act_dim):
        assert isinstance(obs_dim, int)
        assert isinstance(act_dim, int)
        self.obs_dim = obs_dim
        self.act_dim = act_dim
        super(Agent, self).__init__(algorithm)

        # 注意：最开始先同步self.model和self.target_model的参数.
        self.alg.sync_target(decay=0)

    def build_program(self):
        self.pred_program = fluid.Program()
        self.learn_program = fluid.Program()

        with fluid.program_guard(self.pred_program):
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            self.pred_act = self.alg.predict(obs)

        with fluid.program_guard(self.learn_program):
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            act = layers.data(
                name='act', shape=[self.act_dim], dtype='float32')
            reward = layers.data(name='reward', shape=[], dtype='float32')
            next_obs = layers.data(
                name='next_obs', shape=[self.obs_dim], dtype='float32')
            terminal = layers.data(name='terminal', shape=[], dtype='bool')
            _, self.critic_cost = self.alg.learn(obs, act, reward, next_obs,
                                                 terminal)

    def predict(self, obs):
        obs = np.expand_dims(obs, axis=0)
        act = self.fluid_executor.run(
            self.pred_program, feed={'obs': obs},
            fetch_list=[self.pred_act])[0]
        act = np.squeeze(act)
        return act

    def learn(self, obs, act, reward, next_obs, terminal):
        feed = {
            'obs': obs,
            'act': act,
            'reward': reward,
            'next_obs': next_obs,
            'terminal': terminal
        }
        critic_cost = self.fluid_executor.run(
            self.learn_program, feed=feed, fetch_list=[self.critic_cost])[0]
        self.alg.sync_target()
        return critic_cost

通过以上几个算法实践，让我初步了解了Reinforcement Learning的理论及实践知识。同时也要感谢科科老师耐心的讲解课程，使我从零实践强化学习的入门过程。

下面的训练环境，等你来挑战：

1星环境：简单的弹跳和接球游戏：https://github.com/shivaverma/Orbit
2星环境：GYM环境 Box2D (需要安装 box2d-py)：https://gym.openai.com/envs/#box2d
PyGame游戏环境（含Flappy Bird）：https://github.com/ntasfi/PyGame-Learning-Environment
3星环境：GYM环境 Robotics (需要安装 mujoco_py和试用许可证书)：https://gym.openai.com/envs/#robotics
股票预测环境：https://github.com/kh-kim/stock_market_reinforcement_learning
RLSchool四轴飞行器的 速度控制任务 “velocity_control”：https://github.com/PaddlePaddle/RLSchool/tree/master/rlschool/quadrotor
4星环境：RLBench任务环境（使用机械臂完成某一项任务）：https://github.com/stepjam/RLBench
5星环境：交通信号灯控制：https://github.com/Ujwal2910/Smart-Traffic-Signals-in-India-using-Deep-Reinforcement-Learning-and-Advanced-Computer-Vision