逻辑回归梯度下降方法Python实现-依据成绩进行类别预测

最新推荐文章于 2023-01-03 15:35:06 发布
最新推荐文章于 2023-01-03 15:35:06 发布
阅读量1.5k 收藏 20
点赞数 6
分类专栏： 机器学习 文章标签： 机器学习 逻辑回归 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanshuaipeng/article/details/106141084
版权

参考： https://www.cnblogs.com/hello-/articles/9737549.html

测试数据地址：https://download.csdn.net/download/yuanshuaipeng/12423234

案例说明：假设你是一个大学系的管理员，你想根据两次考试的结果来决定每个申请人的录取机会。你有以前的申请人的历史数据，你可以用它作为逻辑回归的训练集。对于每一个培训例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。

导入三大模块：numpy pandas matplotlib

import  time
import numpy as np
import pandas as pd
import  matplotlib.pyplot as plt

读取原始数据：

# 读取数据
    data = pd.read_csv("./LogiReg_data.txt", header=None, 
                           names=["score1", "score2", "label"])
    print(data.head(3))
    print(data.shape)

可视化展示：

def show_data(data):
    set_0 = data[data["label"]==0]
    set_1 = data[data["label"]==1]
    plt.figure(figsize=(10,5))
    plt.scatter(set_0["score1"], set_0["score2"], c="r", marker="*")
    plt.scatter(set_1["score1"], set_1["score2"], c="b", marker="o")
    plt.legend()
    plt.xlabel("score1")
    plt.ylabel("score2")
    plt.show()

逻辑回归实现

目标：建立分类器（求解出三个参数 θ0θ1θ2）,θ0偏置项θ1第一次测试的成绩θ2第二次测试的成绩

设定阈值，根据阈值判断录取结果

完成模块：

sigmoid : 映射到概率的函数

model : 返回预测结果值

cost : 根据参数计算损失

gradient : 计算每个参数的梯度方向

descent : 进行参数更新

1.sigmoid函数：

def sigmode(z):
    return 1 / (1+ np.exp(-z))

2、预测函数：

def model(X, theta):
    """
    X：样本矩阵 （包括第一列的1）
    theta : 行向量 [θ0， θ1, ....θn]
    返回预测的结果值
    :return:
    """
    return sigmode(np.dot(X, theta.T))

3、原始数据及参数初始化

# 数据增加1列，
data.insert(0,"Ones",value=1)
print(data.loc[:3,:])

# set X and y
orig_data =data.as_matrix()
# m 样本的数量， n 特征数量+1（label）
m,n = orig_data.shape
theta = np.zeros(shape=(1, n - 1))

4、损失函数

def cost(X, y, theta):
    """
    获取样本的损失值，为所有样本的损失均值
    """
    # 注意，multipy和 np.dot的区别
    left = np.multiply(-y, np.log(model(X,theta)))
    right = np.multiply(1-y, np.log(1 - model(X,theta)))
    return np.sum(left-right) / len(X)

5、计算梯度：

def gradient(X,y,theta):
    """
    计算梯度，返回一个和theta 一样的数组
    :return:
    """
    #二维数组，1*n
    grad = np.zeros(shape=theta.shape)
    # error n*1
    error = y- model(X,theta)
    for j in range(grad.shape[1]):
        # grad 1*n ,
        grad[0, j] = - np.dot(error.T, X[:,j]) / X.shape[0]
    return grad

6、实现梯度下降：

6.1 设置三种迭代终止策略

1、迭代次数  2、损失差值 3、梯度差值

# 停止准则
STOP_ITER = 0 #  迭代数量
STOP_COST = 1 #损失函数
STOP_GRAD = 2 # 梯度值

def stop_cretion(type, value, threshold):
    if type == STOP_ITER:   return value > threshold
    elif type == STOP_COST: return  abs(value[-1]-value[-2]) < threshold
    elif type == STOP_GRAD: return np.linalg.norm(value) < threshold

6.2 三种梯度下降策略： 1 整批量梯度下降、2、随机梯度下降 3 小批量梯度下降

根据batchsize 来实现三种梯度下降

# 重排数据
def shuffle_data(data):
    np.random.shuffle(data)
    X= data[:,:-1]
    y = data[:,-1:]
    return X,y

