机器学习逻辑回归模型总结——从原理到sklearn实践

最新推荐文章于 2024-06-12 20:59:02 发布

隐形人真忙

最新推荐文章于 2024-06-12 20:59:02 发布

阅读量2w

点赞数 2

分类专栏：机器学习&amp;数据挖掘文章标签：机器学习算法

本文链接：https://blog.csdn.net/u011721501/article/details/49661585

版权

机器学习&数据挖掘专栏收录该内容

2 篇文章 0 订阅

订阅专栏

0x00 基本原理

逻辑回归算法，从名字上看似乎是个回归问题，但实际上逻辑回归是个典型的分类算法。
对于分类问题，一般都是一些离散变量，且y的取值如下：

y \in {0, 1, 2, 3, . . ., n}

$y \in \{0, 1, 2, 3, ..., n\}$ ，显然不能使用线性回归拟合。
以二元分类问题开始讨论，y的取值为“类别1，类别2”，为了表示清楚，这里使用0和1来表示二元分类中的两个类别，即y的取值为：

y∈{0,1} $y \in \{0, 1\}$ 。
和线性回归问题一样，我们规定假设函数为：

hθ(x) $h_\theta(x)$ ，设置取值范围：

0≤hθ(x)≤1 $0 \leq h_\theta(x) \leq 1$ ，因为我们希望算法得出的结果取值非0即1，所以还要设置一个阈值，如果得出的概率大于这个阈值，则假设函数输出1，否则输出0。
在逻辑回归中，实际上对于假设函数，使用了一种逻辑函数的概念，函数如下：

h θ (x) = 1 1 + e - θ T x

$h_\theta(x) = \frac{1}{1+e^{-\theta^Tx}}$
称为S型函数，或者逻辑函数。取值范围为(0,1)，符合我们上面对假设函数的要求。通常，设置阈值为0.5，如果训练样本输入到假设函数中，得到的值大于0.5，则认为分类为1，否则分类为0：

P (y = 0 | x; θ) + P (y = 1 | x; θ) = 1

$P(y=0|x;\theta) + P(y=1|x;\theta) = 1$
相应的，我们的损失函数（Cost Function）为：

J (θ) = 1 m \sum i = 1 m 1 2 (h θ (x (i)) - y (i)) 2

$J(\theta) = \frac{1}{m}\sum_{i=1}^m{\frac{1}{2}(h_\theta(x^{(i)}) - y^{(i)})^2}$
如果这里计算折损的形式还是和线性回归一样平方损失函数：

∑mi=112(hθ(x(i))−y(i))2 $\sum_{i=1}^m{\frac{1}{2}(h_\theta(x^{(i)}) - y^{(i)})^2}$ ，实际上，在求minJ的时候，对于J函数，我们很可能得出的不是凸函数的形式，这样再使用梯度下降算法时，会陷入至局部最优解中，很难找到全局最优解。
所以在计算折损值的时候，逻辑回归中使用了对数损失函数来获得一个凸函数的J，整理得到的最终损失函数形式如下，其中省略了若干数学推导：

我们再次使用梯度下降算法来求出最优的参数向量，梯度下降在逻辑回归中表现如下：

可能有人发现，这不和线性拟合问题中的梯度下降公式一样吗？实际上，由于逻辑回归模型中采用了逻辑函数来表示假设函数，所以这两种模型中的梯度下降表达式是完全不同的两回事儿。
有了梯度下降算法，我们就可以使用训练集来求出最优的参数向量。逻辑回归中，为了消除过度拟合问题，有正则化方法，这里就不再赘述。

0x01 算法实现

根据Andrew Ng所提供的资料，我们依旧选择Octave来实现逻辑回归算法。
首先是sigmoid函数（逻辑函数）的表达：

function g = sigmoid(z)
g = zeros(size(z));
g = 1 ./ (1+exp(-z));
end

Cost Function的实现：

function [J, grad] = costFunction(theta, X, y)
% 初始化
m = length(y);
J = 0;
grad = zeros(size(theta));

% 损失函数的计算
temp = sigmoid(X*theta);
temp = temp(:,size(temp, 2));
J = (1/m) * sum((-y.*log(temp))-((1-y).*log(1-temp))) ;

% 损失函数的导数计算
for i=1:size(theta,1),
  grad(i) = (1/m) * sum((temp - y).*X(:,i));
