机器学习算法系列之逻辑回归

目录

逻辑回归

一、理论知识

二、基于python实现逻辑回归

三、基于sklearn的逻辑回归，实现简单信用分类

---

本系列机器学习的文章打算从机器学习算法的一些理论知识、python实现该算法和调一些该算法的相应包来实现。

逻辑回归

一、理论知识

1. 什么是逻辑回归(Logistics Regression)
          逻辑回归是用来做分类算法的，从上一节的线性回归中我们知道其一般形式为Y=aX+b，且Y的取值范围为[-∞, +∞]，有这么多的取值导致无法进行分类，所以这里采用把Y的结果带入一个非线性变换的sigmoid函数中，即将Y的值域映射成[0，1]之间取值的函数S,S的值可以看成一个概率值，如果我们设置概率阈值为0.5，那么S的值大于0.5的可以看成是正样本，小于0.5的可以看成是负样本，这样就可以完成一个二分类。

2. sigmoid函数
   函数公式：
   函数图像：

   

   
   函数中t无论取什么值，其结果都在[0,1]的区间内，回想一下，一个二分类问题就有两种答案，一种是“是”，一种是“否”，那0对应着“否”，1对应着“是”，那又有人问了，你这不是[0,1]的区间吗，怎么会只有0和1呢？这个问题问得好，我们假设分类的阈值是0.5，那么超过0.5的归为1分类，低于0.5的归为0分类，阈值是可以自己设定的。
   我们把aX+b带入t中就得到了我们的逻辑回归的一般模型方程：
   其结果大于0.5的属于一分类，结果小于0.5的属于0分类，这样就达到了分类的目的

3. 损失函数

逻辑回归的损失函数是log loss ,也就是对数似然函数，函数公式如下：

（y指真实样本）

公式中的y=1表示的是真实值时使用第一个公式，反之用第二个公式计算损失。加上log函数的原因：当真实样本为1时，但模型预测得到的结果h=0(概率),这时对模型的惩罚力度（log 0 = ∞）,损失函数此时的值很大，将模型给予修正；当h=1是，惩罚力度（log 1 =0），也就是没有损失，说明模型预测的结果很正确。所以这里使用log函数来表示损失函数。

最后按照梯度下降法，求解极小值点，得到想要的结果（模型效果）。

cross entropy:

---

 

二、基于python实现逻辑回归

1. 数据说明：在一些二维的散点图，有两个类别分别用0和1表示不同类别-0.60541,0.59722,1

-0.59389,0.005117,1
-0.42108,-0.27266,1
-0.11578,-0.39693,1
0.20104,-0.60161,1
0.46601,-0.53582,1
0.67339,-0.53582,1
-0.13882,0.54605,1
-0.29435,0.77997,1
-0.26555,0.96272,1
-0.16187,0.8019,1

0.93836,0.012427,0
0.86348,-0.082602,0
0.89804,-0.20687,0
0.85196,-0.36769,0
0.82892,-0.5212,0
0.79435,-0.55775,0
0.59274,-0.7405,0
0.51786,-0.5943,0
0.46601,-0.41886,0
0.35081,-0.57968,0
0.28744,-0.76974,0
0.085829,-0.75512,0
0.14919,-0.57968,0
-0.13306,-0.4481,0
-0.40956,-0.41155,0

数据可视化出来的散点图：

 

 

 代码：
 

from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
from scipy import optimize
from matplotlib.font_manager import FontProperties

font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)  # 解决windows环境下画图汉字乱码问题


