阅读 1282

从头开始了解PyTorch的简单实现

选自GitHub上,机器之心编译。
本教程展示了如何从了解张量开始到使用PyTorch训练简单的神经网络,是非常基础的PyTorch入门资源.PyTorch建立在Python和火炬库之上,并提供了一种类似Numpy的抽象方法来表征量(或多维数组),它还能利用GPU来提升性能。本教程的代码并不完整,详情请查看原Jupyter Notebook文档。
PyTorch使入门深度学习变得简单,即使你这方面的背景知识不太充足。至少,知道多层神经网络模型可视为由权重连接的节点图就是有帮助的,你可以基于前向和反向传播,利用优化过程(如梯度计算)从数据中估计权重。
  • 必备知识:该教程假设读者熟悉Python和NumPy。
  • 必备软件:在运行原Jupyter Notebook之前你需要安装PyTorch。原笔记本有代码单元格可以验证你是否做好准备。
  • 必需硬件:你需要安装NVIDIA GPU和CUDA SDK。据报告此举可能实现10-100的加速。当然,如果你没有进行此设置,那么你仍然可以在仅使用CPU的情况下运行PyTorch。但是,记住,在训练神经网络模型时,生命苦短!所以还是尽可能使用GPU吧!

1.必要的PyTorch背景

  • PyTorch是一个建立在Torch库之上的Python包,旨在加速深度学习应用。
  • PyTorch提供一种类似NumPy的抽象方法来表征张量(或多维数组),它可以利用GPU来加速训练。

1.1 PyTorch张量

PyTorch的关键数据结构是张量,即多维数组。其功能与NumPy的ndarray对象类似,如下我们可以使用torch.Tensor()创建张量。
#生成2-d pytorch张量(即,基质)
 pytorch_tensor = torch.Tensor(10,20)
的打印(“类型:” ,类型(pytorch_tensor), “ 和尺寸:”,pytorch_tensor.shape)

复制代码
如果你需要一个兼容NumPy的表征,或者你想从现有的NumPy对象中创建一个PyTorch张量,那么就很简单了。
#将pytorch张量转换为numpy数组:
 numpy_tensor = pytorch_tensor.numpy()
print(“type:”,type(numpy_tensor),“and size:”,numpy_tensor.shape)

#将numpy数组转换为Pytorch Tensor:
 print(“type:”,type(torch.Tensor(numpy_tensor)),“and size:”,torch.Tensor(numpy_tensor).shape)

复制代码

1.2 PyTorch与NumPy

PyTorch并不是NumPy的简单替代品,但它实现了很多NumPy功能。其中有一个不便之处是其命名规则,有时它和和NumPy的命名方法相当不同。我们来举几个例子说明其中的区别:
1张量创建
T = torch.rand(2,4,3,5)
一个= np.random.rand(2,4,3,5)

复制代码
2张量分割
T = torch.rand(2,4,3,5)
一个= t.numpy()
pytorch_slice = T [ 0,1:3,:,4 ] 
numpy_slice = A [ 0,1:3,:,4 ] 
打印('张量[0,1:3,:1,4]:\ N',pytorch_slice)
打印('NdArray [0,1:3,:1,4]:\ N',numpy_slice)

------- -------------------------------------------------- ---------------- 
张量[ 0,1:3,:,4 ]:

 0.2032   0.1594   0.3114 
 0.9073   0.6497   0.2826
 [torch.FloatTensor大小的2 ×3] 

NdArray [ 0,1:3,:,4 ]:
[[ 0.20322084   0.15935552   0.31143939 ] 
[ 0.90726137   0.64966112   0.28259504 ]]

复制代码
3张量掩蔽
t = t  - 0.5
 a = t.numpy()
pytorch_masked = t [t> 0 ] 
numpy_masked = a [a> 0 ]

复制代码
4张量重塑
pytorch_reshape = t.view([ 6,5,4 ])
numpy_reshape = a.reshape([ 6,5,4 ])

复制代码

1.3 PyTorch变量

  • PyTorch张量的简单封装
  • 帮助建立计算图
  • Autograd(自动微分库)的必要部分
  • 将关于这些变量的梯度保存在.grad中
