Torch
 
torch包含了多维张量的数据结构以及基于其上的多种数学运算。此外，它也提供了多种实用工具，其中一些可以更有效地对张量和任意类型进行序列化的工具。
 
它具有CUDA的对应实现，可以在NVIDIA GPU上进行张量运算(计算能力>=3.0)。
 
张量 Tensors
 
torch.is_tensor(obj)
 
判断是否为张量，如果是pytorch张量，则返回True
 
参数： obj (Object) – 判断对象
torch.is_storage(obj)
 
判断是否为pytorch Storage，如何是，则返回True
 
参数： input (Object) – 判断对象
torch.set_default_tensor_type(t)
 
torch.numel(input)->int
 
返回input 张量中的元素个数
 
参数: input (Tensor) – 输入张量
例子:
 
>>> a = torch.randn(1,2,3,4,5)
>>> torch.numel(a)
120
>>> a = torch.zeros(4,4)
>>> torch.numel(a)
16
 
torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)
 
设置打印选项。 完全参考自 Numpy。
 
参数:
 
precision – 浮点数输出的精度位数 (默认为8 )
threshold – 阈值，触发汇总显示而不是完全显示(repr)的数组元素的总数 （默认为1000）
edgeitems – 每个维度的开头和结尾的摘要中的数组项目数（默认为3）。
linewidth – 用于插入行间隔的每行字符数（默认为80）。阈值矩阵将忽略此参数。
profile – pretty打印的完全默认值。 可以覆盖上述所有选项 (默认为short, full)
创建操作 Creation Ops
 
torch.eye(n, m=None, out=None)
 
返回一个2维张量，对角线数字为1，其它位置为0
 
参数:
 
n (int) – 行数
m (int, 可选) – 列数.如果为None,则默认为n
out (Tensor,可选) - 输出张量
返回值: 2维张量，对角线为1，其它为0
 
返回类型： Tensor
 
例子:
 
>>> torch.eye(3)
 1  0  0
 0  1  0
 0  0  1
[torch.FloatTensor of size 3x3]
 
torch.from_numpy(ndarray) → Tensor
 
将numpy.ndarray转换为Tensor。 返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能调整大小。
 
例子:
 
>>> a = numpy.array([1, 2, 3])
>>> t = torch.from_numpy(a)
>>> t
torch.LongTensor([1, 2, 3])
>>> t[0] = -1
>>> a
array([-1,  2,  3])
 
torch.linspace(start, end, steps=100, out=None) → Tensor
 
返回start和end之间长度为steps的一维张量 参数:
 
start (float) – 点集的起始值
end (float) – 点集的最终值
steps (int) – 在start 和 end间的采样数,即返回多少个数
out (Tensor, 可选的) – 结果张量
例子:
 
>>> torch.linspace(1.0,10.0,steps=5,out=None)

  1.0000
  3.2500
  5.5000
  7.7500
 10.0000
[torch.FloatTensor of size 5]

>>> torch.linspace(-10, 10, steps=5)

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

>>> torch.linspace(start=-10, end=10, steps=5)

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]
 
torch.logspace(start, end, steps=100, out=None) → Tensor
 
返回一个1维张量，包含在区间10^start和10^end上以对数刻度均匀间隔的steps个点。 输出1维张量的长度为steps。
 
参数:
 
start (float) – 该点集的起始点
end (float) – 该点集的最终值
steps (int) – 在start 和 end间生成的样本数
out (Tensor, 可选) – 结果张量
例子:
 
>>> torch.logspace(start=-10, end=10, steps=5)

 1.0000e-10
 1.0000e-05
 1.0000e+00
 1.0000e+05
 1.0000e+10
[torch.FloatTensor of size 5]

>>> torch.logspace(start=0.1, end=1.0, steps=5)

  1.2589
  2.1135
  3.5481
  5.9566
 10.0000
[torch.FloatTensor of size 5]
 
torch.ones(*sizes, out=None) → Tensor
 
返回一个全为1的张量，形状由可变参数sizes定义。
 
参数:
 
sizes (int...) – 整数序列，定义了输出形状,如：(5,5)，(2)
out (Tensor, 可选) – 结果张量
例子:
 
>>> torch.ones(2, 3)

 1  1  1
 1  1  1
[torch.FloatTensor of size 2x3]

>>> torch.ones(5)

 1
 1
 1
 1
 1
[torch.FloatTensor of size 5]
 
torch.rand(*sizes, out=None) → Tensor
 
返回一个张量，填充在[0,1]区间的一组均匀分布随机数。 Tensor的形状由变量sizes定义。
 
参数:
 
sizes (int...) – 整数序列，定义了输出形状
out (Tensor, 可选) - 结果张量
例子：
 
>>> torch.rand(4)

 0.9193
 0.3347
 0.3232
 0.7715
[torch.FloatTensor of size 4]

>>> torch.rand(2, 3,out=None)

 0.5010  0.5140  0.0719
 0.1435  0.5636  0.0538
[torch.FloatTensor of size 2x3]
 
torch.randn(*sizes, out=None) → Tensor
 
返回一个张量，包含了从正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随机数。 Tensor的形状由变量sizes定义。
 
参数:
 
sizes (int...) – 整数序列，定义了输出形状
`out (Tensor, 可选) - 结果张量
例子：:
 
>>> torch.randn(4)

-0.1145
 0.0094
-1.1717
 0.9846
[torch.FloatTensor of size 4]

>>> torch.randn(2, 3)

 1.4339  0.3351 -1.0999
 1.5458 -0.9643 -0.3558
[torch.FloatTensor of size 2x3]
 
torch.randperm(n, out=None) → LongTensor
 
输入参数n，返回一个从0 到n -1的随机整数排列。
 
参数:
 
n(int) – 上限(独占),即最大值
例子：
 
>>> torch.randperm(4)

 2
 1
 3
 0
[torch.LongTensor of size 4]
 
torch.arange(start, end, step=1, out=None) → Tensor
 
返回一个1维张量，长度为floor((end−start)/step),floor代表向下取整。包含从start到end，以step为步长的一组序列值(默认步长为1)。
 
参数:
 
start (float) – 该点集的起始点
end (float) – 该点集的终止点
step (float) – 相邻点的间隔大小
out (Tensor, 可选的) – 结果张量
例子：
 
>>> torch.arange(1, 4)

 1
 2
 3
[torch.FloatTensor of size 3]

>>> torch.arange(1, 2.5, 0.5)

 1.0000
 1.5000
 2.0000
[torch.FloatTensor of size 3]
 
torch.range(start, end, step=1, out=None) → Tensor
 
返回一个1维张量，长度为floor((end−start)/step)+1，其中floor代表向下取整数。从start开始，end为结尾，以step为步长的一组值。 step 是两个值之间的间隔，即 Xi+1=Xi+step
 
参数:
 
start (float) – 该点集的起始点
end (float) – 该点集的最终值
step (int) – 相邻点之间的间隔大小
out (Tensor, 可选的) – 结果张量
例子：
 
>>> torch.range(1, 4)

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.range(1, 4, 0.5)

 1.0000
 1.5000
 2.0000
 2.5000
 3.0000
 3.5000
 4.0000
[torch.FloatTensor of size 7]
 
torch.zeros(*sizes, out=None) → Tensor
 
返回一个全0的张量，形状由可变参数sizes定义。
 
参数:
 
sizes (int...) – 整数序列，定义了输出形状
out (Tensor, 可选) – 结果张量
例子：
 
>>> torch.zeros(2, 3)

 0  0  0
 0  0  0
[torch.FloatTensor of size 2x3]

>>> torch.zeros(5)

 0
 0
 0
 0
 0
[torch.FloatTensor of size 5]
 
索引,切片,连接,变异操作
 
torch.cat(seq, dim=0, out=None) → Tensor
 
在给定维度上对输入的张量序列seq 进行连接操作。
 
torch.cat()可以看做 torch.split() 和 torch.chunk()的逆运算。
 
cat()函数可以通过下面例子很好的的理解。
 
参数:
 
seq（Tensors的序列） - 可以是相同类型的Tensor的任何python序列。
dim（int，可选） - 张量连接的尺寸
 
out（Tensor，可选） - 输出参数
 
例子：
 

>>> x = torch.randn(2, 3)
>>> x

0.5983 -0.0341  2.4918
1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]
 
 
 
 
  
 
   
torch.cat((x, x, x), 0)
 
  
 
 
 
 
0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 [torch.FloatTensor of size 6x3]
 
 
 
 
  
 
   
torch.cat((x, x, x), 1)
 
  
 
 
 
 
0.5983 -0.0341 2.4918 0.5983 -0.0341 2.4918 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 1.5981 -0.5265 -0.8735 1.5981 -0.5265 -0.8735 [torch.FloatTensor of size 2x9]
 

```python
torch.chunk(tensor, chunks, dim=0)
 
