devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

（4-3）Q-learning与贝尔曼方程：强化学习中的Q-learning_贝尔方程与q-learning

作者：盐析白兔 | 2024-05-30 15:41:35

赞

踩

贝尔方程与q-learning

4.3  强化学习中的Q-learning

Q-learning是强化学习中的一个重要算法，用于解决基于马尔可夫决策过程（MDP）的任务。Q-learning是一个强大的算法，可用于解决马尔可夫决策过程中的最优策略问题。通过学习Q值函数，并使用贝尔曼方程进行更新，Q-learning能够在不断的训练中逐渐学到最优策略，以实现任务的最大累积奖励。

4.3.1  ε-贪婪策略与探索的关系

ε-贪婪策略（epsilon-greedy policy）是强化学习中一种常用的策略，它与探索的概念密切相关。

1.ε-贪婪策略

ε-贪婪策略是一种在强化学习中用于选择动作的策略，在ε-贪婪策略中，代理有一个参数 ε（epsilon），该参数是一个小于1的正数。在每个时间步骤，代理以ε的概率随机选择一个动作，以便进行探索。以1-ε的概率选择具有最高估计值（通常是 Q 值）的动作，以便进行开发（exploitation）。

2. 探索与开发

在强化学习中，代理需要在探索和开发之间取得平衡。探索是指代理尝试未知动作或状态，以便了解环境并找到更好的策略。没有探索，代理可能会陷入局部最优解。

开发是指代理根据当前已知的最佳策略来执行动作，以最大化累积奖励。没有开发，代理可能无法利用已知的信息来获得奖励。

3.ε-贪婪策略的作用

ε-贪婪策略在探索和开发之间进行权衡。通过调整 ε 的值，可以控制探索的程度。

  1. 当ε较小（接近零）时，代理更倾向于选择具有最高估计值的动作，以进行开发，从而减少探索。
  2. 当ε较大（接近一）时，代理更倾向于随机选择动作，以进行探索，从而减少开发。

ε-贪婪策略的关键在于在学习过程中逐渐减小 ε，以便代理在训练初期更多地进行探索，随着时间的推移逐渐增加开发的机会，直到最终收敛到一个较小的 ε。这样，代理可以在学习过程中逐渐优化其策略，同时探索环境以发现更好的策略。

总之，ε-贪婪策略允许强化学习代理在探索和开发之间找到平衡，这对于有效地学习和优化策略至关重要。通过调整 ε 的值，可以控制代理的探索程度，以适应不同的强化学习任务和学习阶段。

在深度学习中，ε-贪婪策略与探索通常用于训练强化学习智能体，如深度Q网络（DQN）。在下面的示例中，我们将使用Python和PyTorch来演示如何在一个简单的Q-learning任务中使用ε-贪婪策略与探索。

实例4-7：在深度学习模型中使用Q-learning和ε-贪婪策略（源码路径：daima\4\tan.py）

