Deep Learning with Pytorch- A 60 Minute Blitz

以你之姓@ 2024-05-24 03:58 65阅读 0赞

## Deep Learning with Pytorch: A 60 Minute Blitz ##

###### Blitz ：以闪电战空袭 ######

#### 这篇文档的目标 ####

*  在一个较高的水平理解 Pytorch 的 Tensor 库和神经网络
 *  训练一个分类图像的小规模神经网络分类图像

##### 这篇文章假设你基本熟悉 numpy #####

### 什么是Pytorch ###

Pytorch是基于科学计算包的Python，目标两类人群  
1. 为利用 GPU 的能力取代 NumPy  
2. 提供最大灵活性和速度的深度学习研究平台

#### 开始 ####

##### Tensors #####

Tensors类似于Numpy的narrays，只是Tensors可以使用GPU加速计算  
`from __future__ import print_function`  
`import torch`

构建一个 5\*3 的未初始化矩阵  
`x = torch.Tensor(5, 3)`

构建一个随机初始化的矩阵  
`x = torch.rand(5, 3)`

获得矩阵的尺寸  
`print(x.size())`  
`Out: torch.Size([5, 3]) ; 输出的结果`

##### 操作 #####

Pytorch对操作有很多句法。在下面的例子我们会看到加法的操作  
`y = torch.rand(5, 3)`  
`print(x + y)`

或者, 加法语法②  
`torch.add(x, y)`

加法: 提供一个输出tensor作为参数  
`result = torch.Tensor(5, 3)`  
`torch.add(x, y, out=result)`  
`print(result)`

就地 ( in-place )加法  
`y.add_(x)`  
**Note : 任何使一个Tensor就地发生变化的操作都要在后面加上一个’\_’**

同样可以使用像 NumPy 一样的索引表示  
`print(x[:, 1])`

修改大小 :如果你要resize或者reshape tensor,可以使用torch.view  
`x = torch.randn(4, 4)`  
`y = x.view(16)`  
`z = x.view(-1, 8); -1的值会从另一维度推出`  
`print(x.size(), y.size(), z.size())`  
Out: torch.Size(\[4, 4\]), torch.Size(\[16\]), torch.Size(\[2, 8\])

还有 100+ 中操作, 看[**这里**][Link 1]

#### Numpy Bridge ####

将一个 Torch Tensor 转换成 NumPy array 或者反过来是一件很轻松的事情

Torch Tensor 和 NumPy array 会共享隐藏的内存地址,因此改变一个两者都将改变

##### 将一个 Torch Tensor 转换成 NumPy array #####

`a = torch.ones(5);`  
`b = a.numpy()`

看一下 NumPy array 是怎么样改变数值的  
`a.add_(1)`

##### 将一个 NumPy array 转换成 Torch Tensor #####

看一下怎样自动将 NumPy array 转换成 Torch Tensor  
`a = np.ones(5)`  
`b = torch.from_numpy(a)`  
`np.add(a, 1, out=a)`

#### CUDA Tensors ####

Tensors 可以使用**.cuda**方法转移至GPU运算

### 附录: 还有那100+中操作呢…. ###

#### Tensors ####

`torch.is_tensor(obj)`  
返回 True 如果 obj 是一个 Pytorch tensor  
`torch.is_storage(obj)`  
返回 True 如果 obj 是 [pytorch 存储对象][pytorch]  
`torch.set_default_tensor_type()`  
`torch.numel(input)`  
返回输入Tensor中元素总数(numel = number elements ? 我猜的)  
`torch.set_printoptions(precesion=None, threshold=None, edgeitems=None, linewidth=None, profile=None)`

设置打印选项

*  precision - 浮点数输出的精度位数 (默认为8 )
 *  threshold – 阈值，触发汇总显示而不是完全显示(repr)的数组元素的总数 （默认为1000）
 *  edgeitems – 汇总显示中，每维（轴）两端显示的项数（默认值为3）
 *  linewidth – 用于插入行间隔的每行字符数（默认为80）。Thresholded matricies will ignore this parameter.
 *  profile – pretty打印的完全默认值。 可以覆盖上述所有选项 (默认为short, full)

#### Creation Ops 创建操作 ####

`torch.eye(n, m=None, out=None)`

返回2-D张量, 除对角线为1其他全为0

`torch.from_numpy(ndarray)`

将numpy.ndarray转换为Pytorch的Tensor, 返回的张量Tensor和ndarray共享同一内存空间, 修改其中一个另一个也会被修改.

`torch.linspace(start, end, steps=100, out=None)`

