自学内容网 自学内容网
自学内容网 > 正文

融入模糊规则的宽度神经网络结构

🕗 发布于 2024-11-10 13:32 神经网络  人工智能  深度学习  大模型  python  

融入模糊规则的宽度神经网络结构

本文所涉及所有资源均在传知代码平台可获取

论文链接：https://ieeexplore.ieee.org/abstract/document/8432091/metrics#metrics

论文概述

今天来给大家讲解一篇发表在中科院一区顶级期刊上《IEEE Transactions on Cybernetics》的有关于目前人工智能计算机视觉新方向（宽度学习）的文章。作者在这篇文章中基于宽度神经网络提出了一种改进的新模型，融入了模糊规则来提高模型对特殊特征的分辨能力。由于模糊规则的复杂性，本博客用了比较多的博客来讲述，如果大家觉得太难，可以直接下载附件代码先跑起来，从代码入手再回来看数学公式会更直接一点。

该论文作者们提出了一种名为模糊宽度学习系统（BLS）的新型神经模糊模型，通过将Takagi-Sugeno（TS）模糊系统融入BLS而构建。模糊BLS将BLS的特征节点替换为一组TS模糊子系统，并由它们分别处理输入数据。与立即将每个模糊子系统产生的模糊规则输出聚合为一个值不同，模糊BLS将它们全部发送到增强层进行进一步的非线性变换，从而保留输入特性。模糊子系统的去模糊化输出和增强层的输出被组合以获得最终模型输出。前件部分高斯隶属函数的中心以及模糊规则的数量通过k-means方法确定。在模糊BLS中需要计算的参数包括连接增强层输出和模型输出的权重，以及模糊子系统后件部分多项式的随机初始化系数，这些都可以通过解析方法计算。因此，模糊BLS保留了BLS的快速计算特性。

该模糊BLS通过一些流行的回归和分类基准进行评估，并与一些最先进的非模糊和神经模糊方法进行比较。结果表明，模糊BLS在性能上优于其他模型。此外，模糊BLS在模糊规则数量和训练时间方面也优于神经模糊模型，在一定程度上缓解了规则爆炸的问题。
在这里插入图片描述

创新点及贡献

为了建立一个名为模糊BLS的新神经模糊模型,他们用Takagi-Sugeno（TS）模糊子系统代替BLS左部的特征节点。模糊BLS的显著特征与其他神经模糊方法不同，其创新点如下。

  1. 模糊BLS包含一组一阶TS模糊子系统,输入数据由每个子系统处理。所有模糊子系统都参与产生模糊BLS的输出,因此它可以受益于这种"集成"结构。
  2. k均值算法用于对输入数据进行分组,并确定每个模糊子系统的模糊规则数量,以及前件部分高斯隶属函数的中心。由于k均值算法的属性,不同的中心将从训练数据为每个模糊子系统生成,这可以确保产生不同的结果。然后尽可能多地提取输入数据的信息。
  3. 模糊子系统中模糊规则的输出不会立即汇总为一个值。相反,所有模糊子系统产生的中间值被连接为向量,并直接发送到用于非线性转换的增强节点。然后,增强层的输出以及模糊子系统的去模糊输出用于生成最终模型输出。
  4. 模糊BLS的参数包括连接增强层输出到最终输出层的权重以及每个模糊子系统中模糊规则后件部分的系数,这可以通过伪逆快速计算。因此,模糊BLS保留了BLS的快速计算特性。

算法流程讲解

在这里插入图片描述

模糊广义学习系统（FBLS）基于随机向量功能链接神经网络和伪逆理论的架构。该设计使系统能够快速且渐进地学习，并且在无需重新训练的情况下重新建模。FBLS模型如图3所示，包含输入层、模糊子系统层、增强节点复合层和输出层。在复合层中，使用模糊规则从输入数据生成多个模糊子系统。这些模糊子系统随后被增强为增强节点，每个节点具有不同的随机权重。通过将所有特征和增强节点连接到输出层来计算输出。

