PyTorch快速入门系列-01

PyTorch快速入门系列-01

      • PyTorch简介
          • 张量:Tensor
          • Tensors 张量
          • 创建操作 Creation Ops
          • 索引、切片、连接、换位(Indexing、Slicing、Joining、Mutating Ops)

PyTorch简介

深度学习中最常用的框架有Tensorflow、PyTorch。小编本人当初自学深度学习时,Tensorflow2.0刚出来,由于市面上并没有太多的PyTorch资料,而且Tensorflow入门简单,更快,所以选择了Tensorflow。但随着科研深入,发现大多数论文以及项目都是使用PyTorch框架,自己一脸懵逼!!!应该是自己太菜了,不能够灵活运用Tensorflow,而且身边人都开始用PyTorch,所以最终自己又转向学习PyTorch框架。(随着近年来,PyTorch在各行各业的广泛使用,而其灵活性较高,所以建议白都从PyTorch入门深度学习。)
PyTorch优点:

  1. 代码简洁,灵活使用:由于其基于动态图机制,使用起来相比与Tensorflow更灵活。
  2. DeBug方便:调试PyTorch代码,和C/C++/Python一样简单,清晰。
  3. 开发文档:https://pytorch.org/docs/stable/index.html
  4. 学术届、工业界多数算法都是PyTorch开发。
  5. 入门简单,快速。(方便人工智能初学者快速学习)

安装方式:后续出一个完整的安装文章,可自行先安装试试。(一般搭配环境都是安装Anaconda、PyCharm、PyTorch)。
PyTorch官方也出了一个教程,感兴趣的可以看看。

张量:Tensor

官方文档

torch.tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) → Tensor

官方说明:
Parameters:
data (array_like) – Initial data for the tensor. Can be a list, tuple, NumPy ndarray, scalar, and other types.

Keyword Arguments:
dtype (torch.dtype, optional) – the desired data type of returned tensor. Default: if None, infers data type from data.

device (torch.device, optional) – the device of the constructed tensor. If None and data is a tensor then the device of data is used. If None and data is not a tensor then the result tensor is constructed on the CPU.

requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False.

pin_memory (bool, optional) – If set, returned tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False.

解释:

  • data:数据,可以是列表、元组、array数组或其他类型。
  • dtype:数据类型,默认与data保持一致。
  • device:数据所在位置:CPU/GPU。
  • requires_grad:是否需要求导梯度。
  • pin_memory:返回的Tensor是否被分配在固定的内存中。

看起来是不是很麻烦!接下来就不按照官方文档那样介绍了,直接简单一点,想了解更详细的话,看官网文档就行!

Tensors 张量
  • torch.is_tensor(obj)
    如果obj是一个pytorch张量,则返回True
    参数:obj —判断对象

  • torch.is_storage(obj)
    如果obj是一个pytorch storage对象,则返回True
    参数:obj —判断对象

  • torch.__set_default_tensor_type(t)

  • torch.numel(input) -> int
    返回input张量中的元素个数
    参数:input(Tensor)—输入张量
    案例:

a = torch.randn(1,2,3,4,5) 
torch.numel(a)
#a = 5

b =  torch.ones((4,4))
torch.numel(b)
#b = 16
  • torch.set_printoptions(precision=None,threshold=None,edgeitems=None,linewidth=None,profile=None)
    设置打印选项,用的比较少。
创建操作 Creation Ops
  • torch.eye(n,m=None,out=None)
    返回一个2维张量,对角线位置全为1,其他位置全为0.
    参数:n(int) — 行数,m(int,optional) — 列数。如果为None,则默认为n。out(Tensor.optional) — Output tensor 以上参数仅为常用参数。
    返回值:对角线位置全为1,其他位置全为0的二维张量。
    返回值类型:Tensor
    案例:
torch.eye(3)
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])
  • torch.from_numpy(ndarray) -> Tensor
    Numpy桥,将numpy.ndarray转换为pytorch的Tensor。返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能改变大小。
    案例:
a = np.array([1,2,3])
torch.from_numpy(a)
tensor([1, 2, 3], dtype=torch.int32)
  • torch.linspace(start,end,steps=None,out=None) -> Tensor
    返回一个一维张量,包含在区间start和end上均匀间隔的steps个点。输出一维张量的长度为steps。
    参数:start(float) — 序列的起始点 end(float) — 序列的最终值 steps(int) – 在start和end间生成的样本数 out(Tensor,optional) — 张量
    案例:
torch.linspace(-10,10,steps=10)
tensor([-10.0000,  -7.7778,  -5.5556,  -3.3333,  -1.1111,   1.1111,   3.3333,
          5.5556,   7.7778,  10.0000])
  • torch.logspace(start,end,steps=None,out=None) -> Tensor
    返回一个一维张量,包含在区间以10为底数的start和end之间,均匀间隔steps个点。
  • torch.ones(sizes,out=None) -> Tensor
    返回一个全为1的张量,形状由sizes定义。
    案例:
