手写Yolov3
文章目录
1.yolo3简介
1.电脑如何确定一个猫的位置？
这个需要四个参数：
yolo3 是怎么确定这个 四个参数的？
- 防止失真，会在框的上下边缘添加黑框。
- 分成多个网格，大网格负责对大物体的检测，小网格负责对小物体的检测。
2.Yolov3 的网络结构
1.yolov3中的结构
左边这一部分，属于一个特征提取网络，在残差网络里面，最终会生成三个形状不同的特征图。然后他们放到一个 “解码的过程” 中，后边就是如何利用这些特征来完成目标的检测。
- 13*13 的特征图会经过五次卷积，本别有两个输出，往上的是 卷积+上采样（放大原图），最后得到 26*26 的一个的图像，然后和上边 26*26 的结合。。另一个方向，是经过3*3 的卷积，然后再经过 1x1 的通道调整，就得到一个预测结果。
如果理解最下边（13*13*75）呢？ 他是 13*13*3*25的图像， 25 也可以分为（4+1+20）。。13x13 是表示13个格子，3是表示有三个先验框，后边的25是（4，1,20），4表示鲜艳框相对于中心点的一个偏移量，分别是（x，y，h，w），后边的1表示的是置信度，20是分类结果。
2. darknet53 特征提取部分的结构：
残差网路的特点是容易优化，并且能够通过增加相当的深度来提高准确率，器内部的残差块应用了跳跃连接。缓解了深度神经网路中，增加深度带来的梯度消失的问题。
上边主要是应用了残差神经网络，大小变成了 原来的 1/2，通道数变成了原来的 2 倍。
在输入的时候通道数在黑白图的时候，是1，在彩色图的时候，是3，
在中间的时候，通道数是卷积核的数量，可以参考下边的博客
3 x 3 x 3 的卷积核，三个层最后要加起来，所以还是一个卷积核，通道数还是 1 .卷积核的通道数要和进行卷积操作的数据的通道数一样。
python 里面的 * 和 ** 的区别
一个 * 是数组，两个 ** 是字典
3. darknet53 网络，代码：
from functools import wraps
from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.regularizers import l2
from utils.utils import compose
#--------------------------------------------------#
# 单次卷积，可以矮核正则化，
#--------------------------------------------------#
@wraps(Conv2D)
def DarknetConv2D(*args, **kwargs):
darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}
darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides')==(2,2) else 'same'
darknet_conv_kwargs.update(kwargs)
return Conv2D(*args, **darknet_conv_kwargs)
#---------------------------------------------------#
# 卷积块
# DarknetConv2D + BatchNormalization + LeakyReLU
#---------------------------------------------------#
def DarknetConv2D_BN_Leaky(*args, **kwargs):
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
#---------------------------------------------------#
# 卷积块
# DarknetConv2D + BatchNormalization + LeakyReLU
#---------------------------------------------------#
def resblock_body(x, num_filters, num_blocks):
x = ZeroPadding2D(((1,0),(1,0)))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (3,3), strides=(2,2))(x)
for i in range(num_blocks):
y = DarknetConv2D_BN_Leaky(num_filters//2, (1,1))(x)
y = DarknetConv2D_BN_Leaky(num_filters, (3,3))(y)
x = Add()([x,y])
return x
#---------------------------------------------------#
# darknet53 的主体部分
#---------------------------------------------------#
def darknet_body(x):
x = DarknetConv2D_BN_Leaky(32, (3,3))(x)
x = resblock_body(x, 64, 1) #只重复一次
x = resblock_body(x, 128, 2)
x = resblock_body(x, 256, 8) #会重复8次，
feat1 = x #把x提取出来，
x = resblock_body(x, 512, 8) #进行8次残差的处理，输出的是 512
feat2 = x #在把 x 提取出来，是 26*26*512
x = resblock_body(x, 1024, 4)
feat3 = x #再提取出来 13*13*1024
return feat1,feat2,feat3
3.如何通过提取出来的特征，获得预测结果
导入modules，import与from…import的不同之处在于，简单说：
如果你想在程序中用argv代表sys.argv，
则可使用：from sys import argv
一般说来，应该避免使用from…import而使用import语句，
因为这样可以使你的程序更加易读，也可以避免名称的冲突
concat： 堆叠，组合
代码实现中的 body 部分
from functools import wraps
#这个装饰器的功能，在不改变原有功能的基础上，添加额外的功能。
import numpy as np
import tensorflow as tf
from keras import backend as K
from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.models import Model
from keras.regularizers import l2
from darknet53 import darknet_body
from utils.utils import compose
#--------------------------------------------------#
# 单次卷积
#--------------------------------------------------#
@wraps(Conv2D)
def DarknetConv2D(*args, **kwargs):
darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}
darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides')==(2,2) else 'same'
darknet_conv_kwargs.update(kwargs)
return Conv2D(*args, **darknet_conv_kwargs)
#---------------------------------------------------#
# 卷积块
# DarknetConv2D + BatchNormalization + LeakyReLU
#---------------------------------------------------#
def DarknetConv2D_BN_Leaky(*args, **kwargs):
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
#---------------------------------------------------#
# 特征层->最后的输出
#---------------------------------------------------#
def make_last_layers(x, num_filters, out_filters):
# 五次卷积
# 里面包括了正则化和标准化。然后还有激活函数。
x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
# 将最后的通道数调整为outfilter
y = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
#最后进行通道数调整。
y = DarknetConv2D(out_filters, (1,1))(y)
return x, y
#---------------------------------------------------#
# 特征层->最后的输出
# yolov 的主题部分
#---------------------------------------------------#
def yolo_body(inputs, num_anchors, num_classes):
# 生成darknet53的主干模型
# 从 darknet53里面获得三个特征层
# 三个特征层的 shape 分别是 52*52 ，256
# 26*26*512
# 13*13*1024
feat1,feat2,feat3 = darknet_body(inputs)
darknet = Model(inputs, feat3)
# 第一个特征层的处理
# y1=(batch_size,13,13,3,85) #85是因为coco有85个标签
x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
# x 是对应五次卷积后的结果。
# 上采样的环节在这里进行处理。
x = compose(
DarknetConv2D_BN_Leaky(256, (1,1)), #卷积
UpSampling2D(2))(x) #上采样
x = Concatenate()([x,feat2]) #与上一层进行了一个堆叠。
# 第二个特征层
# y2=(batch_size,26,26,3,85)
#堆叠后的结果又进行了一次 make_last_layers
#y2就是第二个特征层处理后的结果。
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1,1)), #卷积
UpSampling2D(2))(x) #上采样
x = Concatenate()([x,feat1]) #然后进行了堆叠
# 第三个特征层
# y3=(batch_size,52,52,3,85)
x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
return Model(inputs, [y1,y2,y3]) #model 是获得返回模型；
4.预测结果解码
yolov 3 每个预测点对应着三个预测框的位置。注意最后一个维度85代表的是什么意思？
预测框的中心，是怎么加出来的？
先验框是怎么回事：是根据已有的数据集，算出来的，一个物体较大和较小物体的平均长宽。
下边是个例子
10,13, 16,30, 33,23,
30,61, 62,45, 59,119,
116,90, 156,198, 373,326
一般越深的卷积层，信息丢失会比较大，所以一般都是使用较小的卷积层，用来检测小物体。
import os
import numpy as np
import copy
import colorsys
from timeit import default_timer as timer
from keras import backend as K
from keras.models import load_model
from keras.layers import Input
from PIL import Image, ImageFont, ImageDraw
from yolo3 import yolo_body,yolo_eval
from utils.utils import letterbox_image
#--------------------------------------------#
# 使用自己训练好的模型预测需要修改2个参数
# model_path和classes_path都需要修改！
#--------------------------------------------#
class YOLO(object):
_defaults = {
"model_path": 'model_data/yolo_weights.h5',
"anchors_path": 'model_data/yolo_anchors.txt',
"classes_path": 'model_data/coco_classes.txt',
"score" : 0.5,
"iou" : 0.3,
"model_image_size" : (416, 416)
}
@classmethod
def get_defaults(cls, n):
if n in cls._defaults:
return cls._defaults[n]
else:
return "Unrecognized attribute name '" + n + "'"
#---------------------------------------------------#
# 初始化yolo
#---------------------------------------------------#
def __init__(self, **kwargs):
self.__dict__.update(self._defaults)
self.class_names = self._get_class() #获得所有类的名字
self.anchors = self._get_anchors() #获得所有的先验框 【9,2】
self.sess = K.get_session() #tf自己的一个结构
self.boxes, self.scores, self.classes = self.generate()
#---------------------------------------------------#
# 获得所有的分类
#---------------------------------------------------#
def _get_class(self):
classes_path = os.path.expanduser(self.classes_path)
with open(classes_path) as f:
class_names = f.readlines()
class_names = [c.strip() for c in class_names]
return class_names
#---------------------------------------------------#
# 获得所有的先验框
#---------------------------------------------------#
def _get_anchors(self):
anchors_path = os.path.expanduser(self.anchors_path)
with open(anchors_path) as f:
anchors = f.readline()
anchors = [float(x) for x in anchors.split(',')]
return np.array(anchors).reshape(-1, 2)
#---------------------------------------------------#
# 获得所有的分类
#---------------------------------------------------#
def generate(self):
model_path = os.path.expanduser(self.model_path) #预训练好的model 的位置
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# 计算anchor数量
# anchor 字面意思是锚 是指的固定的框点。
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
# 载入模型，如果原来的模型里已经包括了模型结构则直接载入。
# 否则先构建模型再载入
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path)#把权重载入进去。
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# 画框设置不同的颜色
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
# 打乱颜色
np.random.seed(10101)
np.random.shuffle(self.colors)
np.random.seed(None)
self.input_image_shape = K.placeholder(shape=(2, ))
# 把预测结果 转变为图片上的预测结果
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
num_classes, self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
#---------------------------------------------------#
# 检测图片
# 下边的就是把图像画出来的过程。
#---------------------------------------------------#
def detect_image(self, image):
start = timer()
# 调整图片使其符合输入要求
new_image_size = (self.model_image_size[0],self.model_image_size[1])
boxed_image = letterbox_image(image, new_image_size)
image_data = np.array(boxed_image, dtype='float32')
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
# 预测结果
out_boxes, out_scores, out_classes = self.sess.run(
[self.boxes, self.scores, self.classes],
feed_dict={
self.yolo_model.input: image_data,
self.input_image_shape: [image.size[1], image.size[0]],
K.learning_phase(): 0
})
print('Found {} boxes for {}'.format(len(out_boxes), 'img'))
# 设置字体
font = ImageFont.truetype(font='font/simhei.ttf',
size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
thickness = (image.size[0] + image.size[1]) // 300
small_pic=[]
# 下边的代码就是画画了。
for i, c in list(enumerate(out_classes)):
predicted_class = self.class_names[c]
box = out_boxes[i]
score = out_scores[i]
top, left, bottom, right = box
top = top - 5
left = left - 5
bottom = bottom + 5
right = right + 5
top = max(0, np.floor(top + 0.5).astype('int32'))
left = max(0, np.floor(left + 0.5).astype('int32'))
bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
# 画框框
label = '{} {:.2f}'.format(predicted_class, score)
draw = ImageDraw.Draw(image)
label_size = draw.textsize(label, font)
label = label.encode('utf-8')
print(label)
if top - label_size[1] >= 0:
text_origin = np.array([left, top - label_size[1]])
else:
text_origin = np.array([left, top + 1])
for i in range(thickness):
draw.rectangle(
[left + i, top + i, right - i, bottom - i],
outline=self.colors[c])
draw.rectangle(
[tuple(text_origin), tuple(text_origin + label_size)],
fill=self.colors[c])
draw.text(text_origin, str(label,'UTF-8'), fill=(0, 0, 0), font=font)
del draw
end = timer()
print(end - start)
return image
def close_session(self):
self.sess.close()
5.Lost 组成
loss值是 y_pre 和 y_true 的值得对比
6.训练自己的数据集
如何制作 voc 格式的数据集？
voc格式的数据集：
- Annotations :用来存放标签。一般是 XML 格式
- ImageSets :用来存放那些文件用来验证，哪些用来训练。主要是是用main 函数中的 train_txt
- JPEGImages ：他是用来存放图片的。（纯图片）
7.labeling 的安装和使用
其实网上给了很多 labelimg 的方法，作者认为最简单的方法就是使用 cmd 里面的 pip 进行直接的安装。
直接输入 pip install labelimg 会自动进行安装
然后运行 labelimg 会进行安装
具体如何使用的方法，用的时候再直接视频吧。
8.断点续练 && 使用自己的模型进行训练
1.可以直接把前边的层给冻结，训练后边，因为前边的权重比较适合于目标检测的算法。
2.利用 log 里面的权重，当准确度不在下降的时候，停止运行，使用log里面的函数进行训练，具体到用的时候再看吧。
