【Matlab】基于粒子群优化算法优化BP神经网络的数据分类预测

news2025/10/31 10:30:29

【Matlab】基于粒子群优化算法优化BP神经网络的数据分类预测（Excel可直接替换数据）

  • 1.模型原理
  • 2.数学公式
  • 3.文件结构
  • 4.Excel数据
  • 5.分块代码
    • 5.1 fun.m
    • 5.2 main.m
  • 6.完整代码
    • 6.1 fun.m
    • 6.2 main.m
  • 7.运行结果

1.模型原理

“基于粒子群优化算法优化BP神经网络的数据分类预测”是一种结合了粒子群优化算法（Particle Swarm Optimization, PSO）和BP神经网络进行数据分类预测任务的方法。PSO是一种全局优化算法，能够帮助BP神经网络更好地优化权重和偏置，从而提高分类预测性能。该方法通过优化BP神经网络的参数，使其能够更准确地将输入数据样本映射到相应的类别标签。

以下是“基于粒子群优化算法优化BP神经网络的数据分类预测”的原理：

  1. BP神经网络简介：
    BP神经网络是一种前向人工神经网络，由输入层、若干隐藏层和输出层组成。它通过前向传播计算输出，并通过反向传播算法来更新权重和偏置，以最小化预测值与真实值之间的误差。BP神经网络在数据分类预测问题中可以用于拟合非线性函数，并通过梯度下降法进行参数优化。

  2. 粒子群优化算法简介：
    PSO是一种群体智能优化算法，受到鸟群觅食行为的启发。在PSO中，个体被称为“粒子”，它们在搜索空间中移动，并通过学习社会最优和个体最优位置来更新自己的位置和速度。每个粒子维护两个向量：速度向量和位置向量，它们决定了粒子在搜索空间中的移动方向和距离。

  3. 基于粒子群优化的BP神经网络优化：
    在使用PSO优化BP神经网络时，我们将BP神经网络的权重和偏置作为待优化的参数。每个粒子表示一组可能的权重和偏置的取值，称为“粒子的位置”。PSO算法中的每个粒子都有一个适应度函数，用于评估其在数据分类预测任务中的表现。在这里，适应度函数可以是分类预测任务中的准确率或交叉熵损失函数。

  4. PSO算法流程：
    PSO算法的基本流程如下：

    • 初始化粒子群的位置和速度。
    • 计算每个粒子的适应度值（即BP神经网络在训练数据上的预测准确率或损失）。
    • 根据个体最优和全局最优位置更新粒子的速度和位置。
    • 重复上述步骤，直到满足停止条件（如达到最大迭代次数或达到预定的精度）。

  5. 优化过程：
    在优化过程中，每个粒子代表了一组BP神经网络的权重和偏置。它们根据自身的适应度和周围粒子的表现来更新自己的位置和速度，以寻找更优的权重和偏置组合。通过迭代优化，粒子逐渐趋向于全局最优解，从而找到了最优的BP神经网络权重和偏置组合，以提高数据分类预测的性能。

  6. 应用于数据分类预测：
    将PSO算法与BP神经网络结合应用于数据分类预测任务时，首先需要准备训练数据和测试数据。然后，利用PSO算法优化BP神经网络的权重和偏置，使其能够更好地拟合训练数据。最后，使用优化后的BP神经网络对测试数据进行预测，得到数据的分类结果。

通过以上的优化过程，基于粒子群优化算法优化BP神经网络的数据分类预测方法可以帮助BP神经网络更好地适应数据分类任务，提高预测准确率，并在实际应用中取得更好的分类性能。

2.数学公式

当然可以！在下面，我将详细介绍“基于粒子群优化算法优化BP神经网络的数据分类预测”的原理，并带上公式：

  1. BP神经网络部分：

