2021-11-13

2024-01-09 21:19:22

DAY 3-4 完结

1.一些简单损失函数的调用
损失函数loss的作用
1.计算实际输出和目标之间的差距
2.为我们更新输出提供一定的依据（反向传播）, grad

import torch
from torch.nn import L1Loss
from torch import nn


# 损失函数loss的作用
# 1.计算实际输出和目标之间的差距
# 2.为我们更新输出提供一定的依据（反向传播）, grad
inputs = torch.tensor([1,2,3] , dtype=torch.float32)
targets = torch.tensor([1,2,5] , dtype=torch.float32)

# reshape成 batchsize：1 ， channels：1 ，行数：1 ，列数： 1
inputs = torch.reshape(inputs , (1, 1,1,3) )
targets = torch.reshape(targets , (1,1,1,3))

# L1Loss()是对应位相减，然后结果取平均
loss = L1Loss()
result = loss(inputs , targets)
print(result)

# MSE 平方差损失函数
# MSE = （0 + 0 +2^2）/3 = 1.333
loss_mse = nn.MSELoss()
result_mse = loss_mse(inputs , targets)
print(result_mse)

# 交叉熵CrossEntropyLoss ， 用于分类问题中
x = torch.tensor([0.1 , 0.2 , 0.3])
y = torch.tensor([1])
x = torch.reshape(x , [1,3])
loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(x , y)
print(result_cross)

