torch模块常用方法总结

torch

torch 包含了多维张量的数据结构以及基于其上的多种数学操作。另外，它也提供了多种工具，其中一些可以更有效地对张量和任意类型进行序列化。

import torch 
1

torch.set_printoptions

设置打印选项
torch.set_printoptions(precision=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)
• sci_mode - 科学计数法

a = torch.rand(100,100)
a
1
2

只会输出一部分数据

torch.set_printoptions(precision=10)
a
1
2

输出全部数据

torch.eye

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

torch.eye(4)
1

tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]])
1
2
3
4

numpy转化为tensor

import numpy as np
1

a = np.array([1,2,3,4,5,6])
a
1
2

array([1, 2, 3, 4, 5, 6])
1

#方法一
tensor_a = torch.tensor(a)
tensor_a
1
2
3

tensor([1, 2, 3, 4, 5, 6], dtype=torch.int32)
1

tensor_a[0] = -1
a
1
2

array([1, 2, 3, 4, 5, 6])
1

b = np.array([1,2,3,4,5,6])
b
1
2

array([1, 2, 3, 4, 5, 6])
1

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

#方法二
tensor_b = torch.from_numpy(b)
tensor_b
1
2
3

tensor([1, 2, 3, 4, 5, 6], dtype=torch.int32)
1

tensor_b[0] = -1
b
1
2

array([-1,  2,  3,  4,  5,  6])
1

torch.linspace

返回一个1维张量，包含在区间start 和 end 上均匀间隔的steps个点。 输出1维张量的长度为steps。

• start (float) – 序列的起始点
• end (float) – 序列的最终值
• steps (int) – 在start 和 end间生成的样本数
• out (Tensor, optional) – 结果张量

torch.linspace(1,5,steps = 10)
1

tensor([1.0000000000, 1.4444444180, 1.8888888359, 2.3333334923, 2.7777776718,
        3.2222223282, 3.6666665077, 4.1111111641, 4.5555553436, 5.0000000000])
1
2

torch.logspace

返回一个1维张量，包含在区间 $10^{start}$和 $10^{end}$上以对数刻度均匀间隔的steps个点。 输出1维张量的长度为steps。

• start (float) – 序列的起始点
• end (float) – 序列的最终值
• steps (int) – 在start 和 end间生成的样本数
• out (Tensor, optional) – 结果张量

torch.logspace(1,8,steps = 3)
1

tensor([   10.0000000000, 31622.7773437500, 100000000.0000000000])
1

torch.ones

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

torch.ones(3,5)
1

tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
1
2
3

torch.rand

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

torch.rand(4)
1

tensor([0.2573032379, 0.2179149985, 0.4656094313, 0.0828071833])
1

torch.rand(5, 3)
1

tensor([[0.7632396221, 0.0302500725, 0.6429942846],
        [0.2644285560, 0.1896467209, 0.4061338902],
        [0.6657168269, 0.1425771117, 0.5113636851],
        [0.9372168183, 0.7655946612, 0.1887679100],
        [0.3604329824, 0.9002583623, 0.0541984439]])
1
2
3
4
5

torch.randn

返回一个张量，包含了从标准正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随机数

torch.randn(2,3)
1

tensor([[-0.3220688105, -1.0411276817, -0.0246272516],
        [ 0.2796218097, -0.4497807026, -0.0062698554]])
1
2

torch.randperm

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

torch.randperm(8)
1

tensor([6, 3, 5, 7, 4, 2, 0, 1])
1

torch.arange

返回一个1维张量，长度为 floor((end−start)/step)。包含从start到end，以step为步长的一组序列值(默认步长为1)。

• start (float) – 序列的起始点
• end (float) – 序列的终止点
• step (float) – 相邻点的间隔大小

 torch.arange(1,10)
1

tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])
1

 torch.arange(1,10,3)
1

tensor([1, 4, 7])
1

torch.zeros

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

torch.zeros(2, 13)
1

tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
1
2

a = torch.tensor([1,2,3,4,5,6,7,8,9])
a
1
2

tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])
1

torch.split

• 当split_size_or_sections为int时，tenor结构和split_size_or_sections，正好匹配，那么ouput就是大小相同的块结构。如果按照split_size_or_sections结构，tensor不够了，那么就把剩下的那部分做一个块处理。
• 当split_size_or_sections 为list时，那么tensor结构会一共切分成len(list)这么多的小块，每个小块中的大小按照list中的大小决定，其中list中的数字总和应等于该维度的大小，否则会报错（注意这里与split_size_or_sections为int时的情况不同）。

torch.split(a,2)
1

(tensor([1, 2]), tensor([3, 4]), tensor([5, 6]), tensor([7, 8]), tensor([9]))
1

torch.split(a,[2,3,4])
1

(tensor([1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8, 9]))
1

torch.cat

torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作

• inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列
• dimension (int, optional) – 沿着此维连接张量序列。

a = torch.tensor([[1,2,3],[3,3,1]])
a
1
2

tensor([[1, 2, 3],
        [3, 3, 1]])
1
2

b = torch.tensor([[11,22,3],[7,3,2]])
b
1
2

tensor([[11, 22,  3],
        [ 7,  3,  2]])
1
2

torch.cat((a,b),0)
1

tensor([[ 1,  2,  3],
        [ 3,  3,  1],
        [11, 22,  3],
        [ 7,  3,  2]])
1
2
3
4

torch.cat((a,b),1)
1

tensor([[ 1,  2,  3, 11, 22,  3],
        [ 3,  3,  1,  7,  3,  2]])
1
2

torch.transpose

返回输入矩阵input的转置

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

a = torch.tensor([[1,2],[3,4]])
a
1
2

tensor([[1, 2],
        [3, 4]])
1
2

torch.transpose(a,0,1)
1

tensor([[1, 3],
        [2, 4]])
1
2

torch.transpose(a,1,0)
1

tensor([[1, 3],
        [2, 4]])
1
2

a.T
1

tensor([[1, 3],
        [2, 4]])
1
2

随机种子

设置CPU生成随机数的种子，方便下次复现实验结果。
为 CPU 设置 种子 用于生成随机数，以使得结果是确定的。
当你设置一个随机种子时，接下来的随机算法生成数根据当前的随机种子按照一定规律生成。
随机种子作用域是在设置时到下一次设置时。要想重复实验结果，设置同样随机种子即可。

# 设定生成随机数的种子，并返回一个 torch._C.Generator 对象。
torch.manual_seed(seed)
# 返回生成随机数的原始种子值
torch.initial_seed()
#  从伯努利分布中抽取二元随机数(0 或者 1)。
torch.bernoulli
1
2
3
4
5
6

torch.abs

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

a = torch.tensor([[-1,2],[-3,-4]])
torch.abs(a)
1
2

tensor([[1, 2],
        [3, 4]])
1
2

torch.add()

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

a = torch.tensor([[-1,2],[-3,-4]])
torch.add(a,10)
1
2

tensor([[ 9, 12],
        [ 7,  6]])
1
2

torch.div()

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

torch.exp

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

torch.floor

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

torch.mul

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

torch.pow

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

torch.round

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

torch.sigmoid

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

torch.sqrt

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

torch.mean

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

torch.median

返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的LongTensor。

torch.equal

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

torch.max

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

torch.min

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

torch.Tensor

torch.Tensor是一种包含单一数据类型元素的多维矩阵。

Torch定义了七种CPU tensor类型和八种GPU tensor类型：

torch.Tensor是默认的tensor类型（torch.FlaotTensor）的简称。