编写实例文件tan.py，功能是实现了一个简单的 Q-learning任务，展示了构建 Q 网络、实施 Q-learning 算法、定义环境和策略，并最终进行训练和测试的过程。本实例可以作为学习强化学习和 Q-learning 的入门示例，实例文件tan.py的具体实现代码如下所示。

  1. import numpy as np
  2. import torch
  3. import torch.nn as nn
  4. import torch.optim as optim
  5.  
  6. # 创建一个简单的Q网络
  7. class QNetwork(nn.Module):
  8.     def __init__(self, state_size, action_size):
  9.         super(QNetwork, self).__init__()
  10.         self.fc1 = nn.Linear(state_size, 24)
  11.         self.fc2 = nn.Linear(24, 24)
  12.         self.fc3 = nn.Linear(24, action_size)
  13.  
  14.     def forward(self, state):
  15.         x = torch.relu(self.fc1(state))
  16.         x = torch.relu(self.fc2(x))
  17.         return self.fc3(x)
  18.  
  19. # 定义ε-贪婪策略
  20. def epsilon_greedy_policy(q_values, epsilon):
  21.     if np.random.rand() < epsilon:
  22.         return np.random.randint(len(q_values))  # 随机选择动作
  23.     else:
  24.         return np.argmax(q_values)  # 选择Q值最大的动作
  25.  
  26. # 定义Q-learning算法
  27. def q_learning(env, q_network, num_episodes, learning_rate, gamma, epsilon):
  28.     optimizer = optim.Adam(q_network.parameters(), lr=learning_rate)
  29.     criterion = nn.MSELoss()
  30.  
  31.     for episode in range(num_episodes):
  32.         state = env.reset()
  33.         done = False
  34.  
  35.         while not done:
  36.             # 将整数状态转换为 one-hot 编码的向量
  37.             state_one_hot = np.zeros(env.num_states)
  38.             state_one_hot[state] = 1
  39.             state_tensor = torch.FloatTensor([state_one_hot])
  40.  
  41.             # 根据当前状态选择动作
  42.             q_values = q_network(state_tensor)
  43.             action = epsilon_greedy_policy(q_values.detach().numpy()[0], epsilon)
  44.  
  45.             # 执行动作并观察奖励和下一个状态
  46.             next_state, reward, done, _ = env.step(action)
  47.  
  48.             # 将整数下一个状态转换为 one-hot 编码的向量
  49.             next_state_one_hot = np.zeros(env.num_states)
  50.             next_state_one_hot[next_state] = 1
  51.             next_state_tensor = torch.FloatTensor([next_state_one_hot])
  52.  
  53.             # 计算目标Q值
  54.             target_q_values = q_values.clone()
  55.             if not done:
  56.                 target_q_values[0][action] = reward + gamma * torch.max(q_network(next_state_tensor))
  57.             else:
  58.                 target_q_values[0][action] = reward
  59.  
  60.             # 计算损失并更新Q网络
  61.             loss = criterion(q_values, target_q_values)
  62.             optimizer.zero_grad()
  63.             loss.backward()
  64.             optimizer.step()
  65.  
  66.             state = next_state
  67.  
  68.     return q_network
  69.  
  70. # 示例环境：一个简单的Q-learning任务
  71. class SimpleEnvironment:
  72.     def __init__(self):
  73.         self.num_states = 4
  74.         self.num_actions = 2
  75.         self.transitions = np.array([[1, 0], [0, 1], [2, 3], [3, 2]])  # 状态转移矩阵
  76.  
  77.     def reset(self):
  78.         return 0
  79.  
  80.     def step(self, action):
  81.         next_state = self.transitions[action, 0]
  82.         reward = self.transitions[action, 1]
  83.         done = (next_state == 3)
  84.         return next_state, reward, done, {}
  85.  
  86. # 创建环境和Q网络
  87. env = SimpleEnvironment()
  88. q_network = QNetwork(env.num_states, env.num_actions)
  89.  
  90. # 训练Q网络
  91. trained_q_network = q_learning(env, q_network, num_episodes=100, learning_rate=0.1, gamma=0.9, epsilon=0.1)
  92.  
  93. # 测试学习后的Q网络
  94. state = env.reset()
  95. done = False
  96. while not done:
  97.     # 将整个状态转换为 one-hot 编码的向量
  98.     state_one_hot = np.zeros(env.num_states)
  99.     state_one_hot[state] = 1
  100.     state_tensor = torch.FloatTensor([state_one_hot])
  101.  
  102.     q_values = trained_q_network(state_tensor)
  103.     action = epsilon_greedy_policy(q_values.detach().numpy()[0], epsilon=0.0)  # 使用贪婪策略进行测试
  104.     next_state, reward, done, _ = env.step(action)
  105.     print(f"State: {state}, Action: {action}, Reward: {reward}, Next State: {next_state}")
  106.     state = next_state

上述代码演示了使用 Q-learning 算法来训练一个神经网络（Q 网络）来解决一个简单的强化学习任务的过程，对上述代码的具体说明如下：

（1）类QNetwork：这个类定义了一个简单的神经网络，用于估算状态动作对的 Q 值。

  1. __init__ 方法初始化神经网络的结构，包括输入层、两个隐藏层和输出层。
  2. forward 方法实现了前向传播，将状态作为输入，并返回对每个动作的 Q 值估计。

（2）函数epsilon_greedy_policy：这个函数定义了一个 ε-贪婪策略，用于在训练中和测试中选择动作。

  1. 在训练中，有 ε 的概率选择随机动作，以便探索环境。
  2. 在测试中，以 1-ε 的概率选择具有最大 Q 值的动作，以便执行最佳策略。

（3）函数q_learning：这个函数实现了 Q-learning 算法，用于训练 Q 网络。在每个回合中，代理根据 Q 值选择动作，观察奖励和下一个状态，然后更新 Q 值以改进策略。优化器使用梯度下降来最小化 Q 值的均方误差损失。函数q_learning接受以下参数：

  1. env：强化学习环境对象，定义了任务和状态转移。
  2. q_network：Q 网络的实例，将在训练中更新。
  3. num_episodes：训练的总回合数。
  4. learning_rate：学习率，用于优化 Q 网络的参数。
  5. gamma：折扣因子，影响未来奖励的权重。
  6. epsilon：ε-贪婪策略中的 ε 值，用于探索和开发的权衡。

（4）类SimpleEnvironment：这个类定义了一个简单的环境，代理在其中执行 Q-learning 任务。

    1. 环境包含了一些状态和动作，以及状态转移和奖励的规则。
    2. reset 方法用于重置环境并返回初始状态。
    3. step 方法用于执行代理选择的动作，并返回下一个状态、奖励和结束标志。

（5）主程序部分：创建了一个 SimpleEnvironment 环境和一个 QNetwork Q 网络。

  1. 使用 q_learning 函数训练 Q 网络，其中包括了 Q-learning 的主要循环。
  2. 在训练结束后，使用训练后的 Q 网络进行测试，输出代理在环境中的行为和奖励。

