
from torch.utils.tensorboard import SummaryWriter
 
writer = SummaryWriter('logs')
 
for i in range(100):
    writer.add_scalar('y=x', i, i)  # 注意这里的add_scalar后面没有s
    # add_scalar中的tag表示标题，scalar_value表示y轴，global_step表示x轴
writer.close()

然后在Terminal中输入tensorboard --logdir=logs,这里默认打开的是6006的端口，一般我们会自己指定端口

tensorboard --logdir=logs --port=6007

torchvision的一般用法：

归一化的介绍：

Normalize中的参数设置：mean表示均值， std表示标准差


# Compose
trans_resize_2 = transforms.Resize(512)
trans_compose = transforms.Compose([trans_resize_2, trans_totensor])
# 执行顺序：先执行一个resize的变换，再进行totensor的变换
# 后面这个参数的 输入 跟前面那个参数的 输出 要进行匹配的

dataloader的用法


import torchvision
 
from torch.utils.data import DataLoader
 
# 准备的测试数据集
test_data = torchvision.datasets.CIFAR10('./dataset02', train=False, transform=torchvision.transforms.ToTensor())
# batch_size 每次取出多少的图片
test_loader = DataLoader(dataset=test_data, batch_size=4, shuffle=True, num_workers=0, drop_last=False)
 
# 测试数据集中第一张图片以及target
img, target = test_data[0]
print(img.shape)
print(target)
 
print('-------------------------')
for data in test_loader:
    imgs, targets = data
    print(imgs.shape)
    print(targets)

前向传播：简单来说就是input 经过一个forward，然后有一个output


from torch import nn
import torch
 
 
class ZWY(nn.Module):  # 每一次都要重写这两个方法
    def __init__(self):
        super(ZWY, self).__init__()  # 调用父类中的方法，也可以写成 super().__init__
 
    def forward(self, input):
        output = input + 1
        return output
 
 
zwy = ZWY()
x = torch.tensor(1.0)
output = zwy(x)  # 这就是一个简单的前向传播
print(output)

卷积操作

当stride=1时，卷积核一个单位一个单位地移动

输入图像（5x5）和卷积核（3x3）对应位置的数字相乘然后相加之和等于输出

这里以二维卷积举例

这里，torch.nn相当于torch.nn.functional的一个封装，其实只需要了解torch.nn的用法就行了

下面的这个是torch.nn.functional


import torch.nn.functional as F
output = F.conv2d(input, kernel, stride=1)  # stride可以是一个int也可以是一个元组，表示每次匹配后横向和纵向的移动距离

torch.nn(要求掌握)

填充的padding默认是0

kernel_size,只需要定义它的大小就行了，因为在训练当中，会不断调整kernel里的值

这张图片的重点在于in_channels和out_channels

当in_channels和out_channels都设置为1的时候如下图

当输入图像的in_channels设置为1，out_channels设置为2，那么就会生成两个不同的卷积核，分别对输入图像进行卷积，得到两个不同的输出图像，然后最终把这两个输出图像叠加起来进行输出

池化层

个最常用的是nn.MaxPool2d

使用的时候可以设置kernel_size，还有floor(向下取整)和ceiling（向上取整），但是要注意的是，这里的stride默认的大小是kernel_size

非线性激活

kernel_size

relu,当input大于等于0的时候，取本身，当小于0的时候就取0

sigmoid

这里的N指batch_size


class ZWY(nn.Module):
    def __init__(self):
        super(ZWY, self).__init__()
        self.relu1 = ReLU()  # inplace ：是否替换原来的值   如果input=-1,当True，那么input = 0, 当False，那么input=-1不变，output=0
        # 一般设置为False
        self.sigmoid1 = Sigmoid()
 
    def forward(self, input):
        # output = self.relu1(input)
        # return output
        output = self.sigmoid1(input)
        return output

input

output

非线性变换的主要目的：

引入一些非线性特征，因为非线性引入得多，才能训练出符合各种曲线的模型

线性层

官方文档


import torch
import torchvision.datasets
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader
 
