torch常用基础函数_torch.tril-CSDN博客

torch常用基础函数

https://www.jianshu.com/p/d678c5e44a6b

torch

本笔记引用自PyTorch中文文档

包torch包含了多维疑是的数据结构及基于其上的多种数学操作。

1. 张量Tensors

`torch.is_tensor(obj)`:

如果obj是一个pytorch张量，则返回True

`torch.is_storage(obj)`:

如果obj是一个pytorch storage对象，则返回True

`torch.numel(input)`:

返回input张量中的元素个数。

2. 创建操作

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

返回一个2维张量，对角线为1,其它位置为0

n (int) -行数
m (int, optional)列数，如果为None,则默认为n
out (Tensor, optional)

`torch.from_numpy(ndarray)`:

将numpy.ndarray转换为Tensor，返回的张量tensor和numpy的ndarray共享同一内存空间，修改一个会导致另一个也被修改，返回的张量不能改变大小

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

返回一个1维张量，包含在start和end上均匀间隔的steps个点

start (float) -序列起点
end (float) - 序列终点
steps (int) - 在start与end间生成的样本数
out (Tensor, optional) - 结果张量

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

返回一个1维张量，包含在区间10exp(start)和10exp(end)上以对数刻度均匀间隔的 steps个点。

`torch.ones(*sizes, out=None)`:

返回一个全为1的张量，形状由可变参数sizes定义

sizes (int...) - 整数序列，定义了输出形状

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

返回一个张量，包含了从区间(0, 1)的均匀分布中抽取的一组随机数，形状由可变参数sizes定义。

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

返回一个张量，包含了从标准正态分布(mean=0, std=1)中抽取一组随机数，形状由可变参数sizes定义。

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

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

