SSD网络结构(vgg16)

import tensorflow as tf
slim = tf.contrib.slim
import numpy as np

import keras
from keras.layers import Conv2D, MaxPooling2D, Lambda, Input, Dense, Flatten, BatchNormalization
from keras.models import Model
from keras.layers.core import Dropout
from keras import optimizers
from keras.callbacks import ReduceLROnPlateau,TensorBoard

from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

from sklearn.preprocessing import OneHotEncoder

def slim_arg_scope_with_bn(weight_decay=0.00001,
                 activation_fn=tf.nn.relu,
                 batch_norm_decay=0.997,
                 batch_norm_epsilon=1e-5,
                 normalizer_fn = slim.batch_norm,
                 batch_norm_scale=True):

    batch_norm_params = {
      'decay': batch_norm_decay,
      'epsilon': batch_norm_epsilon,
      'scale': batch_norm_scale,
      'updates_collections': tf.GraphKeys.UPDATE_OPS,
      }

    with slim.arg_scope(
          [slim.conv2d],
          weights_regularizer=slim.l2_regularizer(weight_decay),
          weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
          activation_fn=activation_fn,
          normalizer_fn=normalizer_fn,
          normalizer_params=batch_norm_params,
          padding="same"):

        with slim.arg_scope([slim.batch_norm], **batch_norm_params) as arg_sc:
            return arg_sc 

net = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(image)
net = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(net)
net = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='block1_pool')(net)
net = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(net)
net = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(net)
net = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='block2_pool')(net)
net = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(net)
net = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(net)
net = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(net)
net = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='block3_pool')(net)
    conv4_clf_reg = slim.conv2d(net, (classes_ + 4)* num_default_pic, [3, 3], stride=1, scope="conv4_3_clf")

with tf.name_scope("SSD") as scope:
    with slim.arg_scope(slim_arg_scope_with_bn()):

        net = slim.conv2d(net, 1024, [3, 3], stride=2, scope=scope+"conv7_1")
        net = slim.conv2d(net, 1024, [1, 1], stride=1, scope=scope+"conv7_2")
        fc7_clf_reg = slim.conv2d(net, (classes_ + 4)* 4, [3, 3], stride=1, padding="same", scope=scope+"7_clf")

        net = slim.conv2d(net, 256, [1, 1], stride=1, scope=scope+"conv8_1")
        net = slim.conv2d(net, 512, [3, 3], stride=2, scope=scope+"conv8_2")
        conv8_clf_reg = slim.conv2d(net, (classes_ + 4)* 4, [3, 3], stride=1, padding="same", scope=scope+"8_clf")

        net = slim.conv2d(net, 128, [1, 1], stride=1, scope=scope+"conv9_1")
        net = slim.conv2d(net, 256, [3, 3], stride=2, scope=scope+"conv9_2")
        conv9_clf_reg = slim.conv2d(net, (classes_ + 4)* 4, [3, 3], stride=1, padding="same", scope=scope+"9_clf")

        net = slim.conv2d(net, 128, [1, 1], stride=1, scope=scope+"conv10_1")
        net = slim.conv2d(net, 256, [3, 3], stride=1, padding="valid", scope=scope+"conv10_2")
        conv10_clf_reg = slim.conv2d(net, (classes_ + 4)* 4, [3, 3], stride=1, padding="same", scope=scope+"10_clf")

        net = slim.conv2d(net, 128, [1, 1], stride=1, scope=scope+"conv11_1")
        net = slim.conv2d(net, 256, [3, 3], stride=1, padding="valid", scope=scope+"conv11_2")
        conv11_clf_reg = slim.conv2d(net, (classes_ + 4)* 4, [3, 3], stride=1, padding="same", scope=scope+"11_clf") 

def flatten_and_concat_layer(clf=True ,*args):

    if clf:
        flatten_layer = [slim.flatten(i[:, :, :, :84]) for i in args]
        concat_layer = tf.concat(flatten_layer, 1)
        L = concat_layer.get_shape().as_list()[1] / classes_
        concat_layer = tf.reshape(concat_layer, [-1, int(L), classes_])
    else:
        flatten_layer = [slim.flatten(i[:, :, :, 84:]) for i in args]
        concat_layer = tf.concat(flatten_layer, 1)

    return  concat_layer

cls_layer = flatten_and_concat_layer(True, conv4_clf_reg, fc7_clf_reg, conv8_clf_reg, conv9_clf_reg, conv10_clf_reg, conv11_clf_reg)
reg_layer = flatten_and_concat_layer(False, conv4_clf_reg, fc7_clf_reg, conv8_clf_reg, conv9_clf_reg, conv10_clf_reg, conv11_clf_reg)