def build_model(self): inputs = Input((self.patch_height, self.patch_width, 1)) conv1 = self.encoding_block(32, strides=(3, 3), padding='same')(inputs) conv1 = self.se_block(ratio=2)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = self.encoding_block(64, strides=(3, 3), padding='same')(pool1) conv2 = self.se_block(ratio=2)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = self.encoding_block(128, strides=(3, 3), padding='same')(pool2) conv3 = self.se_block(ratio=2)(conv3) up = UpSampling2D(size=(2, 2))(conv3) conv4 = decoding_block(filters, strides=(3, 3), padding='same')(up, conv2) conv4 = self.se_block(ratio=2)(conv4) up1 = UpSampling2D(size=(2, 2))(conv4) conv5 = decoding_block(filters, strides=(3, 3), padding='same')(up1, conv1) conv5 = self.se_block(ratio=2)(conv5) conv6 = Conv2D(self.num_seg_class + 1, (1, 1), padding='same')(conv5) conv6 = LeakyReLU(alpha=0.3)(conv6) conv6 = core.Reshape((self.patch_height * self.patch_width, self.num_seg_class + 1))(conv6) act = Activation('softmax')(conv6) model = Model(inputs=inputs, outputs=act) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['categorical_accuracy']) plot_model(model, to_file=os.path.join(self.config.checkpoint, "model.png"), show_shapes=True) self.model = model
def generator(input_dim=INPUT_DIM_START, units=START_NN_NEURONCOUNT, activation='relu'): model = Sequential() model.add(Dense(input_dim=input_dim, units=units)) model.add(BatchNormalization()) model.add(Activation(activation)) denselayerneuroncount = CHANNEL_OF_IMAGE*CHANNEL_COEFFICIENT*2*(WIDTH_OF_IMAGE//4)*(HEIGHT_OF_IMAGE//4) model.add(Dense(denselayerneuroncount)) model.add(BatchNormalization()) model.add(Activation(activation)) model.add(Reshape(((WIDTH_OF_IMAGE//4), (HEIGHT_OF_IMAGE//4), CHANNEL_OF_IMAGE*CHANNEL_COEFFICIENT*2), input_shape=(denselayerneuroncount,))) ''' burada artık elimizde küçük bir matris var çünkü 7*7*128(kanal sayısı) lik bir matris var bunu büyütmek için ise upsampling yapmak gerekli ''' model.add(UpSampling2D((UPSAMPLINGRANGE, UPSAMPLINGRANGE))) #bu aşamadan sonra matris artık 14*14*128 olacak model.add(Conv2D(CHANNEL_COEFFICIENT*CHANNEL_OF_IMAGE, (CONVOLUTIONRANGE, CONVOLUTIONRANGE), padding='same')) #bu aşama derinliği yani kanal sayısını etkiler artık matrisin boyutu 14*14*64 oldu model.add(BatchNormalization()) model.add(Activation(activation)) model.add(UpSampling2D((UPSAMPLINGRANGE, UPSAMPLINGRANGE))) #bu aşamadan sonra matrisin boyutu 28*28*64 oldu model.add(Conv2D(CHANNEL_OF_IMAGE, (CONVOLUTIONRANGE, CONVOLUTIONRANGE), padding='same')) #bu aşamadan sonra ise matrisin boyutu 28*28*1 oldu model.add(Activation('tanh')) #tanh olmasının sebebi de 0 ile 1 arasında çıkmasını sağlamak içindir print(model.summary()) return model
def __init__(self): #self.inception = InceptionResNetV2(weights=None, include_top=True) #self.inception.load_weights('/data/inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5') #inception.graph = tf.get_default_graph() embed_input = Input(shape=(1000,)) encoder_input = Input(shape=(256, 256, 1,)) #encoder_output=GaussianNoise(0.1)(encoder_input) encoder_output = Conv2D(64, (3, 3), activation='relu', padding='same', strides=2)(encoder_input) encoder_output = Conv2D(128, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(128, (3, 3), activation='relu', padding='same', strides=2)(encoder_output) encoder_output = Conv2D(256, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(256, (3, 3), activation='relu', padding='same', strides=2)(encoder_output) encoder_output = Conv2D(512, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(512, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(256, (3, 3), activation='relu', padding='same')(encoder_output) # Fusion fusion_output = RepeatVector(32 * 32)(embed_input) fusion_output = Reshape(([32, 32, 1000]))(fusion_output) fusion_output = concatenate([encoder_output, fusion_output], axis=3) fusion_output = Conv2D(256, (1, 1), activation='relu', padding='same')(fusion_output) # Decoder decoder_output = Conv2D(128, (3, 3), activation='relu', padding='same')(fusion_output) decoder_output = UpSampling2D((2, 2))(decoder_output) decoder_output = Conv2D(64, (3, 3), activation='relu', padding='same')(decoder_output) decoder_output = UpSampling2D((2, 2))(decoder_output) decoder_output = Conv2D(32, (3, 3), activation='relu', padding='same')(decoder_output) decoder_output = Conv2D(16, (3, 3), activation='relu', padding='same')(decoder_output) decoder_output = Conv2D(2, (3, 3), activation='tanh', padding='same')(decoder_output) decoder_output = UpSampling2D((2, 2))(decoder_output) model = Model(inputs=[encoder_input, embed_input], outputs=decoder_output) model.compile(optimizer="adagrad", loss='mse') self.model = model
def darknet4det4(input_shape, output_channels): inputs = Input(shape=(input_shape[0], input_shape[1], 3)) darknet = Model(inputs, darknet_body(inputs)) # downsample subsample_x = compose( DarknetConv2D_BN_Leaky(1024, (3, 3), strides=(1, 1)), DarknetConv2D_BN_Leaky(512, (3, 3), strides=(1, 1)), DarknetConv2D_BN_Leaky(512, (3, 3), strides=(2, 2), padding='SAME') )(darknet.output) _, y4 = make_last_layers(subsample_x, 512, output_channels, output_layer_name="output4") x, y1 = make_last_layers(darknet.output, 512, output_channels, output_layer_name='output1') # print(type(x)) # upsmaple x = compose( DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x) x = Concatenate()([x, darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, output_channels, output_layer_name='output2') # upsample x = compose( DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x) x = Concatenate()([x, darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, output_channels, output_layer_name='output3') # order in descending feature size return Model(inputs, [y3, y2, y1, y4])
def construct_autoencoder(): input_img = Input(shape=(20, 20, 2)) code = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img) code = MaxPooling2D((2, 2), padding='same')(code) code = Conv2D(8, (3, 3), activation='relu', padding='same')(code) code = MaxPooling2D((2, 2), padding='same')(code) code = Conv2D(4, (3, 3), activation='relu', padding='same')(code) code = MaxPooling2D((2, 2), padding='same')(code) encoder = Model(input_img, code) # at this point the representation is (4, 4, 8) i.e. 128-dimensional decoder_input = Input(shape=(3, 3, 4)) x = Conv2D(4, (3, 3), activation='relu', padding='same')(decoder_input) x = UpSampling2D((2, 2))(x) x = Conv2D(8, (3, 3), activation='relu', padding='same')(x) x = UpSampling2D((2, 2))(x) x = Conv2D(16, (3, 3), activation='relu')(x) x = UpSampling2D((2, 2))(x) reconstruction = Conv2D(2, (3, 3), activation='sigmoid', padding='same')(x) decoder = Model(decoder_input, reconstruction) autoencoder_input = Input(shape=(20, 20, 2)) output = decoder(encoder(autoencoder_input)) autoencoder = Model(autoencoder_input, output) opt = Adam() autoencoder.compile(optimizer=opt, loss='binary_crossentropy') return autoencoder, encoder, decoder
def convolutional_autoencoder(spatial_size, channel_first=True): model = Sequential() # encoder if channel_first: model.add( Conv2D(128, (3, 3), activation='relu', input_shape=(3, spatial_size, spatial_size), padding='same')) else: model.add( Conv2D(128, (3, 3), activation='relu', input_shape=(spatial_size, spatial_size, 3), padding='same')) model.add(MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')) model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')) model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2), strides=2, padding='same')) # decoder model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D(2)) model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D(2)) model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D(2)) model.add(Conv2D(3, (3, 3), activation='sigmoid', padding='same')) return model
def generator(input_dim=100, units=1024, activation='relu' ): ##iput dim ilk başlangıç gürültü units ilk nöron sayısı model = Sequential() ## ardışık model model.add(Dense(input_dim=input_dim, units=units)) ## layer oluşturma model.add(BatchNormalization()) model.add(Activation(activation)) model.add(Dense(128 * 7 * 7)) ## nöron sayısı veriyoruz model.add(BatchNormalization()) model.add(Activation(activation)) model.add(Reshape((7, 7, 128), input_shape=(128 * 7 * 7, ))) model.add(UpSampling2D( (2, 2))) ## en boy u arttırdık bunlar derinliği etkilemez model.add(Conv2D(64, (5, 5), padding='same') ) ## filtre olulturduk ve 14 14 128 lik matris üstünde gezdirdik model.add(BatchNormalization()) model.add(Activation(activation)) model.add(UpSampling2D((2, 2))) model.add(Conv2D(1, (5, 5), padding='same')) ## derinliği tekrar 1 eindirdik model.add(Activation('tanh')) ## değerleri -1 1 arasına çeker print(model.summary()) " generator ile bilgisayara görüntü üretmeyi öğretiyoruz " return model
def mobilenetv2_yolo_body(inputs, num_anchors, num_classes, alpha=1.0): # input: 416 x 416 x 3 # conv_pw_13_relu :13 x 13 x 1024 # conv_pw_11_relu :26 x 26 x 512 # conv_pw_5_relu : 52 x 52 x 256 mobilenetv2 = MobileNetV2(input_tensor=inputs, include_top=False, weights='imagenet') x, y1 = make_last_layers_mobilenet(mobilenetv2.output, 17, 512, num_anchors * (num_classes + 5)) x = Conv2D(256, kernel_size=1, padding='same', use_bias=False, name='block_20_conv')(x) x = BatchNormalization(momentum=0.9, name='block_20_BN')(x) x = ReLU(6., name='block_20_relu6')(x) x = UpSampling2D(2)(x) x = Concatenate()([x, MobilenetConv2D(mobilenetv2.get_layer('block_12_project_BN').output, (1, 1), alpha, 384)]) x, y2 = make_last_layers_mobilenet(x, 21, 256, num_anchors * (num_classes + 5)) x = Conv2D(128, kernel_size=1, padding='same', use_bias=False, name='block_24_conv')(x) x = BatchNormalization(momentum=0.9, name='block_24_BN')(x) x = ReLU(6., name='block_24_relu6')(x) x = UpSampling2D(2)(x) x = Concatenate()([x, MobilenetConv2D(mobilenetv2.get_layer('block_5_project_BN').output, (1, 1), alpha, 128)]) x, y3 = make_last_layers_mobilenet(x, 25, 128, num_anchors * (num_classes + 5)) # y1 = Lambda(lambda y: tf.reshape(y, [-1, tf.shape(y)[1],tf.shape(y)[2], num_anchors, num_classes + 5]),name='y1')(y1) # y2 = Lambda(lambda y: tf.reshape(y, [-1, tf.shape(y)[1],tf.shape(y)[2], num_anchors, num_classes + 5]),name='y2')(y2) # y3 = Lambda(lambda y: tf.reshape(y, [-1, tf.shape(y)[1],tf.shape(y)[2], num_anchors, num_classes + 5]),name='y3')(y3) return Model(inputs, [y1, y2, y3])
def UNet(input_size: Tuple[int, int, int] = (128, 128, 1)) -> tf.keras.Model: """A standard UNet implementation in TensorFlow Args: input_size: The size of the input tensor (height, width, channels). Raises: ValueError: Length of `input_size` is not 3. ValueError: `input_size`[0] or `input_size`[1] is not a multiple of 16. Returns: A TensorFlow UNet model. """ _check_input_size(input_size) conv_config = {'activation': 'relu', 'padding': 'same', 'kernel_initializer': 'he_normal'} up_config = {'size': (2, 2), 'interpolation': 'bilinear'} inputs = Input(input_size) conv1 = Conv2D(64, 3, **conv_config)(inputs) conv1 = Conv2D(64, 3, **conv_config)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, **conv_config)(pool1) conv2 = Conv2D(128, 3, **conv_config)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, **conv_config)(pool2) conv3 = Conv2D(256, 3, **conv_config)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, **conv_config)(pool3) conv4 = Conv2D(512, 3, **conv_config)(conv4) drop4 = Dropout(0.5)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, 3, **conv_config)(pool4) conv5 = Conv2D(1024, 3, **conv_config)(conv5) drop5 = Dropout(0.5)(conv5) up6 = Conv2D(512, 3, **conv_config)(UpSampling2D(**up_config)(drop5)) merge6 = concatenate([drop4, up6], axis=-1) conv6 = Conv2D(512, 3, **conv_config)(merge6) conv6 = Conv2D(512, 3, **conv_config)(conv6) up7 = Conv2D(256, 3, **conv_config)(UpSampling2D(**up_config)(conv6)) merge7 = concatenate([conv3, up7], axis=-1) conv7 = Conv2D(256, 3, **conv_config)(merge7) conv7 = Conv2D(256, 3, **conv_config)(conv7) up8 = Conv2D(128, 3, **conv_config)(UpSampling2D(**up_config)(conv7)) merge8 = concatenate([conv2, up8], axis=-1) conv8 = Conv2D(128, 3, **conv_config)(merge8) conv8 = Conv2D(128, 3, **conv_config)(conv8) up9 = Conv2D(64, 3, **conv_config)(UpSampling2D(**up_config)(conv8)) merge9 = concatenate([conv1, up9], axis=-1) conv9 = Conv2D(64, 3, **conv_config)(merge9) conv9 = Conv2D(64, 3, **conv_config)(conv9) conv10 = Conv2D(1, 1, activation='sigmoid')(conv9) model = Model(inputs=inputs, outputs=conv10) return model
def generator(self): if self.G: return self.G self.G = Sequential() dropout = 0.2 depth = 64 + 64 + 64 + 64 dim = 8 self.G.add(Dense(dim * dim * depth, input_dim=100)) self.G.add(BatchNormalization(momentum=0.9)) self.G.add(Activation('relu')) self.G.add(Reshape((dim, dim, depth))) self.G.add(Dropout(dropout)) self.G.add(UpSampling2D()) self.G.add(Conv2DTranspose(int(depth / 2), 5, padding='same')) self.G.add(BatchNormalization(momentum=0.9)) self.G.add(Activation('relu')) self.G.add(UpSampling2D()) self.G.add(Conv2DTranspose(int(depth / 4), 5, padding='same')) self.G.add(BatchNormalization(momentum=0.9)) self.G.add(Activation('relu')) self.G.add(UpSampling2D()) self.G.add(Conv2DTranspose(int(depth / 8), 5, padding='same')) self.G.add(BatchNormalization(momentum=0.9)) self.G.add(Activation('relu')) # Out: 64 x 64 x 1 grayscale image [0.0,1.0] per pix self.G.add(Conv2DTranspose(1, 5, padding='same')) self.G.add(Activation('sigmoid')) self.G.summary() return self.G
def SegNet(classes=1, dropout=0.4): input_img = Input((croppedImageSize, croppedImageSize, 1), name='img') # Encoder x = conv2d_block(input_img, 64, kernel_size=3) x = MaxPooling2D(pool_size=(2, 2))(x) x = conv2d_block(x, 128, kernel_size=3) x = MaxPooling2D(pool_size=(2, 2))(x) x = conv2d_block(x, 256, kernel_size=3) x = MaxPooling2D(pool_size=(2, 2))(x) x = conv2d_block(x, 512, kernel_size=3) x = Dropout(dropout)(x) # Decoder x = conv2d_block(x, 512, kernel_size=3) x = UpSampling2D(size=(2, 2))(x) x = conv2d_block(x, 256, kernel_size=3) x = UpSampling2D(size=(2, 2))(x) x = conv2d_block(x, 128, kernel_size=3) x = UpSampling2D(size=(2, 2))(x) x = conv2d_block(x, 64, kernel_size=3) x = Dropout(dropout)(x) x = Conv2D(1, (1, 1), activation='sigmoid')(x) model = Model(inputs=[input_img], outputs=[x]) return model
def create_generator(): # Create the Generator network structure generator = Sequential() generator.add(Dense(12544, input_dim=100)) generator.add(BatchNormalization(momentum=0.9)) generator.add(Activation('relu')) generator.add(Reshape((7, 7, 256))) generator.add(Dropout(0.4)) generator.add(UpSampling2D()) generator.add(Conv2DTranspose(int(128), 5, padding='same')) generator.add(BatchNormalization(momentum=0.9)) generator.add(Activation('relu')) generator.add(UpSampling2D()) generator.add(Conv2DTranspose(int(64), 5, padding='same')) generator.add(BatchNormalization(momentum=0.9)) generator.add(Activation('relu')) generator.add(Conv2DTranspose(int(32), 5, padding='same')) generator.add(BatchNormalization(momentum=0.9)) generator.add(Activation('relu')) generator.add(Conv2DTranspose(1, 5, padding='same')) generator.add(Activation('sigmoid')) generator.compile(optimizer=RMSprop(lr=0.0004, clipvalue=1.0, decay=3e-8), loss='binary_crossentropy', metrics=['accuracy']) generator.summary() return generator
def sameshape_CNN(input_shape, use_b_norm=True): inputs = Input(shape=input_shape) # print("0)", inputs.shape) conv01 = Conv2D(32, kernel_size=(5, 5), input_shape=input_shape)(inputs) # print("1)", conv01.shape) if use_b_norm: conv01 = BatchNormalization()(conv01) conv01 = Activation('relu')(conv01) conv01_pool = MaxPooling2D((3, 3), strides=(3, 3))(conv01) conv02 = Conv2D(64, kernel_size=(3, 3), padding="same")(conv01_pool) # print("2)", conv02.shape) if use_b_norm: conv02 = BatchNormalization()(conv02) conv02 = Activation('relu')(conv02) conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # print("3)", conv02_pool.shape) up02 = UpSampling2D((2, 2))(conv02_pool) up02 = concatenate([conv02, up02], axis=3) # print("4)", up02.shape) up01 = UpSampling2D((3, 3))(up02) if use_b_norm: up01 = BatchNormalization()(up01) up01 = concatenate([conv01, up01], axis=3) # print("5)", up01.shape) output = Conv2D(1, (1, 1), activation='relu')(up01) # print("6)", output.shape) output = Flatten()(output) model = Model(inputs=inputs, outputs=output) model.compile(loss="mean_squared_error", optimizer='adam') # possible losses are: https://www.tensorflow.org/api_docs/python/tf/losses return model
def __init__(self, num_classes=2, l2_value=0.0): super(Unet, self).__init__() print("Creating Unet model.") self.conv1 = unet_conv2d(64, kernel_regularizer=l2(l2_value)) self.pool1 = MaxPooling2D(pool_size=(2, 2)) self.conv2 = unet_conv2d(128, kernel_regularizer=l2(l2_value)) self.pool2 = MaxPooling2D(pool_size=(2, 2)) self.conv3 = unet_conv2d(256, kernel_regularizer=l2(l2_value)) self.pool3 = MaxPooling2D(pool_size=(2, 2)) self.conv4 = unet_conv2d(512, kernel_regularizer=l2(l2_value)) self.pool4 = MaxPooling2D(pool_size=(2, 2)) self.center = unet_conv2d(1024, kernel_regularizer=l2(l2_value)) self.up_conv5 = UpSampling2D(size=(2, 2)) self.conv6 = unet_conv2d(512, kernel_regularizer=l2(l2_value)) self.up_conv6 = UpSampling2D(size=(2, 2)) self.conv7 = unet_conv2d(256, kernel_regularizer=l2(l2_value)) self.up_conv7 = UpSampling2D(size=(2, 2)) self.conv8 = unet_conv2d(128, kernel_regularizer=l2(l2_value)) self.up_conv8 = UpSampling2D(size=(2, 2)) self.conv9 = unet_conv2d(64, kernel_regularizer=l2(l2_value)) self.conv10 = Conv2D(num_classes, (1, 1))
def _build_decoder(self, code_layer): """ Builds a 4-layer-convolutional decoder. """ dense_layer = Dense(2048, activation='relu')(code_layer) reshape_layer = Reshape((4, 4, 128))(dense_layer) upsampling_layer_1 = UpSampling2D(POOLING_SIZE)(reshape_layer) conv_layer_1 = Conv2D(64, CONVOLUTION_KERNEL_SIZE, activation='relu', padding='same')(upsampling_layer_1) upsampling_layer_2 = UpSampling2D(POOLING_SIZE)(conv_layer_1) conv_layer_2 = Conv2D(32, CONVOLUTION_KERNEL_SIZE, activation='relu', padding='same')(upsampling_layer_2) upsampling_layer_3 = UpSampling2D(POOLING_SIZE)(conv_layer_2) conv_layer_3 = Conv2D(16, CONVOLUTION_KERNEL_SIZE, activation='relu', padding='same')(upsampling_layer_3) upsampling_layer_4 = UpSampling2D(POOLING_SIZE)(conv_layer_3) output_layer = Conv2D(3, CONVOLUTION_KERNEL_SIZE, activation='sigmoid', padding='same')(upsampling_layer_4) return output_layer
def generator_model(): model = Sequential() model.add(Dense(1024, input_dim=100)) model.add(Activation('tanh')) model.add(Dense(128 * 7 * 7)) model.add( BatchNormalization()) # 批量归一化: 将前一层的激活值重新规范化,使得其输出数据的均值接近0,其标准差接近1 model.add(Activation('tanh')) model.add(Reshape((7, 7, 128))) # 2维上采样层,即将数据的行和列分别重复2次 model.add(UpSampling2D(size=(2, 2))) model.add(Conv2D(64, (5, 5), padding='same')) model.add(Activation('tanh')) model.add(UpSampling2D(size=(2, 2))) # 卷积核设为1即输出图像的维度 model.add(Conv2D(1, (5, 5), padding='same')) model.add(Activation('tanh')) return model
def get_upsampled_signal(x): y = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_1')(x) y = LeakyReLU(name='decode_relu_1')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_1')(y) y = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_2')(x) y = LeakyReLU(name='decode_relu_2')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_2')(y) y = Conv2DTranspose(filters=32, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_3')(y) y = LeakyReLU(name='decode_relu_3')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_3')(y) y = Conv2DTranspose(filters=16, kernel_size=(2, 2), strides=1, padding='same', name='decode_convtrans_4')(y) y = LeakyReLU(name='decode_relu_4')(y) return y
def UNet(input_size=(128, 128, 3)): """Creates a U-Net model. This U-Net model is composed of 5 "contracting blocks" and 5 "expansive blocks". Args: input_size (tuple, optional): Shape of input image. Defaults to (128, 128, 3). Returns: 'Model' object: U-Net model. """ conv_config = {'activation': 'relu', 'padding': 'same', 'kernel_initializer': 'he_normal'} inputs = Input(input_size) conv1 = Conv2D(64, 3, **conv_config)(inputs) conv1 = Conv2D(64, 3, **conv_config)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, **conv_config)(pool1) conv2 = Conv2D(128, 3, **conv_config)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, **conv_config)(pool2) conv3 = Conv2D(256, 3, **conv_config)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, **conv_config)(pool3) conv4 = Conv2D(512, 3, **conv_config)(conv4) drop4 = Dropout(0.5)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, 3, **conv_config)(pool4) conv5 = Conv2D(1024, 3, **conv_config)(conv5) drop5 = Dropout(0.5)(conv5) up6 = Conv2D(512, 2, **conv_config)(UpSampling2D(size=(2, 2))(drop5)) merge6 = concatenate([drop4, up6], axis=3) conv6 = Conv2D(512, 3, **conv_config)(merge6) conv6 = Conv2D(512, 3, **conv_config)(conv6) up7 = Conv2D(256, 2, **conv_config)(UpSampling2D(size=(2, 2))(conv6)) merge7 = concatenate([conv3, up7], axis=3) conv7 = Conv2D(256, 3, **conv_config)(merge7) conv7 = Conv2D(256, 3, **conv_config)(conv7) up8 = Conv2D(128, 2, **conv_config)(UpSampling2D(size=(2, 2))(conv7)) merge8 = concatenate([conv2, up8], axis=3) conv8 = Conv2D(128, 3, **conv_config)(merge8) conv8 = Conv2D(128, 3, **conv_config)(conv8) up9 = Conv2D(64, 2, **conv_config)(UpSampling2D(size=(2, 2))(conv8)) merge9 = concatenate([conv1, up9], axis=3) conv9 = Conv2D(64, 3, **conv_config)(merge9) conv9 = Conv2D(64, 3, **conv_config)(conv9) conv9 = Conv2D(2, 3, **conv_config)(conv9) conv10 = Conv2D(1, 1, activation='sigmoid')(conv9) model = Model(inputs=inputs, outputs=conv10) return model
def train_net(steps, epochs): # Get images X = [] for filename in os.listdir('./color_images/Train/'): X.append(img_to_array(load_img('./color_images/Train/' + filename))) # print(filename) X = np.array(X, dtype=float) # Set up training and test data split = int(0.95 * len(X)) Xtrain = X[:split] Xtrain = 1.0 / 255 * Xtrain # Design the neural network model = Sequential() model.add(InputLayer(input_shape=(None, None, 1))) model.add(Conv2D(8, (3, 3), input_shape=(None, None, 1), activation='relu', padding='same', strides=2)) model.add(Conv2D(8, (3, 3), activation='relu', padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same', strides=2)) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(Conv2D(32, (3, 3), activation='relu', padding='same', strides=2)) model.add(UpSampling2D((2, 2))) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(2, (3, 3), activation='tanh', padding='same')) # Finish model model.compile(optimizer='rmsprop', loss='mse') # Image transformer datagen = ImageDataGenerator( shear_range=0.2, zoom_range=0.2, rotation_range=20, horizontal_flip=True) # Generate training data batch_size = 50 def image_a_b_gen(batch_size): for batch in datagen.flow(Xtrain, batch_size=batch_size): lab_batch = rgb2lab(batch) X_batch = lab_batch[:, :, :, 0] Y_batch = lab_batch[:, :, :, 1:] / 128 yield (X_batch.reshape(X_batch.shape + (1,)), Y_batch) # Train model TensorBoard(log_dir='/output') model.fit_generator(image_a_b_gen(batch_size), steps_per_epoch=steps, epochs=epochs) # Test images Xtest = rgb2lab(1.0 / 255 * X[split:])[:, :, :, 0] Xtest = Xtest.reshape(Xtest.shape + (1,)) Ytest = rgb2lab(1.0 / 255 * X[split:])[:, :, :, 1:] Ytest = Ytest / 128 print(model.evaluate(Xtest, Ytest, batch_size=batch_size)) model.save('./result/network.h5') del model
def __init__(self, num_classes=2, l2_value=0.0): super(AttentionalUnet, self).__init__() print("Creating AttentionalUnet model.") self.conv1 = unet_conv2d(64, kernel_regularizer=l2(l2_value)) self.pool1 = MaxPooling2D(pool_size=(2, 2)) self.conv2 = unet_conv2d(128, kernel_regularizer=l2(l2_value)) self.pool2 = MaxPooling2D(pool_size=(2, 2)) self.conv3 = unet_conv2d(256, kernel_regularizer=l2(l2_value)) self.pool3 = MaxPooling2D(pool_size=(2, 2)) self.conv4 = unet_conv2d(512, kernel_regularizer=l2(l2_value)) self.pool4 = MaxPooling2D(pool_size=(2, 2)) self.center = unet_conv2d(1024, kernel_regularizer=l2(l2_value)) self.gating = gating_signal(128) # AttentionBlock1 layers self.att1 = SubAttentionBlock(256) # AttentionBlock end self.up_conv5 = UpSampling2D(size=(2, 2)) self.up_conv6 = unet_conv2d(512, kernel_regularizer=l2(l2_value)) # AttentionBlock2 layers self.att2 = SubAttentionBlock(128) # AttentionBlock end self.up_conv7 = UpSampling2D(size=(2, 2)) self.up_conv8 = unet_conv2d(256, kernel_regularizer=l2(l2_value)) # AttentionBlock3 layers self.att3 = SubAttentionBlock(64) # AttentionBlock end self.up_conv9 = UpSampling2D(size=(2, 2)) self.up_conv10 = unet_conv2d(128, kernel_regularizer=l2(l2_value)) # AttentionBlock4 layers self.att4 = SubAttentionBlock(32) # AttentionBlock end self.up_conv11 = UpSampling2D(size=(2, 2)) self.up_conv12 = unet_conv2d(64, kernel_regularizer=l2(l2_value)) self.up_conv13 = Conv2D(num_classes, (1, 1))
def UNet64_sigmoid_tanh(input_shape): """gleich wie UNet64_output_expansed, teilweise mit sigmoid und tanh statt relu.""" inputs = Input(shape=input_shape) conv01 = Conv2D(10, kernel_size=(3, 3), padding="same")(inputs) # 10 x 64x64 conv01 = Activation('tanh')(conv01) conv01_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv01) # 10 x 32x32 print("0)", conv01_pool.shape, "10 x 32x32") conv02 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv01_pool) # 20 x 32x32 conv02 = Activation('tanh')(conv02) conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # 20 x 16x16 print("1)", conv02_pool.shape, "20 x 16x16") conv03 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv02_pool) # 20 x 16x16 conv03 = Activation('tanh')(conv03) conv03_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv03) # 20 x 8x8 print("2)", conv03_pool.shape, "20 x 8x8") conv04 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv03_pool) # 20 x 8x8 conv04 = Activation('relu')(conv04) conv04_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv04) # 20 x 4x4 print("3)", conv04_pool.shape, "20 x 4x4") ### UPSAMPLING: up04 = UpSampling2D((2, 2))(conv04_pool) # 20 x 8x8 up04 = concatenate([conv04, up04], axis=3) # 20+20 x 8x8 print("4)", up04.shape, "40 x 8x8") up03 = UpSampling2D((2, 2))(up04) # 40 x 16x16 up03 = concatenate([conv03, up03], axis=3) # 20+40 x 16x16 print("5)", up03.shape, "60 x 16x16") up02 = UpSampling2D((2, 2))(up03) # 60 x 32x32 up02 = concatenate([conv02, up02], axis=3) # 20+60 x 32x32 print("6)", up02.shape, "80 x 32x32") up01 = UpSampling2D((2, 2))(up02) # 80 x 64x64 up01 = concatenate([conv01, up01], axis=3) # 15+80 x 64x64 print("7)", up01.shape, "95 x 64x64") output = Conv2D(1, (3, 3), activation='relu', padding="same")(up01) # 1 x 64x64 # output = Activation('tanh')(output) print("8)", output.shape, "1 x 64x64") output = Flatten()(output) model = Model(inputs=inputs, outputs=output) model.compile(loss="mean_squared_error", optimizer='nadam') # ToDo: try Nesterov Adam optimizer (nadam) # http://proceedings.mlr.press/v28/sutskever13.pdf return model
def Colorize(): embed_input = Input(shape=(1000, )) # Encoder encoder_input = Input(shape=( 256, 256, 1, )) encoder_output = Conv2D(64, (3, 3), activation='relu', padding='same', strides=2)(encoder_input) encoder_output = Conv2D(128, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(128, (3, 3), activation='relu', padding='same', strides=2)(encoder_output) encoder_output = Conv2D(256, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(256, (3, 3), activation='relu', padding='same', strides=2)(encoder_output) encoder_output = Conv2D(512, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(512, (3, 3), activation='relu', padding='same')(encoder_output) encoder_output = Conv2D(256, (3, 3), activation='relu', padding='same')(encoder_output) # Fusion fusion_output = RepeatVector(32 * 32)(embed_input) fusion_output = Reshape(([32, 32, 1000]))(fusion_output) fusion_output = concatenate([encoder_output, fusion_output], axis=3) fusion_output = Conv2D(256, (1, 1), activation='relu', padding='same')(fusion_output) # Decoder decoder_output = Conv2D(128, (3, 3), activation='relu', padding='same')(fusion_output) decoder_output = UpSampling2D((2, 2))(decoder_output) decoder_output = Conv2D(64, (3, 3), activation='relu', padding='same')(decoder_output) decoder_output = UpSampling2D((2, 2))(decoder_output) decoder_output = Conv2D(32, (3, 3), activation='relu', padding='same')(decoder_output) decoder_output = Conv2D(16, (3, 3), activation='relu', padding='same')(decoder_output) decoder_output = Conv2D(2, (3, 3), activation='tanh', padding='same')(decoder_output) decoder_output = UpSampling2D((2, 2))(decoder_output) return Model(inputs=[encoder_input, embed_input], outputs=decoder_output)
def CMNet(input_size=(256, 256, 3)): inputs = Input(input_size) conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(inputs) conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4) drop4 = Dropout(0.2)(conv4) conv5 = CACP(drop4, 1024) drop5 = Dropout(0.2)(conv5) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(drop5) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv6) pred1 = Conv2D(1, 1, activation='sigmoid', name="pred1")(conv6) lossLay1 = UpSampling2D(size=(8, 8), name="lossLay1", interpolation='bilinear')(pred1) pred1 = UpSampling2D(interpolation='bilinear')(pred1) up7 = Conv2D(256, 1, activation='relu', strides=1, padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2), interpolation='bilinear')(conv6)) merge7 = concatenate([conv3, up7, pred1]) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7) pred2 = Conv2D(1, 1, activation='sigmoid', name="pred2")(conv7) lossLay2 = UpSampling2D(size=(4, 4), name="lossLay2", interpolation='bilinear')(pred2) pred2 = UpSampling2D(interpolation='bilinear')(pred2) up8 = Conv2D(128, 1, activation='relu', strides=1, padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2), interpolation='bilinear')(conv7)) merge8 = concatenate([conv2, up8, pred2]) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8) pred3 = Conv2D(1, 1, activation='sigmoid', name="pred3")(conv8) lossLay3 = UpSampling2D(size=(2, 2), name="lossLay3", interpolation='bilinear')(pred3) pred3 = UpSampling2D(interpolation='bilinear')(pred3) up9 = Conv2D(64, 1, activation='relu', strides=1, padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2), interpolation='bilinear')(conv8)) merge9 = concatenate([conv1, up9, pred3]) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) result = Conv2D(1, 1, activation='sigmoid', name="result")(conv9) # 预测结果4 layers = [lossLay1, lossLay2, lossLay3] model = Model(inputs=inputs, outputs=result) myloss = Weighted_Diceloss(layers) model.compile(optimizer=Adam(lr=1e-4), loss=myloss, metrics=['accuracy']) model.summary() return model
def UNet64_output_expansed(input_shape): """gleich wie UNet64, nur am output ist ein 3x3 Kernel eingesetzt.""" inputs = Input(shape=input_shape) conv01 = Conv2D(10, kernel_size=(3, 3), padding="same")(inputs) # 10 x 64x64 conv01 = Activation('relu')(conv01) conv01_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv01) # 10 x 32x32 print("0)", conv01_pool.shape, "10 x 32x32") conv02 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv01_pool) # 20 x 32x32 conv02 = Activation('relu')(conv02) conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # 20 x 16x16 print("1)", conv02_pool.shape, "20 x 16x16") conv03 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv02_pool) # 20 x 16x16 conv03 = Activation('relu')(conv03) conv03_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv03) # 20 x 8x8 print("2)", conv03_pool.shape, "20 x 8x8") conv04 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv03_pool) # 20 x 8x8 conv04 = Activation('relu')(conv04) conv04_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv04) # 20 x 4x4 print("3)", conv04_pool.shape, "20 x 4x4") ### UPSAMPLING: up04 = UpSampling2D((2, 2))(conv04_pool) # 20 x 8x8 up04 = concatenate([conv04, up04], axis=3) # 20+20 x 8x8 print("4)", up04.shape, "40 x 8x8") up03 = UpSampling2D((2, 2))(up04) # 40 x 16x16 up03 = concatenate([conv03, up03], axis=3) # 20+40 x 16x16 print("5)", up03.shape, "60 x 16x16") up02 = UpSampling2D((2, 2))(up03) # 60 x 32x32 up02 = concatenate([conv02, up02], axis=3) # 20+60 x 32x32 print("6)", up02.shape, "80 x 32x32") up01 = UpSampling2D((2, 2))(up02) # 80 x 64x64 up01 = concatenate([conv01, up01], axis=3) # 10+80 x 64x64 print("7)", up01.shape, "90 x 64x64") output = Conv2D(1, (3, 3), activation='relu', padding="same")(up01) # 1 x 64x64 print("8)", output.shape, "1 x 64x64") output = Flatten()(output) model = Model(inputs=inputs, outputs=output) model.compile(loss="mean_squared_error", optimizer='adam') return model
def upsample(inp, factor, nchannels, config, bn=None, activation=None, upsampling='bilinear', residual=False): if residual: r1 = UpSampling2D(size=(factor, factor), interpolation=upsampling)(inp) up = Conv2D(nchannels, factor, **config)(r1) r2 = Conv2DTranspose(nchannels, factor, strides=(factor, factor), padding='same')(inp) else: if upsampling in ['bilinear', 'nearest']: up = UpSampling2D(size=(factor, factor), interpolation=upsampling)(inp) up = Conv2D(nchannels, factor, **config)(up) elif upsampling == 'conv': up = Conv2DTranspose(nchannels, factor, strides=(factor, factor), padding='same')(inp) elif upsampling == 'subpixel': up = SubPixelConv2D(upsample_factor=factor, nchannels=nchannels)(inp) else: raise (NotImplementedError) if bn and bn == 'before': act = config['activation'] config['activation'] = None if bn: up = BatchNormalization()(up) if bn == 'before': if act: up = Activation(act)(up) else: up = activation(up) config['activation'] = act if residual: up = up + r2 return up
def build_model(self): state_size = (self.config.screen_width, self.config.screen_height, self.config.screen_dim) action_size = self.config.action_size action = Input(shape=(action_size, ), name="action") image = Input(shape=state_size, name="image") img_conv = Sequential() img_conv.add( Conv2D(256, (4, 4), strides=(2, 2), activation="relu", input_shape=state_size)) img_conv.add(Conv2D(128, (3, 3), strides=(2, 2), activation="relu")) img_conv.add(Conv2D(64, (1, 1), strides=(2, 2), activation="relu")) img_conv.add(Flatten()) img_conv.add(Dense(64, activation="relu")) img_conv.add(Dense(64, activation="relu")) action_s = Sequential() action_s.add(Dense(64, activation="relu", input_shape=(action_size, ))) action_s.add(Dense(64, activation="relu")) stream_1 = img_conv(image) stream_2 = action_s(action) x = concatenate([stream_1, stream_2]) x = Dense(128 * 21 * 21, activation="relu")(x) x = Reshape((21, 21, 128))(x) #x = BatchNormalization(momentum=0.8)(x) x = UpSampling2D()(x) x = Conv2D(128, (3, 3), padding="same", activation="relu")(x) #x = BatchNormalization(momentum=0.8)(x) x = UpSampling2D()(x) x = Conv2D(64, (3, 3), padding="same", activation="relu")(x) #x = BatchNormalization(momentum=0.8)(x) x = Conv2D(self.config.screen_dim, (3, 3), padding='same', activation="relu")(x) model = Model(inputs=[action, image], outputs=[x]) model.compile(optimizer=Adam(0.00001), loss=['mse'], metrics=['accuracy']) #model.summary() return model
def init_model(self): x = Input(shape=(3, 3, CHAT_HISTORY_LENGTH)) # 3 x 3 x 128 layer = Conv2D(128, 3, padding="same", activation="relu")(x) layer = UpSampling2D()(layer) # 6 x 6 x 32 layer = Conv2D(32, 3, padding="same", activation="relu")(layer) layer = UpSampling2D()(layer) layer = Cropping2D(cropping=((0, 1), (0, 1)))(layer) # 11 x 11 x 8 layer = Conv2D(8, 3, padding="same", activation="relu")(layer) y = Conv2D(4, 3, padding="same", activation="relu")(layer) model = tf.keras.models.Model(inputs=x, outputs=y) self.model = model
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1, gap1 = make_last_layers(darknet.output, 512, num_anchors * (num_classes + 5), 1) x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x) x = Concatenate()([x, darknet.layers[152].output]) x, y2, gap2 = make_last_layers(x, 256, num_anchors * (num_classes + 5), 2) x = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x) x = Concatenate()([x, darknet.layers[92].output]) x, y3, gap3 = make_last_layers(x, 128, num_anchors * (num_classes + 5), 3) return Model(inputs, [y1, y2, y3])
def FCN16(nClasses, input_height, input_width): img_input = Input(shape=(input_height, input_width, 3)) # model = vgg16.VGG16(include_top=False,weights='imagenet',input_tensor=img_input) # vgg去除全连接层为:7x7x512 # vgg:5个block,1:filters:64,kernel:3;3-128;3-256;3-512 model = FCN32(11, 320, 320) model.load_weights("model.h5") skip1 = Conv2DTranspose(512, kernel_size=(3, 3), strides=(2, 2), padding='same', kernel_initializer="he_normal", name="upsampling6")(model.get_layer("fc7").output) summed = add(inputs=[skip1, model.get_layer("block4_pool").output]) up7 = UpSampling2D(size=(16, 16), interpolation='bilinear', name='upsamping_7')(summed) o = Conv2D(nClasses, kernel_size=(3, 3), activation='relu', padding='same', name='conv_7')(up7) o = Reshape((-1, nClasses))(o) o = Activation("softmax")(o) fcn16 = Model(model.input, o) return fcn16
def tiny_yolo_body(inputs, num_anchors, num_classes): '''Create Tiny YOLO_v3 model CNN body in keras.''' x1 = compose( DarknetConv2D_BN_Leaky(16, (3, 3)), MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'), DarknetConv2D_BN_Leaky(32, (3, 3)), MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'), DarknetConv2D_BN_Leaky(64, (3, 3)), MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'), DarknetConv2D_BN_Leaky(128, (3, 3)), MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'), DarknetConv2D_BN_Leaky(256, (3, 3)))(inputs) x2 = compose( MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'), DarknetConv2D_BN_Leaky(512, (3, 3)), MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same'), DarknetConv2D_BN_Leaky(1024, (3, 3)), DarknetConv2D_BN_Leaky(256, (1, 1)))(x1) y1 = compose(DarknetConv2D_BN_Leaky(512, (3, 3)), DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x2) x2 = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x2) y2 = compose(Concatenate(), DarknetConv2D_BN_Leaky(256, (3, 3)), DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))([x2, x1]) return Model(inputs, [y1, y2])