PyTorch 的张量模块说明

本笔记大部分整合了一下博客内容，并嘉禾官方文档给出补充，以及按照自己的理解修改了布局 

(6条消息) pytorch Tensor及其基本操作_的博客-****博客_pytorch tensor的基本操作

Tensor的基本增删改查

 Torch本身属性，在创建时指定属性

dtype--data type

temp = torch.tensor( [data], dytpe= xxx)

可以指定tensor的元素的数据类型，一共有9种类型

device--存储tensor的设备

temp = torch.tensor( [data], devoce='cuda')

使用字符串表示tensor存储的设备，可以是'cpu'或者'cuda’

 

 

layout-- tensor的内存布局

目前，我们的torch.layout有torch.stried和torch.sparse_coo这两种，（一般默认值使用torch.stried）

troch.stried是dense Tensors最经常使用的memory layout，设置好torch.layout=torch.stried后，此时调用tensor.strides会返回一个整数列表（int list）：第k个整数代表tensors的第k维从一个元素转到下一个元素所需要的内存。

这个例子可以解读为在第一维中，一个元素到下一个元素需要5个内存，而在第二个维度中，一个元素到下一个元素需要一个内存

Tensor的创建

torch.tensor方法

temp = torch.tensor( [data], dtype= , device= ,layout= )

data可以是list, tuple, numpy array, scalar或其他类型

注意torch.tensor是复制型创建，如果想要索引型创建，需要使用torch.tensor_detach()或者是torch.from_numpy()

指定格式创建

根据数值要求

size是[1维，2维，3维...]的指定union

torch.zeros(*sizes, out=None, …)# 返回大小为sizes的零矩阵，这个out指的就是函数输出，没啥

torch.zeros_like(input, …) # 返回与input相同size的零矩阵

torch.ones(*sizes, out=None, …) #f返回大小为sizes的全1矩阵

torch.ones_like(input, …) #返回与input相同size的全1矩阵

torch.full(size, fill_value, …) #返回大小为sizes,单位值为fill_value的矩阵

torch.full_like(input, fill_value, …) 返回与input相同size，单位值为fill_value的矩阵

torch.arange(start=0, end, step=1, …) #返回从start到end, 单位步长为step的一维tensor.

torch.linspace(start, end, steps=100, …) #返回从start到end, 等距插值数目为steps的一维 tensor

torch.logspace(start, end, steps=100, …) #返回一维 tensor ，从10^start到10^end的等距steps个对数间隔

torch.repeat_interleave(input , int) #返回一维向量，对input遍历一遍，并且复制int个每个元素。

 

根据矩阵要求:

torch.eye(n, m=None, out=None,…) #返回2-D 的单位对角矩阵

torch.empty(*sizes, out=None, …) #返回被未初始化的数值填充，大小为sizes的tensor

torch.empty_like(input, …) # 返回与input相同size,并被未初始化的数值填充的tensor

按照概率生成:
torch.normal(mean, std, out=None, *size) #按照nean平均，标准差为std生成size的tensor

torch.rand(*size, out=None, dtype=None, …) #返回[0,1]之间均匀分布的随机数值

torch.rand_like(input, dtype=None, …) #返回与input相同size的tensor, 填充均匀分布的随机数值

torch.randint(low=0, high, size,…) #返回均匀分布的[low,high]之间的整数随机值

torch.randint_like(input, low=0, high, dtype=None, …) #略

torch.randn(*sizes, out=None, …) #返回大小为size,由均值为0，方差为1的正态分布的随机数值

torch.randn_like(input, dtype=None, …) #略

torch.randperm(n, out=None, dtype=torch.int64) # 返回0到n-1的数列的随机排列

torch.bernoulli(input)  # 以input为概率，生成伯努利分布（0-1分布,input表示概率值[0,1]）

import torch
import numpy as np

‘’‘

