PyTorch-完整的模型训练套路

原创 已于 2023-05-30 10:01:41 修改 · 4k 阅读 · 40 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#pytorch #深度学习 #人工智能

于 2023-05-30 09:14:36 首次发布
文章详细介绍了如何利用PyTorch搭建卷积神经网络模型，处理CIFAR10数据集，进行训练和测试，使用TensorBoard监控损失曲线，并探讨了在GPU上进行训练的方法。
部署运行你感兴趣的模型镜像

目录

1. 准备

1.1 使用Cifar10

1.2 item的用法

1.3 model的搭建

1.4 数据集、参数设置以及训练开始

1.5 测试集

1.6 使用tensorboard

1.7 保存每一轮的训练结果

2. 计算整体的正确率

3. 其他

3.1 train与eval

3.2 使用GPU训练

1. 准备

1.1 使用Cifar10

1.2 item的用法

import torch

a = torch.tensor(3)
print(a)
print(a.item())

tensor(3)
3

1.3 model的搭建

model.py

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear

# 搭建神经网络
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model = nn.Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

# 测试
if __name__ == '__main__':
    myModule = MyModule()
    input = torch.ones((64, 3, 32, 32))
    output = myModule(input)
    print(output.shape)  # torch.Size([64, 10])

1.4 数据集、参数设置以及训练开始

train.py

import torch.optim.optimizer
import torchvision
from model import *

from torch.utils.data import DataLoader

