java算法：逻辑回归和线性回归

最新推荐文章于 2023-06-07 17:13:43 发布
最新推荐文章于 2023-06-07 17:13:43 发布
阅读量847 收藏 4
点赞数
分类专栏： 笔记 文章标签： 算法 java 概率论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43470725/article/details/120369324
版权

线性回归：
参考：https://blog.csdn.net/dong_lxkm/article/details/80551795
通过阶梯递减，训练出我们想要的参数：
事先给出一个我我们想要的值，比如说：1
然后通过这个参数算出结果于已知的结果做对比，看是加上还是减去一定的数值；
eg:代码：

package com.example.dtest.regressionArithmetic;

import java.util.Random;

/**
 * 参考：https://blog.csdn.net/dong_lxkm/article/details/80551795
 * */

public class LinearRegression {

    public static void main(String[] args) {
        //模拟的表达式： y=3*x1+4*x2+5*x3+10
        Random random = new Random();
        double[] results = new double[100];
        double[][] features = new double[100][3];
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < features[i].length; j++) {
//                模拟数据：
                features[i][j] = random.nextDouble();
            }
            results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
        }
        double[] parameters = new double[] { 1.0, 1.0, 1.0, 1.0 };
        double learningRate = 0.01;
        for (int i = 0; i < 30; i++) {
            SGD(features, results, learningRate, parameters);
        }
        parameters = new double[] { 1.0, 1.0, 1.0, 1.0 };
        System.out.println("==========================");
        for (int i = 0; i < 3000; i++) {
            BGD(features, results, learningRate, parameters);
        }
    }

    private static void SGD(double[][] features, double[] results, double learningRate, double[] parameters) {
        for (int j = 0; j < results.length; j++) {
            double gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][0];
            parameters[0] = parameters[0] - 2 * learningRate * gradient;

            gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
                    + parameters[3] - results[j]) * features[j][1];
            parameters[1] = parameters[1] - 2 * learningRate * gradient;

            gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
                    + parameters[3] - results[j]) * features[j][2];
            parameters[2] = parameters[2] - 2 * learningRate * gradient;

            gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
                    + parameters[3] - results[j]);
            parameters[3] = parameters[3] - 2 * learningRate * gradient;
        }

        double totalLoss = 0;
        for (int j = 0; j < results.length; j++) {
            totalLoss = totalLoss + Math.pow((parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]), 2);
        }
        System.out.println(parameters[0] + " " + parameters[1] + " " + parameters[2] + " " + parameters[3]);
        System.out.println("totalLoss:" + totalLoss);
    }

    private static void BGD(double[][] features, double[] results, double learningRate, double[] parameters) {
        double sum = 0;
        for (int j = 0; j < results.length; j++) {
            sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][0];
        }
        double updateValue = 2 * learningRate * sum / results.length;
        parameters[0] = parameters[0] - updateValue;

        sum = 0;
        for (int j = 0; j < results.length; j++) {
            sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][1];
        }
        updateValue = 2 * learningRate * sum / results.length;
        parameters[1] = parameters[1] - updateValue;

        sum = 0;
        for (int j = 0; j < results.length; j++) {
            sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][2];
        }
        updateValue = 2 * learningRate * sum / results.length;
        parameters[2] = parameters[2] - updateValue;

        sum = 0;
        for (int j = 0; j < results.length; j++) {
            sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]);
        }
        updateValue = 2 * learningRate * sum / results.length;
        parameters[3] = parameters[3] - updateValue;

        double totalLoss = 0;
        for (int j = 0; j < results.length; j++) {
            totalLoss = totalLoss + Math.pow((parameters[0] * features[j][0] + parameters[1] * features[j][1]
                    + parameters[2] * features[j][2] + parameters[3] - results[j]), 2);
        }
        System.out.println(parameters[0] + " " + parameters[1] + " " + parameters[2] + " " + parameters[3]);
        System.out.println("totalLoss:" + totalLoss);
    }



}

2、逻辑回归：思想和线性回归差不多，但多了一步函数映射转换，将数据映射再0到1上去：映射到：
Sigmoid函数中（将我们的函数值y，作为该函数的x带入）：
在这里插入图片描述
参考：https://blog.csdn.net/ccblogger/article/details/81739200
举证公式为：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
a为训练速率，x为已知的输入值，e是输出值和预期值之差y-y0
代码如下：

 <!-- 用于矩阵运算 -->
        <dependency>
            <groupId>org.ujmp</groupId>
            <artifactId>ujmp-core</artifactId>
            <version>0.3.0</version>
        </dependency>

