【机器学习】逻辑回归与正则化

本文记录线性回归的一般步骤，并不会详细介绍原理。
视频教程: 第七章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\ge 0$，即$x_1+x_2\ge 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 _{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 _{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 _{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 _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2+\lambda \sum _{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 _{i=1}^m[({(h_{\theta }(x^{(i)})-y^{(i)})}^2+\lambda \sum _{j=1}^n{\theta }_j^2)]$
对上面的算法中$j=1,2,...,n$ 时的更新式子进行调整可得：
${\theta }_j:={\theta }_j(1-a\frac{\lambda }{m})-a\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{\left(i\right)}$
注意: ${\theta }_0$ 不需要加入正则项。

正规方程

正则化的逻辑回归模型

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

$J\left(\theta \right)=\frac{1}{m}\sum _{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 _{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