def build(self, input_shape): self.conv = layers.Conv2D(self.num_layers, self.kernel_size, self.stride, self.padding, activation=self.activation, kernel_regularizer=self.kernel_regularizer) if self.batch_normalize: self.bn = layers.BatchNormalization() # scale=False '''
def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None): """A residual block. Arguments: x: input tensor. filters: integer, filters of the bottleneck layer. kernel_size: default 3, kernel size of the bottleneck layer. stride: default 1, stride of the first layer. conv_shortcut: default True, use convolution shortcut if True, otherwise identity shortcut. name: string, block label. Returns: Output tensor for the residual block. """ bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 if conv_shortcut: shortcut = layers.Conv2D( 4 * filters, 1, strides=stride, name=name + '_0_conv')(x) shortcut = layers.BatchNormalization( axis=bn_axis, epsilon=1.001e-5, name=name + '_0_bn')(shortcut) else: shortcut = x x = layers.Conv2D(filters, 1, strides=stride, name=name + '_1_conv')(x) x = layers.BatchNormalization( axis=bn_axis, epsilon=1.001e-5, name=name + '_1_bn')(x) x = layers.Activation('relu', name=name + '_1_relu')(x) x = layers.Conv2D( filters, kernel_size, padding='SAME', name=name + '_2_conv')(x) x = layers.BatchNormalization( axis=bn_axis, epsilon=1.001e-5, name=name + '_2_bn')(x) x = layers.Activation('relu', name=name + '_2_relu')(x) x = layers.Conv2D(4 * filters, 1, name=name + '_3_conv')(x) x = layers.BatchNormalization( axis=bn_axis, epsilon=1.001e-5, name=name + '_3_bn')(x) x = layers.Add(name=name + '_add')([shortcut, x]) x = layers.Activation('relu', name=name + '_out')(x) return x
def transition_block(x, name, dropout_rate, reduction=0.5): x = layers.BatchNormalization(name=name + '_bn')(x) x = layers.Activation('relu', name=name + '_relu')(x) x = layers.Conv2D(int(x.get_shape().as_list()[-1] * reduction), 1, padding='same', name=name + '_conv')(x) x = layers.Dropout(rate=dropout_rate)(x) x = layers.AveragePooling2D(strides=2, name=name + '_pool')(x) return x
def build_model(): sequences = layers.Input(shape=(MAX_LENGTH, )) embedded = layers.Embedding(MAX_FEATURES, 64)(sequences) x = layers.Conv1D(64, 3, activation='relu')(embedded) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(3)(x) x = layers.Conv1D(64, 5, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(5)(x) x = layers.Conv1D(64, 5, activation='relu')(x) x = layers.GlobalMaxPool1D()(x) x = layers.Flatten()(x) x = layers.Dense(100, activation='relu')(x) predictions = layers.Dense(1, activation='sigmoid')(x) model = models.Model(inputs=sequences, outputs=predictions) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy']) return model
def _identity_block(input_tensor, kernel_size, filters, stage, block): """The identity block is the block that has no conv layer at shortcut. # Arguments input_tensor: input tensor kernel_size: default 3, the kernel size of middle conv layer at main file_list filters: list of integers, the filters of 3 conv layer at main file_list stage: integer, current stage label, used for generating layer names block: 'a','b'..., current block label, used for generating layer names # Returns Output tensor for the block. """ filters1, filters2, filters3 = filters if backend.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = layers.Conv2D(filters1, (1, 1), kernel_initializer='he_normal', name=conv_name_base + '2a')(input_tensor) x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x) x = layers.Activation('relu')(x) x = layers.Conv2D(filters2, kernel_size, padding='same', kernel_initializer='he_normal', name=conv_name_base + '2b')(x) x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x) x = layers.Activation('relu')(x) x = layers.Conv2D(filters3, (1, 1), kernel_initializer='he_normal', name=conv_name_base + '2c')(x) x = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x) x = layers.add([x, input_tensor]) x = layers.Activation('relu')(x) return x
def make_generator_model(): """ implements generate. Returns: model. """ model = tf.keras.Sequential() model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(100, ))) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add(layers.Reshape((7, 7, 256))) assert model.output_shape == (None, 7, 7, 256 ) # Note: None is the batch size model.add( layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)) assert model.output_shape == (None, 7, 7, 128) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add( layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)) assert model.output_shape == (None, 14, 14, 64) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add( layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh')) assert model.output_shape == (None, 28, 28, 1) return model
def res_conv_block(input_layers, num_filters): res_encoder = layers.Conv2D(num_filters, (1, 1), kernel_initializer=initializer, padding="same")(input_layers) res_encoder = layers.BatchNormalization()(res_encoder) res_encoder = layers.Activation("relu")(res_encoder) #encoder = layers.SeparableConv2D(num_filters, (3, 3), depthwise_initializer=initializer, # pointwise_initializer=initializer, padding="same")(input_layers) encoder = layers.Conv2D(num_filters, (3, 3), kernel_initializer=initializer, padding="same")(input_layers) encoder = layers.BatchNormalization()(encoder) encoder = layers.Activation("relu")(encoder) encoder = layers.Conv2D(num_filters, (3, 3), kernel_initializer=initializer, padding="same")(encoder) encoder = layers.BatchNormalization()(encoder) encoder = layers.Activation("relu")(encoder) return encoder + res_encoder
def create_classifier(): with tf.name_scope("Disc"): X = kl.Input((32, 32, 3), name="X") layer = kl.Conv2D(filters=16, kernel_size=3, padding="same", activation="relu")(X) layer = kl.BatchNormalization()(layer) layer = kl.Conv2D(filters=32, kernel_size=3, padding="same", activation="relu")(layer) layer = kl.BatchNormalization()(layer) layer = kl.MaxPool2D()(layer) layer = kl.Conv2D(filters=64, kernel_size=4, padding="same", activation="relu")(layer) layer = kl.BatchNormalization()(layer) layer = kl.MaxPool2D()(layer) layer = kl.Conv2D(filters=128, kernel_size=4, padding="same", activation="relu")(layer) layer = kl.BatchNormalization()(layer) layer = kl.MaxPool2D()(layer) layer = kl.Dropout(0.2)(layer) layer = kl.Flatten()(layer) fidout = layer layer = kl.Dense(512, activation="relu")(layer) layer = kl.Dropout(0.2)(layer) D_out = kl.Dense(10, activation="softmax")(layer) model = k.Model(inputs=X, outputs=D_out) fidmodel = k.Model(inputs=X, outputs=fidout) return model, fidmodel
def cgan_generator(c_dim, z_dim): c = layers.Input(shape=[c_dim]) z = layers.Input(shape=[z_dim]) x = layers.concatenate([c, z]) x = layers.Dense(512)(x) x = layers.BatchNormalization()(x) x = layers.Dense(512, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Dense(512, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Dense(512, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Dense(256, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Dense(99, activation='tanh')(x) return Model(inputs=[c, z], outputs=x)
def make_generator_model(): """ Generating network structure. Returns: Sequential model. """ model = tf.keras.Sequential() model.add(layers.Dense(8 * 8 * 256, use_bias=False, input_shape=(128, ))) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add(layers.Reshape((8, 8, 256))) assert model.output_shape == (None, 8, 8, 256 ) # Note: None is the batch size model.add( layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)) assert model.output_shape == (None, 8, 8, 128) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add( layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)) assert model.output_shape == (None, 16, 16, 64) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add( layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh')) assert model.output_shape == (None, 32, 32, 3) return model
def convnet(input_shape, output_size, conv_filters=(64, 64, 64), conv_kernel_sizes=(3, 3, 3), conv_strides=(2, 2, 2), use_global_average_pool=False, normalization_type=None, normalization_kwargs={}, downsampling_type='conv', name='convnet', *args, **kwargs): assert downsampling_type in ('pool', 'conv'), downsampling_type img_input = layers.Input(shape=input_shape, dtype=tf.float32) x = img_input for (conv_filter, conv_kernel_size, conv_stride) in zip(conv_filters, conv_kernel_sizes, conv_strides): x = layers.Conv2D( filters=conv_filter, kernel_size=conv_kernel_size, strides=(conv_stride if downsampling_type == 'conv' else 1), padding="SAME", activation='linear', *args, **kwargs)(x) if normalization_type == 'batch': x = layers.BatchNormalization(**normalization_kwargs)(x) elif normalization_type == 'layer': x = LayerNormalization(**normalization_kwargs)(x) elif normalization_type == 'group': x = GroupNormalization(**normalization_kwargs)(x) elif normalization_type == 'instance': x = InstanceNormalization(**normalization_kwargs)(x) elif normalization_type == 'weight': raise NotImplementedError(normalization_type) else: assert normalization_type is None, normalization_type x = layers.LeakyReLU()(x) if downsampling_type == 'pool' and conv_stride > 1: x = getattr(tf.keras.layers, 'AvgPool2D')(pool_size=conv_stride, strides=conv_stride)(x) if use_global_average_pool: x = layers.GlobalAveragePooling2D(name='average_pool')(x) else: x = tf.keras.layers.Flatten()(x) model = models.Model(img_input, x, name=name) model.summary() return model
def __init__(self, image_shape: tuple, embedding_size: int = 16, conv_layers: Optional[List[ConvLayerConfig]] = None, l2_param_penalty: float = 0.00): pn = tf.keras.regularizers.l2( l2_param_penalty) if l2_param_penalty > 0 else None if conv_layers is None: conv_layers = [ ConvLayerConfig(stride=2, filter_size=3, nr_filters=8, activation='elu', batch_norm=True), ConvLayerConfig(stride=2, filter_size=3, nr_filters=int(image_shape[-1]), activation='elu', batch_norm=True), ] img_s = [int(x) for x in image_shape[:2]] for cl in conv_layers: img_s = [s / cl.stride for s in img_s] initial_shape = (int(img_s[0]), int(img_s[1]), 1) assert np.allclose( initial_shape[:2], img_s[:2]), 'eventual size divided by strides should be an integer' encoding = layers.Input(shape=(embedding_size, ), name='embedding_input', dtype=tf.float32) e = layers.Dense(units=np.prod(initial_shape), activation='elu')(encoding) e = layers.Reshape(target_shape=initial_shape)(e) for cl in conv_layers: e = layers.Conv2DTranspose(filters=cl.nr_filters, kernel_size=(cl.filter_size, cl.filter_size), strides=(cl.stride, cl.stride), data_format='channels_last', padding='same', activation=cl.activation, kernel_regularizer=pn)(e) if cl.batch_norm: e = layers.BatchNormalization()(e) rgb_norm = e assert rgb_norm.shape[1:] == image_shape self.model = tf.keras.Model(inputs=[encoding], outputs=[rgb_norm])
def build_discriminator_net(img_shape): """ Base network that the supervised/unsupervised children will use Vanilla CNN """ model = Sequential() # Convolutional layer, from 28x28x1 into 14x14x32 tensor model.add( Conv2D(32, kernel_size=3, strides=2, input_shape=img_shape, padding='same')) model.add(LeakyReLU(alpha=0.01)) # Convolutional layer, from 14x14x32 into 7x7x64 tensor model.add( Conv2D(64, kernel_size=3, strides=2, input_shape=img_shape, padding='same')) model.add(layers.BatchNormalization()) model.add(LeakyReLU(alpha=0.01)) # Convolutional layer, from 7x7x64 into 3x3x128 tensor model.add( Conv2D(128, kernel_size=3, strides=2, input_shape=img_shape, padding='same')) model.add(layers.BatchNormalization()) model.add(LeakyReLU(alpha=0.01)) # Starts differing from base CNN GAN here model.add(layers.Dropout(0.5)) model.add(layers.Flatten()) model.add(layers.Dense(NUM_CLASSES)) return model
def create_gen(Zt, Ct, img_shape=(28, 28, 1), noise_shape=(7, 7, 1), filter_size=3, strides=[2, 2], filters=[128, 64]): with tf.name_scope("Gen"): # Generator Z = kl.Input(noise_shape, tensor=Zt, name="Z") C = kl.Input(img_shape, tensor=Ct, name="C") Zf = kl.Flatten()(Z) layer = kl.Dense(np.prod(noise_shape) * 7)(Zf) layer = kl.Reshape( (noise_shape[0], noise_shape[1], noise_shape[-1] * 7))(layer) for l in range(len(filters)): layer = kl.Conv2DTranspose(filters=filters[l], kernel_size=filter_size, padding="same", strides=strides[l], activation="relu")(layer) layer = kl.BatchNormalization()(layer) for l in range(len(filters)): layer = kl.Conv2DTranspose(filters=filters[l], kernel_size=filter_size, padding="same", dilation_rate=l + 2, activation="relu")(layer) layer = kl.BatchNormalization()(layer) G_out = kl.Conv2DTranspose(filters=img_shape[-1], kernel_size=filter_size, activation="tanh", padding="same")(layer) model = k.Model(inputs=[Z, C], outputs=G_out) return model
def conv_block_basic(input_tensor, filters, stage, block, strides=(2, 2), weight_decay=5e-4, use_bias=False): conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = layers.Conv2D(filters, (3, 3), strides=strides, padding='same', kernel_initializer='he_normal', name=conv_name_base + '2a', kernel_regularizer=l2(weight_decay), use_bias=use_bias)(input_tensor) x = layers.BatchNormalization(name=bn_name_base + '2a')(x) x = layers.Activation('relu')(x) x = layers.Conv2D(filters, (3, 3), padding='same', kernel_initializer='he_normal', name=conv_name_base + '2b', kernel_regularizer=l2(weight_decay), use_bias=use_bias)(x) x = layers.BatchNormalization(name=bn_name_base + '2b')(x) x = layers.Activation('relu')(x) shortcut = layers.Conv2D(filters, (1, 1), strides=strides, padding='valid', kernel_initializer='he_normal', name=conv_name_base + '1', kernel_regularizer=l2(weight_decay), use_bias=use_bias)(input_tensor) shortcut = layers.BatchNormalization(name=bn_name_base + '1')(shortcut) x = layers.add([x, shortcut]) x = layers.Activation('relu')(x) return x
def make_last_layers_mobilenet(x, id, num_filters, out_filters): x = compose( kl.Conv2D(num_filters, kernel_size=1, padding='same', use_bias=False, name='block_' + str(id) + '_conv'), kl.BatchNormalization(momentum=0.9, name='block_' + str(id) + '_BN'), kl.LeakyReLU(name='block_' + str(id) + '_relu6'), MobilenetSeparableConv2D(2 * num_filters, kernel_size=(3, 3), use_bias=False, padding='same'), kl.Conv2D(num_filters, kernel_size=1, padding='same', use_bias=False, name='block_' + str(id + 1) + '_conv'), kl.BatchNormalization(momentum=0.9, name='block_' + str(id + 1) + '_BN'), kl.LeakyReLU(name='block_' + str(id + 1) + '_relu6'), MobilenetSeparableConv2D(2 * num_filters, kernel_size=(3, 3), use_bias=False, padding='same'), kl.Conv2D(num_filters, kernel_size=1, padding='same', use_bias=False, name='block_' + str(id + 2) + '_conv'), kl.BatchNormalization(momentum=0.9, name='block_' + str(id + 2) + '_BN'), kl.LeakyReLU(name='block_' + str(id + 2) + '_relu6'))(x) y = compose( MobilenetSeparableConv2D(2 * num_filters, kernel_size=(3, 3), use_bias=False, padding='same'), kl.Conv2D(out_filters, kernel_size=1, padding='same', use_bias=False))(x) return x, y
def resnet_layer(inputs, num_filters, kernel_size=3, strides=1, activation='relu', batch_normalization=True, conv_first=True): ''' 2D Convolution-Batch Normalization-Activation stack builder # Arguments inputs (tensor): input tensor from input image or previous layer num_filters (int): Conv2D number of filters kernel_size (int): Conv2D square kernel dimensions strides (int): Conv2D square stride dimensions activation (string): activation name batch_normalization (bool): whether to include batch normalization conv_first (bool): conv-bn-activation (True) or bn-activation-conv (False) # Returns x (tensor): tensor as input to the next layer ''' conv = layers.Conv2D(num_filters, kernel_size=kernel_size, strides=strides, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4)) x = inputs if conv_first: x = conv(x) if batch_normalization: x = layers.BatchNormalization()(x) if activation is not None: x = layers.Activation(activation)(x) else: if batch_normalization: x = layers.BatchNormalization()(x) if activation is not None: x = layers.Activation(activation)(x) x = conv(x) return x
def Convolutional_LSTM(n_frames, width, height, channels): # take input movies of shape ( ) input = layers.Input(shape=(n_frames, width, height, channels)) x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(input) x = layers.BatchNormalization()(x) x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(x) x = layers.BatchNormalization()(x) x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(x) x = layers.BatchNormalization()(x) x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(x) x = layers.BatchNormalization()(x) x = layers.Conv3D(filters=1, kernel_size=(3, 3, 3), padding='same', data_format='channels_last')(x) x = layers.Activation('sigmoid')(x) conv_lstm = tf.keras.models.Model(input=input, output=x) conv_lstm.compile(optimizer='adadelta', loss='binary_crossentropy') # return a movie of identical shape return conv_lstm
def decoder_block(self, input_tensor, concat_tensor, num_filters, dropout_rate): decoder = layers.Conv2DTranspose(num_filters, (2, 2), strides=(self.stride, self.stride), padding='same')(input_tensor) decoder = layers.concatenate([concat_tensor, decoder], axis=-1) dropout = layers.Dropout(dropout_rate)(decoder) decoder = layers.BatchNormalization()(dropout) decoder = layers.Activation('relu')(decoder) decoder = layers.Conv2D(num_filters, (self.kernel_size, self.kernel_size), padding='same')(decoder) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation('relu')(decoder) decoder = layers.Conv2D(num_filters, (self.kernel_size, self.kernel_size), padding='same')(decoder) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation('relu')(decoder) return decoder
def bn_relu(inputs, axis=-1, momentum=BATCH_NORM_DECAY, epsilon=BATCH_NORM_EPSILON, bn_name=None): x = layers.BatchNormalization(axis=axis, momentum=momentum, epsilon=epsilon, name=bn_name)(inputs) x = layers.ReLU()(x) return x
def resnet50(num_classes, batch_size=None): """Instantiates the ResNet50 architecture. Args: num_classes: `int` number of classes for image classification. batch_size: Size of the batches for each step. Returns: A Keras model instance. """ input_shape = (224, 224, 3) img_input = layers.Input(shape=input_shape, batch_size=batch_size) x = img_input if backend.image_data_format() == 'channels_first': x = layers.Permute((3, 1, 2))(x) bn_axis = 1 else: # channels_last bn_axis = -1 x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(x) x = layers.Conv2D(64, (7, 7), strides=(2, 2), padding='valid', kernel_initializer='he_normal', kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY), name='conv1')(x) x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) x = resnet_block(x, size=3, kernel_size=3, filters=256, stage=2, conv_strides=(1, 1)) x = resnet_block(x, size=4, kernel_size=3, filters=512, stage=3) x = resnet_block(x, size=6, kernel_size=3, filters=1024, stage=4) x = resnet_block(x, size=3, kernel_size=3, filters=2048, stage=5) x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(num_classes, kernel_initializer='he_normal', kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY), name='fc1000')(x) # A softmax that is followed by the model loss must be done cannot be done # in float16 due to numeric issues. So we pass dtype=float32. x = layers.Activation('softmax', dtype='float32')(x) # Create model. return models.Model(img_input, x, name='resnet50')
def _build_resnet(self, num_classes, blocks, num_filters_per_block, dtype='float32', batch_size=None, use_l2_regularizer=True, reduce_mean=False, softmax=True): if backend.image_data_format() == 'channels_first': bn_axis = 1 else: # channels_last bn_axis = 3 # x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(x) self._resnet_layers['conv1'] = layers.Conv2D( 64, (3, 3), strides=(1, 1), padding='same', use_bias=False, kernel_initializer='he_normal', kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer), name='conv1') self._resnet_layers['bn_conv1'] = layers.BatchNormalization( axis=bn_axis, momentum=BATCH_NORM_DECAY, epsilon=BATCH_NORM_EPSILON, name='bn_conv1') for i, (num_block, num_filter) in enumerate(zip(blocks, num_filters_per_block)): stage_id = i + 1 self._build_conv_block(3, [num_filter, num_filter, num_filter], stage=stage_id, block='a_', strides=(1, 1), use_l2_regularizer=use_l2_regularizer) for j in range(num_block): self._build_identity_block( 3, [num_filter, num_filter, num_filter], stage=stage_id, block='b_' + str(j), use_l2_regularizer=use_l2_regularizer) self._build_identity_block( 3, [num_filter, num_filter, num_filter], stage=stage_id, block='c_' + str(j), use_l2_regularizer=use_l2_regularizer) return
def create_sequential_model(): model = tf.keras.Sequential() model.add(layers.Input(shape=(None, None, 3))) model.add( layers.Conv2D(filters=64, kernel_size=(1, 1), strides=2, activation='relu')) model.add(layers.BatchNormalization()) model.add(layers.Dense(2, activation="relu")) return model
def discriminator_and_classifier_model(c_dim): inputs = keras.Input(shape=(99,)) x = layers.Dense(1024, input_shape=(64,))(inputs) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Dense(512)(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Dense(256)(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) d_out = layers.Dense(1)(x) x = layers.Dense(256)(x) x = layers.LeakyReLU()(x) q_out = layers.Dense(c_dim)(x) return keras.Model(inputs=inputs, outputs=d_out), keras.Model(inputs=inputs, outputs=q_out)
def generator(): """ Purpose of the Generator model is to images that looks real. During training, the Generator progressively becomes better at creating images that look real. The Generator model does up-sampling to produces images from random noise. It takes random noise as an input, then up-samples several times until reach desired image size (in this case 224x224x3). Returns: The Generator model. """ start = time.time() model = keras.Sequential([ layers.Dense(units=7 * 7 * 256, use_bias=False, input_shape=(GEN_NOISE_INPUT_SHAPE,)), layers.BatchNormalization(), layers.LeakyReLU(), layers.Reshape((7, 7, 256)), layers.Conv2DTranspose(filters=128, kernel_size=(5, 5), strides=(1, 1), padding="same", use_bias=False), layers.BatchNormalization(), layers.LeakyReLU(), layers.Conv2DTranspose(filters=64, kernel_size=(5, 5), strides=(2, 2), padding="same", use_bias=False), layers.BatchNormalization(), layers.LeakyReLU(), layers.Conv2DTranspose(filters=32, kernel_size=(5, 5), strides=(2, 2), padding="same", use_bias=False), layers.BatchNormalization(), layers.LeakyReLU(), layers.Conv2DTranspose(filters=3, kernel_size=(5, 5), strides=(2, 2), padding="same", use_bias=False, activation="tanh"), ]) end = time.time() if DEBUG_LOG: print("Execution time: {:.9f}s (generator)".format(end - start)) return model
def define_model(self): z = Input(shape=[self.model_parameters.latent_size]) class_id = Input(shape=[1]) embedded_id = layers.Embedding(input_dim=10, output_dim=50)(class_id) embedded_id = layers.Dense(units=7 * 7)(embedded_id) embedded_id = layers.Reshape(target_shape=(7, 7, 1))(embedded_id) x = layers.Dense(units=7 * 7 * 256, use_bias=False)(z) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Reshape((7, 7, 256))(x) inputs = layers.Concatenate(axis=3)([x, embedded_id]) x = layers.Conv2D(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)(inputs) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D(64, (5, 5), strides=(1, 1), padding='same', use_bias=False)(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D(1, (5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh')(x) model = Model(name=self.model_name, inputs=[z, class_id], outputs=x) return model
def DenseNet121(input_shape=None): input_shape = imagenet_utils.obtain_input_shape( input_shape, default_size=224, min_size=32, data_format=backend.image_data_format(), require_flatten=True) img_input = layers.Input(shape=input_shape) bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input) x = layers.Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x) x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1/bn')(x) x = layers.Activation('relu', name='conv1/relu')(x) x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x) x = layers.MaxPooling2D(3, strides=2, name='pool1')(x) x = dense_block(x, 6, name='conv2') x = transition_block(x, 0.5, name='pool2') x = dense_block(x, 12, name='conv3') x = transition_block(x, 0.5, name='pool3') x = dense_block(x, 24, name='conv4') x = transition_block(x, 0.5, name='pool4') x = dense_block(x, 16, name='conv5') x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x) x = layers.Activation('relu', name='relu')(x) x = layers.GlobalAveragePooling2D(name='avg_pool')(x) imagenet_utils.validate_activation('softmax', None) x = layers.Dense(NUM_CLASSES, activation='softmax', name='predictions')(x) # Create model. model = training.Model(img_input, x, name='densenet121') return model
def _separable_conv_block(ip, filters, kernel_size=(3, 3), strides=(1, 1), block_id=None): channel_dim = -1 with backend.name_scope('separable_conv_block_%s' % block_id): x = layers.Activation('relu')(ip) if strides == (2, 2): x = layers.ZeroPadding2D( padding=imagenet_utils.correct_pad(x, kernel_size), name='separable_conv_1_pad_%s' % block_id)(x) conv_pad = 'valid' else: conv_pad = 'same' x = layers.SeparableConv2D(filters, kernel_size, strides=strides, name='separable_conv_1_%s' % block_id, padding=conv_pad, use_bias=False, kernel_initializer='he_normal')(x) x = layers.BatchNormalization(axis=channel_dim, momentum=0.9997, epsilon=1e-3, name='separable_conv_1_bn_%s' % (block_id))(x) x = layers.Activation('relu')(x) x = layers.SeparableConv2D(filters, kernel_size, name='separable_conv_2_%s' % block_id, padding='same', use_bias=False, kernel_initializer='he_normal')(x) x = layers.BatchNormalization(axis=channel_dim, momentum=0.9997, epsilon=1e-3, name='separable_conv_2_bn_%s' % (block_id))(x) return x
def __init__(self, num_hidden, num_classes, use_bn=False, use_dp=False): super(SmallSubclassMLP, self).__init__(name='test_model') self.use_bn = use_bn self.use_dp = use_dp self.layer_a = layers.Dense(num_hidden, activation='relu') activation = 'sigmoid' if num_classes == 1 else 'softmax' self.layer_b = layers.Dense(num_classes, activation=activation) if self.use_dp: self.dp = layers.Dropout(0.5) if self.use_bn: self.bn = layers.BatchNormalization(axis=-1)
def discriminator_model(): model = tf.keras.Sequential() model.add(layers.Dense(1024, input_shape=(121, ))) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add(layers.Dense(512, )) model.add(layers.LeakyReLU()) model.add(layers.Dense(1)) return model