def descent(data, theta, batchsize, stoptype, threshold, alpha):

    i=0  #迭代次数
    b =0 #批量位置索引
    init_time = time.time()

    # 初始化梯度：
    grad = np.zeros(theta.shape)

    #首先对数据清洗
    X, y = shuffle_data(data)

    # 初始化cost
    cost_value = [cost(X,y,theta)]

    while True:
        # 先求梯度：
        grad = gradient(X[b:b+batchsize,:], y[b:b+batchsize,:], theta)
        b += batchsize

        #执行完一次后对数据重新洗牌
        if b>= X.shape[0]:
            b=0
            X,y = shuffle_data(data)

        # 根据梯度更新参数
        theta = theta - alpha * grad
        # 损失值
        ## 注意：尽管求梯度时不一定用到所有样本，但求损失值时，用的是所有样本
        cost_value.append(cost(X,y,theta))
        i+=1

        if stoptype == STOP_ITER: value=i
        elif stoptype == STOP_COST: value= cost_value
        elif stoptype == STOP_GRAD: value= grad

        #判断是否
        if stop_cretion(stoptype, value, threshold): break
        # 返回： theta ,迭代次数，损失值，当前梯度， 运行时间
    return theta, i-1, cost_value, grad, time.time() - init_time

7、主函数及结果展示：

def run(data, theta, batchSize, stopType, thresh, alpha):
    theta, iter, costs, grad, dur = descent(data, theta, batchSize, stopType, thresh, alpha)
    # 根据结果绘制图形
    name = "Original" if (data[:, 1] > 2).sum() > 1 else "Scaled"
    name += " data - learning rate: {} - ".format(alpha)
    if batchSize == data.shape[0]:
        strDescType = "Gradient"
    elif batchSize == 1:
        strDescType = "Stochastic"
    else:
        strDescType = "Mini-batch ({})".format(batchSize)
    name += strDescType + " descent - Stop: "
    if stopType == STOP_ITER:
        strStop = "{} iterations".format(thresh)
    elif stopType == STOP_COST:
        strStop = "costs change < {}".format(thresh)
    else:
        strStop = "gradient norm < {}".format(thresh)
    name += strStop
    print("***{}\nTheta: {} - Iter: {} - Last cost: {:03.2f} - Duration: {:03.2f}s".format(
        name, theta, iter, costs[-1], dur))
    fig, ax = plt.subplots(figsize=(12, 4))
    ax.plot(np.arange(len(costs)), costs, 'r')
    ax.set_xlabel('Iterations')
    ax.set_ylabel('Cost')
    ax.set_title(name.upper() + ' - Error vs. Iteration')
    plt.show()
    return theta

1、 基于批量梯度下降，终止准则5000次迭代

# 按迭代次数为终止条件：
# run(orig_data, theta, m, STOP_ITER, 5000, 0.000001)
#按损失值的差值
# run(orig_data, theta, m, STOP_COST, thresh=0.000001, alpha=0.001)

# 根据梯度变化停止
# run(orig_data, theta, m, STOP_GRAD, thresh=0.05, alpha=0.001)
#标准化后的实验结果
orig_data[:,:(n-1)] = scale(orig_data[:,:(n-1)])
# run(orig_data, theta, m, STOP_ITER, 50000, 0.001)
theta = run(orig_data, theta, 16, STOP_ITER, 50000, 0.001)

全部代码：

#coding=utf-8
import sys
import math
import random
import  time
import numpy as np
import pandas as pd
import  matplotlib.pyplot as plt

from sklearn.preprocessing import scale

# 停止准则
STOP_ITER = 0 #  迭代数量
STOP_COST = 1 #损失函数
STOP_GRAD = 2 # 梯度值


def show_data(data):
    set_0 = data[data["label"]==0]
    set_1 = data[data["label"]==1]
    plt.figure(figsize=(10,5))
    plt.scatter(set_0["score1"], set_0["score2"], c="r", marker="*")
    plt.scatter(set_1["score1"], set_1["score2"], c="b", marker="o")

    plt.xlabel("score1")
    plt.ylabel("score2")
    plt.show()


def sigmode(z):
    return 1 / (1+ np.exp(-z))


def model(X, theta):
    """
    X：样本矩阵 （包括第一列的1）
    theta : 行向量 [θ0， θ1, ....θn]
    返回预测的结果值
    :return:
    """
    return sigmode(np.dot(X, theta.T))

def cost(X, y, theta):
    """
    获取样本的损失值，为所有样本的损失均值
    """
    # 注意，multipy和 np.dot的区别
    left = np.multiply(-y, np.log(model(X,theta)))
    right = np.multiply(1-y, np.log(1 - model(X,theta)))
    return np.sum(left-right) / len(X)

