【PYG】处理Cora数据集分类任务使用的几个函数log_softmax，nll_loss和argmax

只是有点小怂2024-07-08 15:37

文章目录

log_softmax

F.log_softmax(x, dim=1) 是 PyTorch 中的一个函数，用于对输入张量 x 应用 log-softmax 操作。

解释

  • F.log_softmax ：这是 PyTorch 中的一个函数，位于 torch.nn.functional 模块中。它首先对输入进行 softmax 操作，然后取对数。softmax 操作将输入的原始分数转换为概率分布，而取对数可以使后续的计算更稳定且数值范围更适合计算。

  • x：这是输入张量。通常在神经网络中，它是来自最后一层的输出。

  • dim=1 ：这是指定 softmax 操作应用的维度。对于二维张量（例如批处理的数据），dim=1 通常表示在每个样本的类别维度上应用 softmax 操作。

作用

log-softmax 操作的主要作用是在多分类问题中计算模型的输出概率分布，并且在使用负对数似然损失（negative log-likelihood loss，通常用于分类任务）时特别有用。通过先应用 log-softmax，再与目标标签计算负对数似然损失，可以确保计算的数值稳定性。

示例

假设你有一个二维张量 x，表示模型的未归一化输出（logits），其形状为 [batch_size, num_classes]。以下是如何使用 F.log_softmax 的示例：

python 复制代码 
import torch
import torch.nn.functional as F

# 模拟模型输出的logits
logits = torch.tensor([[2.0, 1.0, 0.1],
                       [1.0, 3.0, 0.2]])

# 应用log-softmax
log_probs = F.log_softmax(logits, dim=1)

print(log_probs)

输出可能类似于：

tensor([[-0.4076, -1.4076, -2.3076],
        [-2.1269, -0.1269, -3.1269]])

解释输出

  • 对于第一个样本 logits = [2.0, 1.0, 0.1]，应用 log-softmax 后的输出为 [-0.4076, -1.4076, -2.3076]。这些值是输入经过 softmax 转换为概率后取对数的结果。
  • 对于第二个样本 logits = [1.0, 3.0, 0.2]，应用 log-softmax 后的输出为 [-2.1269, -0.1269, -3.1269]。

log-softmax 的输出可以直接用于计算损失函数，例如交叉熵损失，这在分类任务中特别有用。

nll_loss

F.nll_loss(out[data.train_mask], data.y[data.train_mask]) 是 PyTorch 中用于计算负对数似然损失（Negative Log-Likelihood Loss, NLLLoss）的一种常见用法，通常用于多分类任务。以下是这个函数的详细解释：

解释

  • F.nll_loss ：这是 PyTorch 中的一个函数，用于计算负对数似然损失。它通常与 F.log_softmax 结合使用，因为 F.nll_loss 期望输入是对数概率（log-probabilities）。

  • out ：这是模型的输出，即经过 F.log_softmax 处理后的对数概率张量。形状通常为 [num_nodes, num_classes]。

  • data.train_mask ：这是一个布尔张量，用于指示哪些节点属于训练集。其形状为 [num_nodes]，值为 True 的位置表示对应的节点在训练集中。

  • data.y ：这是节点的标签张量，形状为 [num_nodes]。每个元素表示一个节点的类别标签。

具体操作

  1. 掩码选择 ：使用 data.train_mask 选择训练集中的节点。

    • out[data.train_mask]：选择模型输出中属于训练集的节点。
    • data.y[data.train_mask]：选择标签中属于训练集的节点。

  2. 计算损失 ：F.nll_loss 接收两个参数：

    • input：对数概率张量，形状为 [batch_size, num_classes]。
    • target：目标标签张量，形状为 [batch_size]。

  3. 返回值：返回一个标量，表示训练集上的平均负对数似然损失。

示例代码

假设我们有一个简单的GNN模型，以下是如何使用 F.nll_loss 计算损失的示例代码：

python 复制代码 
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

# 加载Cora数据集
dataset = Planetoid(root='/tmp/Cora', name='Cora', transform=NormalizeFeatures())
data = dataset[0]

