精华内容
下载资源
问答
  • 逻辑回归算法的优化

    千次阅读 2018-04-14 18:00:26
    一:有无截距: 如上图。可以知道,有截距的线条数比无截距的线条数(过原点的线条)要多。所以在选择逻辑回归的时候,通常要设置截距。增加正确的概率。 代码: val lr = new LogisticRegressionWithSGD() ----...

    一:有无截距:

            

    如上图。可以知道,有截距的线条数比无截距的线条数(过原点的线条)要多。所以在选择逻辑回归的时候,通常要设置截距。增加正确的概率。

            代码:

                    val lr = new LogisticRegressionWithSGD()   ----创建逻辑回归对象

                    lr.setIntercept(true) -----设置截距  

    二:线性不可分的时候,增加维度。

    如图:当找不到一条线可以正确分类的时候,可以通过增加维度,找到一个面,正确的分类。而新维度的添加不能是随意的,是根据之前的维度,进行一些计算得到(具体的执行什么计算,是要通过大量的测试得出来的)。

    代码:

    def main(args:Array[String]){

        val conf  = new SparkConf().setAppName("lr").setMaster("local[*]")

        val sc = new SparkContext(conf)

        val inputdata = MLUtils.loadLibSVMFile(sc,"线性不可分的数据集.txt")

                .map{

                        labelpoint=>

                        val label = labelpoint.label

                        val feature = labelpoint.features

                        //新维度的值,必须建立在已有维度的基础上,经过一系列的数据变换得来,本例就是通过已有的两个维度进行求乘积得到的新的维度

                        val array = Array(feature(0),feature(1),feature(0)*feature(1))

                        val converFeature = Vectors.dense(array) --转成向量

                        new LabeledPoint(label,converFeature)

                        .......

                    }

    }

    三:调整分类的阈值

        在一些特定的场合下,如果按照逻辑回归默认的分类阈值(0.5)来进行分类的话,可能会存在一些潜在的风险,比如:

                --癌症病人的判断:

                            --如果病人是癌症     判断成不是癌症   (可能会耽误病人的最佳治疗时间)

                            --如果病人不是癌症  判断成癌症    

         如果病人不是癌症的概率是45%,这个时候我们应该判断成是癌症,因为该概率太接近中间值。也是有很大的几率是癌症的,判断成是癌症可能导致错误率变大,但是却可以规避一些不能接受的风险。就可以调整成以0.3作为阈值。

    代码:

            val lr = new LogisticRegressionWithLBFGS()

            //如果在训练模型的时候没有调用clearThreshold()这个方法,那个这个模型预测出来的结果都是分类号

            //如果在训练模型的时候调用clearThreshold()这个方法,那个这个模型预测出来的结果是一个概率

            val model = lr.run(tariningdata).clearThreshold()  //tariningdata训练模型的数据集

            val errorrate = testData.map{p=>   //testData测试数据

                    val score = model.predict(p.features)//得到的是概率

                    val result = score > 0.3 macth{  //修改阈值为0.3

                        case true =>1;case false=>0

                        Math.abs(result-p.label)

    }.mean()

    }

    四:鲁棒性调优

          鲁棒是Robus的英译,也就是健壮和强壮的意思,例如:计算机软件在输入错误,磁盘故障,网络过载或者有意攻击情况下,能不死机,不崩溃,这就是该软件的鲁棒性。所以算法的鲁棒性就是指这个算法的抗干扰能力。

    代码:

        val lr = LogisticRegressionWithLBFGS()

        lr.optimizer.setRegParam(0.4)  //这块设置lambda,越大越看推广能力(鲁棒性越好),一般不会超过1,0.4很好

        val model = lr.run(trainingData)

      五:归一化数据

    •   最大值最小值归一化(每个值x 转变成 =x-min/(max-min)得到的值都是在 0-1之间的数
    •   方差归一化

    代码:

        val inputData = MLUtils.loadLibSVMFile(sc,"测试.txt")

        val vectors = inputData.map(._features)

        /*

        *scalerModel 这个对象中已经有每一列的均值和方差

        *withStd:代表的方差归一化  withMean:代表的是均值归一化  scalerModel 存放每一列的方差值

        */

        val scalerModel = new StandardScaler(withMean=true,withStd=true).fit(vectors)

        val normalizeInputData = inputData.map{point=>

                val label = point.label

                //对每一条数据进行归一化

                val features = scalerModel.transform(point.features.toDense)

                bew LabeledPoint(label,features)

    }

            

            

    展开全文
  • 1. 介绍: 回归(regression) Y变量为连续数值型(continuous numerical variable) ...如:颜色类别,电脑品牌,有无信誉 2. 简单线性回归(Simple Linear Regression) 很多做决定过过程通常是根据两个或者多个变量之...

    1. 介绍:

    回归(regression) Y变量为连续数值型(continuous numerical variable)
    如:房价,人数,降雨量
    分类(Classification): Y变量为类别型(categorical variable)
    如:颜色类别,电脑品牌,有无信誉

    2. 简单线性回归(Simple Linear Regression)

    很多做决定过过程通常是根据两个或者多个变量之间的关系
    回归分析(regression analysis)用来建立方程模拟两个或者多个变量之间如何关联
    被预测的变量叫做:因变量(dependent variable), y, 输出(output)
    被用来进行预测的变量叫做: 自变量(independent variable), x, 输入(input)

    2.1. 简单线性回归介绍

    简单线性回归包含一个自变量(x)和一个因变量(y)
    以上两个变量的关系用一条直线来模拟
    如果包含两个以上的自变量,则称作多元回归分析(multiple regression)

    2.2. 简单线性回归模型

    被用来描述因变量(y)和自变量(X)以及偏差(error)之间关系的方程叫做回归模型
    简单线性回归的模型是:
    在这里插入图片描述
    β_0、β_1为参数,ε是是一个随机的变量,均值为0,ε的方差(variance)对于所有的自变量x是一样的是独立的 ,ε满足正态分布。

    2.3. 简单线性回归方程

    在这里插入图片描述
    这个方程对应的图像是一条直线,称作回归线。其中,β_0是回归线的截距,β_1是回归线的斜率,E(y)是在一个给定x值下y的期望值(均值)

    3.多元线性回归

    3.1. 多元回归模型

    y=β_0+β_1x_1+β_2x_2+ … +β_p*x_p+ε
    其中:β_0,β_1,β_2… β_p是参数,ε是误差值

    3.2 多元回归方程

    E(y)=β_0+β_1x_1+β_2x_2+ … +β_px_p

    4. 估计流程

    在这里插入图片描述
    根据已有的数据,估计参数值β_0、β_1。。。的值。
    估计的方法:
    在这里插入图片描述

    展开全文
  • 一.概述        ...对求得的回归方程的可信度进行检验,判断自变量对Y有无影响;利用所求得的回归方程进行预测和控制。      &nbs

    阅读此篇前, 建议先对梯度下降法有所了解人工智能-数学基础-函数与优化

    一.概述

           回归分析是研究统计规律的方法之一。在回归分析中我们把所关心的一些指标称为因变量,通常用Y来表示;影响因变量的变量称为自变量,用X1、X2、…XP来表示。回归分析研究的主要问题是:确定Y与X1、X2、…XP间的定量关系表达式,这种表达式称为回归方程;对求得的回归方程的可信度进行检验,判断自变量对Y有无影响;利用所求得的回归方程进行预测和控制。

           线性回归是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法,运用十分广泛。其表达形式为 y = w’x+e,e为误差服从均值为0的正态分布。
           回归分析中,只包括一个自变量和一个因变量,且二者的关系可用一条直线近似表示,这种回归分析称为一元线性回归分析(平面中的直线)。如果回归分析中包括两个或两个以上的自变量,且因变量和自变量之间是线性关系,则称为多元线性回归分析(超立方体中的直线)。

    y^(w,x)=w0+w1x1++wpxp \hat{y}(w,x) = w_0 + w_1x_1+\cdots + w_px_p

    二.线性回归实现

    我们先了解几个概念:
    y=xw+b线形如 y = x \cdot w +b 的模型均为线性模型
    L=E[12(yd)2](MSE)形如 L = \mathbb{E}[\frac 12(y-d)^2] 称为均方误差(MSE)
    使MSE 使用MSE作为损失函数的模型称为最小二乘法。
    ,使最小二乘法告诉我们目标是什么, 然后大部分情况下可以使用梯度下降法来实现。
    , 如果预测的值是连续的, 则该机器学习模型称为:回归模型。
    线+=线 线性模型+回归模型=线性回归

    2.1 利用梯度下降法实现线性回归

    梯度下降法的原理在我的另一篇博客: 机器学习-数学基础-函数与优化

    """
    基于梯度下降法的线性回归
    """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    
    # 一. 模拟训练集数据
    
    # 制造特征, 以x=0为对称轴, 标准差为1的正态分布生成1000个点
    x = np.random.normal(0, 1, [1000])
    # 制造标签, 以一个一元一次方程加上噪声
    d = 2 * x + 5 + np.random.normal(0, 0.5, [1000])
    
    
    # 二.构建机器学习模型
    
    # 构建一元一次方程的机器学习模型 y = ax + b
    def model(x, a, b):
        return a * x + b
    
    
    # 损失函数为: L = 0.5 (y - d)^2, 此为我们的目标函数
    #  对目标函数分别求 a, b 的偏导(梯度)
    def grad(x, d, a, b):
        # 对 L 求 a, b 的偏导
        y = model(x, a, b)
        dLdy = (y - d)
        dLda = np.mean(dLdy * x)
        dLdb = np.mean(dLdy * 1)
        # 损失值
        L = np.mean(0.5 * (y - d) ** 2)
        return dLda, dLdb, L
    
    
    # 三. 进行函数的优化
    
    # 为可训练参数定义初始值
    a = 0
    b = 0
    # 定义超参数学习率
    eta = 0.3
    
    # 开始进行迭代
    for step in range(200):
        ga, gb, L = grad(x, d, a, b)
        a = a - eta * ga
        b = b - eta * gb
        print("a : %s, b: %s" % (a, b))
    
    print("迭代结束后的 a : %s, b: %s" % (a, b))
    
    # 绘制原始数据图,颜色为黑色, 透明度为0.5
    plt.scatter(x, d, color="k", alpha=0.5)
    
    # 绘制拟合后的直线, 颜色为红色, 宽度为6
    x_plt = np.linspace(-3, 3, 100)
    y_plt = model(x_plt, a, b)
    plt.plot(x_plt, y_plt, color="r", lw=6)
    
    plt.show()
    
    迭代结束后的 a : 2.013884999773956, b: 5.003882110267274
    

    在这里插入图片描述

    可以看到, 跟我们预设的训练集的函数很接近

    2.2 sk-learn 实现线性回归

    """
    线性回归(一元线性回归)
    
    LinearRegression基于最小二乘法
    """
    from sklearn.linear_model import LinearRegression
    import matplotlib.pyplot as plt
    import numpy as np
    
    plt.switch_backend("TkAgg")
    
    # 一. 模拟训练集数据
    
    # 制造特征, 以x=0为对称轴, 标准差为1的正态分布生成1000个点
    x = np.random.normal(0, 1, [1000])
    # 制造标签, 以一个一元一次方程加上噪声
    d = 2 * x + 5 + np.random.normal(0, 0.5, [1000])
    # 将x和d转为sk-learn认识的格式
    x = np.array(x).reshape(1000, 1)
    d = np.array(d).reshape(1000, 1)
    
    # 绘制原始数据图,颜色为黑色, 透明度为0.5
    plt.scatter(x, d, color="k", alpha=0.5)
    
    # 二. 模型训练
    # 基于x, d建立模型
    model = LinearRegression()
    model.fit(x, d)
    
    # 绘制拟合后的直线, 颜色为红色, 宽度为6
    x_plt = np.linspace(-3, 3, 100)
    x_plt = np.array(x_plt).reshape(100, 1)
    y_plt = model.predict(x_plt)
    # 将多维数组转为一维
    x_plt = x_plt.flatten()
    y_plt = np.array(y_plt).flatten()
    plt.plot(x_plt, y_plt, color="r", lw=6)
    
    plt.show()
    
    # 打印系数和截距, 分别对应上一个程序的 a 和 b
    print("迭代结束后的 系数 : %s, 截距: %s" % (model.coef_, model.intercept_))
    
    
    迭代结束后的 系数 : [[1.97161116]], 截距: [4.96504692]
    

    在这里插入图片描述

    三.多项式回归

    多项式回归为一种广义上的线性回归(即线性回归中x的系数不全为1):
    :y^(w,x)=w0+w1x1+w1x2+w3x12+w4x22++wpxpn如: \hat{y}(w,x) = w_0 + w_1x_1+ w_1x_2+ w_3x_1^2 + w_4x_2^2+\cdots + w_px_p^n

    3.1 梯度下降法进行多项式回归

    """
    多项式回归( 梯度下降法)
    """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    # 一. 模拟训练集数据
    
    # 制造特征, 以x=0为对称轴, 标准差为1的正态分布生成1000个点
    x = np.random.normal(0, 1, [1000])
    # 制造标签, 以一个一元三次方程加上噪声
    d = x ** 3 + 3 * x ** 2 + 2 * x + 5 + np.random.normal(0, 2, [1000])
    
    
    # 二.构建机器学习模型
    # 构建一元三次方程的机器学习模型 y = ax^3 + bx^2 + cx +k
    def model(x, a, b, c, k):
        return a * x ** 3 + b * x ** 2 + c * x + k
    
    
    # 损失函数为: L = 0.5 (y - d)^2, 此为我们的目标函数
    #  对目标函数分别求 a, b, c, k 的偏导(梯度)
    def grad(x, d, a, b, c, k):
        y = model(x, a, b, c, k)
        dLdy = (y - d)
        dLda = np.mean(dLdy * x ** 3)
        dLdb = np.mean(dLdy * x ** 2)
        dLdc = np.mean(dLdy * x)
        dLdk = np.mean(dLdy * 1)
        # 损失值
        L = np.mean(1 / 2 * (y - d) ** 2)
        return dLda, dLdb, dLdc, dLdk, L
    
    
    # 三. 进行函数的优化
    
    # 为可训练参数定义初始值
    a = 1
    b = 1
    c = 1
    k = 1
    # 定义超参数学习率
    eta = 0.1
    
    # 开始进行迭代
    for step in range(1000):
        ga, gb, gc, gk, L = grad(x, d, a, b, c, k)
        a = a - eta * ga
        b = b - eta * gb
        c = c - eta * gc
        k = k - eta * gk
        print("a : %s, b: %s, c : %s, k: %s" % (a, b, c, k))
    
    print("迭代结束后的 a : %s, b: %s, c : %s, k: %s" % (a, b, c, k))
    
    # 绘制原始数据图,颜色为黑色, 透明度为0.5
    plt.scatter(x, d, color="k", alpha=0.5)
    
    # 绘制拟合后的曲线, 颜色为红色, 宽度为6
    x_plt = np.linspace(-3, 3, 100)
    y_plt = model(x_plt, a, b, c, k)
    plt.plot(x_plt, y_plt, color="r", lw=6)
    
    plt.show()
    
    
    迭代结束后的 a : 1.0254913173071005, b: 2.8978685090191756, c : 1.9014938313936285, k: 5.092306822156842
    

    在这里插入图片描述

    3.2 sklearn进行多项式回归

    """
    多项式回归( sk-learn)
    """
    from sklearn.linear_model import LinearRegression
    from sklearn.preprocessing import PolynomialFeatures, StandardScaler
    from sklearn.pipeline import Pipeline
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    
    # 一. 模拟训练集数据
    
    # 制造特征, 以x=0为对称轴, 标准差为1的正态分布生成1000个点
    x = np.random.normal(0, 1, [1000])
    # 制造标签, 以一个一元三次方程加上噪声
    d = x ** 3 + 3 * x ** 2 + 2 * x + 5 + np.random.normal(0, 2, [1000])
    # 将x和d转为sk-learn认识的格式
    x = np.array(x).reshape(1000, 1)
    d = np.array(d).reshape(1000, 1)
    
    # 绘制原始数据图,颜色为黑色, 透明度为0.5
    plt.scatter(x, d, color="k", alpha=0.5)
    
    # 二. 模型训练
    model_process = [('poly', PolynomialFeatures(degree=3)),  # 多项式次幂,degree为幂数
                     ('standard', StandardScaler()),  # 归一化数据
                     ('linear_reg', LinearRegression())]  # 线性回归
    
    model = Pipeline(model_process)
    model.fit(x, d)
    
    
    # 绘制拟合后的曲线, 颜色为红色, 宽度为6
    x_plt = np.linspace(-3, 3, 100)
    x_plt = np.array(x_plt).reshape(100, 1)
    y_plt = model.predict(x_plt)
    # 将多维数组转为一维
    x_plt = x_plt.flatten()
    y_plt = np.array(y_plt).flatten()
    plt.plot(x_plt, y_plt, color="r", lw=6)
    
    plt.show()
    
    

    在这里插入图片描述

    四. 利用批尺寸训练数据

    以上程序我们采用的是每次迭代都代入全量数据, 我们还可以怎么做呢?

    1. 如果数据集比较小,可采用全数据集进行训练(Full Batch Learning), 由全部训练数据确定的方向能够更好地代表样本总体,从而更准确地指向极值的方向。


    2. 但是对于过大数据集, 由于机器性能的原因, 无法一次性加载计算过大数据,所以我们需要进行批尺寸划分数据(Batch Size)。

    4.1 批尺寸的取值

    1.如果Batch Size 过小, 跑完一次全数据集(epoch)需要的迭代次数更多, 导致训练速度过慢, 并且相邻 mini-batch 间的差异相对较大, 会导致相邻两次迭代的震荡情况比较严重, 不利于收敛。如此 Batch Size为1, 则我们称之为随机梯度下降, 这会失去矩阵运算带来的速度优势, 但因为样本点不同, 每次迭代梯度都是随机下降或震动, 这有可能在面对某些目标函数的时候, 会跳出局部最小值的陷阱。


    2.在一定范围内, Batch Size越大, 内存利用率越高, 大矩阵乘法的并行化效率提高, 跑完一次全数据集(epoch)所需的迭代次数越少, 对相同数据量的处理训练速度加快, 并且较大的 Batch Size 确定的下降方向更准确, 引起的梯度震荡越小。


    3.如果 Batch Size 极端大, 相邻 mini-bacth 间的差异过小, 导致不同 batch 的梯度方向没有变化, 容易陷入局部极小值.并且由于在同样的 epochs下参数更新变少, 反而需要更长的迭代次数, 从而导致性能下降。

    4.2 利用批尺寸拟合一元三次方程

    """
    多项式回归( 梯度下降法)
    采用 Mini-Batch 训练
    """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    # 一. 模拟训练集数据
    
    # 制造特征, 以x=0为对称轴, 标准差为1的正态分布生成1000个点
    x = np.random.normal(0, 1, [1000])
    # 制造标签, 以一个一元三次方程加上噪声
    d = x ** 3 + 3 * x ** 2 + 2 * x + 5 + np.random.normal(0, 2, [1000])
    
    
    # 二.构建机器学习模型
    # 构建一元三次方程的机器学习模型 y = ax^3 + bx^2 + cx +k
    def model(x, a, b, c, k):
        return a * x ** 3 + b * x ** 2 + c * x + k
    
    
    # 损失函数为: L = 0.5 (y - d)^2, 此为我们的目标函数
    #  对目标函数分别求 a, b, c, k 的偏导(梯度)
    def grad(x, d, a, b, c, k):
        y = model(x, a, b, c, k)
        dLdy = (y - d)
        dLda = np.mean(dLdy * x ** 3)
        dLdb = np.mean(dLdy * x ** 2)
        dLdc = np.mean(dLdy * x)
        dLdk = np.mean(dLdy * 1)
        # 损失值
        L = np.mean(1 / 2 * (y - d) ** 2)
        return dLda, dLdb, dLdc, dLdk, L
    
    
    # 三. 进行函数的优化
    
    # 为可训练参数定义初始值
    a = 1
    b = 1
    c = 1
    k = 1
    # 定义超参数学习率
    eta = 0.1
    
    # 对于数据量较多的情况下,我们可以采用 Batch Size进行训练。
    batch_size = 100
    
    # 开始进行迭代
    for step in range(1000):
    
        # 此时 step 可以取值为 0-9, 可以训练所有数据, 也可采用其他分组样式
        step = step % (1000 // batch_size)
        xin = x[step * batch_size:step * batch_size + batch_size]
        din = d[step * batch_size:step * batch_size + batch_size]
    
        ga, gb, gc, gk, L = grad(xin, din, a, b, c, k)
    
        a = a - eta * ga
        b = b - eta * gb
        c = c - eta * gc
        k = k - eta * gk
        print("a : %s, b: %s, c : %s, k: %s" % (a, b, c, k))
    
    print("迭代结束后的 a : %s, b: %s, c : %s, k: %s" % (a, b, c, k))
    
    # 绘制原始数据图,颜色为黑色, 透明度为0.5
    plt.scatter(x, d, color="k", alpha=0.5)
    
    # 绘制拟合后的直线, 颜色为红色, 宽度为6
    x_plt = np.linspace(-3, 3, 100)
    y_plt = model(x_plt, a, b, c, k)
    plt.plot(x_plt, y_plt, color="r", lw=6)
    
    plt.show()
    
    
    迭代结束后的 a : 0.8918837808367376, b: 2.9145724686906496, c : 2.1669257849632313, k: 5.084371880487646
    

    在这里插入图片描述

    五. 数据的归一化

    我们用某宝双十一的营业额做下预测, 我们从互联网上获取到 2011-2019年的营业额, 来预测2020年的营业额

    2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
    0.5, 9.36, 33.6, 191, 350, 571, 912, 1207, 1682, 2135, 2684

    绘制一下:

    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    x = [2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019]
    x = np.array(x)
    d = [0.5, 9.36, 33.6, 191, 350, 571, 912, 1207, 1682, 2135, 2684]
    d = np.array(d)
    
    plt.scatter(x, d, marker="o", c="r", s=20)
    plt.show()
    

    在这里插入图片描述
    我们通过观察, 预测模型为一元二次函数:

    5.1 我们先用原始数据进行预测

    """
    6. 预测 2020 年 双十一销售额
    """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    # 一. 准备训练集数据
    
    x = [2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019]
    x = np.array(x)
    d = [0.5, 9.36, 33.6, 191, 350, 571, 912, 1207, 1682, 2135, 2684]
    d = np.array(d)
    
    
    # 二.构建机器学习模型
    
    # 建立数学模型, ax^2 + bx + c, abc为可训练参数
    def model(x, a, b, c):
        return a * x ** 2 + b * x + c
    
    
    # 损失函数为: L = 0.5 (y - d)^2, 此为我们的目标函数
    #  对目标函数分别求 a, b 的偏导(梯度)
    def grad(x, d, a, b, c):
        y = model(x, a, b, c)
        dLdy = (y - d)
        dLda = np.mean(dLdy * x ** 2)
        dLdb = np.mean(dLdy * x ** 1)
        dLdc = np.mean(dLdy * 1)
        return dLda, dLdb, dLdc
    
    # 三. 进行函数的优化
    
    
    # 为可训练参数定义初始值
    a = 1
    b = 1
    c = 0
    # 定义超参数学习率
    eta = 0.0000000000001
    
    # 开始进行迭代
    for step in range(1000):
        ga, gb, gc = grad(x, d, a, b, c)
        a -= eta * ga
        b -= eta * gb
        c -= eta * gc
        print("a : %s, b: %s, c: %s" % (a, b, c))
    
    predict = model(2020, a, b, c)
    print("2020年销售额预测: %s" % predict)
    
    # 绘制拟合后的直线, 颜色为灰色, 宽度为2
    x_plt = np.linspace(2009, 2021, 100)
    y_plt = model(x_plt, a, b, c)
    plt.plot(x_plt, y_plt, color="k", lw=2)
    
    # 绘制原始数据图,颜色为红色
    plt.scatter(x, d, color="r")
    plt.show()
    

    在这里插入图片描述

    可以看到, 在这里, 学习率定为 0.0000000000001 ,得出的曲线明显欠拟合, 而把学习率稍微调大些, 则直接训练出错报错,这是由于 以年份直接做特征,可能会导致每次迭代得到的梯度过大,而导致不收敛。如我把学习率定位如下 0.1,打印 ga,gb,gc 三个梯度:

    ga : -2.113527971083052e+245, gb: -1.0494102976389005e+242, gc: -5.210551754324035e+238
    ga : 3.4773819527572355e+257, gb: 1.7265919732196034e+254, gc: 8.572906950982553e+250
    ga : -5.7213272834829e+269, gb: -2.8407571840048394e+266, gc: -1.4104981018414135e+263
    ga : 9.413284571391757e+281, gb: 4.673890243696101e+278, gc: 2.3206887776499316e+275
    ga : -1.548765208342707e+294, gb: -7.689939194071007e+290, gc: -3.818223077138074e+287
    ga : 2.5481792804423668e+306, gb: 1.2652236515024691e+303, gc: 6.282112279421257e+299
    ga : -inf, gb: -inf, gc: -inf
    ga : inf, gb: inf, gc: inf
    ga : nan, gb: nan, gc: nan
    ga : nan, gb: nan, gc: nan
    

    各个梯度已经大到超越计算机数字的范围了

    5.2 数据的归一化

    1.归一化是一种简化计算的方式,即将有量纲的表达式,变换为无量纲的表达式,成为标量。目的是让大的输入,大的信号映射到小范围里面。


    2.据归一化后,最优解的寻优过程会变得平缓,更容易收敛,提升模型的收敛速度。


    3.归一化可以提高模型训练精度,在一些涉及距离计算的算法时效果显著,比如算法中要计算欧氏距离,取值范围较大的特征比取值范围较小的特征对结果的影响会更大,所以会导致精度损失,而归一化可以使各个特征向量对结果的影响趋于相同。

    归一化/标准化常用方式:

    1.对原始数据进行放缩, 将数据归一到[0,1]中间, 这种方法的缺陷是当有新数据加入时, 可能导致max和min的变化, 所以这种方法只适用于数据在一个范围内分布的情况。在不涉及距离度量、协方差计算、数据不符合正太分布的时候,可以使用归一化方法。

    X^=xxminxmaxxmin \hat X = \frac{x - x_{min}}{\lvert x_{max} - x_{min} \lvert}

    其他一些标准化/归一化方式(注:标准化和归一化是有区别的, 本章不重点叙述):

    2. 将数据放缩到 [-1, 1]区间

    X^=xxˉxmaxxmin \hat X = \frac{x - \bar x}{\lvert x_{max} - x_{min} \lvert}

    3.如果数据的分布本身就服从正态分布, 可以使数据减去均值然后除以方差(或标准差), 这种数据标准化方法经过处理后数据符合标准正态分布,即均值为0,标准差为1。为防止除数为0, 可在分母上加上一个很小的数.

    X^=xxˉσ+ϵ \hat X = \frac{x - \bar x}{\sigma + \epsilon}

    """
    预测 2020 年 双十一销售额( 归一化)
    """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    # 一. 准备训练集数据
    
    x = [2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019]
    x = np.array(x)
    d = [0.5, 9.36, 33.6, 191, 350, 571, 912, 1207, 1682, 2135, 2684]
    d = np.array(d)
    
    
    # 二.构建机器学习模型
    
    # 建立数学模型, ax^2 + bx + c, abc为可训练参数
    def model(x, a, b, c):
        return a * x ** 2 + b * x + c
    
    
    # 损失函数为: L = 0.5 (y - d)^2, 此为我们的目标函数
    #  对目标函数分别求 a, b 的偏导(梯度)
    def grad(x, d, a, b, c):
        y = model(x, a, b, c)
        dLdy = (y - d)
        dLda = np.mean(dLdy * x ** 2)
        dLdb = np.mean(dLdy * x ** 1)
        dLdc = np.mean(dLdy * 1)
        loss = np.mean(0.5 * (y - d) ** 2)
        return dLda, dLdb, dLdc, loss
    
    
    # 三. 进行函数的优化
    
    # 为可训练参数定义初始值
    a = 1
    b = 1
    c = 0
    # 定义超参数学习率
    eta = 0.2
    
    
    # 进行数据的归一化, 将 x, d 的值归一到 0-1的范围
    x_min = np.min(x)
    x_max = np.max(x)
    xn = (x - x_min) / (x_max - x_min)
    d_min = np.min(d)
    d_max = np.max(d)
    dn = (d - d_min) / (d_max - d_min)
    
    
    # 开始进行迭代
    for step in range(20000):
        ga, gb, gc, loss = grad(xn, dn, a, b, c)
        a -= eta * ga
        b -= eta * gb
        c -= eta * gc
        # print("a : %s, b: %s, c: %s, 损失函数: %s" % (a, b, c, loss))
    
    # 做预测的时候, 需要将 年份 进行归一化
    predict = model((2020 - x_min) / (x_max - x_min), a, b, c)
    # 取出预测值得时候需要按照归一化的规则, 反向获取真正的数值
    print("2020年销售额: ", predict * (d_max - d_min) + d_min)
    
    
    # 绘制拟合后的曲线, 颜色为灰色, 宽度为2(该直线为归一化之后的曲线)
    x_plt = np.linspace(2009, 2021, 100)
    x_plt = (x_plt - x_min) / (x_max - x_min)
    y_plt = model(x_plt, a, b, c)
    
    plt.plot(x_plt, y_plt, color="k", lw=2)
    
    # 绘制训练数据归一化后的散点图,颜色为红色
    plt.scatter(xn, dn, color="r")
    plt.show()
    
    2020年销售额:  3282.2758912241256
    

    在这里插入图片描述
    在我们对原始数据进行归一化后, 较好的拟合出了曲线

    六. 利用矩阵优化程序编写

    利用矩阵的乘法,优化各个梯度的计算方式, 防止每加一个系数就要多求一次偏导:

    """
    预测 2020 年 双十一销售额(矩阵乘法, 一元三次方程)
    """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    # 一. 准备训练集数据
    x = [2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019]
    x = np.array(x)
    d = [0.5, 9.36, 33.6, 191, 350, 571, 912, 1207, 1682, 2135, 2684]
    d = np.array(d)
    
    
    # 二.构建机器学习模型
    
    # 建立通用线性回归模型, y = x @ w +b, w为可训练参数向量
    def model(x, w, b):
        return x @ w + b
    
    
    # 损失函数为: L = 0.5 (y - d)^2, 此为我们的目标函数
    #  对目标函数分别求 w, b 的偏导(梯度)
    def grad(x, d, w, b):
        y = model(x, w, b)
        dLdy = (y - d)
    
        # 利用矩阵的乘法, x为我们为多项式构建的特征向量,
        # x.T为相同特征列表, 最终获得dLdw为 梯度的向量
        dLdw = x.T @ dLdy / len(d)
        # 为偏置参数d求偏导
        # 这里的数据集已经是二维矩阵了, 所以对列求平均
        dLdb = np.mean(dLdy, axis=0)
        loss = 0.5 * (y - d) ** 2
        return dLdw, dLdb, loss
    
    
    # 为 w 向量赋予初始值, 以x=0为对称轴, 标准差为1的正态分布生成三行一列的二维矩阵
    w = np.random.normal(0, 1, [3, 1])
    # 为 b 赋予初始值, 注意也要协程矩阵的形式, 哪怕只有一个数
    b = np.array([0.0])
    
    # 定义超参数学习率
    eta = 0.2
    
    # 进行数据的归一化, 将 x, d 的值归一到 0-1的范围
    x_min = np.min(x)
    x_max = np.max(x)
    xn = (x - x_min) / (x_max - x_min)
    d_min = np.min(d)
    d_max = np.max(d)
    dn = (d - d_min) / (d_max - d_min)
    
    # 将 xn, dn 重组为11行一列的数据, 以满足矩阵运算的要求
    xn = np.reshape(xn, [11, 1])
    dn = np.reshape(dn, [11, 1])
    
    # 将 x, x^2, x^3 作为特征进行拼接
    xn2 = np.concatenate([xn, xn ** 2, xn ** 3], axis=1)
    
    # 开始迭代
    for step in range(20000):
        gw, gb, loss = grad(xn2, dn, w, b)
        w -= eta * gw
        b -= eta * gb
        # print("w: %s, b: %s, 损失函数: %s: " % (w, b, loss))
    
    print("w: %s, b: %s, 损失函数: %s: " % (w, b, loss))
    
    # 三.模型的预测和绘制
    
    # 做预测的时候, 需要将 年份 进行归一化
    predict_x = (2020 - x_min) / (x_max - x_min)
    predict_x_feature = [predict_x, predict_x ** 2, predict_x ** 3]
    predict_y = model(predict_x_feature, w, b)
    print(predict_y)
    
    # 取出预测值得时候需要按照归一化的规则, 反向获取真正的数值
    print("2020年销售额: ", predict_y[0] * (d_max - d_min) + d_min)
    
    
    # 绘制拟合后的曲线, 颜色为灰色, 宽度为2(该直线为归一化之后的曲线)
    x_plt = np.linspace(2009, 2021, 100)
    x_plt = (x_plt - x_min) / (x_max - x_min)
    
    # 将 x_plt 转为 100行1列的数据
    x_plt2 = np.reshape(x_plt, [100, 1])
    # 将 x_plt, x_plt^2, x_plt^3 进行拼接, 得到 100行3列的数据
    x_plt2 = np.concatenate([x_plt2, x_plt2 ** 2, x_plt2 ** 3], axis=1)
    # 代入到模型中
    y_plt = model(x_plt2, w, b)
    
    plt.plot(x_plt, y_plt, color="k", lw=2)
    
    # 绘制训练数据归一化后的散点图,颜色为红色
    plt.scatter(xn, dn, color="r")
    
    plt.show()
    
    2020年销售额:  3173.4911287547034
    

    在这里插入图片描述

    展开全文
  • 一、有无截距对于逻辑回归分类,就是找到z那条直线,不通过原点有截距的直线与通过原点的直线相比,有截距更能将数据分类的彻底。 package com.bjsxt.lr import org.apache.spark.mllib.classification.{...

    环境
      spark-1.6
      python3.5

    一、有无截距
    对于逻辑回归分类,就是找到z那条直线,不通过原点有截距的直线与通过原点的直线相比,有截距更能将数据分类的彻底。

    package com.bjsxt.lr
    
    import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS}
    import org.apache.spark.mllib.util.MLUtils
    import org.apache.spark.{SparkConf, SparkContext}
    /**
     * 逻辑回归 健康状况训练集   
     */
    object LogisticRegression {
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("spark").setMaster("local[3]")
        val sc = new SparkContext(conf)
        //加载 LIBSVM 格式的数据  这种格式特征前缀要从1开始 
        val inputData = MLUtils.loadLibSVMFile(sc, "健康状况训练集.txt")
        val splits = inputData.randomSplit(Array(0.7, 0.3), seed = 1L)
        val (trainingData, testData) = (splits(0), splits(1))
        val lr = new LogisticRegressionWithLBFGS()
    //    lr.setIntercept(true)
        val model = lr.run(trainingData)
        val result = testData
          .map{point=>Math.abs(point.label-model.predict(point.features)) }
        println("正确率="+(1.0-result.mean()))
        
        /**
         *逻辑回归算法训练出来的模型,模型中的参数个数(w0....w6)=训练集中特征数(6)+1 
         */
        println(model.weights.toArray.mkString(" "))
        println(model.intercept)
        
        sc.stop()
      }
    }
    package com.bjsxt.lr
    
    import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}
    import org.apache.spark.mllib.regression.LabeledPoint
    import org.apache.spark.mllib.util.MLUtils
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
      * 有无截距
      */
    object LogisticRegression2 {
    
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("spark").setMaster("local[3]")
        val sc = new SparkContext(conf)
        val inputData: RDD[LabeledPoint] = MLUtils.loadLibSVMFile(sc, "w0测试数据.txt")
        /**
         * randomSplit(Array(0.7, 0.3))方法就是将一个RDD拆分成N个RDD,N = Array.length
         * 第一个RDD中的数据量和数组中的第一个元素值相关
         */
        val splits = inputData.randomSplit(Array(0.7, 0.3),11L)
        val (trainingData, testData) = (splits(0), splits(1))
        val lr = new LogisticRegressionWithSGD
        // 设置要有W0,也就是有截距
        lr.setIntercept(true)
        val model=lr.run(trainingData)
        val result=testData.map{labeledpoint=>Math.abs(labeledpoint.label-model.predict(labeledpoint.features)) }
        println("正确率="+(1.0-result.mean()))
        println(model.weights.toArray.mkString(" "))
        println(model.intercept)
      }
    }

     

    二、线性不可分问题
    对于线性不可分问题,可以使用升高维度的方式转换成线性可分问题。低维空间的非线性问题在高维空间往往会成为线性问题。

    package com.bjsxt.lr
    
    import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}
    import org.apache.spark.mllib.linalg.Vectors
    import org.apache.spark.mllib.regression.LabeledPoint
    import org.apache.spark.mllib.util.MLUtils
    import org.apache.spark.{SparkConf, SparkContext}
    /**
     *  线性不可分 ----升高维度
     */
    object LogisticRegression3 {
    
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("spark").setMaster("local[3]")
        val sc = new SparkContext(conf)
        // 解决线性不可分我们来升维,升维有代价,计算复杂度变大了
        val inputData = MLUtils.loadLibSVMFile(sc, "线性不可分数据集.txt")
          .map { labelpoint =>
            val label = labelpoint.label
            val feature = labelpoint.features
            //新维度的值,必须基于已有的维度值的基础上,经过一系列的数学变换得来
            val array = Array(feature(0), feature(1), feature(0) * feature(1))
            val convertFeature = Vectors.dense(array)
            new LabeledPoint(label, convertFeature)
          }
        val splits = inputData.randomSplit(Array(0.7, 0.3),11L)
        val (trainingData, testData) = (splits(0), splits(1))
        val lr = new LogisticRegressionWithLBFGS()
        lr.setIntercept(true)
        val model = lr.run(trainingData)
        val result = testData
          .map { point => Math.abs(point.label - model.predict(point.features)) }
        println("正确率=" + (1.0 - result.mean()))
        println(model.weights.toArray.mkString(" "))
        println(model.intercept)
      }
    }

     



    三、调整分类阈值
    在一些特定的场景下,如果按照逻辑回归默认的分类阈值0.5来进行分类的话,可能存在一些潜在的风险,比如,假如使用逻辑回归预测一个病人得癌症的概率是0.49,那么按照0.5的阈值,病人推测出来是没有得癌症的,但是49%的概率得癌症,比例相对来说得癌症的可能性也是很高,那么我们就可以降低分类的阈值,比如将阈值设置为0.3,小于0.3认为不得癌症,大于0.3认为得癌症,这样如果病人真的是癌症患者,规避掉了0.49概率下推断病人是不是癌症的风险。
    降低阈值会使逻辑回归整体的正确率下降,错误率增大,但是规避了一些不能接受的风险。

    package com.bjsxt.lr
    
    import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}
    import org.apache.spark.mllib.util.MLUtils
    import org.apache.spark.{SparkConf, SparkContext}
    /**
     * 设置分类阈值
     */
    
    object LogisticRegression4 {
    
      def main(args: Array[String]) {
    
        val conf = new SparkConf().setAppName("spark").setMaster("local[3]")
        val sc = new SparkContext(conf)
        /**
         * LabeledPoint = Vector+Y
         */
        val inputData = MLUtils.loadLibSVMFile(sc, "健康状况训练集.txt")
        val splits = inputData.randomSplit(Array(0.7, 0.3),11L)
        val (trainingData, testData) = (splits(0), splits(1))
        val lr = new LogisticRegressionWithLBFGS()
        lr.setIntercept(true)
        
    //    val model = lr.run(trainingData)
    //    val result = testData
    //      .map{point=>Math.abs(point.label-model.predict(point.features)) }
    //    println("正确率="+(1.0-result.mean()))
    //    println(model.weights.toArray.mkString(" "))
    //    println(model.intercept)
        /**
         * 如果在训练模型的时候没有调用clearThreshold这个方法,那么这个模型预测出来的结果都是分类号
         * 如果在训练模型的时候调用clearThreshold这个方法,那么这个模型预测出来的结果是一个概率
         */
        val model = lr.run(trainingData).clearThreshold()
        val errorRate = testData.map{p=>
          //score就是一个概率值
          val score = model.predict(p.features)
          // 癌症病人宁愿判断出得癌症也别错过一个得癌症的病人
          val result = score>0.3 match {case true => 1 ; case false => 0}
          Math.abs(result-p.label)
        }.mean()
        println(1-errorRate)
      }
    }

     

    四、鲁棒性调优
    鲁棒是Robust的音译,也就是健壮和强壮的意思,比如说,计算机软件在输入错误、磁盘故障、网络过载或有意攻击情况下,能不死机、不崩溃,就是该软件的鲁棒性,那么算法的鲁棒性就是指这个算法的抗干扰能力强。

    package com.bjsxt.lr
    
    import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}
    import org.apache.spark.mllib.optimization.{L1Updater, SquaredL2Updater}
    import org.apache.spark.mllib.util.MLUtils
    import org.apache.spark.{SparkConf, SparkContext}
    /**
     * 鲁棒性调优
     * 提高模型抗干扰能力
     */
    object LogisticRegression5 {
    
      def main(args: Array[String]) {
    
        val conf = new SparkConf().setAppName("spark").setMaster("local[3]")
        val sc = new SparkContext(conf)
        val inputData = MLUtils.loadLibSVMFile(sc, "健康状况训练集.txt")
        val splits = inputData.randomSplit(Array(0.7, 0.3),100)
        val (trainingData, testData) = (splits(0), splits(1))
        /**
         * LogisticRegressionWithSGD 既有L1 又有L2正则化(默认)
         */
        val lr = new LogisticRegressionWithSGD()
        lr.setIntercept(true)
    //    lr.optimizer.setUpdater(new L1Updater())
        lr.optimizer.setUpdater(new SquaredL2Updater)
        
        /**
         * LogisticRegressionWithLBFGS 既有L1 又有L2正则化(默认)
         */
    //    val lr = new LogisticRegressionWithLBFGS()
    //    lr.setIntercept(true)
    //    lr.optimizer.setUpdater(new L1Updater)
    //    lr.optimizer.setUpdater(new SquaredL2Updater)
        
        /**
         *  这块设置的是我们的lambda,越大越看重这个模型的推广能力,一般不会超过1,0.4是个比较好的值
         */
        lr.optimizer.setRegParam(0.4)
        val model = lr.run(trainingData)
        val result=testData
          .map{point=>Math.abs(point.label-model.predict(point.features)) }
        println("正确率="+(1.0-result.mean()))
        println(model.weights.toArray.mkString(" "))
        println(model.intercept)
    
      }
    }

     

    五、归一化数据
    多个维度特征的量级不同,会导致训练出来模型中不同特征对应的w参数差异很大,容易导致参数小的特征对目标函数的影响被覆盖,所以需要对每个特征的数据进行归一化处理,以减少不同量级的特征数据覆盖其他特征对目标函数的影响。
    归一化数据可以使各个特征维度对目标函数的影响权重一致,提高迭代的求解的收敛速度。

    最大最小值归一化: ,缺点是抗干扰能力弱,受离群值影响比较大,中间容易没有数据。最大最小值归一化后的数据落在[0,1]之间。假设某个特征下有一组数据:1,2,3,4,5,100那么对数据使用最大最小值归一化后的值为:0,2/99,3/99,4/99,1。中间没有数据,受离群值100的影响大。

    package com.bjsxt.lr
    
    import org.apache.spark.SparkConf
    import org.apache.spark.SparkContext
    import org.apache.spark.ml.feature.MinMaxScaler
    import org.apache.spark.sql.SQLContext
    import org.apache.spark.mllib.linalg.DenseVector
    import org.apache.spark.mllib.regression.LabeledPoint
    import org.apache.spark.mllib.linalg.Vectors
    import org.apache.spark.mllib.classification.LogisticRegressionWithLBFGS
    
    /**
     * 最大最小值归一化
     */
    object LogisticRegression7 {
      def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("spark").setMaster("local")
        val sc = new SparkContext(conf)
        val sqlContext = new SQLContext(sc)
        /**
         * 加载生成的DataFrame自动有两列:label features
         */
        val df = sqlContext.read.format("libsvm").load("环境分类数据.txt")
    //    df.show()
        /**
         * MinMaxScaler fit需要DataFrame类型数据
         * setInputCol:设置输入的特征名
         * setOutputCol:设置归一化后输出的特征名
         * 
         */
        val minMaxScalerModel = new MinMaxScaler()
                                .setInputCol("features")
                                .setOutputCol("scaledFeatures")
                                .fit(df)
        /**
         * 将所有数据归一化
         */
        val features = minMaxScalerModel.transform(df)
        features.show()
        
        val normalizeInputData = features.rdd.map(row=>{
          val label = row.getAs("label").toString().toDouble
          val dense = (row.getAs("scaledFeatures")).asInstanceOf[DenseVector]
          new LabeledPoint(label,dense)
        })
        
        val splits = normalizeInputData.randomSplit(Array(0.7, 0.3),11L)
        val (trainingData, testData) = (splits(0), splits(1))
        val lr=new LogisticRegressionWithLBFGS()
        lr.setIntercept(true)
        val model = lr.run(trainingData)
        val result=testData.map{point=>Math.abs(point.label-model.predict(point.features)) }
        println("正确率="+(1.0-result.mean()))
        println(model.weights.toArray.mkString(" "))
        println(model.intercept)  
        
      }
    }

     

    方差归一化: ,其中u是样本的均值, 是样本的标准差(方差的开方,方差:所有点与均值的差值平方和)。方差归一化抗干扰能力强,和所有数据有关,求标准差需要所有的值介入,若有离群值,会被抑制下来。但是归一化后的数据最终的结果不一定落在0到1之间。
    注意:理论上一个模型算法如果拿到训练集所有的特征一起训练模型就要归一化数据。决策树算法可以不归一化数据。

    package com.bjsxt.lr
    
    import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}
    import org.apache.spark.mllib.feature.StandardScaler
    import org.apache.spark.mllib.regression.LabeledPoint
    import org.apache.spark.mllib.util.MLUtils
    import org.apache.spark.{SparkConf, SparkContext}
    import org.apache.spark.ml.feature.MinMaxScaler
    import org.apache.spark.sql.SQLContext
    /**
     * 方差归一化
     */
    object LogisticRegression6 {
    
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("spark").setMaster("local[3]")
        val sc = new SparkContext(conf)
        val sqlContext = new SQLContext(sc)
        /**
         * scalerModel 这个对象中已经有每一列的均值和方差
         * withStd:代表的是方差归一化
         * withMean:代表的是均值归一化
         * scalerModel:存放每一列的方差值
         * 
         * withMean默认为false, withStd默认为true
         * 当withMean=true,withStd=false时,向量中的各元素均减去它相应的均值。
         * 当withMean=true,withStd=true时,各元素在减去相应的均值之后,还要除以它们相应的标准差。 
         * 
         */
        val inputData = MLUtils.loadLibSVMFile(sc, "环境分类数据.txt")
        
        val vectors = inputData.map(_.features)
        val scalerModel = new StandardScaler(withMean=true, withStd=true).fit(vectors)
        
        val normalizeInputData = inputData.map{point =>  
          val label = point.label
          //对每一条数据进行了归一化
          val features = scalerModel.transform(point.features.toDense)
          println(features)
          new LabeledPoint(label,features)
        }
    
        
        val splits = normalizeInputData.randomSplit(Array(0.7, 0.3),100)
        val (trainingData, testData) = (splits(0), splits(1))
        val lr=new LogisticRegressionWithLBFGS()
    //    val lr = new LogisticRegressionWithSGD()
        lr.setIntercept(true)
        val model = lr.run(trainingData)
        val result=testData.map{point=>Math.abs(point.label-model.predict(point.features)) }
        println("正确率="+(1.0-result.mean()))
        println(model.weights.toArray.mkString(" "))
        println(model.intercept)
      }
    }

     

    六、调整数据的正负值-均值归一化
    均值归一化是将原来的特征值减去这个特征在数据集中的均值,这样就会使x的各个维度取值上有正有负,在迭代求 参数时,能减少迭代的次数。

     

    七、训练方法选择
    训练逻辑回归的方法有:SGD和L-BFGS,两者的区别为:
    SGD:随机从训练集选取数据训练,不归一化数据,需要专门在外面进行归一化,支持L1,L2正则化,不支持多分类。
    L-BFGS:所有的数据都会参与训练,算法融入方差归一化和均值归一化。支持L1,L2正则化,支持多分类。

    转载于:https://www.cnblogs.com/cac2020/p/10910430.html

    展开全文
  • 机器学习之算法分类

    2018-06-19 13:51:00
    有监督学习:分类算法、回归算法 无监督学习:聚类算法 半监督学习 算法分类(2):针对所解决的问题 分类与回归 聚类 标注 算法分类(3):针对算法本质 生成模型 判别模型 常见的机器学习算法: ...
  • 1.回归算法 2.神经网络 3.svm(支持向量机) 4.聚类算法 5.降维算法 6.推荐算法 7.其它(高斯判别,朴素贝叶斯,决策树等等) 按照训练的数据有无标签,可以将上面算法分为监督学习算法和无监督学习算法...
  • 机器学习算法---总结

    2018-05-21 16:57:15
    下面做一个总结,按照训练的数据有无标签,可以将上面算法分为监督学习算法和无监督学习算法,但推荐算法较为特殊,既不属于监督学习,也不属于非监督学习,是单独的一类。监督学习算法:线性回归,逻辑回归,神经...
  • 其中对于连续答案值使用回归算法,对于离散答案值使用分类算法。 无监督学习 数据集中只要特征值,没有答案,即只告诉计算机是什么,而不告诉计算机要求的是什么,让计算机自动分析,形成多个特征值相近的簇,称为...
  • 根据数据有无类别信息,可将机器学习算法划分为有监督学习(数据集含有类别信息)、无监督学习(不含有类别信息),半监督学习(数据集中只有部分数据有类别信息)。其中,有监督的学习又可以分为分类(预测结果是离散值)和...
  • 种类的判别分析 有无数据的分析 取代逻辑斯蒂回归回归分析上的应用 案例的数据格式和R 语言代码可 为研究随机森林在分类与回归分析中的应用提供参考 ">随机森林 random forest 模型是由Breiman 和Cutler 在2001 ...
  • 什么是分类(classification)?什么是回归(regression)?分类回归 分类 分类是指有有限个可能的问题,预测的是一个离散的、明确的变量。比如给出一张图片,去判断是T恤是裤子或者其他的种类...相反,回归是指有无...
  • 如果我们有无标签数据并且想要去发现结构,这是一个无监督学习问题。如果我们想要通过与环境交互优化目标函数,这是一个强化学习问题。 通过输出分类:如果一个模型的输出是一个数字,这是一个回归问题。如果模型...
  • 机器学习介绍

    2020-04-16 17:43:07
    定义 机器学习是一种能够赋予机器学习的能力以此让它完成直接编程无法完成的功能的方法...回归算法 神经网络 SVM(支持向量机) 聚类算法 降维算法 推荐算法 按照训练的数据有无标签,可以将上面算法分为监督学习算...
  • 机器学习目录

    千次阅读 2019-12-09 21:24:22
    其中对于连续答案值使用回归算法,对于离散答案值使用分类算法。 无监督学习 数据集中只要特征值,没有答案,即只告诉计算机是什么,而不告诉计算机要求的是什么,让计算机自动分析,形成多个特征值相近的簇,称为...
  • ml算法按照有无label可以分为有监督学习和无监督学习,对于无监督学习的算法比较经典的有聚类算法,有监督的相对来说较多,回归算法基本都是的。按照参数有可以划分成有参数模型和无参数模型和半参数模型,有参数...
  • K-Means原理解析

    2020-10-14 10:39:35
    监督学习里面的代表算法就是:SVM、逻辑回归、决策树、各种集成算法等等。 非监督学习主要的任务就是通过一定的规则,把相似的数据聚集到一起,简称聚类。我们今天讲的K-Means算法是在非监督学习比较容易理解的一个...
  • 1. K-Means原理解析

    2019-01-05 12:45:00
    1. K-Means原理解析 2. K-Means的优化 ...监督学习里面的代表算法就是:SVM、逻辑回归、决策树、各种集成算法等等。 非监督学习主要的任务就是通过一定的规则,把相似的数据聚集到一起,简称聚类。我...
  • 在模式识别和机器学习中,k最近邻算法(或简称k-NN)是用于分类和回归的非参数方法。 在这两种情况下,输入都包含的特征空间中的k个最接近的训练示例 实验 我开始这项工作,以比较在有无数据归一化的情况下,由KNN...
  • 我理解的机器学习就是,如何通过设计算法使得机器掌握学习的能力,发现数据中的规律。今天主要来熟悉机器学习的主要任务。具体地说,从有无因变量的角度出发,可以将机器学习任务分为有监督学习和无监督学习。其次,...
  • 首先我们有一组医疗数据,以有无心脏...然而方法有许多种,包括logistics regression(逻辑回归)、K-nearest neighbors(最近邻算法)、support vector machine(支持向量机、SVM)等等,我们该如何从中挑选? C...
  • 卷积网络基础概要

    2019-12-05 09:59:17
    之前曾讲到过分类问题,回归问题等等。但是都是简要概括,只讲了数据有无标签等等,关于如何对数据进行处理以及提取数据中的信息的基础知识将在本博客中介绍。而卷积神经网络是深度学习的代表算法之一,通常用于提取...
  • 其中,对于半监督问题,我们首先采用聚类等无监督的手法,缩小处理范围,然后再利用少量的真值进行有监督的算法。 3.映射函数可以分为两种类型,一种是回归,一种是分类。注意两种函数是可以互相转化的。 4.机器...
  • 统计学习方法概论导学与资源推荐数据与规律课件中推荐的资源机器学习概述机器学习定义理解机器学习应用机器学习的发展历程机器学习VS统计学习统计学习的方法按有无监督分类监督学习无监督学习半监督学习强化学习统计...
  • #首先看下你的设备有无cuda可用: class ReplayBuffer: def __init__(self, action_size, buffer_size, batch_size):# 初始化记忆库 self.action_size = action_size self.memory = deque(maxlen&...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    删除操作一旦执行,立即被监听器捕获到,进而在执行 删除操作前执行自定义的函数体,即判断实体有无undeletable标签,有则中断删除操作,无则正常删除。 用例图 关系 关联关系 ;依赖关系 ;泛化关系;关系的...
  • 精易模块[源码] V5.15

    2015-03-21 22:03:37
    3、改善“文本_加密”与“文本_解密”去除原来算法,改用微软基础加解密API。 4、修复“网页_打印”,无效的BUG,感谢易友【@nameyypx】反馈。 5、修复“时间_取身份证判断”出现17位身份证的BUG,感谢易友【@求其改...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

有无回归算法