dataset = torchvision.datasets.CIFAR10('../data', train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
 
dataloader = DataLoader(dataset, 64)
 
 
class ZWY(nn.Module):
    def __init__(self):
        super(ZWY, self).__init__()
        self.linear1 = Linear(196608, 10)
 
    def forward(self, input):
        output = self.linear1(input)
        return output
 
 
zwy = ZWY()
for data in dataloader:
    imgs, targets = data
    print(imgs.shape)
    output = torch.reshape(imgs, (1, 1, 1, -1))  # torch.reshape()的参数:在imgs后面的小括号里面分别是batchsize, channel, high, wide
    # 上面这一行也可以用下面这一行代替
    # output = torch.flatten(imgs)  # 平坦成一行
    print(output.shape)
    output = zwy(output) # 前向传播，重点
    print(output.shape)

输出结果

输入层in_features = 196608，经过线性层把它转换成out_features = 10

如果不想自己搭建模型，也可以使用别人已经搭建好了的模型，在Torchvision（图像方面）版本可以选择0.9.0，然后再选择torchvision.model，就可以了

Sequential的作用：把步骤结合起来运行，简化代码


import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
 
 
class ZWY(nn.Module):
    def __init__(self):
        super(ZWY, self).__init__()
        # self.conv1 = Conv2d(3, 32, 5, padding=2)  # padding是根据官方文档里面的ConV2d的公式计算得到的（因为要保证输入和输出的尺寸都是32）
        # self.maxpool1 = MaxPool2d(2)
        # self.conv2 = Conv2d(32, 32, 5, padding=2)
        # self.maxpool2 = MaxPool2d(2)
        # self.conv3 = Conv2d(32, 64, 5, padding=2)
        # self.maxpool3 = MaxPool2d(2)
        # self.flatten = Flatten()
        # self.linear1 = Linear(1024, 64)
        # self.linear2 = Linear(64, 10)
 
        # 下面的这个sequential,是把这些步骤结合起来运行，简化代码，用完之后在forward中调用这个方法就行了
        self.model1 = 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.conv1(x)
        # x = self.maxpool1(x)
        # x = self.conv2(x)
        # x = self.maxpool2(x)
        # x = self.conv3(x)
        # x = self.maxpool3(x)
        # x = self.flatten(x)
        # x = self.linear1(x)
        # x = self.linear2(x)
        # # 调用的方法如下
        x = self.model1(x)
 
        return x

损失函数

作用

1、计算实际输出与目标之间的差距

运用文档提供的数学公式进行计算。

2、为我们更新输出提供一定的依据（反向传播）

卷积核当中的参数就是我们需要调优的，我们需要根据反向传播算出每一个参数对应的梯度，然后使用优化器根据这些梯度对参数进行一个优化，达到让loss值降低的目的。

梯度下降法

下面我用L1loss来举例

MSELOSS

平方差，用法和L1loss一样只是公式是不一样的，而且用法也挺简单的，这里就不多说

交叉熵

对于c个类别的分类问题有用

上面的这个线性图是四个输出，这里我们把它看作是3个输出，分别对应3个不同的类别（person, dog, cat）

其中x指那个列表，里面的数字分别表示预测person,dog,cat的概率，因为此处要预测出的是dog，而且要使得loss变小，就要让output中的最大数字对应的索引是target中的数字，这样，-x[class]的绝对值变得很大，然后后面的log这一块，要使它变小，所以就是对于person,dog,cat这些的预测概率都不应该很大，像什么0.8，0.9这种，应该是要预测出的那个很大像0.9，但是其他的很小，像0.2这种

C，代表分类的类别

N：batch_size


x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))
loss_crose = nn.CrossEntropyLoss()
result_cross = loss_crose(x, y)
print(result_cross)

如果要进行反向传播的话，就直接对损失函数使用 .backward()

例如 result_cross.backward()

优化器

先构造优化器

调用优化器的step方法：利用梯度对卷积核当中的参数进行更新

记住：每一次更新完后都要对梯度进行一个清零操作，即上图中蓝色的部分

学习速率设置得不能太大，这样模型训练起来就很不稳定，设置太小训练又会很慢

如何利用现有的网络，去改变它的结构

这里以vgg16来举例，它的输出是1000类，现在我们要把它变成10类


import torchvision
from torch import nn
 
