网络拓扑结构5-9-1读取数据库并训练预测(实际数值)

1、用20个样本进行训练，结果还可以。现在用80个样本进行试验，前79训练，最后一个测试。

2、数据库的设计和数据的采集

CREATE TABLE `test`.`table722` (
  `ID` INTEGER ,
  `sun` varchar(20) NOT NULL,
  `temprature` varchar(20) NOT NULL,
  `airpress` varchar(20) NOT NULL,
  `PH` varchar(20) NOT NULL,
  `humidity` varchar(20) NOT NULL,
  `DO` varchar(20) NOT NULL
);

insert into table722 values(1,1.29,29.69,83.84,101.11,28.48,7.64);
insert into table722 values(2,4.59,29.75,83.62,101.09,28.49,7.68);
insert into table722 values(3,15.35,29.79,82.91,101.04,28.49,7.77);
insert into table722 values(4,23.68,29.81,82.39,101.06,28.49,7.81);
insert into table722 values(5,48.59,29.83,83.39,101.06,28.5,7.85);
insert into table722 values(6,77.34,29.85,82.56,101.02,28.5,7.9);
insert into table722 values(7,110.79,29.89,81.74,101.05,28.51,7.95);
insert into table722 values(8,96.43,29.93,81.84,101.08,28.52,7.89);
insert into table722 values(9,75.58,29.93,82.55,101.06,28.53,7.99);
insert into table722 values(10,74.19,29.98,82.34,101.02,28.55,8.04);
insert into table722 values(11,89.57,30.08,81.87,101.02,28.55,8.08);
insert into table722 values(12,118.98,30.15,81.53,101.07,28.56,8.06);
insert into table722 values(13,141.22,30.18,81.29,101.03,28.57,8.07);
insert into table722 values(14,147.36,30.21,81.67,101.01,28.58,8.24);
insert into table722 values(15,165.66,30.19,81.2,101.01,28.59,8.37);
insert into table722 values(16,168.48,30.18,82.15,100.99,28.6,8.44);
insert into table722 values(17,181.14,30.17,81.66,100.97,28.62,8.49);
insert into table722 values(18,254.82,30.32,81.4,101.02,28.62,8.6);
insert into table722 values(19,355.18,30.41,81.24,101.02,28.62,8.67);
insert into table722 values(20,407.93,30.19,81.15,101.05,28.64,8.76);
insert into table722 values(21,583.07,30.05,82.66,101.04,28.65,8.86);
insert into table722 values(22,378.83,29.75,83.37,101.03,28.67,8.98);
insert into table722 values(23,186.47,29.68,83.88,101.06,28.73,8.99);
insert into table722 values(24,129.34,29.71,83.58,101.05,28.74,9.07);
insert into table722 values(25,114.34,29.81,82.44,101.1,28.76,9.16);
insert into table722 values(26,114.59,29.88,82.65,101.05,28.79,9.11);
insert into table722 values(27,138.02,29.97,80.39,101.06,28.81,9.16);
insert into table722 values(28,171.79,29.98,81.34,101.1,28.85,9.27);
insert into table722 values(29,213.03,30.03,79.97,101.06,28.87,9.34);
insert into table722 values(30,231.21,30.1,79.36,101.11,28.88,9.42);
insert into table722 values(31,270.61,30.14,79.29,101.09,28.9,9.46);
insert into table722 values(32,321.15,30.17,79.08,101.11,28.9,9.51);
insert into table722 values(33,356.5,30.11,80.86,101.14,28.91,9.53);
insert into table722 values(34,532.65,30.04,80.29,101.12,28.94,9.61);
insert into table722 values(35,470.11,29.94,80.71,101.12,28.96,9.71);
insert into table722 values(36,476.81,29.74,80.46,101.13,28.98,9.78);
insert into table722 values(37,384.34,29.6,82.93,101.2,28.99,9.83);
insert into table722 values(38,412.85,29.45,83.48,101.13,29,9.83);
insert into table722 values(39,493.85,29.28,84.22,101.13,29.03,9.87);
insert into table722 values(40,383.12,29.16,84.96,101.15,29.05,9.96);
insert into table722 values(41,271.73,29.13,84.66,101.16,29.06,10.07);
insert into table722 values(42,266,29.16,84.38,101.17,29.1,10.08);
insert into table722 values(43,284,29.06,83.87,101.15,29.13,10.22);
insert into table722 values(44,261.72,29.02,84.5,101.14,29.14,10.12);
insert into table722 values(45,265.55,28.91,85.14,101.16,29.13,10.1);
insert into table722 values(46,239.26,28.78,85.44,101.19,29.1,10.07);
insert into table722 values(47,206.73,28.65,86.53,101.21,29.1,10.09);
insert into table722 values(48,206.21,28.56,86.38,101.21,29.11,10.23);
insert into table722 values(49,180.27,28.46,86.47,101.17,29.11,10.34);
insert into table722 values(50,156.83,28.37,87.25,101.21,29.12,10.41);
insert into table722 values(51,141.05,28.42,87.59,101.15,29.13,10.31);
insert into table722 values(52,144.12,28.45,86.61,101.14,29.14,10.19);
insert into table722 values(53,146.11,28.43,87.69,101.18,29.14,10.25);
insert into table722 values(54,139.09,28.41,86.11,101.17,29.14,10.4);
insert into table722 values(55,158.82,28.42,87.01,101.17,29.14,10.65);
insert into table722 values(56,173.53,28.38,86.95,101.13,29.14,10.83);
insert into table722 values(57,156.01,28.37,87.02,101.16,29.14,10.87);
insert into table722 values(58,145.03,28.31,87.24,101.13,29.14,10.86);
insert into table722 values(59,123.67,28.34,86.82,101.12,29.14,10.77);
insert into table722 values(60,155.58,28.31,87.09,101.16,29.14,10.79);
insert into table722 values(61,174.7,28.38,87.39,101.16,29.14,10.85);
insert into table722 values(62,156.73,28.31,86.6,101.16,29.15,10.94);
insert into table722 values(63,135.88,28.33,87.47,101.14,29.17,11.05);
insert into table722 values(64,162.99,28.29,87.12,101.17,29.19,11.15);
insert into table722 values(65,149.07,28.2,88.31,101.18,29.18,11.31);
insert into table722 values(66,130.4,28.13,88.34,101.13,29.17,11.35);
insert into table722 values(67,105.98,28.09,88.88,101.16,29.19,11.31);
insert into table722 values(68,83.92,28.06,88.8,101.12,29.18,11.33);
insert into table722 values(69,65.11,28.03,89,101.16,29.22,11.21);
insert into table722 values(70,68.23,28.03,88.97,101.12,29.2,11.38);
insert into table722 values(71,72.93,28.07,89.2,101.16,29.23,11.56);
insert into table722 values(72,60.84,27.98,88.85,101.13,29.24,11.6);
insert into table722 values(73,45.47,28.01,89.57,101.12,29.23,11.52);
insert into table722 values(74,45.43,27.98,88.84,101.13,29.24,11.42);
insert into table722 values(75,34.25,27.87,89.73,101.14,29.24,11.48);
insert into table722 values(76,25.9,27.84,89.66,101.09,29.3,11.49);
insert into table722 values(77,18.41,27.82,90.09,101.08,29.24,11.26);
insert into table722 values(78,9.41,27.77,90.15,101.13,29.36,11.85);
insert into table722 values(79,8.3,27.93,89.91,101.1,29.47,11.81);
insert into table722 values(80,4.22,27.95,89.07,101.1,28.74,10.35);

