Exemple #1
0
def deform_center_cnn(class_num, trainable=False, GPU=1):
    conv_args = {
        'trainable': trainable,
        'kernel_initializer': Orthogonal(gain=1.0, seed=None),
        'kernel_regularizer': OrthLocalReg2D,
        'padding': 'same'
    }

    sep_conv_args = {
        'trainable': trainable,
        'kernel_initializer': Orthogonal(gain=1.0, seed=None),
        'kernel_regularizer': OrthLocalRegSep2D,
        'padding': 'same'
    }

    inputs = l = Input((None, None, 3), name='input')
    input_target = Input((1, ), name='input_target')

    # norm_input = RGB2Gray()(inputs)
    norm_input = ImageNorm()(inputs)
    # norm_input = inputs
    stem_stride = (2, 2)
    # conv11
    l = Conv2D(32, (3, 3), strides=stem_stride, name='conv11',
               **conv_args)(norm_input)
    l = Activation('relu', name='conv11_relu')(l)
    l = BatchNormalization(name='conv11_bn')(l)

    l2 = InvConv2D(32, (3, 3),
                   strides=stem_stride,
                   name='inv_conv11',
                   **conv_args)(norm_input)
    l2 = Activation('relu', name='inv_conv11_relu')(l2)
    l2 = BatchNormalization(name='inv_conv11_bn')(l2)

    l = concatenate([l, l2])

    l5 = SeparableConv2D(64, (5, 5),
                         strides=(2, 2),
                         name='conv5_11_12',
                         **sep_conv_args)(l)
    l5 = Activation('relu', name='conv5_11_12_relu')(l5)
    l5 = BatchNormalization(name='conv5_11_12_bn')(l5)

    l3 = SeparableConv2D(64, (3, 3),
                         strides=(2, 2),
                         name='conv3_11_12',
                         **sep_conv_args)(l)
    l3 = Activation('relu', name='conv3_11_12_relu')(l3)
    l3 = BatchNormalization(name='conv3_11_12_bn')(l3)

    l = concatenate([l3, l5])

    l = SeparableConv2D(128, (3, 3), name='conv12_1', **sep_conv_args)(l)
    l = Activation('relu', name='conv12_1_relu')(l)
    l = BatchNormalization(name='conv12_1_bn')(l)

    l = SeparableConv2D(128, (1, 1), name='conv12_2', **sep_conv_args)(l)
    l = Activation('relu', name='conv12_2_relu')(l)
    l = BatchNormalization(name='conv12_2_bn')(l)

    l = SeparableConv2D(128, (3, 3), name='conv13', **sep_conv_args)(l)
    l = Activation('relu', name='conv13_relu')(l)
    l = BatchNormalization(name='conv13_bn')(l)

    l = SeparableConv2D(256, (3, 3),
                        strides=(2, 2),
                        name='conv14',
                        **sep_conv_args)(l)
    l = Activation('relu', name='conv14_relu')(l)
    l = l14 = BatchNormalization(name='conv14_bn')(l)

    l = SeparableConv2D(256, (3, 3), name='conv21', **sep_conv_args)(l)
    l = Activation('relu', name='conv21_relu')(l)
    l = BatchNormalization(name='conv21_bn')(l)

    l = SeparableConv2D(256, (3, 3), name='conv22', **sep_conv_args)(l)
    l = Activation('relu', name='conv22_relu')(l)
    l = BatchNormalization(name='conv22_bn')(l)

    l = Add(name='residual_14_22')([l14, l])

    # conv22
    # l_offset = ConvOffset2D(192, name='conv32_offset')(l)
    # l = Conv2D(256, (3, 3), strides=(2, 2), name='conv23', **conv_args)(l)
    # l = Activation('relu', name='conv23_relu')(l)
    # l = l23 = BatchNormalization(name='conv23_bn')(l)
    #
    # l = Conv2D(256, (3, 3), name='conv31', **conv_args)(l)
    # l = Activation('relu', name='conv31_relu')(l)
    # l = BatchNormalization(name='conv31_bn')(l)

    # l = Conv2D(256, (1, 1), name='conv32', **conv_args)(l31)
    # l = Activation('relu', name='conv32_relu')(l)
    # l = BatchNormalization(name='conv32_bn')(l)

    # l = Conv2D(256, (3, 3), name='conv33', **conv_args)(l)
    # l = Activation('relu', name='conv33_relu')(l)
    # l = BatchNormalization(name='conv33_bn')(l)
    # l = Add(name='residual_23_33')([l23, l])

    l_offset = ConvOffset2D(256, name='conv33_offset')(l)
    l = SeparableConv2D(512, (3, 3),
                        strides=(2, 2),
                        name='conv41',
                        **sep_conv_args)(l_offset)
    l = Activation('relu', name='conv41_relu')(l)
    l = BatchNormalization(name='conv41_bn')(l)

    l = SeparableConv2D(512, (3, 3), name='conv42', **sep_conv_args)(l)
    l = Activation('relu', name='conv42_relu')(l)
    l = BatchNormalization(name='conv42_bn')(l)

    # l_offset = ConvOffset2D(512, name='conv35_offset')(l)
    l = SeparableConv2D(512, (3, 3), name='conv43', **sep_conv_args)(l)
    l = Activation('relu', name='conv43_relu')(l)
    l = BatchNormalization(name='conv43_bn')(l)

    # l = LocallyConnected2D(512, (3, 3), name='conv44', padding='valid')(l)
    # l = Activation('relu', name='conv44_relu')(l)
    # l = BatchNormalization(name='conv44_bn')(l)

    l = SeparableConv2D(1024, (3, 3),
                        strides=(2, 2),
                        name='conv51',
                        **sep_conv_args)(l)
    l = Activation('relu', name='conv51_relu')(l)
    l = BatchNormalization(name='conv51_bn')(l)

    # l_offset = ConvOffset2D(1024, name='conv35_offset')(l)
    l = SeparableConv2D(1024, (3, 3), name='conv52', **sep_conv_args)(l)
    l = Activation('relu', name='conv52_relu')(l)
    l = BatchNormalization(name='conv52_bn')(l)

    l = SeparableConv2D(1024, (3, 3), name='conv53', **sep_conv_args)(l)
    l = Activation('relu', name='conv53_relu')(l)
    l = BatchNormalization(name='conv53_bn')(l)

    # out
    l = GlobalAvgPool2D(name='avg_pool')(l)
    # l = MaxPooling2D(name='max_pool_final')(l)
    # l = Flatten(name='flatten_maxpool')(l)

    l = Dense(512, name='fc1', trainable=trainable)(l)
    l = Activation('relu', name='fc1_relu')(l)

    l = Dense(256, name='fc2', trainable=trainable)(l)
    l = feature = Activation('relu', name='fc2_relu')(l)

    l = Dense(class_num, name='fc3', trainable=trainable)(l)
    outputs = l = Activation('softmax', name='out')(l)

    if GPU == 1:
        centers = Embedding(class_num, 256)(input_target)
        l2_loss = Lambda(
            lambda x: K.sum(K.square(x[0] - x[1][:, 0]), 1, keepdims=True),
            name='l2_loss')([feature, centers])
        Model(inputs=[inputs, input_target], outputs=[outputs, l2_loss])
    elif GPU == 0:
        return inputs, outputs
    else:
        BODY = Model(inputs=[inputs, input_target], outputs=[outputs, feature])
        BODY = make_parallel(BODY, GPU)
        softmax_output = Lambda(lambda x: x, name='output')(BODY.outputs[0])

        centers = Embedding(class_num, 256)(input_target)
        l2_loss = Lambda(
            lambda x: K.sum(K.square(x[0] - x[1][:, 0]), 1, keepdims=True),
            name='l2_loss')([BODY.outputs[1], centers])
        model_withcneter = Model(inputs=BODY.inputs,
                                 outputs=[softmax_output, l2_loss])
        return model_withcneter
