lasso正则化逻辑回归模型

本文记录线性回归的一般步骤，并不会详细介绍原理。
视频教程: 第七章Logistic回归和第八章正则化。
笔记-原理介绍、公式推导代码

1. logistic回归

前面介绍过线性回归，线性回归主要是做预测的，而本文介绍的逻辑回归则是做分类，逻辑回归可以处理二分类和多分类问题。

在分类问题中，我们尝试预测的是结果是否属于某一个类（例如正确或错误）。分类问题的例子有：判断一封电子邮件是否是垃圾邮件；判断一次金融交易是否是欺诈；之前我们也谈到了肿瘤分类问题的例子，区别一个肿瘤是恶性的还是良性的。
本文介绍的是二分类的例子，会提供多分类的思路。

在线性回归中我们是直接预测出一个数字，如果我们将输出数据做如下规定：小于0.5就是0类别，大于等于0.5则为1类别，其实这就完成了一个简单的分类。但是线性回归输出的范围太大了，所以这样分类界限不科学。如果能够将线性回归的输出结果映射到[0, 1]这个范围那么用0.5作为界限类划分类别就比较科学。

Sigmoid function

为： $g\left( z \right)=\frac{1}{1+{{e}^{-z}}}$。

这个函数将任意的输出$z$，都转化为$g(z)$, 且 $g(z)$在0-1之间。

python代码实现：

import numpy as np
def sigmoid(z):
   return 1 / (1 + np.exp(-z))

逻辑回归表达式

所以逻辑回归的目标表达式就可以表示为：

2. 判定边界

在逻辑回归中，我们预测：
当${h_\theta}\left( x \right)>=0.5$时，预测 $y=1$。
当${h_\theta}\left( x \right)<0.5$时，预测 $y=0$ 。
所以分类的界限就是${h_\theta}\left( x \right)=0.5$，

根据上面绘制出的 S 形函数图像，我们知道当
$z=0$ 时 $g(z)=0.5$
$z>0$ 时 $g(z)>0.5$
$z<0$ 时 $g(z)<0.5$
又 $z={\theta^{T}}x$ ，即：
${\theta^{T}}x>=0$ 时，预测 $y=1$
${\theta^{T}}x<0$ 时，预测 $y=0$
所以边界就是：${\theta^{T}}x=0$

现在假设我们有一个模型：

并且参数$\theta$ 是向量[-3 1 1]。 则当$-3+{x_1}+{x_2} \geq 0$，即${x_1}+{x_2} \geq 3$时，模型将预测 $y=1$。

我们可以绘制直线${x_1}+{x_2} = 3$，这条线便是我们模型的分界线，将预测为1的区域和预测为 0的区域分隔开。

假使我们的数据呈现这样的分布情况，怎样的模型才能适合呢？

因为需要用曲线才能分隔 $y=0$ 的区域和 $y=1$ 的区域，我们需要二次方特征：${h_\theta}\left( x \right)=g\left( {\theta_0}+{\theta_1}{x_1}+{\theta_{2}}{x_{2}}+{\theta_{3}}x_{1}^{2}+{\theta_{4}}x_{2}^{2} \right)$是[-1 0 0 1 1]，则我们得到的判定边界恰好是圆点在原点且半径为1的圆形。

我们可以用非常复杂的模型来适应非常复杂形状的判定边界。

3. 代价函数

代价函数主要为了选择合适的一组${\theta}$来分类：

线性回归的代价函数为：$J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{\frac{1}{2}{{\left( {h_\theta}\left({x}^{\left( i \right)} \right)-{y}^{\left( i \right)} \right)}^{2}}}$ 。

这里直接使用相同的代价函数会出现非凸函数（non-convexfunction），

这意味着我们的代价函数有许多局部最小值，这将影响梯度下降算法寻找全局最小值。

我们重新定义逻辑回归的代价函数为：

$J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{{Cost}\left( {h_\theta}\left( {x}^{\left( i \right)} \right),{y}^{\left( i \right)} \right)}$，其中(log是以e为底)