torch.ones((2,3))
tensor([[1., 1., 1.],
        [1., 1., 1.]])
  • torch.rand(sizes,out=None) -> Tensor
    返回一个张量,包含了从区间[0,1)的均匀分布中抽取的一组随机数,形状由sizes定义。
  • torch.randn(sizes,out=None) - > Tensor
    返回一个张量,包含了从标准正态分布(均值为0,方差为1,即高斯白噪声)中抽取一组随机数,形状由sizes定义。
  • torch.randperm(n,out=None)
    给定参数n,返回一个从0到n-1的随机数排列。
    参数: n(int) — 上边界(不包含)
  • torch.arange(start,end,step=1,out=None) - > Tensor
    返回一个一维张量,长度为floor( (end-start) / step )。包含从start到end,以step为步长的一组。序列值默认步长为1。
    案例:
torch.arange(1,4)
tensor([1,2,3])
  • torch.range(start,end,step=1,out=None) -> Tensor
    返回一个一维张量,有floor( (end-start)/step + 1)个元素。包含在半开区间[start,end]。从start开始,以step为步长的一组值。
    很少使用,建议使用torch.arange()!
  • torch.zeros(sizes,out=None) - > Tensor
    返回一个全为标量0的张量,形状由sizes定义。
索引、切片、连接、换位(Indexing、Slicing、Joining、Mutating Ops)
  • torch.cat(inputs,dimension=0) -> Tensor
    在给定维度上输入的张量序列sep进行连接拼接。
    torch.cat() 可以看作 torch.split() 和 torch.chunk() 的反操作。
    参数:input(sequence of Tensors) — 可以是任意相同Tensor 类型的python序列 dimensions(int, optional) —沿着这个维度连接张量序列
    案例:
x = torch.randn((2,3))
x
tensor([[ 0.2392,  1.6352,  0.3733],
        [ 0.2606, -0.3474, -1.9230]])
torch.cat((x,x),0)
tensor([[ 0.2392,  1.6352,  0.3733],
        [ 0.2606, -0.3474, -1.9230],
        [ 0.2392,  1.6352,  0.3733],
        [ 0.2606, -0.3474, -1.9230]])
torch.cat((x,x),1)
tensor([[ 0.2392,  1.6352,  0.3733,  0.2392,  1.6352,  0.3733],
        [ 0.2606, -0.3474, -1.9230,  0.2606, -0.3474, -1.9230]])
  • torch.chunk(tensor,chunks,dim=0)
    在给定维度(轴)上将输入张量进行分块。
    参数:tensor(Tensor) — 待分块的输入张量,chunks(int) — 分块的个数,dim(int) — 沿哪个维度进行分块
  • 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去除并返回。如果输入是形如(A1B1C1D),那么输出形状为:(ABCD).
    当给定dim时,那么挤压操作只在给定维度上。例如,输入形状为:(A
    1B), squeeze(input,0)将保持张量不变,只有用squeeze(input,1),形状会变成(AB)。
    注意:返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个。
    参数:input(Tensor)— 输入张量,dim(int,optional)—如果给定,则input只会在给定维度挤压,out(Tensor,optional)—输出张量。
    案例:
x = torch.zeros((3,1,3,1,3))
x.size()
#torch.Size([3, 1, 3, 1, 3])

torch.squeeze(x,0).size()
#torch.Size([3, 1, 3, 1, 3])

torch.squeeze(x,1).size()
#torch.Size([3, 3, 1, 3])
  • torch.t(input,out=None) - > Tensor
    输入一个矩阵(2维张量),并转置0,1维。可以被看作为 transpose(input,0,1)的简写。
    参数:input(Tensor)—输入张量,out(Tensor,optional)—结果张量
x = torch.randn((2,3))
tensor([[ 1.7073, -0.1557,  1.4400],
        [ 0.3452,  0.0751,  0.1627]])

torch.t(x)
tensor([[ 1.7073,  0.3452],
        [-0.1557,  0.0751],
        [ 1.4400,  0.1627]])

torch.t(x).size()
torch.Size([3, 2])
  • torch.transpose(input,dim0,dim1,out=None)->Tensor
    返回输入矩阵input的转置。交换维度dim0和dim1。输出张量与输入张量共享内存。所以改变其中一个,就会导致另外一个也被修改。
    参数:input(Tensor)—输入张量,dim0(int)—转置的第一维度,dim1(int)—转置的第二维度
    案例:
x = torch.randn(2,3)
x
tensor([[ 1.6700,  2.3639, -1.5683],
        [ 0.0986,  1.5579,  0.9787]])

torch.transpose(x,0,1)
tensor([[ 1.6700,  0.0986],
        [ 2.3639,  1.5579],
        [-1.5683,  0.9787]])
  • torch.unsqueeze(input,dim,out=None)
    返回一个新的张量,对输入的制定位置插入维度1
    注意:返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个。
    如果dim为负,则将会被转化dim+input.dim()+1
    参数:tensor(Tensor)—输入张量,dim(int)—插入维度的索引,out(Tensor,optional)—结果张量
    案例:
x = torch.Tensor([1,2,3,4])
torch.unsqueeze(x,0)
#tensor([[1., 2., 3., 4.]])
x.size()
#torch.Size([4])
torch.unsqueeze(x,0).size()
#torch.Size([1, 4])

你可能感兴趣的:(Pytorch,pytorch,深度学习,python)