# 定义GCN模型
class GCN(torch.nn.Module):
    def __init__(self):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(dataset.num_node_features, 16)
        self.conv2 = GCNConv(16, dataset.num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)

# 初始化模型和优化器
model = GCN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
data = data.to('cuda')
model = model.to('cuda')

# 训练模型
def train():
    model.train()
    optimizer.zero_grad()
    out = model(data)
    loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()
    return loss.item()

# 评估模型
def test():
    model.eval()
    out = model(data)
    pred = out.argmax(dim=1)
    correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
    acc = int(correct) / int(data.test_mask.sum())
    return acc

for epoch in range(200):
    loss = train()
    acc = test()
    print(f'Epoch {epoch+1}, Loss: {loss:.4f}, Accuracy: {acc:.4f}')

解释

  1. 数据加载：加载Cora数据集并归一化特征。
  2. 模型定义：定义一个简单的两层GCN模型。
  3. 训练和评估 ：使用F.nll_loss计算训练集上的损失，并在每个epoch结束时评估模型在测试集上的准确性。

通过这种方式，F.nll_loss 帮助我们衡量模型在训练集上的表现，并为优化模型提供目标函数。

nll_loss+log_softmax=cross_entropy

为了更简洁地实现负对数似然损失（NLL Loss）和log-softmax的结合，我们可以使用 torch.nn.functional.cross_entropy。cross_entropy 函数将 log_softmax 和 nll_loss 两个步骤合并在一起，简化了代码，并且在数值上更加稳定和高效。

解释

  • torch.nn.functional.cross_entropy ：这是 PyTorch 提供的一个函数，用于计算交叉熵损失。它内部会先对输入进行 log_softmax 操作，然后计算 nll_loss。
  • input ：未归一化的模型输出（logits），形状为 [num_nodes, num_classes]。
  • target ：目标标签，形状为 [num_nodes]。

代码示例

以下是如何使用 torch.nn.functional.cross_entropy 替代 log_softmax 和 nll_loss 的代码示例：

python 复制代码 
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

# 加载Cora数据集
dataset = Planetoid(root='/tmp/Cora', name='Cora', transform=NormalizeFeatures())
data = dataset[0]

# 定义GCN模型
class GCN(torch.nn.Module):
    def __init__(self):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(dataset.num_node_features, 16)
        self.conv2 = GCNConv(16, dataset.num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index)
        return x  # 返回未归一化的logits

# 初始化模型和优化器
model = GCN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
data = data.to('cuda')
model = model.to('cuda')