def gradient(X,y,theta):
    """
    计算梯度，返回一个和theta 一样的数组
    :return:
    """
    #二维数组，1*n
    grad = np.zeros(shape=theta.shape)
    # error n*1
    error = y- model(X,theta)
    for j in range(grad.shape[1]):
        # grad 1*n ,
        grad[0, j] = - np.dot(error.T, X[:,j]) / X.shape[0]
    return grad


def gradient2(X, y, theta):
    grad = np.zeros(theta.shape)
    error = (model(X, theta) - y).ravel()
    for j in range(len(theta.ravel())):  # for each parmeter
        term = np.multiply(error, X[:, j])
        grad[0, j] = np.sum(term) / len(X)

    return grad



def stop_cretion(type, value, threshold):
    if type == STOP_ITER:   return value > threshold
    elif type == STOP_COST: return  abs(value[-1]-value[-2]) < threshold
    #
    elif type == STOP_GRAD: return np.linalg.norm(value) < threshold

# 重排数据
def shuffle_data(data):
    np.random.shuffle(data)
    X= data[:,:-1]
    y = data[:,-1:]
    return X,y

def descent(data, theta, batchsize, stoptype, threshold, alpha):

    i=0  #迭代次数
    b =0 #批量位置索引
    init_time = time.time()

    # 初始化梯度：
    grad = np.zeros(theta.shape)

    #首先对数据清洗
    X, y = shuffle_data(data)

    # 初始化cost
    cost_value = [cost(X,y,theta)]

    while True:
        # 先求梯度：
        grad = gradient(X[b:b+batchsize,:], y[b:b+batchsize,:], theta)
        b += batchsize

        #执行完一次后对数据重新洗牌
        if b>= X.shape[0]:
            b=0
            X,y = shuffle_data(data)

        # 根据梯度更新参数
        theta = theta - alpha * grad
        # 损失值
        ## 注意：尽管求梯度时不一定用到所有样本，但求损失值时，用的是所有样本
        cost_value.append(cost(X,y,theta))
        i+=1

        if stoptype == STOP_ITER: value=i
        elif stoptype == STOP_COST: value= cost_value
        elif stoptype == STOP_GRAD: value= grad

        #判断是否
        if stop_cretion(stoptype, value, threshold): break
        # 返回： theta ,迭代次数，损失值，当前梯度， 运行时间
    return theta, i-1, cost_value, grad, time.time() - init_time

def run(data, theta, batchSize, stopType, thresh, alpha):
    theta, iter, costs, grad, dur = descent(data, theta, batchSize, stopType, thresh, alpha)
    # 根据结果绘制图形
    name = "Original" if (data[:, 1] > 2).sum() > 1 else "Scaled"
    name += " data - learning rate: {} - ".format(alpha)
    if batchSize == data.shape[0]:
        strDescType = "Gradient"
    elif batchSize == 1:
        strDescType = "Stochastic"
    else:
        strDescType = "Mini-batch ({})".format(batchSize)
    name += strDescType + " descent - Stop: "
    if stopType == STOP_ITER:
        strStop = "{} iterations".format(thresh)
    elif stopType == STOP_COST:
        strStop = "costs change < {}".format(thresh)
    else:
        strStop = "gradient norm < {}".format(thresh)
    name += strStop
    print("***{}\nTheta: {} - Iter: {} - Last cost: {:03.2f} - Duration: {:03.2f}s".format(
        name, theta, iter, costs[-1], dur))
    fig, ax = plt.subplots(figsize=(12, 4))
    ax.plot(np.arange(len(costs)), costs, 'r')
    ax.set_xlabel('Iterations')
    ax.set_ylabel('Cost')
    ax.set_title(name.upper() + ' - Error vs. Iteration')
    plt.show()
    return theta

def predict(X, theta):
    return [1 if x> 0.5 else 0 for x in model(X,theta)]

def acuuracy(y,predict_value):
    _y =y.ravel()
    correct = [1 if _y[i] == predict_value[i] else 0
               for i in range(len(_y))]
    return np.sum(correct) / len(_y)



