pytorch torch包
torch 包含了多维张量的数据结构以及基于其上的多种数学操作。
函数
- torch.is_tensor(obj)
判断obj是否为一个 pytorch tensor。 - torch.is_storage(obj)
判断obj是否为一个 pytorch storage对象。 - torch.set_default_tensor_type(type)
设置默认的tensor中的数据类型 - torch.numel(tensor)
返回tensor张量中的元素个数 - torch.eye(n, m=None, out=None)
返回一个2维float张量，对角线位置全1，其它位置全0。m默认等于n。 - torch.from_numpy(ndarray)
将numpy.ndarray 转换为pytorch的 longtensor。注意：返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。 - torch.linspace(start, end, steps=step, out=None)
返回一个1维float张量，包含在区间start 和 end 上均匀间隔的step个点。 输出1维张量的长度为step。 - torch.logspace(start, end, steps=step, out=None)
返回一个1维float张量，包含在区间和
上以对数刻度均匀间隔的steps个点。 输出1维张量的长度为step。
- torch.rand(*sizes)
返回一个float张量，包含了从区间[0,1)的均匀分布中抽取的一组随机数，形状由可变参数sizes 决定。 - torch.randn(*sizes)
返回一个float张量，包含了从标准正态分布N(0,1)中抽取的一组随机数，形状由可变参数sizes 决定。 - torch.randperm(n)
返回一个从0 到n -1 的随机整数排列构成的Longtensor。 - torch.arange(start, end, step=steps)
返回一个在区间[start,end)内，从start开始，step为步长的一组值构成的float张量。 - torch.zeros(*sizes)
返回一个全为标量 0 的float张量，形状由可变参数sizes 决定。 - torch.cat(inputs, dimension=dimension)
在给定维度上对输入的张量序列inputs进行连接操作。inputs:tensor构成的序列。 - torch.chunk(tensor, chunks, dim=dimension)
在给定维度上将输入张量进行分块。chunks:分块个数。 - torch.gather(input, dim, index)
沿给定轴dim，将输入的index张量对应的值进行聚合。
index必须为longtensor。
例子：
t = torch.Tensor([[1,2,3],[4,5,6]])
index_a = torch.LongTensor([[0,0],[0,1]])
index_b = torch.LongTensor([[0,1,1],[1,0,0]])
print(t)
print(torch.gather(t,dim=1,index=index_a))
print(torch.gather(t,dim=0,index=index_b))
>>tensor([[1., 2., 3.],
[4., 5., 6.]])
>>tensor([[1., 1.],
[4., 5.]])
>>tensor([[1., 5., 6.],
[4., 2., 3.]])
计算torch.gather(t,dim=1,index=index_a)细节：
output[0,0] = input[0,index[0,0]]= input[0,0]=1
output[0,1] = input[0,index[0,1]]= input[0,0]=1
output[1,0] = input[1,index[1,0]]= input[1,0]=4
output[1,1] = input[1,index[1,1]]= input[1,1]=5
计算torch.gather(t,dim=0,index=index_b)细节：
output[0,0] = input[index[0,0],0]=input[0,0] = 1
output[0,1] = input[index[0,1],1]=input[1,1] = 5
output[0,2] = input[index[0,2],2]=input[1,2] = 6
output[1,0] = input[index[1,0],0]=input[1,0] = 4
output[1,1] = input[index[1,1],1]=input[0,1] = 2
output[1,2] = input[index[1,2],2]=input[0,2] = 3
- torch.index_select(input, dim, index)
沿着指定维度对输入选取指定index进行切片.
index必须为longtensor。 - torch.masked_select(input, mask, out=None)
根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1维张量。
mask须跟input有相同数量的元素数目，但形状或维度不需要相同。 - torch.nonzero(input)
返回一个包含输入input中非零元素索引的张量。 - torch.split(tensor, split_size, dim=0)
将输入张量延指定维度分割成相等形状的split_size个trunks。 - torch.squeeze(input, dim=None)
将输入张量形状中的1 去除并返回。若指定dim，则只会在该给定维度上挤压。
注：返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。 - torch.stack(sequence, dim=0)
沿着一个维度对输入张量序列进行连接。
与cat的区别在于，stack会增加一个新的维度。例如a、b为2x3的tensor，在dim = 0时拼接，cat返回的结果为2x6的tensor，stack返回的结果为2x2x3的结果。
a=torch.rand((1,2))
>>> b=torch.rand((1,2))
>>> print(a)
tensor([[0.8738, 0.8688]])
>>> print(b)
tensor([[0.9889, 0.6731]])
>>> print(torch.stack((a,b),0))
tensor([[[0.8738, 0.8688]],
[[0.9889, 0.6731]]])
>>> print(torch.stack((a,b),1))
tensor([[[0.8738, 0.8688],
[0.9889, 0.6731]]])
>>> print(torch.stack((a,b),0).size())
torch.Size([2, 1, 2])
>>> print(torch.stack((a,b),1).size())
torch.Size([1, 2, 2])
- torch.t(input)
输入一个矩阵（2维张量），并转置0, 1维。被视为函数transpose(input, 0, 1)的简写函数。 - torch.transpose(input, dim0, dim1)
输入矩阵input交换维度dim0和dim1。 输出张量与输入张量共享内存，改变其中一个会导致另外一个也被修改。 - torch.unsqueeze(input, dim)
在指定的维度增加一维。 - torch.unbind(tensor,dim)
删除某个维度。 - torch.manual_seed(seed)
设定生成随机数的种子。 - torch.initial_seed()
返回生成随机数的原始种子值。 - torch.bernoulli(input)
以input 对应位置的值作为伯努利分布中取1的概率，按该分布采样取值。 - torch.normal(means, std)
返回从正态分布采样得到的随机tensor。 - torch.multinomial(input, num_samples,replacement=False, out=None)
把input中的每行作为权重，采样得到对应的Index。replacement =Ture代表可重复采样。 - torch.save(obj,f)
将obj保存到f文件。 - torch.load(f,map_location = location )
读取f文件
# Load all tensors onto the CPU
>>> torch.load('tensors.pt', map_location='cpu')
# Load all tensors onto the CPU, using a function
>>> torch.load('tensors.pt', map_location=lambda storage, loc: storage)
# Load all tensors onto GPU 1
>>> torch.load('tensors.pt', map_location=lambda storage, loc: storage.cuda(1))
# Map tensors from GPU 1 to GPU 0
>>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'})
- torch.abs(input)
对张量每个元素计算绝对值 - torch.acos(input)
对张量每个元素计算反余弦 - torch.cos(input)
对张量每个元素计算余弦 - torch.cosh(input)
对张量每个元素计算双曲余弦 - torch.sinh(input)
对张量每个元素计算双曲正弦 - torch.sin(input）
对张量每个元素计算正弦 - torch.asin(input)
对张量每个元素计算反正弦 - torch.tan(input)
对张量每个元素计算正切 - torch.atan(input)
对张量每个元素计算反正切 - torch.tanh(input)
对张量每个元素计算双曲正切 - torch.ceil(input）
对张量每个元素向上取整 - torch.floor(input）
对张量每个元素向下取整 - torch.round(input)
对张量每个元素四舍五入取整 - torch.add(input, value)
对张量每个元素加上value - torch.add(input, value=value, other)
= (other*value)+input
注：张量 input and other的尺寸不需要匹配，但元素总数必须一样 - torch.addcdiv(tensor, value= value, tensor1, tensor2)
用tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor。 - torch.addcmul(tensor, value=value, tensor1, tensor2)
用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor。 - torch.clamp(input, min, max)
对张量每个元素限制到区间[min,max] - torch.div(input, value)
对张量每个元素除以value - torch.div(input,other)
input与other逐元素相除 - torch.exp(tensor)
对张量每个元素求指数 - torch.remainder(input, divisor)
返回input张量每个元素除以divisor的余数，余数与除数divisor有相同的符号。 - torch.fmod(input, divisor)
返回input张量每个元素除以divisor的余数，余数与被除数input有相同的符号。 - torch.frac(tensor)
返回每个元素的分数部分。 - torch.lerp(start, end, weight)
返回start和end做线性插值的结果。
out = start + weight*(end - start) - torch.log(input)
返回每个元素的自然对数 - torch.log1p(input)
返回每个元素+1的自然对数 - torch.mul(input, value)
返回每个元素*value - torch.mul(input, other)
返回input与other逐元素相乘 - torch.neg(input)
返回每个元素取负 - torch.pow(input, exponent)
返回input按元素求exponent次幂值。
exponent为标量：
exponent为张量： - torch.pow(base, input)
base为标量，input张量： - torch.reciprocal(input)
返回每个元素的倒数 - torch.rsqrt(input)
返回每个元素的平方根倒数 - torch.sigmoid(input)
返回每个元素的sigmoid函数对应的值 - torch.sign(input)
返回每个元素的正负符号(+(-)1) - torch.sqrt(input)
返回每个元素的平方根 - torch.trunc(input)
返回一个新张量，包含输入input张量每个元素的截断值(舍弃其小数部分) - torch.cumprod(input, dim)
返回输入沿指定维度的累积积。 - torch.cumsum(input, dim)
返回输入沿指定维度的累积和。 - torch.dist(input, other, p=p)
返回 (input - other) 的 p范数 。 - torch.mean(input)
返回输入张量所有元素的均值。 - torch.mean(input, dim)
返回输入张量给定维度dim上每行的均值。 - torch.median(input, dim=-1)
返回给定维dim上，每行的中位数值和其索引。 - torch.mode(input, dim=-1)
返回给定维dim上，每行的众数值和其索引。 - torch.norm(input, p=2)
返回输入张量input 的p 范数。
torch.norm(input, p, dim)
返回输入张量给定维dim 上每行的p 范数。 - torch.prod(input)
返回输入张量input 所有元素的积。 - torch.std(input)
返回输入张量input 所有元素的标准差。 - torch.sum(input)
返回输入张量input 所有元素的和。 - torch.sum(input, dim)
返回输入张量给定维度上每行的和。 - torch.var(input)
返回输入张量所有元素的方差 - torch.eq(input, other)
逐元素比较input, other是否相等。 - torch.equal(tensor1, tensor2)
如果两个张量有相同的形状和元素值，则返回True ，否则 False - torch.ge(input, other)
逐元素比较input和other，即是否 input>=other。 - torch.gt(input, other)
逐元素比较input和other。 - torch.kthvalue(input, k, dim=None)
取输入张量input指定维上第k 个最小值和其索引。 - torch.le(input, other)
逐元素比较input和other ， 即是否input<=other - torch.lt(input, other)
逐元素比较input和other ， 即是否 input<other - torch.max(input)
返回输入张量所有元素的最大值。 - torch.min(input)
返回输入张量所有元素的最小值。 - torch.min(input, dim)
返回输入张量给定维度上每行的最小值，并同时返回每个最小值的位置索引 - torch.min(input, other)
input中逐元素与other相应位置的元素对比，返回最小值到输出张量。
- torch.ne(input, other)
逐元素比较input和other ， 即是否 input!=other。1相等，0不相等。 - torch.sort(input, dim=None, descending=False)
对输入张量input沿着指定维按升序排序。如果不给定dim，则默认为输入的最后一维。如果指定参数descending为True，则按降序排序。 - torch.topk(input, k, dim=None, largest=True, sorted=True)
返回沿给定dim维度输入张量input中 k 个最大值和其下标。largest为 False ，则返回最小的 k 个值。返回一个元组 (values,indices)，sorted 为True，将会确保返回的 k 个值被排序。 - torch.cross(input, other)
返回两个张量input和other的向量积（叉积） - torch.diag(input, diagonal=0)
如果输入是一个向量(1D 张量)，则返回一个以input为对角线元素的2D方阵
如果输入是一个矩阵(2D 张量)，则返回一个包含input对角线元素的1D张量
参数diagonal指定对角线 - torch.histc(input, bins=bins, min=min, max=max)
计算输入张量的直方图。以min和max为range边界，将其均分成bins个直条，然后将排序好的数据划分到各个直条(bins)中。如果min和max都为0, 则利用数据中的最大最小值作为边界。 - torch.renorm(input, p, dim, maxnorm)
返回一个张量，包含规范化后的各个子张量，使得沿着dim维划分的各子张量的p范数小于maxnorm。
如果p范数的值小于maxnorm，则当前子张量不需要修改 - torch.trace(input)
返回输入2维矩阵对角线元素的迹 - torch.tril(input, k=0)
返回一个张量，包含输入矩阵(2D张量)的下三角部分，其余部分被设为0。
参数k控制对角线: k = 0, 主对角线;k > 0, 主对角线之上 ;k < 0, 主对角线之下 - torch.triu(input, k=0)
返回一个张量，包含输入矩阵(2D张量)的上三角部分，其余部分被设为0。
参数k控制对角线: k = 0, 主对角线;k > 0, 主对角线之上 ;k < 0, 主对角线之下 - torch.addbmm(beta=1, mat, alpha=1, batch1, batch2)
对两个批batch1和batch2内存储的矩阵进行批矩阵乘操作，附带reduced add 步骤( 所有矩阵乘结果沿着第一维相加)。矩阵mat加到最终结果。
- torch.addmm(beta=1, mat, alpha=1, mat1, mat2)
对矩阵mat1和mat2进行矩阵乘操作。矩阵mat加到最终结果。
- torch.addmv(beta=1, tensor, alpha=1, mat, vec)
对矩阵mat和向量vec对进行相乘操作。向量tensor加到最终结果。
- torch.addr(beta=1, mat, alpha=1, vec1, vec2)
对向量vec1和vec2对进行张量积操作。矩阵mat加到最终结果。
- torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2)
对两个批batch1和batch2内存储的矩阵进行批矩阵乘操作，再加上矩阵mat得到最终结果。
- torch.bmm(batch1, batch2)
对存储在两个批batch1和batch2内的矩阵进行批矩阵乘操作。 - torch.dot(tensor1, tensor2)
返回两个张量的点乘结果 - torch.eig(a, eigenvectors=False)
返回实方阵a 的特征值和特征向量 - torch.ger(vec1, vec2)
计算两向量vec1,vec2的张量积。n*m的矩阵 - torch.inverse(input)
返回方阵input的逆 - torch.mm(mat1, mat2)
返回矩阵mat1和mat2进行相乘的结果 - torch.mv(mat, vec)
返回矩阵mat和向量vec进行相乘的结果 - torch.qr(input)
计算输入矩阵的QR分解：返回两个矩阵q ,r， 使得 x=q∗r ，这里q 是一个半正交矩阵与 r 是一个上三角矩阵 - torch.svd(input, some=True)
返回对形如 n×m的实矩阵 A 进行奇异值分解的结果，U,S,V=torch.svd(A), - torch.symeig(input, eigenvectors=False)
返回实对称矩阵input的特征值和特征向量。eigenvectors=False只计算特征值
