强化学习：使用神经网络解决Cart Pole平衡问题

前言

学习神经网络全连接过程，用来解决Cart Pole平衡问题。

全连接层

全连接层（也称为线性层或密集层）就是通过公式 𝑦=𝑤⋅𝑥+𝑏 来将输入 𝑥 变换为输出 𝑦。

计算过程，如图下：

python代码：

import torch
import torch.nn as nn

if __name__ == '__main__':
    # 定义输入向量
    x = torch.tensor([1.0, 2.0, 3.0])
    # 定义全连接层
    fc = nn.Linear(3, 2)  # 输入大小为3，输出大小为2
    # 手动设置权重和偏置
    with torch.no_grad():
        fc.weight = nn.Parameter(torch.tensor([[0.2, 0.4, 0.6], [0.1, 0.3, 0.5]]))
        fc.bias = nn.Parameter(torch.tensor([0.5, 0.2]))
    # 计算输出
    y = fc(x)
    # 打印结果
    print("Output:", y)

ReLU激活函数

ReLU激活函数的作用是引入非线性，使得神经网络能够更好地学习复杂的模式和特征。计算 ReLU 激活函数非常简单，只需要比较输入值和 0，速度快，计算效率高。

ReLU([2,−3,0.5,−1])=[max(0,2),max(0,−3),max(0,0.5),max(0,−1)]=[2,0,0.5,0]ReLU([2,−3,0.5,−1])=[max(0,2),max(0,−3),max(0,0.5),max(0,−1)]=[2,0,0.5,0]ReLU([2,−3,0.5,−1])=[max(0,2),max(0,−3),max(0,0.5),max(0,−1)]=[2,0,0.5,0]

线性回归

线性回归是一种简单且常用的回归分析方法，用于建立因变量（目标变量）与一个或多个自变量（特征变量）之间的线性关系。

假设有如下数据,满足线性关系：

y	x
10	1
20	2
30	3
40	4

我们随机生成一个公式y=7xy = 7xy=7x，如何通过上面数据去找到y=10xy = 10xy=10x公式呢?

损失函数，计算均方误差

可以通过斜率(𝑤)+1一步步计算，可以看到损失最小为0，就是我们要找的公式。

公式	均方误差	值
y=7xy = 7xy=7x	1/4∗[(10−7∗1)2+(20−7∗2)2+(30−7∗3)2+(40−7∗4)2]1/4*[(10-7*1)^2+(20 -7*2)^2+(30 -7*3)^2+(40 -7*4)^2]1/4∗[(10−7∗1)2+(20−7∗2)2+(30−7∗3)2+(40−7∗4)2]	67.5
y=6xy = 6xy=6x	1/4∗[(10−6∗1)2+(20−6∗2)2+(30−6∗3)2+(40−6∗4)2]1/4*[(10-6*1)^2+(20 -6*2)^2+(30 -6*3)^2+(40 -6*4)^2]1/4∗[(10−6∗1)2+(20−6∗2)2+(30−6∗3)2+(40−6∗4)2]	120
y=8xy = 8xy=8x	1/4∗[(10−8∗1)2+(20−8∗2)2+(30−8∗3)2+(40−8∗4)2]1/4*[(10-8*1)^2+(20 -8*2)^2+(30 -8*3)^2+(40 -8*4)^2]1/4∗[(10−8∗1)2+(20−8∗2)2+(30−8∗3)2+(40−8∗4)2]	30
y=9xy = 9xy=9x	1/4∗[(10−9∗1)2+(20−9∗2)2+(30−9∗3)2+(40−9∗4)2]1/4*[(10-9*1)^2+(20 -9*2)^2+(30 -9*3)^2+(40 -9*4)^2]1/4∗[(10−9∗1)2+(20−9∗2)2+(30−9∗3)2+(40−9∗4)2]	7.5
y=10xy = 10xy=10x	1/4∗[(10−10∗1)2+(20−10∗2)2+(30−10∗3)2+(40−10∗4)2]1/4*[(10-10*1)^2+(20 -10*2)^2+(30 -10*3)^2+(40 -10*4)^2]1/4∗[(10−10∗1)2+(20−10∗2)2+(30−10∗3)2+(40−10∗4)2]	0
y=11xy = 11xy=11x	1/4∗[(10−11∗1)2+(20−11∗2)2+(30−11∗3)2+(40−11∗4)2]1/4*[(10-11*1)^2+(20 -11*2)^2+(30 -11*3)^2+(40 -11*4)^2]1/4∗[(10−11∗1)2+(20−11∗2)2+(30−11∗3)2+(40−11∗4)2]	30
y=12xy = 12xy=12x	1/4∗[(10−12∗1)2+(20−12∗2)2+(30−12∗3)2+(40−12∗4)2]1/4*[(10-12*1)^2+(20 -12*2)^2+(30 -12*3)^2+(40 -12*4)^2]1/4∗[(10−12∗1)2+(20−12∗2)2+(30−12∗3)2+(40−12∗4)2]	120