执行后会输出 Q-learning 的训练过程和测试结果：

  1. State: 0, Action: 1, Reward: 0, Next State: 1
  2.  
  3. State: 1, Action: 0, Reward: 1, Next State: 0
  4.  
  5. State: 0, Action: 0, Reward: 0, Next State: 1
  6.  
  7. State: 1, Action: 1, Reward: 1, Next State: 0
  8.  
  9. ##省略部分输出...
  10.  
  11. State: 3, Action: 1, Reward: 0, Next State: 2
  12.  
  13. State: 2, Action: 0, Reward: 0, Next State: 3
  14.  
  15. State: 3, Action: 0, Reward: 0, Next State: 2
  16.  
  17. State: 2, Action: 1, Reward: 0, Next State: 3

这些输出是在测试学习后的 Q 网络时生成的，它显示了在 Q-learning 过程中代理在环境中移动的状态、选择的动作、获得的奖励以及下一个状态。在训练过程中，还可以选择记录其他信息，如每个回合的累积奖励，以评估学习进展，这将有助于了解代理是否成功地学会了任务。

最终，Q-learning 的目标是通过训练 Q 网络来获得一个优化的策略，使代理在环境中获得最大的累积奖励。上述输出中的信息有助于了解代理如何在环境中行动以及它是否学会了优化策略。

4.3.2  Q-learning中探索策略的变化与优化

Q-learning 中的探索策略的变化和优化通常通过调整 ε-贪婪策略中的 ε 值来实现。ε 值决定了在选择动作时进行探索的概率。在下面列出了一些常用的探索策略的变化和优化方式。

1. 指数递减ε策略

一种常见的方法是使用指数递减函数来减小ε，例如，可以将 ε 设置为初始值，然后在每个回合后乘以一个小于1的因子。这样，ε将以指数方式减小，更快地减小到接近零。这种方法在训练初期进行更强烈的探索，并在训练后期更多地进行开发。请看下面的例子，演示了在深度学习中使用指数递减ε策略进行优化的用法，假设正在训练一个简单的神经网络来拟合一个曲线。

实例4-8：使用指数递减ε策略优化神经网络（源码路径：daima\4\zhi.py）

编写实例文件zhi.py的具体实现代码如下所示。

  1. import numpy as np
  2. import torch
  3. import torch.nn as nn
  4. import torch.optim as optim
  5.  
  6. # 创建一个简单的深度学习模型
  7. class SimpleModel(nn.Module):
  8.     def __init__(self):
  9.         super(SimpleModel, self).__init__()
  10.         self.fc1 = nn.Linear(1, 1)  # 单输入、单输出的线性层
  11.  
  12.     def forward(self, x):
  13.         return self.fc1(x)
  14.  
  15. # 定义指数递减的ε策略
  16. def exponential_decay_epsilon(initial_epsilon, episode, decay_rate):
  17.     return initial_epsilon * np.exp(-decay_rate * episode)
  18.  
  19. # 示例数据：一条简单的曲线
  20. X = torch.FloatTensor(np.linspace(0, 1, 100)).unsqueeze(1)
  21. y = 2 * X + 1 + 0.2 * torch.randn(X.size())
  22.  
  23. # 创建模型和优化器
  24. model = SimpleModel()
  25. optimizer = optim.SGD(model.parameters(), lr=0.01)
  26.  
  27. # Q-learning 参数
  28. initial_epsilon = 1.0  # 初始ε
  29. decay_rate = 0.01     # ε的衰减率
  30. num_episodes = 100     # 总回合数
  31.  
  32. # 定义损失函数
  33. criterion = nn.MSELoss()
  34.  
  35. # 初始化损失
  36. loss = torch.tensor(0.0, requires_grad=True)
  37.  
  38. for episode in range(num_episodes):
  39.     epsilon = exponential_decay_epsilon(initial_epsilon, episode, decay_rate)
  40.  
  41.     # 根据ε-贪婪策略选择动作
  42.     if np.random.rand() < epsilon:
  43.         # 随机选择一个动作（在深度学习优化中通常是随机初始化模型参数的变化）
  44.         model.fc1.weight.data += torch.randn_like(model.fc1.weight.data) * 0.1
  45.     else:
  46.         # 根据当前模型参数执行一个动作（在深度学习优化中通常是使用梯度下降来更新参数）
  47.         model.zero_grad()
  48.         y_pred = model(X)
  49.         loss = criterion(y_pred, y)
  50.         loss.backward()
  51.         optimizer.step()
  52.  
  53.     if episode % 10 == 0:
  54.         print(f"Episode {episode}, Epsilon: {epsilon}, Loss: {loss.item()}")
  55.  
  56. # 打印学习后的模型参数
  57. print("Learned Model Parameters:")
  58. for name, param in model.named_parameters():
  59.     if param.requires_grad:
  60.         print(name, param.data)

