pytorch基础

pytorch基础

Tensor：

张量。是一个多维的矩阵，零维是一个点，一维是一个向量，二维即一般的矩阵，再多维就是多维数组。pytorch的Tensor与numpy中的ndarray相互转换。

不同数据类型的Tensor：

32位浮点型：torch.FloatTensor;

64位浮点类型torch.DoubleTensor;

16位整型torch.ShortTensor;

32位整型torch.IntTensor;

64位整型torch.LongTensor.

注意：torch.Tensor默认是32位浮点类型。

Tensor和numpy之间可以进行转换。

import torch
import numpy as np


a=torch.Tensor([[1,2],[3,4],[5,6]]) #构建一个三行两列的矩阵
print("a is :{}".format(a))
print("a size is{}".format(a.size())) #a size istorch.Size([3, 2])

b=torch.zeros((3,2)) # 创建全0矩阵
print(b)

c=torch.randn((3,2)) # 随机生成三行二列矩阵
print(c)

numpy_a=a.numpy() # 通过简单的a.numpy()进行类型转换
print("conver to numpy is{}".format(a))

d=np.array([[1,2],[3,4],[5,6]])
torch_d=torch.from_numpy(d) # 通过torch.from)_numpy()进行转换
print("from numpy to torch.Tensor is{}".format(torch_d))

可以通过GPU进行加速：加上这句话，并且将变量加载到GPU上（.to（device）即可。

device=torch.device("cuda" if torch.cuda.is_available() else "cpu")

Variable：

Variable具有自动求导的功能，神经网络再做运算的时候要先构造一个计算图谱，然后在里面进行前向传播和反向传播。Variable和Tensor没有本质区别，Variable会被放到计算图谱中进行传播和求导。

import torch
from torch.autograd import Variable

#创建variable
a=Variable(torch.Tensor([1]),requires_grad=True)
b=Variable(torch.Tensor([2]),requires_grad=True)
c=Variable(torch.Tensor([3]),requires_grad=True)

# 创建计算图谱
y=a*b+c

#计算梯度,自动求导不需要明确写明哪个函数对哪个函数求导，直接通过这行代码就可以对所有需要梯度的变量进行求导.
y.backward()

#输出梯度
print(a.grad) #a.grad=2 对a求导时, y=2*a+3,以下类似
print(b.grad) #b.grad=1
print(c.grad) #c.grad=1

#矩阵求导

x=torch.randn(3)
x=Variable(x,requires_grad=True)

y=x*2
print(y)  # tensor([-1.3775,  0.4860,  1.0475], grad_fn=<MulBackward0>)

y.backward(torch.FloatTensor([1,1,1])) # 向量求导时要传入参数声明,得到每个分量的梯度
print(x.grad) # tensor([2., 2., 2.])

y.backward(torch.FloatTensor([1,0.1,0.01])) #这样得到的梯度时原本的梯度乘以1,0.1,0.01
print(x.grad) # tensor([2.0000, 0.2000, 0.0200])

Dataset:

数据的读取与预处理。

一般继承和重写torch.utils.data.Dataset这个类。重新定义__len__与__getitem__这两个函数。通过自带的DataLoader实现batch，shuffle或者多线程去读取数据。

import torch.utils.data as Data
import pandas as pd

class MyDateset(Data.Dataset):
    def __init__(self,csv_file,txt_file,root_dir,other_file):
        self.csv_data=pd.read_csv(csv_file)
        with open(txt_file,"r") as f:
            data_list=f.readlines()
        self.txt_data=data_list
        self.root_dir=root_dir
        

    def __getitem__(self, idx):  #函数重写。
        return self.csv_data[idx],self.txt_data[idx]

    def __len__(self):
        return len(self.csv_data)


# batch,shuffle或者多线程读取数据
dataiter=Data.DataLoader(MyDateset,batch_size=32,shuffle=True)

nn.Module:

在pytorch中编写神经网络，所有的层结构和损失函数都来自于torch.nn，所有的模型构建都是从nn.Module继承的。

以下一个模板。

class MyModel(nn.Module):
    def __init__(self,dim1,dim2,other_arguments):
        super(MyModel,self).__init__()
        self.linear1=nn.Linear(10,dim1)
        self.activation=nn.ReLU()
        self.linear2=nn.Linear(dim1,dim2)
        self.linear3=nn.Linear(dim2,4)
        #其它网络层
    def forward(self,x):
        output=self.linear1(x)
        output=self.activation(output)
        output=self.linear2(output)
        output=self.linear3(output)
        return output

通过nn构建好模型之后，也需要定义损失函数。常见的损失函数都已经定义在了nn中。直接使用就好。

model=MyModel(64,8).to(device)
#损失函数。
loss_fn=nn.CrossEntropyLoss()
#优化器。
optimizer=optim.Adam(model.parameters(),lr=1e-2)

torch.optim:

在机器学习或者深度学习中，我们需要通过修改参数来使得损失函数最小化或者最大化。而优化算法就是一种调整模型参数更新的策略。

直接使用torch.optim中自带的优化算法即可，只需要设置好基本的参数即可，如学习率等。在优化之前需要将梯度归零，然后通过损失函数反向传播，自动求导得到每个参数的梯度，最够做参数更新。

#优化器。
optimizer=optim.Adam(model.parameters(),lr=1e-2)
#三件套
loss.backward()
optimizer.step()
optimizer.zero_grad()

模型的保存和加载：

在pytorch中通过torch.save来保存模型的结构和参数。保存有两种保存方式：第一种是保存整个模型的结构信息和参数信息，保存的对象是model；第二种就是保存模型的参数，保存的对象是模型的状态model.state_dict()。

torch.save的第一个参数是model或者model.state_dict()，第二个参数是保存的路径。

加载完整的模型结构和参数信息时，通过load_model = torch.load("model.pth")即可；加载模型参数信息时，需要先导入模型的结构，然后通过model.load_state_dic("model_state.pth")来导入。