• 神经网络与深度学习-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:      神经网络层数

              M_L ：第l层神经网络的个数

              f_L(.) ：第L层神经元的激活函数

              W^{l}:       l-1层到l层的权重系数矩阵

              b^l:        l-1层到l层的偏置

             z^{l}:        l  层神经元的输入

            a^{l}:         l层神经元的输出

             

             z^{l}=W^{l}a^{l-1}+b^{l}

            a^{l}=f_l(z^{l})

       2.2 参数学习

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

          L(y,\hat{y})=-y^Tlog \hat{y}

        给定训练集D={(x^{i},y^{i})}_{i=1}^{N}，将每个样本输入给前馈神经网络，得到网络的输出为\hat{y}^{i}, 结构化风险函数为

          R(W,b)=\frac{1}{N}\sum_{i}^{N}L(y^i,\hat{y}^{i})+\frac{1}{2}\lambda||W||_F^2

        F: Frobenius 范数

        

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

     Wl=Wl−α∂R∂WlWl=Wl−α∂R∂Wl

     bl=bl−α∂R∂blbl=bl−α∂R∂bl

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

    四  张量数据类型

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

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

    1. # -*- coding: utf-8 -*-
    2. """
    3. Created on Mon Sep  5 21:50:02 2022
    5. @author: cxf
    6. """
    7.  
    8. import torch
    9.  
    10.  
    11. def Debug():
    12.     
    13.     data = torch.randn(2,3)
    14.     
    15.     print("\n 数据类型: ",data.type(),"\t 维度 ",data.dim())
    16.     
    17.     
    18.     
    19.     data_gpu = data.cuda()
    20.     
    21.     hardware = isinstance(data_gpu, torch.cuda.FloatTensor)
    22.     
    23.     print("是否为GPU类型:",hardware)
    24.     
    25.     a = torch.tensor(1.0) #标量
    26.     print("\n 标量: ",a.type(),a.shape,len(a.shape),a.size(),"\t 维度 ",a.dim()) #标量维度
    27.     
    28. if __name__ == "__main__":
    29.     
    30.     Debug()

    二 反向传播算法

    以DNN为例:

    输入：

            训练集D={xn,yn}Nn=1

            验证集V， 学习率α

    repeat

             训练集随机排序

             for  n =1  ... N   do

                     选取样本(xn,yn)      

             前向传播：

                    zl=wlal−1+bl（神经元输入）

                    al=f(zl)(激活函数）

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

              ∂J∂WL=∂J∂zL(aL−1)T

             ∂J∂bL=(∂zL∂bL)T∂J∂zL=E∂J∂zL=∂J∂zL

              ∂J∂zL=Diag(σ′(zL))(aL−y)

                         =(aL−y)⊙σ′(zL)

         求l层：

     

       更新每一层的导数

             ∂J∂Wl=δl(al−1)T

             ∂J∂bl=δl

     更新每一层的参数

             wl=wl−α(δl(al−1)T+λwl)

             bl=bl−αδl

    损失函数

           J=||aL−y||2

       

     

    1. import torch
    2. import torch.utils.data as Data
    3. import numpy as np
    4.  
    5.  
    6. '''
    7. shuffle：（数据类型 bool）
    8.     洗牌。默认设置为False。在每次迭代训练时是否将数据洗牌，默认设置是False。
    9.     将输入数据的顺序打乱，是为了使数据更有独立性
    10. num_workers：（数据类型 Int）
    11.     工作者数量，默认是0。使用多少个子进程来导入数据。
    12.     设置为0，就是使用主进程来导入数据。注意：这个数字必须是大于等于0的，负数估计会出错。
    13. drop_last：（数据类型 bool）
    14.   丢弃最后数据，默认为False。设置了 batch_size 的数目后，
    15.   最后一批数据未必是设置的数目，有可能会小些。这时你是否需要丢弃这批数据。
    16. '''
    17. def load(x,y,batch):
    18.     
    19.     
    20.     BATCH_SIZE = batch #批训练数据量的大小
    21.     trainset = Data.TensorDataset(x, y) #训练数据集
    22.     
    23.     #创建一个dataloader类的实例
    24.     loader = Data.DataLoader(
    25.     dataset=trainset,
    26.     batch_size=BATCH_SIZE,
    27.     shuffle=True,
    28.     num_workers=2,
    29.     drop_last = True)
    30.     
    31.  
    32.     return loader
    33.  
    34. '''
    35. 显示数据集
    36. '''
    37. def sampling(x,y,batch):
    38.     
    39.     loader = load(x,y,batch)
    40.     for epoch in range(1):
    41.         print("\n--------------------")
    42.         for batch_idx, (batch_x, batch_y) in enumerate(loader):
    43.             #print("\n batch_idx:{},\n batch_x:{}, \n batch_y:{}".format(batch_idx, batch_x, batch_y))
    44.             return batch_x, batch_y
    45.            
    46.  
    47.  
    48. '''
    49. 随机采样的API
    50. '''
    51. def sampling(x,y,batch,N):
    52.     
    53.     indices = np.arange(0,N)
    54.     np.random.shuffle(indices)
    55.     indices1 = indices[0:batch]
    56.     
    57.     index = torch.tensor(indices1,dtype=torch.int)
    58.     
    59.     #indices = torch.tensor([0, 2])
    60.     
    61.     trainData = torch.index_select(x, 0, index) #行抽取
    62.     trainLabel = torch.index_select(y, 0, index) #行抽取
    63.     print("\n trainlabel ",trainLabel)
    64.     return trainData, trainLabel
    65.  
    66.  
    67. ----------------
    68. # -*- coding: utf-8 -*-
    69. """
    70. Created on Tue Nov  8 17:09:56 2022
    72. @author: chengxf2
    73. https://blog.51cto.com/u_15132389/4755744
    74. """
    75. import numpy as np 
    76. import torch
    77. from sklearn.datasets import load_iris
    78. import sampling
    79. import torch.nn.functional as F
    80.  
    81. class BP:
    82.     
    83.     
    84.     '''
    85.     损失值
    86.     args
    87.         y: 标签值
    88.         predY: 预测值  [150, 4]
    89.     return 
    90.         loss 值
    91.     '''
    92.     def loss(self, y, predY):
    93.         
    94.         s = -torch.mm(y.T, torch.log(predY))
    95.         loss = s.numpy()[0,0]
    96.         #print("\n s ",loss)
    97.         
    98.         return s
    99.     
    100.     '''
    101.     激活函数
    102.     args
    103.         x: 输入
    104.     return
    105.         y: 输出
    106.     '''
    107.     def softmax(self,x):
    108.         
    109.         y =  F.softmax(x,dim=0) #1 行 
    110.         """
    111.         z = torch.exp(x)
    112.         s = z.sum()
    113.         y = z/s
    114.         """
    115.  
    116.         return y
    117.     
    118.     '''
    119.     训练
    120.     args
    121.        trainData: 训练数据集
    122.        trai
    123.     '''
    124.     def train(self):
    125.         
    126.         m=150
    127.         W =0
    128.         trainData = self.x
    129.         trainLabel = self.y
    130.         
    131.         W = torch.ones((3,4))
    132.         
    133.         m,n = self.x.shape[0],self.x.shape[1]
    134.         print("\n m ",m, "\t n ",n)
    135.         
    136.         trainData, trainLabel = sampling.sampling(self.x,self.y, self.batch,m)
    137.         
    138.         for j in range(self.maxIter):
    139.             for i in  range(self.batch):
    140.                 x = trainData[i].view(4,1)
    141.                 y = trainLabel[i].view(3,1)
    142.                 
    143.      
    144.                 
    145.                 a = torch.mm(W, x)
    146.                 predY = self.softmax(a)
    147.                 deltaW = torch.mm(predY-y,x.T)
    148.                 W= W-self.learnRate*deltaW
    149.                 
    150.             loss = self.loss(y, predY)
    151.             print("\n  i %d   loss %7.3f"%(j,loss))
    152.         print(W)
    153.             
    154.             
    155.             
    156.             
    157.         
    158.         
    159.     '''
    160.     加载数据集#[100,4]
    161.     '''
    162.     def load_data(self):
    163.         
    164.         iris = load_iris()
    165.         
    166.         x = iris.data    #数据
    167.         y = iris.target  #特征
    168.         print("\n数据集数据的形状：", x.shape) #[150,4]
    169.         print("\n数据集的标签：\n", y) #[0,1,2]
    170.  
    171.         
    172.         self.x = torch.tensor(x, dtype=torch.float)
    173.         self.m, self.n = self.x.shape[0], self.x.shape[1]
    174.         self.y =torch.zeros([self.m,3],dtype=torch.float)#one-hot
    175.         
    176.         for i in range(self.m):
    177.             j = y[i]
    178.             self.y[i,j] =1.0
    179.     
    180.         
    181.         
    182.          
    183.     def __init__(self):
    184.         self.m = 0
    185.         self.n = 0 
    186.         self.batch = 20 #从每类数据中随机选取40个
    187.         self.maxIter = 1000 #最大迭代次数
    188.         self.learnRate = 0.1 #学习率
    189.         
    190.         
    191.         
    192.  
    193. if __name__ == "__main__":
    194.        bp = BP()
    195.        
    196.        bp.load_data()
    197.        bp.train()

     

  • 相关阅读:
    猿创征文｜有了这8个开发工具，程序员可以早点下班了
    猿创征文｜Linux系统信息相关命令
    Rust学以致用（一）——读取k线csv文件，生成dataframe后计算MA5指标
    pytorch 训练时raise EOFError EOFError
    【剑指Offer】3.数组中重复的数字
    【机器学习】特征工程之特征选择
    基础算法之枚举
    Hacker 资讯｜11 月中下旬区块链黑客松活动汇总
    【工作总结】证书到底有什么用？
    JAVA毕业设计html5健身房信息管理系统计算机源码+lw文档+系统+调试部署+数据库
  • 原文地址：https://blog.csdn.net/chengxf2/article/details/126628577