PyTorch线性层实战:用CIFAR10数据集手把手教你实现图像分类(附完整代码)

基于 PyTorch 的Cifar图像分类器代码实现(线性,全连接,卷积) 基于 PyTorch 的Cifar图像分类器代码实现 做实验的时候一共要求做三个实验分别是只使用线性层实现,通过全连接实现,通过卷积实现,代码也是参考了许多前人的代码,有一定程度的修改,然而准确度低的不成样子,望各位海涵。 同时本次的实验是在python 3.7 Jupyter上运行的,Cifar数据在py文件同级目录下的data文件中。由于我的显卡不支持CUDA因此都是直接用cpu搞定的。最... 阅读详情

PyTorch线性层实战:从CIFAR10图像分类项目深入理解全连接网络

如果你已经对PyTorch的张量操作和基础模块有了初步了解,可能会好奇:那些看起来简单的线性层,在实际项目中究竟扮演着怎样的角色?今天,我们就通过一个完整的图像分类项目,来彻底搞懂线性层的实战应用。CIFAR10数据集是个绝佳的起点——它足够复杂到需要真正的神经网络来处理,又不会庞大到让初学者望而却步。

很多教程会直接带你搭建复杂的卷积网络,但我觉得,从最基础的线性层开始构建一个分类器,反而能让你更清晰地理解数据是如何在神经网络中流动的。我们会从数据加载开始,一步步构建模型、编写训练循环,直到最终评估性能。在这个过程中,你会看到线性层如何将高维的图片数据“压缩”成10个类别的概率,也会遇到并解决几个新手常踩的坑。

1. 项目环境搭建与数据准备

在开始写代码之前,确保你的环境已经准备就绪。我推荐使用Python 3.8或更高版本,以及PyTorch 1.9以上。如果你还没有安装PyTorch,可以去官网根据你的CUDA版本选择对应的安装命令。对于这个项目,我们不需要GPU也能运行,但如果有的话训练速度会快很多。

# 创建虚拟环境(可选但推荐)
python -m venv pytorch_cifar10
source pytorch_cifar10/bin/activate  # Linux/Mac
# 或 pytorch_cifar10\Scripts\activate  # Windows

# 安装PyTorch和torchvision
pip install torch torchvision matplotlib tqdm

CIFAR10数据集包含60000张32x32像素的彩色图片,分为10个类别:飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车。每类有6000张图片,其中50000张用于训练,10000张用于测试。torchvision已经内置了这个数据集,下载和使用都非常方便。

注意:第一次运行代码时会自动下载数据集,大约163MB。如果你在国内,下载速度可能较慢,可以考虑提前配置镜像源。

让我们先看看数据长什么样。下面的代码会加载数据集并显示一些样本:

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 定义数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),  # 将PIL图像转换为Tensor,并归一化到[0,1]
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 标准化到[-1,1]
])

# 加载训练集和测试集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

# 类别名称
classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')

# 显示一些图片
def imshow(img):
    img = img / 2 + 0.5  # 反标准化
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

# 获取一批数据
dataiter = iter(trainloader)
images, labels = next(dataiter)

