深度学习学习经验——强化学习（rl）

最新推荐文章于 2024-08-27 10:38:36 发布
最新推荐文章于 2024-08-27 10:38:36 发布
阅读量720 收藏 20
点赞数 9
分类专栏： 深度学习学习经验 文章标签： 深度学习 学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41065669/article/details/141536711
版权

强化学习

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

强化学习的主要特点：

  1. 基于试错学习：强化学习中的智能体通过与环境的互动，不断尝试不同的行动，并根据行动结果（即从环境中获得的回报）来调整未来的决策。这个过程通常被称为“试错”学习。

  2. 累积回报：强化学习的目标是找到一种策略，使得智能体在长时间内能够获得最大的累积回报。智能体不仅要关注即时的回报，还需要考虑未来的回报，如何权衡当前的行动与未来的回报是强化学习中的一个关键问题。

  3. 反馈信号（奖励）：智能体从环境中接收到的反馈通常是一个奖励信号，用于指引它的行为。奖励信号可以是正的，也可以是负的，正如一个人可以因做对了事而获得奖励，也可以因犯错而受到惩罚。

  4. 探索与利用的平衡：在强化学习中，智能体需要在探索新的行动（探索）与利用已知信息（利用）之间找到平衡。过多的探索可能导致时间浪费，而过多的利用可能导致智能体陷入局部最优解。

  5. 状态与行动空间：强化学习通常在状态空间（state space）和行动空间（action space）中进行。状态空间表示环境的所有可能状态，行动空间表示智能体在每个状态下可以采取的行动。如何有效地在这些空间中找到最优策略是强化学习的核心挑战之一。

  6. 策略与价值函数：强化学习中的策略（policy）是指智能体在每个状态下选择行动的规则，而价值函数（value function）则评估了在某一状态下采取某一行动所期望获得的累积回报。

实际应用

强化学习在机器人控制、游戏AI、自动驾驶、智能交易系统等领域有广泛的应用。例如，AlphaGo使用了强化学习来学习如何下围棋，并成功战胜了人类冠军。

强化学习实践案例——贪吃蛇游戏

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

第一步：理解强化学习的基本概念

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

在贪吃蛇游戏中：

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

第二步：环境搭建

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

import numpy as np
import random
import torch

class SnakeGame:
    def __init__(self, grid_size=10):
        self.grid_size = grid_size
        self.reset()

    def reset(self):
        self.snake = [(self.grid_size // 2, self.grid_size // 2)]
        self.direction = (0, 1)  # Start by moving right
        self.food = self._place_food()
        self.done = False
        return self._get_observation()

    def _place_food(self):
        while True:
            food = (random.randint(0, self.grid_size - 1), random.randint(0, self.grid_size - 1))
            if food not in self.snake:
                return food

    def _get_observation(self):
        obs = np.zeros((self.grid_size, self.grid_size))
        for x, y in self.snake:
            obs[x, y] = 1
        obs[self.food[0], self.food[1]] = 2
        return obs

    def step(self, action):
        if action == 0:  # Up
            self.direction = (-1, 0)
        elif action == 1:  # Down
            self.direction = (1, 0)
        elif action == 2:  # Left
            self.direction = (0, -1)
        elif action == 3:  # Right
            self.direction = (0, 1)

        head = (self.snake[0][0] + self.direction[0], self.snake[0][1] + self.direction[1])
        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):
            self.done = True
            return self._get_observation(), -10, self.done  # Collision: negative reward

        self.snake = [head] + self.snake[:-1]

        if head == self.food:
            self.snake.append(self.snake[-1])  # Grow
            self.food = self._place_food()
            return self._get_observation(), 10, self.done  # Food eaten: positive reward

        return self._get_observation(), 0, self.done  # Neutral step

第三步：定义强化学习的智能体

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

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

class DQN(nn.Module):
    def __init__(self, grid_size, num_actions):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(grid_size * grid_size, 128)  # 第一层全连接层，输入大小为网格大小平方
        self.fc2 = nn.Linear(128, 64)  # 第二层全连接层
        self.fc3 = nn.Linear(64, num_actions)  # 输出层，输出动作的Q值

    def forward(self, x):
        batch_size = x.size(0)  # 获取批次大小
        x = x.view(batch_size, -1)  # 将输入展平为 (batch_size, grid_size * grid_size) 
        x = torch.relu(self.fc1(x))  # 经过第一层全连接并ReLU激活
        x = torch.relu(self.fc2(x))  # 经过第二层全连接并ReLU激活
        return self.fc3(x)  # 输出动作的Q值


    # 计算输入张量的展平后的特征数目
    def num_flat_features(self, x):
        size = x.size()[1:]  # 除去批次维度，计算特征维度的大小
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

# Initialize DQN
grid_size = 10
num_actions = 4  # Up, Down, Left, Right
dqn = DQN(grid_size, num_actions)
optimizer = optim.Adam(dqn.parameters(), lr=0.001)
loss_fn = nn.MSELoss()

第四步：训练智能体

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

def train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.9):
    for episode in range(episodes):
        state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
        total_reward = 0
        while True:
            q_values = dqn(state)  # 预测当前状态的Q值
            action = torch.argmax(q_values).item()  # 选择Q值最大的动作

            next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
            next_state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度

            with torch.no_grad():
                max_next_q_values = torch.max(dqn(next_state))  # 计算下一状态的最大Q值
                target = reward + gamma * max_next_q_values * (1 - int(done))  # 计算目标Q值

            loss = loss_fn(q_values[0, action], target)  # 计算损失
            optimizer.zero_grad()  # 梯度清零
            loss.backward()  # 反向传播
            optimizer.step()  # 更新网络参数

            state = next_state  # 更新当前状态
            total_reward += reward

            if done:  # 如果游戏结束，退出循环
                break

        print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward}")  # 输出当前回合的总奖励

