def fully_connected_net(args): window_len = args[0] input_state_shape = (10, ) pre_int_shape = (window_len, 3) imu_input_shape = (window_len, 7, 1) # Input layers. Don't change names imu_in = layers.Input(imu_input_shape, name="imu_input") state_in = layers.Input(input_state_shape, name="state_input") _, _, dt_vec = custom_layers.PreProcessIMU()(imu_in) x = layers.Flatten()(imu_in) x = layers.Dense(200)(x) x = norm_activate(x, 'relu') x = layers.Dense(400)(x) x = norm_activate(x, 'relu') x = layers.Dense(400)(x) feat_vec = norm_activate(x, 'relu') r_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x) rot_prior = layers.Reshape(pre_int_shape, name="pre_integrated_R")(r_flat) x = layers.Concatenate()([feat_vec, r_flat]) v_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x) v_prior = layers.Reshape(pre_int_shape, name="pre_integrated_v")(v_flat) x = layers.Concatenate()([feat_vec, r_flat, v_flat]) p_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x) p_prior = layers.Reshape(pre_int_shape, name="pre_integrated_p")(p_flat) return Model(inputs=(imu_in, state_in), outputs=(rot_prior, v_prior, p_prior))
def make_generator_model(dataset='mnist'): """ implements generate. Args: dataset: mnist or cifar10 dataset. (default='mnist'). choice{'mnist', 'cifar'}. Returns: model. """ model = tf.keras.models.Sequential() model.add(layers.Dense(256, input_dim=100)) model.add(layers.LeakyReLU(alpha=0.2)) model.add(layers.Dense(512)) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU(alpha=0.2)) model.add(layers.Dense(1024)) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU(alpha=0.2)) if dataset == 'mnist': model.add(layers.Dense(28 * 28 * 1, activation='tanh')) model.add(layers.Reshape((28, 28, 1))) elif dataset == 'cifar': model.add(layers.Dense(32 * 32 * 3, activation='tanh')) model.add(layers.Reshape((32, 32, 3))) return model
def __init__(self, latent_dim, condition_dim): # prepare latent vector (noise) input generator_input1 = layers.Input(shape=(latent_dim, )) x1 = layers.Dense(1024)(generator_input1) x1 = layers.Activation('tanh')(x1) x1 = layers.Dense(128 * 7 * 7)(x1) x1 = layers.BatchNormalization()(x1) x1 = layers.Activation('tanh')(x1) x1 = layers.Reshape((7, 7, 128))(x1) # prepare conditional input generator_input2 = layers.Input(shape=(condition_dim, )) x2 = layers.Dense(1024)(generator_input2) x2 = layers.Activation('tanh')(x2) x2 = layers.Dense(128 * 7 * 7)(x2) x2 = layers.BatchNormalization()(x2) x2 = layers.Activation('tanh')(x2) x2 = layers.Reshape((7, 7, 128))(x2) # concatenate 2 inputs generator_input = layers.Concatenate()([x1, x2]) x = layers.UpSampling2D(size=(2, 2))(generator_input) x = layers.Conv2D(64, 5, padding='same')(x) x = layers.Activation('tanh')(x) x = layers.UpSampling2D(size=(2, 2))(x) x = layers.Conv2D(1, 5, padding='same')(x) x = layers.Activation('tanh')(x) self.generator = tf.keras.models.Model(inputs=[generator_input1, generator_input2], outputs=x)
def define_generator(latent_dim=50, nclasses=10): label = layers.Input(shape=(1, )) li = layers.Embedding(nclasses, 50)(label) li = layers.Dense(7 * 7 * 1, activation="relu")(li) li = layers.Reshape((7, 7, 1))(li) noise = layers.Input(shape=(latent_dim, )) n = layers.Dense(7 * 7 * 384, activation="relu")(noise) n = layers.Reshape((7, 7, 384))(n) input = layers.concatenate([n, li], axis=-1) x = layers.Conv2DTranspose(filters=192, kernel_size=5, strides=2, padding="same")(input) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2DTranspose(filters=1, kernel_size=5, strides=2, padding="same", activation="tanh")(x) model = tf.keras.Model([noise, label], x) return model
def RSoftmax(x, filters, radix, groups, name): bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 c = filters // radix // groups shape = (groups, radix, c) if bn_axis == 3 else (groups, radix, c) x = layers.Reshape(shape, name=name + '_0_attn_reshape')(x) x = layers.Lambda(lambda x: tf.transpose(x, (0, 2, 1, 3)), name=name + '_attn_transpose')(x) x = layers.Softmax(axis=1, name=name + '_attn_softmax')(x) shape = (1, 1, filters) if bn_axis == 3 else (filters, 1, 1) x = layers.Reshape(shape, name=name + '_1_attn_reshape')(x) return x
def __init__(self, height, width, channels, condition_dim): # prepare real images discriminator_input1 = layers.Input(shape=(height, width, channels)) x1 = layers.Conv2D(64, 5, padding='same')(discriminator_input1) x1 = layers.Activation('tanh')(x1) x1 = layers.MaxPooling2D(pool_size=(2, 2))(x1) x1 = layers.Conv2D(128, 5)(x1) x1 = layers.Activation('tanh')(x1) x1 = layers.MaxPooling2D(pool_size=(2, 2))(x1) # condition input from generator discriminator_input2 = layers.Input(shape=(condition_dim, )) x2 = layers.Dense(1024)(discriminator_input2) x2 = layers.Activation('tanh')(x2) x2 = layers.Dense(5 * 5 * 128)(x2) x2 = layers.BatchNormalization()(x2) x2 = layers.Activation('tanh')(x2) x2 = layers.Reshape((5, 5, 128))(x2) # concatenate 2 inputs discriminator_input = layers.concatenate([x1, x2]) x = layers.Flatten()(discriminator_input) x = layers.Dense(1024)(x) x = layers.Activation('tanh')(x) x = layers.Dense(1, activation='sigmoid')(x) self.discriminator = tf.keras.models.Model(inputs=[discriminator_input1, discriminator_input2], outputs=x)
def generator_model(self): model = tf.keras.Sequential() # Linear block model.add(kl.Dense(self.crop_size * 8 * 4 * 4 * 2, input_shape=(self.z_dim,), kernel_initializer=tf.keras.initializers.random_normal(stddev=0.01))) model.add(kl.Reshape((2, 4, 4, self.crop_size * 8))) model.add(kl.BatchNormalization()) model.add(kl.ReLU()) # Convolution block 1 model.add(kl.Conv3DTranspose(filters=self.crop_size * 4, kernel_size=4, strides=2, padding='same', kernel_initializer=self.conv_init, use_bias=True)) model.add(kl.BatchNormalization()) model.add(kl.ReLU()) # Convolution block 2 model.add(kl.Conv3DTranspose(filters=self.crop_size * 2, kernel_size=4, strides=2, padding='same', kernel_initializer=self.conv_init, use_bias=True)) model.add(kl.BatchNormalization()) model.add(kl.ReLU()) # Convolution block 3 model.add(kl.Conv3DTranspose(filters=self.crop_size, kernel_size=4, strides=2, padding='same', kernel_initializer=self.conv_init, use_bias=True)) model.add(kl.BatchNormalization()) model.add(kl.ReLU()) # Convolution block 4 model.add(kl.Conv3DTranspose(filters=3, kernel_size=4, strides=2, padding='same', kernel_initializer=self.conv_init, use_bias=True, activation='tanh')) return model
def _do_variational_autoencoding(input_signal, latent_dim=2): x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=2, padding='same')(input_signal) x = layers.LeakyReLU()(x) x = layers.Conv2D(filters=32, kernel_size=(3, 3), strides=2, padding='same')(x) x = layers.LeakyReLU()(x) shape_before_flattening = K.int_shape(x) x = layers.Flatten()(x) x = layers.Dense(units=32, activation='relu')(x) z_mean = layers.Dense(units=latent_dim)(x) z_log_var = layers.Dense(units=latent_dim)(x) epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim), mean=0., stddev=1.) z = z_mean + K.exp(z_log_var) * epsilon x = layers.Dense(np.prod(shape_before_flattening[1:]), activation='relu')(z) x = layers.Reshape(shape_before_flattening[1:])(x) x = layers.Conv2DTranspose(filters=32, kernel_size=(3, 3), strides=2, padding='same')(x) x = layers.LeakyReLU()(x) x = layers.Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=2, padding='same', activation='relu')(x) return x
def convnet_preprocessor(input_shapes, image_shape, output_size, name="convnet_preprocessor", make_picklable=True, *args, **kwargs): inputs = [layers.Input(shape=input_shape) for input_shape in input_shapes] concatenated_input = layers.Lambda(lambda x: tf.concat(x, axis=-1))(inputs) image_size = np.prod(image_shape) images_flat, input_raw = layers.Lambda( lambda x: [x[..., :image_size], x[..., image_size:]])( concatenated_input) images = layers.Reshape(image_shape)(images_flat) preprocessed_images = convnet( input_shape=image_shape, output_size=output_size - input_raw.shape[-1], *args, **kwargs, )(images) output = layers.Lambda(lambda x: tf.concat(x, axis=-1))( [preprocessed_images, input_raw]) preprocessor = PicklableKerasModel(inputs, output, name=name) return preprocessor
def define_model(self): z = Input(shape=[self.model_parameters.latent_size]) x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Reshape((8, 8, 256))(x) x = layers.Conv2D(128, (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(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(3, (5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh')(x) model = Model(name=self.model_name, inputs=z, outputs=x) return model
def flatten(x, reshape=False): """ Flattens the input to two dimensional. Parameters: ---------- x : keras.backend tensor/variable/symbol Input tensor/variable/symbol. reshape : bool, default False Whether do reshape instead of flatten. Returns ------- keras.backend tensor/variable/symbol Resulted tensor/variable/symbol. """ if not is_channels_first(): def channels_last_flatten(z): z = K.permute_dimensions(z, pattern=(0, 3, 1, 2)) z = K.reshape(z, shape=(-1, np.prod(K.int_shape(z)[1:]))) updateshape(z) return z return nn.Lambda(channels_last_flatten)(x) else: if reshape: x = nn.Reshape((-1, ))(x) else: x = nn.Flatten()(x) return x
def __init__(self, image_shape: tuple, **kwargs): conv_layers = [ ConvLayerConfig(stride=4, filter_size=8, nr_filters=32, activation='relu', batch_norm=False), ConvLayerConfig(stride=2, filter_size=4, nr_filters=64, activation='relu', batch_norm=False), ConvLayerConfig(stride=1, filter_size=3, nr_filters=64, activation='relu', batch_norm=False), ] rgb = layers.Input(shape=image_shape, name='rgb_input', dtype=tf.uint8) t = layers.Lambda(lambda x: K.cast(x, dtype='float32') / 255.)(rgb) for cl in conv_layers: t = layers.Conv2D( filters=cl.nr_filters, kernel_size=(cl.filter_size, cl.filter_size), strides=(cl.stride, cl.stride), activation=cl.activation, )(t) encoded = layers.Reshape(target_shape=(np.prod(t.shape[1:]), ))(t) self.model = tf.keras.Model(inputs=[rgb], outputs=[encoded]) self.embedding_size = 3136
def rcnn(base_layers, rois, num_classes, image_max_dim, head_fn, pool_size=(7, 7), fc_layers_size=1024): # RoiAlign x = RoiAlign(image_max_dim, pool_size=pool_size)([base_layers, rois]) # # 收缩维度 shared_layer = head_fn(x) # 分类 class_logits = TimeDistributed(layers.Dense(num_classes, activation='linear'), name='rcnn_class_logits')(shared_layer) # 回归(类别相关) deltas = TimeDistributed( layers.Dense(4 * num_classes, activation='linear'), name='rcnn_deltas')( shared_layer) # shape (batch_size,roi_num,4*num_classes) # 变为(batch_size,roi_num,num_classes,4) roi_num = backend.int_shape(deltas)[ 1] # print("roi_num:{}".format(roi_num)) deltas = layers.Reshape((roi_num, num_classes, 4))(deltas) return deltas, class_logits
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 upsampling to produces images from random noise. It takes random noise as an input, then upsamples several times until reach desired image size (in this case 28x28x1). :return: The Generator model. """ 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=1, kernel_size=(5, 5), strides=(2, 2), padding="same", use_bias=False, activation="tanh"), ]) return model
def make_generator_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 make_decoder_model(): """ decoder network structure. Returns: tf.keras.Model """ model = tf.keras.Sequential() model.add(layers.Dense(7 * 7 * 64, activation=tf.nn.relu)) model.add(layers.Reshape((7, 7, 64))) model.add( layers.Conv2DTranspose(64, (3, 3), strides=(2, 2), padding='same', activation=tf.nn.relu, use_bias=False)) model.add( layers.Conv2DTranspose(32, (3, 3), strides=(2, 2), padding='same', activation=tf.nn.relu, use_bias=False)) model.add( layers.Conv2DTranspose(1, (3, 3), strides=(1, 1), padding='same', activation=tf.nn.sigmoid, use_bias=False)) return model
def SplitAttentionConv2D(x, filters, kernel_size, stride=1, padding=(0, 0), groups=1, use_bias=True, radix=2, name=None): bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 reduction_factor = 4 inter_filters = max(filters * radix // reduction_factor, 32) x = layers.ZeroPadding2D((padding, padding), name=name + '_splat_pad')(x) x = layers.Conv2D(filters * radix, kernel_size=kernel_size, strides=stride, groups=groups * radix, use_bias=use_bias, name=name + '_0_splat_conv')(x) x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + '_0_splat_bn')(x) x = layers.Activation('relu', name=name + '_0_splat_relu')(x) splits = layers.Lambda(lambda x: tf.split(x, radix, bn_axis), name=name + '_0_splat_split')(x) x = layers.Add(name=name + '_0_splat_add')(splits) x = layers.GlobalAveragePooling2D(name=name + '_0_splat_pool')(x) shape = (1, 1, filters) if bn_axis == 3 else (filters, 1, 1) x = layers.Reshape(shape, name=name + '_0_splat_reshape')(x) x = layers.Conv2D(inter_filters, kernel_size=1, groups=groups, name=name + '_1_splat_conv')(x) x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + '_1_splat_bn')(x) x = layers.Activation('relu', name=name + '_1_splat_relu')(x) # Attention x = layers.Conv2D(filters * radix, kernel_size=1, groups=groups, name=name + '_2_splat_conv')(x) x = RSoftmax(x, filters * radix, radix, groups, name=name) x = layers.Lambda(lambda x: tf.split(x, radix, bn_axis), name=name + '_1_splat_split')(x) x = layers.Lambda( lambda x: [tf.stack(x[0], axis=bn_axis), tf.stack(x[1], axis=bn_axis)], name=name + '_splat_stack')([splits, x]) x = layers.Multiply(name=name + '_splat_mult')(x) x = layers.Lambda(lambda x: tf.unstack(x, axis=bn_axis), name=name + '_splat_unstack')(x) x = layers.Add(name=name + '_splat_add')(x) return x
def make_generator_model(): model = tf.keras.Sequential() model.add( layers.Dense(4 * 4 * 1024, use_bias=False, input_shape=(100, ), kernel_initializer=weight_initializer)) # model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU(alpha=0.2)) model.add(layers.BatchNormalization()) model.add(layers.Reshape((4, 4, 1024))) assert model.output_shape == (None, 4, 4, 1024) #Upscale using Conv2DTranspose # ToDo: Look into upsampling via interpolation and 2d Convolution model.add( layers.Conv2DTranspose(512, (5, 5), strides=(2, 2), padding='same', use_bias=False, kernel_initializer=weight_initializer)) assert model.output_shape == (None, 8, 8, 512) # model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU(alpha=0.2)) model.add(layers.BatchNormalization()) model.add( layers.Conv2DTranspose(256, (5, 5), strides=(2, 2), padding='same', use_bias=False, kernel_initializer=weight_initializer)) assert model.output_shape == (None, 16, 16, 256) # model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU(alpha=0.2)) model.add(layers.BatchNormalization()) model.add( layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding='same', use_bias=False, kernel_initializer=weight_initializer)) assert model.output_shape == (None, 32, 32, 128) # model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU(alpha=0.2)) model.add(layers.BatchNormalization()) model.add( layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh', kernel_initializer=weight_initializer)) assert model.output_shape == (None, 64, 64, 3) return model
def get_model(): model = models.Sequential() model.add(layers.Reshape((30, 30, 30, 1), input_shape=(30, 30, 30, 1))) model.add(layers.Conv3D(16, 6, strides=2, activation='relu', padding='same')) model.add(layers.Conv3D(64, 5, strides=2, activation='relu', padding='same')) model.add(layers.Conv3D(64, 5, strides=2, activation='relu')) model.add(layers.Flatten()) model.add(layers.Dense(10, activation='softmax')) return model
def regression_sub_net(num_anchor=9): """Creates a regression sub-network for the RetinaNet. Args: num_anchor (int, optional): number of anchor boxes. Defaults to 9. Returns: 'Model' object: regression sub-network. """ model = models.Sequential() model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 4 * num_anchor, kernel_size=3, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add(layers.Reshape( (-1, 4))) # the output dimension is [batch, #anchor, 4] return model
def create_model(self): input_text = Input(shape=self.max_sequence_length) input_image = Input(shape=(self.img_height, self.img_width, self.num_channels)) embedded_id = layers.Embedding(self.vocab_size, self.embedding_size)(input_text) embedded_id = layers.Flatten()(embedded_id) embedded_id = layers.Dense(units=input_image.shape[1] * input_image.shape[2])(embedded_id) embedded_id = layers.Reshape(target_shape=(input_image.shape[1], input_image.shape[2], 1))(embedded_id) x = layers.Concatenate(axis=3)([input_image, embedded_id]) x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = layers.LeakyReLU()(x) x = layers.Dropout(0.3)(x) x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = layers.LeakyReLU()(x) x = layers.Dropout(rate=0.3)(x) # x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) # x = layers.LeakyReLU()(x) # x = layers.Dropout(rate=0.3)(x) # # x = layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) # x = layers.LeakyReLU()(x) # x = layers.Dropout(rate=0.3)(x) x = layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = layers.LeakyReLU()(x) x = layers.Dropout(rate=0.3)(x) x = layers.Flatten()(x) x = layers.Dense(units=1000)(x) x = layers.LeakyReLU()(x) x = layers.Dense(units=1)(x) model = Model(name='discriminator', inputs=[input_text, input_image], outputs=x) return model
def classification_sub_net(num_classes, num_anchor=9): """Creates an object classification sub-network for the RetinaNet. Args: num_classes (int): number of classes. num_anchor (int, optional): number of anchor boxes. Defaults to 9. Returns: 'Model' object: classification sub-network. """ model = models.Sequential() model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( num_classes * num_anchor, kernel_size=3, strides=1, padding='same', activation='sigmoid', kernel_initializer=tf.random_normal_initializer(stddev=0.01), bias_initializer=tf.initializers.constant(np.log(1 / 99)))) model.add(layers.Reshape( (-1, num_classes))) # the output dimension is [batch, #anchor, #classes] return model
def _se_block(inputs, filters, se_ratio, prefix): x = layers.GlobalAveragePooling2D(name=prefix + 'squeeze_excite/AvgPool')(inputs) if backend.image_data_format() == 'channels_first': x = layers.Reshape((filters, 1, 1))(x) else: x = layers.Reshape((1, 1, filters))(x) x = layers.Conv2D(_depth(filters * se_ratio), kernel_size=1, padding='same', name=prefix + 'squeeze_excite/Conv')(x) x = layers.ReLU(name=prefix + 'squeeze_excite/Relu')(x) x = layers.Conv2D(filters, kernel_size=1, padding='same', name=prefix + 'squeeze_excite/Conv_1')(x) x = hard_sigmoid(x) x = layers.Multiply(name=prefix + 'squeeze_excite/Mul')([inputs, x]) return x
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 define_generator(latent_dim=50, nclasses=10): label = layers.Input(shape=(1, )) li = layers.Embedding(nclasses, 50)(label) li = layers.Dense(7*7)(li) li = layers.Reshape((7, 7, 1))(li) in_lat = layers.Input((latent_dim,)) lat = layers.Dense(7*7*128)(in_lat) lat = layers.Reshape((7, 7, 128))(lat) x = layers.concatenate([li, lat], axis=-1) x = layers.Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding="same")(x) x = layers.LeakyReLU(alpha=0.2)(x) x = layers.Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding="same")(x) x = layers.LeakyReLU(alpha=0.2)(x) out = layers.Conv2D(filters=1, kernel_size=7, activation="tanh", padding="same")(x) model = tf.keras.Model([label, in_lat], out) 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 get_model_with_reshapes_and_concats(batch_size=None): inputs = layers.Input((64, ), batch_size=batch_size) x = tf.reshape(inputs, (32, -1)) x = layers.Reshape((16, -1))(x) ones = tf.ones_like(x) t1 = layers.concatenate([x, ones]) # pylint: disable=E1120,E1123 t2 = tf.concat([x, ones], axis=-1) y = tf.concat([t1, t2], axis=-1) y = tf.transpose(y, [2, 0, 1]) y = tf.keras.layers.Flatten()(y) return models.Model(inputs, y, name='ModelWithReshape')
def make_generator_model(input_tensor=None, input_shape=(noise_dim,)): """ Returns: tf.keras.Model """ if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = layers.Dense(7 * 7 * 256, activation=tf.nn.leaky_relu, use_bias=False, name='fc1')(img_input) x = layers.BatchNormalization(name='bn1')(x) x = layers.Reshape(target_shape=(7, 7, 256), name='reshape1')(x) x = layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), activation=tf.nn.leaky_relu, padding='same', use_bias=False, name='deconv1')(x) x = layers.BatchNormalization(name='bn2')(x) x = layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), activation=tf.nn.leaky_relu, padding='same', use_bias=False, name='deconv2')(x) x = layers.BatchNormalization(name='bn3')(x) x = layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), activation=tf.nn.tanh, padding='same', use_bias=False, name='deconv3')(x) if input_tensor is not None: inputs = utils.get_source_inputs(input_tensor) else: inputs = img_input model = models.Model(inputs, x, name='Generator_model') return model
def _classification_sub_net(num_classes, num_anchor=9): model = models.Sequential() model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( 256, kernel_size=3, strides=1, padding='same', activation='relu', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01))) model.add( layers.Conv2D( num_classes * num_anchor, kernel_size=3, strides=1, padding='same', activation='sigmoid', kernel_regularizer=regularizers.l2(0.0001), kernel_initializer=tf.random_normal_initializer(stddev=0.01), bias_initializer=tf.initializers.constant(np.log(1 / 99)))) model.add(layers.Reshape( (-1, num_classes))) # the output dimension is [batch, #anchor, #classes] return model
def make_generator_model(input_tensor=None, input_shape=(noise_dim,)): """ Returns: tf.keras.Model """ if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = layers.Dense(7 * 7 * 256, activation=tf.nn.relu, use_bias=False, name='fc1')(img_input) x = layers.Reshape(target_shape=(7, 7, 128), name='reshape1')(x) x = layers.BatchNormalization(momentum=0.8, name='bn1')(x) x = layers.UpSampling2D(name='upsampling1')(x) x = layers.Conv2D(128, (3, 3), activation=tf.nn.relu, padding="same", use_bias=False, name='conv1')(x) x = layers.BatchNormalization(momentum=0.8, name='bn2')(x) x = layers.UpSampling2D(name='upsampling2')(x) x = layers.Conv2D(64, (3, 3), activation=tf.nn.relu, padding="same", use_bias=False, name='conv2')(x) x = layers.BatchNormalization(momentum=0.8, name='bn3')(x) x = layers.Conv2D(1, (3, 3), activation=tf.nn.tanh, use_bias=False, name='conv3')(x) noise = layers.Input(shape=(noise_dim,)) label = layers.Input(shape=(1,), dtype='int32') label_embedding = layers.Flatten()(layers.Embedding(num_classes, 100)(label)) x = layers.multiply([noise, label_embedding])(x) return models.Model([noise, label], x)