Esempio n. 1
0
    def percept_loss(input_image, reconstructed_image):
        vggface = VGGFace(include_top=False, input_shape=x_dim, model='vgg16')
        vgg_layers = ['conv1_1']
        outputs = [vggface.get_layer(l).output for l in vgg_layers]
        model = Model(inputs=vggface.input, outputs=outputs)

        for layer in model.layers:
            layer.trainable = False

        input_image *= 255.0
        reconstructed_image *= 255.0

        input_image = preprocess_input(input_image, mode='tf', data_format='channels_last')
        reconstructed_image = preprocess_input(reconstructed_image, mode='tf', data_format='channels_last')

        h1_list = model(input_image)
        h2_list = model(reconstructed_image)

        if not isinstance(h1_list, list):
            h1_list = [h1_list]
            h2_list = [h2_list]

        p_loss = 0.0
        for h1, h2 in zip(h1_list, h2_list):
            h1 = K.batch_flatten(h1)
            h2 = K.batch_flatten(h2)
            p_loss += K.mean(K.square(h1 - h2), axis=-1)

        return gamma * p_loss
Esempio n. 2
0
def model_from_vgg(last_layer='pool4'):
    """
    returns a neural network with layers upto <last_layer> from vgg16
    with the weights for the vggface layers preloaded
    """
    vgg_model = VGGFace(model='vgg16', include_top=False, input_shape=(224, 224, 3))
    X = vgg_model.get_layer(last_layer).output
    layer_shape = vgg_model.get_layer(last_layer).output_shape

    n_encoder_layers = int(np.log2(224/layer_shape[2]))

    for n in range(n_encoder_layers):
        X = Conv2DTranspose(int(layer_shape[3]/(2**(n+1))), (3, 3), activation='relu', padding='same', name='deconv'+str(n+1))(X)
        X = UpSampling2D(size=(2, 2), interpolation='bilinear', name='unpool'+str(n+1))(X)

    mask = Conv2D(1, (3, 3), activation='sigmoid', padding='same', name='mask')(X)

    custom_model = Model(vgg_model.input, mask)
    return custom_model
Esempio n. 3
0
def get_classification_face_match(target_image):
    nb_class = 2
    hidden_dim = 512
    vggmodel = VGGFace(include_top=False, input_shape=(224, 224, 3))
    last_layer = vggmodel.get_layer('pool5').output
    x = Flatten(name='flatten')(last_layer)
    x = Dense(hidden_dim, activation='relu', name='fc6')(x)
    x = Dense(hidden_dim, activation='relu', name='fc7')(x)
    out = Dense(nb_class, activation='softmax', name='fc8')(x)
    identity_model = Model(vggmodel.input, out)
    ## Train the model
    ##Predict
    img = image.load_img(target_image, target_size=(224, 224))
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=0)
    x = utils.preprocess_input(x, version=1)
    preds = identity_model.predict(x)
    print('\n', "VGG16")
    print('\n', preds)
    print('\n', 'Predicted:', utils.decode_predictions(preds))
    return utils.decode_predictions(preds)[0][0][0]
Esempio n. 4
0
#         image = combine_images(generated_images)
#     image = image*127.5+127.5
#     Image.fromarray(image.astype(np.uint8)).save(
# #         "./image_result/generated_image.png")


def get_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--mode", type=str)
    parser.add_argument("--batch_size", type=int, default=128)
    parser.add_argument("--nice", dest="nice", action="store_true")
    parser.set_defaults(nice=False)
    args = parser.parse_args()
    return args


if __name__ == "__main__":
    args = get_args()
    if args.mode == "train":
        image_input = Input(shape=(3, 112, 96))
        vgg_model = VGGFace(input_tensor=image_input,
                            include_top=False,
                            pooling='avg')  # pooling: None, avg or max
        out = vgg_model.get_layer('pool5').output
        vgg_conv = Model(image_input, out)
        train(vgg_conv)
    elif args.mode == "generate":
        generate(BATCH_SIZE=args.batch_size, nice=args.nice)
    elif args.mode == "mse":
        MSE(BATCH_SIZE=args.batch_size)