这上述代码中，使用了一个简单的线性模型来拟合一条曲线。指数递减的ε策略被用于选择是随机初始化模型参数的变化还是根据当前模型参数执行梯度下降来更新参数。这个示例的目的是演示如何在深度学习中使用探索策略（ε-贪婪策略）来改变优化行为。执行后会输出：

  1. Episode 0, Epsilon: 1.0, Loss: 0.0
  2. Episode 10, Epsilon: 0.9048374180359595, Loss: 0.0
  3. Episode 20, Epsilon: 0.8187307530779818, Loss: 0.0
  4. Episode 30, Epsilon: 0.7408182206817179, Loss: 0.0
  5. Episode 40, Epsilon: 0.6703200460356393, Loss: 6.356284141540527
  6. Episode 50, Epsilon: 0.6065306597126334, Loss: 5.90389347076416
  7. Episode 60, Epsilon: 0.5488116360940265, Loss: 4.267116069793701
  8. Episode 70, Epsilon: 0.49658530379140947, Loss: 2.5693044662475586
  9. Episode 80, Epsilon: 0.44932896411722156, Loss: 2.223409414291382
  10. Episode 90, Epsilon: 0.4065696597405991, Loss: 1.5685646533966064
  11. Learned Model Parameters:
  12. fc1.weight tensor([[0.0810]])
  13. fc1.bias tensor([0.8807])

2. 线性递减ε策略

另一种方式是在训练过程中逐渐减小 ε 值，从而逐渐减少探索。在开始时，ε 可以设置为较大的值以促使代理更多地进行探索。随着训练的进行，ε 逐渐减小，代理更多地依赖于已知的最佳策略进行开发。这种方法的好处是可以平衡探索和开发，逐渐将探索的重点转向开发。当使用线性递减ε策略时，每个回合都会将ε的值线性减小，直到它达到某个阈值，例如下面是一个使用线性递减ε策略的例子。

实例4-9：使用线性递减ε策略优化神经网络（源码路径：daima\4\xian.py）

实例文件xian.py的具体实现代码如下所示。

  1. import numpy as np
  2. import torch
  3. import torch.nn as nn
  4. import torch.optim as optim
  5.  
  6. # 创建一个简单的深度学习模型
  7. class SimpleModel(nn.Module):
  8.     def __init__(self):
  9.         super(SimpleModel, self).__init__()
  10.         self.fc1 = nn.Linear(1, 1)  # 单输入、单输出的线性层
  11.  
  12.     def forward(self, x):
  13.         return self.fc1(x)
  14.  
  15. # 定义线性递减的ε策略
  16. def linear_decay_epsilon(initial_epsilon, episode, total_episodes):
  17.     epsilon = initial_epsilon - (initial_epsilon / total_episodes) * episode
  18.     return max(epsilon, 0.0)  # 确保ε不小于0
  19.  
  20. # 示例数据：一条简单的曲线
  21. X = torch.FloatTensor(np.linspace(0, 1, 100)).unsqueeze(1)
  22. y = 2 * X + 1 + 0.2 * torch.randn(X.size())
  23.  
  24. # 创建模型和优化器
  25. model = SimpleModel()
  26. optimizer = optim.SGD(model.parameters(), lr=0.01)
  27.  
  28. # Q-learning 参数
  29. initial_epsilon = 1.0  # 初始ε
  30. num_episodes = 100     # 总回合数
  31.  
  32. # 定义损失函数
  33. criterion = nn.MSELoss()
  34.  
  35. # 初始化损失
  36. loss = torch.tensor(0.0, requires_grad=True)
  37.  
  38. for episode in range(num_episodes):
  39.     epsilon = linear_decay_epsilon(initial_epsilon, episode, num_episodes)
  40.  
  41.     # 根据ε-贪婪策略选择动作
  42.     if np.random.rand() < epsilon:
  43.         # 随机选择一个动作（在深度学习优化中通常是随机初始化模型参数的变化）
  44.         model.fc1.weight.data += torch.randn_like(model.fc1.weight.data) * 0.1
  45.     else:
  46.         # 根据当前模型参数执行一个动作（在深度学习优化中通常是使用梯度下降来更新参数）
  47.         model.zero_grad()
  48.         y_pred = model(X)
  49.         loss = criterion(y_pred, y)
  50.         loss.backward()
  51.         optimizer.step()
  52.  
  53.     if episode % 10 == 0:
  54.         print(f"Episode {episode}, Epsilon: {epsilon}, Loss: {loss.item()}")
  55.  
  56. # 打印学习后的模型参数
  57. print("Learned Model Parameters:")
  58. for name, param in model.named_parameters():
  59.     if param.requires_grad:
  60.         print(name, param.data)