将张量沿着给定维度分解成的多个块。
 
参数:
 
tensor (Tensor) – 待分块的输入张量
chunks (int) – 分块的个数
dim (int) – 沿着此维度进行分块
torch.gather(input, dim, index, out=None) → Tensor
 
沿给定轴dim，将输入索引张量index指定位置的值进行聚合。
 
对一个3维张量，输出可以定义为：
 
out[i][j][k] = tensor[index[i][j][k]][j][k]  # dim=0
out[i][j][k] = tensor[i][index[i][j][k]][k]  # dim=1
out[i][j][k] = tensor[i][j][index[i][j][k]]  # dim=3
 
如果输入是一个n维张量（(x0,x1...,xi−1,xi,xi+1,...,xn−1)和暗=我，然后指数必须是一个n维张量的大小(x0,x1,...,xi−1,y,xi+1,...,xn−1)其中y > = 1和有同样大小的指标。
 
参数：
 
input(Tensor) - 源张量
dim(int) - 要索引的轴
index(LongTensor) - 要收集的元素的索引
out(Tensor，可选) - 目的张量
例子：
 
>>> t = torch.Tensor([[1,2],[3,4]])
>>> torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]]))
 1  1
 4  3
[torch.FloatTensor of size 2x2]
 
torch.index_select(input, dim, index, out=None) → Tensor
 
返回一个新的张量，其索引input 张量沿尺寸 dim使用的条目中index这是一个LongTensor。
 
返回的Tensor具有与原始Tensor相同数量的尺寸。
 
注意： 返回的张量不与原始张量共享内存空间。
 
参数:
 
input (Tensor) – 输入张量
dim (int) – 索引的轴
index (LongTensor) – 包含索引下标的一维张量
out (Tensor, 可选的) – 目标张量
例子：
 
>>> x = torch.randn(3, 4)
>>> x

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]
 

torch.masked_select(input, mask, out=None) → Tensor
 
根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1D张量，
 
张量 mask须跟input张量有相同数量的元素数目，但形状或维度不需要相同。 注意： 返回的张量不与原始张量共享内存空间。
 
参数:
 
input (Tensor) – 输入张量
mask (ByteTensor) – 掩码张量，包含了二元索引值
out (Tensor, 可选的) – 目标张量
例子：
 
>>> x = torch.randn(3, 4)
>>> x

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]
 
torch.nonzero
 
torch.nonzero(input, out=None) → LongTensor
 
返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。
 
如果输入input有n维，则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。
 
参数:
 
input (Tensor) – 源张量
out (LongTensor, 可选的) – 包含索引值的结果张量
例子：
 
>>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))

 0
 1
 2
 4
[torch.LongTensor of size 4x1]

>>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0],
...                             [0.0, 0.0, 1.2, 0.0],
...                             [0.0, 0.0, 0.0,-0.4]]))

 0  0
 1  1
 2  2
 3  3
[torch.LongTensor of size 4x2]
 
torch.split
 
torch.split(tensor, split_size, dim=0)
 
将输入张量分割成相等形状的chunks（如果可分）。 如果沿指定维的张量形状大小不能被split_size 整分， 则最后一个分块会小于其它分块。
 
参数:
 
tensor (Tensor) – 待分割张量
split_size (int) – 单个分块的形状大小
dim (int) – 沿着此维进行分割
torch.squeeze
 
torch.squeeze(input, dim=None, out=None)
 
将输入张量形状中的1 去除并返回。 如果输入是形如\((A \times 1\times B \times 1 \times C \times 1 \times D) \)，那么输出形状就为： \((A \times B \times C \times D) \)
 
当给定dim时，那么挤压操作只在给定维度上。例如，输入形状为: \((A \times 1 \times B) \), squeeze(input, 0) 将会保持张量不变，只有用 squeeze(input, 1)，形状会变成 \( (A \times B )\)。
 
注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
 
参数:
 
input (Tensor) – 输入张量
dim (int, 可选的) – 如果给定，则input只会在给定维度挤压
out (Tensor, 可选的) – 输出张量
例子：
 
>>> x = torch.zeros(2,1,2,1,2)
>>> x.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x)
>>> y.size()
(2L, 2L, 2L)
>>> y = torch.squeeze(x, 0)
>>> y.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x, 1)
>>> y.size()
(2L, 2L, 1L, 2L)
 
torch.stack[source]
 
torch.stack(sequence, dim=0)
 
沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。
 
参数:
 
sqequence (Sequence) – 待连接的张量序列
dim (int) – 插入的维度。必须介于 0 与 待连接的张量序列数之间。
torch.t
 
torch.t(input, out=None) → Tensor
 
输入一个矩阵（2维张量），并转置0, 1维。 可以被视为函数transpose(input, 0, 1)的简写函数。
 
参数:
 
input (Tensor) – 输入张量
 
out (Tensor, 可选的) – 结果张量
 

>>> x = torch.randn(2, 3)
>>> x

0.4834  0.6907  1.3417
-0.1300  0.5295  0.2321
[torch.FloatTensor of size 2x3]
 
 
 
 
  
 
   
torch.t(x)
 
  
 
 
 
 
0.4834 -0.1300 0.6907 0.5295 1.3417 0.2321 [torch.FloatTensor of size 3x2]
 

