pytorch learning

     torch.multinomial(input,num_samples,replacement=False, out=None)

        input 是一个张量，每一行的元素为非负，且每一行的元素和为正，固定的每一行中的列元素的相对大小决定了在抽取时被取到的概率大小。num_samples 表示对每一行的抽取的次数，

        如果replacement 为 true，则允许在每一行重复抽取，这种情况下，那一行对应的列元素为零的概率为零时， 就不能被抽到了。

    torch.normal(mean = tensor,std = tensor, out = None)

        这里均值由原先的means关键词改为mean，且均值，方差分别共享参数

并行化 parallelism

    torch.get_num_threads

    torch.get_num_threads() → int

           获得用于并行化CPU操作的OpenMP线程数

    torch.set_num_threads

    torch.set_num_threads(int)

           设定用于并行化CPU操作的OpenMP线程数

 

     torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor

                用tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor

           torch.atan & torch.atan2

               一般情况下用atan即可，当对所求出角度的取值范围有特殊要求时，应使用atan2

     torch.div(input, other, out=None)

                两张量input和other逐元素相除，并将结果返回到输出.

     torch.fmod(input, divisor, out=None) → Tensor

                计算除法余数。 除数与被除数可能同时含有整数和浮点数。此时，余数的正负与被除数相同。

torch.lerp

torch.lerp(input, end, weight, out=None)

对两个张量以input，end做线性插值， 将结果返回到输出张量。

即，out i =start i +weight∗(end i −start i ) outi=starti+weight∗(endi−starti)

参数：

• input (Tensor) – 起始点张量
• end (Tensor) – 终止点张量
• weight (float) – 插值公式的weight,必须是float，不能为张量
• out (Tensor, optional) – 结果张量

torch.log1p

torch.log1p(input, out=None) → Tensor

计算 input+1 input+1
的自然对数 y i =log(x i +1)input+1 的自然对数

torch.mul

torch.mul(input, value, out=None)

用标量值value乘以输入input的每个元素，并返回一个新的结果张量。 out=tensor∗value out=tensor∗value

torch.mul(input, other, out=None)

两个张量input,other按元素进行相乘，并返回到输出张量

torch.pow(input, exponent, out=None)

对输入input的按元素求exponent次幂值，并返回结果张量。 幂值exponent 可以为单一 float 数或者与input相同元素数的张量。

当幂值为标量时，执行操作：out_i=x_i*exponent

 当幂值为张量时，执行操作：out_i=x_i*exponent_i

torch.reciprocal