结构图:
计算图和变量:在PyTorch中,神经网络会使用相互连接的变量作为计算图来表示.PyTorch允许通过代码构造计算图来构建网络模型;之后PyTorch会简化估计模型权重的流程,例如通过自动计算梯度的方式。
举例来说,假设我们想构建两层模型,那么首先要输入和输出创建张量变量。我们可以将PyTorch Tensor包装进变量对象中:
从 torch.autograd 进口可变
进口 torch.nn.functional 作为 ˚F 

X =变数(torch.randn(4,1),requires_grad = 假)
Y =变量(torch.randn(3,1),requires_grad = 假)

复制代码
我们把requires_grad设置为True,表明我们想要自动计算梯度,这将用于反向传播中以优化权重。
现在我们来定义权重:
W1 =变数(torch.randn(5,4),requires_grad = 真)
W2 =变量(torch.randn(3,5),requires_grad = 真)

复制代码
训练模型:
def  model_forward (x):
    return F.sigmoid(w2 @ F.sigmoid(w1 @ x))

 print(w1)
 print(w1.data.shape)
 print(w1.grad)#最初,不存在

 ---- -------------------------------------------------- -------------------
可变含:
  1.6068  -1.3304  -0.6717  -0.6097 
-0.3414  -0.5062  -0.2533   1.0260 
-0.0341  -1.2144  -1.5983  -0.1392 
-0.5473   0.0084   0.4054   0.0970 
 0.3596   0.5987  -0.0324   0.6116
 [torch.Float传感器的大小5 X4的] 

torch.Size([ 5,4 ])
无

复制代码

1.4 PyTorch反向传播

这样我们有了输入和目标,模型权重,那么是时候训练模型了我们需要三个组件:
损失函数:描述我们模型的预测距离目标还有多远;
导入 torch.nn 为 nn 
条件= nn.MSELoss()

复制代码
优化算法:用于更新权重;
导入 torch.optim 作为 optim 
optimizer = optim.SGD([w1,w2],lr = 0.001)

复制代码
反向传播步骤:
对于历元在范围(10):
    损耗=标准(model_forward(x)中,y)的
    optimizer.zero_grad() #零出以前梯度
     loss.backward()#计算新梯度
     optimizer.step() #应用这些梯度


打印( w1)

------------------------------------------------ ------------------------- 
变量包含:
 1.6067  -1.3303  -0.6717  -0.6095 
-0.3414  -0.5062  -0.2533   1.0259 
-0.0340  -1.2145  -1.5983  -0.1396 
-0.5476   0.0085   0.4055   0.0976
 0.3597   0.5986  -0.0324   0.6113
 [火炬。尺寸为5 x4的飞溅传感器 ]

复制代码

1.5 PyTorch CUDA接口

PyTorch的优势之一是为张量和autograd库提供CUDA接口。使用CUDA GPU,你不仅可以加速神经网络训练和推断,还可以加速任何映射至PyTorch张量的工作负载。
你可以调用torch.cuda.is_available()函数,检查PyTorch中是否有可用CUDA。
cuda_gpu = torch.cuda.is_available()
if(cuda_gpu):
    print(“Great,you have a GPU!”)
elseprint(“Life is short  -  consider a GPU!”)

复制代码
很好,现在你有GPU了。
.cuda()
之后,使用cuda加速代码就和调用一样简单。如果你在张量上调用.cuda(),则它将执行从CPU到CUDA GPU的数据迁移。如果你在模型上调用.cuda(),则它不仅将所有内部储存移到GPU,还将整个计算图映射至GPU。
要想将张量或模型复制回CPU,比如想和NumPy交互,你可以调用.cpu()。
如果 cuda_gpu:
    x = x.cuda()
    printtype(x.data))

x = x.cpu()
printtype(x.data))

--------------- -------------------------------------------------- -------- 
< class ' 火炬。cuda。FloatTensor '> 
< class ' 火炬。FloatTensor '>