### torch.transpose
```python
torch.transpose(input, dim0, dim1, out=None) → Tensor
 
返回输入矩阵input的转置。交换维度dim0和dim1。 输出张量与输入张量共享内存，所以改变其中一个会导致另外一个也被修改。
 
参数:
 
input (Tensor) – 输入张量
dim0 (int) – 转置的第一维
dim1 (int) – 转置的第二维
>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.transpose(x, 0, 1)

 0.5983  1.5981
-0.0341 -0.5265
 2.4918 -0.8735
[torch.FloatTensor of size 3x2]
 
torch.unbind
 
torch.unbind(tensor, dim=0)[source]
 
移除指定维后，返回一个元组，包含了沿着指定维切片后的各个切片
 
参数:
 
tensor (Tensor) – 输入张量
dim (int) – 删除的维度
torch.unsqueeze
 
torch.unsqueeze(input, dim, out=None)
 
返回一个新的张量，对输入的制定位置插入维度 1
 
注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
 
如果dim为负，则将会被转化\( dim+input.dim()+1 \)
 
参数:
 
tensor (Tensor) – 输入张量
dim (int) – 插入维度的索引
out (Tensor, 可选的) – 结果张量
>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
 1  2  3  4
[torch.FloatTensor of size 1x4]
>>> torch.unsqueeze(x, 1)
 1
 2
 3
 4
[torch.FloatTensor of size 4x1]
 
随机抽样 Random sampling
 
torch.manual_seed
 
torch.manual_seed(seed)
 
设定生成随机数的种子，并返回一个 _torch.C.Generator 对象.
 
参数: seed (int or long) – 种子.
 
torch.initial_seed
 
torch.initial_seed()
 
返回生成随机数的原始种子值（python long）。
 
torch.get_rng_state
 
torch.get_rng_state()[source]
 
返回随机生成器状态(ByteTensor)
 
torch.set_rng_state
 
torch.set_rng_state(new_state)[source]
 
设定随机生成器状态 参数: new_state (torch.ByteTensor) – 期望的状态
 
torch.default_generator
 
torch.default_generator = <torch._C.Generator object>
 
torch.bernoulli
 
torch.bernoulli(input, out=None) → Tensor
 
从伯努利分布中抽取二元随机数(0 或者 1)。
 
输入张量须包含用于抽取上述二元随机值的概率。 因此，输入中的所有值都必须在［0,1］区间，即 \( 0<=input_i<=1 \)
 
输出张量的第i个元素值， 将会以输入张量的第i个概率值等于1。
 
返回值将会是与输入相同大小的张量，每个值为0或者1 参数:
 
input (Tensor) – 输入为伯努利分布的概率值
out (Tensor, 可选的) – 输出张量(可选)
例子：
 
>>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
>>> a

 0.7544  0.8140  0.9842
 0.5282  0.0595  0.6445
 0.1925  0.9553  0.9732
[torch.FloatTensor of size 3x3]

>>> torch.bernoulli(a)

 1  1  1
 0  0  1
 0  1  1
[torch.FloatTensor of size 3x3]

>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
>>> torch.bernoulli(a)

 1  1  1
 1  1  1
 1  1  1
[torch.FloatTensor of size 3x3]

>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
>>> torch.bernoulli(a)

 0  0  0
 0  0  0
 0  0  0
[torch.FloatTensor of size 3x3]
 
torch.multinomial
 
torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor
 
返回一个张量，每行包含从input相应行中定义的多项分布中抽取的num_samples个样本。
 
当抽取样本时，依次从左到右排列(第一个样本对应第一列)。
 
如果输入input是一个向量，输出out也是一个相同长度num_samples的向量。如果输入input是有 \(m \)行的矩阵，输出out是形如\( m \times n \)的矩阵。
 
如果参数replacement 为 True, 则样本抽取可以重复。否则，一个样本在每行不能被重复抽取。
 
参数num_samples必须小于input长度(即，input的列数，如果是input是一个矩阵)。
 
参数:
 
input (Tensor) – 包含概率值的张量
num_samples (int) – 抽取的样本数
replacement (bool, 可选的) – 布尔值，决定是否能重复抽取
out (Tensor, 可选的) – 结果张量
例子：
 
>>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
>>> torch.multinomial(weights, 4)

 1
 2
 0
 0
[torch.LongTensor of size 4]

>>> torch.multinomial(weights, 4, replacement=True)

 1
 2
 1
 2
[torch.LongTensor of size 4]
 
torch.normal()
 
torch.normal(means, std, out=None)
 
返回一个张量，包含从给定参数means,std的离散正态分布中抽取随机数。 均值means是一个张量，包含每个输出元素相关的正态分布的均值。 std是一个张量，包含每个输出元素相关的正态分布的标准差。 均值和标准差的形状不须匹配，但每个张量的元素个数须相同。
 
参数:
 
means (Tensor) – 均值
std (Tensor) – 标准差
out (Tensor) – 可选的输出张量
torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))

 1.5104
 1.6955
 2.4895
 4.9185
 4.9895
 6.9155
 7.3683
 8.1836
 8.7164
 9.8916
[torch.FloatTensor of size 10]
 
torch.normal(mean=0.0, std, out=None)
 
与上面函数类似，所有抽取的样本共享均值。
 
参数:
 
means (Tensor,可选的) – 所有分布均值
std (Tensor) – 每个元素的标准差
out (Tensor) – 可选的输出张量
例子:
 
>>> torch.normal(mean=0.5, std=torch.arange(1, 6))

  0.5723
  0.0871
 -0.3783
 -2.5689
 10.7893
[torch.FloatTensor of size 5]
 
torch.normal(means, std=1.0, out=None)
 
与上面函数类似，所有抽取的样本共享标准差。
 
参数:
 
means (Tensor) – 每个元素的均值
std (float, 可选的) – 所有分布的标准差
out (Tensor) – 可选的输出张量
例子:
 
>>> torch.normal(means=torch.arange(1, 6))

 1.1681
 2.8884
 3.7718
 2.5616
 4.2500
[torch.FloatTensor of size 5]
 
序列化 Serialization
 
torch.saves[source]
 
torch.save(obj, f, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>, pickle_protocol=2)
 
保存一个对象到一个硬盘文件上 参考: Recommended approach for saving a model 参数：
 
obj – 保存对象
f － 类文件对象 (返回文件描述符)或一个保存文件名的字符串
pickle_module – 用于pickling元数据和对象的模块
pickle_protocol – 指定pickle protocal 可以覆盖默认参数
torch.load[source]
 
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进行扩展，使用自己定义的标记和反序列化方法。
 
参数:
 
f – 类文件对象 (返回文件描述符)或一个保存文件名的字符串
map_location – 一个函数或字典规定如何remap存储位置
pickle_module – 用于unpickling元数据和对象的模块 (必须匹配序列化文件时的pickle_module )
例子:
 
>>> 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
 
torch.get_num_threads() → int
 
获得用于并行化CPU操作的OpenMP线程数
 
torch.set_num_threads
 
torch.set_num_threads(int)
 
设定用于并行化CPU操作的OpenMP线程数
 
数学操作Math operations
 
Pointwise Ops
 
torch.abs
 
torch.abs(input, out=None) → Tensor
 
计算输入张量的每个元素绝对值
 
例子：
 
>>> torch.abs(torch.FloatTensor([-1, -2, 3]))
FloatTensor([1, 2, 3])
 
torch.acos(input, out=None) → Tensor
 
torch.acos(input, out=None) → Tensor
 
返回一个新张量，包含输入张量每个元素的反余弦。 参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4)
>>> a

-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.acos(a)
 2.2608
 1.2956
 1.1075
    nan
[torch.FloatTensor of size 4]
 
torch.add()
 
torch.add(input, value, out=None)
 
对输入张量input逐元素加上标量值value，并返回结果到一个新的张量out，即 \( out = tensor + value \)。
 
如果输入input是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。
 
input (Tensor) – 输入张量
value (Number) – 添加到输入每个元素的数
out (Tensor, 可选的) – 结果张量
>>> a = torch.randn(4)
>>> a

 0.4050
-1.2227
 1.8688
-0.4185
[torch.FloatTensor of size 4]

>>> torch.add(a, 20)

 20.4050
 18.7773
 21.8688
 19.5815
[torch.FloatTensor of size 4]
 
torch.add(input, value=1, other, out=None)
 
other 张量的每个元素乘以一个标量值value，并加到iput 张量上。返回结果到输出张量out。即，\( out=input+(other∗value ) \)
 
两个张量 input and other的尺寸不需要匹配，但元素总数必须一样。
 
如果other是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。
 
参数:
 
input (Tensor) – 第一个输入张量
value (Number) – 用于第二个张量的尺寸因子
other (Tensor) – 第二个输入张量
out (Tensor, 可选的) – 结果张量
例子：
 
>>> import torch
>>> a = torch.randn(4)
>>> a

-0.9310
 2.0330
 0.0852
-0.2941
[torch.FloatTensor of size 4]

>>> b = torch.randn(2, 2)
>>> b

 1.0663  0.2544
-0.1513  0.0749
[torch.FloatTensor of size 2x2]

>>> torch.add(a, 10, b)
 9.7322
 4.5770
-1.4279
 0.4552
[torch.FloatTensor of size 4]
 
torch.addcdiv
 
torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor
 
对tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor。
 
张量的形状不需要匹配，但元素数量必须一致。
 
如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。
 
参数：
 
tensor (Tensor) – 张量，对 tensor1 ./ tensor 进行相加
value (Number, 可选的) – 标量，对 tensor1 ./ tensor2 进行相乘
tensor1 (Tensor) – 张量，作为被除数(分子)
tensor2 (Tensor) –张量，作为除数(分母)
out (Tensor, 可选的) – 输出张量
例子：
 
>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcdiv(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]
 
torch.addcmul
 
torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor
 
用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor。 张量的形状不需要匹配，但元素数量必须一致。 如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。
 
参数：
 
tensor (Tensor) – 张量，对tensor1 ./ tensor 进行相加
value (Number, 可选的) – 标量，对 tensor1 . tensor2 进行相乘
tensor1 (Tensor) – 张量，作为乘子1
tensor2 (Tensor) –张量，作为乘子2
out (Tensor, 可选的) – 输出张量
例子：
 
>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcmul(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]
 
torch.asin
 
torch.asin(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的反正弦函数
 
参数：
 
tensor (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.asin(a)
-0.6900
 0.2752
 0.4633
    nan
[torch.FloatTensor of size 4]
 
torch.atan
 
torch.atan(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的反正切函数
 
参数：
 
tensor (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.atan(a)
-0.5669
 0.2653
 0.4203
 0.9196
[torch.FloatTensor of size 4]
 
torch.atan2
 
torch.atan2(input1, input2, out=None) → Tensor
 
返回一个新张量，包含两个输入张量input1和input2的反正切函数
 
参数：
 
input1 (Tensor) – 第一个输入张量
input2 (Tensor) – 第二个输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.atan2(a, torch.randn(4))
-2.4167
 2.9755
 0.9363
 1.6613
[torch.FloatTensor of size 4]
 
torch.ceil
 
torch.ceil(input, out=None) → Tensor
 
天井函数，对输入input张量每个元素向上取整, 即取不小于每个元素的最小整数，并返回结果到输出。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.ceil(a)

 2
 1
-0
-0
[torch.FloatTensor of size 4]
 
torch.clamp
 
torch.clamp(input, min, max, out=None) → Tensor
 
将输入input张量每个元素的夹紧到区间 \([min, max] \)，并返回结果到一个新张量。
 
操作定义如下：
 
      | min, if x_i < min
y_i = | x_i, if min <= x_i <= max
      | max, if x_i > max
 
如果输入是FloatTensor or DoubleTensor类型，则参数min max 必须为实数，否则须为整数。
 
参数：
 
input (Tensor) – 输入张量
min (Number) – 限制范围下限
max (Number) – 限制范围上限
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=-0.5, max=0.5)

 0.5000
 0.3912
-0.5000
-0.5000
[torch.FloatTensor of size 4]
 
torch.clamp(input, *, min, out=None) → Tensor
 
将输入input张量每个元素的限制到不小于min ，并返回结果到一个新张量。
 
如果输入是FloatTensor or DoubleTensor类型，则参数 value 必须为实数，否则须为整数。
 
参数：
 
input (Tensor) – 输入张量
value (Number) – 限制范围下限
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=0.5)

 1.3869
 0.5000
 0.5000
 0.5000
[torch.FloatTensor of size 4]
 
torch.clamp(input, *, max, out=None) → Tensor
 
将输入input张量每个元素的限制到不大于max ，并返回结果到一个新张量。
 
如果输入是FloatTensor or DoubleTensor类型，则参数 value 必须为实数，否则须为整数。
 
参数：
 
input (Tensor) – 输入张量
value (Number) – 限制范围上限
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, max=0.5)

 0.5000
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
 
torch.cos
 
torch.cos(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的余弦。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.cos(a)
 0.8041
 0.9633
 0.9018
 0.2557
[torch.FloatTensor of size 4]
 
torch.cosh
 
torch.cosh(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的双曲余弦。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.cosh(a)
 1.2095
 1.0372
 1.1015
 1.9917
[torch.FloatTensor of size 4]
 
torch.div()
 
torch.div(input, value, out=None)
 
将input逐元素除以标量值value，并返回结果到输出张量out。 即 \( out=tensor/value \)
 
如果输入是FloatTensor or DoubleTensor类型，则参数 value 必须为实数，否则须为整数。
 
参数：
 
input (Tensor) – 输入张量
value (Number) – 除数
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(5)
>>> a

-0.6147
-1.1237
-0.1604
-0.6853
 0.1063
[torch.FloatTensor of size 5]

>>> torch.div(a, 0.5)

-1.2294
-2.2474
-0.3208
-1.3706
 0.2126
[torch.FloatTensor of size 5]
 
torch.div(input, other, out=None)
 
两张量input和other逐元素相除，并将结果返回到输出。即， \( out_i= input_i / other_i \)
 
两张量形状不须匹配，但元素数须一致。
 
注意：当形状不匹配时，input的形状作为输出张量的形状。
 
参数：
 
input (Tensor) – 张量(分子)
other (Tensor) – 张量(分母)
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4,4)
>>> a

-0.1810  0.4017  0.2863 -0.1013
 0.6183  2.0696  0.9012 -1.5933
 0.5679  0.4743 -0.0117 -0.1266
-0.1213  0.9629  0.2682  1.5968
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(8, 2)
>>> b

 0.8774  0.7650
 0.8866  1.4805
-0.6490  1.1172
 1.4259 -0.8146
 1.4633 -0.1228
 0.4643 -0.6029
 0.3492  1.5270
 1.6103 -0.6291
[torch.FloatTensor of size 8x2]

>>> torch.div(a, b)

-0.2062  0.5251  0.3229 -0.0684
-0.9528  1.8525  0.6320  1.9559
 0.3881 -3.8625 -0.0253  0.2099
-0.3473  0.6306  0.1666 -2.5381
[torch.FloatTensor of size 4x4]
 
torch.exp
 
torch.exp(tensor, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的指数。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量 
>>> torch.exp(torch.Tensor([0, math.log(2)]))
torch.FloatTensor([1, 2])
 
torch.floor
 
torch.floor(input, out=None) → Tensor
 
床函数: 返回一个新张量，包含输入input张量每个元素的floor，即不小于元素的最大整数。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.floor(a)

 1
 0
-1
-1
[torch.FloatTensor of size 4]
 
torch.fmod
 
torch.fmod(input, divisor, out=None) → Tensor
 
计算除法余数。 除数与被除数可能同时含有整数和浮点数。此时，余数的正负与被除数相同。
 
参数：
 
input (Tensor) – 被除数
divisor (Tensor or float) – 除数，一个数或与被除数相同类型的张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([-1, -0, -1, 1, 0, 1])
>>> torch.fmod(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])
 
参考: torch.remainder(), 计算逐元素余数， 相当于python 中的 % 操作符。
 
torch.frac
 
torch.frac(tensor, out=None) → Tensor
 
返回每个元素的分数部分。
 
例子：
 
>>> torch.frac(torch.Tensor([1, 2.5, -3.2])
torch.FloatTensor([0, 0.5, -0.2])
 
torch.lerp
 
torch.lerp(start, end, weight, out=None)
 
对两个张量以start，end做线性插值， 将结果返回到输出张量。
 
即，\( out_i=start_i+weight∗(end_i−start_i) \)
 
参数：
 
start (Tensor) – 起始点张量
end (Tensor) – 终止点张量
weight (float) – 插值公式的weight
out (Tensor, 可选的) – 结果张量
例子：
 
>>> start = torch.arange(1, 5)
>>> end = torch.Tensor(4).fill_(10)
>>> start

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> end

 10
 10
 10
 10
[torch.FloatTensor of size 4]

>>> torch.lerp(start, end, 0.5)

 5.5000
 6.0000
 6.5000
 7.0000
[torch.FloatTensor of size 4]
 
torch.log
 
torch.log(input, out=None) → Tensor
 
计算input 的自然对数
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(5)
>>> a

-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]

>>> torch.log(a)

    nan
-0.9883
    nan
-0.8797
-0.5349
[torch.FloatTensor of size 5]
 
torch.log1p
 
torch.log1p(input, out=None) → Tensor
 
计算 \( input +1 \)的自然对数 \( y_i=log(x_i+1) \)
 
注意：对值比较小的输入，此函数比torch.log()更准确。
 
如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(5)
>>> a

-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]

>>> torch.log1p(a)

-0.5418
 0.3164
-0.3697
 0.3471
 0.4611
[torch.FloatTensor of size 5]
 
torch.mul
 
torch.mul(input, value, out=None)
 
用标量值value乘以输入input的每个元素，并返回一个新的结果张量。 \( out=tensor ∗ value \)
 
如果输入是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。
 
参数：
 
input (Tensor) – 输入张量
value (Number) – 乘到每个元素的数
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(3)
>>> a

-0.9374
-0.5254
-0.6069
[torch.FloatTensor of size 3]

>>> torch.mul(a, 100)

-93.7411
-52.5374
-60.6908
[torch.FloatTensor of size 3]
 
torch.mul(input, other, out=None)
 
两个张量input,other按元素进行相乘，并返回到输出张量。即计算\( out_i=input_i ∗ other_i \)
 
两计算张量形状不须匹配，但总元素数须一致。
 
参数：
 
input (Tensor) – 第一个相乘张量
other (Tensor) – 第二个相乘张量
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4,4)
>>> a

-0.7280  0.0598 -1.4327 -0.5825
-0.1427 -0.0690  0.0821 -0.3270
-0.9241  0.5110  0.4070 -1.1188
-0.8308  0.7426 -0.6240 -1.1582
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(2, 8)
>>> b

 0.0430 -1.0775  0.6015  1.1647 -0.6549  0.0308 -0.1670  1.0742
-1.2593  0.0292 -0.0849  0.4530  1.2404 -0.4659 -0.1840  0.5974
[torch.FloatTensor of size 2x8]

>>> torch.mul(a, b)

-0.0313 -0.0645 -0.8618 -0.6784
 0.0934 -0.0021 -0.0137 -0.3513
 1.1638  0.0149 -0.0346 -0.5068
-1.0304 -0.3460  0.1148 -0.6919
[torch.FloatTensor of size 4x4]
 
torch.neg
 
torch.neg(input, out=None) → Tensor
 
返回一个新张量，包含输入input 张量按元素取负。 即， \( out=−1∗input \)
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(5)
>>> a

-0.4430
 1.1690
-0.8836
-0.4565
 0.2968
[torch.FloatTensor of size 5]

>>> torch.neg(a)

 0.4430
-1.1690
 0.8836
 0.4565
-0.2968
[torch.FloatTensor of size 5]
 
torch.pow
 
torch.pow(input, exponent, out=None)
 
对输入input的按元素求exponent次幂值，并返回结果张量。 幂值exponent 可以为单一 float 数或者与input相同元素数的张量。
 
当幂值为标量时，执行操作： $$ out_i=x^{exponent} $$
 
当幂值为张量时，执行操作： $$ out_i=x^{exponent_i} $$
 
参数：
 
input (Tensor) – 输入张量
exponent (float or Tensor) – 幂值
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

-0.5274
-0.8232
-2.1128
 1.7558
[torch.FloatTensor of size 4]

>>> torch.pow(a, 2)

 0.2781
 0.6776
 4.4640
 3.0829
[torch.FloatTensor of size 4]

>>> exp = torch.arange(1, 5)
>>> a = torch.arange(1, 5)
>>> a

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> exp

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.pow(a, exp)

   1
   4
  27
 256
[torch.FloatTensor of size 4]
 
torch.pow(base, input, out=None)
 
base 为标量浮点值,input为张量， 返回的输出张量 out 与输入张量相同形状。
 
执行操作为: $$ out_i=base^{input_i} $$
 
参数：
 
base (float) – 标量值，指数的底
input ( Tensor) – 幂值
out (Tensor, 可选的) – 输出张量
例子：
 
>>> exp = torch.arange(1, 5)
>>> base = 2
>>> torch.pow(base, exp)

  2
  4
  8
 16
[torch.FloatTensor of size 4]
 
torch.reciprocal
 
torch.reciprocal(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的倒数，即 1.0/x。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.reciprocal(a)

 0.7210
 2.5565
-1.1583
-1.8289
[torch.FloatTensor of size 4]
 
torch.remainder
 
torch.remainder(input, divisor, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的除法余数。 除数与被除数可能同时包含整数或浮点数。余数与除数有相同的符号。
 
参数：
 
input (Tensor) – 被除数
divisor (Tensor or float) – 除数，一个数或者与除数相同大小的张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> torch.remainder(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([1, 0, 1, 1, 0, 1])
>>> torch.remainder(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])
 
torch.round
 
torch.round(input, out=None) → Tensor
 
返回一个新张量，将输入input张量每个元素舍入到最近的整数。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.round(a)

 1
 1
-1
-0
[torch.FloatTensor of size 4]
 
torch.rsqrt
 
torch.rsqrt(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的平方根倒数。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.rsqrt(a)

 0.9020
 0.8636
    nan
    nan
[torch.FloatTensor of size 4]
 
torch.sigmoid
 
torch.sigmoid(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的sigmoid值。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.sigmoid(a)

 0.3782
 0.7943
 0.5264
 0.4341
[torch.FloatTensor of size 4]
 
torch.sign
 
torch.sign(input, out=None) → Tensor
 
符号函数：返回一个新张量，包含输入input张量每个元素的正负。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sign(a)

-1
 1
 1
 1
[torch.FloatTensor of size 4]
 
torch.sin
 
torch.sin(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的正弦。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sin(a)
-0.5944
 0.2684
 0.4322
 0.9667
[torch.FloatTensor of size 4]
 
torch.sinh
 
torch.sinh(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的双曲正弦。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sinh(a)
-0.6804
 0.2751
 0.4619
 1.7225
[torch.FloatTensor of size 4]
 
torch.sqrt
 
torch.sqrt(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的平方根。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.sqrt(a)

 1.1086
 1.1580
    nan
    nan
[torch.FloatTensor of size 4]
 
torch.tan
 
torch.tan(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的正切。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.tan(a)
-0.7392
 0.2786
 0.4792
 3.7801
[torch.FloatTensor of size 4]
 
torch.tanh
 
torch.tanh(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的双曲正切。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.tanh(a)
-0.5625
 0.2653
 0.4193
 0.8648
[torch.FloatTensor of size 4]
 
torch.trunc
 
torch.trunc(input, out=None) → Tensor
 
返回一个新张量，包含输入input张量每个元素的截断值(标量x的截断值是最接近其的整数，其比x更接近零。简而言之，有符号数的小数部分被舍弃)。
 
参数：
 
input (Tensor) – 输入张量
out (Tensor, 可选的) – 输出张量
例子：
 
>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.trunc(a)

-0
 1
 0
-0
[torch.FloatTensor of size 4]
 
Reduction Ops
 
torch.cumprod
 
torch.cumprod(input, dim, out=None) → Tensor
 
返回输入沿指定维度的累积积。例如，如果输入是一个N 元向量，则结果也是一个N 元向量，第i 个输出元素值为\( yi=x1∗x2∗x3∗...∗xi \)
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 累积积操作的维度
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(10)
>>> a

 1.1148
 1.8423
 1.4143
-0.4403
 1.2859
-1.2514
-0.4748
 1.1735
-1.6332
-0.4272
[torch.FloatTensor of size 10]

>>> torch.cumprod(a, dim=0)

 1.1148
 2.0537
 2.9045
-1.2788
-1.6444
 2.0578
-0.9770
-1.1466
 1.8726
-0.8000
[torch.FloatTensor of size 10]

>>> a[5] = 0.0
>>> torch.cumprod(a, dim=0)

 1.1148
 2.0537
 2.9045
-1.2788
-1.6444
-0.0000
 0.0000
 0.0000
-0.0000
 0.0000
[torch.FloatTensor of size 10]
 
torch.cumsum
 
torch.cumsum(input, dim, out=None) → Tensor
 
返回输入沿指定维度的累积和。例如，如果输入是一个N元向量，则结果也是一个N元向量，第i 个输出元素值为 \( yi=x1+x2+x3+...+xi\)
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 累积和操作的维度
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(10)
>>> a

-0.6039
-0.2214
-0.3705
-0.0169
 1.3415
-0.1230
 0.9719
 0.6081
-0.1286
 1.0947
[torch.FloatTensor of size 10]

>>> torch.cumsum(a, dim=0)

-0.6039
-0.8253
-1.1958
-1.2127
 0.1288
 0.0058
 0.9777
 1.5858
 1.4572
 2.5519
[torch.FloatTensor of size 10]
 
torch.dist
 
torch.dist(input, other, p=2, out=None) → Tensor
 
返回 (input - other) 的 p范数 。
 
参数：
 
input (Tensor) – 输入张量
other (Tensor) – 右侧输入张量
p (float, 可选的) – 所计算的范数
out (Tensor, 可选的) – 结果张量
例子：
 
>>> x = torch.randn(4)
>>> x

 0.2505
-0.4571
-0.3733
 0.7807
[torch.FloatTensor of size 4]

>>> y = torch.randn(4)
>>> y

 0.7782
-0.5185
 1.4106
-2.4063
[torch.FloatTensor of size 4]

>>> torch.dist(x, y, 3.5)
3.302832063224223
>>> torch.dist(x, y, 3)
3.3677282206393286
>>> torch.dist(x, y, 0)
inf
>>> torch.dist(x, y, 1)
5.560028076171875
 
torch.mean
 
torch.mean(input) → float
 
返回输入张量所有元素的均值。
 
参数： input (Tensor) – 输入张量
 
例子：
 
>>> a = torch.randn(1, 3)
>>> a

-0.2946 -0.9143  2.1809
[torch.FloatTensor of size 1x3]

>>> torch.mean(a)
0.32398951053619385
 
torch.mean(input, dim, out=None) → Tensor
 
返回输入张量给定维度dim上每行的均值。
 
输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
dim (int) – the dimension to reduce
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4, 4)
>>> a

-1.2738 -0.3058  0.1230 -1.9615
 0.8771 -0.5430 -0.9233  0.9879
 1.4107  0.0317 -0.6823  0.2255
-1.3854  0.4953 -0.2160  0.2435
[torch.FloatTensor of size 4x4]

>>> torch.mean(a, 1)

-0.8545
 0.0997
 0.2464
-0.2157
[torch.FloatTensor of size 4x1]
 
torch.median
 
torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)
 
返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的LongTensor。
 
dim值默认为输入张量的最后一维。 输出形状与输入相同，除了给定维度上为1.
 
注意: 这个函数还没有在torch.cuda.Tensor中定义
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 缩减的维度
values (Tensor, 可选的) – 结果张量
indices (Tensor, 可选的) – 返回的索引结果张量
>>> a

 -0.6891 -0.6662
 0.2697  0.7412
 0.5254 -0.7402
 0.5528 -0.2399
[torch.FloatTensor of size 4x2]

>>> a = torch.randn(4, 5)
>>> a

 0.4056 -0.3372  1.0973 -2.4884  0.4334
 2.1336  0.3841  0.1404 -0.1821 -0.7646
-0.2403  1.3975 -2.0068  0.1298  0.0212
-1.5371 -0.7257 -0.4871 -0.2359 -1.1724
[torch.FloatTensor of size 4x5]

>>> torch.median(a, 1)
(
 0.4056
 0.1404
 0.0212
-0.7257
[torch.FloatTensor of size 4x1]
,
 0
 2
 4
 1
[torch.LongTensor of size 4x1]
)
 
torch.mode
 
torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)
 
返回给定维dim上，每行的众数值。 同时返回一个LongTensor，包含众数职的索引。dim值默认为输入张量的最后一维。
 
输出形状与输入相同，除了给定维度上为1.
 
注意: 这个函数还没有在torch.cuda.Tensor中定义
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 缩减的维度
values (Tensor, 可选的) – 结果张量
indices (Tensor, 可选的) – 返回的索引张量
例子：
 
>>> a

 -0.6891 -0.6662
 0.2697  0.7412
 0.5254 -0.7402
 0.5528 -0.2399
[torch.FloatTensor of size 4x2]

>>> a = torch.randn(4, 5)
>>> a

 0.4056 -0.3372  1.0973 -2.4884  0.4334
 2.1336  0.3841  0.1404 -0.1821 -0.7646
-0.2403  1.3975 -2.0068  0.1298  0.0212
-1.5371 -0.7257 -0.4871 -0.2359 -1.1724
[torch.FloatTensor of size 4x5]

>>> torch.mode(a, 1)
(
-2.4884
-0.7646
-2.0068
-1.5371
[torch.FloatTensor of size 4x1]
,
 3
 4
 2
 0
[torch.LongTensor of size 4x1]
)
 
torch.norm
 
torch.norm(input, p=2) → float
 
返回输入张量input 的p 范数。
 
参数：
 
input (Tensor) – 输入张量
p (float,可选的) – 范数计算中的幂指数值
例子：
 
>>> a = torch.randn(1, 3)
>>> a

-0.4376 -0.5328  0.9547
[torch.FloatTensor of size 1x3]

>>> torch.norm(a, 3)
1.0338925067372466
 
torch.norm(input, p, dim, out=None) → Tensor
 
返回输入张量给定维dim 上每行的p 范数。 输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
p (float) – 范数计算中的幂指数值
dim (int) – 缩减的维度
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4, 2)
>>> a

-0.6891 -0.6662
 0.2697  0.7412
 0.5254 -0.7402
 0.5528 -0.2399
[torch.FloatTensor of size 4x2]

>>> torch.norm(a, 2, 1)

 0.9585
 0.7888
 0.9077
 0.6026
[torch.FloatTensor of size 4x1]

>>> torch.norm(a, 0, 1)

 2
 2
 2
 2
[torch.FloatTensor of size 4x1]
 
torch.prod
 
torch.prod(input) → float
 
返回输入张量input 所有元素的积。
 
参数：input (Tensor) – 输入张量
 
例子：
 
>>> a = torch.randn(1, 3)
>>> a

 0.6170  0.3546  0.0253
[torch.FloatTensor of size 1x3]

>>> torch.prod(a)
0.005537458061418483
 
torch.prod(input, dim, out=None) → Tensor
 
返回输入张量给定维度上每行的积。 输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 缩减的维度
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4, 2)
>>> a

 0.1598 -0.6884
-0.1831 -0.4412
-0.9925 -0.6244
-0.2416 -0.8080
[torch.FloatTensor of size 4x2]

>>> torch.prod(a, 1)

-0.1100
 0.0808
 0.6197
 0.1952
[torch.FloatTensor of size 4x1]
 
torch.std
 
torch.std(input) → float
 
返回输入张量input 所有元素的标准差。
 
参数：- input (Tensor) – 输入张量
 
例子：
 
>>> a = torch.randn(1, 3)
>>> a

-1.3063  1.4182 -0.3061
[torch.FloatTensor of size 1x3]

>>> torch.std(a)
1.3782334731508061
 
torch.std(input, dim, out=None) → Tensor
 
返回输入张量给定维度上每行的标准差。 输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 缩减的维度
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4, 4)
>>> a

 0.1889 -2.4856  0.0043  1.8169
-0.7701 -0.4682 -2.2410  0.4098
 0.1919 -1.1856 -1.0361  0.9085
 0.0173  1.0662  0.2143 -0.5576
[torch.FloatTensor of size 4x4]

>>> torch.std(a, dim=1)

 1.7756
 1.1025
 1.0045
 0.6725
[torch.FloatTensor of size 4x1]
 
torch.sum
 
torch.sum(input) → float
 
返回输入张量input 所有元素的和。
 
输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
例子：
 
>>> a = torch.randn(1, 3)
>>> a

 0.6170  0.3546  0.0253
[torch.FloatTensor of size 1x3]

>>> torch.sum(a)
0.9969287421554327
 
torch.sum(input, dim, out=None) → Tensor
 
返回输入张量给定维度上每行的和。 输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
dim (int) – 缩减的维度
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4, 4)
>>> a

-0.4640  0.0609  0.1122  0.4784
-1.3063  1.6443  0.4714 -0.7396
-1.3561 -0.1959  1.0609 -1.9855
 2.6833  0.5746 -0.5709 -0.4430
[torch.FloatTensor of size 4x4]

>>> torch.sum(a, 1)

 0.1874
 0.0698
-2.4767
 2.2440
[torch.FloatTensor of size 4x1]
 
torch.var
 
torch.var(input) → float
 
返回输入张量所有元素的方差
 
输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
例子：
 
>>> a = torch.randn(1, 3)
>>> a

-1.3063  1.4182 -0.3061
[torch.FloatTensor of size 1x3]

>>> torch.var(a)
1.899527506513334
 
torch.var(input, dim, out=None) → Tensor
 
返回输入张量给定维度上每行的方差。 输出形状与输入相同，除了给定维度上为1.
 
参数：
 
input (Tensor) – 输入张量
dim (int) – the dimension to reduce
out (Tensor, 可选的) – 结果张量 例子： 

>>> a = torch.randn(4, 4)
>>> a
 
-1.2738 -0.3058 0.1230 -1.9615 0.8771 -0.5430 -0.9233 0.9879 1.4107 0.0317 -0.6823 0.2255 -1.3854 0.4953 -0.2160 0.2435 [torch.FloatTensor of size 4x4]
 
 
 
 
  
 
   
torch.var(a, 1)
 
  
 
 
 
 
0.8859 0.9509 0.7548 0.6949 [torch.FloatTensor of size 4x1]
 

## 比较操作 Comparison Ops

### torch.eq
```python 
torch.eq(input, other, out=None) → Tensor
 
