登录 / 注册

机器学习(共10篇)

找到 10 篇与机器学习相关的结果

在FPGA上部署轻量BP神经网络-Python与Verilog：信号检测实战摘要本文介绍了在FPGA上部署轻量BP神经网络进行信号检测的实战，包括系统架构、神经网络模型设计、FPGA硬件实现详解以及关键优化技巧，实验结果表明该方案功耗低、性能好。关键词：FPGA, BP神经网络, 信号检测, 低功耗, 实时处理目录储备知识：一、背景：为什么要在FPGA上跑神经网络？二、系统整体架构三、神经网络模型设计：极致轻量四、FPGA硬件实现详解4.1 串并转换模块（Serial-to-Parallel 4.2 数据归一化模块 4.3 隐藏层神经元模块（核心计算单元） 4.4 ReLU激活函数模块 4.5 输出层神经元模块 4.6 阈值判断模块五、关键优化技巧5.1 归一化的"逆向"处理 5.2 权值二值化（BWN）降低功耗 5.3 亚稳态消除六、实验结果：功耗与性能七、总结与思考 python和verilog源程序下载储备知识：我们在前文讲了BP神经网络算法和激活函数 BP神经网络算法 https://ee.ac.cn/index.php/archives/612.html 激活函数讲解 https://ee.ac.cn/index.php/archives/617.html 一、背景：为什么要在FPGA上跑神经网络？在无源物联网（Battery-free IoT）和反向散射通信（Backscatter）场景中，传统的信号检测方法（如能量检测）虽然电路简单，但无法区分同频段的多种信号，且受噪声影响大；而基于PC或GPU的深度学习方案虽然精度高，但功耗动辄数十瓦，显然无法部署在依赖能量采集的微瓦级标签上。核心矛盾在于：缺乏一种检测精度高、功耗极低（毫瓦级）、且能实时处理的解决方案。答案是将轻量级的BP神经网络部署到低功耗FPGA上，在边缘端完成信号推理。二、系统整体架构整个检测系统的链路如下： graph LR subgraph 射频前端 A[目标信号] --> B[天线] B --> C[阻抗匹配] C --> D[LNA放大] end subgraph 信号处理 D --> E["包络检波(ENV)"] E --> F["ADC采样<br>1MSPS, 12bit"] end subgraph 智能决策 F --> G["FPGA<br>BP神经网络推理"] G --> H[调制控制信号] end在FPGA内部，BP神经网络负责识别当前输入的512点采样数据是否为目标信号的前导码（Preamble）。一旦识别成功，输出控制信号，开启后端的Backscatter调制模块。 FPGA选型：Actel IGLOO/e系列 AGLE600V5-FG484。选择它的原因是： Flash架构：上电即运行，无需外部配置芯片，适合无源系统；超低功耗：静态功耗仅0.046mW，适合能量采集场景；资源适中：13824个逻辑单元，足以容纳轻量级网络。三、神经网络模型设计：极致轻量为了在FPGA上高效部署，网络结构必须足够"轻"。本文设计的网络结构如下： pasted_1785558315326_lc6zyp.png图片层级神经元数说明输入层512对应ADC采集的一条信号的512个采样点隐藏层2仅2个神经元，大幅降低计算量输出层1二分类：是目标信号(1) / 非目标信号(0)激活函数：隐藏层和输出层均采用 ReLU。 $$f(x) = \max(0, x)$$ 选择ReLU的原因不仅是训练效果好，更重要的是硬件实现极其简单——只需一个比较器判断正负，无需计算指数或乘法，这对FPGA非常友好。 pasted_1785561816152_bsny25.png图片训练环境：TensorFlow/Keras，使用Adam优化器和MSE损失函数。在真实环境数据集上训练后，测试集识别准确率可达 95.76%。 pasted_1785561967835_yy5zgm.png图片四、FPGA硬件实现详解 FPGA内部的神经网络是一个纯推理引擎。本节按数据流方向，逐个拆解每个模块的设计思路和Verilog实现要点。 pasted_1785562098406_gf64mu.png图片整体RTL结构如下： pasted_1785563631508_f74j4w.png图片 4.1 串并转换模块（Serial-to-Parallel pasted_1785563649652_chqrj8.png图片 ADC（ADS7042）在片选信号CS拉低后，先输出2个前导0，再输出12位有效数据（D11→D0），每个数据位占用一个CLK周期。设计要点： CS和CLK由FPGA内部产生，CS每16个CLK周期拉低一次；在CS下降沿开始，用计数器对串行数据移位寄存；凑齐12位有效数据后，输出一组并行数据 adc_data[11:0]。波形图 pmhbofe.png图片 module serial_p(input data0_in,input cs,input clk,output[12:0] data0_out,input rst); reg[11:0] temp; reg[12:0] save; integer count; integer cnt; always @(negedge clk or negedge rst) begin if(!rst) begin//reset temp<=12'b000000000000; count<=-1; save<=12'b111111111111; cnt<=-1; end else if(cs&&count%16==0) begin save<={1'b0,temp}; count<=1; cnt<=cnt+1; if(cnt==512) begin cnt<=1; end end else if(cs) begin temp<=12'b0; count<=1; end else if(count<3) count<=count+1; else begin temp<={temp,data0_in}; count<=count+1; end end assign data0_out=save; endmodule 4.2 数据归一化模块问题：训练时，输入数据被归一化到 [0, 1.8]（对应ADC参考电压1.8V）。如果在FPGA中直接用除法做 Vin = adc_data / 4095 * 1.8，会消耗大量逻辑资源（FPGA做除法器代价极高）。解决方案：在软件端完成归一化，FPGA端只做整数运算。具体做法：在Python/Keras训练时，将输入数据 x 归一化为 x_norm = x / 4095 * 1.8；在提取权值时，将第一层权值 w 除以 1.8 并放大 1024 倍取整；这样FPGA输入的原始ADC值 adc_data（范围0~4095）直接与预处理后的权值相乘，等效于完成了归一化+加权。 # 创建一个自定义的回调对象 cb = MyCallback() # 以只读方式打开训练数据文件 with open('/content/work/data/data.txt') as traindata: # 读取文件内容 data = traindata.read() # 将文件内容转换为numpy数组，并将数据类型转换为float，并将数组形状调整为(47100, 2) data = np.array(list(data.split()), dtype=float).reshape((47100, 2)) # 创建一个最大最小归一化对象 min_max_scaler = preprocessing.MinMaxScaler() # 归一化 data = data * (1/65535) # 以只读方式打开训练标签文件 with open('/content/work/data/label.txt') as labda: # 读取文件内容 labels = labda.read() # 将文件内容转换为numpy数组，并将数据类型转换为float，并将数组形状调整为(47100, 2) labels = np.array(list(labels.split()), dtype=float).reshape((47100, 2)) # 对data和labels进行乱序，保持它们的对应关系 # 为了保持对应关系，需要先将data和labels沿着第二个维度拼接起来，形成一个(100, 4)的数组 # 然后对这个数组进行乱序，再将它们沿着第二个维度分开，还原成data和labels data_labels = np.concatenate((data, labels), axis=1) np.random.shuffle(data_labels) data = data_labels[:, :2] labels = data_labels[:, 2:]FPGA端实现：实际上，归一化模块在FPGA中被合并到了权值预处理阶段，硬件上不需要额外的归一化电路。但为了模块化清晰，也可以显式设计一个"电压映射"模块，将12bit ADC码值转换为定点数格式：工程建议：永远不要在FPGA里做除法。所有线性变换（归一化、缩放）都应在软件端合并到权值中，FPGA只做整数乘加。 4.3 隐藏层神经元模块（核心计算单元）隐藏层的数学表达式： $$y = \text{ReLU}\left( \sum_{i=1}^{512} x_i \cdot w_i + b \right)$$ , i = 1..512 工程难点： 512次乘累加如果在一个时钟周期完成，需要512个乘法器，资源爆炸；如果纯串行完成，需要512个时钟周期，一条chirp要512×512=262144个周期，太慢。解决方案：采用串行MAC流水线 + 双缓冲FIFO 架构。设计思路：权值存储：512个权值和1个偏置在编译时以 reg [31:0] w[0:511] 形式固化在FPGA中； FIFO缓存：ADC每输出一个采样点，立即写入FIFO。FIFO深度设为16即可（只要保证不溢出），因为读出速度（MAC运算）和写入速度（ADC采样）基本匹配；串行MAC：每个时钟周期从FIFO读出一个数据 xi，与对应的 wi 相乘，累加到累加器 acc； 512个周期后：累加器结果加上偏置 b，送入ReLU模块。 pasted_1785563798085_32317i.png图片 FIFO波形图 pmhqDBt.png图片关键设计细节：位宽设计：输入22bit × 权值32bit = 乘法结果54bit，累加512次需要额外9bit，因此累加器至少需要 63bit。如果位宽不够，累加会溢出，导致结果完全错误。时序约束：乘法器和加法器要满足16MHz时钟的建立保持时间。如果组合逻辑延迟太大，需要插入流水线寄存器（将乘法器和加法器分两级完成）。双神经元并行：隐藏层有2个神经元，需要例化两个上述模块，各自独立的权值存储和累加器，但共享同一个FIFO输入。 4.4 ReLU激活函数模块 ReLU的硬件实现是整个网络中最简单的部分： pmhqWcj.png图片 module relu ( input wire clk, input wire rst_n, input wire [31:0] x_in, // MAC+bias结果 input wire x_valid, output reg [31:0] y_out, output reg y_valid ); always @(posedge clk or negedge rst_n) begin if (!rst_n) begin y_out <= 32'd0; y_valid <= 1'b0; end else begin y_valid <= x_valid; if ($signed(x_in) >= 0) y_out <= x_in; else y_out <= 32'd0; end end endmodule4.5 输出层神经元模块输出层只有1个神经元，输入是隐藏层2个神经元的输出： $$\text{output} = \text{ReLU}\left( h_1 \cdot w'_1 + h_2 \cdot w'_2 + b' \right)$$ 这个模块与隐藏层类似，但逻辑资源消耗极小。 pmhq7NT.png图片 module nerual_out( clk, rst,x1,x2,data_out ); input clk, rst; input signed[0:49] x1,x2; output signed[79:0] data_out; //<statements> //reg signed[0:28] weight[0:1]; reg signed[0:7] save,save1,save2; localparam bais=-50'd214979034352654; //localparam bais = -26'd6406874; localparam weight0 = 29'd22506522; localparam weight1 =-29'd341584992; //integer bais; integer count; always @(negedge clk or negedge rst) begin if(!rst) //reset,set values and bias begin // bais<=-50'd214979034352654; // weight[0]<=29'd22506522; // weight[1]<=-29'd341584992; save<=0; save1<=0; save2<=0; count<=0; end else begin save1<=x1*weight0; save2<=x2*weight1; count<=count+1; if(count>518) save<=save1+save2+bais;//Multiply the input by the weights and add up the results end end assign data_out=save; endmodule4.6 阈值判断模块为什么需要阈值判断？前面提到，我们在保存权值时将所有参数扩大了 1024 倍（即 $2^{10}$）。这意味着：隐藏层的输出值也被放大了约1024倍；输出层的计算结果同样被放大；原本训练时，输出层ReLU后大于0即判定为目标信号；现在由于数值被放大，不能简单以0为界，需要设定一个等效的阈值。阈值推导：原始判定边界：输出 > 0.5（二分类常用阈值）；放大后等效边界：threshold = 0.5 × 1024 × 1024 = 524288；实际上，由于隐藏层和输出层都放大了1024倍，总放大倍数为 $1024^2 = 1048576$，因此： threshold = 0.5 × 1048576 = 524288。波形图 pmhqXv9.png图片五、关键优化技巧 5.1 归一化的"逆向"处理再次强调这个最重要的优化：处理方式FPGA资源消耗推荐度FPGA内做除法（adc/4095）极高，需除法器IP❌FPGA内用移位近似除法中等，精度损失大△权值预处理（本文方法）零额外消耗✅具体做法：训练时归一化：$V_{\text{in}} = \frac{\text{adc_data}}{4095} \times 1.8$；提取权值时：$w' = \frac{w}{1.8} \times 1024$，取整； FPGA输入：直接使用原始ADC值 $x$（0~4095）；等效运算。 5.2 权值二值化（BWN）降低功耗为了进一步压缩模型、降低功耗，本文采用了 Binary-Weight-Networks (BWN) 对权值进行二值化：权值只取 +1 或 -1；引入缩放因子 α 保证量化后的权值尽可能接近原始浮点权值。二值化后，乘法运算退化为加减法或符号位判断，FPGA资源占用和动态功耗大幅下降。虽然精度略有损失，但在本场景中仍能保持97%以上的识别率。二值化乘法器的Verilog实现： // 二值化权值乘法：只需判断符号 wire signed [31:0] product; assign product = bin_weight ? x_in : -x_in; // bin_weight=1为正，0为负相比32bit×32bit的硬件乘法器，这个逻辑几乎不消耗DSP资源。 5.3 亚稳态消除 ADC数据输入和CS信号是异步信号（相对于16MHz系统时钟），必须做双级触发器同步，防止亚稳态传播： reg adc_dat_d1, adc_dat_d2; always @(posedge clk) begin adc_dat_d1 <= adc_dat; // 第一级 adc_dat_d2 <= adc_dat_d1; // 第二级（稳定后使用） end wire adc_dat_sync = adc_dat_d2;六、实验结果：功耗与性能通过 Actel Libero SOC 对FPGA各模块进行功耗仿真，结果如下：工作模式静态功耗动态功耗总功耗空闲态0.046 mW00.046 mW正常工作0.046 mW2.79 mW2.835 mWFlash*Freeze模式0.115 mW00.115 mW2.835 mW 的总功耗，对于低功耗设备来说是完全可以接受的。各子模块动态功耗分解：串并转换：0.01 mW 隐藏层神经元（含FIFO）：0.083 mW ReLU激活：0.067 mW 输出层神经元：0.067 mW 七、总结与思考本文介绍了一套完整的从算法到硬件的轻量化神经网络部署方案：算法层：针对低功耗约束，设计了512-2-1极简BP网络，避免使用CNN/RNN等重算力模型；数据层：在真实环境中采集目标信号，建立含噪样本库，并通过数据增强提升泛化能力；硬件层：基于Actel低功耗FPGA，用FIFO流水、整数运算、ReLU硬判决、权值二值化等手段，实现了毫瓦级推理；系统层：与射频前端（LNA、包络检波、ADC）紧密配合，形成完整的标签信号检测链路。可扩展性：该FPGA神经网络框架不仅可用于目标信号检测，只需更换训练数据集和权值参数，即可用于FMCW、RFID等其他射频信号的识别，具备良好的通用性。 python和verilog源程序下载

