深度学习学习履历——强化学习（rl）

强化学习

强化学习（Reinforcement Learning, RL）是一种机器学习方法，重要用于让智能体（agent）通过与环境的互动，逐步学习如何在不恻隐况下采取最佳办法，以最大化其获得的累积回报。与监督学习和无监督学习不同，强化学习并不依靠于已标注的数据集，而是通过智能体在环境中的探索和试错来学习最优策略。
强化学习的重要特点：

• 基于试错学习：强化学习中的智能体通过与环境的互动，不断实行不同的办法，并根据办法结果（即从环境中获得的回报）来调整未来的决议。这个过程通常被称为“试错”学习。
  
• 累积回报：强化学习的目标是找到一种策略，使得智能体在长时间内可以或许获得最大的累积回报。智能体不但要关注即时的回报，还需要考虑未来的回报，如何权衡当前的办法与未来的回报是强化学习中的一个关键题目。
  
• 反馈信号（奖励）：智能体从环境中吸收到的反馈通常是一个奖励信号，用于指引它的举动。奖励信号可以是正的，也可以是负的，正如一个人可以因做对了事而获得奖励，也可以因犯错而受到惩罚。
  
• 探索与利用的平衡：在强化学习中，智能体需要在探索新的办法（探索）与利用已知信息（利用）之间找到平衡。过多的探索大概导致时间浪费，而过多的利用大概导致智能体陷入局部最优解。
  
• 状态与办法空间：强化学习通常在状态空间（state space）和办法空间（action space）中举行。状态空间表示环境的全部大概状态，办法空间表示智能体在每个状态下可以采取的办法。如何有效地在这些空间中找到最优策略是强化学习的核心挑战之一。
  
• 策略与价值函数：强化学习中的策略（policy）是指智能体在每个状态下选择办法的规则，而价值函数（value function）则评估了在某一状态下采取某一办法所期望获得的累积回报。
  

实际应用

强化学习在机器人控制、游戏AI、自动驾驶、智能交易系统等领域有广泛的应用。比方，AlphaGo利用了强化学习来学习如何下围棋，并成功降服了人类冠军。
强化学习实践案例——贪吃蛇游戏

让我们从零开始，通过一个简朴而经典的游戏——贪吃蛇（Snake Game），来逐步了解强化学习的基本概念和如何利用PyTorch实现它。
第一步：明白强化学习的基本概念

在强化学习中，智能体（agent） 在一个 环境（environment） 中不断地做出决议，这些决议被称为 办法（actions）。环境会根据智能体的办法给予反馈，这个反馈通常是一个 奖励（reward）。智能体的目标是通过选择适当的办法来最大化其获得的累积奖励。
在贪吃蛇游戏中：

• 环境：游戏的棋盘和蛇的状态（位置、方向等）。
  
• 智能体：控制蛇移动的程序。
  
• 办法：上、下、左、右移动。
  
• 奖励：吃到食品时获得正奖励；撞墙或撞到自己时获得负奖励。
  

第二步：环境搭建

首先，我们需要创建一个简朴的贪吃蛇游戏环境。这个环境将包罗蛇的状态（位置、方向等）以及食品的位置。