n (int) - 上边界(不包含）

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

返回一个1维张量，长度为floor((end-start)/step)，以step`为步长的一组序列值。

start (float) - 起点
end (float) - 终点(不包含）
step (float) - 相邻点的间隔大小
out (Tensor, optional)

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

还是推荐使用torch.arange()

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

返回一个全为标量0的张量，形状由可变参数sizes定义

3. 索引，切片，连接，换位(Index, Slicing, Joining, Mutating)

`torch.cat(inputs, dimension=0)`:

在给定维度上对输入的张量序列seq进行连接操作。

inputs (sequence of Tensors)
dimension (int optional) - 沿着此维连接张量序列

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

在给定维度上将输入张量进行分块

tensors(Tensors) - 待分场的输入张量
chunks (int) - 分块的个数
dim (int) - 沿着此维度

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

沿给定轴dim,将输入索引张量index指定位置的值进行聚合。

input(Tensor) - 源张量
dim(int) - 索引的轴
index(LongTensor) - 聚合元素的下标
out - 目标张量

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

沿指定维度对输入进行切片，取index中指定的相应项，然后返回一个新的张量，返回的张量与原始张量有相同的维度(在指定轴上)，返回的张量与原始张量不共享内存空间

input(Tensor) - 输入张量
dim(int) - 索引的轴
index(LongTensor) - 包含索引下标的一维张量
out - 目标张量

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

根据掩码张量mask中的二元值，取输入张量中的指定项，将取值返回到一个新的1D张量。
张量mask须跟input张量有相同的元素数目，但形状或维度不需要相同。返回的张量不与原始张量共享内存空间

input(Tensor) - 输入张量
mask(ByteTensor) - 掩码张量，包含了二元索引值
out - 目标张量

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

返回一个包含输入input中非零元素索引的张量，输出张量中的每行包含输入中非零元素的索引
若输入input有n维，则输出的索引张量output形状为z * n, 这里z是输入张量input中所有非零元素的个数

input(Tensor) - 输入张量
out - 包含索引值的结果张量

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

将输入张量分割成相等形状的chunks(如果可分)。如果沿指定维的张量形状大小不能被split_size整分，则最后一个分块会小于其它分块。

tensor(Tensor) - 待分割张量
split_size(int) - 单个分块的形状大小
dim(int) - 沿着此维进行分割

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

将输入张量形状中的1去除并返回，如果输入是形如(A * 1 * B * 1 * C * 1 *D)，那么输出形状就为：(A * B * C * D)。
当给定dim时，则只在给定维度上进行挤压，如输入形状为(A * 1 * B)，squeeze(input, 0)，将会保持张量不变，只有用squeeze(input, 1)，形状会变成(A *B)。
输入张量与返回张量共享内存

input(Tensor) - 输入张量
dim(int, optional) - 如果给定，则只在给定维度挤压
out(Tensor, optional) - 输出张量

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

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

sequence(Sequence) - 待连接的张量序列
dim(int) - 插入的维度

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

输入一个矩阵(2维张量)，并转置0,1维，可以被视为transpose(input, 0, 1)的简写函数

input(Tensor) - 输入张量
out(Tensor, optional) - 结果张量

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

返回输入矩阵input的转置，交换维度dim0和dim1。输入张量与输出张量共享内存。

input(Tensor) - 输入张量
dim0(int) - 转置的第一维
dim1(int) - 转置的第二维

`torch.unbind(tensor, dim=0)[source]`:

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

tensor(Tensor) - 输入张量
dim(int) - 删除的维度

`torch.unsequeeze(input, dim, out=None)`:

返回一个新的张量，对输入的指定位置插入维度1，返回张量与输入张量共享内存，若dim为负，则将被转化为dim+input.dim()+1

tensor(Tensor) - 输入张量
dim(int) - 插入维度的索引
out(Tensor, optional) - 结果张量

4. 随机抽样Random sampling

`torch.manual_seed(seed)`:

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

`torch.initial_seed()`:

返回生成随机数的原始种子值

`torch.rng_state()[source]`

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

`torch.set_rng_state(new_state)[source]`:

设定随机生成器状态参数：new_state(torch.ByteTensor) - 期望的状态

`torch.default_generator`

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

从伯努利分布中抽取二元随机数(0或者1），输入中所有值必须在[0, 1]区间，输出张量的第i个元素值，将以输入张量的第i个概率值等于1。
返回值将会是与输入相同大小的张量，每个值为0或1

input(Tensor) - 输入为伯努利分布的概率值
out(Tensor, optional)

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

返回一个张量，每行包含从input相应行中定义的多项式分布中抽取的num_samples个样本。
input每行的值不需要总和为1,但必须非负且总和不能为0.

input(Tensor) - 包含概率值的张量
num_samples(int) - 抽取的样本数
replacement(bool, optional) - 布尔值，决定是否能重复抽取
out(Tensor, optional)

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

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

means(Tensor) - 均值
std(Tensor) - 标准差
out(Tensor, optional)

5. 序列化 Serialization

`torch.saves(obj, f, pickle_module, pickle_protocol=2)`:

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

obj - 保存对象
f - 类文件对象
pickle_module - 用于pickling元数据和对象的模块
pickle_protocol - 指定pickle protocal可以覆盖默认参数

`torch.load(f, map_location=None, pickle_module=)`:

从磁盘文件中读取一个通过torch.save()保存的对象，可通过参数map_location动态地进行内存重映射

f - 类文件对象
map_location - 一个函数或字典规定如何remap存储位置
pickle_module - 用于unpickling元数据和对象的模块

6. 并行化 Parallelism

`torch.get_num_threads()`:

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

`torch.set_num_threads(int)`:

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

7. 数学操作 Math operations

7.1 Pointwise Ops

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

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

input(Tensor) - 输入张量
out(Tensor, optional) - 结果张量

`torch.acos(input, out=None)`:

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

input(Tensor) - 输入张量
out(Tensor, optional)

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

对输入张量input逐元素加上标量值value，并返回结果到一个新的张量。

input(Tensor) - 输入张量
value(Number) - 添加到输入每个元素的数
out(Tensor, optional)

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

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

tensor(Tensor) - 张量
value(Number, optional) - 标量
tensor1(Tensor) - 张量，作为分子
tensor2(Tensor) - 张量，作为分母
out(Tensor, optional)

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

用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor，张量形状不需要匹配，但元素数量必须一致。

tensor(Tensor) - 张量
value(Number, optional) - 标量，
tensor1(Tensor) - 张量，乘子1
tensor2(Tensor) - 张量，乘子2
out(Tensor, optional)

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

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

input(Tensor) - 输入张量
out(Tensor, optional)

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

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

input(Tensor)
out(Tensor, optional)

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

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

input1(Tensor) - 第一个输入张量
input2(Tensor) - 第二个输入张量
out(Tensor, optional)

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

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

input(Tensor) - 输入张量
out(Tensor, optional)

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

将输入input张量每个元素值约束到区间[min, max]，并返回结果到一个新张量
也可以只设定min或只设定max

input(Tensor) - 输入张量
min(Number) - 限制范围下限
max(Number) - 限制范围上限
out(Tensor, optional)

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

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

input(Tensor)
out(Tensor, optional)

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

input(Tensor)
out(Tensor, optional)

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

将input逐元素除以标量值value，并返回结果到输出张量out

input(Tensor) - 输入张量
value(Number) - 除数
out(Tensor, optional)

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

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

input(Tensor)
out(Tensor, optional)

`torch.floor(input, out=None)`:

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

input(Tensor)
out(Tensor, optional)

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

计算除法余数，余数的正负与被除数相同

input(Tensor)
divisor(Tensor or float) - 除数
out(Tensor, optional)

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

返回每个元素的分数部分

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

对两个张量以start, end做线性插值，将结果返回到输出张量
out = start + weight*(end - start)

start(Tensor) - 起始点张量
end(Tensor) - 终止点张量
weight(float) - 插值公式中的weight
out(Tensor, optional)

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

计算input的自然对数

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

计算input + 1的自然对数y = log(x + 1)
对值比较小的输入，此函数比torch.log()更准确

input(Tensor)
out(Tensor, optional)

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

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

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

两个张量input, other按元素相乘，并返回到输出张量，两个张量形状不须匹配，但总元素数须一致。当形状不匹配时，input的形状作为输出张量的形状

input(Tensor) - 第一个张量
other(Tensor) - 第二个张量
out(Tensor, optional)

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

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

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

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

input(Tensor) - 输入张量
exponent(float or Tensor) - 幂值
out(Tensor, optional)

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

base为标量浮点值，input为张量。

base(float) - 标量值，指数的底
input(Tensor) - 幂值
out(Tensor, optional)

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

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

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

返回一个新张量，包含输入input张量每个元素的除法余数，余数与除数有相同的符号。

input(Tensor) - 被除数
divisor(Tensor or float) - 除数
out(Tensor, optional)

`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张量每个元素的截断值，使更接近零。即有符号数的小数部分被舍弃。

7.2 Reduction Ops

`torch.cumprod(input, dim, out=None) -> Tensor`:

返回输入沿指定维度的累积积，如输入是一个N元向量，则结果也是一个N元向量，第i个输出元素值为yi = x1 * x2 * x3 * ...* xi

input(Tensor) - 输入张量
dim(int) - 累积乘积操作的维度
out(Tensor, optional)

`torch.cumsum(input, dim, out=None) -> Tensor`:

返回输入沿指定维度的累积和

`torch.dist(input, other, p=2, out=None) -> Tensor`:

返回(input - other)的p范数

input(Tensor) - 输入张量
other(Tensor) - 右侧输入张量
p(float, optional) - 要计算的范数
out(Tensor, optional)

`torch.mean(input) -> float`:

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

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

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

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

返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引。dim默认为输入张量的最后一维

input(Tensor) - 输入张量
dim(int) - 缩减的维度
values(Tensor, optional) - 结果张量
indices(Tensor, optional) - 返回的索引结果张量

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

返回给定维度dim上，每行的众数值，同时返回一个索引张量。dim值默认为输入张量的最后一维。输出形状与输入相同，除了给定维度上为1。

`torch.norm(input, p=2) -> float`:

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

input(Tensor) - 输入张量
p(float, optional) - 范数计算中的幂指数值

`torch.norm(input, p, dim, out=None) -> Tensor`:

返回输入张量给定维度dim上每行的p范数。

`torch.prod(input) -> float`:

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

`torch.prod(input, dim, out=None) -> Tensor`:

返回输入张量给定维度上每行的积。

`torch.std(input) -> float`:

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

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

返回输入张量给定维度上每行的标准差。

`torch.sum(input) -> float`:

返回输入张量input所有元素的各

`torch.sum(input, dim, out=None) -> Tensor`:

返回输入疑是给定维度上每行的和

`torch.var(input) -> float`:

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

`torch.var(input, dim, out=None) -> Tensor`:

返回输入张量给定维度上每行的方差。

7.3 比较操作Comparison Ops

`torch.eq(input, other, out=None) -> Tensor`:

比较元素相等性，第二个参数可为一个数，或与第一个参数同类型形状的张量

input(Tensor) - 待比较张量
other(Tensor or float) - 比较张量或数
out(Tensor, optional) - 输出张量，须为ByteTensor类型或与input同类型

`torch.equal(tensor1, tensor2) -> bool`:

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

`torch.ge(input, other, out=None) -> Tensor`:

逐元素比较input和other，即是否input >= other
第二个参数可以为一个数或与第一个参数相同形状和类型的张量。

input(Tensor) - 待对比的张量
other(Tensor or float) - 对比的张量或float值
out(Tensor, optional) - 输出张量，必须为ByteTensor或与第一个参数相同类型。

`torch.gt(input, other, out=None) -> Tensor`:

逐元素比较input和other，是否input > other。若两个张量有相同的形状和元素值，则返回True，否则False。第二个参数
可以为一个数或与第一个参数相同形状和类型的张量。

`torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)`:

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

input(Tensor) - 输入张量
k(int) - 第k个最小值
dim(int, optional)` - 沿着此维度进行排序
out(tuple, optional) - 输出元组

`torch.le(input, other, out=None) -> Tensor`:

逐元素比较input和other，即是否input <= other，第二个参数可以为一个数或与第一个参数相同形状和类型的张量。

`torch.lt(input, other, out=None) -> Tensor`:

逐元素比较input和other，即是否input < other

`torch.max(input, dim, max=None, max_indice=None) -> (Tensor, LongTensor)`:

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

input(Tensor) - 输入张量
dim(int) - 指定的维度
max(Tensor, optional) - 结果张量，包含给定维度上的最大值
max_indices(LongTensor, optional) - 包含给定维度上每个最大值的位置索引。

`torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)`:

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

`torch.min(input, other, out=None) -> Tensor`:

input中逐元素与other相应位置的元素对比，返回最小值到输出张量。两张量形状不需匹配，但元素数须相同。

`torch.ne(input, other, out=Tensor) -> Tensor`:

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

`torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)`:

对输入张量input沿着指定维度按升序排序，如果不给定dim，默认为输入的最后一维。如果指定参数descending为True，则按降序排序。
返回两项：重排后的张量，和重排后元素在原张量的索引

input(Tensor) - 输入张量
dim(int, optional) - 沿此维排序，默认为最后一维
descending(bool, optional) - 布尔值，默认升序

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

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

7.4 其它操作 Other Operations

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

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

`torch.diag(input, diagonal=0, out=None) -> Tensor`:

如果输入是一个向量，则返回一个以input为对角线元素的2D方阵
如果输入是一个矩阵，则返回一个包含input为对角元素的1D张量
参数diagonal指定对角线：

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

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

计算输入张量的直方图。如果min和max都为0,则利用数据中的最大最小值作为边界。

`torch.renorm(input, p, dim, maxnorm, out=None) -> Tensor`:

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

`torch.trace(input) -> float`:

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

`torch.tril(input, diagonal=0, out=None) -> Tensor`:

返回一个张量，包含输入张量(2D张量)的下三角部分，其余部分设为0，参数diagonal控制对角线。

`torch.triu（input, diagonal=0, out=None) -> Tensor`:

返回一个张量，包含输入矩阵的上三角部分，其余被置为0。

7.5 BLAS and LAPACK Operations

`torch.dot(tensor1, tensor2) -> float`:

计算两个张量的点乘，两个张量都为1-D向量

`torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)`:

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

a(Tensor) - 方阵
eigenvectors(bool) - 如果为True，同时计算特征值和特征微量，否则只计算特征值
返回值：
e(Tensor) - a的右特征向量
v(Tensor) - 如果eigenvectors为True，则为包含特征向量的张量，否则为空。

`torch.inverse(input, out=None) -> Tensor`:

对方阵input求逆

`torch.mm(mat1, mat2, out=None) -> Tensor`:

对矩阵mat1和mat2进行相乘。

`torch.mv(mat, vec, out=None) -> Tensor`:

对矩阵mat和向量vec进行相乘。

torch常用基础函数