pytorch指令整理

 数据类型

pytorch是一个gpu加速库，不是一个完备的语言库，面向数据计算，面向数据计算的tensor前面表示类型，不同维度表示不同的数据类型

        如果遇到处理string的情况，但是又没有自带的表示方法，就用one-hot编码或者embedding来表示

        one-hot编码，如果要表示3类，就制造一个三类的向量，但是由于每一个位置，不能表现单词之间的相关性，表达一个意思如果表示较大的单词、汉字等，矩阵会变得非常稀疏，大部分都是0

        embedding可以用数字的编码表示一个语言，编码的方式表示string

 

数据类型的识别比较常用的就是floattensor、bytetensor、inttensor，在gpu里面，数据需要加上cuda，同一个tensor部署在cpu和gpu上是不一样的

用data = data.cuda()可以把数据搬运到gpu上面，进行一个gpu上面的运用

创建tensor

 import torch

#根据list数据生成Tensor

torch.Tensor([1,2,3,4,5,6])

#根据指定形状生成Tensor

torch.Tensor(2,3)

#根据给定的Tensor的形状

t=torch.Tensor([[1,2,3],[4,5,6]])

#查看Tensor的形状，size()

t.size()

#shape与size()等价方式

t.shape

#根据已有形状创建Tensor

torch.Tensor(t.size())

#生成一个单位矩阵,eye(row,column),Tensor

torch.eye(2,2)

#自动生成全是0的矩阵

torch.zeros(2,3)

#根据规则生成数据,linspace(start,end,steps),从start到end均匀且分成steps份

torch.linspace(1,10,4)

#生成满足[0,1）均匀分布随机数

torch.rand(2,3)

#生成满足标准正态分布随机数

torch.randn(2,3)

#返回所给数据形状相同，值全为0的张量

torch.zeros_like(torch.rand(2,3))

torch.tensor（从数据中推断数据类型）

torch.Tensor（默认使用FloatTensor）

import torch

t1=torch.Tensor(1)

t2=torch.tensor(1)

#t1的值tensor([3.5731e-20]),t1的数据类型torch.FloatTensor，返回大小为1的张量，随机初始化的值

#t2的值1,t2的数据类型torch.LongTensor

修改tensor形状

import torch

#生成一个形状为2x3的矩阵

x = torch.randn(2, 3)

#查看矩阵的形状

x.size()

# 结果为 torch.Size([2, 3])

#查看x的维度

x.dim()

# 结果为 2

#把x变为3x2的矩阵，view(*shape)，修改Tensor的shape

x.view(3,2)

#把x展平为1维向量

y=x.view(-1)

y.shape

#添加一个维度

z=torch.unsqueeze(y,0)

#查看z的形状，返回张量的shape属性值

z.size()

# 结果为 torch.Size([1, 6])

#计算Z的元素个数，计算Tensor的元素个数

z.numel()

# 结果为 6

reshape() 可以由 torch.reshape() ，也可由 torch.Tensor.reshape() 调用

view() 只可由 torch.Tensor.view() 来调用

如果你只想重塑张量使用torch.reshape

还关注内存使用情况并希望确保两个张量共享相同的数据使用torch.view。

选择操作

import torch

#设置一个随机种子

torch.manual_seed(100)

#生成一个形状为2x3的矩阵

x = torch.randn(2, 3)

#根据索引获取第1行，所有数据

x[0,:]

#获取最后一列数据

x[:,-1]

#生成是否大于0的Byter张量

mask=x>0

#获取大于0的值

torch.masked_select(x,mask)

#获取非0下标,即行，列索引

torch.nonzero(mask)

广播机制

import torch

import numpy as np

#arrange(start,end,step),在区间star和end之间，以step为间隔生成一个序列张量

A = np.arange(0, 40,10).reshape(4, 1)

B = np.arange(0, 3)

#把ndarray转换为Tensor

A1=torch.from_numpy(A) # 形状为 4x1

B1=torch.from_numpy(B) # 形状为 3

#Tensor自动实现广播

C=A1+B1

#我们可以根据广播机制，手工进行配置

#根据规则1，B1需要向A1看齐，把B变为（1,3）

B2=B1.unsqueeze(0) #B2 的形状为 1x3

#使用expand函数重复数组，分别的4x3的矩阵

A2=A1.expand(4,3)

B3=B2.expand(4,3)

# 然后进行相加

逐个元素操作

import torch

t = torch.randn(1, 3)

t1 = torch.randn(3, 1)

t2 = torch.randn(1, 3)

#t+0.1*(t1/t2)  

torch.addcdiv(t, 0.1, t1, t2)

#计算sigmoid，激活函数

torch.sigmoid(t)

#将t限制在[0,1]之间，clamp(t,min,max)

torch.clamp(t,0,1)

#t+2进行就地运算  

t.add_(2)

归并操作

import torch

#生成一个含6个数的向量，从一到十均匀分成6个数

a=torch.linspace(0,10,6)

#使用view方法，把a变为2x3矩阵

a=a.view((2,3))

#沿y轴方向累加，即dim=0，维度为0

b=a.sum(dim=0)

#b 的形状为 [3]

#沿y轴方向累加，即dim=0,keepdim说明输出结果中是否保留维度1

b=a.sum(dim=0,keepdim=True)

#b 的形状为 [1,3]

比较操作

import torch

x=torch.linspace(0,10,6).view(2,3)

#求所有元素的最大值

torch.max(x) # 结果为 10

#求y轴方向的最大值，max(t,axis)，指定axis额外返回下标

torch.max(x,dim=0)

# 结果为 [6,8,10]

#求最大的2个元素，指定的axis维度上取最高的k个值，topk(t,k,axis)

torch.topk(x,1,dim=0)

# 结果为 [6,8,10], 对应索引为 tensor([[1, 1, 1]

矩阵操作

import torch

#根据list数据生成tensor

a=torch.tensor([2, 3])

b=torch.tensor([3, 4])

#dot(t1,t2),计算张量的内积，Torch中的dot是对两个为1D张量进行点积运算

torch.dot(a,b)

# 运行结果为 18

x=torch.randint(10,(2,3))

y=torch.randint(6,(3,4))

#mm(mat1，mat2)，计算矩阵乘法，mm是对2D的矩阵进行点积

torch.mm(x,y)

x=torch.randint(10,(2,2,3))

y=torch.randint(6,(2,3,4))

#bmm对含batch的3D进行点积运算。

torch.bmm(x,y)

numpy和pytorch的对照表

参考文献

吴茂贵《python深度学习基于pytorch》