比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。
 
参数：
 
input (Tensor) – 待比较张量
other (Tensor or float) – 比较张量或数
out (Tensor, 可选的) – 输出张量，须为 ByteTensor类型 or 与input同类型
返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(相等为1，不等为0 )
 
返回类型： Tensor
 
例子：
 
>>> torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
1  0
0  1
[torch.ByteTensor of size 2x2]
 
torch.equal
 
torch.equal(tensor1, tensor2) → bool
 
如果两个张量有相同的形状和元素值，则返回True ，否则 False。
 
例子：
 
>>> torch.equal(torch.Tensor([1, 2]), torch.Tensor([1, 2]))
True
 
torch.ge
 
torch.ge(input, other, out=None) → Tensor
 
逐元素比较input和other，即是否 \( input >= other \)。
 
如果两个张量有相同的形状和元素值，则返回True ，否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
 
参数:
 
input (Tensor) – 待对比的张量
other (Tensor or float) – 对比的张量或float值
out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。
返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 input >= other )。 返回类型： Tensor
 
例子：
 
>>> torch.ge(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 1  1
 0  1
[torch.ByteTensor of size 2x2]
 
torch.gt
 
torch.gt(input, other, out=None) → Tensor
 
逐元素比较input和other ， 即是否\( input > other \) 如果两个张量有相同的形状和元素值，则返回True ，否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
 
参数:
 
input (Tensor) – 要对比的张量
other (Tensor or float) – 要对比的张量或float值
out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。
返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 input >= other )。 返回类型： Tensor
 