Esempio n. 5
0
def train(BATCH_SIZE):
    #    Load the training data
    print('Data loading..')
    X_train, y_train, X_test, y_test = Data.loadData('data.h5')
    print('Data Loaded. Now normalizing..')

    X_train = (X_train.astype(np.float32) - 127.5) / 127.5
    y_train = (y_train.astype(np.float32) - 127.5) / 127.5
    print('Data Normalized.')

    #    Optimization setting RMSprop(lr=0.0001, rho=0.9, epsilon=1e-08, decay=0.0)
    d_optim = SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True)
    g_optim = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)
    g_vgg_optim = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)

    #    Vgg model goes here
    image_input = Input(shape=(112, 96, 3))
    vgg_model = VGGFace(input_tensor=image_input,
                        include_top=False,
                        pooling='avg')  # pooling: None, avg or max
    out = vgg_model.get_layer('pool5').output
    vgg_conv = Model(image_input, out)

    #    Generator model goes here
    generator = res_net((112, 96, 3))
    #    Generator = cnn_model()
    generator.compile(loss='mean_squared_error', optimizer=g_optim)

    #    Discriminative model goes here
    discriminator = discriminator_model()
    discriminator.trainable = True
    discriminator.compile(loss='binary_crossentropy', optimizer=d_optim)

    #    Gener_VGG model
    generator_vgg = \
            generator_containing_discriminator(generator, vgg_conv)
    generator_vgg.compile(loss=conv_loss, optimizer=g_vgg_optim)

    #    Gener_Discrim model
    generator_discriminator = \
            generator_containing_discriminator(generator, discriminator)
    generator_discriminator.compile(loss='binary_crossentropy',
                                    optimizer=g_optim)

    for epoch in range(100):
        print("Epoch is", epoch)
        print("Number of batches", int(X_train.shape[0] / BATCH_SIZE))
        for index in range(int(X_train.shape[0] / BATCH_SIZE)):
            lr_image_batch = X_train[index * BATCH_SIZE:(index + 1) *
                                     BATCH_SIZE]
            hr_image_batch = y_train[index * BATCH_SIZE:(index + 1) *
                                     BATCH_SIZE]
            generated_images = generator.predict(lr_image_batch, verbose=0)
            shape = generated_images.shape

            if index % 10 == 0:
                image = save_image(generated_images)
                image = image * 127.5 + 127.5
                #imsave("./image_result/"+ str(epoch)+"_"+ str(index)+ ".png", image)
                #                imsave("./image_result/"+ str(epoch)+"_"+ str(index)+ ".png", image.astype(np.uint8))
                im = Image.fromarray(image.astype(np.uint8))
                im.save("./image_result/" + str(epoch) + "_" + str(index) +
                        ".png")

            X = np.concatenate((hr_image_batch, generated_images))
            y = [1] * BATCH_SIZE + [0] * BATCH_SIZE

            if epoch >= 5:
                #    Discriminative Model Training
                d_loss = discriminator.train_on_batch(X, y)
                print("batch %d d_loss : %f" % (index, d_loss))
                discriminator.trainable = False

                #    Generator Model Training
                g_loss1 = generator.train_on_batch(lr_image_batch,
                                                   hr_image_batch)
                print("batch %d gene_discri_loss : %f" % (index, g_loss1))

                #    Generator_Discri Model Training
                g_loss2 = generator_discriminator.train_on_batch(
                    lr_image_batch, [1] * BATCH_SIZE)
                discriminator.trainable = True
                print("batch %d gene_discri_loss : %f" % (index, g_loss2))
                print(' ')
            else:
                #    Discriminative Model Training
                d_loss = discriminator.train_on_batch(X, y)
                print("batch %d d_loss : %f" % (index, d_loss))
                discriminator.trainable = False

                #    Generator Model Training
                g_loss1 = generator.train_on_batch(lr_image_batch,
                                                   hr_image_batch)
                print("batch %d generator loss : %f" % (index, g_loss1))

                #    Generator_Discri Model Training
                g_loss2 = generator_discriminator.train_on_batch(
                    lr_image_batch, [1] * BATCH_SIZE)
                discriminator.trainable = True
                print("batch %d gene_discri_loss : %f" % (index, g_loss2))

                #    Generate feature labels for the hr_images
                labels = vgg_conv.predict(hr_image_batch)
                g_loss2 = generator_vgg.train_on_batch(lr_image_batch, labels)
                print("batch %d gene_vgg_loss : %f" % (index, g_loss2))

            if index % 10 == 9:
                generator.save_weights('generator', True)
                discriminator.save_weights('discriminator', True)
