1. 统计学的三要素

  1. 模型 - 在监督学习过程中,模型就是所要学习的条件概率分布或决策函数。
    • 决策函数$$\mathscr{F}=\{f|\pmb{Y}=f(\pmb{X})\}$$$$\mathscr{F}=\{f|\pmb{Y}=f_{\theta}(\pmb{X}),\theta \in \pmb{R}^n\}$$
    • 概率分布$$\mathscr{F}=\{P|P(\pmb{Y}|\pmb{X})\}$$$$\mathscr{F}=\{P|P_{\theta}(\pmb{Y}|\pmb{X}),\theta \in \pmb{R}^n\}$$
  2. 策略 - 从假设空间中选取最优模型的准则
    • 常用的损失函数(0-1 loss function)
      • 0-1损失函数$$L(Y,f(X))=\begin{cases} 1,\quad Y \neq f(X) \\ 0, \quad Y = f(x)\end{cases}$$
      • 平方损失函数(quadratic loss function)$$L(Y, f(X))=(Y-f(X))^2$$
      • 绝对损失函数(absolute loss function)$$L(Y,f(X))=\big{|}Y-f(X)\big{|}$$
      • 对数损失函数(logarithmic loss function)$$L(Y,f(X))=-logP(Y|X)$$
    • 风险函数/损失函数
      • 期望风险(expected risk)$$R_{exp}(f)=E_p[L(Y,f(X))]=\int_{\mathcal{x} \times \mathcal{y}}L(y,f(x))P(x,y)\;\mathrm{d}x$$
      • 经验风险(empirical risk)$$R_{emp}(f)=\frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i}))$$
      • 经验风险最小化(empirical risk minimization)$$\min_{f \in \mathscr{F}}\frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i}))$$
      • 结构风险(structural risk)$$R_{srm}(f)=\frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i}))+\lambda J(f)$$
      • 结构风险最小化(structural risk minimization)$$\min_{f \in \mathscr{F}} \frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i}))+\lambda J(f)$$
    • 风险函数最小化的两个例子
      • 极大似然估计(maximum likelihood estimization):当模型是条件概率分布,损失函数是对数损失函数,经验风险最小化等价于极大似然估计
      • 最大后验概率(maximum posterior probability):当模型是条件概率分布,损失函数时对数损失函数,模型复杂度由模型的先验概率表示,结构风险最小化等价与最大后验概率
  3. 算法 - 学习模型的具体的计算方法

2. 交叉验证

  1. 简单交叉验证 - 随机的将数据分成两份,一份训练,一份测试
  2. S-折交叉验证 - 随机的将数据均分成为S份,利用S-1份训练,剩下1份测试,重复S次
  3. 留一交叉验证 - 时S-折交叉验证的特殊情况,S=N

3. 感知机(perceptron)

  1. 模型$$f(x)=sign(w \cdot x + b)$$求解$w$和$b$
  2. 策略
    • 误分类点的总数(不好计算,一般不用)
    • 误分类点到超平面的距离$$L(w,b)=\sum_{x_{i} \in M}{\frac{1}{\lVert w \rVert}}|w \cdot x_{i} + b|$$$M$时误分类点的个数。不考虑$\frac{1}{\lVert w \rVert}$,并且考虑$y$值,则有$$L(w,b)=-\sum_{x_{i} \in M}{y_{i}(w \cdot x_{i} + b)}$$
  3. 算法
    • 梯度下降法$$\nabla_{w}L(w,b)=-\sum_{x_{i} \in M}{y_{i} x_{i}}$$ $$\nabla_{b}L(w,b)=-\sum_{x_{i} \in M}{y_i}$$
    • 停止条件:训练集中没有误分类点

In [17]:
#实现好挫啊
def perceptron(points, w=[0,0], b=0, eta=1):
    reset = True
    while(reset):
        for point in points:
            print(point)
            print(point[1] * (w[0] * point[0][0] + w[1] * point[0][1] + b))
            if(point[1] * (w[0] * point[0][0] + w[1] * point[0][1] + b) <= 0):
                w[0] += eta * point[1] * point[0][0]
                w[1] += eta * point[1] * point[0][1]
                b += eta * point[1]
                break
            print(w)
            print(b)
        else:
            reset = False
            
    return (w, b)

print(perceptron([[(3,3), 1],[(4,3), 1],[(1,1), -1]]))


[(3, 3), 1]
0
[(3, 3), 1]
19
[3, 3]
1
[(4, 3), 1]
22
[3, 3]
1
[(1, 1), -1]
-7
[(3, 3), 1]
12
[2, 2]
0
[(4, 3), 1]
14
[2, 2]
0
[(1, 1), -1]
-4
[(3, 3), 1]
5
[1, 1]
-1
[(4, 3), 1]
6
[1, 1]
-1
[(1, 1), -1]
-1
[(3, 3), 1]
-2
[(3, 3), 1]
17
[3, 3]
-1
[(4, 3), 1]
20
[3, 3]
-1
[(1, 1), -1]
-5
[(3, 3), 1]
10
[2, 2]
-2
[(4, 3), 1]
12
[2, 2]
-2
[(1, 1), -1]
-2
[(3, 3), 1]
3
[1, 1]
-3
[(4, 3), 1]
4
[1, 1]
-3
[(1, 1), -1]
1
[1, 1]
-3
([1, 1], -3)