1. import numpy as np
2. import random
3. import torch
5. class SnakeGame:
6.     def __init__(self, grid_size=10):
7.         self.grid_size = grid_size
8.         self.reset()
10.     def reset(self):
11.         self.snake = [(self.grid_size // 2, self.grid_size // 2)]
12.         self.direction = (0, 1)  # Start by moving right
13.         self.food = self._place_food()
14.         self.done = False
15.         return self._get_observation()
17.     def _place_food(self):
18.         while True:
19.             food = (random.randint(0, self.grid_size - 1), random.randint(0, self.grid_size - 1))
20.             if food not in self.snake:
21.                 return food
23.     def _get_observation(self):
24.         obs = np.zeros((self.grid_size, self.grid_size))
25.         for x, y in self.snake:
26.             obs[x, y] = 1
27.         obs[self.food[0], self.food[1]] = 2
28.         return obs
30.     def step(self, action):
31.         if action == 0:  # Up
32.             self.direction = (-1, 0)
33.         elif action == 1:  # Down
34.             self.direction = (1, 0)
35.         elif action == 2:  # Left
36.             self.direction = (0, -1)
37.         elif action == 3:  # Right
38.             self.direction = (0, 1)
40.         head = (self.snake[0][0] + self.direction[0], self.snake[0][1] + self.direction[1])
41.         if (head in self.snake) or (head[0] < 0 or head[0] >= self.grid_size) or (head[1] < 0 or head[1] >= self.grid_size):
42.             self.done = True
43.             return self._get_observation(), -10, self.done  # Collision: negative reward
45.         self.snake = [head] + self.snake[:-1]
47.         if head == self.food:
48.             self.snake.append(self.snake[-1])  # Grow
49.             self.food = self._place_food()
50.             return self._get_observation(), 10, self.done  # Food eaten: positive reward
52.         return self._get_observation(), 0, self.done  # Neutral step

复制代码

第三步：界说强化学习的智能体

我们将利用一个简朴的神经网络作为我们的智能体，它将输入贪吃蛇游戏的状态，输出每个大概的动作的“价值”（即采取该办法的预期回报）。在强化学习中，我们通常利用 Q-learning 算法来练习这个网络。

1. import torch.nn as nn
2. import torch.optim as optim
4. class DQN(nn.Module):
5.     def __init__(self, grid_size, num_actions):
6.         super(DQN, self).__init__()
7.         self.fc1 = nn.Linear(grid_size * grid_size, 128)  # 第一层全连接层，输入大小为网格大小平方
8.         self.fc2 = nn.Linear(128, 64)  # 第二层全连接层
9.         self.fc3 = nn.Linear(64, num_actions)  # 输出层，输出动作的Q值
11.     def forward(self, x):
12.         batch_size = x.size(0)  # 获取批次大小
13.         x = x.view(batch_size, -1)  # 将输入展平为 (batch_size, grid_size * grid_size)
14.         x = torch.relu(self.fc1(x))  # 经过第一层全连接并ReLU激活
15.         x = torch.relu(self.fc2(x))  # 经过第二层全连接并ReLU激活
16.         return self.fc3(x)  # 输出动作的Q值
19.     # 计算输入张量的展平后的特征数目
20.     def num_flat_features(self, x):
21.         size = x.size()[1:]  # 除去批次维度，计算特征维度的大小
22.         num_features = 1
23.         for s in size:
24.             num_features *= s
25.         return num_features
27. # Initialize DQN
28. grid_size = 10
29. num_actions = 4  # Up, Down, Left, Right
30. dqn = DQN(grid_size, num_actions)
31. optimizer = optim.Adam(dqn.parameters(), lr=0.001)
32. loss_fn = nn.MSELoss()

复制代码

第四步：练习智能体

在这个步骤中，我们将利用贪吃蛇的游戏状态作为输入，通过神经网络推测各个办法的价值，并选择价值最高的办法。然后，我们利用Q-learning来更新神经网络的参数。

1. def train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.9):
2.     for episode in range(episodes):
3.         state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
4.         total_reward = 0
5.         while True:
6.             q_values = dqn(state)  # 预测当前状态的Q值
7.             action = torch.argmax(q_values).item()  # 选择Q值最大的动作
9.             next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
10.             next_state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度
12.             with torch.no_grad():
13.                 max_next_q_values = torch.max(dqn(next_state))  # 计算下一状态的最大Q值
14.                 target = reward + gamma * max_next_q_values * (1 - int(done))  # 计算目标Q值
16.             loss = loss_fn(q_values[0, action], target)  # 计算损失
17.             optimizer.zero_grad()  # 梯度清零
18.             loss.backward()  # 反向传播
19.             optimizer.step()  # 更新网络参数
21.             state = next_state  # 更新当前状态
22.             total_reward += reward
24.             if done:  # 如果游戏结束，退出循环
25.                 break
27.         print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward}")  # 输出当前回合的总奖励
29. # Train the agent
30. game = SnakeGame(grid_size)
31. train(game, dqn, optimizer, loss_fn, episodes=1000)

复制代码

第五步：评估和可视化

练习完智能体后，我们可以让它在游戏中实行跑几局，并观察它的表现。以下代码展示了如何评估智能体并可视化它的表现。