3、程序实现

package pa;    
import java.sql.*;  
  
public class BP{  
  
    public static int M=80;  //记录条数   
    public static int N=6;  //字段个数   
    public static double Data[][]=new double[M][N]; //从数据库中读取的原始数据，并归一化   
    public static double Max[]=new double[N];   //各个字段的最大值，归一化和反归一化时要用到   
    public static double Min[]=new double[N];   //各个字段的最小值，归一化和反归一化时要用到   
      
    public static double Step=0.01;    //学习步长
    public static int TrainTimes=500;  //学习次数 
    public static int L0=5; //输入层节点数   
    public static int L1=9; //隐层节点数   
    public static int L2=1; //输出层节点数   
      
    public static double Weight01[][]=new double[L0][L1];  
    public static double Weight12[][]=new double[L1][L2];  
    public static double Threshold1[]=new double[L1];  
    public static double Threshold2[]=new double[L2];  
      
    /*函数说明 
     * public static void getData()//准备数据 
     * public static void reflect()//将数据归一化处理
     * public static void checkData()//检验数据是否有丢失。若有，用前六组的数据补充
     * public static void init()//初始化权值和阈值 
     * public static double transfer(double x)//传递函数 
     * public static double train(double i1 ,double i2,double i3, double i4,double i5,double d) 
     *      训练函数。输入参数是归一化处理之后的数据，返回正向传播的结果 
     * public static double run(double i1,double i2,double i3,double i4,double i5) 
     *      测试函数。输入参数是归一化处理之后的数据，返回值也是归一化的。和实际值进行比较，需要反归一化 
     *  public static void print()//打印所有的权值和阈值 
     *   public static void printData() //打印数据Data[][]的内容
     * public static void main(String[] args) //主函数，负责调用训练函数和测试函数，输出测试的结果 
     */  
    //测试yx的数据2011-7-22
    public static void getData()  
    {  
        //从数据库中读取   
        String driverName="com.mysql.jdbc.Driver";//驱动程序名   
        String userName="root";//数据库用户名   
        String userPasswd="xhp";//密码   
        String dbName="test";//数据库名   
        String tableName="table722";//表名   
        try  
        {  
            String url="jdbc:mysql://localhost/"+dbName+"?user="+userName+"&password="+userPasswd;//连接字符串  
            Class.forName(driverName);  
            Connection connection=DriverManager.getConnection(url);  
            Statement statement = connection.createStatement();       
            String sql="SELECT * FROM "+tableName;  
            ResultSet rs = statement.executeQuery(sql);  
            for(int i=0;i<M;i++)  
            {  
                if(rs.next())  
                {  
                    Data[i][0]=Double.parseDouble(rs.getString("sun"));  
                    Data[i][1]=Double.parseDouble(rs.getString("temprature"));  
                    Data[i][2]=Double.parseDouble(rs.getString("airpress"));  
                    Data[i][3]=Double.parseDouble(rs.getString("PH"));  
                    Data[i][4]=Double.parseDouble(rs.getString("humidity"));  
                    Data[i][5]=Double.parseDouble(rs.getString("DO"));  
                }  
            }  
            rs.close();  
            statement.close();  
            connection.close();  
        }  
        catch(ClassNotFoundException e)  
        {  
            e.printStackTrace();  
        }  
        catch(SQLException e)  
        {  
            e.printStackTrace();  
        }          
    }  
    