模糊广义学习系统的主要概念是将输入数据映射到一组模糊规则中，然后利用BLS算法学习和优化这些规则的权重和参数。这些模糊规则由模糊集及其对应的隶属函数组成，这些函数描述了输入和输出之间的模糊关系。通过采用模糊逻辑推理，系统可以基于输入数据的模糊表示进行预测和分类。

FBLS是一种结合了随机向量功能链接神经网络和伪逆理论的神经网络模型。该设计允许系统快速学习和适应，无需重新训练。如图3所示，该模型由输入层、模糊子系统层、增强层和输出层组成。在模糊子系统层，使用模糊规则从输入数据生成多个模糊子系统。这些模糊子系统随后使用随机权重转换为增强节点。通过将所有模糊子系统和增强节点连接到输出层来计算输出。

模糊规则生成

模糊规则由模糊集及其对应的隶属函数组成，这些函数描述了输入和输出之间的模糊关系。通过采用模糊逻辑推理，系统可以基于输入数据的模糊表示进行预测和分类。具体实施步骤如下：在模糊BLS中，假设有 n n n个模糊系统和 m m m组增强节点。输入特征用 X ∈ R N × M X∈R^{N×M} X∈RN×M表示，其中 M M M是每个特征向量的维数。假设第 i i i个模糊子系统具有以下形式的 K i K_i Ki​个模糊规则。
i f   x 1   i s   A k 1 ,   x 2   i s   A k 2 , . . . ,   x M   i s   A k M t h e n z s k i = f k i ( x s 1 , x s 2 , . . . , x s M ) , k = 1 , 2 , . . . , K i (1) if \, x_1 \, is \, A_{k1}, \, x_2 \, is \, A_{k2},... , \, x_M \, is \, A_{kM} \\ then z^i_{sk}=f^i_k(x_{s1},x_{s2},...,x_{sM}), k=1,2,...,K_i \tag{1} ifx1​isAk1​,x2​isAk2​,...,xM​isAkM​thenzski​=fki​(xs1​,xs2​,...,xsM​),k=1,2,...,Ki​(1)

其中Akj是模糊集合，xj是系统输入（j=1, 2, …, M），K是规则的数量。然后，我们采用一阶TS模糊系统，并设定
z s k i = f k i ( x s 1 , x s 2 , . . . , x s M = ∑ t = 1 M α k t i x s t ) (2) z_{sk}^i=f_k^i(x_{s1},x_{s2},...,x_{sM}=\sum_{t=1}^M\alpha_{kt}^ix_{st})\tag{2} zski​=fki​(xs1​,xs2​,...,xsM​=t=1∑M​αkti​xst​)(2)
其中 α k t i α^i_{kt} αkti​是系数。第 i i i 个模糊子系统中第 k k k 个模糊规则的火热度(fire strength)是
r s k i = ∏ t = 1 M μ k t i ( x s t ) (3) r^i_{sk}=\prod_{t=1}^M \mu^i_{kt}(x_{st}) \tag{3} rski​=t=1∏M​μkti​(xst​)(3)
然后，我们将每个模糊规则的加权火热度表示为
ω s k i ∗ ( r s k i / ∑ k = 1 K i r s k i ) (4) \omega_{sk}^i*(r^i_{sk}/\sum_{k=1}^{K_i} r_{sk}^i) \tag{4} ωski​∗(rski​/k=1∑Ki​​rski​)(4)
选择与模糊集合 A k t i A^i_{kt} Akti​对应的 μ k t i ( x ) μ^i_{kt}(x) μkti​(x)的高斯隶属函数，其定义如下：
μ k t i ( x ) = e − ( x − c k t i / θ k t i ) 2 (5) \mu^i_{kt}(x)=e^{-(x-c^i_{kt}/\theta^i_{kt})^2} \tag{5} μkti​(x)=e−(x−ckti​/θkti​)2(5)
其中 c k t i c^i_{kt} ckti​和 σ k t i σ^i_{kt} σkti​分别代表宽度和中心。在FBLS中，模糊子系统将中间向量传递到增强层，在重新训练输入特征时进行进一步的非线性修改。在第 i i i个模糊子系统中，没有聚合的中间向量 x s x_s xs​是
Z s i = ( ω s 1 i z s 1 i , ω s 2 i z s 2 i , . . . , ω s K i i z s K i i ) (6) Z_{si}=(\omega^i_{s1}z^i_{s1},\omega^i_{s2}z^i_{s2},...,\omega^i_{sK_i}z^i_{sK_i})\tag{6} Zsi​=(ωs1i​zs1i​,ωs2i​zs2i​,...,ωsKi​i​zsKi​i​)(6)