# 显示图片
imshow(torchvision.utils.make_grid(images))
print(' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))

运行这段代码,你会看到4张随机的小图片和它们的标签。注意观察图片的尺寸——32x32像素,3个颜色通道(RGB)。这意味着每张图片在数学上可以表示为一个形状为[3, 32, 32]的张量,或者展平后是[3072]的一维向量。这个3072(3×32×32)就是即将输入到我们线性层的特征数量。

2. 理解线性层的数学本质与PyTorch实现

线性层,也叫全连接层,是神经网络中最基础的组件之一。它的数学形式非常简单:y = xW^T + b。其中x是输入向量,W是权重矩阵,b是偏置向量。但在深入代码之前,我想先澄清几个容易混淆的概念。

线性层并不只是“一条直线”——虽然它的每个神经元确实执行线性变换,但多个线性层堆叠,配合非线性激活函数,就能拟合极其复杂的函数。这有点像用许多小线段来逼近曲线,线段越多,逼近得越好。

在PyTorch中,线性层由torch.nn.Linear类实现。它的构造函数有三个关键参数:

torch.nn.Linear(in_features, out_features, bias=True)

让我们拆解一下:

  • in_features:每个输入样本的特征维度
  • out_features:每个输出样本的特征维度
  • bias:是否添加可学习的偏置项,默认为True

为了直观理解,我做了个对比表格:

参数作用示例值(针对CIFAR10)注意事项
in_features定义输入向量的长度3072(32×32×3)必须与展平后的图片向量长度一致
out_features定义输出向量的长度10(类别数)或中间层节点数最后一层通常等于类别数
bias是否添加偏置项True(推荐)设置为False可减少参数,但可能降低模型表达能力

现在来看一个具体的例子。假设我们有一批4张CIFAR10图片,形状是[4, 3, 32, 32]。要输入线性层,我们需要先把它展平:

import torch.nn as nn

# 创建一个线性层:3072个输入特征,10个输出特征
linear_layer = nn.Linear(3072, 10)

# 模拟一批数据:4张图片,每张3×32×32
batch_size = 4
dummy_input = torch.randn(batch_size, 3, 32, 32)  # 随机数据
print(f"原始输入形状: {dummy_input.shape}")  # torch.Size([4, 3, 32, 32])

# 展平操作
flattened = dummy_input.view(batch_size, -1)  # -1表示自动计算该维度大小
print(f"展平后形状: {flattened.shape}")  # torch.Size([4, 3072])

# 通过线性层
output = linear_layer(flattened)
print(f"线性层输出形状: {output.shape}")  # torch.Size([4, 10])

这里有几个关键点需要注意:

  1. view() vs flatten():两者都能展平张量,但view()要求数据在内存中是连续的,而flatten()总是返回一个拷贝。对于从DataLoader加载的数据,通常使用flatten(start_dim=1),其中start_dim=1表示从第1维开始展平(保留batch维度)。

  2. 批量处理:线性层天然支持批量处理。如果你输入形状为[batch_size, in_features]的张量,它会输出[batch_size, out_features]。这是PyTorch设计的一大优点。

  3. 参数数量:这个线性层有多少参数?权重矩阵W的形状是[10, 3072],偏置b的形状是[10],所以总参数是10×3072 + 10 = 30730。对于32x32的小图片来说,这已经不少了!

提示:你可以用list(linear_layer.parameters())查看层的所有参数,或者用sum(p.numel() for p in linear_layer.parameters())计算总参数数量。

3. 构建基于线性层的图像分类模型

单靠一个线性层就想在CIFAR10上取得好成绩?几乎不可能。因为线性变换只能实现数据的线性分离,而图像分类问题通常是非线性的。我们需要堆叠多个线性层,并在它们之间加入非线性激活函数。

为什么需要非线性激活函数? 如果没有非线性,多个线性层的组合仍然等价于一个线性层。数学上可以证明:f(x) = W2(W1x + b1) + b2 = (W2W1)x + (W2b1 + b2),这还是一个线性变换。加入ReLU、Sigmoid或Tanh等非线性函数后,网络才能学习复杂的模式。

让我们设计一个简单的多层感知机(MLP)来处理CIFAR10:

import torch.nn as nn
import torch.nn.functional as F

class SimpleMLP(nn.Module):
    def __init__(self):
        super(SimpleMLP, self).__init__()
        # 第一层:3072 -> 512
        self.fc1 = nn.Linear(32 * 32 * 3, 512)
        # 第二层:512 -> 256  
        self.fc2 = nn.Linear(512, 256)
        # 第三层:256 -> 128
        self.fc3 = nn.Linear(256, 128)
        # 输出层:128 -> 10
        self.fc4 = nn.Linear(128, 10)
        
        # Dropout层防止过拟合
        self.dropout = nn.Dropout(0.3)
        
    def forward(self, x):
        # 展平输入:从[batch, 3, 32, 32]到[batch, 3072]
        x = x.view(-1, 32 * 32 * 3)
        
        # 第一层 + ReLU激活 + Dropout
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        
        # 第二层
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        
        # 第三层
        x = F.relu(self.fc3(x))
        x = self.dropout(x)
        
        # 输出层(不需要激活函数,后面会接CrossEntropyLoss)
        x = self.fc4(x)
        return x

# 实例化模型
model = SimpleMLP()
print(model)

这个模型有四个线性层,每层后面都跟着ReLU激活函数和Dropout。Dropout在训练时随机“关闭”一部分神经元,强迫网络学习更鲁棒的特征,这是防止过拟合的有效技巧。

关于层大小选择的经验:我通常遵循“漏斗”原则——逐渐减少每层的神经元数量。从3072到512是个较大的压缩,然后逐步降到10。太大的层会增加计算量和过拟合风险,太小的层可能无法捕捉足够特征。512-256-128-10这个配置在CIFAR10上是个不错的起点。

模型参数数量统计:

def count_parameters(model):
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

total_params = count_parameters(model)
print(f"模型总参数: {total_params:,}")
print(f"各层参数分布:")
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"  {name}: {param.numel():,}")

你会看到参数主要集中在第一层(约157万),因为3072×512的权重矩阵很大。这也是为什么对于图像任务,我们通常先用卷积层提取特征,再用线性层分类——卷积层参数更少,且能利用图像的局部相关性。

4. 训练策略与优化技巧

有了模型,接下来要定义损失函数和优化器。对于多分类问题,交叉熵损失(CrossEntropyLoss)是标准选择。它结合了Softmax和负对数似然,数值稳定且梯度良好。

import torch.optim as optim

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 学习率调度器:每10个epoch将学习率乘以0.5
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)

为什么选择Adam优化器? 相比传统的SGD,Adam自适应调整每个参数的学习率,通常收敛更快,对超参数不那么敏感。对于新手来说,Adam的默认参数(lr=0.001)在大多数情况下都能工作得很好。

现在让我们看看完整的训练循环。我添加了一些实用功能:进度条、训练损失记录、验证准确率计算。

from tqdm import tqdm
import time

def train_model(model, trainloader, testloader, criterion, optimizer, scheduler, epochs=20):
    train_losses = []
    val_accuracies = []
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model.to(device)
    
    print(f"使用设备: {device}")
    print("开始训练...")
    
    for epoch in range(epochs):
        start_time = time.time()
        
        # 训练阶段
        model.train()
        running_loss = 0.0
        train_correct = 0
        train_total = 0
        
        # 使用tqdm显示进度条
        pbar = tqdm(trainloader, desc=f'Epoch {epoch+1}/{epochs}')
        for i, data in enumerate(pbar):
            inputs, labels = data
            inputs, labels = inputs.to(device), labels.to(device)
            
            # 清零梯度
            optimizer.zero_grad()
            
            # 前向传播
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            
            # 反向传播
            loss.backward()
            
            # 梯度裁剪(防止梯度爆炸)
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            
            # 更新参数
            optimizer.step()
            
            # 统计
            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            train_total += labels.size(0)
            train_correct += (predicted == labels).sum().item()
            
            # 更新进度条
            pbar.set_postfix({'loss': running_loss/(i+1), 'acc': 100*train_correct/train_total})
        
        # 计算训练集平均损失和准确率
        train_loss = running_loss / len(trainloader)
        train_acc = 100 * train_correct / train_total
        
        # 验证阶段
        model.eval()
        val_correct = 0
        val_total = 0
        
        with torch.no_grad():
            for data in testloader:
                inputs, labels = data
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)
                _, predicted = torch.max(outputs.data, 1)
                val_total += labels.size(0)
                val_correct += (predicted == labels).sum().item()
        
        val_acc = 100 * val_correct / val_total
        val_accuracies.append(val_acc)
        train_losses.append(train_loss)
        
        # 更新学习率
        scheduler.step()
        
        epoch_time = time.time() - start_time
        
        print(f"Epoch {epoch+1:2d}/{epochs} | "
              f"Time: {epoch_time:.1f}s | "
              f"Train Loss: {train_loss:.4f} | "
              f"Train Acc: {train_acc:.2f}% | "
              f"Val Acc: {val_acc:.2f}% | "
              f"LR: {scheduler.get_last_lr()[0]:.6f}")
    
    print("训练完成!")
    return train_losses, val_accuracies