在这个示例中，我定义了一个线性递减的ε策略 linear_decay_epsilon，并将它用于每个回合。ε的值会从初始值开始线性减小，直到达到0为止。这个策略允许模型在训练的早期更多地进行探索，在训练的后期更多地进行开发。你可以根据需要调整初始ε和总回合数来控制ε的线性减小速度。执行后会输出：

  1. Episode 0, Epsilon: 1.0, Loss: 0.0
  2. Episode 10, Epsilon: 0.9, Loss: 0.0
  3. Episode 20, Epsilon: 0.8, Loss: 0.8105946183204651
  4. Episode 30, Epsilon: 0.7, Loss: 0.8105946183204651
  5. Episode 40, Epsilon: 0.6, Loss: 0.39483004808425903
  6. Episode 50, Epsilon: 0.5, Loss: 0.49674656987190247
  7. Episode 60, Epsilon: 0.4, Loss: 0.36505362391471863
  8. Episode 70, Epsilon: 0.29999999999999993, Loss: 0.27561822533607483
  9. Episode 80, Epsilon: 0.19999999999999996, Loss: 0.28438231348991394
  10. Episode 90, Epsilon: 0.09999999999999998, Loss: 0.14754557609558105
  11. Learned Model Parameters:
  12. fc1.weight tensor([[1.5640]])
  13. fc1.bias tensor([1.0217])

3. 自适应ε策略

有些方法可以根据代理的学习进展自适应地调整 ε 值。如果代理的性能在一段时间内没有改善，可以增加 ε 值以增加探索的机会。如果代理的性能在一段时间内有所改善，可以减小 ε 值以便更多地进行开发。

4. UCB（Upper Confidence Bound）策略

UCB 策略是一种基于不确定性的探索方法，它使用置信上界来估计每个动作的不确定性，然后选择具有最高置信上界的动作进行探索。这种方法允许代理在探索和开发之间进行平衡，同时考虑到不确定性。

5. 贝叶斯方法

一些方法使用贝叶斯推断来估计不确定性，然后根据不确定性来选择探索的动作。这些方法通常需要更复杂的数学模型，但可以提供更精确的不确定性估计。例如下面是一个使用Q-learning的例子，使用贝叶斯方法估计状态转移概率的不确定性。

实例4-10：使用线性递减ε策略优化神经网络（源码路径：daima\4\beiye.py）

实例文件beiye.py的具体实现代码如下所示。

  1. import numpy as np
  2. import pymc3 as pm
  3.  
  4. # 创建一个简单的 Q-learning 环境
  5. num_states = 2
  6. num_actions = 2
  7. transitions = np.array([[0.9, 0.1], [0.2, 0.8]])
  8.  
  9. # 使用 PyMC3 定义状态转移概率的贝叶斯分布
  10. with pm.Model() as model:
  11.     # 定义先验分布
  12.     transition_probs = pm.Beta("transition_probs", alpha=2, beta=2, shape=(num_states, num_actions))
  13.  
  14.     # 定义 Q-learning 算法
  15.     Q = np.zeros((num_states, num_actions))
  16.     gamma = 0.9
  17.     alpha = 0.1
  18.  
  19.     num_episodes = 1000
  20.  
  21.     for episode in range(num_episodes):
  22.         state = 0
  23.         done = False
  24.  
  25.         while not done:
  26.             action = pm.Categorical("action", p=transition_probs[state], shape=1)
  27.             next_state = pm.Categorical("next_state", p=transitions[state], shape=1)
  28.             
  29.             reward = transitions[state][action]
  30.             target = reward + gamma * np.max(Q[next_state])
  31.             Q[state][action] = Q[state][action] + alpha * (target - Q[state][action])
  32.             
  33.             state = next_state
  34.  
  35. # 运行 MCMC 推断
  36. with model:
  37.     trace = pm.sample(1000, tune=1000)
  38.  
  39. # 打印后验分布的统计信息
  40. pm.summary(trace)

在上述代码中，使用 PyMC3 来定义状态转移概率的贝叶斯分布，并在 Q-learning 算法中使用它。通过运行 MCMC 推断，可以得到状态转移概率的后验分布，从而获得不确定性估计。执行后会输出：

在现实应用中，选择适当的探索策略取决于具体的问题和环境。通常，需要在训练过程中进行试验和调整，以找到最有效的探索策略。探索策略的目标是平衡探索和开发，以最大化长期累积奖励。

4.3.3  探索策略对Q-learning性能的影响分析

在本节的内容中，将通过一个简单的例子来演示探索策略对 Q-learning 性能的影响分析。在本实例中，将使用一个简单的 Q-learning 环境，并比较不同的探索策略对性能的影响。

实例4-11：比较Q-learning中贪婪策略和 ε-贪婪策略的性能（源码路径：daima\4\bi.py）