返回一维Tensor, steps均分从 start 到 end, 包含端点

`torch.logspace(start, end, steps=100, out=None)`

返回一维tensor, steps均分从10start  10 s t a r t  到 10end  10 e n d  , 包含端点

`torch.ones(*size,out=None)`

返回所有元素都是标量1的tensor, 由size决定shape

`torch.ones_like(input, out=None)`

返回和input的size一样的所有元素都是1的tensor

`torch.arange(start=0, end, step=1, out=None)`

返回一维tensor,尺寸为(end-start)/step, \[start, end), 每两个相邻元素之间差step

`torch.range(start, end, step=1, out=None)`

就是比arange多了一个end元素  
**Warning : 该函数由于arange已被弃用**

`torch.zeros(*size, out=None)`

返回所有元素都是0的Tensor,由size决定shape

`torch.zeros_like(input, out=None)`

参照上面 ones\_like

`torch.rand(*sizes, out=None)`

返回一个Tensor, 包含了从区间(0, 1)的**均匀分布**中抽取的一组随机数, 形状由参数sizes定义.

`torch.randn(*sizes, out=None)`

返回一个Tensor, 包含了从**标准正态分布**(高斯白噪声)中抽取一组随机数, 形状有sizes指定

`torch.randperm(n, out=None)`

给定参数n, 返回一个从0到n-1的随机整数排列

`torch.arange(start, end, step=1, out=None)`

返回一个一维Tensor, 长度为floor(end−startstep)  f l o o r ( e n d − s t a r t s t e p )  , 包含从start从end, 以step为步长的一组序列值

`torch.zeros(*sizes, out=None)`

返回一个全为标量0的张量, 形状由sizes定义

#### 索引, 切片, 联合, 旋转操作 ####

`torch.cat(seq, dimension=0, out=None)`

cat for concatenate (成串)连结  
将给定的Tensor序列在给定的维度上连结, 除了在cat维, 所有Tensor必须size相同

`torch.chunk(tensor, chunks, dim=0)`

将一个在给定的维度上Tensor分解成给定数目的块

`torch.gather(input, dim, index, out=None)`

在一个给定维度上将索引张量index指定位置的值进行聚合

t = torch.Tensor([[1, 2], [3, 4]])
    torch.gather(t, dim=1, torch.LongTensor([[0, 0], [1, 0]]))
    1 1 # [0 0] 是指着t的第一行
    4 3 # [1 0] 是指着t的第二行

`torch.index_select(input, dim, index, out=None)`

沿着指定维度对输入进行切片, 取index中制定的相应项(index为一个LongTensor), 然后返回到一个新的张量, 返回的张量和原始张量在指定轴上有相同的维度(捕鱼原始张量共享内存空间)

x = torch.randn(3, 4)
     1.2045  2.4084  0.4001  1.1372
     0.5596  1.5677  0.6219 -0.7954
     1.3635 -1.2313 -0.5414 -1.8478
    indices = torch.LongTensor([0, 2])
    torch.index_select(x, dim=0, ,indices)
     1.2045  2.4084  0.4001  1.1372
     1.3635 -1.2313 -0.5414 -1.8478
    torch.index_select(x, dim=1, ,indices)
     1.2045  0.4001
     0.5596  0.6219
     1.3635 -0.5414

`torch.masked_select(input, mask, out=None)`

根据掩码张量mask(ByteTensor)中的二元值， 取输入张量中的指定项, 将去除的值返回到一个新的一维张量.

mask 和 input 有相同数量的元素数目, 但形状或者维度不需要相同, 返回的张量和原始张量不共享内存空间

x = torch.randn(3, 4)
    1.2045 2.4084 0.4001 1.1372
    0.5596 1.5677 0.6219 -0.7954
    1.3635 -1.2313 -0.5414 -1.8478
    mask = x.ge(0.5)
    1 1 0 1
    1 1 1 0
    1 0 0 0
    torch.masked_select(x, mask)
    1.2045
    2.4084
    1.1372
    0.5596
    1.5677
    0.6219
    1.3635

`torch.nonzero(input, out=None)`

返回一个包含输入input中非零元素索引的张量, 输出张量中每行包含的非零元素的索引

`torch.split(tensor, split_size(int), dim=0)`

将输入张量分割成相等形状(split\_size)的chunks(如果可分), 如果沿着指定维度的张量形状大小不能被split\_size整分, 则最后一个分块会小于其他分块. split\_size是沿着dim维度的整型, 剩下的维度全部选择