映射节点生成

对于所有训练样本 X X X，第 i i i个模糊子系统的输出矩阵是
Z n = ( Z 1 , Z 2 , . . . , Z n ) ∈ R N × ( K 1 + K 2 + . . . + K n ) (7) Z^n=(Z_1,Z_2,...,Z_n)\in R^{N\times(K_1+K_2+...+K_n)}\tag{7} Zn=(Z1​,Z2​,...,Zn​)∈RN×(K1​+K2​+...+Kn​)(7)
然后，我们考虑 Z n Z_n Zn​被传递到增强层进行进一步的非线性处理。考虑第 j j j个增强节点组由 L j L_j Lj​个神经元组成
H j = χ j ( Z n W h j + b h j ) ∈ R N × L j (8) H^j=\chi_j(Z^n W_{h_j}+b_{h_j}) \in R^{N \times L_j} \tag{8} Hj=χj​(ZnWhj​​+bhj​​)∈RN×Lj​(8)
其中， W h j W_{h_j} Whj​​和 b h j b_{h_j} bhj​​分别是第 j j j个增强节点组的随机权重和偏置项。增强层的输出矩阵是
H j = ( H 1 , H 2 , . . . , H m ) (9) H^j=(H_1,H_2,...,H_m)\tag{9} Hj=(H1​,H2​,...,Hm​)(9)
我们现在考虑每个模糊子系统的输出，这个过程称为反模糊化。然后，将反模糊化输出 F n F_n Fn​与增强层输出矩阵 H m H_m Hm​结合起来，并发送到顶层。首先考虑第 j j j个模糊子系统的输出向量。
F s i = ( ∑ k = 1 K i ω s k i ( ∑ t = 1 M ϕ k 1 i α k t i x s t ) , . . . , ∑ k = 1 K i ω s k i ( ∑ t = 1 M ϕ k C i α k t i x s t ) ) = ∑ t = 1 M α k t i x s t ( ω s 1 i , . . . , ω s K i i ) ∗ U 其中 U = [ ϕ 11 i . . . ϕ 1 C i . . . . . . . . . ϕ K i 1 i . . . ϕ K i C i ] (10) F_{si}=(\sum_{k=1}^{K_i}\omega_{sk}^i(\sum_{t=1}^M\phi_{k1}^i\alpha_{kt}^ix_{st}),...,\sum_{k=1}^{K_i}\omega_{sk}^i(\sum_{t=1}^M\phi_{kC}^i\alpha_{kt}^ix_{st}))=\sum_{t=1}^M\alpha_{kt}^ix_{st}(\omega_{s1}^i,...,\omega_{sK_i}^i)*U \\ 其中U= \begin{bmatrix} \phi_{11}^i & ... & \phi_{1C}^i \\ ... & ... & ... \\ \phi_{K_i1}^i & ... & \phi_{K_iC}^i \end{bmatrix} \tag{10} Fsi​=(k=1∑Ki​​ωski​(t=1∑M​ϕk1i​αkti​xst​),...,k=1∑Ki​​ωski​(t=1∑M​ϕkCi​αkti​xst​))=t=1∑M​αkti​xst​(ωs1i​,...,ωsKi​i​)∗U其中U= ​ϕ11i​...ϕKi​1i​​.........​ϕ1Ci​...ϕKi​Ci​​ ​(10)
其中 φ k C i φ^i_{kC} φkCi​是FBLS中的一个新参数。为了减少参数数量，我们将 α k t i α^i_{kt} αkti​转换为 φ k C i α k t i φ^i_{kC}α^i_{kt} φkCi​αkti​并计算伪逆。对于所有模糊子系统，我们设置
D = d i a g { ∑ t = 1 M α k t i x 1 t , . . . , ∑ t = 1 M α k t i x N t } (11) D=diag\{\sum_{t=1}^M\alpha_{kt}^ix_{1t},...,\sum_{t=1}^M\alpha_{kt}^ix_{Nt}\}\tag{11} D=diag{t=1∑M​αkti​x1t​,...,t=1∑M​αkti​xNt​}(11)
π i = [ ω 11 i . . . ω 1 K i i . . . . . . . . . ω K i 1 i . . . ω K i C i ] (12) \pi^i= \begin{bmatrix} \omega_{11}^i & ... & \omega_{1K_i}^i \\ ... & ... & ... \\ \omega_{K_i1}^i & ... & \omega_{K_iC}^i \end{bmatrix} \tag{12} πi= ​ω11i​...ωKi​1i​​.........​ω1Ki​i​...ωKi​Ci​​ ​(12)
ϕ i = [ ϕ 11 i . . . ϕ 1 C i . . . . . . . . . ϕ K i 1 i . . . ϕ K i C i ] (13) \phi^i= \begin{bmatrix} \phi_{11}^i & ... & \phi_{1C}^i \\ ... & ... & ... \\ \phi_{K_i1}^i & ... & \phi_{K_iC}^i \end{bmatrix} \tag{13} ϕi= ​ϕ11i​...ϕKi​1i​​.........​ϕ1Ci​...ϕKi​Ci​​ ​(13)
然后将这三个术语组合并重写为 F F F。 输入数据 X X X的第 i i i个模糊子系统的输出是
F n = ∑ i = 1 n F i = ∑ i = 1 n D π i ϕ i (14) F^n=\sum_{i=1}^nF_i=\sum_{i=1}^nD\pi^i\phi^i \tag{14} Fn=i=1∑n​Fi​=i=1∑n​Dπiϕi(14)

