numpy pandas sklearn
算法
神经网络的Math
动手实现网络结构
应用
TensorFlow框架
图像案例
Machine Learning VS Deep Learning
1 特征提取方面 自动
2 数量集 量大/参数大
* 机器学习 ： 朴素贝叶斯 决策树
深度学习 ： 统称神经网络
3 应用
图识别/自然语言处理/语言识别
4 架构
Caffe TensorFlow Pytorch（Facebook）
架构/框架对比
Followers
TensorFlow：
语言多 ： C++封装 Python封装 可Go/Swift
分布式训练 ： GPU TPU（Google）
TensorBoard可视化 ： Web
跨平台应用 ： HTTP的TF服务 / TF Lite / tf .js
2 Tensorflow架构（一）
加法
a_t = tf.constant(10)
b_t = tf.constant(20)
c_t = tf.add(a_t ,b_t)
减法
* print 不支持，需要开启会话
with tf.session() as sess :
sum_t = sess.run(c_t)
print(“sum:/t”, sum_t)
3 Tensorflow架构（二）
Tensorflow ： 构架图阶段 ， 执行图阶段
图 ： 指令之间依赖关系
会话 ： 本地/远程多设备
张量 ： tensor 节点（operate） ： 图的操作
数据流图：
**
2 图和TensorBroad
图包含tf.Operation计算单元 tf.Tensor 数据流动
#获取默认图片
g = tf.get_default_graph()
print(g)
print(a.graph)
print(b.graph)
#会话默认图
print(sess.graph)
通过tf.Graph()创建图
new_g = tf.graph()
with new_g.as_default() :
new_a = tf.constant(30)
new_b = tf.constant(40)
new_c = tf.add(new_a ,new_b)
*很少，但是可以一个程序多个图（Model）
TensorBroad
图略
1 数据序列化 - events文件
tf.summary.FileWriter(./temp/tests , graph = sess.graph)
events.out.tfevents.{timestamp}{hostname}
2 启动 TensorBroad
tensorboard --logdir = “./temp/tests”
代码
graph = sess.graph
OP
神经网络组件
softmax sigmod relu convolution max_pool
存储 恢复
save restore
队列及同步运算
Enqueue Dequeue MutexAcquire MutexRelease
*打印类型
Tensor(“Const_1:0” , shape=() ,dtype =float32)
Tensor(“Add:0” , shape=() ,dtype =float32)
2.3 会话
tf.session()
tf.InteractiveSession() : 交互上下文，用于shell
初始化
__int__(target=”” , graph = None ,config = None)
#通用开启
with tf.session() as sess :
...
return None
target 网址，训练器
config 控制会话
# 代码
tf.session(config = tf.ConfigProtol , allow_soft_placement = True , log_device_placement = True)
会话运行
run(fetches , feed_dict = None , option = None , run_metadata = None)
*定义占位符（不知何值）
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
sum_ab = tf.add(a ,b)
sess.run(sum_ab ,feed_dict = {a:30 ,b:40})
会话在Shell中 InteractiveSession :
$ iPython
tf.InteractiveSession() 交互式
a.eval() #在shell中直接run
张量Tensor
type shape（几阶）
类型图
阶
创建张量指令
tf.zeros()
tf.one()
tf.contant()
random_n = tf.random_normal( [3,4] ,mean = 0.0 , stddev = 1.0)
平均值 标准差 （正态分布）
张量的转换
类型转换
tf.string_to_number()
tf.cast()
形状改变
cast_one = tf.cast(one , tf.int32)
动态/静态
动态：
tf.reshape
元素数匹配即可
静态：
tf.set_shape
2D -> 2D
1D -> 1D
*形状可选/定义
a_p = tf.placeholder(dtype = tf.float32 , shape = [None ,None])
//联想四元数，角动量（slam）
变量OP
variable 可存磁盘 （权重、偏置）
tf.variable()
init = tf.global_variable_inltialier()
sess.run(init)
6 线性回归案例
y = wx + b Wi
案例 y = 0.8x + 0.7
运算
矩阵运算 tf.matmul(x ,w)
平方 tf.square(error)
均值 tf.redoce_mean(error)
梯度下降优化
tf.train.GradientDescentOptimizer(learning_rate)
梯度下降优化
learning_rate 学习率，一般为0~1之间的较小值
method ：
minimize（loss）
return ： 梯度下降op
#特征值x，目标值y_true
X = tf.random_normal(shape=(100,1) ,mean=2 ,stddev=2)
y_true = tf.matmul(X ,[[0.8]]) + 0.7
#建立线性模型
weights = tf.Variable(initial_value = tf.rnadom_normal(shape=(1,1)))
bias = tf.Variable(initial_value=tf.random_normal(shape=(1,1)))
#确认损失函数（预测值与真实值之间的误差） - 均方差
error = tf.reduce_mean(tf.squera(y_predict - y_true))
#梯度下降优化损失 ： 需要学习率（超参数）
#W2 = W1 - 学习率*方向
#b2 = b1 - 学习率*方向
optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.01).minimize(error)
#初始化变量
init = tf.global_variables_initializer()
with tf.Session() as sess :
sess.run(init)
print(“随机初始化权重%f，偏置为%f” % （weights.eval() , bias.eval()）)
#训练
for i in range(100):
sess.run(optimizer)
print(“第%d步的误差为%f ，权重为%f ，偏置为%f” % （i ,error.eval() ,weights.eval()）)
return None
/
def linearregression() :
#1准备数据集
#x [100 ,1] 0.8 + 0.7 = [100,1]
X = tf.random_normal([100,1] ,mean=0.0 ,stddev=1.0)
#0.8是个二维
y_true = tf.matmul(X ,[[0.8]] ) +[[0.7]]
#2建立线性回归模型
#W [1,1] , b 1
weights = tf.Variable(inital_value = = tf.random_normal( [1,1] ) ) //w初始化
bias = tf.Variable(inital_value = = tf.random_normal( [1,1] ) ) //b必须使用变量OP被训练
y_predict = tf.matmul(X ,weights) + bias
#3确立损失函数，均方误差((y-y_predict)^2) / m
loss = tf.reduce_mean(tf.square(y_predict - y_true))
#4梯度下降优化：需要学习率（超参数）
optimizer = tf.train.GradientDescentOptimzer(learning_rate = 0.01).minimize(loss)
init_op = tf.gobal_variables_initalizer()
with tf.Session() as sess:
sess.run(init_op)
print(sess.run(optimizer)) // （1）优化不明显
for i in range(100):
print(sess.run(optimizer)) //(2)优化步长，梯度下降
print(“loss:” ,sess.run(loss))
print(“loss:” ,sess.run(“loss: weight: bias:” % [loss ,weigth ,bias] ))
return None
if __name__ == ‘__main__’ :
linearregression()
变量Variable设置trainable观察
属性 trainable
指定参数被训练
*迁移学习，部分参数（权重、偏置）不被训练
TensorBoard
添加命名空间
// Session命名空间
with tf.variable_scope(“original_data”) :
with tf.variable_scope(“linear_model”) :
//
Variable （ ，name = “rognal_date_since”）
Variable （ ，name = “w”）
// 添加本地文件
file_writer = tf.summary.FileWritter(“./temp/summary” ,)
$ tensorboard --logdir = “./temp/summary”
添加变量
零维度 tf.summary.scalar(“error” ,error)
高维度 tf.summary.histogram(“bias” ,bias) weight
merge = tf.summary.merge_all()
for i in range(100) : //训练100此，每次损失值都要记录
summary = sess.run(merge)
file_writer = tf.summary(summary ，i)
模型的保存与加载（简单方式）
tf.train.Saver(var_list = None ,max_to_keep = 5) //每隔5次
* 保存原则 ： 什么值重要？ 权重、偏置。
saver.save(sess ,”/tmp/ckpt/test/myregression.ckpt”)
saver.restore(sess ,”/tmp/ckpt/test/myregression.ckpt”)
ckpt格式 检查点文件格式
*eval（）函数
1 字符串string转化成有效表达式
2 定义图、计算图时，类似run
3 有输出的Operation
命令行参数的使用
tf.app.flag 有个FLAG标志，它在程序中使用。
tf.app.flags.DEFINE_interger(“max_step” ,10 ,“训练步长”)
FLAG = tf.app.flags
for i in range(FLAG.max_step) :
print(“train loss:%f ,weight:%f ,bias:%f”% (loss.eval() ,weight.eval() ,bias.eval()))
逻辑回归复习（神经网络基础）
Logistic回归
主要的二分分类的算法。
Sigmoid函数
逻辑回归 sigmoid 线性回归 均方误差
概率小于1，log是负值 ： -log(P) -log(0.4)
代价函数Cost Function : 所有损失值的平均数
导数向量化编程介绍
梯度gradient
参数 w b 的更新
α是学习速率，即每次更新的w的步伐长度
导数
J雅可比公式 b b - a c < 0
逻辑回归训练实现前向和后向
向量化编程 ： m个样本，每个样本都可以处理梯度
向量化 ： 提高计算速度，比如Numpy
improt numpy as np
import time
a = np.random.rand(100000)
np常用：
np.ones np.zeros 全1 全0 矩阵
np.exp 指数运算
np.log 对数计算
np.abs 绝对值计算
实现逻辑回归 - 案例
1 使用数据：制作二分类数据集
from sklearn.datasets import load_iris ,make_classification
from sklearn.model_selection import train_test_split
import numpy as np
X,Y = make_classification(n_samples = 500 ,n_features = 5 , n_classes = 2)
x_train ,x_test ,y_train ,y_test = train_test_split(X ,Y ,test_size=0.3)
2 步骤设计
def basic_sigmoid(x) :
s = 1 / (1 + np.exp(-x))
return s
def propagate(w ,b ,X ,Y): //前向传播
m = X.shape[1] //维数
A = basic_sigmoid(np.dot(w.T ,X) + b)
#计算损失
cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A)) // sigmoid函数的导数公式
dz = A - Y
dw = 1 / m * np.dot(X ,dz.T)
db = 1 / m * np.sum(dz)
cost = np.squeeze(cost)
grad = {“dw”:dw ,””db”:db}
return grads ,cost
def optimize(w ,b ,X ,Y ,num_iterations ,learning_rate):
costs = []
for i in range(num_iterations) :
# 梯度更新计算函数
grads ,cost = propagate(w ,b ,X ,Y)
#取出两个部分参数的梯度
dw = grads[‘dw’]
db = grads[‘db’]
#按照梯度下降公式去计算
w = w - learning_rate *dw
b = b - learning_rate * db
if i % 100 == 0 :
costs.append(cost)
if i % 100 = 0
print(“损失结果 %i : %f”% (i ,cost))
print(b)
params = {“w”:w ,”b”:b}
grads = {“dw”:dw ,”db”:db}
return params ,grads ,costs
def predict(w ,b ,X):
m = X.shape[1]
y_prediction = np.zeros( (1,m) )
w = w.reshape(X.shape[0] ,1)
#计算结果
A = basic_sigmoid(np.dot(w.T ,X) + b)
for i in range(A.shape[1]) :
if A[0 ,i] <=0.5 :
y_prediction[0 ,i] = 0
else :
y_prediction[0 ,i] = 1
return y_prediction
def model(x_train ,x_test ,y_train ,y_test ,num_iterations = 2000 ,learning_rate=0.0001)
x_train = x_train.reshape(-1 ,x_train.shape[0])
x_test = x_test.reshape(-1 ,x_test.shape[0])
y_train = y_train.reshape(-1 ,y_train.shape[0])
y_test= y_test.reshape(-1 ,y_test.shape[0])
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
#初始化参数
w , b = initialize_with_zeros(x_train.shape[0])
#梯度下降
#params：更新后的网络参数
#grads：最后一次梯度
#costs：每次更新损失列表
optimize(w ,b ,x_train ,y_train ,num_iterations ,learning_rate)
return None
神经网络与tf.keras
图片：宽 高 通道
如果一个像素点，有RGB三个颜色来描述它，就是三通道。
Keras开源的Python的神经网络库。
*减少认知困难，提供一系列API
*因为Keras和底层深度学习语言（特别是Tensorflow）集成一起
*Keras被学界和工业界广泛使用
*GPU相关的训练
tf.Keras的API
applications module : Keras应用程序具有预训练权重的固定架构
callbacks module ： 回调，再模型训练期间在某些点调用的实用程序
datasets module : 数据集
initializers module : 序列化/反序列化
layers module : API
losses module : 内置损失功能
metrics module : 内置模标
models module : 代码克隆、线程模型 API
optimizers module : 内置优化器
preprocessing module : 数据预处理工具（图片预处理）
regularizers module : 内置正则化器
utils module ： 实用程序
图片预处理
tensorflow.python.keras.preprocessing.image
预下载图片读取库
pip install Pillow
image = load_image(path = “”,target_size)
imageArr = image_to_array(image)
print(imageArr.shape)
NHWC 和 NCHW
通道数在前面，通道数在后面
NHWC [batch ,height ,width ,channels]
NCHW [batch ,channels ,height ,width]
Tensorflow 默认[height ,width ,channel]
RGB的格式
tf.transpose( depth_major ,[1 ,2 ,0]).eval() //横竖转换
*转换维度
tf.reshape( [1,2,3,4,5,6,7,8,9,10,11,12] ,[3 , 2 ,2]).eval() //成功
tf.reshape( [1,2,3,4,5,6,7,8,9,10,11,12] ,[2 ,2 3]).eval() //失败
reshape()不能对一维中按照RGB做channel_last变换，只能做channel_first变换。
NHWC和NCHW变换
1 首先reshape()
2 transpose（），维度位置变换
tf.keras数据集
CIFAR小图片分类数据集
50000张32x32的小图片
10000张32x32的测试图片
from keras.datasets import cifar100
(x_train ,y_train) ,(x_test ,y_test) = cifar100.load_data()
时装分类Minist数据集
(x_train ,y_train) ,(x_test ,y_test) = keras.datasets.fashion_mnist.load_data()
图像神经网络
神经网络Neural Network NN ：
输入层 隐藏层 输出层
*没有隐藏层，直接链接的层数，叫做全连接层。
感知机 Perceptorn Learning Algorithm PLA
具有链接的权重和偏置 W b
Playground 2016年谷歌发布的模拟神经网络
x12 x1*x2 sin（x2）各自出现非线性分类的过程
神经网络原理
多分类 ： 避免n个双分类器，设置n个输出结点的全连接输出
Softmax回归
1 数值 -> 预测概率值
2 概率和为1（归一化）
交叉熵损失 ：
衡量预测的概率分布，和真实的概率分布之间的关系
损失大 /损失小 -> 预测不准 / 预测更准
训练中增大或减少每个参数，看如何减少相比于训练数据集的误差，以望能找到最有的权重、偏置参数组合。
上示负责数据，三层隐藏层的解决方案（增加深度）
tf.keras API介绍（一）
构建模型 ：
tf.keras.Sequential() //堆叠层数
tf.keras.layers() :
from tensorflow.python.keras.layers import Dense
from tensorflow.python.keras.layers import DepthwiseConv2D
from tensorflow.python.keras.layers import Dot
from tensorflow.python.keras.layers import Dropout
from tensorflow.python.keras.layers import ELU
from tensorflow.python.keras.layers import Embedding
from tensorflow.python.keras.layers import Flatten
from tensorflow.python.keras.layers import GRU
from tensorflow.python.keras.layers import LSTMCell
......
Flatten :
将输入进行形状改变展开
28x28 -> 784
Dense :
Dense（units ,activation=None ,**kwargs）:
*untis : 神经元个数
*activations : 激活函数，参考：
tf.nn.relu
tf.nn,softmax
tf.nn.sigmoid
tf.nn.tanh
*kwargs : 输入上层输入的形状，input_shape = ()
//两个隐藏层的10分类器
model = keras.Sequential(
keras.layers.Flattern(input_shape = (28 ,28)),
keras.layers.Dense(128 ,activation = tf.nn.relu),
keras.layers.Dense(10 ,activation = tf.nn.softmax)
)
训练与评估
通过调用model的compile方法去配置该模型所需要的训练参数和评估方法
optimizer :
梯度下降的优化器（keras.optimizers）
from tensorflow.keras.optimizers import Adadelta
from tensorflow.keras.optimizers import Adagrad
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.optimizers import Nadam
from tensorflow.keras.optimizers import Optimizer
from tensorflow.keras.optimizers import RMSprop
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.optimizers import desrialize
from tensorflow.keras.optimizers import get
from tensorflow.keras.optimizers import serialize
from tensorflow.keras.optimizers import AdamOptimizer()
losses :
真实值和预测值之间的差值
损失类型
from tensorflow.keras.losses import KLD
from tensorflow.keras.losses import KLD as kls
from tensorflow.keras.losses import KLD as kullback_leibler_divergence
from tensorflow.keras.losses import MAE
from tensorflow.keras.losses import MAE as mae
from tensorflow.keras.losses import MAE as mean_absolute_error
from tensorflow.keras.losses import MAPE
from tensorflow.keras.losses import MAPE as mape
from tensorflow.keras.losses import MAPE as mean_ablsolute_precentage_error
from tensorflow.keras.losses import MSE
from tensorflow.keras.losses import MSLE
from tensorflow.keras.losses import binary_crossntroy
from tensorflow.keras.losses import categorical_crossentropy //均方误差
from tensorflow.keras.losses import cosine
from tensorflow.keras.losses import desrialize
from tensorflow.keras.losses import get
from tensorflow.keras.losses import hinge
from tensorflow.keras.losses import logcosh
from tensorflow.keras.losses import pisson
metrics = None,[‘accuracy‘] //指标
进行训练
model.fit(x = None ,y = None ,batch_size = None ,epochs = 1 ,callbacks = None)
x : 特征值
1 numpy array
2 tensor
3 tf.data / tuple
4 a generate
y : 目标值
batch_size = None ：
批次大小
epochs = 1
训练迭代次数
tf.keras API介绍（二）
Model module :
Model(inputs = a ,output = b)
*input : 定义模型的输入，input类型
*output ： 定义模型的输出
def call(self , inputs) : 接受来自上层的输入
from keras.models import Model
from keras.layers import Input ,Dense
data = Input(shape=(784 ,))
out = Dense(32)data
model_Sec = Model(input = data ,output = out)
print(model_Sec)
model.compile(optimizer=tf.keras.optimizers.Adam(),loss = ‘sparse_categorical_crossentropy’,metrics=[‘accuracy’])
return None
Models 属性
Models.Layers
Models.Input
Models.Output
Model.Compile（) ：
优化器 算法 损失计算
损失计算 :
sparse_categorical_crossentropy 对于目标值是整型的进行交叉熵损失计算
categorical_crossentropy 对于两个output tensor and a target tensor （one-hot code）进行交叉熵损失
Model.fit(x=None ,y=None ,batch_size=None ,epoch=1 ，call backs=None)
x：特征值
y：目标值
epochs=1 ： 训练迭代次数
callback=None ： 添加回调列表（用于tensorboard显示等）
model.evalute(test_image ,test_labels):
评估
或者预测model.predict（test）
其他方法：
model.save_weight()
model.load_weight()
使用多层神经网络进行时装分类
class SingleNN(object) :
model = keras.Sequential(
keras.layers.Flattern(input_shape=(28,28)),
keras.layers.Dense(128 ,activation=tf.nn.relu),
keras.layers.Dense(10 ,activation=tf.nn.softmax)
)
// 双层：128个单元，全连接10个类别输出
//编译定义优化过程，这里选择我们SGD优化器
keras.optimizers.SGD(lr=0.01)
//lose:tf.keras.losses.spare_categorical_crossentropy
//metrics:accuracy
def compile(self):
SingleNN.model.compile(optimizer=keras.optimizer.SGD(lr=0.01) ,loss=tf.keras.losses.spare_categorical_crossentropy ,metrics=[‘accuracy’])
return None
//训练
//设置batch_size=32或者128查看效果（值如何设置，优化部分会进行详解）
def fit(self):
SingleNN.model.fit(self.train ,self.train_label ,epochs=5 ,batch_size=32)
return None
//评估
def evaluate(self):
test_loss ,test_acc = SingleNN.model.evaluate(self.test ,self.test_label)
print(test_loss ,test_acc)
return None
def__init__(self):
(self.train_,self.train_label),(self.test ,self.test_label) = keras.datasets.fashion_mnist.load_data()
效果修改和对比
效果不好 ：换优化器等
效果不好的根本原因： 对图片特征进行归一化
(0 ~ 255) -> (0~1)
#进行数据归一化
self.train = self.train / 255.0
self.test= self.test/ 255.0
模型的保存和加载
保存到h5文件，避免多个文件夹
SingleNN.model.load_weights(“./ckpt/SingleNN.h5”)
model check point
fit 的 Callbacks = “”详解
keras.callbacks.ModelCheckpoint(filepath ,mointor=’val_loss’,save_best_only=False ,save_weights_only=False ,mode=’auto’,period=1)
每隔多少次保存一次模型
提前中止 ： 准确率或者阈值，然后中止
modelcheck = keras.callbacks.ModelCheckpoint(
filepath = ‘./ckpt/singlenn_{epoch:02d}-{val_acc:.2f}.h5’,
montor=’val_acc’,
save_best_only = True.
save_weights_only = True,
period = 1,
mode = ‘auto’
)
SingleNN.model.fit(self.x_train ,self.y_train ,epochs=1, batch_size=128 ,callbacks=[modelcheck])
Tensorboard效果
keras.callbacks.TensorBoard( log_dir=’./logs’,histogram_freq=0 ,batch_size=32 ,write_graph = True,write_grads=False,write_images=False ,embeddings_freq=0 ,embeddings_layer_names=None ,embeddings_metadata=None ,embeddings_data=None ,update_freq=’epoch’)
write_graph = True : 是否显示图结构
write_images = False :是否显示图片
write_grads = True ：是否显示梯度hitogram_freq 必须大于零
tensorboard=keras.callbacks.TensorBoard(log_dir=’./graph’,histogram_freq=1 ,write_graph=True ,write_images=True)
SingleNN.model.fit(self.train ,self.train_label ,epochs=5 ,callbacks=[tensorboard])
深层神经网络
随着模型的层数（深度）增加，处理复杂问题的能力，可能越好
什么是深层网络？
前向传播和反向传播
例如四层
单个样本的反向传播
多个样本的反向传播
参数和超参数
网络有限相关的两个概念
参数（权重、偏置） ：模型运行过程中学习到的
超参数（人为设置） ： 需要控制的一些参数信息（学习率、迭代次数、隐藏层层数、每层神经元个数、激活函数选择 等等）
优化过程遇到的问题
梯度消失和局部最优
如何解决上述问题？
1 初始化参数策略 （relu函数无问题）
2 Mini梯度下降算法
batch一起epoch
3 梯度下降算法的优化
SGD 随机梯度下降
BGD 批梯度下降
Mini-Batch 小批量梯度下降
*选择方法是个数量的经验值
马鞍面
加权平均值优化
绿线显示的数据更光滑
RMSProp算法 ： 求导增加一个动量，减少摆动。更平滑。
Adam算法 ：（Adaptive Moment Estimation 自适应矩估计）
亚当
目前在机器学习中，处理梯度最好的算法
tf.train.AdamOptimizer(learning_rate = 0.001 ,beta1 = 0.9 , beta2 = 0.999 ,epsilon = 1e-08 ,name = ‘adam’)
学习率α ： 尝试一系列的值，寻找比较合适的
β1 ： 作者常用却省值0.9
β2 ： 建议0.999
ε ： 建议1e-8
4 学习率衰减
如果设置一个固定的学习率，在最小点附件不容易收敛
所以随着时间逐渐减小学习率α的大小，有助于算法收敛
指数衰减 α = 0.95^(epoch_num) * α0
*其他非算法的优化的方式
标准化输入 平均值0 标准差1 的 平均正态分布
卷积神经网络的简介
Convolution Neural Network
线性模型解决问题的能力是有限的。
使用非线性的激活函数
Leaky Relu 带泄露的Relu
为什么需要非线性的激活函数？
如果直接logistic回归，那么无论多少神经网络层，输出都是输入的线性组合。与没有隐藏层相当，相当于最原始的感知器。
感受野概念
如果不使用卷积处理图片？ 特征数量太大（几个神经元，几千万个权重参数）。
基于是觉得卷积神经网络：
边缘检测 ：
过滤器Filter
卷积网络CNN的三个组成
由一个或多个卷积层（Convolutions） ， 池化层(Subsmpling) ，以及全连接层(Full connection)组成。
卷积曾主要目的是：提取图片特征
size ： 卷积核/Filter的大小 3*3 5*5
padding ： 填充
stride ： 步长，通常1
为什么填充增加0值？ 不对运算造成影响。
填充多少？ Vailed/Same输出大小和输入大小的比较。
池化层 Pooling
池化层作用 ：
1 收集/减少图片的特征数量，避免全连接层参数过多。
2 提高FeatureMap的鲁棒性，防止过拟合（训练好但是测试差）
Max Pooling / Avg Pooling
全连接层
先对FeatureMap 扁平化
再接一个或多个全连接层，以进行模型学习
CIFAR100类识别
构建CNN常用API
Conv2D
MaxPool2D
keras.layers.Conv2D(32,kernel_size=5 ,strides=1 ,padding=’same’ ,data_format=’channels_last’,activation=tf.nn.relu),keras.layers.MaxPool2D(pool_size=2 ,strides=2 ,padding=’same’))
步骤实现，缩减版的LeNet v5
class CNNMnist(object) :
def __init__(self) :
(self.train ,self.train_label) ,(self.test ,self.test_label) = \ keras.datasets.cifar100.load_data()
self.train = self.train.reshape(-1 ,32 ,32 ,3) / 255.0
self.test = self.test.reshape(-1 ,32 ,32 ,3) / 255.0
设计模型LeNet：
两层卷积层 + 两个神经网络层
第一层
卷积： 32个filter 大小5*5 strides=1 padding=“SAME”
激活： Relu函数
池化： 大小2X2 strides=2
第二层
卷积： 64个filter 大小5*5 strides=1 padding=“SAME”
激活： Relu
池化：大小2X2 strides=2
model = keras.Sequential([
keras.layers.Conv2D(32 ,kerenl_size=5,strides=1,padding=”same”,data_format=’channel_last’,activation=tf.nn.relu),
keras.layers.MaxPool2D(pool_size=2 ,strides=2 ,padding=’same’),
keras.layers.Conv2D(64 ,kernel_size=5 ,strides=1 ,padding=’same’,data_format=’channels_last’ ,activation=tf.nn.relu),
keras.layers.MaxPool2D(pool_size=2 ,strides=2 ,padding=’same’),
keras.layers.Flatten(),
keras.layers.Dense(1024 ,activation =tf.nn.relu),
keras.layers.Dense(100 ,activation=tf.nn.softmax),
])
编译/执行。评估。
def compile(self):
CNNMnist.model.compile(
optimizer=keras.optimizers.Adam() ,
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=[‘accuracy’]
)
return None
def fit(self):
CNNMnist.model.fit(self.train ,self.train_label ,epochs=1 ,batch_size=32)
return None
def ecaluate(self):
test_loss,test_acc=CNNMnist.model.evaluate(self.test ,self.test_label)
print(test_loss ,test_acc)
return None
卷积神经网络案例实现
#归一化
self.train = self.train /255.0
self.test = self.test /255.0
其余的代码同上节
正则化（Regularization）介绍 - 偏差方差
梯度下降的优化：限制权重；期望为0的正态分布；
梯度下降的优化，主要是数学方面。正则化的数学意义不大，主要是工程方面的意义。
数据集的划分
三个数据集：训练集（train set）、验证集（development set）、测试集（test set）
6：3：1 的比例（或者其他比例），进行交叉验证，选出最好的模型。
偏差-方差分解（bias-variance decomposition） 是解释学习算法泛化能力的一种重要工具
泛化误差： 数据集的偏差、方差、噪声。泛化性能是学习算法的能力、数据的充分性、以及学习任务的难度决定
偏差：度量学习算法的期望预测与真实值的偏离程度，刻画学习算法的拟合能力
方差：度量同样大小的训练集的变动所导致的性能变化，刻画数据扰动所造成的影响
噪声：表达当前任务上任何学习算法所能达到的期望泛化误差的下界，刻画学习问题本身的难度
那么偏差、方差和数据集划分到底有什么关系？
1 训练集的错误率较小，验证集/测试集的错误率较大，说明模型存在较大方差，可能出现过拟合
2 训练集和测试集误差都很大，且两者接近，说明模型存在较大方差，可能出现欠拟合
3 反之，训练集和测试集错误率很小，且两者接近，说明模型效果比较好
*算法优化和正则化的区别？
算法优化是针对问题选模型、层数、激活函数；
正则化是处理过拟合中训练集/测试集（实际问题）的能力不一致；
正则化的方法：
1 L1和L2
2 DropOut
3 早停止
欧姆剃刀：简单模型比复杂模型的泛化能力好
正则化，即在成本函数中加入一个正则化项（惩罚项），惩罚模型的复杂度。防止网络过拟合。
逻辑回归L1和L2
L2又叫做权重衰减（减小的慢）
keras.regularizers.l1(0.01)
keras.regularizers.l2(0.01)
keras.regularizers.l1_l2(l1=0.01 ,l2=0.01)
DroupOut正则化
Drouput-regularition Model (随机丢弃)
keep_prob = 0.8
其他正则经验
早停止法（Early stop）
*
数据增强
通过多种组合变换达成增加数据集大小
剪切 旋转/翻转 缩放 对比度变换 噪声扰动 颜色变换
翻转 tf.image.random_flip_left_right
旋转 tf.image.rotate
剪裁 tf.image.random_crop
数据增强在理论上，不会增加噪声。
经典分类网络结构
AlexNet
总参数数量： 60M = 6000万 ， 5层卷积+3层全连接
使用非线性激活函数： Relu
防止过拟合的方法：Dropout
进化历史： AlexNet -- NIN -- (VGG / GoogLeNet) -- ResNet
VGG
2014年分类第二（第一是GoogleNet），定位任务第一
参数量大，140M = 1.4亿
模型分两种 16层，19层
为保持精确度，改进内存，引入Inception模块
MLP： 卷积1X1 NIN ： 网络中的网络
参数/权重 数量的减少：
1 看作对三个通道进行线性组合
2 通常卷积后加入非线性函数，这里加入激活函数，理解成一个简单MLP
实际中的Inception Modul：
卷积神经网络的学习可视化过程
使用Pre_trained模型进行VGG预测
tensorflow.keras.applications有很多现有模型。
from tensorflow.python.keras.applications.vgg16 import VGG16
from tensorflow.python.keras.applications.vgg16 import preprocess_input,decode_prediction
from tensorflow.python.keras.preprocessing.image import load_img, img_to_array
def predict():
model = VGG16()
print(model.summary())
image = load_img('' ,target_size = (224 ,224))
image = image_to_array(image)
print(image.shape)
#输入卷积中，需要四维结构
image = image.reshape((1 ,image.shape[0] ,image.shape[1] ,image.shape[2] ))
#VGG16进行归一化处理
image = preprocess_input(image)
y_predictions = model.predict(image)
print(y_predictions)
# 1000个类别里，“老虎”图片的维度是最大的
#VGG16解码工具
label = decode_predictions(y_predictions)
print("预测类别：%s ,概率是%s" % (label[0][0][1] ,label[0][0][2])) //获取其中元组
if __name__ == '__main__':
predict()
以上内容，是使用VGG进行迁移学习。
神经网络调优与BN层
知道常用的一些超参数
知道BN层的意义以及数学原理
算法层面：
学习率α （一般自学习）
β1 β2 ：Adam优化算法的超参数，通常设置0.9 0.999 10-8
λ：正则化网络参数
网络层面：
hidden units : 各隐藏层神经元个数
layers: 神经网络层数
调参技巧：
合理参数设置：
学习率α： 0.001 0.01 0.1 跨度尽量大
算法参数β： 0.999 0.995 0.998 尽量接近1
试参数很步骤很麻烦，如何让整个过程简单？
批标准化 BN （Batch Normaliztion）：
2015年2月的arxiv论文
内部协变量偏移 （internal covariate shift）的现象，通过标准层化来解决。
使用批标准化的图像分类，效果优于人类。
深藏网络中，不止是初始的特征输入，而隐藏层也有输出，所以对深层网络层的每一层层级进行批标准化。
防止分母为0
原作者不希望方差1均值0，所以增加参数γ β
增加参数γ β（同W b一样），可以用各种梯度下降算法更新γ β的值，如同更新神经网络权重一样。为什么？
如果方差1均值0，那么得到较差的模型。
如果测试集中的数据，分布不一样，这个网路可能就不能准确区分。这种情况下需要重新训练。
1 Batch Normalization的作用是减少 Internal Covation Shift带来的影响，让模型的鲁棒性更强。
2 Batch Normalization的作用，使得均值和方差保持固定（每层由γ β决定），不同层学习到不同的分布状态
3 因此厚层的学习更容易些，Batch Normalization 减少各层W和b之间的耦合性，让各层更加独立，实现自我训练学习的效果。
CNN（卷积神经网络） 的内容复习
激活函数的选择？
非线性的Relu比tanh好，避免梯度消失。
感受野/边缘检测 的概念
网络层的组成？
一个或多个卷积层、池化层以及全连接层等组成
卷积层（Convolutions）
池化层（Subsampling）
卷积层的目的是什么？
提取特征 filter
卷积核 padding stride
Valid填充/Same原图大小
多通道卷积
池化层的作用？
作用：减少图片的特征数量
最大池化/平均池化
stride （类似卷积核）
部分代码
Conv2D
MaxPooling
正则化的作用？
作用：避免过拟合
训练好（迭代过多，层过深），效果差（测试机、线上效果差）
L2 Lp
消除噪声
Droupout为什么有效？
当确定已发生过拟合现象时，
来保证损失函数是单调下降的。
其他的正则化方法/训练方法？
早停止
数据增强（旋转/裁剪等等）
经典的网络结构？
LeNet
参数6万
AlexNet
2012年，参数6M=6000万，5层卷积+3层全连接
VGG
1.4亿参数，输入224*224*3 ，1000个分类
GoogleNet
引入Inception结构，500万参数
什么是Inception结构？
卷积层代替全连接 / Conv2D 代替 Dense
参数量减少
案例： 迁移学习Pre_trained的VGG16模型，识别图片“老虎”
批标准化的作用？
手动超参数的网络调优。
解决 内部协变量 的现象。
减少各个层W和b之间的耦合性，让各层更加独立，实现自我训练学习的效果。
迁移学习（Transfer Learning）
利用旧领域（数据、任务或模型）的相似性，将旧领域学习或训练好的模型，应用到新的领域中。
相反，机器学习系统很容易从海量数据中学习到一个鲁棒性很强的系统。
方法：
最常见的 fine tuning （微调）。
已训练好的模型，叫Pre-trained model
任务A海量数据已训练好的模型（1000类图片识别），新增任务B（250类图片识别）
1 可以在最后输出层（全连接层），在1000基础上，新增250个神经元
2 如果B数据量小，我们对A所有层进行freeze（通过Tensorflow的trainable=False参数实现），剩下层部分进行参数调整
3 如果B数据量大，我们对A中一半或者大部分的层进行freeze，剩下的部分layer进行新任务数据基础的微调。
迁移学习案例介绍
基于Keras中的VGG对五种图片类别的识别。
思路和步骤：
读取本地图片数据及类别
keras.preprocessing.image import ImageDataGenerator提供读取转换功能
模型的结构修改（添加自定义的分类层）
freeze掉原始VGG模型
编译以及训练和保存模型方式
输入数据进行预测
迁移学习--数据读取
train_generator = ImageDataGenerator()
生产图片的批次张量并且提供数据增强功能
rescale = 1.0/255 标准化
zca_whitening = False #zca白化的作用是针对图片进行PCA降维操作，减少图片冗余信息。
等等
import tensorflow as tf
from tensorflow.python import keras
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
class TransferModel(object):
def __init__(self):
self.train_generator = ImageDataGennerator(rescale = 1.0 / 255.0)
self.test_generator = ImageDataGennerator(rescale = 1.0 / 255.0)
self.train_dir = "./data/train"
self.test_dir = "./data/test"
self.image_size = (244 ,244)
self.batch_size = 32
def get_local_data(self):
train_gen = self.train_generator.flow_from_directory(
self.train_dir,
traget_size = (244 ,244),
class_model = self.image_size,
batch_size = self.batch_size,
shuffle = True
)
test_gen = self.train_generator.flow_from_directory(
self.test_dir,
traget_size = (244 ,244),
class_model = self.image_size,
batch_size = self.batch_size,
shuffle = True
)
return train_gen,test_gen
if __name__ == '__main__':
tm = TransferModel()
train_gen ,test_gen = tm.get_local_data()
print(train_gen)
print(test_gen)
for data in train_gen:
print(data)
模型定义
谷歌提供的NoTop模型：
VGG16不包含最后的三个全链接层。用来做fine tuning，专门开源模型。
keras_application/vgg16.py
self.base_ model = VGG16(weights = 'imagenet' ,include_top = Fasle)
weights='imagenet'，意思是VGG在imagenet比赛中预训练的权重，使用resnet训练
模型修改
VGG模型的修改添加全连接层 GlobalAveragePooling2D
全局池化：
图像分类任务中，模型经过最后CNN层的尺寸为[batch_size ,img_width ,img_height ,channels]，通常做法是街一个flaten layer，将尺寸改为[batch_size ,w h channels]再至少链接一个FC layer。这样做的问题：模型参数越多，容易过拟合
利用pooling layer来代替最后的FC layer
参数Dense 8 * 8 * 2048 * 1000
参数Conv2D 1 * 1 * 2048 * 1000
*如果正常训练，那么参数数量不可缺少、很重要
def refine_vgg_model(self):
'''
微调VGG结构：
5blocks后面+全局平均池化（减少迁移学习的参数数量） + 两个全连接层
'''
#获取NoTop模型输出
x = self.base_model.outputs[0]
#在输出层后面增加我们结构
x = keras.layers.GlobalAveragePooling2D()(x)
x = keras.layers.Dense(1024 ,activation = rf.nn.relu)(x)
y_predict = keras.layers.Dense(5 ,activation=tf.nn.softmax)
transfer_model = keras.Model(input=self.base_model.inputs ,outputs = y_predict)
return transfer_model
freeze VGG模型
如果参数数量小，可以全部层freeze（trainable = False）
def freeze_vgg_model(self):
for layer in self.base_model.layers:
layer.trainable = False
#主代码
tm.freeze_vgg_model()
tm.compile(model)
tm.fit_generator(model ,train_gen ,test_gen)
#class tranfer类
trainfer_model = keras.models.Model(
input=self.base_model.inputs ,
outputs = y_predict
)
transfer_model.compile(
optimizer = keras.optimizers.Adam(),
loss = keras.losses.sparse_categotical_crossentropy,
metrics=['accuracy']
)
#class tranfer类的自定义fit方法
def fit_generator(self ,model ,train_gen ,test_gen)
keras.callbacks.ModelCheckpoint('./ckpt/transfer_{epoch:02d}-{val_acc:.2d}.h5',
mointor='val_acc',
save_weight_only = True,
save_best_only = True,
model = 'auto',
period = 1
)
transfer_model.fit_generator(
train_gen ,
epochs = 3,
validation_data = test_gen,
callbacks=[model]
)
freeze模型训练 And 模型预测
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator ,load_img ,img_to_array
#class transfer类
def predict(self ,model):
#加载模型 transfer_model
model.load_weights("./ckpt/transfer_02-0/93.h5")
#读取图片、处理
load_img(./data/test/dinosaurs/400.jpg ,target_size = (224 ,224))
image = img_to_array(image)
print(image.shape)
#四维（224 ，224 ，3）-> （1 ，224 ，224 ，3）
// image = tf.reshape(image ,[1 ,image.shape[0], image.shape[1], image.shape[2],] )
image = image.reshape(image ,[1 ,image.shape[0], image.shape[1], image.shape[2],] )
#处理图像内容，归一化处理等，进行预测
img = preprocess_input(img)
print(img.shape)
y_predict = model.predict(img)
index = np.argmax(y_predict ,axis = 1)
print(self.label_dict[str(index[0])])
#预测结果进行处理
image = preprocess_input(image)
predictions = model.predict(image)
print(predictions)
案例--商品物体检测
项目已部署上线，Web检测，百度机器人识别段。
Tensorflow server部署，SSD和YOLO
目标检测算法：
两步走：先区分推荐，再进行目标分类。
R-CNN FastR-CNN FasterR-CNN
端到端：采用一个网络一步到位
YOLO SSD
回顾图片分类的原理：
图片经过卷积、激活、池化相关层，最后加入全连接层。
常见CNN模型： AlexNet VGG GoogleNet ResNet
目标检测不仅仅是分类这么简单，还需要输出位置信息。
语义切割主要评估指标： IOU （Intersection over Union）
B-Box （bounding box）： （x ,y ,w ,h）
Ground-truth bounding box : 图片真实标记的框 （人手画的）
Predicted bounding box：预测时标记的框
对于分类的概率，还是使用交叉熵损失。
位置信息具体的数值，可使用MSE俊芳误差损失（L2损失）
R-CNN （region proposal method 候选区域方法）
为什么要循环检测？
因为检测数量不确定。解决办法overfeat模型。
Overfeat方法： K X M
缺点是暴力破解，计算量大
CVPR2014年提出的R-CNN。
R-CNN的原理
论文中的步骤：
1 默认找图片中2k个候选区域region proposal
2 基于ALexNet的227X227，通过CNN提取特征，2000X4096维矩阵
3 2000X4096维矩阵经过SVM分类器（假如20种分类，SVM是二分类，则有20个SVM SVM分类已经过时）， 2000X20种类别矩阵，[2000 20]得分。
4 对2000X20矩阵做非极大抑制（NMS non-maximum suppression） ，去除重复、不好的候选区域
5 修正B-box，对bbox做出回归微调
*候选区域（Region of Interset）
选择性搜索（SelectiveSearch），首先将每个像素分组，然后相近的像素进行合并。
候选框的长宽不固定，不能直接输入ALexNet CNN网络
修正候选区域
bbox regression，回归用于修正筛选后的候选区域，使之归于ground-truth。默认是线性关系，因为最后筛选出来的候选区域和ground-truth。
目标检测—评估指标
IoU交并比
平均精确率（mean average precision map）
精确率/召回率 *
R-CNN总结
在VOC2007数据集上平均map准确率达到66%
缺点：
1 训练阶段多： 微调网络+SVM训练+训练边框回归器
2 训练耗时：5000张图片，几百G的特征文件
3 处理速度慢： GPU VGG16需要47秒
4 图形形状变化： 需要crop/warp进行处理
R-CNN改进 SPPNet
改进哪里了？改进的详细细节？
R-CNN最慢的步骤在哪里？ 进行卷积运算。
通过spatial pyramid pooling 将特征图转换成特定大小的特征向量。
CNN的改进 — Fast R-CNN
提出Rol pooling，然后整合模型，把CNN Rolpooling 分类器SVM B-box一起训练。
Softmax替换SVM
多任务损失 Multi-task loss
1 对分类损失，是一个N+1的softmax输出
2 对回归损失，是一个4XN的输出的regression
所以使用平均绝对误差MAE 损失，即L1损失
fine-tuning 训练
微调时，调整CNN + Rol pooling + softmax
调整bbox regression回归中的参数
缺点
使用Selective Search 提取 Region Proposals ，没有真正的端到端，比较耗时
CNN改进 Faster R-CNN
Faster R-CNN 看成区域特征生成网路，加上Fast R-CNN。
区域特征生成网络 Region Proposal Networks RPN ：
用于生成region proposals，称之为anchors。
通过softmax判断anchors属于前景foreground还是背景background
bounding box regression 修正anchors获得精确的proposals
获取经验的2000个候选区
候选区域的训练：
正负anchors样本比例 1:3
RPN的原理
目的是得到候选区域
使用nxn的大小窗口去扫描特征图，得到K个候选窗口
Faster R-CNN 的训练：
1 RPN的训练，得到score分高的候选区域
2 Fast R-CNN的训练
Fast R-CNN classificaion : 得到正确的分类
Fast R-CNN regression (B-Box loss) : 得到更好的位置
开源Keras Faster RCNN 模型介绍
地址 GitHub - jinfagang/keras_frcnn: Keras Implementation of faster-rcnn
代码笔记
assert 断言 ，不成立条件中断执行
__feature__ 使用python3的新特性
__iter__ 迭代器，返回的是对象本身
**kw 关键词参数，用于词典
pip install opencv-python #视频的OpenCv用途更大
代码架构：
工程里所有trainable = True
YOLO（You only look once）
YOLOv4 结构 ：
GoogleNet + 4个卷积 + 2个全连接层
惊不惊喜，意不意外？
例如：
1 每一个单元格，计算两个候选框
2 对9 X2 = 18 个候选框，进行概率计算、筛选
单元格 Grid Cell
YOLOv4 网络层输出大小： 7X7X30
每个Grid Cell 需要预测一个物体类别
每个Grid Cell 预测两个（默认）B-box位置，两个B-box置信度。
一个B-box： xmin ymin xmax ymax confidence
两个B-box 4 +1 + 4 + 1 有10个值
所以一个Grid Cell 需要输出 10 + 20（预测） = 30 个值
Grid Cell 的Score值
如没有object，score是0
如果有object，score是object和confidence的乘积
一个object的ground truth，两个B-box的IoU值比较，确定自己的物体。
不同于faster rcnn 的anchors，yolo的框坐标直接由网络输出，在 7X7X30 的30里面。但是RPN网络对其优化得到一个更准的坐标和是否北京类别。
非最大抑制（NMS）
每个B-box的Class-Specific Confidence Score以后，设置阈值，滤掉概率低的bbox，对每个类别过滤IoU，得到最终检测结果
损失
三个部分 B-box损失 + confidence损失 + classfication 损失
与Faster R-CNN对比
Faster R-CNN利用RPN网络与真实值调整候选区域，然后再进行候选区域和卷积特征结果映射的特征向量，通过与真实值优化网络预测结果。
Yolo将这两步合成一步，直接网络输出预测结果进行优化。
YOLO是回归法的代表，特点是块，缺点是准确率（Grid Cell 中间）
YOLO对运动跟踪的效果更好
SSD （Single Shot MultiBox Detector）
2016年发表arxiv论文。结合yolo的回归思想和faster rcnn的anchors机制。
核心：不同尺度的特征图上采取卷积核预测一系列Default Bounding Boxes的类别、坐标偏移。
SSD以VGG-16为基础，使用VGG的前五个卷积，后面增加从Conv6开始的五个卷积结构，输入图片要求300*300
SSD会把中间不同尺度的特征图，再会进行BoundingBox的Detector & Classifier 预测
SSD会把中间不同尺度的feature map特征图都使用PriorBox层。
Detector & Classifier
PriorBox层由 Detector & Classifier 组成。
Detector & Classifier 的三个部分：
1 PriorBox层： 生成default boxes ，默认候选框
2 吸取YOLO邮电 Conv3X3 ： 网络生成localization ，confidence，4个位置、预测概率、置信度
PriorBox 层 类似B-Box：
生成候选框后，prior_variance 做微调
SSD多个 Detector & Classifier的作用？
核心是在不同尺度的特征图上，进行Detector&Classifier容易使SSD观察到更小的物体。
localization & confidence
两者主要是用来过滤、训练
训练与测试流程
输入-> 输出-> 结果与ground truth标记样本回归损失计算-> 反向传播，更新权值
样本标记
将prior box 与ground truth box 做匹配，标记正负样本。先不训练8735张图片，先进行置信度筛选，并且训练指定的正负样本。
default boxes按照正负样本控制positive ：negative = 1 ： 3
损失 losses
网络输出预测predict box 与ground truth回归变换之间的损失计算，置信度采用Softmax Loss（Faster R-CNN 是logstic loss），位置采用L1 losses。
测试test流程
输入 -> 输出 -> nms -> 输出
SSD兼顾速度和精度。
Keras SSD 代码结构
num_priors = 6 #配置好的关联框
案例： 利用SSD做图片的物体检测
输入数据，找几千个PriorBox，在非最大抑制NMS，输出结果
from nets.ssd_net import ssd300
from utils.ssd_utils import BBoxUtility
from tensorflow.python.keras.preprocesing.iamge import load_img ,img_to_array
from scipy.misc import imread
from keras.applications.imagenet_utils import preprocess_input
import os
class SSDTest(object):
def __init__:
self.classes_name = ['car' ,'sofa' 等等]
self.classes_nums = len(self.classes_name) + 1
self.input_shape = (300 ,300 ,3)
def test(self):
#SSD300模型的输入以及加载参数
model=SSD300(self.input_shape ,num_classes=self.classes_nums)
#加载训练好的模型
model.load_weights("./ckpt/weights_SSD300.hdf5" ,by_name=True)
#读取多个本地路径测试图片，preprocess_input以及保存图片像素值
feature = []
images_data = []
for path in os.listdir("./images"):
img_path = os.path.join("./images" ,path)
image=load_img(img_path ,target_size=(self.input_shape[0] ,self.input_shape[0] ))
image = img_to_array(image)
feature.append(image)
images_data.append( imreadimread(img_path)) # 图片数据集
#预处理需要数组，不能是列表
#inputs = preprocess_input(feature)
#print(inputs)
inputs = preprocess_input(np.array(feature))
print(inputs)
#模型预测结果，处理7308个PriorBox
pred= model.predict(inputs ，batch_size =1 ,verbvose=1)
print(pred.shape)
#形状是(2 ,7308 ,33)
# 2 张图片数量 ，7308个PriorBox ，33： 4+ 21+ 88（position confidence ）
#进行非最大抑制算法处理NMS
bb = BBoxUtility(self.classes_nums)
res = bb.detection_out(pred)
print(res)
print(res[0].shape ,res[1].shape)
# (200 ,6) (200,6)
#NMS后还有200个PriorBox ,6是label location xmin ymin xmax ymax
return res ,images_data
def teg_picture(self ,images_data ,outputs):
for i , img in enumerate(images_data):
pre_label = outputs[i][: , 0]
pre_conf = outputs[i][: , 1]
pre_xmin = outputs[i][: , 2]
pre_ymin = outputs[i][: , 3]
pre_xmax = outputs[i][: , 4]
pre_ymax = outputs[i][: , 5]
print("pre_label:{} ,pre_conf:() ,pre_xmin:{} ,pre_ymin:{} ,pre_xmax:{} ,pre_ymax:{}" .format(pre_label ,pre_conf ,pre_xmin ,pre_ymin ,pre_xmax ,pre_ymax))
#概率预测结果太多，置信度大于90%的图片我们看一下
top_indeicts = [i for i ,conf in enumerate(pre_conf) if conf > 0.9]
top_label_indices = pre_label[top_indeicts].tolist()
top_xmin = pre_xmin[top_indices]
top_ymin = pre_ymin[top_indices]
top_xmax = pre_xmax[top_indices]
top_ymax = pre_ymax[top_indices]
print("after filter top_label:{} ,top_conf:() ,top_xmin:{} ,top_ymin:{} ,top_xmax:{} ,top_ymax:{}" .format(top_label ,top_conf ,top_xmin ,top_ymin ,top_xmax ,top_ymax))
#matplot画图显示
#定义21种颜色，显示图片
#currentAxis增加图片中文本显示和标记
colors = plt.m.hsv(np.linspace(0,1,21)).tolist()
plt.imshow(img / 255.)
currentAxis = plt.gca()
for i in range(top_conf.shape[0]):
xmin = int(round(top_xmin[i] * img.shape[1]))
ymin = int(round(top_ymin[i] * img.shape[0]))
xmax = int(round(top_xmax[i] * img.shape[1]))
ymax = int(round(top_ymax[i] * img.shape[0]))
#获取图片的预测概率，名称，定义显示颜色
score = top_conf[i]
label = int(top_label_indices[i])
label_name = self.classes_name[label-1]
display_txt = '{:0.2f} ,{}'.format(score ,label_name)
coords = (xmin ,ymin),xmax - xmin + 1 ,ymax - ymin + 1
color = colors[label]
#显示方框
currentAxis.add_patch(plt.Rectangle(*coords ,fill= False ,edgecolor = color , 'alpha':0.5))
lt.show()
return None
if __name___ == '__main__':
ssd = SSDTest()
res = ssd.test()
ssd.tag_picture(images_data ,outputs)
常用目标检测检测数据集介绍
pascal Visual Object Classes
Classification Detection Segementation PersonLayout 由VOC2007 VOC2012提供
Open Images Dataset V4
谷歌提供
2018年发布190万张图片，针对600类别的1540万个边框盒
XML对应标记信息
<Annotations>
<size></size>
<object>
<bndbox>
<xmin></xmin>
<ymin></ymin>
<xmax></ymax>
<ymax></ymax>
</bndbox>
</object>
</Annotations>
数据集的目标标记
提供给训练的数据样本，图片和目标真实结果
特定的场景会缺少标记图片
LabelImg的图形图像注释工具。基于QT。注释以PASCAL格式保存。
Linux MacOS的教程
商品检测数据集的处理
XML的结构解析
from xml.etree import ElementTree as ET
tree = et.parse(filename) #获得树形结构
tree.getroot() #获得树根
root.find() 与 findall()进行查询XML每个标签的内容
商品检测数据集的存储
复习（一）
YOLO的结构：
GoogleNet + 4个卷积 + 2个全连接
网络输出大小 7X7X30
单元格Grid Cell
一个B-box： xmin ymin xmax ymax confidence
损失
bbox损失 + confidence损失 + classification损失
优点
速度快，适合视频和跟踪
缺点
对单元格分割处不敏感，对小物体不敏感
SSD的结构：
基本结构同YOLO
Detector & Classifier 块：
组成PriorBox层，默认的候选框群
Conv3X3 组成localization，4个位置偏移
Conv3X3 组成confidence，21个类别置信度（需要区分前景背景）
数据集的制作和保存
复习（二）
训练时的fine tuning
案例 商品物体检测
上章节的分类图片迭代器
keras.preprocessing.image import ImageDataGeneratorm
本地图片，标注分割数据类
from utils.detection_generate import Generator
1 初始化模型参数以及冻结部分结构
2 compile与fit_generator
from utils.ssd_losses import MultiboxLoss
指定模型冻结
freeze = [
'input_1' , 'conv1_1' ,'conv1_2','pool1',
'conv2_1'，‘conv2_2’，‘pool2’，
'conv3_1'， 'conv3_2' , 'conv3_3' ,'pool3'
]
for L in self.model.layers :
if L.name in freeze:
L.trainable = False
SSD训练商品数据
略。
同以上，无新意。
问题解决与多GPU训练
GPU训练
英伟达
tf.keras DistrubutionSttrategy
OpenCv介绍
视频捕捉
cv.VideoCapture()
CV颜色空间转换
HSV（色相 饱和度 明度）是一种将RGB彩色模型的点，在圆柱种表示的方法。
cv2.COLOR_BGR2GRAY
cv2.COLOR_BGR2HSV
cv2.COLOR_BGR2RBGB
CV画框画图
案例--视频检测介绍获取帧数据
太简单了。
CV采集视频，上文的SSD，NMS置信区间判断物体。
案例--视频检测介绍获取帧数据（2）
文本框显示
显示FPS
总结：
1 图片的大小会变化
2 图片的信息shape ，随着处理，Tensor一直在变。
模型部署逻辑
- 1 将训练好的模型，进行导出，tf.export工具
- 2 使用TensorFlow serving 开启模型服务
- 3 编写模型客户端程序，在web后台使用
模型格式pb
可以支持热更新
Serving服务安装开启和Serving
使用Docker部署
Client端代码
Serving Client 代码编写
这样做的目的，是服务端/客户端的分离，方便成员分工。
再次见到 Session
Web服务开启和Client对接
讲道理，这里不是核心知识，而且有点过时。
百度机器人接口对接
不完全开源
百度飞浆平台
收费
很多好的模型
人脸识别
模型基础都是BERT
人脸SDK
文字识别
识别笔画、语系
进行CNN识别
高精度的文字识别（生僻字）
调超参数
车牌识别
通用发票识别
语音识别
讯飞、搜狗、阿里
普通话、四川话、粤语
特征
傅里叶转换，正弦周期性
语音合成
物体检测课程总结
*
上述视频录制时间是2019年。技术2至5年一代，理论20至50年一代。
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