# train_data = torchvision.datasets.ImageNet('data_image_net', split='train', download=True,
#                                            transform=torchvision.transforms.ToTensor())
# 上面的这个数据集太大了，有大概100多个G，所以这边就不建议下载了
vgg16_false = torchvision.models.vgg16(pretrained=False)  # 网络架构中的参数都是默认的
vgg16_true = torchvision.models.vgg16(pretrained=True)  # 网络架构中的参数是在数据集上训练好了的
print(vgg16_true)  # vgg16的网络架构
 
train_data = torchvision.datasets.CIFAR10('../data', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
# vgg16_true.add_module('add_linear', nn.Linear(1000, 10))
# print(vgg16_true)
# 如果想要加到classifier里面，就进行下面的操作就可以了
vgg16_true.classifier.add_module('add_linear1', nn.Linear(1000, 10))
print(vgg16_true)
 
# 修改网络
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)
print(vgg16_false)

模型保存方式


import torchvision
import torch
from torch import nn
 
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1   这种方式不仅可以保存网络模型的结构，而且还可以保存参数
torch.save(vgg16, 'vgg16_method1.pth')  # 第二个参数是保存的路径
 
# 保存方式2（官方推荐）  不再保存网络模型的结构了，但是会保存网络模型的参数（保存成字典）
torch.save(vgg16.state_dict(), 'vgg16_method2.pth')
 
 
#  陷阱的演示
class ZWY(nn.Module):
    def __init__(self):
        super(ZWY, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, 3)
 
    def forward(self, x):
        x = self.conv1(x)
        return x
 
 
zwy = ZWY()
torch.save(zwy, 'zwy_method.pth')

陷阱是，当我们在加载这个模型的时候，前面必须要把那个网络结构（即class ZWY）写过来，或者导入过来才可以，否则会报错.

加载模型的代码是

model = torch.load('zwy_method.pth')

完整的模型训练代码

model模块


# 搭建神经网络
import torch
from torch import nn
 
 
class ZWY(nn.Module):
    def __init__(self):
        super(ZWY, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10)
        )
 
    def forward(self, x):
        x = self.model(x)
        return x
 
 
if __name__ == '__main__':
    zwy = ZWY()
    input = torch.ones((64, 3, 32, 32))
    output = zwy(input)
    print(output.shape)  # 输出的torch.Size([64, 10])中，表示返回64行数据，每一行数据上有10个数据，这10个数据表示每一张图片在10个类别当中的一个预测概率

大体流程（使用CPU训练）


# 想看类别就在  test_data 那里打断点，然后debug，看class_to_idx就行
import torch
import torchvision
from torch import nn
from torch.utils.tensorboard import SummaryWriter
 
from model import *
import time
# 准备数据集
from torch.utils.data import DataLoader
 
