[人工智能]机器学习对数学模型的简单实践

参考书目：数学教科书，作者：我妻幸长

回归与过度学习

回归与分类

模型（用数学公式表示的定量规则）$Y=f(X)$来捕捉数据的倾向， Y = { y 1 , y 2 , ? ? , y m } Y=\{y_1,y_2,\cdots,y_m\} Y={y1?,y2?,?,ym?}， X = { x 1 , x 2 , ? ? , x n } X=\{x_1,x_2,\cdots,x_n\} X={x1?,x2?,?,xn?}

若此时Y是连续值，则称为回归，若Y是0、1等离散值则称为分类

多项式回归

可以用求和的方式来表示n次多项式
$$f(x)=\sum _{k=0}^n{a}_k{x}^k\text{\hspace{1em}(1-1)}$$
此时$a_0,a_1.?,a_n$是函数的参数

最小二乘法

$$J=\sum _{j=1}^m(f(x_j)?t_j{)}^2\text{\hspace{1em}(1-2)}$$
最小二乘法就是将$J$最小化，求出$f(x)$的参数的方法，其中$t_j$表示每个数据，通过函数的输出与各项数据相减得出差再求平方和，机器学习中常将此结果乘上1/2后作为误差（为了微分时便于处理）

利用梯度下降法最小化误差

综上我们可以得出线性回归多项式的误差公式
$$E=\frac{1}{2}\sum _{j=0}^m(\sum _{k=0}^n{a}_k{x}_j^k?t_j{)}^2$$
即$f(x)$在$x_j$取$x_1,x_2,?,x_m$下对实际值$t_j$的差做平方的1/2，我们使用梯度下降法调整参数$a_k$使$E$最小化。
$$a_i=a_i?\eta \frac{?E}{?a_i}$$
其中$0?i?n$

此时要求偏微分$\frac{?E}{?a_i}$

推导过程
令$$\begin{gathered} u_j=\sum _{k=0}^n{a}_k{x}_j^k?t_j \\ ?\frac{?E}{?a_i}=\frac{?E}{?u_j}\frac{?u_j}{?a_i} \\ =\sum _{j=0}^m{u}_j{x}_j^i=\sum _{j=0}^m(f(x_j)?t_j)x_j^i \end{gathered}$$
$$\sum _{j=0}^m{u}_j{x}_j^i=\sum _{j=0}^m(f(x_j)?t_j)x_j^i\text{\hspace{1em}(1-3)}$$

#实验数据的产生
#该数据由sin函数加上噪声
import numpy as np
import matplotlib.pyplot as plt
X=np.linspace(-np.pi,np.pi)

T=np.sin(X)
#画出添加噪声前的图像sin()
plt.plot(X,T)
T+=0.4*np.random.randn(len(X))#len是取X的长度50，生成50个正态分布随机数
plt.scatter(X,T)
plt.show()
X/=np.pi#为方便收敛X限定在-1到1之间，若大于1或小于-1由于x^i可能会很大导致E也很大使得收敛过慢

#实现多项式回归
eta=0.01 #学习系数
#---多项式实现---
def polynomial(x,params):
    poly=0
    for i in range(len(params)):
        poly+=params[i]*x**i
    return poly
#求个参数的偏微分（斜率）
def grad_params(X,T,params):
    grad_ps=np.zeros(len(params))
    for i in range(len(params)):
        #偏微分公式
        for j in range(len(X)):
            grad_ps[i]+=(polynomial(X[j],params)-T[j])*X[j]**i
    return grad_ps
#学习
#degree多项式次数，epoch重复次数
def fit(X,T,degree,epoch):
    #设定参数初始值
    params=np.random.randn(degree+1)#注i次多项式有i+1个参数
    #因为x为小数次数越高的参数初始值要越大
    for i in range(len(params)):
        params[i]*=2**i#用2^i使参数初值增大一些
    for i in range(epoch):
        #这里python方便的数组操作省去了一个for循环，将所有参数都一起更新
        params-=eta*grad_params(X,T,params)
    return params
#显示结果
degrees=[1,2,3,4,5,6]#这里测试3个多项式次数分别为1，3，6
for degree in degrees:
    print("---"+str(degree)+"次多项式---")
    params=fit(X,T,degree,1000)#训练1000次后获取训练后的参数
    print(params)
    #从训练好的多项式中得到Y轴数组
    Y=polynomial(X,params)
    plt.scatter(X,T)
    plt.plot(X,Y,linestyle="dashed")
    plt.show()

---1次多项式---
[0.0342224 0.9152711]

---2次多项式---
[0.03000374 0.9152711  0.01215966]

---3次多项式---
[ 0.03000374  2.79869276  0.01215966 -3.01761218]

