def create_generator(input_shape): input_vec = Input(input_shape, name='input') x = Dense(128 * 4 * 4, activation='tanh', name='dense')(input_vec) x = BatchNormalization()(x) x = Reshape((4, 4, 128))(x) x = Conv2DTranspose(512, (3, 3), strides=2, activation=tf.nn.leaky_relu, padding='same', name='de_conv_1')(x) x = Conv2DTranspose(256, (3, 3), strides=2, activation=tf.nn.leaky_relu, padding='same', name='de_conv_2')(x) x = Conv2DTranspose(128, (3, 3), strides=2, activation=tf.nn.leaky_relu, padding='same', name='de_conv_3')(x) output = Conv2D(3, (3, 3), activation='tanh', padding='same', name='conv_2')(x) model = Model(input_vec, outputs=output) return model
def FCN8(nClasses,input_height,input_width): # 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="up7")(model.get_layer("fc7").output) # skip2 = Conv2DTranspose(256,kernel_size=(3,3),strides=(2,2),padding='same',kernel_initializer="he_normal",name="up4")(model.get_layer('block4_pool').output) summed = add(inputs=[skip1,model.get_layer("block4_pool").output]) skip2 = Conv2DTranspose(256,kernel_size=(3,3),strides=(2,2),padding='same',kernel_initializer="he_normal",name='up4')(summed) summed = add(inputs=[skip2,model.get_layer("block3_pool").output]) up7 = UpSampling2D(size=(8,8),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) fcn8 = Model(model.input,o) return fcn8
def __init__(self, raanan_architecture=False, sigmoid_activation=True): super(Decoder, self).__init__() self.input_layer = InputLayer() self.fully_connected3 = Dense(512) self.fully_connected4 = Dense(7 * 7 * 64) self.reshape = Reshape((7, 7, 64)) self.conv_transpose1 = Conv2DTranspose(32, 3, padding="same", strides=2) self.conv_transpose2 = Conv2DTranspose(1, 3, padding="same", strides=2) self.relu1 = ReLU() self.relu2 = ReLU() self.relu3 = ReLU() self.last_activation = sigmoid if sigmoid_activation else tanh if raanan_architecture: self.relu1 = LeakyReLU() self.relu2 = LeakyReLU() self.relu3 = LeakyReLU() print("Decoder network created with raanan architecture={}".format( raanan_architecture))
def __init__(self): super(TopModel, self).__init__() input_filters = 2048 # output of resnet self.output_filters = 256 self.nbJoints = 17 self.depth_dim = 64 self.deconv1 = Conv2DTranspose(filters=self.output_filters, kernel_size=4, strides=(2, 2), padding="valid") self.relu1 = ReLU() self.batchnorm1 = BatchNormalization() self.deconv2 = Conv2DTranspose(filters=self.output_filters, kernel_size=4, strides=(2, 2), padding="valid") self.relu2 = ReLU() self.batchnorm2 = BatchNormalization() self.deconv3 = Conv2DTranspose(filters=self.output_filters, kernel_size=4, strides=(2, 2), padding="valid") self.relu3 = ReLU() self.batchnorm3 = BatchNormalization() self.final_conv = Conv2D(filters=self.nbJoints * self.depth_dim, kernel_size=1, strides=1, padding="valid")
def standardUnet(width, height, chann, nc): inputs = Input((height, width, chann)) # image normalization between 0 and 1 s = Lambda(lambda x: x / 255) (inputs) c1 = Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (s) #c1 = Dropout(0.1) (c1) c1 = Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c1) p1 = MaxPooling2D((2, 2)) (c1) c2 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (p1) #c2 = Dropout(0.1) (c2) c2 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c2) p2 = MaxPooling2D((2, 2)) (c2) c3 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (p2) #c3 = Dropout(0.2) (c3) c3 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c3) p3 = MaxPooling2D((2, 2)) (c3) c4 = Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (p3) #c4 = Dropout(0.2) (c4) c4 = Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c4) p4 = MaxPooling2D(pool_size=(2, 2)) (c4) c5 = Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (p4) #c5 = Dropout(0.3) (c5) c5 = Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c5) u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same') (c5) u6 = concatenate([u6, c4]) c6 = Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (u6) #c6 = Dropout(0.2) (c6) c6 = Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c6) u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c6) u7 = concatenate([u7, c3]) c7 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (u7) #c7 = Dropout(0.2) (c7) c7 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c7) u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c7) u8 = concatenate([u8, c2]) c8 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (u8) #c8 = Dropout(0.1) (c8) c8 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c8) u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c8) u9 = concatenate([u9, c1], axis=3) c9 = Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (u9) #c9 = Dropout(0.1) (c9) c9 = Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c9) outputs = Conv2D(nc, (1, 1), activation='softmax') (c9) model = Model(inputs=inputs, outputs=outputs) return model
def create_generator(): model = Sequential() # Reshape input into 32x32x256 tensor via a fully connected layer model.add(Dense(64 * 32 * 32, input_dim=z_dim)) model.add(Reshape((32, 32, 64))) model.add( Conv2DTranspose( # Transposed convolution layer, from 32x32x256 into 64x64x128 tensor 128, kernel_size=3, strides=2, padding='same')) model.add(BatchNormalization()) # Batch normalization model.add(LeakyReLU(alpha=0.01)) # Leaky ReLU model.add( Conv2DTranspose( # Transposed convolution layer, from 64x64x128 to 128x128x64 tensor 64, kernel_size=3, strides=2, padding='same')) model.add(BatchNormalization()) # Batch normalization model.add(LeakyReLU(alpha=0.01)) # Leaky ReLU model.add( Conv2DTranspose( # Transposed convolution layer, from 128x128x64 to 256x256x3 tensor 3, kernel_size=3, strides=2, padding='same')) model.add(Activation('tanh')) # Tanh activation model.compile(loss='binary_crossentropy', optimizer=adam_optimizer()) model.summary() return model
def Decoder(inputs, opts, istrain=True): assert opts.isize % 16 == 0, "isize has to be a multiple of 16" cngf, tisize = opts.dis_filter // 2, 4 while tisize != opts.isize: cngf = cngf * 2 # after loop, cngf reaches to 256 tisize = tisize * 2 '''z is input, and first deconvolution layer to size channel * 4 * 4''' x = Conv2DTranspose(cngf, (4, 4), padding='valid', use_bias=False)(inputs) x = batch_norm(x, "bn1", is_train=istrain) x = Activation('relu')(x) '''size increaing layers ''' size_now = 4 while size_now < opts.isize // 2: x = Conv2DTranspose(cngf // 2, (4, 4), strides=2, padding='same', use_bias=False)(x) x = batch_norm(x, "bn2_" + str(size_now), is_train=istrain) x = Activation('relu')(x) cngf = cngf // 2 size_now = size_now * 2 '''extral layers, keep the channel and size of the layers same''' for t in range(opts.n_extra_layers): x = Conv2DTranspose(cngf, (3, 3), padding='same', use_bias=False)(x) x = batch_norm(x, "bn3_" + str(t), is_train=istrain) x = Activation('relu')(x) ''' final layer, expand the size with 2 and channel of n_output_channel''' x = Conv2DTranspose(opts.image_channel, (4, 4), strides=2, padding='same', use_bias=False)(x) x = Activation('tanh')(x) return x
def get_upsampled_signal(x): y = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_1')(x) y = LeakyReLU(name='decode_relu_1')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_1')(y) y = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_2')(x) y = LeakyReLU(name='decode_relu_2')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_2')(y) y = Conv2DTranspose(filters=32, kernel_size=(3, 3), strides=1, padding='same', name='decode_convtrans_3')(y) y = LeakyReLU(name='decode_relu_3')(y) y = UpSampling2D(size=(2, 2), name='decode_upsample_3')(y) y = Conv2DTranspose(filters=16, kernel_size=(2, 2), strides=1, padding='same', name='decode_convtrans_4')(y) y = LeakyReLU(name='decode_relu_4')(y) return y
def init_generator(self): layers = [ Dense(self.latent_space_size, input_dim=self.latent_space_size, activation='tanh'), Reshape((self.image_height, self.image_width, 1)), BatchNormalization(), Conv2DTranspose(64, (4, 4), strides=(1, 1), kernel_initializer=self.kernel_init, padding='same', use_bias=False), LeakyReLU(), BatchNormalization(), Conv2DTranspose(1, (4, 4), strides=(1, 1), kernel_initializer=self.kernel_init, padding='same', use_bias=False), ] self.generator = self.make_model(layers) self.generator = self.compile_model(self.generator) self.generator_first_layer_to_unlock = 0 self.generator_last_layer_to_unlock = len(layers) #-1 ?
def define_generator(latent_dim, n_classes=10): # weight initialization init = RandomNormal(stddev=0.02) # label input in_label = Input(shape=(1,)) # embedding for categorical input li = Embedding(n_classes, 50)(in_label) # linear multiplication n_nodes = 7 * 7 li = Dense(n_nodes, kernel_initializer=init)(li) # reshape to additional channel li = Reshape((7, 7, 1))(li) # image generator input in_lat = Input(shape=(latent_dim,)) # foundation for 7x7 image n_nodes = 384 * 7 * 7 gen = Dense(n_nodes, kernel_initializer=init)(in_lat) gen = Activation('relu')(gen) gen = Reshape((7, 7, 384))(gen) # merge image gen and label input merge = Concatenate()([gen, li]) # upsample to 14x14 gen = Conv2DTranspose(192, (5,5), strides=(2,2), padding='same', kernel_initializer=init)(merge) gen = BatchNormalization()(gen) gen = Activation('relu')(gen) # upsample to 28x28 gen = Conv2DTranspose(1, (5,5), strides=(2,2), padding='same', kernel_initializer=init)(gen) out_layer = Activation('tanh')(gen) # define model model = Model([in_lat, in_label], out_layer) return model
def __generate_detection_resnet34(self, input_layer, n_category=None): out_filters = n_category + 4 x_1, x_2, x_3, x = self.__generate_encoder(input_layer) # Deconvolution block 1: (16, 16, 512) -> (32, 32, 512) x = Conv2D(filters=256, kernel_size=3, strides=1, padding='same')(x) x = Conv2DTranspose(filters=256, kernel_size=4, strides=2, padding='same')(x) x = Concatenate()([x_3, x]) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) # Deconvolution block 2: (32, 32, 512) -> (64, 64, 256) x = Conv2D(filters=128, kernel_size=3, strides=1, padding='same')(x) x = Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding='same')(x) x = Concatenate()([x_2, x]) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) # Deconvolution block 3: (64, 64, 256) -> (128, 128, 128) x = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(x) x = Conv2DTranspose(filters=64, kernel_size=4, strides=2, padding='same')(x) x = Concatenate()([x_1, x]) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) # Block 4: x = Conv2D(filters=out_filters, kernel_size=1, strides=1, padding='same')(x) out = Activation('sigmoid')(x) # optional return Model(input_layer, out)
def decoder_128(vector_len: int) -> Model: input_decoder = Input(shape=(vector_len, ), name=f"input_{vector_len}x1") x = Dense(64, activation=tanh, name="Activate_Input")(input_decoder) x = Reshape((8, 8, 1), name="Reshape_8x8")(x) x = Conv2DTranspose(16, (3, 3), strides=1, activation=relu, padding='same', name="Transpose_8x8")(x) x = Conv2DTranspose(32, (3, 3), strides=2, activation=relu, padding='same', name="Transpose_16x16")(x) x = Conv2DTranspose(32, (5, 5), strides=2, activation=relu, padding='same', name="Transpose_32x32")(x) x = Conv2DTranspose(64, (5, 5), strides=2, activation=relu, padding='same', name="Transpose_64x64")(x) decoded = Conv2DTranspose(4, (5, 5), strides=2, activation=sigmoid, padding='same', name="Output_128x128")(x) return Model(input_decoder, decoded, name="Decoder")
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 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 decoder(): latent_inputs = keras.Input(shape=(128, )) x = Dropout(0.25)(Dense(8 * 8 * 512)(latent_inputs)) x = Reshape((8, 8, 512))(x) x = Conv2D(512, 1, padding='same')(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2DTranspose(512, 3, strides=2, padding="same")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2DTranspose(256, 3, strides=2, padding="same")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) x = Conv2DTranspose(128, 3, padding="same")(x) x = BatchNormalization()(x) x = LeakyReLU()(x) decoder_outputs = Conv2D(128, 1, strides=1, padding='same', activation='sigmoid')(x) decoder = Model(latent_inputs, decoder_outputs, name="decoder") return decoder
def initialize_model(): model = Sequential() model.add( Conv2D(40, 11, strides=1, padding='same', input_shape=(1, 1024, 4))) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(Conv2D(40, 11, strides=1, padding='same')) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(1, 64))) model.add(Flatten()) model.add(Dense(units=500)) model.add(Dense(units=640)) model.add(Reshape((1, 16, 40))) model.add(Conv2DTranspose(40, 11, strides=(1, 64), padding='same')) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(Conv2DTranspose(40, 11, strides=(1, 1), padding='same')) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(Conv2D(4, 11, strides=1, padding='same', activation='sigmoid')) model.summary() model.compile(optimizer='adam', loss='mse') return model
def build(self): inputs = Input(shape=[None, None, 3]) conv1 = Conv2D(64, 4, 2, activation=LeakyReLU(0.2), padding='same')(inputs) conv2 = Conv2D(128, 4, 2, padding='same')(conv1) conv2 = self.norm(conv2) conv2 = LeakyReLU(0.2)(conv2) conv3 = Conv2D(256, 4, 2, padding='same')(conv2) conv3 = self.norm(conv3) conv3 = LeakyReLU(0.2)(conv3) conv4 = Conv2D(512, 4, 2, padding='same')(conv3) conv4 = self.norm(conv4) conv4 = LeakyReLU(0.2)(conv4) conv5 = Conv2D(1, 4, 2, padding='same')(conv4) upconv1 = Conv2DTranspose(256, 4, 2, padding='same')(conv5) upconv1 = self.norm(upconv1) upconv1 = Activation('relu')(upconv1) concat1 = Concatenate()([conv4, upconv1]) upconv2 = Conv2DTranspose(128, 4, 2, padding='same')(concat1) upconv2 = self.norm(upconv2) upconv2 = Activation('relu')(upconv2) concat2 = Concatenate()([conv3, upconv2]) upconv3 = Conv2DTranspose(64, 4, 2, padding='same')(concat2) upconv3 = self.norm(upconv3) upconv3 = Activation('relu')(upconv3) concat3 = Concatenate()([conv2, upconv3]) upconv4 = Conv2DTranspose(32, 4, 2, padding='same')(concat3) upconv4 = self.norm(upconv4) upconv4 = Activation('relu')(upconv4) concat4 = Concatenate()([conv1, upconv4]) outputs = Conv2DTranspose(self.classes, 4, 2, padding='same', activation='softmax')(concat4) model = Model(inputs=inputs, outputs=[conv5, outputs]) return model
def __init__(self, **kwargs): super(Generator, self).__init__(**kwargs) self.conv1 = Conv2D(64, kernel_size=7, strides=1, padding="valid") self.conv2 = Conv2D(64 * 2, kernel_size=3, strides=2, padding="same") self.conv3 = Conv2D(64 * 4, kernel_size=3, strides=2, padding="same") self.in_c1 = InstanceNorm_kong() self.in_c2 = InstanceNorm_kong() self.in_c3 = InstanceNorm_kong() self.resb1 = ResBlock(c_num=64 * 4) self.resb2 = ResBlock(c_num=64 * 4) self.resb3 = ResBlock(c_num=64 * 4) self.resb4 = ResBlock(c_num=64 * 4) self.resb5 = ResBlock(c_num=64 * 4) self.resb6 = ResBlock(c_num=64 * 4) self.resb7 = ResBlock(c_num=64 * 4) self.resb8 = ResBlock(c_num=64 * 4) self.resb9 = ResBlock(c_num=64 * 4) self.convT1 = Conv2DTranspose(64 * 2, kernel_size=3, strides=2, padding="same") self.convT2 = Conv2DTranspose(64, kernel_size=3, strides=2, padding="same") self.in_cT1 = InstanceNorm_kong() self.in_cT2 = InstanceNorm_kong() self.convRGB = Conv2D(3, kernel_size=7, strides=1, padding="valid")
def _create_decoder(input_shape, encode_block): conv3 = encode_block.get_layer('conv3').output x = Input(shape=input_shape, name='decoder_input') net = Add()([x, conv3]) conv2 = encode_block.get_layer('conv2').output net = Conv2DTranspose(filters=64, kernel_size=3, strides=2, name='dconv1')(x) net = Add()([net, conv2]) net = BatchNormalization()(net) net = Conv2DTranspose(filters=32, kernel_size=3, strides=2, name='dconv2')(net) net = BatchNormalization()(net) encoder_input = encode_block.get_layer('encoder_input').output net = Conv2DTranspose(filters=1, kernel_size=3, strides=2, name='dconv3')(net) net = Add()([net, encoder_input]) net = BatchNormalization()(net) net = Model(inputs=[x, encode_block.input], outputs=net, name='decoder') return net
def get_unet(IMG_WIDTH=256,IMG_HEIGHT=256,IMG_CHANNELS=3): inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)) s = Lambda(lambda x: x / 255) (inputs) c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (s) c1 = Dropout(0.1) (c1) c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c1) p1 = MaxPooling2D((2, 2)) (c1) c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p1) c2 = Dropout(0.1) (c2) c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c2) p2 = MaxPooling2D((2, 2)) (c2) c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p2) c3 = Dropout(0.2) (c3) c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c3) p3 = MaxPooling2D((2, 2)) (c3) c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p3) c4 = Dropout(0.2) (c4) c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c4) p4 = MaxPooling2D(pool_size=(2, 2)) (c4) c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p4) c5 = Dropout(0.3) (c5) c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c5) u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same') (c5) # u6 = concatenate([u6, c4]) c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u6) c6 = Dropout(0.2) (c6) c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c6) u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c6) # u7 = concatenate([u7, c3]) c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u7) c7 = Dropout(0.2) (c7) c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c7) u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c7) # u8 = concatenate([u8, c2]) c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u8) c8 = Dropout(0.1) (c8) c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c8) u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c8) # u9 = concatenate([u9, c1], axis=3) c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u9) c9 = Dropout(0.1) (c9) c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c9) outputs = Conv2D(1, (1, 1), activation='sigmoid') (c9) model = Model(inputs=[inputs], outputs=[outputs]) model.compile(optimizer='adam',loss='binary_crossentropy', metrics=[my_iou_metric]) return model
def build_model(self): inputs = Input((self.patch_height, self.patch_width, 1)) conv1 = Conv2D(32, (1, 1), activation=None, padding='same')(inputs) conv1 = normalization.BatchNormalization(epsilon=2e-05, axis=3, momentum=0.9, weights=None, beta_initializer='zero', gamma_initializer='one')(conv1) conv1 = Activation('relu')(conv1) conv1 = self.DenseBlock(conv1, 32) # 48 conv1 = self.se_block(ratio=2)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = self.DenseBlock(pool1, 64) # 24 conv2 = self.se_block(ratio=2)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = self.DenseBlock(pool2, 64) # 12 conv3 = self.se_block(ratio=2)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = self.DenseBlock(pool3, 64) # 12 conv4 = self.se_block(ratio=2)(conv4) up1 = Conv2DTranspose(64, (3, 3), strides=2, activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0001))(conv4) up1 = concatenate([up1, conv3], axis=3) conv5 = self.DenseBlock(up1, 64) conv5 = self.se_block(ratio=2)(conv5) up2 = Conv2DTranspose(64, (3, 3), strides=2, activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0001))(conv5) up2 = concatenate([up2, conv2], axis=3) conv6 = self.DenseBlock(up2, 64) conv6 = self.se_block(ratio=2)(conv6) up3 = Conv2DTranspose(32, (3, 3), strides=2, activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0001))(conv6) up3 = concatenate([up3, conv1], axis=3) conv7 = self.DenseBlock(up3, 32) conv7 = self.se_block(ratio=2)(conv7) conv8 = Conv2D(self.num_seg_class + 1, (1, 1), activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0001))(conv7) # conv6 = normalization.BatchNormalization(epsilon=1e-06, mode=1, axis=-1, momentum=0.9, weights=None, beta_init='zero', gamma_init='one')(conv6) # for tensorflow conv8 = core.Reshape((self.patch_height * self.patch_width, self.num_seg_class + 1))(conv8) # for theano # conv8 = core.Reshape(((self.num_seg_class + 1), self.patch_height * self.patch_width))(conv8) # conv8 = core.Permute((2, 1))(conv8) ############ act = Activation('softmax')(conv8) 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 _deconv4x(x, filters, kernel_sizes, cfg): assert len(filters) == 2 assert len(kernel_sizes) == 2 x = Conv2DTranspose(filters=filters[0], kernel_size=kernel_sizes[0], strides=2, **cfg)(x) x = Conv2DTranspose(filters=filters[1], kernel_size=kernel_sizes[1], strides=2, **cfg)(x) return x
def simple_instance_network(shape): input_img = Input(shape=shape) input_img_1 = Reshape((*shape, 1))(input_img) # Stage 1 x = Conv2D(32, (3, 3), strides=(1, 1), padding='same', name='conv1', use_bias=True)(input_img_1) x = BatchNormalization(name='bn_conv1')(x) thumbnail1 = x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x) # Stage 2 x = conv_block(x, 3, [64, 64], stage=2, block='a') thumbnail2 = x = identity_block(x, 3, [64, 64], stage=2, block='b') x = MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x) # Stage 3 x = conv_block(x, 3, [128, 128], stage=3, block='a') thumbnail4 = x = identity_block(x, 3, [128, 128], stage=3, block='b') x = MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x) # Stage 4 x = conv_block(x, 3, [256, 256], stage=4, block='a') thumbnail8 = identity_block(x, 3, [256, 256], stage=4, block='b') # Co-stage 4 forge8 = thumbnail8 forge8 = conv_block(forge8, 3, [256, 256], stage=5, block='a') forge8 = identity_block(forge8, 3, [256, 256], stage=5, block='b') # Co-stage 3 forge4 = Conv2DTranspose(128, (3, 3), padding='same', strides=(2, 2), activation='relu')(forge8) forge4_post = identity_block(forge4, 3, [128, 128], stage=6, block='a') thumbnail4_shortcut = conv_block(thumbnail4, 3, [128, 128], stage=6, block='b') forge4_sum_shortcut = Add()([forge4_post, thumbnail4_shortcut]) # Co-stage 2 forge2 = Conv2DTranspose(64, (3, 3), padding='same', strides=(2, 2), activation='relu')(forge4_sum_shortcut) forge2_post = identity_block(forge2, 3, [64, 64], stage=7, block='a') thumbnail2_shortcut = conv_block(thumbnail2, 3, [64, 64], stage=7, block='b') forge2_sum_shortcut = Add()([forge2_post, thumbnail2_shortcut]) # Co-stage 1 forge1 = Conv2DTranspose(32, (3, 3), padding='same', strides=(2, 2), activation='relu')(forge2_sum_shortcut) forge1_post = identity_block(forge1, 3, [32, 32], stage=8, block='a') thumbnail1_shortcut = conv_block(thumbnail1, 3, [32, 32], stage=8, block='b') forge1_sum_shortcut = Add()([forge1_post, thumbnail1_shortcut]) output = Conv2D(2, (3, 3), padding='same', strides=(1, 1), activation='sigmoid')(forge1_sum_shortcut) generated = Model(input=input_img, output=output) return generated
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 miniUnet(width, height, chann, nc): inputs = Input((height, width, chann)) # image normalization between 0 and 1 #s = Lambda(lambda x: x / 255) (inputs) c1 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (inputs) #c1 = Dropout(0.1) (c1) #c1 = BatchNormalization()(c1) c1 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c1) #c1 = BatchNormalization()(c1) p1 = MaxPooling2D((2, 2)) (c1) c2 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (p1) #c2 = Dropout(0.2) (c2) #c2 = BatchNormalization()(c2) c2 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c2) #c2 = BatchNormalization()(c2) p2 = MaxPooling2D((2, 2)) (c2) c3 = Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (p2) #c3 = Dropout(0.2) (c3) #c3 = BatchNormalization()(c3) c3 = Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c3) #c3 = BatchNormalization()(c3) u4 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c3) u4 = concatenate([u4, c2]) c4 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (u4) #c4 = Dropout(0.2) (c4) #c4 = BatchNormalization()(c4) c4 = Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c4) #c4 = BatchNormalization()(c4) u5 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c4) u5 = concatenate([u5, c1]) c5 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (u5) #c5 = Dropout(0.1) (c5) #c5 = BatchNormalization()(c5) c5 = Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c5) #c5 = BatchNormalization()(c5) outputs = Conv2D(nc, (1, 1), activation='softmax') (c5) model = Model(inputs=[inputs], outputs=[outputs]) return model
def kaggle_u_net_direct(im_height, im_width, im_chan): """ This is a kaggle recommended u-net architecture from kaggle kernels. https://www.kaggle.com/jesperdramsch/intro-to-seismic-salt-and-how-to-geophysics :return: """ inputs = Input((im_height, im_width, im_chan)) s = tf.keras.layers.Lambda(lambda x: x / 255)(inputs) c1 = Conv2D(8, (3, 3), activation='relu', padding='same')(s) c1 = Conv2D(8, (3, 3), activation='relu', padding='same')(c1) p1 = MaxPooling2D((2, 2))(c1) c2 = Conv2D(16, (3, 3), activation='relu', padding='same')(p1) c2 = Conv2D(16, (3, 3), activation='relu', padding='same')(c2) p2 = MaxPooling2D((2, 2))(c2) c3 = Conv2D(32, (3, 3), activation='relu', padding='same')(p2) c3 = Conv2D(32, (3, 3), activation='relu', padding='same')(c3) p3 = MaxPooling2D((2, 2))(c3) c4 = Conv2D(64, (3, 3), activation='relu', padding='same')(p3) c4 = Conv2D(64, (3, 3), activation='relu', padding='same')(c4) p4 = MaxPooling2D(pool_size=(2, 2))(c4) c5 = Conv2D(128, (3, 3), activation='relu', padding='same')(p4) c5 = Conv2D(128, (3, 3), activation='relu', padding='same')(c5) u6 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c5) u6 = concatenate([u6, c4]) c6 = Conv2D(64, (3, 3), activation='relu', padding='same')(u6) c6 = Conv2D(64, (3, 3), activation='relu', padding='same')(c6) u7 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(c6) u7 = concatenate([u7, c3]) c7 = Conv2D(32, (3, 3), activation='relu', padding='same')(u7) c7 = Conv2D(32, (3, 3), activation='relu', padding='same')(c7) u8 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same')(c7) u8 = concatenate([u8, c2]) c8 = Conv2D(16, (3, 3), activation='relu', padding='same')(u8) c8 = Conv2D(16, (3, 3), activation='relu', padding='same')(c8) u9 = Conv2DTranspose(8, (2, 2), strides=(2, 2), padding='same')(c8) u9 = concatenate([u9, c1], axis=3) c9 = Conv2D(8, (3, 3), activation='relu', padding='same')(u9) c9 = Conv2D(8, (3, 3), activation='relu', padding='same')(c9) outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9) return inputs, outputs
def encoder_decoder_generator(start_img): """ """ layer1 = Conv2D(64, kernel_size=4, strides=2, activation='elu', padding='same')(start_img) layer2 = Conv2D(64, kernel_size=4, strides=2, activation='elu', padding='same')(layer1) layer3 = Conv2D(64, kernel_size=4, strides=1, activation='elu', padding='same')(layer2) layer4 = Conv2DTranspose(64, kernel_size=4, strides=2, activation='elu', padding="same")(layer3) layer5 = Conv2DTranspose(64, kernel_size=4, strides=2, activation='elu', padding="same")(layer4) layer6 = Conv2D(64, kernel_size=2, strides=1, activation='elu', padding='same')(layer5) # Make sure that generator output is in the same range as `inputs` # ie [-1, 1]. net = Conv2D(3, kernel_size=1, activation = 'tanh', padding='same')(layer6) return net
def simpleUnet(width, height, chann, nc, n_filters = 16, dropout = 0.1, batchnorm = False): inputs = Input((height, width, chann)) # image normalization between 0 and 1 s = Lambda(lambda x: x / 255) (inputs) # Contracting Path c1 = conv2dBlock(s, n_filters * 1, kernel_size = 3, batchnorm = batchnorm) p1 = MaxPooling2D((2, 2))(c1) #p1 = Dropout(dropout)(p1) c2 = conv2dBlock(p1, n_filters * 2, kernel_size = 3, batchnorm = batchnorm) p2 = MaxPooling2D((2, 2))(c2) #p2 = Dropout(dropout)(p2) c3 = conv2dBlock(p2, n_filters * 4, kernel_size = 3, batchnorm = batchnorm) p3 = MaxPooling2D((2, 2))(c3) #p3 = Dropout(dropout)(p3) c4 = conv2dBlock(p3, n_filters * 8, kernel_size = 3, batchnorm = batchnorm) p4 = MaxPooling2D((2, 2))(c4) #p4 = Dropout(dropout)(p4) c5 = conv2dBlock(p4, n_filters = n_filters * 16, kernel_size = 3, batchnorm = batchnorm) # Expansive Path u6 = Conv2DTranspose(n_filters * 8, (3, 3), strides = (2, 2), padding = 'same')(c5) u6 = concatenate([u6, c4]) #u6 = Dropout(dropout)(u6) c6 = conv2dBlock(u6, n_filters * 8, kernel_size = 3, batchnorm = batchnorm) u7 = Conv2DTranspose(n_filters * 4, (3, 3), strides = (2, 2), padding = 'same')(c6) u7 = concatenate([u7, c3]) #u7 = Dropout(dropout)(u7) c7 = conv2dBlock(u7, n_filters * 4, kernel_size = 3, batchnorm = batchnorm) u8 = Conv2DTranspose(n_filters * 2, (3, 3), strides = (2, 2), padding = 'same')(c7) u8 = concatenate([u8, c2]) #u8 = Dropout(dropout)(u8) c8 = conv2dBlock(u8, n_filters * 2, kernel_size = 3, batchnorm = batchnorm) u9 = Conv2DTranspose(n_filters * 1, (3, 3), strides = (2, 2), padding = 'same')(c8) u9 = concatenate([u9, c1]) #u9 = Dropout(dropout)(u9) c9 = conv2dBlock(u9, n_filters * 1, kernel_size = 3, batchnorm = batchnorm) outputs = Conv2D(nc, (1, 1), activation='softmax')(c9) model = Model(inputs=[inputs], outputs=[outputs]) return model
def define_generator(latent_dim): model = Sequential() # foundation for 7x7 image n_nodes = 128 * 7 * 7 model.add(Dense(n_nodes, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.2)) model.add(Reshape((7, 7, 128))) # upsample to 14x14 model.add(Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')) model.add(LeakyReLU(alpha=0.2)) # upsample to 28x28 model.add(Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')) model.add(LeakyReLU(alpha=0.2)) model.add(Conv2D(1, (7, 7), activation='sigmoid', padding='same')) return model
def build_encoder_decoder(self,input_shape=(224, 224, 3)): """変換用ネットワークの構築""" # Encoder部分 input_ts = Input(shape=input_shape, name='input') # 入力を[0, 1]の範囲に正規化 x = Lambda(lambda a: a/255.)(input_ts) x = Conv2D(32, (9, 9), strides=1, padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2D(64, (3, 3), strides=2, padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2D(128, (3, 3), strides=2, padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) # ResidualBlockを5ブロック追加 for _ in range(5): x = self.residual_block(x) # Decoder部分 x = Conv2DTranspose( 64, (3, 3), strides=2, padding='same' )(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2DTranspose(32, (3, 3), strides=2, padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2DTranspose(3, (9, 9), strides=1, padding='same')(x) x = BatchNormalization()(x) x = Activation('tanh')(x) # 出力値が[0, 255]になるようにスケール変換 gen_out = Lambda(lambda a: (a + 1)*127.5)(x) model_gen = Model( inputs=[input_ts], outputs=[gen_out] ) return model_gen