数学建模-2024妈妈杯数学建模思路ABCD题思路汇总分析 MathorCup建模思路分享

 1 赛题思路

(赛题出来以后第一时间在群内分享，点击下方群名片即可加群)

2 比赛日期和时间

报名截止时间：2024年4月11日（周四）12:00

比赛开始时间：2024年4月12日（周五）8:00

比赛结束时间：2024年4月16日（周二）9:00

3 组织机构

主办单位：中国优选法统筹法与经济数学研究会

中国优选法统筹法与经济数学研究会是在中国科学技术协会直接领导下的学术性社会团体，是国家一级学会。学会由华罗庚教授于1981年发起成立，至今成立了评价方法与应用、项目管理、计算机模拟、统筹、管理决策与信息系统、工业工程、高等教育管理、数学教育、经济数学与管理数学、应急管理、灰色系统研究，复杂系统研究等十余个专业分会。竞赛是由中国优选法统筹法与经济数学研究会主办，MathorCup高校数学建模挑战赛组委会具体负责竞赛的组织。

4 建模常见问题类型

趁现在赛题还没更新，A君给大家汇总一下建模经常使用到的数学模型，题目八九不离十基本属于一下四种问题，对应的解法A君也相应给出

分别为：

分类模型
优化模型
预测模型
评价模型

4.1 分类问题

判别分析：

又称“分辨法”，是在分类确定的条件下，根据某一研究对象的各种特征值判别其类型归属问题的一种多变量统计分析方法。

其基本原理是按照一定的判别准则，建立一个或多个判别函数；用研究对象的大量资料确定判别函数中的待定系数，并计算判别指标；据此即可确定某一样本属于何类。当得到一个新的样品数据，要确定该样品属于已知类型中哪一类，这类问题属于判别分析问题。

聚类分析：

聚类分析或聚类是把相似的对象通过静态分类的方法分成不同的组别或者更多的子集，这样让在同一个子集中的成员对象都有相似的一些属性，常见的包括在坐标系中更加短的空间距离等。

聚类分析本身不是某一种特定的算法，而是一个大体上的需要解决的任务。它可以通过不同的算法来实现，这些算法在理解集群的构成以及如何有效地找到它们等方面有很大的不同。

代码：

clc;clear;close all;

load('C_03_Apr_2024_10_31_26.mat')

data=G_out_data.data_process; %总体处理后的数据 G_out_data.data_O 处理前的数据

jiangwei_num=G_out_data.jiangwei_num; %设置降维数

Z=data;

label_distance=G_out_data.label_distance; %确定聚类采用距离

cluster_num=G_out_data.cluster_num; %确定聚类数

[index,center] = kmeans(Z,cluster_num,'Distance',label_distance); %Kmeans聚类

