Pytorch基础(1)

pytorch学习强推莫烦up主：https://github.com/MorvanZhou/PyTorch-Tutorial

1. numpy与tensor

x = torch.Tensor(5, 3)                #创建一个未初始化的5*3矩阵
x = torch.zeros(5,3, dtype=torch.long)#创建一个数据类型为long的零矩阵
x = torch.Tensor([5.5, 3])            #用数据创造一个张量

#numpy bridge以 numpy作媒介 实现tensor与numpy的转化
#Torch Tensor 和 Numpy 数组共享底层的内存位置，改变任何一个都将改变另一个.

np_data = np.arange(6).reshape((2,3)) #创造numpy数据
torch_data = torch.from_numpy(np_data) #转化为torch数据
tensor2array = torch_data.numpy() #torch数据转化为numpy数据

print(
    '\nnumpy', np_data,
    '\ntorch', torch_data,
    '\ntensor2array', tensor2array,
)
#结果
numpy [[0 1 2]
 [3 4 5]] 
torch tensor([[0, 1, 2],
        [3, 4, 5]], dtype=torch.int32) 
tensor2array [[0 1 2]
 [3 4 5]]

#矩阵相乘，numpy两种方法，torch为一种
data = [[1,2], [3,4]]
tensor = torch.FloatTensor(data)
print(
    '\nnumpy', np.matmul(data,data),    #矩阵相乘 或者data.dot(data)
    '\ntorch', torch.mm(tensor,tensor)

)

2.网络的搭建，自定义网络和快速搭建

import torch
#两种搭建网络的方式：
#自定义网络模块
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
net1 = Net(1, 10, 1)   # 这是我们用这种方式搭建的 net1
#快速搭建
net2 = torch.nn.Sequential(
    torch.nn.Linear(1, 10),
    torch.nn.ReLU(),
    torch.nn.Linear(10, 1)
)

 对比两者结构：

Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)
Sequential(
  (0): Linear(in_features=1, out_features=10, bias=True)
  (1): ReLU()
  (2): Linear(in_features=10, out_features=1, bias=True)
)

3.保存提取，两者方式：提取网络，提取网络参数

import torch
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# fake data
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size())  # noisy y data (tensor), shape=(100, 1)
def save():
    # save net1
    net1 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )
    optimizer = torch.optim.SGD(net1.parameters(), lr=0.5)
    loss_func = torch.nn.MSELoss()
#训练
    for t in range(100):
        prediction = net1(x)
        loss = loss_func(prediction, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    # 2 ways to save the net
    torch.save(net1, 'net.pkl')  # save entire net
    torch.save(net1.state_dict(), 'net_params.pkl')   # save only the parameters

def restore_net():        #法1，提取网络
    # restore entire net1 to net2
    net2 = torch.load('net.pkl')
    prediction = net2(x)

def restore_params():     #法2，提取网络参数
    # restore only the parameters in net1 to net3
    net3 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )

    # copy net1's parameters into net3
    net3.load_state_dict(torch.load('net_params.pkl'))
    prediction = net3(x)

#省略作图
# 保存 net1 (1. 整个网络, 2. 只有参数)
save()

# 提取整个网络
restore_net()

# 提取网络参数, 复制到新网络
restore_params()

4.批训练(minibatch)

import torch
import torch.utils.data as Data
torch.manual_seed(1)    # reproducible

BATCH_SIZE = 5      # 批训练的数据个数

x = torch.linspace(1, 10, 10)       # x data (torch tensor)
y = torch.linspace(10, 1, 10)       # y data (torch tensor)

# 先转换成 torch 能识别的 Dataset
torch_dataset = Data.TensorDataset(x, y)#注1.0版本TensorDataset只能装入一个tensor

# 把 dataset 放入 DataLoader，Dataloader是用来包装数据的工具
loader = Data.DataLoader(
    dataset=torch_dataset,      # torch TensorDataset format，tensor类型
    batch_size=BATCH_SIZE,      # mini batch size
    shuffle=True,               # 要不要打乱数据 (打乱比较好)
    num_workers=2,              # 多线程来读数据
)
def show_batch():
    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())

if __name__ == '__main__':
    show_batch()
#结果
Epoch:  0 | Step:  0 | batch x:  [ 5.  7. 10.  3.  4.] | batch y:  [6. 4. 1. 8. 7.]
Epoch:  0 | Step:  1 | batch x:  [2. 1. 8. 9. 6.] | batch y:  [ 9. 10.  3.  2.  5.]
Epoch:  1 | Step:  0 | batch x:  [ 4.  6.  7. 10.  8.] | batch y:  [7. 5. 4. 1. 3.]
Epoch:  1 | Step:  1 | batch x:  [5. 3. 2. 1. 9.] | batch y:  [ 6.  8.  9. 10.  2.]
Epoch:  2 | Step:  0 | batch x:  [ 4.  2.  5.  6. 10.] | batch y:  [7. 9. 6. 5. 1.]
Epoch:  2 | Step:  1 | batch x:  [3. 9. 1. 8. 7.] | batch y:  [ 8.  2. 10.  3.  4.]

若size=8，在step为2时，只会出现剩下的2个数字

如有错误，欢迎指正！