发表于
字数统计: | 阅读时长 ≈

OpenCV：二值化操作cv2.threshold函数

(一)简单阈值

简单阈值当然是最简单，选取一个全局阈值，然后就把整幅图像分成了非黑即白的二值图像了。函数为cv2.threshold()
这个函数有四个参数，第一个原图像，第二个进行分类的阈值，第三个是高于（低于）阈值时赋予的新值，第四个是一个方法选择参数，常用的有：
• cv2.THRESH_BINARY（黑白二值）
• cv2.THRESH_BINARY_INV（黑白二值反转）
• cv2.THRESH_TRUNC （得到的图像为多像素值）
• cv2.THRESH_TOZERO
• cv2.THRESH_TOZERO_INV
该函数有两个返回值，第一个ret（得到的阈值值（在后面一个方法中会用到）），第二个就是阈值化后的图像。
一个实例如下：

1
2
3
4
5
import cv2
import matplotlib as mpt
image=cv2.imread("h.jpg",cv2.IMREAD_UNCHANGED)
cv2.imshow("frame",image)
cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
gray=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
ret,thresh1 = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
ret,thresh2 = cv2.threshold(gray,127,255,cv2.THRESH_BINARY_INV)
ret,thresh3 = cv2.threshold(gray,127,255,cv2.THRESH_TRUNC)
ret,thresh4 = cv2.threshold(gray,127,255,cv2.THRESH_TOZERO)
ret,thresh5 = cv2.threshold(gray,127,255,cv2.THRESH_TOZERO_INV)

