目标检测算法-yolo-v4代码详解(代码片段)

from functools import wraps
from keras import backend as K
from keras.layers import Conv2D,Add,ZeroPadding2D,UpSampling2D,Concatenate,MaxPooling2D,Layer,Input
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.regularizers import l2
from keras.layers import Activation
from keras import Model
#将定义好的函数添加到keras系统中
from keras.utils import get_custom_objects


# class Mish(Activation):
#     def __init__(self,activation):
#         super(Mish, self).__init__(activation)
#         self.__name__ ="Mish"
# def mish(inputs):
#     return inputs*K.tanh(K.softplus(inputs))
# get_custom_objects().update("Mish":Mish(mish))

class Mish(Layer):
    def __init__(self):
        super(Mish, self).__init__()

    def call(self,inputs):
        return inputs * K.tanh(K.softplus(inputs))



#darknet单次卷积
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)

#卷积块
def DarknetConv2D_BN_Mish(x,*args,**kwargs):
    no_bias_kwargs="use_bias":False
    no_bias_kwargs.update(kwargs)
    x=DarknetConv2D(*args,**no_bias_kwargs)(x)
    x=BatchNormalization()(x)
    #x=Activation("Mish")(x)
    x=Mish()(x)
    return x


def DarknetConv2D_BN_Leaky(x, *args, **kwargs):
    no_bias_kwargs = "use_bias": False
    no_bias_kwargs.update(kwargs)
    x = DarknetConv2D(*args, **no_bias_kwargs)(x)
    x = BatchNormalization()(x)
    # x=Activation("Mish")(x)
    x = LeakyReLU(alpha=0.1)(x)
    return x



def resblock_body(x,num_filters,num_blocks,all_narrow=True):
    preconv1 =ZeroPadding2D(padding=((1,0),(1,0)))(x)
    preconv1 =DarknetConv2D_BN_Mish(preconv1,num_filters,(3,3),strides=(2,2))
    #生成一个大的残差边
    shortconv =DarknetConv2D_BN_Mish(preconv1,num_filters//2 if all_narrow else num_filters,(1,1))
    #主干部分的卷积
    mainconv =DarknetConv2D_BN_Mish(preconv1,num_filters//2 if all_narrow else num_filters,(1,1))

    for i in range(num_blocks):
        x=DarknetConv2D_BN_Mish(mainconv,num_filters//2,(1,1))
        x=DarknetConv2D_BN_Mish(x,num_filters//2 if all_narrow else num_filters,(3,3))

        mainconv=Add()([mainconv,x])
    postconv =DarknetConv2D_BN_Mish(mainconv,num_filters//2 if all_narrow else num_filters,(1,1))
    route = Concatenate()([postconv,shortconv])

    return DarknetConv2D_BN_Mish(route,num_filters,(1,1))


def darknet_body(x):
    x =DarknetConv2D_BN_Mish(x,32,(3,3))
    x=resblock_body(x,64,1,False)
    x=resblock_body(x,128,2)
    x=resblock_body(x,256,8)
    feat1=x
    x=resblock_body(x,512,8)
    feat2=x
    x=resblock_body(x,1024,4)
    feat3=x
    return feat1,feat2,feat3

def Label_Smoothing(y_true,label_smoothing):
    y_true = np.cast(y_true,tf.float32)
    num_classes = float((y_true.shape[-1]))
    label_smoothing = K.constant(label_smoothing,dtype=K.floatx())
    return y_true * (1.0-label_smoothing) + label_smoothing/num_classes

#b1预测框,b2真实框
def box_ciou(b1,b2):
    b1_xy = b1[...,:2]
    b1_wh = b1[...,2:4]
    b1_wh_half = b1_wh/2.
    b1_mins = b1_xy-b1_wh_half
    b1_maxes = b1_xy+b1_wh_half

    b2_xy = b2[...,:2]
    b2_wh = b2[...,2:4]
    b2_wh_half = b2_wh/2.0
    b2_mins = b2_xy-b2_wh_half
    b2_maxes = b2_xy+b2_wh_half

    intersect_mins = K.maximum(b1_mins,b2_mins)
    intersect_maxes = K.minimum(b1_maxes,b2_maxes)
    intersect_wh = K.maximum(intersect_maxes-intersect_mins,0.)
    intersect_area = intersect_wh[...,0]*intersect_wh[...,1]
    b1_area = b1_wh[...,0]*b1_wh[...,1]
    b2_area = b2_wh[...,0]*b2_wh[...,1]

    union_area = b1_area+b2_area-intersect_area
    #K.epsilon()返回一个浮点数
    iou = intersect_area/(union_area+K.epsilon())
    #计算中心距离
    center_distance = K.sum(K.square(b1_xy-b2_xy),axis=-1)

    #找到包裹两个框的最小框的左上角跟右下角
    enclose_mins = K.minimum(b1_mins,b2_mins)
    enclose_maxes = K.maximum(b1_maxes,b2_maxes)
    enclose_wh = K.maximum(enclose_maxes-enclose_mins,0.0)

    #计算对角线距离
    enclose_diagonal = K.sum(K.square(enclose_wh),axis=-1)

    ciou = iou - 1.0 *(center_distance)/(enclose_diagonal+K.epsilon())

    v = 4*K.square(tf.math.atan2(b1_wh[...,0],b1_wh[...,1])-tf.math.atan2(b2_wh[...,0],b2_wh[...,1]))/(math.pi*math.pi)

    alpha = v/(1.0-iou+v)
    ciou = ciou-alpha*v
    ciou = K.expand_dims(ciou,axis=-1)

    return ciou



def get_loss_con(ytrue,ypre,noobj_scale,object_mask,IOU):
    object_mask = K.squeeze(object_mask,axis=-1)
    con_delta = object_mask*(ypre*IOU-ytrue) + noobj_scale*(1-object_mask)*(ypre*IOU-ytrue)
    loss_con = K.sum(K.square(con_delta),list(range(1,4)))

    return loss_con

import numpy as np
import matplotlib.pyplot as plt


def compute_eta_t(eta_min, eta_max, T_cur, Ti):
    pi = np.pi
    eta_t = eta_min + 0.5 * (eta_max - eta_min) * (np.cos(pi * T_cur / Ti) + 1)
    return eta_t


# 每Ti个epoch进行一次restart。
Ti = [20, 40, 80, 160]
n_batches = 200
eta_ts = []
for ti in Ti:
    T_cur = np.arange(0, ti, 1 / n_batches)
    for t_cur in T_cur:
        eta_ts.append(compute_eta_t(0, 1, t_cur, ti))

n_iterations = sum(Ti) * n_batches
epoch = np.arange(0, n_iterations) / n_batches

plt.plot(epoch, eta_ts)
plt.show()