输出预测结果

现在考虑顶层。我们将模糊化 F n F_n Fn​的值发送到增强层 H m H_m Hm​的输出相关，并连接到增强层的权重矩阵 W e ∈ R ( L 1 + L 2 + L m ) × C W_e∈R(L1+L2+Lm)×C We​∈R(L1+L2+Lm)×C，发送到FBLS的顶层。因此，FBLS 的最终输出等于 Y ^ \hat{Y} Y^:
Y ^ = F n + H m W e = D π ϕ + H m W e = ( D π , H m ) W (15) \hat{Y}=F^n+H^mW_e=D\pi\phi+H^mW_e=(D\pi,H^m)W \tag{15} Y^=Fn+HmWe​=Dπϕ+HmWe​=(Dπ,Hm)W(15)
W W W表示模糊 BLS 的参数矩阵。通过给定训练目标 Y Y Y，可以快速计算 W W W的伪逆。
W = ( D π , H m ) − 1 Y = ( ( D π , H m ) T ( D π , H m ) − 1 ) ) ( D π , H m ) T (16) W=(D\pi,H^m)^{-1}Y=((D\pi,H^m)^T(D\pi,H^m)^{-1}))(D\pi,H^m)^T \tag{16} W=(Dπ,Hm)−1Y=((Dπ,Hm)T(Dπ,Hm)−1))(Dπ,Hm)T(16)

核心代码复现

