package anfis_classify;
import com.mathworks.toolbox.javabuilder.MWException;
import classify.anfis_classify;
public class anfis_classify_class {
public static void main(String[] args) throws MWException {
  // TODO Auto-generated method stub
  anfis_classify ma = new anfis_classify();
  try{
    double [][] get_data =new double [][]{
                 {1,1,1,1,1,1} ,
                 {2,5,5,4,3,3} ,  
                  {3,3,5,3,1,2} ,
                  {4,1,1,1,1,3} ,
                  {5, 5,5,5,4,4} ,
                  {6,5,5,2,5,5} ,
                  {7,5,5,5,5,5} ,
                  {8,5,5,5,5,4} ,
                  {9,1,1,3,3,1} ,
                  {10,1,1,3,3,1} ,
                  {11,5,5,5,3,4} ,
                  {12,1,5,3,1,3} ,
                  {13,1,3,5,3,2} ,
                  {14, 2,2,2,1,1} ,
                  {15,2,2,4,5,2} ,
                  {16, 2,2,1,2,3} ,
                  {17, 5,5,5,1,4} ,
                  {18,5,2,4,4,4} ,
                  {19, 3,2,1,2,2} ,
                  {20,1,1,1,1,1 } ,
                  {21, 5,5,3,3,4} ,
                  {22,2,2,5,2,3} ,
                  {23,2,2,2,3,3} ,
                  {24,1,1,1,1,3} ,
                  {25,3,3,1,2,2} ,
                  {26,3,5,4,4,3} ,
                  {27,5,5,4,4,5} ,
                  {28,5,5,3,3,4} ,
                  {29,5,5,1,1,4 } ,
                  
                 } ;
   
    double [][] test_data =new double [][]{   
      {30,5,5,1,4,1} ,
         {11,5,5,5,3,4} ,
                   {12,1,5,3,1,3} ,
                   {13,1,3,5,3,2} ,
                   {14, 2,2,2,1,1} ,
                   {15,2,2,4,5,2} ,
                   {16, 2,2,1,2,3} ,
                   {17, 5,5,5,1,4} ,
                   {18,5,2,4,4,4} ,
                   {19, 3,2,1,2,2} ,
                   {20,1,1,1,1,1 } ,
                   {21, 5,5,3,3,4} ,
                   {22,2,2,5,2,3} ,
                   {23,2,2,2,3,3} ,
                   {24,1,1,1,1,3} ,
                   {25,3,3,1,2,2} ,
    };
   
   
    double [][] train_data =new double [][]{   
      {30,5,5,1,4,1} ,
         {11,5,5,5,3,4} ,
                   {12,1,5,3,1,3} ,
                   {13,1,3,5,3,2} ,
                   {14, 2,2,2,1,1} ,
                   {15,2,2,4,5,2} ,
                   {16, 2,2,1,2,3} ,
                   {17, 5,5,5,1,4} ,
                   {18,5,2,4,4,4} ,
                   {19, 3,2,1,2,2} ,
                   {20,1,1,1,1,1 } ,
                   {21, 5,5,3,3,4} ,
                   {22,2,2,5,2,3} ,
                   {23,2,2,2,3,3} ,
                   {24,1,1,1,1,3} ,
                   {25,3,3,1,2,2} ,
    };
   
  
    double [][] predict_data =new double [][]{   
      {30,5,5,1,4}   
    };/////这个预测的赋值，注意格式,只需要X的属性值，没有类号。  ,
   
     String  figure_path="E:\\image";///图像保存路径,特别注意，这个路径要用
    //英文的路径，不然java调用会出错。
   
      
            float  test_data_number = 2 ;//测试数据 的个数
   
            ////空值则不保存图形
           // String figure_name="rbf_time_series_figure";//图片的名称
         
            String train_figure_name="membership_functions_before_train,membership_functions_after_train,anfis_classify_train_figure,anfis_error_figure";//图片的名称
            String test_figure_name="anfis_classify_test_figure";//图片的名称
            
            float epochs=100;
            String mfType="gbellmf";//图片的名称
               
          double [][] figure_set =new double [][]{   
      { 7} ,
      {650},
      {320},
          };
            
            
          ///总函数
       System.out.println(ma.anfis_classify(4,get_data,test_data_number,predict_data,epochs,mfType,figure_path,train_figure_name,test_figure_name,figure_set)[3]);
        
            ///训练函数  
    // System.out.println(ma.anfis_train(8,train_data,test_data,epochs,mfType,figure_path,train_figure_name,figure_set)[0]);
      
           ///测试函数
    /*     Object  ob[]=ma.anfis_train(8,train_data,test_data,epochs,mfType,figure_path,train_figure_name,figure_set);
        
         Object  chkFis = ob[3];
         
       System.out.println(ma.anfis_test(2,test_data,chkFis,figure_path,test_figure_name,figure_set)[0]);
       */
      
         
       ///预测函数
       /*  Object  ob[]=ma.anfis_train(8,train_data,test_data,epochs,mfType,figure_path,train_figure_name,figure_set);
            
            Object  Fis = ob[0];
       System.out.println(ma.anfis_predict(1,predict_data,Fis)[0]);
*/
        
  }
  catch(Exception ex){
   ex.printStackTrace();
  }
}


}
****************************************************************************
function[ptrnTestAcc,ptrnTest,ppre,allInfo] = anfisClassify(getD,tstDNum,preD,trnPara,mfType,figPath,trnFigName,tstFigName,figSet)
%% 相关参数说明
%%%使用自适应神经网络模糊推理系统（anfis）预测方法进行分类，
%%%输入参数
%tstDNum，数据库中，用于参与测试（检验的）实际值的个数
%mfType='gbellmf';  %输入隶属度函数类型
%隶属度函数的类型主要由：trimf(三角形)，trapmf(梯形),gbellmf(钟型),gaussmf(高斯型),gauss2mf(高斯2性),
%sigmf(s型),dsigmf
%(s和型),psigmf(s积型),pimf(π型),
% 网络训练参数trnPara，参数意义:训练次数，期望误差，初始步长，步长递减率，步长递增率，隶属度函数个数，默认值[100;0.0001;0.01;0.09;1.1;2]。
%FLEX界面上模型训练参数排序：
% 1-训练次数
% 2-期望误差
% 3-初始步长
% 4-步长递减率
% 5-步长递增率
% 6-隶属度函数类型（下拉框选）
% 7-隶属度函数个数