def LogisticRegression():
    data = loadtxtAndcsv_data("data2.txt", ",", np.float64)
    X = data[:, 0:-1]
    y = data[:, -1]

    plot_data(X, y)  # 作图

    X = mapFeature(X[:, 0], X[:, 1])  # 映射为多项式
    initial_theta = np.zeros((X.shape[1], 1))  # 初始化theta
    initial_lambda = 0.1  # 初始化正则化系数，一般取0.01,0.1,1.....

    J = costFunction(initial_theta, X, y, initial_lambda)  # 计算一下给定初始化的theta和lambda求出的代价J

    print(J)  # 输出一下计算的值，应该为0.693147
    # result = optimize.fmin(costFunction, initial_theta, args=(X,y,initial_lambda))    #直接使用最小化的方法，效果不好
    '''调用scipy中的优化算法fmin_bfgs（拟牛顿法Broyden-Fletcher-Goldfarb-Shanno）
    - costFunction是自己实现的一个求代价的函数，
    - initial_theta表示初始化的值,
    - fprime指定costFunction的梯度
    - args是其余测参数，以元组的形式传入，最后会将最小化costFunction的theta返回 
    '''
    result = optimize.fmin_bfgs(costFunction, initial_theta, fprime=gradient, args=(X, y, initial_lambda))
    p = predict(X, result)  # 预测
    print(u'在训练集上的准确度为%f%%' % np.mean(np.float64(p == y) * 100))  # 与真实值比较，p==y返回True，转化为float

    X = data[:, 0:-1]
    y = data[:, -1]
    plotDecisionBoundary(result, X, y)  # 画决策边界


# 加载txt和csv文件
def loadtxtAndcsv_data(fileName, split, dataType):
    return np.loadtxt(fileName, delimiter=split, dtype=dataType)


# 加载npy文件
def loadnpy_data(fileName):
    return np.load(fileName)


# 显示二维图形
def plot_data(X, y):
    pos = np.where(y == 1)  # 找到y==1的坐标位置
    neg = np.where(y == 0)  # 找到y==0的坐标位置
    # 作图
    plt.figure(figsize=(15, 12))
    plt.plot(X[pos, 0], X[pos, 1], 'ro')  # red o
    plt.plot(X[neg, 0], X[neg, 1], 'bo')  # blue o
    plt.title(u"两个类别散点图", fontproperties=font)
    plt.show()


# 映射为多项式
def mapFeature(X1, X2):
    degree = 2;  # 映射的最高次方
    out = np.ones((X1.shape[0], 1))  # 映射后的结果数组（取代X）
    '''
    这里以degree=2为例，映射为1,x1,x2,x1^2,x1,x2,x2^2
    '''
    for i in np.arange(1, degree + 1):
        for j in range(i + 1):
            temp = X1 ** (i - j) * (X2 ** j)  # 矩阵直接乘相当于matlab中的点乘.*
            out = np.hstack((out, temp.reshape(-1, 1)))
    return out


# 代价函数
def costFunction(initial_theta, X, y, inital_lambda):
    m = len(y)
    J = 0

    h = sigmoid(np.dot(X, initial_theta))  # 计算h(z)
    theta1 = initial_theta.copy()  # 因为正则化j=1从1开始，不包含0，所以复制一份，前theta(0)值为0
    theta1[0] = 0

    temp = np.dot(np.transpose(theta1), theta1)
    J = (-np.dot(np.transpose(y), np.log(h)) - np.dot(np.transpose(1 - y),
                                                      np.log(1 - h)) + temp * inital_lambda / 2) / m  # 正则化的代价方程
    return J


# 计算梯度
def gradient(initial_theta, X, y, inital_lambda):
    m = len(y)
    grad = np.zeros((initial_theta.shape[0]))

    h = sigmoid(np.dot(X, initial_theta))  # 计算h(z)
    theta1 = initial_theta.copy()
    theta1[0] = 0

    grad = np.dot(np.transpose(X), h - y) / m + inital_lambda / m * theta1  # 正则化的梯度
    return grad


# S型函数
def sigmoid(z):
    h = np.zeros((len(z), 1))  # 初始化，与z的长度一置

    h = 1.0 / (1.0 + np.exp(-z))
    return h