本人在复现时用三个文件来完成本次项目，分别是main.py文件作为顶层文件调用所有函数和方法；utils.py文件作为工具文件，封装了一些所需要用到的方法；FBLS.py文件中实现了Fuzzy规则和BLS结合的新型宽度神经网络模型——FBLS，下面我们将分别给出他们的伪代码来进一步帮大家理解。

main.py文件

开始
|
|---> 导入 numpy 和 scipy.io 中的 loadmat 和 savemat 函数
|---> 导入 random 和 FBLS 模块中的 bls_train 函数
|
|---> 定义主函数 main():
|        |
|        |---> 从 MATLAB 文件 'wbc.mat' 中加载数据
|        |        data = loadmat('wbc.mat')
|        |        train_x = data['train_x']
|        |        train_y = data['train_y']
|        |        test_x = data['test_x']
|        |        test_y = data['test_y']
|        |
|        |---> 转换测试集
|        |        n = 随机生成一个置换数组，长度为 test_x.shape[0]
|        |        使用置换数组 n 的前 140 行来更新 test_x 和 test_y，并将它们转换为 np.float64 类型
|        |        train_y 和 test_y 转换为二元标签 (-1, +1)
|        |
|        |---> 初始化常数和变量
|        |        C = 2 ** -30
|        |        s = 0.8
|        |        best = 0.72
|        |        result = 空列表
|        |
|        |        NumRule = 2
|        |        NumFuzz = 6
|        |        NumEnhan = 20
|        |
|        |---> 设置随机种子为 1，生成 Alpha 和 WeightEnhan
|        |        Alpha = 空列表
|        |        对于 i 从 0 到 NumFuzz-1:
|        |            生成大小为 (train_x.shape[1], NumRule) 的随机数组 alpha
|        |            将 alpha 添加到 Alpha
|        |
|        |        生成大小为 (NumFuzz * NumRule + 1, NumEnhan) 的随机数组 WeightEnhan
|        |
|        |---> 打印模糊规则数、模糊系统数和增强器数
|        |        打印字符串 'Fuzzy rule No.= {NumRule}, Fuzzy system No. ={NumFuzz}, Enhan. No. = {NumEnhan}'
|        |
|        |---> 调用 bls_train 函数进行模型训练和测试
|        |        调用 bls_train(train_x, train_y, test_x, test_y, Alpha, WeightEnhan, s, C, NumRule, NumFuzz)
|        |        返回 NetoutTest, Training_time, Testing_time, TrainingAccuracy, TestingAccuracy
|        |
|        |---> 计算总时间，并将结果保存到 result 列表中
|        |        total_time = Training_time + Testing_time
|        |        将 [NumRule, NumFuzz, NumEnhan, TrainingAccuracy, TestingAccuracy] 添加到 result 列表
|        |
|        |---> 如果 TestingAccuracy 比 best 大，则更新 best，并将结果保存到 'optimal.mat' 文件中
|        |        如果 best < TestingAccuracy:
|        |            更新 best 为 TestingAccuracy
|        |            将 {'TrainingAccuracy': TrainingAccuracy, 'TestingAccuracy': TestingAccuracy,
|        |                 'NumRule': NumRule, 'NumFuzz': NumFuzz, 'NumEnhan': NumEnhan, 'time': total_time}
|        |            保存到 'optimal.mat'
|        |
|        |---> 将 result 列表保存到 'result.mat' 文件中
|        |        将 {'result': np.array(result)} 保存到 'result.mat'
|        |
|        |---> 打印字符串 'Results saved!'
|
|---> 如果运行在主模块下：
|        调用主函数 main()
|
结束

在main.py文件中，我们将FBLS模型封装在bls_train函数中，加载好数据集之后输入模型中进行训练，并编写代码对输出的结果进行测试，打印出评价指标。

FBLS.py文件