# 开始训练
train_losses, val_accuracies = train_model(
    model, trainloader, testloader, criterion, optimizer, scheduler, epochs=20
)

这个训练循环包含几个重要技巧:

  1. 梯度裁剪:clip_grad_norm_防止梯度变得太大导致训练不稳定。这在深度网络中特别重要。

  2. 模型模式切换:训练时用model.train(),验证时用model.eval()。这会影响Dropout和BatchNorm等层的行为。

  3. 学习率调度:随着训练进行,逐渐降低学习率可以帮助模型更精细地调整参数,找到更好的局部最优解。

  4. 验证集评估:每个epoch结束后在测试集上评估,监控模型是否过拟合。

训练过程中你可能会观察到一些典型现象:

  • 前几个epoch损失快速下降,准确率迅速提升
  • 随后提升速度变慢,可能需要调整学习率
  • 如果训练准确率远高于验证准确率,说明过拟合了

5. 模型评估与性能分析

训练完成后,我们需要全面评估模型性能。准确率是个好指标,但不是全部。让我们看看模型在哪些类别上表现好,哪些类别上容易混淆。

def evaluate_model(model, testloader):
    device = next(model.parameters()).device
    model.eval()
    
    # 初始化混淆矩阵
    confusion_matrix = torch.zeros(10, 10, dtype=torch.long)
    
    # 各类别准确率
    class_correct = list(0. for _ in range(10))
    class_total = list(0. for _ in range(10))
    
    with torch.no_grad():
        for data in testloader:
            inputs, labels = data
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs, 1)
            
            # 更新混淆矩阵
            for t, p in zip(labels.view(-1), predicted.view(-1)):
                confusion_matrix[t.long(), p.long()] += 1
            
            # 更新各类别统计
            c = (predicted == labels).squeeze()
            for i in range(labels.size(0)):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1
    
    # 总体准确率
    total_correct = sum(class_correct)
    total_samples = sum(class_total)
    overall_acc = 100 * total_correct / total_samples
    
    print(f"\n总体测试准确率: {overall_acc:.2f}%")
    print("\n各类别准确率:")
    for i in range(10):
        if class_total[i] > 0:
            acc = 100 * class_correct[i] / class_total[i]
            print(f"  {classes[i]:5s}: {acc:.2f}% ({int(class_correct[i])}/{int(class_total[i])})")
        else:
            print(f"  {classes[i]:5s}: 无样本")
    
    return confusion_matrix, overall_acc

# 评估模型
confusion_matrix, overall_acc = evaluate_model(model, testloader)

运行这段代码,你会看到类似这样的输出:

总体测试准确率: 52.34%

各类别准确率:
  plane: 58.20% (582/1000)
  car  : 65.30% (653/1000)  
  bird : 42.10% (421/1000)
  cat  : 31.50% (315/1000)
  deer : 45.60% (456/1000)
  dog  : 40.80% (408/1000)
  frog : 62.70% (627/1000)
  horse: 55.40% (554/1000)
  ship : 68.90% (689/1000)
  truck: 61.20% (612/1000)

分析结果:纯线性层模型在CIFAR10上大约能达到50-55%的准确率。注意观察类别间的差异——车辆(car、truck、ship)通常比动物(cat、dog、bird)更容易分类,因为车辆有更规整的形状和明显的特征。

为了更直观地查看错误模式,我们可以可视化混淆矩阵:

import matplotlib.pyplot as plt
import numpy as np

def plot_confusion_matrix(cm, classes):
    fig, ax = plt.subplots(figsize=(10, 8))
    im = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
    ax.figure.colorbar(im, ax=ax)
    
    # 设置坐标轴
    ax.set(xticks=np.arange(cm.shape[1]),
           yticks=np.arange(cm.shape[0]),
           xticklabels=classes, yticklabels=classes,
           ylabel='真实标签',
           xlabel='预测标签')
    
    # 旋转x轴标签
    plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
    
    # 在格子中显示数值
    thresh = cm.max() / 2.
    for i in range(cm.shape[0]):
        for j in range(cm.shape[1]):
            ax.text(j, i, format(cm[i, j], 'd'),
                    ha="center", va="center",
                    color="white" if cm[i, j] > thresh else "black")
    
    fig.tight_layout()
    plt.show()

# 绘制混淆矩阵
plot_confusion_matrix(confusion_matrix.numpy(), classes)

混淆矩阵的对角线元素表示正确分类的数量,非对角线元素表示混淆。你可能会看到猫和狗经常被混淆,鸟和鹿也容易分错。这很合理——这些类别在32x32的低分辨率下确实相似。

6. 模型优化与改进方向

如果50%的准确率不能满足你的需求(通常确实不够),我们可以从几个方向改进模型。但在此之前,先保存我们训练好的模型:

# 保存模型
torch.save({
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'train_losses': train_losses,
    'val_accuracies': val_accuracies,
}, 'cifar10_linear_model.pth')

print("模型已保存到 cifar10_linear_model.pth")

现在来看看改进策略。我按照效果和实现难度排序:

6.1 增加模型容量

最简单的改进是增加层数或每层的神经元数量。但要注意,线性层的参数增长很快:

class LargerMLP(nn.Module):
    def __init__(self):
        super(LargerMLP, self).__init__()
        self.fc1 = nn.Linear(32*32*3, 1024)
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 256)
        self.fc4 = nn.Linear(256, 128)
        self.fc5 = nn.Linear(128, 64)
        self.fc6 = nn.Linear(64, 10)
        self.dropout = nn.Dropout(0.5)  # 增加Dropout率防止过拟合
        
    def forward(self, x):
        x = x.view(-1, 32*32*3)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = F.relu(self.fc3(x))
        x = self.dropout(x)
        x = F.relu(self.fc4(x))
        x = self.dropout(x)
        x = F.relu(self.fc5(x))
        x = self.dropout(x)
        x = self.fc6(x)
        return x