torch.reciprocal(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的倒数，即  1.0/x。

参数：

• input (Tensor) –  输入张量
• out (Tensor, optional)

torch.round

torch.round(input, out=None) → Tensor

返回一个新张量，将输入input张量每个元素舍入到最近的整数。

 

 

torch.rsqrt

torch.rsqrt(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的平方根倒数。

torch.trunc

torch.trunc(input, out=None) → Tensor

返回一个新张量，包含输入input张量每个元素的截断值(标量x的截断值是最接近其的整数，其比x更接近零。简而言之，有符号数的小数部分被舍弃)。

torch.cumprod

torch.cumprod(input, dim, out=None) → Tensor

返回输入沿指定维度的累积积。例如，如果输入是一个N 元向量，则结果也是一个N 元向量，

yi=x1∗x2∗x3∗...∗xi yi=x1∗x2∗x3∗...∗xi

torch.cumsum

torch.cumsum(input, dim, out=None) → Tensor

返回输入沿指定维度的累积和。例如，如果输入是一个N元向量，则结果也是一个N元向量

torch.dist

torch.dist(input, other, p=2, out=None) → Tensor

返回 (input - other) 的 p范数

torch.mean(input, dim, out=None) → Tensor

返回输入张量给定维度dim上每行的均值。

输出形状与输入相同，除了给定维度上为1

torch.median

torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的LongTensor。

dim值默认为输入张量的最后一维。 输出形状与输入相同，除了给定维度上为1.

注意: 这个函数还没有在torch.cuda.Tensor中定义

torch.mode

torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回给定维dim上，每行的众数值。 同时返回一个LongTensor，包含众数职的索引。dim值默认为输入张量的最后一维。

输出形状与输入相同，除了给定维度上为1.

注意: 这个函数还没有在torch.cuda.Tensor中定义

torch.std(input) → float

返回输入张量input 所有元素的标准差

torch.topk

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

沿给定dim维度返回输入张量input中 k 个最大值。 如果不指定dim，则默认为input的最后一维。 如果为largest为 False ，则返回最小的 k 个值。

返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。 如果设定布尔值sorted 为_True_，将会确保返回的 k 个值被排序。

torch.cross

torch.cross(input, other, dim=-1, out=None) → Tensor

返回沿着维度dim上，两个张量input和other的向量积（叉积）。 input和other 必须有相同的形状，且指定的dim维上size必须为3。

如果不指定dim，则默认为第一个尺度为3的维。

torch.diag

torch.diag(input, diagonal=0, out=None) → Tensor

• 如果输入是一个向量(1D 张量)，则返回一个以input为对角线元素的2D方阵
• 如果输入是一个矩阵(2D 张量)，则返回一个包含input对角线元素的1D张量

参数diagonal指定对角线:

• diagonal = 0, 主对角线
• diagonal > 0, 主对角线之上
• diagonal < 0, 主对角线之下

• torch.histc

  torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor
  

  计算输入张量的直方图。以min和max为range边界，将其均分成bins个直条，然后将排序好的数据划分到各个直条(bins)中。如果min和max都为0, 则利用数据中的最大最小值作为边界。

  参数：

  • input (Tensor) – 输入张量
  • bins (int) – 直方图 bins(直条)的个数(默认100个)
  • min (int) – range的下边界(包含)
  • max (int) – range的上边界(包含)
  • out (Tensor, optional) – 结果张量

  • torch.renorm

    torch.renorm(input, p, dim, maxnorm, out=None) → Tensor
    

    返回一个张量，包含规范化后的各个子张量，使得沿着dim维划分的各子张量的p范数小于maxnorm。

    注意 如果p范数的值小于maxnorm，则当前子张量不需要修改。

• torch.orgqr

  torch.orgqr()
  

  torch.ormqr

  torch.ormqr()
  

  torch.potrf

  torch.potrf()
  

  torch.potri

  torch.potri()
  

  torch.potrs

  torch.potrs()
  

  torch.pstrf

  torch.pstrf()
  

  torch.qr

  torch.qr(input, out=None) -> (Tensor, Tensor)
  

  计算输入矩阵的QR分解：返回两个矩阵q q
  ,r r
  ， 使得 x=q∗r x=q∗r
  ，这里q q
    是一个半正交矩阵与 r r
  是一个上三角矩阵

  本函数返回一个thin(reduced)QR分解。

  注意 如果输入很大，可能可能会丢失精度。

  注意 本函数依赖于你的LAPACK实现，虽然总能返回一个合法的分解，但不同平台可能得到不同的结果。

  Irrespective of the original strides, the returned matrix q will be transposed, i.e. with strides (1, m) instead of (m, 1).

  参数：

  • input (Tensor) – 输入的2维张量
  • out (tuple, optional) – 输出元组tuple，包含Q和R

  • torch.gesv

    torch.gesv(B, A, out=None) -> (Tensor, Tensor)
    

    X,LU=torch.gesv(B,A) X,LU=torch.gesv(B,A)
    ，返回线性方程组AX=B AX=B
    的解。

    LU 包含两个矩阵L，U。A须为非奇异方阵，如果A是一个m×m m×m
    矩阵，B 是m×k m×k
    矩阵，则LU 是m×m m×m
    矩阵， X为m×k m×k
    矩阵

    参数：

    • B (Tensor) – m×k m×k
      矩阵
    • A (Tensor) – m×m m×m
      矩阵
    • out (Tensor, optional) – 可选地输出矩阵X X

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

out i =input i /other i  outi=inputi/otheri

 

转载于:https://www.cnblogs.com/zw-randy/p/9749408.html