例子：
 
>>> torch.gt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 0  1
 0  0
[torch.ByteTensor of size 2x2]
 
torch.kthvalue
 
torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)
 
取输入张量input指定维上第k 个最小值。如果不指定dim，则默认为input的最后一维。
 
返回一个元组 (values,indices)，其中indices是原始输入张量input中沿dim维的第 k 个最小值下标。
 
参数:
 
input (Tensor) – 要对比的张量
k (int) – 第 k 个最小值
dim (int, 可选的) – 沿着此维进行排序
out (tuple, 可选的) – 输出元组 (Tensor, LongTensor) 可选地给定作为 输出 buffers
例子：
 
>>> x = torch.arange(1, 6)
>>> x

 1
 2
 3
 4
 5
[torch.FloatTensor of size 5]

>>> torch.kthvalue(x, 4)
(
 4
[torch.FloatTensor of size 1]
,
 3
[torch.LongTensor of size 1]
)
 
torch.le
 
torch.le(input, other, out=None) → Tensor
 
逐元素比较input和other ， 即是否\( input <= other \) 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
 
参数:
 
input (Tensor) – 要对比的张量
other (Tensor or float ) – 对比的张量或float值
out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。
返回值： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 input >= other )。 返回类型： Tensor
 
例子：
 
>>> torch.le(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 1  0
 1  1
[torch.ByteTensor of size 2x2]
 
torch.lt
 
torch.lt(input, other, out=None) → Tensor
 
逐元素比较input和other ， 即是否 \( input < other \)
 
第二个参数可以为一个数或与第一个参数相同形状和类型的张量
 
参数:
 
input (Tensor) – 要对比的张量
other (Tensor or float ) – 对比的张量或float值
out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。
input： 一个 torch.ByteTensor 张量，包含了每个位置的比较结果(是否 tensor >= other )。 返回类型： Tensor
 
例子：
 
>>> torch.lt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 0  0
 1  0
[torch.ByteTensor of size 2x2]
 
torch.max
 
torch.max()
 
返回输入张量所有元素的最大值。
 
参数:
 
input (Tensor) – 输入张量
例子：
 
>>> a = torch.randn(1, 3)
>>> a

 0.4729 -0.2266 -0.2085
[torch.FloatTensor of size 1x3]

>>> torch.max(a)
0.4729
 
torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)
 