更大的模型可能将准确率提升到60%左右,但很快就会遇到瓶颈。因为线性层没有利用图像的二维结构信息。

6.2 添加批归一化(BatchNorm)

批归一化可以加速训练、提高稳定性,有时还能轻微提升准确率:

class MLPWithBN(nn.Module):
    def __init__(self):
        super(MLPWithBN, self).__init__()
        self.fc1 = nn.Linear(32*32*3, 512)
        self.bn1 = nn.BatchNorm1d(512)
        self.fc2 = nn.Linear(512, 256)
        self.bn2 = nn.BatchNorm1d(256)
        self.fc3 = nn.Linear(256, 128)
        self.bn3 = nn.BatchNorm1d(128)
        self.fc4 = nn.Linear(128, 10)
        self.dropout = nn.Dropout(0.3)
        
    def forward(self, x):
        x = x.view(-1, 32*32*3)
        x = self.dropout(F.relu(self.bn1(self.fc1(x))))
        x = self.dropout(F.relu(self.bn2(self.fc2(x))))
        x = self.dropout(F.relu(self.bn3(self.fc3(x))))
        x = self.fc4(x)
        return x

批归一化通常放在线性层和激活函数之间。注意:在测试时,批归一化使用训练时计算的移动平均值,而不是当前批次的统计量。

6.3 使用更好的优化策略

除了Adam,还有一些优化技巧值得尝试:

# 权重衰减(L2正则化)
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

# 学习率预热(前几个epoch使用较小的学习率)
def warmup_scheduler(optimizer, warmup_epochs, base_lr):
    def lr_lambda(epoch):
        if epoch < warmup_epochs:
            return (epoch + 1) / warmup_epochs
        else:
            return 0.95 ** ((epoch - warmup_epochs) // 5)
    return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

# 早停(Early Stopping)
best_val_acc = 0
patience = 5
counter = 0

for epoch in range(epochs):
    # ... 训练代码 ...
    
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        counter = 0
        # 保存最佳模型
        torch.save(model.state_dict(), 'best_model.pth')
    else:
        counter += 1
        if counter >= patience:
            print(f"早停触发,最佳验证准确率: {best_val_acc:.2f}%")
            break

6.4 数据增强

对于图像任务,数据增强是提升性能最有效的方法之一。我们可以对训练图像进行随机变换,增加数据多样性:

from torchvision import transforms

# 增强的数据预处理
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),  # 随机水平翻转
    transforms.RandomCrop(32, padding=4),  # 随机裁剪
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 测试集不需要增强
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 重新加载数据
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=train_transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

数据增强可以让模型看到更多样的图像变体,提高泛化能力。即使对于线性模型,这也可能带来几个百分点的提升。

7. 从线性层到卷积网络:理解两者的关系

如果你跟着做到了这里,可能会发现纯线性层模型的局限性。即使加上所有优化技巧,准确率也很难超过65%。这是因为线性层在处理图像时有根本性的缺陷:

  1. 参数效率低:每个输入像素都与每个输出神经元相连,参数数量巨大
  2. 忽略局部相关性:图像中相邻像素通常高度相关,但线性层平等对待所有连接
  3. 平移不变性差:物体在图像中移动位置,线性层需要重新学习

这就是卷积神经网络(CNN)出现的原因。但有趣的是,卷积层本质上是一种特殊的、参数共享的线性层。理解这一点能帮你更好地掌握深度学习。

考虑一个简单的卷积操作:3×3卷积核在32×32图像上滑动。这等价于:

  • 将每个3×3局部区域展平为9维向量
  • 用同一个线性变换(卷积核)处理所有局部区域
  • 结果重新排列成特征图

用PyTorch代码表示这种等价关系:

import torch.nn as nn

# 方式1:使用卷积层
conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