根据斜率和均方误差绘制如下图：

python计算过程

下面是这个计算过程的代码实现：

import torch
import torch.nn as nn
import torch.optim as optim

# 生成数据
x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
y = torch.tensor([[10.0], [20.0], [30.0], [40.0]])

# 定义模型
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        # 全连接 设置 bias=False 不使用偏置项 b
        self.linear = nn.Linear(1, 1, bias=False)

    def forward(self, x):
        return self.linear(x)

# 创建模型实例和损失函数
model = LinearRegressionModel()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

with torch.no_grad():
    model.linear.weight.fill_(7.0)

# 训练模型
num_epochs = 50
for epoch in range(num_epochs):

    # 前向传播
    outputs = model(x)
    loss = criterion(outputs, y)

    params = list(model.named_parameters())
    print(f"epoch:{epoch} 权重(𝑤):{params[0][1].data},损失值(loss):{loss.item():.4f}")

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 打印最终的参数
params = list(model.named_parameters())
print(f"最终的权重(𝑤):{params[0][1].data}")

现在，我们可以看到通过一次梯度更新，参数 𝑤 从 7 更新到了 7.45。

epoch:0 权重(𝑤):tensor([[7.]]),损失值(loss):67.5000
epoch:1 权重(𝑤):tensor([[7.4500]]),损失值(loss):48.7688
epoch:2 权重(𝑤):tensor([[7.8325]]),损失值(loss):35.2354
epoch:3 权重(𝑤):tensor([[8.1576]]),损失值(loss):25.4576
epoch:4 权重(𝑤):tensor([[8.4340]]),损失值(loss):18.3931
epoch:5 权重(𝑤):tensor([[8.6689]]),损失值(loss):13.2890
epoch:6 权重(𝑤):tensor([[8.8686]]),损失值(loss):9.6013
epoch:7 权重(𝑤):tensor([[9.0383]]),损失值(loss):6.9369
epoch:8 权重(𝑤):tensor([[9.1825]]),损失值(loss):5.0119
epoch:9 权重(𝑤):tensor([[9.3051]]),损失值(loss):3.6211
epoch:10 权重(𝑤):tensor([[9.4094]]),损失值(loss):2.6163
epoch:11 权重(𝑤):tensor([[9.4980]]),损失值(loss):1.8903
epoch:12 权重(𝑤):tensor([[9.5733]]),损失值(loss):1.3657

Cart Pole游戏实现

主要流程：

graph LR 
遍历 --> 选择动作
选择动作 --> 游戏执行动作
游戏执行动作 --> 计算奖励
计算奖励 --> 计算损失 
计算损失 --> 模型更新w和b
模型更新w和b --> 遍历

代码：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import gymnasium as gym
import random
import matplotlib.pyplot as plt

class QNetwork(nn.Module):
    def __init__(self, state_num, action_num):
        super(QNetwork, self).__init__()
        self.fc1 = nn.Linear(state_num, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_num)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

