torch的拼接函数_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进行相乘。