# 方式2:用线性层模拟(仅用于理解,实际不这样用)
class ConvAsLinear(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size
        
        # 一个卷积核对应一个线性层
        self.linear = nn.Linear(in_channels * kernel_size * kernel_size, out_channels)
        
    def forward(self, x):
        # x形状: [batch, channels, height, width]
        batch, channels, height, width = x.shape
        
        # 提取所有局部区域
        patches = F.unfold(x, kernel_size=self.kernel_size, padding=1, stride=1)
        # patches形状: [batch, channels*kernel_size*kernel_size, num_patches]
        
        # 转置以便线性层处理
        patches = patches.transpose(1, 2)
        # 现在形状: [batch, num_patches, channels*kernel_size*kernel_size]
        
        # 应用线性变换(共享权重!)
        output = self.linear(patches)
        # 形状: [batch, num_patches, out_channels]
        
        # 重新折叠成特征图
        output = output.transpose(1, 2)
        output = F.fold(output, output_size=(height, width), 
                       kernel_size=1, stride=1)
        
        return output

这个例子展示了卷积如何通过权重共享大幅减少参数。对于CIFAR10,一个更好的架构是在前面使用卷积层提取特征,后面再用线性层分类:

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 卷积部分
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        
        # 线性部分
        self.fc1 = nn.Linear(64 * 8 * 8, 256)  # 注意尺寸计算!
        self.fc2 = nn.Linear(256, 10)
        self.dropout = nn.Dropout(0.3)
        
    def forward(self, x):
        # 卷积层
        x = self.pool(F.relu(self.conv1(x)))  # 32x32 -> 16x16
        x = self.pool(F.relu(self.conv2(x)))  # 16x16 -> 8x8
        
        # 展平
        x = x.view(-1, 64 * 8 * 8)
        
        # 全连接层
        x = self.dropout(F.relu(self.fc1(x)))
        x = self.fc2(x)
        
        return x

这个简单的CNN在CIFAR10上轻松达到70-75%的准确率,参数数量却比纯线性模型少得多。关键在于理解:卷积层负责提取局部特征,线性层负责综合这些特征做出分类决策。

8. 实战中的调试技巧与常见问题

在项目实践中,你可能会遇到各种问题。这里分享一些我调试线性层模型时积累的经验:

8.1 输入形状错误

这是最常见的问题。线性层要求输入形状为[batch_size, in_features],但图像数据通常是[batch_size, channels, height, width]。

错误示例:

# 错误:直接传递4D张量给线性层
output = linear_layer(images)  # 报错:mat1 and mat2 shapes cannot be multiplied

正确做法:

# 方法1:使用view展平
batch_size = images.shape[0]
flattened = images.view(batch_size, -1)

# 方法2:使用flatten
flattened = torch.flatten(images, start_dim=1)  # 从第1维开始展平

# 方法3:在模型forward方法中处理
def forward(self, x):
    x = x.view(x.size(0), -1)  # 保持batch维度,其余展平
    x = self.fc1(x)
    return x

8.2 梯度消失/爆炸

深度线性网络(即使有非线性激活)也可能遇到梯度问题。症状包括:

  • 损失变成NaN
  • 权重值变得极大或极小
  • 模型不学习(准确率不提升)

解决方案:

# 1. 权重初始化
def init_weights(m):
    if isinstance(m, nn.Linear):
        nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
        if m.bias is not None:
            nn.init.constant_(m.bias, 0)

model.apply(init_weights)

# 2. 梯度裁剪(前面训练循环中已包含)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# 3. 使用批归一化(前面已介绍)

# 4. 调整学习率
optimizer = optim.Adam(model.parameters(), lr=0.0001)  # 尝试更小的学习率

8.3 过拟合

当训练准确率远高于验证准确率时,就是过拟合了。

应对策略对比表:

方法实现方式效果注意事项
Dropoutnn.Dropout(p=0.5)中等训练和评估模式行为不同
L2正则化weight_decay=1e-4中等增加优化器参数
数据增强transforms.Random...高只用于训练集
早停监控验证损失中等需要验证集
简化模型减少层数/神经元高可能欠拟合

我通常的组合是:Dropout + 数据增强 + 适度的L2正则化。

8.4 学习率设置不当

学习率太大导致震荡,太小导致收敛慢。

诊断方法:

# 记录每个batch的损失
batch_losses = []

for batch_idx, (data, target) in enumerate(trainloader):
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()
    
    batch_losses.append(loss.item())
    
    if batch_idx % 100 == 0:
        print(f"Batch {batch_idx}, Loss: {loss.item():.4f}")

# 绘制损失曲线
plt.plot(batch_losses)
plt.xlabel('Batch')
plt.ylabel('Loss')
plt.title('Training Loss per Batch')
plt.show()

如果损失曲线剧烈震荡,降低学习率。如果下降太慢,适当提高学习率或使用学习率预热。

8.5 类别不平衡

CIFAR10是平衡数据集,但实际项目中常遇到类别不平衡。线性层对此比较敏感。

处理技巧:

# 1. 为损失函数添加类别权重
class_counts = [5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000]  # CIFAR10实际计数
class_weights = [1.0 - (count / sum(class_counts)) for count in class_counts]
class_weights = torch.FloatTensor(class_weights).to(device)

criterion = nn.CrossEntropyLoss(weight=class_weights)

# 2. 过采样少数类
from torch.utils.data import WeightedRandomSampler

# 为每个样本分配权重(少数类权重高)
sample_weights = [1.0 / class_counts[label] for _, label in trainset]
sampler = WeightedRandomSampler(sample_weights, len(sample_weights))
trainloader = DataLoader(trainset, batch_size=64, sampler=sampler)

这些调试技巧大多来自实际项目的经验积累。刚开始可能会觉得麻烦,但熟悉之后就能快速定位和解决问题了。

9. 扩展应用:线性层在其他任务中的使用

虽然我们用图像分类作为例子,但线性层的应用远不止于此。理解它的通用性很重要,因为这是深度学习的基础构件。

9.1 回归任务

将输出层改为1个神经元(不加激活函数),就可以做回归:

class RegressionMLP(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 1)  # 输出单个值
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)  # 没有激活函数,直接输出
        return x

# 使用均方误差损失
criterion = nn.MSELoss()

9.2 多标签分类

每个样本可以属于多个类别,使用Sigmoid激活和BCE损失:

class MultiLabelMLP(nn.Module):
    def __init__(self, input_dim, num_labels):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, 128)
        self.fc2 = nn.Linear(128, num_labels)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))  # 输出[0,1]之间的概率
        return x

# 二元交叉熵损失
criterion = nn.BCELoss()

9.3 嵌入层 + 线性层

在自然语言处理中,经常先用嵌入层将单词索引转换为向量,再用线性层处理:

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.fc1 = nn.Linear(embed_dim, 128)
        self.fc2 = nn.Linear(128, num_classes)
        
    def forward(self, x):
        # x形状: [batch, seq_len]
        embedded = self.embedding(x)  # [batch, seq_len, embed_dim]
        
        # 池化:取序列平均值
        pooled = embedded.mean(dim=1)  # [batch, embed_dim]
        
        # 线性层
        x = F.relu(self.fc1(pooled))
        x = self.fc2(x)
        return x

9.4 自定义线性层

理解线性层的原理后,你甚至可以自己实现一个:

class MyLinear(nn.Module):
    def __init__(self, in_features, out_features, bias=True):
        super().__init__()
        self.in_features = in_features
        self.out_features = out_features
        
        # 初始化权重
        self.weight = nn.Parameter(torch.Tensor(out_features, in_features))
        if bias:
            self.bias = nn.Parameter(torch.Tensor(out_features))
        else:
            self.register_parameter('bias', None)
            
        # 初始化参数
        self.reset_parameters()
        
    def reset_parameters(self):
        nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
        if self.bias is not None:
            fan_in, _ = nn.init._calculate_fan_in_and_fan_out(self.weight)
            bound = 1 / math.sqrt(fan_in)
            nn.init.uniform_(self.bias, -bound, bound)
            
    def forward(self, input):
        # y = xW^T + b
        return F.linear(input, self.weight, self.bias)
    
    def extra_repr(self):
        return f'in_features={self.in_features}, out_features={self.out_features}, bias={self.bias is not None}'

