【示例】如何使用Pytorch堆叠一个神经网络

本文主要从大致步骤上讲述如何从零开始构建一个网络，仅提供一个思路，具体实现以实际情况为准。

一、构建网络

  

   

    

     

    
    

     

      class 
      网络模型(nn.Module):
     
    
   

    

     

    
    

     
    
      #----初始化函数----#
     
    
   

    

     

    
    

     
    
      #主要用来构建网络单元，类似于类定义
     
    
   

    

     

    
    

     
    
      def 
      __init__(
      self,需要传入的参数列表): 
     
    
   

    

     

    
    

     
        
      super(网络模型,self).__init__()
     
    
   

    

     

    
    

     
        
      #----定义一些相关的神经单元----#
     
    
   

    

     

    
    

     

              self.backbone=BackBone(...)
     
    
   

    

     

    
    

     
        
      #----将神经单元堆叠成网络模块----#
     
    
   

    

     

    
    

     

              self.block=nn.Sequential(
     
    
   

    

     

    
    

     
            
      #将标准模块堆叠
     
    
   

    

     

    
    

     

              )
     
    
   

    

     

    
    

     

              self.cls_conv=nn.Conv2d(
      256,numclass,
      1,stride=
      1)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #----前向传递函数----#
     
    
   

    

     

    
    

     
    
      #----主要用来实现网络计算，需要按严格的顺序堆叠
     
    
   

    

     

    
    

     
    
      def 
      forward(
      self,x):    
      # x为输入特征
     
    
   

    

     

    
    

     
        
      #----堆叠网络 
     
    
   

    

     

    
    

     
        
      return x
     
    
  
 

  
 

        以类的形式来构造神经网络的主结构，同时可以通过多个类的叠加来区分基干网络等各个部分，但是每个网络类中主要分为两个部分：

        ①类定义：主要负责声明神经模组，如卷积，池化，BN层等；以及参数的注入。同时将一些标准模块堆叠成神经模块（可以构造多个）；类似于声明，顺序没有特殊要求（小模块内有顺序）

        ②前向传递函数：将类定义中构造的各模块进行顺序构造。x为传入的特征向量，通过让x按顺序经过各模块来实现网络的构造。类似于实现，需要遵守严格的顺序

二、网络训练

  

   

    

     

    
    

     

      #----各种参数的定义，预处理----#
     
    
   

    

     

    
    

     

      # 包括一些超参数，路径，cuda等参数的设定，以及卷积核尺寸等参数的计算
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----网络模型实体化----#
     
    
   

    

     

    
    

     

      model = 类定义(参数列表)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----权重的加载/初始化----#
     
    
   

    

     

    
    

     

      model_dict = model.state_dict()    
      #获取网络结构
     
    
   

    

     

    
    

     

      pretrained_dict = torch.load(modePath,map_location=device)    
      #从文件中加载权重
     
    
   

    

     

    
    

     

      for k,v 
      in pretrained_dict.items():
     
    
   

    

     

    
    

     
    
      #逐层判断网络结构是否一致
     
    
   

    

     

    
    

     

      model_dict.update(temp_dict)         
      #上传权重参数
     
    
   

    

     

    
    

     

      model.load_state_dict(model_dict)    
      #加载权重
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----如有必要，进行cuda型的转换----#
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----数据集的加载----#
     
    
   

    

     

    
    

     

      dataset = 
     
    
   

    

     

    
    

     

      dataloader = 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----进行训练----#
     
    
  
 

  
 

        由于训练的步数较多，建议将其分为预处理和具体训练分开编写。预处理包括网络的实体化，参数和超参数的处理及填充，数据集的加载和转换

        而训练部分则包括：优化器的实例化和参数的填充，训练和验证

        训练是指分步将训练数据从dataloader中取出并执行以下步骤：         

                        ①前向传递

                        ②计算损失函数

                        ③梯度清零

                        ④前向传递

                        ⑤优化参数

        随后将测试集从dataloader中取出按训练同样的步骤进行预测，并计算损失函数 

        训练步骤

  

   

    

     

    
    

     

      loss_fn=   
      #设置交叉函数
     
    
   

    

     

    
    

     

      learing_rate=   
      #学习率
     
    
   

    

     

    
    

     

      optimizer = torch.optim   
      #设置优化器
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----开始训练----#
     
    
   

    

     

    
    

     

      for i 
      in 
      range(epoch):
     
    
   

    

     

    
    

     
    
      #----将训练集从dataloader中解包----#
     
    
   

    

     

    
    

     
    
      for data 
      in train_loader:
     
    
   

    

     

    
    

     

              imgs,targes=data    
     
    
   

    

     

    
    

     

              outputs=mynet(imgs) 
      #网络前向传递
     
    
   

    

     

    
    

     

              loss=loss_fn(outputs,targes)    
      #计算损失函数
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              optimizer.zero_grad()   
      #梯度清零
     
    
   

    

     

    
    

     

              loss.backward()  
      #前向传递
     
    
   

    

     

    
    

     

              optimizer.step()    
      #逐步优化
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              total_train_step+=
      1 
      #训练计数
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----开始测试----#
     
    
   

    

     

    
    

     

      with torch.no_grad():    
      #不设置梯度（保证不进行调优）
     
    
   

    

     

    
    

     
    
      #----将测试集从dataloader中拆包----#
     
    
   

    

     

    
    

     
    
      for data 
      in test_loader:
     
    
   

    

     

    
    

     

              imgs,targets = data 
     
    
   

    

     

    
    

     

              outputs = mynet(imgs)    
      #进行预测
     
    
   

    

     

    
    

     

              loss = loss_fn(outputs,targets)    
      #计算损失函数
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      #----保存每轮的模型----#
     
    
   

    

     

    
    

     

      #torch.save(mynet,"MyNerNet_Ver{}.pth".format(total_train_step))
     
    
  
 

  
 

三、进行预测

        进行预测总体和训练类似，但是不需要将数据送入dataset和dataloader中，一般也不需要计算损失函数，仅需要调用网络对数据进行预测即可。是神经网络的应用环节。

  

   

    

     

    
    

     
    
      def 
      ImgDetect(
      self,img,count=False,nameClasses=None,outType=0):
     
    
   

    

     

    
    

     
        
      #----图片的预处理----#
     
    
   

    

     

    
    

     
        
      # 主要包括图像的参数计算，resize，和添加batch_size维度
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      #----使用网络预测----#
     
    
   

    

     

    
    

     
        
      with torch.no_grad():
     
    
   

    

     

    
    

     
            
      # 类型转换
     
    
   

    

     

    
    

     

                  imgs = torch.from_numpy(img_data)
     
    
   

    

     

    
    

     
            
      # 传入网络并得到结果
     
    
   

    

     

    
    

     

                  Img = self.net(imgs)
     
    
   

    

     

    
    

     
            
      # 进行后续处理
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      #----返回结果----#
     
    
   

    

     

    
    

     
        
      return Img