if __name__ == '__main__':
    # 读取数据
    data = pd.read_csv("./LogiReg_data.txt", header=None, names=["score1", "score2", "label"])
    print(data.head(3))
    print(data.shape)
    # show_data(data)

    # 数据增加1列，
    data.insert(0,"Ones",value=1)
    print(data.loc[:3,:])

    # set X and y
    orig_data =data.as_matrix()
    # m 样本的数量， n 特征数量+1（label）
    m,n = orig_data.shape
    theta = np.zeros(shape=(1, n - 1))
    #批量梯度下降
    # 按迭代次数为终止条件：
    # run(orig_data, theta, m, STOP_ITER, 5000, 0.000001)

    #按损失值的差值
    # run(orig_data, theta, m, STOP_COST, thresh=0.000001, alpha=0.001)

    # 根据梯度变化停止
    # run(orig_data, theta, m, STOP_GRAD, thresh=0.05, alpha=0.001)

    #标准化
    orig_data[:,:(n-1)] = scale(orig_data[:,:(n-1)])
    # run(orig_data, theta, m, STOP_ITER, 50000, 0.001)
    theta = run(orig_data, theta, 16, STOP_ITER, 50000, 0.001)

    #计算准确率
    print("准确率为：", acuuracy(orig_data[:,-1], predict(orig_data[:,:(n-1)], theta)))

 

 

 

 

 