x = torch.randn(4, 5)
    tensor([[-0.0508,  0.2582,  0.6659, -0.4130, -0.1920],
            [-1.5397, -0.5102, -0.0232,  0.5928, -0.8344],
            [ 1.2239, -0.0847,  0.0059,  1.2770, -0.5065],
            [-0.6631,  1.1189, -0.3950,  0.6652, -1.2388]])
    torch.split(x, 2, dim=0)
    (tensor([[-0.0508,  0.2582,  0.6659, -0.4130, -0.1920],
             [-1.5397, -0.5102, -0.0232,  0.5928, -0.8344]]),
     tensor([[ 1.2239, -0.0847,  0.0059,  1.2770, -0.5065],
             [-0.6631,  1.1189, -0.3950,  0.6652, -1.2388]]))
    torch.split(x, 2, dim=1)
    (tensor([[-0.0508,  0.2582],
             [-1.5397, -0.5102],
             [ 1.2239, -0.0847],
             [-0.6631,  1.1189]]), 
     tensor([[ 0.6659, -0.4130],
             [-0.0232,  0.5928],
             [ 0.0059,  1.2770],
             [-0.3950,  0.6652]]), 
     tensor([[-0.1920],
             [-0.8344],
             [-0.5065],
             [-1.2388]]))

`torch.squeeze(input, dim=None, out=None)`

将输入张量形状中的**1**去除, 并返回. 如果输入张量维度为(A×1×B×1×C×1×D)  ( A × 1 × B × 1 × C × 1 × D ) , 输入形状为(A×B×C×D)  ( A × B × C × D )

`torch.stack(sequence, dim=0)`

沿着一个新维度对输入张量序列进行连接, 序列中所有的张量都应该是相同形状

x = torch.randn(2,1)
    # tensor([-0.7956,  0.0735])
    y = torch.randn(2,1)
    # tensor([-0.5577, -2.3484])
    torch.stack([x, y])    
    # tensor([[-0.7956,  0.0735],
    #         [-0.5577, -2.3484]])
    torch.stack([x, y], dim=1)
    # tensor([[-0.7956, -0.5577],
    #         [ 0.0735, -2.3484]])

`torch.t(input, out=None)`

输入一个二维张量, 并转置0,1维, 可以看成是**transpose(input, 0, 1)**的简写

`torch.transpose(input, dim0, dim1, out=None)`

返回输入Tensor的转置, 交换维度dim0和dim1, **输出张量和输出张量共享内存**

`torch.unbind(tensor, dim=0)`

移除指定维度之后, 返回一个元组, 包含了沿着指定维切片后的各个切片

In [61]: x = torch.randn(4, 5)
    tensor([[-1.5689,  0.2382,  0.7735, -0.3593,  1.0564],
            [ 0.3576, -1.2402,  0.1892,  0.9585, -2.5909],
            [ 0.5032,  1.8156,  1.6229,  0.2221,  0.3007],
            [ 0.8306, -0.5932,  0.7558, -1.3012, -0.6159]])
    
    In [63]: torch.unbind(x, 0)
    (tensor([-1.5689,  0.2382,  0.7735, -0.3593,  1.0564]),
     tensor([ 0.3576, -1.2402,  0.1892,  0.9585, -2.5909]),
     tensor([ 0.5032,  1.8156,  1.6229,  0.2221,  0.3007]),
     tensor([ 0.8306, -0.5932,  0.7558, -1.3012, -0.6159]))
    
    In [64]: torch.unbind(x, 1)
    (tensor([-1.5689,  0.3576,  0.5032,  0.8306]),
     tensor([ 0.2382, -1.2402,  1.8156, -0.5932]),
     tensor([ 0.7735,  0.1892,  1.6229,  0.7558]),
     tensor([-0.3593,  0.9585,  0.2221, -1.3012]),
     tensor([ 1.0564, -2.5909,  0.3007, -0.6159]))

`torch.unsqueeze(input, dim, out=None)`

返回一个新的张量, 对输入的指定位置插入维度1. **输出张量和输出张量共享内存**

In [65]: x = torch.randn(2, 3)
    tensor([[-0.4725, -1.7609, -0.3230],
            [ 1.1519,  1.1096, -0.4129]])
    
    In [67]: torch.unsqueeze(x, 1)
    tensor([[[-0.4725, -1.7609, -0.3230]],
            [[ 1.1519,  1.1096, -0.4129]]])
    In [70]: x.size()
    torch.Size([2, 1, 3])

#### **随机抽样 Randomly sampling** ####

`torch.manual_seed(seed)`

设定生成随机数的种子, 并返回一个torch.\_C.Generator对象

`torch.initial_seed()`