开始
|
|        返回 2 / (1 + exp(-2 * x)) - 1
|
|---> 函数 result_tra(output):
|        返回 argmax(output, axis=1)
|
|---> 函数 bls_train(train_x, train_y, test_x, test_y, Alpha, WeightEnhan, s, C, NumRule, NumFuzz):
|        |
|        |---> std = 1
|        |---> 记录开始时间
|        |
|        |---> 设置 H1 为 train_x
|        |---> 初始化 y 为大小 (train_x.shape[0], NumFuzz * NumRule) 的零矩阵
|        |---> 初始化 CENTER 为一个空列表
|        |---> 初始化 ps 为一个空列表
|        |
|        |---> 循环 i 从 0 到 NumFuzz-1:
|        |         |
|        |         |---> 设置 b1 为 Alpha[i]
|        |         |---> 初始化 t_y 为大小 (train_x.shape[0], NumRule) 的零矩阵
|        |         |---> 使用 NumRule 个聚类对 train_x 进行 KMeans 聚类，并将中心设置为聚类中心
|        |         |
|        |         |---> 循环 j 从 0 到 train_x.shape[0]-1:
|        |         |         |
|        |         |         |---> 计算 MF 为 exp(-sum((train_x[j, :] - center) ** 2) / std)
|        |         |         |---> 将 MF 归一化
|        |         |         |---> 设置 t_y[j, :] 为 MF * (train_x[j, :].dot(b1))
|        |         |
|        |         |---> 将 center 添加到 CENTER
|        |         |---> 初始化 scaler 为范围 (0, 1) 的 MinMaxScaler
|        |         |---> 使用 scaler 对 t_y 进行拟合和变换，并将结果设置为 T1
|        |         |---> 将 scaler 添加到 ps
|        |         |---> 设置 y[:, NumRule * i:NumRule * (i + 1)] 为 T1
|        |
|        |---> 将 y 与一个全为 0.1 的列连接起来形成 H2
|        |---> 计算 T2 为 H2 dot WeightEnhan
|        |---> 设置 l2 为 s / max(T2)
|        |---> 对 T2 乘以 l2 应用 tansig
|        |---> 将 y 与 T2 连接起来形成 T3
|        |
|        |---> 计算 beta 为 inverse(T3.T dot T3 + eye(T3.shape[1]) * C) dot T3.T dot train_y
|        |---> 记录训练时间
|        |---> 打印 'Training has been finished!' 和训练时间
|        |---> 计算 NetoutTrain 为 T3 dot beta
|        |
|        |---> 设置 yy 为 result_tra(NetoutTrain)
|        |---> 设置 train_yy 为 result_tra(train_y)
|        |---> 计算 TrainingAccuracy 为 mean(yy == train_yy)
|        |---> 打印训练准确率
|        |
|        |---> 记录开始时间
|        |
|        |---> 设置 HH1 为 test_x
|        |---> 初始化 yy1 为大小 (test_x.shape[0], NumFuzz * NumRule) 的零矩阵
|        |
|        |---> 循环 i 从 0 到 NumFuzz-1:
|        |         |
|        |         |---> 设置 b1 为 Alpha[i]
|        |         |---> 初始化 t_y 为大小 (test_x.shape[0], NumRule) 的零矩阵
|        |         |---> 设置 center 为 CENTER[i]
|        |         |
|        |         |---> 循环 j 从 0 到 test_x.shape[0]-1:
|        |         |         |
|        |         |         |---> 计算 MF 为 exp(-sum((test_x[j, :] - center) ** 2) / std)
|        |         |         |---> 将 MF 归一化
|        |         |         |---> 设置 t_y[j, :] 为 MF * (test_x[j, :].dot(b1))
|        |         |
|        |         |---> 设置 scaler 为 ps[i]
|        |         |---> 使用 scaler 变换 t_y 并将结果设置为 TT1
|        |         |---> 设置 yy1[:, NumRule * i:NumRule * (i + 1)] 为 TT1
|        |
|        |---> 将 yy1 与一个全为 0.1 的列连接起来形成 HH2
|        |---> 对 HH2 dot WeightEnhan 乘以 l2 应用 tansig
|        |---> 将 yy1 与 TT2 连接起来形成 TT3
|        |
|        |---> 计算 NetoutTest 为 TT3 dot beta
|        |---> 设置 y 为 result_tra(NetoutTest)
|        |---> 设置 test_yy 为 result_tra(test_y)
|        |---> 计算 TestingAccuracy 为 mean(y == test_yy)
|        |---> 记录测试时间
|        |---> 打印 'Testing has been finished!' 和测试时间
|        |---> 打印测试准确率
|        |
|        |---> 返回 NetoutTest, Training_time, Testing_time, TrainingAccuracy, TestingAccuracy
|
结束