自己实现层有助于深入理解底层原理。你可以尝试添加一些变体,比如稀疏连接、权重共享等。

10. 性能优化与部署考虑

最后,当模型训练好后,我们还需要考虑如何优化性能和部署。对于线性层模型,有几个实用的优化技巧:

10.1 模型量化

线性层特别适合量化,因为大部分计算是矩阵乘法:

# 训练后动态量化
quantized_model = torch.quantization.quantize_dynamic(
    model, {nn.Linear}, dtype=torch.qint8
)

# 比较大小
import os

torch.save(model.state_dict(), 'model_fp32.pth')
torch.save(quantized_model.state_dict(), 'model_int8.pth')

fp32_size = os.path.getsize('model_fp32.pth') / 1024
int8_size = os.path.getsize('model_int8.pth') / 1024

print(f"FP32模型大小: {fp32_size:.1f} KB")
print(f"INT8模型大小: {int8_size:.1f} KB")
print(f"压缩比: {fp32_size/int8_size:.1f}x")

量化通常能将模型大小减少4倍,推理速度提升2-3倍,准确率损失很小(<1%)。

10.2 使用TorchScript导出

为了在生产环境中部署,可以将模型导出为TorchScript:

# 转换为TorchScript
example_input = torch.randn(1, 3, 32, 32)
traced_script_module = torch.jit.trace(model, example_input)

# 保存
traced_script_module.save("cifar10_model.pt")

# 加载使用(不需要Python环境)
loaded_model = torch.jit.load("cifar10_model.pt")
output = loaded_model(example_input)

10.3 批处理优化

线性层的计算效率与批处理大小密切相关:

import time

batch_sizes = [1, 4, 16, 64, 256]
throughputs = []

for batch_size in batch_sizes:
    # 创建测试数据
    test_input = torch.randn(batch_size, 3, 32, 32)
    
    # 预热
    for _ in range(10):
        _ = model(test_input)
    
    # 测量时间
    start = time.time()
    for _ in range(100):
        _ = model(test_input)
    end = time.time()
    
    throughput = 100 * batch_size / (end - start)
    throughputs.append(throughput)
    print(f"Batch size {batch_size:3d}: {throughput:.1f} images/sec")

# 绘制结果
plt.plot(batch_sizes, throughputs, 'o-')
plt.xlabel('Batch Size')
plt.ylabel('Throughput (images/sec)')
plt.title('线性层模型吞吐量 vs 批处理大小')
plt.xscale('log')
plt.grid(True)
plt.show()

你会发现,在一定范围内,批处理越大,吞吐量越高。但太大的批处理可能受限于GPU内存。

10.4 内存使用分析

了解模型的内存占用有助于优化:

def get_memory_usage(model, input_size=(1, 3, 32, 32)):
    device = next(model.parameters()).device
    
    # 前向传播内存
    input_tensor = torch.randn(*input_size).to(device)
    
    # 清除缓存
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()
    
    # 前向传播
    output = model(input_tensor)
    
    if torch.cuda.is_available():
        memory_allocated = torch.cuda.memory_allocated() / 1024**2
        memory_cached = torch.cuda.memory_cached() / 1024**2
        print(f"GPU内存占用: {memory_allocated:.2f} MB (已分配)")
        print(f"GPU缓存: {memory_cached:.2f} MB")
    
    # 参数内存
    param_memory = sum(p.numel() * p.element_size() for p in model.parameters()) / 1024**2
    print(f"参数内存: {param_memory:.2f} MB")
    
    # 梯度内存(近似)
    grad_memory = param_memory  # 梯度通常与参数同样大小
    print(f"梯度内存: {grad_memory:.2f} MB")
    
    return output

get_memory_usage(model)

对于我们的简单MLP,参数大约8MB,加上激活和梯度,总共可能需要24MB左右。这对于现代GPU来说很小,但如果是更大的模型或批处理,就需要仔细管理了。

通过这些优化,你可以将训练好的线性层模型部署到各种环境,从服务器到移动设备。虽然今天我们用CIFAR10作为示例,但线性层的这些特性和优化技巧适用于几乎所有深度学习任务。

手把手教你实现PyTorch版ViT:图像分类任务中的Transformer实战 Vision Transformer (ViT) 架构解析 本文从具身智能的基础设施Transformer出发,详细解析了Vision Transformer (ViT)的核心架构。ViT将图像分割为16×16的patch作为"视觉词",通过线性投影转换为token序列,采用纯Transformer结构处理视觉信息。文章重点剖析了ViT的两个关键模块:Patch Embedding将图像分割展平为向量序列;分类标记与位置编码模块引入[CLS] token聚合全局信息,并通过可学习位置编码 阅读详情

相关推荐

从NLP到CV:手把手教你用PyTorch实现ViT图像分类(附完整代码)

本文提供了使用PyTorch从零实现Vision Transformer(ViT)进行图像分类的完整实战教程。通过详细解析Patch Embedding、Transformer Encoder等核心模块的源码,并对比其在CIFAR-10数据集上与CNN模型的性能表现,帮助读者深入理解ViT的工作原理、训练技巧及实际应用中的关键细节。

weixin_29040367的博客 555

【深度学习图像识别课程】keras实现CNN系列:(4)MLP/CNN实现CIFAR-10图像分类

  一、卷积层、池化层的一般设置 1、卷积层 滤波器数量逐渐增加,kernel_size范围2*2~5*5,一般设置为2*2,strides设置为1, padding='same',并在最后添加Relu激活。如果对于第一层,还要增加input_shape。 深度从输入层的3,变成16,再到32,再到64,维度越来越大。深度要更深,于是我们考虑减少宽度、高度。 from keras....

It_BeeCoder的博客 1550

