Update app.py

app.py

@@ -20,6 +20,704 @@ def bce_dice(y_true, y_pred):
     return bce(y_true, y_pred) - K.log(jacard(y_true, y_pred))
 
 
+def upsample(X,X_side):
+    """
+    Upsampling and concatination with the side path
+    """
+    
+    X = Conv2DTranspose(int(X.shape[1]/2), (3, 3), strides=(2, 2), padding='same')(X)
+    #X = tf.keras.layers.UpSampling2D((2,2))(X)
+    concat = tf.keras.layers.Concatenate()([X,X_side])
+    return concat
+
+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
+    :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 attention_block(x, gating, inter_shape):
+    shape_x = K.int_shape(x)
+    shape_g = K.int_shape(gating)
+
+# Getting the x signal to the same shape as the gating signal
+    theta_x = layers.Conv2D(inter_shape, (2, 2), strides=(2, 2), padding='same')(x)  # 16
+    shape_theta_x = K.int_shape(theta_x)
+
+# Getting the gating signal to the same number of filters as the inter_shape
+    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 = repeat_elem(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 repeat_elem(tensor, rep):
+    # lambda function to repeat Repeats the elements of a tensor along an axis
+    #by a factor of rep.
+    # If tensor has shape (None, 256,256,3), lambda will return a tensor of shape 
+    #(None, 256,256,6), if specified axis=3 and rep=2.
+
+     return layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=3),
+                          arguments={'repnum': rep})(tensor)
+
+
+activation_funtion = 'relu'
+recurrent_repeats = 2 * 4
+FILTER_NUM = 4 * 4
+axis = 3
+
+act_func = 'relu'
+filters = 64
+def encoder(inputs, input_tensor):
+    
+   #Contraction path
+    conv_1 = Conv2D(filters, (3, 3), activation='relu', padding='same')(inputs)
+    conv_1 = BatchNormalization()(conv_1)
+    conv_1 = Dropout(0.1)(conv_1)  
+    conv_1 = Conv2D(filters, (3, 3), activation='relu', padding='same')(conv_1)
+    conv_1 = BatchNormalization()(conv_1)
+    pool_1 = MaxPooling2D((2, 2))(conv_1)
+    
+    conv_2 = Conv2D(2*filters, (3, 3), activation='relu', padding='same')(pool_1)
+    conv_2 = BatchNormalization()(conv_2)
+    conv_2 = Dropout(0.1)(conv_2)  
+    conv_2 = Conv2D(2*filters, (3, 3), activation='relu', padding='same')(conv_2)
+    conv_2 = BatchNormalization()(conv_2)
+    pool_2 = MaxPooling2D((2, 2))(conv_2)
+     
+    conv_3 = Conv2D(4*filters, (3, 3), activation='relu', padding='same')(pool_2)
+    conv_3 = BatchNormalization()(conv_3)
+    conv_3 = Dropout(0.1)(conv_3)
+    conv_3 = Conv2D(4*filters, (3, 3), activation='relu', padding='same')(conv_3)
+    conv_3 = BatchNormalization()(conv_3)
+    pool_3 = MaxPooling2D((2, 2))(conv_3)
+     
+    conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same')(pool_3)
+    conv_4 = BatchNormalization()(conv_4)
+    conv_4 = Dropout(0.1)(conv_4)
+    conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same')(conv_4)
+    conv_4 = BatchNormalization()(conv_4)
+    pool_4 = MaxPooling2D(pool_size=(2, 2))(conv_4)
+         
+    conv_5 = Conv2D(16*filters, (3, 3), activation='relu', padding='same')(pool_4)    
+    conv_5 = BatchNormalization()(conv_5)
+    conv_5 = Dropout(0.1)(conv_5)
+    
+    
+    model = Model(inputs=[input_tensor], outputs=[conv_5, conv_4, conv_3, conv_2, conv_1])
+    return model
+
+def encoder_unet(inputs):
+    ## Project residual
+     #   residual = layers.Conv2D(filters, 1, strides=2, padding="same")(
+      #      previous_block_activation
+       # )
+        #x = layers.add([x, residual])  # Add back residual
+    #Contraction path
+    #Contraction path
+    conv_11 = Conv2D(filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(inputs)
+    conv_11 = BatchNormalization()(conv_11)
+    conv_11 = Dropout(0.2)(conv_11)  
+    conv_1 = Conv2D(filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_11)
+    conv_1 = BatchNormalization()(conv_1)
+    #conv_1 = concatenate([resblock(conv_11, 64), conv_1], axis=3)
+    #conv_1 = Dropout(0.2)(conv_1)
+    #pool_1 = layers.GaussianNoise(0.1+np.random.random()*0.4)(conv_1)
+    pool_1 = MaxPooling2D((2, 2))(conv_1)
+    
+    
+    
+    conv_2 = Conv2D(2*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(pool_1)
+    conv_2 = BatchNormalization()(conv_2)
+    conv_2 = Dropout(0.2)(conv_2)  
+    conv_2 = Conv2D(2*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_2)
+    conv_2 = BatchNormalization()(conv_2)
+    #conv_2 = Dropout(0.2)(conv_2)  
+    #conv_2 = Conv2D(2*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_2) 
+    #conv_2 = concatenate([resblock(pool_1, 128), conv_2], axis=3)
+    #conv_2 = BatchNormalization()(conv_2)
+    #conv_2 = Dropout(0.2)(conv_2)
+    #pool_2 = layers.GaussianNoise(0.1+np.random.random()*0.4)(conv_2)
+    pool_2 = MaxPooling2D((2, 2))(conv_2)
+    
+    
+     
+    conv_3 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(pool_2)
+    conv_3 = BatchNormalization()(conv_3)
+    conv_3 = Dropout(0.2)(conv_3)
+    conv_3 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_3)
+    conv_3 = BatchNormalization()(conv_3)
+    #conv_3 = Dropout(0.2)(conv_3)
+    #conv_3 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_3)
+    #conv_3 = BatchNormalization()(conv_3)
+    #conv_3 = Dropout(0.2)(conv_3)
+    conv_3 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_3)
+    conv_3 = BatchNormalization()(conv_3)
+    #conv_3 = concatenate([resblock(pool_2, 256), conv_3], axis=3)
+    #conv_3 = Dropout(0.2)(conv_3)
+    #pool_3 = layers.GaussianNoise(0.1+np.random.random()*0.4)(conv_3)
+    pool_3 = MaxPooling2D((2, 2))(conv_3)
+    
+    
+        
+    conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(pool_3)
+    conv_4 = BatchNormalization()(conv_4)
+    conv_4 = Dropout(0.2)(conv_4)
+    #conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_4)
+    #conv_4 = BatchNormalization()(conv_4)
+    #conv_4 = Dropout(0.2)(conv_4)
+    conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_4)
+    conv_4 = BatchNormalization()(conv_4)
+    conv_4 = Dropout(0.2)(conv_4)
+    #conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_4)
+    #conv_4 = BatchNormalization()(conv_4)
+    #conv_4 = Dropout(0.2)(conv_4)
+    conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_4)
+    conv_4 = BatchNormalization()(conv_4)
+    #conv_4 = concatenate([resblock(pool_3, 512), conv_4], axis=3)
+    #conv_4 = Dropout(0.2)(conv_4)
+    #pool_4 = layers.GaussianNoise(0.1+np.random.random()*0.4)(conv_4)
+    pool_4 = MaxPooling2D(pool_size=(2, 2))(conv_4)
+        
+    
+    conv_44 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(pool_4)
+    conv_44 = BatchNormalization()(conv_44)
+    conv_44 = Dropout(0.2)(conv_44)
+    conv_44 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_44)
+    conv_44 = BatchNormalization()(conv_44)
+    conv_44 = Dropout(0.2)(conv_44)
+    #conv_44 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_44)
+    #conv_44 = BatchNormalization()(conv_44)
+    #conv_44 = Dropout(0.2)(conv_44)
+    #conv_4 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_4)
+    #conv_4 = BatchNormalization()(conv_4)
+    #conv_4 = Dropout(0.2)(conv_4)
+    conv_44 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_44)
+    conv_44 = BatchNormalization()(conv_44)
+    #conv_4 = concatenate([resblock(pool_3, 512), conv_4], axis=3)
+    #conv_44 = Dropout(0.2)(conv_44)
+    #pool_4 = layers.GaussianNoise(0.1+np.random.random()*0.4)(conv_4)
+    pool_44 = MaxPooling2D(pool_size=(2, 2))(conv_44)
+    
+    
+         
+    conv_5 = Conv2D(16*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(pool_44)    
+    conv_5 = BatchNormalization()(conv_5)
+    #conv_5 = Conv2D(16*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_5)    
+    #conv_5 = BatchNormalization()(conv_5)
+    #conv_5 = concatenate([resblock(pool_4, 1024), conv_5], axis=3)    
+    #conv_5 = Dropout(0.2)(conv_5)
+    #conv_5 = layers.GaussianNoise(0.1)(conv_5)
+    
+    
+    
+    model = Model(inputs=[inputs], outputs=[conv_5, conv_44, conv_3, conv_2, conv_1])
+    return model
+
+def decoder(inputs, input_tensor):
+    #Expansive path
+    
+    gating_64 = gating_signal(inputs[0], 16*FILTER_NUM, True)
+    att_64 = attention_block(inputs[1], gating_64, 16*FILTER_NUM)
+    up_stage_2 = upsample(inputs[0],inputs[1])
+    #u6 = Conv2DTranspose(512, (2, 2), strides=(2, 2), padding='same')(inputs[0])
+    u6 = concatenate([up_stage_2, att_64], axis=3)
+    #u6 = concatenate([att_5, u6])
+    #conv_6 = Conv2D(512, (3, 3), activation='relu', padding='same')(u6)
+    #conv_6 = BatchNormalization()(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)
+    #conv_6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)
+    conv_6 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(u6)
+    conv_6 = BatchNormalization()(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)
+    conv_6 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_6)
+    conv_6 = BatchNormalization()(conv_6)
+    #conv_6 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_6)
+    #conv_6 = BatchNormalization()(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)
+    #conv_6 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_6)
+    #conv_6 = BatchNormalization()(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)
+    conv_6 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_6)
+    conv_6 = BatchNormalization()(conv_6)
+    conv_6 = Dropout(0.2)(conv_6)
+    
+    
+    up_stage_22 = Conv2DTranspose(int(conv_6.shape[1]/2), (3, 3), strides=(2, 2), padding='same')(conv_6)
+    conv_66 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(up_stage_22)
+    conv_66 = BatchNormalization()(conv_66)
+    #conv_6 = Dropout(0.2)(conv_6)
+    #conv_66 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_66)
+    #conv_66 = BatchNormalization()(conv_66)
+    conv_66 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_66)
+    conv_66 = BatchNormalization()(conv_66)
+    #conv_6 = Dropout(0.2)(conv_6)
+    #conv_66 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_66)
+    #conv_66 = BatchNormalization()(conv_66)
+    #conv_6 = Dropout(0.2)(conv_6)
+    conv_66 = Conv2D(8*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_66)
+    conv_66 = BatchNormalization()(conv_66)
+    conv_66 = Dropout(0.2)(conv_66)
+    
+    
+    gating_128 = gating_signal(conv_66, 8*FILTER_NUM, True)
+    att_128 = attention_block(inputs[2], gating_128, 8*FILTER_NUM)
+    up_stage_3 = upsample(conv_66,inputs[2])      
+    #u7 = Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(conv_6)
+    u7 = concatenate([up_stage_3, att_128], axis=3)
+    #conv_7 = Conv2D(256, (3, 3), activation='relu', padding='same')(u7)
+    #conv_7 = BatchNormalization()(conv_7)
+    #conv_7 = Dropout(0.2)(conv_7)
+    #conv_7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv_7)
+    #conv_7 = Dropout(0.2)(conv_7)
+    conv_7 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(u7)
+    conv_7 = BatchNormalization()(conv_7)
+    #conv_7 = Dropout(0.2)(conv_7)
+    conv_7 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_7)
+    conv_7 = BatchNormalization()(conv_7)
+    #conv_7 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_7)
+    #conv_7 = BatchNormalization()(conv_7)
+    #conv_7 = Dropout(0.2)(conv_7)
+    conv_7 = Conv2D(4*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_7)
+    conv_7 = BatchNormalization()(conv_7)
+    conv_7 = Dropout(0.2)(conv_7)
+    
+    gating_256 = gating_signal(conv_7, 4*FILTER_NUM, True)
+    att_256 = attention_block(inputs[3], gating_256, 4*FILTER_NUM)
+    up_stage_4 = upsample(conv_7,inputs[3]) 
+    #u8 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(conv_7)
+    u8 = concatenate([up_stage_4, att_256], axis=3)
+    #conv_8 = Conv2D(128, (3, 3), activation='relu', padding='same')(u8)
+    #conv_8 = BatchNormalization()(conv_8)
+    #conv_8 = Dropout(0.1)(conv_8)
+    conv_8 = Conv2D(2*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(u8)
+    conv_8 = BatchNormalization()(conv_8)
+    #conv_8 = Dropout(0.2)(conv_8)  
+    #conv_8 = Conv2D(2*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(u8)
+    #conv_8 = BatchNormalization()(conv_8)
+    #conv_8 = Dropout(0.2)(conv_8)  
+    conv_8 = Conv2D(2*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_8)
+    conv_8 = BatchNormalization()(conv_8)
+    conv_8 = Dropout(0.2)(conv_8)
+    
+    gating_512 = gating_signal(conv_8, 2*FILTER_NUM, True)
+    att_512 = attention_block(inputs[4], gating_512, 2*FILTER_NUM)
+    up_stage_5 = upsample(conv_8,inputs[4])    
+    #u9 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(conv_8)
+    u9 = concatenate([up_stage_5, att_512], axis=3)   
+    
+    conv_9 = Conv2D(1*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(u9)
+    conv_9 = BatchNormalization()(conv_9)
+    #conv_9 = Dropout(0.2)(conv_9)
+    conv_9 = Conv2D(1*filters, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal')(conv_9)
+    conv_9 = BatchNormalization()(conv_9)
+    conv_9 = Dropout(0.2)(conv_9)
+    
+    model = Model(inputs=[input_tensor], outputs=[conv_9])
+    return model
+
+
+
+
+def autoencoder(n_classes=2, height=size, width=size, channels=3):
+    inputs = Input((height, width, channels))
+    #Contraction path
+    conv_1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)
+    conv_1 = BatchNormalization()(conv_1)
+    conv_1 = Dropout(0.2)(conv_1)  
+    conv_1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv_1)
+    conv_1 = BatchNormalization()(conv_1)
+    pool_1 = MaxPooling2D((2, 2))(conv_1)
+    
+    conv_2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool_1)
+    conv_2 = BatchNormalization()(conv_2)
+    conv_2 = Dropout(0.2)(conv_2)  
+    conv_2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv_2)
+    conv_2 = BatchNormalization()(conv_2)
+    pool_2 = MaxPooling2D((2, 2))(conv_2)
+     
+    conv_3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool_2)
+    conv_3 = BatchNormalization()(conv_3)
+    conv_3 = Dropout(0.2)(conv_3)
+    conv_3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv_3)
+    conv_3 = BatchNormalization()(conv_3)
+    pool_3 = MaxPooling2D((2, 2))(conv_3)
+     
+    conv_4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool_3)
+    conv_4 = BatchNormalization()(conv_4)
+    conv_4 = Dropout(0.2)(conv_4)
+    conv_4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv_4)
+    conv_4 = BatchNormalization()(conv_4)
+    pool_4 = MaxPooling2D(pool_size=(2, 2))(conv_4)
+     
+         
+    #conv_5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool_4)    
+    #conv_5 = BatchNormalization()(conv_5)
+    conv_5 = Dropout(0.1)(pool_4)    
+    
+    #Expansive path
+    
+    u6 = UpSampling2D((2, 2))(conv_5)
+    #u6 = concatenate([att_5, u6])
+    conv_6 = Conv2D(256, (3, 3), activation='relu', padding='same')(u6)
+    conv_6 = BatchNormalization()(conv_6)
+    conv_6 = Dropout(0.2)(conv_6)  
+    #conv_6 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)  
+    #conv_6 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv_6)
+    #conv_6 = BatchNormalization()(conv_6)
+    #conv_6 = Dropout(0.2)(conv_6)    
+    conv_6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv_6)
+    conv_6 = BatchNormalization()(conv_6)
+    
+    """
+    u66 = UpSampling2D((2, 2))(conv_6)    
+    conv_66 = Conv2D(128, (3, 3), activation='relu', padding='same')(u66)
+    conv_66 = BatchNormalization()(conv_66)
+    conv_66 = Conv2D(128, (3, 3), activation='relu', padding='same')(u66)
+    conv_66 = Conv2D(128, (3, 3), activation='relu', padding='same')(u66)
+    conv_66 = BatchNormalization()(conv_66)
+    conv_66 = Dropout(0.2)(conv_66)
+    conv_66 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv_66)
+    """
+     
+    u7 = UpSampling2D((2, 2))(conv_6)    
+    conv_7 = Conv2D(128, (3, 3), activation='relu', padding='same')(u7)
+    conv_7 = BatchNormalization()(conv_7)
+    conv_7 = Dropout(0.2)(conv_7)
+    #conv_7 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv_7)
+    #conv_7 = Dropout(0.1)(conv_7)
+    #conv_7 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv_7)
+    #conv_7 = BatchNormalization()(conv_7)
+    #conv_7 = Dropout(0.1)(conv_7)
+    conv_7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv_7)
+    conv_7 = BatchNormalization()(conv_7)
+     
+    u8 = UpSampling2D((2, 2))(conv_7)    
+    conv_8 = Conv2D(64, (3, 3), activation='relu', padding='same')(u8)
+    conv_8 = BatchNormalization()(conv_8)
+    conv_8 = Dropout(0.2)(conv_8) 
+    #conv_8 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv_8)
+    #conv_8 = Dropout(0.2)(conv_8) 
+    #conv_8 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv_8)
+    #conv_8 = BatchNormalization()(conv_8)
+    #conv_8 = Dropout(0.2)(conv_8)  
+    conv_8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv_8)
+    conv_8 = BatchNormalization()(conv_8)
+     
+    u9 = UpSampling2D((2, 2))(conv_8)    
+    conv_9 = Conv2D(32, (3, 3), activation='relu', padding='same')(u9)
+    conv_9 = BatchNormalization()(conv_9)
+    conv_9 = Dropout(0.2)(conv_9)
+    #conv_9 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv_9)
+    #conv_9 = Dropout(0.1)(conv_9)
+    #conv_9 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv_9)
+    #conv_9 = BatchNormalization()(conv_9)
+    #conv_9 = Dropout(0.1)(conv_9)
+    conv_9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv_9)
+    conv_9 = BatchNormalization()(conv_9)
+     
+    outputs = Conv2D(n_classes, (1, 1), activation='softmax')(conv_9)
+    
+    model = Model(inputs=[inputs], outputs=[outputs])
+    return model
+    
+"""
+    gating_16 = gating_signal(stage_5, 8*FILTER_NUM, True)
+    att_16 = attention_block(stage_4, stage_5, 8*FILTER_NUM)
+    up_stage_1 = upsample(stage_5,stage_4)
+    up_16 = layers.concatenate([up_stage_1, att_16], axis=axis)
+    
+    
+    gating_32 = gating_signal(up_repeat_elem1, 4*FILTER_NUM, True)
+    att_32 = attention_block(stage_3, gating_32, 4*FILTER_NUM)
+    up_stage_2 = upsample(up_repeat_elem1,stage_3)
+    up_32 = layers.concatenate([up_stage_2, att_32], axis=axis)
+    
+    
+    gating_64 = gating_signal(up_repeat_elem2, 2*FILTER_NUM, True)
+    att_64 = attention_block(stage_2, gating_64, 2*FILTER_NUM)
+    up_stage_3 = upsample(up_repeat_elem2,stage_2)
+    up_64 = layers.concatenate([up_stage_3, att_64], axis=axis)
+    
+    
+    gating_128 = gating_signal(up_repeat_elem3, FILTER_NUM, True)
+    att_128 = attention_block(stage_1, gating_128, FILTER_NUM)
+    up_stage_4 = upsample(up_repeat_elem3,stage_1)
+    up_128 = layers.concatenate([up_stage_4, att_128], axis=axis)
+    
+    
+    gating_256 = gating_signal(up_repeat_elem4, FILTER_NUM, True)
+    att_256 = attention_block(conv_1, gating_256, FILTER_NUM)
+    up_stage_5 = upsample(up_repeat_elem4,conv_1)
+    up_256 = layers.concatenate([up_stage_5, att_256], axis=axis)
+"""
+
+def unet_2( n_classes=2, height=size, width=size, channels=3, metrics = ['accuracy']):
+    inputs = Input((height, width, channels))
+    
+    
+    encode = encoder_unet(inputs)
+    decode = decoder(encode.output, inputs)
+    #print(type(decode.output))
+    #print(decode.output.shape)
+    
+    #encode_2 = encoder(decode.output, inputs)
+    #decode_2 = decoder(encode_2.output, inputs)
+    #########outputs = decode.output
+    #print(encode_2.output.shape)
+    #u7 = UpSampling2D((2, 2))(encode_2.output)
+    #u7 = Conv2D(32, (3, 3), activation='relu', padding='same')(u7)
+    #u7 = UpSampling2D((2, 2))(u7)
+    #u7 = Conv2D(64, (3, 3), activation='relu', padding='same')(u7)
+    #u7 = UpSampling2D((2, 2))(u7)
+    #u7 = Conv2D(128, (3, 3), activation='relu', padding='same')(u7)
+    #u7 = UpSampling2D((2, 2))(u7)  
+    outputs = decode.output 
+    #outputs = Conv2D(n_classes, (1, 1), activation='softmax', padding='same', kernel_initializer='he_normal')(decode.output)
+    #outputs = tf.reshape(encode_2.output[0], [None, 16, 16, 256])
+    model = Model(inputs=[inputs], outputs=[outputs])
+   
+     
+    
+    
+    if n_classes <= 2: 
+      model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = metrics)
+    elif n_classes > 2: 
+      model.compile(optimizer = Adam(lr = 1e-3), loss = 'categorical_crossentropy', metrics = metrics)
+
+     
+    #model.summary()
+    
+    return model
+
+def unet_enssemble(n_classes=2, height=64, width=64, channels=3, metrics = ['accuracy']):
+    x = Input((height, width, channels))
+    #x = inputs
+    
+    #augmented = data_augmentation(x)
+    #augmented_0 = data_augmentation_0(x)
+    #augmented_1 = data_augmentation_1(x)
+    #augmented_2 = data_augmentation_2(x)
+    #augmented_3 = data_augmentation_3(x)
+    #augmented_4 = data_augmentation_4(x)
+    #augmented_5 = data_augmentation_5(x)
+    #augmented = layers.GaussianNoise(0.1)(augmented)
+    
+    #out_x = concatenate([augmented, augmented_0], axis=0)
+    
+    #augmented = x
+    #BACKBONE = 'resnet152'
+    #BACKBONE = 'efficientnetb7'
+    #model5 = sm.Linknet(BACKBONE, encoder_weights='imagenet', classes=n_classes, activation='softmax')    
+    #model10 = sm.Unet(BACKBONE, 
+                    #pyramid_block_filters=32, 
+     #               encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #BACKBONE = 'vgg16'
+    #model7 = sm.FPN(BACKBONE, 
+                    #encoder_freeze = True,
+                    #pyramid_block_filters=16,
+     #               encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #BACKBONE = 'inceptionresnetv2'
+    #model8 = sm.FPN(BACKBONE, pyramid_block_filters=16, encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #BACKBONE = 'resnext50'
+    #BACKBONE = 'seresnet152'
+    #decode_filt=(256, 128, 64, 32, 16)
+    #BACKBONE = 'mobilenetv2'
+    #model10 = sm.FPN(BACKBONE, pyramid_block_filters=256, encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #model10_x1 = sm.Unet(BACKBONE, decoder_filters=decode_filt,
+     #                    decoder_block_type='upsampling',
+                         #decoder_block_type='transpose',
+      #                   encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #model10_x2 = sm.Linknet(BACKBONE, encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #BACKBONE = 'resnet18'
+    #BACKBONE = 'resnext50'
+    #BACKBONE = 'mobilenetv2'
+    #BACKBONE = 'efficientnetb7'
+    #model10 = sm.FPN(BACKBONE, 
+                     #encoder_freeze = True, 
+                     #pyramid_block_filters=16, 
+     #                encoder_weights='imagenet',
+      #               classes=n_classes, activation='softmax')
+    #BACKBONE = 'vgg16'
+    #model7 = sm.FPN(BACKBONE,
+     #               pyramid_block_filters=512,
+      #              encoder_weights='imagenet', classes=n_classes, activation='softmax')
+    #model9 = create_cct_model(n_classes=n_classes, height = height, width = width, channels = n_channels)
+    #reshaped = tf.reshape(encoded_patches , [-1,256,256,64])
+    
+    #model7 = unet_2( n_classes=n_classes, height = height, width = width, channels = 3)
+    model10 = unet_2( n_classes=n_classes, height = height, width = width, channels = 3)
+    #model10_xx = unet_2( n_classes=n_classes, height = height, width = width, channels = 3)
+    #model8 = unet_2( n_classes=n_classes,
+     #               height = height, width = width, channels = n_channels)(augmented)
+    ###model8_x = unet_2( n_classes=n_classes,
+          ###          height = height, width = width, channels = n_channels)(x)
+    
+    
+
+    #model1 = get_model(inputs=x, n_classes=n_classes, height = height, width = width, channels = n_channels)
+    #model2 = DeeplabV3Plus(model_input=x, image_size=256, num_classes=n_classes)
+    #model4 = unet_2(inputs=x, n_classes=n_classes, height = height, width = width, channels = n_channels)
+    #model3 = swin_unet_2d_base(x, filter_num_begin, depth, stack_num_down, stack_num_up, 
+     #                 patch_size, num_heads, window_size, num_mlp, 
+      #                shift_window=shift_window, name='swin_unet')
+    #print(model1.output.shape, model2.output.shape)
+    #model5.trainable = False
+    #model6.trainable = False
+    
+    #out = model11(augmented)
+    #out = Conv2D(3, (3, 3), activation=activation_funtion, padding='same')(out)
+    #out = K.flatten(out)
+    #out = K.reshape(out,(-1,256,256,1))
+    #out = model11(x)
+    #out = unet_2(inputs=augmented, n_classes=n_classes, height = height, width = width, channels = n_channels)
+    
+    #quantize_model_7 = tfmot.quantization.keras.quantize_model
+    # q_aware stands for for quantization aware.
+    #q_aware_model_7 = quantize_model(model7)
+    #quantize_model_11 = tfmot.quantization.keras.quantize_model
+    # q_aware stands for for quantization aware.
+    #q_aware_model_11 = quantize_model(model11)
+    
+    
+    out = model10(x)
+    #out = layers.GaussianNoise(0.1+np.random.random()*0.4)(out)
+    #out = layers.GaussianNoise(0.1)(out)
+    #out = concatenate([q_aware_model_7(augmented), q_aware_model_11(augmented)], axis=3)
+    #out = concatenate([model6(augmented), model8(augmented), model6(x), model8(x)], axis=3)
+    #out = concatenate([model10_x1(augmented), model10_x1(x), model10_x1(augmented_0)], axis=3)
+    #out_7 = concatenate([model11(augmented), model7(augmented)], axis=3)
+    
+    #out = concatenate([x, out], axis=3)
+    #out = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')(out)
+    #out = Conv2D(3, (3, 3), activation=activation_funtion, padding='same')(out)    
+    #out = model7(out)
+    
+    
+    
+        
+    #out = model10_x(attention_weights)
+    #model11 = Conv2D(32, (3, 3), activation=activation_funtion, padding='same')(model11)
+    #model7 = Conv2D(32, (3, 3), activation=activation_funtion, padding='same')(model7)
+    #out = concatenate([model10_x(x), model10_x(augmented), model10_x(augmented_0)], axis=3)
+    #out = concatenate([ model7(x), model11(x),
+     #                 model7(augmented_0), model11(augmented_0),
+      #                model7(augmented_1), model11(augmented_1),
+       #               model7(augmented_2), model11(augmented_2),
+        #              model7(augmented_3), model11(augmented_3),
+         #             model7(augmented_4), model11(augmented_4),
+          #            model7(augmented_5), model11(augmented_5)],axis=3)
+    
+    #out = tf.keras.layers.PReLU()(out)
+    #out = Conv2D(64, (3, 3), activation=activation_funtion, padding='same')(out)
+    #out = BatchNormalization()(out)
+    #out = Dropout(0.2)(out)
+    
+    #####out = hybrid_pool_layer((2,2))(out)
+    
+    #a = tf.keras.layers.AveragePooling2D(padding='same')(out)
+    #a = Lambda(lambda xx : xx*alpha)(a)
+    #m = tf.keras.layers.MaxPooling2D(padding='same')(out)
+    #m = Lambda(lambda xx : xx*(1-alpha))(m)
+    #out = tf.keras.layers.Add()([a,m])
+    #out = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')(out)
+    
+    #out = layers.add([model1.output, model2.output])
+    #out = layers.multiply([model1.output, model2.output])
+    ##out = layers.add([model, encode.output])
+    ##out = layers.multiply([model, encode.output])
+    
+    #out = Conv2D(128, (3, 3), activation=activation_funtion, padding='same')(out)    
+    #out = BatchNormalization()(out)
+    #out = Conv2D(64, (3, 3), activation=activation_funtion, padding='same')(out)
+    #out = SpikingActivation("relu")(out)
+    #out = BatchNormalization()(out)
+    #out = Dropout(0.2)(out)
+    #out = Conv2D(32, (3, 3), activation=activation_funtion, padding='same')(out)    
+    #out = BatchNormalization()(out)    
+    #out = Conv2D(64, (3, 3), activation=activation_funtion, padding='same')(out)    
+    #out = BatchNormalization()(out)
+    #out = Dropout(0.2)(out)
+    #out = tf.keras.layers.PReLU()(out)
+    #out = Conv2D(64, (3, 3), activation=activation_funtion, padding='same')(out)    
+    #out = BatchNormalization()(out)
+    #out = Dropout(0.2)(out)
+    #out = tf.keras.layers.PReLU()(out)
+    
+    #out = concatenate([conv_out_jump, out], axis=3)
+    #out = Conv2D(256, (3, 3), activation=activation_funtion, padding='same')(out)
+    #out = BatchNormalization()(out)
+    #out = Dropout(0.2)(out)
+    
+    #out = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')(out)
+    #out = UpSampling2D((2, 2))(out)
+    
+    #out_list = []
+    #for i in range(1,23):
+     #   outputs1 = Conv2D(n_classes-i, (1, 1), activation='softmax')(out)
+      #  out_list.append(outputs1)
+    #outputs2 = Conv2D(n_classes-1, (1, 1), activation='softmax')(out)
+    #outputs3 = Conv2D(n_classes-2, (1, 1), activation='softmax')(out)
+    #outputs4 = Conv2D(n_classes-3, (1, 1), activation='softmax')(out)
+    #outputs5 = Conv2D(n_classes-4, (1, 1), activation='softmax')(out)
+    #outputs6 = Conv2D(n_classes-5, (1, 1), activation='softmax')(out)
+    #outputs7 = Conv2D(n_classes-6, (1, 1), activation='softmax')(out)
+    #outputs8 = Conv2D(n_classes-7, (1, 1), activation='softmax')(out)
+    #outputs9 = Conv2D(n_classes-8, (1, 1), activation='softmax')(out)
+    
+    #out_list = [outputs1, outputs2, outputs3, outputs4, outputs5, outputs6, outputs7, outputs8, outputs9]
+    #outputs = Conv2D(n_classes, (1, 1), activation='softmax')(encode.output)
+    #outputs = concatenate(out_list, axis=3)
+    #outputs = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')(outputs)
+    outputs = Conv2D(n_classes, (1, 1), activation='softmax',  padding='same')(out)
+    
+    
+    #model = Model(inputs=[inputs], outputs=[encode.output])
+    model = Model(inputs=[x], outputs=[outputs])
+    #model = Model(inputs=[model7.input, model11.input], outputs=[outputs])
+   
+     
+    
+    
+    if n_classes <= 2: 
+      model.compile(optimizer = Adam(lr = 1e-3), loss = 'binary_crossentropy', metrics = metrics)
+    elif n_classes > 2: 
+      model.compile(optimizer = Adam(lr = 1e-3), loss = 'categorical_crossentropy', metrics = metrics)
+
+    #if summary: 
+     # model.summary()
+    
+    return model
+
+model = unet_enssemble(n_classes=n_classes, height = height, width = width, channels = n_channels)
+
+
 size = 1024
 pach_size = 256
 
@@ -127,7 +825,7 @@ def weighted_categorical_crossentropy(weights):
 # Load the model
 #model = tf.keras.models.load_model("model.h5", custom_objects={"jacard":jacard, "wcce":weighted_categorical_crossentropy})
 #model = tf.keras.models.load_model("model_2.h5", custom_objects={"jacard":jacard, "bce_dice":bce_dice})
-model = tf.keras.models.load_model("model_2_A (1).h5", custom_objects={"jacard":jacard, "bce_dice":bce_dice})
+model = model.load_weights("model_2_A (1).h5")
 
 # Create a user interface for the model
 my_app = gr.Blocks()