在FBLS.py文件中，我们完整地复现了FBLS模型的代码，依照上面提到的算法流程一比一实现了FBLS从输入数据到输出测试结果的过程。

使用方法

在FBLS.py文件中我们已经封装好了结果，因此我们可以直接在main.py文件中调用我们想要的数据集并进行训练。

首先，我们需要把本地的数据集放入到当前目录中然后修改数据集名称为大家本地的数据集名称，或者给出它的绝对路径：data=loadmat(‘文件名的绝对路径’)
在这里插入图片描述

在这里插入图片描述

这里我们的数据集中有四个变量：train_x，train_y，test_x，test_y，分别存储的训练集的数据、标签和测试集的数据、标签，标签采用独热编码。

然后在这里，我们可以修改模型的超参数（模糊规则数、模糊节点数和增强层数量）来使我们的模型拟合到最优结果
在这里插入图片描述

接下来就可以得到我们输出的结果啦，训练精度、测试精度、训练时间、测试时间都会被打印出来，大家如果想多使用一些评价指标，也可以自行添加需要的指标，具体方法可以参考我之前的博客。
在这里插入图片描述

测试结果

在一次训练测试结束后，我们可以看到最后的结果，训练精度和测试精度都可以达到97%。
在这里插入图片描述

我们可以修改一下超参数，让 NumRule = 10，NumFuzz = 20，NumEnhan = 100
在这里插入图片描述

可以看到现在模型训练精度虽然达到了100%，但是测试精度出现了下降，这就说明我们参数调的太大让模型出现了过拟合现象，具体的调参大家可以根据自己的数据集来调整。

示例：使用公开数据集进行本地训练

有了复现代码之后，大家肯定很感兴趣我们应该怎么利用这个复现好的模型来在公开数据集上进行本地训练呢，这样才能推进我们的研究。这里我就以MNIST数据集为例教大家如何利用这份代码来进行在公开数据集上的训练

准备数据

首先我们需要将想要用到的数据集导入到本地环境中，

import ssl
import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import pandas as pd

ssl._create_default_https_context = ssl._create_unverified_context

# 定义数据转换（预处理）
transform = transforms.Compose([
    transforms.Resize((10, 10)),
    transforms.ToTensor(),  # 转换为Tensor
    # transforms.Normalize((0.1307,), (0.3081,))  # 归一化
])

# 下载并加载训练数据集
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

# 下载并加载测试数据集
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = DataLoader(dataset=test_dataset, batch_size=1000, shuffle=False)

现在很多公开数据集都提供了第三方库的内置接口，如上面的代码，我们可以很方便地直接使用代码将数据导入到本地环境中。这份MNIST公开数据集中包含70000张首先数字签名的图片，其中60000张被用作训练集，10000张被用作测试集。这里为了适应我们的模型，我们需要对图像数据做一些处理，我们将图像调整为10*10的大小，并将其按照像素点进行展平，将展平后的像素点作为每一个样本的特征，也就是说我们最后会得到训练数据格式为（60000，100），测试数据格式为（10000，100）的数据集用于实验。

# 将每张图片展平并检查加载的数据
examples = enumerate(train_loader)
batch_idx, (example_data, example_targets) = next(examples)

