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

最新推荐文章于 2023-07-26 16:09:24 发布
最新推荐文章于 2023-07-26 16:09:24 发布
阅读量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实现梯度下降和逻辑回归
09-17
主要为大家详细介绍了python实现梯度下降和逻辑回归，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
案例实战：Python实现逻辑回归(Logistic Regression)与梯度下降策略
bigcindy的博客
06-09 7608
0. 案例背景 我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学系的管理员，你想根据两次考试的结果来决定每个申请人的录取机会。你有以前的申请人的历史数据，你可以用它作为逻辑回归的训练集。对于每一个培训例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。 1. 导入pythony库 #导入机器学习三大件：Numpy, Pandas, Matplotlib import numpy as np import pandas
Python实现逻辑回归（使用梯度下降算法）
qq_21565363的博客
03-23 985
本文通过建立逻辑斯蒂分类模型，使用梯度下降法和批量梯度下降法对模型参数进行求解，最终在测试集上的准确率达到了 94.56% 和 94.48%，效果非常好。同时也探究了两种迭代方法在本案例中的优劣。
python机器学习（五）逻辑回归、决策边界、代价函数、梯度下降法实现线性和非线性逻辑回归
hwwaizs的博客
07-26 1968
逻辑回归、决策边界、代价函数、梯度下降法实现线性和非线性逻辑回归
非线性逻辑回归的梯度下降算法python实现以及决策边界的绘制
Mekeater的博客
05-02 1466
非线性逻辑回归的梯度下降算法python实现以及决策边界的绘制 前言： 对于逻辑回归的决策边界有很多并不是线性的而是非线性的，那么这样我就需要训练非线性的逻辑回归，如何训练非线性的逻辑回归呢？仍然利用sklearn的特征转换思路，将非线性问题转为线性问题进行解决，具体思路参考我这篇博文 关乎逻辑回归的理论知识参考我这篇博文 一、非线性逻辑回归解决分类问题Demo import matplotli...
＜＜从零入门机器学习＞＞ 逻辑回归之预测考生是否通过考试
弗兰-随风小欢的博客
07-07 1796
1. 学习前需要掌握的知识以及问题背景 1.1 学习知识背景        学习本实战例子前提需要掌握机器学习中逻辑回归的概念，Python的基础语法，MSE，R2_score等变量的含义，以及数学求解过程，本篇博客默认是基于掌握如上知识点进行的。 1.2 考生成绩预测问题以及本实战的原始数据(testdata.csv文件放在文章的末尾，自行取)         如下是usa_housing_price.csv文件的部分数据截图
机器学习入门 — 根据推导公式使用Python实现梯度下降与逻辑回归
12-21
在本篇教程中，我们将基于Python实现逻辑回归，特别是利用梯度下降法来求解模型参数。梯度下降是一种优化算法，用于寻找函数最小值，是机器学习中求解模型参数的常用方法。首先，我们需要了解梯度下降的基本原理。...
基于 Python 的梯度下降、逻辑回归等源码实现
最新发布
06-02
【作品名称】：基于 Python 的梯度下降、逻辑回归等源码实现 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：基于 ...
python实现逻辑回归与梯度下降策略
04-26
逻辑回归是在线性回归的基础上，增加一个转化函数，能够将预测值映射到【0,1】之间，以0.5为分界线，从而达到分类的目的。其中经常用到的转化函数是sigmoid：
逻辑回归与梯度下降策略之Python实现
自成背后的博客
02-24 4713
Python实现逻辑回归与梯度下降策略1. 映射到概率的函数sigmoid2. 返回预测结果值model函数3. 计算损失值cost4. 计算梯度gradient5. 进行参数更新计算精度 我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学系的管理员，你想根据两次考试的结果来决定每个申请人的录取机会。你有以前的申请人的历史数据，你可以用它作为逻辑回归的训练集。 这里我们有一个LogiReg_data.txt文件数据： 对于每一个培训例子，你有两个考试的申请人的分数和录取决定。为了做到
逻辑回归梯度下降 Python实现
qq_43235359的博客
05-17 2087
加载库， 数据读取。正类样本：（x_1, y_1），负类样本：（x_0, y_0），标签：label。 import numpy as np import math import matplotlib.pyplot as plt filename = r"C:\Users\samsara\Desktop\LR.txt" fr = open(filename) #读取数据 data, la...
逻辑回归-梯度下降法 python实现
u013593585的专栏
05-14 5498
机器学习的基本框架： 模型、目标(cost function)、算法 Step1：对于一个问题，需要首先建立一个模型，如回归或分类模型； step2：通过最小分类误差、最大似然或最大后验概率建立模型的代价函数； step3：最优化问题求解 a.如果优化函数存在解析解，则可以通过一般的求值方法-对代价函数求导，找到倒数为0的点，即是最大值或者最小孩子； b.如果上述方法求优化函数导数比较
逻辑回归python梯度下降_Python机器学习之Logistic回归梯度下降算法实例（批量/随机） | kTWO-个人博客...
weixin_39952190的博客
12-09 621
前言在上一篇文章《机器学习之Logistic回归(非线性回归)》中我们对Logistic回归算法做了简单的描述，同时也说到了梯度下降算法，我们之前说过，Logistic回归是解决分类问题的模型，同线性回归形似但从根本上来说还是有很大区别的。在Logistic回归求最小值的时候我们使用的方法是梯度下降算法，上一篇理论性的文章中我们没有给出具体的代码，下面我们就Logistic回归利用两种梯度下降算法...
Stanford coursera Andrew Ng 机器学习课程编程作业（Exercise 2）及总结
weixin_33834075的博客
11-18 189
Exercise 1：Linear Regression---实现一个线性回归 关于如何实现一个线性回归，请参考：http://www.cnblogs.com/hapjin/p/6079012.html   Exercise 2：Logistic Regression---实现一个逻辑回归 问题描述：用逻辑回归根据学生的考试成绩来判断该学生是否可以入学。 这里的训练数据(training inst...
Python+sklearn使用逻辑回归算法预测期末考试能否及格
董付国的Python专栏
05-20 1866
封面图片：《Python程序设计实验指导书》，董付国编著，清华大学出版社=================虽然名字中带有“回归”二字，但实际上逻辑回归是一个用于分类的线性模型，通常也称作最...
基于 NumPy 实现随机梯度下降算法
AI科技大本营
07-26 1338
作者 | 云朵君来源 |数据STUDIO今天和大家一起学习非常常用的一种优化算法：梯度下降，在机器学习应用中经常被用来寻找对应于预测和实际输出之间最佳拟合的模型参数。这是一个不精确但强大的技术。接下来我们就一起学习吧！本文较长，信息量较大，建议收藏！随机梯度下降在机器学习应用中被广泛使用。与反向传播相结合，它在神经网络训练应用中占主导地位。在本文中，我们将一起学习：梯度...
python+numpy利用梯度下降算法实现逻辑回归（对比sklearn官方demo）
weixin_42677438的博客
07-22 630
文章目录概要描述详细说明python实现梯度下降算法sklearn官方demo 概要描述 在逻辑回归中，可以使用梯度下降算法来求解模型（即确定sigmoid函数中的各系数和截距）。 本文用python实现梯度下降算法，并使用numpy做矩阵计算求解逻辑回归模型，最后与sklearn官方代码结果验证结果正确性。 详细说明 python实现梯度下降算法 # !/usr/bin/python # -*- coding: utf-8 -*- """ PROJECT_NAME = Datawhale Author :
第三讲 Numpy理解各种梯度下降等优化算法
biyesheji1000的专栏
02-09 763
Numpy理解各种梯度下降等优化算法 一 本节课程介绍 1.1 知识点 1、优化算法的基本介绍； 2、梯度下降算法的实现； 3、随机梯度下降的实现； 4、其他优化算法的对比； 二 课程内容 2.1 优化算法基本介绍 优化算法常用在最优化模型上，使得模型的损失值为最小。经典的优化算法分为直接法和迭代法。直接法是指能够直接获取到优化问题的最优解。其要求目标函数需要满足两个条件：（1）目标函数需要是凸函数，若目标函数是凸函数，其最优解处的梯度为0；（2）对于求解目标函数梯度为0，需要有其闭式解。常见的直接优化算
机器学习之逻辑回归以及梯度下降法求解
学习笔记
09-21 1709
逻辑回归，其实不是回归任务，而是分类任务，逻辑回归模型对二分类问题效果较好。
逻辑回归梯度下降算法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、付费专栏及课程。

余额充值