返回生成随机数的原始种子(python long)

`torch.get_rng_state()`

返回随机生成器状态(ByteTensor)

`torch.set_rng_state(new_state)`

设定随机生成器状态, 参数new\_state(ByteTensor)

`torch.default_generator = <torch._C.Generator object>`

`torch.bernoulli(input, out=None)`

从伯努利分布中抽取二元随机数0或1

输入张量(input)需包含用于抽取上述二元随机值的概率, 即0≤inputi≤1  0 ≤ i n p u t i ≤ 1

输出张量和输入张量大小相同, 且**输出张量第i个元素为1的概率是输入张量第i个元素的值**

torch.Tensor(3,3).uniform_(0, 1)
    tensor([[ 0.9106,  0.0777,  0.5530],
            [ 0.3175,  0.9495,  0.4689],
            [ 0.7621,  0.2560,  0.8528]])
    torch.bernoulli(a)
    tensor([[ 1.,  0.,  0.],
            [ 0.,  0.,  1.],
            [ 1.,  1.,  0.]])

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

返回一个张量, 每行包含从input的相应行中定义的多项分布中抽取的num\_samples个样本 **Note: input每行值的和不需要为1, 但是必须为正数**

如果参数**replacement**为True, 则样本可以重复抽取, 否则, 一个样本在每行不能被重复抽取. 参数**num\_samples**必须小于input长度(列数)

In [94]: weights = torch.Tensor([0, 10, 3, 0])
     tensor([  0.,  10.,   3.,   0.])
    
    In [96]: torch.multinomial(weights, 4)
     tensor([ 1,  2,  0,  0])

`torch.normal(means, std, out=None)`

返回一个张量, 包含从给定的参数**means, std** 的离散正态分布中抽取随机数, 均值**means** 是一个张量, 包含每个输出元素相关的正态分布的均值. **std** 是一个张量, 包含每个输出元素相关的正态分布的标准差, 均值和标准差的形状不须匹配, 但是每个张量的元素个数必须相同

`torch.normal(mean=0.0, std, out=None)`

与上面函数类似, 所有抽样的样本共享均值

`torch.normal(means, std=1.0, out=None)`

所有抽样的样本共享标准差

#### **序列化 Serialization** ####

`torch.save(obj, f, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>, pickle_protocol=2)`

保存一个对象到一个硬盘文件上

*  obj - 保存对象
 *  f - 类文件对象(返回文件的描述符)或一个保存文件名的字符串
 *  pickle\_module - 用于pickling元数据和对象的模块
 *  pickle\_protocol - 指定pickle protocol可以覆盖参数

`torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py')`

从磁盘文件中读取一个通过**torch.save()**保存的对象, `torch.load()` 可通过参数`map_location` 动态地进行内存重映射，使其能从不动设备中读取文件。一般调用时，需两个参数: storage 和 location tag. 返回不同地址中的storage，或着返回None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话，意味着其是从文件的地址标记到当前系统的地址标记的映射。 默认情况下， location tags中 “cpu”对应host tensors，‘cuda:device\_id’ (e.g. ‘cuda:2’) 对应cuda tensors。 用户可以通过register\_package进行扩展，使用自己定义的标记和反序列化方法。

torch.load('tensors.pt')
    # Load all tensors onto the CPU
    torch.load('tensors.pt', map_location=lambda storage, loc:storage)
    # Map tensors from GPU 1 to GPU 0
    torch.load('tensors.pt', map_location={
       'cuda:1':'cuda:0'})

#### **并行化 Parallelism** ####

`torch.get_num_threads()`

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

`torch.set_num_threads(int)`

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

#### **数学操作 Math operations** ####

##### **Pointwise Ops** #####

`torch.abs(input, out=None)`

计算输入张量的每个元素绝对值

`torch.acos(input, out=None) → Tensor`

返回一个新张量，包含输入张量每个元素的反余弦

`torch.add(input, value, out=None)`

对输入张量`input`逐元素加上**标量值**`value`，并返回结果到一个新的张量`out`，即 out=tensor\+valueout=tensor\+value  o u t = t e n s o r + v a l u e o u t = t e n s o r + v a l u e 。

`torch.add(input, value=1, other, out=None)`

`other` 张量的每个元素乘以一个标量值`value`，并加到`iput` 张量上。返回结果到输出张量`out`。即，out=input\+(other×value)  o u t = i n p u t + ( o t h e r × v a l u e )  . 两个张量input和other的尺寸不需要匹配, 但是元素总数必须一样. **注意** :当两个张量形状不匹配时，输入张量的形状会作为输出张量的尺寸。

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