titles = ['img','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
images = [image,thresh1,thresh2,thresh3,thresh4,thresh5]
for i in range(6):
    mpt.subplot(2,3,i+1),mpt.imshow(images[i],'gray')
    mpt.title(titles[i])
    mpt.xticks([]),mpt.yticks([])
mpt.show()

（二）自适应阈值

前面看到简单阈值是一种全局性的阈值，只需要规定一个阈值值，整个图像都和这个阈值比较。而自适应阈值可以看成一种局部性的阈值，通过规定一个区域大小，比较这个点与区域大小里面像素点的平均值（或者其他特征）的大小关系确定这个像素点是属于黑或者白（如果是二值情况）。使用的函数为：cv2.adaptiveThreshold（）
该函数需要填6个参数：

  • 第一个原始图像

  • 第二个像素值上限

  • 第三个自适应方法Adaptive Method:
    —cv2.ADAPTIVE_THRESH_MEAN_C：领域内均值
    —cv2.ADAPTIVE_THRESH_GAUSSIAN_C ：领域内像素点加权和，权 重为一个高斯窗口

  • 第四个值的赋值方法：只有cv2.THRESH_BINARY 和cv2.THRESH_BINARY_INV

  • 第五个Block size:规定领域大小（一个正方形的领域）

  • 第六个常数C，阈值等于均值或者加权值减去这个常数（为0相当于阈值 就是求得领域内均值或者加权值）
    这种方法理论上得到的效果更好，相当于在动态自适应的调整属于自己像素点的阈值，而不是整幅图像都用一个阈值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import cv2
    import matplotlib.pyplot as plt

    img=cv2.imread("h.jpg")
    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    #全局阈值
    ret,th1=cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
    #自适应阈值
    th2=cv2.adaptiveThreshold(gray,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2)
    th3=cv2.adaptiveThreshold(gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
    images=[gray,th1,th2,th3]
    plt.figure()
    for i in range(4):
        plt.subplot(2,2,i+1),plt.imshow(images[i],'gray')
    plt.show()

(三)Otsu’s二值化

有的图像可能阈值不是127得到的效果更好。那么这里我们需要算法自己去寻找到一个阈值，而Otsu’s就可以自己找到一个认为最好的阈值。并且Otsu’s非常适合于图像灰度直方图(灰度直方图是反映一幅图像中各灰度级像素出现的频率与灰度级的关系，以灰度级为横坐标，频率为纵坐标，绘制频率同灰度级的关系图像就是一幅灰度图像的直方图)具有双峰的情况，他会在双峰之间找到一个值作为阈值，对于非双峰图像，可能并不是很好用。那么经过Otsu’s得到的那个阈值就是函数cv2.threshold的第一个参数了。因为Otsu’s方法会产生一个阈值，那么函数cv2.threshold的的第二个参数（设置阈值）就是0了，并且在cv2.threshold的方法参数中还得加上语句cv2.THRESH_OTSU。图像的灰度统计图中可以明显看出只有两个波峰就是双峰图像，比如下面一个图的灰度直方图就可以是双峰图：

绘制灰度直方图：

cv2
1
2
3
4
5
6
import matplotlib.pyplot as plt
import numpy as np

img=cv2.imread("h.jpg")
plt.hist(img.ravel(),256)
plt.show()

这里所用的实例不具有明显的双峰，所以可能效果不好

1
2
3
4
5
6
7
8
9
10
11
12
13
import cv2
import matplotlib.pyplot as plt

img=cv2.imread("h.jpg")
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#简单滤波
ret1,th1=cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
#Otsu 滤波
ret2,th2 = cv2.threshold(gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
plt.figure()
plt.subplot(221),plt.imshow(gray,'gray')
plt.subplot(223),plt.imshow(th1,'gray')
plt.subplot(224),plt.imshow(th2,'gray')

发表于
字数统计: | 阅读时长 ≈

SVM算法补充(一): 核函数

1.名词

  • 分割超平面

  • 支持向量：离分割超平面最近的点

  • 间距:支持向量到分割超平面的距离的两倍

原理：找到一个分割超平面。将数据正确分类，并且间距最大。

2.计算间距

  1. 在二维空间既是点到直线的距离
  2. 在高维空间中，使用直线方程：距离相应的表示为：

由于支持向量在直线 W^Tx+b=-1和W^Tx+b=1 上，所以带入可得

为了使得距离最大，只需要找到合适的参数w和b,使得最大即可。 ||w|| 就是向量w的L2范数。使用分割超平面可以解决分类问题。求解SVM算法，就是在满足约束条件下求w的L2范数的最小值。

3.松弛系数

针对现行不可分的数据集，上面的方法就不能用了。解决这个问题的办法就是引入一个参数ϵ，称为松弛系数。然后把优化的目标函数变为,m是数据集的个数，R为算法参数，其约束条件变为:，可以把ε理解为样本x(i)违反一大间距规则的程度。针对大多数满足约束条件的样本ε=0。而对部分违反最大间距规则的样本ε>0。参数R则表示对违反约束的样本的”惩罚”。R越大对违反约束的点“惩罚力度”越大反之越小 。这样模型就会倾向于允许部分点违反最大间距规则。可以纠正过拟合问题

核函数

核函数是特征转换函数。

（1）最基础的核函数

间距最大是我们的优化目标。真确地对数据分类是约束条件。即在满足约束条件y(i)(wTx(i)+b)≥1的前提下，求解||w||^2的最小值。
使用拉格朗日乘子法：

对w和b求骗到，用拉格朗日法解得:

对这个公式求解最小值，求出的ai大多数是0，因为只有支持向量所对应的样本才决定了间隙的大小，引入核函数：

L里的x(i)^Tx(j)部分，其中x(i)是一个特征向量，所以x(i)^Tx(j)是一个数值，就是两个输入特征向量的内积。预测函数为：预测函数中也包含x(i)^Tx(j),引入K(x^(i),x(j))=x(i)^Tx(j)作为核函数，白哦是两个向量的相似性，如向量垂直时，就表示两个向量线性无关，值为0，引入核函数后预测函数变为：

(2)相似性函数

对无法进行线性分割的样本集，可以使用一定的规则将样本映射到更高纬度的空间，然后找出超平面。核函数的引入就是为了实现这种映射，联想利用多项式解决线性回归欠拟合问题的方法。如果输入特征是一维的[x1]变量，我们把它变成二维的一个方法是把输入特征转化为[x1,2x1 ^2]，定义这种特征映射的函数就称之为相似性函数Φ(x)。这样在原来低维度计算相似性的运算x(i)^Tx(j)，就可以转换为高纬度空间里进行相似性运算Φ(x(i))^TΦ(x(i))。

(3)常用的核函数

一般有两种：多项式核函数和高斯核函数。

1.多项式核函数

2.高斯核函数

如果输入的特征是一维的标量，那么高斯核函数对应的形状就是一个反钟形的曲线，其参数σσ控制反钟形的宽度。由K(x(i),x(j))=Φ(x(i))TΦ(x(i))，经过合适的数学变换，可得高斯核函数对应的特征转换函数为：

前面无限多项的累加器，其物理意义就是把特征向量转换到无限多维向量空间里，即高斯函数可以吧输入特征扩展到无限多维空间里。公式的推导公式会用到泰勒公式。

其中K(x(i),x(j))是高斯核函数，ai只在支持向量对应的样本出不为0.由此可知，预测函数时中心点在支持向量机处的高斯函数的线性组合，其线性组合的系数为aiy(i)。因此，高斯核函数也称为RBF核函数，即反钟形函数的线性组合。

(4)核函数的对比(摘自网络)

1、线性核函数：这是最简单的核函数，它直接计算两个输入特征向量的内积。

  • 优点：简单高效，结果易解释，总能生成一个最简洁的线性分割超平面
  • 缺点：只适用线性可分的数据集

2、多项式核函数：通过多项式来作为特征映射函数

  • 优点：可以拟合出复杂的分割超平面。
  • 缺点：参数太多。有γ,c,nγ,c,n三个参数要选择，选择起来比较困难；另外多项式的阶数不宜太高否则会给模型求解带来困难。

3、高斯核函数：

  • 优点：可以把特征映射到无限多维，并且没有多项式计算那么困难，参数也比较好选择。
  • 缺点：不容易解释，计算速度比较慢，容易过拟合。

（5）核函数的选择

1、最一般的选择原则是针对数据量很大的时候，可以选择复杂一点的模型。虽然复杂模型容易过拟合，但由于数据量很大，可以有效弥补过拟合问题。如果数据集较小选择简单点的模型，否则很容易过拟合，此时特别要注意模型是否欠拟合，如果欠拟合可以增加多项式纠正欠拟合。

2、根据样本量mm和特征量nn进行选择：

  • 特征相比样本较大（如m=10～1000，n=10000）：选逻辑回归或者线性函数SVM
  • 特征较少，样本量中（如m=10～10000，n=1～1000）：选择高斯SVM
  • 特征量少，样本多（如m=50000+，n=1~1000)：选多项式或高斯SVM

发表于
字数统计: | 阅读时长 ≈

AdaBoost算法流程与优化

1.AdaBoost分类问题的损失函数优化
1
2
AdaBoost的弱学习器权重系数公式和样本权重更新公式，可以从AdaBoost的损失函数推导出来。
AdaBoost算法是模型为加法模型、损失函数为指数函数、学习算法为前向分步算法时的二类分类学习方法。 模型为加法模型很好理解，最终的强分类器是若干个弱分类器加权平均得到的。 前向分步学习算法也好理解，算法是通过一轮轮的弱学习器学习，利用前一个弱学习器的结果来更新后一个弱学习器的训练集权重，即第k-1轮的强学习器为

1
第k轮学习器为：

1
可以得到

可以看出强学习器时通过前向学习算法一步步得到的。

AdaBoost损失函数为指数函数，定义损失函数为：

利用前向分布学习算法的关系可以得到：

令Wki=exp(-YiFk-1(x)),他的值不依赖于α,G，因此与最小化无关，仅仅依赖于fk-1(x)，随每一轮迭代而改变。将这个式子代入损失函数，损失函数转化为

发表于
字数统计: | 阅读时长 ≈

AdaBoost算法补充

1.AdaBoost的回归问题

此处以AdaBoost算法为准

1.误差率

2.弱学习器的权重系数

3.更新权重

第k+1个弱学习器的样本集权重系数为

Z_K时规范化因子:

最终的强回归器为：

2.AdaBoost算法的正则化

为防止AdaBoost过拟合，通常会加入正则化项，这个正则化项通常称为步长，定义为ν，对于前面弱学习器的迭代

如果加上前面的正则项，有：

ν的取值范围为0<ν<1，对于同样的训练集学习效果，较小的ν意味着需要更多的弱学习器迭代次数，通常用步长和迭代最大次数一起来决定算法的拟合效果。

3.AdaBoost小结

理论上任何学习器都可以用于Adaboost，但一般来说，使用最广泛的Adaboost弱学习器是决策树和神经网络。对于决策树，Adaboost分类用了CART分类树，而Adaboost回归用了CART回归树。
Adaboost的主要优点有：
（1）Adaboost作为分类器时，分类精度很高；
（2）在Adaboost的框架下，可以使用各种回归分类模型来构建弱学习器，非常灵活；
（3）作为简单的二元分类器时，构造简单，结果可理解；
（4）不容易发生过拟合。
Adaboost的主要缺点有：
对异常样本敏感，异常样本在迭代中可能会获得较高的权重，影响最终的强学习器的预测准确性。

发表于
字数统计: | 阅读时长 ≈

机器学习之集成学习（二) AdaBoost算法(部分)

一. Boosting系列算法需要解决以下几个具体问题：

​ 1、如何计算学习误差e？
​ 2、如何得到弱学习器权重系数a？
​ 3、如何更新样本权重D？
​ 4、使用何种结合策略？

二. AdaBoost算法的基本思路

假设训练集为T={(Xi,Yi)},训练集的第k个弱学习器的输出权重为D(k)=(Wk1,Wk2,…….),初始时权重为:Wi=1/N。

2.1Adaboost的分类问题

  • 误差率

    由于多元分类是二元分类的推广，这里假设是二元分类，输出为{-1, 1}，则第k个弱分类器Gk(x)在训 练集上的加权误差率为:

  • 弱学习器权重a

    对于二元分类问题，第k个弱分类器Gk(x)的权重系数为

    ​

    ​ 从上式可以看出，分类误差率e_k越大，则对应的弱分类器权重系数越小，误差率小的弱分类器权重系数越大

  • 更新样本权重D
    假设第k个弱分类器的样本集权重系数为D(k)=(Wk1,Wk2…..WkN)，则第k+1个弱分类器的样本集权重系数为

    这里Z_K是规范化因子

    从的计算公式可以看出，如果第i个样本分类错误，则，导致样本的权重在第k+1个弱分类器中增大；如果分类正确，则权重在第k+1个弱分类器中减小。

  • 结合策略

    AdaBoost分类采用加权平均法，最终的强分类器为:

2.2Adaboost的回归问题

  • 误差率

  • 弱学习器权重系数

  • 更新样本权重

发表于
字数统计: | 阅读时长 ≈

一、集成学习概述

​ 集成学习通过构建并结合多个学习器来完成学习任务。通过将多个学习器结合，常可以获得比单一学习器显著优越的泛化性能，达到博采众长的目的。

  • 集成学习有两个主要的问题需要解决：
    1、如何训练每个学习器？
    2、如何融合各个学习器？

二、个体学习器

要获得好的学习器，个体学习器应“好而不同”，即个体学习器要有一定的准确性，并且要有多样性。
根据个体学习器包含的类型，可分为同质个体学习器和异质个体学习器。集成中可以只包含同种类型的个体学习器，如决策树、神经网络，这样的集成是同质的，同质集成中的个体学习器亦称“基学习器”，相应的学习算法称为“基学习算法”。集成也可以包含不同类型的个体学习器，如同时包含决策树和神经网络，这样的集成是异质的，个体学习器常称为“组件学习器”。目前同质个体学习器的应用岁最广泛的，一般提到集成学习都是指同质个体学习器，而同质个体学习器使用最多的模型是CART决策树和神经网络。
根据个体学习器的生成是否存在依赖关系，可以分为两类。个体学习器间存在强依赖关系，必须串行生成，代表算法是boosting系列算法；个体学习器之间不存在强依赖关系，可以并行生成，代表算法是bagging和随机森林系列算法

三.集成学习之Boosting

Boosting算法的工作机制是首先从训练集中用初始权重训练出一个弱学习器1，根据弱学习器的学习误差率来更新训练样本的权重，使弱学习器1学习误差率高的训练样本点的权重变高，在后面的弱学习器2中得到更多的重视，然后基于调整权重后的训练集来训练弱学习器2，如此重复，直到弱学习器数目达到事先指定的数目T，最后将T个弱学习器通过集合策略进行整合，得到最终的强学习器。从偏差-方差分解的角度看，Boosting主要关注降低偏差，因此Boosting能基于泛化性能相当弱的学习器构建出很强的集成。

四.集成学习之Bagging

Bagging算法通过T次随机采样得到T个采样集，独立训练出T个弱学习器，再通过集合策略得到最终的强学习器。这里的随机采样一般采用自助采样法（Bootstrap sampling），即在包含m个样本的数据集中，每次随机取出一个样本放入采样集中，再把该样本放回原数据集中，这样下次采样时该样本仍有可能被选中，这样经过m次随机采样可以得到含m个样本的采样集。原训练集中有的样本在采样集中多次出现，有的从未出现，初始训练集中约63.2%的样本出现在采样集中。从偏差-方差分解的角度看，Bagging主要关注降低方差，因此在不剪枝决策树、神经网络等易受样本扰动的学习器上效果更为明显。
随机森林是Bagging的一个特化进阶版，特化是因为随机森林的弱学习器都是决策树，进阶是因为随机森林在Bagging的样本随机采样基础上，又加上了特征的随机选择，其基本思想没有脱离Bagging的范畴。

五.集成学习的结合策略

1.平均法

对于数值类的回归预测，通常使用平均法，也就是对T个弱学习器的输出进行平均得到最终的预测输出。通常有:

  1. 算术平均法

  2. 加权平均法

2.投票法

对于分类问题的预测，通常使用投票法。假设预测类别是{c1,c2,c3……ck}

  • 相对多数投票法

    1
    最简单的投票法，也就是常说的少数服从多数，T个弱学习器对样本的预测中，数量最多的类别作为最终的分类类别，如果不止一个类别票数最高，则随机选择一个作为最终类别。

  • 绝对多数投票法

    1
    稍微复杂些，也就是常说的票过半数，在相对多数投票法的基础上，不仅要求获得最高票，还要求票过半数，否则会拒绝预测，这在可靠性要求较高的学习任务中是一个很好的机制。

  • 加权投票法

    1
    和加权平均法一样，每个弱学习器的分类票数要乘以一个权重，最终将各类别的加权票数求和，最大值对应的类别为最终类别。

发表于
字数统计: | 阅读时长 ≈

数据分析任务(1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import Imputer
from sklearn.model_selection import train_test_split

#导入数据
data = pd.read_csv('D:\statistical\data.csv', encoding='gbk')

#查看数据概况
data.info()

#查看数据前5行
data.head()

#统计每列的缺失值个数
data.isnull().sum().sort_values(ascending=False)

#'student_feature' 这列考虑删除, 或者将NA以0填充
data[['student_feature', 'status']].groupby(data['status']).count()

cat_vars = []
def fea_categorical_check(df):
    print('描述变量有:\n')
    for col in df.columns:
        if df[col].dtype == 'object':
            print(col)
            cat_vars.append(col)
    return cat_vars
    

#测试集30%，训练集70%，随机种子设置为2018
from sklearn.model_selection import train_test_split
x_train,x_test,y_train,y_test=train_test_split(data,y_data,train_size=0.7,random_state=2018

发表于
字数统计: | 阅读时长 ≈

逻辑回归基础

所以逻辑回归，不是回归，而是分类器，二分类，多分类。

1.使用sigmoid函数，对y的取值进行压缩至[0,1]

图像如下：

2.损失函数

真实值与预测值之间的误差的函数，我们希望这个函数越小越好。在这里，最小损失是0。

3.在sklearm中的应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

sklearn.linear_model.LogisticRegression(penalty=l2, # 惩罚项，可选l1,l2，对参数约束，减少过拟合风险

                                        dual=False, # 对偶方法（原始问题和对偶问题），用于求解线性多核（liblinear)的L2的惩罚项上。样本数大于特征数时设置False

                                        tol=0.0001, # 迭代停止的条件，小于等于这个值停止迭代，损失迭代到的最小值。

                                        C=1.0, # 正则化系数λ的倒数，越小表示越强的正则化。

                                        fit_intercept=True, # 是否存在截距值，即b

                                        intercept_scaling=1, #

                                        class_weight=None, # 类别的权重，样本类别不平衡时使用，设置balanced会自动调整权重。为了平横样本类别比例，类别样本多的，权重低，类别样本少的，权重高。

                                        random_state=None, # 随机种子

                                        solver=’liblinear’, # 优化算法的参数，包括newton-cg,lbfgs,liblinear,sag,saga,对损失的优化的方法

                                        max_iter=100,# 最大迭代次数，

                                        multi_class=’ovr’,# 多分类方式，有‘ovr','mvm'

                                        verbose=0, # 输出日志，设置为1，会输出训练过程的一些结果

                                        warm_start=False, # 热启动参数，如果设置为True,则下一次训练是以追加树的形式进行（重新使用上一次的调用作为初始化）

                                        n_jobs=1 # 并行数，设置为1，用1个cpu运行，设置-1，用你电脑的所有cpu运行程序

                                            )

发表于
字数统计: | 阅读时长 ≈

发表于
字数统计: | 阅读时长 ≈

神经网络基础

1.RNN结构

(1).背景

DNN以及CNN在对样本提取特征的时候，样本与样本之间是独立的，而有些情况是无法把每个输入的样本都看作是独立的，比如NLP中的此行标注问题，ASR中每个音素都和前一个音素是相关的，这类问题可以看做一种带有时序序列的问题，无法将样本看做是相互独立的，因此单纯的DNN和CNN解决这类问题就比较棘手。此时RNN就是一种解决这类问题很好的模型。

特点：

  • 权重W,U,V是共享的，以此减少参数量

  • 第t时刻的输出与第t-1时刻的输出有关

(2).优缺点，存在的问题

DNN无法对时间序列上有变化的情况进行处理。然而，样本出现的时间顺序对于自然语言处理、语音识别、手写体识别等应用非常重要。因此出现了——循环神经网络RNN。
在普通的全连接网络或CNN中，每层神经元的信号只能向上一层传播，样本的处理在各个时刻独立，因此又被成为前向神经网络(Feed-forward Neural Networks)。而在RNN中，神经元的输出可以在下一个时间段直接作用到自身，即第i层神经元在m时刻的输入，除了(i-1)层神经元在该时刻的输出外，还包括其自身在(m-1)时刻的输出！

但是出现了一个问题——“梯度消失”现象又要出现了，只不过这次发生在时间轴上。
所以RNN存在无法解决长时依赖的问题。为解决上述问题，提出了LSTM（长短时记忆单元），通过cell门开关实现时间上的记忆功能，并防止梯度消失.

(3).RNN如何实现参数更新(基于时间得反向传播算法 BPTT)

下图展示了在训练过程中的损失的产生：

详细的数学推导过程：

首先列出在推导过程中的一般计算公式：

将输出对应的损失求导：

接下来是对参数W,U,b进行更新，虽然三者在过程中是共享的，但是他们不止在t时刻做出了贡献，在t+1时刻也对隐藏层St+1做出了贡献，所以求导时，要从前往后一步步推导。

三者有一个共同项，所以先求这个共同项：

在求解激活函数导数时，是将已知的部分求导之后，然后将它和激活函数导数部分进行哈达马乘积。激活函数的导数一般是和前面的进行哈达马乘积，这里的激活函数是双曲正切，用矩阵中对角线元素表示向量中各个值的导数，可以去掉哈达马乘积，转化为矩阵乘法。

在求得了st以后，将其带回最初得公式对参数进行求导：

在有了各个导数以后，对参数进行更新：

2.双向RNN

Bidirectional RNN(双向RNN)假设当前t的输出不仅仅和之前的序列有关，并且 还与之后的序列有关，例如：预测一个语句中缺失的词语那么需要根据上下文进 行预测；Bidirectional RNN是一个相对简单的RNNs，由两个RNNs上下叠加在 一起组成。输出由这两个RNNs的隐藏层的状态决定。

3.LSTM

LSTM 通过刻意的设计来避免长期依赖问题。记住长期的信息在实践中是 LSTM 的默认行为，

4.Text-RNN原理

TextCNN擅长捕获更短的序列信息，但是TextRNN擅长捕获更长的序列信息。

代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
tf.set_random_seed(1)

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

# hyperparameters
lr = 0.001
training_iters = 100000
batch_size = 128

n_inputs = 28  # shape 28*28
n_steps = 28  # time steps
n_hidden_unis = 128  # neurons in hidden layer
n_classes = 10  # classes 0-9

# tf Graph input
x = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
y = tf.placeholder(tf.float32, [None, n_classes])

# Define weights
weights = {
    # (28,128)
    'in': tf.Variable(tf.random_normal([n_inputs, n_hidden_unis])),
    # (128,10)
    'out': tf.Variable(tf.random_normal([n_hidden_unis, n_classes]))
}
biases = {
    # (128,)
    'in': tf.Variable(tf.constant(0.1, shape=[n_hidden_unis, ])),
    # (10,)
    'out': tf.Variable(tf.constant(0.1, shape=[n_classes, ]))
}


def RNN(X, weights, biases):

    # hidden layer for input to cell
    # X(128 batch, 28 steps, 28 inputs) => (128*28, 28)
    X = tf.reshape(X, [-1, n_inputs])
    # ==>(128 batch * 28 steps, 28 hidden)
    X_in = tf.matmul(X, weights['in'])+biases['in']
    # ==>(128 batch , 28 steps, 28 hidden)
    X_in = tf.reshape(X_in,[-1, n_steps, n_hidden_unis])


    # cell
    lstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden_unis, forget_bias=1.0, state_is_tuple=True)
    # lstm cell is divided into two parts(c_state, m_state)
    _init_state = lstm_cell.zero_state(batch_size, dtype=tf.float32)
    outputs, states = tf.nn.dynamic_rnn(lstm_cell, X_in, initial_state=_init_state, time_major=False)


    # hidden layer for output as the final results
    results = tf.matmul(states[1], weights['out']) + biases['out']  # states[1]->m_state states[1]=output[-1]
    # outputs = tf.unstack(tf.transpose(outputs,[1,0,2]))
    # results = tf.matmul(outputs[-1], weights['out']) + biases['out']
    return results


pred = RNN(x, weights, biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
train_op = tf.train.AdamOptimizer(lr).minimize(cost)

correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    step = 0
    while step * batch_size < training_iters:
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        batch_xs = batch_xs.reshape([batch_size, n_steps, n_inputs])
        sess.run([train_op], feed_dict={
            x: batch_xs,
            y: batch_ys
        })
        if step % 20 ==0:
            print (sess.run(accuracy, feed_dict={
            x: batch_xs,
            y: batch_ys
        }))
        step += 1