# 1.数据集准备
train_data = torchvision.datasets.CIFAR10('../dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10('../dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
train_data_size = len(train_data)
test_data_size = len(test_data)
# print(train_data_size, test_data_size)  # 50000 10000

# 2.加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 3.创建网络模型
myModule = MyModule()

# 4.损失函数
loss_fn = nn.CrossEntropyLoss()
# 5.优化器
learningRate = 1e-2
optimizer = torch.optim.SGD(myModule.parameters(), lr=learningRate)
# 6.设置训练网络的一些参数
total_train_step = 0  # 记录训练的次数
total_test_step = 0  # 记录测试的次数
epoch = 10  # 记录训练的轮数
for i in range(epoch):
    # 开始训练
    for data in train_dataloader:
        imgs, targets = data
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        print("训练次数: {},loss: {}".format(total_train_step, loss.item()))

Files already downloaded and verified
Files already downloaded and verified
训练次数: 1,loss: 2.291430711746216
训练次数: 2,loss: 2.294950485229492
训练次数: 3,loss: 2.3185925483703613
训练次数: 4,loss: 2.2968363761901855
训练次数: 5,loss: 2.30112886428833
训练次数: 6,loss: 2.3146629333496094
训练次数: 7,loss: 2.3073482513427734
训练次数: 8,loss: 2.3127682209014893

......

1.5 测试集

目的：可以拿测试集来验证模型训练的怎么样了。

train.py

import torch.optim.optimizer
import torchvision
from model import *

from torch.utils.data import DataLoader

# 1.数据集准备
train_data = torchvision.datasets.CIFAR10('../dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10('../dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
train_data_size = len(train_data)
test_data_size = len(test_data)
# print(train_data_size, test_data_size)  # 50000 10000

# 2.加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 3.创建网络模型
myModule = MyModule()

# 4.损失函数
loss_fn = nn.CrossEntropyLoss()
# 5.优化器
learningRate = 1e-2
optimizer = torch.optim.SGD(myModule.parameters(), lr=learningRate)
# 6.设置训练网络的一些参数
total_train_step = 0  # 记录训练的次数
total_test_step = 0  # 记录测试的次数
epoch = 10  # 记录训练的轮数
for i in range(epoch):
    print("-----第{}轮训练开始-----".format(i + 1))
    # 开始训练
    for data in train_dataloader:
        imgs, targets = data
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数: {},loss: {}".format(total_train_step, loss.item()))
    # 测试步骤开始
    # 这一部分没有梯度,不需要再调优参数
    total_test_loss = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = myModule(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
    print("整体测试集上的Loss: {}".format(total_test_loss))

-----第1轮训练开始-----
训练次数: 100,loss: 2.298675060272217
训练次数: 200,loss: 2.285764694213867
训练次数: 300,loss: 2.2791736125946045
训练次数: 400,loss: 2.233513593673706
训练次数: 500,loss: 2.1184940338134766
训练次数: 600,loss: 2.019355297088623
训练次数: 700,loss: 2.0219309329986572
整体测试集上的Loss: 316.859619140625
-----第2轮训练开始-----
训练次数: 800,loss: 1.8966532945632935
训练次数: 900,loss: 1.8539228439331055
训练次数: 1000,loss: 1.9396780729293823
训练次数: 1100,loss: 1.9399535655975342
训练次数: 1200,loss: 1.6813435554504395
训练次数: 1300,loss: 1.6371924877166748
训练次数: 1400,loss: 1.744162678718567
训练次数: 1500,loss: 1.7939480543136597
整体测试集上的Loss: 296.5897216796875

1.6 使用tensorboard

目的：画出Loss曲线，Making sure gradient descent is working correctly. 

train.py

import torch.optim.optimizer
import torchvision
from torch.utils.tensorboard import SummaryWriter

from model import *

from torch.utils.data import DataLoader

# 1.数据集准备
train_data = torchvision.datasets.CIFAR10('../dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10('../dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
train_data_size = len(train_data)
test_data_size = len(test_data)
# print(train_data_size, test_data_size)  # 50000 10000

# 2.加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 3.创建网络模型
myModule = MyModule()

# 4.损失函数
loss_fn = nn.CrossEntropyLoss()
# 5.优化器
learningRate = 1e-2
optimizer = torch.optim.SGD(myModule.parameters(), lr=learningRate)
# 6.设置训练网络的一些参数
total_train_step = 0  # 记录训练的次数
total_test_step = 0  # 记录测试的次数
epoch = 10  # 记录训练的轮数

# 添加tensorboard
writer = SummaryWriter('logs_train')

for i in range(epoch):
    print("-----第{}轮训练开始-----".format(i + 1))
    # 开始训练
    for data in train_dataloader:
        imgs, targets = data
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数: {},loss: {}".format(total_train_step, loss.item()))
            # 画出损失函数
            writer.add_scalar('train_loss', loss.item(), total_train_step)
    # 测试步骤开始
    # 这一部分没有梯度,不需要再调优参数
    total_test_loss = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = myModule(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
    print("整体测试集上的Loss: {}".format(total_test_loss))
    total_test_step = total_test_step + 1
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
writer.close()

1.7 保存每一轮的训练结果：

for i in range(epoch):
    print("-----第{}轮训练开始-----".format(i + 1))
    # 开始训练
    for data in train_dataloader:
        imgs, targets = data
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数: {},loss: {}".format(total_train_step, loss.item()))
            # 画出损失函数
            writer.add_scalar('train_loss', loss.item(), total_train_step)
    # 测试步骤开始
    # 这一部分没有梯度,不需要再调优参数
    total_test_loss = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = myModule(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
    print("整体测试集上的Loss: {}".format(total_test_loss))
    total_test_step = total_test_step + 1
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
    # 保存每一轮训练的结果
    torch.save(myModule, 'myModule_{}.pth'.format(i))
writer.close()

2. 计算整体的正确率

目的：查看训练的网络模型在测试集上的效果。

方法：预测正确的数量/整体的数量。

argmax：可以返回指定维度上最大值的索引。

test.py

import torch

outputs = torch.tensor([
    [0.1, 0.2],
    [0.3, 0.4]
])
# 填1的时候横向看,可以返回指定维度最大值的序号
preds = outputs.argmax(1)
targets = torch.tensor([0, 1])
print(preds == targets)
# 计算对应位置相等的个数
print((preds == targets).sum())

tensor([False,  True])
tensor(1)

for i in range(epoch):
    print("-----第{}轮训练开始-----".format(i + 1))
    # 开始训练
    for data in train_dataloader:
        imgs, targets = data
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数: {},loss: {}".format(total_train_step, loss.item()))
            # 画出损失函数
            writer.add_scalar('train_loss', loss.item(), total_train_step)
    # 测试步骤开始
    # 这一部分没有梯度,不需要再调优参数
    total_test_loss = 0
    total_accuracy = 0  # 整体正确的个数
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = myModule(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy
    print("整体测试集上的Loss: {}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy / test_data_size))
    writer.add_scalar('test_accuracy', total_accuracy / test_data_size, total_test_step)
    total_test_step = total_test_step + 1
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
    # 保存每一轮训练的结果
    torch.save(myModule, './model_save/myModule_{}.pth'.format(i))
writer.close()

Files already downloaded and verified
Files already downloaded and verified
-----第1轮训练开始-----
训练次数: 100,loss: 2.291329860687256
训练次数: 200,loss: 2.2846291065216064
训练次数: 300,loss: 2.2555723190307617
训练次数: 400,loss: 2.145618438720703
训练次数: 500,loss: 2.0252487659454346
训练次数: 600,loss: 2.0127859115600586
训练次数: 700,loss: 1.9800595045089722
整体测试集上的Loss: 307.11065673828125
整体测试集上的正确率：0.2930999994277954
-----第2轮训练开始-----
训练次数: 800,loss: 1.8316386938095093
训练次数: 900,loss: 1.7961711883544922
训练次数: 1000,loss: 1.8935333490371704
训练次数: 1100,loss: 1.9779611825942993
训练次数: 1200,loss: 1.679609775543213
训练次数: 1300,loss: 1.6376134157180786
训练次数: 1400,loss: 1.707167148590088
训练次数: 1500,loss: 1.7555652856826782
整体测试集上的Loss: 292.63409423828125
整体测试集上的正确率：0.3312000036239624
-----第3轮训练开始-----
训练次数: 1600,loss: 1.7143256664276123
训练次数: 1700,loss: 1.6653105020523071
训练次数: 1800,loss: 1.942317247390747
训练次数: 1900,loss: 1.697310209274292
训练次数: 2000,loss: 1.8977160453796387
训练次数: 2100,loss: 1.532772183418274
训练次数: 2200,loss: 1.4647372961044312
训练次数: 2300,loss: 1.7696183919906616
整体测试集上的Loss: 257.3481750488281
整体测试集上的正确率：0.4074999988079071

......

3. 其他

3.1 train与eval

它们对一些网络模型、层是有作用的。

可以这样加入： 

3.2 使用GPU训练

图片来源于：b站up主 我是土堆

方法一：

train_gpu_1.py

import torch.optim.optimizer
import torchvision
from torch.utils.tensorboard import SummaryWriter
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear

from torch.utils.data import DataLoader

# 1.数据集准备
train_data = torchvision.datasets.CIFAR10('../dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10('../dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
train_data_size = len(train_data)
test_data_size = len(test_data)
# print(train_data_size, test_data_size)  # 50000 10000

# 2.加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 3.创建网络模型
# 搭建神经网络
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model = nn.Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

myModule = MyModule()
if torch.cuda.is_available():
    myModule = myModule.cuda()

# 4.损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda()
# 5.优化器
learningRate = 1e-2
optimizer = torch.optim.SGD(myModule.parameters(), lr=learningRate)
# 6.设置训练网络的一些参数
total_train_step = 0  # 记录训练的次数
total_test_step = 0  # 记录测试的次数
epoch = 10  # 记录训练的轮数

# 添加tensorboard
writer = SummaryWriter('logs_train')

for i in range(epoch):
    print("-----第{}轮训练开始-----".format(i + 1))
    # 开始训练
    myModule.train()
    for data in train_dataloader:
        imgs, targets = data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数: {},loss: {}".format(total_train_step, loss.item()))
            # 画出损失函数
            writer.add_scalar('train_loss', loss.item(), total_train_step)
    # 测试步骤开始
    myModule.eval()
    # 这一部分没有梯度,不需要再调优参数
    total_test_loss = 0
    total_accuracy = 0  # 整体正确的个数
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            if torch.cuda.is_available():
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = myModule(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy
    print("整体测试集上的Loss: {}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy / test_data_size))
    writer.add_scalar('test_accuracy', total_accuracy / test_data_size, total_test_step)
    total_test_step = total_test_step + 1
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
    # 保存每一轮训练的结果
    torch.save(myModule, './model_save/myModule_{}.pth'.format(i))
writer.close()

注：访问Google colaboratory， 可以免费使用GPU。

方法二：

import torch.optim.optimizer
import torchvision
from torch.utils.tensorboard import SummaryWriter
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear

from torch.utils.data import DataLoader

# 定义训练的设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 1.数据集准备
train_data = torchvision.datasets.CIFAR10('../dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10('../dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
train_data_size = len(train_data)
test_data_size = len(test_data)
# print(train_data_size, test_data_size)  # 50000 10000

# 2.加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 3.创建网络模型
# 搭建神经网络
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model = nn.Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

myModule = MyModule()
myModule = myModule.to(device)

# 4.损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)
# 5.优化器
learningRate = 1e-2
optimizer = torch.optim.SGD(myModule.parameters(), lr=learningRate)
# 6.设置训练网络的一些参数
total_train_step = 0  # 记录训练的次数
total_test_step = 0  # 记录测试的次数
epoch = 10  # 记录训练的轮数

# 添加tensorboard
writer = SummaryWriter('logs_train')

for i in range(epoch):
    print("-----第{}轮训练开始-----".format(i + 1))
    # 开始训练
    myModule.train()
    for data in train_dataloader:
        imgs, targets = data
        imgs = imgs.to(device)
        targets = targets.to(device)
        outputs = myModule(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        # a.梯度清零
        optimizer.zero_grad()
        loss.backward()  # b.反向传播,拿到梯度
        optimizer.step()  # c.对参数进行优化
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数: {},loss: {}".format(total_train_step, loss.item()))
            # 画出损失函数
            writer.add_scalar('train_loss', loss.item(), total_train_step)
    # 测试步骤开始
    myModule.eval()
    # 这一部分没有梯度,不需要再调优参数
    total_test_loss = 0
    total_accuracy = 0  # 整体正确的个数
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            imgs = imgs.to(device)
            targets = targets.to(device)
            outputs = myModule(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy
    print("整体测试集上的Loss: {}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy / test_data_size))
    writer.add_scalar('test_accuracy', total_accuracy / test_data_size, total_test_step)
    total_test_step = total_test_step + 1
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
    # 保存每一轮训练的结果
    torch.save(myModule, './model_save/myModule_{}.pth'.format(i))
writer.close()

您可能感兴趣的与本文相关的镜像

PyTorch 2.8

PyTorch 2.8

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

Pytorch深度学习-----完整神经网络模型训练套路
LGL
08-12 1664
定义适当的损失函数来计算模型预测结果于真实标签之间的差异。选择适当的优化器算法来更新模型参数，如随机梯度下降（SGD）、Adam等。使用torchvision库加载CIFAR10数据集。将训练集和测试集分别存放在train_data和test_data中。引用model.py文件，在其中创建名为"Lgl"的模型。定义损失函数为交叉熵损失（nn.CrossEntropyLoss）。定义优化器为随机梯度下降（SGD）优化器，并将模型参数传递给优化器。
Pytorch深度学习-----完整的模型验证套路
LGL
12-31 1354
return xLgl类定义了一个CNN，包含三个卷积层，接着是最大池化、展平操作以及两个线性层。该模型设计用于图像分类。
【Pytorch】训练模型
aaon22357的博客
01-14 8844
文章目录一、训练完整流程二、高阶操作1.自定义学习率2. 只训练特定的网络层3. 逐层释放/冻结网络参数4.恢复优化器状态时参数不match的解决方案5. 梯度反传，loss反传，梯度裁剪三、恢复保存的优化器状态，继续优化四、加载模型到指定的卡上 一、训练完整流程 使用Pytorch训练神经网络的一般流程为（伪代码，许多功能需要自己实现，这里只列出了流程）： import torch import...
PyTorch 模型训练实用教程（附代码及原文下载）
12-20
自 2017 年 1 月 PyTorch 推出以来，其热度持续上升，一度有赶超 TensorFlow 的趋势。PyTorch 能在短时间内被众多研究人员和工程师接受并推崇是因为其有着诸多优点，如采用 Python 语言、动态图机制、网络构建灵活以及拥有强大的社群等。因此，走上学习 PyTorch 的道路已刻不容缓。 本教程以实际应用、工程开发为目的，着重介绍模型训练过程中遇到的实际问题和方法。如上图所示，在机器学习模型开发中，主要涉及三大部分，分别是数据、模型和损失函数及优化器。本文也按顺序的依次介绍数据、模型和损失函数及优化器，从而给大家带来清晰的机器学习结构。
Pytorch学习（训练模型、网络、Transformer模型、UNet网络）
最新发布
警警的博客
10-17 1031
PyTorch是一个灵活易用的深度学习框架，其核心架构包含四层：基础计算层（支持GPU加速的张量运算）、自动微分层（动态计算图实现自动梯度计算）、神经网络层（提供各种网络模块和优化器）以及工具生态层（数据加载和可视化）。PyTorch凭借动态计算图、Python化的开发体验和强大的调试能力，成为学术研究的主流选择。通过简单的线性回归示例展示了PyTorch的工作流程：模型定义、损失函数设置、训练循环和预测。建议从张量基础开始，逐步掌握自动微分原理，最终深入专业领域应用。
从零开始Pytorch深度学习-完整的训练过程
weixin_43507744的博客
05-24 3037
数据封装 1.先获取训练集和验证集的图片图片路径（放在列表里面）、对应标签 其文件路径如图1所示 图1 代码如下： train_images_path, train_images_label, val_images_path, val_images_label = read_split_data(args.data_path) read_split_data（）函数的定义如下： def read_split_data(root: str, val_rate: float ...
Pytorch模型训练（一）
hello.reader
09-05 1163
构建一个适合任务的神经网络模型至关重要。这里我们定义一个卷积神经网络（CNN），它能够有效地处理图像数据。# 第一个卷积层：输入为1个通道，输出为32个特征图，卷积核大小为3x3# 第二个卷积层：输入为32个通道，输出为64个特征图，卷积核大小为3x3# 最大池化层：池化窗口为2x2# 全连接层1：输入为64*7*7个节点，输出为128个节点# 全连接层2：输入为128个节点，输出为64个节点# 输出层：输入为64个节点，输出为10个类别# 前向传播，依次通过卷积层、激活函数、池化层、全连接层。
pytorch-模型训练
wyw0000的博客
06-27 1992
pytorch 模型训练
pytorch -- CIFAR10 完整的模型训练套路
斑驳的岁月
02-26 756
【代码】pytorch -- CIFAR10 完整的模型训练套路。
Pytorch 完整的模型训练套路
别下完这场雪
02-16 2302
Pytorch 完整的模型训练套路 model.py import torch from torch import nn # 搭建神经网络 class Model(nn.Module): def __init__(self) -> None: super().__init__() self.model = nn.Sequential( nn.Conv2d(3, 32, 5, 1, 2), nn.MaxPool2
[pytorch]完整的模型训练套路&&完整的模型验证(测试、demo)套路
m0_51955470的博客
05-09 720
【代码】[pytorch]完整的模型训练套路。
PyTorch模型训练最新实用教程 (余霆嵩) PDF版
12-24
本教程以实际应用、工程开发为目的，着重介绍模型训练过程中遇到的实际问题和方法。如上图所示，在机器学习模型开发中，主要涉及三大部分，分别是数据、模型和损失函数及优化器。本文也按顺序的依次介绍数据、模型和损失函数及优化器，从而给大家带来清晰的机器学习结构。 本教程内容主要为在 PyTorch 中训练一个模型所可能涉及到的方法及函数，并且对 PyTorch 提供的数据增强方法（22 个）、权值初始化方法（10 个）、损失函数（17 个）、优化器（6 个）及 tensorboardX 的方法（13 个）进行了详细介绍。 本教程分为四章，结构与机器学习三大部分一致： 第一章，介绍数据的划分，预处理，数据增强； 第二章，介绍模型的定义，权值初始化，模型 Finetune； 第三章，介绍各种损失函数及优化器； 第四章，介绍可视化工具，用于监控数据、模型权及损失函数的变化。
Pytorch 模型训练步骤
知识搬运者
11-29 8165
目录 1、导入必要库 2、加载数据 3、训练模型 4、保存模型参数 1）、仅仅保存和加载模型参数 2）、保存和加载整个模型 1、导入必要库 import torch from torch import optim, nn import torch.utils.data as Data 2、加载数据 x = torch.linspace(1, 10, 10) # x data (torch tensor) y = torch.linspace......
机器学习----PyTorch模型训练
bjsyc123456的博客
05-18 1824
PyTorch 在前面使用纯手工做了线性回归，线性回归的问题其实就是求解损失函数最小的情况下的w值。 在PyTorch里面很多的函数都进行了封装，我们直接用就可以。 损失函数 手写损失函数 def loss(y, y_pred): """损失函数""" # (真实值 - 预测值)^2 的平均值 return ((y_pred - y)**2).mean() PyTorch封装的损失函数 损失函数就是计算 （预测值-真实值）^2的平均值 （均方误差） torch.nn.MSELoss()方
手把手教你用PyTorch从零训练自己的大模型（非常详细）零基础入门到精通，收藏这一篇就够了
Python_0011的博客
07-09 6351
长按关注《AI科技论谈》LLM是如今大多数AI聊天机器人的核心基础，例如ChatGPT、Gemini、MetaAI、Mistral AI等。这些LLM背后的核心是Transformer架构。本文介绍如何一步步使用PyTorch从零开始构建和训练一个大型语言模型（LLM）。该模型以Transformer架构为基础，实现英文到马来语的翻译功能，同时也适用于其他语言翻译任务。
pytorch模型训练
rosefun96的博客
01-01 429
1.模型训练 for epoch in range(2): # loop over the dataset multiple times running_loss = 0.0 for i, data in enumerate(trainloader, 0): # get the inputs; data is a list of [inputs, labels]...
pytorch模型训练全过程
qq_42202395的博客
07-14 4077
pytorch模型训练全过程
Pytorch模型训练&保存/加载（搭建完整流程）
热门推荐
`or 1 or 不正经の泡泡
01-27 3万+
文章目录前言模型训练完整步骤模型保存与加载GPU训练“借鸡生蛋“模型使用 本博文优先在掘金社区发布！ 前言 我们这边还是以CIARF10这个模型为例子。 现在的话先说明一下，关于CIARF10的一个输出 这个是一个十分类的模型，所以输出结果是一个矩阵一个tensor其中它的shape是你的(batch_size,10)这样的结果。假设你的batch_size = 1 那么你得到的结果应该是[[1,2,3,4,5,6,7,8,9,10]]这种类型的。你的输入的标签是这样的[ 9 ] 所以，如果你想要判断你的结
PyTorch：模型训练、评估和预测
皮皮blog
10-21 1万+
模型训练、评估和预测。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值