    public static void reflect()
    {
    	//寻找每个字段的最大值最小值   
        for(int i=0;i<N;i++)  
        {  
            Max[i]=-32767;  
            Min[i]=32767;  
            for(int j=0;j<M;j++)  
            {  
                if(Data[j][i]>Max[i])  
                {  
                    Max[i]=Data[j][i];  
                }  
                if(Data[j][i]<Min[i])  
                {  
                    Min[i]=Data[j][i];  
                }  
            }  
        }  
        //归一化处理   
        for(int i=0;i<M;i++)  
        {  
            for(int j=0;j<N;j++)  
            {  
                Data[i][j]=(Data[i][j]-Min[j])/(Max[j]-Min[j]);  
            }  
        }  
    }
    public static void checkData()
	{
		//若前6组数据有缺失的，就没有办法了（需要从数据库中重新读取，很费时间的）
		for(int i=6;i<M;i++)
		{
			for(int j=0;j<N;j++)
			{
				if(Data[i][j]==0)
					{
						double temp=0;
						for(int k=1;k<=6;k++)
						{
							temp+=Data[i-k][j];//从历史记录里面读取6组数据
						}
						Data[i][j]=(float)temp/6;//取平均值					
					}
			}
		}
	}
    public static void printData()  
    {  
        for(int i=0;i<M;i++)  
        {  
            for(int j=0;j<N;j++)  
            {  
                System.out.print(Data[i][j]+"   ");  
            }  
            System.out.println();  
        }  
    }  
    public static void init()  
    {  
        for(int i=0;i<L0;i++)  
        {  
            for(int j=0;j<L1;j++)  
            {  
                Weight01[i][j]=Math.random()*2-1;  
            }  
        }  
        for(int i=0;i<L1;i++)  
        {  
            for(int j=0;j<L2;j++)  
            {  
                Weight12[i][j]=Math.random()*2-1;  
            }  
        }  
        for(int i=0;i<L1;i++)  
        {  
            Threshold1[i]=Math.random()*2-1;  
        }  
        for(int i=0;i<L2;i++)  
        {  
            Threshold2[i]=Math.random()*2-1;  
        }  
    }  
    public static double transfer(double x)  
    {  
        return 1/(1+Math.exp(-x));  
    }  
    public static double train(double i1 ,double i2,double i3,double i4,double i5,double d)  
    {  
    	double Input[]=new double[L0];//输入层单元
    	double Hide[]=new double[L1];//隐层单元    	
        double out=0;//输出层的输出  
        //设置输入层的数值
        Input[0]=i1;
        Input[1]=i2;
        Input[2]=i3;
        Input[3]=i4;
        Input[4]=i5;
        
        //计算隐含层的神经元值，隐层的输入   
        for(int i=0;i<L1;i++)
        { 
        	for(int j=0;j<L0;j++)
        	{
        		Hide[i]+=Input[j]*Weight01[j][i];
        	}
        	Hide[i]+=Threshold1[i];
        }        
  
        //使用S函数，隐层的输出   
        for(int i=0;i<L1;i++)
        {
        	Hide[i]=transfer(Hide[i]);
        }
        
        //计算输出层的值，输出层的输入   
        for(int i=0;i<L2;i++)
        {
        	for(int j=0;j<L1;j++)
        	{
            	out+=Hide[j]*Weight12[j][i];        		
        	}
        	out+=Threshold2[i];
        }          
        
        //使用S函数，输出层的输出   
        out=transfer(out);  
  
        //计算误差，反向传播   
        double error1[]=new double[L1];//隐层的误差  
        double error2[]=new double[L2];//输出层的误差  
        	
        	//计算输出层的误差
        error2[0]=out*(1-out)*(d-out);  
  
        	//计算隐层的误差
        for(int i=0;i<L1;i++)
        {
        	error1[i]=Hide[i]*(1-Hide[i])*(Weight12[i][0])*(error2[0]);  
        }
        
        //调整阈值   ，正向调整
        	//调整隐层的阈值
        for(int i=0;i<L1;i++)
        {  
            Threshold1[i]+=Step*error1[i];  
        }  
        	//输出层的阈值
        Threshold2[0]+=Step*error2[0];  
  
        //调整权值   
        	//输入层和隐层之间的权值
        for(int i=0;i<L0;i++)
        {  
        	for(int j=0;j<L1;j++)
        	{
                Weight01[i][j]+=Step*Input[i]*error1[j];  
        	}
        }  
        	//隐层和输出层之间的权值
        for(int i=0;i<L1;i++)
        {
        	Weight12[i][0]+=Step*Hide[i]*error2[0];  
        }
        return out;  
    }  
    public static double run(double i1,double i2,double i3,double i4,double i5)  
    {  
        double Hide[]=new double[L1];
        double out=0;  
        //计算隐层的输入
        for(int i=0;i<L1;i++)
        {
            Hide[i]=1*Threshold1[i]+i1*Weight01[0][i]+i2*Weight01[1][i]+i3*Weight01[2][i]+i4*Weight01[3][i]+i5*Weight01[4][i];
        }  
        //计算隐层的输出
        for(int i=0;i<L1;i++)
        {
            Hide[i]=transfer(Hide[i]);          	
        }
        //计算输出层的输入
        for(int i=0;i<L2;i++)
        {
        	for(int j=0;j<L1;j++)
        	{
        		out+=Hide[j]*Weight12[j][i];
        	}
        	out+=Threshold2[i];
        }
        //计算输出层的输出
        return transfer(out);  
    }  
    public static void print()  
    {  
        System.out.println("权值Weight01:");  
        for(int i=0;i<L0;i++)  
        {  
            for(int j=0;j<L1;j++)  
            {  
                System.out.print(Weight01[i][j]+"   ");  
            }  
            System.out.println();  
        }  
        System.out.println("权值Weight12:");  
        for(int i=0;i<L1;i++)  
        {  
            for(int j=0;j<L2;j++)  
            {  
                System.out.print(Weight12[i][j]+"   ");  
            }  
            System.out.println();  
        }  
        System.out.println("阈值Threshold1:");  
        for(int i=0;i<L1;i++)  
        {  
            System.out.print(Threshold1[i]+"    ");  
        }  
        System.out.println("\n阈值Threshold2:");  
        for(int i=0;i<L2;i++)  
        {  
            System.out.print(Threshold2[i]+"    ");  
        }  
        System.out.println("\n权值阈值打印完毕！");  
    }  
    public static void main(String[] args)   
    {  
        getData();  
        printData();       
        reflect();
        printData(); 
        init();  
        for(int i=0;i<TrainTimes;i++)  
        {  
        	for(int j=0;j<M-1;j++)//训练前79个样本,0~78
        	{
        		train(Data[j][0],Data[j][1],Data[j][2],Data[j][3],Data[j][4],Data[j][5]); //注意期望输出是第6列
        	}
        }    
        double result=run(Data[M-1][0],Data[M-1][1],Data[M-1][2],Data[M-1][3],Data[M-1][4]);  //测试最后一个样本
        result=result*(Max[5]-Min[5])+Min[5];  
        System.out.println("预测值："+result);  
        double act=Data[M-1][5]*(Max[5]-Min[5])+Min[5];  
        System.out.println("实际值："+act);  
        /* */   
    }  
}  

4、运行结果

预测值：10.52429997102293
实际值：10.35

5、结果分析

训练集79，测试集1

步长0.01

学习次数500

网络拓扑结构5-9-1

训练前79个样本,0~78，测试最后一个样本

 

 

讨论：不知道训练集增大了如何调整参数，调整哪些参数

 

快出现准确可靠的数据吧，快出现吧~