if __name__ == '__main__':

    # 检查是否有GPU可用
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    # 创建游戏环境
    env = gym.make("CartPole-v1")
    state_num = env.observation_space.shape[0]
    action_num = env.action_space.n

    # 创建模型
    module = QNetwork(state_num, action_num)
    # 损失函数(平方均差)
    criterion = nn.MSELoss()
    # 创建优化器(梯度下降)
    optimizer = optim.SGD(module.parameters(), lr=0.01)

    # 参数
    episodes = 5000
    gamma = 0.9  # 折扣率
    alpha = 0.1  # 学习率
    epsilon = 1.0  # 探索率
    epsilon_decay = 0.995  # 衰减率
    epsilon_min = 0.01  # 最小探索率
    avg_array = []

    for episode in range(episodes):
        # 重置环境
        state, _ = env.reset()
        # 转成张量为了更好计算
        state = torch.tensor(state, dtype=torch.float32)
        terminated = False  # 任务完成
        truncated = False   # 任务终止
        total_reward = 0
        loss_array = []
        while not (terminated or truncated):
            # 小于探索值选择随机动作
            if random.random() < epsilon:
                action = env.action_space.sample()
            else:
                # 不参与梯度计算
                with torch.no_grad():
                    # 选择状态下最大的动作
                    action = module(state).to(device).argmax().item()
            # 环境运行动作
            next_state, reward, terminated, truncated, _ = env.step(action)
            next_state = torch.tensor(next_state, dtype=torch.float32)
            # 结束不计算下一个状态奖励
            with torch.no_grad():
                if terminated or terminated:
                    target = reward
                else:
                    target = reward + gamma * module(next_state).to(device).max().item()
            # 计算当前动作奖励
            current = module(state).to(device)[action]
            current_update = current + alpha * (target - current)
            # 比较损失
            loss = criterion(current, current_update.clone().detach())

            state = next_state
            total_reward += reward
            loss_array.append(loss.item())

            # 反向传播和优化
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        # 更新 epsilon
        if epsilon > epsilon_min:
            epsilon *= epsilon_decay
        loss_avg = np.mean(loss_array)
        avg_array.append(loss_avg)
        print(f"episode:{episode} reward:{total_reward} epsilon:{epsilon:.4f} loss:{loss_avg:.6f}")

    # 绘制损失函数图表
    plt.plot(avg_array, label='Loss')
    plt.xlabel('Training Steps')
    plt.ylabel('Loss')
    plt.title('Training Loss')
    plt.legend()
    plt.show()

那么，我们该如何学习大模型？

作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

一、大模型全套的学习路线

学习大型人工智能模型，如GPT-3、BERT或任何其他先进的神经网络模型，需要系统的方法和持续的努力。既然要系统的学习大模型，那么学习路线是必不可少的，下面的这份路线能帮助你快速梳理知识，形成自己的体系。

L1级别:AI大模型时代的华丽登场

L2级别：AI大模型API应用开发工程

L3级别：大模型应用架构进阶实践

L4级别：大模型微调与私有化部署

一般掌握到第四个级别，市场上大多数岗位都是可以胜任，但要还不是天花板，天花板级别要求更加严格，对于算法和实战是非常苛刻的。建议普通人掌握到L4级别即可。

以上的AI大模型学习路线，不知道为什么发出来就有点糊，高清版可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

二、640套AI大模型报告合集

这套包含640份报告的合集，涵盖了AI大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。

三、大模型经典PDF籍

随着人工智能技术的飞速发展，AI大模型已经成为了当今科技领域的一大热点。这些大型预训练模型，如GPT-3、BERT、XLNet等，以其强大的语言理解和生成能力，正在改变我们对人工智能的认识。 那以下这些PDF籍就是非常不错的学习资源。

四、AI大模型商业化落地方案

作为普通人，入局大模型时代需要持续学习和实践，不断提高自己的技能和认知水平，同时也需要有责任感和伦理意识，为人工智能的健康发展贡献力量。