Exemple #2
0
def get_large_deform_cnn2(class_num, trainable=False, GPU=1):
    # init = Orthogonal(gain=1.0, seed=None)
    init = 'random_normal'

    inputs = l = Input((200, 200, 3), name='input')
    input_target = Input((1, ), name='input_target')

    #norm_input = ImageNorm()(inputs)
    norm_input = inputs

    # conv11
    l = Conv2D(32, (3, 3),
               padding='same',
               name='conv11',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(norm_input)
    l = Activation('relu', name='conv11_relu')(l)
    l = BatchNormalization(name='conv11_bn')(l)

    l2 = InvConv2D(32, (3, 3),
                   padding='same',
                   name='inv_conv11',
                   trainable=trainable,
                   kernel_initializer=init,
                   kernel_regularizer=OrthLocalReg2D)(norm_input)
    l2 = Activation('relu', name='inv_conv11_relu')(l2)
    l2 = BatchNormalization(name='inv_conv11_bn')(l2)

    l3 = Conv2D(32, (3, 1),
                padding='same',
                name='conv11_2',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(norm_input)
    l3 = Activation('relu', name='conv11_2_relu')(l3)
    l3 = BatchNormalization(name='conv11_2_bn')(l3)

    l5 = Conv2D(32, (1, 3),
                padding='same',
                name='conv11_3',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(norm_input)
    l5 = Activation('relu', name='conv11_3_relu')(l5)
    l5 = BatchNormalization(name='conv11_3_bn')(l5)

    l4 = InvConv2D(32, (3, 1),
                   padding='same',
                   name='conv11_2i',
                   trainable=trainable,
                   kernel_initializer=init,
                   kernel_regularizer=OrthLocalReg2D)(norm_input)
    l4 = Activation('relu', name='conv11_2i_relu')(l4)
    l4 = BatchNormalization(name='conv11_2i_bn')(l4)

    l6 = InvConv2D(32, (1, 3),
                   padding='same',
                   name='conv11_3i',
                   trainable=trainable,
                   kernel_initializer=init,
                   kernel_regularizer=OrthLocalReg2D)(norm_input)
    l6 = Activation('relu', name='conv11_3i_relu')(l6)
    l6 = BatchNormalization(name='conv11_3i_bn')(l6)

    l = concatenate([l, l2, l3, l5, l4, l6])

    # conv12
    # l_offset = ConvOffset2D(32, name='conv12_offset')(l)

    l5 = Conv2D(128, (5, 5),
                padding='same',
                strides=(2, 2),
                name='pool5_11_12',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(l)
    l5 = Activation('relu', name='pool5_11_12_relu')(l5)
    l5 = BatchNormalization(name='pool5_11_12_bn')(l5)

    l3 = Conv2D(128, (3, 3),
                padding='same',
                strides=(2, 2),
                name='pool3_11_12',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(l)
    l3 = Activation('relu', name='pool3_11_12_relu')(l3)
    l3 = BatchNormalization(name='pool3_11_12_bn')(l3)

    l = concatenate([l3, l5])

    l3 = Conv2D(32, (5, 3),
                padding='same',
                name='conv12_2',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(l)
    l3 = Activation('relu', name='conv12_2_relu')(l3)
    l3 = BatchNormalization(name='conv12_2_bn')(l3)

    l5 = Conv2D(32, (3, 5),
                padding='same',
                name='conv12_3',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(l)
    l5 = Activation('relu', name='conv12_3_relu')(l5)
    l5 = BatchNormalization(name='conv12_3_bn')(l5)

    l = Conv2D(128, (3, 3),
               padding='same',
               name='conv12',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv12_relu')(l)
    l = BatchNormalization(name='conv12_bn')(l)

    l = concatenate([l, l3, l5])

    l = Conv2D(128, (3, 3),
               padding='same',
               name='conv13',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv13_relu')(l)
    l = jump = BatchNormalization(name='conv13_bn')(l)

    l = Conv2D(192, (3, 3),
               padding='same',
               strides=(2, 2),
               name='conv14',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv14_relu')(l)
    # l = BatchNormalization(name='conv14_bn')(l)

    l = Conv2D(192, (3, 3),
               padding='same',
               name='conv21',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv21_relu')(l)
    l = BatchNormalization(name='conv21_bn')(l)

    l = Conv2D(192, (3, 3),
               padding='same',
               name='conv22',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv22_relu')(l)
    l = BatchNormalization(name='conv22_bn')(l)

    # conv22
    # l_offset = ConvOffset2D(192, name='conv32_offset')(l)
    l = Conv2D(256, (3, 3),
               padding='same',
               strides=(2, 2),
               name='conv23',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv23_relu')(l)
    l = BatchNormalization(name='conv23_bn')(l)

    l = Conv2D(256, (3, 3),
               padding='same',
               name='conv31',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv31_relu')(l)
    l31 = BatchNormalization(name='conv31_bn')(l)

    # l = Conv2D(256, (1, 1), padding='same', name='conv32', trainable=trainable, kernel_initializer=init, kernel_regularizer=OrthLocalReg2D)(l31)
    # l = Activation('relu', name='conv32_relu')(l)
    # l = BatchNormalization(name='conv32_bn')(l)

    l = Conv2D(256, (3, 3),
               padding='same',
               name='conv33',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv33_relu')(l)
    l = BatchNormalization(name='conv33_bn')(l)
    l = Add(name='residual_31_32')([l31, l])

    lj = Conv2D(256, (3, 3),
                padding='same',
                strides=(2, 2),
                name='jump_pool',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(jump)
    lj = Activation('relu', name='jump_pool_relu')(lj)
    lj = BatchNormalization(name='jump_pool_bn')(lj)

    lj = Conv2D(256, (3, 3),
                padding='same',
                strides=(2, 2),
                name='jump_pool2',
                trainable=trainable,
                kernel_initializer=init,
                kernel_regularizer=OrthLocalReg2D)(lj)
    lj = Activation('relu', name='jump_pool2_relu')(lj)
    lj = BatchNormalization(name='jump_pool2_bn')(lj)

    l = concatenate([l, lj])

    l_offset = ConvOffset2D(512, name='conv33_offset')(l)
    l = Conv2D(512, (3, 3),
               padding='same',
               strides=(2, 2),
               name='conv41',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l_offset)
    l = Activation('relu', name='conv41_relu')(l)
    l = BatchNormalization(name='conv41_bn')(l)

    l = Conv2D(512, (3, 3),
               padding='same',
               name='conv42',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv42_relu')(l)
    l = BatchNormalization(name='conv42_bn')(l)

    # l_offset = ConvOffset2D(512, name='conv35_offset')(l)
    l = Conv2D(512, (3, 3),
               padding='same',
               name='conv43',
               trainable=trainable,
               kernel_initializer=init,
               kernel_regularizer=OrthLocalReg2D)(l)
    l = Activation('relu', name='conv43_relu')(l)
    l = BatchNormalization(name='conv43_bn')(l)

    # out
    # l = GlobalAvgPool2D(name='avg_pool')(l)
    l = MaxPooling2D(name='max_pool_final')(l)
    l = Flatten(name='flatten_maxpool')(l)
    l = Dense(768,
              name='fc1',
              trainable=trainable,
              kernel_initializer=init,
              kernel_regularizer=OrthLocalReg1D)(l)
    l = Activation('relu', name='fc1_relu')(l)

    l = feature = Dense(256,
                        name='fc2',
                        trainable=trainable,
                        kernel_initializer=init)(l)
    l = Activation('relu', name='fc2_relu')(l)

    l = Dense(class_num, name='fc3', trainable=trainable)(l)
    outputs = l = Activation('softmax', name='out')(l)

    if GPU == 1:
        centers = Embedding(class_num, 256)(input_target)
        l2_loss = Lambda(
            lambda x: K.sum(K.square(x[0] - x[1][:, 0]), 1, keepdims=True),
            name='l2_loss')([feature, centers])
        Model(inputs=[inputs, input_target], outputs=[outputs, l2_loss])
    elif GPU == 0:
        return inputs, outputs
    else:
        BODY = Model(inputs=[inputs, input_target], outputs=[outputs, feature])
        BODY = make_parallel(BODY, GPU)
        softmax_output = Lambda(lambda x: x, name='output')(BODY.outputs[0])

        centers = Embedding(class_num, 256)(input_target)
        l2_loss = Lambda(
            lambda x: K.sum(K.square(x[0] - x[1][:, 0]), 1, keepdims=True),
            name='l2_loss')([BODY.outputs[1], centers])
        model_withcneter = Model(inputs=BODY.inputs,
                                 outputs=[softmax_output, l2_loss])
        return model_withcneter
Exemple #3
0
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
    with tf.device(GPU):
        K.set_session(sess)

        # ---
        # Deformable CNN
        inputs, outputs = get_large_res_deform_cnn2(class_num, trainable=True)
        model = Model(inputs=inputs, outputs=outputs)

        model.summary()

        if GPU_NUM > 1:
            model = make_parallel(model, GPU_NUM)

        if args.weight is not None:
            print(colored("[weight] %s" % args.weight, color='green'))
            model.load_weights(args.weight)

        optim = Adam(1e-4)
        # optim = SGD(1e-4, momentum=0.99, nesterov=True)
        loss = categorical_crossentropy
        # model._weights('../models/deform_cnn.h5')

        model.compile(optim, [loss, loss], metrics=['accuracy'])
        checkpoint = ModelCheckpoint("deform_cnn_inv_best.h5",
                                     monitor='concatenate_3_acc',
                                     save_best_only=True)
        checkpoint_tl = ModelCheckpoint("deform_cnn_inv_trainbest.h5",
Exemple #4
0
parser = argparse.ArgumentParser()
parser.add_argument("-w", "--weight", help=".h5 model weight file.")
parser.add_argument("-g", "--gpu_num", help="gpu number used when training this model.")
parser.add_argument("-c", "--class_num", help="number of class of classifier's output")

args = parser.parse_args()
class_num = int(args.class_num) if args.class_num is not None else 6

K.set_learning_phase(0)
inputs, outputs = get_test_cnn(class_num, trainable=False)
# inputs, outputs = get_large_deform_cnn(class_num, trainable=True)
# inputs, outputs = get_large_deform_cnn(class_num, trainable=True)
model = Model(inputs=inputs, outputs=outputs)

if args.gpu_num:
    model = make_parallel(model, int(args.gpu_num))

model.load_weights(args.weight)
model.summary()

if args.gpu_num:
    print(colored('[Deparallelize model]', color='green'))
    single_gpu_model = model.layers[-2]  # TODO: subscript of layers may change?
    model = single_gpu_model
    model.summary()
    model_name = args.weight[:-3] + '_1gpu.h5'
    model.save_weights(model_name)

    print(colored('Restart this script with new .h5 weight:', color='red'))
    print(model_name)
    sys.exit(0)