以下内容是本人在初学PyTorch的过程中, 记录的一些常用的函数参数以及简单的示例，由于作者英语水平有限，有些地方翻译的不好，可能文章里面存在一些问题，还望各位多多指点， 本文会陆陆续续更新。
加油，阿光！！！我看好你哦
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)
False2、torch.is_storage()
torch.is_storage(obj)
判断指点对象是否为Tensor的存储对象
- obj：目标对象
示例：
>>>x=torch.tensor([1,2,3])
>>>torch.is_storage(x.storage())
True3、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])
True4、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)
True5、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 ambiguous6、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.complex1287、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.float648、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.float649、torch.numel()
torch.numel(input)
返回张量中的总元素个数
- input：目标张量
示例：
>>>torch.numel(torch.randn(2,3))
6
>>>torch.numel(torch.randn(2))
2Creation 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()
611916985068500Random 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()
42、torch.set_num_threads()
torch.set_num_threads(int)
设置用于CPU上的内部运算并行化的线程数
- int：用于CPU计算的并行化线程数
示例：
>>>torch.set_num_threads(5)
>>>torch.get_num_threads()
5Locally 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_fn2、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、
示例：
17、
示例：
18、
示例：
19、
示例：
20、
示例：
21、
示例：
22、
示例：
23、
示例：
24、
示例：
25、
示例：
26、
示例：
27、
示例：
28、
示例：
29、
示例：
30、
示例：
31、
示例：
32、
示例：
33、
示例：
34、
示例：
35、
示例：
36、
示例：
37、
示例：
38、
示例：
39、
示例：
40、
示例：
41、
示例：
42、
示例：
43、
示例：
44、
示例：
45、
示例：
46、
示例：
47、
示例：
48、
示例：
49、
示例：
50、
示例：
11、
示例：
12、
示例：
13、
示例：
14、
示例：
15、
示例：
16、
示例：
17、
示例：
18、
示例：
19、
示例：
10、
示例：
11、
示例：
12、
示例：
13、
示例：
14、
示例：
15、
示例：
16、
示例：
17、
示例：
18、
示例：
19、
示例：
10、
示例：
11、
示例：
12、
示例：
13、
示例：
14、
示例：
15、
示例：
16、
示例：
17、
示例：
18、
示例：
19、
示例：
10、
示例：
11、
示例：
12、
示例：
13、
示例：
14、
示例：
15、
示例：
16、
示例：
17、
示例：
18、
示例：
19、
示例：
10、
示例：
11、
示例：
12、
示例：
13、
示例：
14、
示例：
15、
示例：
16、
示例：
17、
示例：
18、
示例：
19、
示例：