package com.example.dtest.regressionArithmetic.logisticregression;


import org.ujmp.core.DenseMatrix;
import org.ujmp.core.Matrix;

/**
* 参考：https://blog.csdn.net/weixin_45040801/article/details/102542209
 * https://blog.csdn.net/ccblogger/article/details/81739200
* */
public class LogisticRegression {

    public static double[] train(double[][] data, double[] classValues) {

        if (data != null && classValues != null && data.length == classValues.length) {
//            期望矩阵
//            Matrix matrWeights = DenseMatrix.Factory.zeros(data[0].length + 1, 1);
            Matrix matrWeights = DenseMatrix.Factory.zeros(data[0].length, 1);
            System.out.println("data[0].length + 1========"+data[0].length + 1);
//            数据矩阵
//            Matrix matrData = DenseMatrix.Factory.zeros(data.length, data[0].length + 1);
            Matrix matrData = DenseMatrix.Factory.zeros(data.length, data[0].length);
//            标志矩阵
            Matrix matrLable = DenseMatrix.Factory.zeros(data.length, 1);
//            训练速率矩阵
//            Matrix matrRate = DenseMatrix.Factory.zeros(data[0].length + 1,data.length);
//            统计difference的总体失误的辅助矩阵
            Matrix matrDiffUtil =  DenseMatrix.Factory.zeros(data[0].length,data.length);
            for(int i=0;i<data.length;i++){
                for(int j=0;j<data[0].length;j++) {
                    matrDiffUtil.setAsDouble(1, j, i);
                }
            }
            System.out.println("matrDiffUtil="+matrDiffUtil);
            /**
            * 行数应该和期望矩阵一致列数
             * 列数应该和标志矩阵一致
            * */

//            System.out.println("matrRate======="+matrRate);
            //            设置训练速率矩阵
//            for(int i=0;i<data[0].length + 1;i++){
//                for(int j=0;j<data.length;j++){
//                }
//            }



            for (int i = 0; i < data.length; i++) {
//                matrData.setAsDouble(1.0, i, 0);
//                初始化标志矩阵
                matrLable.setAsDouble(classValues[i], i, 0);
                for (int j = 0; j < data[0].length; j++) {
//                    初始化数据矩阵
//                    matrData.setAsDouble(data[i][j], i, j + 1);
                    matrData.setAsDouble(data[i][j], i, j);
                    if (i == 0) {
//                        初始化期望矩阵
//                        matrWeights.setAsDouble(1.0, j+1, 0);
                        matrWeights.setAsDouble(1.0, j, 0);

                    }
                }
            }
//            matrWeights.setAsDouble(-0.5, data[0].length, 0);

//            matrRate  = matrData.transpose().times(0.9);

//            System.out.println("matrRate============"+matrRate);


            double step = 0.011;
            int maxCycle = 5000000;
//            int maxCycle = 5;

            System.out.println("matrData======"+matrData);
            System.out.println("matrWeights"+matrWeights);
            System.out.println("matrLable"+matrLable);

            /**
             * 使用梯度下降法的思想：
            * 矩阵运算，参考：https://blog.csdn.net/lionel_fengj/article/details/53400715
             *
            * */
            for (int i = 0; i < maxCycle; i++) {
//                将想要函数转换为sigmoid函数并得到的值
                Matrix h = sigmoid(matrData.mtimes(matrWeights));
//                System.out.println("h=="+h);
//                求出预期和真实的差值
                Matrix difference = matrLable.minus(h);
//                System.out.println("difference "+difference);
//              matrData转置后和difference相乘，得到预期和真实差值的每一个值
//                公式：@0 = @0 - ax(y0-y),可以参考：https://blog.csdn.net/ccblogger/article/details/81739200
                matrWeights = matrWeights.plus(matrData.transpose().mtimes(difference).times(step));
//                matrWeights = matrWeights.plus(matrRate.mtimes(difference).times(step));
//                matrWeights = matrWeights.plus(matrDiffUtil.mtimes(difference).times(step));
            }

            double[] rtn = new double[(int) matrWeights.getRowCount()];
            for (long i = 0; i < matrWeights.getRowCount(); i++) {
                rtn[(int) i] = matrWeights.getAsDouble(i, 0);
            }

            return rtn;


        }

        return null;
    }