返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。
 
输出形状中，将dim维设定为1，其它与输入形状保持一致。
 
参数:
 
input (Tensor) – 输入张量
dim (int) – 指定的维度
max (Tensor, 可选的) – 结果张量，包含给定维度上的最大值
max_indices (LongTensor, 可选的) – 结果张量，包含给定维度上每个最大值的位置索引
例子：
 
>> a = torch.randn(4, 4)
>> a

0.0692  0.3142  1.2513 -0.5428
0.9288  0.8552 -0.2073  0.6409
1.0695 -0.0101 -2.4507 -1.2230
0.7426 -0.7666  0.4862 -0.6628
torch.FloatTensor of size 4x4]

>>> torch.max(a, 1)
(
 1.2513
 0.9288
 1.0695
 0.7426
[torch.FloatTensor of size 4x1]
,
 2
 0
 0
 0
[torch.LongTensor of size 4x1]
)
 
torch.max(input, other, out=None) → Tensor
 
返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。 即，\( out_i=max(input_i,other_i) \)
 
输出形状中，将dim维设定为1，其它与输入形状保持一致。
 
参数:
 
input (Tensor) – 输入张量
other (Tensor) – 输出张量
out (Tensor, 可选的) – 结果张量
例子：
 
>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> b = torch.randn(4)
>>> b

 1.0067