实例文件bi.py的具体实现代码如下所示。

  1. import numpy as np
  2.  
  3. class SimpleEnvironment:
  4.     def __init__(self):
  5.         self.num_states = 4
  6.         self.num_actions = 2
  7.         self.transitions = np.array([[1, 0], [0, 1], [2, 3], [3, 2]])  # 状态转移矩阵
  8.  
  9.     def reset(self):
  10.         return 0
  11.  
  12.     def step(self, action):
  13.         next_state = self.transitions[action, 0]
  14.         reward = self.transitions[action, 1]
  15.         done = (next_state == 3)
  16.         return next_state, reward, done
  17.  
  18. # 贪婪策略
  19. def greedy_policy(q_values, epsilon):
  20.     return np.argmax(q_values)
  21.  
  22. # ε-贪婪策略
  23. def epsilon_greedy_policy(q_values, epsilon):
  24.     if np.random.rand() < epsilon:
  25.         return np.random.randint(len(q_values))  # 随机选择动作
  26.     else:
  27.         return np.argmax(q_values)  # 选择Q值最大的动作
  28.  
  29. # Q-learning算法
  30. def q_learning(env, num_episodes, learning_rate, gamma, epsilon, policy):
  31.     Q = np.zeros((env.num_states, env.num_actions))
  32.  
  33.     for episode in range(num_episodes):
  34.         state = env.reset()
  35.         done = False
  36.  
  37.         while not done:
  38.             action = policy(Q[state], epsilon)
  39.             next_state, reward, done = env.step(action)
  40.  
  41.             # 更新Q值
  42.             target = reward + gamma * np.max(Q[next_state])
  43.             Q[state][action] = Q[state][action] + learning_rate * (target - Q[state][action])
  44.  
  45.             state = next_state
  46.  
  47.     return Q
  48.  
  49. # 创建环境
  50. env = SimpleEnvironment()
  51. num_episodes = 1000
  52. learning_rate = 0.1
  53. gamma = 0.9
  54.  
  55. # 比较贪婪策略和ε-贪婪策略
  56. q_greedy = q_learning(env, num_episodes, learning_rate, gamma, epsilon=0.0, policy=greedy_policy)
  57. q_epsilon_greedy = q_learning(env, num_episodes, learning_rate, gamma, epsilon=0.1, policy=epsilon_greedy_policy)
  58.  
  59. # 输出最终的Q值
  60. print("Greedy Q-values:")
  61. print(q_greedy)
  62. print("\nε-Greedy Q-values:")
  63. print(q_epsilon_greedy)

在上述代码中，首先创建了一个简单的 Q-learning 环境，然后使用 Q-learning 算法测试不同的探索策略，比较贪婪策略和ε-贪婪策略的性能。执行后会输出：

  1. Greedy Q-values:
  2. [[0.    0.   ]
  3.  [0.    0.   ]
  4.  [0.    1.   ]
  5.  [0.    0.   ]]
  6.  
  7. ε-Greedy Q-values:
  8. [[0.         0.        ]
  9.  [0.         0.        ]
  10.  [0.         0.9025    ]
  11.  [0.         0.        ]]

在上面的输出中，Greedy Q-values部分将显示使用贪婪策略训练后的 Q 值函数，ε-Greedy Q-values部分将显示使用 ε-贪婪策略训练后的 Q 值函数。这些值表示在每个状态下，不同动作的 Q 值估计。贪婪策略的 Q 值通常会更加保守，而ε-贪婪策略的 Q 值可能会更加探索性。大家可以根据需要进一步调整参数、增加迭代次数或者尝试更复杂的环境来观察不同策略的效果。

4.3.4  使用Q-learning寻找某股票的买卖点

在本节的内容中，将通过一个简单的例子来演示使用Q-learning算法寻找某股票的买卖点的用法。假设在文件stock_data.csv中保存了某股票的历史交易数据，内容格式如下所示：

实例4-12：使用Q-learning寻找某股票的买卖点（源码路径：daima\4\mg.py）

实例文件mg.py的具体实现代码如下所示。

  1. import pandas as pd
  2. import numpy as np
  3.  
  4. # 从CSV文件加载股票数据
  5. data = pd.read_csv('stock_data.csv')
  6.  
  7. # 定义Q-learning算法的参数
  8. learning_rate = 0.1
  9. discount_factor = 0.9
  10. exploration_prob = 0.2
  11. num_episodes = 100
  12.  
  13. # 初始化Q-table，每个状态对应一个动作值
  14. num_states = len(data)
  15. num_actions = 2  # 0表示卖出，1表示持有
  16. Q = np.zeros((num_states, num_actions))
  17.  
  18. # 定义一个函数来选择动作，使用ε-greedy策略
  19. def choose_action(state):
  20.     if np.random.rand() < exploration_prob:
  21.         return np.random.choice(num_actions)
  22.     else:
  23.         return np.argmax(Q[state, :])
  24.  
  25. # 定义一个函数来更新Q值
  26. def update_Q(state, action, reward, next_state):
  27.     best_next_action = np.argmax(Q[next_state, :])
  28.     Q[state, action] += learning_rate * (reward + discount_factor * Q[next_state, best_next_action] - Q[state, action])
  29.  
  30. # 训练Q-learning代理
  31. for episode in range(num_episodes):
  32.     state = 0  # 初始状态
  33.     total_reward = 0
  34.  
  35.     while state < num_states - 1:
  36.         action = choose_action(state)
  37.  
  38.         # 模拟执行动作，计算奖励
  39.         if action == 0:  # 卖出
  40.             reward = -data.iloc[state]['close']
  41.         else:  # 持有
  42.             reward = 0
  43.  
  44.         next_state = state + 1
  45.         update_Q(state, action, reward, next_state)
  46.         total_reward += reward
  47.         state = next_state
  48.  
  49.     print(f"Episode {episode + 1}: Total Reward = {total_reward}")
  50.  
  51. # 根据训练后的Q-table找出买入和卖出点
  52. buy_points = []
  53. sell_points = []
  54.  
  55. for state in range(num_states):
  56.     action = choose_action(state)
  57.     if action == 0:  # 卖出
  58.         sell_points.append(data.iloc[state]['close'])
  59.     else:  # 持有
  60.         buy_points.append(data.iloc[state]['close'])
  61.  
  62. print("买入点：", buy_points)
  63. print("卖出点：", sell_points)

