torch
Tensors
1、torch.is_tensor()
torch.is_tensor(obj)
判断指定对象是否为Tensor张量
- obj：目标对象
示例：
>>>x=torch.tensor([1,2,3]) >>>torch.is_tensor(x) True >>>torch.is_tensor(1) False
2、torch.is_storage()
torch.is_storage(obj)
判断指点对象是否为Tensor的存储对象
- obj：目标对象
示例：
>>>x=torch.tensor([1,2,3]) >>>torch.is_storage(x.storage()) True
3、torch.is_complex()
torch.is_complex(input)
判断目标张量是否为负数类型
- input：待判断的张量
示例：
>>>real = torch.tensor([1, 2], dtype=torch.float32) >>>imag = torch.tensor([3, 4], dtype=torch.float32) >>>x = torch.complex(real, imag) >>>print(x) >>>torch.is_complex(x) tensor([1.+3.j, 2.+4.j]) True
4、torch.is_floating_point()
torch.is_floating_point(input)
判断指定张量是否为浮点类型
- input：待判断张量
示例：
>>>x=torch.tensor([1,2,3]) >>>torch.is_floating_point(x) False >>>x=torch.tensor([1.0,2.0,3.0]) >>>torch.is_floating_point(x) True
5、torch.is_nonzero()
torch.is_nonzero(input)
如果输入张量不为0，则返回true，否则为False，注意这里必须是单张量，否则会抛出异常
- input：待判断张量
示例：
>>>torch.is_nonzero(torch.tensor([0])) False >>>torch.is_nonzero(torch.tensor([0.0])) False >>>torch.is_nonzero(torch.tensor([1])) True >>>torch.is_nonzero(torch.tensor([1,2,3])) Boolean value of Tensor with more than one value is ambiguous
6、torch.set_default_dtype()
torch.set_default_dtype(d)
用于设置默认的浮点类型
- d：需要设置的数据类型
示例：
>>>torch.tensor([1,2,3]).dtype torch.int64 >>>torch.tensor([1.0,2,3]).dtype torch.float32 >>>torch.tensor([1+2j]).dtype torch.complex64 >>>torch.set_default_dtype(torch.float64) >>>torch.tensor([1.0,2,3]).dtype torch.float64 >>>torch.tensor([1+2j]).dtype torch.complex128
7、torch.get_default_dtype()
torch.get_default_dtype()
返回默认的浮点类型
示例：
>>>torch.get_default_dtype() torch.float32 >>>torch.set_default_dtype(torch.float64) >>>torch.get_default_dtype() torch.float64
8、torch.set_default_tensor_type()
torch.set_default_tensor_type(t)
设置默认的张量Tensor类型
- t：浮点张量的类型
示例：
>>> torch.tensor([1.2, 3]).dtype torch.float32 >>> torch.set_default_tensor_type(torch.DoubleTensor) >>> torch.tensor([1.2, 3]).dtype torch.float64
9、torch.numel()
torch.numel(input)
返回张量中的总元素个数
- input：目标张量
示例：
>>>torch.numel(torch.randn(2,3)) 6 >>>torch.numel(torch.randn(2)) 2
Creation Ops
1、torch.tensor()
torch.tensor(data,dtype=None,device=None,requires_grad=False,pin_memory=False)
根据传入的数据返回相应形状的张量
- data：传入的数据，该数据可以为列表、元组、标量、ndarray等
- dtype：返回Tensor的数据类型，如果为None，会根据原数据类型进行推断
- requires_grad：默认False，如果为True，返回的张量会自动进行累积梯度
- device：将返回的Tensor加载到CPU还是GPU，默认是当前设备
- pin_memort：返回的张量将在固定内存中分配。仅适用于CPU张量
示例：
>>>torch.tensor([1,2,3]) tensor([1, 2, 3]) # 这里需要注意如果将requires_grad设置为True，那么整个Tensor应该为浮点类型，至于浮点类型才可以求导 # 可以在后面的dtype指名类型，也可以在数据中加入个浮点数，使之变成浮点数组[[1.0,2,3],[4,5,6]] >>>torch.tensor([[1,2,3],[4,5,6]],requires_grad=True,device=torch.device('cpu'),dtype=torch.float32) tensor([[1., 2., 3.], [4., 5., 6.]], dtype=torch.float32, requires_grad=True) >>>torch.tensor(1.26) torch.tensor(1.26)
2、torch.as_tensor()
torch.as_tensor(data,dtype=None,device=None)
将指定的数据转化成torch.tensor
- data：待转化的数据
- dtype：返回张量的数据类型
- device：返回的张量加载到CPU还是GPU
示例：
>>>x=np.array([1,2,3]) >>>torch.as_tensor(x) tensor([1, 2, 3], dtype=torch.int32)
3、torch.as_strided()
torch.as_strided(input,size,stride,storage_offset=0)
创建tensor的视图，具有指定的大小形状，步长和storage的偏移量
- input：输入的Tensor
- size：输出视图的形状
- stride：对应视图的步长（行步长和列步长）
- storage_offset：storage对应元素的起始偏移量
示例：
>>>x=torch.arange(1,13).reshape(3,4) >>>print(x) tensor([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) # 偏移量为2，所以从3开始计算，行步长为2，所以对应3、5、7，列步长为2 # 从每行起始位置向后偏移2位 >>>torch.as_strided(x,(3,3),(2,2),2) tensor([[ 3, 5, 7], [ 5, 7, 9], [ 7, 9, 11]])
4、torch.from_numpy()
torch.from_numpy(ndarray)
将numpy类型数据转化成Tensor类型，转化后的tensor与原数据共享内存
- ndarray：numpy数据类型数据
示例：
>>>x=np.array([1,2,3]) >>>y=torch.from_numpy(x) >>>y[0]=999 >>>print(x) [999 2 3]
5、torch.zeros()
torch.zeros(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回指定形状大小的全零张量
- *size：指定张量的形状
- dtype：输出张量的类型
- layout：返回张量的布局，默认是torch.strided
- requires_grad：返回的张量是否进行累积梯度
示例：
>>>torch.zeros(5) tensor([0., 0., 0., 0., 0.]) >>>torch.zeros(3,4) tensor([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])
6、torch.zeros_like()
torch.zeros_like(input,dtype=None,layout=None,device=None,requires_grad=False,memory_format=torch.preserve_format)
返回一个与指定张量相同形状的全零tensor
- input：输入的张量
- memory_format：返回的tensor所需的内存格式，默认是torch.preserve_format
示例：
>>>x=torch.randn(2,3) >>>torch.zeros_like(x) tensor([[0., 0., 0.], [0., 0., 0.]])
7、torch.ones()
torch.ones(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回指定形状大小的全1张量
- *size：指定张量的形状
- dtype：输出张量的类型
- layout：返回张量的布局，默认是torch.strided
- requires_grad：返回的张量是否进行累积梯度
示例：
>>>torch.ones(5) tensor([1., 1., 1., 1., 1.]) >>>torch.zeros(3,4) tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])
8、torch.ones_like()
torch.ones_like(input,dtype=None,layout=None,device=None,requires_grad=False,memory_format=torch.preserve_format)
返回一个与指定张量相同形状的全1tensor
- input：输入的张量
- memory_format：返回的tensor所需的内存格式，默认是torch.preserve_format
示例：
>>>x=torch.randn(2,3) >>>torch.ones_like(x) tensor([[1., 1., 1.], [1., 1., 1.]])
9、torch.arange()
torch.arange(start=0,end,step=1,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回一个一维张量，起始为start，终止为end，步长为step，左闭右开
- start：起始的位置
- end：终止的位置，但是不包括，左闭右开
- step：步长，可以为浮点数
示例：
>>>torch.arange(5) tensor([0, 1, 2, 3, 4]) >>>torch.arange(1,10,2.5) tensor([1.0000, 3.5000, 6.0000, 8.5000])
10、torch.linspace()
torch.linspace(start,end,steps,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回一个等差数列，长度为steps，左闭右闭
- start：起始点
- end：终止位置
- step：输出向量的长度
示例：
>>>torch.linspace(1,10,5) tensor([ 1.0000, 3.2500, 5.5000, 7.7500, 10.0000])
11、torch.logspace()
torch.logspace(start,end,steps,base=10.0,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回一组张量，该张量是以底数为base，指数为一组等差数列形成的张量
- start：等差数列的起始点
- end：终止位置
- steps：等差数列的长度
- base：底数
示例：
>>>torch.logspace(1,10,10,base=2) tensor([ 2., 4., 8., 16., 32., 64., 128., 256., 512., 1024.])
12、torch.eye()
torch.eye(n,m=None,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回一个指定形状的对角矩阵，如只指出n，则返回n*n的对角方矩阵
- n、m：指明生成张量的形状
示例：
>>>torch.eye(3,4) tensor([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]]) >>>torch.eye(3) tensor([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
13、torch.empty()
torch.empty(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False)
返回一个指定形状的随机初始化的张量
- size：指定张量的形状
- requires_grad：是否对其进行累积梯度
示例：
>>>torch.empty(3,5) tensor([[4.9407e-324, 7.4110e-323, 0.0000e+00, 0.0000e+00, 0.0000e+00], [ 0.0000e+00, 4.9407e-324, 0.0000e+00, 0.0000e+00, 0.0000e+00], [ 0.0000e+00, 0.0000e+00, 7.4110e-323, 5.4111e-312, 2.1220e-314]]) >>>torch.empty(3) tensor([0.0000e+00, 4.4703e-38, 4.4702e-90])
14、torch.empty_like()
torch.empty_like(input,dtype=None,layout=None,device=None,requires_grad=False,memory_format=torch.preserve_format)
返回一个与指定张量形状相同的随机初始化张量
- input：指定的张量
示例：
>>>x=torch.randn(2,3) >>>torch.empty_like(x) tensor([[8.3444e-308, 1.7802e-306, 6.2306e-307], [9.7911e-307, 6.8981e-307, 7.5659e-307]])
15、torch.empty_strided()
torch.empty_strided(size,stride,dtype=None,layout=None,device=None,requires_grad=False,pin_memory=False)
返回一个指定形状，指定步长（行步长和列步长）的张量
- size：指定的形状
- stride：行步长和列步长
示例：
>>>torch.empty_strided((2,3),(1,2)) tensor([[8.3444e-308, 6.2306e-307, 6.8981e-307], [1.7802e-306, 9.7911e-307, 7.5659e-307]])
16、torch.full()
torch.full(size,fill_value,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
创建一个用fill_value 填充的大小为size 的张量，张量的 dtype 是从 fill_value 推断出来的
- size：指定张量的形状
- fill_value：待填充的值
示例：
>>>torch.full((2,3),5) tensor([[5, 5, 5], [5, 5, 5]])
17、torch.full_like()
torch.full_like(input,fill_value,dtype=None,layout=torch.strided,device=None,requires_grad=False,memory_format=torch.preserve_format)
返回与填充了 fill_value 的输入具有相同大小的张量
- input：指定的张量
- fill_value：用于填充的值
示例：
>>>x=torch.randn(2,3) >>>torch.full_like(x,9) tensor([[9., 9., 9.], [9., 9., 9.]])
18、torch.complex()
torch.complex(real,imag,out=None)
创建一个复数张量
- real：实部张量
- imag：虚部张量
示例：
>>>real = torch.tensor([1, 2], dtype=torch.float32) >>>imag = torch.tensor([3, 4], dtype=torch.float32) >>>z = torch.complex(real, imag) >>>z tensor([1.+3.j, 2.+4.j], dtype=torch.complex64)
19、torch.heaviside()
torch.heaviside(input,values,out=None)
返回一个张量，每个张量分别是本身对应的跃阶函数值
- input：输入的张量
- values：input=0时待填充的值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IpoLRzfd-1622815899242)(E:\其他\Markdown\image\image-20210530113838465.png)]
示例：
>>>x=torch.tensor([-1,0,1]) >>>torch.heaviside(x,torch.tensor([5])) tensor([0, 5, 1])
Indexing, Slicing, Joining, Mutating Ops
1、torch.cat()
torch.cat(tensors,dim=0,out=None)
将指定的张量按照指定维度进行拼接，要求两个张量必须是同形状
- tensors：用于拼接的张量
- dim：需要拼接的维度，如果是二维，dim=0就是按行拼接，dim=1就是按列拼接
示例：
>>>x=torch.tensor([[1,2,3,4,5,6]]) >>>print(x) >>>torch.cat((x,x),dim=0) tensor([[1, 2, 3, 4, 5, 6]]) tensor([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]]) >>>torch.cat((x,x),dim=1) tensor([[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]])
2、torch.chunk()
torch.chunk(input,chunks,dim=0)
将输入张量按照指定维度进行拆分，如果维度不能够整除，前面的保持最大拆分，最后一个张量保留最少的
- input：待拆分的张量
- chunks：将张量分成几块
- dim：按按个维度进行拆分
示例：
>>>x=torch.arange(12).reshape(3,4) >>>print(x) >>>torch.chunk(x,2,dim=0) tensor([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) (tensor([[0, 1, 2, 3], [4, 5, 6, 7]]), tensor([[ 8, 9, 10, 11]])) >>>torch.chunk(x,2,dim=1) (tensor([[0, 1], [4, 5], [8, 9]]), tensor([[ 2, 3], [ 6, 7], [10, 11]]))
3、torch.column_stack()
torch.column_stack(tensors,out=None)
将多个张量进行水平拼接，要求张量的行数必须相同，如果是向量则将它变成（n，1）维张量后进行拼接
- tensors：待拼接的张量
示例：
>>>x=torch.tensor([1,2,3]) >>>y=torch.tensor([4,5,6]) >>>torch.column_stack((x,y)) tensor([[1, 4], [2, 5], [3, 6]]) >>>z=torch.arange(6).reshape(3,2) >>>torch.column_stack((x,z)) >>>tensor([[1, 0, 1], [2, 2, 3], [3, 4, 5]])
4、torch.index_select()
torch.index_select(input,dim,index,out=None)
按照指定的下标进行指定维度向量的选取
- input：输入的张量
- dim：选取下标时按照的维度
- index：下标，要求是tensor
示例：
>>>x=torch.rand(3,4) >>>print(x) >>>torch.index_select(x,0,torch.tensor([1,2])) tensor([[0.4395, 0.0137, 0.3365, 0.2348], [0.9258, 0.5344, 0.5208, 0.6679], [0.5748, 0.9210, 0.5702, 0.7754]]) tensor([[0.9258, 0.5344, 0.5208, 0.6679], [0.5748, 0.9210, 0.5702, 0.7754]]) >>>torch.index_select(x,1,torch.tensor([1,2])) tensor([[0.1270, 0.5676], [0.5333, 0.6595], [0.4739, 0.9381]])
5、torch.masked_select()
torch.masked_select(input,mask,out=None)
按照给定的布尔掩码进行元素索引
- input：输入的张量
- mask：该张量的布尔掩码
示例：
>>>x=torch.arange(12).reshape(3,4) >>>print(x) >>>mask=x.ge(5) >>>print(mask) tensor([[False, False, False, False], [False, True, True, True], [ True, True, True, True]]) >>>torch.masked_select(x,mask) tensor([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) tensor([ 5, 6, 7, 8, 9, 10, 11])
6、torch.movedim()
torch.movedim(input,source,destination)
将张量的维度进行互换，但是注意这里和reshape不一样，虽说都可以改变维度，但是数据交换的方式不一样
- input：输入的张量
- source、destination：需要交换的维度
示例：
>>>x=torch.arange(1,25).reshape(2,3,4) >>>print(x) >>>torch.movedim(x,0,1) tensor([[[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]], [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]) tensor([[[ 1, 2, 3, 4], [13, 14, 15, 16]], [[ 5, 6, 7, 8], [17, 18, 19, 20]], [[ 9, 10, 11, 12], [21, 22, 23, 24]]])
7、torch.narrow()
torch.narrow(input,dim,start,length)
返回一个张量，该张量是将input按照指定维度和要求分割，就是类似于切片
- input：输入的张量
- dim：需要分割的维度
- start：开始的下标
- length：切片的长度
示例：
>>>x=torch.randn(3,3) >>>print(x) tensor([[ 1.0549, 0.1591, -0.2812], [-0.9391, 0.1298, 0.3361], [ 0.0672, -0.3930, -0.4832]]) >>>torch.narrow(x,0,0,1) tensor([[ 1.0549, 0.1591, -0.2812]]) >>>torch.narrow(x,1,0,2) tensor([[ 1.0549, 0.1591], [-0.9391, 0.1298], [ 0.0672, -0.3930]])
8、torch.reshape()
torch.reshape(input,shape)
改变输入张量的形状
- input：输入的张量
- shape：需要转换的形状
示例：
>>>x=torch.randn(3,4) >>>torch.reshape(x,(2,6)).shape torch.Size([2, 6])
9、torch.split()
torch.split(tensor,split_size_or_sections,dim=0)
将输入的张量指定维度以及每块需要分割的大小进行拆分，和torch.chunk()差不多，只不过是chunk的参数是将张量分成几块，而split是每块具体多少
- tensor：待分割的张量
- split_size_or_sections：分割每块的大小，可以是int也可以是列表代表每块的大小
- dim：按照指定维度
示例：
>>>x=torch.randn(6,2) >>>print(x) tensor([[ 1.5753, 1.6751], [-1.9584, -0.0209], [-0.3770, 0.0582], [-0.9312, 1.1433], [-0.3046, -0.9651], [-0.1767, 0.9164]]) >>>torch.split(x,2,dim=0) (tensor([[ 1.5753, 1.6751], [-1.9584, -0.0209]]), tensor([[-0.3770, 0.0582], [-0.9312, 1.1433]]), tensor([[-0.3046, -0.9651], [-0.1767, 0.9164]])) >>>torch.split(x,[1,2,3],dim=0) (tensor([[1.5753, 1.6751]]), tensor([[-1.9584, -0.0209], [-0.3770, 0.0582]]), tensor([[-0.9312, 1.1433], [-0.3046, -0.9651], [-0.1767, 0.9164]]))
10、torch.squeeze()
torch.squeeze(input,dim=None,out=None)
返回一个张量，将所有为1的维度进行删除，也可以指定维度进行删除，如果指定的维度不为1，不发生任何效果
- input：输入的张量
- dim：指定的维度
示例：
>>>x=torch.randn(2,3,1,3,1,2) >>>print(x.shape) torch.Size([2, 3, 1, 3, 1, 2]) >>>torch.squeeze(x).shape torch.Size([2, 3, 3, 2]) >>>torch.squeeze(x,dim=2).shape torch.Size([2, 3, 3, 1, 2])
11、torch.unsqueeze()
torch.unsqueeze(input,dim)
将输入的张量按指定维度进行升维，常用于图片处理，将图片变成4维形成一个批次
- input：输入的张量
- dim：需要升维的维度
示例：
>>>x=torch.tensor([1,2,3]) >>>print(x.shape) torch.Size([3]) >>>torch.unsqueeze(x,dim=0).shape torch.Size([1, 3]) >>>torch.unsqueeze(x,dim=1).shape torch.Size([3, 1])
12、torch.t()
torch.t(input)
将输入的张量进行转置，注意张量的维度只能为1或者是2
- input：输入的张量
示例：
>>>x=torch.randn(2,3) >>>print(x) tensor([[ 0.3328, -0.8055, 0.6797], [-1.1625, -1.0922, -0.1599]]) >>>torch.t(x) tensor([[ 0.3328, -1.1625], [-0.8055, -1.0922], [ 0.6797, -0.1599]])
13、torch.take()
torch.take(input,index)
按照指定的下标切片取出张量中对应的元素，返回的张量为1D
- input：输入的张量
- index：指定的下标切片
示例：
>>>x=torch.arange(1,24,2).reshape(3,4) >>>print(x) tensor([[ 1, 3, 5, 7], [ 9, 11, 13, 15], [17, 19, 21, 23]]) >>>torch.take(x,torch.tensor([0,3,4])) tensor([1, 7, 9])
14、torch.tile()
torch.tile(input,reps)
将输入的张量按照每个维度进行重复复制
- input：输入的张量
- reps：每个维度需要复制的次数
示例：
>>>x=torch.tensor([[1,2,3],[4,5,6]]) >>>print(x) tensor([[1, 2, 3], [4, 5, 6]]) >>>torch.tile(x,(2,3)) tensor([[1, 2, 3, 1, 2, 3, 1, 2, 3], [4, 5, 6, 4, 5, 6, 4, 5, 6], [1, 2, 3, 1, 2, 3, 1, 2, 3], [4, 5, 6, 4, 5, 6, 4, 5, 6]])
15、torch.where()
torch.where(condition,x,y)
如果条件成立，返回x中元素，否则返回y中元素
- condition：条件
- x，y：对应的张量
示例：
>>>x=torch.arange(12).reshape(3,4).double() >>>print(x) >>>y=torch.ones(3,4) >>>print(y) tensor([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]]) tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]]) >>>torch.where(x>0,x,y) tensor([[ 1., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]])
Generators
1、torch.Generators()
torch.Generator(device=‘cpu’)
创建并返回一个生成器对象，该对象管理生成伪随机数的算法的状态。在许多就地随机采样函数中用作关键字参数
- device：生成器需要的设备
示例：
>>>generator=torch.Generator(device='cpu') >>>generator.seed() 611916985068500
Random sampling
1、torch.rand()
torch.rand(*size,dtype=None,layout=torch.dtrided,device=None,requires_grad=False)
返回符合0-1均匀分布的随机张量
- size：定义指定张量的形状，可以是一个标量或者是元组、列表等
- dtype：返回张量的所需数据类型。默认值：如果为None，则使用全局默认值
- layout：返回张量的所需布局。默认值：如果为None，则默认为输入的布局
- device：返回张量的所需设备
- requires_grad：如果为True，会对该张量累计梯度，默认False
示例：
>>>print(torch.rand(5)) tensor([0.7064, 0.8214, 0.3419, 0.9137, 0.2276]) >>>print(torch.rand(2,3)) tensor([[0.7915, 0.1482, 0.2567], [0.8610, 0.1996, 0.7721]])
2、torch.rand_like()
torch.rand_like(input,dtype=None,layout=torch.dtrided,device=None,requires_grad=False)
返回一个与输入张量的形状相同且符合0-1均匀分布的随机张量
- input：所需指定维度的张量
示例：
>>>x=torch.randn(2,3) tensor([[-0.3432, 1.1508, -1.6057], [-1.4066, 0.8564, -0.2964]]) >>>torch.rand_like(x) tensor([[0.6321, 0.3238, 0.9716], [0.8112, 0.7977, 0.6651]])
3、torch.randint()
torch.randint(low=0,high,size,generator=None,dtype=None)
返回在low-high区间符合均匀分布的随机张量
- low：起始值
- high：终止值
- size：指定张量的形状
- generator：用于数字采样的生成器，就是制定了就会用这个生成器去生成数据，不会每次生成不同的值
示例：
>>>torch.randint(0,10,(3,)) tensor([8, 8, 1]) >>>torch.randint(0,10,(3,),generator=torch.Generator()) tensor([0, 4, 7]) >>>torch.randint(1,9,(2,3)) tensor([[3, 2, 8], [3, 1, 3]])
4、torch.randint_like()
torch.randint_like(input,low=0,high)
返回一个与输入张量的形状相同且符合low-high均匀分布的随机张量
- input：指定形状的向量
示例：
>>>x=torch.rand(2,3) >>>torch.randint_like(x,0,5) tensor([[2., 3., 4.], [4., 4., 4.]])
5、torch.randn()
torch.randn(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)
返回符合均值为0，方差为1的标准正态分布张量
- *size：指定形状，可以是标量或者元组
示例：
>>>torch.randn(3) tensor([-0.6165, 2.5210, -0.4892]) >>>torch.randn(2,3) tensor([[-1.7389, 0.6000, -0.7431], [ 0.7352, 1.2683, 1.3413]]) # 这里可以发现计算均值和方差并不是0和1，这是因为数据太少，很难符合标准正态分布 >>>print(torch.randn(2,3).mean(),torch.randn(2,3).std()) tensor(-0.2583) tensor(0.5524) >>>print(torch.randn(9999,9999).mean(),torch.randn(9999,9999).std()) tensor(-9.7010e-05) tensor(1.0000)
6、torch.randn_like()
torch.randn_like(input,*)
返回一个与输入张量的形状相同且符合均值为0，方差为1的标准正态分布的随机张量
- input：指定形状的张量
示例：
>>>x=torch.rand(2,3) >>>torch.randn_like(x) tensor([[ 2.4693, 0.0086, -2.1851], [ 0.5438, -0.2272, -0.0619]])
7、torch.normal()
torch.normal(mean,std,generator=None,*)
返回均值为mean，方差为std的标准正态分布的随机张量
- mean：均值
- std：方差
- generator：数字采样的生成器
示例：
>>>torch.normal(0,1,(2,3),generator=torch.Generator()) tensor([[ 0.9773, 1.1569, -0.3807], [ 1.2525, -0.3068, -1.4705]]) >>>torch.normal(0,1,(3,)) tensor([ 0.9773, 1.1569, -0.3807]) # 从不同的正态分布中进行随机采样数字，注意在mean的里面是1.0，因为要与后面std浮点数进行匹配，否则会造成数据类型不匹配 >>>torch.normal(mean=torch.arange(1.0, 11.0), std=torch.arange(1, 0, -0.1)) tensor([ 1.6370, 1.6014, 3.7083, 2.7965, 6.1434, 5.9427, 7.0117, 7.7423, 9.1217, 10.0489])
8、torch.randperm()
torch.randperm(n,generator=None,dtype=torch.int64)
返回0-n-1之间的数字的随机排列
- n：终止数字
- generator：数字采样的生成器
- dtype：默认是torch.int64
示例：
>>>torch.randperm(10) tensor([4, 7, 8, 9, 5, 2, 0, 3, 6, 1])
Serialization
1、torch.save()
torch.save(obj,f,pickle_module=pickle,pickle_protocol=2,_use_new_zipfile_serialization=True)
将一个对象保存为磁盘文件，一般用于保存模型参数
- obj：需要保存的对象
- f：对应的文件，一般是待保存的文件名或者路径
示例：
>>>x=torch.tensor([1,2,3,4]) >>>torch.save(x,'./x.pth') >>>torch.load('./x.pth') tensor([1, 2, 3, 4]) >>>net=nn.Linear(10,1) >>>torch.save(net.state_dict(),'modle.pth') >>>torch.load('./modle.pth') OrderedDict([('weight', tensor([[ 0.2403, 0.1767, -0.0659, 0.2238, 0.1523, 0.1028, -0.1183, -0.2205, 0.1396, 0.2485]])), ('bias', tensor([-0.0691]))])
2、torch.load()
torch.load(f,map_location=None,pickle_module=pickle,*)
用于加载torch.save()保存的序列化数据，一般用于加载模型参数
- f：待加载的文件名或者路径
- map_location：用于指定将加载的数据放到cpu还是gpu
示例：
>>>net=nn.Linear(10,1) >>>torch.save(net.state_dict(),'model.pth') >>>net.load_state_dict(torch.load('./model.pth', map_location=torch.device('cpu')))
Parallelism
1、torch.get_num_threads()
torch.get_num_threads()
返回用于并行化CPU操作的线程数
示例：
>>>torch.get_num_threads() 4
2、torch.set_num_threads()
torch.set_num_threads(int)
设置用于CPU上的内部运算并行化的线程数
- int：用于CPU计算的并行化线程数
示例：
>>>torch.set_num_threads(5) >>>torch.get_num_threads() 5
Locally disabling gradient computation
1、torch.no_grad()
torch.no_grad()
禁用梯度计算的上下文管理器，它将减少原本需要require_grad = True的计算的内存消耗
示例：
>>>x=torch.tensor(2.0,requires_grad=True) >>>y=2*x >>>y.backward() >>>x.grad tensor(2.) # 报错的原因：torch.no_grad()标记下面的张量不会累计梯度，就是不会进行梯度的累计记录，y是不知道自己怎么从x来的，所以在y.backward()这一函数就会报错，y找不到需要求导的变量 >>>with torch.no_grad(): x=torch.tensor(2.0,requires_grad=True) y=2*x y.backward() x.grad RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
2、torch.set_grad_enabled()
torch.set_grad_enabled()
将渐变计算设置为开或关的上下文管理器
- mode：是否开启累计梯度
示例：
>>>x=torch.tensor(3.0,requires_grad=True) >>>with torch.set_grad_enabled(True): y=2*x y.backward() print(y.requires_grad) print(x.grad) >>>torch.set_grad_enabled(False) >>>y=2*x >>>print(y.requires_grad) >>>torch.set_grad_enabled(True) >>>y=2*x >>>y.backward() >>>print(y.requires_grad) >>>print(x.grad) True tensor(2.) False True tensor(4.) # 这里为什么一个是2，一个是4呢？因为重新开启梯度后，x的梯度没有清0，第二次求导会在之前的基础上进行累计
3、torch.enabled_grad()
torch.enabled_grad()
启用梯度计算的上下文管理器
示例：
>>>x=torch.tensor(3.0,requires_grad=True) >>>with torch.no_grad(): with torch.enable_grad(): y=2*x print(y.requires_grad) y.backward() print(x.grad) True tensor(2.)
Math operations
Pointwise Ops
Reduction Ops
Comparison Ops
Spectral Ops
Other Operations
BLAS and LAPACK Operations
Utilities
16、
示例：
• 1
17、
示例：
• 1
18、
示例：
• 1
19、
示例：
• 1
20、
示例：
• 1
21、
示例：
• 1
22、
示例：
• 1
23、
示例：
• 1
24、
示例：
• 1
25、
示例：
• 1
26、
示例：
• 1
27、
示例：
• 1
28、
示例：
• 1
29、
示例：
• 1
30、
示例：
• 1
31、
示例：
• 1
32、
示例：
• 1
33、
示例：
• 1
34、
示例：
• 1
35、
示例：
• 1
36、
示例：
• 1
37、
示例：
• 1
38、
示例：
• 1
39、
示例：
• 1
40、
示例：
• 1
41、
示例：
• 1
42、
示例：
• 1
43、
示例：
• 1
44、
示例：
• 1
45、
示例：
• 1
46、
示例：
• 1
47、
示例：
• 1
48、
示例：
• 1
49、
示例：
• 1
50、
示例：
• 1
11、
示例：
• 1
12、
示例：
• 1
13、
示例：
• 1
14、
示例：
• 1
15、
示例：
• 1
16、
示例：
• 1
17、
示例：
• 1
18、
示例：
• 1
19、
示例：
• 1
10、
示例：
• 1
11、
示例：
• 1
12、
示例：
• 1
13、
示例：
• 1
14、
示例：
• 1
15、
示例：
• 1
16、
示例：
• 1
17、
示例：
• 1
18、
示例：
• 1
19、
示例：
• 1
10、
示例：
• 1
11、
示例：
• 1
12、
示例：
• 1
13、
示例：
• 1
14、
示例：
• 1
15、
示例：
• 1
16、
示例：
• 1
17、
示例：
• 1
18、
示例：
• 1
19、
示例：
• 1
10、
示例：
• 1
11、
示例：
• 1
12、
示例：
• 1
13、
示例：
• 1
14、
示例：
• 1
15、
示例：
• 1
16、
示例：
• 1
17、
示例：
• 1
18、
示例：
• 1
19、
示例：
• 1
10、
示例：
• 1
11、
示例：
• 1
12、
示例：
• 1
13、
示例：
• 1
14、
示例：
• 1
15、
示例：
• 1
16、
示例：
• 1
17、
示例：
• 1
18、
示例：
• 1
19、
示例：
• 1
