pytorch实战（正在更新）

本文参照多个视频，

首先见B站刘二大人的《PyTorch深度学习实践》完结合集。所有代码作者亲测

进入刘二大人视频课程

首先初步使用torch.tensor

import torch
import numpy as np
#直接把List放进去
x = torch.tensor([[1,-1],[-1,1]])
#把numpy矩阵放进from_numpy函数中
x = torch.from_numpy(np.array([[1,-1],[-1,1]]))

#产生一个全零tensor（二维）
x = torch.zeros([2,2])
#产生一个全一tensor（三维）
x = torch.ones([1,2,5])
x = torch.tensor([[1,-1],[-1,1]])

x = x.unsqueeze(1)

#把两个维度对调，当只有两维的矩阵对调时即求转置
x = torch.zeros([2,1,3])
y = torch.zeros([2,3,3])
z = torch.zeros([2,2,3])
w = torch.cat([x,y,z],dim = 1)

x = torch.tensor([[1.,0.],[-1.,1.]],requires_grad=True)
#Loss计算公式（构建计算图），这是前馈过程Forward
z = x.pow(2).sum()
#反向传播backward，计算各个梯度
z.backward()
#读出x的梯度
print(x.grad)

实现梯度下降

import numpy as np
import matplotlib.pyplot as plt

x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]
w=1.0


def forward(x):
    return x*w

def cost(xs,ys):
    cost = 0
    for x,y in zip(xs,ys):
        y_pred = forward(x)
        cost +=(y_pred-y)**2
    return cost/len(xs)

def gradient(xs,ys):
    grad = 0
    for x,y in zip(xs,ys):
        grad += 2*x*(x*w-y)
    return grad/len(xs)

for epoch in range(100):
    cost_val = cost(x_data, y_data)
    grad_val = gradient(x_data,y_data)
    w+=-0.01*grad_val
    print('epoch:',epoch,'w=',w,'loss=',cost_val)

保存神经网络模型

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 myModule(nn.Module):
    def __init__(self):
        super(myModule,self).__init__()
        self.conv1 = nn.Conv2d(3,64,kernel_size=3)

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

Module = myModule()
torch.save(Module.state_dict(),"mymodel.pth")

加载神经网络模型

import torch
import torchvision
from torch import nn

# 方式1 加载方式1
vgg16 = torch.load("vgg16_method1.pth")
#print(vgg16, "vgg16_method")

# 方式1 加载方式1
vgg16 = torch.load("vgg16_method2.pth")
#print(vgg16, "vgg16_method")

# 加载自定义的模型，必须引入要加载模型的类，也就是引入结构
class myModule(nn.Module):
    def __init__(self):
        super(myModule,self).__init__()
        self.conv1 = nn.Conv2d(3,64,kernel_size=3)

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

model = torch.load('mymodel.pth')
print(model)