2.在网络中加入损失函数

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Linear, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("dataseset_CIFAR10" , train=False , transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset , batch_size=1)


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        # self.conv1 = Conv2d(3 , 32 , 5, stride=1 , padding=2)
        # 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.linear1 = Linear(1024 , 64)
        # # 隐藏层到输出层
        # self.linear2 = Linear(64 , 10)
        # self.flatten = Flatten()

        # 引入一个Sequential,将做的操作打包成model1，以便下面使用
        # 下面这段代码和上面注释的代码作用相同
        self.model1 = Sequential(Conv2d(3 , 32 , 5, stride=1 , 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

# 在网络中加入损失函数
loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    imgs , targets = data
    outputs = tudui(imgs)
    result_loss = loss(outputs , targets)
    result_loss.backward()
    print("ok")

result_loss = loss(outputs , targets)
参数是实际结果与目标结果
result_loss.backward()
然后反向传播一下

3.优化器

# 定义一个优化器 ， 学习速率lr设为 0.01
optim = torch.optim.SGD(tudui.parameters() , lr=0.01)
然后注意将每次循环的梯度清零，因为之前的梯度对现在没用```

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Linear, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10(“dataseset_CIFAR10” , train=False , transform=torchvision.transforms.ToTensor(),
download=True)
dataloader = DataLoader(dataset , batch_size=1)

class Tudui(nn.Module):
def init(self):
super(Tudui, self).init()
# self.conv1 = Conv2d(3 , 32 , 5, stride=1 , padding=2)
# 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.linear1 = Linear(1024 , 64)
# # 隐藏层到输出层
# self.linear2 = Linear(64 , 10)
# self.flatten = Flatten()

    # 引入一个Sequential,将做的操作打包成model1，以便下面使用
    # 下面这段代码和上面注释的代码作用相同
    self.model1 = Sequential(Conv2d(3 , 32 , 5, stride=1 , 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

loss = nn.CrossEntropyLoss()
tudui = Tudui()

定义一个优化器，学习速率lr设为 0.01

optim = torch.optim.SGD(tudui.parameters() , lr=0.01)
for epoch in range(20):
running_loss = 0.0
for data in dataloader:
imgs , targets = data
outputs = tudui(imgs)
result_loss = loss(outputs , targets)
# 将梯度清零，因为之前的梯度对现在没用
optim.zero_grad()
# 将梯度反向传播
result_loss.backward()
optim.step()
running_loss = running_loss + result_loss
print(running_loss)

***4.下载训练好和没训练的模型***

import torchvision

# False是没训练的网络模型

from torch import nn

现有模型的使用和修改

vgg16_false = torchvision.models.vgg16(pretrained=False , progress=True)

# True是训练好的网络模型

vgg16_true = torchvision.models.vgg16(pretrained=True , progress=True)
print(vgg16_true)

train_data = torchvision.datasets.CIFAR10(“dataseset_CIFAR10” , train=True , transform=torchvision.transforms.ToTensor(),
download=True)

在网络模型的classifier里添加一个线性层

因为CIFAR10输出的features是10 ，而vgg16最后输出的features是1000 ，所以需要转换一下

vgg16_true.classifier.add_module(‘7’ , nn.Linear(1000 , 10))
vgg16_false.classifier.add_module(‘7’ , nn.Linear(1000 , 10))
print(vgg16_true)

在现有模型中改动

vgg16_true.classifier.add_module(‘7’ , nn.Linear(1000 , 10))


***5.模型的两种保存方式***

import torch
import torchvision
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 Tudui(nn.Module):
def init(self):
super(Tudui , self).init()
self.conv1 = nn.Conv2d(3 , 64 ,kernel_size=3)

def _slow_forward(self, x):
    x = self.conv1(x)
    return x

tudui = Tudui()
torch.save(tudui , “tudui_method1.pth”)

***6.两种保存方式对应的加载模型方式***

import torch
from torch import nn

方式1 —》保存方式1 ，加载模型

import torchvision.models

model = torch.load(“vgg16_method1.pth”)
print(model)

方式2 加载模型

vgg16 =torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load(“vgg16_method2.pth”))

陷阱1：是运行不出来的需要#注释部分仅仅省略了##部分

class Tudui(nn.Module):

def init(self):

super(Tudui , self).init()

self.conv1 = nn.Conv2d(3 , 64 ,kernel_size=3)

def _slow_forward(self, x):

x = self.conv1(x)

return x

#tudui = Tudui()

model = torch.load(‘tudui_method1.pth’)
print(model)

***8.一个完整的用cpu训练的模型***

import torch
from torch import nn

方式1 —》保存方式1 ，加载模型

import torchvision.models

model = torch.load(“vgg16_method1.pth”)
print(model)

方式2 加载模型

vgg16 =torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load(“vgg16_method2.pth”))

陷阱1：是运行不出来的需要#注释部分仅仅省略了##部分

class Tudui(nn.Module):

def init(self):

super(Tudui , self).init()

self.conv1 = nn.Conv2d(3 , 64 ,kernel_size=3)

def _slow_forward(self, x):

x = self.conv1(x)

return x

#tudui = Tudui()

model = torch.load(‘tudui_method1.pth’)
print(model)

**9.一个完整的用gpu训练的模型**

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time

#可以用cuda训练的东西

网络模型

数据（输入，标注）

损失函数

.cuda()

准备数据集

train_data = torchvision.datasets.CIFAR10(“dataseset_CIFAR10”,train=True ,transform=torchvision.transforms.ToTensor(),
download=True)
test_data = torchvision.datasets.CIFAR10(“dataseset_CIFAR10”,train=False ,transform=torchvision.transforms.ToTensor(),
download=True)

length 长度

train_data_size = len(train_data)
test_data_size = len(test_data)
print(“训练数据集长度为：{}”.format(train_data_size))
print(“测试数据集长度为：{}”.format(test_data_size))

利用DataLoader来加载数据集

train_data = DataLoader(train_data , batch_size=64)
test_data = DataLoader(test_data , batch_size=64)

搭建神经网络

class Tudui(nn.Module):
def init(self):
super(Tudui, self).init()
self.model = nn.Sequential(
nn.Conv2d(3,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,64,5,1,2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(1024,64),
nn.Linear(64,10)
)

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

创建网络模型

tudui = Tudui()
tudui = tudui.cuda()

损失函数

loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.cuda()

优化器

learning_rate = 0.01
optimizer = torch.optim.SGD(tudui.parameters(),lr=learning_rate,)

设置训练网络的一些参数

记录训练的次数

total_train_step = 0

记录测试的次数

total_test_step = 0

训练的轮数

epoch = 10

添加Tensorboard

writer = SummaryWriter(“logs”)
start_time = time.time()

for i in range(epoch):
print("------第{}轮训练开始了----".format(i+1))

# 训练步骤开始
tudui.train() #这一行代码对一些特定的网络层有用，如dropout
for data in train_data:
    imgs , targets = data
    imgs = imgs.cuda()
    targets = targets.cuda()
    outputs = tudui(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("第{}轮训练时间是：{}".format(total_train_step, end_time - start_time ))
        print("训练次数：{}，Loss：{}".format(total_train_step , loss))
        writer.add_scalar("train_loss" , loss.item(),total_train_step)

#     测试步骤开始
tudui.eval() #同理，对一些特定的层有用
total_test_loss = 0
with torch.no_grad():

即不需要调优

    for data in test_data:
        imgs , targets = data
        imgs = imgs.cuda()
        targets = targets.cuda()
        outputs = tudui(imgs)
        loss = loss_fn(outputs , targets)
        total_test_loss += loss.item()
print("整体测试集上的Loss：{}".format(total_test_loss))
writer.add_scalar("test_loss",total_test_loss,total_test_step)
total_test_step += 1

模型的保存

torch.save(tudui,"tudui_{}_gpu.pth".format(i))
print("模型已保存")

total_end_time = time.time()
print(“总训练时间是：{}”.format( total_end_time - start_time))

writer.close()

***10.模型的测试***

import torch
import torchvision.transforms
from PIL import Image
from torch import nn

image_path = “imgs/dog.png”
image = Image.open(image_path)
print(image)
image = image.convert(‘RGB’)

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)

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

加载训练好的模型

model = torch.load(“tudui_9_gpu.pth”,map_location= torch.device(‘cpu’))
print(model)
image = torch.reshape(image , (1,3,32,32))
model.eval()
with torch.no_grad():
output = model(image)
print(output)
print(output.argmax(1))

码农公寓

DAY 3-4 完结

定义一个优化器 ， 学习速率lr设为 0.01

# False是没训练的网络模型

现有模型的使用和修改

# True是训练好的网络模型

在网络模型的classifier里添加一个线性层

因为CIFAR10输出的features是10 ， 而vgg16最后输出的features是1000 ， 所以需要转换一下

保存方式1–模型结构+模型参数

保存方式2–模型参数（官方推荐）

把参数保存成字典

陷阱

方式1 —》 保存方式1 ， 加载模型

方式2 加载模型

陷阱1： 是运行不出来的 需要#注释部分 仅仅省略了##部分

class Tudui(nn.Module):

def init(self):

super(Tudui , self).init()

self.conv1 = nn.Conv2d(3 , 64 ,kernel_size=3)

def _slow_forward(self, x):

x = self.conv1(x)

return x

#tudui = Tudui()

方式1 —》 保存方式1 ， 加载模型

方式2 加载模型

陷阱1： 是运行不出来的 需要#注释部分 仅仅省略了##部分

class Tudui(nn.Module):

def init(self):

super(Tudui , self).init()

self.conv1 = nn.Conv2d(3 , 64 ,kernel_size=3)

def _slow_forward(self, x):

x = self.conv1(x)

return x

#tudui = Tudui()

网络模型

数据（输入，标注）

损失函数

.cuda()

准备数据集

length 长度

利用DataLoader来加载数据集

搭建神经网络

创建网络模型

损失函数

优化器

设置训练网络的一些参数

记录训练的次数

记录测试的次数

训练的轮数

添加Tensorboard

即不需要调优

模型的保存

加载训练好的模型

相关文章

定义一个优化器，学习速率lr设为 0.01

因为CIFAR10输出的features是10 ，而vgg16最后输出的features是1000 ，所以需要转换一下

方式1 —》保存方式1 ，加载模型

陷阱1：是运行不出来的需要#注释部分仅仅省略了##部分

方式1 —》保存方式1 ，加载模型

陷阱1：是运行不出来的需要#注释部分仅仅省略了##部分