深度学习入门实战:基于PyTorch从零构建图像分类项目

很多刚接触深度学习的同学,面对复杂的理论、海量的框架和层出不穷的模型,常常感到无从下手。想动手做一个项目,却卡在环境配置、数据准备、模型选择和代码调试等环节,最终只能停留在“看教程”的阶段。本文将为你提供一套清晰、可执行的“从零到一”的深度学习项目实战指南,手把手带你完成一个完整的图像分类项目。无论你是计算机专业的学生,还是希望转行AI的开发者,都能通过本文快速上手,获得第一个可运行的深度学习项目成果。 1. 项目目标与核心概念:从“是什么”到“做什么” 在开始敲代码之前,我们需要明确目标。本次实战的目标是

weixin_34008805的博客 870

33- PyTorch实现分类和线性回归 (PyTorch系列) (深度学习)

线性回归预测的是一个连续值, 逻辑回归给出的”是”和“否”的回答, 逻辑回归通过sigmoid函数把线性回归的结果规范到0到1之间.sigmoid函数是一个概率分布函数, 给定某个输入,它将输出为一个概率值.# 回归和分类之间, 区别不大, 回归后面加上一层sigmoid, 就变成分类了.(pytorch 最常见的创建模型的方式, 子类)# pytorch 最常见的创建模型的方式, 子类# 需要自定义类# 先调用父类的方法# 定义网络中会用到的东西.

March_A的博客 2534

【PyTorch】在PyTorch中使用线性层和交叉熵损失函数进行数据分类

在机器学习的众多任务中,分类问题无疑是最基础也是最重要的一环。本文将介绍如何在PyTorch框架下,使用线性层和交叉熵损失函数来解决分类问题。我们将以简单的Iris数据集作为起点,探讨线性模型在处理线性可分数据上的有效性。随后,我们将尝试将同样的线性模型应用于复杂的CIFAR-10图像数据集,并分析其性能表现。

weixin_45568812的博客 1387

CIFAR10图像分类实战:用PyTorch构建CNN模型完整指南

图像分类是计算机视觉的基础任务,而卷积神经网络(CNN)则是从像素中学习特征的经典工具。CIFAR10作为最常用的入门数据集,以6万张32×32彩色小图覆盖10个类别,既考验特征提取能力,又因规模适中而成为算法对比与调参的试金石。CNN通过卷积、池化与批归一化逐层抽象视觉特征,结合随机裁剪、随机翻转等数据增强手段,可有效抑制过拟合并提升泛化能力。在实际工程中,数据加载的标准化、学习率衰减策略以及模型权重的保存与加载,直接决定了从实验到部署的顺畅度。无论你是刚接触深度学习,还是需要快速验证模型结构,基于PyT

weixin_33985679的博客 406

超参数调优实战:让MLP-Mixer在CIFAR-10数据集上达到98%准确率的秘密

