百度七日入门强化学习训练营

最新推荐文章于 2022-09-11 21:33:39 发布

weixin_40054643

最新推荐文章于 2022-09-11 21:33:39 发布

阅读量406

点赞数

文章标签：数据挖掘深度学习

本文链接：https://blog.csdn.net/weixin_40054643/article/details/106883706

版权

一直都有在参加百度7日训练营活动，这次是关于强化学习的~

强化学习一直都是我想学，但是总是遇到各种阻碍就放弃的，这次算是系统的学习了一遍，希望以后有时间可以继续深化~

科科老师牛皮~

强化学习（RL）初印象

Part1 什么是强化学习

强化学习（英语：Reinforcement learning，简称RL）是机器学习中的一个领域，强调如何基于环境而行动，以取得最大化的预期利益。
核心思想：智能体agent在环境environment中学习，根据环境的状态state（或观测到的observation），执行动作action，并根据环境的反馈 reward（奖励）来指导更好的动作。

注意：从环境中获取的状态，有时候叫state，有时候叫observation，这两个其实一个代表全局状态，一个代表局部观测值，在多智能体环境里会有差别，但我们刚开始学习遇到的环境还没有那么复杂，可以先把这两个概念划上等号。

强化学习模型

Part2 强化学习能做什么

游戏（马里奥、Atari、Alpha Go、星际争霸等）
机器人控制（机械臂、机器人、自动驾驶、四轴飞行器等）
用户交互（推荐、广告、NLP等）
交通（拥堵管理等）
资源调度（物流、带宽、功率等）
金融（投资组合、股票买卖等）
其他

Part3 强化学习与监督学习的区别

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

Part4 强化学习的如何解决问题

强化学习通过不断的试错探索，吸取经验和教训，持续不断的优化策略，从环境中拿到更好的反馈。
强化学习有两种学习方案：基于价值(value-based)、基于策略(policy-based)

Part5 强化学习的算法和环境

经典算法：Q-learning、Sarsa、DQN、Policy Gradient、A3C、DDPG、PPO
环境分类：离散控制场景（输出动作可数）、连续控制场景（输出动作值不可数）
强化学习经典环境库GYM将环境交互接口规范化为：重置环境reset()、交互step()、渲染render()
强化学习框架库PARL将强化学习框架抽象为Model、Algorithm、Agent三层，使得强化学习算法的实现和调试更方便和灵活。

Part6 实践熟悉强化学习环境

GYM是强化学习中经典的环境库，下节课我们会用到里面的CliffWalkingWapper和FrozenLake环境，为了使得环境可视化更有趣一些，直播课视频中演示的Demo对环境的渲染做了封装，感兴趣的同学可以在PARL代码库中的examples/tutorials/lesson1中下载gridworld.py使用。
PARL开源库地址：https://github.com/PaddlePaddle/PARL

Lesson2 表格型方法——Sarsa

1. Sarsa 简介

Sarsa全称是state-action-reward-state'-action'，目的是学习特定的state下，特定action的价值Q，最终建立和优化一个Q表格，以state为行，action为列，根据与环境交互得到的reward来更新Q表格，更新公式为：

Sarsa在训练中为了更好的探索环境，采用ε-greedy方式来训练，有一定概率随机选择动作输出。

2. Sarsa 实战

使用Sarsa解决悬崖问题，找到绕过悬崖通往终点的路径。

Step1 安装依赖

In[1]

!pip install gym

Step2 导入依赖

In[2]

import gym
import numpy as np
import time

Step3 Agent

Agent是和环境environment交互的主体。
predict()方法：输入观察值observation（或者说状态state），输出动作值
sample()方法：再predict()方法基础上使用ε-greedy增加探索
learn()方法：输入训练数据，完成一轮Q表格的更新

In[3]

