机器学习与集成学习作业4

1.回归问题和分类问题的联系和区别，如何利用回归问题理解分类问题？

分类是预测一个离散标签的任务，回归是预测一个连续数量的任务。

分类和回归也有一些相同的地方：

• 分类算法可能预测到一个连续的值，但是这些连续值对应的是一个类别的概率的形式。
• 回归算法可以预测离散值，但是以整型量的形式预测离散值的。

有些算法既可以用来分类，也可以稍作修改就用来做回归问题，例如决策树和人工神经网络。但是一些算法就不行了——或者说是不太容易用于这两种类型的问题，例如线性回归是用来做回归预测建模的，logistics 回归是用来做分类预测建模的。

重要的是，我们评价分类模型和预测模型的方式是不一样的，例如：

• 分类预测可以使用准确率来评价，而回归问题则不能。
• 回归预测可以使用均方根误差来评价，但是分类问题则不能。

在一些情况中是可以将回归问题转换成分类问题的。例如，被预测的数量是可以被转换成离散数值的范围的。
同样，分类问题也可转换为回归问题。例如，一个标签可以被转换成一个连续的范围。一些算法早已通过为每一个类别预测一个概率，这个概率反过来又可以被扩展到一个特定的数值范围：$quantity=min+probability\ast range$

只是如果分类问题中的类别标签没有自然顺序的关系，那么从分类问题到回归问题的转换也许会导致奇诡的结果或者很差的性能，因为模型可能学到一个并不存在于从输入到连续输出之间的映射函数。

详细可参考：https://www.jiqizhixin.com/articles/2017-12-15-2

2.为什么分类问题的损失函数可以是交叉熵而不是均方误差？

首先回忆二者定义,两者作为损失函数都是可行的。

• 均方误差：$L=(y-y_{pred}{)}^2$
• 交叉熵：$L=-(yln(y_{pred})+(1-y)ln(1-y_{pred}))$

再看看其梯度：

sigmoid函数的一阶导函数在sigmoid函数值接近 0 和 1 的时候是非常小的，故导致在使用最小均方差Loss时，模型参数w会学习的非常慢。而使用交叉熵Loss则没有这个问题。为了更快的学习速度，分类问题一般采用交叉熵损失函数。

3.线性判别分析和逻辑回归在估计参数方面有什么异同点？

• 假设不同。LDA需要假设$X$服从正态分布，LogitsR无此假设。
• 参数估计方式不同。LDA根据样本计算均值和协方差矩阵，然后带入判别式。LogitsR使用极大对数似然估计参数。
• 模型意义不同。LDA属于生成模型，用到样本的先验信息，极大化后验概率，maximizing full log-likelihood。LogitsR属于判别模型，只考虑给定$X$ 时的条件概率，maximizing conditional log-likelihood。LogitsR概率等价于每个类别具有相同先验概率时的贝叶斯后验概率。

从形式上看LDA和LogitsR的log-ratio具有相同的形式。

4.尝试从0推导svm：