1. import matplotlib.pyplot as plt
3. def evaluate(game, dqn, episodes=10):
4.     for episode in range(episodes):
5.         state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
6.         total_reward = 0
7.         steps = 0
9.         plt.figure()  # 创建新的图像窗口
11.         while True:
12.             q_values = dqn(state)  # 预测当前状态的Q值
13.             action = torch.argmax(q_values).item()  # 选择Q值最大的动作
15.             next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
16.             state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度
17.             total_reward += reward
18.             steps += 1
20.             # Visualization (Optional)
21.             plt.imshow(state.squeeze(0).numpy())  # 去掉批次维度进行显示
22.             plt.axis('off')  # 隐藏坐标轴
23.             plt.pause(0.1)  # 短暂停留以更新视图
25.             if done:
26.                 print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward} - Steps: {steps}")
27.                 break
28.         
29.         plt.close()  # 关闭图像窗口

复制代码

最终代码汇总

1. import numpy as np
2. import random
3. import torch
4. import torch.nn as nn
5. import torch.optim as optim
6. import matplotlib.pyplot as plt
8. # 定义贪吃蛇游戏环境
9. class SnakeGame:
10.     def __init__(self, grid_size=10):
11.         self.grid_size = grid_size
12.         self.reset()
14.     # 重置游戏状态，初始化蛇的位置和食物的位置
15.     def reset(self):
16.         self.snake = [(self.grid_size // 2, self.grid_size // 2)]  # 蛇的初始位置在网格的中央
17.         self.direction = (0, 1)  # 蛇的初始移动方向为向右
18.         self.food = self._place_food()  # 随机放置食物
19.         self.done = False
20.         return self._get_observation()
22.     # 随机生成一个食物位置，确保不与蛇的身体重叠
23.     def _place_food(self):
24.         while True:
25.             food = (random.randint(0, self.grid_size - 1), random.randint(0, self.grid_size - 1))
26.             if food not in self.snake:
27.                 return food
29.     # 获取当前游戏状态，返回一个网格表示的观察值
30.     def _get_observation(self):
31.         obs = np.zeros((self.grid_size, self.grid_size))  # 初始化一个全0的网格
32.         for x, y in self.snake:
33.             obs[x, y] = 1  # 用1表示蛇的身体
34.         obs[self.food[0], self.food[1]] = 2  # 用2表示食物的位置
35.         return obs
37.     # 游戏的主要逻辑：根据动作更新蛇的状态
38.     def step(self, action):
39.         if action == 0:  # 上
40.             self.direction = (-1, 0)
41.         elif action == 1:  # 下
42.             self.direction = (1, 0)
43.         elif action == 2:  # 左
44.             self.direction = (0, -1)
45.         elif action == 3:  # 右
46.             self.direction = (0, 1)
48.         # 更新蛇头的位置
49.         head = (self.snake[0][0] + self.direction[0], self.snake[0][1] + self.direction[1])
50.         
51.         # 如果蛇撞到自己或墙壁，游戏结束
52.         if (head in self.snake) or (head[0] < 0 or head[0] >= self.grid_size) or (head[1] < 0 or head[1] >= self.grid_size):
53.             self.done = True
54.             return self._get_observation(), -10, self.done  # 碰撞：给予负奖励
56.         # 更新蛇的身体
57.         self.snake = [head] + self.snake[:-1]
59.         # 如果蛇吃到食物
60.         if head == self.food:
61.             self.snake.append(self.snake[-1])  # 蛇的身体增长
62.             self.food = self._place_food()  # 重新放置食物
63.             return self._get_observation(), 10, self.done  # 吃到食物：给予正奖励
65.         return self._get_observation(), 0, self.done  # 普通移动：奖励为0
67. # 定义DQN（深度Q网络）模型
68. class DQN(nn.Module):
69.     def __init__(self, grid_size, num_actions):
70.         super(DQN, self).__init__()
71.         self.fc1 = nn.Linear(grid_size * grid_size, 128)  # 第一层全连接层，输入大小为网格大小平方
72.         self.fc2 = nn.Linear(128, 64)  # 第二层全连接层
73.         self.fc3 = nn.Linear(64, num_actions)  # 输出层，输出动作的Q值
75.     def forward(self, x):
76.         batch_size = x.size(0)  # 获取批次大小
77.         x = x.view(batch_size, -1)  # 将输入展平为 (batch_size, grid_size * grid_size)
78.         x = torch.relu(self.fc1(x))  # 经过第一层全连接并ReLU激活
79.         x = torch.relu(self.fc2(x))  # 经过第二层全连接并ReLU激活
80.         return self.fc3(x)  # 输出动作的Q值
83.     # 计算输入张量的展平后的特征数目
84.     def num_flat_features(self, x):
85.         size = x.size()[1:]  # 除去批次维度，计算特征维度的大小
86.         num_features = 1
87.         for s in size:
88.             num_features *= s
89.         return num_features
91. # 初始化DQN
92. grid_size = 10
93. num_actions = 4  # 上、下、左、右四个动作
94. dqn = DQN(grid_size, num_actions)
95. optimizer = optim.Adam(dqn.parameters(), lr=0.00001)  # 使用Adam优化器
96. loss_fn = nn.MSELoss()  # 使用均方误差损失函数
98. # 训练智能体
99. def train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.9):
100.     for episode in range(episodes):
101.         state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
102.         total_reward = 0
103.         while True:
104.             q_values = dqn(state)  # 预测当前状态的Q值
105.             action = torch.argmax(q_values).item()  # 选择Q值最大的动作
107.             next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
108.             next_state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度
110.             with torch.no_grad():
111.                 max_next_q_values = torch.max(dqn(next_state))  # 计算下一状态的最大Q值
112.                 target = reward + gamma * max_next_q_values * (1 - int(done))  # 计算目标Q值
114.             loss = loss_fn(q_values[0, action], target)  # 计算损失
115.             optimizer.zero_grad()  # 梯度清零
116.             loss.backward()  # 反向传播
117.             optimizer.step()  # 更新网络参数
119.             state = next_state  # 更新当前状态
120.             total_reward += reward
122.             if done:  # 如果游戏结束，退出循环
123.                 break
125.         print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward}")  # 输出当前回合的总奖励
127. # 训练智能体
128. game = SnakeGame(grid_size)
129. train(game, dqn, optimizer, loss_fn, episodes=10000)  # 开始训练
132. # Step 5: Evaluate the Agent
133. def evaluate(game, dqn, episodes=10):
134.     for episode in range(episodes):
135.         state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
136.         total_reward = 0
137.         steps = 0
139.         plt.figure()  # 创建新的图像窗口
141.         while True:
142.             q_values = dqn(state)  # 预测当前状态的Q值
143.             action = torch.argmax(q_values).item()  # 选择Q值最大的动作
145.             next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
146.             state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度
147.             total_reward += reward
148.             steps += 1
150.             # Visualization (Optional)
151.             plt.imshow(state.squeeze(0).numpy())  # 去掉批次维度进行显示
152.             plt.axis('off')  # 隐藏坐标轴
153.             plt.pause(0.1)  # 短暂停留以更新视图
155.             if done:
156.                 print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward} - Steps: {steps}")
157.                 break
158.         
159.         plt.close()  # 关闭图像窗口
163. # Evaluate the trained agent
164. evaluate(game, dqn)