# Train the agent
game = SnakeGame(grid_size)
train(game, dqn, optimizer, loss_fn, episodes=1000)

第五步：评估和可视化

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

import matplotlib.pyplot as plt

def evaluate(game, dqn, episodes=10):
    for episode in range(episodes):
        state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
        total_reward = 0
        steps = 0

        plt.figure()  # 创建新的图像窗口

        while True:
            q_values = dqn(state)  # 预测当前状态的Q值
            action = torch.argmax(q_values).item()  # 选择Q值最大的动作

            next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
            state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度
            total_reward += reward
            steps += 1

            # Visualization (Optional)
            plt.imshow(state.squeeze(0).numpy())  # 去掉批次维度进行显示
            plt.axis('off')  # 隐藏坐标轴
            plt.pause(0.1)  # 短暂停留以更新视图

            if done:
                print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward} - Steps: {steps}")
                break
        
        plt.close()  # 关闭图像窗口

最终代码汇总

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

# 定义贪吃蛇游戏环境
class SnakeGame:
    def __init__(self, grid_size=10):
        self.grid_size = grid_size
        self.reset()

    # 重置游戏状态，初始化蛇的位置和食物的位置
    def reset(self):
        self.snake = [(self.grid_size // 2, self.grid_size // 2)]  # 蛇的初始位置在网格的中央
        self.direction = (0, 1)  # 蛇的初始移动方向为向右
        self.food = self._place_food()  # 随机放置食物
        self.done = False
        return self._get_observation()

    # 随机生成一个食物位置，确保不与蛇的身体重叠
    def _place_food(self):
        while True:
            food = (random.randint(0, self.grid_size - 1), random.randint(0, self.grid_size - 1))
            if food not in self.snake:
                return food

    # 获取当前游戏状态，返回一个网格表示的观察值
    def _get_observation(self):
        obs = np.zeros((self.grid_size, self.grid_size))  # 初始化一个全0的网格
        for x, y in self.snake:
            obs[x, y] = 1  # 用1表示蛇的身体
        obs[self.food[0], self.food[1]] = 2  # 用2表示食物的位置
        return obs

    # 游戏的主要逻辑：根据动作更新蛇的状态
    def step(self, action):
        if action == 0:  # 上
            self.direction = (-1, 0)
        elif action == 1:  # 下
            self.direction = (1, 0)
        elif action == 2:  # 左
            self.direction = (0, -1)
        elif action == 3:  # 右
            self.direction = (0, 1)

        # 更新蛇头的位置
        head = (self.snake[0][0] + self.direction[0], self.snake[0][1] + self.direction[1])
        
        # 如果蛇撞到自己或墙壁，游戏结束
        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):
            self.done = True
            return self._get_observation(), -10, self.done  # 碰撞：给予负奖励

        # 更新蛇的身体
        self.snake = [head] + self.snake[:-1]

        # 如果蛇吃到食物
        if head == self.food:
            self.snake.append(self.snake[-1])  # 蛇的身体增长
            self.food = self._place_food()  # 重新放置食物
            return self._get_observation(), 10, self.done  # 吃到食物：给予正奖励

        return self._get_observation(), 0, self.done  # 普通移动：奖励为0

# 定义DQN（深度Q网络）模型
class DQN(nn.Module):
    def __init__(self, grid_size, num_actions):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(grid_size * grid_size, 128)  # 第一层全连接层，输入大小为网格大小平方
        self.fc2 = nn.Linear(128, 64)  # 第二层全连接层
        self.fc3 = nn.Linear(64, num_actions)  # 输出层，输出动作的Q值

    def forward(self, x):
        batch_size = x.size(0)  # 获取批次大小
        x = x.view(batch_size, -1)  # 将输入展平为 (batch_size, grid_size * grid_size) 
        x = torch.relu(self.fc1(x))  # 经过第一层全连接并ReLU激活
        x = torch.relu(self.fc2(x))  # 经过第二层全连接并ReLU激活
        return self.fc3(x)  # 输出动作的Q值


    # 计算输入张量的展平后的特征数目
    def num_flat_features(self, x):
        size = x.size()[1:]  # 除去批次维度，计算特征维度的大小
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

# 初始化DQN
grid_size = 10
num_actions = 4  # 上、下、左、右四个动作
dqn = DQN(grid_size, num_actions)
optimizer = optim.Adam(dqn.parameters(), lr=0.00001)  # 使用Adam优化器
loss_fn = nn.MSELoss()  # 使用均方误差损失函数

# 训练智能体
def train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.9):
    for episode in range(episodes):
        state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
        total_reward = 0
        while True:
            q_values = dqn(state)  # 预测当前状态的Q值
            action = torch.argmax(q_values).item()  # 选择Q值最大的动作

            next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
            next_state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度

            with torch.no_grad():
                max_next_q_values = torch.max(dqn(next_state))  # 计算下一状态的最大Q值
                target = reward + gamma * max_next_q_values * (1 - int(done))  # 计算目标Q值

            loss = loss_fn(q_values[0, action], target)  # 计算损失
            optimizer.zero_grad()  # 梯度清零
            loss.backward()  # 反向传播
            optimizer.step()  # 更新网络参数

            state = next_state  # 更新当前状态
            total_reward += reward

            if done:  # 如果游戏结束，退出循环
                break

        print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward}")  # 输出当前回合的总奖励