# 训练模型
def train():
    model.train()
    optimizer.zero_grad()
    out = model(data)
    loss = F.cross_entropy(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()
    return loss.item()

# 评估模型
def test():
    model.eval()
    out = model(data)
    pred = out.argmax(dim=1)  # 提取预测类别
    correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
    acc = int(correct) / int(data.test_mask.sum())
    return acc

for epoch in range(200):
    loss = train()
    acc = test()
    print(f'Epoch {epoch+1}, Loss: {loss:.4f}, Accuracy: {acc:.4f}')

解释

  1. 数据加载：加载Cora数据集并归一化特征。
  2. 模型定义：定义一个简单的两层GCN模型。在前向传播过程中返回未归一化的logits。
  3. 训练过程 ：使用 F.cross_entropy 直接计算损失，它将自动对输入进行 log_softmax 并计算 nll_loss。
  4. 评估过程 ：使用 out.argmax(dim=1) 提取预测类别，并计算准确性。

通过这种方式，我们简化了代码，并且避免了在计算 log_softmax 和 nll_loss 时可能出现的数值问题。

argmax()

pred = out.argmax(dim=1) 是 PyTorch 中用于从模型的输出中提取预测类别标签的一个常用方法。以下是详细解释：

解释

  • out ：这是模型的输出，通常是一个形状为 [num_nodes, num_classes] 的张量，其中每一行表示一个节点或样本的类别对数概率（log-probabilities）。

  • argmax(dim=1) ：这是一个张量操作，用于在指定维度上找到最大值的索引。dim=1 表示我们在类别维度上进行操作，因此对于每个节点或样本，argmax(dim=1) 将返回具有最大对数概率的类别索引。

作用

通过 argmax(dim=1)，我们从模型的输出中提取每个节点或样本的预测类别。对于分类任务，这一步是必要的，因为模型的输出通常是每个类别的对数概率分布，我们需要从中选出概率最大的类别作为预测结果。

示例代码

假设我们有一个GNN模型的输出 out，其形状为 [num_nodes, num_classes]，以下是如何使用 argmax 提取预测类别的示例代码：

python 复制代码 
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

# 加载Cora数据集
dataset = Planetoid(root='/tmp/Cora', name='Cora', transform=NormalizeFeatures())
data = dataset[0]

# 定义GCN模型
class GCN(torch.nn.Module):
    def __init__(self):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(dataset.num_node_features, 16)
        self.conv2 = GCNConv(16, dataset.num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)

# 初始化模型和优化器
model = GCN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
data = data.to('cuda')
model = model.to('cuda')

# 训练模型
def train():
    model.train()
    optimizer.zero_grad()
    out = model(data)
    loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()
    return loss.item()

# 评估模型
def test():
    model.eval()
    out = model(data)
    pred = out.argmax(dim=1)  # 提取预测类别
    correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
    acc = int(correct) / int(data.test_mask.sum())
    return acc

for epoch in range(200):
    loss = train()
    acc = test()
    print(f'Epoch {epoch+1}, Loss: {loss:.4f}, Accuracy: {acc:.4f}')

解释

  1. 数据加载：加载Cora数据集并归一化特征。
  2. 模型定义：定义一个简单的两层GCN模型。
  3. 训练和评估 ：在训练过程中使用F.nll_loss计算损失。在评估过程中使用out.argmax(dim=1)提取预测类别，并计算准确性。

示例输出

假设 out 的输出如下：

python 复制代码 
out = torch.tensor([[0.1, 2.3, 0.4],
                    [1.2, 0.8, 3.5],
                    [0.6, 0.7, 0.2]])

使用 out.argmax(dim=1) 提取预测类别：

python 复制代码 
pred = out.argmax(dim=1)
print(pred)

输出将是：

tensor([1, 2, 1])

这表示模型预测第一个样本的类别为1，第二个样本的类别为2，第三个样本的类别为1。通过这种方式，我们可以从模型的输出中提取每个样本的预测类别，用于后续的评估或其他处理。

相关推荐
AI_NEW_COME5 分钟前
知识库管理系统可扩展性深度测评
人工智能
海棠AI实验室27 分钟前
AI的进阶之路：从机器学习到深度学习的演变（一）
人工智能·深度学习·机器学习
hunteritself29 分钟前
AI Weekly『12月16-22日』：OpenAI公布o3，谷歌发布首个推理模型，GitHub Copilot免费版上线！
人工智能·gpt·chatgpt·github·openai·copilot
IT古董1 小时前
【机器学习】机器学习的基本分类-强化学习-策略梯度（Policy Gradient，PG）
人工智能·机器学习·分类
落魄君子1 小时前
GA-BP分类-遗传算法（Genetic Algorithm）和反向传播算法（Backpropagation）
算法·分类·数据挖掘
centurysee1 小时前
【最佳实践】Anthropic：Agentic系统实践案例
人工智能
mahuifa1 小时前
混合开发环境---使用编程AI辅助开发Qt
人工智能·vscode·qt·qtcreator·编程ai
四口鲸鱼爱吃盐1 小时前
Pytorch | 从零构建GoogleNet对CIFAR10进行分类
人工智能·pytorch·分类
落魄君子1 小时前
ELM分类-单隐藏层前馈神经网络（Single Hidden Layer Feedforward Neural Network, SLFN）
神经网络·分类·数据挖掘
蓝天星空1 小时前
Python调用open ai接口
人工智能·python
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程