精华内容
下载资源
问答
  • 有监督学习--简单线性回归模型(梯度下降法代码实现)0.引入依赖1.导入数据(data.csv)2.定义损失函数3.定义模型的超参数4.定义核心梯度下降模型函数5.测试:运行梯度下降算法,计算最优的 w 和 b6.画出拟合曲线7....

    有监督学习--简单线性回归模型(梯度下降法代码实现)0.引入依赖1.导入数据(data.csv)2.定义损失函数3.定义模型的超参数4.定义核心梯度下降模型函数5.测试:运行梯度下降算法,计算最优的 w 和 b6.画出拟合曲线7.附录-测试数据


    有监督学习--简单线性回归模型(梯度下降法代码实现)

    0.引入依赖

    import numpy as np
    import matplotlib.pyplot as plt

    1.导入数据(data.csv)

    points = np.genfromtxt('data.csv', delimiter=',')

    # points
    # 提取 points 中的两对数据,分别作为 x, y
    # points[0][0]  等价于
    # points[0,0]  # 第一行第一列数据
    # points[0,0:1] # array([32.50234527])
    # points[0,0:2] # 第一行数据 array([32.50234527, 31.70700585])
    # points[0,0:] # 第一行数据 array([32.50234527, 31.70700585])
    x = points[:,0# 第一列数据
    y = points[:,1# 第二列数据

    # 用 scatter 画出散点图
    plt.scatter(x, y)
    plt.show()

    作图如下:

    2.定义损失函数

    # 损失函数是模型系数的函数,还需要传入数据的 x,y
    def compute_cost(w, b, points):
        total_cost = 0
        M = len(points)
        # 逐点计算【实际数据 yi 与 模型数据 f(xi) 的差值】的平方,然后求平均
        for i in range(M):
            x = points[i, 0]
            y = points[i, 1]
            total_cost += (y - w * x - b) ** 2

        return total_cost / M

    3.定义模型的超参数

    alpha = 0.0001
    initial_w = 0
    initial_b = 0
    num_iter = 10

    4.定义核心梯度下降模型函数

    def grad_desc(points, initial_w, initial_b, alpha, num_iter):
        w = initial_w
        b = initial_b
        # 定义一个list保存所有的损失函数值,用来显示下降的过程
        cost_list = []

        for i in range(num_iter):
            # 先计算初始值的损失函数的值
            cost_list.append(compute_cost(w, b, points))
            w, b = step_grad_desc(w, b, alpha, points)

        return [w, b, cost_list]

    def step_grad_desc(current_w, current_b, alpha, points):
        sum_grad_w = 0
        sum_grad_b = 0
        M = len(points)

        # 对每一个点带入公式求和
        for i in range(M):
            x = points[i, 0]
            y = points[i, 1]
            sum_grad_w += (current_w * x + current_b - y) * x
            sum_grad_b += (current_w * x + current_b - y)

        # 用公式求当前梯度
        grad_w = 2 / M * sum_grad_w
        grad_b = 2 / M * sum_grad_b

        # 梯度下降,更新当前的 w 和 b
        updated_w = current_w - alpha * grad_w
        updated_b = current_b - alpha * grad_b

        return updated_w, updated_b

    5.测试:运行梯度下降算法,计算最优的 w 和 b

    w, b, cost_list = grad_desc(points, initial_w, initial_b, alpha, num_iter)

    print('w is:', w)
    print('b is:', b)


    cost = compute_cost(w, b, points)
    print('cost is:', cost)

    plt.plot(cost_list)
    plt.show()

    输出结果如下:

    is1.4774173755483797
    is0.02963934787473238
    cost is112.65585181499748

    作图如下:

    6.画出拟合曲线

    # 先用 scatter 画出2维散点图
    plt.scatter(x, y)

    # 针对每一个x,计算出预测的值
    pred_y = w * x + b
    # 再用 plot 画出2维直线图
    plt.plot(x, pred_y, c='r')
    plt.show()

    作图如下:

    7.附录-测试数据

    测试数据 data.csv 如下:

    32.502345269453031,31.70700584656992
    53.426804033275019,68.77759598163891
    61.530358025636438,62.562382297945803
    47.475639634786098,71.546632233567777
    59.813207869512318,87.230925133687393
    55.142188413943821,78.211518270799232
    52.211796692214001,79.64197304980874
    39.299566694317065,59.171489321869508
    48.10504169176825,75.331242297063056
    52.550014442733818,71.300879886850353
    45.419730144973755,55.165677145959123
    54.351634881228918,82.478846757497919
    44.164049496773352,62.008923245725825
    58.16847071685779,75.392870425994957
    56.727208057096611,81.43619215887864
    48.955888566093719,60.723602440673965
    44.687196231480904,82.892503731453715
    60.297326851333466,97.379896862166078
    45.618643772955828,48.847153317355072
    38.816817537445637,56.877213186268506
    66.189816606752601,83.878564664602763
    65.41605174513407,118.59121730252249
    47.48120860786787,57.251819462268969
    41.57564261748702,51.391744079832307
    51.84518690563943,75.380651665312357
    59.370822011089523,74.765564032151374
    57.31000343834809,95.455052922574737
    63.615561251453308,95.229366017555307
    46.737619407976972,79.052406169565586
    50.556760148547767,83.432071421323712
    52.223996085553047,63.358790317497878
    35.567830047746632,41.412885303700563
    42.436476944055642,76.617341280074044
    58.16454011019286,96.769566426108199
    57.504447615341789,74.084130116602523
    45.440530725319981,66.588144414228594
    61.89622268029126,77.768482417793024
    33.093831736163963,50.719588912312084
    36.436009511386871,62.124570818071781
    37.675654860850742,60.810246649902211
    44.555608383275356,52.682983366387781
    43.318282631865721,58.569824717692867
    50.073145632289034,82.905981485070512
    43.870612645218372,61.424709804339123
    62.997480747553091,115.24415280079529
    32.669043763467187,45.570588823376085
    40.166899008703702,54.084054796223612
    53.575077531673656,87.994452758110413
    33.864214971778239,52.725494375900425
    64.707138666121296,93.576118692658241
    38.119824026822805,80.166275447370964
    44.502538064645101,65.101711570560326
    40.599538384552318,65.562301260400375
    41.720676356341293,65.280886920822823
    51.088634678336796,73.434641546324301
    55.078095904923202,71.13972785861894
    41.377726534895203,79.102829683549857
    62.494697427269791,86.520538440347153
    49.203887540826003,84.742697807826218
    41.102685187349664,59.358850248624933
    41.182016105169822,61.684037524833627
    50.186389494880601,69.847604158249183
    52.378446219236217,86.098291205774103
    50.135485486286122,59.108839267699643
    33.644706006191782,69.89968164362763
    39.557901222906828,44.862490711164398
    56.130388816875467,85.498067778840223
    57.362052133238237,95.536686846467219
    60.269214393997906,70.251934419771587
    35.678093889410732,52.721734964774988
    31.588116998132829,50.392670135079896
    53.66093226167304,63.642398775657753
    46.682228649471917,72.247251068662365
    43.107820219102464,57.812512976181402
    70.34607561504933,104.25710158543822
    44.492855880854073,86.642020318822006
    57.50453330326841,91.486778000110135
    36.930076609191808,55.231660886212836
    55.805733357942742,79.550436678507609
    38.954769073377065,44.847124242467601
    56.901214702247074,80.207523139682763
    56.868900661384046,83.14274979204346
    34.33312470421609,55.723489260543914
    59.04974121466681,77.634182511677864
    57.788223993230673,99.051414841748269
    54.282328705967409,79.120646274680027
    51.088719898979143,69.588897851118475
    50.282836348230731,69.510503311494389
    44.211741752090113,73.687564318317285
    38.005488008060688,61.366904537240131
    32.940479942618296,67.170655768995118
    53.691639571070056,85.668203145001542
    68.76573426962166,114.85387123391394
    46.230966498310252,90.123572069967423
    68.319360818255362,97.919821035242848
    50.030174340312143,81.536990783015028
    49.239765342753763,72.111832469615663
    50.039575939875988,85.232007342325673
    48.149858891028863,66.224957888054632
    25.128484647772304,53.454394214850524

    转载于:https://www.cnblogs.com/chenmingjun/p/10884542.html

    展开全文
  • 批量梯度下降: 随机梯度下降:        学习率不能太大。 当学习率增大的时候,迭代次数也需要同倍的变化。 #!/usr/bin/python # -*- coding: UTF-8 -*- # 文件名: batch_gradient_descent.py ...

    批量梯度下降:

    随机梯度下降:

     

     

     

     学习率不能太大。

    当学习率增大的时候,迭代次数也需要同倍的变化。

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # 文件名: batch_gradient_descent.py
    
    import numpy as np
    
    __author__ = 'yasaka'
    
    X = 2 * np.random.rand(100, 1)
    y = 4 + 3 * X + np.random.randn(100, 1)
    X_b = np.c_[np.ones((100, 1)), X]
    # print(X_b)
    
    learning_rate = 0.01
    n_iterations = 100000
    m = 100
    
    # 1,初始化theta,w0...wn
    theta = np.random.randn(2, 1)
    
    # 4,不会设置阈值,直接设置超参数,迭代次数,迭代次数到了,我们就认为收敛了
    for iteration in range(n_iterations):
        # 2,接着求梯度gradient
        gradients = X_b.T.dot(X_b.dot(theta)-y)
        # 3,应用公式调整theta值,theta_t + 1 = theta_t - grad * learning_rate
        theta = theta - learning_rate * gradients
    
    print(theta)

     

    展开全文
  • 前言梯度下降法是深度学习领域用于最优化的常见方法,根据使用的batch大小,可分为随机梯度下降法(SGD)和批量梯度下降法(BGD)和小批量梯度下降法(MBGD),这里简单介绍下并且提供Python代码演示。 如有谬误,...

    前言

    梯度下降法是深度学习领域用于最优化的常见方法,根据使用的batch大小,可分为随机梯度下降法(SGD)和批量梯度下降法(BGD)和小批量梯度下降法(MBGD),这里简单介绍下并且提供Python代码演示。
    如有谬误,请联系指正。转载请注明出处。
    联系方式:
    e-mail: FesianXu@163.com
    QQ: 973926198
    github: https://github.com/FesianXu
    代码开源:click

    梯度下降法

    其基本思想就是使得网络的各个参数朝着优化函数的梯度的反方向更新,因为梯度的方向是增长最速方向,所以梯度的反方向就是减少的最速方向,因此只要设定一个步进η\etaη,然后朝着梯度的反方向下降减小即可将优化函数最小化。公式表达如:
    wijl:=wijl−η∂C∂wijl w^l_{ij} := w^l_{ij}-\eta \frac{\partial{C}}{\partial{w^l_{ij}}} wijl:=wijlηwijlC

    以下讨论都假设使用的损失函数是MSE损失函数,模型为线性回归模型。
    L=12m∑i=1m(y−h(x(i)))2,m是样本总数 L = \frac{1}{2m} \sum_{i=1}^m (y-h(x^{(i)}))^2,m是样本总数 L=2m1i=1m(yh(x(i)))2m
    h(xi)=θTx(i)+b,其中x(i)为第i个样本,x(i)∈Rn h(x_i) = \theta^Tx^{(i)}+b,其中x^{(i)}为第i个样本,x^{(i)} \in R^n h(xi)=θTx(i)+bx(i)ix(i)Rn

    批量梯度下降法(BGD)

    批量梯度下降法(Batch Gradient Descent, BGD)是梯度下降法的最原始的形式,其特点就是每一次训练迭代都需要利用所有的训练样本,其表达式为:
    ∂L∂θj=−1m∑i=1m[(y−h(x(i)))xj(i)],xj(i)是第i个样本的第j个输入分量 \frac{\partial{L}}{\partial{\theta_j}} = -\frac{1}{m}\sum_{i=1}^m [(y-h(x^{(i)}))x^{(i)}_j],x^{(i)}_j是第i个样本的第j个输入分量 θjL=m1i=1m[(yh(x(i)))xj(i)]xj(i)ij
    θj:=θj+η1m∑i=1m[(y−h(x(i)))xj(i)] \theta_j := \theta_j+\eta \frac{1}{m}\sum_{i=1}^m [(y-h(x^{(i)}))x^{(i)}_j] θj:=θj+ηm1i=1m[(yh(x(i)))xj(i)]
      可以发现,对于每一个参数的更新都需要利用到所有的m个样本,这样会导致训练速度随着训练样本的增大产生极大地减慢,不适合于大规模训练样本的场景,但是,其解是全局最优解,精度高。

    随机梯度下降法(SGD)

    随机梯度下降法(Stochastic Gradient Descent, SGD)是梯度下降法的改进形式之一,其特点就是每一次训练迭代只需要训练样本集中的一个样本,其表达式为:
    ∂L∂θj=−(y−h(x))xj,xj是选定样本的第j个输入分量 \frac{\partial{L}}{\partial{\theta_j}} = -(y-h(x))x_j, x_j是选定样本的第j个输入分量 θjL=(yh(x))xjxjj
    θj:=θj+η(y−h(x))xj \theta_j := \theta_j+\eta (y-h(x))x_j θj:=θj+η(yh(x))xj
      和BGD进行对比可以发现,其参数更新过程中,只需要选取训练集中的一个训练样本,因此训练速度快,但是因为其只是利用了训练集的一部分知识,因此其解为局部最优解,精度较低。

    小批量梯度下降法(MBGD)

    小批量梯度下降法(Mini-Batch Gradient Descent, MBGD)是结合了SGD和BGD的一种改进版本,既有训练速度快,也有精度较高的特点,其基本特点就是每一次训练迭代在训练集中随机采样batch_size个样本,其表达式为:
    ∂L∂θj=−1M∑i=1M[(y−h(x(i)))xj(i)],其中M为batch_size \frac{\partial{L}}{\partial{\theta_j}} = -\frac{1}{M}\sum_{i=1}^M [(y-h(x^{(i)}))x^{(i)}_j],其中M为batch\_size θjL=M1i=1M[(yh(x(i)))xj(i)]Mbatch_size
    θj:=θj+η1M∑i=1M[(y−h(x(i)))xj(i)] \theta_j := \theta_j+\eta \frac{1}{M}\sum_{i=1}^M [(y-h(x^{(i)}))x^{(i)}_j] θj:=θj+ηM1i=1M[(yh(x(i)))xj(i)]
      这个改进版本在深度学习的网络训练中有着广泛地应用,因为其既有较高的精度,也有较快的训练速度。

    代码实现

    这里以线性回归模型作为演示,实现梯度下降。代码实现基于python和numpy,matplotlib绘图,matlab生成数据集。代码由github托管。

    数据描述

    目标直线为y=2.5x+3.5y=2.5x+3.5y=2.5x+3.5,加上了一个高斯噪声,代码如:

    x = -20:0.01:20;
    line = 2.5*x+3.5;
    x_rand = randn(1, length(line))*10;
    line = line+x_rand;
    x = x';
    line = line';
    samples = [x, line];
    

    图像如:
    dataset
    主要代码如:

    import numpy as np
    import scipy.io as sio
    import random
    import matplotlib.pyplot as plt
    
    path = u'./samples.mat'
    mat = sio.loadmat(path)
    dataset = mat['samples']
    batch_size = 1
    
    def random_get_samples(mat, batch_size):
        batch_id = random.sample(range(mat.shape[0]), batch_size)
        ret_batch = mat[batch_id, 0]
        ret_line = mat[batch_id, 1]
        return ret_batch, ret_line
    
    
    params = {
        'w1': np.random.normal(size=(1)),
        'b': np.random.normal(size=(1))
    }
    
    def predict(x):
        return params['w1']*x+params['b']
    
    learning_rate = 0.001
    for i in range(3000):
        batch, line = random_get_samples(dataset, batch_size)
        y_pred = predict(batch)
        y_pred = np.reshape(y_pred, (batch_size, 1))
        line = np.reshape(line, (batch_size, 1))
        batch = np.reshape(batch, (batch_size, 1))
        delta = line-y_pred
        params['w1'] = params['w1']+learning_rate*np.sum(delta*batch)/batch_size
        params['b'] = params['b']+learning_rate*np.sum(delta)/batch_size
        if i % 100 == 0:
            print(np.sum(np.abs(line-y_pred))/batch_size)
    
    print(params['w1'])
    print(params['b'])
    x = dataset[:, 0]
    line = dataset[:, 1]
    y = params['w1']*x+params['b']
    plt.figure(1)
    plt.plot(x, line, 'b--')
    plt.plot(x, y, 'r--')
    plt.show()
    

    其中调整batch_size可以分别实现SGD,BGD和MBGD,当其为1时为SGD,当其为dataset.shape[0]时为BGD,当其为其他固定常数时如128,为MBGD。通过实验可以明显发现,当batch_size为1时,训练速度最快,但是精度欠佳,当batch_size=dataset.shape[0]时,训练速度最慢,但是精度较高,当batch_size=128或其他常数时,速度和精度兼有顾及。最后的结果图像如:
    regression
    可见红线成功拟合了原数据。

    展开全文
  • 梯度下降法代码python实现 -有数据有图有真相 今天我们做了一个实验,通过生成多元回归数据进行梯度下降求解权重 生成一份线性数据 y=w1∗x1=w2∗x2+w3∗x3+by=w_1*x_1=w_2*x_2+w_3*x_3+by=w1​∗x1​=w2​∗x2​+...

    梯度下降法代码python实现 -有数据有图有真相

    今天我们做了一个实验,通过生成多元回归数据进行梯度下降求解权重

    1. 生成一份线性数据 y=w1x1=w2x2+w3x3+by=w_1*x_1=w_2*x_2+w_3*x_3+b
      代码测试为 y=5x1=w27+4x3+8y=5*x_1=w_2*7+4*x_3+8

    2. 为线性数据增加噪声值 y=y+np.random.randn()*1+8

    3. 之后通过梯度下降算法进行迭代,迭代次数5000轮

    4. 绘制误差和权重迭代曲线

    下面代码对于学习而言是个非常好的例子,如有疑问,可以在博客留言询问

    
    import numpy as np
    import os
    
    import matplotlib.pyplot  as plt
    w=np.array([5,7,4])
    
    
    sample=np.random.randint(0,10,(100,3))
    
    
    y=np.dot(sample,w)
    
    #print(sample)
    #print(y)
    
    y=y+np.random.randn()*1+8
    print(y)
    
    w_zz=np.array([1,1,1,1])
    
    learn_rating=0.0001
    p=0
    w=[[1],[1],[1],[1]]
    
    loss=[]
    for i in range(5000):
         d=0
         p=0
         loss_sum=np.array([])
         for x in  sample:
            sample_convert=np.append(x,1)
          #  print(sample_convert)
           # print(np.dot(sample_convert,w_zz)-y[p])
            loss_sum=np.append(loss_sum,(np.dot(sample_convert,w_zz)-y[p])**2)
            d=d+learn_rating*sample_convert*(np.dot(sample_convert,w_zz)-y[p])
            p=p+1
           # print(w_zz)
         w_zz=w_zz-d
         loss.append(loss_sum.mean())
         print(loss_sum.mean())
         for i in range(4):
                w[i].append(w_zz[i])
        
    print(w_zz)
        
    #print(w)
    
    plt.plot(w[0])
    plt.plot(w[1])
    plt.plot(w[2])
    plt.plot(w[3])
    plt.legend(["w1","w2","w3","w4"])
    plt.show()
    plt.plot(loss[500:])
    plt.show()
    os.system("pause")
    
    

    截图过下图所示
    在这里插入图片描述

    误差曲线图
    在这里插入图片描述

    权重迭代曲线图:
    在这里插入图片描述

    数据我已经上传到我的资源,可以免费下载,文件名为BP神经网络

    展开全文
  • 梯度下降法的python代码实现(多元线性回归最小化损失函数)1、梯度下降法主要用来最小化损失函数,是一种比较常用的最优化方法,其具体包含了以下两种不同的方式:批量梯度下降法(沿着梯度变化最快的方向进行搜索...
  • 通过学习斯坦福公开课的线性规划和梯度下降,参考他人代码自己做了测试,写了个类以后有时间再去扩展,代码注释以后再加,作业好多:import numpy as npimport matplotlib.pyplot as pltimport randomclass ...
  • 主要介绍了Python编程实现线性回归和批量梯度下降法代码实例,具有一定借鉴价值,需要的朋友可以参考下
  • 通过学习斯坦福公开课的线性规划和梯度下降,参考他人代码自己做了测试,写了个类以后有时间再去扩展,代码注释以后再加,作业好多:import numpy as npimport matplotlib.pyplot as pltimport randomclass ...
  • 梯度下降法(Gradient descent)是一个一阶最优化算法,通常也称为最速下降法。 要使用梯度下降法找到一个函数的局部极小值,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索。如果...
  • 在学习线性回归的时候很多课程都会讲到用梯度下降法求解参数,对于梯度下降算法怎么求出这个解讲的较少,自己实现一遍算法比较有助于理解算法,也能注意到比较细节的东西。具体的数学推导可以参照这一篇博客...
  • 梯度下降: 分治—可能会错过更好的取值。如果数据集或者维度大,代价也大。
  • 梯度下降法的概念原理和公式这里就不介绍了,搜一下就能搜到很多博主写的很好的,简单写了一下梯度下降法Python代码,也包括numpy简单的向量运算。...单变量梯度下降法代码实现: 多变量梯度下降法程序实现: ...
  • 基于python的梯度下降法实现 代码: def _numerical_gradient_no_batch(f, x): h = 1e-4 # 0.0001 grad = np.zeros_like(x) for idx in range(x.size): tmp_val = x[idx] x[idx] = float(tmp_val)...
  • 梯度下降法的python代码实现(多元线性回归最小化损失函数)1、梯度下降法主要用来最小化损失函数,是一种比较常用的最优化方法,其具体包含了以下两种不同的方式:批量梯度下降法(沿着梯度变化最快的方向进行搜索...
  • 梯度下降法原理 使用二次函数简单实现和验证梯度下降 画出梯度下降的过程 学习率对梯度下降快慢的影响 在线性回归模型中使用梯度下降法 Conclusion(总结) 摘要 使用代码实现和验证梯度下降算法 梯度下降法...
  • 前面通过梯度下降寻找二次函数的最小值,下面将用代码实现梯度下降法完成一个拟合问题。 1. 梯度下降代码实现 先随机构造一些散点,再用一条直线来拟合这些散点 import random import matplotlib.pyplot as plt #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 576
精华内容 230
关键字:

梯度下降法代码实现