---4次多项式---
[ 0.31493447  2.79964178 -2.5431648  -3.01905297  2.78197178]

---5次多项式---
[-1.79404683e-02 -3.11067261e+00  3.78078310e-01  2.18767750e+01
 -3.66761172e-01 -2.08018029e+01]

---6次多项式---
[ -0.50409283   3.92572196  11.29919126  -7.97066592 -33.29678186
   4.24010247  23.80830819]

可以看出1次多项式只能大致把握数据趋势，3次多项式函数形状与sin()函数接近，6次多项式发生了过拟合。

过拟合：模型过于复杂等原因而过度拟合数据和适应数据，从而没有抓住数据的本质降低了模型预测未知数据的性能，如6次多项式的预测结果与sin()函数想差较大，应当避免这种问题的发生。

分类与逻辑回归

以0、1等离散值为输出的机器学习模型来捕捉数据的倾向被称为分类

逻辑回归将输入分为0、1二值，例如肿瘤预测根据患者的一些症状表现用$x_i$表示，1为有症状，0为无症状来作为输入对肿瘤进行预测。

逻辑回归中被用于分类的公式：
$$y=\frac{1}{1+\exp (?(\sum _{k=1}^n{a}_k{x}_k+b\left)\right)}\text{\hspace{1em}(2-1)}$$
令$u= \sum\limits_{k=1}^na_kx_k+b $则上式可写为
$$y=\frac{1}{1+\exp (?u)}\text{\hspace{1em}(2-2)}$$
上式为sigmoid函数，有在$(0,1)$之间连续输出的特性，可以解释为概率，可以使用交叉熵来表示误差

参数优化

使用梯度下降法
$$\begin{gathered} a_i=a_i?\eta \frac{?E}{?a_i} \\ b=b?\eta \frac{?E}{?b}\text{\hspace{1em}(2-3)} \end{gathered}$$
交叉熵处理误差
$$E=?\sum _{j=1}^m(t_j\log y_j+(1?t_j)\log (1?y_j))\text{\hspace{1em}(2-4)}$$
$$y_j=\frac{1}{1+\exp (?(\sum _{k=1}^n{a}_k{x}_k+b\left)\right)}\text{\hspace{1em}(2-5)}$$
计算偏微分，过程略，计算得：
$$\frac{?E}{?a_i}=\sum _{j=1}^m(y_j?t_j)x_{ji}\text{\hspace{1em}(2-6)}$$
$$\frac{?E}{?b}=\sum _{j=1}^m(y_j?t_j)\text{\hspace{1em}(2-7)}$$

生成数据

import numpy as np
import matplotlib.pyplot as plt
n_data=500#数据的数量
X=np.zeros((n_data,2))#500行2列的矩阵，第一列为坐标x，第二列为坐标y，也可看做是两个维度x1，x2
T=np.zeros((n_data))#正确的数据标签，用0、1表示
for i in range(n_data):
    #随机设定x、y坐标
    x_rand=np.random.rand()
    y_rand=np.random.rand()
    X[i,0]=x_rand
    X[i,1]=y_rand
    #x比y大即右下角的标签设为1
    #使用正态分布使边界模糊
    if x_rand>y_rand+0.2*np.random.randn():
        T[i]=1
plt.scatter(X[:,0],X[:,1],c=T)#c=1的上色，参数c根据传入的数值0-1变色
plt.colorbar()
plt.show()

实现逻辑回归

#学习系数
eta=0.01
#计算分类，y
def classify(x,a_params,b_param):
    #计算∑aixi+b
    u=np.dot(x,a_params)+b_param
    return 1/(1+np.exp(-u))
#计算交叉熵误差
def corss_entropy(Y,T):
    delta=1e-7#极小值防止出现log0
    return -np.sum(T*np.log(Y+delta)+(1-T)*np.log(1-Y+delta))

#微分计算
def grad_a_params(X,T,a_params,b_param):
    grad_a=np.zeros(len(a_params))
    for i in range(len(a_params)):#a_params=2，公式(2-6)
        for j in range(len(X)):#len(X)=500
            grad_a[i]+=(classify(X[j],a_params,b_param)-T[j])*X[j,i]#X[j]是传入第j行的两个维度
    return grad_a
def grad_b_param(X,T,a_params,b_param):
    grad_b=0
    for i in range(len(X)):
        grad_b+=(classify(X[i],a_params,b_param)-T[i])
    return grad_b
#学习
#记录误差
error_x=[]
error_y=[]
def fit(X,T,dim,epoch):
    #dim是维度，epoch是训练次数
    a_params=np.random.randn(dim)
    b_param=np.random.randn()
    #更新参数
    for i in range(epoch):
        grad_a=grad_a_params(X,T,a_params,b_param)
        grad_b=grad_b_param(X,T,a_params,b_param)
        a_params-=eta*grad_a
        b_param-=eta*grad_b
        Y=classify(X,a_params,b_param)
        error_x.append(i)
        error_y.append(corss_entropy(Y,T))
    return (a_params,b_param)