end;
end

由于资料中所给的不是直接使用梯度下降算法，而是使用了Octave中的优化方法来求最优参数向量，所以只需要返回损失函数J和各个损失函数的导数grad。实际上，如果改成直接使用梯度下降的话，只需要在求grad的过程中，同步更新我们各个参数即可。
预测函数如下，这里一般选择阈值为0.5，所以大于0.5的假设函数返回值，我们就判断类别为1。

function p = predict(theta, X)
m = size(X, 1); 
p = zeros(m, 1);

% 计算类别，使用p向量返回
for i=1:m,
  prop = sigmoid(X(i,:)*theta) ;
  if prop >= 0.5,
    p(i) = 1;
  end;
end;
end;

0x02 算法运行

运行算法，可以看到可视化的决策边界：

0x03 sklearn库实践

清楚了逻辑回归模型的原理，我们使用python进行机器学习演练，使用sklearn机器学习库，可以很方便地进行实践。
数据集为学生的两次考试成绩以及是否通过大学申请，我们用逻辑回归进行分类，以后给出一个样本，输出成功通过大学申请的概率。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.cross_validation import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report 
from sklearn.metrics import precision_recall_curve, roc_curve, auc 

data = pd.read_csv('ex2data1.txt', sep=',', \
    skiprows=[2], names=['score1','score2','result'])
score_data = data.loc[:,['score1','score2']]
result_data = data.result

p = 0
for i in xrange(10):
    x_train, x_test, y_train, y_test = \
        train_test_split(score_data, result_data, test_size = 0.2)
    model = LogisticRegression(C=1e9)
    model.fit(x_train, y_train)
    predict_y = model.predict(x_test)
    p += np.mean(predict_y == y_test)

# 绘制图像
pos_data = data[data.result == 1].loc[:,['score1','score2']]
neg_data = data[data.result == 0].loc[:,['score1','score2']]

h = 0.02
x_min, x_max = score_data.loc[:, ['score1']].min() - .5, score_data.loc[:, ['score1']].max() + .5
y_min, y_max = score_data.loc[:, ['score2']].min() - .5, score_data.loc[:, ['score2']].max() + .5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])

# 绘制边界和散点
Z = Z.reshape(xx.shape)
plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired)
plt.scatter(x=pos_data.score1, y=pos_data.score2, color='black', marker='o')
plt.scatter(x=neg_data.score1, y=neg_data.score2, color='red', marker='*')

plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()

# 模型表现
answer = model.predict_proba(x_test)[:,1]  
precision, recall, thresholds = precision_recall_curve(y_test, answer)      
report = answer > 0.5  
print(classification_report(y_test, report, target_names = ['neg', 'pos']))  
print("average precision:", p/100)

运行结果如下：

画出了决策边界之后，就可以看到我们最后的分类结果。
当然也可以使用precision_call_curve方法自动计算召回率精度等数据：

               precision    recall  f1-score   support

        neg       0.88      0.88      0.88         8
        pos       0.92      0.92      0.92        12

avg / total       0.90      0.90      0.90        20
('average precision:', 0.089999999999999997)

精度达到了90%，模型效果还不错。

0x04 总结

逻辑回归模型实际上是一个典型的监督学习分类算法，配合sklearn库可以很方便的进行逻辑回归处理。前提是要真正理解逻辑回归模型的原理和推导过程。
实战中，机器学习和信息安全结合越来越紧密了，所以这也是我为啥开始学习机器学习的原因，就逻辑回归而言，完全可以用在防爬检测，扫描器检测，恶意URL提取的应用上，实战的前提是了解原理：）

隐形人真忙

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
4
评论
机器学习逻辑回归模型总结——从原理到sklearn实践

0x00 基本原理逻辑回归算法，从名字上看似乎是个回归问题，但实际上逻辑回归是个典型的分类算法。对于分类问题，一般都是一些离散变量，且y的取值如下： y∈{0,1,2,3,...,n}y \in \{0, 1, 2, 3, ..., n\}，显然不能使用线性回归拟合。以二元分类问题开始讨论，y的取值为“类别1，类别2”，为了表示清楚，这里使用0和1来表示二元分类中的两个类别，即y的取值为：
复制链接

扫一扫

专栏目录