# 训练智能体
game = SnakeGame(grid_size)
train(game, dqn, optimizer, loss_fn, episodes=10000)  # 开始训练


# Step 5: Evaluate the Agent
def evaluate(game, dqn, episodes=10):
    for episode in range(episodes):
        state = torch.tensor(game.reset(), dtype=torch.float32).unsqueeze(0)  # 添加批次维度
        total_reward = 0
        steps = 0

        plt.figure()  # 创建新的图像窗口

        while True:
            q_values = dqn(state)  # 预测当前状态的Q值
            action = torch.argmax(q_values).item()  # 选择Q值最大的动作

            next_state, reward, done = game.step(action)  # 执行动作并获得下一状态和奖励
            state = torch.tensor(next_state, dtype=torch.float32).unsqueeze(0)  # 将下一状态转换为张量并添加批次维度
            total_reward += reward
            steps += 1

            # Visualization (Optional)
            plt.imshow(state.squeeze(0).numpy())  # 去掉批次维度进行显示
            plt.axis('off')  # 隐藏坐标轴
            plt.pause(0.1)  # 短暂停留以更新视图

            if done:
                print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward} - Steps: {steps}")
                break
        
        plt.close()  # 关闭图像窗口



# Evaluate the trained agent
evaluate(game, dqn)

通过这个贪吃蛇的例子，我们逐步了解了强化学习的概念，并通过使用PyTorch实现了一个简单的强化学习智能体。这种方法不仅适用于贪吃蛇游戏，也可以扩展到更复杂的环境和任务中。

如何提高训练效果（调整参数）

在强化学习过程中，有多个参数可以进行调整，以提高训练效果和智能体的表现。以下是一些关键参数和调整建议：

1. 学习率（Learning Rate）

  • 定义：学习率决定了模型在每次参数更新时的步长。太高的学习率可能导致模型不收敛，而太低的学习率可能使训练过程非常缓慢。
  • 调整建议：通常在0.001到0.00001之间进行调整。可以通过逐步减小学习率（例如使用学习率衰减策略）来提高训练的稳定性。
