Pytorch————（0）

一、Pytorch简介

        Torch是LUA语言下的一个有大量机器学习算法支持的科学框架，是一个与Numpy类似的操作库，其特点是特别灵活，但其接口语言是LUA语言（相当于一个小型加强版的C，支持类和面向对象，运行效率极高，与C语言结合“特别默契”），所以流行度不高。所有就有了Pytorch框架，Pytorch 就是由FaceBook开发的基于Python的机器学习和深度学习框架级工具，起初用于大规模图像分析，如目标检测、分割与分类，当然不限于此，和Torch 一样底层语言都是C语言，但Pytorch还有C++语言，因其吸收了caffe2，进行了很多代码合并，所以现在Pytorch语言底层虽然依然是C语言为主，但逐渐过渡到C++接口为主。（目前来看，两者的底层库的 C语言部分区别还是不大，尽管Pytorch使用了C++接口，但是由于代码的兼容性，使用torch拓展的底层代码在Pytorch中照样可以编译使用。）Pytorch 不仅能够 实现强大的GPU加速，同时还支持动态神经网络，还提供了两个高级功能： * 具有强大的GPU加速的张量计算（如Numpy） * 包含自动求导系统的深度神经网络。

        PyTorch的代码对比其他框架而言，更加简洁直观，底层代码也更容易看懂，这对于使用
它的人来说理解底层肯定是一件很便利的事。

         Pytorch优点：1、支持GPU 。2、灵活，支持动态神经网络。 3、 底层代码易于理解。 4、 命令式体验。5、自定义扩展。

        Pytorch缺点：对比TensorFlow，其功能全面性尚不足；针对移动端、嵌入式部署以及高性能服务器端的部署其性能表现有待提升；其次因为这个框架较新，社区成熟度和支持度在不断增加。

二、环境支持与安装

       Pytorch基于Python语言，所以安装首先要安装Python，一般搭建环境时，选择安装Anaconda或者Pycharm 这样的Python IDE, 尤其以Anaconda为常见。Anaconda是一个用于科学计算的Python发行版，支持Linux、Mac和Window系统，提供了包管理与环境管理的功能，可以很方便地解决Python并存、切换，以及各种第三方包安装的问题。

     所有首选安装Anaconda，可以直接从Anaconda 官网下载，因官网服务器在国外，所以推荐使用清华的镜像来下载安装。

    安装并进行环境变量配置后，就可以安装 Pytorch和Torchvision（Torchvision是 PyTorch 的一个独立子库，主要用于计算机视觉任务，包括图像处理、数据加载、数据增强、预训练模型等。）。

    具体安装分pip 和conda两种环境，在pytorch官网,依次选择Pytorch 版本，OS版本，Package分环境，Python版本，CUDA(支持GPU)，生成本环境下的对应安装命令行，然后在相应环境下安装。

    安装后测试，如在Anaconda的conda下安装，则打开Jupyter Notebook,输入如下命令：

    如出现以上的结果（虽然被称为PyTorch，但是代码中使⽤torch⽽不是pytorch），说明 Pytorch和Torchvision安装成功。

三、开始学习——张量与张量操作

        PyTorch的数据结构采用计算图和张量两种基本类型，因此基本操作和张量的定义、索引、重整、改变数据类型是很重要的。因此解决方法就是大量上机操作，以掌握张量和张量的各种方法。

    例如，可以在Python中判断一个对象是否为张量对象、是否为storage类型，可以用is_tensor() 和 is_storage()(Storage类型是pytorch中的一个类型，它与tensor是对应的。Storage实例在内存中实质上就是一个连续的、一维的数组。tensor 分为头信息区(Tensor)和存储区(Storage)。信息区(Tensor)主要存储tensor的形状(size)、步长(stride)、数据类型(type)等信息，其真正的数据保存为连续数组，存储在存储区(Storage)中)。在Python中运行示例：

x = [12,23,34,45,56,67,78]     
# 创建一个标量=10 。    
scalar = torch.tensor(10)
scalar
tensor(10)
scalar.ndim   #标量的维度为0    也就是0维张量        
0
scalar.item()
10
#vector     创建一个向量  ，  1维张量 。                   
vector = torch.tensor([5,5])
vector
tensor([5, 5])
vector.ndim       # 向量的维度为1  。   
1
vector.shape
torch.Size([2])   # 注意：shape 不是1* 2，1* 2表示是2维张量。
# Matrix      创建一个矩阵，矩阵的维度为2，2维张量
matrix = torch.tensor([[4, 5],
[10, 110]])
matrix
tensor([[ 4, 5], [ 10, 110]])