a_params,b_param=fit(X,T,2,200)        
Y=classify(X,a_params,b_param)

#使用模型分类
result_x=[]#x坐标
result_y=[]#y坐标
result_z=[]#概率
for i in range(len(Y)):
    result_x.append(X[i, 0])
    result_y.append(X[i, 1])
    result_z.append(Y[i])
print("---概率分布---")
plt.scatter(result_x,result_y,c=result_z)
plt.colorbar()
plt.show()
#误差变化
print("---误差的变化---")
plt.plot(error_x,error_y)
plt.xlabel("Epoch",size=14)
plt.ylabel("Cross entropy",size=14)
plt.show()

---概率分布---

---误差的变化---

小结

1. 
   
2. 数据分布是根据随机生成的0-1之间的坐标，再通过正态分布模糊边界
3. 
   
4. 使用了sigmoid函数和交叉熵得到预测误差E
5. 
   
6. 由于数据只有x和y轴维度为2维所以$u=a_0{x}_0+a_1{x}_1+b$通过上面的classify函数实现
7. 
   
8. 将误差E求偏微分得到$\frac{?E}{?a_i}$和$\frac{?E}{?b}$再根据梯度下降优化参数降低误差
9. 
   
10. 每次优化参数后记录误差
11. 
    
12. 根据训练好的参数进行预测分类，用所得概率值使颜色渐变画出分类图像，并画出误差改变的图像
13. 
    

神经网络概述

人工智能、机器学习、神经网络

列举几种与人工智能相关的概念

• 
  
• 机器学习：计算机算法通过经验进行学习并自动改进，做出判断。
• 
  
• 遗传算法：模仿进化论，通过组合交叉和变异演算计算模型。
• 
  
• 群智能：遵循简单规则行动的个体的集合体，以集团形式采取高级的行动。
• 
  
• 专家系统：模仿人类专家的思维，可以提出基于知识的建议。
• 
  
• 模糊控制：通过模糊控制规则采取接近人类经验的控制行为。主要用于家电等。
• 
  
• 强化学习：智能体可以通过反复试验试错，学习如何在环境中实现价值最大化。
• 
  
• 决策树：通过训练树形结构，可以将数据进行树枝状分类。通过这种方法可以更好地对数据进行预测。
• 
  
• 支持向量机：训练超平面（平面的扩张），以此来对数据进行分类
• 
  
• $K$临近：使用最相邻的$K$个点，通过多数决定进行分类。是最简单的机器学习算法
• 
  
• 神经网络：以大脑的神经网格为原型构思出的模型，是近年来备受关注的深度学习的基础
• 
  

神经元模型

在单一神经元中，对多个输入乘以权重并相加然后施加偏置，最后用激活函数进行处理。通过调整每个输入的权重并改变偏置就可以调整进入激活函数的值，偏置可以用来表示神经元灵敏度的值，激活函数就是能令神经元兴奋的函数，根据输入大小决定神经元兴奋程度即是输出。

神经元网络

学习机制

单一神经元的学习

神经网络通常由具有多个神经元的层组成，为了方便学习使用单一神经元并进行简单的学习。


只有一个输入的神经元，输入为x坐标输出为y坐标。

正向传播表达式

$$\begin{gathered} u=wx+b \\ y=f(u)\text{\hspace{1em}(3-1)} \end{gathered}$$
其中$w$是权重，$b$是偏置，$f(x)$是激活函数通过该函数得到$y$这里使用sigmoid函数，因此：
$$y=\frac{1}{1+\exp (?(wx+b))}$$
误差（这里处理回归最小二乘，若是处理分类则使用交叉熵）：
$$E=\frac{1}{2}\sum _{j=1}^m(y_j?t_j{)}^2$$
由于是单一神经元所以可以写为
$$\frac{1}{2}(y?t{)}^2\text{\hspace{1em}(3-2)}$$
每一次正向传播都求出误差并更新参数，这种学习称为在线学习，若是利用误差的总和对参数进行更新的学习被称为批处理学习。

#准备正确数据
#学习sin()曲线，由于只有一个神经元只能学习曲线的一部分所以只使用-pi/2到pi/2之间的曲线，又sigmoid只能输出0-1要将正确的值调整到这个范围内
import numpy as np
import matplotlib.pyplot as plt
X=np.linspace(-np.pi/2,np.pi/2)
T=(np.sin(X)+1)/2#使正确值都在0-1之间
plt.plot(X,T)
plt.xlabel("x",size=14)
plt.ylabel("y",size=14)
plt.grid()
plt.show()