%preD,要进行模型预测的X影响值，这个值的赋值要和建模的影响因素的X赋值格式一致。
%figPath 生成图形保存路径,格式如'E:\image'，还需要在相应路径下创建文件夹,特别注意，这个路径要用
%英文的路径，不然java调用会出错。
%trnFigName，训练阶段的图形
%tstFigName，测试阶段的图形
%figSet图形设置，格式如figSet=[7;650;320];7%图形字体大小，650图形长度，320图形宽度
%%%输出参数
%ppre,预测值
%ptrnTest,建模阶段和测试阶段的预测值
%ptrnTestErr,建模阶段,测试阶段的相对误差百分比
%allInfo   重要信息输出
%% 相关数据赋值，这只在程序调试阶段用，实际通过参数传递
%getD,读入数据，第一列为ID，不参与建模，第二列为建模的时间序列数据。
tstDNum=50;
mfType='gbellmf';
epochs=100;
figPath='E:\image';
%trnFigName='membership_functions_before_train,membership_functions_after_train,anfis_classify_train_figure,anfis_error_figure';%第一张图片的名称
trnFigName='a,b,c,d,e,f';%第一张图片的名称
%tstFigName='anfis_classify_test_figure'; %第4张图片的名称
tstFigName='g,h'; %第4张图片的名称
preD=[111 1 1 1  1; 3333 2 2 2 2 ];
%  %predict_data=[];
figSet=[7;650;320];
numeric=1;
fldName='fld1,fld2,fld3';
%% 数据读取
close all;
    [getD]=xlsread('data.xls','data');
    getD=getD(:,4:end);%获数据，
%读入数据，第一列为ID，不参与建模，最后一列为输出。
[x_m,x_n]=size(getD);
%%%%%参与建模的数据个数=数据库的总个数-用于检验的数据个数_ 陈东清
netDNum=x_m-tstDNum;
%%% 整理建模所需要数据
trnD=getD(1:netDNum,:);%%%建模所需要的所有数据
tstD=getD(netDNum+1:end,:);%%%%测试所需要的所有数据
% 网络训练参数
trnPara=[100;0.0001;0.01;0.09;1.1;2];
%参数意义:训练次数，期望误差，初始步长，步长递减率，步长递增率，隶属度函数个数。
%% 模型训练
[Fis, error, stepSize, chkFis, chkEr,ptrn,trnAcc,anfisTrnInfo]=anfisTrain(numeric,fldName,trnD,tstD,trnPara,mfType,figPath,trnFigName,figSet);
% exhsrch(1, trnD,tstD)
%% 模型测试
[ptst,tstAcc]=anfisTest(numeric,tstD,chkFis,figPath,tstFigName,figSet);

%% 模型预测
if length(preD)~=0
    [ppre]=anfisPredict(preD,Fis);
else
    ppre=[];
end
%% % %% 把数据保存成EXCEL文件
% max_line=x_m+10;%最大行数
% x=[blanks(max_line)' blanks(max_line)'  blanks(max_line)'  blanks(max_line)'];
% xlswrite('data.xls',x,'data_test');%清空EXCEL文件
ptrnTest=[ptrn;ptst];%%建模和测试的预测值
ptrnTestAcc=[trnAcc;tstAcc];%%建模和测试的预测值相对误差
% data_out=[getD ptrnTest];
% xlswrite('data.xls',data_out,'data_test');%%建模和测试的预测值
allInfo=[anfisTrnInfo];
end