假设我们有一个数据集 ( D D D)，其中包含 ( N N N) 个样本： D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D = \{(x_1, y_1), (x_2, y_2), ..., (x_N, y_N)\} D={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，其中 ( x i x_i xi​) 是第 ( i i i) 个样本的输入特征， ( y i y_i yi​) 是对应的标签。

在BP神经网络中，我们使用前向传播计算隐藏层和输出层的输出，然后使用反向传播算法来更新权重和偏置，以最小化预测值与真实值之间的误差。隐藏层和输出层的计算公式如下：

隐藏层的计算公式：
z h = W x h ⋅ x + b h z_h = W_{xh} \cdot x + b_h zh​=Wxh​⋅x+bh​
h = σ ( z h ) h = \sigma(z_h) h=σ(zh​)

输出层的计算公式：
z o = W h o ⋅ h + b o z_o = W_{ho} \cdot h + b_o zo​=Who​⋅h+bo​
y = σ ( z o ) y = \sigma(z_o) y=σ(zo​)

其中，

  • ( h h h) 是隐藏层的输出（隐藏状态），
  • ( y y y) 是输出层的输出（预测值），
  • ( W x h W_{xh} Wxh​) 是输入到隐藏层的权重矩阵，
  • ( W h o W_{ho} Who​) 是隐藏层到输出层的权重矩阵，
  • ( b h b_h bh​) 是隐藏层的偏置，
  • ( b o b_o bo​) 是输出层的偏置，
  • ( σ \sigma σ) 是激活函数（如sigmoid或tanh）。
  1. 粒子群优化算法部分：

在粒子群优化算法中，每个粒子代表一组可能的BP神经网络的权重和偏置，即一组解。这些粒子在搜索空间中移动，并通过学习社会最优和个体最优位置来更新自己的位置和速度。每个粒子维护两个向量：速度向量和位置向量，它们决定了粒子在搜索空间中的移动方向和距离。

假设第 ( i i i) 个粒子在当前时刻的位置向量为 ( x i x_i xi​)，速度向量为 ( v i v_i vi​)，个体最优位置为 ( p i p_{i} pi​)，全局最优位置为 ( p g p_{g} pg​)。

粒子更新的公式为：
v i ( t + 1 ) = ω ⋅ v i ( t ) + c 1 ⋅ r 1 ⋅ ( p i − x i ( t ) ) + c 2 ⋅ r 2 ⋅ ( p g − x i ( t ) ) v_{i}(t+1) = \omega \cdot v_{i}(t) + c_1 \cdot r_1 \cdot (p_{i} - x_{i}(t)) + c_2 \cdot r_2 \cdot (p_{g} - x_{i}(t)) vi​(t+1)=ω⋅vi​(t)+c1​⋅r1​⋅(pi​−xi​(t))+c2​⋅r2​⋅(pg​−xi​(t))
x i ( t + 1 ) = x i ( t ) + v i ( t + 1 ) x_{i}(t+1) = x_{i}(t) + v_{i}(t+1) xi​(t+1)=xi​(t)+vi​(t+1)

其中，

  • ( t t t) 是当前时刻，
  • ( ω \omega ω) 是惯性权重，控制粒子的惯性，
  • ( c 1 c_1 c1​) 和 ( c 2 c_2 c2​) 是学习因子，分别控制个体和全局的权重，
  • ( r 1 r_1 r1​) 和 ( r 2 r_2 r2​) 是随机数，用于增加随机性。

在每一次迭代中，通过计算每个粒子的适应度（即BP神经网络在训练数据上的预测准确率或损失），找到个体最优位置 ( p i p_{i} pi​) 和全局最优位置 ( p g p_{g} pg​)，并更新粒子的速度和位置，直到达到停止条件（如达到最大迭代次数或达到预定的精度）为止。

  1. 数据分类预测：

在完成粒子群优化过程后，每个粒子都代表了一组优化后的BP神经网络的权重和偏置。我们可以选择具有最佳适应度的粒子所代表的BP神经网络作为最终的分类器。

将新的输入数据样本 ( x new x_{\text{new}} xnew​) 输入该BP神经网络，通过前向传播计算输出的隐藏层和输出层的输出，得到预测值 ( y pred y_{\text{pred}} ypred​)。根据预测值 ( y pred y_{\text{pred}} ypred​) 和分类标签 ( y true y_{\text{true}} ytrue​)（来自测试数据集）的对比，我们可以计算分类的准确率或损失，用于评估优化后的BP神经网络在测试数据上的表现。

通过以上的BP神经网络运算、粒子群优化和数据分类预测过程，我们可以实现“基于粒子群优化算法优化BP神经网络的数据分类预测”。这种方法结合了全局优化算法PSO和BP神经网络，能够帮助BP神经网络更好地适应数据分类任务，提高分类准确率，并在实际应用中取得更好的分类性能。

3.文件结构

在这里插入图片描述

fun.m							% 适应度值函数
main.m							% 主函数
数据集.xlsx						% 可替换数据集

4.Excel数据

在这里插入图片描述

5.分块代码

5.1 fun.m

function error = fun(pop, hiddennum, net, p_train, t_train)

%% 节点个数

inputnum  = size(p_train, 1);  % 输入层节点数
outputnum = size(t_train, 1);  % 输出层节点数

%% 提取权值和阈值

w1 = pop(1 : inputnum * hiddennum);
B1 = pop(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = pop(inputnum * hiddennum + hiddennum + 1 : ...
    inputnum * hiddennum + hiddennum + hiddennum * outputnum);
B2 = pop(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
    inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);

%% 网络赋值

net.Iw{1, 1} = reshape(w1, hiddennum, inputnum );
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1}     = reshape(B1, hiddennum, 1);
net.b{2}     = B2';

%% 网络训练

net = train(net, p_train, t_train);

%% 仿真测试

t_sim1 = sim(net, p_train);

%% 反归一化

T_sim1  = vec2ind(t_sim1 );
T_train = vec2ind(t_train);

%% 适应度值

error = 1 - sum(T_sim1 == T_train) / length(T_sim1);

5.2 main.m

%% 清空环境变量

warning off             % 关闭报警信息
close all               % 关闭开启的图窗
clear                   % 清空变量
clc                     % 清空命令行

%% 导入数据

res = xlsread('数据集.xlsx');

%% 划分训练集和测试集

temp = randperm(357);

P_train = res(temp(1: 240), 1: 12)';
T_train = res(temp(1: 240), 13)';
M = size(P_train, 2);

P_test = res(temp(241: end), 1: 12)';
T_test = res(temp(241: end), 13)';
N = size(P_test, 2);

%% 数据归一化

[p_train, ps_input] = mapminmax(P_train, 0, 1);
p_test  = mapminmax('apply', P_test, ps_input);
t_train = ind2vec(T_train);
t_test  = ind2vec(T_test );

%% 节点个数

inputnum  = size(p_train, 1);  % 输入层节点数
hiddennum = 6;                 % 隐藏层节点数
outputnum = size(t_train,1);   % 输出层节点数

%% 建立网络

net = newff(p_train, t_train, hiddennum);

%% 设置训练参数

net.trainParam.epochs     = 1000;      % 训练次数
net.trainParam.goal       = 1e-5;      % 目标误差
net.trainParam.lr         = 0.01;      % 学习率
net.trainParam.showWindow = 0;         % 关闭窗口

%% 参数初始化

c1      = 4.494;       % 学习因子
c2      = 4.494;       % 学习因子
maxgen  =   30;        % 种群更新次数  
sizepop =    5;        % 种群规模
Vmax    =  1.0;        % 最大速度
Vmin    = -1.0;        % 最小速度
popmax  =  2.0;        % 最大边界
popmin  = -2.0;        % 最小边界

%% 节点总数

numsum = inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum;

for i = 1 : sizepop
    pop(i, :) = rands(1, numsum);  % 初始化种群
    V(i, :) = rands(1, numsum);    % 初始化速度
    fitness(i) = fun(pop(i, :), hiddennum, net, p_train, t_train);
end

%% 个体极值和群体极值

[fitnesszbest, bestindex] = min(fitness);
zbest = pop(bestindex, :);     % 全局最佳
gbest = pop;                   % 个体最佳
fitnessgbest = fitness;        % 个体最佳适应度值
BestFit = fitnesszbest;        % 全局最佳适应度值

%% 迭代寻优

for i = 1 : maxgen
    for j = 1 : sizepop
        
        % 速度更新
        V(j, :) = V(j, :) + c1 * rand * (gbest(j, :) - pop(j, :)) + c2 * rand * (zbest - pop(j, :));
        V(j, (V(j, :) > Vmax)) = Vmax;
        V(j, (V(j, :) < Vmin)) = Vmin;
        
        % 种群更新
        pop(j, :) = pop(j, :) + 0.2 * V(j, :);
        pop(j, (pop(j, :) > popmax)) = popmax;
        pop(j, (pop(j, :) < popmin)) = popmin;
        
        % 自适应变异
        pos = unidrnd(numsum);
        if rand > 0.95
            pop(j, pos) = rands(1, 1);
        end
        
        % 适应度值
        fitness(j) = fun(pop(j, :), hiddennum, net, p_train, t_train);

    end
    
    for j = 1 : sizepop

        % 个体最优更新
        if fitness(j) < fitnessgbest(j)
            gbest(j, :) = pop(j, :);
            fitnessgbest(j) = fitness(j);
        end

        % 群体最优更新 
        if fitness(j) < fitnesszbest
            zbest = pop(j, :);
            fitnesszbest = fitness(j);
        end

    end

    BestFit = [BestFit, fitnesszbest];    
end

%% 提取最优初始权值和阈值

w1 = zbest(1 : inputnum * hiddennum);
B1 = zbest(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = zbest(inputnum * hiddennum + hiddennum + 1 : inputnum * hiddennum ...
    + hiddennum + hiddennum * outputnum);
B2 = zbest(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
    inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);

%% 网络赋值

net.Iw{1, 1} = reshape(w1, hiddennum, inputnum );
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1}     = reshape(B1, hiddennum, 1);
net.b{2}     = B2';

%% 打开训练窗口

net.trainParam.showWindow = 1;        % 打开窗口

%% 网络训练

net = train(net, p_train, t_train);

%% 仿真预测

t_sim1 = sim(net, p_train);
t_sim2 = sim(net, p_test );

%% 数据反归一化

T_sim1 = vec2ind(t_sim1);
T_sim2 = vec2ind(t_sim2);

%% 数据排序

[T_train, index_1] = sort(T_train);
[T_test , index_2] = sort(T_test );

T_sim1 = T_sim1(index_1);
T_sim2 = T_sim2(index_2);

%% 性能评价

error1 = sum((T_sim1 == T_train)) / M * 100 ;
error2 = sum((T_sim2 == T_test )) / N * 100 ;

%% 绘图

figure
plot(1: M, T_train, 'r-*', 1: M, T_sim1, 'b-o', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'训练集预测结果对比'; ['准确率=' num2str(error1) '%']};
title(string)
xlim([1, M])
grid

figure
plot(1: N, T_test, 'r-*', 1: N, T_sim2, 'b-o', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'测试集预测结果对比'; ['准确率=' num2str(error2) '%']};
title(string)
xlim([1, N])
grid

%% 误差曲线迭代图

figure
plot(1 : length(BestFit), BestFit, 'LineWidth', 1.5);
xlabel('粒子群迭代次数');
ylabel('适应度值');
xlim([1, length(BestFit)])
string = {'模型迭代误差变化'};
title(string)

%% 混淆矩阵

figure
cm = confusionchart(T_train, T_sim1);
cm.Title = 'Confusion Matrix for Train Data';
cm.ColumnSummary = 'column-normalized';
cm.RowSummary = 'row-normalized';
    
figure
cm = confusionchart(T_test, T_sim2);
cm.Title = 'Confusion Matrix for Test Data';
cm.ColumnSummary = 'column-normalized';
cm.RowSummary = 'row-normalized';

6.完整代码

6.1 fun.m

function error = fun(pop, hiddennum, net, p_train, t_train)

%%  节点个数
inputnum  = size(p_train, 1);  % 输入层节点数
outputnum = size(t_train, 1);  % 输出层节点数

%%  提取权值和阈值
w1 = pop(1 : inputnum * hiddennum);
B1 = pop(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = pop(inputnum * hiddennum + hiddennum + 1 : ...
    inputnum * hiddennum + hiddennum + hiddennum * outputnum);
B2 = pop(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
    inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);

%%  网络赋值
net.Iw{1, 1} = reshape(w1, hiddennum, inputnum );
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1}     = reshape(B1, hiddennum, 1);
net.b{2}     = B2';

%%  网络训练
net = train(net, p_train, t_train);

%%  仿真测试
t_sim1 = sim(net, p_train);

%%  反归一化
T_sim1  = vec2ind(t_sim1 );
T_train = vec2ind(t_train);

%%  适应度值
error = 1 - sum(T_sim1 == T_train) / length(T_sim1);

6.2 main.m

%%  清空环境变量
warning off             % 关闭报警信息
close all               % 关闭开启的图窗
clear                   % 清空变量
clc                     % 清空命令行

%%  导入数据
res = xlsread('数据集.xlsx');

%%  划分训练集和测试集
temp = randperm(357);

P_train = res(temp(1: 240), 1: 12)';
T_train = res(temp(1: 240), 13)';
M = size(P_train, 2);

P_test = res(temp(241: end), 1: 12)';
T_test = res(temp(241: end), 13)';
N = size(P_test, 2);

%%  数据归一化
[p_train, ps_input] = mapminmax(P_train, 0, 1);
p_test  = mapminmax('apply', P_test, ps_input);
t_train = ind2vec(T_train);
t_test  = ind2vec(T_test );

%%  节点个数
inputnum  = size(p_train, 1);  % 输入层节点数
hiddennum = 6;                 % 隐藏层节点数
outputnum = size(t_train,1);   % 输出层节点数

%%  建立网络
net = newff(p_train, t_train, hiddennum);

%%  设置训练参数
net.trainParam.epochs     = 1000;      % 训练次数
net.trainParam.goal       = 1e-5;      % 目标误差
net.trainParam.lr         = 0.01;      % 学习率
net.trainParam.showWindow = 0;         % 关闭窗口

%%  参数初始化
c1      = 4.494;       % 学习因子
c2      = 4.494;       % 学习因子
maxgen  =   30;        % 种群更新次数  
sizepop =    5;        % 种群规模
Vmax    =  1.0;        % 最大速度
Vmin    = -1.0;        % 最小速度
popmax  =  2.0;        % 最大边界
popmin  = -2.0;        % 最小边界

%%  节点总数
numsum = inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum;

for i = 1 : sizepop
    pop(i, :) = rands(1, numsum);  % 初始化种群
    V(i, :) = rands(1, numsum);    % 初始化速度
    fitness(i) = fun(pop(i, :), hiddennum, net, p_train, t_train);
end

%%  个体极值和群体极值
[fitnesszbest, bestindex] = min(fitness);
zbest = pop(bestindex, :);     % 全局最佳
gbest = pop;                   % 个体最佳
fitnessgbest = fitness;        % 个体最佳适应度值
BestFit = fitnesszbest;        % 全局最佳适应度值

%%  迭代寻优
for i = 1 : maxgen
    for j = 1 : sizepop
        
        % 速度更新
        V(j, :) = V(j, :) + c1 * rand * (gbest(j, :) - pop(j, :)) + c2 * rand * (zbest - pop(j, :));
        V(j, (V(j, :) > Vmax)) = Vmax;
        V(j, (V(j, :) < Vmin)) = Vmin;
        
        % 种群更新
        pop(j, :) = pop(j, :) + 0.2 * V(j, :);
        pop(j, (pop(j, :) > popmax)) = popmax;
        pop(j, (pop(j, :) < popmin)) = popmin;
        
        % 自适应变异
        pos = unidrnd(numsum);
        if rand > 0.95
            pop(j, pos) = rands(1, 1);
        end
        
        % 适应度值
        fitness(j) = fun(pop(j, :), hiddennum, net, p_train, t_train);

    end
    
    for j = 1 : sizepop

        % 个体最优更新
        if fitness(j) < fitnessgbest(j)
            gbest(j, :) = pop(j, :);
            fitnessgbest(j) = fitness(j);
        end

        % 群体最优更新 
        if fitness(j) < fitnesszbest
            zbest = pop(j, :);
            fitnesszbest = fitness(j);
        end

    end

    BestFit = [BestFit, fitnesszbest];    
end

%%  提取最优初始权值和阈值
w1 = zbest(1 : inputnum * hiddennum);
B1 = zbest(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = zbest(inputnum * hiddennum + hiddennum + 1 : inputnum * hiddennum ...
    + hiddennum + hiddennum * outputnum);
B2 = zbest(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
    inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);

%%  网络赋值
net.Iw{1, 1} = reshape(w1, hiddennum, inputnum );
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1}     = reshape(B1, hiddennum, 1);
net.b{2}     = B2';

%%  打开训练窗口 
net.trainParam.showWindow = 1;        % 打开窗口

%%  网络训练
net = train(net, p_train, t_train);

%%  仿真预测
t_sim1 = sim(net, p_train);
t_sim2 = sim(net, p_test );

%%  数据反归一化
T_sim1 = vec2ind(t_sim1);
T_sim2 = vec2ind(t_sim2);

%%  数据排序
[T_train, index_1] = sort(T_train);
[T_test , index_2] = sort(T_test );

T_sim1 = T_sim1(index_1);
T_sim2 = T_sim2(index_2);

%%  性能评价
error1 = sum((T_sim1 == T_train)) / M * 100 ;
error2 = sum((T_sim2 == T_test )) / N * 100 ;

%%  绘图
figure
plot(1: M, T_train, 'r-*', 1: M, T_sim1, 'b-o', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'训练集预测结果对比'; ['准确率=' num2str(error1) '%']};
title(string)
xlim([1, M])
grid

figure
plot(1: N, T_test, 'r-*', 1: N, T_sim2, 'b-o', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'测试集预测结果对比'; ['准确率=' num2str(error2) '%']};
title(string)
xlim([1, N])
grid

%%  误差曲线迭代图
figure
plot(1 : length(BestFit), BestFit, 'LineWidth', 1.5);
xlabel('粒子群迭代次数');
ylabel('适应度值');
xlim([1, length(BestFit)])
string = {'模型迭代误差变化'};
title(string)

%%  混淆矩阵
figure
cm = confusionchart(T_train, T_sim1);
cm.Title = 'Confusion Matrix for Train Data';
cm.ColumnSummary = 'column-normalized';
cm.RowSummary = 'row-normalized';
    
figure
cm = confusionchart(T_test, T_sim2);
cm.Title = 'Confusion Matrix for Test Data';
cm.ColumnSummary = 'column-normalized';
cm.RowSummary = 'row-normalized';

7.运行结果

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/796851.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Unity100个实用小技巧】如何动态生成图片的Mipmap

【Unity100个实用小技巧】如何动态生成图片的Mipmap

☀️博客主页&#xff1a;CSDN博客主页&#x1f4a8;本文由 萌萌的小木屋 原创&#xff0c;首发于 CSDN&#x1f4a2;&#x1f525;学习专栏推荐&#xff1a;面试汇总❗️游戏框架专栏推荐&#xff1a;游戏实用框架专栏⛅️点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd;&#…
阅读更多...
linux V4L2子系统——v4l2架构（1）之整体架构

linux V4L2子系统——v4l2架构（1）之整体架构

概述 V4L&#xff08;Video for Linux&#xff09;是Linux内核中关于视频设备的API接口&#xff0c;涉及视频设备的音频和视频信息采集及处理、视频设备的控制。V4L出现于Linux内核2.1版本&#xff0c;经过修改bug和添加功能&#xff0c;Linux内核2.5版本推出了V4L2&#xff08…
阅读更多...
【python】AttributeError: ‘DataFrame‘ object has no attribute ‘append‘

【python】AttributeError: ‘DataFrame‘ object has no attribute ‘append‘

在使用pandas时出现这个问题&#xff0c;因为我复现的代码是很久之前发布的了&#xff0c;我用的pandas又是最新版本2.0.3&#xff0c;大概猜到是pandas版本出了问题&#xff0c;参考 (6条消息) 解决AttributeError: ‘DataFrame‘ object has no attribute ‘append‘_wang_j…
阅读更多...
辅助驾驶功能开发-执行器篇(03)-Mobileye Control Requirements

辅助驾驶功能开发-执行器篇(03)-Mobileye Control Requirements

1. 目的 本文描述了产品开发不同阶段&#xff08;研发、验证和产品化&#xff09;车辆集成的控制要求。 2. 控制接口要求 2.1 接口类型 控制模块与车辆之间的接口应基于CAN协议或Flexray协议。 2.2 通讯频率 控制模块与车辆之间的通讯频率应高于36Hz。通信频率优先选择为 50…
阅读更多...
Spring高手之路11——BeanDefinition解密：构建和管理Spring Beans的基石

Spring高手之路11——BeanDefinition解密：构建和管理Spring Beans的基石

文章目录 1. 探索BeanDefinition1.1 官方文档对BeanDefinition的解读1.2 BeanDefinition关键方法剖析1.3 BeanDefinition部分方法的实际运用1.4 BeanDefinition深层信息结构梳理 2. BeanDefinition构造体系解析2.1 BeanDefinition的类型及其应用2.2 生成BeanDefinition的原理剖…
阅读更多...
最全语言模型领域知识评估Benchmark——獬豸：包含了516门学科、13学科门类、240w条数据

最全语言模型领域知识评估Benchmark——獬豸：包含了516门学科、13学科门类、240w条数据

论文链接&#xff1a;https://arxiv.org/abs/2306.05783 代码链接&#xff1a;https://github.com/MikeGu721/XiezhiBenchmark 复旦大学肖仰华团队——獬豸&#xff08;Xiezhi&#xff09;是一套针对语言模型&#xff08;LM&#xff09;的领域评估Benchmark。它由249587道多选…
阅读更多...
linux下frp实现内网穿透

linux下frp实现内网穿透

frp简介 frp是什么&#xff1f; frp采用Golang语言编写&#xff0c;支持跨平台&#xff0c;仅需下载对应平台的二进制文件即可执行&#xff0c;没有额外依赖。 frp是一个专注于内网穿透的高性能的反向代理应用&#xff0c;支持TCP&#xff0c;UDP,HTTP,HTTPS等多种协议。可以将…
阅读更多...
Android开发之Fragment

Android开发之Fragment

Fragment可以看作一种灵活的子Activity&#xff0c;其依附于Activity运行。一个Activity下可以依附多个Fragment&#xff0c;从而实现一个页面多个窗口&#xff0c;而同一个Fragment也能被多个Activity复用&#xff0c;因此Fragment是Android开发中相当重要的板块。 文章目录 …
阅读更多...
Docker-compose容器编排

Docker-compose容器编排

Docker-Compose介绍 Compose 是 Docker 公司推出的一个工具软件&#xff0c;可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml&#xff0c;写好多个容器之间的调用关系。然后&#xff0c;只要一个命令&#xff0c;就能同时启动/关…
阅读更多...
Visual Studio 2022 程序员必须知道高效调试手段与技巧（中）

Visual Studio 2022 程序员必须知道高效调试手段与技巧（中）

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏:《C语言初阶篇》 《C语言进阶篇》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 文章目录 &#x1f4cb; 前言&#x1f4ac; 调试的时候查看程序当前信息&#x1f4ad; 查看临时变量的值&#x1f4ad; 查…
阅读更多...
实验报告-Sublime配置默认语法，以配置Verilog语法为例

实验报告-Sublime配置默认语法，以配置Verilog语法为例

实验报告-Sublime配置默认语法，以配置Verilog语法为例 1，下载Verilog语法环境2，Sublime配置语法工作环境，以Verilog语法环境为例。3，打开一个新的Sublime，验证编辑器配置Verilog为默认语法成功！4，Sublime汉化1，下载Verilog语法环境 参考文献： 1，Sublime Text 4加载…
阅读更多...
29.Git版本控制工具

29.Git版本控制工具

1.Git简介 Git是一开源的分布式版本控制系统&#xff0c;提供了存储代码、管理版本历史、分支和合并等功能。 版本控制是指对软件开发过程中各种程序代码、配置文件及说明文档等文件变更的管理&#xff0c;是软件配置管理的核心思想之一。它的主要目的是跟踪和记录软件开发过程…
阅读更多...
【2500. 删除每行中的最大值】

【2500. 删除每行中的最大值】

来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 描述&#xff1a; 给你一个 m x n 大小的矩阵 grid &#xff0c;由若干正整数组成。 执行下述操作&#xff0c;直到 grid 变为空矩阵&#xff1a; 从每一行删除值最大的元素。如果存在多个这样的值&#xff0c;删除其…
阅读更多...
手把手教你写代码——基于控制台的通讯录管理系统（单表）

手把手教你写代码——基于控制台的通讯录管理系统（单表）

栏目介绍 本栏目专为入门java学习者设计的一些简单的入门项目 功能介绍 本项目为简单的基于控制台的通讯录管理系统&#xff0c;所需要的环境仅仅为jdk以及mysql&#xff08;版本不限&#xff09;&#xff01;只有一个简单的eclipse软件以及我们的mysql可视化工具&#xff08;视…
阅读更多...
企业网关：打开商业大门的关键

企业网关：打开商业大门的关键

企业网关&#xff1a;打开商业大门的关键 在当今数字化时代&#xff0c;企业网关的重要性变得越来越明显。作为连接企业内外的关键枢纽&#xff0c;企业网关不仅提供了安全可靠的网络连接&#xff0c;还为企业提供了更高效的业务运营和更好的客户体验。本文将深入探讨企业网关…
阅读更多...
Vue-路由

Vue-路由

一、目标 能够说出前端路由工作的过程能够知道如何在vue3中配置路由能够知道如何使用嵌套路由能够知道如何实现动态路由匹配能够知道如何使用编程式导航能够知道如何使用导航守卫 二、目录 前端路由的概念与原理vue-router的基本使用vue-router的高级用法后台管理案例 前端…
阅读更多...
linux下的questasim安装和与vivado的关联

linux下的questasim安装和与vivado的关联

一、questasim安装 参考链接 IC验证工具&#xff1a;Ubuntu下Questasim10.7安装&#xff08;64bit&#xff09;全攻略 参考2 易特创芯 linux环境下questasim 10.7的安装总结_limanjihe的博客-CSDN博客 前面操作参照的第一个链接&#xff0c;后面激活文件参考的第二个 另外…
阅读更多...
JavaScript 常用数组方法之数组扁平化「赶紧收藏」

JavaScript 常用数组方法之数组扁平化「赶紧收藏」

一、什么是数组扁平化 数组扁平化&#xff0c;就是将一个复杂的嵌套多层的数组&#xff0c;一层一层的转化为层级较少或者只有一层的数组。 比如&#xff1a; // 多维数组 var arr [1,2,[3,4,5,[6,7,8],9],10,[11,12]]; // 数组扁平化 [1,2,3,4,5,6,7,8,9,10,11,12]二、实现…
阅读更多...
关于在Python的for循环中改变列表的值问题探究

关于在Python的for循环中改变列表的值问题探究

案例一&#xff1a; def test():a [1, 2]for i in a:print(i, id(a))if i 5:breaka [a[0]2, a[1]2] 输出&#xff1a; 1 4313456192 2 4313269056 解释&#xff1a; 在for循环语句中的变量a使用的内存地址为4313456192&#xff0c;这个地址以及存储的值不会因为a的重新赋…
阅读更多...
ceph-mon运行原理分析

ceph-mon运行原理分析

一、流程&#xff1a;ceph-deploy部署ceph-mon组建集群 1.ceph-deploy部署ceph-mon的工作流程及首次启动 1&#xff09;通过命令创建ceph-mon&#xff0c;命令为&#xff1a;ceph-deploy create mon keyring def mon(args):if args.subcommand create:mon_create(args)elif…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023