# 画决策边界
def plotDecisionBoundary(theta, X, y):
    pos = np.where(y == 1)  # 找到y==1的坐标位置
    neg = np.where(y == 0)  # 找到y==0的坐标位置
    # 作图
    plt.figure(figsize=(15, 12))
    plt.plot(X[pos, 0], X[pos, 1], 'ro')  # red o
    plt.plot(X[neg, 0], X[neg, 1], 'bo')  # blue o
    plt.title(u"决策边界", fontproperties=font)

    # u = np.linspace(30,100,100)
    # v = np.linspace(30,100,100)

    u = np.linspace(-1, 1.5, 50)  # 根据具体的数据，这里需要调整
    v = np.linspace(-1, 1.5, 50)

    z = np.zeros((len(u), len(v)))
    for i in range(len(u)):
        for j in range(len(v)):
            z[i, j] = np.dot(mapFeature(u[i].reshape(1, -1), v[j].reshape(1, -1)), theta)  # 计算对应的值，需要map

    z = np.transpose(z)
    plt.contour(u, v, z, [0, 0.01], linewidth=2.0)  # 画等高线，范围在[0,0.01]，即近似为决策边界
    # plt.legend()
    plt.show()


# 预测
def predict(X, theta):
    m = X.shape[0]
    p = np.zeros((m, 1))
    p = sigmoid(np.dot(X, theta))  # 预测的结果，是个概率值

    for i in range(m):
        if p[i] > 0.5:  # 概率大于0.5预测为1，否则预测为0
            p[i] = 1
        else:
            p[i] = 0
    return p


# 测试逻辑回归函数
def testLogisticRegression():
    LogisticRegression()


if __name__ == "__main__":
    testLogisticRegression()

在完成分类后绘制出决策边界

 

---

三、基于sklearn的逻辑回归，实现简单信用分类

1. 数据说明：

   银行在市场经济中起着至关重要的作用。他们决定谁能获得资金，以什么条件获得资金，并决定投资决策的成败。为了让市场和社会发挥作用，个人和企业需要获得信贷。

   信用评分算法是银行用来决定贷款是否应该发放的一种方法，它对违约概率进行猜测。这项比赛要求参赛者通过预测某人在未来两年内遭遇财务困境的可能性，来提高自己在信用评分方面的水平。数据 
   （这个建议在jupyter中运行）

   

 

import pandas as pd
pd.set_option('display.max_columns', 500)
import zipfile
with zipfile.ZipFile('KaggleCredit2.csv.zip', 'r') as z:   ##读取zip里的文件
    f = z.open('KaggleCredit2.csv')
    data = pd.read_csv(f, index_col=0)
data.head(20)   #显示前20条数据

#进行数据处理和清洗
data.isnull().sum(axis=0)
data.dropna(inplace=True)   ##去掉为空的数据
data.shape
y = data['SeriousDlqin2yrs']
X = data.drop('SeriousDlqin2yrs', axis=1)

把数据划分成训练集和测试集

from sklearn import model_selection
x_tran,x_test,y_tran,y_test=model_selection.train_test_split(X,y,test_size=0.2)
print(x_test.shape)
print(x_tran.shape)

使用logistic regression分类算法进行分类，尝试查sklearn API了解模型参数含义，调整不同的参数。 

from sklearn.linear_model import LogisticRegression
## https://blog.csdn.net/sun_shengyun/article/details/53811483
lr=LogisticRegression(multi_class='ovr',solver='sag',class_weight='balanced')
lr.fit(x_tran,y_tran)
score=lr.score(x_tran,y_tran)
print(score) ##最好的分数是1

这里预测出来的分数为：

0.9323730412572769

在测试集上进行预测，计算准确度 

from sklearn.metrics import accuracy_score
## https://blog.csdn.net/qq_16095417/article/details/79590455
train_score=accuracy_score(y_tran,lr.predict(x_tran))
test_score=lr.score(x_test,y_test)
print('训练集准确率：',train_score)
print('测试集准确率：',test_score)

 

训练集准确率： 0.9323730412572769
测试集准确率： 0.9332719742291763