神经网络与深度学习-9- 网络结构 -PyTorch

参考

  《神经网络与深度学习》

    课时14 张量数据类型-1_哔哩哔哩_bilibili

    深度神经网络(DNN) - _yanghh - 博客园

目录

    1： 常见网络结构

    2： 前馈神经网络

    3： 反向传播算法

    4： Softmax 分类例子

## Versions:
- [Version 1.0](https://docs.google.com/presentation/d/11mR1nkIR9fbHegFkcFq8z9oDQ5sjv8E3JJp1LfLGKuk/edit?usp=sharing)

---

一  常见网络结构

     1.1 前馈网络

           定义：

           每一层中的神经元接收前一层神经元的输出，并输出到下一层神经元。

         主要包括：

                     全连接前馈网络 和 卷积神经网络

       

     1.2 记忆网络

            称为反馈网络,网络中的神经元不但可以接收其它神经元的信息，也可以接收自己的历史信息。 增加了记忆功能

           主要包括：

                     RNN,LSTM,Hopfield,玻尔兹曼机，受限玻尔兹曼机

   

     1.3 图网络

             前面输入都可以表示向量或者向量序列，实际应用中很多数据是图结构数据，比如

知识谱，社交网络，分子网络。

          主要包括：

          图卷网络  Graph Conolutional Network

          图注意网络： Graph Attention Network GAT

          消息传递网络   Message Passing Neural Netwrok 

---

二  前馈神经网络

     2.1 前馈神经网络记号

          :      神经网络层数

           ：第l层神经网络的个数

           ：第L层神经元的激活函数

          :       l-1层到l层的权重系数矩阵

          :        l-1层到l层的偏置

         :        l  层神经元的输入

        :         l层神经元的输出

         

         

        

   2.2 参数学习

      这边以分类问题为例，其损失函数为

      

    给定训练集，将每个样本输入给前馈神经网络，得到网络的输出为, 结构化风险函数为

      

    F: Frobenius 范数

    

 在梯度下降法的每次迭代中，第l层的参数和 参数更新方式为

 

 

   在神经网络的训练过程中经常使用反向传播算法来高效计算梯度

---

四  张量数据类型

   pytorch 没有string 类型，对于单个字母用one-hot向量表示

如果是字符串，用word2vec 或者 glove 来实现

  

   

    

     

    
    

     

      # -*- coding: utf-8 -*-
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     

      Created on Mon Sep 5 21:50:02 2022
     
    
   

    

     

    
    

     

      
     
    
   

    

     

    
    

     

      @author: cxf
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import torch
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def 
      Debug():
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          data = torch.randn(
      2,
      3)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      print(
      "\n 数据类型: ",data.
      type(),
      "\t 维度 ",data.dim())
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          data_gpu = data.cuda()
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          hardware = 
      isinstance(data_gpu, torch.cuda.FloatTensor)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      print(
      "是否为GPU类型:",hardware)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          a = torch.tensor(
      1.0) 
      #标量
     
    
   

    

     

    
    

     
    
      print(
      "\n 标量: ",a.
      type(),a.shape,
      len(a.shape),a.size(),
      "\t 维度 ",a.dim()) 
      #标量维度
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

      if __name__ == 
      "__main__":
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          Debug()
     
    
  
 

  
 

---

二 反向传播算法

以DNN为例:

输入：

        训练集

        验证集V， 学习率

repeat

         训练集随机排序

         for  n =1  ... N   do

                 选取样本      

         前向传播：

                （神经元输入）

                (激活函数）

          反向传播计算每一层的误差

          

         

          

                     

     求层：

 

   更新每一层的导数

         

         

 更新每一层的参数

         

         

损失函数

       

   

---

 

  

   

    

     

    
    

     

      import torch
     
    
   

    

     

    
    

     

      import torch.utils.data 
      as Data
     
    
   

    

     

    
    

     

      import numpy 
      as np
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      shuffle：（数据类型 bool）
     
    
   

    

     

    
    

     

       洗牌。默认设置为False。在每次迭代训练时是否将数据洗牌，默认设置是False。
     
    
   

    

     

    
    

     

       将输入数据的顺序打乱，是为了使数据更有独立性
     
    
   

    

     

    
    

     

      num_workers：（数据类型 Int）
     
    
   

    

     

    
    

     

       工作者数量，默认是0。使用多少个子进程来导入数据。
     
    
   

    

     

    
    

     

       设置为0，就是使用主进程来导入数据。注意：这个数字必须是大于等于0的，负数估计会出错。
     
    
   

    

     

    
    

     

      drop_last：（数据类型 bool）
     
    
   

    

     

    
    

     

       丢弃最后数据，默认为False。设置了 batch_size 的数目后，
     
    
   

    

     

    
    

     

       最后一批数据未必是设置的数目，有可能会小些。这时你是否需要丢弃这批数据。
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      def 
      load(
      x,y,batch):
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          BATCH_SIZE = batch 
      #批训练数据量的大小
     
    
   

    

     

    
    

     

          trainset = Data.TensorDataset(x, y) 
      #训练数据集
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      #创建一个dataloader类的实例
     
    
   

    

     

    
    

     

          loader = Data.DataLoader(
     
    
   

    

     

    
    

     

          dataset=trainset,
     
    
   

    

     

    
    

     

          batch_size=BATCH_SIZE,
     
    
   

    

     

    
    

     

          shuffle=
      True,
     
    
   

    

     

    
    

     

          num_workers=
      2,
     
    
   

    

     

    
    

     

          drop_last = 
      True)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return loader
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      显示数据集
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      def 
      sampling(
      x,y,batch):
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          loader = load(x,y,batch)
     
    
   

    

     

    
    

     
    
      for epoch 
      in 
      range(
      1):
     
    
   

    

     

    
    

     
        
      print(
      "\n--------------------")
     
    
   

    

     

    
    

     
        
      for batch_idx, (batch_x, batch_y) 
      in 
      enumerate(loader):
     
    
   

    

     

    
    

     
            
      #print("\n batch_idx:{},\n batch_x:{}, \n batch_y:{}".format(batch_idx, batch_x, batch_y))
     
    
   

    

     

    
    

     
            
      return batch_x, batch_y
     
    
   

    

     

    
    

     
           
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      随机采样的API
     
    
   

    

     

    
    

     

      '''
     
    
   

    

     

    
    

     

      def 
      sampling(
      x,y,batch,N):
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          indices = np.arange(
      0,N)
     
    
   

    

     

    
    

     

          np.random.shuffle(indices)
     
    
   

    

     

    
    

     

          indices1 = indices[
      0:batch]
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          index = torch.tensor(indices1,dtype=torch.
      int)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      #indices = torch.tensor([0, 2])
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          trainData = torch.index_select(x, 
      0, index) 
      #行抽取
     
    
   

    

     

    
    

     

          trainLabel = torch.index_select(y, 
      0, index) 
      #行抽取
     
    
   

    

     

    
    

     
    
      print(
      "\n trainlabel ",trainLabel)
     
    
   

    

     

    
    

     
    
      return trainData, trainLabel
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      ----------------
     
    
   

    

     

    
    

     

      # -*- coding: utf-8 -*-
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     

      Created on Tue Nov 8 17:09:56 2022
     
    
   

    

     

    
    

     

      
     
    
   

    

     

    
    

     

      @author: chengxf2
     
    
   

    

     

    
    

     

      https://blog.51cto.com/u_15132389/4755744
     
    
   

    

     

    
    

     

      """
     
    
   

    

     

    
    

     

      import numpy 
      as np 
     
    
   

    

     

    
    

     

      import torch
     
    
   

    

     

    
    

     

      from sklearn.datasets 
      import load_iris
     
    
   

    

     

    
    

     

      import sampling
     
    
   

    

     

    
    

     

      import torch.nn.functional 
      as F
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      class 
      BP:
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       损失值
     
    
   

    

     

    
    

     

       args
     
    
   

    

     

    
    

     

       y: 标签值
     
    
   

    

     

    
    

     

       predY: 预测值 [150, 4]
     
    
   

    

     

    
    

     

       return 
     
    
   

    

     

    
    

     

       loss 值
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      loss(
      self, y, predY):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              s = -torch.mm(y.T, torch.log(predY))
     
    
   

    

     

    
    

     

              loss = s.numpy()[
      0,
      0]
     
    
   

    

     

    
    

     
        
      #print("\n s ",loss)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      return s
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       激活函数
     
    
   

    

     

    
    

     

       args
     
    
   

    

     

    
    

     

       x: 输入
     
    
   

    

     

    
    

     

       return
     
    
   

    

     

    
    

     

       y: 输出
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      softmax(
      self,x):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              y =  F.softmax(x,dim=
      0) 
      #1 行 
     
    
   

    

     

    
    

     
        
      """
     
    
   

    

     

    
    

     

       z = torch.exp(x)
     
    
   

    

     

    
    

     

       s = z.sum()
     
    
   

    

     

    
    

     

       y = z/s
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      return y
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       训练
     
    
   

    

     

    
    

     

       args
     
    
   

    

     

    
    

     

       trainData: 训练数据集
     
    
   

    

     

    
    

     

       trai
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      train(
      self):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              m=
      150
     
    
   

    

     

    
    

     

              W =
      0
     
    
   

    

     

    
    

     

              trainData = self.x
     
    
   

    

     

    
    

     

              trainLabel = self.y
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              W = torch.ones((
      3,
      4))
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              m,n = self.x.shape[
      0],self.x.shape[
      1]
     
    
   

    

     

    
    

     
        
      print(
      "\n m ",m, 
      "\t n ",n)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              trainData, trainLabel = sampling.sampling(self.x,self.y, self.batch,m)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      for j 
      in 
      range(self.maxIter):
     
    
   

    

     

    
    

     
            
      for i 
      in  
      range(self.batch):
     
    
   

    

     

    
    

     

                      x = trainData[i].view(
      4,
      1)
     
    
   

    

     

    
    

     

                      y = trainLabel[i].view(
      3,
      1)
     
    
   

    

     

    
    

     
                
     
    
   

    

     

    
    

     
     
     
    
   

    

     

    
    

     
                
     
    
   

    

     

    
    

     

                      a = torch.mm(W, x)
     
    
   

    

     

    
    

     

                      predY = self.softmax(a)
     
    
   

    

     

    
    

     

                      deltaW = torch.mm(predY-y,x.T)
     
    
   

    

     

    
    

     

                      W= W-self.learnRate*deltaW
     
    
   

    

     

    
    

     
                
     
    
   

    

     

    
    

     

                  loss = self.loss(y, predY)
     
    
   

    

     

    
    

     
            
      print(
      "\n i %d loss %7.3f"%(j,loss))
     
    
   

    

     

    
    

     
        
      print(W)
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
            
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
      '''
     
    
   

    

     

    
    

     

       加载数据集#[100,4]
     
    
   

    

     

    
    

     

       '''
     
    
   

    

     

    
    

     
    
      def 
      load_data(
      self):
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              iris = load_iris()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              x = iris.data    
      #数据
     
    
   

    

     

    
    

     

              y = iris.target  
      #特征
     
    
   

    

     

    
    

     
        
      print(
      "\n数据集数据的形状：", x.shape) 
      #[150,4]
     
    
   

    

     

    
    

     
        
      print(
      "\n数据集的标签：\n", y) 
      #[0,1,2]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              self.x = torch.tensor(x, dtype=torch.
      float)
     
    
   

    

     

    
    

     

              self.m, self.n = self.x.shape[
      0], self.x.shape[
      1]
     
    
   

    

     

    
    

     

              self.y =torch.zeros([self.m,
      3],dtype=torch.
      float)
      #one-hot
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      for i 
      in 
      range(self.m):
     
    
   

    

     

    
    

     

                  j = y[i]
     
    
   

    

     

    
    

     

                  self.y[i,j] =
      1.0
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
         
     
    
   

    

     

    
    

     
    
      def 
      __init__(
      self):
     
    
   

    

     

    
    

     

              self.m = 
      0
     
    
   

    

     

    
    

     

              self.n = 
      0 
     
    
   

    

     

    
    

     

              self.batch = 
      20 
      #从每类数据中随机选取40个
     
    
   

    

     

    
    

     

              self.maxIter = 
      1000 
      #最大迭代次数
     
    
   

    

     

    
    

     

              self.learnRate = 
      0.1 
      #学习率
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      "__main__":
     
    
   

    

     

    
    

     

             bp = BP()
     
    
   

    

     

    
    

     
       
     
    
   

    

     

    
    

     

             bp.load_data()
     
    
   

    

     

    
    

     

             bp.train()
     
    
  
 

  
 

 

转载：https://blog.csdn.net/chengxf2/article/details/126628577