复制代码
我们来定义两个函数(训练函数和测试函数)来使用我们的模型执行训练和推断任务。该代码同样来自PyTorch官方教程,我们摘选了所有训练/推断的必要步骤。
对于训练和测试网络,我们需要执行一系列动作,这些动作可直接映射至PyTorch代码:
1.我们将模型转换到训练/推断模式;
2.我们通过在数据集上成批获取图像,以迭代训练模型;
3.对于每一个批量的图像,我们都要加载数据和标注,运行网络的前向步骤来获取模型输出;
4.我们定义损失函数,计算每个批量的模型输出和目标之间的损失;
5.训练时,我们初始化梯度为零,使用上一步定义的优化器和反向传播,来计算所有与损失有关的层级梯度;
6.训练时,我们执行权重更新步骤。
def  train (model,epoch,criterion,optimizer,data_loader):
     model.train()
     for batch_idx,(data,target) in enumerate(data_loader):
         if cuda_gpu:
            data,target = data.cuda(),target.cuda( )
            model.cuda()
        数据,目标=变量(数据),变量(目标)
        输出=模型(数据)

        optimizer.zero_grad()
        损失=标准(输出,目标)
        loss.backward()
        optimizer.step()
         if( batch_idx + 1)% 400 == 0:
            print'Train Epoch:{} [{} / {}({:.0f}%)] \ tLoss:{:.6f}'. format(
                epoch,(batch_idx + 1)* len(data),len(data_loader.dataset ),
                100 *(batch_idx + 1)/ LEN(data_loader),loss.data [ 0 ]))


DEF  试验(模型,历元,标准,data_loader) :
     model.eval()
    test_loss = 0
     正确= 0 
    为数据,目标在 data_loader中:
        if cuda_gpu:
            data,target = data.cuda(),target.cuda()
            model.cuda()
        数据,target =变量(数据),变量(目标)
        output = model(data)
        test_loss + = criterion(output,target).data [ 0 ] 
        pred = output.data.max(1)[ 1 ] #获取最大对数概率索引
         + = pred.eq(目标数据).cpu()。sum()

    test_loss / = len(data_loader)#失败函数已经在批量大小上取平均值
     acc = correct / len(data_loader.dataset)
    print'\ nTest set:Average loss:{:。 4f},准确度:{} / {}({:.0f }%)\ n'.format(
        test_loss,correct,len(data_loader.dataset),100. * acc))
    return(acc,test_loss)

复制代码
现在介绍完毕,让我们开始这次数据科学之旅吧!

2.使用PyTorch进行数据分析

  • 使用torch.nn库构建模型
  • 使用torch.autograd库训练模型
  • 将数据封装进torch.utils.data.Dataset库
  • 使用NumPy接口连接你的模型,数据和你最喜欢的工具
在查看复杂模型之前,我们先来看个简单的:简单合成数据集上的线性回归,我们可以使用sklearn工具生成这样的合成数据集。
从 sklearn.datasets 导入 make_regression 
进口 seaborn 作为 SNS 
进口熊猫作为 PD 
进口 matplotlib.pyplot 作为 PLT 

sns.set()

x_train,y_train,W_target = make_regression(N_SAMPLES次= 100,n_features = 1,噪声= 10,COEF = 真)

DF = pd.DataFrame(data = { 'X':x_train.ravel(),'Y':y_train.ravel()})

sns.lmplot(x = 'X',y = 'Y',data = df,fit_reg = True)
plt.show()

1)x_torch = torch.FloatTensor(x_train)
y_torch = torch.FloatTensor(y_train)
y_torch = y_torch.view(y_torch.size()[ 0 ],1)

复制代码
PyTorch的nn库中有大量有用的模块,其中一个就是线性模块。如名字所示,它对输入执行线性变换,即线性回归。
class  LinearRegression (torch.nn.Module):
    def  __init__ (self,input_size,output_size):
         super(LinearRegression,self).__ init __()
        self.linear = torch.nn.Linear(input_size,output_size)  

     def  forward (self,x ):
        返回 self.linear(x)的

模型=线性回归( 1, 1)

复制代码
要训练线性回归,我们需要从nn库中添加合适的损失函数。对于线性回归,我们将使用MSELoss() - 均方差损失函数。

我们还需要使用优化函数(SGD),并运行与之前示例类似的反向传播。本质上,我们重复上文定义的train()函数中的步骤。不能直接使用该函数的原因是我们实现它的目的是分类而不是回归,以及我们使用交叉熵损失和最大元素的索引作为模型预测。而对于线性回归,我们使用线性层的输出作为预测。

准则= torch.nn.MSELoss()
优化= torch.optim.SGD(model.parameters(),LR = 0.1)   


对于历元在范围(50):
    数据,目标=变量(x_torch),变量(y_torch)
    输出= model(data)

    optimizer.zero_grad()
    loss = criterion(output,target)
    loss.backward()
    optimizer.step()

predict = model(Variable(x_torch))。data.numpy()