matrix.ndim
2
matrix.shape
torch.Size([2, 2])
# Tensor is multidimensional   例子是三维张量
tensor = torch.tensor([[[4,64, 5,4],
[10,20,30, 110],
[45,34,67,40],
[56,67,89,90]]])
tensor
tensor([[[ 4, 64, 5, 4], [ 10, 20, 30, 110], [ 45, 34, 67, 40], [ 56, 67, 89, 90]]])
tensor.ndim
3
tensor.shape  # 
torch.Size([1, 4, 4])
tensor.dtype  #数据类型
torch.int64  
tensor.device
device(type='cpu')

#判断是否是张量 ，以即是否是Storage类型
torch.is_tensor(x)
False
torch.is_storage(x)
False

      #创建一个含有随机数的张量，类似于Numpy,还可以做类似上节的检查。

y = torch.randn(1,2,3,4,5) #创建一个1*2*3*4*5 的五维张量，用标准正态分布生成数值。
torch.is_tensor(y)   # 判断是否张量
True

torch.is_storage(y)   # 判断是否张量存储类型
False   # 这里y 是tensor类型 因此不是Storage类型
torch.numel(y) # 张量的总元素数  the total number of elements in the input Tensor 120 = 1*2*3*4*5 

      下面的代码是另一个创造一个2D的零值张量，并且计算元素数量。

torch.zeros(4,4)
tensor([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])
torch.numel(torch.zeros(4,4))

16
torch.eye(3)
tensor([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
torch.eye(5)
tensor([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]])

      像Numpy一样，eye()函数用于创建一个单位矩阵,也就是对角线元素为1，其他元素为0，

同时eye 函数可以指定形状，如（n,m）则在 （ min(n,m)，min(n,m）)部分设置为单位矩阵，其他部分仍然为0。

torch.eye(3,4)
tensor([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]])
torch.eye(5,4)
tensor([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.], [0., 0., 0., 0.]])

  可以创建线性空间等间隔的点，例如在从2到10的线性空间创建25个点。Torch可以从NumPy 数组中读取并转成张量。

import numpy as np
x1 = np.array(x)
x1
array([12, 23, 34, 45, 56, 67, 78])
torch.from_numpy(x1)
tensor([12, 23, 34, 45, 56, 67, 78])
torch.linspace(2, 10, steps=25) #线性间隔取值。
tensor([ 2.0000, 2.3333, 2.6667, 3.0000, 3.3333, 3.6667, 4.0000, 4.3333, 4.6667, 5.0000, 5.3333, 5.6667, 6.0000, 6.3333, 6.6667, 7.0000, 7.3333, 7.6667, 8.0000, 8.3333, 8.6667, 9.0000, 9.3333, 9.6667, 10.0000])
torch.linspace(-10, 10, steps=15)
tensor([-1.0000e+01, -8.5714e+00, -7.1429e+00, -5.7143e+00, -4.2857e+00, -2.8571e+00, -1.4286e+00, -2.3842e-07, 1.4286e+00, 2.8571e+00, 4.2857e+00, 5.7143e+00, 7.1429e+00, 8.5714e+00, 1.0000e+01])

      同理，也可以在对数线性空间上创建点。

torch.logspace(start=-10, end=10, steps=15) #对数等间隔取值
tensor([1.0000e-10, 2.6827e-09, 7.1969e-08, 1.9307e-06, 5.1795e-05, 1.3895e-03, 3.7276e-02, 1.0000e+00, 2.6827e+01, 7.1969e+02, 1.9307e+04, 5.1795e+05, 1.3895e+07, 3.7276e+08, 1.0000e+10])

      随机数产生在数据科学中是一个常见的过程，用于在某空间产生样本数据以模拟数据集中的潜在结构。随机数可以从经验统计分布、任何两个已知、或者预定义分布中产生。像Numpy函数一样，随机数字可以按以下例子产生。例如，均匀分布就是每个结果有同等的发生概率，因此事件的概率是个常数。

    #产生0-1范围内均匀分布的随机数字
torch.rand(10)
tensor([0.1408, 0.4445, 0.4251, 0.2663, 0.3743, 0.4784, 0.3760, 0.1876, 0.2151, 0.6876])

     # 产生0-1范围内的随机数字，并形成一个（4,5）形状的矩阵。也可以从标准正态分布产生0至1范围内的随机数字。

      # 用随机顺序（random permutation）从某一特定范围内产生随机数，首先需要定义range list。而range list 可以用arange函数，arange函数需指定步长以使得取值等间隔，默认步长为1。