yuanshuaipeng
关注
  • 6
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现逻辑回归（使用梯度下降算法）
qq_21565363的博客
03-23 965
本文通过建立逻辑斯蒂分类模型，使用梯度下降法和批量梯度下降法对模型参数进行求解，最终在测试集上的准确率达到了 94.56% 和 94.48%，效果非常好。同时也探究了两种迭代方法在本案例中的优劣。
非线性逻辑回归的梯度下降算法python实现以及决策边界的绘制
Mekeater的博客
05-02 1457
非线性逻辑回归的梯度下降算法python实现以及决策边界的绘制 前言： 对于逻辑回归的决策边界有很多并不是线性的而是非线性的，那么这样我就需要训练非线性的逻辑回归，如何训练非线性的逻辑回归呢？仍然利用sklearn的特征转换思路，将非线性问题转为线性问题进行解决，具体思路参考我这篇博文 关乎逻辑回归的理论知识参考我这篇博文 一、非线性逻辑回归解决分类问题Demo import matplotli...
＜＜从零入门机器学习＞＞ 逻辑回归之预测考生是否通过考试
弗兰-随风小欢的博客
07-07 1758
1. 学习前需要掌握的知识以及问题背景 1.1 学习知识背景        学习本实战例子前提需要掌握机器学习中逻辑回归的概念，Python的基础语法，MSE，R2_score等变量的含义，以及数学求解过程，本篇博客默认是基于掌握如上知识点进行的。 1.2 考生成绩预测问题以及本实战的原始数据(testdata.csv文件放在文章的末尾，自行取)         如下是usa_housing_price.csv文件的部分数据截图
逻辑回归-梯度下降法 python实现
u013593585的专栏
05-14 5486
机器学习的基本框架： 模型、目标(cost function)、算法 Step1：对于一个问题，需要首先建立一个模型，如回归或分类模型； step2：通过最小分类误差、最大似然或最大后验概率建立模型的代价函数； step3：最优化问题求解 a.如果优化函数存在解析解，则可以通过一般的求值方法-对代价函数求导，找到倒数为0的点，即是最大值或者最小孩子； b.如果上述方法求优化函数导数比较
机器学习之逻辑回归以及梯度下降法求解
学习笔记
09-21 1703
逻辑回归，其实不是回归任务，而是分类任务，逻辑回归模型对二分类问题效果较好。
python实现梯度下降和逻辑回归
09-17
主要为大家详细介绍了python实现梯度下降和逻辑回归，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于 Python 的梯度下降、逻辑回归等源码实现
最新发布
06-02
【作品名称】：基于 Python 的梯度下降、逻辑回归等源码实现 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：基于 ...
机器学习入门 — 根据推导公式使用Python实现梯度下降与逻辑回归
12-21
关于梯度下降与逻辑回归，我在之前的文章中已经写过了公式推导，本文中将用python代码进行实现并做简单的实验 机器学习入门 — 梯度下降原理 机器学习入门 — 逻辑回归算法 案例概述 在这里我们将建立一个逻辑回归...
python实现逻辑回归与梯度下降策略
04-26
逻辑回归是在线性回归的基础上，增加一个转化函数，能够将预测值映射到【0,1】之间，以0.5为分界线，从而达到分类的目的。其中经常用到的转化函数是sigmoid：
python机器学习《基于逻辑回归的预测分类》
weixin_54201782的博客
01-01 1019
python机器学习逻辑回归模型
Logistic算法（随机梯度下降法）的Python代码和数据样本
03-12
资源中包含随机梯度下降逻辑回归算法的Python代码和测试数据，python的版本为3.6，您运行代码前，将测试文件路径修改为您本地的存储路径，使用pycharm平台运行即可。
使用python逻辑回归模型来进行数据预测
weixin_35749796的博客
01-03 1541
可以使用 python 中的逻辑回归模型来进行数据预测。逻辑回归是一种用于分类的机器学习算法，它可以根据输入的特征来预测目标变量是 0 还是 1。 举个例子，假设你想要根据一些人的年龄、身高、体重和性别来预测他们是否得了糖尿病。你可以使用逻辑回归模型来分析这些数据，并根据输入的特征来预测每个人是否得了糖尿病。 在 python 中，你可以使用 scikit-learn 库中的 LogisticRe...
python实现逻辑回归建模进行分类预测及特征分析
数据杂坛
05-27 1447
python实现数据读取、数据清洗、数据编码、数据划分，并实现逻辑回归建模分类预测及特征分析（完整代码+实现效果）。
逻辑斯蒂回归原理及梯度下降法python实现
drdtddtrdr的博客
11-24 637
逻辑斯蒂回归笔记
三、梯度下降法求解最优θ值
beyond谚语的博客
04-23 1923
一、得到目标函数J(θ)，求解使得J(θ)最小时的θ值 通过最小二乘法求目标函数最小值 令偏导为0即可求解出最小的θ值，即 二、判定为凸函数 凸函数有需要判断方法，比如：定义、一阶条件、二阶条件等。利用正定性判定使用的是二阶条件。 半正定一定是凸函数，开口朝上，半正定一定有极小值 在用二阶条件进行判定的时候，需要得到Hessian矩阵，根据Hessian的正定性判定函数的凹凸性。比如Hessian矩阵半正定，函数为凸函数；Hessian矩阵正定，函数为严格凸函数 Hessian矩阵：黑塞矩阵(Hess
logistic回归详解（四）：梯度下降训练逻辑回归python实现
bitcarmanlee的博客
10-14 8065
1.逻辑回归梯度下降的迭代公式 在参考文献1中，我们推导出了逻辑回归的参数迭代公式为: θ=θ−α∗XT∗E\theta = \theta - \alpha * X ^ T * Eθ=θ−α∗XT∗E 接下来我们按照这个思路，用python来手动实现以下逻辑回归算法。 2.准备数据 -0.017612 14.053064 0 -1.395634 4.662541 1 -0.752...
Logistic regression 梯度下降|牛顿法 python实现
wcy708708的博客
10-26 4641
写在开头： 这篇文章主要是为了整合我在学习并用python实现logistic regression回归模型的参数估计时的一系列知识点。文章内干货较多，然而对原理方面的介绍较少，希望理解原理的话请移步wiki。 batch gradient descent:  https://en.wikipedia.org/wiki/Gradient_descent logistic regression...
Python实现逻辑回归与梯度下降策略
qq_33543737的博客
01-23 778
我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学的管理员，你想根据两次考试的结果来决定每个申请人的录取机会。你有以前申请人的历史数据，你可以用它作为逻辑回归的训练集，对于每一个训练例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。 import pandas as pd import numpy as np ...
[机器学习]逻辑回归公式推导及其梯度下降法的Python实现
一番の宝物
02-09 3878
一般来说，二项逻辑斯谛回归模型是一个二分类判别模型，由条件概率分布P(Y|X)P(Y|X)P(Y|X)表示，随机变量XXX为实数，YYY取值0或者1。我们通过比较P(Y=1|x)P(Y=1|x)P(Y=1|x)和P(Y=0|x)P(Y=0|x)P(Y=0|x)值大小来判断给定x的类别为1还是0。 从线性模型推导 我们先说广义的线性回归：y=wx+by=wx+by=wx+b，这里 yyy为回...
逻辑回归梯度下降算法python实战
10-10
下面是一个使用Python实现逻辑回归梯度下降算法的示例代码： ```python import numpy as np def sigmoid(z): """Sigmoid函数""" return 1 / (1 + np.exp(-z)) def logistic_regression(X, y, num_iterations, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值