optimizer = optim.Adam(dqn.parameters(), lr=0.0005)  # 例如，减小学习率

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

  • 定义：折扣因子决定了智能体在优化过程中对未来奖励的重视程度。γ 值接近1时，智能体会更加注重长远的回报；γ 值接近0时，智能体则更关注短期的回报。
  • 调整建议：γ 通常设置在0.9到0.99之间。对于较短的游戏或回报立即显现的任务，可以选择较低的 γ 值。
train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.95)  # 例如，稍微降低 γ

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

  • 定义：在强化学习中，智能体需要在探索新策略和利用已知策略之间找到平衡。常用的探索策略有 ε-greedy，其中 ε 是智能体随机选择行动的概率。
  • 调整建议：可以设置一个较高的初始 ε 值（例如0.9），然后逐步减小，减少随机探索的次数。也可以引入更多先进的策略，如 UCB 或 Boltzmann 探索。
epsilon = 0.9  # 初始探索率
decay_rate = 0.995  # 衰减率

for episode in range(episodes):
    epsilon = max(epsilon * decay_rate, 0.01)  # 确保 epsilon 最小为 0.01
    # 其余代码保持不变

4. 经验回放（Experience Replay）

  • 定义：经验回放存储智能体在环境中经历的状态、行动、奖励和下一状态。训练时从这些存储的经验中随机抽取一个批次进行学习，从而提高训练的效率和稳定性。
  • 调整建议：增加经验回放的批次大小或扩展经验回放池的容量，可以帮助智能体更有效地学习。
from collections import deque

replay_memory = deque(maxlen=10000)  # 扩展经验回放池的容量

def train(game, dqn, optimizer, loss_fn, episodes=1000, gamma=0.99, batch_size=64):
    for episode in range(episodes):
        state = torch.tensor(game.reset(), dtype=torch.float32)
        total_reward = 0
        while True:
            if random.random() < epsilon:
                action = random.randint(0, num_actions - 1)
            else:
                q_values = dqn(state)
                action = torch.argmax(q_values).item()

            next_state, reward, done = game.step(action)
            next_state = torch.tensor(next_state, dtype=torch.float32)
            replay_memory.append((state, action, reward, next_state, done))

            # 开始经验回放训练
            if len(replay_memory) > batch_size:
                minibatch = random.sample(replay_memory, batch_size)
                for s, a, r, ns, d in minibatch:
                    q_values = dqn(s)
                    with torch.no_grad():
                        max_next_q_values = torch.max(dqn(ns))
                        target = r + gamma * max_next_q_values * (1 - int(d))
                    loss = loss_fn(q_values[a], target)
                    optimizer.zero_grad()
                    loss.backward()
                    optimizer.step()

            state = next_state
            total_reward += reward

            if done:
                break
        print(f"Episode {episode + 1}/{episodes} - Total Reward: {total_reward}")

5. 训练轮数（Number of Episodes）

  • 定义：训练轮数决定了智能体在环境中训练的总次数。
  • 调整建议：增加训练轮数通常会提高模型的表现，特别是在训练的早期阶段。如果训练过程过长，可能会导致过拟合问题，因此要注意在增加训练轮数的同时监控模型性能。
train(game, dqn, optimizer, loss_fn, episodes=5000)  # 增加训练轮数

6. 奖励函数（Reward Function）

  • 定义：奖励函数是强化学习中非常关键的一部分，它直接影响到智能体的行为。不同的奖励设计会引导智能体做出不同的决策。
  • 调整建议：可以通过修改奖励函数来更加准确地引导智能体的行为。例如，给予更多的奖励当蛇接近食物，或者减少每一步行动的惩罚，从而激励智能体更积极地去接近食物。
def step(self, action):
    if action == 0:  # Up
        self.direction = (-1, 0)
    elif action == 1:  # Down
        self.direction = (1, 0)
    elif action == 2:  # Left
        self.direction = (0, -1)
    elif action == 3:  # Right
        self.direction = (0, 1)

    head = (self.snake[0][0] + self.direction[0], self.snake[0][1] + self.direction[1])
    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):
        self.done = True
        return self._get_observation(), -10, self.done  # Collision: negative reward

    self.snake = [head] + self.snake[:-1]

    if head == self.food:
        self.snake.append(self.snake[-1])  # Grow
        self.food = self._place_food()
        return self._get_observation(), 10, self.done  # Food eaten: positive reward

    # 距离食物近一步，给出微小奖励
    dist = abs(head[0] - self.food[0]) + abs(head[1] - self.food[1])
    reward = 1.0 / (dist + 1)  # 距离越近，奖励越大

    return self._get_observation(), reward, self.done  # Neutral step