用`tensor2`对`tensor1`逐元素相除，然后乘以标量值`value` 并加到`tensor`。张量的形状不需要匹配，但元素数量必须一致。tensor=tensor\+value×tensor1./tensor2  t e n s o r = t e n s o r + v a l u e × t e n s o r 1. / t e n s o r 2

`torch.addcmul(tensor, value=1, tensor1, tensor2, out=None)`

用`tensor2`对`tensor1`逐元素相乘，并对结果乘以标量值`value`然后加到`tensor`。 张量的形状不需要匹配，但元素数量必须一致。 tensor=tensor\+value×tensor1.×tensor2  t e n s o r = t e n s o r + v a l u e × t e n s o r 1 . × t e n s o r 2

`torch.asin(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的反正弦函数

`torch.atan(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的反正切函数

`torch.atan2(input1, input2, out=None)`

返回一个新张量，包含两个输入张量`input1`和`input2`的反正切函数

`torch.ceil(input, out=None)`

天井函数，对输入`input`张量每个元素向上取整, 即取不小于每个元素的最小整数，并返回结果到输出。

`torch.clamp(input, min, max, out=None)`

将输入`input`张量每个元素的夹紧到区间 \[min,max\]  \[ m i n , m a x \] ，并返回结果到一个新张量。 input中小于min的元素变为min, 大于max的元素变为max, 其余不变.

`torch.clamp(input, *, min, out=None)`

将输入`input`张量每个元素的限制到不小于`min` ，并返回结果到一个新张量。

a = torch.randn(4)
    Out[104]: tensor([ 0.2284, -0.7502,  0.3903, -0.3869])
    
     torch.clamp(a, min=0)
    Out[105]: tensor([ 0.2284,  0.0000,  0.3903,  0.0000])

`torch.clamp(input, *, max, out=None)`

将输入`input`张量每个元素的限制到不大于`max` ，并返回结果到一个新张量。

`torch.cos(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的余弦。

`torch.cosh(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的双曲余弦。

`torch.div(input, value, out=None)`

将`input`逐元素除以标量值`value`，并返回结果到输出张量`out`。 即out=tensor/value  o u t = t e n s o r / v a l u e

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

两张量`input`和`other`逐元素相除，并将结果返回到输出。即，out=input./other  o u t = i n p u t . / o t h e r  **两张量形状不须匹配，但元素数须一致**。

`torch.exp(tensor, out=None)`

返回一个新张量，包含输入`input`张量每个元素的指数。

`torch.floor`

地板函数: 返回一个新张量，包含输入`input`张量每个元素的floor，即不大于元素的最大整数。

`torch.fmod(input, divisor, out=None)`

计算除法余数。 除数与被除数可能同时含有整数和浮点数。此时，余数的正负与被除数相同。**divisor (Tensor or float) – 除数，一个数或与被除数相同类型的张量**

`torch.frac(tensor, out=None)`

返回每个元素的分数部分。

torch.frac(torch.Tensor([1, 2.5,-3.3]))
    Out[106]: tensor([ 0.0000,  0.5000, -0.3000])

`torch.lerp(start, end, weight, out=None)`

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

outi=starti\+weighti×(endi−starti)  o u t i = s t a r t i + w e i g h t i × ( e n d i − s t a r t i )

start = torch.arange(1, 5)
    Out[108]: tensor([ 1.,  2.,  3.,  4.])
     end = torch.Tensor(4).fill_(10)
    Out[114]: tensor([ 10.,  10.,  10.,  10.])
     torch.lerp(start,end,weight=0.5)
    Out[115]: tensor([ 5.5000,  6.0000,  6.5000,  7.0000])

`torch.log(input, out=None)`

计算`input` 的自然对数

`torch.log1p(input, out=None)`

计算 input\+1  i n p u t + 1 的自然对数 yi=log(xi\+1)  y i = l o g ( x i + 1 )

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

用标量值`value`乘以输入`input`的每个元素，并返回一个新的结果张量。 out=tensor×value  o u t = t e n s o r × v a l u e

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

两个张量`input`,`other`按元素进行相乘，并返回到输出张量。即计算outi=inputi×otheri  o u t i = i n p u t i × o t h e r i

`torch.neg(input, out=None)`

返回一个新张量，包含输入`input` 张量按元素取负。

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

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

outi=xexponent  o u t i = x e x p o n e n t

或者

outi=xexponenti  o u t i = x e x p o n e n t i

`torch.pow(base, input, out=None)`

`base` 为标量浮点值,`input`为张量， 返回的输出张量 `out` 与输入张量相同形状. outi=baseexponenti  o u t i = b a s e e x p o n e n t i

`torch.reciprocal(input, out=None)`

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

`torch.remainder(input, divisor, out=None)`

返回一个新张量，包含输入`input`张量每个元素的除法余数。 除数与被除数可能同时包含整数或浮点数。**余数与除数有相同的符号**

`torch.round(input, out=None)`

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

`torch.rsqrt(input, out=None)`

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

`torch.sigmoid(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的sigmoid值。

`torch.sign(input, out=None)`

符号函数：返回一个新张量，包含输入`input`张量每个元素的正负。

`torch.sin(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的正弦。

`torch.sinh(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的双曲正弦。

`torch.sqrt(input, out=None)`

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

`torch.tan(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的正切。

`torch.tanh(input, out=None)`

返回一个新张量，包含输入`input`张量每个元素的双曲正切。

`torch.trunc(input, out=None)`

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

##### Reduction Ops #####

`torch.cumprod(input, dim, out=None)`

返回输入沿指定维度的**累积积(每个元素都会编程它所在的指定维度之前所有元素的乘积(包括自己))**。例如，如果输入是一个N 元向量，则结果也是一个N 元向量，第`i` 个输出元素值为yi=x1×x2×x3×...×xi  y i = x 1 × x 2 × x 3 × . . . × x i

x = torch.Tensor([[1, 2, 3], [4, 5, 6]])
    # Out[123]: tensor([[ 1.,  2.,  3.],
    #                 [ 4.,  5.,  6.]])
     torch.cumprod(x, dim=1)
    # Out[125]: tensor([[   1.,    2.,    6.],
    #                 [   4.,   20.,  120.]])

`torch.cumsum(input, dim, out=None)`

返回输入沿指定维度的累积和。例如，如果输入是一个N元向量，则结果也是一个N元向量，第`i` 个输出元素值为 yi=x1\+x2\+x3\+...\+xi  y i = x 1 + x 2 + x 3 + . . . + x i

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

返回 (`input` \- `other`) 的 `p`范数 。

`torch.mean(input)`

返回输入张量所有元素的均值。

`torch.mean(input, dim, out=None)`

返回输入张量给定维度`dim`上每行的均值。输出形状与输入相同，除了给定维度上为1.

`torch.median(input, dim=-1, values=None, indices=None)`

返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的`LongTensor`。`dim`值默认为输入张量的最后一维。 输出形状与输入相同，除了给定维度上为1.***注意***: 这个函数还没有在`torch.cuda.Tensor`中定义

`torch.mode(input, dim=-1, values=None, indices=None)`

返回给定维`dim`上，每行的**众数值**。 同时返回一个`LongTensor`，包含众数值的索引。`dim`值默认为输入张量的最后一维。***注意***: 这个函数还没有在`torch.cuda.Tensor`中定义

`torch.norm(input, p=2)`

返回输入张量`input` 的p 范数。

`torch.norm(input, p, dim, out=None)`

返回输入张量给定维`dim` 上每行的p 范数。 输出形状与输入相同，除了给定维度上为1.

`torch.prod(input)`

返回输入张量`input` 所有元素的积。

`torch.prod(input, dim, out=None)`

返回输入张量给定维度上每行的积。 输出形状与输入相同，除了给定维度上为1.

`torch.std(input)`

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

`torch.std(input, dim, out=None)`

返回输入张量给定维度上每行的标准差。 输出形状与输入相同，除了给定维度上为1. dim∈\[−1,0\]  d i m ∈ \[ − 1 , 0 \]

`torch.sum(input)`

返回输入张量`input` 所有元素的和。

`torch.sum(input, dim, out=None)`

返回输入张量给定维度上每行的和。 输出形状与输入相同，除了给定维度上为1.

`torch.var(input)`

返回输入张量所有元素的方差

`torch.var(input, dim, out=None)`

返回输入张量给定维度上每行的方差。 输出形状与输入相同，除了给定维度上为1.

#### **比较操作 Comparison Ops** ####

`torch.eq(input, other, out=None)`

比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。 返回值： 一个 `torch.ByteTensor` 张量，包含了每个位置的比较结果(相等为1，不等为0 )

`torch.equal(tensor1, tensor2)`

如果两个张量有相同的形状和元素值，则返回`True` ，否则 `False`。

`torch.ge(input, other, out=None)`

逐元素比较`input`和`other`，即是否 input≥other  i n p u t ≥ o t h e r 。 **ge: greater equal** 返回值： 一个 `torch.ByteTensor` 张量，包含了每个位置的比较结果

`torch.gt(input, other, out=None)`

逐元素比较`input`和`other` ， 即是否input>other  i n p u t > o t h e r  如果两个张量有相同的形状和元素值，则返回`True` ，否则 `False`。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量 . 返回值： 一个 `torch.ByteTensor` 张量，包含了每个位置的比较结果

`torch.kthvalue(input, k, dim=None, out=None)`

取输入张量`input`指定维上第k 个最小值。如果不指定`dim`，则默认为`input`的最后一维。返回一个元组 *(values,indices)*，其中`indices`是原始输入张量`input`中沿`dim`维的第 `k` 个最小值下标。

`torch.le(input, other, out=None)`

逐元素比较`input`和`other` ， 即是否input≤other  i n p u t ≤ o t h e r  第二个参数可以为一个数或与第一个参数相同形状和类型的张量 . 返回值： 一个 `torch.ByteTensor` 张量，包含了每个位置的比较结果 **le : less equal**

`torch.lt(input, other, out=None)`

逐元素比较`input`和`other` ， 即是否 input<other  i n p u t < o t h e r  返回值： 一个 `torch.ByteTensor` 张量，包含了每个位置的比较结果

`torch.max()`

返回输入张量所有元素的最大值。

`torch.max(input, dim, max=None, max_indices=None)`

返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。

`torch.max(input, other, out=None)`

input的每个元素和other相应位置的元素进行比较 outi=max(tensori,otheri)  o u t i = m a x ( t e n s o r i , o t h e r i ) , input和other的形状不需要匹配, 但是元素总数要求相同

`torch.min(input)`

返回输入张量所有元素的最小值。

`torch.min(input, dim, min=None, min_indices=None)`

返回输入张量给定维度上每行的最小值，并同时返回每个最小值的位置索引。

`torch.min(input, other, out=None)`

`input`中逐元素与`other`相应位置的元素对比，返回最小值到输出张量。 outi=min(inputi,otheri)  o u t i = m i n ( i n p u t i , o t h e r i )  两张量形状不需匹配，但元素数须相同。

`torch.ne(input, other, out=None)`

逐元素比较`input`和`other` ， 即是否 input!=other  i n p u t ! = o t h e r 。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量 返回值： 一个 `torch.ByteTensor` 张量，包含了每个位置的比较结果 (如果 tensor != other 为`True` ，返回`1`)。

`torch.sort(input, dim=None, descending=False, out=None)`

对输入张量`input`沿着指定维按升序排序。如果不给定`dim`，则默认为输入的最后一维。如果指定参数`descending`为`True`，则按降序排序 . 返回元组 (sorted\_tensor, sorted\_indices) ， `sorted_indices` 为原始输入中的下标。

x
    Out[148]:
    tensor([[ 0.2442,  0.5686, -1.7293,  0.1022, -0.0359],
            [ 0.6838,  0.4000,  0.8362,  0.2984,  0.6517],
            [-0.4735, -0.2439, -0.3921, -1.1544, -0.3728],
            [ 1.3744,  0.7321,  0.9233,  0.0430,  0.5061]])
     torch.sort(x, dim=1)
    Out[149]:
    (tensor([[-1.7293, -0.0359,  0.1022,  0.2442,  0.5686],
             [ 0.2984,  0.4000,  0.6517,  0.6838,  0.8362],
             [-1.1544, -0.4735, -0.3921, -0.3728, -0.2439],
             [ 0.0430,  0.5061,  0.7321,  0.9233,  1.3744]]),
     tensor([[ 2,  4,  3,  0,  1],
             [ 3,  1,  4,  0,  2],
             [ 3,  0,  2,  4,  1],
             [ 3,  4,  1,  2,  0]]))

`torch.topk(input, k, dim=None, largest=True, sorted=True, out=None)`

沿给定`dim`维度返回输入张量`input`中 `k` 个最大值。 如果不指定`dim`，则默认为`input`的最后一维。 如果为`largest`为 `False` ，则返回最小的 `k` 个值。 返回一个元组 *(values,indices)*，其中`indices`是原始输入张量`input`中测元素下标。 如果设定布尔值`sorted` 为*True*，将会确保返回的 `k` 个值被排序。

#### **其他操作 Other Operations** ####

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

返回沿着维度`dim`上，两个张量`input`和`other`的向量积（[**叉积**][Link 2]）。 `input`和`other` 必须有相同的形状，且指定的`dim`维上size须为`3`。 如果不指定`dim`，则默认为第一个尺度为`3`的维。

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

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

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

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

diagonal相当于对角线相对于主对角线差了几条对角线, 当diagonal为不同的值时, 函数选择的对角线也是不同的

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

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

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

> 返回一个张量，包含规范化后的各个子张量，使得沿着`dim`维划分的各子张量的p范数小于`maxnorm`。 **注意** 如果p范数的值小于`maxnorm`，则当前子张量不需要修改。

`torch.trace(input)`

返回输入2维矩阵对角线元素的和(迹)

`torch.tril(input, k=0, out=None)`

返回一个张量`out`，包含输入矩阵(2D张量)的下三角部分，`out`其余部分被设为`0`。这里所说的下三角部分为矩阵指定对角线(**参数k指定**)`diagonal`之上的元素。 参数`k`控制对角线: - `k` = 0, 主对角线 - `k` > 0, 主对角线之上 - `k` < 0, 主对角线之下

In [172]: torch.tril(x, 1)
    Out[172]:
    tensor([[ 0.4708,  0.8223,  0.0000,  0.0000],
            [-0.9161, -1.6687,  0.1482,  0.0000],
            [ 0.3284, -2.1040,  0.7475,  1.6485],
            [-1.0157,  0.7602, -0.0066, -0.1975]])
    
    In [173]: torch.tril(x, -1)
    Out[173]:
    tensor([[ 0.0000,  0.0000,  0.0000,  0.0000],
            [-0.9161,  0.0000,  0.0000,  0.0000],
            [ 0.3284, -2.1040,  0.0000,  0.0000],
            [-1.0157,  0.7602, -0.0066,  0.0000]])

`torch.triu(input, k=0, out=None)`

参见上面的函数

`torch.eig(a, eigenvectors=False, out=None)`

计算实方阵`a` 的特征值和特征向量

返回值： 元组，包括：

*  e (Tensor): a 的右特征向量
 *  v (Tensor): 如果`eigenvectors`为`True`，则为包含特征向量的张量; 否则为空张量

`torch.gels(B, A, out=None)`

对形如m×n  m × n  的满秩矩阵A计算其最小二乘和最小范数问题的解

如果m≥n  m ≥ n  , 求解最小二乘问题 min∥AX−B∥F  m i n ‖ A X − B ‖ F

如果m≤n  m ≤ n  , 求解最小范数问题 min∥X∥s.t.AX=B  m i n ‖ X ‖ s . t . A X = B

返回矩阵X  X 的前n行包含解, 余下的行包含残差信息: 相应的列从第n行开始计算的每列的欧式距离

`torch.ger(vec1, vec2, out=None)`

计算两向量`vec1`,`vec2`的张量积。如果`vec1`的长度为`n`,`vec2`长度为`m`，则输出`out`应为形如n x m的矩阵。

`torch.gesv(B, A, out=None)`

X,LU=torch.gesv(B,A) X , L U = t o r c h . g e s v ( B , A ) 返回线性方程组 AX=B  A X = B 的解

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

`torch.inverse(input, out=None)`

对输入的**方阵input** 取逆

`torch.mm(mat1, mat2, out=None)`

对矩阵`mat1`和`mat2`进行相乘。 如果`mat1` 是一个 n×m 张量，`mat2` 是一个 m×p 张量，将会输出一个 n×p 张量`out`。

`torch.mv(mat, vec, out=None)`

对矩阵`mat`和向量`vec`进行相乘。 如果`mat` 是一个n×m 张量，`vec` 是一个m元 1维张量，将会输出一个n元 1维张量。

`torch.svd(input, some=True, out=None)`

U,S,V=torch.svd(A)  U , S , V = t o r c h . s v d ( A )  返回对形如 n×m的实矩阵 A 进行奇异值分解的结果，使得 A=USV’∗。 UU 形状为 n×n，SS 形状为 n×m ，VV 形状为 m×m

some代表了需要计算的奇异值的个数, 如果some=True, 计算一部分, 否则计算全部

`torch.symeig(input, eigenvectors=False, upper=True, out=None)`

e,V=torch.symeig(input)  e , V = t o r c h . s y m e i g ( i n p u t )  返回实对称矩阵`input`的特征值和特征向量。

input 和 V 为 m×m 矩阵，e 是一个m 维向量。 此函数计算`intput`的所有特征值(和特征向量)，使得 input=Vdiag(e)V′

[Link 1]: http://pytorch.org/docs/stable/torch.html
[pytorch]: https://pytorch-cn.readthedocs.io/zh/latest/package_references/Storage/
[Link 2]: https://wikipedia.olqy.cc/