for i, layer in enumerate(model_F_L.layers):
    layer.name = layer.name + '_f_l'
for i, layer in enumerate(model_F_R.layers):
    layer.name = layer.name + '_f_r'

# Freeze layers that are not needed to train
for layer in model_M_L.layers[:LayersToFreeze_E]:
    layer.trainable = False
for layer in model_M_R.layers[:LayersToFreeze_E]:
    layer.trainable = False
for layer in model_F_L.layers[:LayersToFreeze_E]:
    layer.trainable = False
for layer in model_F_R.layers[:LayersToFreeze_E]:
    layer.trainable = False

last_layer_M_L = model_M_L.get_layer('conv5_3_m_l').output
last_layer_M_R = model_M_R.get_layer('conv5_3_m_r').output
last_layer_F_L = model_F_L.get_layer('conv5_3_f_l').output
last_layer_F_R = model_F_R.get_layer('conv5_3_f_r').output

# Global Average pooling layer at output of 4 networks
modelOutM_L = GlobalAveragePooling2D()(last_layer_M_L)
modelOutM_R = GlobalAveragePooling2D()(last_layer_M_R)
modelOutF_L = GlobalAveragePooling2D()(last_layer_F_L)
modelOutF_R = GlobalAveragePooling2D()(last_layer_F_R)

# Landmark layers
model_land_i = Input((272, ))
model_land_hidden_1 = Dense(272)(model_land_i)
model_land_elev_pred = Dense(NetworkHelper.numElevClasses)(model_land_hidden_1)
model_land_azim_pred = Dense(NetworkHelper.numAzimClasses)(model_land_hidden_1)
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Dropout, Flatten, Convolution2D, MaxPooling2D, ZeroPadding2D
from keras.optimizers import Adam
from keras_vggface import VGGFace
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ModelCheckpoint, EarlyStopping

device_name = tf.test.gpu_device_name()

vgg_face = VGGFace(include_top=True, input_shape=(224, 224, 3))

for layer in vgg_face.layers:
    layer.trainable = False

last_layer = vgg_face.get_layer('fc7/relu').output

out = Dense(1283, activation='softmax', name='fc8')(last_layer)
custom_vgg_face = Model(vgg_face.input, out)

adam = Adam(lr=1e-3, beta_1=0.9, beta_2=0.999)
custom_vgg_face.compile(optimizer=adam,
                        loss='categorical_crossentropy',
                        metrics=['accuracy'])

traindir = r"..\data\VGG_DB\trainSet"
valdir = r"..\data\VGG_DB\validSet"
testdir = r"..\data\VGG_DB\TestSet"

batch_size = 64
input_shape = ()
Esempio n. 8
0
import os
from keras.engine import Model
from keras.layers import Input
from keras_vggface import VGGFace
import numpy as np
from keras.preprocessing import image
from scipy.io import savemat

# FC7 Features
vgg_model = VGGFace()  # pooling: None, avg or max
out = vgg_model.get_layer('fc7').output
vgg_model_fc7 = Model(vgg_model.input, out)


def get_features(image_path):
    """

    :param image_path(str): Path of a image to extract features with VGG-face.
    :return: A 4096 feature vector.
    """
    img = image.load_img(image_path, target_size=(224, 224))
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=0)
    vgg_model_fc7_preds = vgg_model_fc7.predict(x)
    #print(vgg_model_fc7_preds[0].shape)
    return vgg_model_fc7_preds[0]


def create_all_features(path):
    """