torch.rand(4, 5)
#产生0-1范围内的随机数字，并形成一个（4,5）形状的矩阵。
tensor([[0.2733, 0.0302, 0.8835, 0.9537, 0.9662], [0.6296, 0.3106, 0.4029, 0.8133, 0.1697], [0.8578, 0.6517, 0.0440, 0.6197, 0.9889], [0.8614, 0.6288, 0.2158, 0.4593, 0.2444]])

#产生10个标准正态分布的数字。
torch.randn(10)
tensor([ 1.0115, -0.7502, 1.1994, 0.8736, 0.5633, -0.7702, 0.1826, -1.9931, 0.5159, 0.1521])
torch.randn(4, 5)
tensor([[ 0.3744, 2.1839, -1.8229, 1.0682, 1.5394], [ 0.9689, -1.3085, -0.3300, 0.3960, -0.6079], [ 2.3485, 1.2880, 0.6754, -2.0426, -0.3121], [-0.4897, -1.5335, 0.0467, -0.6213, 1.7185]])

在1D张量中找到最大值和最小值采用argmin, argmax。如果是matrix则需要指定维度以确认从某一维度（行或列）中寻找最大值和最小值。
d = torch.randn(4, 5)
d
tensor([[ 1.0085, -0.8545, -0.6958, 1.6716, -0.0118], [ 0.2134, 1.1154, -0.6426, -1.3651, -1.5724], [ 0.2452, 0.8356, 2.0297, -0.2397, 0.8560],
[ 0.9786, -0.8538, -0.6449, 0.3903, 1.5966]])
torch.argmin(d,dim=1)
tensor([1, 4, 3, 1])   #返回的是指定维度的下标
torch.argmax(d,dim=1)
tensor([3, 1, 2, 4])

1D张量就是一行或一列，2D张量就是一个矩阵，具有行和列。多于2维则称为多维张量。
# 创建一个2D张量并用0充填。
torch.zeros(4,5)
tensor([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]])

#创建一个1D的张量并用0充填
torch.zeros(10)
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

#创建一个2D张量，并且用concat连接张量。
x = torch.randn(4,5)
x
tensor([[-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280]])
#连接两个张量，默认为0维，即在行方向上连接。
torch.cat((x,x))
tensor([[-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280], [-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280]])

也可以创建3D张量，由2D到3D张量可以从行或者列拓展得到。
#根据张量的大小，连接张量n次。
torch.cat((x,x,x))
tensor([[-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280], [-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280], [-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280]])

#根据张量的大小，在列方向上连接张量n次。得到的结果张量就是（n,m*连接次数）形状的。
torch.cat((x,x,x),1)
tensor([[-1.5343, -1.3533, -0.8621, -1.1674, -0.1114, -1.5343, -1.3533, -0.8621, -1.1674, -0.1114, -1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379, 0.2790, 0.0463, 1.5364, -0.1287, 0.6379, 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602, -0.4542, 0.5196, 0.2335, -0.5135, -0.6602, -0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280, -0.6930, 0.0541, -0.8463, -0.4498, -0.0280, -0.6930, 0.0541, -0.8463, -0.4498, -0.0280]])
#根据张量的大小，在列方向上连接张量n次。得到的结果张量就是（n*连接次数,m）形状的。
torch.cat((x,x),0)
tensor([[-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280], [-1.5343, -1.3533, -0.8621, -1.1674, -0.1114], [ 0.2790, 0.0463, 1.5364, -0.1287, 0.6379], [-0.4542, 0.5196, 0.2335, -0.5135, -0.6602], [-0.6930, 0.0541, -0.8463, -0.4498, -0.0280]])

# 分割张量成小的箱，例如torch.arange(12)生成一个大小12的1D张量，并将其分成6个箱，torch.arange(12).chunk(2)，即6个小的张量，每个张量大小为2。在分箱过程中，如果不能除尽，则剩余数值分在最后一个tensor中。

torch.arange(11).chunk(6)
(tensor([0, 1]),
tensor([2, 3]),
tensor([4, 5]),
tensor([6, 7]),
tensor([8, 9]),
tensor([10]))
torch.arange(12).chunk(6)
(tensor([0, 1]),
tensor([2, 3]),
tensor([4, 5]),
tensor([6, 7]),
tensor([8, 9]),
tensor([10, 11]))
torch.arange(13).chunk(6)

(tensor([0, 1, 2]),
tensor([3, 4, 5]),
tensor([6, 7, 8]),
tensor([ 9, 10, 11]),
tensor([12]))