机器学习-吴恩达-笔记

机器学习

1.线性回归

线性回归是通过已知的数据集来预测未来的值，所有原数据集中有需要特征值$x$和结果值$y$。

假设函数：

​ 单变量特征公式 $h_{\theta }(x)={\theta }_0+{\theta }_{1}x$

​ 多变量特征公式 $h_{\theta }\left(x\right)=X\theta ={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2+...+{\theta }_n{x}_n$
令$\theta$=$$\left(\begin{array}{c}{\theta }_0\\ {\theta }_1\\ ⋮\\ {\theta }_n\end{array}\right)$， $X=\left[\begin{array}{cccc}1& x_1^{(1)}& x_2^{(1)}& ....x_n^{(1)}\\ 1& x_1^{(2)}& x_2^{(2)}& ....x_n^{(2)}\\ ⋮& & & \\ 1& x_1^{(m)}& x_2^{(m)}& ....x_n^{(m)}\end{array}\right]$

损失函数是用于衡量预测值与实际值的偏离程度，即模型预测的错误程度

则以参数θ为多特征函数的代价/损失函数
$J\left(\theta \right)=\frac{1}{2m}\sum _{i=1}^m{\left(h_{\theta }\left(x^{(i)}\right)-y^{(i)}\right)}^2$ = $\frac{1}{2m}\sum _{i=1}^m(X\theta -y{)}^2$ ( $y$为通过特征值得到的结果)

代价函数求导

​ $\frac{dJ\left(\theta \right)}{d{\theta }_j}$=$\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)}-y^{(i)})x_j^{(i)}$ 当$j$=0时,$x_0$=1

接下来是梯度下降求代价函数最小值:

​ repeat until minimal：{

​ ${\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J\left(\theta \right)$ for j=0 to n

​ }

根据代价函数求导，令$\delta$=$\left[\begin{array}{c}\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)}-y^{(i)})x_0^{(i)}\\ \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)}-y^{(i)})x_1^{(i)}\\ ⋮\\ \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)}-y^{(i)})x_n^{(i)}\end{array}\right]$ 则可得$\delta$=$\frac{1}{m}$ $\left[\begin{array}{cccc}1& 1& \dots & 1\\ x_1^{(1)}& x_1^{(2)}& \dots & x_1^{(m)}\\ ⋮& & & \\ x_n^{(1)}& x_n^{(2)}& \dots & x_n^{(m)}\end{array}\right]$$\cdot (X\theta -y)$=$\frac{1}{m}{X}^T\cdot (X\theta -y)$

${\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J\left(\theta \right)$ 可以通过上面的推导变成 $\theta =\theta -\alpha \frac{1}{m}{X}^T\cdot (X\theta -y)$​
repeat until minimal：{

​ $\theta =\theta -\alpha \frac{1}{m}{X}^T\cdot (X\theta -y)$ for j=0 to n

}

维度：$X$（m,n) $y$(n,1) $\theta$(n,1)

1.1 正规方程

上述的梯度下降有可替换方案，则是正规方程。

​ $\theta =(X^T\cdot X{)}^{-1}\cdot X^T\cdot y$

注意：当$(X^T\cdot X{)}^{-1}$不可逆的时候,可考虑$X$中的$x_1\dots$$x_n$中特征值是否有线性相关。

梯度下降	正规方程
缺点: 需要选择学习率a 需要多次迭代 特征值范围相差太大，要特征缩放 优点: 当特征数n很大时，能够工作的很好	优点: 不需要选择学习率a 不需要多次迭代 不需要特征缩放(feature scaling) 缺点; 当特征数n很大时，运算的很慢。因为求解逆矩阵的时间复杂度是O(N^3)

一般情况下，当n<10000，选择正规方程，其次当一些复杂的算法最好选择梯度下降。

2.逻辑回归

逻辑回归是用来解决分类问题，将问题预测值最终回归到0或者1上面。

假设函数：

​ 单变量特征公式 $$h_{\theta }(x)={\theta }_0+{\theta }_{1}x$$

​ 多变量特征公式 $h_{\theta }\left(x\right)=X\theta ={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2+...+{\theta }_n{x}_n$

与线性回归不同，我们需要一个sigmoid函数，作为激活函数，将$h_{\theta }(x)$的预测值回归到0-1的范围中。

g 代表一个常用的逻辑函数（logistic function）为S形函数（Sigmoid function），公式为：$g\left(z\right)=\frac{1}{1+e^{-z}}$
合起来，我们得到逻辑回归模型的假设函数：
$h_{\theta }\left(x\right)=\frac{1}{1+e^{-\theta X}}$ 同理可以写成 $g(h_{\theta }(x))$

Sigmoid function 函数图像：

代价函数：
$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)]$ 这里的$log$是$ln$，相当于以$e$为底。在python中numpy.log()，也是默认以$e$为底。

代价函数求导

​ $\frac{dJ\left(\theta \right)}{d{\theta }_j}$=$\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)}-y^{(i)})x_j^{(i)}$ 当$j$=0时,$x_0$=1

代价函数求导和线性回归的求导是一样的，虽然形式一样，但函数完全不一样。

2.1 正则化

为了解决过拟合的问题，则引入了正则化。

正则化说白了就是在损失函数后面添加一项：

​ $\frac{\lambda }{2m}\sum _{j=1}^n{\theta }_j^2$

则逻辑回归的损失函数变为：$$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$$

线性回归的损失函数变为：$J\left(\theta \right)=\frac{1}{2m}\sum _{i=1}^m{\left(h_{\theta }\left(x^{(i)}\right)-y^{(i)}\right)}^2$ = $\frac{1}{2m}\sum _{i=1}^m(X\theta -y{)}^2+\frac{\lambda }{2m}\sum _{j=1}^n{\theta }_j^2$

对正则化部分求导为：$\frac{\lambda }{m}{\theta }_j$

2.2 线性不可分

对于线性不可分的数据集，因为特征值较少，所以需要特征拟合为更高阶的，然后再进行梯度下降。

这就需要特征映射：特征映射的目的是将输入的两个特征$x1$和 $x2$映射到一个更高维度的特征空间，以支持线性不可分数据的逻辑回归。

例如将两个特征$x1$和 $x2$映射到二维:

​ MapFeature = $\left[\begin{array}{c}1\\ x_1\\ x_2\\ x_1{x}_2\\ x_1^2\\ x_2^2\end{array}\right]$

代码如下：

def feature_mapping(x1,x2,power):
    data = {}
    for i in np.arange(power+1):
        for j in np.arange(i + 1):
            data['F{}{}'.format(i-j,j)] = np.power(x1,i-j) * np.power(x2,j)
    return pd.DataFrame(data)