# agent.py 
class SarsaAgent(object):
    def __init__(self, obs_n, act_n, learning_rate=0.01, gamma=0.9, e_greed=0.1):
        self.act_n = act_n      # 动作维度，有几个动作可选
        self.lr = learning_rate # 学习率
        self.gamma = gamma      # reward的衰减率
        self.epsilon = e_greed  # 按一定概率随机选动作
        self.Q = np.zeros((obs_n, act_n))

    # 根据输入观察值，采样输出的动作值，带探索
    def sample(self, obs):
        if np.random.uniform(0, 1) < (1.0 - self.epsilon): #根据table的Q值选动作
            action = self.predict(obs)
        else:
            action = np.random.choice(self.act_n) #有一定概率随机探索选取一个动作
        return action

    # 根据输入观察值，预测输出的动作值
    def predict(self, obs):
        Q_list = self.Q[obs, :]
        maxQ = np.max(Q_list)
        action_list = np.where(Q_list == maxQ)[0]  # maxQ可能对应多个action
        action = np.random.choice(action_list)
        return action

    # 学习方法，也就是更新Q-table的方法
    def learn(self, obs, action, reward, next_obs, next_action, done):
        """ on-policy
            obs: 交互前的obs, s_t
            action: 本次交互选择的action, a_t
            reward: 本次动作获得的奖励r
            next_obs: 本次交互后的obs, s_t+1
            next_action: 根据当前Q表格, 针对next_obs会选择的动作, a_t+1
            done: episode是否结束
        """
        predict_Q = self.Q[obs, action]
        if done:
            target_Q = reward # 没有下一个状态了
        else:
            target_Q = reward + self.gamma * self.Q[next_obs, next_action] # Sarsa
        self.Q[obs, action] += self.lr * (target_Q - predict_Q) # 修正q

    # 保存Q表格数据到文件
    def save(self):
        npy_file = './q_table.npy'
        np.save(npy_file, self.Q)
        print(npy_file + ' saved.')
    
    # 从文件中读取Q值到Q表格中
    def restore(self, npy_file='./q_table.npy'):
        self.Q = np.load(npy_file)
        print(npy_file + ' loaded.')

Step4 Training && Test（训练&&测试）

run_episode()：agent在一个episode中训练的过程，使用agent.sample()与环境交互，使用agent.learn()训练Q表格。
test_episode()：agent在一个episode中测试效果，评估目前的agent能在一个episode中拿到多少总reward。

In[4]

def run_episode(env, agent, render=False):
    total_steps = 0 # 记录每个episode走了多少step
    total_reward = 0

    obs = env.reset() # 重置环境, 重新开一局（即开始新的一个episode）
    action = agent.sample(obs) # 根据算法选择一个动作

    while True:
        next_obs, reward, done, _ = env.step(action) # 与环境进行一个交互
        next_action = agent.sample(next_obs) # 根据算法选择一个动作
        # 训练 Sarsa 算法
        agent.learn(obs, action, reward, next_obs, next_action, done)

        action = next_action
        obs = next_obs  # 存储上一个观察值
        total_reward += reward
        total_steps += 1 # 计算step数
        if render:
            env.render() #渲染新的一帧图形
        if done:
            break
    return total_reward, total_steps


def test_episode(env, agent):
    total_reward = 0
    obs = env.reset()
    while True:
        action = agent.predict(obs) # greedy
        next_obs, reward, done, _ = env.step(action)
        total_reward += reward
        obs = next_obs
        # time.sleep(0.5)
        # env.render()
        if done:
            break
    return total_reward

Step5 创建环境和Agent，启动训练

In[5]

# 使用gym创建悬崖环境
env = gym.make("CliffWalking-v0")  # 0 up, 1 right, 2 down, 3 left

# 创建一个agent实例，输入超参数
agent = SarsaAgent(
        obs_n=env.observation_space.n,
        act_n=env.action_space.n,
        learning_rate=0.1,
        gamma=0.9,
        e_greed=0.1)


# 训练500个episode，打印每个episode的分数
for episode in range(500):
    ep_reward, ep_steps = run_episode(env, agent, False)
    print('Episode %s: steps = %s , reward = %.1f' % (episode, ep_steps, ep_reward))

# 全部训练结束，查看算法效果
test_reward = test_episode(env, agent)
print('test reward = %.1f' % (test_reward))

Episode 0: steps = 545 , reward = -1931.0
Episode 1: steps = 519 , reward = -1113.0
Episode 2: steps = 523 , reward = -919.0
Episode 3: steps = 164 , reward = -164.0
Episode 4: steps = 302 , reward = -500.0
Episode 5: steps = 146 , reward = -146.0
Episode 6: steps = 177 , reward = -375.0
Episode 7: steps = 148 , reward = -148.0
Episode 8: steps = 160 , reward = -160.0

1. Q-learning简介

Q-learning也是采用Q表格的方式存储Q值（状态动作价值），决策部分与Sarsa是一样的，采用ε-greedy方式增加探索。
Q-learning跟Sarsa不一样的地方是更新Q表格的方式。
- Sarsa是on-policy的更新方式，先做出动作再更新。
- Q-learning是off-policy的更新方式，更新learn()时无需获取下一步实际做出的动作next_action，并假设下一步动作是取最大Q值的动作。
Q-learning的更新公式为：

2. Q-learning实战

使用Q-learning解决悬崖问题，找到绕过悬崖通往终端的最短路径。