pythorch 基本学习

左手的ㄟ右手 2022-02-23 08:16 98阅读 0赞

**tensor：**

import torch
    data = [[1,2], [3,4]]
    tensor = torch.FloatTensor(data)

各种操作和numpy.array类似

**Variable：**  
from torch.autograd import Variable  
变量，里面的主要元素就是tensor（type(Variable.data) == A\_KIND\_OF\_TENSORS），但是一个variable是会记住自己是被哪些Variable计算出来的（variable = Variable(tensor, requires\_grad=True)），所以当我们计算出最后一个Variable：loss时，就可以通过loss.backward()，来对梯度进行反向传播。然后loss.grad就是其对应的梯度，loss计算图中的各个Variable中的grad成员也会自动变成其对应的参数，记得每次计算新的grad时，要把原来的梯度清0。（optimizer.zero\_grad()可以自动完成这个操作，把所有Variable的grad成员数值变为0，然后optimizer.step()则在每个Variable的grad都被计算出来后，更新每个Variable的数值）

**激励函数：**  
import torch.nn.functional as F  
F里面存着各种激励函数，进去一个Variable，出来一个Variable，最常用的当然就是F.relu(A\_VARIABLE)

**optimizer:**

optimizer = torch.optim.SGD(net.parameters(), lr=0.5)

qusetion：net.parameters()是哪里来的，作用是什么？  
optimizer.zero\_grad()可以把所有Variable的grad成员数值变为0  
optimizer.step()则可以用所有Variable的grad成员和lr的数值自动更新Variable的数值。  
给Variable打上粗体是因为之中Variable会被optimizer的相关函数更新，如果你把东西放在list或其它东西里，它们的梯度是不会被更新的！

**loss function：**  
loss\_func = torch.nn.MSELoss()**建立一个神经网络**：

class Net(torch.nn.Module):  # 继承 torch 的 Module
        def __init__(self, n_feature, n_hidden, n_output):
            super(Net, self).__init__()     # 继承 __init__ 功能
            # 定义每层用什么样的形式
            self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
            self.predict = torch.nn.Linear(n_hidden, n_output)   # 输出层线性输出
    
        def forward(self, x):   # 这同时也是 Module 中的 forward 功能
            # 正向传播输入值, 神经网络分析出输出值
            x = F.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
            x = self.predict(x)             # 输出值
            return x
    
    net = Net(n_feature=1, n_hidden=10, n_output=1)
    
    print(net)  # net 的结构"""
    Net (
      (hidden): Linear (1 -> 10)
      (predict): Linear (10 -> 1)
    )
    """

**训练一个网络：**  
\# optimizer 是训练的工具optimizer = torch.optim.SGD(net.parameters(), lr=0.5)  \# 传入 net 的所有参数, 学习率loss\_func = torch.nn.MSELoss()      \# 预测值和真实值的误差计算公式 (均方差)

for t in range(100):
        prediction = net(x)     # 喂给 net 训练数据 x, 输出预测值
    
        loss = loss_func(prediction, y)     # 计算两者的误差
    
        optimizer.zero_grad()   # 清空上一步的残余更新参数值
        loss.backward()         # 误差反向传播, 计算参数更新值
        optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

**快速搭建网络：**  
之前写的搭建方法适用于你可以对网络进行各种各样的自定义  
接下来的方法，如果不需要什么复杂的过程的话，只需要按下面的过程来构建就好了。

net2 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )

**保存网络：**

torch.save(net1, 'net.pkl') # 保存整个网络
    torch.save(net1.state_dict(), 'net_params.pkl') # 只保存网络中的参数 (速度快, 占内存少)

**提取网络：**  
提取整个神经网络, 网络大的时候可能会比较慢.

def restore_net():
        # restore entire net1 to net2
        net2 = torch.load('net.pkl')
        prediction = net2(x)

只提取网络参数

def restore_params():
        # 新建 net3
        net3 = torch.nn.Sequential(
            torch.nn.Linear(1, 10),
            torch.nn.ReLU(),
            torch.nn.Linear(10, 1)
        )

\# 将保存的参数复制到 net3

net3.load_state_dict(torch.load('net_params.pkl'))
        prediction = net3(x)

**批处理：**

# 把 dataset 放入 DataLoaderloader = Data.DataLoader(
        dataset=torch_dataset,      # torch TensorDataset format
        batch_size=BATCH_SIZE,      # mini batch size
        shuffle=True,               # 要不要打乱数据 (打乱比较好)
        num_workers=2, )             # 多线程来读数据)
    
    for epoch in range(3):   # 训练所有!整套!数据 3 次
        for step, (batch_x, batch_y) in enumerate(loader):  # 每一步 loader 释放一小批数据用来学习
            # 假设这里就是你训练的地方...
    
            # 打出来一些数据
            print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
                  batch_x.numpy(), '| batch y: ', batch_y.numpy())
    
    """
    Epoch:  0 | Step:  0 | batch x:  [ 6.  7.  2.  3.  1.] | batch y:  [  5.   4.   9.   8.  10.]
    Epoch:  0 | Step:  1 | batch x:  [  9.  10.   4.   8.   5.] | batch y:  [ 2.  1.  7.  3.  6.]
    Epoch:  1 | Step:  0 | batch x:  [  3.   4.   2.   9.  10.] | batch y:  [ 8.  7.  9.  2.  1.]
    Epoch:  1 | Step:  1 | batch x:  [ 1.  7.  8.  5.  6.] | batch y:  [ 10.   4.   3.   6.   5.]
    Epoch:  2 | Step:  0 | batch x:  [ 3.  9.  2.  6.  7.] | batch y:  [ 8.  2.  9.  5.  4.]
    Epoch:  2 | Step:  1 | batch x:  [ 10.   4.   8.   1.   5.] | batch y:  [  1.   7.   3.  10.   6.]
    """

\---------------------