复制代码
现在我们可以打印出原始数据和适合PyTorch的线性回归。
plt.plot(x_train,y_train,'o',label = '原始数据')
plt.plot(x_train,predicted,label = 'Fitted line')
plt.legend()
plt.show()

复制代码
为了转向更复杂的模型,我们下载了MNIST数据集至「数据集」文件夹中,并测试了一些PyTorch中可用的初始预处理.PyTorch具备数据加载器和处理器,可用于不同的数据集。下载好后,你可以随时使用。你还可以将数据包装进PyTorch张量,创建自己的数据加载器类别。
批大小(batch size)是机器学习中的术语,指一次迭代中使用的训练样本数量。批大小可以是以下三种之一:
  • batch模式:批大小等于整个数据集,因此迭代和epoch值一致;
  • mini-batch模式:批大小大于1但小于整个数据集的大小。通常,数量可以是能被整个数据集整除的值。
  • 随机模式:批大小等于1.因此梯度和神经网络参数在每个样本之后都要更新。
从 torchvision 导入数据集,变换

batch_num_size = 64

 train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('data',train = True,download = True,transform = transforms.Compose([ 
        transforms.ToTensor()),
        转换。 Normalize((0.1307,),(0.3081,))
    ])),
    batch_size = batch_num_size,shuffle = True)

test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('data',train = False,transform = transforms。撰写([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,),(0.3081,))
    ])),
    batch_size = batch_num_size,shuffle = True)

复制代码

3. PyTorch中的LeNet卷积神经网络(CNN)

现在我们从头开始创建第一个简单神经网络。该网络要执行图像分类,识别MNIST数据集中的手写数字。这是一个四层的卷积神经网络(CNN),一种分析MNIST数据集的常见架构。该代码来自PyTorch官方教程,你可以在这里(http://pytorch.org/tutorials/)找到更多示例。
我们将使用torch.nn库中的多个模块:
1.线性层:使用层的权重对输入张量执行线性变换;
2. Conv1和Conv2:卷积层,每个层输出在卷积核(小尺寸的权重张量)和同样尺寸输入区域之间的点积;
3. Relu:修正线性单元函数,使用逐元素的激活函数max(0,x);
池化层:使用max运算执行特定区域的下采样(通常2x2像素);
5. Dropout2D:随机将输入张量的所有通道设为零。当特征图具备强相关时,dropout2D提升特征图之间的独立性;
6. Softmax:将Log(Softmax(x))函数应用到n维输入张量,以使输出在0到1之间。
类 LeNet (nn.Module) :
    DEF  __init__ (个体):
         超级(LeNet,自我).__ INIT __()
        self.conv1 = nn.Conv2d( 1, 10,kernel_size = 5)
        self.conv2 = nn.Conv2d( 10, 20,kernel_size = 5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear( 320, 50)
        self.fc2 = nn.Linear( 50, 10)

     DEF  向前(个体,X) :
         X = F .relu(F.max_pool2d(self.conv1(x)的2))
        X = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(X)),2))
        X = x.view(-1,320)
        X = F.relu(self.fc1(X ))
        x = F.dropout(x,training = self.training)
        x = self.fc2(x)
        return F.log_softmax(x,dim = 1)

复制代码
创建LeNet类后,创建对象并移至GPU:
model = LeNet()
if cuda_gpu:
    model.cuda()

print'MNIST_net model:\ n'print(model)

----------------------- -------------------------------------------------- 
MNIST_net模型:

LeNet(
  (CONV1):Conv2d(1,10,kernel_size =(5,5),跨度=(1,1))
  (CONV2):Conv2d(10,20,kernel_size =(5,5),步幅=(1,1))
  (conv2_drop):Dropout2d(p值=0.5)
  (fc1):线性(in_features = 320,out_features = 50,bias = 真)
  (fc2):线性(in_features = 50,out_features = 10,bias = 真)
)

复制代码
要训练该模型,我们需要使用带动量的SGD,学习率为0.01,动量为0.5。
criteria = nn.CrossEntropyLoss()   
优化器= optim.SGD(model.parameters(),lr = 0.005,动量= 0.9)

复制代码
仅仅需要5个epoch(一个epoch意味着你使用整个训练数据集来更新训练模型的权重),我们就可以训练出一个相当准确的LeNet模型。这段代码检查可以确定文件中是否已有预训练好。的模型有则加载;无则训练一个并保存至磁盘。
import os epochs

 = 5 