复制代码

通过这个贪吃蛇的例子，我们逐步了解了强化学习的概念，并通过利用PyTorch实现了一个简朴的强化学习智能体。这种方法不但实用于贪吃蛇游戏，也可以扩展到更复杂的环境和任务中。
如何进步练习效果（调整参数）

在强化学习过程中，有多个参数可以举行调整，以进步练习效果和智能体的表现。以下是一些关键参数和调整建议：
1. 学习率（Learning Rate）

• 界说：学习率决定了模型在每次参数更新时的步长。太高的学习率大概导致模型不收敛，而太低的学习率大概使练习过程非常缓慢。
  
• 调整建议：通常在0.001到0.00001之间举行调整。可以通过逐步减小学习率（比方利用学习率衰减策略）来进步练习的稳定性。
  

1. optimizer = optim.Adam(dqn.parameters(), lr=0.0005)  # 例如，减小学习率

复制代码

2. 折扣因子（Discount Factor, γ）

• 界说：折扣因子决定了智能体在优化过程中对未来奖励的器重程度。γ 值靠近1时，智能体会更加注重长远的回报；γ 值靠近0时，智能体则更关注短期的回报。
  
• 调整建议：γ 通常设置在0.9到0.99之间。对于较短的游戏或回报立即显现的任务，可以选择较低的 γ 值。
  

1. train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.95)  # 例如，稍微降低 γ

复制代码

3. 探索与利用的平衡（Exploration vs Exploitation）

• 界说：在强化学习中，智能体需要在探索新策略和利用已知策略之间找到平衡。常用的探索策略有 ε-greedy，其中 ε 是智能体随机选择办法的概率。
  
• 调整建议：可以设置一个较高的初始 ε 值（比方0.9），然后逐步减小，淘汰随机探索的次数。也可以引入更多先辈的策略，如 UCB 或 Boltzmann 探索。
  

