什么事CartPole游戏
CartPole（也称为倒立摆问题）是一个经典的控制理论和强化学习的基础问题，通常用于测试和验证控制算法的性能。具体来说，它是一个简单的物理模拟问题，其目标是通过在一个平衡杆（倒立摆）上安装在小车（或称为平衡车）上的水平移动，使杆子保持竖直直立的状态。
有两个动作（action）：
左移（0）
右移（1）
四个状态（state）： 1. 小车在轨道上的位置 2. 杆子与竖直方向的夹角 3. 小车速度 4. 角度变化率
神经网络设计
1、强化学习的训练网络cartpole_train.py
import gym
import pygame
import time
import random
import torch
from torch.distributions import Categorical
from torch import nn, optim
import torch.nn.functional as F
def compute_policy_loss(n, log_p):
r = list()
#构造奖励r列表
for i in range(n, 0 ,-1):
r.append(i *1.0)
r = torch.tensor(r)
r = (r - r.mean()) / r.std() #进行标准化处理
loss = 0
#计算损失函数
for pi, ri in zip(log_p, r):
loss += -pi * ri
return loss
class CartPolePolicy(nn.Module):
def __init__(self):
super(CartPolePolicy, self).__init__()
self.fc1 = nn.Linear(in_features = 4, out_features = 128)
self.fc2 = nn.Linear(128, 2) #输出为神经元个数为2表示，向左和向向右
self.drop = nn.Dropout(p=0.6)
def forward(self, x):
x = self.fc1(x)
x = self.drop(x)
x = F.relu(x)
x = self.fc2(x)
#使用softmax决策最终的行动，是向左还是右
return F.softmax(x, dim=1)
if __name__ == '__main__':
env = gym.make("CartPole-v1") #启动环境
env.reset(seed= 543)
torch.manual_seed(543)
policy = CartPolePolicy() #定义模型
optimizer = optim.Adam(policy.parameters(), lr = 0.01) #优化器
#我们一共最多训练1000个回合
#每个回合最多行动10000次
#当某一回合的游戏步数超过5000时，就认为完成训练
max_episod = 1000 #最大游戏回合数
max_action = 10000 #每回合最大行动数
max_steps = 5000 #完成训练的步数
for episod in range(1, max_episod + 1):
# 对于每一轮循环，都要重新启动一次游戏环境
state, _ = env.reset()
step = 0
log_p = list()
for step in range(1, max_action + 1):
state = torch.from_numpy(state).float().unsqueeze(0)
probs = policy(state) #计算神经网络给出的行动概率
# 基于网络给出的概率分布，随机选择行动
m = Categorical(probs)
# 这里并不是直接使用概率较大的行动，而是通过概率分布生成action, 这样可以进一步探索低概率行动
action = m.sample()
state, _, done, _, _ = env.step(action.item())
if done:
break #表示跳出该for循环
log_p.append(m.log_prob(action)) #保存每次行动对应的概率分布
if step > max_steps: #当step大于最大步数时
print(f"Done! last episode {episod} Run steps {step}")
break #跳出循序，结束训练
#每一回合游戏，都会做一次梯度下降算法
optimizer.zero_grad()
loss = compute_policy_loss(step, log_p)
loss.backward()
optimizer.step()
if episod % 10 ==0:
print(f"Episode {episod} Run step {step}")
#保存模型
torch.save(policy.state_dict(), f"cartpole_policy.pth")
2、验证：cartpole_eval.py
import gym
import pygame
import torch.nn as nn
import torch.nn.functional as F
import time
import torch
class CartPolePolicy(nn.Module):
def __init__(self):
super(CartPolePolicy, self).__init__()
self.fc1 = nn.Linear(4, 128)
self.fc2 = nn.Linear(128, 2)
self.drop = nn.Dropout(p=0.6)
def forward(self, x):
x = self.fc1(x)
x = self.drop(x)
x = F.relu(x)
x = self.fc2(x)
return F.softmax(x, dim=1)
if __name__ == '__main__':
pygame.init() #初始化pygame
#使用gym, 创建一个artPole游戏的运行环境，这个环境是提供给人类玩家使用的
env = gym.make('CartPole-v1', render_mode = "human")
state, _ =env.reset()
#使用env.reset重置环境后，会得到CartPole游戏中关键参数state
cart_position = state[0] #小车位置
cart_speed = state[1] #小车速度
pole_angle = state[2] #杆的角度
pole_speed = state[3] #杆的尖端速度
#加载网络
policy = CartPolePolicy()
policy.load_state_dict(torch.load("cartpole_policy.pth"))
policy.eval()
start_time =time.time()
max_action =1000 #设置游戏最大执行次数
#最多执行1000次方向键，游戏就可以通关结束
step = 0
fail = False
for step in range(1, max_action + 1):
#首先使用time.sleep,使游戏暂停0.3s,用于人的反应，觉得自己反应慢可以设置更长时间
# time.sleep(0.3)
#小车的控制方式，通过神经网络，来决定小车的运动方向
#将环境参数state转为张量
state = torch.from_numpy(state).float().unsqueeze(0)
#输入至网络模型,计算行动概率probs
probs = policy(state)
#选取行动概率最大的行动
action =torch.argmax(probs, dim = 1).item()
state, _, done, _, _ = env.step(action) #done为True,表示杆倒了
if done:
fail = True
break
print(f"step = {step} action = {action} angle = {state[2]:.2f} position = {state[0]:.2f}")
end_time = time.time()
game_time = end_time - start_time
if fail:
print(f"Game over ,you play {game_time:.2f} seconds, {step} steps.")
else:
print(f"Congratulations! you play {game_time:.2f} seconds, {step} steps.")
env.close()
视频讲解：