你是否还在为神经网络调参而烦恼?本文将以gh_mirrors/vi/vision_transformer项目中的MLP-Mixer模型为例,通过分析[vit_jax/configs/mixer_base16_cifar10.py](https://link.gitcode.com/i/d42bbfa58fd805d9c46b5b0a3f9d0fe5)配置文件和[vit_jax/models_mix...

gitblog_00466的博客 716

MLP-神经网络-:多层感知(MLP)网络,对属于STL-10数据集中10个类别之一的图像数据进行分类

MLP-神经网络-:多层感知(MLP)网络,对属于STL-10数据集中10个类别之一的图像数据进行分类

图像分类的 PyTorch 实现 (CIFAR10)

点击关注我哦欢迎关注“小白玩转Python”,发现更多 “有趣”图像分类是最基本的问题之一,对于人类大脑来说可能是微不足道的,但对于计算机来说却似乎是不可能完成的任务。但是只要有正确的...

Warmer_Sweeter 1575

经典卷积神经网络源码(cifar10数据集为例)

卷积神经网络经典代码,采用tensorflow框架,能够实现对cifar10数据集的经典分类。

Dify工作流实践—根据word需求文档编写测试用例到Excel中

文章介绍了用dify工作流实现从word需求文档到测试用例写入excel的详细落地过程

weixin_42476668的博客 5336

【PyTorch】使用PyTorch创建卷积神经网络并在CIFAR-10数据集上进行分类

在深度学习的世界中,图像分类任务是一个经典的问题,它涉及到识别给定图像中的对象类别。CIFAR-10数据集是一个常用的基准数据集,包含了10个类别的60000张32x32彩色图像。在本博客中,我们将探讨如何使用PyTorch框架创建一个简单的卷积神经网络(CNN)来对CIFAR-10数据集中的图像进行分类。在下一篇博客中,我们将尝试不断优化模型结构和训练过程,以达到更高的准确率和性能。

weixin_45568812的博客 1899

Axure RP 10表单数据提交制作

本文介绍了如何使用Axure RP 10实现表单数据提交。

Peppaaa的博客 990

LeNet和ResNet神经网络做CIFAR10图像分类(PyTorch)

图像分类的算法有很多,大部分其实都用CNN来提取图像的特征,今天我们一起来学习用PyTorch做CIFAR10数据集的分类。CIFAR10数据集是一个10个类的图像数据集,图片大小是32*32的。首先我们来看LeNet模型,这个模型进行图像识别的流程入下图所示: 由上图可以清晰地看出整个的流程是经过一个卷积层,然后经过池化,再经过卷积,再进行一层池化层,最后是三个全连接层,最终输出10维的向量就...

深圳湾刘能的博客 4976

Excel转LaTeX表格神器:excel2latex.xla插件使用全攻略(含下载链接与配置教程)

本文详细介绍了Excel转LaTeX表格神器excel2latex.xla插件的完整使用攻略。从下载安装、基础转换到高级配置,深入讲解了如何利用该插件高效生成LaTeX代码,特别针对IEEE双栏等复杂排版需求提供了专业解决方案,帮助用户彻底告别手动编码,提升学术与专业文档的排版效率。

app77的博客 298

AUTOSAR开发实战:NvM模块如何解决汽车电子中的EEPROM与Flash存储难题?

本文深入探讨了AUTOSAR中的NvM模块如何有效解决汽车电子系统中EEPROM与Flash存储的难题。通过分层架构设计,NvM模块实现了硬件抽象与统一管理,支持数据一致性检查、错误恢复等高级功能,显著提升了存储可靠性和耐久性。文章结合实战案例,详细解析了NvM的核心机制及工程优化方案,为汽车电子开发者提供宝贵参考。

e3f4g5的博客 566

cifar10数据集_【PyTorch神经网络基础】以CIFAR10图像分类为例

本节详细介绍如何利用当下火热的PyTorch深度学习框架,搭建神经网络,并对CIFAR10图像数据集进行分类。如有错误,欢迎指出!阅读本文之前,读者应该到百科上面查找相关教程安装好PyTorch学习环境,如有则跳过。编者按01—机器学习基础知识在之前的6月份,公众号也曾发布过一篇使用tensorflow进行MNIST手写体识别的文章,戳此。但那个时候默认读者已经知道了相关概念,造成阅读体...

weixin_33871105的博客 692

【Android14 ShellTransitions】Transition就绪:双Transaction与SurfaceControl显示时机剖析

本文深入剖析了Android14 ShellTransitions框架中Transition就绪阶段的核心机制。重点解释了为何需要“双Transaction”来精确控制SurfaceControl的显示与隐藏时机,以确保Activity切换动画的流畅性。通过分析onTransactionReady流程、窗口绘制状态机及动画目标提升策略,揭示了系统如何协调WMCore与WMShell,实现从状态收集到动画播放的无缝衔接。

ooo22的博客 530

Pytorch入门之CIFAR10图片分类

Pytorch初探之CIFAR10图片分类 Pytorch官方文档真的是宝藏,不仅有所有函数功能的讲解,还有丰富的入门案例学习。在看了论文代码以后,感觉自己还是要来补一下基本的入门知识,就写一下其中CIFAR图片分类的知识点。 其实这个数据集和MNIST很像,不过这个数据集的图片是彩色的,也就是说传入的数据集是有RGB三个通道的,同时这个数据内容会比手写数字更加丰富一些,最后也是把图片分为十个类。...

faithfulzl的博客 567

USB摄像头开发避坑指南:UVC协议中的Alternate Setting详解

本文深入解析UVC协议中的Alternate Setting机制,这是USB摄像头开发中影响视频流稳定性的关键。文章通过实际案例,详解了Alternate Setting如何管理USB带宽分配,并分析了帧率不达标、图像花屏等典型问题的根源与排查方法,为开发者提供实用的避坑指南和调试技巧。

meat5的博客 241

【技能】OpenClaw Skills学习及手搓一个极简skill

本文介绍了OpenClaw Skills的基础概念与使用方法。Skills是OpenClaw代理使用工具的核心载体,通过SKILL.md文件定义技能属性和执行方式。技能加载遵循"工作区>本地>内置>自定义目录"的优先级规则。用户可通过ClawHub一键安装现成技能,也可自定义开发技能:创建技能目录,编写包含YAML元数据和执行指令的SKILL.md文件,放置于工作区skills目录进行测试。文章还介绍了多代理场景下的技能共享、插件集成以及安全注意事项,包括沙箱使用和敏感

海兰 3977

用 PyTorch 搭建 CIFAR10 线性分类器:从数据加载到模型推理全流程解析

super(Prayer, self).__init__() # 继承nn.Module的初始化方法# 定义线性层:输入维度3072,输出维度10(1)继承nn.Module的意义nn.Module是 PyTorch 中所有神经网络模块的基类,自定义模型必须继承它。自动管理模型中的可训练参数(比如线性层的权重和偏置);支持前向传播(forward方法)和反向传播(自动求导);提供模型保存、加载、移动到 GPU 等便捷功能。(2)的作用这行代码是 "子类调用父类初始化方法" 的标准写法,目的是。

StarPrayers.的博客 993

10、贝叶斯曲线拟合与预测分布详解

本文详细介绍了贝叶斯曲线拟合与预测分布的核心概念与计算方法。从最大似然估计出发,引入参数的先验分布,推导出后验分布与最大后验估计,并进一步展示如何通过积分获得完整的预测分布。文章解析了预测分布中均值与方差的构成,强调贝叶斯方法在量化不确定性方面的优势,涵盖金融、医疗、气象等实际应用场景。最后总结了操作步骤与未来研究方向,帮助读者系统掌握贝叶斯方法在回归问题中的应用。

android的专栏 106

autoencoder pytorch_【PyTorch神经网络基础】以CIFAR10图像分类为例

本节详细介绍如何利用当下火热的PyTorch深度学习框架,搭建神经网络,并对CIFAR10图像数据集进行分类。如有错误,欢迎指出!阅读本文之前,读者应该到百科上面查找相关教程安装好PyTorch学习环境,如有则跳过。编者按01—机器学习基础知识在之前的6月份,公众号也曾发布过一篇使用tensorflow进行MNIST手写体识别的文章,戳此。但那个时候默认读者已经知道了相关概念,造成阅读体...

weixin_39976960的博客 699

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

用ResNet对CIFAR数据集进行图像分类

CIFAR数据集的导入 CIFAR-10数据集有60000张32*32的彩色图片,总共10类,每一类有6000张图片。分为50000张训练集和10000张测试集 在torchvision包中可以非常方便地直接导入cifar数据集 输入dataroot,是否是训练集,transform等参数。 transform参数一般传入transforms.Compose([])进行一些变换 这里就可以从网上下载得到CIFAR的原始数据集了 cifar_train=datasets.CIFAR10('cifar',Tr

kiss_the_rian的博客 1766

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

上一篇: SAP PS实战:如何用Grouping WBS简化项目物料管理(附配置截图)
下一篇: Windows 10下ROS2安装避坑指南:从Chocolatey到Graphviz环境变量配置
pluto
博客等级 码龄25年 46粉丝 1562原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值