精华内容
下载资源
问答
  • 回归算法线性回归线性回归的定义线性回归误差的度量线性回归减小误差的方法方法一:正规方程方法二:梯度下降正规方程和梯度下降的对比回归性能评估过拟合和欠拟合过拟合欠拟合解决方法岭回归岭回归的概念岭回归的...

    线性回归

    线性回归的定义

    线性回归通过一个或多个自变量与因变量之间的关系进行建模与回归分析,其特点为一个或多个回归系数的参数的线性组合。根据自变量的个数不同分为一元线性回归和多元线性回归。其具体表示公式如下:
    在这里插入图片描述

    线性回归误差的度量

    损失函数,又称最小二乘法,其具体表示公式如下:
    在这里插入图片描述

    线性回归减小误差的方法

    核心思想:找到最小损失对应的W值

    方法一:正规方程
    • 具体公式
      在这里插入图片描述
    • 注意点:需要进行标准化处理
    • 缺点:当特征过于复杂时,求解速度太慢。
    • 代码示例(预测波士顿房价)
    from sklearn.datasets import load_boston
    from sklearn.linear_model import LinearRegression
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def mylinear():
        """
        用LinearRegression方法预测波士顿房价
    
        :return: None
        """
    
        # 获取数据
        lb = load_boston()
    
        # 分割数据集
        x_train, x_test, y_train, y_test = train_test_split(lb.data,lb.target,test_size=0.25)
    
        # 标准化处理(注意特征值和目标值需要实例化两个API,因为维数不一样)
    
        std_x = StandardScaler()
        x_train = std_x.fit_transform(x_train)
        x_test = std_x.transform(x_test)
    
        std_y = StandardScaler()
        y_train = std_y.fit_transform(y_train.reshape(-1,1))
        y_test = std_y.transform(y_test.reshape(-1,1))
    
        # 用估计器预测房价结果
        lr = LinearRegression()
        lr.fit(x_train,y_train)
        print(lr.coef_)
    
        predict_std = lr.predict(x_test)
        y_predict = std_y.inverse_transform(predict_std.reshape(-1,1))
        print("线性回归方程预测房价结果:", y_predict)
        print("线性回归方程预测军方误差:", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
    
        return None
    
    if __name__ == '__main__':
        mylinear()
    

    输出结果:

    [[-0.07189689  0.11056253  0.00852308  0.06510871 -0.17156743  0.3417623
      -0.0550457  -0.29720397  0.22697546 -0.21461555 -0.21549207  0.12524146
      -0.323476  ]]
    线性回归方程预测房价结果: [[16.67298491]
     [21.51430668]
     [15.63161012]
     [41.67971428]
     [22.12070811]
     [29.74143583]
     [45.16135176]
     [13.47566068]
     [18.94535531]
     [28.80047496]
     [21.2140528 ]
     [28.17246202]
     [26.24308882]
     [12.27271099]
     [26.33784283]
     [20.0184693 ]
     [15.56019304]
     [19.78458139]
     [ 8.44834886]
     [19.2649333 ]
     [32.51179258]
     [23.04744077]
     [12.19437145]
     [18.24760861]
     [18.15170883]
     [11.03283082]
     [25.74066679]
     [30.53326076]
     [28.75518113]
     [15.41794206]
     [31.71846201]
     [13.11025356]
     [ 9.39360885]
     [25.86065388]
     [14.83219011]
     [19.17522972]
     [24.72453426]
     [17.97900083]
     [24.60920764]
     [16.33075212]
     [32.92539655]
     [19.33175092]
     [22.56207634]
     [22.08126759]
     [26.8019178 ]
     [27.81518837]
     [ 6.13935003]
     [20.20341886]
     [15.83163726]
     [33.39822915]
     [21.91187973]
     [21.30148556]
     [29.69154311]
     [35.27221326]
     [25.36056497]
     [22.99531908]
     [24.23264307]
     [ 9.91553065]
     [26.88413251]
     [22.80506192]
     [22.10942353]
     [34.84690799]
     [17.0764197 ]
     [30.17811061]
     [30.3602628 ]
     [25.59228421]
     [19.61567103]
     [17.44520032]
     [32.08421329]
     [22.42346097]
     [35.13647673]
     [23.55930269]
     [27.7629917 ]
     [25.36087011]
     [22.98636269]
     [23.81183436]
     [43.91295741]
     [31.0158378 ]
     [23.90163612]
     [19.8617725 ]
     [ 0.40462815]
     [19.06456293]
     [21.00950922]
     [30.57172582]
     [21.54336377]
     [17.94269787]
     [22.56265107]
     [18.70495122]
     [28.99876226]
     [34.92273719]
     [23.07659802]
     [10.38802434]
     [21.50174461]
     [16.91550915]
     [28.36196581]
     [24.33000943]
     [25.9625918 ]
     [17.19987812]
     [36.29645747]
     [20.3181725 ]
     [ 6.31130636]
     [ 9.82912988]
     [ 5.71437948]
     [12.55375899]
     [11.8760076 ]
     [21.08312231]
     [16.16794352]
     [23.89854365]
     [19.00454068]
     [16.35134125]
     [25.74128361]
     [15.40079632]
     [36.4936849 ]
     [ 5.36164699]
     [24.70578649]
     [34.23378414]
     [28.17193439]
     [27.68687533]
     [17.6316129 ]
     [27.19337924]
     [19.31946272]
     [22.02621029]
     [27.28518294]
     [29.49658103]
     [39.68007288]
     [40.08295584]
     [26.26031041]]
    线性回归方程预测军方误差: 30.331638135174217
    
    方法二:梯度下降
    • 概念:沿着这个函数下降的方向找,最后就能找到山谷的最低点,然后更新W值,每次下降的幅度不同。
    • 算法公式:
      在这里插入图片描述
    • 示意图
      即从一开始随机生成的权重对应的cost函数值,沿着下降方向,以不同的学习速率下降,直到最终找到cost函数最小时对应的W值为止。
      在这里插入图片描述
    • 注意点:需要进行标准化处理
    • 适用场景:面对训练数据规模十分庞大的任务
    • 代码示例(预测波士顿房价)
    from sklearn.datasets import load_boston
    from sklearn.linear_model import SGDRegressor
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def mysgd():
        """
        用SGDRegression方法预测波士顿房价
    
        :return: None
        """
    
        # 获取数据
        lb = load_boston()
    
        # 分割数据集
        x_train, x_test, y_train, y_test = train_test_split(lb.data,lb.target,test_size=0.25)
    
        # 标准化处理(注意特征值和目标值需要实例化两个API,因为维数不一样)
    
        std_x = StandardScaler()
        x_train = std_x.fit_transform(x_train)
        x_test = std_x.transform(x_test)
    
        std_y = StandardScaler()
        y_train = std_y.fit_transform(y_train.reshape(-1,1))
        y_test = std_y.transform(y_test.reshape(-1,1))
    
        # 用估计器预测房价结果
        sgd = SGDRegressor()
        sgd.fit(x_train,y_train)
        print(sgd.coef_)
    
        predict_std = sgd.predict(x_test)
        y_predict = std_y.inverse_transform(predict_std.reshape(-1,1))
        print("梯度回归方程预测房价结果:", y_predict)
        print("梯度回归方程预测军方误差:", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
    
        return None
    
    if __name__ == '__main__':
        mysgd()
    

    输出结果:

    [-0.09899378  0.05707105 -0.06552787  0.10473573 -0.10534929  0.36552032
     -0.02953529 -0.21774241  0.10686514 -0.05112742 -0.19883048  0.07593193
     -0.34252204]
    梯度回归方程预测房价结果: [[18.15533454]
     [34.11869678]
     [32.14174411]
     [21.34420274]
     [17.21388765]
     [16.35700059]
     [21.91035209]
     [25.74225411]
     [13.80938554]
     [37.0260741 ]
     [20.34283321]
     [22.60332358]
     [10.57004107]
     [20.23572153]
     [ 9.59137916]
     [28.41603421]
     [17.68100316]
     [21.23897539]
     [17.53442359]
     [13.19849714]
     [20.14575752]
     [33.52831795]
     [17.12473639]
     [21.36697523]
     [17.90262181]
     [ 4.09907073]
     [21.95366187]
     [33.80847587]
     [20.27105119]
     [17.53696132]
     [33.11813363]
     [28.80634195]
     [ 6.57209533]
     [25.48550927]
     [23.35904861]
     [35.9924995 ]
     [ 5.20083665]
     [20.03161132]
     [26.15215008]
     [36.99552849]
     [21.72707286]
     [36.55176266]
     [22.03371153]
     [23.26822998]
     [21.48258812]
     [19.91669232]
     [24.69897601]
     [41.31930121]
     [20.08257762]
     [13.07880876]
     [20.2117174 ]
     [23.51263223]
     [40.44256018]
     [33.56951898]
     [27.71772647]
     [24.50848523]
     [17.46991589]
     [21.44298149]
     [19.40351808]
     [-4.20320864]
     [24.41236848]
     [22.70770552]
     [18.32786776]
     [21.20199655]
     [29.35400254]
     [17.98159301]
     [23.30945554]
     [19.72799619]
     [17.12636849]
     [17.75898183]
     [23.46041889]
     [13.44739229]
     [22.7480483 ]
     [17.2265867 ]
     [26.99748033]
     [21.60716127]
     [14.71744082]
     [20.73697436]
     [32.00570023]
     [17.61311475]
     [20.89879453]
     [18.10165056]
     [24.57757874]
     [35.80571785]
     [23.92253462]
     [25.27805868]
     [40.2727596 ]
     [13.42459155]
     [19.19037907]
     [32.87888685]
     [ 6.42186031]
     [19.53277955]
     [ 8.98051468]
     [26.30031149]
     [20.90806747]
     [15.90596611]
     [16.28474562]
     [20.14033052]
     [30.55707971]
     [17.70373075]
     [15.45362061]
     [ 5.7067405 ]
     [21.30190112]
     [32.76682679]
     [38.25465606]
     [27.28654404]
     [15.74370192]
     [20.45658597]
     [28.26599518]
     [12.94885544]
     [35.28388653]
     [26.48460038]
     [21.49836632]
     [20.56639879]
     [28.386673  ]
     [32.78291138]
     [12.35907231]
     [ 9.89626638]
     [24.98827917]
     [29.76318234]
     [18.2809601 ]
     [21.24515354]
     [34.17683845]
     [29.44239205]
     [22.00955944]
     [22.65328658]
     [22.50688932]]
    梯度回归方程预测军方误差: 24.97920841695512
    

    正规方程和梯度下降的对比

    在这里插入图片描述
    注:正规方程适用于小规模场景,梯度方程适用于大规模场景

    • 不同算法使用场景截图(官网)
      在这里插入图片描述

    回归性能评估

    • 评估函数
      (均方误差(Mean Squared Error)MSE) 评价机制,具体公式如下:
      在这里插入图片描述
    • 评估代码实现
    1. API:sklearn.metrics.mean_squared_error
    2. 函数:mean_squared_error(y_true, y_pred)
      均方误差回归损失
      y_true:真实值
      y_pred:预测值
      return:浮点数结果
    3. 注意点:真实值,预测值为标准化之前的值

    过拟合和欠拟合

    过拟合和欠拟合所处区间示意图
    在这里插入图片描述

    过拟合

    一个假设在训练数据上能够获得比其他假设更好的拟合, 但是在训练数据外的数据集上却不能很好地拟合数据,此时认为这个假设出现了过拟合的现象。(模型过于复杂)

    欠拟合

    一个假设在训练数据上不能获得更好的拟合, 但是在训练数据外的数据集上也不能很好地拟合数据,此时认为这个假设出现了欠拟合的现象。(模型过于简单)

    解决方法
    • 欠拟合:
    1. 欠拟合形成原因:学习到数据的特征过少
    2. 欠拟合解决方法:增加数据的特征数量
    • 过拟合
    1. 过拟合形成原因:原始特征过多,存在一些嘈杂特征, 模型过于复杂是因为模型尝试去兼顾各个测试数据点
    2. 1) 进行特征选择,消除关联性大的特征(很难做);2)交叉验证,只能帮助判断是过拟合还是欠拟合,但不能从根本上解决这一问题(让所有数据都有过训练);3)正则化(了解)

    岭回归

    岭回归的概念

    针对线性回归中的过拟合问题,以正则化为解决方法,产生了“岭回归”这种回归算法。
    目的:尽量减小高次项特征的影响
    作用:可以使得W的每个元素都很小,都接近于0
    优点:回归得到的回归系数更符合实际,更可靠。另外,能让
    估计参数的波动范围变小,变的更稳定。在存在病态数据偏多的研究中有较大的实用价值。

    岭回归的代码实现

    1. API:sklearn.linear_model.Ridge
    2. 函数:klearn.linear_model.Ridge(alpha=1.0)
      具有l2正则化的线性最小二乘法
      alpha:正则化力度
      coef_:回归系数
    3. 正则化程度的变化对结果的影响在这里插入图片描述
    4. 代码示例(预测波士顿房价)1
    from sklearn.datasets import load_boston
    from sklearn.linear_model import Ridge
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_squared_error
    
    def mysgd():
        """
        用SGDRegression方法预测波士顿房价
    
        :return: None
        """
    
        # 获取数据
        lb = load_boston()
    
        # 分割数据集
        x_train, x_test, y_train, y_test = train_test_split(lb.data,lb.target,test_size=0.25)
    
        # 标准化处理(注意特征值和目标值需要实例化两个API,因为维数不一样)
    
        std_x = StandardScaler()
        x_train = std_x.fit_transform(x_train)
        x_test = std_x.transform(x_test)
    
        std_y = StandardScaler()
        y_train = std_y.fit_transform(y_train.reshape(-1,1))
        y_test = std_y.transform(y_test.reshape(-1,1))
    
        # 用估计器预测房价结果
        rd = Ridge()
        rd.fit(x_train,y_train)
        print(rd.coef_)
    
        predict_std = rd.predict(x_test)
        y_predict = std_y.inverse_transform(predict_std.reshape(-1,1))
        print("岭回归方程预测房价结果:", y_predict)
        print("岭回归方程预测军方误差:", mean_squared_error(std_y.inverse_transform(y_test),y_predict))
    
    
        return None
    
    if __name__ == '__main__':
        mysgd()
    

    输出结果:

    [[-0.09712775  0.10193582  0.04583568  0.09351994 -0.18624549  0.31246168
      -0.00936299 -0.30612679  0.31170519 -0.28632496 -0.18517174  0.13279692
      -0.40581663]]
    岭回归方程预测房价结果: [[37.00176928]
     [13.26132682]
     [23.54672912]
     [22.71654214]
     [25.67990408]
     [19.54523528]
     [20.67861965]
     [32.5417979 ]
     [22.99726104]
     [28.36399662]
     [40.68055885]
     [21.15905508]
     [16.67517075]
     [14.19302252]
     [17.38041852]
     [31.24705479]
     [13.50863022]
     [27.34963008]
     [41.25713632]
     [20.70165982]
     [23.24533533]
     [39.85987694]
     [32.83040663]
     [13.04899638]
     [14.0838789 ]
     [18.06380925]
     [19.6426615 ]
     [27.21555235]
     [17.67976907]
     [34.45092919]
     [26.22531561]
     [-0.33650528]
     [23.34381681]
     [33.72670693]
     [15.28809868]
     [23.24733193]
     [24.30973196]
     [18.18241414]
     [15.5708979 ]
     [16.64774211]
     [23.98182194]
     [40.942158  ]
     [26.93749796]
     [29.60798076]
     [22.77235029]
     [20.29534231]
     [28.39466337]
     [19.64746016]
     [ 2.4324661 ]
     [26.53607902]
     [21.28318569]
     [16.89454292]
     [13.02035884]
     [27.05552907]
     [18.76256831]
     [25.48453803]
     [22.98359125]
     [34.12163382]
     [-0.07566267]
     [27.22672687]
     [24.57249196]
     [31.35506797]
     [21.51520609]
     [18.1874919 ]
     [ 5.91854968]
     [28.8187358 ]
     [20.02153002]
     [22.97045159]
     [20.51448762]
     [23.01560955]
     [36.30354424]
     [26.7269793 ]
     [19.40240129]
     [25.22398079]
     [25.89558279]
     [25.43732688]
     [28.03109779]
     [19.60742959]
     [23.1766216 ]
     [33.27108218]
     [22.40006098]
     [23.6421197 ]
     [17.17184732]
     [10.82001448]
     [25.60073618]
     [16.22722067]
     [19.81550019]
     [11.61445192]
     [35.65601271]
     [15.29808558]
     [24.62870842]
     [24.89710764]
     [17.93088168]
     [23.31675652]
     [35.35558844]
     [13.24745034]
     [22.10891563]
     [22.51795098]
     [22.32261331]
     [30.19595212]
     [33.13758238]
     [39.13321668]
     [24.43840237]
     [22.96093311]
     [21.18458161]
     [30.30673668]
     [33.30111801]
     [19.22585514]
     [18.14130464]
     [14.90996596]
     [ 9.36230842]
     [15.03863595]
     [13.26064651]
     [23.26088159]
     [21.56648367]
     [22.11404782]
     [29.44668622]
     [25.73617186]
     [19.26855022]
     [17.1962654 ]
     [22.0283875 ]
     [36.84887348]
     [11.14088656]
     [26.13613835]
     [24.94894001]
     [23.38184477]
     [16.32009033]]
    岭回归方程预测军方误差: 27.751727283864966
    

    1. 比较不同回归算法的效果时,需要将训练集和测试集固定,本文中三种算法的训练集和测试集未固定,均为随机生成。 ↩︎

    展开全文
  • TensorFlow 梯度下降线性回归并可视化

    千次阅读 热门讨论 2017-11-13 21:06:57
    python手写模拟梯度下降以2元线性回归为例实现分类器: 线性回归函数:误差函数(损失函数):每次梯度下降参数的变化:使用TensorFlow框架import tensorflow as tf import numpy as np import matplotlib.pyplot ...


    python手写模拟梯度下降

    以2元线性回归为例实现分类器:

                

    线性回归函数:

    误差函数(损失函数):


    每次梯度下降参数的变化:






    使用TensorFlow框架

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    def add_layer(input, in_size, out_size, activation_function=None):
        Weight = tf.Variable(tf.random_normal([in_size, out_size]))
        biases = tf.Variable(tf.zeros([1, out_size]))
        y = tf.matmul(input, Weight) + biases
        if activation_function is None:
            return y
        else:
            return activation_function(y)
    
    
    X_data = np.linspace(-1, 1, 100, dtype=np.float32)[:, np.newaxis]
    noise = np.random.normal(0, 0.05, (X_data.shape[0], 1))
    # 使得产生的数据在x^2+0.5曲线上下
    y_data = np.square(X_data) + 0.5 + noise
    
    X = tf.placeholder(tf.float32, [None, 1])
    y = tf.placeholder(tf.float32, [None, 1])
    
    # 通过add_layer指定了该层框架,之后在迭代过程中不再调用函数
    # 输入层为1个神经元,隐藏层为10个神经元,输出层为1个神经元
    hidden_layer = add_layer(X, 1, 10, activation_function=tf.nn.relu)
    output_layer = add_layer(hidden_layer, 10, 1, activation_function=None)
    
    loss = tf.reduce_mean(tf.square(y - output_layer))
    trainer = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    
    fig, ax = plt.subplots(1, 1)
    ax.scatter(X_data, y_data)
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for _ in range(301):
            sess.run(trainer, feed_dict={X: X_data, y: y_data})
            if _ % 50 == 0:
                print(sess.run(loss, feed_dict={X: X_data, y: y_data}))
                curve = ax.plot(X_data, sess.run(output_layer, feed_dict={X: X_data, y: y_data}))
                plt.pause(0.5)  # 停留0.5s
                if _ != 300:
                    ax.lines.remove(curve[0])  # 抹除ax上的线,必须以列表下标的形式
    
    
    plt.show()


    线性回归,梯度下降算法可视化:

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    
    lr = 0.1
    real_params = [1.2, 2.5]   # 真正的参数
    
    
    tf_X = tf.placeholder(tf.float32, [None, 1])
    tf_y = tf.placeholder(tf.float32, [None, 1])
    weight = tf.Variable(initial_value=[[5]], dtype=tf.float32)
    bia = tf.Variable(initial_value=[[4]], dtype=tf.float32)
    y = tf.matmul(tf_X, weight) + bia
    
    loss = tf.losses.mean_squared_error(tf_y, y)
    train_op = tf.train.GradientDescentOptimizer(lr).minimize(loss)
    
    X_data = np.linspace(-1, 1, 200)[:, np.newaxis]
    noise = np.random.normal(0, 0.1, X_data.shape)
    y_data = X_data * real_params[0] + real_params[1] + noise
    
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    
    weights = []
    biases = []
    losses = []
    for step in range(400):
        w, b, cost, _ = sess.run([weight, bia, loss, train_op],
                                 feed_dict={tf_X: X_data, tf_y: y_data})
        weights.append(w)
        biases.append(b)
        losses.append(cost)
    result = sess.run(y, feed_dict={tf_X: X_data, tf_y: y_data})
    
    plt.figure(1)
    plt.scatter(X_data, y_data, color='r', alpha=0.5)
    plt.plot(X_data, result, lw=3)
    
    fig = plt.figure(2)
    ax_3d = Axes3D(fig)
    w_3d, b_3d = np.meshgrid(np.linspace(-2, 7, 30), np.linspace(-2, 7, 30))
    loss_3d = np.array(
        [np.mean(np.square((X_data * w_ + b_) - y_data))
         for w_, b_ in zip(w_3d.ravel(), b_3d.ravel())]).reshape(w_3d.shape)
    ax_3d.plot_surface(w_3d, b_3d, loss_3d, cmap=plt.get_cmap('rainbow'))
    weights = np.array(weights).ravel()
    biases = np.array(biases).ravel()
    
    # 描绘初始点
    ax_3d.scatter(weights[0], biases[0], losses[0], s=30, color='r')
    ax_3d.set_xlabel('w')
    ax_3d.set_ylabel('b')
    ax_3d.plot(weights, biases, losses, lw=3, c='r')
    plt.show()
    


    拟合线性函数:y=1.2 x + 2.5
    设初始的参数w=5,b=4,lr=0.1的拟合图像和梯度下降图像:



    更改学习速率lr=1.0的图像:

    展开全文
  • 代码托管在github https://github.com/sofiathefirst/matlabdemo/tree/master/02Linear_regressin_demo x=[-2:0.1:2]; y = 4*x; z=normrnd(0,0.6,1,41); y = y+z; w = -5; plot(x,y,'.') ......

    代码托管在github

    https://github.com/sofiathefirst/matlabdemo/tree/master/02Linear_regressin_demo

     

    x=[-2:0.1:2];
    y = 4*x;
    z=normrnd(0,0.6,1,41);
    y = y+z;

    w = -5;
    plot(x,y,'.')
    %hold on
    for i =[1:1000]
        d=w*x*x' - y*x';
        if(abs(d)<1)
            break;
        end
        w = w-0.004*d
        plot(x,y,'.',x,w*x)
        pause(0.1)
    end

     

     

     

    展开全文
  • python实现梯度下降线性回归 1.误差问题:fit_intercept 2.迭代率:eat0 3.最大迭代次数,迭代次数越多(过拟合),越少(欠拟合) 4.增量式机器学习 class SGDLinearRegression ( object ) : #构造...
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import SGDRegressor
    
    iris = load_iris().data
    #特征必须是二维的
    feature = iris[:,2].reshape(-1,1)
    #目标值可以是一维度
    labels = iris[:,-1]
    
    X_train,X_test,y_train,y_test = train_test_split(feature,labels,test_size=.3)
    
    #fit_intercept不考虑误差   eta0=0.01 学习率
    sgd = SGDRegressor(fit_intercept=False,eta0=0.01).fit(X_train,y_train)
    
    sgd.score(X_train,y_train)
    

    在这里插入图片描述

    sgd.coef_,sgd.intercept_
    

    在这里插入图片描述

    #获取x轴的最大值和最小值
    max_,min_ = feature.max()+1,feature.min()-1
    #线型图需要向量
    x = np.linspace(min_,max_,100)
    y = sgd.coef_ * x
    plt.plot(feature,labels,lw=0,marker='o')
    plt.plot(x,y)
    

    在这里插入图片描述

    python实现梯度下降线性回归

    • 1.误差问题:fit_intercept
    • 2.迭代率:eat0
    • 3.最大迭代次数,迭代次数越多(过拟合),越少(欠拟合)
    • 4.增量式机器学习
    class SGDLinearRegression(object):
        
        #构造函数
        def __init__(self,fit_intercept=True,eta0=0.01,max_iter=100):
            #全局属性
            self.fit_intercept = fit_intercept
            #迭代率
            self.eta0 =  eta0
            #最大迭代次数
            self.max_iter = max_iter
            
        #线性回归不是一个惰性学习
        def fit(self,X,y):
            #强制转换
            X = np.array(X)
            y = np.array(y)
            #获取特征和样本数量
            sample_sum,feature_nums = X.shape
            
            #将系数进行一个初始化的设定 ,一个有几个特征 那么 就有几个系数 矩阵(多行,1列)
            #初始化系数全部为0
            self.coef_ = np.zeros(shape=(feature_nums,1))
            #初始化误差为0  误差是一个常数项
            self.intercept_ = 0
            
            #添加一个数组,用于梯度下降的  残差 的记录
            self.save_loss_ = np.zeros(shape=self.max_iter)
            
            #梯度下降对比   真实目标值  和 预测目标值  残差
            for i in np.arange(self.max_iter):
                #预测的目标值
                h = np.add(np.dot(X,self.coef_),self.intercept_)
                
                #残差函数-->设置损失函数:  残差越大的话  系数和误差 向上增长的越快
                #传递了一个 特征数据   真实目标值  预测目标值  样本数量
                grad_w,grad_b,loss_ = self.loss(X,y,h,sample_sum)
                
                #粗调和精调
                self.coef_ -= self.eta0 * grad_w  
                
                if self.fit_intercept:
                    self.intercept_ -= self.eta0 * grad_b
                else:
                    self.intercept_ = 0
                    
                #将系数转换成一位维的
            self.coef_ = self.coef_.ravel()
            return self
        #OOP思想,一个函数一件事
        def loss(self,X,y,h,sample_sum):
            #系数是二维的  特征也是二维  y有可能是一维    X 10 4   coef_  4 1  = (10,1)
            if y.ndim < 2:
                y = y.reshape(-1,1)
                
            #残差平方和
            #每一条数据相减  得到残差 
            #计算的是平fang误差   n条的数据误差相加的平方  除以  样本的数量  开根号
            loss = np.sqrt(np.divide(np.sum(np.square(np.subtract(y,h))),sample_sum))
            
            #调解系数增长
            grad_w = X.T.dot(h-y) / sample_sum
            
            #误差也需要增长
            grad_b = .5 * np.sum(h-y) / sample_sum
            
            return grad_w,grad_b,loss
        
        def predict(self,X):
            X = np.array(X)
            #获取预测目标值
            return X.dot(self.coef_) + self.intercept_
    
    sgd_ = SGDLinearRegression(fit_intercept=False,eta0=0.01,max_iter=100).fit(X_train,y_train)
    
    sgd_.coef_,sgd_.intercept_
    

    在这里插入图片描述

    #获取x轴的最大值和最小值
    max_,min_ = feature.max()+1,feature.min()-1
    #线型图需要向量
    x = np.linspace(min_,max_,100)
    y = sgd_.coef_* x
    plt.plot(feature,labels,lw=0,marker='o')
    plt.plot(x,y)
    

    展开全文
  • 我试图在MatLab中实现一个函数,使用牛顿方法计算最佳线性回归.但是,我陷入了困境.我不知道如何找到二阶导数.所以我无法实现它.这是我的代码.谢谢你的帮助.function [costs,thetas] = mod_gd_linear_reg(x,y,numofit)...
  • 记录一下第一个Octave的代码。 传入的参数分别为自变量x,因变量(真实值)y,参数 ... %用来记录每次下降后的代价函数值 if(abs(m-j)), break; end j=m; t1=t1+1; end 收敛效果(代价函数J)如图:
  • 梯度下降算法线性回归数据
  • 线性回归随机梯度下降In this article, we will introduce about batch gradient and stochastic gradient descent method for solving the linear regression optimization problem. The linear regression problem...
  • 我正在学习机器学习/线性回归。下面是他们如何描述用于求解估计的OLS系数的梯度下降算法:因此,他们使用w作为系数,H用于设计矩阵(或他们所称的特性),而{}用于因变量。它们的收敛准则通常是RSS的梯度范数小于容限...
  • 一般对于连续的值进行预测,使用回归的方式。...梯度下降法是一种学习率(learning_rate)不变的回归方式,他每次迭代根据学习率不同对每个参数进行一定的更改以达到最贴近数据的参数。我们使用的c...
  • 线性回归 梯度下降线性回归
  • 梯度下降法及一元线性回归的python实现一、梯度下降法形象解释设想我们处在一座山的半山腰的位置,现在我们需要找到一条最快的下山路径,请问应该怎么走?根据生活经验,我们会用一种十分贪心的策略,即在现在所处的...
  • 梯度下降线性回归详解1. 一元线性回归1.1 一元线性回归1.2 梯度下降1.3波士顿房价预测1.3.1代码实现(Python)1.3.2 输出结果2. 多元线性回归2.1 鸢尾花数据集2.1.1代码实现(Python)2.1.2输出结果3. 三种数据集...
  • 梯度下降算法和线性回归算法(线性假设和平方差成本函数)比较如图: 对我们之前的线性回归问题运用梯度下降法,关键在于求出代价函数的导数,即: 则算法(批量梯度下降算法)改写成: ...
  • 0x00前言 在上一篇文章《手动实现梯度下降(可视化)》的多元线性回归中,使用梯度下降法求损失函数的最小值。在多元线性回归中,我们已经使用“标准方程解”求了损失函数最小值,那么如何使用梯度下降来计算最小值呢...
  • 梯度下降法的python代码实现(多元线性回归最小化损失函数)1、梯度下降法主要用来最小化损失函数,是一种比较常用的最优化方法,其具体包含了以下两种不同的方式:批量梯度下降法(沿着梯度变化最快的方向进行搜索...
  • 在机器学习中,有时候需要对原始的模型构造损失函数,然后通过优划算法对损失函数进行优划,从而找到最优的参数使损失函数达到...梯度下降的方式分为三种:批量梯度下降(Batch Gradient Descent),随机梯度下降(...
  • 今天主要是想和大家分享一下使用梯度下降解决线性回归问题,使用的框架是TensorFlow,开发环境在Linux ubuntu其中需要用到的Python库有numpy和matplotlib,大家对这两个库不清楚的可以直接Google 或者百度一下哈。...
  • 文章目录单变量线性回归(Linear Regression with One Variable)2.5 梯度下降2.6 梯度下降的直观理解2.7 梯度下降线性回归2.8 接下来的内容 单变量线性回归(Linear Regression with One Variable) 2.5 梯度下降 ...
  • 本课程是人工智能系列课程中的一部分课程。通过本系列课程希望大家能从零基础顺利的进入到人工智能领域当中来。 主要讲解: 线性回归 梯度下降 逻辑回归 通过实际案例来巩固知识点
  • 线性回归梯度下降 线性回归梯度下降 线性回归梯度下降 定义 利用回归方程对一个或者多个自变量(特征值)和因变量(目标)之间关系进行建模的一种分析方式 表示方法 h(w) = w1x1 + w2x2 + w3x3 + … b = W...
  • 我已经用python实现了线性回归算法,但结果并不理想。I python代码如下:import numpy as npx = [[1,1,1,1,1,1,1,1,1,1],[10,20,30,40,50,60,70,80,90,100]]y = [10,16,20,23,29,30,35,40,45,50]x = np.array(x)y = ...
  • 梯度下降线性回归

    2020-01-13 16:23:37
    文章目录梯度下降问题描述算法思路伪代码例子 梯度下降 梯度下降算法是为了解决连续解空间中极值。 梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向...
  • 线性回归属于监督学习,因此方法和监督学习应该是一样的,先给定一个训练集,根据这个训练集学习出一个线性函数,然后测试这个函数训练的好不好(即此函数是否足够拟合训练集数据),挑选出最好的函数(cost function...
  • 线性回归是由代价函数和梯度下降算法组成的,上一篇文章已经介绍过代价函数,这一篇我来介绍如何使用梯度下降算法来找到代价函数最小值。梯度下降的场景假设:梯度下降算法的基本思想可以类比为一个下山过程。一个人...
  • 1.线性回归 1.1 线性模型 试图学得一个通过属性的线性组合来进行预测的函数: 1.2 定义 定义:线性回归通过一个或者多个自变量与因变量之间进行建模的回归分析。其中特点为一个或多个称为回归系数的模型参数的线性...
  • 梯度下降法的python代码实现(多元线性回归最小化损失函数)1、梯度下降法主要用来最小化损失函数,是一种比较常用的最优化方法,其具体包含了以下两种不同的方式:批量梯度下降法(沿着梯度变化最快的方向进行搜索...
  • 梯度下降是机器学习里的一个重要的方法,用来寻找最优解在线性回归里, 梯度下降用于找出一条曲线里的最优切线,也就是求 y =m * X +b 里的M及bX是自变量,y是应变量。 m 是要计算的斜率,b 是 intercept,也就是截距...
  • 线性回归属于监督学习,因此方法和监督学习应该是一样的,先给定一个训练集,根据这个训练集学习出一个线性函数,然后测试这个函数训练的好不好(即此函数是否足够拟合训练集数据),挑选出最好的函数(cost function...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,199
精华内容 2,479
关键字:

梯度下降线性回归