    public static Matrix sigmoid(Matrix sourceMatrix) {
        Matrix rtn = DenseMatrix.Factory.zeros(sourceMatrix.getRowCount(), sourceMatrix.getColumnCount());
        for (int i = 0; i < sourceMatrix.getRowCount(); i++) {
            for (int j = 0; j < sourceMatrix.getColumnCount(); j++) {
                rtn.setAsDouble(sigmoid(sourceMatrix.getAsDouble(i, j)), i, j);
            }

        }

        return rtn;
    }

    public static double sigmoid(double source) {
        return 1.0 / (1 + Math.exp(-1 * source));
    }

//    测试预测值：
    public static double getValue(double[] sourceData, double[] model) {
//        double logisticRegressionValue = model[0];
        double logisticRegressionValue = 0;
        for (int i = 0; i < sourceData.length; i++) {
//            logisticRegressionValue = logisticRegressionValue + sourceData[i] * model[i + 1];
            logisticRegressionValue = logisticRegressionValue + sourceData[i] * model[i];
        }
        logisticRegressionValue = sigmoid(logisticRegressionValue);

        return logisticRegressionValue;
    }

}

package com.example.dtest.regressionArithmetic.logisticregression;


public class LogisicRegressionTest {

    public static void main(String[] args) {
        double[][] sourceData = new double[][] { { -1, 1 }, { 0, 1 }, { 1, -1 }, { 1, 0 }, { 0, 0.1 }, { 0, -0.1 }, { -1, -1.1 }, { 1, 0.9 } };
        double[] classValue = new double[] { 1, 1, 0, 0, 1, 0, 0, 0 };
        double[] modle = LogisticRegression.train(sourceData, classValue);
//        double logicValue = LogisticRegression.getValue(new double[] { 0, 0 }, modle);
        double logicValue0 = LogisticRegression.getValue(new double[] { -1, 1 }, modle);
        double logicValue1 = LogisticRegression.getValue(new double[] { 0, 1 }, modle);
        double logicValue2 = LogisticRegression.getValue(new double[] { 1, -1}, modle);//3.1812246935599485E-60无限趋近于0
        double logicValue3 = LogisticRegression.getValue(new double[] { 1, 0}, modle);//3.091713602147872E-30无限趋近于0
        double logicValue4 = LogisticRegression.getValue(new double[] { 0, 0.1}, modle);//3.091713602147872E-30无限趋近于0
        double logicValue5 = LogisticRegression.getValue(new double[] {  0, -0.1 }, modle);//3.091713602147872E-30无限趋近于0
        System.out.println("---model---");
        for (int i = 0; i < modle.length; i++) {
            System.out.println(modle[i]);
        }
        System.out.println("-----------");
//        System.out.println(logicValue);
        System.out.println(logicValue0);
        System.out.println(logicValue1);
        System.out.println(logicValue2);
        System.out.println(logicValue3);
        System.out.println(logicValue4);
        System.out.println(logicValue5);

//        绘制散点图
//        double[][][] chartData = new double[3][][];
//        double[][] c0 = new double[2][5];
//        double[][] c1 = new double[2][3];
//        c1[0][0] = sourceData[0][0];
//        c1[1][0] = sourceData[0][1];
//
//        c1[0][1] = sourceData[1][0];
//        c1[1][1] = sourceData[1][1];
//
//        c0[0][0] = sourceData[2][0];
//        c0[1][0] = sourceData[2][1];
//
//        c0[0][1] = sourceData[3][0];
//        c0[1][1] = sourceData[3][1];
//
//        c1[0][2] = sourceData[4][0];
//        c1[1][2] = sourceData[4][1];
//
//        c0[0][2] = sourceData[5][0];
//        c0[1][2] = sourceData[5][1];
//
//        c0[0][3] = sourceData[6][0];
//        c0[1][3] = sourceData[6][1];
//
//        c0[0][4] = sourceData[7][0];
//        c0[1][4] = sourceData[7][1];
//
//        String[] c = new String[] { "1", "0", "L" };
//        double[][] c2 = new double[2][21];
//        int ind = 0;
//        for (double x = -1; x <= 1; x = x + 0.1) {
//            c2[0][ind] = x;
//            c2[1][ind] = (-modle[0] - modle[1] * x) / modle[2];
//            ind++;
//        }
//
//        chartData[0] = c0;
//        chartData[1] = c1;
//        chartData[2] = c2;

//        ScatterPlot.showScatterPlotChart("LogisticRegression", c, chartData);
}

}

