def build_discriminator(self): model = Sequential() model.add( Conv2D(32, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(64, kernel_size=3, strides=2, padding="same")) model.add(ZeroPadding2D(padding=((0, 1), (0, 1)))) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=3, strides=2, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(256, kernel_size=3, strides=1, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) model.summary() img = Input(shape=self.img_shape) validity = model(img) return Model(img, validity)
def generator_unet_upsampling(img_shape, disc_img_shape, model_name="generator_unet_upsampling"): filters_num = 64 axis_num = -1 channels_num = img_shape[-1] min_s = min(img_shape[:-1]) unet_input = Input(shape=img_shape, name="unet_input") conv_num = int(np.floor(np.log(min_s) / np.log(2))) list_filters_num = [filters_num * min(8, (2**i)) for i in range(conv_num)] # Encoder first_conv = Conv2D(list_filters_num[0], (3, 3), strides=(2, 2), name='unet_conv2D_1', padding='same')(unet_input) list_encoder = [first_conv] for i, f in enumerate(list_filters_num[1:]): name = 'unet_conv2D_' + str(i + 2) conv = conv_block_unet(list_encoder[-1], f, name, axis_num) list_encoder.append(conv) # prepare decoder filters list_filters_num = list_filters_num[: -2][:: -1] # list_filters_num -> [512, 512, 512, 256, 128, 64] if len(list_filters_num) < conv_num - 1: list_filters_num.append(filters_num) # Decoder first_up_conv = up_conv_block_unet(list_encoder[-1], list_encoder[-2], list_filters_num[0], "unet_upconv2D_1", axis_num, dropout=True) list_decoder = [first_up_conv] for i, f in enumerate(list_filters_num[1:]): name = "unet_upconv2D_" + str(i + 2) if i < 2: d = True else: d = False up_conv = up_conv_block_unet(list_decoder[-1], list_encoder[-(i + 3)], f, name, axis_num, dropout=d) list_decoder.append(up_conv) x = Activation('relu')(list_decoder[-1]) x = UpSampling2D(size=(2, 2))(x) x = Conv2D(disc_img_shape[-1], (3, 3), name="last_conv", padding='same')(x) x = Activation('tanh')(x) generator_unet = Model(inputs=[unet_input], outputs=[x]) return generator_unet
def build(self): model = Sequential() img = Input(shape=self.img_shape) model.add( Conv2D(32, kernel_size=3, activation="relu", strides=2, padding="same")) model.add( Conv2D(32, kernel_size=3, activation="relu", strides=2, padding="same")) model.add( Conv2D(64, kernel_size=3, activation="relu", strides=1, padding="same")) model.add(Dropout(0.25)) model.add(MaxPooling2D((2, 2), strides=None, padding="same")) model.add(Flatten()) # Extract feature representation mp = model(img) # Determine valence of the image v1 = Dense(64, activation="relu", name='valence')(mp) valence = Dense(1, activation="sigmoid")(v1) valence = Lambda(lambda x: x * 10.)(valence) a1 = Dense(64, activation="relu", name='arousal')(mp) arousal = Dense(1, activation="sigmoid")(a1) arousal = Lambda(lambda x: x * 10.)(arousal) d1 = Dense(64, activation="relu", name='dominance')(mp) dominance = Dense(1, activation="sigmoid")(d1) dominance = Lambda(lambda x: x * 10.)(dominance) #model.summary() return Model(img, [arousal, valence, dominance])
def up_conv_block_unet(x, x2, f, name, bn_axis, bn=True, dropout=False): x = Activation('relu')(x) x = UpSampling2D(size=(2, 2))(x) x = Conv2D(f, (3, 3), name=name, padding='same')(x) if bn: x = BatchNormalization(axis=bn_axis)(x) if dropout: x = Dropout(0.5)(x) x = Concatenate(axis=bn_axis)([x, x2]) return x
def layers(input_shape): return [ ZeroPadding2D(padding=3, input_shape=input_shape, data_format='channels_first'), # <1> Conv2D(48, (7, 7), data_format='channels_first'), Activation('relu'), ZeroPadding2D(padding=2, data_format='channels_first'), # <2> Conv2D(32, (5, 5), data_format='channels_first'), Activation('relu'), ZeroPadding2D(padding=2, data_format='channels_first'), Conv2D(32, (5, 5), data_format='channels_first'), Activation('relu'), ZeroPadding2D(padding=2, data_format='channels_first'), Conv2D(32, (5, 5), data_format='channels_first'), Activation('relu'), Flatten(), Dense(512), Activation('relu'), ]
def define_lenet(input_shape, num_classes): model = Sequential() model.add( Conv2D( filters=20, input_shape=input_shape, kernel_size=5, padding='same', activation='relu', )) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D( filters=50, kernel_size=5, padding='same', activation='relu', )) model.add(Flatten()) model.add(Dense(500, activation='relu')) model.add(Dense(num_classes)) model.add(Activation('softmax')) model.summary() return model
def build_generator(self): model = Sequential() model.add( Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim)) model.add(Reshape((7, 7, 128))) model.add(UpSampling2D()) model.add(Conv2D(128, kernel_size=3, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(Activation("relu")) model.add(UpSampling2D()) model.add(Conv2D(64, kernel_size=3, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(Activation("relu")) model.add(Conv2D(self.channels, kernel_size=3, padding="same")) model.add(Activation("tanh")) model.summary() noise = Input(shape=(self.latent_dim, )) img = model(noise) return Model(noise, img)
def conv_block_unet(x, f, name, bn_axis, bn=True, strides=(2, 2)): x = LeakyReLU(0.2)(x) x = Conv2D(f, (3, 3), strides=strides, name=name, padding='same')(x) if bn: x = BatchNormalization(axis=bn_axis)(x) return x
def DCGAN_discriminator(img_shape, disc_img_shape, patch_num, model_name='DCGAN_discriminator'): disc_raw_img_shape = (disc_img_shape[0], disc_img_shape[1], img_shape[-1]) list_input = [ Input(shape=disc_img_shape, name='disc_input_' + str(i)) for i in range(patch_num) ] list_raw_input = [ Input(shape=disc_raw_img_shape, name='disc_raw_input_' + str(i)) for i in range(patch_num) ] axis_num = -1 filters_num = 64 conv_num = int(np.floor(np.log(disc_img_shape[1]) / np.log(2))) list_filters = [filters_num * min(8, (2**i)) for i in range(conv_num)] # First Conv generated_patch_input = Input(shape=disc_img_shape, name='discriminator_input') xg = Conv2D(list_filters[0], (3, 3), strides=(2, 2), name='disc_conv2d_1', padding='same')(generated_patch_input) xg = BatchNormalization(axis=axis_num)(xg) xg = LeakyReLU(0.2)(xg) # First Raw Conv raw_patch_input = Input(shape=disc_raw_img_shape, name='discriminator_raw_input') xr = Conv2D(list_filters[0], (3, 3), strides=(2, 2), name='raw_disc_conv2d_1', padding='same')(raw_patch_input) xr = BatchNormalization(axis=axis_num)(xr) xr = LeakyReLU(0.2)(xr) # Next Conv for i, f in enumerate(list_filters[1:]): name = 'disc_conv2d_' + str(i + 2) x = Concatenate(axis=axis_num)([xg, xr]) x = Conv2D(f, (3, 3), strides=(2, 2), name=name, padding='same')(x) x = BatchNormalization(axis=axis_num)(x) x = LeakyReLU(0.2)(x) x_flat = Flatten()(x) x = Dense(2, activation='softmax', name='disc_dense')(x_flat) PatchGAN = Model(inputs=[generated_patch_input, raw_patch_input], outputs=[x], name='PatchGAN') x = [ PatchGAN([list_input[i], list_raw_input[i]]) for i in range(patch_num) ] if len(x) > 1: x = Concatenate(axis=axis_num)(x) else: x = x[0] x_out = Dense(2, activation='softmax', name='disc_output')(x) discriminator_model = Model(inputs=(list_input + list_raw_input), outputs=[x_out], name=model_name) return discriminator_model
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) if config['backup']['create_backup']: config = create_backup(config) keras.backend.tensorflow_backend.set_session(get_session()) #path for the training and validation dataset datasetTrainPath = os.path.join(args.folder, "train") datasetValPath = os.path.join(args.folder, "val") for folder in [datasetTrainPath, datasetValPath]: if not os.path.isdir(folder): raise Exception("{} doesn't exist!".format(folder)) classesTrain = next(os.walk(datasetTrainPath))[1] classesVal = next(os.walk(datasetValPath))[1] if not classesVal == classesTrain: raise Exception( "The training and validation classes must be the same!") else: folders = classesTrain #training configuration epochs = config['train']['nb_epochs'] batchSize = config['train']['batch_size'] width = config['model']['input_size_w'] height = config['model']['input_size_h'] depth = 3 if config['model']['gray_mode'] == False else 1 #config keras generators if len( folders ) == 2: #if just have 2 classes, the model will have a binary output classes = 1 else: classes = len(folders) #count all samples imagesTrainPaths = [] imagesValPaths = [] for folder in folders: imagesTrainPaths += list( list_images(os.path.join(datasetTrainPath, folder))) imagesValPaths += list( list_images(os.path.join(datasetValPath, folder))) generator_config = { 'IMAGE_H': height, 'IMAGE_W': width, 'IMAGE_C': depth, 'BATCH_SIZE': batchSize } #callbacks model_name = config['train']['saved_weights_name'] checkPointSaverBest = ModelCheckpoint(model_name, monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) ckp_model_name = os.path.splitext(model_name)[1] + "_ckp.h5" checkPointSaver = ModelCheckpoint(ckp_model_name, verbose=1, save_best_only=False, save_weights_only=False, period=10) tb = TensorBoard(log_dir=config['train']['tensorboard_log_dir'], histogram_freq=0, batch_size=batchSize, write_graph=True, write_grads=False, write_images=False, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None) #create the classification model # make the feature extractor layers if depth == 1: input_size = (height, width, 1) input_image = Input(shape=input_size) else: input_size = (height, width, 3) input_image = Input(shape=input_size) feature_extractor = import_feature_extractor(config['model']['backend'], input_size) train_generator = BatchGenerator(imagesTrainPaths, generator_config, norm=feature_extractor.normalize, jitter=True) val_generator = BatchGenerator(imagesValPaths, generator_config, norm=feature_extractor.normalize, jitter=False) features = feature_extractor.extract(input_image) # make the model head output = Conv2D(classes, (1, 1), padding="same")(features) output = BatchNormalization()(output) output = LeakyReLU(alpha=0.1)(output) output = GlobalAveragePooling2D()(output) output = Activation("sigmoid")(output) if classes == 1 else Activation( "softmax")(output) if config['train']['pretrained_weights'] != "": model = load_model(config['model']['pretrained_weights']) else: model = Model(input_image, output) opt = Adam() model.compile(loss="binary_crossentropy" if classes == 1 else "categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) model.summary() model.fit_generator(train_generator, steps_per_epoch=len(imagesTrainPaths) // batchSize, epochs=epochs, validation_data=val_generator, validation_steps=len(imagesValPaths) // batchSize, callbacks=[checkPointSaverBest, checkPointSaver, tb], workers=12, max_queue_size=40)