张量（Tensor）
tensor是一个多维数组，他是标量、向量、矩阵的高维拓展，
其中，标量是0维张量，向量是1维张量，矩阵是2维张量，RGB图像是3维张量.
tensor共有三类创建方式：直接式、基于数值式、基于概率式
'''
# 1、直接式
array = np.zeros((3, 3))
tensor1 = torch.tensor(array)  # array作为导入数据创建tensor，不共享id
tensor2 = torch.from_numpy(array)  # 基于array创建tensor。共享id
# 2、基于数值式
tensor3 = torch.zeros((3, 3))  # 不读取数据，直接创建0tensor
tensor4 = torch.zeros_like(tensor3)  # 不读取数据，直接创建与tensor3等size的0tensor
tensor5 = torch.ones((3, 3))  # 同上
tensor6 = torch.ones_like(tensor5)  # 同上
tensor7 = torch.full((3, 3), fill_value=4)  # 同上
tensor8 = torch.full_like(tensor7, fill_value=5)  # 同上
tensor9 = torch.linspace(start=1, end=10, steps=2)  # 建均分的1维张量（start，end，Steps=）
tensor10 = torch.logspace(start=1, end=10, steps=3, base=2)  # 建对数均分的1维张量（start，end，Steps=数列长度，base=对数函数的底，默认10）
tensor11 = torch.eye(n=3, m=4)  # 创建二维单位对角矩阵
# 基于概率式
tensor12 = torch.randn((3, 3))  # 生成标准正态分布（size=张量的形状）
tensor13 = torch.randn_like(tensor12)
tensor14 = torch.rand((3, 3))  # 生成在[0,1)的均匀分布
tensor15 = torch.rand_like(tensor14)
tensor16 = torch.randint(low=1, high=10, size=(3, 3))  # 生成在[low,high)的整数均匀分布（size=张量的形状）
tensor17 = torch.randint_like(tensor16, low=1, high=10)
tensor18 = torch.randperm(n=10)  # 生成0到n-1的随机排列（n=张量长度）
tensor19 = torch.bernoulli(tensor1)  # 以input为概率，生成伯努利分布（0-1分布,input表示概率值）

torch.tril(input, diagonal=0, out=None) #返回矩阵的下三角矩阵，其他为0      -> triangle low

torch.triu(input, diagonal=0, out=None) #返回矩阵的上三角矩阵，其他为0     -> triangle up

torch.diag(input, diagonal=0, out=None) #如果是1维，返回以之作为对角阵的矩阵，若是2维，返回对角向量，dianoal为0则是正对角，大于0在上，小于0在下

Tensor操作

基操

联结操作

torch.cat([tensor1,tensor2],dim=0,out=None) # 沿着dim连接tensors, 所有的tensor必须有相同的size或为empty， 其相反的操作为 torch.split() 和torch.chunk()

torch.stack(seq, dim=0, out=None) #同上

#注: .cat 和 .stack的区别在于 cat会增加现有维度的值,可以理解为续接，stack会新加增加一个维度，可以理解为叠加

cat([M,N]) 和 stack([M,N])的区别，cat是直接按照维度方向拼接，而stack是按照行堆叠后原来的行称为哪个维度，如:

A和B是个m*n的tensor，C=torch.stack((A,B),dim=i)
i=0时，C[0]=A, C[1]=B，A和B没有任何维度上的堆叠；
i=1时，C[0]=[A[0],B[0]], C[1]=[A[1],B[1]]······，相当于A和B在行这个维度上堆叠；
i=2时，C[0]=[ [A[0][0],B[0][0]], ······, [A[0][n-1],B[0][n-1]] ]······，相当于A和B在列这个维度上的堆叠。

cat和stack都是dim=0

cat dim=1, stack dim=2

 

torch.gather(input, dim, index, out=None) #返回沿着dim收集的新的tensor

就是说，按照dim的维度遍历input，指的是index元素在input中的维度槽，如

gather( M, 1, index）则为

[ M[ 0, index[0,0] ] , M[0, index[0,1] ] , ... , M[0, index[0,n] ],
  M[ 1, index[1,0] ] , M[1, index[1,1] ] , ... , M[1, index[1,n] ],
  M[ 2, index[2,0] ] , M[2, index[2,1] ] , ... , M[2, index[2,n] ],
        ............
  M[ m, index[m,0] ] , M[m, index[m,1] ] , ... , M[m, index[m,n] ] ]

out[i][j][k] = input[ index[i][j][k] ] [j] [k] # if dim == 0
out[i][j][k] = input[i] [index[i][j][k]] [k] # if dim == 1
out[i][j][k] = input[i] [j] [index[i][j][k]] # if dim == 2

拆分操作

torch.split(tensor, split_size_or_sections, dim=0) #按照dim方向将tensor 拆分成相应大小的组块

e.g.

 

torch.chunk(tensor, chunks, dim=0) #将tensor沿着dim拆分成相应数量的组块， 最后一块会小一些如果不能整除的话，就会除以比他小的最近能整除的数字

这两个拆分返回的是元组tuple，不是tensor.torch

索引操作

torch.index_select(input, dim=x, index=tensor) #按照dim选出其中的torch列，index必须是1维的（这个其实就是按维度抽样）

torch.mask_select(input, mask=tensor） #按照mask向量的bool值，取input得列向量，并按行展开拼接维一个tensor向量

 

改变自身状态的操作

torch.t(input) #矩阵和向量转置操作

torch.transpose(input, dim0, dim1) #转置tensor的dim0和dim1两个维度

torch.squeeze(input) #维度坍缩，把所有size的维度清除

torch.unsqueeze(input) #升维，把A*B升为1*A*B

Tensor.reshape(input_tensor, [x,-1,x,x]) -> output_tensor

输入tensor和需要转变成的维度，返回需要的结果，并非对原input_tensor进行操作

其中，后面的tuple对各个维度的描述可以用一个用-1代替，表示“系统你自己看着办”，注意，维度上重塑后的总数量必须和原来一致，否则会报错

torch.where(condition, yes, no) #判断con的每个元素的谓词P，yes则取yes对应的元素值，否则取no对应位置的值

torch.unbind(tensor, dim=0) #返回tuple 解除指定的dim的绑定,相当于按指定dim拆分，返回元组（返回多个tensor的都是返回元组）

torch.nonzero(input) #返回非0值的索引

Tensor点对点操作

torch.exp(input) #对每个元素都进行自然指数运算

torch.fmod(input, divisor, out=None) #返回input/divisor的余数

torch.fft(input, signal_ndim, normalized=False) #快速傅里叶变换，应该不是点对点操作吧

torch.[math](input) #对每个元素进行数学运算，例如上文exp

torch.add(input, [tensor/num]， alpha=num ) #out= input+[tensor/num]*alpha

 

torch.addcdiv(input, tensor1, tensor2, value=num) #out= input+ num*(tensor1/tensor2)

 

torch.addcdiv(input, tensor1, tensor2, value=num) #略

 

torch.mul/div(input, [tensor/num] ) #乘除

降维操作

torch.argmax(input, dim=None, keepdim=False) #返回最大值排序的索引值
torch.argmin(input, dim=None, keepdim=False) #返回最小值排序的索引值

torch.cumprod(input, dim, out=None) #y_i=x_1 * x_2 * x_3 … x_i
torch.cumsum(input, dim, out=None) #y_i=x_1 + x_2 + … + x_i

torch.dist(input, out, p=2) #返回input和out的p式距离
torch.mean() #返回平均值
torch.sum() #返回总和
torch.median(input) #返回中间值
torch.mode(input) #返回众数值
torch.unique(input, sorted=False) #返回1-D的唯一的tensor,每个数值返回一次.

output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long))
output
tensor([ 2, 3, 1])

torch.std(） #返回标准差
torch.var()   #返回方差

torch.norm(input, p=2) #返回p-norm的范式
torch.prod(input, dim, keepdim=False) #返回指定维度每一行的乘积

 

对比操作

torch.eq(input, other, out=None) #按成员进行等式操作，相同返回1

torch.equal(tensor1, tensor2) #如果tensor1和tensor2有相同的size和elements，则为true

torch.ge(input, other, out=None) # input>= other -> greater equal
torch.gt(input, other, out=None) # input>other
torch.le(input, other, out=None) # input=<other
torch.lt(input, other, out=None)  # input<other
torch.ne(input, other, out=None) # input != other 不等于not equal

torch.max() # 返回最大值
torch.min() # 返回最小值
torch.isnan(tensor) #判断是否为’nan’
torch.sort(input, dim=None, descending=False, out=None) #对目标input进行排序

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) #沿着指定维度返回最大k个数值及其索引值

torch.kthvalue(input, k, dim=None, deepdim=False, out=None) #沿着指定维度返回最小k个数值及其索引值

矩阵计算操作

torch.t(input) #矩阵和向量转置操作

torch.cross(input, other, dim=-1, out=None) #叉乘(外积)

torch.dot(tensor1, tensor2) #返回tensor1和tensor2的点乘

torch.mm(mat1, mat2, out=None) #返回矩阵mat1和mat2的乘积

torch.eig(a, eigenvectors=False, out=None) #返回矩阵a的特征值/特征向量

torch.det(A) #返回矩阵A的行列式

torch.trace(input) #返回2-d 矩阵的迹(对对角元素求和)

torch.histc(input, bins=100, min=0, max=0, out=None) #计算input的直方图