python类VGG16的实例源码

def apply_vgg(tensor):
    print('importing VGG16...')
    from keras.applications.vgg16 import VGG16
    from keras import backend as K
    K.set_session(ct.get_session()) # make sure we are in the same universe

    vgginst = VGG16(include_top=False, weights='imagenet', input_tensor=tensor)
    return vgginst.get_layer('block1_conv2').output

def build_vgg(img_shape=(3, 224, 224), n_classes=1000, n_layers=16, l2_reg=0.,
                load_pretrained=False, freeze_layers_from='base_model'):
    # Decide if load pretrained weights from imagenet
    if load_pretrained:
        weights = 'imagenet'
    else:
        weights = None

    # Get base model
    if n_layers==16:
        base_model = VGG16(include_top=False, weights=weights,
                           input_tensor=None, input_shape=img_shape)
    elif n_layers==19:
        base_model = VGG19(include_top=False, weights=weights,
                           input_tensor=None, input_shape=img_shape)
    else:
        raise ValueError('Number of layers should be 16 or 19')

    # Add final layers
    x = base_model.output
    x = Flatten(name="flatten")(x)
    x = Dense(4096, activation='relu', name='dense_1')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu', name='dense_2')(x)
    x = Dropout(0.5)(x)
    x = Dense(n_classes, name='dense_3_{}'.format(n_classes))(x)
    predictions = Activation("softmax", name="softmax")(x)

    # This is the model we will train
    model = Model(input=base_model.input, output=predictions)

    # Freeze some layers
    if freeze_layers_from is not None:
        if freeze_layers_from == 'base_model':
            print ('   Freezing base model layers')
            for layer in base_model.layers:
                layer.trainable = False
        else:
            for i, layer in enumerate(model.layers):
                print(i, layer.name)
            print ('   Freezing from layer 0 to ' + str(freeze_layers_from))
            for layer in model.layers[:freeze_layers_from]:
               layer.trainable = False
            for layer in model.layers[freeze_layers_from:]:
               layer.trainable = True

    return model

def build_vgg(img_shape=(3, 224, 224), n_classes=1000, n_layers=16, l2_reg=0.,
                load_pretrained=False, freeze_layers_from='base_model'):
    # Decide if load pretrained weights from imagenet
    if load_pretrained:
        weights = 'imagenet'
    else:
        weights = None

    # Get base model
    if n_layers==16:
        base_model = VGG16(include_top=False, weights=weights,
                           input_tensor=None, input_shape=img_shape)
    elif n_layers==19:
        base_model = VGG19(include_top=False, weights=weights,
                           input_tensor=None, input_shape=img_shape)
    else:
        raise ValueError('Number of layers should be 16 or 19')

    # Add final layers
    x = base_model.output
    x = Flatten(name="flatten")(x)
    x = Dense(4096, activation='relu', name='dense_1')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu', name='dense_2')(x)
    x = Dropout(0.5)(x)
    x = Dense(n_classes, name='dense_3_{}'.format(n_classes))(x)
    predictions = Activation("softmax", name="softmax")(x)

    # This is the model we will train
    model = Model(input=base_model.input, output=predictions)

    # Freeze some layers
    if freeze_layers_from is not None:
        if freeze_layers_from == 'base_model':
            print ('   Freezing base model layers')
            for layer in base_model.layers:
                layer.trainable = False
        else:
            for i, layer in enumerate(model.layers):
                print(i, layer.name)
            print ('   Freezing from layer 0 to ' + str(freeze_layers_from))
            for layer in model.layers[:freeze_layers_from]:
               layer.trainable = False
            for layer in model.layers[freeze_layers_from:]:
               layer.trainable = True

    return model

def run(epochs, PP=None, rgb_mean=None):
    # Load Data
    ig = image.ImageDataGenerator()  # rescale=1/255.0)
    it = ig.flow_from_directory(
        'tiny-imagenet-200/train/', target_size=(64, 64), batch_size=1000)
    ystr2y = it.class_indices
    Xt, Yt, yt = img.load_validation_data(
        it.class_indices, 'tiny-imagenet-200/val/images/', 'tiny-imagenet-200/val/val_annotations.txt')

    Num_classes = 200
    Input_shape = (64, 64, 3)

    # Build a Model
    vgg_model = VGG16(include_top=False)
    x = Input(shape=Input_shape)
    if PP:
        h = PP(8, 0.5, rgb_mean)(x)
        base_model = get_new_base_model_x_h(vgg_model, x, h)
    else:
        base_model = get_new_base_model_x(vgg_model, x)

    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    predictions = Dense(Num_classes, activation='softmax')(x)
    model = Model(inputs=base_model.input, outputs=predictions)

    for layer in base_model.layers:
        layer.trainable = False
    model.compile(optimizer='rmsprop',
                  loss='categorical_crossentropy', metrics=['accuracy'])

    # Training
    model.fit_generator(it, 1000, epochs=epochs, validation_data=(Xt, Yt))

    # Class Activiation Map
    conv_model = base_model
    Ft = conv_model.predict(Xt[:20])

    Wb_all = model.get_weights()
    L_Wb = len(Wb_all)

    W_dense = Wb_all[L_Wb - 2]
    b_dense = Wb_all[L_Wb - 1]
    W_dense.shape, b_dense.shape

    CAM = CAM_process(Ft, yt, W_dense)

    from kakao import bbox
    for i in range(20):
        plt.figure(figsize=(12, 4))
        plt.subplot(1, 3, 1)
        plt.imshow(Xt[i])
        plt.subplot(1, 3, 2)
        CAM4 = img.cam_intp_reshape(CAM[i], Xt[i].shape[:2])
        plt.imshow(CAM4, interpolation='bicubic', cmap='jet_r')
        plt.subplot(1, 3, 3)
        plt.imshow(Xt[i])
        plt.imshow(CAM4, interpolation='bicubic', cmap='jet_r', alpha=0.5)
        plt.show()