上述代码的实现流程如下：

  1. 定义Q-learning算法的参数。
  2. 初始化Q-table，用于存储Q值。
  3. 定义选择动作的函数，根据ε-greedy策略选择动作。
  4. 定义更新Q值的函数，使用Q-learning更新规则。
  5. 进行多轮的训练，每轮中代理从初始状态开始，依据Q值选择动作，并根据奖励和下一个状态的最大Q值更新Q值。

执行后会输出：

  1. Episode 1: Total Reward = -6789.550000000008
  2. Episode 2: Total Reward = -1250.8799999999999
  3. Episode 3: Total Reward = -668.9400000000002
  4. ###省略部分输出
  5. Episode 97: Total Reward = -609.9899999999999
  6. Episode 98: Total Reward = -776.4999999999999
  7. Episode 99: Total Reward = -600.7399999999999
  8. Episode 100: Total Reward = -702.2499999999998
  9. 买入点： [9.73, 9.83, 10.04, 10.1, 10.24, 10.72, 10.79, 10.63, 10.86, 11.05, 11.06, 11.18, 11.27, 10.9, 10.49, 10.29, 10.81, 10.81, 11.2, 10.92, 11.3, 11.12, 11.48, 11.71, 11.24, 11.69, 11.61, 11.85, 12.02, 12.12, 11.86, 11.91, 11.94, 11.87, 11.73, 11.57, 11.68, 11.98, 11.73, 11.55, 11.63, 12.0, 11.95, 12.1, 11.81, 11.63, 12.15, 12.02, 12.2, 12.48, 12.33, 12.55, 12.41, 12.54, 12.52, 12.65, 13.13, 13.19, 14.65, 15.87, 14.99, 15.14, 14.8, 15.21, 15.38, 14.58, 14.3, 14.14, 15.0, 15.22, 15.5, 14.6, 14.51, 13.95, 14.24, 13.36, 13.3, 13.44, 13.14, 13.36, 13.67, 14.39, 14.39, 14.03, 14.06, 15.11, 14.9, 15.49, 15.98, 15.45, 15.04, 15.97, 15.09, 17.7, 15.98, 16.86, 15.89, 16.42, 16.17, 15.5, 15.87, 16.9, 15.84, 16.74, 18.6, 18.97, 20.08, 19.2, 16.85, 16.46, 16.89, 17.98, 16.78, 15.25, 15.0, 14.07, 13.82, 13.27, 12.2, 11.51, 12.17, 11.8, 10.98, 11.57, 11.06, 11.36, 11.66, 11.53, 11.31, 10.79, 10.76, 11.72, 11.19, 11.65, 11.88, 11.01, 10.01, 10.84, 10.18, 9.69, 9.37, 9.7, 8.82, 8.02, 7.29, 7.27, 7.14, 7.19, 7.0, 7.11, 7.04, 7.04, 6.95, 6.8, 6.85, 6.72, 6.7, 6.67, 6.8, 6.75, 6.73, 6.78, 6.8, 6.74, 6.54, 6.48, 6.41, 6.54, 6.53, 6.58, 6.47, 6.48, 6.55, 6.59, 6.86, 6.97, 6.95, 6.98, 7.07, 7.15, 7.18, 7.14, 7.01, 6.89, 6.86, 6.72, 6.86, 6.84, 6.89, 6.98, 7.06, 7.26, 7.4, 7.22, 7.27, 7.21, 7.06, 7.1, 7.09, 7.21, 7.09, 7.06, 6.99, 7.13, 7.12, 7.08, 6.77, 7.18, 7.05, 6.78, 6.83, 6.94, 6.94, 6.91, 6.97, 7.01, 6.82, 6.7, 6.59, 6.38, 6.34, 6.5, 6.55, 6.63, 6.77, 6.67, 6.99, 7.06, 7.09, 7.13, 7.61, 7.5, 7.5, 7.39, 7.53, 7.51, 7.38, 7.32, 7.22, 7.3, 7.24, 7.45, 7.51, 7.49, 7.56, 7.62, 7.6, 7.65, 7.76, 7.8, 7.66, 7.73, 7.76, 7.57, 7.23, 7.12, 7.05, 7.43, 7.39, 7.48, 7.38, 7.4, 7.37, 7.47, 7.47, 7.41, 7.33, 7.87, 7.92, 7.96, 8.13, 8.11, 8.26, 8.42, 8.44, 8.52, 8.49, 8.48, 8.31, 8.4, 8.32, 8.15, 8.35, 8.38, 8.37, 8.51, 8.36, 8.3, 8.32, 8.4, 8.31, 8.43, 8.47, 8.37, 8.28, 8.28, 8.13, 8.16, 7.99, 8.38, 8.3, 8.2, 8.33, 8.14, 8.11, 8.24, 8.21, 8.22, 8.19, 8.17, 8.19, 8.19, 7.87, 7.93, 7.78, 8.0, 8.52, 8.73, 8.98, 9.12, 9.15, 9.16, 9.31, 9.28, 9.41, 9.22, 9.65, 9.7, 10.0, 9.98, 10.03, 9.89, 9.99, 9.94, 9.97, 10.12, 10.23, 10.06, 10.18, 10.05, 9.79, 9.61, 10.2, 10.51, 10.63, 10.63, 10.54, 10.53, 10.75, 10.71, 10.49, 10.46, 10.48, 10.44, 10.86, 10.79, 11.01, 10.8, 10.66, 10.77, 10.67, 10.61, 10.75, 10.86, 10.83, 10.75, 10.58, 10.44, 10.45, 10.94, 11.49, 12.05, 12.29, 12.57, 12.62, 12.55, 12.54, 12.29, 12.33, 12.44, 12.65, 12.7, 12.78, 12.84, 12.83, 12.72, 12.5, 12.51, 12.47, 12.38, 12.43, 12.28, 12.39, 12.02, 11.9, 12.04, 12.23, 12.16, 12.23, 12.4, 12.21, 12.32, 12.22, 12.21, 12.21, 12.26, 12.09, 12.13, 11.96, 11.89, 11.94, 12.04, 11.96, 11.96, 12.0, 12.01, 11.93, 12.22, 12.37, 12.33, 12.41, 12.43, 12.4, 12.06, 12.26, 12.34, 12.27, 12.33, 12.04, 11.91, 12.18, 11.86, 11.82, 11.8, 11.8, 11.99, 11.77, 11.88, 11.93, 11.88, 11.81, 11.98, 12.01, 11.88, 11.8, 11.96, 11.97, 11.83, 12.12, 12.09, 12.35, 12.55, 12.44, 12.49, 12.54, 12.38, 12.47, 12.74, 12.19, 12.18, 12.07, 12.08, 11.9, 11.66, 11.78, 11.96, 12.27, 12.11, 11.99, 11.83, 12.02, 12.04, 12.06, 12.15, 12.24, 12.16, 12.34, 12.36, 12.18, 12.09, 12.38, 12.26, 12.3, 11.93, 11.78, 12.16, 12.25, 12.56, 12.87, 12.97, 12.74, 12.96, 12.97, 12.88, 13.05, 13.07, 13.52, 12.61, 12.63, 12.36, 12.05, 11.82, 12.39, 12.29, 12.01, 12.2, 12.04, 12.12, 12.07, 12.4, 12.46, 12.7, 13.09, 11.9, 12.0, 11.85, 11.85, 11.93, 12.13, 12.44, 12.25, 12.17, 12.44, 12.24, 12.28, 12.19, 12.02, 12.19, 11.95, 12.0, 11.95, 12.05, 12.17, 12.68, 12.49, 12.46, 12.61, 12.89, 12.71, 13.09, 12.93, 13.05, 13.18, 13.97, 14.1, 13.95, 13.84, 13.82, 13.57, 13.61, 13.84, 14.01, 14.17, 14.27, 14.02, 13.97, 13.92, 14.06, 13.86, 13.89, 13.92, 13.87, 13.93, 13.75, 13.97, 13.98, 14.07, 14.29, 14.81, 15.32, 15.74, 15.6, 15.88, 16.1, 15.6, 15.96, 15.82, 16.32, 16.68, 16.29, 16.27, 16.01, 15.79, 15.5, 15.64, 15.65, 16.23, 16.39, 16.27, 17.21, 17.8, 17.05, 17.37, 17.6, 16.71, 16.66, 17.32, 17.59, 17.85, 17.47, 17.75, 17.51, 15.93, 16.4, 15.43]
  10. 卖出点： [10.37, 11.07, 11.2, 10.88, 12.16, 14.71, 15.19, 16.77, 16.58, 17.45, 11.34, 11.2, 6.8, 6.87, 6.86, 7.13, 7.53, 7.54, 7.48, 7.26, 7.32, 7.29, 7.56, 7.5, 7.92, 8.11, 8.45, 8.2, 8.13, 8.23, 9.99, 10.85, 12.53, 12.18, 11.97, 11.95, 12.5, 12.04, 11.94, 12.42, 12.21, 12.21, 12.05, 12.5, 12.14, 12.94, 14.27, 13.99, 14.02, 14.45, 14.33, 15.64, 15.67, 17.66, 17.28, 15.73]

本《Q-learning与贝尔曼方程》专题已完结：

（4-1）Q-learning与贝尔曼方程：Q-learning算法原理-CSDN博客

（4-2）Q-learning与贝尔曼方程：贝尔曼方程在Q-learning中的应用-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/647597
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号