将构建的 $Cost\left( {h_\theta}\left( x \right),y \right)$简化如下：

$Cost\left( {h_\theta}\left( x \right),y \right)=-y\times log\left( {h_\theta}\left( x \right) \right)-(1-y)\times log\left( 1-{h_\theta}\left( x \right) \right)$

Python代码实现：

import numpy as np
    
def cost(theta, X, y):
    
  theta = np.matrix(theta)
  X = np.matrix(X)
  y = np.matrix(y)
  first = np.multiply(-y, np.log(sigmoid(X* theta.T))) # log下什么都不写默认是自然对数 
  second = np.multiply((1 - y), np.log(1 - sigmoid(X* theta.T)))
  return np.sum(first - second) / (len(X))

4. 梯度下降

得到这个等式：

${\theta_j}:={\theta_j}-\alpha \frac{1}{m}\sum\limits_{i=1}^{m}{({h_\theta}({{x}^{(i)}})-{{y}^{(i)}}){x_{j}}^{(i)}}$

其中求梯度的代码：

# 梯度下降：求导
def gradient(theta, X, y):
#     '''just 1 batch gradient'''
    return (1 / len(X)) * X.T @ (sigmoid(X @ theta) - y)

5. 多类别分类：一对多

对分类的例子就是当作二分类的来处理，也就是依次取出其中一类作为目标类，剩余的类看作一个类别，这样就转化为二分类问题了，求出该样本属于目标类的概率就行。一共有多少个类别就求多少个目标类的概率就行，最后看哪个类别的概率最大则属于该类。

7. 正则化

正则化主要解决过拟合问题，因为你选择的变量次数越高，拟合程度就会越接好，但是这仅仅体现在训练数据上面，往往这种模型在新数据的作用效果就很差，于是就要尽量避免这样拟合过度的情况，正则化的思路就是对高次项进行惩罚。

一个较为简单的能防止过拟合问题的假设：

$J\left( \theta \right)=\frac{1}{2m}[\sum\limits_{i=1}^{m}{{{({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})}^{2}}+\lambda \sum\limits_{j=1}^{n}{\theta_{j}^{2}}]}$

其中${\lambda }$又称为正则化参数（Regularization Parameter）。
如果选择的正则化参数$\lambda$，导致模型变成 ${h_\theta}\left( x \right)={\theta_{0}}$，也就是上图中红色直线所示的情况，造成欠拟合。

正则化线性回归

正则化线性回归的代价函数为：

梯度下降：

$J\left( \theta \right)=\frac{1}{2m}\sum\limits_{i=1}^{m}{[({{({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})}^{2}}+\lambda \sum\limits_{j=1}^{n}{\theta _{j}^{2}})]}$
对上面的算法中${j=1,2,...,n}$ 时的更新式子进行调整可得：
${\theta_j}:={\theta_j}(1-a\frac{\lambda }{m})-a\frac{1}{m}\sum\limits_{i=1}^{m}{({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})x_{j}^{\left( i \right)}}$
注意: ${\theta_0}$

正规方程

正则化的逻辑回归模型

自己计算导数同样对于逻辑回归，我们也给代价函数增加一个正则化的表达式，得到代价函数：

$J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{[-{{y}^{(i)}}\log \left( {h_\theta}\left( {{x}^{(i)}} \right) \right)-\left( 1-{{y}^{(i)}} \right)\log \left( 1-{h_\theta}\left( {{x}^{(i)}} \right) \right)]}+\frac{\lambda }{2m}\sum\limits_{j=1}^{n}{\theta _{j}^{2}}$

Python代码：

import numpy as np

def costReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y, np.log(sigmoid(X*theta.T)))
    second = np.multiply((1 - y), np.log(1 - sigmoid(X*theta.T)))
    reg = (learningRate / (2 * len(X))* np.sum(np.power(theta[:,1:theta.shape[1]],2))
    return np.sum(first - second) / (len(X)) + reg