我的PyTorch

记录一下PyTorch的一些奇奇怪怪的方法和函数

Dataset&DataLoader

class MyDataSet(Dataset):
    def __init__(self,sava_path):

    def __len__(self):
        return 0

    def __getitem__(self,idx):
        return  0

    def collate_fn(data):
        return 0

collate_fn()的参数输入是__getitem__()得到的结果，一般是管这些拿到的数据怎么拼接成一个batch。

但collate_fn()不是Dateset里的函数，是放一边用来替换Dataloader中collate_fn的函数。

# 加载到dataloader
loader = DataLoader(mydataset, batch_size=10, collate_fn=collate_fn)
# 这么写
for epoch in range(3):
    for step, batch_x in enumerate(loader):
        # training
        print("step:{}, batch_x:{}".format(step, batch_x))

torch.stack

沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。

# 两个都是 3*3
T1 = torch.tensor([[1, 2, 3],
        		[4, 5, 6],
        		[7, 8, 9]])
T2 = torch.tensor([[10, 20, 30],
        		[40, 50, 60],
        		[70, 80, 90]])

print(torch.stack((T1,T2),dim=0).shape)
print(torch.stack((T1,T2),dim=1).shape)
print(torch.stack((T1,T2),dim=2).shape)
print(torch.stack((T1,T2),dim=3).shape)
# outputs:
torch.Size([2, 3, 3])
torch.Size([3, 2, 3])
torch.Size([3, 3, 2])
'选择的dim>len(outputs)，所以报错'
IndexError: Dimension out of range (expected to be in range of [-3, 2], but got 3)

torch.trunk

import torch
print(torch.arange(5).chunk(3))
#  (tensor([0, 1]), tensor([2, 3]), tensor([4]))  
#  得到一个元祖，将[1,2,3,4,5]分成3份

a=torch.tensor([[[1,2],[3,4]],
               [[5,6],[7,8]]])
b=torch.chunk(a,2,dim=1) # 按照a的第一维度切分
print(a.size())   # torch.Size([2, 2, 2])
print(a)  
# tensor([[[1, 2],
#         [3, 4]],
#
#        [[5, 6],
#         [7, 8]]])

# print(b.size())  # b是元祖，执行报错
print(b) 
# (tensor([[[1, 2]],[[5, 6]]]), tensor([[[3, 4]],[[7, 8]]]))

torch.nn.init.uniform_

torch.nn.init.uniform(tensor, a=0, b=1)

从均匀分布U(a, b)中生成值，填充输入的张量或变量

参数：
tensor - n维的torch.Tensor
a - 均匀分布的下界
b - 均匀分布的上界

torch.nn.Parameter()

self.v = torch.nn.Parameter(torch.FloatTensor(hidden_size))

含义是将一个固定不可训练的tensor转换成可以训练的类型parameter，并将这个parameter绑定到这个module里面(net.parameter()中就有这个绑定的parameter，所以在参数优化的时候可以进行优化的)，所以经过类型转换这个self.v变成了模型的一部分，成为了模型中根据训练可以改动的参数了。使用这个函数的目的也是想让某些变量在学习的过程中不断的修改其值以达到最优化。

优化器简单的一句话

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

torch验证时，注意加上不要梯度

    with torch.no_grad():
        results = model()

torch去重升序

x = torch.unique(input)  #升序
x = torch.unique(input,return_inverse=True) #逆序

保存和加载模型各种信息

####  保存
torch.save({'model': model.state_dict(), 'optimizer': optimizer.state_dict()}, 'model_{}.pth'.format(epoch))

#### 加载
weight =torch.load('model_0.pth')
model.load_state_dict(weight['model'])
optimizer.load_state_dict(weight['optimizer'])

torch.tensor 转化为list

a = torch.Tensor([1,2,3])
lis = a.numpy().tolist()
print(lis)
# [1.0, 2.0, 3.0]

for i in range(len(lis)):lis[i] = int(lis[i])
#  把所有元素转成int

快速将torch.Tensor生成txt

a = torch.eye(8)
pd.DataFrame(a.int().cpu().detach().numpy()).to_csv('test.csv')

torch.Tensor转为numpy

numpy_array = torch_Tensor.cpu().detach().numpy()

torch.nn.Embedding

import torch
import torch.nn as nn
embed=nn.Embedding(10,5)   # 10指x有10个不同的元素，5是指要把每个元素扩展成多少维度
x=torch.LongTensor([[0,1,2],[3,2,1],[4,5,6],[9,7,8]]) # 4*3
x_embed=embed(x)
print(x_embed.size())
# torch.Size([4, 3, 5])
print(x_embed)

torch.nn.BatchNorm1d

import torch
import torch.nn as nn
BN = torch.nn.BatchNorm1d(5)
input = torch.Tensor([[1,2,3,4,5],
                     [10,20,30,40,50],
                     [100,200,400,400,500]])
output = BN(input)
print(output.size()) 
# torch.Size([3, 5])
print(output)
# tensor([[-0.8054, -0.8054, -0.7803, -0.8054, -0.8054],
#        [-0.6040, -0.6040, -0.6313, -0.6040, -0.6040],
#        [ 1.4094,  1.4094,  1.4116,  1.4094,  1.4094]],
#        grad_fn=)

快速生成torch的等差序列

X = torch.LongTensor([i for i in range(10)])
print(X)
#  tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

pytorch之nn.Conv1d和nn.Conv2d超详解

pytorch之nn.Conv1d和nn.Conv2d超详解_lyj157175的博客-CSDN博客

torch.mul() 和 torch.mm() 的区别

torch.mul() 和 torch.mm() 的区别_Geek Fly的博客-CSDN博客_torch.mm

图可视化

import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
x = edge_index.numpy()
G.add_edges_from(edge_index.numpy().transpose())   # 这个格式要是 num_edge*2,numpy格式
adj = nx.adjacency_matrix(G)
print("G的节点数目",G.number_of_nodes())
print("G的边的数目",G.number_of_edges())
nx.draw(G, node_color = 'pink',with_labels=True)
plt.show()

可以写成函数形式，放在utils里

import networkx as nx
import matplotlib.pyplot as plt

def present_graph(edge_index):  # 接受torch.LongTensor 2*num_edge 形式
    G = nx.Graph()
    G.add_edges_from(edge_index.numpy().transpose())
    adj = nx.adjacency_matrix(G)
    print("G的节点数目",G.number_of_nodes())
    print("G的边的数目",G.number_of_edges())
    nx.draw(G, node_color = 'pink',with_labels=True)
    plt.show()

小技巧

生成一个矩阵，这个矩阵中的每行的某个位置的数字越小，表示对应的位置的元素越大

a = torch.tensor([[10, 2, 3],
                  [4, 6, 5],
                  [7, 8, 9]])
a = torch.argsort(torch.argsort(a, dim=1, descending=True), dim=1, descending=False)
print(a)

# tensor([[0, 2, 1],
#        [2, 0, 1],
#        [2, 1, 0]])