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_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 __init__(self, out_channels=256, **kwargs): ''' Feature Pyramid Networks Attributes --- out_channels: int. the channels of pyramid feature maps. ''' super(FPN, self).__init__(**kwargs) self.out_channels = out_channels self.fpn_c2p2 = layers.Conv2D(out_channels, (1, 1), kernel_initializer='he_normal', name='fpn_c2p2') self.fpn_c3p3 = layers.Conv2D(out_channels, (1, 1), kernel_initializer='he_normal', name='fpn_c3p3') self.fpn_c4p4 = layers.Conv2D(out_channels, (1, 1), kernel_initializer='he_normal', name='fpn_c4p4') self.fpn_c5p5 = layers.Conv2D(out_channels, (1, 1), kernel_initializer='he_normal', name='fpn_c5p5') self.fpn_p3upsampled = layers.UpSampling2D(size=(2, 2), name='fpn_p3upsampled') self.fpn_p4upsampled = layers.UpSampling2D(size=(2, 2), name='fpn_p4upsampled') self.fpn_p5upsampled = layers.UpSampling2D(size=(2, 2), name='fpn_p5upsampled') self.fpn_p2 = layers.Conv2D(out_channels, (3, 3), padding='SAME', kernel_initializer='he_normal', name='fpn_p2') self.fpn_p3 = layers.Conv2D(out_channels, (3, 3), padding='SAME', kernel_initializer='he_normal', name='fpn_p3') self.fpn_p4 = layers.Conv2D(out_channels, (3, 3), padding='SAME', kernel_initializer='he_normal', name='fpn_p4') self.fpn_p5 = layers.Conv2D(out_channels, (3, 3), padding='SAME', kernel_initializer='he_normal', name='fpn_p5') self.fpn_p6 = layers.MaxPooling2D(pool_size=(1, 1), strides=2, name='fpn_p6')
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)
def RetinaNet(input_shape, num_classes, num_anchor=9): """Creates the RetinaNet. RetinaNet is composed of an FPN, a classification sub-network and a localization regression sub-network. Args: input_shape (tuple): shape of input image. num_classes (int): number of classes. num_anchor (int, optional): number of anchor boxes. Defaults to 9. Returns: 'Model' object: RetinaNet. """ inputs = tf.keras.Input(shape=input_shape) # FPN resnet50 = tf.keras.applications.ResNet50(weights="imagenet", include_top=False, input_tensor=inputs, pooling=None) assert resnet50.layers[80].name == "conv3_block4_out" C3 = resnet50.layers[80].output assert resnet50.layers[142].name == "conv4_block6_out" C4 = resnet50.layers[142].output assert resnet50.layers[-1].name == "conv5_block3_out" C5 = resnet50.layers[-1].output P5 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C5) P5_upsampling = layers.UpSampling2D()(P5) P4 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C4) P4 = layers.Add()([P5_upsampling, P4]) P4_upsampling = layers.UpSampling2D()(P4) P3 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C3) P3 = layers.Add()([P4_upsampling, P3]) P6 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P6")(C5) P7 = layers.Activation('relu')(P6) P7 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P7")(P7) P5 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P5")(P5) P4 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P4")(P4) P3 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P3")(P3) # classification subnet cls_subnet = classification_sub_net(num_classes=num_classes, num_anchor=num_anchor) P3_cls = cls_subnet(P3) P4_cls = cls_subnet(P4) P5_cls = cls_subnet(P5) P6_cls = cls_subnet(P6) P7_cls = cls_subnet(P7) cls_output = layers.Concatenate(axis=-2)([P3_cls, P4_cls, P5_cls, P6_cls, P7_cls]) # localization subnet loc_subnet = regression_sub_net(num_anchor=num_anchor) P3_loc = loc_subnet(P3) P4_loc = loc_subnet(P4) P5_loc = loc_subnet(P5) P6_loc = loc_subnet(P6) P7_loc = loc_subnet(P7) loc_output = layers.Concatenate(axis=-2)([P3_loc, P4_loc, P5_loc, P6_loc, P7_loc]) return tf.keras.Model(inputs=inputs, outputs=[cls_output, loc_output])
def _decoder_block_last(self, num_filters, inputs, strides=(2, 2)): features, encoder_out = inputs upsample = layers.UpSampling2D(size=strides)(encoder_out) conv_1 = self._conv_block(num_filters, upsample) concat = layers.Concatenate(axis=-1)([conv_1, features]) conv_2 = self._conv_block(num_filters * 2, concat) return conv_2
def dsv_block(input_layers, num_filters, scale_factor): dsv = layers.Conv2D(num_filters, kernel_size=1, strides=1, kernel_initializer=initializer, padding="same")(input_layers) dsv = layers.UpSampling2D(size=scale_factor, interpolation='bilinear')(dsv) return dsv
def __init__(self, latent_dim): generator_input = tf.keras.Input(shape=(latent_dim,)) x = layers.Dense(1024)(generator_input) x = layers.Activation('tanh')(x) x = layers.Dense(128*7*7)(x) x = layers.BatchNormalization()(x) x = layers.Activation('tanh')(x) x = layers.Reshape((7, 7, 128))(x) x = layers.UpSampling2D(size=(2, 2))(x) 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(generator_input, x)
def _decoder_block(self, num_filters, inputs, strides=(2, 2)): features, encoder_out = inputs upsample = layers.UpSampling2D(size=strides)(encoder_out) conv_1 = self._conv_block(num_filters, upsample) concat = layers.Concatenate(axis=-1)([conv_1, features]) conv_2 = self._conv_block(num_filters, concat) conv_3 = layers.Conv2D(num_filters, (1, 1), padding='same')(conv_2) output = layers.LeakyReLU(alpha=0.01)( InstanceNormalization(axis=-1)(conv_3)) return output
def upsampling1d(x, size=2): """ Args: x: input_tensor (N, L) size: int Returns: tensor (N, L*ks) """ _x = tf.expand_dims(x, axis=2) _x = kl.UpSampling2D((size, 1))(_x) _x = tf.squeeze(_x, axis=2) return _x
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 __init__(self,filter:int, **kwargs): super(AttnGatingBlock, self).__init__() self.theta_x = layers.Conv2D(filter, kernel_size=(2,2), strides=(2, 2), **kwargs) self.phi_g = layers.Conv2D(filter, kernel_size=(1,1), **kwargs) self.deconv_g = layers.Conv2DTranspose(filter, kernel_size=(3,3), strides=(1,1), **kwargs) self.act_xg = layers.Activation('relu') self.conv = layers.Conv2D(1, kernel_size=(1,1), **kwargs) self.act_sigmoid = layers.Activation('sigmoid') self.upsample = layers.UpSampling2D() self.conv_end = layers.Conv2D(filter, kernel_size=(1, 1), **kwargs) self.bn = layers.BatchNormalization()
def define_generator(latent_dim=50, nclasses=10): label = layers.Input(shape=(1, )) li = layers.Embedding(nclasses, latent_dim)(label) li = layers.Flatten()(li) noise = layers.Input(shape=(latent_dim, )) input = layers.multiply([li, noise]) x = layers.Dense(7*7*128, activation="relu")(input) x = layers.Reshape((7, 7, 128))(x) x = layers.BatchNormalization(momentum=0.8)(x) x = layers.UpSampling2D()(x) x = layers.Conv2D(filters=128, kernel_size=3, padding="same", activation="relu")(x) x = layers.BatchNormalization(momentum=0.8)(x) x = layers.UpSampling2D()(x) x = layers.Conv2D(filters=64, kernel_size=3, padding="same", activation="relu")(x) x = layers.BatchNormalization(momentum=0.8)(x) out = layers.Conv2D(filters=1, kernel_size=3, padding="same", activation="tanh")(x) model = tf.keras.Model([noise, label], out) return model
def _forward(self, level, inp, var_scope, is_train): # Upper branch up1 = inp up1 = self._modules['b1_' + str(level)]( up1, 256, 256, var_scope=var_scope + "_ConvBlock_b1_level_%d" % level, is_train=is_train) # Lower branch low1 = layers.AveragePooling2D(pool_size=(2, 2), strides=2, name=var_scope + '_AvgPool2D_level_%d' % level)(inp) low1 = self._modules['b2_' + str(level)]( low1, 256, 256, var_scope=var_scope + "_ConvBlock_b2_level_%d" % level, is_train=is_train) if level > 1: low2 = self._forward(level - 1, low1, var_scope=var_scope + '_forward_level_%d' % level, is_train=is_train) else: low2 = low1 low2 = self._modules['b2_plus_' + str(level)]( low2, 256, 256, var_scope=var_scope + "_ConvBlock_b2_plus_level_%d" % level, is_train=is_train) low3 = low2 low3 = self._modules['b3_' + str(level)]( low3, 256, 256, var_scope=var_scope + "_ConvBlock_b3_level_%d" % level, is_train=is_train) up2 = layers.UpSampling2D(size=(2, 2), name=var_scope + '_UpSample2D')(low3) return up1 + up2
def build(self): inputs = layers.Input(self.input_size) output0 = self._context_module(16, inputs, strides=(1, 1)) output1 = self._context_module(32, output0, strides=(2, 2)) output2 = self._context_module(64, output1, strides=(2, 2)) output3 = self._context_module(128, output2, strides=(2, 2)) output4 = self._context_module(256, output3, strides=(2, 2)) decoder0 = self._decoder_block(128, [output3, output4]) decoder1 = self._decoder_block(64, [output2, decoder0]) decoder2 = self._decoder_block(32, [output1, decoder1]) decoder3 = self._decoder_block_last(16, [output0, decoder2]) output0 = layers.Conv2D(self.num_class, (1, 1))(decoder3) output1 = layers.Conv2D(self.num_class, (1, 1))(decoder2) output2_up = layers.UpSampling2D(size=(2, 2))(layers.Conv2D( self.num_class, (1, 1))(decoder1)) output_sum = layers.Add()([output2_up, output1]) output_sum = layers.UpSampling2D(size=(2, 2))(output_sum) output_sum = layers.Add()([output_sum, output0]) output = layers.Softmax()(output_sum) return models.Model(inputs=[inputs], outputs=[output])
def yolov3(input_size, anchors=yolo_anchors, num_classes=80, iou_threshold=0.5, score_threshold=0.5, training=False): """Create YOLO_V3 model CNN body in Keras.""" num_anchors = len(anchors) // 3 inputs = Input(input_size) x_26, x_43, x = darknet_body(name='Yolo_DarkNet')(inputs) x, y1 = make_last_layers(x, 512, num_anchors, num_classes) x = darknetconv2d_bn_leaky(x, 256, (1, 1)) x = layers.UpSampling2D(2)(x) x = layers.Concatenate()([x, x_43]) x, y2 = make_last_layers(x, 256, num_anchors, num_classes) x = darknetconv2d_bn_leaky(x, 128, (1, 1)) x = layers.UpSampling2D(2)(x) x = layers.Concatenate()([x, x_26]) x, y3 = make_last_layers(x, 128, num_anchors, num_classes) h, w, _ = input_size y1 = YoloOutputBoxLayer(anchors[6:], 1, num_classes, training)(y1) y2 = YoloOutputBoxLayer(anchors[3:6], 2, num_classes, training)(y2) y3 = YoloOutputBoxLayer(anchors[0:3], 3, num_classes, training)(y3) if training: return Model(inputs, (y1, y2, y3), name='Yolo-V3') outputs = NMSLayer(num_classes, iou_threshold, score_threshold)([y1, y2, y3]) return Model(inputs, outputs, name='Yolo-V3')
def decoder_block(num_filers, conv1, conv2): up = layers.concatenate([layers.UpSampling2D(size=(2, 2))(conv1), conv2], axis=-1) # to reduce checkerboard effect conv = layers.Conv2D(num_filers, (3, 3), padding='same', kernel_initializer=VarianceScaling())(up) conv = layers.BatchNormalization()(conv) conv = layers.Activation('relu')(conv) conv = layers.Conv2D(num_filers, (3, 3), padding='same', kernel_initializer=VarianceScaling())(conv) conv = layers.BatchNormalization()(conv) conv = layers.Activation('relu')(conv) return conv
def yolov3_tiny(input_size, anchors=yolo_tiny_anchors, num_classes=80, iou_threshold=0.5, score_threshold=0.5, training=False): num_anchors = len(anchors) // 3 inputs = Input(input_size) x1 = darknetconv2d_bn_leaky(inputs, 16, (3, 3)) x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1) x1 = darknetconv2d_bn_leaky(x1, 32, (3, 3)) x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1) x1 = darknetconv2d_bn_leaky(x1, 64, (3, 3)) x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1) x1 = darknetconv2d_bn_leaky(x1, 128, (3, 3)) x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1) x1 = darknetconv2d_bn_leaky(x1, 256, (3, 3)) x2 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1) x2 = darknetconv2d_bn_leaky(x2, 512, (3, 3)) x2 = layers.MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')(x2) x2 = darknetconv2d_bn_leaky(x2, 1024, (3, 3)) x2 = darknetconv2d_bn_leaky(x2, 256, (1, 1)) # make last layer 1 y1 = darknetconv2d_bn_leaky(x2, 512, (3, 3)) y1 = darknetconv2d(y1, num_anchors*(num_classes+5), (1, 1)) y1 = YoloOutputLayer(num_anchors, num_classes)(y1) # Up Sampling x2 = darknetconv2d_bn_leaky(x2, 128, (1, 1)) x2 = layers.UpSampling2D(2)(x2) # make last layer 2 y2 = layers.Concatenate()([x2, x1]) y2 = darknetconv2d_bn_leaky(y2, 256, (3, 3)) y2 = darknetconv2d(y2, num_anchors*(num_classes+5), (1, 1)) y2 = YoloOutputLayer(num_anchors, num_classes)(y2) h, w, _ = input_size y1 = YoloOutputBoxLayer(anchors[3:], 1, num_classes, training)(y1) y2 = YoloOutputBoxLayer(anchors[:3], 2, num_classes, training)(y2) if training: return Model(inputs, (y1, y2), name='Yolo-V3') outputs = NMSLayer(num_classes, iou_threshold, score_threshold)([y1, y2]) return Model(inputs, outputs, name='Yolo-V3')
def call(self, x): if self.npath == 1: out = x for j in range(self.nsublayer): out = getattr(self, f"conv{i+1}_{j+1}")(self.relu(out)) out += x else: assert isinstance(x, (list, tuple)) maxh = tf.reduce_max([xi.shape[-2] for xi in x]) maxw = tf.reduce_max([xi.shape[-1] for xi in x]) out = 0 for i in range(self.npath): outi = x[i] for j in range(self.nsublayer): outi = getattr(self, f"conv{i+1}_{j+1}")(self.relu(outi)) outi += x[i] assert maxh % out.shape[-2] == 0 assert maxw % out.shape[-1] == 0 upsample_size = (maxh / xi.shape[-2], maxw / xi.shape[-1]) if upsample_size != (1, 1): self.upsample = layers.UpSampling2D(upsample_size, "channels_first", interpolation="bilinear") outi = self.upsample(outi) out += outi return out
def _decode_layer(self, vertical_input, horizontal_input, filter_num, filter_size): upu3a = layers.UpSampling2D(size=(2, 2))(vertical_input) convu3a = layers.Conv2DTranspose( filter_num, (2, 2), strides=1, padding="same", activation='relu', kernel_initializer=xavier_initializer_conv2d())(upu3a) convu3b = layers.concatenate(inputs=[horizontal_input, convu3a], axis=3) convu3c = layers.Conv2D( filter_num, filter_size, activation='relu', padding="same", kernel_initializer=xavier_initializer_conv2d())(convu3b) convu3d = layers.Conv2D( filter_num, filter_size, activation='relu', padding="same", kernel_initializer=xavier_initializer_conv2d())(convu3c) return convu3d
def YOLOv4(inputs, num_classes, num_anchors, initial_filters=32, fast=False, anchors=None, conf_thresh=0.05, nms_thresh=0.45, keep_top_k=100, nms_top_k=100): i32 = initial_filters i64 = i32 * 2 i128 = i32 * 4 i256 = i32 * 8 i512 = i32 * 16 i1024 = i32 * 32 if fast: # x = PreLayer()(inputs) x = inputs else: x = inputs # cspdarknet53部分 x = conv2d_unit(x, i32, 3, strides=1, padding='same') # ============================= s2 ============================= x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i64, 3, strides=2) s2 = conv2d_unit(x, i64, 1, strides=1) x = conv2d_unit(x, i64, 1, strides=1) x = stack_residual_block(x, i32, i64, n=1) x = conv2d_unit(x, i64, 1, strides=1) x = layers.Concatenate()([x, s2]) x = conv2d_unit(x, i64, 1, strides=1) # ============================= s4 ============================= x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i128, 3, strides=2) s4 = conv2d_unit(x, i64, 1, strides=1) x = conv2d_unit(x, i64, 1, strides=1) x = stack_residual_block(x, i64, i64, n=2) x = conv2d_unit(x, i64, 1, strides=1) x = layers.Concatenate()([x, s4]) x = conv2d_unit(x, i128, 1, strides=1) # ============================= s8 ============================= x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i256, 3, strides=2) s8 = conv2d_unit(x, i128, 1, strides=1) x = conv2d_unit(x, i128, 1, strides=1) x = stack_residual_block(x, i128, i128, n=8) x = conv2d_unit(x, i128, 1, strides=1) s8 = layers.Concatenate()([x, s8]) x = conv2d_unit(s8, i256, 1, strides=1) # ============================= s16 ============================= x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i512, 3, strides=2) s16 = conv2d_unit(x, i256, 1, strides=1) x = conv2d_unit(x, i256, 1, strides=1) x = stack_residual_block(x, i256, i256, n=8) x = conv2d_unit(x, i256, 1, strides=1) s16 = layers.Concatenate()([x, s16]) x = conv2d_unit(s16, i512, 1, strides=1) # ============================= s32 ============================= x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i1024, 3, strides=2) s32 = conv2d_unit(x, i512, 1, strides=1) x = conv2d_unit(x, i512, 1, strides=1) x = stack_residual_block(x, i512, i512, n=4) x = conv2d_unit(x, i512, 1, strides=1) x = layers.Concatenate()([x, s32]) x = conv2d_unit(x, i1024, 1, strides=1) # cspdarknet53部分结束 # fpn部分 x = conv2d_unit(x, i512, 1, strides=1, act='leaky') x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i512, 1, strides=1, act='leaky') x = spp(x) x = conv2d_unit(x, i512, 1, strides=1, act='leaky') x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky') fpn_s32 = conv2d_unit(x, i512, 1, strides=1, act='leaky') x = conv2d_unit(fpn_s32, i256, 1, strides=1, act='leaky') x = layers.UpSampling2D(2)(x) s16 = conv2d_unit(s16, i256, 1, strides=1, act='leaky') x = layers.Concatenate()([s16, x]) x = conv2d_unit(x, i256, 1, strides=1, act='leaky') x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i256, 1, strides=1, act='leaky') x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky') fpn_s16 = conv2d_unit(x, i256, 1, strides=1, act='leaky') x = conv2d_unit(fpn_s16, i128, 1, strides=1, act='leaky') x = layers.UpSampling2D(2)(x) s8 = conv2d_unit(s8, i128, 1, strides=1, act='leaky') x = layers.Concatenate()([s8, x]) # output_s x = conv2d_unit(x, i128, 1, strides=1, act='leaky') x = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i128, 1, strides=1, act='leaky') x = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i128, 1, strides=1, act='leaky') output_s = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky') output_s = conv2d_unit(output_s, num_anchors * (num_classes + 5), 1, strides=1, bn=0, act=None) # output_m x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i256, 3, strides=2, act='leaky') x = layers.Concatenate()([x, fpn_s16]) x = conv2d_unit(x, i256, 1, strides=1, act='leaky') x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i256, 1, strides=1, act='leaky') x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i256, 1, strides=1, act='leaky') output_m = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky') output_m = conv2d_unit(output_m, num_anchors * (num_classes + 5), 1, strides=1, bn=0, act=None) # output_l x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x) x = conv2d_unit(x, i512, 3, strides=2, act='leaky') x = layers.Concatenate()([x, fpn_s32]) x = conv2d_unit(x, i512, 1, strides=1, act='leaky') x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i512, 1, strides=1, act='leaky') x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky') x = conv2d_unit(x, i512, 1, strides=1, act='leaky') output_l = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky') output_l = conv2d_unit(output_l, num_anchors * (num_classes + 5), 1, strides=1, bn=0, act=None) # 用张量操作实现后处理 if fast: def output_layer(args): output_s, output_m, output_l = args # 先对坐标解码 pred_xywh_s, pred_conf_s, pred_prob_s = decode( output_s, anchors[0], 8, num_classes) pred_xywh_m, pred_conf_m, pred_prob_m = decode( output_m, anchors[1], 16, num_classes) pred_xywh_l, pred_conf_l, pred_prob_l = decode( output_l, anchors[2], 32, num_classes) # 获取分数 pred_score_s = pred_conf_s * pred_prob_s pred_score_m = pred_conf_m * pred_prob_m pred_score_l = pred_conf_l * pred_prob_l # 所有输出层的预测框集合后再执行nms all_pred_boxes = tf.concat([pred_xywh_s, pred_xywh_m, pred_xywh_l], axis=1) # [batch_size, -1, 4] all_pred_scores = tf.concat( [pred_score_s, pred_score_m, pred_score_l], axis=1) # [batch_size, -1, 80] # 用fastnms output = fastnms(all_pred_boxes, all_pred_scores, conf_thresh, nms_thresh, keep_top_k, nms_top_k) return output output = layers.Lambda(output_layer)([output_s, output_m, output_l]) model_body = keras.models.Model(inputs=inputs, outputs=output) else: model_body = keras.models.Model(inputs=inputs, outputs=[output_l, output_m, output_s]) return model_body
def create_model(self): input_images = Input(shape=[self.img_height, self.img_width, self.num_channels]) x1 = layers.Conv2D( filters=64, kernel_size=(7, 7), strides=(2, 2), padding='same', use_bias=False, )(input_images) x1 = tfa.layers.InstanceNormalization()(x1) x1 = layers.ReLU()(x1) x2 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x1) x2 = tfa.layers.InstanceNormalization()(x2) x2 = layers.ReLU()(x2) x3 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x2) x3 = tfa.layers.InstanceNormalization()(x3) x3 = layers.ReLU()(x3) x4 = layers.Conv2D( filters=512, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x3) x4 = tfa.layers.InstanceNormalization()(x4) x4 = layers.ReLU()(x4) x5 = layers.UpSampling2D()(x4) x5 = layers.Concatenate()([x5, x3]) x5 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x5) x5 = tfa.layers.InstanceNormalization()(x5) x5 = layers.LeakyReLU(alpha=0.2)(x5) x6 = layers.UpSampling2D()(x5) x6 = layers.Concatenate()([x6, x2]) x6 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x6) x6 = tfa.layers.InstanceNormalization()(x6) x6 = layers.LeakyReLU(alpha=0.2)(x6) x7 = layers.UpSampling2D()(x6) x7 = layers.Concatenate()([x7, x1]) x7 = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x7) x7 = tfa.layers.InstanceNormalization()(x7) x7 = layers.LeakyReLU(alpha=0.2)(x7) x8 = layers.UpSampling2D()(x7) x8 = layers.Concatenate()([x8, input_images]) x8 = layers.Conv2D( filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x8) x8 = tfa.layers.InstanceNormalization()(x8) x8 = layers.LeakyReLU(alpha=0.2)(x8) x9 = layers.Conv2D( filters=3, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x8) model = Model(name='Generator', inputs=input_images, outputs=x9) return model
def RetinaNet(input_shape, num_classes, num_anchor=9): inputs = tf.keras.Input(shape=input_shape) # FPN resnet50 = tf.keras.applications.ResNet50(weights="imagenet", include_top=False, input_tensor=inputs, pooling=None) assert resnet50.layers[80].name == "conv3_block4_out" C3 = resnet50.layers[80].output assert resnet50.layers[142].name == "conv4_block6_out" C4 = resnet50.layers[142].output assert resnet50.layers[-1].name == "conv5_block3_out" C5 = resnet50.layers[-1].output P5 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001))(C5) P5_upsampling = layers.UpSampling2D()(P5) P4 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001))(C4) P4 = layers.Add()([P5_upsampling, P4]) P4_upsampling = layers.UpSampling2D()(P4) P3 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001))(C3) P3 = layers.Add()([P4_upsampling, P3]) P6 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P6", kernel_regularizer=regularizers.l2(0.0001))(C5) P7 = layers.Activation('relu')(P6) P7 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P7", kernel_regularizer=regularizers.l2(0.0001))(P7) P5 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P5", kernel_regularizer=regularizers.l2(0.0001))(P5) P4 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P4", kernel_regularizer=regularizers.l2(0.0001))(P4) P3 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P3", kernel_regularizer=regularizers.l2(0.0001))(P3) # classification subnet cls_subnet = _classification_sub_net(num_classes=num_classes, num_anchor=num_anchor) P3_cls = cls_subnet(P3) P4_cls = cls_subnet(P4) P5_cls = cls_subnet(P5) P6_cls = cls_subnet(P6) P7_cls = cls_subnet(P7) cls_output = layers.Concatenate(axis=-2)([P3_cls, P4_cls, P5_cls, P6_cls, P7_cls]) # localization subnet loc_subnet = _regression_sub_net(num_anchor=num_anchor) P3_loc = loc_subnet(P3) P4_loc = loc_subnet(P4) P5_loc = loc_subnet(P5) P6_loc = loc_subnet(P6) P7_loc = loc_subnet(P7) loc_output = layers.Concatenate(axis=-2)([P3_loc, P4_loc, P5_loc, P6_loc, P7_loc]) return tf.keras.Model(inputs=inputs, outputs=[cls_output, loc_output])
h1 = layers.Conv2D(16, 3, activation=tf.nn.relu)(encode_input) h1 = layers.Conv2D(32, 3, activation=tf.nn.relu)(h1) h1 = layers.MaxPool2D(3)(h1) h1 = layers.Conv2D(32, 3, activation='relu')(h1) h1 = layers.Conv2D(16, 3, activation='relu')(h1) encode_output = layers.GlobalMaxPool2D()(h1) encode_model = tf.keras.Model(inputs=encode_input, outputs=encode_output, name='encoder') encode_model.summary() decode_input = tf.keras.Input(shape=(16, ), name='encoded_img') h2 = layers.Reshape((4, 4, 1))(decode_input) h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2) h2 = layers.Conv2DTranspose(32, 3, activation='relu')(h2) h2 = layers.UpSampling2D(3)(h2) h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2) decode_output = layers.Conv2DTranspose(1, 3, activation='relu')(h2) decode_model = tf.keras.Model(inputs=decode_input, outputs=decode_output, name='decoder') decode_model.summary() autoencoder_input = tf.keras.Input(shape=(28, 28, 1), name='img') h3 = encode_model(autoencoder_input) autoencoder_output = decode_model(h3) autoencoder = tf.keras.Model(inputs=autoencoder_input, outputs=autoencoder_output, name='autoencoder') autoencoder.summary()
def get_model(): img_height = 256 img_width = 256 img_channels = 1 input_shape = (img_height, img_width, img_channels) img_input = tf.keras.Input(shape=input_shape) conv1 = layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(img_input) conv1 = layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = layers.Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool1) conv2 = layers.Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv2) pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = layers.Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2) conv3 = layers.Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3) pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = layers.Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3) conv4 = layers.Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4) drop4 = layers.Dropout(0.5)(conv4) pool4 = layers.MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = layers.Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool4) conv5 = layers.Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv5) drop5 = layers.Dropout(0.5)(conv5) up6 = layers.Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')( layers.UpSampling2D(size=(2, 2))(drop5)) merge6 = layers.concatenate([drop4, up6]) conv6 = layers.Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge6) conv6 = layers.Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv6) up7 = layers.Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')( layers.UpSampling2D(size=(2, 2))(conv6)) merge7 = layers.concatenate([conv3, up7]) conv7 = layers.Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7) conv7 = layers.Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7) up8 = layers.Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')( layers.UpSampling2D(size=(2, 2))(conv7)) cv1 = layers.Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(up8) merge8 = layers.concatenate([conv2, up8]) conv8 = layers.Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8) conv8 = layers.Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8) up9 = layers.Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')( layers.UpSampling2D(size=(2, 2))(conv8)) merge9 = layers.concatenate([conv1, up9]) conv9 = layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9) conv9 = layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) conv9 = layers.Conv2D(2, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) conv10 = layers.Conv2D(1, 1, activation='sigmoid')(conv9) model = models.Model(img_input, conv10) return model
def create_model(self): # inputs = Input(shape=[self.max_sequence_length, self.embedding_size]) z = Input(shape=[self.hidden_size]) captions = Input(shape=self.max_sequence_length) embeddings = layers.Embedding(self.vocab_size, self.embedding_size)(captions) embeddings = attention.multihead_attention_model(embeddings) embeddings = layers.Flatten()(embeddings) embeddings = layers.Dense(units=8 * 8 * 32, use_bias=False)(embeddings) embeddings = layers.BatchNormalization()(embeddings) embeddings = layers.LeakyReLU()(embeddings) embeddings = layers.Reshape((8, 8, 32))(embeddings) x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Reshape((8, 8, 256))(x) x = layers.Concatenate(axis=3)([x, embeddings]) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) n_resnet = 6 for _ in range(n_resnet): x = resnet_block(256, x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2D( filters=3, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x) # model = Model(name='Generator', inputs=z, outputs=x) model = Model(name='Generator', inputs=[z, captions], outputs=x) return model
def upsample_block(x): u = layers.UpSampling2D((2, 2))(x) return u
def upsample5_concat_block(x, xskip): # concatenates a decoder output with and encoder output of same size u = layers.UpSampling2D((5, 5))(x)# image dimensions are multiplied by 2 c = layers.Concatenate()([u, xskip]) return c
def define_model(self): input_images = Input(shape=[ self.model_parameters.img_height, self.model_parameters.img_width, self.model_parameters.num_channels ]) x = layers.Conv2D( filters=64, kernel_size=(7, 7), padding='same', use_bias=False, )(input_images) x = tfa.layers.InstanceNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x) x = tfa.layers.InstanceNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x) x = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x) n_resnet = 6 for _ in range(n_resnet): x = advanced_layers.residual_block(256, x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = tfa.layers.InstanceNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = tfa.layers.InstanceNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = tfa.layers.InstanceNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2D( filters=32, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False, )(x) x = tfa.layers.InstanceNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2D( filters=3, kernel_size=(7, 7), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x) model = Model(name=self.model_name, inputs=input_images, outputs=x) return model
def define_model(self): input_images = Input(shape=[ self.model_parameters.img_height, self.model_parameters.img_width, self.model_parameters.num_channels ]) x1 = layers.Conv2D( filters=64, kernel_size=(7, 7), strides=(2, 2), padding='same', use_bias=False, )(input_images) x1 = tfa.layers.InstanceNormalization()(x1) x1 = layers.ReLU()(x1) x2 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x1) x2 = tfa.layers.InstanceNormalization()(x2) x2 = layers.ReLU()(x2) x3 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x2) x3 = tfa.layers.InstanceNormalization()(x3) x3 = layers.ReLU()(x3) x4 = advanced_layers.densely_connected_residual_block(x3) x5 = layers.Concatenate()([x4, x3]) x5 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x5) x5 = tfa.layers.InstanceNormalization()(x5) x5 = layers.LeakyReLU(alpha=0.2)(x5) x6 = layers.UpSampling2D()(x5) x6 = layers.Concatenate()([x6, x2]) x6 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x6) x6 = tfa.layers.InstanceNormalization()(x6) x6 = layers.LeakyReLU(alpha=0.2)(x6) x7 = layers.UpSampling2D()(x6) x7 = layers.Concatenate()([x7, x1]) x7 = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x7) x7 = tfa.layers.InstanceNormalization()(x7) x7 = layers.LeakyReLU(alpha=0.2)(x7) x8 = layers.UpSampling2D()(x7) x8 = layers.Concatenate()([x8, input_images]) x8 = layers.Conv2D( filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x8) x8 = tfa.layers.InstanceNormalization()(x8) x8 = layers.LeakyReLU(alpha=0.2)(x8) x9 = layers.Conv2D( filters=3, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x8) model = Model(name=self.model_name, inputs=input_images, outputs=x9) return model