if(os.path.isfile('pretrained / MNIST_net.t7')):
    print'Loading model')
    model.load_state_dict(torch.load('pretrained / MNIST_net.t7',map_location = lambda storage ,LOC:存储))
    ACC,损耗=试验(模型,1,标准,test_loader)
否则:
    打印('训练模式')
    用于历元在范围(1,历元+ 1:)
        系(模型,历元,标准,优化,train_loader)
        acc,loss = test(model,1,criterion,test_loader)
    torch.save(model.state_dict(),'pretrained / MNIST_net.t7')

------------------ -------------------------------------------------- ----- 
加载模型
试验组:平均损耗:0.0471,准确度:9859号文件 / 10000(99%)

复制代码
现在我们来看下模型。首先,打印出该模型的信息。打印函数显示所有层(如Dropout被实现为一个单独的层)及其名称和参数。同样有一个迭代器在模型中所有已命名模块之间运行。当你具备一个包含多个「内部」模型的复杂时,此有所帮助。在所有已命名模块之间的迭代允许我们创建模型解析器,可读取模型参数,创建与该网络类似的模块。
print'Internal models:'for idx,m in enumerate(model.named_modules()):
    print(idx,' - >',m)
    print'-------------- -------------------------------------------------- ---------”)

#输出:
内部模型:
0 - >('',LeNet(
  (CONV1):Conv2d(1,10,kernel_size =(5,5),跨度=(1,1))
  (CONV2):Conv2d(10,20,kernel_size =(5,5),跨度=(1,1))
  (conv2_drop):Dropout2d(p值= 0.5)
  (FC1):线性(in_features = 320,out_features = 50,偏压= 真)
  (FC2):线性(in_features = 50,out_features = 10,bias = True)
))
----------------------------------------- -------------------------------- 
1 - >('CONV1',Conv2d(1,10,kernel_size =(5,5),跨度=(1,1)))
-------------------------------------------------- ----------------------- 
2 - >('CONV2',Conv2d(10,20,kernel_size =(5,5),跨度=(1,1)))
---------------------------------------------- --------------------------- 
3 - >('conv2_drop',Dropout2d(p = 0.5))
-------- -------------------------------------------------- --------------- 
4 - >('fc1',Linear(in_features = 320,out_features = 50,bias = True))
-------------------------------------------------- ----------------------- 
5 - >('fc2',Linear(in_features = 50,out_features = 10,bias = True))
---- -------------------------------------------------- -------------------

复制代码
你可以使用.cpu()方法将张量移到CPU(或确保它在那里)。或者,当GPU可用时(torch.cuda。可用),使用.cuda()方法将张量移至GPU。你可以看到张量是否在GPU上,其类型为torch.cuda.FloatTensor。如果张量在CPU上,则其类型为torch.FloatTensor 。
printtype(t.cpu()。data))
if torch.cuda.is_available():
    print(“Cuda is available”)
    printtype(t.cuda()。data))
elseprint(“Cuda is不可用“)

---------------------------------------------- --------------------------- 
< 类 ' 炬。FloatTensor '> 
Cuda的 是 可用的
 < 类 ' 炬。cuda。FloatTensor '>

复制代码
如果张量在CPU上,我们可以将其转换成NumPy数组,其共享同样的内存位置,改变其中一个就会改变另一个。
如果 torch.cuda.is_available():
    尝试:
        打印(t.data.numpy()),
    除了 RuntimeError 为 e:
        “你不能将GPU张量转换为numpy nd数组,你必须将你的weight tendor复制到cpu然后获取numpy数组“

 printtype(t.cpu()。data.numpy()))
print(t.cpu()。data.numpy()。shape)
print(t.cpu()。data)。 numpy的())

复制代码
现在我们了解了如何将张量转换成NumPy数组,我们可以利用该知识使用matplotlib进行可视化!我们来打印出第一卷积层的卷积滤波器。
data = model.conv1.weight.cpu()。data.numpy()
print(data.shape)
print(data [:, 0 ] .shape)

kernel_num = data.shape [ 0 ] 

fig,axes = plt.subplots( NCOLS = kernel_num,figsize =(2 * kernel_num,2))

为山口在范围(kernel_num):
    轴[COL] .imshow(数据[COL,0,:,:],CMAP = plt.cm.gray)
PLT。显示()

复制代码
以上是简要的教程资源,还有更多的内容和实验可以查看原项目了解更多。