1. epsilon = 0.9  # 初始探索率
2. decay_rate = 0.995  # 衰减率
4. for episode in range(episodes):
5.     epsilon = max(epsilon * decay_rate, 0.01)  # 确保 epsilon 最小为 0.01
6.     # 其余代码保持不变

复制代码

4. 履历回放（Experience Replay）

• 界说：履历回放存储智能体在环境中经历的状态、办法、奖励和下一状态。练习时从这些存储的履历中随机抽取一个批次举行学习，从而进步练习的效率和稳定性。
  
• 调整建议：增加履历回放的批次巨细或扩展履历回放池的容量，可以帮助智能体更有效地学习。
  

1. from collections import deque
3. replay_memory = deque(maxlen=10000)  # 扩展经验回放池的容量
5. def train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.99, batch_size=64):
6.     for episode in range(episodes):
7.         state = torch.tensor(game.reset(), dtype=torch.float32)
8.         total_reward = 0
9.         while True:
10.             if random.random() < epsilon:
11.                 action = random.randint(0, num_actions - 1)
12.             else:
13.                 q_values = dqn(state)
14.                 action = torch.argmax(q_values).item()
16.             next_state, reward, done = game.step(action)
17.             next_state = torch.tensor(next_state, dtype=torch.float32)
18.             replay_memory.append((state, action, reward, next_state, done))
20.             # 开始经验回放训练
21.             if len(replay_memory) > batch_size:
22.                 minibatch = random.sample(replay_memory, batch_size)
23.                 for s, a, r, ns, d in minibatch:
24.                     q_values = dqn(s)
25.                     with torch.no_grad():
26.                         max_next_q_values = torch.max(dqn(ns))
27.                         target = r + gamma * max_next_q_values * (1 - int(d))
28.                     loss = loss_fn(q_values[a], target)
29.                     optimizer.zero_grad()
30.                     loss.backward()
31.                     optimizer.step()
33.             state = next_state
34.             total_reward += reward
36.             if done:
37.                 break
38.         print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward}")

复制代码

5. 练习轮数（Number of Episodes）

• 界说：练习轮数决定了智能体在环境中练习的总次数。
  
• 调整建议：增加练习轮数通常会进步模型的表现，特别是在练习的早期阶段。如果练习过程过长，大概会导致过拟合题目，因此要留意在增加练习轮数的同时监控模型性能。
  

1. train(game, dqn, optimizer, loss_fn, episodes=5000)  # 增加训练轮数

复制代码

6. 奖励函数（Reward Function）

• 界说：奖励函数是强化学习中非常关键的一部分，它直接影响到智能体的举动。不同的奖励设计会引导智能体做出不同的决议。
  
• 调整建议：可以通过修改奖励函数来更加正确地引导智能体的举动。比方，给予更多的奖励当蛇靠近食品，大概淘汰每一步办法的惩罚，从而激励智能体更积极地去靠近食品。
  

1. def step(self, action):
2.     if action == 0:  # Up
3.         self.direction = (-1, 0)
4.     elif action == 1:  # Down
5.         self.direction = (1, 0)
6.     elif action == 2:  # Left
7.         self.direction = (0, -1)
8.     elif action == 3:  # Right
9.         self.direction = (0, 1)
11.     head = (self.snake[0][0] + self.direction[0], self.snake[0][1] + self.direction[1])
12.     if (head in self.snake) or (head[0] < 0 or head[0] >= self.grid_size) or (head[1] < 0 or head[1] >= self.grid_size):
13.         self.done = True
14.         return self._get_observation(), -10, self.done  # Collision: negative reward
16.     self.snake = [head] + self.snake[:-1]
18.     if head == self.food:
19.         self.snake.append(self.snake[-1])  # Grow
20.         self.food = self._place_food()
21.         return self._get_observation(), 10, self.done  # Food eaten: positive reward
23.     # 距离食物近一步，给出微小奖励
24.     dist = abs(head[0] - self.food[0]) + abs(head[1] - self.food[1])
25.     reward = 1.0 / (dist + 1)  # 距离越近，奖励越大
27.     return self._get_observation(), reward, self.done  # Neutral step

复制代码

通过这些参数的调整，你可以进步练习的效果和智能体的表现。每个参数的调整对练习结果都有大概产生明显的影响，因此建议在调整时逐步举行，并仔细观察练习的变化环境。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。