def build(input_size, latent_dim): layer_units = [512, 256] input_shape = (input_size, 1) inputs = Input(shape=input_shape) x = inputs xd = Dropout(0.1, input_shape=(None, 978, 1))(x) x = xd for f in layer_units: x = Dense(f)(x) x = LeakyReLU(alpha=0.2)(x) shape = K.int_shape(x) x = Flatten()(x) latent = Dense(latent_dim, use_bias=False)(x) encoder = Model(inputs, latent, name="encoder") latent_inputs = Input(shape=(latent_dim,)) xd_input = Input(shape=input_shape) x = Dense(shape[1] * shape[2])(latent_inputs) x = Reshape((shape[1], shape[2]))(x) for f in layer_units[::-1]: x = Dense(f)(x) x = LeakyReLU(alpha=0.2)(x) x = Dropout(0.5, input_shape=(None, input_size, layer_units[0]))(x) z = tf.keras.layers.Concatenate(axis=-1)([x, xd_input]) x = Dense(1)(z) outputs = Activation("tanh")(x) decoder = Model([xd_input, latent_inputs], outputs, name="decoder") autoencoder = Model(inputs, decoder([xd, encoder(inputs)]), name="autoencoder") return autoencoder
def SHCNN( input_shape=(192, 192, 3), num_classes=8, initial_lr=0.01, alpha=0.02): input = Input(shape=input_shape) X = Conv2D(44, (5, 5), padding='same', kernel_initializer='he_normal')(input) X = MaxPooling2D((2, 2), padding='same')(X) X = LeakyReLU(alpha=alpha)(X) X = Conv2D(44, (3, 3), padding='same', kernel_initializer='he_normal')(X) X = MaxPooling2D((2, 2), padding='same')(X) X = LeakyReLU(alpha=alpha)(X) X = Conv2D(88, (5, 5), padding='same', kernel_initializer='he_normal')(X) X = MaxPooling2D((2, 2), padding='same')(X) X = LeakyReLU(alpha=alpha)(X) X = Flatten()(X) X = Dropout(rate=0.40)(X) X = Dense(2048)(X) X = LeakyReLU(alpha=alpha)(X) X = Dropout(rate=0.40)(X) X = Dense(1024)(X) X = LeakyReLU(alpha=alpha)(X) X = Dense(num_classes)(X) output = Activation('softmax')(X) model = Model(inputs=input, outputs=output) model.compile(optimizer=Adam(lr=initial_lr), loss='categorical_crossentropy', metrics=['accuracy']) return model
def resdual_net(x, num_filters, num_blocks, name=None): x = Lambda(padding)(x) x = Conv2D(filters=num_filters, kernel_size=3, strides=2, padding='VALID', use_bias=False)(x) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) for i in range(num_blocks): y = Conv2D(filters=num_filters // 2, kernel_size=1, strides=1, padding='VALID', use_bias=False)(x) y = BatchNormalization()(y) y = LeakyReLU(alpha=0.1)(y) y = Lambda(padding)(y) y = Conv2D(filters=num_filters, kernel_size=3, strides=1, padding='VALID', use_bias=False)(y) y = BatchNormalization()(y) y = LeakyReLU(alpha=0.1)(y) if i == num_blocks - 1: x = Add(name=name)([x, y]) else: x = Add()([x, y]) return x
def build_model(self, n_inputs, n_outputs): inputs = Input(shape=(n_inputs, ), name='state_' + str(self.worker_idx)) x = Dense(units=128, kernel_initializer='he_normal', bias_initializer='zero', name="layer_0_" + str(self.worker_idx))(inputs) x = LeakyReLU(alpha=0.05)(x) x = Dense(units=128, kernel_initializer='he_normal', bias_initializer='zero', name="layer_1_" + str(self.worker_idx))(x) x = LeakyReLU(alpha=0.05)(x) x = Dense(units=128, kernel_initializer='he_normal', bias_initializer='zero', name="layer_2_" + str(self.worker_idx))(x) x = LeakyReLU(alpha=0.05)(x) x = Dense(units=n_outputs, kernel_initializer='he_normal', bias_initializer='zero', activation='linear', name='layer_3_' + str(self.worker_idx))(x) model = Model(inputs, x) model.summary() return model
def get_downsampled_signal(img_tensor, module_name): x = Conv2D(filters=32, kernel_size=(5, 5), strides=2, padding='same', name='downsample_{0}_conv_1'.format(module_name))(img_tensor) x = InstanceNormalization(name='downsample_{0}_in_1'.format(module_name))( x) if module_name == 'content' else x x = LeakyReLU(name='downsample_{0}_relu_1'.format(module_name))(x) x = Conv2D(filters=64, kernel_size=(3, 3), strides=2, padding='same', name='downsample_{0}_conv_2'.format(module_name))(x) x = InstanceNormalization(name='downsample_{0}_in_2'.format(module_name))( x) if module_name == 'content' else x x = LeakyReLU(name='downsample_{0}_relu_2'.format(module_name))(x) x = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='downsample_{0}_conv_3'.format(module_name))(x) x = InstanceNormalization(name='downsample_{0}_in_3'.format(module_name))( x) if module_name == 'content' else x x = LeakyReLU(name='downsample_{0}_relu_3'.format(module_name))(x) return x
def activation(self, new_activation): if new_activation == 'leaky_relu': LR = LeakyReLU(alpha=0.001) LR.__name__ = 'relu' self._activation = LR else: self._activation = new_activation
def res_block(input_x, filters, sizes, layer_id): f1, f2 = filters s1, s2 = sizes #1 x = Conv2D(f1, s1, padding='same', use_bias=False, name='conv_' + str(layer_id))(input_x) x = BatchNormalization(epsilon=0.001, name='bnorm_' + str(layer_id))(x) x = LeakyReLU(alpha=0.1, name='leaky_' + str(layer_id))(x) #2 x = Conv2D(f2, s2, padding='same', use_bias=False, name='conv_' + str(layer_id + 1))(x) x = BatchNormalization(epsilon=0.001, name='bnorm_' + str(layer_id + 1))(x) x = LeakyReLU(alpha=0.1, name='leaky_' + str(layer_id + 1))(x) x = add([input_x, x]) return x
def get_upsampled_signal(x): y = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_1')(x) y = LeakyReLU(name='decode_relu_1')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_1')(y) y = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_2')(x) y = LeakyReLU(name='decode_relu_2')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_2')(y) y = Conv2DTranspose(filters=32, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_3')(y) y = LeakyReLU(name='decode_relu_3')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_3')(y) y = Conv2DTranspose(filters=16, kernel_size=(2, 2), strides=1, padding='same', name='decode_convtrans_4')(y) y = LeakyReLU(name='decode_relu_4')(y) return y
def shortcut_convolution(high_res_img, low_res_target, nb_channels_out): if img_size(low_res_target) == 1: kernel_size = img_size(high_res_img) downsampled_input = kl.TimeDistributed( SpectralNormalization( kl.Conv2D(nb_channels_out, kernel_size, activation=LeakyReLU(0.2))), name='shortcut_conv_1')(high_res_img) else: strides = int( tf.math.ceil( (2 + img_size(high_res_img)) / (img_size(low_res_target) - 1))) margin = 2 padding = int( tf.math.ceil((strides * (img_size(low_res_target) - 1) - img_size(high_res_img)) / 2) + 1 + margin) kernel_size = int(strides * (1 - img_size(low_res_target)) + img_size(high_res_img) + 2 * padding) downsampled_input = kl.TimeDistributed( kl.ZeroPadding2D(padding=padding))(high_res_img) downsampled_input = kl.TimeDistributed( SpectralNormalization( kl.Conv2D(nb_channels_out, kernel_size, strides=strides, activation=LeakyReLU(0.2))), name='shortcut_conv')(downsampled_input) downsampled_input = kl.LayerNormalization()(downsampled_input) return downsampled_input
def get_model(): img_tensor = Input(shape=(64, 64, 3)) x = Conv2D(filters=32, kernel_size=(5, 5), strides=1, padding='same')(img_tensor) x = BatchNormalization()(x) x = LeakyReLU()(x) x = MaxPool2D(pool_size=(3, 3), strides=2, padding='valid')(x) x = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='valid')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = MaxPool2D(pool_size=(3, 3), strides=2, padding='valid')(x) x = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='valid')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = MaxPool2D(pool_size=(3, 3), strides=2, padding='valid')(x) x = Conv2D(filters=32, kernel_size=(3, 3), strides=1, padding='valid')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = AvgPool2D(pool_size=(2, 2), strides=1, padding='valid')( x ) # Blurred output produced by AvgPool2D, intuitively, gives a better estimate of filters used rather than sharp one produced by MaxPool2D because in blur output the neighboring colors are aggregated and sharp outputs often contain max values due to presence of edges. x = Flatten()(x) x = Dense(units=32, activation='relu')(x) x = Dropout(0.25)(x) predicted_class = Dense(units=num_classes, activation='softmax')(x) model = Model(inputs=[img_tensor], outputs=[predicted_class]) return model
def build(input_size, channels, latent_dim): layer_units = [512, 256] input_shape = (input_size, channels) drop_rate = 0.8 inputs = Input(shape=input_shape) x = inputs x = Dropout(0.4, input_shape=(None, 978, 1))(x) for f in layer_units: x = Dense(f)(x) x = LeakyReLU(alpha=0.2)(x) x = Dropout(drop_rate, input_shape=(None, input_size, layer_units[1]))(x) shape = K.int_shape(x) x = Flatten()(x) latent = Dense(latent_dim, kernel_regularizer=regularizers.l2(1e-5), activity_regularizer=regularizers.l1(1e-5))(x) #, kernel_regularizer=regularizers.l2(1e-5), # activity_regularizer=regularizers.l1(1e-5) encoder = Model(inputs, latent, name="encoder") latent_inputs = Input(shape=(latent_dim,)) x = Dense(shape[1] * shape[2])(latent_inputs) x = Reshape((shape[1], shape[2]))(x) for f in layer_units[::-1]: x = Dense(f)(x) x = LeakyReLU(alpha=0.2)(x) x = Dropout(drop_rate, input_shape=(None, input_size, layer_units[0]))(x) x = Dense(1)(x) outputs = Activation("tanh")(x) decoder = Model(latent_inputs, outputs, name="decoder") autoencoder = Model(inputs, decoder(encoder(inputs)), name="autoencoder") return autoencoder
def decoder(): latent_inputs = keras.Input(shape=(128, )) x = Dropout(0.25)(Dense(8 * 8 * 512)(latent_inputs)) x = Reshape((8, 8, 512))(x) x = Conv2D(512, 1, padding='same')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2DTranspose(512, 3, strides=2, padding="same")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2DTranspose(256, 3, strides=2, padding="same")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2DTranspose(128, 3, padding="same")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) decoder_outputs = Conv2D(128, 1, strides=1, padding='same', activation='sigmoid')(x) decoder = Model(latent_inputs, decoder_outputs, name="decoder") return decoder
def build(self): inputs = Input(shape=[None, None, 3]) conv1 = Conv2D(64, 4, 2, activation=LeakyReLU(0.2), padding='same')(inputs) conv2 = Conv2D(128, 4, 2, padding='same')(conv1) conv2 = self.norm(conv2) conv2 = LeakyReLU(0.2)(conv2) conv3 = Conv2D(256, 4, 2, padding='same')(conv2) conv3 = self.norm(conv3) conv3 = LeakyReLU(0.2)(conv3) conv4 = Conv2D(512, 4, 2, padding='same')(conv3) conv4 = self.norm(conv4) conv4 = LeakyReLU(0.2)(conv4) conv5 = Conv2D(1, 4, 2, padding='same')(conv4) upconv1 = Conv2DTranspose(256, 4, 2, padding='same')(conv5) upconv1 = self.norm(upconv1) upconv1 = Activation('relu')(upconv1) concat1 = Concatenate()([conv4, upconv1]) upconv2 = Conv2DTranspose(128, 4, 2, padding='same')(concat1) upconv2 = self.norm(upconv2) upconv2 = Activation('relu')(upconv2) concat2 = Concatenate()([conv3, upconv2]) upconv3 = Conv2DTranspose(64, 4, 2, padding='same')(concat2) upconv3 = self.norm(upconv3) upconv3 = Activation('relu')(upconv3) concat3 = Concatenate()([conv2, upconv3]) upconv4 = Conv2DTranspose(32, 4, 2, padding='same')(concat3) upconv4 = self.norm(upconv4) upconv4 = Activation('relu')(upconv4) concat4 = Concatenate()([conv1, upconv4]) outputs = Conv2DTranspose(self.classes, 4, 2, padding='same', activation='softmax')(concat4) model = Model(inputs=inputs, outputs=[conv5, outputs]) return model
def discriminator_model(img_shape): model = Sequential() model.add( Conv2D(32, kernel_size=3, strides=2, input_shape=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(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(128, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(256, kernel_size=3, strides=1, padding="same")) 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=img_shape) validity = model(img) return Model(img, validity)
def make_cnn_model(vocab_size=10000, embed_dim=8, input_seq_length=20): """ I am the builder function for the CNN Model. :param vocab_size: size of the vocabulary of the embedding, should be size of vocab of the vectorizer :param embed_dim: how many dimensions to use for the vector embedding :param input_seq_length: how long the sequence of inputs will be :return: Keras Model """ x = inp = Input(shape=(None, ), dtype="int64") x = Embedding( input_dim=vocab_size, output_dim=embed_dim, input_length=input_seq_length, )(x) x = Conv1D(filters=64, kernel_size=3, strides=2, activation="linear")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv1D(filters=64, kernel_size=3, strides=2, activation="linear")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv1D(filters=64, kernel_size=3, strides=2, activation="linear")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = GlobalMaxPooling1D()(x) x = Dense(units=128, activation="linear")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) out = Dense(1, activation="sigmoid")(x) return Model(inputs=[inp], outputs=[out], name="cnn_model")
def Encoder(inputs, opts, istrain=True, name='e1'): assert opts.isize % 16 == 0, "isize has to be a multiple of 16" ''' initial layer''' x = Conv2D(opts.gen_filter, (4, 4), strides=2, padding='same', use_bias=False)(inputs) x = LeakyReLU(0.2)(x) size_now = opts.isize // 2 ''' Extra layers''' for t in range(opts.n_extra_layers): x = Conv2D(opts.gen_filter, (3, 3), padding='same', use_bias=False)(x) x = batch_norm(x, name + "_bn1_" + str(t), is_train=istrain) x = LeakyReLU(0.2)(x) channel = opts.gen_filter # channel: default number is 64 ''' reduction layers''' while size_now > 4: x = Conv2D(channel * 2, (4, 4), strides=2, padding='same', use_bias=False)(x) x = batch_norm(x, name + "_bn2_" + str(channel), is_train=istrain) x = LeakyReLU(0.2)(x) channel = channel * 2 size_now = size_now // 2 # state size. channel x 4 x 4 ''' final layer, resize the layer to channel X 1 X 1''' output = Conv2D(opts.z_size, (4, 4), padding='valid', use_bias=False)(x) return output
def __init__(self, raanan_architecture=False, sigmoid_activation=True): super(Decoder, self).__init__() self.input_layer = InputLayer() self.fully_connected3 = Dense(512) self.fully_connected4 = Dense(7 * 7 * 64) self.reshape = Reshape((7, 7, 64)) self.conv_transpose1 = Conv2DTranspose(32, 3, padding="same", strides=2) self.conv_transpose2 = Conv2DTranspose(1, 3, padding="same", strides=2) self.relu1 = ReLU() self.relu2 = ReLU() self.relu3 = ReLU() self.last_activation = sigmoid if sigmoid_activation else tanh if raanan_architecture: self.relu1 = LeakyReLU() self.relu2 = LeakyReLU() self.relu3 = LeakyReLU() print("Decoder network created with raanan architecture={}".format( raanan_architecture))
def get_model(self, input_shape, n_classes=1, use_imagenet=False): decoder = Sequential() number_layers = int(math.log2(input_shape[0])) - 1 for i in range(number_layers): if i == 0: self.build_block(decoder, self.filters * (2**(number_layers - i - 2)), Conv2DTranspose, input_shape=self.code_shape) #decoder.add(Activation('relu')) decoder.add(LeakyReLU(alpha=self.leaky_alpha)) elif i == number_layers - 1: self.build_block(decoder, 3, Conv2DTranspose, padding='same') decoder.add(Activation(activation='tanh')) else: self.build_block(decoder, self.filters * (2**(number_layers - i - 2)), Conv2DTranspose, padding='same') #decoder.add(Activation('relu')) decoder.add(LeakyReLU(alpha=self.leaky_alpha)) self.model = decoder return self.model
def get_model(self, input_shape, n_classes=1, use_imagenet=False): encoder = Sequential() number_layers = int(math.log2(input_shape[0])) - 1 for i in range(number_layers): if i == 0: self.build_block(encoder, self.filters * (2**i), Conv2D, padding='same', input_shape=input_shape) encoder.add(LeakyReLU(alpha=self.leaky_alpha)) elif i == (number_layers - 1): self.build_block(encoder, self.code_shape, Conv2D) encoder.add(LeakyReLU(alpha=self.leaky_alpha)) else: self.build_block(encoder, self.filters * (2**i), Conv2D, padding='same') encoder.add(LeakyReLU(alpha=self.leaky_alpha)) if self.include_top: encoder.add(Flatten()) encoder.add( Dense(n_classes, activation='sigmoid', name='predictions')) self.model = encoder return self.model
def discriminator(num_filters=64, num_downsamplings=3): num_filters_ = num_filters x_in = Input(shape=(None, None, 3)) x = Conv2D(num_filters, kernel_size=4, padding='same')(x_in) x = LeakyReLU(alpha=0.2)(x) for _ in range(num_downsamplings - 1): num_filters = min(num_filters * 2, num_filters_ * 8) x = Conv2D(num_filters, kernel_size=4, strides=2, padding='same', use_bias=False)(x) x = InstanceNormalization()(x) x = LeakyReLU(alpha=0.2)(x) num_filters = min(num_filters * 2, num_filters_ * 8) x = Conv2D(num_filters, kernel_size=4, strides=1, padding='same', use_bias=False)(x) x = InstanceNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(1, kernel_size=4, strides=1, padding='same')(x) return Model(x_in, x)
def build_generator(self, config_gener): m = float(config_gener['momentum']) a = float(config_gener['leaky_relu_alpha']) model = Sequential() model.add( Dense(int(config_gener['dense1']), input_dim=self.embeddings_dim)) model.add(LeakyReLU(alpha=a)) model.add(BatchNormalization(momentum=m)) model.add(Dense(int(config_gener['dense2']))) model.add(LeakyReLU(alpha=a)) model.add(BatchNormalization(momentum=m)) model.add(Dense(int(config_gener['dense3']))) model.add(LeakyReLU(alpha=a)) model.add(BatchNormalization(momentum=m)) model.add( Dense(np.prod(self.img_shape), activation=config_gener['activation'])) model.add(Reshape(self.img_shape)) noise = Input(shape=(self.embeddings_dim, )) label = Input(shape=(1, ), dtype='int32') label_embedding = Flatten()(Embedding( self.embeddings_vocab, self.embeddings_dim, weights=[self.word_embeddings.vectors], trainable=False)(label)) model_input = multiply([noise, label_embedding]) img = model(model_input) return Model([noise, label], img)
def sr_resnet(num_filters=64, num_res_blocks=16): lr_input = Input(shape=(24, 24, 3)) x_start = Conv2D(64, kernel_size=3, strides=1, padding='same')(lr_input) x_start = LeakyReLU(0.2)(x_start) x = RRDB(x_start) x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x) x = Lambda(lambda x: x * 0.2)(x) x = Add()([x, x_start]) x = upsample(x, 1) if upscaling_factor > 2: x = upsample(x, 2) if upscaling_factor > 4: x = upsample(x, 3) x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x) x = LeakyReLU(0.2)(x) hr_output = Conv2D(channels, kernel_size=3, strides=1, padding='same', activation='tanh')(x) model = Model(inputs=lr_input, outputs=hr_output) return model
def __init__(self, act='', lrelu_alpha=0.1, **kwargs): super(_Act, self).__init__(**kwargs) if act == 'prelu': self.func = PReLU() else: self.func = LeakyReLU(alpha=lrelu_alpha)
def discriminator(self): if self.D: return self.D self.D = Sequential() depth = 64 dropout = 0.2 input_shape = (self.img_rows, self.img_cols, self.channel) self.D.add( Conv2D(depth * 1, 5, strides=2, input_shape=input_shape, padding='same')) self.D.add(LeakyReLU(alpha=0.2)) self.D.add(Dropout(dropout)) self.D.add(Conv2D(depth * 2, 5, strides=2, padding='same')) self.D.add(LeakyReLU(alpha=0.2)) self.D.add(Dropout(dropout)) self.D.add(Conv2D(depth * 4, 5, strides=2, padding='same')) self.D.add(LeakyReLU(alpha=0.2)) self.D.add(Dropout(dropout)) self.D.add(Conv2D(depth * 8, 5, strides=1, padding='same')) self.D.add(LeakyReLU(alpha=0.2)) self.D.add(Dropout(dropout)) # Out: 1-dim probability self.D.add(Flatten()) self.D.add(Dense(1)) self.D.add(Activation('sigmoid')) self.D.summary() return self.D
def __generate_detection_resnet34(self, input_layer, n_category=None): out_filters = n_category + 4 x_1, x_2, x_3, x = self.__generate_encoder(input_layer) # Deconvolution block 1: (16, 16, 512) -> (32, 32, 512) x = Conv2D(filters=256, kernel_size=3, strides=1, padding='same')(x) x = Conv2DTranspose(filters=256, kernel_size=4, strides=2, padding='same')(x) x = Concatenate()([x_3, x]) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) # Deconvolution block 2: (32, 32, 512) -> (64, 64, 256) x = Conv2D(filters=128, kernel_size=3, strides=1, padding='same')(x) x = Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding='same')(x) x = Concatenate()([x_2, x]) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) # Deconvolution block 3: (64, 64, 256) -> (128, 128, 128) x = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(x) x = Conv2DTranspose(filters=64, kernel_size=4, strides=2, padding='same')(x) x = Concatenate()([x_1, x]) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) # Block 4: x = Conv2D(filters=out_filters, kernel_size=1, strides=1, padding='same')(x) out = Activation('sigmoid')(x) # optional return Model(input_layer, out)
def createModel( self, inputs, outputs, hiddenLayers, activationType, learningRate ): model = Sequential() if len(hiddenLayers) == 0: model.add( Dense(self.output_size, input_shape=(self.input_size,), init='lecun_uniform') ) model.add( Activation('linear') ) else: model.add( Dense(hiddenLayers[0], input_shape=(self.input_size,), kernel_initializer='lecun_uniform') ) if activationType == 'LeakyReLU': model.add( LeakyReLU(alpha=0.01) ) else: model.add( Activation(activationType) ) for index in range(1,len(hiddenLayers)): layerSize = hiddenLayers[index] model.add( Dense(layerSize,kernel_initializer='lecun_uniform') ) if activationType == 'LeakyReLU': model.add( LeakyReLU(alpha=0.01) ) else: model.add( Activation(activationType) ) model.add( Dense(self.output_size,kernel_initializer='lecun_uniform') ) model.add( Activation('linear') ) optimizer = optimizers.RMSprop( lr = learningRate, rho = 0.9, epsilon = 1e-6 ) model.compile( loss = "mse", optimizer = optimizer ) model.summary() return model
def build(self, hr_shape): x_in = Input(shape=hr_shape) x = self.discriminator_block(x_in, self.n_filters) x = self.discriminator_block(x, self.n_filters * 2) x = self.discriminator_block(x, self.n_filters * 4) x = self.discriminator_block(x, self.n_filters * 8) x = self.discriminator_block(x, self.n_filters * 16) x = Conv2D(self.n_filters * 16, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, use_bias=False, padding='same')(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(self.n_filters * 16, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, use_bias=False, padding='same')(x) x = LeakyReLU(alpha=0.2)(x) x = Flatten()(x) x = Dense(128)(x) x = LeakyReLU(alpha=0.2)(x) x = Dense(1)(x) x = Model(x_in, x) return x
def build(self): input_discriminator = Input(shape=self.input_shape) x = Conv2D(64, kernel_size=(3, 3), strides=(1, 1), use_bias=False, activation=None, padding='same')(input_discriminator) x = LeakyReLU(alpha=0.2)(x) x = conv_block(x, filters=64, kernel_size=(4, 4), strides=(2, 2), axis=self.axis) x = conv_block(x, filters=128, kernel_size=(3, 3), strides=(1, 1), axis=self.axis) x = conv_block(x, filters=128, kernel_size=(4, 4), strides=(2, 2), axis=self.axis) x = conv_block(x, filters=256, kernel_size=(3, 3), strides=(1, 1), axis=self.axis) x = conv_block(x, filters=256, kernel_size=(4, 4), strides=(2, 2), axis=self.axis) x = conv_block(x, filters=512, kernel_size=(3, 3), strides=(1, 1), axis=self.axis) x = conv_block(x, filters=512, kernel_size=(4, 4), strides=(2, 2), axis=self.axis) x = Flatten(data_format=self.data_format)(x) x = Dense(1024, activation=None)(x) x = LeakyReLU(alpha=0.2)(x) output_discriminator = Dense(1, activation='sigmoid')(x) discriminator_model = Model(inputs=input_discriminator, outputs=output_discriminator, name="Discriminador") # tf.keras.utils.plot_model(discriminator_model, 'E:\\TFM\\outputs\\model_imgs\\discriminator_model.png', # show_shapes=True) return discriminator_model
def createRegularizedModel( self, inputs, outputs, hiddenLayers, # List of nodes at each hidden layer activationType, learningRate ): bias = True dropout = 0 regularizationFactor = 0.01 model = Sequential() if len(hiddenLayers) == 0: model.add( Dense(self.output_size, input_shape=(self.input_size,), init='lecun_uniform',bias=bias) ) model.add( Activation("linear") ) else: if regularizationFactor > 0: model.add( Dense(hiddenLayers[0], input_shape=(self.input_size,), init='lecun_uniform', W_regularizer=l2(regularizationFactor), bias=bias) ) else: model.add( Dense(hiddenLayers[0], input_shape=(self.input_size,), init='lecun_uniform', bias=bias) ) if activationType == 'LeakyReLU': model.add( LeakyReLU(alpha=0.01) ) else: model.add( Activation(activationType) ) for index in range(1,len(hiddenLayers)): layerSize = hiddenSize[index] if regularizationFactor > 0.0: model.add( Dense(hiddenLayers[index], init='lecun_uniform', W_regularizer=l2(regularizationFactor), bias=bias) ) else: model.add( Dense(hiddenLayers[index], init='lecun_uniform', bias=bias) ) if activationType == "LeakyReLU": model.add( LeakyReLU(alpha=0.01) ) else: model.add( Activation(activationType) ) if dropout > 0: model.add( Dropout(dropout) ) model.add( Dense(self.output_size, init='lecun_uniform', bias=bias) ) model.add( Activation("linear") ) optimizer = optimizers.RMSprop( lr = learningRate, rho = 0.9, epsilon = 1e-6 ) model.compile( loss = "mse", optimizer = optimizer ) model.summary() return model
def _deconv_block(x, filters, kernel_size=1): x = DepthwiseConv2D(kernel_size=kernel_size, padding="same", use_bias=False)(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2D(filters, kernel_size=1, use_bias=False)(x) x = BatchNormalization()(x) x = LeakyReLU()(x) return UpSampling2D()(x)