跟着官方入门pytorch(二)

2019-06-16 本文已影响0人 NJUST江波

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张量，包含在区间 $10^{start}$ 和 $10^{end}$ 上以对数刻度均匀间隔的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为标量： $out^i=input_i^{exponent}$
exponent为张量： $out^i=input_i^{exponent_i}$
torch.pow(base, input)
base为标量，input张量： $out^i=base^{input_i}$
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相应位置的元素对比，返回最小值到输出张量。
$out_i=min(tensor_i,other_i)$
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加到最终结果。
$res=(beta∗mat)+(alpha∗\sum(batch1_i \times batch2_i))$
torch.addmm(beta=1, mat, alpha=1, mat1, mat2)
对矩阵mat1和mat2进行矩阵乘操作。矩阵mat加到最终结果。
$res = (beta*mat + （alpha* mat1 \times mat2)$
torch.addmv(beta=1, tensor, alpha=1, mat, vec)
对矩阵mat和向量vec对进行相乘操作。向量tensor加到最终结果。
$res = (beta*tensor + （alpha* mat \times vec)$
torch.addr(beta=1, mat, alpha=1, vec1, vec2)
对向量vec1和vec2对进行张量积操作。矩阵mat加到最终结果。
$res = (beta*mat + （alpha* vec1 \times vec2)$
torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2)
对两个批batch1和batch2内存储的矩阵进行批矩阵乘操作，再加上矩阵mat得到最终结果。
$res_i = (beta*mat_i + （alpha* batch1_i \times batch2_i)$
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), $A = USV^{'}$
torch.symeig(input, eigenvectors=False)
返回实对称矩阵input的特征值和特征向量。eigenvectors=False只计算特征值

跟着官方入门pytorch(二)

pytorch torch包

函数

猜你喜欢

热点阅读