# CIFAR10有10种类别
train_data = torchvision.datasets.CIFAR10(root='../data', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='../data', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
# 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print('训练集的长度是：{}'.format(train_data_size))
print('测试集的长度是：{}'.format(test_data_size))
 
# 利用DataLoader来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
 
# 创建网络模型
zwy = ZWY()
 
# 损失函数
loss_fn = nn.CrossEntropyLoss()
 
# 优化器
learning_rate = 0.01
# 也可以写成：learning_rate = 1e-2, 1e-2 = 1 x (10)^(-2) = 0.01
optimizer = torch.optim.SGD(zwy.parameters(), lr=learning_rate)
 
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
 
# 添加tensorboard
writer = SummaryWriter('logs_train')
start_time = time.time()
for i in range(epoch):
    print('----------第{}轮训练开始----------'.format(i + 1))
    # 训练步骤开始
    zwy.train()
    for data in train_dataloader:
        imgs, targets = data
        outputs = zwy(imgs)
        loss = loss_fn(outputs, targets)
 
        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
 
        total_train_step += 1
        if total_train_step % 100 == 0:
            end_time = time.time()
            print(end_time - start_time)
            print('训练次数：{}， Loss：{}'.format(total_train_step, loss))
            # print('训练次数：{}， Loss：{}'.format(total_train_step, loss.item()))
            # 也可以像上面这样子写
            # 举个例子
            # a = torch.tensor(5)
            # print(a)     # 输出tensor(5)
            # print(a.item()) # 输出 5
            writer.add_scalar('train_loss', loss.item(), total_train_step)  # 添加标量
 
    # 测试步骤开始
    # 在测试的过程中就不需要对模型进行调优了
    zwy.eval()
    total_accuracy = 0
    total_test_loss = 0
    with torch.no_grad():  # 保证不会对他进行一个调优
        for data in test_dataloader:
            imgs, targets = data
            outputs = zwy(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss += loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()  # argmax(1):横向（从左到右）取最大数对应的索引
            total_accuracy += accuracy                       # argmax(0):纵向（从上到下）取最大数对应的索引
    print('整体测试集上的Loss：{}'.format(total_test_loss))
    print('整体测试集上的正确率：{}'.format(total_accuracy / test_data_size))
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
    writer.add_scalar('test_accuracy', total_accuracy / test_data_size, total_test_step)
    total_test_step += 1
    torch.save(zwy, 'zwy{}.pth'.format(i))
    print('模型已保存')
writer.close()

使用GPU训练1

将网络模型、数据（输入，标注）、损失函数调用.cuda(),然后返回就行了


# 如何训练gpu
 
# 将网络模型、数据（输入，标注）、损失函数调用.cuda(),然后返回就行了
 
import torch
import torchvision
from torch import nn
from torch.utils.tensorboard import SummaryWriter
 
from model import *
import time
# 准备数据集
from torch.utils.data import DataLoader
 
# CIFAR10有10种类别
train_data = torchvision.datasets.CIFAR10(root='../data', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='../data', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
# 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print('训练集的长度是：{}'.format(train_data_size))
print('测试集的长度是：{}'.format(test_data_size))
 
# 利用DataLoader来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
 
# 创建网络模型
zwy = ZWY()
if torch.cuda.is_available():
    zwy = zwy.cuda()
 
# 损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda()
# 优化器
learning_rate = 0.01
# 也可以写成：learning_rate = 1e-2, 1e-2 = 1 x (10)^(-2) = 0.01
optimizer = torch.optim.SGD(zwy.parameters(), lr=learning_rate)
 
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
 
# 添加tensorboard
writer = SummaryWriter('logs_train')
start_time = time.time()
for i in range(epoch):
    print('----------第{}轮训练开始----------'.format(i + 1))
    # 训练步骤开始
    zwy.train()
    for data in train_dataloader:
        imgs, targets = data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = zwy(imgs)
        loss = loss_fn(outputs, targets)
 
        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
 
        total_train_step += 1
        if total_train_step % 100 == 0:
            end_time = time.time()
            print(end_time - start_time)
            print('训练次数：{}， Loss：{}'.format(total_train_step, loss))
            # print('训练次数：{}， Loss：{}'.format(total_train_step, loss.item()))
            # 也可以像上面这样子写
            # 举个例子
            # a = torch.tensor(5)
            # print(a)     # 输出tensor(5)
            # print(a.item()) # 输出 5
            writer.add_scalar('train_loss', loss.item(), total_train_step)  # 添加标量
 
    # 测试步骤开始
    # 在测试的过程中就不需要对模型进行调优了
    zwy.eval()
    total_accuracy = 0
    total_test_loss = 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 = zwy(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss += loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()  # argmax(1):横向（从左到右）取最大数对应的索引
            total_accuracy += accuracy  # argmax(0):纵向（从上到下）取最大数对应的索引
    print('整体测试集上的Loss：{}'.format(total_test_loss))
    print('整体测试集上的正确率：{}'.format(total_accuracy / test_data_size))
    writer.add_scalar('test_loss', total_test_loss, total_test_step)
    writer.add_scalar('test_accuracy', total_accuracy / test_data_size, total_test_step)
    total_test_step += 1
    torch.save(zwy, 'zwy{}.pth'.format(i))
    print('模型已保存')
writer.close()

使用GPU训练2

# 只有数据、图片、标注需要赋值像这样imgs = imgs.to(device)
# 损失函数、网络模型就这样就好,不需要赋值： tudui.to(device)
# 方式2是比较常用的方式

# 使用方法
# .to(device)
# device = torch.device('cpu') # 括号里面也可以写cuda,表示使用gpu

完结

注：本文由b站上up主们的一些视频截图以及自己平时的积累组成。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/949403