# 将每张图片展平
flat_example_data = example_data.view(example_data.size(0), -1)

print(flat_example_data.shape)  # 应该输出 (64, 784)
print(example_targets.shape)  # 应该输出 (64,)

# 将整个训练集展平
all_flat_train_data = []
all_train_targets = []

for batch_idx, (data, targets) in enumerate(train_loader):
    flat_data = data.view(data.size(0), -1)
    all_flat_train_data.append(flat_data)
    all_train_targets.append(targets)

all_flat_train_data = torch.cat(all_flat_train_data)
all_train_targets = torch.cat(all_train_targets)

print(all_flat_train_data.shape) 
print(all_train_targets.shape)  # 应该输出 (60000,)

# 将整个测试集展平
all_flat_test_data = []
all_test_targets = []

for batch_idx, (data, targets) in enumerate(test_loader):
    flat_data = data.view(data.size(0), -1)
    all_flat_test_data.append(flat_data)
    all_test_targets.append(targets)

all_flat_test_data = torch.cat(all_flat_test_data)
all_test_targets = torch.cat(all_test_targets)

print(all_flat_test_data.shape) 
print(all_test_targets.shape)  # 应该输出 (10000,)

# 将数据转换为DataFrame并保存为CSV文件
train_df = pd.DataFrame(all_flat_train_data.numpy())
train_df['label'] = all_train_targets.numpy()
train_df.to_csv('mnist_train_flattened.csv', index=False)

test_df = pd.DataFrame(all_flat_test_data.numpy())
test_df['label'] = all_test_targets.numpy()
test_df.to_csv('mnist_test_flattened.csv', index=False)

print("数据已成功保存到CSV文件中。")

数据输入模型进行训练

接下来我们可以选择多种方式将数据输入到模型中进行训练，我这里选择的是先将处理好的数据保存到csv文件中，然后输入的时候将其读出来导入环境中。
保存：

# 将数据转换为DataFrame并保存为CSV文件
train_df = pd.DataFrame(all_flat_train_data.numpy())
train_df['label'] = all_train_targets.numpy()
train_df.to_csv('mnist_train_flattened.csv', index=False)

test_df = pd.DataFrame(all_flat_test_data.numpy())
test_df['label'] = all_test_targets.numpy()
test_df.to_csv('mnist_test_flattened.csv', index=False)

导入：

train_data = pd.read_csv('mnist_train_flattened.csv')
test_data = pd.read_csv('mnist_test_flattened.csv')
train_x = train_data.drop('label', axis=1).values
train_y = convert_onehot(train_data['label'].values).astype(int)
test_x = test_data.drop('label', axis=1).values
test_y = convert_onehot(test_data['label'].values).astype(int)

接下来的步骤就如跟上述使用测试数据的逻辑一样

实验结果

接下来我们来看看使用FBLS进行MNIST数据集分类的效果，本次我主要测试了随着各个节点数的上升，FBLS的效果会有什么变化，结果如下图：
在这里插入图片描述

模型的分类准确率基本在90%左右，可以看到固定其他变量不变，模糊节点数、模糊规则数和增强节点数的增加都会带来模型性能的提升，但相应的训练时间也会一定程度的增加。

需要注意的是上表可以看作是对FBLS三个关键性参数的敏感性测试，FBLS的参数调节比较粗略，其分类最优值其实可以达到更优，目前我手调能达到的值已经到了97%，大家也可以多多尝试更广泛的参数看看是否可以收敛的更好，对MNIST数据集进行实验的代码我也一并放在了附件代码中，大家可以下载下来好好研究。

环境配置

  • 本次使用的python版本最好为python3.8及以上
  • 使用的库函数包括numpy、scipy、sklearn和random

资源获取

详细复现过程的项目源码、数据和预训练好的模型可从该文章下方附件地址获取。

附件地址：融入模糊规则的宽度神经网络结构


原文地址：https://blog.csdn.net/qq_52354698/article/details/143624447

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024