def double_conv_layer(x, filter_size, size, dropout, batch_norm=False): ''' construction of a double convolutional layer using SAME padding RELU nonlinear activation function :param x: input :param filter_size: size of convolutional filter :param size: number of filters :param dropout: FLAG & RATE of dropout. if < 0 dropout cancelled, if > 0 set as the rate :param batch_norm: flag of if batch_norm used, if True batch normalization :return: output of a double convolutional layer ''' axis = 3 conv = layers.Conv2D(size, (filter_size, filter_size), padding='same')(x) if batch_norm is True: conv = layers.BatchNormalization(axis=axis)(conv) conv = layers.Activation('relu')(conv) conv = layers.Conv2D(size, (filter_size, filter_size), padding='same')(conv) if batch_norm is True: conv = layers.BatchNormalization(axis=axis)(conv) conv = layers.Activation('relu')(conv) if dropout > 0: conv = layers.Dropout(dropout)(conv) shortcut = layers.Conv2D(size, kernel_size=(1, 1), padding='same')(x) if batch_norm is True: shortcut = layers.BatchNormalization(axis=axis)(shortcut) res_path = layers.add([shortcut, conv]) return res_path
def feature_fusion_module_new(self, input, name, num_features): input_big = input[0] input_small = input[1] b_shape = input_big.get_shape() s_shape = input_small.get_shape() if(b_shape[1].value > s_shape[1].value): up_sampled_input = keras_ly.UpSampling2D(size=(2, 2), name=name+'_upsample')(input_small) else: up_sampled_input = input_small concat_1 = tf.concat(axis=3, values=[input_big, up_sampled_input], name=name+'_concat') conv_1 = keras_ly.Conv2D(num_features, [3, 3], padding='SAME', name=name+'_conv1')(concat_1) conv_1_bn_relu = tf.nn.relu(slim.batch_norm(conv_1, fused=True)) global_pool = tf.reduce_mean(conv_1_bn_relu, [1, 2], keep_dims=True) conv_2 = keras_ly.Conv2D(num_features, [1, 1], padding='SAME', name=name+'_conv2')(global_pool) conv_3 = keras_ly.Conv2D(num_features, [1, 1], padding='SAME', name=name+'_conv3')(conv_2) sigmoid = tf.sigmoid(conv_3, name=name+'_sigmoid') mul = tf.multiply(sigmoid, conv_1_bn_relu, name=name+'_multiply') #sigmoid * conv_1 add_out = tf.add(conv_1_bn_relu, mul, name=name+'_add_out') # conv_1 + mul return add_out
def VGG6(inputs, n_class=10): # Block 1 x = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='block1_conv1')(inputs) x = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='block1_conv2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) # Block 2 x = layers.Conv2D(64, (3, 3), activation='relu', padding='same', name='block2_conv1')(x) x = layers.Conv2D(64, (3, 3), activation='relu', padding='same', name='block2_conv2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) x = layers.Flatten(name='flatten')(x) x = layers.Dense(512, activation='relu', name='fc1')(x) features = layers.Dense(512, activation='relu', name='fc2')(x) outputs = layers.Dense(n_class, activation='softmax', name='predictions')(features) return outputs
def feature_fusion_module(self, input, name): input_big = input[0] input_small = input[1] up_sampled_input = keras_ly.UpSampling2D(size=(2, 2), name=name + '_upsample')(input_small) concat_1 = tf.concat(axis=3, values=[input_big, up_sampled_input], name=name + '_concat') conv_1 = keras_ly.Conv2D(1024, [3, 3], padding='SAME', name=name + '_conv1')(concat_1) global_pool = tf.reduce_mean(conv_1, [1, 2], keep_dims=True) conv_2 = keras_ly.Conv2D(1024, [1, 1], padding='SAME', name=name + '_conv2')(global_pool) conv_3 = keras_ly.Conv2D(1024, [1, 1], padding='SAME', name=name + '_conv3')(conv_2) sigmoid = tf.sigmoid(conv_3, name=name + '_sigmoid') mul = tf.multiply(sigmoid, conv_1, name=name + '_multiply') add_out = tf.add(conv_1, mul, name=name + '_add_out') return add_out
def grouped_convolution(y, nb_channels, _strides): # when `cardinality` == 1 this is just a standard convolution if cardinality == 1: return layers.Conv2D(nb_channels, kernel_size=(3, 3), strides=_strides, padding='same')(y) assert not nb_channels % cardinality _d = nb_channels // cardinality # in a grouped convolution layer, input and output channels are divided into `cardinality` groups, # and convolutions are separately performed within each group groups = [] for j in range(cardinality): group = layers.Lambda(lambda z: z[:, :, :, j * _d:j * _d + _d])(y) groups.append( layers.Conv2D(_d, kernel_size=(3, 3), strides=_strides, padding='same')(group)) # the grouped convolutional layer concatenates them as the outputs of the layer y = layers.concatenate(groups) return y
def classifier_model(): model = models.Sequential() model.add( layers.Conv2D(NUM_FILTERS_1, [3, 3], strides=(2, 2), padding='same', activation='relu', input_shape=(28, 28, 1), kernel_initializer=initializers.glorot_normal(), bias_initializer=initializers.Zeros())) model.add( layers.Conv2D(NUM_FILTERS_2, [3, 3], strides=(2, 2), padding='same', activation='relu', kernel_initializer=initializers.glorot_normal(), bias_initializer=initializers.Zeros())) model.add(layers.Flatten()) model.add( layers.Dense(NUM_CLASSES, kernel_initializer=initializers.glorot_normal(), bias_initializer=initializers.Zeros())) return model
def olliNetwork(self): self.model = models.Sequential() self.model.add( layers.Conv2D(64, (5, 5), activation='relu', input_shape=(48, 48, 1))) self.model.add(layers.Conv2D(64, (5, 5), activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add(layers.Dropout(0.25)) self.model.add(layers.Conv2D(64, (5, 5), activation='relu')) self.model.add(layers.Conv2D(64, (5, 5), activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add(layers.Dropout(0.25)) self.model.add(layers.Conv2D(128, (4, 4), activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) self.model.add(layers.Dropout(0.25)) self.model.add(layers.Flatten()) self.model.add(layers.Dense(3072, activation='relu')) self.model.add(layers.Dropout(0.5)) self.model.add(layers.Dense(128, activation='relu')) self.model.add(layers.Dropout(0.5)) self.model.add(layers.Dense(3, activation='softmax'))
def attention_block(x, gating, inter_shape): shape_x = K.int_shape(x) shape_g = K.int_shape(gating) theta_x = layers.Conv2D(inter_shape, (2, 2), strides=(2, 2), padding='same')(x) # 16 shape_theta_x = K.int_shape(theta_x) phi_g = layers.Conv2D(inter_shape, (1, 1), padding='same')(gating) upsample_g = layers.Conv2DTranspose( inter_shape, (3, 3), strides=(shape_theta_x[1] // shape_g[1], shape_theta_x[2] // shape_g[2]), padding='same')(phi_g) # 16 concat_xg = layers.add([upsample_g, theta_x]) act_xg = layers.Activation('relu')(concat_xg) psi = layers.Conv2D(1, (1, 1), padding='same')(act_xg) sigmoid_xg = layers.Activation('sigmoid')(psi) shape_sigmoid = K.int_shape(sigmoid_xg) upsample_psi = layers.UpSampling2D(size=(shape_x[1] // shape_sigmoid[1], shape_x[2] // shape_sigmoid[2]))( sigmoid_xg) # 32 upsample_psi = expend_as(upsample_psi, shape_x[3]) y = layers.multiply([upsample_psi, x]) result = layers.Conv2D(shape_x[3], (1, 1), padding='same')(y) result_bn = layers.BatchNormalization()(result) return result_bn
def _create_generator(self): inputs = layers.Input(shape=(self.args.latent_dims, )) x = layers.Dense(128 * 16 * 16)(inputs) x = layers.LeakyReLU()(x) x = layers.Reshape((16, 16, 128))(x) x = layers.Conv2D(256, kernel_size=5, strides=1, padding='same')(x) x = layers.LeakyReLU()(x) # we use a kernel-size which is a multiple of the strides to don't have artifacts when up-sampling x = layers.Conv2DTranspose(256, kernel_size=4, strides=2, padding='same')(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(256, kernel_size=5, padding='same')(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(256, kernel_size=5, padding='same')(x) x = layers.LeakyReLU()(x) outputs = layers.Conv2D(CHANNELS, kernel_size=7, activation='tanh', padding='same')(x) generator = models.Model(inputs, outputs) return generator
def conv_block(input_tensor, num_filters): encoder = layers.Conv2D(num_filters, (3, 3), padding='same')(input_tensor) encoder = layers.BatchNormalization()(encoder) encoder = layers.Activation('relu')(encoder) encoder = layers.Conv2D(num_filters, (3, 3), padding='same')(encoder) encoder = layers.BatchNormalization()(encoder) encoder = layers.Activation('relu')(encoder) return encoder
def decoder_block(input_tensor, concat_tensor, num_filters): decoder = layers.Conv2DTranspose(num_filters, (2, 2), strides=(2, 2), padding='same')(input_tensor) decoder = layers.concatenate([concat_tensor, decoder], axis=-1) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation('relu')(decoder) decoder = layers.Conv2D(num_filters, (3, 3), padding='same')(decoder) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation('relu')(decoder) decoder = layers.Conv2D(num_filters, (3, 3), padding='same')(decoder) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation('relu')(decoder) return decoder
def residual_block(y, nb_channels_in, nb_channels_out, _strides=(1, 1), _project_shortcut=False): """ Our network consists of a stack of residual blocks. These blocks have the same topology, and are subject to two simple rules: - If producing spatial maps of the same size, the blocks share the same hyper-parameters (width and filter sizes). - Each time the spatial map is down-sampled by a factor of 2, the width of the blocks is multiplied by a factor of 2. """ shortcut = y # we modify the residual building block as a bottleneck design to make the network more economical y = layers.Conv2D(nb_channels_in, kernel_size=(1, 1), strides=(1, 1), padding='same')(y) y = add_common_layers(y) # ResNeXt (identical to ResNet when `cardinality` == 1) y = grouped_convolution(y, nb_channels_in, _strides=_strides) y = add_common_layers(y) y = layers.Conv2D(nb_channels_out, kernel_size=(1, 1), strides=(1, 1), padding='same')(y) # batch normalization is employed after aggregating the transformations and before adding to the shortcut y = layers.BatchNormalization()(y) # identity shortcuts used directly when the input and output are of the same dimensions if _project_shortcut or _strides != (1, 1): # when the dimensions increase projection shortcut is used to match dimensions (done by 1×1 convolutions) # when the shortcuts go across feature maps of two sizes, they are performed with a stride of 2 shortcut = layers.Conv2D(nb_channels_out, kernel_size=(1, 1), strides=_strides, padding='same')(shortcut) shortcut = layers.BatchNormalization()(shortcut) y = layers.add([shortcut, y]) # relu is performed right after each batch normalization, # expect for the output of the block where relu is performed after the adding to the shortcut y = layers.LeakyReLU()(y) return y
def attention_refinment_module(self, input, name): global_pool = tf.reduce_mean(input, [1, 2], keep_dims=True) #conv_1 = keras_ly.Conv2D(2048, [1, 1], padding='SAME', name=name+'_conv1')(global_pool) conv_1 = keras_ly.Conv2D(input.get_shape()[3], [1, 1], padding='SAME', name=name+'_conv1')(global_pool) sigmoid = tf.sigmoid(conv_1, name=name+'_sigmoid') mul_out = tf.multiply(input, sigmoid, name=name+'_multiply') return mul_out
def create_model(dropout_rate): model = models.Sequential() model.add( layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3))) model.add(layers.MaxPool2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPool2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPool2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPool2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(dropout_rate)) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) return model
def conv2_bn(x, filts, k=3, stride=1, rate=1, name=None, pad='same'): x = l.Conv2D(filts, (k, k), strides=(stride, stride), dilation_rate=rate, padding=pad, name=name)(x) x = l.BatchNormalization(name=name + '_bn')(x) x = l.Activation('relu', name=name + '_relu')(x) return x
def attention_block(x, gating, inter_shape, name): """ self gated attention, attention mechanism on spatial dimension :param x: input feature map :param gating: gate signal, feature map from the lower layer :param inter_shape: intermedium channle numer :param name: name of attention layer, for output :return: attention weighted on spatial dimension feature map """ shape_x = K.int_shape(x) shape_g = K.int_shape(gating) theta_x = layers.Conv2D(inter_shape, (2, 2), strides=(2, 2), padding='same')(x) # 16 shape_theta_x = K.int_shape(theta_x) phi_g = layers.Conv2D(inter_shape, (1, 1), padding='same')(gating) upsample_g = layers.Conv2DTranspose( inter_shape, (3, 3), strides=(shape_theta_x[1] // shape_g[1], shape_theta_x[2] // shape_g[2]), padding='same')(phi_g) # 16 # upsample_g = layers.UpSampling2D(size=(shape_theta_x[1] // shape_g[1], shape_theta_x[2] // shape_g[2]), # data_format="channels_last")(phi_g) concat_xg = layers.add([upsample_g, theta_x]) act_xg = layers.Activation('relu')(concat_xg) psi = layers.Conv2D(1, (1, 1), padding='same')(act_xg) sigmoid_xg = layers.Activation('sigmoid')(psi) shape_sigmoid = K.int_shape(sigmoid_xg) upsample_psi = layers.UpSampling2D(size=(shape_x[1] // shape_sigmoid[1], shape_x[2] // shape_sigmoid[2]), name=name + '_weight')(sigmoid_xg) # 32 upsample_psi = expend_as(upsample_psi, shape_x[3]) y = layers.multiply([upsample_psi, x]) result = layers.Conv2D(shape_x[3], (1, 1), padding='same')(y) result_bn = layers.BatchNormalization()(result) return result_bn
def classifier_model(): #Building of the CNN model = models.Sequential() model.add( layers.Conv2D(1, [2, 40], input_shape=(1, 40, 173), strides=(1, 1), padding='valid', activation='relu')) # #model.add(layers.MaxPool1D(pool_size=2, strides=2, padding='valid')) # model.add( layers.Conv2D(1, [2, 20], strides=(1, 1), padding='valid', activation='relu', kernel_initializer=initializers.glorot_normal(), bias_initializer=initializers.Zeros())) # # model.add(layers.MaxPool1D(pool_size=2, strides=2, padding='valid')) # # model.add( layers.Conv2D(1, [2, 10], strides=(3, 3), padding='valid', activation='relu', kernel_initializer=initializers.glorot_normal(), bias_initializer=initializers.Zeros())) # # model.add(layers.MaxPool1D(pool_size=2, strides=2, padding='valid')) # model.add(layers.Flatten()) # model.add( layers.Dense(1, kernel_initializer=initializers.glorot_normal(), bias_initializer=initializers.Zeros())) print(model.summary()) return model
def residual_layer(input_tensor, nb_in_filters=64, nb_bottleneck_filters=16, filter_sz=3, stage=0, reg=0.0): bn_name = 'bn' + str(stage) conv_name = 'conv' + str(stage) relu_name = 'relu' + str(stage) merge_name = 'add' + str(stage) # batchnorm-relu-conv, from nb_in_filters to nb_bottleneck_filters via 1x1 conv if stage>1: # first activation is just after conv1 x = layers.BatchNormalization(axis=-1, name=bn_name+'a')(input_tensor) x = layers.Activation('relu', name=relu_name+'a')(x) else: x = input_tensor x = layers.Conv2D(nb_bottleneck_filters, (1, 1), kernel_initializer='glorot_normal', kernel_regularizer=regularizers.l2(reg), use_bias=False, name=conv_name+'a')(x) # batchnorm-relu-conv, from nb_bottleneck_filters to nb_bottleneck_filters via FxF conv x = layers.BatchNormalization(axis=-1, name=bn_name+'b')(x) x = layers.Activation('relu', name=relu_name+'b')(x) x = layers.Conv2D(nb_bottleneck_filters, (filter_sz, filter_sz), padding='same', kernel_initializer='glorot_normal', kernel_regularizer=regularizers.l2(reg), use_bias = False, name=conv_name+'b')(x) # batchnorm-relu-conv, from nb_in_filters to nb_bottleneck_filters via 1x1 conv x = layers.BatchNormalization(axis=-1, name=bn_name+'c')(x) x = layers.Activation('relu', name=relu_name+'c')(x) x = layers.Conv2D(nb_in_filters, (1, 1), kernel_initializer='glorot_normal', kernel_regularizer=regularizers.l2(reg), name=conv_name+'c')(x) # merge x = layers.add([x, input_tensor], name=merge_name) return x
def classifier_model(): # linear stack of ################################################################################ ############################ YOUR CODE HERE ################################ # Define a Sequential model model = models.Sequential() # The first two layers are convolutional layers. For the first layer, we must specify the input shape. model.add( layers.Conv2D( NUM_FILTERS_1, 3, strides=(2, 2), activation='relu', padding='same', input_shape=(28, 28, 1))) # we have to add 2d convolutional layer # a conv layer is defined by the number of filters # second dimension we have to choose a stride of 2 : amount of shift that we are using for shift # papdding same = output is cropped , output should be 28*28 # specify the kind of activate : RELU # first layer of input dimension # we initialize the biases to 0 # we set kernel initializer model.add( layers.Conv2D(NUM_FILTERS_2, 3, strides=(2, 2), activation='relu', padding='same')) # also a convolutional layer # 3x3 filters , 2x2 strides # we don't specify the input shape # The final layer is a dense, 1 dimensional layer. We must therefore first flatten the result of the # previous layer model.add( layers.Flatten() ) # we want to reduce to 1 dimension to be able to have a dense layer of 1 dim # convert 2-3 layer dimension into a vextor model.add(layers.Dense(10)) return model
def classifier_model(): #Building of the CNN model = models.Sequential() model.add( layers.Conv2D(1, [2, 10], input_shape=(40, 44, 1), strides=(1, 1), padding='valid', activation='relu', data_format='channels_last')) model.add( layers.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)) model.add( layers.Conv2D(1, [2, 6], strides=(1, 1), padding='valid', activation='relu')) model.add( layers.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)) model.add( layers.Conv2D(1, [2, 3], strides=(1, 1), padding='valid', activation='relu')) model.add(layers.Flatten()) model.add(layers.Dense(1)) print(model.summary()) return model
def conv2d_bn(x, filters, num_row, num_col, padding='same', strides=(1, 1)): if K.image_data_format() == 'channels_first': bn_axis = 1 else: bn_axis = 3 x = layers.Conv2D(filters, (num_row, num_col), strides=strides, padding=padding)(x) # use_bias=False, x = layers.BatchNormalization(axis=bn_axis)(x) # scale=False, x = layers.Activation('relu')(x) return x
def _create_discriminator(self): inputs = layers.Input(shape=(HEIGHT, WIDTH, CHANNELS)) x = layers.Conv2D(128, kernel_size=3)(inputs) x = layers.LeakyReLU()(x) x = layers.Conv2D(128, kernel_size=4, strides=2)(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(128, kernel_size=4, strides=2)(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(128, kernel_size=4, strides=2)(x) x = layers.LeakyReLU()(x) x = layers.Flatten()(x) x = layers.Dropout(self.args.dropout)(x) outputs = layers.Dense(1, activation='sigmoid')(x) discriminator = models.Model(inputs, outputs) return discriminator
def model_definition(self): self.model = models.Sequential() self.model.add( layers.Conv2D(64, (5, 5), activation='relu', input_shape=self.input_shape)) self.model.add(layers.Conv2D(64, (5, 5), activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add(layers.Dropout(0.25)) self.model.add(layers.Conv2D(64, (5, 5), activation='relu')) self.model.add(layers.Conv2D(64, (5, 5), activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add(layers.Dropout(0.25)) self.model.add(layers.Conv2D(128, (3, 3), activation='relu')) self.model.add(layers.AveragePooling2D()) self.model.add(layers.Conv2D(128, (1, 1), activation='relu')) self.model.add(layers.MaxPooling2D(pool_size=(2, 2))) self.model.add(layers.Dropout(0.25)) self.model.add(layers.Flatten()) self.model.add(layers.Dense(3072, activation='relu')) self.model.add(layers.Dropout(0.5)) self.model.add(layers.Dense(128, activation='relu')) self.model.add(layers.Dropout(0.5)) self.model.add(layers.Dense(3, activation='softmax')) adam = optimizers.Adamax() self.model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['acc'])
def gating_signal(input, out_size, batch_norm=False): """ resize the down layer feature map into the same dimension as the up layer feature map using 1x1 conv :param input: down-dim feature map :param out_size:output channel number :return: the gating feature map with the same dimension of the up layer feature map """ x = layers.Conv2D(out_size, (1, 1), padding='same')(input) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) return x
def keras_efficientnet(blocks_args, global_params, training=False): inp = layers.Input((224, 224, 3)) x = layers.Conv2D(32, 3, padding='same', strides=2, name='stem_conv2d', use_bias=False)(inp) x = em.batchnorm(name='stem_tpu_batch_normalization')(x) x = layers.Lambda(lambda x: em.relu_fn(x))(x) idx = 0 for block in blocks_args: x = el.mbConvBlock(x, block, global_params, idx, training=training) # x = MBConvBlock(block, global_params, idx)(x, training=training) idx += 1 if block.num_repeat > 1: block = block._replace( input_filters=block.output_filters, strides=[1, 1]) for _ in range(block.num_repeat - 1): x = el.mbConvBlock(x, block, global_params, idx, training=training) idx += 1 x = layers.Conv2D(1280, 1, name='head_conv2d', use_bias=False)(x) x = em.batchnorm(name='head_tpu_batch_normalization')(x) x = layers.Lambda(lambda x: em.relu_fn(x))(x) x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(1000, activation='softmax', name='head_dense', )(x) model = models.Model(inp, x, name='efficientnet-b0') return model
def create_model(img_shape): inputs = layers.Input(shape=img_shape) encoder0_pool, encoder0 = encoder_block(inputs, 32) encoder1_pool, encoder1 = encoder_block(encoder0_pool, 64) encoder2_pool, encoder2 = encoder_block(encoder1_pool, 128) encoder3_pool, encoder3 = encoder_block(encoder2_pool, 256) encoder4_pool, encoder4 = encoder_block(encoder3_pool, 512) center = conv_block(encoder4_pool, 1024) decoder4 = decoder_block(center, encoder4, 512) decoder3 = decoder_block(decoder4, encoder3, 256) decoder2 = decoder_block(decoder3, encoder2, 128) decoder1 = decoder_block(decoder2, encoder1, 64) decoder0 = decoder_block(decoder1, encoder0, 32) outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(decoder0) # change to perceptron? model = models.Model(inputs=[inputs], outputs=[outputs]) return model
def attention_refinment_module_new(self, input, name, last_arm=False): global_pool = tf.reduce_mean(input, [1, 2], keep_dims=True) conv_1 = keras_ly.Conv2D(input.get_shape()[3], [1, 1], padding='SAME', name=name+'_conv1')(global_pool) with tf.variable_scope(name+'_conv1_bn') as scope: conv_1_bn = slim.batch_norm(conv_1, fused=True, scope=scope) sigmoid = tf.sigmoid(conv_1_bn, name=name+'_sigmoid') mul_out = tf.multiply(input, sigmoid, name=name+'_multiply') if last_arm: glob_red = tf.reduce_mean(mul_out, [1, 2], keep_dims=True) out_scale = tf.multiply(glob_red, mul_out) print('last arm shape') print(input.shape) print(out_scale.shape) return out_scale else: return mul_out
def conv_layer(layer_name, layer_num): w = get_weights(vgg_layers, layer_num) b = get_bias(vgg_layers, layer_num) filters = w[3] kernel_size = [w[0], w[1]] has_bias = False bias_initial = None if b: has_bias = True bias_initial = tf.keras.initializers.Constant(b) conv = layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=1, padding='same', use_bias=has_bias, bias_initializer=bias_initial, activation='relu') return conv
def shortcut(self, input, residual): """Adds a shortcut between input and residual block and merges them with "sum" """ # Expand channels of shortcut to match residual. # Stride appropriately to match residual (width, height) # Should be int if network architecture is correctly configured. input_shape = K.int_shape(input) #residual_shape = K.int_shape(residual) try: residual_shape = np.shape(residual).as_list() except: residual_shape = np.shape(residual) stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS])) stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS])) equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS] #equal_width = input_shape[ROW_AXIS] == residual_shape[ROW_AXIS] #equal_heights = input_shape[COL_AXIS] == residual_shape[COL_AXIS] shortcut = input # 1 X 1 conv if shape is different. Else identity. if stride_width > 1 or stride_height > 1 or not equal_channels: #if not equal_width or not equal_height or not equal_channels: shortcut = layers.Conv2D(filters=residual_shape[CHANNEL_AXIS], kernel_size=(1, 1), strides=(stride_width, stride_height), padding="valid", kernel_initializer="he_normal", kernel_regularizer=regularizers.l2(0.0001))(input) return layers.add([shortcut, residual])
def create_model(self, img_shape, num_class): concat_axis = 3 inputs = layers.Input(shape = img_shape) conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='conv1_1')(inputs) conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv1) pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(pool1) conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv2) pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool2) conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv3) pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool3) conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv4) pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4) conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(pool4) conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(conv5) up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5) ch, cw = self.get_crop_shape(conv4, up_conv5) crop_conv4 = layers.Cropping2D(cropping=(ch,cw))(conv4) up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis) conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(up6) conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv6) up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6) ch, cw = self.get_crop_shape(conv3, up_conv6) crop_conv3 = layers.Cropping2D(cropping=(ch,cw))(conv3) up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis) conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(up7) conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv7) up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7) ch, cw = self.get_crop_shape(conv2, up_conv7) crop_conv2 = layers.Cropping2D(cropping=(ch,cw))(conv2) up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis) conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(up8) conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv8) up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8) ch, cw = self.get_crop_shape(conv1, up_conv8) crop_conv1 = layers.Cropping2D(cropping=(ch,cw))(conv1) up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis) conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(up9) conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv9) model = models.Model(inputs=inputs, outputs=conv9) return model