Pytorch常用操作

torch.randn((3,2)) # 服从高斯分布的随机数randn
torch.randn(3,2)
# 上面两种都是一样的，会生成3行2列的默认数据类型为float32的Tensor (pytorch默认float32，是为了节省资源)
torch.randn((3,2),dtype=torch.float64)

torch.zeros((3,2))
torch.ones((3,2))
torch.Tensor([[2.0,3.2],[3,2]])
torch.from_numpy(a) # a = np.random.randn((2,3)) 将numpy的narray类型转换为tensor类型
torch.arange(6).reshape(2,3)

a = torch.randint((3,2))
a = a.to(torch.float32) # to这个方法还挺常用的，包括可以给数据指定cpu还是gpu a.to("cuda:0")
a = a.int() #其实a.int()就是调用了a.to(torch.int32)

"""
对于相同大小维度的张量相加减乘的时候，就是对应位运算了，但也是可以利用传播机制，张量可以与标量进行运算
或者只要有一维相同就可以实现运算,下面假设a和b都是shape大小为(2,3)的tensor,且dtype相同。
"""
a+b 
a-b
a*b #对应位相乘 等价于a.mul(b)
a.pow(2)
torch.mm(a,b.reshape(3,2))# 矩阵相乘，n*m m*p -> n*p 这里需注意的是两张量的dtype需完全一致，即使是int32和int64也会报错

a = torch.randn((1,3,2,1))
a = a.squeeze() # a.shape (3,2) squeeze会将维度大小为1的维度干掉
a = a.unsqueeze(2) # a.shape (3,2,1) unsqueeze(d)指定增加第d维，最小为第0维

a = torch.randn((3,2))
a = a.T # a.shape (2,3) 最好只用于2维，高于二维目前会warning，在未来版本中会报错
a = a.transpose(0,1) # 交换第0和第1维，可以通过a.transpose_(0,1)直接改变a变量而不用赋值(在pytorch中很多操作都可以通过加入一个_来实现原地修改)，在2-D的tensor下，等价于a.T，在高维下就是交换两个指定的维度

"""
可以感觉transpose方法显得有些鸡肋，所以使用permute会更为方便
"""
a = torch.arange(12).reshape(2,3,2)
a = a.permute(1,0,2) 
# 交换了第0和第1维，permute需要把所有维度列出来，其中的参数代表的就是原来的维度，重新排列就可以同时交换多维
# 上面的a.permute(1,0,2)可以等价于a.transpose(0,1)

"""
x [2.,3.,4.]
requires_grad 允许自动微分
dtype torch.float32 指定为浮点型
Only Tensors of floating point and complex dtype can require gradients
只有浮点型和复数类型可以允许求梯度
"""
x = torch.arange(2,5,dtype=torch.float32,requires_grad=True)
y = x.pow(2).sum() # 可以用y.grad_fn查看反向传播的函数
y.backward() # 反向传播，求梯度
x.grad # [4.,6.,8.]

from torch.utils.data import Dataset

class myDataset(Dataset):
	super(myDataset,self).__init__()
	def __init__(self):
        # 读取数据X_data, y
		self.X_data = X_data
        self.y = y
    
    def __getitem__(self,idx):
        return X_data[idx],y[idx]
    
    def __len__(self):
        return len(self.y)

import torch.nn as nn
import torch

class myNetwork(nn.Module):
    def __init__(self):
        super(myNetwork,self).__init__()
        # 这里使用nn.Sequential只是定义网络的一种方式，也可以单独拆开每个层，分别定义
        self.fc = nn.Sequential(  
            nn.Linear(3,6),
            nn.Sigmoid(),
            nn.Linear(6,1)
        )
    
    def forward(self,x):
        x = self.fc(x)

        return x

from torch.utils.data import DataLoader,random_split
import torch.nn as nn
import torch

from mydataset import myDataset
from mynetwork import myNetwork

#定义超参数
n_epochs = 60 #迭代次数,每个epoch会对整个训练集遍历一遍
batch_size = 16 #一次加载的数据量，对一个epoch中的样本数的拆分
learning_rate = 0.001 #学习率，或者说步长

#加载数据
train_data = myDataset(is_train=True)
test_dataset = myDataset(is_train=False)
#按8:2划分训练集和验证集
train_size = int(len(train_data)*0.8)
validate_size = len(train_data) - train_size
train_dataset,validate_dataset = random_split(train_data,[train_size,validate_size])
#使用DataLoader加载数据集，转换为迭代器
train_dataloader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
validate_dataloader = DataLoader(validate_dataset,batch_size=batch_size) #用于训练中验证模型效果，进而可以动态调整超参数，控制训练
test_dataloader = DataLoader(test_dataset,batch_size=batch_size)

#设置设备
device = "cuda" if torch.cuda.is_available() else "cpu"

#加载模型
model = myNetWork()
model.to(device)

#设置优化器
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)

#设置损失函数
criterion = nn.MSEloss()

#训练模型
for epoch_idx in range(n_epochs):
    model.train()
    train_loss = 0.0
    for batch_idx,(X,y) in enumerate(train_dataloader):
        optimizer.zero_grad()
        X,y = X.to(device),y.to(device)
        pred = model(y)
        loss = criterion(pred,y)
        train_loss += loss.item()
        loss.backward()
        optimizer.step()
 	
    #验证模型
    model.eval()
    validate_loss = 0.0
    with torch.no_grad(): #不计算梯度，加快运算速度
        for batch_idx,(X,y) in enumerate(validate_dataloader):
            X,y = X.to(device),y.to(device)
            pred = model(y)
            loss = criterion(pred,y)
            validate_loss += loss.item()
    
    
    print(f"[epoch:{epoch_idx+1}/{epochs}] || train_loss:{train_loss:.2f} || validate_loss:{validate_loss:.2f}")
        

#保存
torch.save(the_model.state_dict(), PATH)
#读取
the_model = TheModelClass(*args, **kwargs)
the_model.load_state_dict(torch.load(PATH))

#保存
torch.save(the_model, PATH)
#读取
the_model = torch.load(PATH)