权重与偏置的更新

推导过程略$$\begin{gathered} w=w?\eta \frac{?E}{?w}=x\delta \\ b=b?\eta \frac{?E}{?b}=\delta \\ \delta =(y?t)(1?y)y\text{\hspace{1em}(3-3)} \end{gathered}$$

列出公式

$$u=xw+b\text{\hspace{1em}(3-4)}$$
$$y=f(u)\text{\hspace{1em}(3-5)}$$
$$w=w?\eta \frac{?E}{?w}=x\delta \text{\hspace{1em}(3-6)}$$
$$b=b?\eta \frac{?E}{?b}=\delta \text{\hspace{1em}(3-7)}$$
$$\delta =(y?t)(1?y)y\text{\hspace{1em}(3-8)}$$

输入与正确数据

import numpy as np
import matplotlib.pyplot as plt
X=np.linspace(-np.pi/2,np.pi/2)#输入
T=(np.sin(X)+1)/2#正确数据
n_data=len(T)

正向传播和反向传播

#正向传播
def forward(x,w,b):
    u=x*w+b
    y=1/(1+np.exp(-u))
    return y
#反向传播，优化参数
def backward(x,y,t):
    delta=(y-t)*(1-y)*y
    grad_w=x*delta
    grad_b=delta
    return (grad_w,grad_b)
#结果显示
def show_output(X,Y,T,epoch):
    plt.plot(X,T,linestyle="dashed")#虚线画出正确数据
    plt.scatter(X,Y,marker="+")#散点图显示输出
    plt.xlabel("x",size=14)
    plt.ylabel("y",size=14)
    plt.grid()
    plt.show()
    print("Epoch:",epoch)
    print("Error:",1/2*np.sum((Y-T)**2))#误差

    
#---梯度下降学习---
eta=0.1
epoch =100
#初值
w=0.2
b=-0.2
for i in range(epoch):
    if i<10:#仅显示前10期的学习进度
        Y=forward(X,w,b)
        show_output(X,Y,T,i)
    #每一个epoch都使用随机抽取样本进行反向传播训练
    idx_rand=np.arange(n_data)#从0开始到n_data-1的整数
    np.random.shuffle(idx_rand)#打乱
    for j in idx_rand:#随机样本
        x=X[j]
        t=T[j]
        y=forward(X,w,b)
        grad_w,grad_b=backward(x,y,t)#反向传播
        w-=eta*grad_w
        b-=eta*grad_b
Y=forward(X,w,b)#显示最终结果
show_output(X,Y,T,epoch)

Epoch: 0
Error: 2.4930145826202508

Epoch: 1
Error: 1.577394653470916

Epoch: 2
Error: 1.0861769315491316

Epoch: 3
Error: 0.8038342421209601

省略剩余的epoch

Epoch: 100
Error: 0.11897860684226028

迈向深度学习

多层神经网络的正向传播和反向传播

正向传播：

一个神经元可以有多个输入$$\begin{gathered} u=\sum _{k=1}^n{w}_k{x}_k+b \\ y=f(u) \end{gathered}$$
反向传播：

$$\delta =\frac{?E}{?u}=\frac{?E}{?y}\frac{?y}{?u}$$
同单一神经元$$\begin{gathered} \frac{?E}{?w_i}=x\delta \\ \frac{?E}{?b}=\delta \end{gathered}$$
对于$\frac{?y}{?u}$可以使用该层的激活函数求得

而对中间层求$\frac{?E}{?y}$因为这一层的y是下一层的输入所以需要知道下一层（接近输出的层）的信息
$$\frac{?E}{?y}=\sum _{j=1}^m\frac{?E}{?u_j^{(nl)}}\frac{?u_j^{(nl)}}{?y}$$
$nl$代表是该层下一层的变量，本质上还是链式求导法则E为输出层的误差由变量$u^{(nl)}$组成而$u^{(nl)}$又由上一层的输出y作为$u^{(nl)}$的输入变量所以可以通过链式求导得出中间层的偏微分。

上面的$\frac{?E}{?u_j^{(nl)}}$可以由$\delta$表示
$${\delta }_j^{nl}=\frac{?E}{?u_j^{(nl)}}$$
又$\frac{?u_j^{(nl)}}{?y}=w_j^{nl}{w}_j^{(nl)}$是y作为下一层输入对y叠加的权重，所以：
$$\frac{?E}{?y}=\sum _{j=1}^m{\delta }_j^{(nl)}{w}_j^{(nl)}$$
通过这种方式依次从输出层到各级中间层最后到输入层更新参数，这种反向传播算法也称为误差反向传播法，此外可以通过矩阵同时对层内所有神经元进行处理。