通过这些参数的调整，你可以提高训练的效果和智能体的表现。每个参数的调整对训练结果都有可能产生显著的影响，因此建议在调整时逐步进行，并仔细观察训练的变化情况。

Linductor
关注
  • 9
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
PyTorch深度学习实战（45）——强化学习
盼小辉丶的博客
07-10 1482
强化学习是当前人工智能领域的研究热点问题，强化学习主要通过考察智能体与环境的相互作用，得到策略模型、优化策略并最大化累积回报的过程。强化学习具有巨大的研究价值和应用潜力，是实现通用人工智能的关键技术。本文首先介绍强化学习的基本原理，包括马尔可夫决策过程、价值函数、探索-利用问题等，然后介绍经典的强化学习算法，最后使用 PyTorch 实现在游戏中模拟强化学习算法。
李宏毅深度强化学习导论——基本概念
日积月累，天道酬勤
03-21 1025
李宏毅强化学习简介
强化学习（RL)——Reinforcement learning
雨落i的博客
09-24 8598
强化学习（Reinforcement Learning, RL）**是机器学习中的一个领域**，又称再励学习、评价学习或增强学习。强化学习也是一类机器学习算法, 而强化学习是介于监督学习和非监督学习的另外一种学习方式。 强化学习+深度学习就等同于人工智能！
李宏毅深度学习——强化学习
wkywcd的博客
09-10 1466
强化学习一、RL是什么二、RL的框架1、第一步：Function with unknown2、第二步：定义损失函数3、第三步：Optimization三、Policy gradient（1）如何控制你的actor（2）如何确定哪个行为是好的版本1（3）如何确定哪个行为是好的版本2（4）如何确定哪个行为是好的版本3（5）exploration四、Actor-Critic1、Gritic（1）如何估计value function（2）将critic用在Actor中2、Tip of Actor-Critic五、R
强化学习课程学习（6）——基于深度学习方法求解RL
Cecilia
06-22 755
在之前讲到了强化学习求解方法，无论是动态规划DP，蒙特卡罗方法MC，还是时序差分TD，使用的状态都是离散的有限个状态集合SSS。此时问题的规模比较小，比较容易求解。但是假如我们遇到复杂的状态集合呢？甚至很多时候，状态是连续的，那么就算离散化后，集合也很大，此时我们的传统方法，比如Q-Learning，根本无法在内存中维护这么大的一张Q表。对此，随着深度学习地方法的发展兴起，基于深度学习的算法模型开始流行起来——Deep Q-learning、Nature DQN、Double DQN、Prioritized
【强化学习】demo系列——基于gym自定义RL环境
liuyider的博客
03-29 1836
gym是许多强化学习框架都支持了一种常见RL环境规范，实现简单，需要重写的api很少也比较通用。本文旨在给出一个简单的基于gym的自定义单智能体强化学习环境demo写好了自定义的RL环境后，还需要注册到安装好的gym库中，不然导入的时候是没有办法成功的。首先需要在gym/envs文件目录下创建一个文件夹用于保存你的RL环境（），一般路径为./anaconda3/envs/RL/lib/python3.8/site-packages/gymnasium/envs。在保存RL环境的文件夹下创建“init。
深度强化学习算法的未来——样本效率研究
soaring_casia的专栏
07-13 1250
强化学习由于其能自动适应环境而成为实现智能体的重要工具。在深度学习模型的加持下，强化学习可以在复杂任务（比如玩像素游戏）中表现出巨大潜力。
神经网络与深度学习——第14章 深度强化学习
a_blade_of_grass的博客
05-29 1485
本文讨论的内容参考自《神经网络与深度学习》https://nndl.github.io/ 第14章 深度强化学习 深度强化学习 强化学习（Reinforcement Learning，RL），也叫增强学习，是指一类从与环境交互中不断学习的问题以及解决这类问题的方法，强化学习可以描述为一个智能体从与环境交互中不断学习以完成特定目标（比如取得最大奖励值）。和深度学习类似，强化学习中的关键问题也是贡献度分配问题（即一个系统中不同的组件（component）对最终输出结果的贡献或影响），每一个动作并不能直接得到监督
强化学习简介——介绍强化学习的应用及理论.pptx
06-03
**强化学习（Reinforcement Learning, RL）**是一种机器学习方法，它使智能体（Agent）能够在与环境交互的过程中通过不断试错来学习最佳行为策略。不同于监督学习和无监督学习，强化学习中的智能体在与环境互动时会...
通用人工智能之路：什么是强化学习？如何结合深度学习？
FRIGIDWINTER的博客
07-03 6668
【专栏订阅必读】ChatGPT强大魔力的关键因素之一是应用了强化学习模型，本文系统梳理强化学习中环境、智能体、奖赏、动作、状态等关键概念，并给出深度强化学习框架。
深度学习100问10-什么是CBOW模型
yyq916的博客
08-24 202
为了完成这个任务，CBOW 会先把这些线索词（周围的词）都转换成向量，然后把这些向量加起来或者求平均，得到一个综合的向量表示。接着，CBOW 会用这个综合向量去预测目标词。在这个过程中，CBOW 就学会了如何把每个词都用一个向量来表示，而且意思相近的词对应的向量也会比较接近。这样训练出来的词向量可以用于很多自然语言处理任务，比如文本分类、情感分析、机器翻译等。它从一个文本中选取一个词作为目标词，然后把这个目标词周围的几个词当成线索。CBOW 的任务就是根据这些线索来猜出目标词是什么。
深度学习学习经验——全连接神经网络（FCNN）
Linductor的博客
08-22 910
全连接神经网络（FCNN）是最基础的神经网络结构，它由多个神经元组成，这些神经元按照层级顺序连接在一起。每一层的每个神经元都与前一层的每个神经元连接。接待区交流区和结果区。
【深度学习与NLP】——深度卷积神经网络AlexNet
最新发布
lingxw的博客
08-27 711
AlexNet 的出现极大地推动了深度学习在计算机视觉领域的发展。它证明了深度神经网络在图像识别等任务上的强大能力，为后续的研究提供了重要的参考和启示。此后，各种深度神经网络架构不断涌现，性能也不断提升。总之，AlexNet 是深度学习发展历程中的一个重要里程碑，它的创新之处和优异性能对计算机视觉领域产生了深远的影响。
深度学习学习经验——长短期记忆网络（LSTM）
Linductor的博客
08-23 1198
长短期记忆网络（LSTM，Long Short-Term Memory）是一种特殊的循环神经网络（RNN），专为解决 RNN 中长期依赖问题而设计。
深度学习 回归问题
Network_Engineer的博客
08-24 1572
梯度下降算法与求极值的方法非常类似, 其核心思想是求解。为学习率, 以上述公式为基础，发展出了更多的求解器.深度学习中, 梯度下降算法是是一种很重要的算法.加了压缩函数后, 压缩了预测范围[0, 1].在现实世界中, 数据总是会存在误差.预测范围为实数区间.
Unet改进2：在不同位置添加CBAM注意力机制
m0_51530640的博客
08-24 89
摘要。我们提出了卷积块注意模块(CBAM)，这是一种简单而有效的前馈卷积神经网络注意模块。给定一个中间特征映射，我们的模块沿着两个独立的维度依次推断注意力映射，通道和空间，然后将注意力映射乘以输入特征映射以进行自适应特征细化。因为CBAM是一个轻量级的通用模块，它可以无缝地集成到任何CNN架构中，开销可以忽略不计，并且可以与基础CNN一起进行端到端训练。我们通过在ImageNet-1K、MS COCO检测和VOC 2007检测数据集上进行大量实验来验证我们的CBAM。
深度学习100问8-什么是PTB语料库
yyq916的博客
08-24 253
对于自然语言处理领域的研究者和开发者来说，PTB语料库非常有价值。比如，通过分析语料库中的词性和句法结构，可以帮助计算机学会正确地分析句子结构，从而更好地进行机器翻译、文本分类、信息检索等任务。想象一下，PTB语料库就像是一个精心整理的英语语言宝库。里面的文本不仅有各种故事、新闻、论文等内容，而且还被仔细地分析和标注了各种语言信息。PTB（Penn Treebank）语料库是一个非常著名且被广泛使用的语料库。这些标注包括词性标注、句法结构标注等。总之，PTB语料库是英语自然语言处理中一个重要的资源。
深度学习--复制机制：CopyNet 模型在序列到序列模型中的应用以及代码实现
GDHBFTGGG的博客
08-25 863
CopyNet 是一种特别设计的序列到序列（Seq2Seq）模型，旨在更好地处理那些在输出序列中需要直接复制输入序列中的部分或全部内容的任务。它在机器翻译、摘要生成、文本复述等任务中有广泛的应用，尤其是在输入和输出有显著重叠的场景。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Linductor

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值