PyTorch学习

莫烦Python的回归教程，有很多亮点值得学习，避免忘记，把代码贴一下

# -*- coding: utf-8 -*-
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

"""
torch的squeeze和unsqueeze方法针对的是数据的维度操作

torch.squeeze(input, dim=None, out=None)
    Returns a Tensor with all the dimensions of input of size 1 removed.
    默认是去掉＊所有维度＊中维度大小为1的维度并返回
    若指定了dim（从0开始），则判断该维度大小是否为1,若为1则去掉，不影响其他维度
     
torch.unsqueeze(input, dim, out=None)
    Returns a new tensor with a dimension of size one inserted at the specified position.
    在指定位置插入一个1维tensor
    
torch.squeeze() 对于tensor变量进行维度压缩，去除维数为1的的维度
torch.unsqueeze() 是squeeze()的反向操作，增加一个维度，该维度维数为1，可以指定添加的维度
"""

# 将数据变成２维的，pytorch只能处理2维的数据。
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
# 对ｘ平方再加噪声
y = x.pow(2) + 0.2 * torch.randn(x.size())

x, y = Variable(x), Variable(y)


# 打印出散点图
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
class Net(torch.nn.Module):
    """
    一般神经网络的类都继承自torch.nn.Module，__init__()和forward()两个函数是自定义类的主要函数。在__init__()中都要添加一句
    super(Net, self).__init__()，这是固定的标准写法，用于继承父类的初始化函数。__init__()中只是对神经网络的模块进行了声明，真正的搭建是在
    forwad()中实现。自定义类中的成员都通过self指针来进行访问，所以参数列表中都包含了self。
    """
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        # 神经网络中的层信息都是模块中的属性
        # 试一下设置bias为true
        self.hidden = torch.nn.Linear(n_feature, n_hidden)  #
        self.predict = torch.nn.Linear(n_hidden, n_output)

    def forward(self, data):
        """
        在init中定义好了层，但不代表已经搭好了神经网络，需要将各个层连接起来
        :param data:　输入数据
        :return:　返回神经网络的最后输出值
        """
        hidden_layer_output = F.relu(self.hidden(data))
        predict_layer_output = self.predict(hidden_layer_output)
        return predict_layer_output


net = Net(n_feature=1, n_hidden=10, n_output=1)
# 可以用print打印出神经网络层的架构信息，学会使用这种方法
# print(net)

# 设置matplotlib为实时打印过程
plt.ion()
plt.show()

# 因为要优化神经网络中的所有参数，所以要传入神经网络的所有参数net.parameters()
optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
loss_func = torch.nn.MSELoss()


for t in range(100):
    """
    定义训练步数
    """
    # 为什么输入的时候是x,是直接调用forward方法吗？
    prediction = net(x)

    # 注意预测值在前，真实值在后
    loss = loss_func(prediction, y)

    # 先将所有参数的梯度置之为０，因为每次更新之后梯度都会保留在optimizer之中
    optimizer.zero_grad()
    # 进行反向传递
    loss.backward()
    # 以学习效率0.5来优化梯度
    optimizer.step()

    # 可视化每次的序列训练效果
    # if t % 5 == 0:
        # plot and show learning process
    plt.cla()
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
    plt.text(0.5, 0, 'Loss=%.4f' % loss.data[0], fontdict={'size': 20, 'color': 'red'})
    plt.pause(0.5)

plt.ioff()
plt.show()