在支持向量机中, 我们用间隔 (margin) 刻画划分超平面与样本之间的距离.。在引入间隔之前, 我们需要先知道如何计算空间中点到平面的距离。$R^d$ 空间中某点 $p\in R^d$ 到超平面 $w^{\top }x+b=0$的距离为：$$\frac{1}{\Vert \mathbf{w}\Vert }\left|{\mathbf{w}}^{\top }\mathbf{p}+b\right|$$
间隔表示距离划分超平面最近的样本到划分超平面距离的两倍，即
$$\gamma :=2\underset{i}{\min }\frac{1}{\Vert \mathbf{w}\Vert }\left|{\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right|$$

线性支持向量机的目标是找到一组合适的参数(w; b), 使得
$$\begin{array}{rl}\underset{\mathbf{w},b}{\max }\underset{i}{\min }& \frac{2}{\Vert \mathbf{w}\Vert }\left|{\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right|\\ \text{ s.t. }& y_i\left({\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right)>0,i=1,2,\dots ,m\end{array}$$

但是这个问题十分复杂, 难以处理. 为了能在现实中应用, 我们希望能对其做一些简化。由于对 (w; b) 的放缩不影响解, 为了简化优化问题,我们约束 (w; b) 使得：
$$\underset{i}{\min }\left|{\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right|=1$$
因此，我们线性支持向量机的问题可重述为：找到一组合适的参数(w; b), 使得
$$\begin{array}{rl}\underset{w,b}{\min }& \frac{1}{2}{\mathbf{w}}^{\top }\mathbf{w}\\ \text{ s.t. }& y_i\left({\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right)\ge 1,i=1,2,\dots ,m\end{array}$$
写成拉格朗日函数的形式为：
$$\mathcal{L}(\mathbf{w},b,\mathbf{\alpha }):=\frac{1}{2}{\mathbf{w}}^{\top }\mathbf{w}+\sum _{i=1}^m{\alpha }_i\left(1-y_i\left({\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right)\right)$$
线性支持向量机的对偶问题等价于找到一组合适的参数 α, 使得那么其对偶问题为：
$$\begin{array}{rl}\underset{\mathbf{\alpha }}{\max }\underset{\mathbf{w},b}{\min }& \frac{1}{2}{\mathbf{w}}^{\top }\mathbf{w}+\sum _{i=1}^m{\alpha }_i\left(1-y_i\left({\mathbf{w}}^{\top }{\mathbf{x}}_i+b\right)\right)\\ & \\ \text{ s.t. }& {\alpha }_i\ge 0,i=1,2,\dots ,m\end{array}$$
通过求导的方式可得：
$$\begin{array}{r}\frac{\partial \mathcal{L}}{\partial \mathbf{w}}=0\Rightarrow \mathbf{w}=\sum _{i=1}^m{\alpha }_i{y}_i{\mathbf{x}}_i\\ \frac{\partial \mathcal{L}}{\partial b}=0\Rightarrow \sum _{i=1}^m{\alpha }_i{y}_i=0\end{array}$$
将求导后的结果代入对偶问题中可得最后代求的优化问题：
$$\begin{array}{rl}\underset{\alpha }{\min }& \frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^{\top }{\mathbf{x}}_j-\sum _{i=1}^m{\alpha }_i\\ & \\ \text{ s.t. }& \sum _{i=1}^m{\alpha }_i{y}_i=0,\\ & \\ & {\alpha }_i\ge 0,i=1,2,\dots ,m\end{array}$$

5.二次判别分析，线性判别分析，朴素贝叶斯之间的联系和区别

线性判别分析(LDA)和二次判别分析(QDA)是两个经典的分类器。
它们分别构造了线性决策平面和二次决策平面。这些分类器很容易计算得到解析解(指通过严格的公式所求得的解)，其天生具有多分类的特性，且在实践中无需调参。线性判别分析与二次判别分析不同之处在于二次判别分析可以学习二次边界，模型更加灵活。

朴素贝叶斯是个生成模型，朴素贝叶斯分类器是一系列以假设特征之间强独立下运用贝叶斯定理为基础的概率分类器。它假设所有属性相互独立，而LDA和QDA则无此要求。

6使用 python+ numpy实现逻辑回归。

from math import exp

import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets.samples_generator import make_blobs


def sigmoid(num):
    '''

    :param num: 待计算的x
    :return: sigmoid之后的数值
    '''
    if type(num) == int or type(num) == float:
        return 1.0 / (1 + exp(-1 * num))
#     else:
#         raise ValueError, 'only int or float data can compute sigmoid'


class logistic():
    def __init__(self, x, y): 
        if type(x) == type(y) == list:
            self.x = np.array(x)
            self.y = np.array(y)
        elif type(x) == type(y) == np.ndarray:
            self.x = x
            self.y = y
#         else:
#             raise ValueError, 'input data error'

    def sigmoid(self,x):
        '''
        :param x: 输入向量
        :return: 对输入向量整体进行simgoid计算后的向量结果
        '''
        s = np.frompyfunc(lambda x: sigmoid(x), 1, 1)
        #第二个参数为func中的参数个数，第三个参数为func中的返回值的个数
        return s(x)

    def train_with_punish(self, alpha, errors, punish=0.0001):
        '''
        :param alpha: alpha为学习速率
        :param errors: 误差小于多少时停止迭代的阈值
        :param punish: 惩罚系数
        :param times: 最大迭代次数
        :return:
        '''
        self.punish = punish
        dimension = self.x.shape[1]
        self.theta = np.random.random(dimension)
        compute_error = 100000000
        times = 0
        while compute_error > errors:
            res = np.dot(self.x, self.theta)
            delta = self.sigmoid(res) - self.y
            self.theta = self.theta - alpha * np.dot(self.x.T, delta) - punish * self.theta  # 带惩罚的梯度下降方法
            compute_error = np.sum(delta)
            times += 1

    def predict(self, x):
        '''
        :param x: 给入新的未标注的向量
        :return: 按照计算出的参数返回判定的类别
        '''
        x = np.array(x)
        if self.sigmoid(np.dot(x, self.theta)) > 0.5:
            return 1
        else:
            return 0


def test1():
    '''
    用来进行测试和画图，展现效果
    :return:
    '''
    x, y = make_blobs(n_samples=200, centers=2, n_features=2, random_state=0, center_box=(10, 20))
    x1 = []
    y1 = []
    x2 = []
    y2 = []
    for i in range(len(y)):
        if y[i] == 0:
            x1.append(x[i][0])
            y1.append(x[i][1])
        elif y[i] == 1:
            x2.append(x[i][0])
            y2.append(x[i][1])
    # 以上均为处理数据，生成出两类数据
    p = logistic(x, y)
    p.train_with_punish(alpha=0.00001, errors=0.005, punish=0.01)  # 步长是0.00001，最大允许误差是0.005，惩罚系数是0.01
    x_test = np.arange(10, 20, 0.01)
    y_test = (-1 * p.theta[0] / p.theta[1]) * x_test
    plt.plot(x_test, y_test, c='g', label='logistic_line')
    plt.scatter(x1, y1, c='r', label='positive')
    plt.scatter(x2, y2, c='b', label='negative')
    plt.legend(loc=2)
    plt.title('punish value = ' + p.punish.__str__())
    plt.show()


if __name__ == '__main__':
    test1()

7.基本优化算法入门：梯度下降法，牛顿法，拟牛顿法与smo算法等

首先了解一下无约束优化问题。无约束优化问题是众多优化问题中最基本的问题，它对自变量 x 的取值范围不加限制，所以无需考虑 x 的可行性。

• 对于光滑函数，我们可以较容易地利用梯度和海瑟矩阵的信息来设计算法；
• 对于非光滑函数，我们可以利用次梯度来构造迭代格式．

很多无约束优化问题的算法思想可以推广到其他优化问题上，因此掌握如何求解无约束优化问题的方法是设计其他优化算法的基础。

无约束优化问题的优化算法主要分为两大类：线搜索类型的优化算法和信赖域类型的优化算法。它们都是对函数 f (x) 在局部进行近似，但处理近似问题的方式不同。线搜索类型的优化算法根据搜索方向的不同可以分为梯度类算法、次梯度算法、牛顿算法、拟牛顿算法等。

梯度下降法：其本质是仅仅使用函数的一阶导数信息选取下降方向 $d_k$．这其中最基本的算法是梯度下降法，即直接选择负梯度作为下降方向 $d_k$。

对于光滑函数$ f (x)$，在迭代点 $x^k$ 处，我们需要选择一个较为合理的 $d_k$作为下降方向．注意到 $\varphi (\alpha )=f(x^k+\alpha d_k)$ 有泰勒展开：

$$\varphi (\alpha )=f(x^k)+{\alpha }_k\nabla f(x^k{)}^T{d}_k+O({\alpha }^2\Vert d_k{\Vert }^2)$$
根据柯西不等式，当 α 足够小时，取 $d_k=-\nabla f(x^k)$会使得函数下降最快．因此梯度法就是选取 $d_k=-\nabla f(x_k)$ 的算法，它的迭代格式为
$$x^{k+1}=x^k-{\alpha }_k\nabla f(x^k)$$其中步长 ${\alpha }_k$ 的选取可依赖线搜索算法，也可直接选取固定的 ${\alpha }_k$。

牛顿法：牛顿类算法就是利用二阶导数信息来构造迭代格式的算法．由于利用的信息变多，牛顿法的实际表现可以远好于梯度法，但是它对函数 f (x) 的要求也相应变高．

拟牛顿法：它能够在每一步以较小的计算代价生成近似矩阵，并且使用近似矩阵代替海瑟矩阵而产生的迭代序列仍具有超线性收敛的性质。

smo算法：
序列最小化 (SMO) 是一个利用支持向量机自身特性高效的优化算法. SMO 的基本思路是坐标下降。坐标下降的流程如下：