*********************************************************
function[ppre]=anfisPredict(preD,Fis)
%%%anfis模型进行预测
preD=preD(:,2:end);
%% %计算训练后神经模糊系统的输出
ppre=evalfis(preD,Fis);%训练后神经模糊系统输出
%ppre= round(ppre);%进行四舍五入，计算归属类

end
*****************************************************
function [] = anfisStructure(fldName,membershipGrade, figPath, figName, figSet)
%%trnInputNum, 输入节点数
%%membershipGrade , 隶属度
%figPath 生成图形保存路径,格式如'E:\image'，还需要在相应路径下创建文件夹,特别注意，这个路径要用
%英文的路径，不然java调用会出错。
%figName 生成图片名称，格式如  'fuzzy_neural_network.png'。
%figSet图形设置，格式如figSet=[7;650;320];7%图形字体大小，650图形长度，320图形宽度
f1=figure('Name','测试样本误差图','NumberTitle','off','MenuBar','none');
set(gca, 'fontname','隶书');
hold on
%% 相关数据赋值，这只在程序调试阶段用，实际通过参数传递
%membershipGrade = 2;
%figPath = 'E:\image';
%figNName = 'anfis.png';
%fldName = '属性一,属性二,属性三,属性四,输出';
%figSet = [7;650;320];
%图片设置赋值
fontSize=figSet(1);
figLength=figSet(2);
figWidth=figSet(3);
fldName = regexp(fldName, ',', 'split');
%%-------------------------------
trnInputNum=size(fldName,2)-1;
I = trnInputNum;      %输入节点数
M = membershipGrade;  %隶属度
%构建R = 0.5的圆
R = 0.3;
s = 0 : .1 : 2*pi;
x = R*cos(s);
y = R*sin(s);  
t = 6;   %间隔距离
fldName1 = {'输入层', '第一层', '第二层', '第三层', '第四层', '输出层'};
for node1 = I : -1 : 1
    f(node1) = plot(x + 0, y + node1*M*M*M/(I+1), 'k');
    text(0 - 2, node1*M*M*M/(I+1), '\rightarrow', 'fontsize', 12);
    text(0 - 3, node1*M*M*M/(I+1) + R,fldName{node1}, 'fontsize', fontSize);
    for node2 = I*M : -1 : 1
        if  node2 < (node1*M + 1) && node2 > (node1 - 1)*M                                       
            plot([0 + R, t - R], [node1*M*M*M/(I+1), node2*M*M*M/(I*M + 1)], 'k');                                 
        end
        
    end
end
for node2 = I*M : -1 : 1  
    f(node2)=plot(x + t, y + node2*M*M*M/(I*M + 1), 'k');
    for node3 = M*M*M : -1 : 1            
        for node_m = 1:M            
            if node_m == M
                if node3 < M*M*node_m + 1 && node3 > M*M*(node_m - 1) && mod(node2, M) == 0                           
                    plot([t + R, 2*t - R], [node2*M*M*M/(I*M + 1), node3], 'k');
                end
            else
                if node3 < M*M*node_m + 1 && node3 > M*M*(node_m - 1) && mod(node2, M) == node_m               
                    plot([t + R, 2*t - R], [node2*M*M*M/(I*M + 1), node3], 'k');           
                end
            end
        end
    end
end
for node3 = M*M*M : -1 : 1   
    f(node3) = plot(x + 2*t, y + node3, 'k');
    for node4 = M*M*M : -1 : 1               
        if node3 == node4                    
            plot([2*t + R, 3*t - R], [node3, node4], 'k');               
        end
    end
end
            
for node4 = M*M*M : -1 : 1
    f(node4) = plot(x + 3*t, y + node4, 'k');
    for node5 = 1
        f(node5) = plot(x + 4*t, y + (M*M*M + 1)/2, 'k');                       
        plot([3*t + R, 4*t - R], [node4, (M*M*M+1)/2], 'k');               
    end
end
     
plot(x + 5*t, y + (M*M*M + 1)/2, 'k'); %输出结点
plot([4*t + R, 5*t - R], [(M*M*M + 1)/2, (M*M*M + 1)/2], 'k');
text(5*t + R + 0.1, (M*M*M + 1)/2, '\rightarrow', 'fontsize', 12);
text(5*t + R + 0.1, (M*M*M + 1)/2 + R, fldName{end}, 'fontsize', fontSize);
for fn = 1 : length(fldName1)        
    text((fn)*t - 8, -1, fldName1(fn), 'fontsize', fontSize);
end
title('自适应神经网络结构图','fontsize',1.3*fontSize);
axis([-3 (5*t + R + 2) -2 (M*M*M + 2*R)]);
axis off
set(f1, 'PaperPositionMode', 'auto', 'Position', [100,200, figLength, figWidth]);
set(f1, 'visible', 'off');%%使图形不跳出界面
%% 生成图像文件
if isempty(figName) == 0  %%%如果文件名，不为空的时候，就保存图形，否则不保存     
    figPathName = strcat(figPath, '\', figName);
    print(f1, '-dpng', figPathName); %将图形保存为jpeg/jpg格式的图片。
end
end