FPGA&ASIC 通信&信息处理机器学习软硬件算法 # ASIC/FPGA # 信号处理 # 机器学习 # 软件算法 # 物联网 # Python

刘航宇 8月1日
0 76 6
2024-01-20
机器学习/深度学习-训练过程讲解acc/loss/val_acc/val_loss分析摘要本文探讨了机器学习/深度学习训练过程中的loss、acc、val_acc、val_loss等指标分析，强调了模型选择、参数调优和过拟合问题，并提供了解决训练过程中震荡和收敛问题的方法。关键词：机器学习, 深度学习, 训练过程, loss分析, accuracy计算loss是会把所有loss层的loss相加。那么如何选取一个较为理想的medel？单独观察训练集loss曲线 loss出现NAN 联合观察loss曲线和acc TensorFlow中loss与val_loss、accuracy和val_accuracy含义震荡修复计算loss是会把所有loss层的loss相加。从验证集误差是和测试集误差的角度分析其实你这个问题就是个伪命题，如果我们刻意的去在训练集上拟合模型，使其准确率达到很高的高度，或者说尽量在验证集合上表现的好，都是相悖的。因为我们不能为了某一特定数据集来刻意拟合，因为模型预测数据是不一定就在这个训练或者验证集合的空间中。还有，如果这个model预测集合acc20% 训练集合acc19% （即训练集精度低于测试集精度），那么这个模型肯定是不好的。还有一点需要注意，就是千万不能为了拟合测试集合而去更改模型，测试集合应该每次都有不同。那么如何选取一个较为理想的medel？首先，要有一个期望的准确率，通过不同模型的实验，找到最能接近的；然后，选定模型后进行参数调优；那么我们要尽可能的提高model的准确率，同时提高其泛化的能力，不能单一看某一指标，此时可参考准确率、召回率、虚警率、F1Score等指标综合评判。或者采用多重验证随机划分训练、预测、验证集合，多次随机后找到最优参数。有时候训练集合误差很低，但是泛化能力极差，产生过拟合，有时候验证集合误差很低，但是可能验证集合无法代表所有的样本，有特殊性或者其他异常点较多。所以模型问题不能单一从你这两点来评判。一般而言，训练集loss < 验证集loss <测试集loss 因为网络 [已见过] 所有训练集samples，故最低。而网络用验证集作为反馈来调节参数，相当于参考了验证集samples中的信息（间接 [已见过]）。又因为网络没有任何测试集的信息，所以测试结果一般而言最差。不过这都不是绝对的，有不符合这个一般现象的task，而我们不可以说哪种情况更“好”。多数情况验证集上错误率更低一点。因为是选择在验证集上准确率最高的模型来进行测试。考虑到数据的随机性，在验证集上准确率最高的模型在测试集上不一定是最高的，所以算出来的指标通常验证集会比测试集上好一点。但是实际情况下都有可能，特别是数据量不太大的时候。样本集合的数据也只是近似整体的分布，肯定会有波动。一个好的网络，二者的差距应该是很低的。但一般情况下因为网络不可避免地存在一定程度上的过拟合，所以肯定是train_loss低于test_lost，但如果低太多，就得考虑是过拟合的问题还是因为样本的特征空间不统一的问题。一般训练集不大时，最终训练的网络及容易过拟合，也就是说train-loss一定会收敛，但是test-loss不会收敛；训练时的loss会低于test的loss大概1~2个数量级，通常是10倍左右。单独观察训练集loss曲线 1）如果你的 learning_rate_policy 是 step 或者其他变化类型的话, loss 曲线可以帮助你选择一个比较合适的 stepsize； 2）如果loss曲线表现出线性（下降缓慢）表明学习率太低； 3）如果loss不再下降，表明学习率太高陷入局部最小值； 4）曲线的宽度和batch size有关，如果宽度太宽，说明相邻batch间的变化太大，应该减小batch size。可能导致不收敛的问题（如loss为87.3365，loss居高不下等）的解决方案 1）在caffe中可以在solver里面设置：debug_info: true,看看各个层的data和diff是什么值，一般这个时候那些值不是NAN（无效数字）就是INF（无穷大）； 2）检查数据标签是否从0开始并且连续； 3）把学习率base_lr调低； 4）数据问题，lmdb生成有误； 5）中间层没有归一化，导致经过几层后，输出的值已经很小了，这个时候再计算梯度就比较尴尬了，可以尝试在各个卷积层后加入BN层和SCALE层； 5）把base_lr调低，然后batchsize也调高； 6）把data层的输入图片进行归一化，就是从0-255归一化到0-1，使用的参数是： transform_param { scale: 0.00390625//像素归一化，1/255 } 7）网络参数太多，网络太深，删掉几层看看，可能因为数据少，需要减少中间层的num_output； 8）记得要shuffle数据，否则数据不够随机，几个batch之间的数据差异很小。 loss出现NAN 1）观察loss值的趋势，如果迭代几次以后一直在增大，最后变成nan，那就是发散了，需要考虑减小训练速率，或者是调整其他参数。 2）数据不能太少，如果太少的话很容易发散" 3）Gradient Clipp 处理gradient之后往后传，一定程度上解决梯度爆炸问题。（但由于有了batch normalization，此方法用的不多） 4）原因可能是训练的时间不够长。 5）可以看一下训练时，网络参数的L2或L1 联合观察loss曲线和acc 1）单独的 loss 曲线能提供的信息很少的,一般会结合测试机上的 accuracy 曲线来判断是否过拟合； 2）关键是要看你在测试集上的acc如何； 3）可以把accuracy和loss的曲线画出来，方便设定stepsize，一般在accuracy和loss都趋于平缓的时候就可以减小lr了； 4）看第一次test时（即iteration 0），loss和精度，如果太差，说明初始点的设置有问题 5）使用caffe时，train时，看见的loss是训练集的；accuracy才是测试集的 6）所谓的过拟合是：loss下降，accuracy也下降 TensorFlow中loss与val_loss、accuracy和val_accuracy含义图片 loss：训练集损失值 accuracy:训练集准确率 val_loss:测试集损失值 val_accruacy:测试集准确率以下5种情况可供参考： train loss 不断下降，test loss不断下降，说明网络仍在学习;（最好的） train loss 不断下降，test loss趋于不变，说明网络过拟合;（max pool或者正则化） train loss 趋于不变，test loss不断下降，说明数据集100%有问题;（检查dataset） train loss 趋于不变，test loss趋于不变，说明学习遇到瓶颈，需要减小学习率或批量数目;（减少学习率） train loss 不断上升，test loss不断上升，说明网络结构设计不当，训练超参数设置不当，数据集经过清洗等问题。（最不好的情况）震荡修复验证集曲线震荡图片分析原因：训练的batch_size太小目前batch_size = 64，改成128：图片改成200：图片可见，增大batch_size 变大，震荡逐渐消失，同时在测试集的acc也提高了。batch_size为200时，训练集acc小于测试集，模型欠拟合，需要继续增大epoch。总结增大batchsize的好处有三点： 1）内存的利用率提高了，大矩阵乘法的并行化效率提高。 2）跑完一次epoch(全数据集)所需迭代次数减少，对于相同的数据量的处理速度进一步加快，但是达到相同精度所需要的epoch数量也越来越多。由于这两种因素的矛盾， batch_Size 增大到某个时候，达到时间上的最优。 3）一定范围内，batchsize越大，其确定的下降方向就越准，引起训练震荡越小。盲目增大的坏处： 1）当数据集太大时，内存撑不住。 2）过大的batchsize的结果是网络很容易收敛到一些不好的局部最优点。 3）batchsize增大到一定的程度，其确定的下降方向已经基本不再变化。 4）太小的batch也存在一些问题，比如训练速度很慢，训练不容易收敛等。 5）具体的batch size的选取和训练集的样本数目相关。

机器学习 # 机器学习

刘航宇 2年前
0 3,461 3
泛化能力，过拟合，欠拟合，不收敛，奥卡姆剃刀摘要本文介绍了机器学习中的泛化能力、欠拟合、过拟合和不收敛等概念，并分析了它们的成因和解决方法，包括增加数据特征、使用更高级的模型、降低模型复杂度、数据集扩增、数据增强、正则化、dropout、早停、重新清洗数据和集成学习方法等。关键词：泛化能力, 过拟合, 欠拟合, 不收敛, 正则化泛化能力欠拟合过拟合与不收敛解决手段一、模型训练拟合的分类和表现二、欠拟合三、过拟合总结：泛化能力泛化能力（generalization ability）是指机器学习算法对新鲜样本的适应能力，简而言之是在原有的数据集上添加新的数据集，通过训练输出一个合理的结果。学习的目的是学到隐含在数据背后的规律，对具有同一规律的学习集以外的数据，经过训练的网络也能给出合适的输出，该能力称为泛化能力。欠拟合过拟合与不收敛用比较直白的话来讲，就是通过数据训练学习的模型，拿到真实场景去试，这个模型到底行不行，如果达到了一定的要求和标准，它就是行，说明泛化能力好，如果表现很差，说明泛化能力就差。为了更好的理解泛化能力，这里引入三种现象，欠拟合、过拟合以及不收敛。欠拟合（under-fitting），是指模型拟合程度不高，数据距离拟合曲线较远，或指模型没有很好地捕捉到数据特征，不能够很好地拟合数据。即，在训练数据集上表现差，在测试集数据也表现差。过拟合（over-fitting），是指模型在训练集上表现很好，在测试集上效果差。不收敛（non-convergence）,指误差函数一直在振荡，不能趋近一个定值，没有找到局部或者全局最小值。举个例子来说明下，好比高考数学考试，为了在高考能有个好成绩，高一到高三，好多人会采用“题海战术”来训练自己的做题能力，但高考试卷上的题，都是新题，几乎没有一模一样的题，学生们为了掌握解题规律就不停的刷题，希望最后自己碰到类似的题，能够举一反三，能学以致用，这种规律掌握的适用性，就是泛化能力。有的人对相似题型的解题规律掌握的很好，并且解题效果也很好，这种就是泛化能力强，这种同学往往数学成绩就好。有的同学成绩不好，就是泛化能力差，可能有三种情况 1.做了不少题，但没有找到解题规律，不管碰到老题和新题都不会做，这种就是欠拟合。 2.做了很多题，自认为做过的每一类题型的解题规律都掌握了，而且在之前“题海战术”的题目中，确实表现的很好，但是一碰到新的题目，完全就不会，或者做错，这种学生就是那种喜欢死记硬背的，这种就是过拟合。 3.平常也不做题，然后每次一做题就瞎蒙，导致偶尔对，偶尔错，这种就是不收敛。为了更直观展示，引用了几张图来说明，如下图所示，真实曲线是正弦曲线，蓝色的点是训练数据，红色的线为拟合曲线。图片图片解决手段在深度学习的模型建立过程中，一般都是用已经产生的数据训练，然后使用训练得到的模型去拟合未来的数据，借此来预测一些东西。在机器学习和深度学习的训练过程中，经常会出现欠拟合和过拟合的现象。训练一开始，模型通常会欠拟合，所以会对模型进行优化，等训练到一定程度后，就需要解决过拟合的问题了。一、模型训练拟合的分类和表现如何判断过拟合呢？我们在训练的时候会定义训练误差，验证集误差，测试集误差（即泛化误差）。训练误差总是减少的，而泛化误差一开始会减少，到了一定程度后不减少反而开始增加，这时候便出现了过拟合的现象。如下图，直观理解，欠拟合就是还没有学习到数据的特征，还有待继续学习，所以此时判断的不准确；而过拟合则是学习的太彻底，以至于把数据的一些不需要的局部特征或者噪声所带来的特征都给学习到了，所以在测试的时候泛化误差也不佳。图片从方差和偏差的角度来说，欠拟合就是在训练集上高方差，高偏差，过拟合就是高方差，低偏差。为了更加直观，我们看下面的图图片对比上图，图一的拟合并没有把大体的规律给拟合出来，拟合效果不好，这个就是欠拟合，还需要继续学习规律，此时模型简单；图三的拟合过于复杂，拟合的过于细致，以至于拟合了一些没有必要的东西，这样在训练集上效果很好，但放到测试集和验证集就会不好。图二是最好的，把数据的规律拟合出来了，也没有更复杂，更换数据集后也不会效果很差。在上面的拟合函数中，可以想到，图三过拟合的拟合函数肯定是一个高次函数，其参数个数肯定比图二多，可以说图三的拟合函数比图二要大，模型更加复杂。这也是过拟合的一个判断经验，模型是否过于复杂。另外针对图三，我们把一些高次变量对应的参数值变小，也就相当于把模型变简单了。从这个角度上讲，可以减少参数值，也就是一般模型过拟合，参数值整体比较大。从模型复杂性上讲，可以是： ——模型的参数个数； ——模型的参数值的大小。个数越多，参数值越大，模型越复杂。二、欠拟合欠拟合的表现有什么方法来判断模型是否欠拟合呢？其实一般都是依靠模型在训练集和验证集上的表现，有一个大概的判断就行了。如果要有一个具体的方法，可以参考机器学中，学习曲线来判断模型是否过拟合，如下图：图片欠拟合的解决方案（1）增加数据特征：欠拟合是由于学习不足导致的，可以考虑添加特征，从数据中挖掘更多的特征，有时候嗨需要对特征进行变换，使用组合特征和高次特征；（2）使用更高级的模型：模型简单也会导致欠拟合，即模型参数过少，结构过于简单，例如线性模型只能拟合一次函数的数据。尝试使用更高级的模型有助于解决欠拟合，增加神经网络的层数，增加参数个数，或者使用更高级的方法；（3）减少正则化参数：正则化参数是用来防止过拟合的，出现欠拟合的情况就要考虑减少正则化参数。三、过拟合过拟合的定义模型在训练集上表现好，但在测试集和验证集上表现很差，这就是过拟合图片过拟合的原因（1）数据量太小这是很容易产生过拟合的原因。设想我们有一组数据很好的满足了三次函数的规律，但我们只取了一小部分数据进行训练，那么得到的模型很可能是一个线性函数，把这个线性函数用于测试集上，可想而知肯定效果很差。（此时训练集上效果好，测试集效果差）（2）训练集和验证集分布不一致这也是很大一个原因。训练集上训练出来的模型适合训练集，当把模型应用到一个不一样分布的数据集上，效果肯定大打折扣，这个是显而易见的。（3）网络模型过于复杂选择模型算法时，选择了一个复杂度很高的模型，然而数据的规律是很简单的，复杂的模型反而不适用了。（4）数据质量很差数据有很多噪声，模型在学习的时候，肯定也会把噪声规律学习到，从而减少了一般性的规律。这个时候模型预测效果也不好。（5）过度训练这是同第四个相联系的，只要模型训练时间足够长，那么模型肯定会把一些噪声隐含的规律学习到，这时候降低模型的性能也是显而易见的。解决方法（1）降低模型复杂度处理过拟合的第一步就是降低模型复杂度。为了降低复杂度，我们可以简单地移除层或者减少神经元的数量使得网络规模变小。与此同时，计算神经网络中不同层的输入和输出维度也十分重要。虽然移除层的数量或神经网络的规模并无通用的规定，但如果你的神经网络发生了过拟合，就尝试缩小它的规模。（2）数据集扩增在数据挖掘领域流行着这样的一句话，“有时候往往拥有更多的数据胜过一个好的模型”。因为我们在使用训练数据训练模型，通过这个模型对将来的数据进行拟合，而在这之间又一个假设便是，训练数据与将来的数据是独立同分布的。即使用当前的训练数据来对将来的数据进行估计与模拟，而更多的数据往往估计与模拟地更准确。因此，更多的数据有时候更优秀。但是往往条件有限，如人力物力财力的不足，而不能收集到更多的数据，如在进行分类的任务中，需要对数据进行打标，并且很多情况下都是人工得进行打标，因此一旦需要打标的数据量过多，就会导致效率低下以及可能出错的情况。所以，往往在这时候，需要采取一些计算的方式与策略在已有的数据集上进行手脚，以得到更多的数据。通俗的讲，数据机扩增即需要得到更多的符合要求的数据，即和已有的数据是独立同分布的，或者近似独立同分布的。一般有以下方法： ——从数据源头采集更多数据 ——复制原有数据加上噪声 ——重采样 ——根据当前数据集估计数据分布参数，利用该分布产生更多数据（3）数据增强使用数据增强可以生成多幅相似图像。这可以帮助我们增加数据集从而减少过拟合。因为随着数据量的增加，模型无法过拟合所有样本，因此不得不进行泛化。计算机视觉领域通常的做法有：翻转，平移，旋转，缩放，改变亮度，添加噪声等。（4）正则化正则化是指在进行目标函数或者代价函数优化时，在目标函数或者代价函数后面加上一个正则项，一般有L1正则和L2正则等。 L1惩罚项的目的是使权重绝对值最小化，公式如下：图片 L1惩罚项的目的是使权重的平方最小化，公式如下：图片下面对两种正则化方法进行了比较：图片如果数据过于复杂以致没有办法进行准确的建模，那么L2是更好的选择，因为它能够学习数据中呈现的内在模式。而当数据足够简单，可以精确建模的话，L1更合适，对于我遇到的大多数计算机视觉问题，L2正则化几乎总是可以给出最好的结果。然而L1不容易受到离群值的影响。所以正确的正则化选项取决于我们想要解决的问题。总结：正则项是为了降低模型的复杂度，从而避免模型过分拟合训练数据，包括噪声与异常点。从另一个角度讲，正则化即是假设模型参数服从先验概率，即为模型参数添加先验，只是不同的正则化方式的先验分布是不一样的。这样就规定了参数的分布，使得模型的复杂度降低（试想一下，限定条件多了，是不是模型的复杂度就降低了呢），这样模型对于噪声和异常点的抗干扰性的能力增强，从而提高模型的泛化能力。还有个解释，从贝叶斯学派来看，加了先验，在数据少的时候，先验知识可以防止过拟合；从频率学派来看，正则项限定了参数的取值，从而提高了模型的稳定性，而稳定性强的模型不会过拟合，即控制模型空间。另外一个角度，过拟合从直观上理解便是，在对训练数据进行拟合时，需要照顾到每个点，从而使得拟合函数波动性非常大，即方差大。在某些小区间里，函数值的变化很剧烈，意味着函数在某些小区间的导数值的绝对值非常大，由于自变量的值在给定的训练数据集中是一定的，因为只有系数足够大，才能保证导数的绝对值足够大，如下图：图片另一个解释，规则化项的引入，在训练（最小化cost）的过程中，当某一维的特征所对应的权重过大时，而此时模型的预测和真实数据之间的距离很小，通过规则化项就可以使整体的cost取较大的值，从而，在训练的过程中避免了去选择了那些某一维（或几维）特征权重过大的情况，即过分依赖某一维（或几维）的特征。 L1和L2的区别是，L1正则是拉普拉斯先验，L2正则则是高斯先验。它们都是服从均值为0，协方差为1/λ。当λ=0，即没有先验，没有正则项，则相当于先验分布具有无穷大的协方差，那么这个先验约束则会非常弱，模型为了拟合拟合所有的训练集数据，参数可以变得任意大从而使得模型不稳定，即方差大而偏差小。λ越大，表明先验分布协方差越小，偏差越大，模型越稳定。即，加入正则项是在偏差bias与方差variance之间做平衡tradeoff。下图即为L2与L1正则的区别：图片上图中的模型是线性回归，有两个特征，要优化的参数分别是w1和w2，左图的正则化是L2，右图是L1。蓝色线就是优化过程中遇到的等高线，一圈代表一个目标函数值，圆心就是样本观测值（假设一个样本），半径就是误差值，受限条件就是红色边界（就是正则化那部分），二者相交处，才是最优参数。可见右边的最优参数只可能在坐标轴上，所以就会出现0权重参数，使得模型稀疏。其实拉普拉斯分布和高斯分布是数学家从试验中误差服从什么分布研究得出的。一般直观上的认识是服从均值为0的对称分布，并且误差大的概率低，误差小的概率高，因为拉普拉斯使用拉普拉斯分布对误差的分布进行拟合，如下图：图片而拉普拉斯在最高点，即自变量为0处不可导，因为不便于计算，于是高斯在这基础上使用高斯分布对其进行拟合，如下图：图片（5）dropout 正则时通过再代价函数后面加上正则项来防止过拟合的。而在神经网络中，有一种方法时通过修改神经网络本身结构实现的，其名为dropout。该方法是对网络进行训练时用的一种技巧，对于如下的三层人工神经网络：图片对于上图所示的网络，在训练开始时，随即删除一些（可自己设定概率）隐藏层神经元，即认为这些神经元不存在，同时保持输入层和输出层的个数不变，这样便得到如下的ANN：图片然后按照BP学习算法对ANN中的参数进行学习更新（虚线链接的单元不更新，因为认为这些连接元被临时删除了）。这样一次迭代更新便完成了，下一次迭代中，同样随机删除一些神经元，与上次不一样，做随机选择，这样一直进行，直至训练结束。这种技术被证明可以减少很多问题的过拟合，这些问题包括图像分类，图像切割，词嵌入，语义匹配等问题。（6）早停对模型的训练即是对模型的参数进行更新的过程，这个参数学习的过程往往会用到一些迭代方法，如梯度下降（Gradient descent）学习算法。Early stopping一种迭代次数截断的方法来防止过拟合的方法，即在模型对训练数据集迭代收敛之前停止迭代来防止过拟合。 Early stopping方法的具体做法是，在每一个Epoch结束时（一个Epoch集为对所有的训练数据的一轮遍历）计算验证集的正确率，当正确率不再提高时，就停止训练。这种做法很符合直观感受，因为正确率都不在提高了，再继续训练也是无益的，只会提高训练的时间。如下图，在几次迭代后，即使训练误差仍然在减少，但测验误差已经开始增加了。图片那么该做法的一个重点便是怎样才认为验证准确率validation accurary不再提高了呢？并不是说验证准确率validation accurary一降下来便认为不再提高了，因为可能经过这个Epoch后，正确率降低了，但是随后的Epoch又让正确率又上去了，所以不能根据一两次的连续降低就判断不再提高。一般的做法是，在训练的过程中，记录到目前为止最好的验证准确率validation accurary，当连续10次没达到最佳正确率时，认为不再提高了，此时便可以停止迭代。这种策略也称为“No-improvement-in-n”，n即Epoch的次数，可以根据实际情况取，如10、20、30…… （7）重新清洗数据把明显异常的数据剔除。（8）使用集成学习方法把多个模型集成在一起，降低单个模型的过拟合风险。

机器学习 # 机器学习

刘航宇 2年前
0 1,335 2
2023-12-26
AI: 机器学习必须懂的几个术语：Label、Feature、Model... 摘要本文介绍了机器学习中关键术语，包括标签、特征、样本、模型、回归和分类，并简要说明了它们在机器学习中的应用和重要性。关键词：AI, 机器学习, 术语, Label, Feature1.标签 Label 2.特征 Feature 3.样本 Example3.1有标签样本(labeled): 3.2无标签样本(unlabeled)： 4.模型 Model 5.回归 Regression 6.分类 Classification 7.机器学习算法地图 1.标签 Label 标签：所预测的东东实际是什么（可理解为结论），如线性回归中的 y 变量，如分类问题中图片中是猫是狗（或图片中狗的种类）、房子未来的价格、音频中的单词等等任何事物，都属于Label。（如一组图片，已经表明了哪些是狗，哪些是猫，这里Label就是分类问题中每一个类）图片 2.特征 Feature 特征是事物固有属性，可理解为做出某个判断的依据，如人的特征有长相、衣服、行为动作等等，一个事物可以有N多特征，这些组成了事物的特性，作为机器学习中识别、学习的基本依据。图片特征是机器学习模型的输入变量。如线性回归中的 x 变量。图片例如在垃圾邮件分类问题中，特征可能包括：电子邮件中是否包含 “ 广告、贷款、交易” 等短语电子邮件文本中的字词发件人的地址发送电子邮件的时段其中机器学习重要步骤：特征提取就是通过多种方式，对数据的特征数据进行提取。一般，特征数据越多，训练的机器学习模型就会越精确，但处理难度也越大。 3.样本 Example 样本是指一组或几组数据，样本一般作为训练数据来训练模型样本分为以下两类：有标签样本无标签样本 3.1有标签样本(labeled): 同时包含特征和标签图片在监督学习中利用数据做训练时，有标签数据/样本（Labeled data）或叫有/无标记数据，就是指有没有将数据归为要预测的类别。例如以下房价数据集：图片其中包含特征：卧室数量等，最右边一列是标签：房价中间值（注，因为该问题要预测未来房价走势，所以Label就是某条房屋数据中的房价） 3.2无标签样本(unlabeled)：包含特征，但不包含标签如以下数据集：去掉了Label，但是一样有用（如用在测试训练后的模型，即训练好模型后，输入该数据，那到预测后的房价与原标签进行比较，得到模型误差）图片 4.模型 Model 模型定义了特征与标签之间的关系，就是我们机器学习的一组数据关系表示，也是我们学习机器学习的核心例如，垃圾邮件检测模型可能会将某些特征与“垃圾邮件”紧密联系起来。模型生命周期的两个重要阶段：训练 Training是指创建或学习模型。也就是说，向模型展示有标签样本，让模型逐渐学习特征与标签之间的关系。训练模型表示通过有标签样本来学习（确定）所有权重和偏差的理想值推断 Inference是指将训练后的模型应用于无标签样本。也就是说，使用经过训练的模型做出有用的预测 (y’)。例如，模型训练好后，就可以使用模型进行Inference ，可以针对新的无标签样本预测房价medianHouseValue。图片 5.回归 Regression 回归就是我们数学学习的线性方程，是一种经典函数逼近算法。在机器学习中，就是根据数据集，建立一个线性方程组，能够无线逼近数据集中的数据点，是一种基于已有数据关系实现预测的算法。回归模型可预测连续值（线性）例如，回归模型做出的预测可回答如下问题：某小区房价的趋势？用户点击此广告的概率是多少？图片当机器学习模型最终目标（模型输出）是求一个具体数值时，例如房价的模型输出为25000，则大多数可以通过回归问题来解决。线性回归的好处在与模型简单，计算速度快，方便应用在分布式系统对大数据进行处理。线性回归还有个姐妹：逻辑回归（Logistic Regression），主要应用在分类领域 6.分类 Classification 顾名思义，分类模型可用来预测离散值例如，分类模型做出的预测可回答如下问题：是/否问题，某个指定电子邮件是垃圾邮件还是非垃圾邮件？图片是动物还是人？垃圾分类图片当机器学习模型最终目标（模型输出）是布尔或一定范围的数时，例如判断一张图片是不是人，模型输出0/1：0不是，1是；又例如垃圾分类，模型输出1-10之间的整数，1代表生活垃圾，2代表厨余垃圾。。等等，这类需求则大多数可以通过分类问题来解决。 7.机器学习算法地图机器学习算法多种多样，许多情况下，建模和算法设计是Designer所选择的，具体采用哪种算法也没有一定要求，根据实际具体问题具体分析。图片

机器学习 # 机器学习

刘航宇 3年前
0 1,275 2
2023-11-01
机器学习/深度学习-10个激活函数详解摘要本文详细介绍了深度学习中常见的十种激活函数，包括Sigmoid、Tanh、ReLU、Leaky ReLU、ELU、PReLU、Softmax、Swish、Maxout和Softplus，并分析了它们的优缺点。关键词：机器学习, 深度学习, 激活函数, Sigmoid, ReLU图片综述 1. Sigmoid 激活函数 2. Tanh / 双曲正切激活函数 3. ReLU 激活函数 4. Leaky ReLU 5. ELU 6. PReLU（Parametric ReLU） 7. Softmax 8. Swish 9. Maxout 10. Softplus 综述激活函数（Activation Function）是一种添加到人工神经网络中的函数，旨在帮助网络学习数据中的复杂模式。类似于人类大脑中基于神经元的模型，激活函数最终决定了要发射给下一个神经元的内容。在人工神经网络中，一个节点的激活函数定义了该节点在给定的输入或输入集合下的输出。标准的计算机芯片电路可以看作是根据输入得到开（1）或关（0）输出的数字电路激活函数。因此，激活函数是确定神经网络输出的数学方程式，本文概述了深度学习中常见的十种激活函数及其优缺点。首先我们来了解一下人工神经元的工作原理，大致如下：图片上述过程的数学可视化过程如下图所示：图片 1. Sigmoid 激活函数 lofj8ajx.png图片 Sigmoid 函数的图像看起来像一个 S 形曲线。函数表达式如下： $$\[\mathrm{f(z)=1/(1+e^{\wedge}-z)}\]$$ 在什么情况下适合使用 Sigmoid 激活函数呢？ Sigmoid 函数的输出范围是 0 到 1。由于输出值限定在 0 到 1，因此它对每个神经元的输出进行了归一化；用于将预测概率作为输出的模型。由于概率的取值范围是 0 到 1，因此 Sigmoid 函数非常合适；梯度平滑，避免「跳跃」的输出值；函数是可微的。这意味着可以找到任意两个点的 sigmoid 曲线的斜率；明确的预测，即非常接近 1 或 0。 Sigmoid 激活函数有哪些缺点？倾向于梯度消失；函数输出不是以 0 为中心的，这会降低权重更新的效率； Sigmoid 函数执行指数运算，计算机运行得较慢。 2. Tanh / 双曲正切激活函数图片 tanh 激活函数的图像也是 S 形，表达式如下： $$f(x)=tanh(x)=\frac{2}{1+e^{-2x}}-1$$ tanh 是一个双曲正切函数。tanh 函数和 sigmoid 函数的曲线相对相似。但是它比 sigmoid 函数更有一些优势。图片首先，当输入较大或较小时，输出几乎是平滑的并且梯度较小，这不利于权重更新。二者的区别在于输出间隔，tanh 的输出间隔为 1，并且整个函数以 0 为中心，比 sigmoid 函数更好；在 tanh 图中，负输入将被强映射为负，而零输入被映射为接近零。注意：在一般的二元分类问题中，tanh 函数用于隐藏层，而 sigmoid 函数用于输出层，但这并不是固定的，需要根据特定问题进行调整。 3. ReLU 激活函数图片 ReLU 激活函数图像如上图所示，函数表达式如下：图片 ReLU 函数是深度学习中较为流行的一种激活函数，相比于 sigmoid 函数和 tanh 函数，它具有如下优点：当输入为正时，不存在梯度饱和问题。计算速度快得多。ReLU 函数中只存在线性关系，因此它的计算速度比 sigmoid 和 tanh 更快当然，它也有缺点： Dead ReLU 问题。当输入为负时，ReLU 完全失效，在正向传播过程中，这不是问题。有些区域很敏感，有些则不敏感。但是在反向传播过程中，如果输入负数，则梯度将完全为零，sigmoid 函数和 tanh 函数也具有相同的问题；我们发现 ReLU 函数的输出为 0 或正数，这意味着 ReLU 函数不是以 0 为中心的函数。 4. Leaky ReLU 它是一种专门设计用于解决 Dead ReLU 问题的激活函数：图片 ReLU vs Leaky ReLU 为什么 Leaky ReLU 比 ReLU 更好？ $$f(y_i)=\begin{cases}y_i,&\text{if }y_i>0\\a_iy_i,&\text{if }y_i\leq0\end{cases}.$$ 1、Leaky ReLU 通过把 x 的非常小的线性分量给予负输入（0.01x）来调整负值的零梯度（zero gradients）问题； 2、leak 有助于扩大 ReLU 函数的范围，通常 a 的值为 0.01 左右； 3、Leaky ReLU 的函数范围是（负无穷到正无穷）。注意：从理论上讲，Leaky ReLU 具有 ReLU 的所有优点，而且 Dead ReLU 不会有任何问题，但在实际操作中，尚未完全证明 Leaky ReLU 总是比 ReLU 更好。 5. ELU 图片 ELU vs Leaky ReLU vs ReLU ELU 的提出也解决了 ReLU 的问题。与 ReLU 相比，ELU 有负值，这会使激活的平均值接近零。均值激活接近于零可以使学习更快，因为它们使梯度更接近自然梯度。图片显然，ELU 具有 ReLU 的所有优点，并且：没有 Dead ReLU 问题，输出的平均值接近 0，以 0 为中心； ELU 通过减少偏置偏移的影响，使正常梯度更接近于单位自然梯度，从而使均值向零加速学习； ELU 在较小的输入下会饱和至负值，从而减少前向传播的变异和信息。一个小问题是它的计算强度更高。与 Leaky ReLU 类似，尽管理论上比 ReLU 要好，但目前在实践中没有充分的证据表明 ELU 总是比 ReLU 好。 6. PReLU（Parametric ReLU）图片 PReLU 也是 ReLU 的改进版本： $$f(y_i)=\begin{cases}y_i,&\text{if }y_i>0\\a_iy_i,&\text{if }y_i\leq0\end{cases}.$$ 看一下 PReLU 的公式：参数α通常为 0 到 1 之间的数字，并且通常相对较小。如果 a_i= 0，则 f 变为 ReLU 如果 a_i> 0，则 f 变为 leaky ReLU 如果 a_i 是可学习的参数，则 f 变为 PReLU PReLU 的优点如下：在负值域，PReLU 的斜率较小，这也可以避免 Dead ReLU 问题。与 ELU 相比，PReLU 在负值域是线性运算。尽管斜率很小，但不会趋于 0。 7. Softmax 图片 Softmax 是用于多类分类问题的激活函数，在多类分类问题中，超过两个类标签则需要类成员关系。对于长度为 K 的任意实向量，Softmax 可以将其压缩为长度为 K，值在（0，1）范围内，并且向量中元素的总和为 1 的实向量。图片 Softmax 与正常的 max 函数不同：max 函数仅输出最大值，但 Softmax 确保较小的值具有较小的概率，并且不会直接丢弃。我们可以认为它是 argmax 函数的概率版本或「soft」版本。 Softmax 函数的分母结合了原始输出值的所有因子，这意味着 Softmax 函数获得的各种概率彼此相关。 Softmax 激活函数的主要缺点是：在零点不可微；负输入的梯度为零，这意味着对于该区域的激活，权重不会在反向传播期间更新，因此会产生永不激活的死亡神经元。 8. Swish 图片函数表达式：y = x * sigmoid (x) Swish 的设计受到了 LSTM 和高速网络中 gating 的 sigmoid 函数使用的启发。我们使用相同的 gating 值来简化 gating 机制，这称为 self-gating。 self-gating 的优点在于它只需要简单的标量输入，而普通的 gating 则需要多个标量输入。这使得诸如 Swish 之类的 self-gated 激活函数能够轻松替换以单个标量为输入的激活函数（例如 ReLU），而无需更改隐藏容量或参数数量。 Swish 激活函数的主要优点如下：「无界性」有助于防止慢速训练期间，梯度逐渐接近 0 并导致饱和；（同时，有界性也是有优势的，因为有界激活函数可以具有很强的正则化，并且较大的负输入问题也能解决）；导数恒 > 0；平滑度在优化和泛化中起了重要作用。 9. Maxout 图片在 Maxout 层，激活函数是输入的最大值，因此只有 2 个 maxout 节点的多层感知机就可以拟合任意的凸函数。单个 Maxout 节点可以解释为对一个实值函数进行分段线性近似 (PWL) ，其中函数图上任意两点之间的线段位于图（凸函数）的上方。 $ReLU=\max\bigl(0,x\bigr),\mathrm{abs}\bigl(x\bigr)=\max\bigl(x,-x\bigr)$ Maxout 也可以对 d 维向量（V）实现：图片假设两个凸函数 h_1(x) 和 h_2(x)，由两个 Maxout 节点近似化，函数 g(x) 是连续的 PWL 函数。 $$g\bigl(x\bigr)=h_1\bigl(x\bigr)-h_2\bigl(x\bigr)$$ 因此，由两个 Maxout 节点组成的 Maxout 层可以很好地近似任何连续函数。图片 10. Softplus 图片 Softplus 函数：f（x）= ln（1 + exp x） Softplus 的导数为 f ′(x)=exp(x) / ( 1+exp⁡ x ) = 1/ (1 +exp(−x )) ，也称为 logistic / sigmoid 函数。 Softplus 函数类似于 ReLU 函数，但是相对较平滑，像 ReLU 一样是单侧抑制。它的接受范围很广：(0, + inf)。

机器学习 # 机器学习 # 软件算法 # DL/ML

刘航宇 3年前
0 697 0
Python-BP神经网络实现单特征多分类摘要本文使用Python和BP神经网络对同半径的圆进行多分类（3分类），通过生成圆的坐标，计算半径作为输入，构建神经网络模型，并使用训练数据和测试数据进行训练和测试，最终实现了对圆的分类。关键词：Python, BP神经网络, 单特征多分类, 圆半径分类, 神经网络实现不同于图像处理，神经网络在处理其他不少领域，常常需要单特征分类，本例实现同半径的圆进行多分类（3分类），特征即为圆的半径。输入层12节点，一个6节点的隐藏层，输出层3个节点。 1.目标 2.开发环境 3.准备数据 4.处理数据 5.构建BP神经网络总结 1.目标通过BP算法实现对不同半径的圆的分类。 2.开发环境 Python3.10;jupyter notebook 3.准备数据目的：生成3类圆在第一象限内的坐标（圆心都是原点）第1类：半径范围为1~10，分类标识为‘0’ 第2类：半径范围为10~20，分类标识为‘1’ 第3类：半径范围为20~30，分类标识为‘2’ 代码如下：data_generate.py import numpy as np import math import random import csv # 只生成第一象限内的坐标即可。每个圆生成12个坐标(x,y)，相当于12个特征维度 def generate_circle(lower, upper): # 圆在第一象限内的坐标 data_ur = np.zeros(shape=(12, 2)) # 在上下限范围内，随机产生一个值作为半径 radius = random.randint(int(lower), int(upper)) # 在0~90度内，每隔7.5度取一次坐标，正好取12次 angles = np.arange(0, 0.5 * np.pi, 1 / 24 * np.pi) for i in range(12): temp_ur = np.zeros(2) x = round(radius * math.cos(angles[i]), 2) y = round(radius * math.sin(angles[i]), 2) temp_ur[0] = x temp_ur[1] = y data_ur[i] = temp_ur return data_ur, label # 将坐标保存到CSV文件中 def save2csv(data, batch, label): out = open("D:\\circles.csv", 'a', newline='') csv_write = csv.writer(out, dialect='excel') length = int(data.size / 2) for i in range(length): string = str(data[i][0]) + ',' + str(data[i][1]) + ',' + str(batch) + ',' + str(label) temp = string.split(',') csv_write.writerow(temp) out.close() if __name__ == "__main__": ''' 生成3类圆，标签（label）分别为：0、1、2 第1类圆的半径下限为1，上限为10 第2类圆的半径下限为10，上限为20 第3类圆的半径下限为20，上限为30 圆心都为原点 ''' lower = [1, 10, 20] # 半径随机值的下限 upper = [10, 20, 30] # 半径随机值的上限 label = ['0', '1', '2'] # 种类的标签 for i in range(len(label)): # 每类数据生成50组 for j in range(50): data, label = generate_circle(lower[i], upper[i]) batch = 50 * i + j + 1 # 数据的批次，用来区分每个坐标是属于哪个圆的 save2csv(data, batch, label[i])共3类圆，每类生成50个圆，每个圆有12个坐标，因此在输出文件D:\circles.csv中总共有3×50×12=1800行数据：图片通过生成的坐标绘制散点图如下：图片图中蓝色的点是label为0的圆，绿色的点是label为1的圆，红色的点是label为2的圆。 4.处理数据目标：根据第3步获得的坐标，计算每个圆的半径（勾股定理）作为神经网络的输入。代码如下：data_process.py import csv import math def process(file_name): # 要读取的CSV文件 csv_file = csv.reader(open(file_name, encoding='utf-8')) # 要生成的CSV文件 out_file = open("D:\\circles_data.csv", 'a', newline='') csv_write = csv.writer(out_file, dialect='excel') # 将csv_file每一行的圆坐标取出，如果是同一批次的（同一个圆），则写入到out_file的一行中 rows = [row for row in csv_file] current_batch = 'unknown' current_label = 'unknown' data_list = [] for r in rows: # 将无关字符都替换为空格 temp_string = str(r).replace('[', '').replace(']', '').replace('\'', '') # 将字符串以逗号分隔 item = str(temp_string).split(',') # 分别取出x轴坐标、y轴坐标、批次、标签 x = float(item[0]) y = float(item[1]) batch = item[2] label = item[3] # 如果是同一批次（同一个圆），则都放入data_list中 if current_batch == batch: # 根据勾股定理计算半径 distance = math.sqrt(pow(x, 2) + pow(y, 2)) data_list.append(distance) # 如果不是同一批次（同一个圆），则在末尾加上标签后，作为一行写入输出文件 else: if len(data_list) != 0: # 这个地方需注意一下，最后的标签用3列来表示，而不是一列 if label.strip() == '0': data_list.append(1) data_list.append(0) data_list.append(0) elif label.strip() == '1': data_list.append(0) data_list.append(1) data_list.append(0) else: data_list.append(0) data_list.append(0) data_list.append(1) result_string = str(data_list).replace('[', '').replace(']', '').replace('\'', '').strip() csv_write.writerow(result_string.split(',')) # 清空data_list，继续写入下一个批次 data_list.clear() distance = math.sqrt(pow(x, 2) + pow(y, 2)) data_list.append(distance) current_batch = batch current_label = label # 确保最后一个批次的数据能写入 if current_label.strip() == '0': data_list.append(1) data_list.append(0) data_list.append(0) elif current_label.strip() == '1': data_list.append(0) data_list.append(1) data_list.append(0) else: data_list.append(0) data_list.append(0) data_list.append(1) result_string = str(data_list).replace('[', '').replace(']', '').replace('\'', '').strip() csv_write.writerow(result_string.split(',')) # 关闭输出文件 out_file.close() if __name__ == "__main__": process('D:\\circles.csv')需要注意的是，生成的CSV文件共有15列，前12列为坐标对应的半径值，最后三列组合起来表示分类（label）：图片 (1,0,0)表示类型为“0”的圆，(0,1,0)表示类型为“1”的圆，(0,0,1)表示类型为“2”的圆，这样做的目的是为了下一步使用神经网络时处理起来方便。 5.构建BP神经网络上一步处理好的数据可以作为训练数据，命名为：circles_data_training.csv 重复第3步和第4步，可以生成另一批数据作为测试数据，命名为：circles_data_test.csv 当然，也可以手动划分出训练数据和测试数据。训练数据和测试数据在输入时，做了矩阵的转置，将列转置为行。代码如下：data_analysis_bpnn.py import pandas as pd import numpy as np import datetime from sklearn.utils import shuffle # 1.初始化参数 def initialize_parameters(n_x, n_h, n_y): np.random.seed(2) # 权重和偏置矩阵 w1 = np.random.randn(n_h, n_x) * 0.01 b1 = np.zeros(shape=(n_h, 1)) w2 = np.random.randn(n_y, n_h) * 0.01 b2 = np.zeros(shape=(n_y, 1)) # 通过字典存储参数 parameters = {'w1': w1, 'b1': b1, 'w2': w2, 'b2': b2} return parameters # 2.前向传播 def forward_propagation(X, parameters): w1 = parameters['w1'] b1 = parameters['b1'] w2 = parameters['w2'] b2 = parameters['b2'] # 通过前向传播来计算a2 z1 = np.dot(w1, X) + b1 # 这个地方需注意矩阵加法：虽然(w1*X)和b1的维度不同，但可以相加 a1 = np.tanh(z1) # 使用tanh作为第一层的激活函数 z2 = np.dot(w2, a1) + b2 a2 = 1 / (1 + np.exp(-z2)) # 使用sigmoid作为第二层的激活函数 # 通过字典存储参数 cache = {'z1': z1, 'a1': a1, 'z2': z2, 'a2': a2} return a2, cache # 3.计算代价函数 def compute_cost(a2, Y, parameters): m = Y.shape[1] # Y的列数即为总的样本数 # 采用交叉熵（cross-entropy）作为代价函数 logprobs = np.multiply(np.log(a2), Y) + np.multiply((1 - Y), np.log(1 - a2)) cost = - np.sum(logprobs) / m return cost # 4.反向传播（计算代价函数的导数） def backward_propagation(parameters, cache, X, Y): m = Y.shape[1] w2 = parameters['w2'] a1 = cache['a1'] a2 = cache['a2'] # 反向传播，计算dw1、db1、dw2、db2 dz2 = a2 - Y dw2 = (1 / m) * np.dot(dz2, a1.T) db2 = (1 / m) * np.sum(dz2, axis=1, keepdims=True) dz1 = np.multiply(np.dot(w2.T, dz2), 1 - np.power(a1, 2)) dw1 = (1 / m) * np.dot(dz1, X.T) db1 = (1 / m) * np.sum(dz1, axis=1, keepdims=True) grads = {'dw1': dw1, 'db1': db1, 'dw2': dw2, 'db2': db2} return grads # 5.更新参数 def update_parameters(parameters, grads, learning_rate=0.0075): w1 = parameters['w1'] b1 = parameters['b1'] w2 = parameters['w2'] b2 = parameters['b2'] dw1 = grads['dw1'] db1 = grads['db1'] dw2 = grads['dw2'] db2 = grads['db2'] # 更新参数 w1 = w1 - dw1 * learning_rate b1 = b1 - db1 * learning_rate w2 = w2 - dw2 * learning_rate b2 = b2 - db2 * learning_rate parameters = {'w1': w1, 'b1': b1, 'w2': w2, 'b2': b2} return parameters # 建立神经网络 def nn_model(X, Y, n_h, n_input, n_output, num_iterations=10000, print_cost=False): np.random.seed(3) n_x = n_input # 输入层节点数 n_y = n_output # 输出层节点数 # 1.初始化参数 parameters = initialize_parameters(n_x, n_h, n_y) # 梯度下降循环 for i in range(0, num_iterations): # 2.前向传播 a2, cache = forward_propagation(X, parameters) # 3.计算代价函数 cost = compute_cost(a2, Y, parameters) # 4.反向传播 grads = backward_propagation(parameters, cache, X, Y) # 5.更新参数 parameters = update_parameters(parameters, grads) # 每1000次迭代，输出一次代价函数 if print_cost and i % 1000 == 0: print('迭代第%i次，代价函数为：%f' % (i, cost)) return parameters # 对模型进行测试 def predict(parameters, x_test, y_test): w1 = parameters['w1'] b1 = parameters['b1'] w2 = parameters['w2'] b2 = parameters['b2'] z1 = np.dot(w1, x_test) + b1 a1 = np.tanh(z1) z2 = np.dot(w2, a1) + b2 a2 = 1 / (1 + np.exp(-z2)) # 结果的维度 n_rows = y_test.shape[0] n_cols = y_test.shape[1] # 预测值结果存储 output = np.empty(shape=(n_rows, n_cols), dtype=int) # 取出每条测试数据的预测结果 for i in range(n_cols): # 将每条测试数据的预测结果（概率）存为一个行向量 temp = np.zeros(shape=n_rows) for j in range(n_rows): temp[j] = a2[j][i] # 将每条结果（概率）从小到大排序，并获得相应下标 sorted_dist = np.argsort(temp) length = len(sorted_dist) # 将概率最大的置为1，其它置为0 for k in range(length): if k == sorted_dist[length - 1]: output[k][i] = 1 else: output[k][i] = 0 print('预测结果：') print(output) print('真实结果：') print(y_test) count = 0 for k in range(0, n_cols): if output[0][k] == y_test[0][k] and output[1][k] == y_test[1][k] and output[2][k] == y_test[2][k]: count = count + 1 acc = count / int(y_test.shape[1]) * 100 print('准确率：%.2f%%' % acc) if __name__ == "__main__": # 读取数据 data_set = pd.read_csv('D:\\circles_data_training.csv', header=None) data_set = shuffle(data_set) # 打乱数据的输入顺序 # 取出“特征”和“标签”，并做了转置，将列转置为行 X = data_set.ix[:, 0:11].values.T # 前12列是特征 Y = data_set.ix[:, 12:14].values.T # 后3列是标签 Y = Y.astype('uint8') # 开始训练 start_time = datetime.datetime.now() # 输入12个节点，隐层6个节点，输出3个节点，迭代10000次 parameters = nn_model(X, Y, n_h=6, n_input=12, n_output=3, num_iterations=10000, print_cost=True) end_time = datetime.datetime.now() print("用时：" + str((end_time - start_time).seconds) + 's' + str(round((end_time - start_time).microseconds / 1000)) + 'ms') # 对模型进行测试 data_test = pd.read_csv('D:\\circles_data_test.csv', header=None) x_test = data_test.ix[:, 0:11].values.T y_test = data_test.ix[:, 12:14].values.T y_test = y_test.astype('uint8') predict(parameters, x_test, y_test)码中需要注意的几个关键参数： learning_rate=0.0075，学习率（可调） n_h=6，隐藏层节点数（可调） n_input=12，输入层节点数 n_output=3，输出层节点数 num_iterations=10000，迭代次数（可调）另外，对于predict(parameters, x_test, y_test)函数需要说明一下： a2矩阵是最终的预测结果，但是是以概率的形式表示的（可以打印看一下）。通过比较3个类的概率，选出概率最大的那个置为1，其它两个置为0，形成output矩阵。运行结果：图片上图中第一红框表示神经网络预测出的分类结果，第二个红框表示测试集中真实的分类（(1,0,0)表示这个圆属于类型“0”）。每次运行时，正确率可能不一样，最高能达到100%。通过调整刚才提到的关键参数中的学习率、隐藏层节点数、迭代次数可以提高正确率。总结神经网络的输入为12个半径值，输出结果为一个3维向量，其中置1的位就是对应的分类。在实际应用中，12个半径值对应12个特征，3维向量表示能分3类。只要根据实际应用的需要修改特征数和分类数即可将上述程序应用于不同分类场景。

机器学习 # 机器学习

刘航宇 3年前
0 498 1
2023-10-15
DL-神经网络的正向传播与反向传播摘要本文介绍了神经网络的基本概念，包括前向传播和反向传播。前向传播从输入层开始，通过隐层计算输出；反向传播则根据损失函数计算参数的梯度，以更新网络参数。同时，文章还讨论了深层神经网络和单个神经元的工作原理。关键词：神经网络, 正向传播, 反向传播, 激活函数, 梯度下降神经网络简述前向传播反向传播四、深层神经网络（Deep Neural Network） 1.单个神经元 2.由神经元组成的神经网络 3.目标函数 4.求解损失函数对某个权值的梯度 5.反向传播算法Backpropgation 5.2 计算一个梯度 5.3 反向传播误差 6.优化示例神经网络简述神经网络，就是在Logistic regression的基础上增加了一个或几个隐层（hidden layer），下面展示的是一个最最最简单的神经网络，只有两层：两层神经网络图片需要注意的是，上面的图是“两层”，而不是三层或者四层，输入和输出不算层! 这里，我们先规定一下记号（Notation）： z是x和w、b线性运算的结果，z=wx+b； a是z的激活值；下标的1,2,3,4代表该层的第i个神经元（unit）；上标的[1],[2]等代表当前是第几层。 y^代表模型的输出，y才是真实值，也就是标签另外，有一点经常搞混：上图中的x1，x2，x3，x4不是代表4个样本！而是一个样本的四个特征（4个维度的值）！你如果有m个样本，代表要把上图的过程重复m次：图片神经网络的“两个传播”：前向传播（Forward Propagation）前向传播就是从input，经过一层层的layer，不断计算每一层的z和a，最后得到输出y^ 的过程，计算出了y^，就可以根据它和真实值y的差别来计算损失（loss）。反向传播（Backward Propagation）反向传播就是根据损失函数L(y^,y)来反方向地计算每一层的z、a、w、b的偏导数（梯度），从而更新参数。前向传播和反向传播：图片每经过一次前向传播和反向传播之后，参数就更新一次，然后用新的参数再次循环上面的过程。这就是神经网络训练的整个过程。前向传播如果用for循环一个样本一个样本的计算，显然太慢，是使用Vectorization，把m个样本压缩成一个向量X来计算，同样的把z、a都进行向量化处理得到Z、A，这样就可以对m的样本同时进行表示和计算了。不熟悉的朋友可以看这里：这样，我们用公式在表示一下我们的两层神经网络的前向传播过程： Layer 1:Z[1] = W[1]·X + b[1]A[1] = σ(Z[1]) Layer 2:Z[2] = W[2]·A[1] + b[2]A[2] = σ(Z[2]) 而我们知道，X其实就是A[0]，所以不难看出:每一层的计算都是一样的： Layer i:Z[i] = W[i]·A[i-1] + b[i]A[i] = σ(Z[i]) （注：σ是sigmoid函数）因此，其实不管我们神经网络有几层，都是将上面过程的重复。对于损失函数，就跟Logistic regression中的一样，使用 “交叉熵（cross-entropy）”，公式就是二分类问题：L(y^,y) = -[y·log(y^ )+(1-y)·log(1-y^ )]- 多分类问题：L=-Σy(j)·y^(j) 这个是每个样本的loss，我们一般还要计算整个样本集的loss，也称为cost，用J表示，J就是L的平均： J(W,b) = 1/m·ΣL(y^(i),y(i)) 上面的求Z、A、L、J的过程就是正向传播。反向传播反向传播说白了根据根据J的公式对W和b求偏导，也就是求梯度。因为我们需要用梯度下降法来对参数进行更新，而更新就需要梯度。但是，根据求偏导的链式法则我们知道，第l层的参数的梯度，需要通过l+1层的梯度来求得，因此我们求导的过程是“反向”的，这也就是为什么叫“反向传播”。具体求导的过程，这里就不赘述了。像各种深度学习框架TensorFlow、Keras，它们都是只需要我们自己构建正向传播过程，反向传播的过程是自动完成的，所以大家也确实不用操这个心。进行了反向传播之后，我们就可以根据每一层的参数的梯度来更新参数了，更新了之后，重复正向、反向传播的过程，就可以不断训练学习更好的参数了。四、深层神经网络（Deep Neural Network）前面的讲解都是拿一个两层的很浅的神经网络为例的。深层神经网络也没什么神秘，就是多了几个/几十个/上百个hidden layers罢了。可以用一个简单的示意图表示：深层神经网络: 图片注意，在深层神经网络中，我们在中间层使用了 “ReLU”激活函数，而不是sigmoid函数了，只有在最后的输出层才使用了sigmoid函数，这是因为 ReLU函数在求梯度的时候更快，还可以一定程度上防止梯度消失现象，因此在深层的网络中常常采用。关于深层神经网络，我们有必要再详细的观察一下它的结构，尤其是每一层的各个变量的维度，毕竟我们在搭建模型的时候，维度至关重要。图片我们设: 总共有m个样本，问题为二分类问题（即y为0,1）；网络总共有L层，当前层为l层（l=1,2,...,L）；第l层的单元数为n[l]；那么下面参数或变量的维度为： W[l]:(n[l],n[l-1])（该层的单元数，上层的单元数） b[l]:(n[l],1) z[l]:(n[l],1) Z[l]:(n[l],m) a[l]:(n[l],1) A[l]:(n[l],m) X:(n[0],m) Y:(1,m) 可能有人问，为什么 W和b的维度里面没有m？因为 W和b对每个样本都是一样的，所有样本采用同一套参数（W，b），而Z和A就不一样了，虽然计算时的参数一样，但是样本不一样的话，计算结果也不一样，所以维度中有m。深度神经网络的正向传播、反向传播和前面写的2层的神经网络类似，就是多了几层，然后中间的激活函数由sigmoid变为ReLU了。 1.单个神经元神经网络是由一系列神经元组成的模型，每一个神经元实际上做得事情就是实现非线性变换。如下图就是一个神经元的结构：图片神经元将两个部分：上一层的输出(x1,x2,....,xn)与权重(w1,w2,....,wn),对应相乘相加，然后再加上一个偏置 b之后的值经过激活函数处理后完成非线性变换。记 z = w ⋅ x + b ,a=σ(z)，则 z 是神经元非线性变换之前的结果，这部分仅仅是一个简单的线性函数。σ 是Sigmod激活函数，该函数可以将无穷区间内的数映射到(-1,1)的范围内。a 是神经元将 z z 进行非线性变换之后的结果。 Sigmod函数图像如下图 $$\mathrm{sigmod(x)=\frac{1}{1+e^{-x}}}$$ 图片因此，结果 a 就等于：图片这里再强调一遍，神经元的本质就是做非线性变换 2.由神经元组成的神经网络神经元可以理解成一个函数，神经网络就是由很多个非线性变换的神经元组成的模型，因此神经网络可以理解成是一个非常复杂的复合函数。图片对于上图中的网络： (x1,x2,....,xn)为n维输入向量 Wij,表示后一层低i个神经元与前一层第j个神经元之间的权值 z = Wx + b是没有经过激活函数非线性变换之前的结果 a=σ(z)，是 z 经过激活函数非线性变换之后的结果 \mathrm{s=U^Ta}，为网络最终的输出结果。 3.目标函数以折页损失为目标函数： $$\mathrm{minmizeJ}=\max(\Delta+s_{c}-s,0)$$ 其中$\mathrm{s_c=U^T\sigma(Wx_c+b),s=U^T\sigma(Wx+b)}$。一般可以把$\Delta$固定下来,比如设为1或者10。一般来说，学习算法的学习过程就是优化调整参数，使得损失函数，或者说预测结果和实际结果的误差减小。BP算法其实是一个双向算法，包含两个步骤： 1.正向传递输入信息，得到 Loss 值。 2.反向传播误差，从而由优化算法来调整网络权值。 4.求解损失函数对某个权值的梯度图片其中$\mathrm{s_c=U^T\sigma(Wx_c+b),s=U^T\sigma(Wx+b)}$。一般可以把$\Delta$固定下来,比如设为1或者10。对于上面的图, 假设图中指示出的网络中的某个权值 w$_\mathrm{jk}^\mathrm{l}$ 发生了一个小的改变 $\Delta w_\mathrm{jk}^\mathrm{l}$ , 假设网络最终损失函数的输出为$\mathbb{C}$,则 C 应该是关于 $\mathrm{w}_\mathrm{jk}^{\mathrm{l}}$ 的一个复合函数。所谓复合函数,就是把 $\mathbb{C}$ 看成因变量,则$\mathrm{w}_\mathrm{jk}^{\mathrm{l}}$ 可以看成导致 C 改变的自变量, 比如假设有一个复合函数 $\mathrm{y=f(g(x))}$,则 y 就好比这里的$\mathbb{C}$ , x 就好比$\mathrm{w}_{\mathrm{jk}}^{\mathrm{l}}$, w$_{jk}^{\mathrm{l}}$ 每经过一层网络可以看成是经过某个函数的处理。而下面求写的时候都用偏导数, 是因为虽然我们这里只关注了一个 w$_\mathrm{jk}^{\mathrm{l}}$,但是实际上网络中的每一个 w 都可以看成一个 x。显然,这个$\Delta w_\mathrm{jk}^\mathrm{l}$的变化会引起下一层直接与其相连的一个神经元,以及下一层之后所有神经元直到最终输出 C 的变化, 如图中蓝线标记的就是该权值变化的影响传播路径。把 C 的改变记为 $\Delta\mathbb{C}$, 则根据高等数学中导数的知识可以得到: 则神经元 a$_\mathrm{j}^1$ 下面一层第 q 个与其相连的神经元 a$_{\mathrm{q}}^{1+1}$ 的变化为: $$ \Delta\mathrm{a_q^{1+1}}\approx\frac{\partial\mathrm{a_q^{1+1}}}{\partial\mathrm{a_j^1}}\Delta\mathrm{a_j^1} $$将 $(2)$ 代入 (3) 可以得到: $$ \Delta\mathrm{a_{q}^{l+1}}\:\approx\:\frac{\partial\mathrm{a_{q}^{l+1}}}{\partial\mathrm{a_{j}^{l}}}\:\frac{\partial\mathrm{a_{j}^{l}}}{\partial\mathrm{w_{jk}^{l}}}\:\Delta\mathrm{w_{jk}^{l}} $$假设从 $\mathrm{a_j}^1$ 到 C的一条路径为$\mathrm{a_j}^1,\mathrm{a_q}^{1+1},...,\mathrm{a_n}^{\mathrm{L-1}},\mathrm{a_m}^{\mathrm{L}}$,则在该条路径上 C 的变化量 $\Delta C$ 为: $$\Delta\mathrm{C}\approx\frac{\partial\mathrm{C}}{\partial\mathrm{a}_\mathrm{m}^\mathrm{L}}\frac{\partial\mathrm{a}_\mathrm{m}^\mathrm{L}}{\partial\mathrm{a}_\mathrm{n}^\mathrm{L-1}}\frac{\partial\mathrm{a}_\mathrm{n}^\mathrm{L-1}}{\partial\mathrm{a}_\mathrm{p}^\mathrm{L-2}}[USD3P]\frac{\partial\mathrm{a}_\mathrm{q}^\mathrm{l+1}}{\partial\mathrm{a}_\mathrm{j}^\mathrm{l}}\frac{\partial\mathrm{a}_\mathrm{j}^\mathrm{l}}{\partial\mathrm{w}_\mathrm{jk}^\mathrm{l}}\Delta\mathrm{w}_\mathrm{jk}^\mathrm{l}$$ 至此,我们已经得到了一条路径上的变化量, 其实本质就是链式求导法则,或者说是复合函数求导法则。那么整个的变化量就县把所有可能链路上的变化量加起来: $$\Delta\mathrm{C}\approx\sum_{\mathrm{minp[USD3P]q}}\frac{\partial\mathrm{C}}{\partial\mathrm{a_{m}^{L}}}\frac{\partial\mathrm{a_{m}^{L}}}{\partial\mathrm{a_{n}^{L-1}}}\frac{\partial\mathrm{a_{n}^{L-1}}}{\partial\mathrm{a_{p}^{L-2}}}[USD3P]\frac{\partial\mathrm{a_{q}^{l+1}}}{\partial\mathrm{a_{j}^{l}}}\frac{\partial\mathrm{a_{j}^{l}}}{\partial\mathrm{w_{jk}^{l}}}\Delta\mathrm{w_{jk}^{l}}$$ $$\begin{aligned}\text{则 C 对某个权值 w}_{\mathrm{jk}}^{\dagger}&\text{的梯度为:}\\&\frac{\partial\mathrm{C}}{\partial\mathrm{w}_{\mathrm{jk}}^{\dagger}}\approx\sum_{\mathrm{nmp},

机器学习 # DL/ML

刘航宇 3年前
0 685 2
2023-07-23
Python机器学习- 鸢尾花分类摘要本文介绍了使用Python和sklearn库实现鸢尾花分类的机器学习项目。首先，通过train_and_predict函数使用高斯朴素贝叶斯分类器进行分类，然后通过transform_three2two_cate函数将数据集转化为二分类问题，并使用决策树分类器进行训练和评估，要求测试集准确率不小于0.95。关键词：Python, 机器学习, 鸢尾花分类, sklearn, 朴素贝叶斯1、描述 2、code 3、描述 4、code 1、描述请编写代码实现train_and_predict功能，实现能够根据四个特征对三种类型的鸢尾花进行分类。 train_and_predict函数接收三个参数: train_input_features—二维NumPy数组，其中每个元素都是一个数组，它包含:萼片长度、萼片宽度、花瓣长度和花瓣宽度。 train_outputs—一维NumPy数组，其中每个元素都是一个数字，表示在train_input_features的同一行中描述的鸢尾花种类。0表示鸢尾setosa，1表示versicolor，2代表Iris virginica。 prediction_features—二维NumPy数组，其中每个元素都是一个数组，包含:萼片长度、萼片宽度、花瓣长度和花瓣宽度。该函数使用train_input_features作为输入数据，使用train_outputs作为预期结果来训练分类器。请使用训练过的分类器来预测prediction_features的标签，并将它们作为可迭代对象返回(如list或numpy.ndarray)。结果中的第n个位置是prediction_features参数的第n行。 2、code # 导入numpy库，用于处理多维数组 import numpy as np # 导入sklearn库中的数据集、模型选择、度量和朴素贝叶斯模块 from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn import metrics from sklearn.naive_bayes import GaussianNB # 定义train_and_predict函数，接收三个参数:训练输入特征、训练输出标签和预测输入特征 def train_and_predict(train_input_features, train_outputs, prediction_features): # 创建一个高斯朴素贝叶斯分类器对象 clf = GaussianNB() # 使用训练输入特征和训练输出标签来训练分类器 clf.fit(train_input_features, train_outputs) # 使用预测输入特征来预测输出标签，并将结果返回 y_pred = clf.predict(prediction_features) return y_pred # 加载鸢尾花数据集，包含150个样本，每个样本有四个特征和一个标签 iris = datasets.load_iris() # 将数据集随机分成训练集和测试集，其中训练集占70%，测试集占30%，并设置随机种子为0 X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, test_size=0.3, random_state=0 ) # 调用train_and_predict函数，使用训练集来训练分类器，并使用测试集来预测标签，将结果赋值给y_pred y_pred = train_and_predict(X_train, y_train, X_test) # 如果y_pred不为空，打印预测标签和真实标签的准确率，即正确预测的比例 if y_pred is not None: print(metrics.accuracy_score(y_test, y_pred))3、描述机器学习库 sklearn 自带鸢尾花分类数据集，分为四个特征和三个类别，其中这三个类别在数据集中分别表示为 0, 1 和 2，请实现 transform_three2two_cate 函数的功能，该函数是一个无参函数，要求将数据集中 label 为 2 的数据进行移除，也就是说仅保留 label 为 0 和为 1 的情况，并且对 label 为 0 和 1 的特征数据进行保留，返回值为 numpy.ndarray 格式的训练特征数据和 label 数据，分别为命名为 new_feat 和 new_label。然后在此基础上，实现 train_and_evaluate 功能，并使用生成的 new_feat 和 new_label 数据集进行二分类训练，限定机器学习分类器只能从逻辑回归和决策树中进行选择，将训练数据和测试数据按照 8:2 的比例进行分割。要求输出测试集上的 accuracy_score，同时要求 accuracy_score 要不小于 0.95。 4、code #导入numpy库，它是一个提供了多维数组和矩阵运算等功能的Python库 import numpy as np #导入sklearn库中的datasets模块，它提供了一些内置的数据集 from sklearn import datasets #导入sklearn库中的model_selection模块，它提供了一些用于模型选择和评估的工具，比如划分训练集和测试集 from sklearn.model_selection import train_test_split #导入sklearn库中的preprocessing模块，它提供了一些用于数据预处理的工具，比如归一化 from sklearn.preprocessing import MinMaxScaler #导入sklearn库中的linear_model模块，它提供了一些线性模型，比如逻辑回归 from sklearn.linear_model import LogisticRegression #导入sklearn库中的metrics模块，它提供了一些用于评估模型性能的指标，比如F1分数、ROC曲线面积、准确率等 from sklearn.metrics import f1_score,roc_auc_score,accuracy_score #导入sklearn库中的tree模块，它提供了一些树形模型，比如决策树 from sklearn.tree import DecisionTreeClassifier #定义一个函数transform_three2two_cate，它的作用是将鸢尾花数据集中的三分类问题转化为二分类问题 def transform_three2two_cate(): #从datasets模块中加载鸢尾花数据集，并赋值给data变量 data = datasets.load_iris() #其中data特征数据的key为data，标签数据的key为target #需要取出原来的特征数据和标签数据，移除标签为2的label和特征数据，返回值new_feat为numpy.ndarray格式特征数据，new_label为对应的numpy.ndarray格式label数据 #需要注意特征和标签的顺序一致性，否则数据集将混乱 #code start here #使用numpy库中的where函数找出标签为2的索引，并赋值给index_arr变量 index_arr = np.where(data.target == 2)[0] #使用numpy库中的delete函数删除特征数据中对应索引的行，并赋值给new_feat变量 new_feat = np.delete(data.data, index_arr, 0) #使用numpy库中的delete函数删除标签数据中对应索引的元素，并赋值给new_label变量 new_label = np.delete(data.target, index_arr) #code end here #返回新的特征数据和标签数据 return new_feat,new_label #定义一个函数train_and_evaluate，它的作用是用决策树分类器来训练和评估鸢尾花数据集 def train_and_evaluate(): #调用transform_three2two_cate函数，得到新的特征数据和标签数据，并赋值给data_X和data_Y变量 data_X,data_Y = transform_three2two_cate() #使用train_test_split函数，将数据集划分为训练集和测试集，其中测试集占20%，并赋值给train_x,test_x,train_y,test_y变量 train_x,test_x,train_y,test_y = train_test_split(data_X,data_Y,test_size = 0.2) #已经划分好训练集和测试集，接下来请实现对数据的训练 #code start here #创建一个决策树分类器的实例，并赋值给estimator变量 estimator = DecisionTreeClassifier() #使用fit方法，用训练集的特征和标签来训练决策树分类器 estimator.fit(train_x, train_y) #使用predict方法，用测试集的特征来预测标签，并赋值给y_predict变量 y_predict = estimator.predict(test_x) #code end here #注意模型预测的label需要定义为 y_predict，格式为list或numpy.ndarray #使用accuracy_score函数，计算测试集上的准确率分数，并打印出来 print(accuracy_score(y_predict,test_y)) #如果这个文件是作为主程序运行，则执行以下代码 if __name__ == "__main__": #调用train_and_evaluate函数 train_and_evaluate() #要求执行train_and_evaluate()后输出为： #1、{0,1}，代表数据label为0和1 #2、测试集上的准确率分数，要求>0.95

机器学习 # 机器学习 # Python

刘航宇 3年前
0 593 0
2023-05-29
Windows安装Jupyter Notebook及机器学习的库摘要本文介绍了在Windows上安装Jupyter Notebook及配置机器学习库的步骤，包括下载安装Jupyter Notebook、安装所需库、配置工作目录和可选的代码自动补全功能。关键词：Jupyter Notebook, Windows安装, 机器学习库, pip安装, Jupyter配置Jupyter Notebook安装（Windows）下载Jupyter Notebook （1）打开cmd（如果没有把Python安装目录添加到Path，需要切换到Python安装目录的Scripts目录下）；（2）输入pip install jupyter；（推荐在外网环境下安装） 2.库安装下载下面文件 requirements.txt 下载地址：https://wwek.lanzoub.com/iLI2S0xm6a3a 提取码：然后执行： pip3 install -r requirements.txt 启动Juypter Notebook （1）命令行窗口输入jupyter notebook；浏览器会打开Jupyter Notebook窗口，说明Jupyter Notebook安装成功。 (2) 配置Jupyter Notebook 1、行窗口输入jupyter notebook --generate-config，会发现C:\Users\用户名\ .jupyter下多出了一个配置文件jupyter_notebook_config.py； image.png图片 2、这个配置文件，找到下面这句#c.NotebookApp.notebook_dir = ''。可以把它修改成c.NotebookApp.notebook_dir = 'D:\jupyter-notebook'，当然具体的目录由自己创建的文件夹决定（需要自己创建）。配置文件修改完成后，以后在jupyter notebook中写的代码都会保存在该目录下。现在重新启动jupyter notebook，就进入了新的工作目录； 5.添加代码自动补全功能（可选）（1）打开cmd，输入pip install jupyter_contrib_nbextensions，等待安装成功；（2）安装完之后需要配置nbextension（配置前要确保已关闭jupyter notebook），在cmd中输入jupyter contrib nbextension install --user --skip-running-check，等待配置成功；（3）在前两步成功的情况下，启动jupyter notebook，会发现在选项栏中多出了Nbextension的选项，点开该选项，并勾选Hinterland，即可添加代码自动补全功能。 image.png图片

机器学习 # 机器学习

刘航宇 3年前
0 466 1
2023-05-15
机器学习代码实现:线性回归与岭回归摘要本文介绍了线性回归和岭回归的机器学习模型及其代码实现。首先阐述了线性回归模型的基本原理和损失函数，然后展示了如何通过正规方程直接求解参数。接着，详细介绍了线性回归的Python实现，包括fit、predict和loss方法。最后，介绍了岭回归模型，并展示了如何通过增加正则项来控制参数规模，以及如何通过Python代码实现岭回归。关键词：机器学习, 线性回归, 岭回归, 梯度下降, 正规方程1.线性回归模型线性回归模型是最简单的一种线性模型，模型的形式就是： $y=W^T x+b$ 我们可以通过对原本的输入向量x扩增一个为1的维度将参数W和b统一成一个参数W，即模型变成了 $y=W^T x$ 这里的W是原本两个参数合并之后的而其损失函数的形式是残差平方损失RSS $L=\frac{1}{2 m} \sum_{i=1}^m\left(W^T x_i-y_i\right)^2=\frac{1}{2 m}\left(W^T X-y\right)^T\left(W^T X-y\right)$ 我们很容易就可以通过求导得到线性回归模型的关于W的梯度 $\nabla_W L=\frac{1}{m} \sum_{i=1}^m\left(W^T x_i-y_i\right) x_i=\frac{1}{m} X^T\left(W^T X-y\right)$ 这样一来我们就可以通过梯度下降的方式来训练参数W，可以用下面的公式表示 $W:=W-\alpha \frac{1}{m} X^T\left(W^T X-y\right)$ 但实际上线性模型的参数W可以直接求解出，即： $W=\left(X^T X\right)^{-1} X^T y$ 2.线性回归的编程实现具体代码中的参数的形式可能和上面的公式推导略有区别，我们实现了一个LinearRegression的类，包含fit，predict和loss三个主要的方法，fit方法就是求解线性模型的过程，这里我们直接使用了正规方程来解 class LinearRegression: def fit(self, X: np.ndarray, y: np.ndarray) -> float: N, D = X.shape # 将每个样本的特征增加一个维度，用1表示，使得bias和weight可以一起计算 # 这里在输入的样本矩阵X末尾增加一列来给每个样本的特征向量增加一个维度 # 现在X变成了N*(D+1)维的矩阵了 expand_X = np.column_stack((X, np.ones((N, 1)))) self.w = np.matmul(np.matmul(np.linalg.inv(np.matmul(expand_X.T, expand_X)), expand_X.T), y) return self.loss(X, y)predict实际上就是将输入的矩阵X放到模型中进行计算得到对应的结果，loss给出了损失函数的计算方式： def loss(self, X: np.ndarray, y: np.ndarray): """ 线性回归模型使用的是RSS损失函数 :param X:需要预测的特征矩阵X，维度是N*D :param y:标签label :return: """ delta = y - self.predict(X) total_loss = np.sum(delta ** 2) / X.shape[0] return total_loss3.岭回归Ridge Regression与代码实现岭回归实际上就是一种使用了正则项的线性回归模型，也就是在损失函数上加上了正则项来控制参数的规模，即： $L=\frac{1}{2 m} \sum_{i=1}^m\left(W^T x_i-y_i\right)^2+\lambda\|W\|_2=\frac{1}{2 m}\left(W^T X-y\right)^T\left(W^T X-y\right)+\lambda W^T W$ 因此最终的模型的正规方程就变成了： $W=\left(X^T X+\lambda I\right)^{-1} X^T y$ 这里的\lambda是待定的正则项参数，可以根据情况选定，岭回归模型训练的具体代码如下 class RidgeRegression: def fit(self, X: np.ndarray, y: np.ndarray): N, D = X.shape I = np.identity(D + 1) I[D][D] = 0 expand_X = np.column_stack((X, np.ones((N, 1)))) self.W = np.matmul(np.matmul(np.linalg.inv(np.matmul(expand_X.T, expand_X) + self.reg * I), expand_X.T), y) return self.loss(X, y)4.数据集实验这里使用了随机生成的二位数据点来对线性模型进行测试，测试结果如下： image.png图片线性模型测试结果岭回归也使用同样的代码进行测试。

机器学习软硬件算法 # 机器学习 # 软件算法

刘航宇 3年前
0 382 1

317 文章数

574 评论量

关于作者：刘航宇，FPGA工程师，西北大学电子系硕士，有多年西北大学电子通信考研辅导和FPGA与嵌入式项目指导经验

人生倒计时

最新回复

Guest
2026-09-07

很好的插件。感谢！
guxin
2026-09-05

看看
YA.
2026-08-28

感谢分享，下载试试。