精华内容
下载资源
问答
  • 多元线性回归java实现

    2017-11-28 16:08:08
    根据随机变量y及自变量x0,x1...xm-1的n组观测值做线性回归分析,简单实例,有注释,Java实现
  • 本资源包含了收集到的”多元线性回归“算法的介绍文档、Java实现以及Excel多元线性回归分析功能的使用方法。并基于同一份数据,分别用来源于网络的2种Java代码、Excel进行了计算,并对3者的计算结果进行了比较,以...
  • Java完成多元线性回归相关算法编程。资源是从百度文库上下载的https://wenku.baidu.com/view/070d30eb988fcc22bcd126fff705cc1755275f61.html。
  • java 实现的多元线性回归分析

    热门讨论 2008-12-23 13:09:21
    java 实现的一元线性回归、多元线性回归 采用最小二乘法
  • import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class LinearRegression { /* * 训练数据示例: * x0 x1 x2 ...
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.io.IOException;
     
    public class LinearRegression {
        /*
         * 训练数据示例:
         *   x0        x1        x2        y
            1.0       1.0       2.0       7.2
            1.0       2.0       1.0       4.9
            1.0       3.0       0.0       2.6
            1.0       4.0       1.0       6.3
            1.0       5.0      -1.0       1.0
            1.0       6.0       0.0       4.7
            1.0       7.0      -2.0      -0.6
            注意!!!!x1,x2,y三列是用户实际输入的数据,x0是为了推导出来的公式统一,特地补上的一列。
            x0,x1,x2是“特征”,y是结果
     
            h(x) = theta0 * x0 + theta1* x1 + theta2 * x2
     
            theta0,theta1,theta2 是想要训练出来的参数
     
             此程序采用“梯度下降法”
     
         *
         */
     
        private double [][] trainData;//训练数据,一行一个数据,每一行最后一个数据为 y
        private int row;//训练数据  行数
        private int column;//训练数据 列数
     
        private double [] theta;//参数theta
     
        private double alpha;//训练步长
        private int iteration;//迭代次数
     
        public LinearRegression(String fileName)
        {
            int rowoffile=getRowNumber(fileName);//获取输入训练数据文本的   行数
            int columnoffile = getColumnNumber(fileName);//获取输入训练数据文本的   列数
     
            trainData = new double[rowoffile][columnoffile+1];//这里需要注意,为什么要+1,因为为了使得公式整齐,我们加了一个特征x0,x0恒等于1
            this.row=rowoffile;
            this.column=columnoffile+1;
     
            this.alpha = 0.001;//步长默认为0.001
            this.iteration=100000;//迭代次数默认为 100000
     
            theta = new double [column-1];//h(x)=theta0 * x0 + theta1* x1 + theta2 * x2 + .......
            initialize_theta();
     
            loadTrainDataFromFile(fileName,rowoffile,columnoffile);
        }
        public LinearRegression(String fileName,double alpha,int iteration)
        {
            int rowoffile=getRowNumber(fileName);//获取输入训练数据文本的   行数
            int columnoffile = getColumnNumber(fileName);//获取输入训练数据文本的   列数
     
            trainData = new double[rowoffile][columnoffile+1];//这里需要注意,为什么要+1,因为为了使得公式整齐,我们加了一个特征x0,x0恒等于1
            this.row=rowoffile;
            this.column=columnoffile+1;
     
            this.alpha = alpha;
            this.iteration=iteration;
     
            theta = new double [column-1];//h(x)=theta0 * x0 + theta1* x1 + theta2 * x2 + .......
            initialize_theta();
     
            loadTrainDataFromFile(fileName,rowoffile,columnoffile);
        }
     
        private int getRowNumber(String fileName)
        {
            int count =0;
            File file = new File(fileName);
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(file));
                while ( reader.readLine() != null)
                    count++;
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e1) {
                    }
                }
            }
            return count;
     
        }
     
        private int getColumnNumber(String fileName)
        {
            int count =0;
            File file = new File(fileName);
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(file));
                String tempString = reader.readLine();
                if(tempString!=null)
                    count = tempString.split(" ").length;
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e1) {
                    }
                }
            }
            return count;
        }
     
        private void initialize_theta()//将theta各个参数全部初始化为1.0
        {
            for(int i=0;i<theta.length;i++)
                theta[i]=1.0;
        }
     
        public void trainTheta()
        {
            int iteration = this.iteration;
            while( (iteration--)>0 )
            {
                    //对每个theta i 求 偏导数
                double [] partial_derivative = compute_partial_derivative();//偏导数
                    //更新每个theta
                for(int i =0; i< theta.length;i++)
                    theta[i]-= alpha * partial_derivative[i];
            }
        }
     
        private double [] compute_partial_derivative()
        {
            double [] partial_derivative = new double[theta.length];
            for(int j =0;j<theta.length;j++)//遍历,对每个theta求偏导数
            {
                partial_derivative[j]= compute_partial_derivative_for_theta(j);//对 theta i 求 偏导
            }
            return partial_derivative;
        }
        private double compute_partial_derivative_for_theta(int j)
        {
            double sum=0.0;
            for(int i=0;i<row;i++)//遍历 每一行数据
            {
                sum+=h_theta_x_i_minus_y_i_times_x_j_i(i,j);
            }
            return sum/row;
        }
        private double h_theta_x_i_minus_y_i_times_x_j_i(int i,int j)
        {
            double[] oneRow = getRow(i);//取一行数据,前面是feature,最后一个是y
            double result = 0.0;
     
            for(int k=0;k< (oneRow.length-1);k++)
                result+=theta[k]*oneRow[k];
            result-=oneRow[oneRow.length-1];
            result*=oneRow[j];
            return result;
        }
        private double [] getRow(int i)//从训练数据中取出第i行,i=0,1,2,。。。,(row-1)
        {
            return trainData[i];
        }
     
        private void loadTrainDataFromFile(String fileName,int row, int column)
        {
            for(int i=0;i< row;i++)//trainData的第一列全部置为1.0(feature x0)
                trainData[i][0]=1.0;
     
            File file = new File(fileName);
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(file));
                String tempString = null;
                int counter = 0;
                while ( (counter<row) && (tempString = reader.readLine()) != null) {
                    String [] tempData = tempString.split(" ");
                    for(int i=0;i<column;i++)
                        trainData[counter][i+1]=Double.parseDouble(tempData[i]);
                    counter++;
                }
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }
     
        public void printTrainData()
        {
            System.out.println("Train Data:\n");
            for(int i=0;i<column-1;i++)
                System.out.printf("%10s","x"+i+" ");
            System.out.printf("%10s","y"+" \n");
            for(int i=0;i<row;i++)
            {
                for(int j=0;j<column;j++)
                {
                    System.out.printf("%10s",trainData[i][j]+" ");
                }
                System.out.println();
            }
            System.out.println();
        }
     
        public void printTheta()
        {
            for(double a:theta)
                System.out.print(a+" ");
        }
     
    }
    

     

    测试类:

    public class TestLinearRegression {
     
        public static void main(String[] args) {
            // TODO Auto-generated method stub
             LinearRegression m = new LinearRegression("trainData",0.001,1000000);
             m.printTrainData();
             m.trainTheta();
             m.printTheta();
        }
     
    }
    

     

    参考地址:

    https://www.bbsmax.com/A/xl563Y21dr/

    展开全文
  • java实现多元线性回归

    2021-03-13 14:52:12
    } 打印的结果: 0.9304953560371505 0.38761609907120753 1.2626934984520124 数组beta中的值按顺序依次代表回归方程中的常量、x1系数、x2系数,因此,最终的回归方程为: y=0.93+0.3876x1+1.263x2 y=0.93+0.3876x_...

    一个例子

    约翰逊过滤股份公司对遍布南佛罗里达州的水过滤系统提供维修保养服务。当顾客的水过滤系统出现故障时,他们就要与约翰逊公司进行联系,请求公司对他们的水过滤系统进行维修。为了估计服务时间和服务成本,约翰逊公司的管理人员希望对顾客的每一次维修请求预测必要的维修时间。所以,按小时计算的维修时间是因变量。管理人员认为,维修时间依赖两个因素:从最近一次维修服务至今水过滤系统已经使用的时间和需要维修的故障类型。由10次维修服务组成一个样本,有关资料数据如下1

    维修服务请求最近一次维修服务至今的时间(x1维修的故障类型(x2维修时间(y1
    1212.9
    2603.0
    3814.8
    4301.8
    5212.9
    6714.9
    7904.2
    8804.8
    9414.4
    10614.5

    分析计算

    我们计算利用的工具是Apache Commons Math2

    准备数据
    OLSMultipleLinearRegression oregression = new OLSMultipleLinearRegression();
    		double[] y = new double[]{2.9, 3.0, 4.8, 1.8, 2.9,4.9,4.2,4.8,4.4,4.5};
    		double[][] x = new double[10][2];
    		x[0] = new double[]{2, 1};
    		x[1] = new double[]{6, 0};
    		x[2] = new double[]{8, 1};
    		x[3] = new double[]{3, 0};
    		x[4] = new double[]{2, 1};
    		x[5] = new double[]{7, 1};
    		x[6] = new double[]{9, 0};
    		x[7] = new double[]{8, 0};
    		x[8] = new double[]{4, 1};
    		x[9] = new double[]{6, 1};
    

    y代表的是维修时间,为因变量;二维数组x代表最近一次维修服务至今的时间和故障类型,为自变量,其中数字10 表示维修服务的请求次数,也即样本的数量,数字2表示自变量的个数(这里例子中有2个变量:x1,x2),每个一维数组对应一组自变量的值。

    计算
    oregression.newSampleData(y, x);
    
    查看结果

    模型参数

    double[] beta = oregression.estimateRegressionParameters();
    for (double d : beta) {
    	System.out.println(d);
    }
    

    打印的结果:

    0.9304953560371505
    0.38761609907120753
    1.2626934984520124
    

    数组beta中的值按顺序依次代表回归方程中的常量、x1系数、x2系数,因此,最终的回归方程为:
    y = 0.93 + 0.3876 x 1 + 1.263 x 2 y=0.93+0.3876x_1+1.263x_2 y=0.93+0.3876x1+1.263x2
    该方程的标准差S:

    double s = oregression.estimateRegressionStandardError();
    

    判定系数R2:

    double rSquared = oregression.calculateRSquared();
    

    参考

    - [1] 《商务与经济统计》
    - [2] http://commons.apache.org/proper/commons-math/userguide/stat.html#a1.4_Simple_regression
    展开全文
  • 多元线性回归

    2016-12-05 13:58:23
    多元线性回归模型
    一、线性模型

    x1 x2 是两个标量或维数相同的变量, α β为任意标量,则称 αx1+βx2 x1 x2 的线性组合。若 f x的线性函数,则有

    f(αx1+βx2)=αf(x1)+βf(x2)
    特别地,当 α=1β 时, αx1+βx2 x1 x2 的加权平均,而 f 的线性性质决定了加权平均的函数值等于各函数值的加权平均。
    x=(x1,...,xn)为向量,而 f(x) 为标量,则 f 的形式为:
    f(x)=a+b1x1+...+bnxn=a+bx
    其中, b=(b1,...,bn)
    线性模型可用于任何预测任务,包括分类、概率估计和回归。

    二、多元线性回归

    在回归分析中,如果有两个或两个以上的自变量,就称为多元回归。
    多元线性回归的方程如下:

    y=h(x)=hθ(x)=θ0+θ1x1+...+θnxn
    其中, θ=(θ0,θ1,...,θn) 就是方程的回归系数。
    假设 (x1i,x2i,...,xni;yi),i=(1,2,...,m) ,为m组样本,在该样本下,回归方程的方程组形式如下:
    y1=θ0+θ1x11+θ2x21+...+θnxn1y2=θ0+θ1x12+θ2x22+...+θnxn2...ym=θ0+θ1x1m+θ2x2m+...+θnxnm

    利用矩阵运算,可表示为:
    y1y2yn=111x11x12x1mxn1xn2xnmθ0θ1θn

    y=y1y2yn
    X=111x11x12x1mxn1xn2xnm
    θ=θ0θ1θn
    则在该组样本下,回归模型的矩阵表示为:
    hθ(x)=θTX
    这里 x0=1

    三、损失函数

    损失函数是用来估量模型的预测值 h(x) 与真实值 Y 的不一致程度,它是一个非负实值函数,损失函数越小,模型的鲁棒性就越好。定义回归函数和实际值之间差的均方和为损失函数:

    J(θ)=12mi=1m(hθ(x(i)y(i))2
    m为样本数量,我们的目的是求出使损失函数 J(θ) 最小的参数 θ 的值。

    1.梯度下降法

    θ是包含所有参数的一维向量,我们先初始化一个 θ ,在这个θ值之上,用梯度下降法去求出下一组 θ 的值,由于是梯度下降的,所以损失函数J(θ)的值在下降。当迭代到一定程度, J(θ) 的值趋于稳定,此时的 θ 即为要求得的值。
    方法如下:
    (1)先确定向下一步的步伐大小,即α;
    (2)任意给定一个初始值:θ;
    (3)确定一个向下的方向,并向下走预先规定的步伐,并更新,即θjJ(θ)
    (4)当下降的高度小于某个定义的值,则停止下降;
    迭代函数如下:

    θj:=θjαθjJ(θ)=θjα1mi=1m(hθ(x(i))y(i))x(i)j
    j=(0,1,...,n)
    x(i)j 代表第 i 个样本集的第j个特征
    θ0:θ0α1mi=1m(hθ(x(i))y(i))x(i)0
    θ1:θ1α1mi=1m(hθ(x(i))y(i))x(i)1
    ...
    θn:θnα1mi=1m(hθ(x(i))y(i))x(i)n

    2.最小二乘法

    最小二乘法推导出来的公式为:

    θ=(XTX)1XTY

    参考资料:http://blog.csdn.net/xiazdong/article/details/7950084

    展开全文
  • java多元线性回归

    千次阅读 2016-06-21 16:43:20
    *模型:多元线性回归 *简要说明:根据一个样本集,计算线性回归分析系数。线性回归分析的模型为:Y=k0+k1X1+k2X2+....+knXn,其中,X1,X2,....,Xn为因变量,Y为变量 * k0,k1,....,kn为回归系数,该函数就是要...
    package  com.lc.v3.scm.datamining.math;  
       
       
    /*************************************************************************************  
     * @author   
     *  
     *    
     *    
     *   
     ******************************************************************************/   
       
    /***********************************************************************************  
     * Desc: The regression analyse is a widely used statistices  method  ,It was always  
     * used for forecast,cause and effect analyse  and so on.  
     * --统计分析-〉回归分析,一般分为线形回归和非线性回归  
     * All of us familiar with the line regression.In fact,this method can extend to non   
     * linear regression ,But the model built based on the analyser's private experience   
     * and his knowledge of practice.  
     * ************************************************************************************/   
       
      
       
    public  class  Regression    
    {   
        public Regression()   
        {   
           
        }   
       
        /***************************************************************************************  
        *模型:多元线性回归  
        *简要说明:根据一个样本集,计算线性回归分析系数。线性回归分析的模型为:Y=k0+k1X1+k2X2+....+knXn,其中,X1,X2,....,Xn为因变量,Y为变量  
        *     k0,k1,....,kn为回归系数,该函数就是要根据一组样本(Xi1,Xi2,...Xin,Yi)i=1,2,...,m[m个样本],根据最小二乘法得原则,计算出  
        *     最佳得回归分析系数k0,k1,....,kn,从而得到线性回归分析模型,该模型稍加扩展,就可以推广到非线性回归模型  
        *输入参数:  
        *    @param  double[][]  X  自变量样本集  
        *    @param  double[]    Y  变量结果集  
        *    @param  double[]   K  回归系数  
        *    @param  int  n  回归变量个数  
        *    @param  int  m  样本个数  
        *输出参数:  
        *    @return double result  0:失败,其他:成功  
        ****************************************************************************************/   
        public static double  LineRegression(   
                                                double[][] X,   
                                                double[] Y,   
                                                double[] K,   
                                                int n,   
                                                int m  
                                            )   
        {   
            double result = 0 ;   
               
            /*  
            *线性回归问题,最终转换为解一个对称线性方程组的求解问题  
            *线性方程组的系数矩阵为n+1*n+1,常数矩阵为n+1*1  
            */   
            int  XLen = n+1;   
            int  YLen = 1;   
            int i,j,k;   
            double[][]  coeffX = new double[XLen][XLen];   
            double[][]  constY = new double[XLen][1];   
            double[][]  resultK = new double[XLen][1];   
               
            /*  
            *根据参数,计算所要求解方程组的系数矩阵、常数矩阵  
            */   
            double[][] temp = new double[m+1][n+1];   
            for(i =0;i<n+1;i++)   
            {   
                temp[0][i] = 1;   
            }   
            for(i =0;i<m+1;i++)   
            {   
                temp[i][0] = 1;   
            }   
            for( i=1;i<m+1;i++)   
                for( j=1;j<n+1;j++)   
                temp[i][j]= X[i-1][j-1];   
            /*  
            *开始计算每一个系数  
            */   
            for(i=0;i<n+1;i++)   
            {   
                /*  
                *coeffX的第i行和i列的系数,注意,是对称矩阵  
                */   
                for( j= i;j<n+1;j++){   
                    double col = 0 ;   
                    for(k=1;k<m+1;k++)   
                        col+= ( temp[k][i]*temp[k][j] );   
                    coeffX[i][j] = col;   
                    coeffX[j][i] = col;            
                }   
       
                /*  
                *constY的第i个元素  
                */   
                double conTemp =0 ;   
                for(k=1;k<m+1;k++)   
                        conTemp+= ( Y[k-1]*temp[k][i]);   
               constY[i][0]=conTemp;   
       
            }   
       
            /*  
            *调用Sequation方法,解线性方程组  
            */   
            result = Sequation.guassEquation(coeffX,constY,resultK,XLen,1);    
            if(result ==0 )   
            {   
                //System.out.println("The regression is failed,please check the sample point \n");   
                return result;   
            }else{   
                for(i= 0;i<n+1;i++)   
                    K[i] = resultK[i][0];   
            }   
            return result;   
        }   
       
        /*****************************************************************************************  
        *模型名称:样本自优化线性回归  
        *简要说明:该模型是对简单线性回归模型的改良,其基本的考虑是所提供的样本数据中可能有些异常点使得模型的精度大大降低,系统通过一个度量函数自动  
        *         找那种对模型的拟合度最差的样本点,然后去掉该样本点再进行回归运算.本模型用实际值与模型预测值之间的平均偏差作为度量模型准确性的效  
        *         用函数。  
        *         如果平均偏差减少,标识模型在去掉噪声数据后模型拟合的效果增加,否则停止继续优化的步骤。另外,无论如何优化,都必须至少保留样本保有率  
        *         所确定的最少样本个数  
        *注:该模型尚未得到理论论证,是作者自己的经验总结  
        *函数参数:  
        *    @param  double[][]  X  自变量样本集  
        *    @param  double[]    Y  变量结果集  
        *    @param  int  n  回归变量个数  
        *    @param  double[]   K  最终回归系数(返回)  
        *    @param  int  m  样本个数  
        *    @param   double retainRate  样本最低保有率  
        *    @param  int[] LossPoint 被丢弃的样本点(返回)  
        *输出参数:  
        *    @return double res  -1:失败,1:成功  
        *******************************************************************************************/   
        public static  double optLineRegression( double[][] X,   
                                                 double[] Y,   
                                                 double[] K,   
                                                 int n,   
                                                 int m,   
                                                 double retainRate ,   
                                                 int[] LossPoint){   
               
            double res = -1;   
            if(n<1||m<1){   
                //System.out.println("The parameter is not normal ,please check it\n");   
                return res;        
            }   
            if(retainRate>=1.0||retainRate<=0.0){   
                //System.out.println("The retain parameter is not in 0 and 1 \n");   
                return res;   
            }   
               
            //必须确保的最小样本个数   
           
            Double Dtemp = new Double(m*retainRate);   
            int minsample = Dtemp.intValue();    
       
       
            //被丢弃的样本点的个数   
       
            int lossnum =0 ;   
       
            int[] LossPointTemp = new int[m];   
       
           
            //进行第一次回归   
       
            double temp = LineRegression(X,Y, K,n,m);    
            if(temp == 0){   
                //System.out.println("The regression operation is failed\n");   
                return res;        
            }   
       
            //第一次的平均误差   
       
            double ErrorStd = avgerror(X, Y, K,n, m);   
       
            double[][] SampleX = X;   
            double[]   SampleY = Y;   
            double[]    CoeffK = K;   
            int SampleNum = m;   
       
            /*  
            *记载样本位置的变化情况  
            */   
            int[] change = new int[m];   
            for(int k=0;k<m;k++)   
                change[k]=k;   
            int index_max = -1;   
       
            for (int i=m;i>minsample ;i-- )   
            {   
                /*  
                *找当前回归样本中的误差最大的样本index。  
                */   
                index_max = maxErrorIndex(SampleX,SampleY,CoeffK,n,SampleNum);   
       
                if(index_max == -1)   
                    return -1;   
       
                /*  
                *第index_max为误差最大样本,去掉该样本  
                */   
       
                int Loss = change[index_max];   
                lossnum +=1;   
                SampleNum -=1;   
       
       
                double[][] SampleXTemp = SampleX;   
                SampleX = new double[SampleNum][n];   
       
                double[] SampleYTemp = SampleY;   
                SampleY  = new double[SampleNum];   
       
                for(int j= 0;j<index_max;j++){   
                    for(int k=0;k<n;k++)   
                    {   
                    SampleX[j][k]=SampleXTemp[j+1][k];   
                    }   
                    SampleY[j]=SampleYTemp[j];   
                }   
       
                for(int j= index_max;j<SampleNum;j++){   
                    for(int k=0;k<n;k++){   
                        SampleX[j][k]=SampleXTemp[j+1][k];   
                    }   
                    SampleY[j] = SampleYTemp[j+1];   
                    change[j] = change[j+1];   
       
                }   
       
                /*  
                *利用新的样本进行回归  
                */   
                res=LineRegression(SampleX,SampleY,CoeffK,n,SampleNum);   
       
                /*  
                *比较新的预测模型误差与老模型的误差,如果没有改良,结束,否则,记载相关结果,并继续  
                */   
       
                double  ErrorOpt = avgerror(SampleX,SampleY,CoeffK,n,SampleNum);   
       
                if (ErrorOpt>=ErrorStd)//优化过程没有任何改良   
                {   
                    return  1;   
                }   
                else   
                {   
                   
                /*  
                *记载样本删减情况,记载回归系数  
                */   
                LossPoint[m-i] = Loss;   
       
                K=CoeffK;   
                               
                }   
            }   
            return 1;              
        }   
       
        /************************************************************************************  
        *简要说明:计算回归模型的平均误差  
        *输入参数:  
        *    @param  double[][]  X  自变量样本集  
        *    @param  double[]    Y  变量结果集  
        *    @param  int  n  回归变量个数  
        *    @param  double[]   K  回归系数  
        *    @param  int  m  样本个数  
        *输出参数:  
        *    @return double Ierror :-1失败 平均误差  
        *************************************************************************************/   
        public static double avgerror(double[][] X,double[] Y,double[] K,int n,int m){   
            double res = -1;   
            /*  
            *YF用于存放模型的预测结果  
            */   
            double[] YF = new double[m];    
            for(int i=0;i<m;i++){   
                YF[i] = K[0];    
                for(int j=0;j<n;j++)   
                    YF[i]+=X[i][j]*K[j+1];             
            }   
               
            /*  
            *计算初始预测与真实值的误差(平均维和距)  
            */   
            res = Base.dimaddavg(Y,YF);    
            return res;   
        }   
       
       
        /************************************************************************************  
        *简要说明:计算回归模型的误差最大的样本点的index_id  
        *输入参数:  
        *    @param  double[][]  X  自变量样本集  
        *    @param  double[]    Y  变量结果集  
        *    @param  int  n  回归变量个数  
        *    @param  double[]   K  回归系数  
        *    @param  int  m  样本个数  
        *输出参数:  
        *    @return int Index_id :-1失败   
        ************************************************************************************/   
        public static int maxErrorIndex(double[][] X,double[] Y,double[] K,int n,int m){   
            int index_id = -1;   
            /*  
            *YF用于存放模型的预测结果  
            */   
            double[] YF = new double[m];    
            for(int i=0;i<m;i++){   
                YF[i] = K[0];    
                for(int j=0;j<n;j++)   
                    YF[i]+=X[i][j]*K[j+1];             
            }   
               
            /*  
            *计算误差最大的样本点的index  
            */   
            index_id = Base.maxerrordim(Y,YF);   
            return index_id;       
        }   
       
    }   

    package com.lc.v3.scm.datamining.math;   
       
    public class  Base   
    {   
        public Base(){   
           
        }   
        /*  
        *Desc:get the max value for a  nonmultidimensional array  
        */   
        public static double max( double[] sample){   
            int n = sample.length;   
            double result =sample[0];   
            for (int i=1;i<n ;i++ )   
            {   
                if (sample[i]>result)   
                {   
                    result=sample[i];   
                }   
            }   
            return result;     
        }   
       
        /*  
        *Desc:get the min value for a nonmultidimensional array  
        **/   
        public static double min( double[] sample){   
            int n = sample.length;   
            double result =sample[0];   
            for (int i=1;i<n ;i++ )   
            {   
                if (sample[i]<result)   
                {   
                    result=sample[i];   
                }   
            }   
            return result;     
        }   
       
        /*  
        *Desc:get the average value  for a nonmultidimensional array  
        */   
        public static double avg( double[] sample){   
            int n = sample.length;   
            double result =sample[0];   
            for (int i=1;i<n ;i++ )   
            {   
                result +=sample[i];   
            }   
            return result/n;       
        }   
       
        /*  
        *Desc: get the variance (方差)for a nonmultidimensional array  
        * (Inpute)输入参数:  
        *     @param double[] sample 样本数组  
        * (OutPute)输出参数:  
        *     @return double if ==-1,样本为空  
        * (Logic)计算逻辑:  
        *     sample - 平均值的平方求和  
        **/   
        public static double val( double[] sample){   
            int n = sample.length;   
            double result = -1;   
            if (n<=0)   
            {   
                return result ;   
            }else{   
                double avg = avg(sample);   
                result = 0;   
                for(int j=0;j<n;j++)   
                    result += (sample[j]-avg)*(sample[j]-avg);   
               
            }   
             result/=n;   
             return result;    
        }   
       
        /*  
        *Desc: get the standard variance(标准方差) for a nonmultidimensional array  
        * (Inpute)输入参数:  
        *     @param double[] sample 样本数组  
        * (Output)输出参数:  
        *     @return double if ==-1,样本为空  
        * (Logic)计算逻辑:  
        *     sample[]的方差开方  
        **/   
        public static double stdval (double[] sample){   
            int n = sample.length;   
            double result = -1;   
            if(n<=0){   
                return result;   
            }else {   
                result = val(sample);   
                result = Math.sqrt(result);        
            }   
            return result;     
        }   
       
       
        /*  
        *Desc: get the max distance  for a nonmultidimensional array  
        * (Inpute)输入参数:  
        *     @param double[] sample 样本数组  
        * (Outpute)输出参数:  
        *     @return double if ==-1,样本为空  
        * (Logic)计算逻辑:  
        *     The array of sample 's max value subtract Its  
        *     min value [sample[]的最大值-最小值]  
        **/   
        public static double maxdis (double[] sample){   
            int n = sample.length;   
            double result = -1;   
            if(n<=0){   
                return result;   
            }else {   
                result = max(sample)-min(sample);          
            }   
            return result;     
        }   
       
        /*  
        *Desc: get the average warp for a nonmultidimensional array  
        * (Inpute)输入参数:  
        *     @param double[] sample 样本数组  
        * (Outpute)输出参数:  
        *     @return double if ==-1,样本为空  
        * (Logic)计算逻辑:  
        *     sample[]的每一个元素-平均值的绝对值的平均值  
        **/   
        public static double  meddev (double[] sample){   
            int n = sample.length;   
            double result = -1;   
            if(n<=0){   
                return result;   
            }else {   
                double avg = avg(sample);   
                result =0;   
                for(int j=0;j<n;j++){   
                    result += Math.abs(sample[j]-avg);   
                }   
            }   
            result /=n;   
            return result;     
        }   
       
        /*  
        *Desc: get the inside multiplication of  two array  
        *(Inpute)输入参数:  
        *     @param double[] sample1  
        *     @param double[] sample2  
        *(OutPute)输出参数:  
        *     @return double res;  
        *(Logic)处理逻辑:  
        *   Sum the value of two array's corresponding element production [对应元素乘积的和]  
        **/   
       
        public static double inmul(double[] sample1,double[] sample2){   
               double result = 1.0/0.0;   
               int len1 = sample1.length;   
               int len2 = sample2.length;   
               if(len1 != len2){   
                    System.out.println("two vector dose not at the same dimension,please check it\n");   
                    return result ;           
               }else{   
                    result = 0;   
                    for (int i=0;i<len1 ;i++ )   
                    {   
                        result += sample1[i]*sample2[i];   
                    }   
                          
               }   
               return result;      
        }   
       
        /*  
        *Desc : get the opposite production of two array to comprise a new array  
        *(Inpute)输入参数:  
        *     @param double[] sample1  
        *     @param double[] sample2  
        *(Outpute)输出参数:  
        *     @return double[] result;  
        *(Logic)处理逻辑:  
        *   形成新的向量,元素为对应元素的乘积  
        **/   
       
        public static double[] vecmul(double[] sample1,double[] sample2){   
               int len1 = sample1.length;   
               int len2 = sample2.length;   
               double[] result = new double[len1];   
               if(len1 != len2){   
                    System.out.println("two vector dose not at the same dimension,please check it\n");   
                    return result ;           
               }else{   
                    for (int i=0;i<len1 ;i++ )   
                    {   
                        result[i]= sample1[i]*sample2[i];   
                    }   
                          
               }   
               return result;      
        }   
       
       
        /*  
        *Desc : sort the element of the array into a from  great to little order  
        */   
        public  void  decorder(double[] sample){   
            int n = sample.length;   
            for(int i=0;i<n-1;i++){   
                for(int j=i+1;j<n;j++){   
                    if (sample[i]<sample[j])   
                    {   
                        double temp = sample[i];   
                        sample[i]=sample[j];   
                        sample[j]=sample[i];   
                    }          
                }   
            }   
        }   
       
        /*  
        *Desc : sort the element of the array into a from  little to great order  
        */   
        public  void  ascorder(double[] sample){   
            int n = sample.length;   
            for(int i=0;i<n-1;i++){   
                for(int j=i+1;j<n;j++){   
                    if (sample[i]>sample[j])   
                    {   
                        double temp = sample[i];   
                        sample[i]=sample[j];   
                        sample[j]=sample[i];   
                    }          
                }   
            }   
        }   
       
       /*  
       *Desc: get two point distance of standard (Euclid distance)  
       *Inpute:  
       *     @param  double[] Pfrom  
       *     @param  double[] Pto  
       * Outpute:  
       *     @param  double res  
       * Logic:  
       */   
       public static double eudis(double[] Pfrom ,double[] Pto){   
            int Lfrom = Pfrom.length;   
            int Lto = Pto.length;   
            if (Lfrom != Lto)   
            {   
                return -1;   
            }   
            double res = 0;   
            for(int i=0;i<Lfrom;i++){   
                double temp = Pfrom[i]-Pto[i];   
                temp*=temp;   
                res+=temp;     
            }   
            return Math.sqrt(res);      
       }   
       
       /*  
       *Desc : get the min value of two array's corresponding element's distance  
       *Inpute:  
       *    @param  double[] Pfrom  
       *    @parma  double[] Pto  
       *Outpute:  
       *    @return double res  
       *Logic:  
       */   
       public static double mindis(double[] Pfrom,double[] Pto){   
            int Lfrom = Pfrom.length;   
            int Lto = Pto.length;   
            if (Lfrom != Lto)   
            {   
                return -1;   
            }   
            double res = Math.abs(Pfrom[0]-Pto[0]);   
            for(int i=1;i<Lfrom;i++){   
                double temp = Math.abs(Pfrom[i]-Pto[i]);   
                if (temp < res )   
                {   
                    res =  temp;   
                }   
            }   
            return res;           
       }   
       
       /*  
        *Desc : get the max value of two array's corresponding element's distance  
        *Inpute:  
        *   @param  double[] Pfrom  
        *   @parma  double[] Pto  
        *Outpute:  
        *   @return double res  
        *Logic:  
        */   
       public static double maxdis(double[] Pfrom,double[] Pto){   
            int Lfrom = Pfrom.length;   
            int Lto = Pto.length;   
            if (Lfrom != Lto)   
            {   
                return -1;   
            }   
            double res = Math.abs(Pfrom[0]-Pto[0]);   
            for(int i=1;i<Lfrom;i++){   
                double temp = Math.abs(Pfrom[i]-Pto[i]);   
                if (temp > res )   
                {   
                    res =  temp;   
                }   
            }   
            return res;           
       }   
       
       
       /*  
        *Desc : get the total sum value of two array's corresponding element's distance  
        *Inpute:  
        *   @param  double[] Pfrom  
        *   @parma  double[] Pto  
        *Outpute:  
        *   @return double res  
        *Logic:  
        */   
       public static double sumdis(double[] Pfrom,double[] Pto){   
            int Lfrom = Pfrom.length;   
            int Lto = Pto.length;   
            if (Lfrom != Lto)   
            {   
                return -1;   
            }   
            double res = Math.abs(Pfrom[0]-Pto[0]);   
            for(int i=1;i<Lfrom;i++){   
                double temp = Math.abs(Pfrom[i]-Pto[i]);   
                res += temp;   
            }   
            return res;           
       }   
       
       /*  
        *Desc : get the averagedistance of two array's corresponding element's distance  
        *Inpute:  
        *   @param  double[] Pfrom  
        *   @parma  double[] Pto  
        *Outpute:  
        *   @return double res  
        *Logic:  
        */   
       public static double dimaddavg(double[] Pfrom,double[] Pto){   
            int Lfrom = Pfrom.length;   
            int Lto = Pto.length;   
            if (Lfrom != Lto)   
            {   
                return -1;   
            }   
            double res = Math.abs(Pfrom[0]-Pto[0]);   
            for(int i=1;i<Lfrom;i++){   
                double temp = Math.abs(Pfrom[i]-Pto[i]);   
                res += temp;   
            }   
            return res/Lfrom;             
       }   
       
       /*  
        *Desc : get the diemnsional id  of two array's corresponding element's distance   
        *       who has tha max value   
        *Inpute:  
        *   @param  double[] Pfrom  
        *   @parma  double[] Pto  
        *Outpute:  
        *   @return Int  id  
        *Logic:  
        */   
       public static int maxerrordim(double[] Pfrom,double[] Pto){   
            int Lfrom = Pfrom.length;   
            int Lto = Pto.length;   
            if (Lfrom != Lto)   
            {   
                return -1;   
            }   
            double maxerror=Math.abs(Pfrom[0]-Pto[0]);   
            int res = 0;   
            for(int i=1;i<Lfrom;i++){   
                double temp = Math.abs(Pfrom[i]-Pto[i]);   
                if ( temp>maxerror)   
                {   
                    res = i;   
                    maxerror=temp;   
                }   
            }   
            return res;      
       }   
       
    }   

       
    /***********************************************************************  
     * @author leitw  
     *  
     * 
     *  
     *  
     **********************************************************************/   
       
    /***********************************************************************  
     * This class was write for Line sequation group,The line sequation was used   
     * widely ,such as regression analysic,linear programming in operational management  
     * and so on.  
     * This class offered some basic method for solute line sequations,  
     * the first step offered guass method  
     * ***********************************************************************/   
       
    /************************************************************************  
    *线性方程组,根据AX=B,A为系数矩阵,B为常数矩阵  
    *线性方程求解法则参见线性代数  
    *  
    *****************************************************************/   
    public class Sequation    
    {   
        public Sequation()   
        {   
        }   
           
        /***********************************************************************  
        *简要说明:全选主元高斯消元法  
        *功能:解线性方程组  
        *输入参数:  
        *    @param  double[][]  coeffA  系数矩阵 n×n  
        *    @param  double[][]  constB  常向量  线性方程组的右端 n×m  
        *    @param  double[][]  resultX 返回线性方程组的解   n×m  
        *    @param  int    n  矩阵coeffA的阶数  
        *    @param  int    m  矩阵const的列数  
        *输出参数:  
        *    @return double abs  矩阵coeffA的行列式,如果abs=0,比较复杂,本函数不作处理,认为没有希望得到的解当|coeffA|=0,可能有无穷多解  
        **********************************************************************/   
        public static  double  guassEquation(double[][] coeffA ,double[][] constB, double[][] resultX , int n , int m )   
        {   
            int i,j,k,row,line;   
            double temp,max,abs=1;   
            /*  
            *change用于记载系数矩阵列交换的信息  
            */   
            int[] change = new int[n] ;   
            for(i=0;i<n;i++) change[i]=i ;   
            /*  
            *从矩阵的第一行开始  
            *a、找主元  
            *b、行列互换  
            *c、线性变换  
            */   
            for(i=0;i<n-1;i++)   
            {   
                /*  
                *找主元  
                */   
                row=i;line=i; max = Math.abs(coeffA[i][i]);   
                for(j=i;j<n;j++)   
                {   
                    for(k=i;k<n;k++)   
                        {   
                            temp = Math.abs(coeffA[j][k]);   
                            if(temp>max)   
                                {   
                                max = temp;   
                                row = j;   
                                line = k;   
                               
                                }   
                   
                        }   
                }   
                /*  
                *主元找到了为第row行,第line列,值为max  
                *如果max=0 ,表示行列式为0,返回0,退出  
                */   
                if(max==0)   
                {   
                    return 0;   
                }   
                /*  
                *第二步,行列互换,准备先行变换  
                */   
                if(row != i)   
                {   
                    for(k=i;k<n;k++)   
                    {   
                        temp = coeffA[i][k];   
                        coeffA[i][k] = coeffA[row][k];   
                        coeffA[row][k] = temp ;   
                    }   
                    for(k=0;k<m;k++)   
                    {   
                        temp=constB[i][k];   
                        constB[i][k]=constB[row][k];   
                        constB[row][k]=temp;   
                    }   
                }   
       
                if(line != i)   
                {   
                    for(j=0;j<n;j++)   
                    {   
                        temp = coeffA[j][line];   
                        coeffA[j][line]= coeffA[j][i];   
                        coeffA[j][i]=temp;   
                    }   
                    /*  
                    *记载变量位置的变化(列变换信息标识了变量位置的变化信息)  
                    */   
                    k=change[i];   
                    change[i]=change[line];   
                    change[line]= k;   
                }   
       
                /*  
                *开始线性变换,先对第i行归一化,然后对余行线性变换  
                */   
                abs *=coeffA[i][i];   
                for(k=i+1;k<n;k++) coeffA[i][k]/=coeffA[i][i];   
                for(k=0;k<m;k++) constB[i][k] /= coeffA[i][i];   
                coeffA[i][i]=1;   
       
                /*  
                *余矩阵变换  
                */   
                for(j=i+1;j<n;j++)   
                {   
                    for(k=i+1;k<n;k++) coeffA[j][k] -= coeffA[j][i]*coeffA[i][k];   
                    for(k=0;k<m;k++) constB[j][k] -= coeffA[j][i]*constB[i][k];   
                    coeffA[j][i] =0 ;   
                   
                }   
       
            }   
            abs *= coeffA[n-1][n-1];   
       
            /*  
            *回代消元  
            */   
            for(k=0;k<m;k++)   
            {   
                constB[n-1][k] /= coeffA[n-1][n-1];   
                for(i=n-2;i>=0;i--)   
                    for(j=i+1;j<n;j++)   
                    constB[i][k]-=coeffA[i][j]*constB[j][k];   
            }   
       
            /*  
            *根据change,调整变量顺序,得最后解  
            */   
            for(i=0;i<n;i++)   
            {   
                for(j=0;j<m;j++)   
                {   
                resultX[change[i]][j]=constB[i][j];   
                }   
            }   
            return abs ;   
        }   
    }  

    展开全文
  • 多元线性回归方程

    2018-10-29 19:18:47
    这个是用来计算多元线性回归方程的算法,可以代替matlab中的函数,结果绝对正确
  • 对于数据分析而言,我们总是极力找数学模型来描述数据发生的...那么这个规律通常是可以用一些函数来描述,函数可能是线性的,也可能是非线性的,怎么找到这些函数,是机器学习的首要问题。 本篇博客尝试用梯度下...
  • java实现多元线性回归,与matlab中计算一致 多元线性回归,计算的是某一列与多列的关系,入参是一个一维数组和一个二维数组。 首先,maven引入的依赖,此为apach提供的公共计算包,包含了各种各样的计算模型 <!--...
  • * 多元线性回归正规方程,最小二乘 A=(X*X^T)^-1*X^T*Y * * @author yzhang * */ public class LinearRegressionLSM { static List<String> trainData = new ArrayList<String>(); static int ...
  • 基于矩阵求解多元线性回归

    千次阅读 2018-05-19 22:57:34
    多元线性回归法也是深度学习的内容之一,用java实现一下多元线性回归。一元线性回归的公式为 y = a*x + b, 多元线性回归的公式与一元线性回归的公式类似,不过是矩阵的形式,可以表示为Y = AX + b,其中,Y是样本...
  • * 多元线性回归批量梯度下降 * @author yzhang * */ public class LinearRegressionBGD { public static void main(String[] args) { LinearRegressionBGD lr = new LinearRegressionBGD(0.0001,100000,0....
  • 多元线性回归之Spss实现

    千次阅读 2017-05-17 17:56:24
    我们还以上篇中的数据来进行多元线性回归的分析及说明:首先来看引入一个变量时候,也就是分析不良贷款和各项贷款余额的回归分析,这里只做对比用,详细的分析结果可以上上一篇博客: 引入两个自变量时,各年贷款...
  • 经典线性模型自变量的线性预测就是因变量的估计值。 广义线性模型:自变量的线性预测的函数是因变量的...1.线性回归原理 其中,为偏置参数,M为特征数目,为基函数(径向基函数(rbf)、sigmoid基函数等), 特...
  • 机器学习第3天:多元线性回归

    万次阅读 2018-09-21 08:10:19
    文章目录一、具体实现步骤第1步:数据预处理导入库导入数据集将类别数据数字化躲避虚拟变量陷阱拆分数据集为训练集和测试集第2步: 在训练集上训练多元线性回归模型第3步:在测试集上预测结果第4步:数据可视化二、...
  • 多元线性回归----Java简单实现 学习Andrew N.g的机器学习课程之后的简单实现. 课程地址:https://class.coursera.org/ml-007 不大会编辑公式,所以略去具体的推导,有疑惑的同学去看看Andrew 的课程吧,顺...
  • 多元线性回归多元线性回归模型实际中有很多问题是一个因变量与多个自变量成线性相关,我们可以用一个多元线性回归方程来表示。为了方便计算,我们将上式写成矩阵形式:Y = XW假设自变量维度为NW为自变量的系数,下标0...
  • 多元线性回归解释 什么是线性搜索? (What is Linear Search?) Suppose you are given a list or an array of items. You are searching for a particular item. How do you do that? 假设给您一个列表或项目数组。 ...
  • java实现的多元线性回归代码

    千次阅读 2015-01-26 10:11:56
    *模型:多元线性回归 *简要说明:根据一个样本集,计算线性回归分析系数。线性回归分析的模型为:Y=k0+k1X1+k2X2+....+knXn,其中,X1,X2,....,Xn为因变量,Y为变量 * k0,k1,....,kn为回归系数,该函数就是要...
  • 这是正态方程方法的 Java 实现,应用于多元线性回归。 (只提供了一个特征,但我们通过对所提供的特征求幂来生成更多特征:x^2、x^3...x^31)。 如果我们有更多的自然特征(但用图形表示会更难),则以相同的方式...
  • 多元线性回归 机器学习基础(1)

    千次阅读 2016-01-25 15:23:16
    机器学习基础之多元线性回归 描述了假设函数、求解方法(梯度法和正规方程)、基于Octave/MATLAB的向量化表达方法。
  • 多元线性回归及梯度下降

    千次阅读 2016-09-26 15:45:11
    一、线性回归定义  方法:线性回归属于监督学习,因此方法和监督学习应该是一样的,先给定一个训练集,根据这个训练集学习出一个线性函数,然后测试这个函数训练的好不好(即此函数是否足够拟合训练集数据),挑选...
  • 线性回归原理: 线性回归公式:y = b + w*x,w表示权重b表示偏置。 在实际实现中可以将公式写作:y = w[0] * x[0] + w[1] * x[1],x[0]=1,这样就可以很方便的进行参数求解,同样稍作修改将公式写成:y = w[0] * x...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,751
精华内容 700
关键字:

多元线性回归java

java 订阅