PyTorch基础(part3)

学习笔记，仅供参考，有错必纠

---

文章目录

---

PyTorch 基础

线性回归

常用代码

# 支持多行输出
from IPython.core.interactiveshell import InteractiveShell 
InteractiveShell.ast_node_interactivity = 'all' #默认为'last'

导包

# 导入常用的包
import torch
from torch import nn,optim
import numpy as np
import matplotlib.pyplot as plt
from torch.autograd import Variable

生成数据

x_data = np.random.rand(100)
noise = np.random.normal(0,0.01,x_data.shape)
y_data = x_data*0.1 + 0.2 + noise

plt.scatter(x_data,y_data)
plt.show()

<matplotlib.collections.PathCollection at 0x1dbfa189240>

# 将数据变为2维数据，因为在用pytorch在训练模型时，需要传入一个批次的数据
x_data = x_data.reshape(-1,1) # -1表示自动匹配，1表示列为1列。那么这样换算下来，就会转换为(100,1)的二维数组
y_data = y_data.reshape(-1,1)

# 将numpy 变成 tensor
x_data = torch.FloatTensor(x_data)
y_data = torch.FloatTensor(y_data)

# 定义模型的输入变量
inputs = Variable(x_data)
# 定义模型的输出标签
targets = Variable(y_data)

构建神经网络模型

# 定义一个自己的类，这个类需要继承pytorch中的一个类
class MyLR(nn.Module):
    # 初始化方法，定义网络的结构(一般把网络中具有可学习参数的层放在__init__()中)
    def __init__(self):
        # 初始化父类nn.Module
        super(MyLR, self).__init__()
        self.fc = nn.Linear(1, 1) # (1, 1)表示输入1个神经元，输出一个神经元
        pass
    # 前向传递，定义网络的计算
    def forward(self, x):
        out = self.fc(x)
        return out

# 定义模型
model = MyLR()
# 定义损失函数
mse_loss = nn.MSELoss()
# 定义优化器
optimizer = optim.SGD(model.parameters(), lr = 0.1)

# 查看模型参数(未训练的初始化参数)
for name, parameters in model.named_parameters():
    print('name:{}, para:{}'.format(name, parameters))

name:fc.weight, para:Parameter containing:
tensor([[0.4478]], requires_grad=True)
name:fc.bias, para:Parameter containing:
tensor([-0.3437], requires_grad=True)

for i in range(1000):
    out = model(inputs)
    # 计算loss
    loss = mse_loss(out, targets)
    # 梯度清0,否则之前计算的梯度会叠加
    optimizer.zero_grad()
    # 计算梯度
    loss.backward()
    # 修改权值
    optimizer.step()
    if i % 100 == 0:
        print(i, loss.item())

0 0.1456504464149475
100 0.0016374412225559354
200 0.00021086522610858083
300 0.00010340119479224086
400 9.530589886708185e-05
500 9.469607175560668e-05
600 9.465014591114596e-05
700 9.464671165915206e-05
800 9.464642789680511e-05
900 9.464641334488988e-05

# 计算预测值
y_pred = model(inputs)
plt.scatter(x_data,y_data)
plt.plot(x_data,y_pred.data.numpy(),'r-',lw=3)
plt.show()

<matplotlib.collections.PathCollection at 0x1dbfa5dc978>






[<matplotlib.lines.Line2D at 0x1dbfa5c2c88>]

非线性回归

生成数据

# 在 -2 到 2 之间产生呈等差变化的200个数值，并将其变为2维数据
x_data = np.linspace(-2, 2, 200)[:, np.newaxis]
noise = np.random.normal(0,0.2,x_data.shape)
y_data = np.square(x_data) + noise

plt.scatter(x_data,y_data)
plt.show()

<matplotlib.collections.PathCollection at 0x1dbfa76f240>

# 将numpy 变成 tensor
x_data = torch.FloatTensor(x_data)
y_data = torch.FloatTensor(y_data)

# 定义模型的输入变量
inputs = Variable(x_data)
# 定义模型的输出标签
targets = Variable(y_data)

构建神经网络模型

# 定义一个自己的类，这个类需要继承pytorch中的一个类
class MyLR(nn.Module):
    # 初始化方法，定义网络的结构(一般把网络中具有可学习参数的层放在__init__()中)
    def __init__(self):
        # 初始化父类nn.Module
        super(MyLR, self).__init__()
        # 定义1-10-1的网络结构
        self.fc1 = nn.Linear(1, 10)
        # 设置激活函数
        self.tanh = nn.Tanh()
        self.fc2 = nn.Linear(10, 1)
        pass
    # 前向传递，定义网络的计算
    def forward(self, x):
        x = self.fc1(x)
        x = self.tanh(x)
        out = self.fc2(x)
        return out

# 定义模型
model = MyLR()
# 定义损失函数
mse_loss = nn.MSELoss()
# 定义优化器
optimizer = optim.SGD(model.parameters(), lr = 0.3)

# 查看模型参数(未训练的初始化参数)
for name, parameters in model.named_parameters():
    print('name:{}, para:{}'.format(name, parameters))

name:fc1.weight, para:Parameter containing:
tensor([[-0.8362],
        [ 0.2621],
        [ 0.9536],
        [ 0.9033],
        [-0.5467],
        [ 0.1015],
        [-0.4320],
        [-0.4793],
        [ 0.2248],
        [ 0.6971]], requires_grad=True)
name:fc1.bias, para:Parameter containing:
tensor([ 0.6691,  0.4091, -0.4945, -0.9603,  0.7015, -0.7920,  0.9798,  0.6661,
         0.5042,  0.3837], requires_grad=True)
name:fc2.weight, para:Parameter containing:
tensor([[ 0.1721,  0.2141, -0.1088, -0.2049, -0.1316, -0.0525,  0.0242,  0.1614,
          0.2276,  0.0702]], requires_grad=True)
name:fc2.bias, para:Parameter containing:
tensor([0.2010], requires_grad=True)

for i in range(2000):
    out = model(inputs)
    # 计算loss
    loss = mse_loss(out, targets)
    # 梯度清0,否则之前计算的梯度会叠加
    optimizer.zero_grad()
    # 计算梯度
    loss.backward()
    # 修改权值
    optimizer.step()
    if i % 100 == 0:
        print(i, loss.item())

0 2.2675838470458984
100 0.07629517465829849
200 0.11858276277780533
300 0.08543253690004349
400 0.08349892497062683
500 0.08922693133354187
600 0.09121432155370712
700 0.08348247408866882
800 0.10780174285173416
900 0.08897148072719574
1000 0.08086799830198288
1100 0.07277610898017883
1200 0.06655674427747726
1300 0.061655644327402115
1400 0.05747130513191223
1500 0.054821696132421494
1600 0.052742671221494675
1700 0.051381915807724
1800 0.050302788615226746
1900 0.04957994446158409

# 计算预测值
y_pred = model(inputs)
plt.scatter(x_data,y_data)
plt.plot(x_data,y_pred.data.numpy(),'r-',lw=3)
plt.show()

<matplotlib.collections.PathCollection at 0x1dbfa7ce630>






[<matplotlib.lines.Line2D at 0x1dbfa3e26d8>]