-0.8010
 0.6258
 0.3627
[torch.FloatTensor of size 4]

>>> torch.max(a, b)

 1.3869
 0.3912
 0.6258
 0.3627
[torch.FloatTensor of size 4]
 
torch.min
 
torch.min(input) → float
 
返回输入张量所有元素的最小值。
 
参数: input (Tensor) – 输入张量
 
例子：
 
>>> a = torch.randn(1, 3)
>>> a

 0.4729 -0.2266 -0.2085
[torch.FloatTensor of size 1x3]

>>> torch.min(a)
-0.22663167119026184
 
torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)
 
返回输入张量给定维度上每行的最小值，并同时返回每个最小值的位置索引。
 
输出形状中，将dim维设定为1，其它与输入形状保持一致。
 
参数:
 
input (Tensor) – 输入张量
dim (int) – 指定的维度
min (Tensor, 可选的) – 结果张量，包含给定维度上的最小值
min_indices (LongTensor, 可选的) – 结果张量，包含给定维度上每个最小值的位置索引
例子：
 

>> a = torch.randn(4, 4)
>> a

0.0692  0.3142  1.2513 -0.5428
0.9288  0.8552 -0.2073  0.6409
1.0695 -0.0101 -2.4507 -1.2230
0.7426 -0.7666  0.4862 -0.6628
torch.FloatTensor of size 4x4]

>> torch.min(a, 1)

0.54

1. 字面理解：torch.cat是将两个张量（tensor）拼接在一起，cat是concatenate的意思，即拼接，联系在一起。
 
2. 例子理解
 
>>> import torch
>>> A=torch.ones(2,3) #2x3的张量（矩阵）                                     
>>> A
tensor([[ 1.,  1.,  1.],
        [ 1.,  1.,  1.]])
>>> B=2*torch.ones(4,3)#4x3的张量（矩阵）                                    
>>> B
tensor([[ 2.,  2.,  2.],
        [ 2.,  2.,  2.],
        [ 2.,  2.,  2.],
        [ 2.,  2.,  2.]])
>>> C=torch.cat((A,B),0)#按维数0（行）拼接
>>> C
tensor([[ 1.,  1.,  1.],
         [ 1.,  1.,  1.],
         [ 2.,  2.,  2.],
         [ 2.,  2.,  2.],
         [ 2.,  2.,  2.],
         [ 2.,  2.,  2.]])
>>> C.size()
torch.Size([6, 3])
>>> D=2*torch.ones(2,4) #2x4的张量（矩阵）
>>> C=torch.cat((A,D),1)#按维数1（列）拼接
>>> C
tensor([[ 1.,  1.,  1.,  2.,  2.,  2.,  2.],
        [ 1.,  1.,  1.,  2.,  2.,  2.,  2.]])
>>> C.size()
torch.Size([2, 7])
 
上面给出了两个张量A和B，分别是2行3列，4行3列。即他们都是2维张量。因为只有两维，这样在用torch.cat拼接的时候就有两种拼接方式：按行拼接和按列拼接。即所谓的维数0和维数1. 
 
C=torch.cat((A,B),0)就表示按维数0（行）拼接A和B，也就是竖着拼接，A上B下。此时需要注意：列数必须一致，即维数1数值要相同，这里都是3列，方能列对齐。拼接后的C的第0维是两个维数0数值和，即2+4=6.
 
C=torch.cat((A,B),1)就表示按维数1（列）拼接A和B，也就是横着拼接，A左B右。此时需要注意：行数必须一致，即维数0数值要相同，这里都是2行，方能行对齐。拼接后的C的第1维是两个维数1数值和，即3+4=7.
 
从2维例子可以看出，使用torch.cat((A,B),dim)时，除拼接维数dim数值可不同外其余维数数值需相同，方能对齐。
 
3.实例
 
在深度学习处理图像时，常用的有3通道的RGB彩色图像及单通道的灰度图。张量size为cxhxw,即通道数x图像高度x图像宽度。在用torch.cat拼接两张图像时一般要求图像大小一致而通道数可不一致，即h和w同，c可不同。当然实际有3种拼接方式，另两种好像不常见。比如经典网络结构：U-Net
 
                                    
 
里面用到4次torch.cat,其中copy and crop操作就是通过torch.cat来实现的。可以看到通过上采样（up-conv 2x2）将原始图像h和w变为原来2倍，再和左边直接copy过来的同样h,w的图像拼接。这样做，可以有效利用原始结构信息。
 
4.总结
 
使用torch.cat((A,B),dim)时，除拼接维数dim数值可不同外其余维数数值需相同，方能对齐。
 
 
 
 

 
深度学习环境配置2——windows下的torch=1.2.0环境配置
 
注意事项
一、2021/9/11更新
二、2021/7/8更新
  
学习前言
环境内容
环境配置
一、Anaconda安装
1、Anaconda的下载
2、Anaconda的安装
   
二、Cudnn和CUDA的下载和安装
1、Cudnn和CUDA的下载
2、Cudnn和CUDA的安装
   
三、配置torch环境
1、pytorch环境的创建与激活
2、pytorch库的安装
a、官方推荐安装方法（推荐）
b、先下载whl后安装
    
3、其它依赖库的安装
4、安装较慢请注意换源
   
四、安装VSCODE
1、下载安装包安装（推荐）
a、VSCODE的下载
b、VSCODE的安装
    
2、anaconda上安装
  
 

 
注意事项
 
一、2021/9/11更新
 