sc_xishu=mean(silhouette(data,index')); %轮廓系数

a=unique(index); %找出分类出的个数

yang_num=length(a);

C=cell(1,length(a));

color_list=G_out_data.color_list; %颜色数据库

fu_str=G_out_data.fu_str; %样式数据库1

fu_str1=G_out_data.fu_str1; %样式数据库2

color_list_cha=G_out_data.color_list_cha;

color_all=G_out_data.color_all;

makesize=G_out_data.makesize; %标记大小

Line_Width=G_out_data.LineWidth; %线宽

data_num=size(data1,2); %数据维度

legend_str=G_out_data.legend_str;

get_legend_str=strsplit(legend_str,',');

FontSize=G_out_data.FontSize; % 字体大小

kuang_with1=G_out_data.kuang_width; % 字体粗细

FontName1=G_out_data.FontName; % 字体样式

xlabel1=G_out_data.xlabel; % xlabel

ylabel1=G_out_data.ylabel; % ylabel

title1=G_out_data.title; % title

kuang=G_out_data.kuang; % 框的选择

grid1=G_out_data.grid; % 网格选择

zlabel1=G_out_data.zlabel; % ylabel

leg_kuang1=G_out_data.leg_kuang; % 图例框

kuang_with1=G_out_data.kuang_width; % 整体框设置

figure;

if yang_num<=2

N1=1;N2=2;

elseif yang_num<=4&&yang_num>2

N1=2;N2=2;

else

N2=3;N1=ceil(yang_num/N2);

end

if(length(get_legend_str)<yang_num)

for i=length(get_legend_str):yang_num

get_legend_str{1,i}=['类别',num2str(i)];

end

end

for NN=1:yang_num

subplot(N1,N2,NN)

data_get=data1(C{1,NN},:);

for NN1=1:size(data_get,1)

plot(1:data_num,data_get(NN1,:),'LineWidth',Line_Width(1),'MarkerSize',makesize);hold on

end

set(gca,'FontName',FontName1,'FontSize',FontSize,'LineWidth',kuang_with1)

title(gca,title1)

box(gca,kuang)

grid(grid1)

title(gca,get_legend_str{1,NN})

xlabel(gca,xlabel1)

ylabel(gca,ylabel1)

ylim([min(min(data1)),max(max(data1))])

xlim([0.5,data_num+0.5])

end

figure;

rand_list1=G_out_data.rand_list1;

for NN=1:yang_num

subplot(N1,N2,NN)

data_get=data1(C{1,NN},:);

score=(mean(data_get));score_L=(score-std(data_get));score_H=(score+std(data_get));

h1=fill(gca,[1:length(score),fliplr(1:length(score))],[score_L,fliplr(score_H)],'r'); hold (gca,'on')

h1.FaceColor = color_all(rand_list1(NN),:);%定义区间的填充颜色

h1.EdgeColor =[1,1,1];%边界颜色设置为白色

alpha (gca,0.3) %设置透明色

plot(gca,1:length(score), score,fu_str1{1,NN},'Color',color_all(rand_list1(NN),:),'LineWidth',Line_Width(1),'MarkerSize',makesize)

set(gca,'FontName',FontName1,'FontSize',FontSize,'LineWidth',kuang_with1)

title(gca,title1)

box(gca,kuang)

grid(grid1)

title(gca,get_legend_str{1,NN})

xlabel(gca,xlabel1)

ylabel(gca,ylabel1)

ylim([min(min(data1)),max(max(data1))])

xlim([0.5,data_num+0.5])

end

神经网络分类：

BP 神经网络是一种神经网络学习算法。其由输入层、中间层、输出层组成的阶层型神经网络，中间层可扩展为多层。RBF（径向基）神经网络：径向基函数(RBF-Radial Basis Function)神经网络是具有单隐层的三层前馈网络。它模拟了人脑中局部调整、相互覆盖接收域的神经网络结构。感知器神经网络：是一个具有单层计算神经元的神经网络，网络的传递函数是线性阈值单元。主要用来模拟人脑的感知特征。线性神经网络：是比较简单的一种神经网络，由一个或者多个线性神经元构成。采用线性函数作为传递函数，所以输出可以是任意值。自组织神经网络：自组织神经网络包括自组织竞争网络、自组织特征映射网络、学习向量量化等网络结构形式。K近邻算法：　K最近邻分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。

clc;clear;close all;	
load('MT_03_Apr_2024_10_33_51.mat')	
	
data_str=G_out_data.data_path_str ;  %读取数据的路径 	
dataO1=readtable(data_str,'VariableNamingRule','preserve'); %读取数据 	
data1=dataO1(:,2:end);test_data=table2cell(dataO1(1,2:end));	
for i=1:length(test_data)	
      if ischar(test_data{1,i})==1	
          index_la(i)=1;     %char类型	
      elseif isnumeric(test_data{1,i})==1	
          index_la(i)=2;     %double类型	
      else	
        index_la(i)=0;     %其他类型	
    end 	
end	
index_char=find(index_la==1);index_double=find(index_la==2);	
	
%%数值类型数据处理	
if length(index_double)>=1	
     data_numshuju=table2array(data1(:,index_double));	
     data_numshuju2=data_numshuju;	
     index_need_last=index_double;	
else	
     index_need_last=index_double;	
    data_numshuju2=[];	
end	
	
% 文本类型数据处理	
data_shuju=[];	
if length(index_char)>=1	
   for j=1:length(index_char)	
     data_get=table2array(data1(:,index_char(j)));	
	
    data_label=unique(data_get);	
     for NN=1:length(data_label)	
         idx = find(ismember(data_get,data_label{NN,1}));	
         data_shuju(idx,j)=NN;	
     end	
   end	
 end	
data_all_last=[data_shuju,data_numshuju2];	
 label_all_last=[index_char,index_need_last];	
data=data_all_last;	
     data_biao_all=data1.Properties.VariableNames;	
   for j=1:length(label_all_last)	
     data_biao{1,j}=data_biao_all{1,label_all_last(j)};	
  end	
	
	
	
	
data_numshuju=data;	
for NN=1:size(data_numshuju,2)	
      data_test=data_numshuju(:,NN);	
      index=isnan(data_test);	
      data_test1=data_test;	
      data_test1(index)=[];	
      index_label=1:length(data_test);	
      index_label1=index_label;	
      index_label1(index)=[];	
      data_all=interp1(index_label1,data_test1,index_label,'spline');	
	
     dataO(:,NN)=data_all;	
end	
	
  A_data1=dataO;	
 data_biao1=data_biao;	
 select_feature_num=G_out_data.select_feature_num;   %特征选择的个数	
 predict_num=G_out_data.predict_num_set;   %预测的点个数	
index_name=data_biao1;	
print_index_name=[]; 	
 [B,~] = lasso(A_data1(:,1:end-predict_num),A_data1(:,end-predict_num+1),'Alpha',1); 	
 L_B=(B~=0);   SL_B=sum(L_B); [~,index_L1]=min(abs(SL_B-select_feature_num)); 	
 feature_need_last=find(L_B(:,index_L1)==1);  	
 data_select=[A_data1(:,feature_need_last),A_data1(:,end-predict_num+1:end)];	
	
	
 for NN=1:length(feature_need_last) 	
   print_index_name{1,NN}=index_name{1,feature_need_last(NN)};	
end 	
disp('选择特征');disp(print_index_name)  	
	
data_select1=data_select;	
data_select1=data_select1;	
	
	
	
%%波形分解	
data_select1_cell=[];	
data_select1_cell{1,1}=data_select1;	
	
	
 % 模型训练参数	
select_predict_num=G_out_data.select_predict_num;  %待预测数	
num_feature=G_out_data.num_feature;    %特征选择量	
num_series=G_out_data.num_series;     %序列选择	
num_input_serise=num_series;     	
min_batchsize=G_out_data.min_batchsize; 	
roll_num=G_out_data.roll_num;    %滚动次数	
roll_num_in=G_out_data.roll_num_in;	
 num_pop=G_out_data.num_pop;  %优化种群数	
num_iter=G_out_data.num_iter;  %优化迭代数	
num_BO_iter=G_out_data.num_BO_iter;  %贝叶斯优化迭代次数	
max_epoch_LC=G_out_data.max_epoch_LC; %最大轮数	
method_mti=G_out_data.method_mti; %最大轮数	
list_cell=	G_out_data.list_cell;	
	
attention_label=G_out_data.attention_label;	
attention_head=G_out_data.attention_head;	
	
 %% 模型训练	
 x_mu_all=[];x_sig_all=[];y_mu_all=[];y_sig_all=[];  	
for NUM_all=1:length(data_select1_cell)	
       data_process=data_select1_cell{1,NUM_all};	
  [x_feature_label,y_feature_label]=timeseries_process2(data_process,select_predict_num,num_series); 	
  [~,y_feature_label1]=timeseries_process2(data_select1,select_predict_num,num_series);    %未分解之前	
	
	
	
index_label1=1:(size(x_feature_label,1)); index_label=index_label1;	
spilt_ri=G_out_data.spilt_ri;	
train_num=round(spilt_ri(1)/(sum(spilt_ri))*size(x_feature_label,1));                    %训练集个数	
vaild_num=round((spilt_ri(1)+spilt_ri(2))/(sum(spilt_ri))*size(x_feature_label,1)); %验证集个数	
%训练集，验证集，测试集	
train_x_feature_label=x_feature_label(index_label(1:train_num),:);	
train_y_feature_label=y_feature_label(index_label(1:train_num),:);	
vaild_x_feature_label=x_feature_label(index_label(train_num+1:vaild_num),:);	
vaild_y_feature_label=y_feature_label(index_label(train_num+1:vaild_num),:);	
test_x_feature_label=x_feature_label(index_label(vaild_num+1:end),:);	
test_y_feature_label=y_feature_label(index_label(vaild_num+1:end),:);	
%Zscore 标准化	
	
%训练集	
 x_mu = mean(train_x_feature_label);  x_sig = std(train_x_feature_label); 	
 train_x_feature_label_norm = (train_x_feature_label - x_mu) ./ x_sig;    % 训练数据标准化	
y_mu = mean(train_y_feature_label);  y_sig = std(train_y_feature_label); 	
train_y_feature_label_norm = (train_y_feature_label - y_mu) ./ y_sig;    % 训练数据标准化	
x_mu_all(NUM_all,:)=x_mu;x_sig_all(NUM_all,:)=x_sig;y_mu_all(NUM_all,:)=y_mu;y_sig_all(NUM_all,:)=y_sig;                   	
%验证集	
vaild_x_feature_label_norm = (vaild_x_feature_label - x_mu) ./ x_sig;    % 训练数据标准化	
vaild_y_feature_label_norm = (vaild_y_feature_label - y_mu) ./ y_sig;    % 训练数据标准化	
%测试集	
test_x_feature_label_norm = (test_x_feature_label - x_mu) ./ x_sig;    % 训练数据标准化	
test_y_feature_label_norm = (test_y_feature_label - y_mu) ./ y_sig;    % 训练数据标准化	
	
	
	
	
y_train_predict_norm=zeros(size(train_y_feature_label,1),size(train_y_feature_label,2));y_vaild_predict_norm=zeros(size(vaild_y_feature_label,1),size(vaild_y_feature_label,2));	
y_test_predict_norm=zeros(size(test_y_feature_label,1),size(test_y_feature_label,2));	
	
  for N1=1:length(list_cell)	
    hidden_size=G_out_data.hidden_size;	
    p_train1=reshape(train_x_feature_label_norm',size(train_x_feature_label_norm,2),1,1,size(train_x_feature_label_norm,1));	
    	
    p_vaild1=reshape(vaild_x_feature_label_norm',size(vaild_x_feature_label,2),1,1,size(vaild_x_feature_label,1));	
   	
  p_test1=reshape(test_x_feature_label_norm',size(test_x_feature_label,2),1,1,size(test_x_feature_label,1));	
 	
	
   if(length(hidden_size)<2)	
       layers = [imageInputLayer([ size(train_x_feature_label,2) 1 1])%%2D-CNN   ) 	
        convolution2dLayer([2,1],hidden_size(1))	
        batchNormalizationLayer                                           	
        dropoutLayer(0.2)                                 % 防止过拟合  	
        reluLayer	
       maxPooling2dLayer([2 1],'Stride',1) 	
      	
	
       fullyConnectedLayer(size(train_y_feature_label(:,list_cell{1,N1}),2))	
       regressionLayer];	
	
     elseif (length(hidden_size)>=2) 	
       layers = [imageInputLayer([ size(train_x_feature_label,2) 1 1])%%2D-CNN   )	
       convolution2dLayer([2,1],hidden_size(1))	
       batchNormalizationLayer	
       reluLayer	
       maxPooling2dLayer([2 1],'Stride',1)	
       convolution2dLayer([2,1],hidden_size(2))	
       batchNormalizationLayer	
       reluLayer	
      maxPooling2dLayer([2 1],'Stride',1)	
      fullyConnectedLayer(size(train_y_feature_label(:,list_cell{1,N1}),2))	
       regressionLayer];	
 	
 	
 end	
	
	
	
	
	
	
      options = trainingOptions('adam', ...	
         'MaxEpochs',max_epoch_LC, ...	
         'MiniBatchSize',min_batchsize,...	
         'InitialLearnRate',0.001,...	
         'ValidationFrequency',20, ...	
         'LearnRateSchedule','piecewise', ...	
         'LearnRateDropPeriod',125, ...	
        'LearnRateDropFactor',0.2, ...	
        'Plots','training-progress');	
   Mdl = trainNetwork(p_train1,  train_y_feature_label_norm(:,list_cell{1,N1}), layers, options);	
    y_train_predict_norm_roll = predict(Mdl, p_train1,'MiniBatchSize',min_batchsize);	
    y_vaild_predict_norm_roll = predict(Mdl, p_vaild1,'MiniBatchSize',min_batchsize);	
    y_test_predict_norm_roll =  predict(Mdl, p_test1,'MiniBatchSize',min_batchsize);	
	
	
	
	
	
	
y_train_predict_norm(:,list_cell{1,N1})=y_train_predict_norm_roll;	
y_vaild_predict_norm(:,list_cell{1,N1})=y_vaild_predict_norm_roll;	
y_test_predict_norm(:,list_cell{1,N1})=y_test_predict_norm_roll;	
 lgraph = layerGraph(Mdl.Layers);	
  figure 	
 plot(lgraph)	
 model_all{NUM_all,N1}=Mdl;	
   	
	
figure	
	
subplot(2, 1, 1)	
plot(1 : length(Loss.TrainingRMSE), Loss.TrainingRMSE, '-', 'LineWidth', 1)	
xlabel('迭代次数');ylabel('均方根误差');legend('训练集均方根误差');title ('训练集均方根误差曲线');grid;set(gcf,'color','w')	
	
subplot(2, 1, 2)	
plot(1 : length(Loss.TrainingLoss), Loss.TrainingLoss, '-', 'LineWidth', 1)	
xlabel('迭代次数');ylabel('损失函数');legend('训练集损失值');title ('训练集损失函数曲线');grid;set(gcf,'color','w')	
 end	
	
	
	
y_train_predict_cell{1,NUM_all}=y_train_predict_norm.*y_sig+y_mu;  %反标准化操作	
y_vaild_predict_cell{1,NUM_all}=y_vaild_predict_norm.*y_sig+y_mu;	
 y_test_predict_cell{1,NUM_all}=y_test_predict_norm.*y_sig+y_mu;	
	
end	
	
	
	
y_train_predict=0;y_vaild_predict=0;y_test_predict=0;	
for i=1:length(data_select1_cell)	
      y_train_predict=y_train_predict+ y_train_predict_cell{1,i};	
      y_vaild_predict=y_vaild_predict+ y_vaild_predict_cell{1,i};	
      y_test_predict=y_test_predict+ y_test_predict_cell{1,i};	
end	
	
 train_y_feature_label=y_feature_label1(index_label(1:train_num),:); 	
 vaild_y_feature_label=y_feature_label1(index_label(train_num+1:vaild_num),:);	
test_y_feature_label=y_feature_label1(index_label(vaild_num+1:end),:);	
	
Tvalue=G_out_data.Tvalue;  %使用的方法	
	
train_y=train_y_feature_label; 	
train_MAE=sum(sum(abs(y_train_predict-train_y)))/size(train_y,1)/size(train_y,2) ; disp([Tvalue,'训练集平均绝对误差MAE：',num2str(train_MAE)])	
train_MAPE=sum(sum(abs((y_train_predict-train_y)./train_y)))/size(train_y,1)/size(train_y,2); disp([Tvalue,'训练集平均相对误差MAPE：',num2str(train_MAPE)])	
train_MSE=(sum(sum(((y_train_predict-train_y)).^2))/size(train_y,1)/size(train_y,2)); disp([Tvalue,'训练集均方误差MSE：',num2str(train_MSE)])    	
train_RMSE=sqrt(sum(sum(((y_train_predict-train_y)).^2))/size(train_y,1)/size(train_y,2)); disp([Tvalue,'训练集均方根误差RMSE：',num2str(train_RMSE)]) 	
train_R2 = 1 - mean(norm(train_y - y_train_predict)^2 / norm(train_y - mean(train_y))^2);   disp([Tvalue,'训练集R方系数R2：',num2str(train_R2)]) 	
disp('************************************************************************************')	
vaild_y=vaild_y_feature_label;	
vaild_MAE=sum(sum(abs(y_vaild_predict-vaild_y)))/size(vaild_y,1)/size(vaild_y,2) ; disp([Tvalue,'验证集平均绝对误差MAE：',num2str(vaild_MAE)])	
vaild_MAPE=sum(sum(abs((y_vaild_predict-vaild_y)./vaild_y)))/size(vaild_y,1)/size(vaild_y,2); disp([Tvalue,'验证集平均相对误差MAPE：',num2str(vaild_MAPE)])	
vaild_MSE=(sum(sum(((y_vaild_predict-vaild_y)).^2))/size(vaild_y,1)/size(vaild_y,2)); disp([Tvalue,'验证集均方误差MSE：',num2str(vaild_MSE)])     	
vaild_RMSE=sqrt(sum(sum(((y_vaild_predict-vaild_y)).^2))/size(vaild_y,1)/size(vaild_y,2)); disp([Tvalue,'验证集均方根误差RMSE：',num2str(vaild_RMSE)]) 	
vaild_R2 = 1 - mean(norm(vaild_y - y_vaild_predict)^2 / norm(vaild_y - mean(vaild_y))^2);   disp([Tvalue,'验证集R方系数R2：',num2str(vaild_R2)]) 	
disp('************************************************************************************')	
test_y=test_y_feature_label;	
test_MAE=sum(sum(abs(y_test_predict-test_y)))/size(test_y,1)/size(test_y,2) ; disp([Tvalue,'测试集平均绝对误差MAE：',num2str(test_MAE)])	
test_MAPE=sum(sum(abs((y_test_predict-test_y)./test_y)))/size(test_y,1)/size(test_y,2); disp([Tvalue,'测试集平均相对误差MAPE：',num2str(test_MAPE)])	
test_MSE=(sum(sum(((y_test_predict-test_y)).^2))/size(test_y,1)/size(test_y,2)); disp([Tvalue,'测试集均方误差MSE：',num2str(test_MSE)]) 	
test_RMSE=sqrt(sum(sum(((y_test_predict-test_y)).^2))/size(test_y,1)/size(test_y,2)); disp([Tvalue,'测试集均方根误差RMSE：',num2str(test_RMSE)]) 	
test_R2 = 1 - mean(norm(test_y - y_test_predict)^2 / norm(test_y - mean(test_y))^2);   disp([Tvalue,'测试集R方系数R2：',num2str(test_R2)]) 	
	
	
	
	
%% 调用模型得到数据预测结果	
	
y_last_predict_cell=cell(1,length(data_select1_cell));	
for NUM_all=1:length(data_select1_cell)	
      data_process=data_select1_cell{1,NUM_all};	
      data_process=data_process(vaild_num+1:end,:);	
	
       [x_feature_label]=timeseries_process2_Pre(data_process,select_predict_num,num_series);	
	
       x_mu=x_mu_all(NUM_all,:);	
       x_sig=x_sig_all(NUM_all,:);	
       pre_x_feature_label_norm = (x_feature_label - x_mu) ./ x_sig;    % 训练数据标准化	
	
      	
      p_pre1=reshape(pre_x_feature_label_norm',size(pre_x_feature_label_norm,2),1,1,size(pre_x_feature_label_norm,1));	
   	
   	
       for N1=1:length(list_cell)	
            Mdl=model_all{NUM_all,N1};	
            y_pre_predict_norm1 =  predict(Mdl, p_pre1,'MiniBatchSize',min_batchsize);	
            y_pre_predict_norm(:,list_cell{1,N1})=y_pre_predict_norm1;	
       end	
	
    	
     	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
        y_last_predict_cell{1,NUM_all}=y_pre_predict_norm.*y_sig_all(NUM_all,:)+y_mu_all(NUM_all,:);  %反标准化操作	
    end	
	
 y_last_predict=0;   y_before=0;	
for i=1:length(data_select1_cell)	
      y_last_predict=y_last_predict+ y_last_predict_cell{1,i};	
      y_before=y_before+data_select1_cell{1,i}(vaild_num+1:end,end);	
end	
	
y_last_predict1=y_last_predict(end,1:end);	
disp('预测未来时间点数据为:')	
disp(y_last_predict1)	
figure;	
plot([1:length(y_before)],y_before,'-o','LineWidth',1);		
hold on	
plot([length(y_before)+1:length(y_before)+length(y_last_predict1)],y_last_predict1,'-p','LineWidth',1.2)		
hold on	
legend('True','Predict')	
set(gca,'LineWidth',1.2)	
	
	
show_wei_num=G_out_data.show_wei_num; %展示输出的维度	
train_y1=train_y(:,show_wei_num);	
vaild_y1=vaild_y(:,show_wei_num);	
test_y1=test_y(:,show_wei_num);	
	
y_train_predict1=y_train_predict(:,show_wei_num);	
y_vaild_predict1=y_vaild_predict(:,show_wei_num);	
y_test_predict1=y_test_predict(:,show_wei_num);	
	
color_list=G_out_data.color_list; 	
Line_Width=G_out_data.Line_Width;	
rand_list1=G_out_data.rand_list1;	
makesize=G_out_data.makesize;	
 figure;	
XX=1:length(train_y1);	
index_show=1:show_num1;	
plot(gca,XX(index_show),train_y1(index_show),yang_str2{1,3},'Color',color_list(rand_list1(1),:),'LineWidth',Line_Width(i))	
hold (gca,'on')	
plot(gca, XX(index_show),y_train_predict1(index_show),yang_str3{1,1},'Color',color_list(rand_list1(2),:),'LineWidth',Line_Width(i),'MarkerSize',makesize)	
hold (gca,'on')	
title('训练集测试效果')	
	
FontName=G_out_data.FontName;	
FontSize=G_out_data.FontSize;	
kuang_width=G_out_data.kuang_width;	
 set(gca,'FontName',FontName,'FontSize',FontSize,'LineWidth',kuang_width)	
	
xlabel1=G_out_data.xlabel1;	
ylabel1=G_out_data.ylabel1;	
legend1=G_out_data.legend1;	
 xlabel(xlabel1)	
ylabel(ylabel1)	
legend(legend1)	
	
box1=G_out_data.box1;	
 box(gca,box1) 	
le_kuang=G_out_data.le_kuang;	
 legend(gca,le_kuang) %图例框消失	
grid1=G_out_data.grid1;	
grid(gca,grid1)	
	
if show_num2>length(test_y1)	
   show_num2=length(test_y1);	
end	
	
	
figure;	
XX=1:length(test_y1);	
index_show=1:show_num2;	
 plot(gca,XX(index_show),test_y1(index_show),yang_str2{1,3},'Color',color_list(rand_list1(1),:),'LineWidth',Line_Width(i))	
hold (gca,'on')	
plot(gca, XX(index_show),y_test_predict1(index_show),yang_str3{1,1},'Color',color_list(rand_list1(2),:),'LineWidth',Line_Width(i),'MarkerSize',makesize)	
hold (gca,'on')	
 title('测试集测试效果')	
	
 set(gca,'FontName',FontName,'FontSize',FontSize,'LineWidth',kuang_width)	
	
 xlabel(xlabel1)	
ylabel(ylabel1)	
legend(legend1)	
	
 box(gca,box1) 	
 legend(gca,le_kuang) %图例框消失	
grid(gca,grid1)	
	
 if show_num3>length(vaild_y1)	
     show_num3=length(vaild_y1);	
end	
	
figure;	
XX=1:length(vaild_y1);	
index_show=1:show_num3;	
 plot(gca,XX(index_show),vaild_y1(index_show),yang_str2{1,3},'Color',color_list(rand_list1(1),:),'LineWidth',Line_Width(i))	
 hold (gca,'on')	
 plot(gca, XX(index_show),y_vaild_predict1(index_show),yang_str3{1,1},'Color',color_list(rand_list1(2),:),'LineWidth',Line_Width(i),'MarkerSize',makesize)	
hold (gca,'on')	
title('验证集测试效果')	
	
 set(gca,'FontName',FontName,'FontSize',FontSize,'LineWidth',kuang_width)	
	
 xlabel(xlabel1)	
ylabel(ylabel1)	
legend(legend1)	
	
 box(gca,box1) 	
 legend(gca,le_kuang) %图例框消失	
grid(gca,grid1)	

4.2 优化问题
线性规划：

研究线性约束条件下线性目标函数的极值问题的数学理论和方法。英文缩写LP。它是运筹学的一个重要分支，广泛应用于军事作战、经济分析、经营管理和工程技术等方面。建模方法：列出约束条件及目标函数；画出约束条件所表示的可行域；在可行域内求目标函数的最优解及最优值。

非线性规划:

非线性规划是具有非线性约束条件或目标函数的数学规划，是运筹学的一个重要分支。非线性规划研究一个 n元实函数在一组等式或不等式的约束条件下的极值问题，且 目标函数和约束条件至少有一个是未知量的非线性函数。目标函数和约束条件都是 线性函数的情形则属于线性规划。

整数规划：

规划中的变量（全部或部分）限制为整数，称为整数规划。若在线性模型中，变量限制为整数，则称为整数线性规划。目前所流行的求解整数规划的方法往往只适用于整数线性规划。一类要求问题的解中的全部或一部分变量为整数的数学规划。从约束条件的构成又可细分为线性，二次和非线性的整数规划。

动态规划：

包括背包问题、生产经营问题、资金管理问题、资源分配问题、最短路径问题和复杂系统可靠性问题等。

动态规划主要用于求解以时间划分阶段的动态过程的优化问题，但是一些与时间无关的静态规划(如线性规划、非线性规划)，只要人为地引进时间因素，把它视为多阶段决策过程，也可以用动态规划方法方便地求解。

多目标规划：

多目标规划是数学规划的一个分支。研究多于一个的目标函数在给定区域上的最优化。任何多目标规划问题，都由两个基本部分组成：

（1）两个以上的目标函数；
（2）若干个约束条件。有n个决策变量，k个目标函数， m个约束方程，则：

Z=F(X）是k维函数向量，Φ（X）是m维函数向量；G是m维常数向量；

4.3 预测问题

回归拟合预测

拟合预测是建立一个模型去逼近实际数据序列的过程，适用于发展性的体系。建立模型时，通常都要指定一个有明确意义的时间原点和时间单位。而且，当t趋向于无穷大时，模型应当仍然有意义。将拟合预测单独作为一类体系研究，其意义在于强调其唯“象”性。一个预测模型的建立，要尽可能符合实际体系，这是拟合的原则。拟合的程度可以用最小二乘方、最大拟然性、最小绝对偏差来衡量。

灰色预测

灰色预测是就灰色系统所做的预测。是一种对含有不确定因素的系统进行预测的方法。灰色预测通过鉴别系统因素之间发展趋势的相异程度，即进行关联分析，并对原始数据进行生成处理来寻找系统变动的规律，生成有较强规律性的数据序列，然后建立相应的微分方程模型，从而预测事物未来发展趋势的状况。其用等时距观测到的反映预测对象特征的一系列数量值构造灰色预测模型，预测未来某一时刻的特征量，或达到某一特征量的时间。

马尔科夫预测：是一种可以用来进行组织的内部人力资源供给预测的方法.它的基本 思想是找出过去人事变动的 规律,以此来推测未来的人事变动趋势.转换矩阵实际上是转换概率矩阵,描述的是组织中员工流入,流出和内部流动的整体形式,可以作为预测内部劳动力供给的基础.

BP神经网络预测

BP网络（Back-ProPagation Network）又称反向传播神经网络， 通过样本数据的训练，不断修正网络权值和阈值使误差函数沿负梯度方向下降，逼近期望输出。它是一种应用较为广泛的神经网络模型，多用于函数逼近、模型识别分类、数据压缩和时间序列预测等。

支持向量机法

支持向量机(SVM)也称为支持向量网络[1]，是使用分类与回归分析来分析数据的监督学习模型及其相关的学习算法。在给定一组训练样本后，每个训练样本被标记为属于两个类别中的一个或另一个。支持向量机(SVM)的训练算法会创建一个将新的样本分配给两个类别之一的模型，使其成为非概率二元线性分类器(尽管在概率分类设置中，存在像普拉托校正这样的方法使用支持向量机)。支持向量机模型将样本表示为在空间中的映射的点，这样具有单一类别的样本能尽可能明显的间隔分开出来。所有这样新的样本映射到同一空间，就可以基于它们落在间隔的哪一侧来预测属于哪一类别。

4.4 评价问题

层次分析法：是指将一个复杂的 多目标决策问题 作为一个系统，将目标分解为多个目标或准则，进而分解为多指标（或准则、约束）的若干层次，通过定性指标模糊量化方法算出层次单排序（权数）和总排序，以作为目标（多指标）、多方案优化决策的系统方法。

优劣解距离法又称理想解法，是一种有效的多指标评价方法。这种方法通过构造评价问题的正理想解和负理想解，即各指标的最大值和最小值，通过计算每个方案到理想方案的相对贴近度，即靠近正理想解和远离负理想解的程度，来对方案进行排序，从而选出最优方案。

模糊综合评价法：是一种基于模糊数学的综合评标方法。 该综合评价法根据模糊数学的隶属度理论把定性评价转化为定量评价，即用模糊数学对受到多种因素制约的事物或对象做出一个总体的评价。 它具有结果清晰,系统性强的特点,能较好地解决模糊的、难以量化的问题,适合各种非确定性问题的解决。

灰色关联分析法（灰色综合评价法）

对于两个系统之间的因素，其随时间或不同对象而变化的关联性大小的量度，称为关联度。在系统发展过程中，若两个因素变化的趋势具有一致性，即同步变化程度较高，即可谓二者关联程度较高；反之，则较低。因此，灰色关联分析方法，是根据因素之间发展趋势的相似或相异程度，亦即“灰色关联度”，作为衡量因素间关联程度的一种方法。

典型相关分析法：是对互协方差矩阵的一种理解，是利用综合变量对之间的相关关系来反映两组指标之间的整体相关性的多元统计分析方法。它的基本原理是：为了从总体上把握两组指标之间的相关关系，分别在两组变量中提取有代表性的两个综合变量U1和V1（分别为两个变量组中各变量的线性组合），利用这两个综合变量之间的相关关系来反映两组指标之间的整体相关性。

主成分分析法（降维）

是一种统计方法。通过正交变换将一组可能存在相关性的变量转换为一组线性不相关的变量，转换后的这组变量叫主成分。在用统计分析方法研究多变量的课题时，变量个数太多就会增加课题的复杂性。人们自然希望变量个数较少而得到的信息较多。在很多情形，变量之间是有一定的相关关系的，当两个变量之间有一定相关关系时，可以解释为这两个变量反映此课题的信息有一定的重叠。主成分分析是对于原先提出的所有变量，将重复的变量（关系紧密的变量）删去多余，建立尽可能少的新变量，使得这些新变量是两两不相关的，而且这些新变量在反映课题的信息方面尽可能保持原有的信息。设法将原来变量重新组合成一组新的互相无关的几个综合变量，同时根据实际需要从中可以取出几个较少的综合变量尽可能多地反映原来变量的信息的统计方法叫做主成分分析或称主分量分析，也是数学上用来降维的一种方法。

因子分析法（降维）

因子分析是指研究从变量群中提取共性因子的统计技术。最早由英国心理学家C.E.斯皮尔曼提出。他发现学生的各科成绩之间存在着一定的相关性，一科成绩好的学生，往往其他各科成绩也比较好，从而推想是否存在某些潜在的共性因子，或称某些一般智力条件影响着学生的学习成绩。因子分析可在许多变量中找出隐藏的具有代表性的因子。将相同本质的变量归入一个因子，可减少变量的数目，还可检验变量间关系的假设。

BP神经网络综合评价法

是一种按误差逆传播算法训练的多层前馈网络，是应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hide layer)和输出层(output layer)。

5 建模资料

若有需要请联系：

建模忠哥小师妹