精华内容
下载资源
问答
  • 逻辑回归的梯度下降算法python实现 前言: 逻辑回归是解决分类问题的一种的方法,关于逻辑回归的具体理论知识请至我的博文中查看 一、逻辑回归python实现示例代码 import matplotlib.pyplot as plt import numpy as ...

    线性逻辑回归的梯度下降算法python实现

    前言: 逻辑回归是解决分类问题的一种的方法,关于逻辑回归的具体理论知识请至我的博文中查看

    一、逻辑回归python实现示例代码

    import matplotlib.pyplot as plt
    import numpy as np
    from sklearn.metrics import classification_report
    from sklearn import preprocessing
    
    # 数据是否需要标准化
    scale = False
    # 读取数据
    data = np.genfromtxt('LR-testSet.csv', delimiter=',')
    x_data = data[:, 0:-1]
    y_data = data[:, -1, np.newaxis]
    
    # 绘制各类别的数据散点图
    def plotClass():
        x0 = []
        y0 = []
        x1 = []
        y1 = []
        for i in range(len(x_data)):
            if y_data[i] == 0:
                x0.append(x_data[i, 0])
                y0.append(x_data[i, 1])
            else:
                x1.append(x_data[i, 0])
                y1.append(x_data[i, 1])
    
        # 绘图
        s1 = plt.scatter(x0, y0, c='b', marker='o')
        s2 = plt.scatter(x1, y1, c='r', marker='x')
        plt.legend(handles=[s1, s2], labels=['class0', 'class1'])
    
    
    # 给样本添加偏置值项
    X_data = np.concatenate((np.ones((100, 1)), x_data), axis=1)
    
    
    # 定义逻辑回归的模型函数(S型函数)
    def sigmoid(x):
        return 1 / (1 + np.exp(-x))
    
    
    # 计算代价值
    def cost(xMat, yMat, ws):
        left = np.multiply(yMat, np.log(sigmoid(xMat * ws)))
        right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat * ws)))
        return np.sum(left + right) / -len(xMat)
    
    
    # 梯度下降算法
    def gradAscent(xArr, yArr):
        if scale:
            xArr = preprocessing.scale(xArr)
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
    
        # 学习率
        lr = 0.001
        # 梯度下降迭代次数
        ite = 10000
        # 记录梯度下降过程中的代价值
        costList = []
        # 计算数据行列数
        m, n = np.shape(xMat)
        # 初始化线性函数权重
        ws = np.mat(np.ones((n, 1)))
        for i in range(ite + 1):
            h = sigmoid(xMat * ws)
            ws_grad = xMat.T * (h - yMat) / m
            ws = ws - lr * ws_grad
            if i % 50 == 0:
                costList.append(cost(xMat, yMat, ws))
        return ws, costList
    ws, costList = gradAscent(X_data, y_data)
    # 画决策边界
    if not scale:
        plotClass()
        x_test = [[-4], [3]]
        y_test = (-ws[0] - x_test * ws[1]) / ws[2]
        plt.plot(x_test, y_test, 'k')
    
    # 绘制代价值的变化
    plt.figure()
    x = np.linspace(0, 10000, 201)
    plt.plot(x, costList, c='r')
    plt.title('Train')
    plt.xlabel('iteration')
    plt.ylabel('cost')
    
    # 根据训练的模型进行预测类型
    def predict(x_data, ws):
        if scale:
            x_data = preprocessing.scale(x_data)
        xMat = np.mat(x_data)
        ws = np.mat(ws)
        return [1 if x >= 0.5 else 0 for x in sigmoid(xMat * ws)]
    
    predictions = predict(X_data, ws)
    # 计算准确率,召回率,F1值
    print(classification_report(y_data, predictions))
    plt.show()
    
    

    二、执行结果

                  precision    recall  f1-score   support
    
             0.0       0.82      1.00      0.90        47
             1.0       1.00      0.81      0.90        53
    
       micro avg       0.90      0.90      0.90       100
       macro avg       0.91      0.91      0.90       100
    weighted avg       0.92      0.90      0.90       100
    

    在这里插入图片描述
    三、数据下载
    链接:https://pan.baidu.com/s/1cOxjGUyVbf3qDtPFPJKqwA
    提取码:1mlo

    展开全文
  • 包括里面拟合的函数,以及求梯度的方法,还有构造的数据直接用的人家的。但是看他的代码有问题迭代的时候虽然最后c参数的梯度为0,但是不代表就不对他进行求解了。再加上他的图我没怎么看懂含义,所以自己改了改代码...

    不能算原创,因为我参考的是别人的博客。包括里面拟合的函数,以及求梯度的方法,还有构造的数据直接用的人家的。但是看他的代码有问题迭代的时候虽然最后c参数的梯度为0,但是不代表就不对他进行求解了。再加上他的图我没怎么看懂含义,所以自己改了改代码,重新画了画错误率的图。

    #coding:utf-8
    import numpy as np
    import matplotlib.pyplot as plt
    #y=2 * (x1) + (x2) + 3
    rate = 0.001
    threshold=1e-15 #停止阈值
    x_train = np.array([    [1, 2],    [2, 1],    [2, 3],    [3, 5],    [1, 3],    [4, 2],    [7, 3],    [4, 5],    [11, 3],    [8, 7]    ])
    y_train = np.array([7, 8, 10, 14, 8, 13, 20, 16, 28, 26])
    x_test  = np.array([    [1, 4],    [2, 2],    [2, 5],    [5, 3],    [1, 5],    [4, 1]    ])
    
    err_avg=[]
    a = np.random.normal()
    b = np.random.normal()
    c = np.random.normal()
    
    def h(x):
        return a*x[0]+b*x[1]+c
    
    for i in range(10000):#最多迭代10000次
        sum_a=0
        sum_b=0
        sum_c=0
        flag=0
        for x, y in zip(x_train, y_train):
            for xi in x:
                sum_a = sum_a + rate * (y - h(x)) * x[0]
                sum_b = sum_b + rate * (y - h(x)) * x[1]
                sum_c = sum_c + rate * (y - h(x))
        a1 = a + sum_a
        b1 = b + sum_b
        c1 = c + sum_c
        if abs(a-a1)<=threshold and abs(b-b1)<=threshold and abs(c-c1)<=threshold  :
            print ("迭代的总次数"+str(i))
            break
        else:
            a = a1
            b = b1
            c = c1
            #plt.plot([yi-h(xi) for xi,yi in zip(x_train,y_train)])
            err = 0
            for xi,yi in zip(x_train,y_train):
                err += yi-h(xi)
            err_avg.append(err/float(len(x_train))) #每次迭代的平均错误率
    
    print(a)
    print(b)
    print(c)
    
    plt.plot(err_avg)
    for i in range(0,len(err_avg)):
        plt.scatter(i,err_avg[i], c='r')
    
    result=[h(xi) for xi in x_train]
    print(result)
    
    result=[h(xi) for xi in x_test]
    print(result)
    
    plt.show()
    运行结果如下:

    迭代的总次数8319
    2.0
    1.0
    3.0
    [6.9999999999998153, 7.9999999999997655, 9.9999999999998916, 14.000000000000032, 7.9999999999998792, 12.999999999999854, 19.999999999999954, 16.000000000000043, 28.000000000000004, 26.00000000000022]
    [8.9999999999999432, 8.9999999999998277, 12.00000000000002, 15.999999999999929, 10.000000000000007, 11.99999999999979]



    因为为了等会儿放大好看所以画了散点图,放大看:


    可以看到大概在150次过后其实就算的差不多了。

    如果代码还有问题,请看到的各位指正!


    展开全文
  • 10.999999999974364
  • 在机器学习中,我们在求最小值时使用梯度下降法,求最大值时使用梯度上升法. 为了尽快的得到最小值或者最大值,我们尽量让每一步运算的变化率都足够大,因此,在每一次运算时,我们要使函数变化的方向与梯度相同或相反,即...
  • 《深度学习的数学》 梯度下降法 Excel版 《深度学习的数学》 梯度下降法 ...#《深度学习的数学》 梯度下降法 python实现 def gradient_descent(init_x,init_y,lr): x = symbols("x") y = symbols("y") z = pow...

    《深度学习的数学》 梯度下降法 Excel版

    在这里插入图片描述

    《深度学习的数学》 梯度下降法 python版

    from sympy import *
    import time
    
    #《深度学习的数学》 梯度下降法 python实现
    def gradient_descent(init_x,init_y,lr):
        x = symbols("x")
        y = symbols("y")
        z = pow(x,2) + pow(y,2) #定义表达式 z = x^2 + y^2
        dif_x = diff(z,x) #自变量x导数
        dif_y = diff(z,y) #自变量y导数
    
        offset_x = 0
        offset_y = 0
        #梯度下降30次
        for no in range(30):
            x_val = init_x
            y_val = init_y
            dif_x_val = dif_x.subs("x",init_x)
            dif_y_val = dif_y.subs("y",init_y)
            offset_x = -lr * dif_x_val #位移向量x
            offset_y = -lr * dif_y_val #位移向量y
            init_x = init_x + offset_x
            init_y = init_y + offset_y
            z_val = round(z.evalf(subs={x:x_val,y:y_val}),2)
            print("No:",no,"x值:",round(init_x,2),"y值:",round(init_y,2),
                  "x梯度:",round(dif_x_val,2),"y梯度:",round(dif_y_val,2),
                  "x位移向量:",round(offset_x,2),"y位移向量:",round(offset_y,2),
                  "函数值:",z_val)
            time.sleep(0.1)
    
    x = 3
    y = 2
    lr = 0.1
    gradient_descent(x,y,lr)
    

    运行结果:

    在这里插入图片描述

    展开全文
  • 非线性逻辑回归的梯度下降算法python实现以及决策边界的绘制 前言: 对于逻辑回归的决策边界有很多并不是线性的而是非线性的,那么这样我就需要训练非线性的逻辑回归,如何训练非线性的逻辑回归呢?仍然利用sklearn...

    非线性逻辑回归的梯度下降算法python实现以及决策边界的绘制

    前言: 对于逻辑回归的决策边界有很多并不是线性的而是非线性的,那么这样我就需要训练非线性的逻辑回归,如何训练非线性的逻辑回归呢?仍然利用sklearn的特征转换思路,将非线性问题转为线性问题进行解决,具体思路参考我这篇博文,关乎逻辑回归的理论知识 参考我这篇博文

    一、非线性逻辑回归解决分类问题Demo

    import matplotlib.pyplot as plt
    import numpy as np
    from sklearn.metrics import classification_report
    from sklearn import preprocessing
    from sklearn.preprocessing import PolynomialFeatures
    
    # 数据是否需要标准化
    scale = False
    
    # 读取数据
    data = np.genfromtxt('LR-testSet2.txt', delimiter=',')
    x_data = data[:, 0:-1]
    y_data = data[:, -1, np.newaxis]
    
    # 绘制各类别的数据散点图
    def plotClass():
        x0 = []
        y0 = []
        x1 = []
        y1 = []
        for i in range(len(x_data)):
            if y_data[i] == 0:
                x0.append(x_data[i, 0])
                y0.append(x_data[i, 1])
            else:
                x1.append(x_data[i, 0])
                y1.append(x_data[i, 1])
    
        # 绘图
        s1 = plt.scatter(x0, y0, c='b', marker='o')
        s2 = plt.scatter(x1, y1, c='r', marker='x')
        plt.legend(handles=[s1, s2], labels=['class0', 'class1'])
    
    
    # 定义多项式回归,degree的值可以调节多项式的特征
    poly_reg = PolynomialFeatures(degree=3)  # 得到非线性方程y = theta0+theta1*x1+theta2*x1^2+theta3*x1*x2+theta4*x^2所需的样本数据
    # 特征处理(获取多项式相应特征所对应的样本数据)
    x_poly = poly_reg.fit_transform(x_data)
    
    # 定义逻辑回归的模型函数(S型函数)
    def sigmoid(x):
        return 1 / (1 + np.exp(-x))
    
    # 计算代价值
    def cost(xMat, yMat, ws):
        left = np.multiply(yMat, np.log(sigmoid(xMat * ws)))
        right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat * ws)))
        return np.sum(left + right) / -len(xMat)
    
    # 梯度下降算法
    def gradAscent(xArr, yArr):
        if scale:
            xArr = preprocessing.scale(xArr)
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
    
        # 学习率
        lr = 0.03
        # 梯度下降迭代次数
        ite = 50000
        # 记录梯度下降过程中的代价值
        costList = []
        # 计算数据行列数
        m, n = np.shape(xMat)
        # 初始化线性函数权重
        ws = np.mat(np.ones((n, 1)))
        for i in range(ite + 1):
            h = sigmoid(xMat * ws)
            ws_grad = xMat.T * (h - yMat) / m
            ws = ws - lr * ws_grad
            if i % 50 == 0:
                costList.append(cost(xMat, yMat, ws))
        return ws, costList
    
    # 训练模型
    ws, costList = gradAscent(x_poly, y_data)
    # 获取数据值所在的范围
    x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
    y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    
    # 生成网格矩阵
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02))
    # 测试点的预测值
    z = sigmoid(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]).dot(np.array(ws)))
    print(xx.shape)
    print(len(z))
    for i in range(len(z)):
        if z[i] > 0.5:
            z[i] = 1
        else:
            z[i] = 0
    
    z = z.reshape(xx.shape)
    # 绘制等高线图
    cs = plt.contourf(xx, yy, z)
    plotClass()
    
    # 根据训练的模型进行预测类型
    def predict(x_data, ws):
        if scale:
            x_data = preprocessing.scale(x_data)
        xMat = np.mat(x_data)
        ws = np.mat(ws)
        return [1 if x >= 0.5 else 0 for x in sigmoid(xMat * ws)]
    
    predictions = predict(x_poly, ws)
    # 计算准确率,召回率,F1值
    print(classification_report(y_data, predictions))
    plt.show()
    
    

    二、执行结果

    precision    recall  f1-score   support
    
             0.0       0.86      0.83      0.85        60
             1.0       0.83      0.86      0.85        58
    
       micro avg       0.85      0.85      0.85       118
       macro avg       0.85      0.85      0.85       118
    weighted avg       0.85      0.85      0.85       118
    

    在这里插入图片描述
    三、数据下载
    链接:https://pan.baidu.com/s/1Lvrzw7s0d4F5jB7SVlkJzg
    提取码:q3uv

    展开全文
  • m = 100000 x = np.random.normal(size = m) X = x.reshape(-1, 1) y = 4.0 * x + 3.0 + np.random.normal(0 ,3, size = m) 。。。
  • 线性回归参数估计--最小二乘法与梯度下降法Python实现
  • 1.方程模型 h = np.dot(X,theta) ...3.梯度下降 deltatheta = (1.0/m) * np.dot(X.T,h-y) 4.参数更新 theta -= alpha * deltatheta 注释 这里把数据集的特征定义为X,h为预测值,J为代价函数,y为真实值,alph...
  • 以简单的抛物曲面的最小化问题为例,在Python环境中实现了多种常见地图下降算法,SGD、Momentum、AdaGrad、RMSprop、AdaDelta、Adam、AdaMax、AMSGrad等。 所有参数已整定,可以直接运行得到结果,每个循环中,只对...
  • 【八】机器学习之路——梯度下降法python实现

    万次阅读 热门讨论 2017-11-01 15:38:14
    今天咱们来介绍下,如何用梯度下降法拟合数据。   还记得梯度下降法是怎么做的吗?忘记的同学可以回头看下前面的博客线性回归。咱们还是拿之前博客线性回归python实现里的数据进行讲解。   假设咱们现在想用y=...
  • 在学习线性回归的时候很多课程都会讲到用梯度下降法求解参数,对于梯度下降算法怎么求出这个解讲的较少,自己实现一遍算法比较有助于理解算法,也能注意到比较细节的东西。具体的数学推导可以参照这一篇博客...
  • 梯度下降法及其Python实现 http://blog.csdn.net/yhao2014/article/details/51554910 梯度下降法(gradient descent),又名最速下降法(steepest descent)是求解无约束最优化问题最常用的...
  • 逻辑回归-梯度下降法 python实现

    千次阅读 2016-05-14 21:58:49
    模型、目标(cost function)、算法 Step1:对于一个问题,需要首先建立一个模型,如回归或分类模型; step2:通过最小分类误差、最大似然或最大后验概率建立模型的代价函数; step3:最优化问题求解 a.如果优化函数...
  • 梯度下降算法python实现(学习笔记)

    万次阅读 多人点赞 2017-06-17 21:00:46
    批量梯度下降算法、随机梯度下降算法、mini-batch梯度下降算法 python实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,801
精华内容 13,920
关键字:

梯度下降法python实现

python 订阅