安装CUDA前需要安装Visual Studio，我安装的版本为Visual Studio 2017，视频与视频中未提及，请小伙伴们注意。
 
30系列显卡不适合该教程，30系列显卡仅支持CUDA11.0，可以参考博客https://blog.csdn.net/weixin_44791964/article/details/120668551进行配置。
 
博文中显示的安装环境为tensorflow，这是因为我讲pytorch和tensorflow装在一起了，所以不用管，大家自己安装激活的环境是pytorch。
 
二、2021/7/8更新
 
许多粉丝反馈，报TypeError: array() takes 1 positional argument but 2 were given错误，可以修改pillow版本解决。
 
pip install pillow==8.2.0
 
学习前言
 
好多人问环境怎么配置，还是出个教程吧。
 
pytorch-cpu版本的环境配置博客为https://blog.csdn.net/weixin_44791964/article/details/120655098。
 
 
环境内容
 
torch：1.2.0
 torchvision：0.4.0
 
环境配置
 
一、Anaconda安装
 
Anaconda的安装主要是为了方便环境管理，可以同时在一个电脑上安装多种环境，不同环境放置不同框架：pytorch、tensorflow、keras可以在不同的环境下安装，只需要使用conda create –n创建新环境即可。
 
1、Anaconda的下载
 
同学们可以选择安装新版Anaconda和旧版的Anaconda，安装步骤没有什么区别。
 
旧版本anaconda的下载：
 新版本的Anaconda没有VSCODE，如果大家为了安装VSCODE方便可以直接安装旧版的Anaconda，百度网盘连接如下。也可以装新版然后分开装VSCODE。
 链接: https://pan.baidu.com/s/12tW0Oad_Tqn7jNs8RNkvFA 提取码: i83n
 
新版本anaconda的下载：
 如果想要安装最新的Anaconda，首先登录Anaconda的官网：https://www.anaconda.com/distribution/。直接下载对应安装包就可以。
 
 
 一般是下载64位的，下载完成后打开。
 
2、Anaconda的安装
 

 选择安装的位置，可以不安装在C盘。
 
 我选择了Add Anaconda to my PATH environment variable，这样会自动将anaconda装到系统的环境变量中，配置会更加方便一些。
 
 等待安装完之后，Anaconda的安装就结束了。
 
二、Cudnn和CUDA的下载和安装
 
我这里使用的是torch=1.2.0，官方推荐的Cuda版本是10.0，因此会用到cuda10.0，与cuda10.0对应的cudnn是7.4.1。
 
1、Cudnn和CUDA的下载
 
网盘下载：
 链接: https://pan.baidu.com/s/1znYSRDtLNFLufAuItOeoyQ
 提取码: 8ggr
 
官网下载：
 cuda10.0官网的地址是：
 cuda10.0官网地址
 cudnn官网的地址是：需要大家进去后寻找7.4.1.5。
 cudnn官网地址
 
下载完之后得到这两个文件。
 
 
 
2、Cudnn和CUDA的安装
 
下载好之后可以打开exe文件进行安装。
 
 这里选择自定义。
 
 然后直接点下一步就行了。
 
 安装完后在C盘这个位置可以找到根目录。
 C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0
 然后大家把Cudnn的内容进行解压。
 
 把这里面的内容直接复制到C盘的根目录下就可以了。
 
 
三、配置torch环境
 
1、pytorch环境的创建与激活
 
Win+R启动cmd，在命令提示符内输入以下命令：
 
conda create –n pytorch python=3.6
 
activate pytorch
 
这里一共存在两条指令：
 前面一条指令用于创建一个名为pytorch的环境，该环境的python版本为3.6。
 后面一条指令用于激活一个名为pytorch的环境。
 
2、pytorch库的安装
 
由于我们所有的操作都要在对应环境中进行，所以在进行库的安装前需要先激活环境。
 
activate pytorch 
 
此时cmd窗口的样子为：
 
 
a、官方推荐安装方法（推荐）
 
打开pytorch的官方安装方法：
 https://pytorch.org/get-started/previous-versions/
 官网推荐的安装代码如下，我使用的是Cuda10的版本，不太懂为什么要写3个=才能正确定位，两个=会定位到cuda92的whl：
 
# CUDA 10.0
pip install torch===1.2.0 torchvision===0.4.0 -f https://download.pytorch.org/whl/torch_stable.html
 
这是pytorch官方提供的指令，用于安装torch和torchvision。
 
b、先下载whl后安装
 
需要注意的是，直接这样安装似乎特别慢，因此我们可以进入如下网址:
 https://download.pytorch.org/whl/torch_stable.html
 找到自己需要的轮子下载。下载的时候使用迅雷下载就行了，速度还是比较快的！
 
 
 下载完成后找到安装路径：
 
 在cmd定位过来后利用文件全名进行安装就行了！
 
 这里我也传一个百度网盘的版本。
 链接: https://pan.baidu.com/s/14-QVk7Kb_CVwaVZxVPIgtw
 提取码: rg2e
 全部安装完成之后重启电脑。
 
3、其它依赖库的安装
 
但如果想要跑深度学习模型，还有一些其它的依赖库需要安装。具体如下：
 
scipy==1.2.1
numpy==1.17.0
matplotlib==3.1.2
opencv_python==4.1.2.30
torch==1.2.0
torchvision==0.4.0
tqdm==4.60.0
Pillow==8.2.0
h5py==2.10.0
 
如果想要更便捷的安装可以在桌面或者其它地方创建一个requirements.txt文件，复制上述内容到txt文件中。
 
 使用如下指令安装即可。下述指令中，requirements.txt前方的路径是我将文件放在桌面的路径，各位同学根据自己的电脑修改。
 
pip install -r C:\Users\33232\Desktop\requirements.txt
 
4、安装较慢请注意换源
 
需要注意的是，如果在pip中下载安装比较慢可以换个源，可以到用户文件夹下，创建一个pip文件夹，然后在pip文件夹里创建一个txt文件。
 
 修改txt文件的内容，并且把后缀改成ini
 
[global]
index-url = http://pypi.mirrors.ustc.edu.cn/simple
[install]
use-mirrors =true
mirrors =http://pypi.mirrors.ustc.edu.cn/simple/
trusted-host =pypi.mirrors.ustc.edu.cn
 

 
 全部安装完成之后重启电脑。
 
四、安装VSCODE
 
我个人喜欢VSCODE，所以就安装它啦。其它的编辑软件也可以，个人喜好罢了。
 
1、下载安装包安装（推荐）
 
最新版本的Anaconda没有VSCODE因此可以直接百度VSCODE进行安装。
 
a、VSCODE的下载
 
直接加载VSCODE的官网https://code.visualstudio.com/，点击Download for Windows即可下载。
 
 
b、VSCODE的安装
 
首先同意协议，点一下步。
 
 其他里面的几个勾要打起来，因为这样就可以右键文件夹用VSCODE打开，非常方便。下一步。
 
 继续下一步安装即可。
 
 
安装完成后在左下角更改自己的环境就行了。
 
 
2、anaconda上安装
 
打开anaconda，切换环境。
 
 安装VSCODE，安装完就可以launch一下了，之后就可以把VScode固定到任务栏上，方便打开。
 

torch.no_grad() 是一个上下文管理器，被该语句 wrap 起来的部分将不会track 梯度。
 
例如：
 
a = torch.tensor([1.1], requires_grad=True)
b = a * 2
 
打印b可看到其 grad_fn 为 mulbackward 表示是做的乘法。
 
b
Out[63]: tensor([2.2000], grad_fn=<MulBackward0>)
 
b.add_(2)
Out[64]: tensor([4.2000], grad_fn=<AddBackward0>)
 
可以看到不被wrap的情况下，b.grad_fn 为 addbackward 表示这个add 操作被track了
 
with torch.no_grad():
    b.mul_(2)
 
在被包裹的情况下可以看到 b.grad_fn 还是为 add，mul 操作没有被 track. 但是注意，乘法操作是被执行了的。(4.2 -> 8.4)
 
b
Out[66]: tensor([8.4000], grad_fn=<AddBackward0>)
 
所以如果有不想被track的计算部分可以通过这么一个上下文管理器包裹起来。这样可以执行计算，但该计算不会在反向传播中被记录。
 
同时 torch.no_grad() 还可以作为一个装饰器。
 比如在网络测试的函数前加上
 
@torch.no_grad()
def eval():
	...
 
扩展：
 同样还可以用 torch.set_grad_enabled()来实现不计算梯度。
 例如：
 
def eval():
	torch.set_grad_enabled(False)
	...	# your test code
	torch.set_grad_enabled(True)