在神经网络中预测识别和预测的过程中，其实都是一个函数的对应关系：$$y=f(x)$$ 的函数关系，为了找到这个函数的关系，我们需要做大量的训练，具体的过程可以总结下面几个步骤：
获得随机矩阵w1和b1,经过一个激活函数，得到隐藏层。
获得随机矩阵w2和b2，计算出对应的预测y
利用y与样本y_的差距，有平方差和交叉熵等方式，来定义损失函数
利用指数衰减学习率，计算出学习率
用滑动平均计算输出的参数的平均值
利用梯度下降的方法，减少损失函数的差距
用with结构初始化所有的参数
利用for循环喂入数据，反复训练模型
利用这个八个步骤拟合出的一个圆的函数，代码和结果如下：
1 | # coding:utf-8 |
感慨下，学了这么久终于有能有点实战的东西了，这篇文章本想写于2019-04-14,可是担心会对学习的进度产生影响，就一直拖后。所以就再今天（2019-04-24）开始去写这篇实战的文章。
写这篇博客的目的就是为了写一个识别手写程序的方案，首先我们准备了mnist(mnist数据集)的数据集，和一张手写的图片
{:height=”600px” width=”600px”}
为了测试，增加了一些干扰线：
{:height=”600px” width=”600px”}
我们知道，在mnist的数据集中，是对单个28*28像素图片进行处理，而且是黑底白字的数字图片，所以为了能够使用mnist的数据样本训练，我们也需要对手写的图片处理。
具体的处理方法我们可以分为：
1.二值化
2.去噪声
3.裁剪
4.缩放28*28的图像
5.训练样本
6.识别结果
对于这个图片的二值化可以使用opencv相关处理模块，二值化是直接把图片编程只有黑白两种颜色的图：
{:height=”600px” width=”600px”}
我们可以看到上面有几个 使用均值模糊可以去除干扰线和噪点：
{:height=”600px” width=”600px”}
对模糊后的图片再进行二值化，得到结果如下：
{:height=”600px” width=”600px”}
对应的代码如下：
1 | import cv2 as cv |
对图片进行裁剪 ,分别按行和列去做累加，找到平均值不等于255的点，找出最小值和最大值，对应的图片裁剪的开始和结束。
1 | def corp_img(image): |
截取后保存后的图片结果为：
mnist的样本数据结果：
对比样本数据结果：
通过对比，我们可以发现截取后的图片没有边框，是白底黑字，分辨率也和mnist的样本数据不同，为了能够使用mnist的数据模型，需要对图片做进一步填充，缩放，反色：
1 | # 反色函数 |
经过处理后的图片效果如下,基本与mnist的数据样本格式一致：
原理： 要被识别和训练的模型是一个28*28的图片矩阵，共有784个元素。而最终我们需要得到的结果是一个1x10的数组，所以我们对原来的图片转换成1x784的一维数组X，根据前向传播的神经元模型：$$y=wx+b$$,可以知道W是784*10的矩阵，b是一个1*10的矩阵。我们的训练步骤如下：
784*10矩阵W和偏执项1*10的矩阵brelu,计算出一个不准确的y 神经网络的代码如下：
前向传播代码：minst_forward.py
1 | # coding:utf-8 |
反向传播代码：minst_backward.py
1 | # coding:utf-8 |
运行backword.py的程序，使用mnist的数据，进行10w的训练，得到数据模型如下：
利用模型获得最大可能的预测值，代码如下：
1 | import imageUtils |
识别结果如下：
我们再输入一个正常的手写图片：
输出结果：
识别大部分数据正确，还有有识别错误的现象，因为训练的模型的差异和训练次数过少，所以会导致识别出错的现象。
前面说的都是全连接NN的demo,(每个神经元余额前后的相邻的每一个神经元都有链接关系，输入特征，输出为预测结果)
在全连接NN中，一张分辨率为28*28的黑白图像， 有784个数据，如果我们采用了500个样本整个的参数的个数为：
1 | 第一层： 784*500+500 |
算下来接近40w个参数，参数过多，容易导致模型过拟合，如果换成高分辨率的彩色图像，问题会更为严重。 为了解决这个问题一般会首先提取图像的特征，把提取后的特征再喂给全连接网络，再对参数进行优化。
卷积是一种提取图片特征的方法，一般用一个正方形卷积核，遍历图片上的每一个像素点。图片与卷积内相对应的权重，然后求和，再加上偏置后，最后输出一个图片的像素值（图片来自网络，侵权请联系删除）。
{:height=”600px” width=”600px”}
正常的卷积会导致图片的缩小，为了能够让输入和输出的图片尺寸一致，对图片周围的空数据进行全0填充。（图片来自网络，侵权请联系删除）。
{:height=”600px” width=”600px”}
在tensorflow中，使用tf.nn.conv2d方法来实现卷积的算法. conv2d有四个参数，对图片的描述，卷积核的描述，卷积核的滑动步长和是否使用padding.
具体参数描述：
对输入图片的描述：用batch给出一次喂入多少张图片，每张图片的分辨率大小，比如5行5列，以及这些图片包含几个通道的信息，如果是灰度图则是单通道，参数是1 ，彩色图像是3.
对于卷积核的描述： 要给出卷积的行分辨率和列分辨率，通道数以及用了几个卷积核。卷积核的通道数是由输入图片的通道数决定的，卷积核的通道数等于输入图片的通道数，所以卷积核的通道数也是1。
对卷积核滑动步长的描述： 第一个参数和最后一个参数是固定的，第二个和第三个表示滑动步长。
是否使用padding：padding=’valid’ 代表使用padding
在大多数情况下，输入的图片是RGB三个颜色组成的彩色图。输入的图片包含红绿蓝三层数据，卷积核的深度应该等于输入图片的通道数.
多层卷积的计算方法和单层卷积核相似，卷积核为了匹配红绿蓝的三个颜色，把三层的卷积核套在三层的彩色图片上，重合的像素进行累加，再加上偏置项b，最终得到输出的值。
{:height=”600px” width=”600px”}
池化是对图片的像素进行优化和简化，具体过程如下图：
{:height=”600px” width=”600px”}
池化包括对最大值池化和平均值池化。
MINST数据库是由是一个手写数字的数据集，官方网址：http://yann.lecun.com/exdb/mnist/。
> MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.
MINST数据总共有4个包,解压出来的数据如下：
{:height=”600px” width=”600px”}
train-images-idx3-ubyte.gz,train-labels-idx1-ubyte.gz:提供了60000张，28*28像素的黑底白字图片用来训练t10k-images-idx3-ubyte.gz,t10k-labels-idx1-ubyte.gz:提供了10000张，28*28像素的黑底白字图片用来测试mnist提供的图片有784（28*28）个像素点，把每个像素点的值，组织成一个一维的数组，作为输入参数。形式如下：
1 | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.386 0.379 0....... 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ] |
既然是图片数据，我们就能把他们都还原过去，代码如下：
1 | #coding:utf-8 |
今天整理下学习的tensorflow的几个常用的方法和代码片段.
tf.get_collection("") 从集合中取出全部变量，生成一个列表
tf.add_n([]) 列表内对应元素相加
tf.cast(x,dtype) 把x转为dtype类型
tf.argmax(x,axis) 返回最大值所在索引号，如 tf.argmax([0,1,0]) 返回2
with tf.Graph().as_default() as g: 其内定义的节点在计算图g中
保存模型：
1 | saver=tf.train.Saver()# 实例化saver对象 |
反向传播均方误差和减少loss
1 | loss=tf.reduce_mean(tf.square(y_-y)) |
损失函数
1 | # tf.nn.relu #未找到使用地方 |
学习率计算
1 |
|
滑动平均
1 | ema=tf.train.ExponentialMovingAverage(衰减率MOVING_AVERAGE_DECAY,当前轮数global_step) |
正则化
1 | loss(w)=tf.contrib.layers.l1_regularizer(REGULARIZER)(w) #w加和 |
实例化可还原滑动平均值的saver
1 | ema=tf.train.ExponentialMovingAverage(滑动平均数) |
准确率计算方法
1 | correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(y_,1)) |
这几天终于把tensorflow的基础学完了，虽然还有点云里雾里，但毕竟入门是一件困难的事情。下面把这几次的写的代码整理出来。
generateds.py文件
1 | import numpy as np |
有时候发现，模型在训练数据集的准确率非常高，但很难预测新的数据，这样我们称为，模型存在了过拟合的现象。 正则化是缓解过拟合一种有效的方法.
正则化在损失函数中引入模型复杂度指标，利用给W加权值，弱化训练数据的噪声（一般不正则化b） ，具体公式如下:
$$loss=loss(y与y’)+REGULARIZER*loss(w)$$
其中，模型中所有参数的损失函数如：交叉熵，均方误差 。
用超参数REGULARIZER给出参数w在总loss中的比例，及正则化的权重 w是正则化的参数.
使用tensorflow表示：
1 |
|
我们生成几个随机点，然后利用生成分界线,代码如下：
#coding:utf-8
# 0.导入模块，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE=30
seed=2
# 基于seed产生随机数
rdm=np.random.RandomState(seed)
# 随机数返回300行2列的矩阵，表示300组坐标点（x0，x1)作为输入数据集
X=rdm.randn(300,2)
#从X这个300行2列的矩阵中取出一行，判断如果两个坐标系的平方和小于2，给Y赋值1 其余赋值0.
# 作为输入数据集的标签，
Y_=[int (x0*x0+x1*x1<2) for(x0,x1) in X]
# 遍历Y中的每个元素，1 赋值'red' 其余赋值'blue' ，这样可视化显示是人可以直观区分
Y_c=[['red' if y else 'blue'] for y in Y_]
# 对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X=np.vstack(X).reshape(-1,2)
Y_=np.vstack(Y_).reshape(-1,1)
print(X)
print(Y_)
print(Y_c)
#用plt.sctter画出数据集X各行中第0列元素和第1列元素的点即个行的（x0,x1)，用各行Y_c对应的值表示颜色（c是color的缩写）
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.show()
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
def get_weight(shape,regularizer):
w=tf.Variable(tf.random_normal(shape),dtype=tf.float32)
tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(regularizer)(w))
return w
def get_bias(shape):
b=tf.Variable(tf.constant(0.01,shape=shape))
return b
w1=get_weight([2,11],0.01)
b1=get_bias([11])
y1=tf.nn.relu(tf.matmul(x,w1)+b1)
w2=get_weight([11,1],0.01)
b2=get_bias([1])
y=tf.matmul(y1,w2)+b2
loss_mse=tf.reduce_mean(tf.square(y-y_))
loss_total=loss_mse+tf.add_n(tf.get_collection('losses'))
train_step=tf.train.AdamOptimizer(0.0001).minimize(loss_mse)
with tf.Session() as sess:
init_op=tf.global_variables_initializer()
sess.run(init_op)
STEPS=40000
for i in range(STEPS):
start=(i*BATCH_SIZE)%32
end=start+BATCH_SIZE
sess.run(train_step,feed_dict={
x:X[start:end],y_:Y_[start:end]
})
if i%2000==0:
loss_mse_v=sess.run(loss_mse,feed_dict={x:X,y_:Y_})
print("After %d training steps,loss on all data is %s"%(i,loss_mse_v))
xx,yy=np.mgrid[-3:3:0.1,-3:3:.01]
grid=np.c_[xx.ravel(),yy.ravel()]
probs=sess.run(y,feed_dict={x:grid})
probs=probs.reshape(xx.shape)
print("w1:",sess.run(w1))
print("b1:",sess.run(b1))
print("w2:",sess.run(w2))
print("b2:",sess.run(b2))
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[.5])
plt.show()
生成点的结果如下:
{:height=”600px” width=”600px”}
我们拟合的结果为：
{:height=”600px” width=”600px”}
使用正则化后，我们拟合的结果为：
{:height=”600px” width=”600px”}
滑动平均，又叫影子值，记录了每个参数一段时间内过往值的平均，增加了模型的泛化性。
针对所有参数：w和b。（像是给参数加了影子，参数变化，影子缓慢追随）,具体的计算公式如下:
影子=衰减率*影子+(1-衰减率)* 参数
影子初值=参数初值
衰减率=$$min\left({cases}MOVING_AVERAGE_DECAY, \frac{1+step}{10+step}\right)$$
例如：
MOVING_AVERAGE_DECAY为0.99，参数w1为0，轮数global_step为0，w1的滑动平均值为0，参数w1更新为1.则：
*w1滑动平均值=min(0.99,1/10)*0+(1-min(0.99,1/10))1=0.9
轮数global_step为100是，参数w1更新为10，则：
*w1滑动平均值=min(0.99,101/110)*0.9+(1-min(0.99,101/110))10=0.826+0.818=1.644
再次运行：
*w1滑动平均值=min(0.99,101/110)*1.644+(1-min(0.99,101/110))10=2.328
再次运行：
w1平均值=2.956
使用tensorflow表示如下：
1 | ema=tf.train.ExponentialMovingAverage(衰减率MOVING_AVERAGE_DECAY,当前轮数global_step) |
我们使用代码来使用模拟上面的计算逻辑：
1 | #coding:utf-8 |
打印结果：
1 | [0.0, 0.0] |
可以看到平均值一直趋近于w1。
学习率（learning_rate）是每次参数更新的幅度。
$$
W_{n+1}=W_n-learning_rate▽
$$
其中$$W_{n+1}$$时更新后的参数，$$W_n$$当前参数，▽是损失函数的梯度（导数）
例如：
损失函数$$loss=(w+1)^2$$ 梯度 $$▽=\frac{\partial loss}{\partial w}=2w+2$$
例如：参数w初始化为5，学习率为0.2，则：
1次 参数w：5 5-0.2*(2*5+2)=2.6
2次 参数w：2.6 2.6-0.2*(2*2.6+2)=1.16
3次 参数w：1.16 1.16-0.2*(2*1.16+2)=0.296
4次 参数w：0.296
…..
函数图像为:
{:height=”600px” width=”600px”}
根据图像我们可以看出在x=-1时，有最小值。
我们利用tensorflow看看能不能找到x=-1这个极值点。
1 | #coding:utf-8 |
代码运行结果:
1 | After 0 steps: w is 2.600000,loss is 12.959999 |
可以看到，随着loss减小，loss无限趋近与-1 。
在上面的代码中，如果把学习率改成1时，发现结果一直在震荡：
1 | After 1 steps: w is 5.000000,loss is 36.000000 |
如果把学习率改成0.001 ，发现w变化非常慢。
从上面的例子中可以看到，学习率大了震荡不收敛，学习率小了收敛速度慢。
学习率应该怎么正确设置？
相对于固定的学习率，提出了指数衰减学习率，tensorflow的表示如下：
$$learning_rate=LEARNINF_RATE_BASE * LEARNINF_RATE_DECY*\frac{global_step}{LEARNINF_RATE_STEP}$$
其中LEARNINF_RATE_BASE是学习初始值，LEARNINF_RATE_DECY是学习衰减率，0~1。 global_step代表运行了几轮，LEARNINF_RATE_STEP多少轮更新一次学习率（总样本数/BATCH_SIZE）具体的代码表示为：
1 | global_step=tf.Variable(0,trainable=False) |
最终我们使用指数衰减的学习率训练的模型代码如下：
1 | #coding:utf-8 |
输出结果如下：
1 | After 0 ,global_step is 1,w is 3.800000,learning_rate is 0.099000,loss is 23.040001 |
可以从上面的结果中看出w和learning_rate的变化。
在前面几个博客中说了一个学习模型，具体表现如下：
具体的计算公式：$$Y=\sum_{i}^nX_iW_i$$
曾经有人提出另一个神经元模型，多了激活函数和偏执项。
具体的计算公式：
$$
Y=f(\sum_{i}^nX_iW_i+b)
$$
其中f是激活函数,b是偏执项。
损失函数（loss）：预测值y’和已知答案y的差距
我们的优化目标就是把loss降低为最小。
引入激活函数有效的避免仅使用$$XW$$的线性组合，是模型更准确，更具有表达能力。
常用的激活函数有：
relu（tf.nn.relu）：
$$
f(x)=max(x,0)= \begin{cases}
0, & \text{$x<=0$} \
x, & \text{$x>0$}
\end{cases}
$$
用tensorflow表示为:tf.nn.relu ,函数图像为：
sigmoid（tf.nn.sigmoid）:tensorflow表示为:tf.nn.sigmoid,函数图像为：
tanh:
$$
f(x)=(1-e^{-2x})/(1+e^{-2x})
$$
用tensorflow表示为:tf.nn.tanh,函数图像为：
预测酸奶的日销量，x1、x2是影响日销量的因素，建模前应预先猜测的数据有：每日x1、x2和销量y_（即已知答案，最佳情况，产量=销量）拟造数据集X,Y;y_=x1+x2,噪声是-0.05~+0.05 拟合可以预测销量的函数。
根据上面的模型，我们生成随机数，进行训练，代码如下：
1 | #coding:utf-8 |
打印结果：
1 | After 17500 training steps,wl isL |
看到两个权重的值，都趋于1. 与数据结果y=x1+x2 结果一致。
在预测商品销量，预测多了，损失成本，预测少了损失利润，若利润不等于成本，则mse产生的loss无法利益最大化。
自定义损失函数 $$\sum_{i}^nf(y’,y)$$
$$
f(y’,y) =
\begin{cases}
PROFIT*(y’-y), & \text{$y<y’$ 预测y少了，损失利润（PROFIT）} \
COST*(y-y’), & \text{$y>=y’$ 预测y多了，损失成本（COST）}
\end{cases}
$$
使用下面的函数进行修正： loss=tf.reduce_sum(tf.where(tf.greater(y,y_),COST(y-y_),PROFIT(y_-y)))
如上面的例子，酸奶的成本（COST)1元，酸奶的利润（PROFIT)9元。
预测少了损失利润9元，预测多了损失成本预测。
预测少了损失大，希望生成的预测函数。往多了预测。
我们把损失函数进行替换，换成我们的自定义的函数，代码如下：
1 | #coding:utf-8 |
1 | After 18500 training steps,wl isL |
可以看到预测尽量往多的方向去预测。
交叉熵表示两个概率分布之间的距离。
$$
H(y’,y)=-\sum y’*logy
$$
例如，已知答案y’=(1,0),预测**y1=(0.6,0.4) y2=(0.8,0.2)**哪个更接近标准答案？
$$
H_1((1,0),(0.6,0.4))=-(1log0.6+0log0.4)\approx0.222
$$
$$
H_2((1,0),(0.8,0.2))=-(1log0.8+0log0.2)\approx0.097
$$
所以y2预测更为准确。
我们可以使用交叉熵的形式，来更精确的训练我们的模型。
ce=-tf.reduce_mean(y'*tf.log(tf.clip_by_value(y,1e^-12,1.0)))
其中y<1e^-12是，y=1e^-12，防止log0的出现
当n分类的n个输出（y1,y2,…yn）通过softmax()函数,便满足了概率的分布要求：
$$
P(X=x)\rightarrow[0,1] 且 \sum P(X=x)=1
$$
$$
softmax(y_i)=\frac{e^{y_i}}{\sum_{j=1}^ne^{y_i}}
$$
可以用ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logtis=y,labels=tf.argmax(y_,1))
cem=tf.reduce_mean(ce) 替换交叉熵的函数，代表的是当前的预测值与标准答案的差距。
Update your browser to view this website correctly.&npsb;Update my browser now