春风霓裳
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Logistic回归在Java中的实现
禅与计算机程序设计艺术
04-06 553
Logistic回归在Java中的实现 作者：禅与计算机程序设计艺术 1. 背景介绍 Logistic回归是一种广泛应用于分类问题的机器学习算法。它可以用于预测二分类或多分类问题中的输出变量。相比于线性回归，Logistic回归具有更好的适用性和稳定性。在许多实际应用场
逻辑回归（LR）算法java实现<转>
yongjian_luo的专栏
06-27 2728
按照机器学习实战的python代码，用java重写LR的梯度上升算法： package com.log; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.io.File; import java.util.Ar
java实现逻辑斯特回归_逻辑回归的相关问题及java实现
weixin_35036735的博客
02-13 417
本讲主要说下逻辑回归的相关问题和详细的实现方法1. 什么是逻辑回归逻辑回归是线性回归的一种，那么什么是回归，什么是线性回归回归指的是公式已知，对公式中的未知參数进行预计，注意公式必须是已知的，否则是没有办法进行回归的线性回归指的是回归中的公式是一次的，比如z=ax+by逻辑回归事实上就是在线性回归的基础上套了一个sigmoid函数，详细的样子例如以下2. 正则化项引入正则化项的目的是防止模型过拟合...
Java代码使用最小二乘法实现线性回归预测
洛阳泰山的博客
02-20 3186
最小二乘法是一种在误差估计、不确定度、系统辨识及预测、预报等数据处理诸多学科领域得到广泛应用的数学工具。它通过最小化误差（真实目标对象与拟合目标对象的差）的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。最小二乘法还可用于曲线拟合。对于平面中的这n个点，可以使用无数条曲线来拟合。要求样本回归函数尽可能好地拟合这组值。综合起来看，这条直线处于样本数据的中心位置最合理。
linear-regression:用Java编写的一种简单的线性回归算法，用于理解梯度下降
05-09
线性回归 一种简单的线性回归算法，用Java编写，是理解梯度下降的一种练习。 用NetBeans编写。
Java做回归分析
weixin_50627332的博客
10-20 3562
用Java实现一元线性回归分析，多元线性回归分析，一元非线性回归分析
基于matlab程序的各种回归、分类算法实现，多元线性回归，主成分分析，偏最小二乘- 逻辑斯蒂回归，感知机- 粒子群优化等等
最新发布
12-21
MLR - 多元线性回归 PCA - 主成分分析 PLS - 偏最小二乘 LogisticR - 逻辑斯蒂回归 Ganzhiji - 感知机(perception) PSO - 粒子群优化 KNN - K_近邻 Bayes - 贝叶斯 OSC - 正交信号校正 GDescent - 梯度下降...
多元逻辑斯蒂回归matlab代码-simple-ml:简单毫升
05-28
一些用香草Java和单个线性代数库编写的非常简单的机器学习算法 训练套 训练集的简要说明： food-truck-profits-per-city.txt是有关食品卡车利润的培训集 它包含1个功能和一个标签： 城市人口 利润 6.1101 17.592 5....
Logistic回归统计算法的matlab实现.rar_Java__Java_
08-09
统计回归分析，逻辑斯蒂多元线性回归，机器学习，详细代码解说，机器训练等
基于Java实现的一层简单人工神经网络算法示例
08-28
本文将详细介绍如何基于Java实现一层简单的人工神经网络算法。首先，我们需要理解人工神经...要深入理解和实现这样的网络，需要熟悉神经网络的基本原理，以及Java编程语言和可能用到的数学工具，如线性代数和微积分。
java笔试题算法-rapaio:统计、数据挖掘和机器学习工具箱
06-03
已实现算法和功能的不完整列表包括：核心统计工具、常见分布和假设检验、朴素贝叶斯、二元逻辑回归、决策树（回归和分类）、随机森林（回归和分类）、AdaBoost、梯度提升树（回归）和分类）、BinarySMO SVM、相关...
java求线性回归置信区间,线性回归分析详解9：总体回归、置信度、置信区间及其计算方法...
weixin_39620037的博客
03-11 1607
许栩原创专栏《从入门到高手：线性回归分析详解》第9章：总体回归、置信度、置信区间及其计算方法。多元回归方程求解后，我们分别确认了回归方程的精度和进行了回归方程的显著性验证，接下来，我们需要计算置信区间。置信区间是回归分析的一个重要概念，但是，将回归分析应用到需求预测，并不强求引入置信区间，也就是说，用回归分析做需求预测时，可以不进行置信区间的计算，而直接进行后续的预测步骤。所以，从这一点来说，大家...
基于Spark的机器学习实践 (七) - 回归算法
weixin_34337381的博客
04-15 318
0 相关源码 1 回归分析概述 1.1 回归分析介绍 ◆ 回归与分类类似，只不过回归的预测结果是连续的,而分类的预测结果是离散的 ◆ 如此,使得很多回归与分类的模型可以经过改动而通用 ◆ 因此对于回归和分类中基本原理相同或类似的模型 ,不再赘述 1.2 Spark中集成的回归算法 ◆ Spark实现的回归算法很丰富 ,有很多模型同样可以用于分类 官方文档回归算法列表 1.3 回归与分类的区...
练习1：线性回归
scout11123的博客
06-07 120
在该部分练习任务中，你需要实现一个计算成本 𝐽(𝜃)的函数computeCost，用于检查梯度下降实现的收敛性。假设你是一家餐厅的领导，正在考虑在不同的城市开设新的分店。该连锁店已经在不同的城市有了餐车，并且你能够获得每个城市的人口和利润数据。要点:完成该函数后，将 𝜃值初始化为0并进行成本的计算，将得到的成本值打印出来。在该部分练习中,将通过代码实现返回一个5*5的对角矩阵。在该部分中，将使用梯度下降来选择合适的线性回归参数θ用以拟合给定数据集。在该部分练习中，将实现单变量线性回归并用来预测餐车的利润。
逻辑回归算法检测java_meterpreter
Yale的博客
05-18 589
本次实验我们来学习使用逻辑回归算法来检测java meterpreter. 先来学习逻辑回归算法 首先需要搞懂逻辑回归与线性回归（Linear Regression）的区别，虽然二者都带有“回归”二字，但是用来解决不同的问题。线性回归解决“回归”问题，用一条直线来拟合所有的点，例如探究某超市的销售额与小区常住人口数的关系；而逻辑回归则解决“分类”问题，例如可预测一封邮件是否为垃圾邮件，预测客户是否会发生债务违约等。 逻辑回归算法分三步进行，首先，我们需要确定一个预测函数，即预测出一个值来判断归属哪一类，可定
Java实现线性回归预测成绩分析（借助weka工具包）
Nothing_ness的博客
10-28 3484
在项目中使用线性回归预测成绩 因为涉及到版权问题，只弄核心部分。 数据方面以及weka在这一篇博客中介绍了 链接: https://blog.csdn.net/Nothing_ness/article/details/109331074. 1引入依赖pom.xml(记得刷新maven配置) <!-- weka集成java--> <dependency> <groupId>nz.ac.waikato.cms.weka</
java实现的多元线性回归代码
huyou1983216的专栏
01-26 3604
package com.lc.v3.scm.datamining.math; /************************************************************************************* * @author * * * * *********************
java解非线性方程组_将一组非线性方程组解为一个数组
weixin_39578197的博客
02-13 386
我正在尝试解决两个方程的交集： y=Rx^1.75 和 y=ax^2+bx+c 用于我的数据帧中的所有行(大约100K行) . R,a,b,c 的每个值对于每一行是不同的 . 我可以通过遍历数据帧并为每一行调用 fsolve() 逐个解决它们(如下所示)，但我想知道是否有更好的方法来执行此操作 .My question is ：是否可以将其转换为数组计算，即一次解决所有行？关于如何更快地完成计...
scala 淘宝回头客 逻辑回归
08-06
逻辑回归是一种二分类算法，目的是根据特征变量的线性组合来预测不同类别的概率。在淘宝回头客的应用中，我们可以将各种用户特征作为输入变量，例如用户年龄、性别、购买历史等，以及目标变量，即用户是否成为回头客...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值