def conv3d(layer_input, filters, axis=-1, se_res_block=True, se_ratio=16, down_sizing=True): if down_sizing == True: layer_input = MaxPooling3D(pool_size=(2, 2, 2))(layer_input) d = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(layer_input) d = InstanceNormalization(axis=axis)(d) d = LeakyReLU(alpha=0.3)(d) d = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(d) d = InstanceNormalization(axis=axis)(d) if se_res_block == True: se = GlobalAveragePooling3D()(d) se = Dense(filters // se_ratio, activation='relu')(se) se = Dense(filters, activation='sigmoid')(se) se = Reshape([1, 1, 1, filters])(se) d = Multiply()([d, se]) shortcut = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(layer_input) shortcut = InstanceNormalization(axis=axis)(shortcut) d = add([d, shortcut]) d = LeakyReLU(alpha=0.3)(d) return d
def res_block(x, n_filters): res = Conv2D(filters=n_filters, kernel_size=(3, 3), strides=(1, 1), padding='same')(x) res = InstanceNormalization(axis=3)(res) res = LeakyReLU(0.2)(res) # res = Conv2D(filters=n_filters, kernel_size=(3, 3), strides=(1, 1), padding='same')(res) res = AtrousConvolution2D(n_filters, 3, 3, atrous_rate=(2, 2), border_mode='same')(res) res = InstanceNormalization(axis=3)(res) res = Activation('relu')(res) # res = LeakyReLU(0.2)(res) # # res = Conv2D(filters=n_filters, kernel_size=(1, 1), strides=(1, 1), padding='same')(res) # res = InstanceNormalization(axis=3)(res) # res = LeakyReLU(0.2)(res) x = Conv2D(filters=n_filters, kernel_size=(1, 1), strides=(1, 1), padding='same')(x) out = Add()([x, res]) return out
def bottleneck_layer(self, input_tensor, growth_k): out_bn_1 = InstanceNormalization(axis=self.concat_axis, center=True)(input_tensor) out_relu_1 = Activation('relu')(out_bn_1) out_conv_1 = Convolution3D(filters=growth_k * 4, kernel_size=(1, 1, 1), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(out_relu_1) out_bn_2 = InstanceNormalization(axis=self.concat_axis, center=True)(out_conv_1) out_relu_2 = Activation('relu')(out_bn_2) output_tensor = Convolution3D(filters=growth_k, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(out_relu_2) return output_tensor
def deconv3d(layer_input, skip_input, filters, axis=-1, se_res_block=True, se_ratio=16): u1 = ZeroPadding3D(((0, 1), (0, 1), (0, 1)))(layer_input) u1 = Conv3DTranspose(filters, (2, 2, 2), strides=(2, 2, 2), use_bias=False, padding='same')(u1) u1 = InstanceNormalization(axis=axis)(u1) # u1 = LeakyReLU(alpha=0.3)(u1) u1 = Activation('selu')(u1) u1 = CropToConcat3D()([u1, skip_input]) u2 = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(u1) u2 = InstanceNormalization(axis = axis)(u2) # u2 = LeakyReLU(alpha=0.3)(u2) u2 = Activation('selu')(u2) u2 = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(u2) u2 = InstanceNormalization(axis = axis)(u2) if se_res_block == True: se = GlobalAveragePooling3D()(u2) se = Dense(filters // se_ratio, activation='relu')(se) se = Dense(filters, activation='sigmoid')(se) se = Reshape([1, 1, 1, filters])(se) u2 = Multiply()([u2, se]) shortcut = Conv3D(filters, (3, 3, 3), use_bias=False, padding='same')(u1) shortcut = InstanceNormalization(axis=axis)(shortcut) u2 = layers.add([u2, shortcut]) # u2 = LeakyReLU(alpha=0.3)(u2) u2 = Activation('selu')(u2) return u2
def recurrent_block(x, n_filters, t=2): padding = 'same' x_ = Conv2D(filters=n_filters, kernel_size=(1, 1), strides=(1, 1), padding=padding)(x) for i in range(t): if i == 0: x1 = Conv2D(filters=n_filters, kernel_size=(3, 3), strides=(1, 1), padding=padding)(x) x1 = InstanceNormalization()(x1) x1 = LeakyReLU(0.2)(x1) a = Add()([x_, x1]) x1 = Conv2D(filters=n_filters, kernel_size=(3, 3), strides=(1, 1), padding=padding)(a) x1 = InstanceNormalization()(x1) x1 = LeakyReLU(0.2)(x1) return x1
def resnet_block(x): x2 = Conv2D(filters=256, kernel_size=3, strides=1, padding="same")(x) x2 = InstanceNormalization(axis=1)(x2) x2 = Activation('relu')(x2) x2 = Conv2D(filters=256, kernel_size=3, strides=1, padding="same")(x2) x2 = InstanceNormalization(axis=1)(x2) return Add()([x2, x])
def conv_block(feat_maps_out, prev): prev = InstanceNormalization(gamma_initializer=gamma_init)(prev, training=1) # Specifying the axis and mode allows for later merging prev = Activation('relu')(prev) # possibile migliore risultato con ReLU? prev = Conv2D(feat_maps_out, (3, 3), padding='same', kernel_initializer=conv_init)(prev) prev = InstanceNormalization(gamma_initializer=gamma_init)(prev, training=1) # Specifying the axis and mode allows for later merging prev = Activation('relu')(prev) prev = Conv2D(feat_maps_out, (3, 3), padding='same', kernel_initializer=conv_init)(prev) return prev
def build_generator(): """ Create a generator network using the hyperparameter values defined below """ input_shape = (128, 128, 3) residual_blocks = 6 input_layer = Input(shape=input_shape) # First Convolution block x = Conv2D(filters=32, kernel_size=7, strides=1, padding="same")(input_layer) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) # 2nd Convolution block x = Conv2D(filters=64, kernel_size=3, strides=2, padding="same")(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) # 3rd Convolution block x = Conv2D(filters=128, kernel_size=3, strides=2, padding="same")(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) # Residual blocks for _ in range(residual_blocks): x = residual_block(x) # Upsampling blocks # 1st Upsampling block x = Conv2DTranspose(filters=64, kernel_size=3, strides=2, padding='same', use_bias=False)(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) # 2nd Upsampling block x = Conv2DTranspose(filters=32, kernel_size=3, strides=2, padding='same', use_bias=False)(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) # Last Convolution layer x = Conv2D(filters=3, kernel_size=7, strides=1, padding="same")(x) output = Activation('tanh')(x) model = Model(inputs=[input_layer], outputs=[output]) return model
def build_generator(self): model = Sequential() model.add(Dense(128 * 125, input_dim=self.latent_dim)) model.add(Reshape((125, 128))) # 5 model.add(UpSampling1D()) model.add(Conv1D(128, kernel_size=3, strides=2, padding="same")) model.add(InstanceNormalization()) model.add(LeakyReLU(alpha=0.2)) model.add(UpSampling1D()) model.add(Conv1D(64, kernel_size=3, strides=2, padding="same")) model.add(InstanceNormalization()) model.add(LeakyReLU(alpha=0.2)) # 7 model.add(UpSampling1D()) model.add(Conv1D(64, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU(alpha=0.2)) # 8 model.add(UpSampling1D()) model.add(Conv1D(64, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU(alpha=0.2)) # 9 model.add(UpSampling1D()) model.add(Conv1D(64, kernel_size=3, strides=1, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(UpSampling1D()) model.add(Conv1D(self.channels, kernel_size=3, padding="same")) # change to LeakyRelu since a lot of signal exceeding 1 model.add(Activation("tanh")) model.summary() noise = Input(shape=(self.latent_dim, )) # img = model(noise) label = Input(shape=(4, )) # label_embedding = Flatten()(Embedding(4,np.prod(self.signal_shape)//4,input_length=4)(label)) # label_embedding = Flatten()(Embedding(4,np.prod(self.signal_shape)//4)(label)) label_embedding = Flatten()(RepeatVector( np.prod(self.signal_shape) // 4)(Dense(4)(label))) model_input = multiply([noise, label_embedding]) # label_embedding = Flatten()(RepeatVector(self.latent_dim)(label)) # print("@",label.shape,label_embedding.shape,noise.shape) # model_input = concatenate([noise, label]) # model_input = noise img = model(model_input) return Model([noise, label], img)
def last_label_layer(self, input_tensor): bn_1 = InstanceNormalization(axis=self.concat_axis, center=True)(input_tensor) relu_1 = Activation('relu')(bn_1) conv_1 = Convolution3D(filters=256, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(relu_1) bn_2 = InstanceNormalization(axis=self.concat_axis, center=True)(conv_1) relu_2 = Activation('relu')(bn_2) conv_2 = Convolution3D(filters=512, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(relu_2) return subpixel_8_3D_wChannel(out_c=1)(conv_2)
def test_instancenorm_perchannel_correctness(): # have each channel with a different average and std x = np.random.normal(loc=5.0, scale=2.0, size=(10, 1, 4, 4)) y = np.random.normal(loc=10.0, scale=3.0, size=(10, 1, 4, 4)) z = np.random.normal(loc=-5.0, scale=5.0, size=(10, 1, 4, 4)) batch = np.append(x, y, axis=1) batch = np.append(batch, z, axis=1) # this model does not provide a normalization axis model = Sequential() norm = InstanceNormalization(axis=None, input_shape=(3, 4, 4), center=False, scale=False) model.add(norm) model.compile(loss='mse', optimizer='sgd') model.fit(batch, batch, epochs=4, verbose=0) out = model.predict(batch) # values will not be normalized per-channel for instance in range(10): for channel in range(3): activations = out[instance, channel] assert abs(activations.mean()) > 1e-2 assert abs(activations.std() - 1.0) > 1e-6 # but values are still normalized per-instance activations = out[instance] assert_allclose(activations.mean(), 0.0, atol=1e-1) assert_allclose(activations.std(), 1.0, atol=1e-1) # this model sets the channel as a normalization axis model = Sequential() norm = InstanceNormalization(axis=1, input_shape=(3, 4, 4), center=False, scale=False) model.add(norm) model.compile(loss='mse', optimizer='sgd') model.fit(batch, batch, epochs=4, verbose=0) out = model.predict(batch) # values are now normalized per-channel for instance in range(10): for channel in range(3): activations = out[instance, channel] assert_allclose(activations.mean(), 0.0, atol=1e-1) assert_allclose(activations.std(), 1.0, atol=1e-1)
def build_discriminator(self): model = Sequential() model.add(Reshape((self.time_length, self.channels))) model.add( Conv1D(32, kernel_size=3, strides=2, input_shape=self.signal_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(Conv1D(64, kernel_size=3, strides=2, padding="same")) model.add(ZeroPadding1D(padding=0)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(InstanceNormalization()) # model.add(BatchNormalization(momentum=0.8)) model.add(Conv1D(128, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(InstanceNormalization()) # model.add(BatchNormalization(momentum=0.8)) model.add(Conv1D(256, kernel_size=3, strides=1, padding="same")) # model.add(InstanceNormalization()) # model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) # model.summary() img = Input(shape=self.signal_shape) label = Input(shape=(1, )) # reason is referred as before label_embedding = Flatten()(Embedding(self.num_classes, np.prod( self.signal_shape))(label)) # label_embedding = Flatten()(RepeatVector(np.prod(self.signal_shape))(label)) flat_img = Flatten()(img) model_input = multiply([flat_img, label_embedding]) validity = model(model_input) return Model([img, label], validity)
def resnet_block(n_filters, input_layer): # weight initialization init = RandomNormal(stddev=0.02) # first layer convolutional layer g = Conv2D(n_filters, (3, 3), padding='same', kernel_initializer=init)(input_layer) g = InstanceNormalization(axis=-1)(g) g = Activation('relu')(g) # second convolutional layer g = Conv2D(n_filters, (3, 3), padding='same', kernel_initializer=init)(g) g = InstanceNormalization(axis=-1)(g) # concatenate merge channel-wise with input layer g = Concatenate()([g, input_layer]) return g
def build_generator(self): model = Sequential() model.add( Dense(128 * 125, activation=LeakyReLU(), input_dim=self.latent_dim)) model.add(Reshape((125, 128))) model.add(UpSampling1D()) model.add(Conv1D(128, kernel_size=3, padding="same")) model.add(LeakyReLU()) model.add(InstanceNormalization()) # model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling1D()) model.add(Conv1D(128, kernel_size=3, padding="same")) model.add(LeakyReLU()) model.add(InstanceNormalization()) model.add(UpSampling1D()) model.add(Conv1D(256, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU()) model.add(InstanceNormalization()) # model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling1D()) model.add(Conv1D(128, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU()) model.add(InstanceNormalization()) model.add(Conv1D(self.channels, kernel_size=3, padding="same")) # change to LeakyRelu since a lot of signal exceeding 1 model.add(Activation("tanh")) model.summary() noise = Input(shape=(self.latent_dim, )) # img = model(noise) label = Input(shape=(1, )) label_embedding = Flatten()(Embedding(self.num_classes, np.prod( self.signal_shape))(label)) # label_embedding = Flatten()(RepeatVector(self.latent_dim)(label)) model_input = multiply([noise, label_embedding]) img = model(model_input) return Model([noise, label], img)
def define_generator_network(num_resnet_blocks=9): input_size = (128, 128, 3) #Input RGB image input_layer = Input(shape=input_size) #Down-sampling using conv2d x = Conv2D(filters=64, kernel_size=7, strides=1, padding="same")(input_layer) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) x = Conv2D(filters=128, kernel_size=3, strides=2, padding="same")(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) x = Conv2D(filters=256, kernel_size=3, strides=2, padding="same")(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) #Transforming the hidden representation using the resnet blocks for i in range(num_resnet_blocks): x = resnet_block(x) #Upsampling to recover the transformed image #Conv2DTranspose with a stride 2 works like Conv2D with stride 1/2 x = Conv2DTranspose(filters=128, kernel_size=3, strides=2, padding='same', use_bias=False)(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) x = Conv2DTranspose(filters=64, kernel_size=3, strides=2, padding='same', use_bias=False)(x) x = InstanceNormalization(axis=1)(x) x = Activation("relu")(x) x = Conv2D(filters=3, kernel_size=7, strides=1, padding="same")(x) output = Activation('tanh')( x) #tanh activation to get normalised output image model = Model(inputs=[input_layer], outputs=[output]) return model
def conv2d(layer_input, filters, f_size=4): """Layers used during downsampling""" d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = LeakyReLU(alpha=0.2)(d) d = InstanceNormalization()(d) return d
def test_instancenorm_perinstancecorrectness(): model = Sequential() norm = InstanceNormalization(input_shape=(10, )) model.add(norm) model.compile(loss='mse', optimizer='sgd') # bimodal distribution z = np.random.normal(loc=5.0, scale=10.0, size=(2, 10)) y = np.random.normal(loc=-5.0, scale=17.0, size=(2, 10)) x = np.append(z, y) x = np.reshape(x, (4, 10)) model.fit(x, x, epochs=4, batch_size=4, verbose=1) out = model.predict(x) out -= K.eval(norm.beta) out /= K.eval(norm.gamma) # verify that each instance in the batch is individually normalized for i in range(4): instance = out[i] assert_allclose(instance.mean(), 0.0, atol=1e-1) assert_allclose(instance.std(), 1.0, atol=1e-1) # if each instance is normalized, so should the batch assert_allclose(out.mean(), 0.0, atol=1e-1) assert_allclose(out.std(), 1.0, atol=1e-1)
def build_discriminator(): """ Create a discriminator network using the hyperparameter values defined below """ input_shape = (128, 128, 3) hidden_layers = 3 input_layer = Input(shape=input_shape) x = ZeroPadding2D(padding=(1, 1))(input_layer) # 1st Convolutional block x = Conv2D(filters=64, kernel_size=4, strides=2, padding="valid")(x) x = LeakyReLU(alpha=0.2)(x) x = ZeroPadding2D(padding=(1, 1))(x) # 3 Hidden Convolution blocks for i in range(1, hidden_layers + 1): x = Conv2D(filters=2**i * 64, kernel_size=4, strides=2, padding="valid")(x) x = InstanceNormalization(axis=1)(x) x = LeakyReLU(alpha=0.2)(x) x = ZeroPadding2D(padding=(1, 1))(x) # Last Convolution layer output = Conv2D(filters=1, kernel_size=4, strides=1, activation="sigmoid")(x) model = Model(inputs=[input_layer], outputs=[output]) return model
def transition_layer(self, input_tensor, theta=0.5): nb_channel = int(input_tensor.shape[-1]) out_bn_1 = InstanceNormalization(axis=self.concat_axis, center=True)(input_tensor) out_conv_1 = Convolution3D(filters=int(nb_channel * theta), kernel_size=(1, 1, 1), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(out_bn_1) return out_conv_1
def _normalization(inputs, norm='bn'): if norm == 'bn': return BatchNormalization()(inputs) elif norm == 'in': return InstanceNormalization()(inputs) elif norm == 'gn': return GroupNormalization()(inputs)
def create_convolution_block(input_layer, n_filters, batch_normalization=False, kernel=(3, 3, 3), activation=None, padding='same', strides=(1, 1, 1), instance_normalization=False): """ :param strides: :param input_layer: :param n_filters: :param batch_normalization: :param kernel: :param activation: Keras activation layer to use. (default is 'relu') :param padding: :return: """ layer = Conv3D(n_filters, kernel, padding=padding, strides=strides)(input_layer) if batch_normalization: layer = BatchNormalization(axis=1)(layer) elif instance_normalization: try: from keras_contrib.layers import InstanceNormalization except ImportError: raise ImportError("Install keras_contrib in order to use instance normalization." "\nTry: pip install git+https://www.github.com/farizrahman4u/keras-contrib.git") layer = InstanceNormalization(axis=1)(layer) if activation is None: return Activation('relu')(layer) else: return activation()(layer)
def __init__(self, base_filters=32, lrelu_alpha=0.2, pad_type="reflect", norm_type="batch"): super(Discriminator, self).__init__(name="Discriminator") if pad_type == "reflect": self.flat_pad = ReflectionPadding2D() elif pad_type == "constant": self.flat_pad = ZeroPadding2D() else: raise ValueError(f"pad_type not recognized {pad_type}") self.flat_conv = Conv2D(base_filters, 3) self.flat_lru = LeakyReLU(lrelu_alpha) self.strided_conv1 = StridedConv(base_filters * 2, lrelu_alpha, pad_type, norm_type) self.strided_conv2 = StridedConv(base_filters * 4, lrelu_alpha, pad_type, norm_type) self.conv2 = Conv2D(base_filters * 8, 3) if norm_type == "instance": self.norm = InstanceNormalization() elif norm_type == "batch": self.norm = BatchNormalization() self.lrelu = LeakyReLU(lrelu_alpha) self.final_conv = Conv2D(1, 3)
def define_discriminator_network(): input_size = (128, 128, 3) num_hidden_layers = 3 input_layer = Input(shape=input_size) x = ZeroPadding2D(padding=(1, 1))(input_layer) x = Conv2D(filters=64, kernel_size=4, strides=2, padding="valid")(x) x = LeakyReLU(alpha=0.2)(x) x = ZeroPadding2D(padding=(1, 1))(x) for i in range(1, num_hidden_layers + 1): x = Conv2D(filters=2**i * 64, kernel_size=4, strides=2, padding="valid")(x) x = InstanceNormalization(axis=1)(x) x = LeakyReLU(alpha=0.2)(x) x = ZeroPadding2D(padding=(1, 1))(x) #Sigmoid activation to normalise output values between 0 and 1 which will be used to train real or fake labels output = Conv2D(filters=1, kernel_size=4, strides=1, activation="sigmoid")(x) #This is the patch output model = Model(inputs=[input_layer], outputs=[output]) return model
def convt(x, filters, kernel_size=(3,3), strides=(2,2), relu=True, normalization="instance"): y = Conv2DTranspose(filters, kernel_size, strides=strides, padding="same")(x) if normalization == "instance": y = InstanceNormalization(axis=-1)(y) if relu: y = Activation("relu")(y) return y
def res_block(_input: Layer, filters: int, kernel_size: int, dropout: bool, activation: Optional[str], name_prefix: str) -> Layer: _x = Conv2D(filters, kernel_size=kernel_size, strides=1, padding='same', name=f'{name_prefix}conv1')(_input) if dropout: _x = DropoutPermanent(rate=0.5, name=f'{name_prefix}dropout1')(_x) _x = InstanceNormalization(axis=-1, epsilon=1e-05, name=f'{name_prefix}norm1')(_x) if activation == 'lrelu': _x = LeakyReLU(alpha=0.2, name=f'{name_prefix}{activation}1')(_x) else: _x = Activation(activation, name=f'{name_prefix}{activation}1')(_x) _x = Conv2D(filters, kernel_size=kernel_size, strides=1, padding='same', name=f'{name_prefix}conv2')(_x) if dropout: _x = DropoutPermanent(rate=0.5, name=f'{name_prefix}dropout2')(_x) _x = InstanceNormalization(axis=-1, epsilon=1e-05, name=f'{name_prefix}norm2')(_x) return Add(name=f'{name_prefix}add')([_input, _x])
def get_norm(norm_type): if norm_type == "instance": return InstanceNormalization() elif norm_type == 'batch': return BatchNormalization() else: raise ValueError(f"Unrecognized norm_type {norm_type}")
def normalise(norm=None, **kwargs): if norm == 'instance': return InstanceNormalization(**kwargs) elif norm == 'batch': return BatchNormalization() else: return Lambda(lambda x: x)
def d_layer(layer_input, filters, f_size=4, normalization=True): """Discriminator layer""" d = Conv3D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = LeakyReLU(alpha=0.2)(d) if normalization: d = InstanceNormalization()(d) return d
def DenseNet_v3(self, input): # growth_k = 8 growth_k = 4 theta = 0.5 init_conv_0 = Convolution3D(filters=growth_k * 2, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(input) # 200 x 200 x 200 init_bn_0 = InstanceNormalization(axis=self.concat_axis, center=False)(init_conv_0) init_relu_0 = Activation('relu')(init_bn_0) init_conv_1 = Convolution3D(filters=growth_k * 2, kernel_size=(7, 7, 7), strides=(2, 2, 2), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(init_relu_0) # 100 x 100 x 100 nb_layers = 12 denseblk_1 = self.dense_block(init_conv_1, nb_layers=nb_layers, growth_k=growth_k) transit_1 = self.transition_layer(denseblk_1, theta=theta) bsize, zz, yy, xx, c = transit_1.get_shape().as_list() transit_1 = Convolution3D(filters=c, kernel_size=(3, 3, 3), strides=(2, 2, 2), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(transit_1) # 50 x 50 x50 nb_layers = 24 denseblk_2 = self.dense_block(transit_1, nb_layers=nb_layers, growth_k=growth_k) transit_2 = self.transition_layer(denseblk_2, theta=theta) bsize, zz, yy, xx, c = transit_2.get_shape().as_list() transit_2 = Convolution3D(filters=c, kernel_size=(3, 3, 3), strides=(2, 2, 2), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(transit_2) # 25 x 25 x 25 nb_layers = 18 denseblk_3 = self.dense_block(transit_2, nb_layers=nb_layers, growth_k=growth_k) label_0 = self.last_label_layer(denseblk_3) label_1 = self.last_label_layer(denseblk_3) label_2 = self.last_label_layer(denseblk_3) concat_1 = Concatenate()([label_0, label_1, label_2, init_relu_0]) last_conv_0 = Convolution3D(filters=growth_k, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(concat_1) # 200 x 200 x 200 last_bn_0 = InstanceNormalization(axis=self.concat_axis, center=False)(last_conv_0) last_relu_0 = Activation('relu')(last_bn_0) last_conv_1 = Convolution3D(filters=3, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', use_bias=True, kernel_initializer='he_normal', kernel_regularizer=None)(last_relu_0) return last_conv_1
def conv_block(x, num_filters, kernel_size=3, strides=2, padding='same'): x = Conv2D(filters=num_filters, kernel_size=kernel_size, strides=strides, padding=padding)(x) x = InstanceNormalization()(x) x = LeakyReLU(alpha=.2)(x) return x