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+ 中操作, 看这里
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 存储对象
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
相同元素数的张量
或者
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
的向量积(叉积)。 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)
返回线性方程组 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′