import gradio as gr from PIL import Image from patchify import patchify, unpatchify import numpy as np from skimage.io import imshow, imsave import tensorflow import tensorflow as tf from tensorflow.keras import backend as K size = 1024 pach_size = 256 def jacard(y_true, y_pred): y_true_c = K.flatten(y_true) y_pred_c = K.flatten(y_pred) intersection = K.sum(y_true_c * y_pred_c) return (intersection + 1.0) / (K.sum(y_true_c) + K.sum(y_pred_c) - intersection + 1.0) def bce_dice(y_true, y_pred): bce = tf.keras.losses.BinaryCrossentropy() 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 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 def predict_2(image): image = Image.fromarray(image).resize((size,size)) image = np.array(image) stride = 1 steps = int(pach_size/stride) patches_img = patchify(image, (pach_size, pach_size, 3), step=steps) #Step=256 for 256 patches means no overlap patches_img = patches_img[:,:,0,:,:,:] patched_prediction = [] for i in range(patches_img.shape[0]): for j in range(patches_img.shape[1]): single_patch_img = patches_img[i,j,:,:,:] single_patch_img = single_patch_img/255 single_patch_img = np.expand_dims(single_patch_img, axis=0) pred = model.predict(single_patch_img) # Postprocess the mask pred = np.argmax(pred, axis=3) #print(pred.shape) pred = pred[0, :,:] patched_prediction.append(pred) patched_prediction = np.reshape(patched_prediction, [patches_img.shape[0], patches_img.shape[1], patches_img.shape[2], patches_img.shape[3]]) unpatched_prediction = unpatchify(patched_prediction, (image.shape[0], image.shape[1])) unpatched_prediction = targets_classes_colors[unpatched_prediction] return 'Predicted Masked Image', unpatched_prediction targets_classes_colors = np.array([[ 0, 0, 0], [128, 64, 128], [130, 76, 0], [ 0, 102, 0], [112, 103, 87], [ 28, 42, 168], [ 48, 41, 30], [ 0, 50, 89], [107, 142, 35], [ 70, 70, 70], [102, 102, 156], [254, 228, 12], [254, 148, 12], [190, 153, 153], [153, 153, 153], [255, 22, 96], [102, 51, 0], [ 9, 143, 150], [119, 11, 32], [ 51, 51, 0], [190, 250, 190], [112, 150, 146], [ 2, 135, 115], [255, 0, 0]]) class_weights = {0: 0.1, 1: 0.1, 2: 2.171655596616696, 3: 0.1, 4: 0.1, 5: 2.2101197049812593, 6: 11.601519937899578, 7: 7.99072122367673, 8: 0.1, 9: 0.1, 10: 2.5426918173402457, 11: 11.187574445057574, 12: 241.57620214903147, 13: 9.234779790464515, 14: 1077.2745952165694, 15: 7.396021659003857, 16: 855.6730643687165, 17: 6.410869993189135, 18: 42.0186736125025, 19: 2.5648760196752947, 20: 4.089194047656931, 21: 27.984593442818955, 22: 2.0509251319694712} weight_list = list(class_weights.values()) def weighted_categorical_crossentropy(weights): weights = weight_list def wcce(y_true, y_pred): Kweights = K.constant(weights) if not tf.is_tensor(y_pred): y_pred = K.constant(y_pred) y_true = K.cast(y_true, y_pred.dtype) return bce_dice(y_true, y_pred) * K.sum(y_true * Kweights, axis=-1) return wcce # 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 = model.load_weights("model_2_A (1).h5") # Create a user interface for the model my_app = gr.Blocks() with my_app: gr.Markdown("Statellite Image Segmentation Application UI with Gradio") with gr.Tabs(): with gr.TabItem("Select your image"): with gr.Row(): with gr.Column(): img_source = gr.Image(label="Please select source Image") source_image_loader = gr.Button("Load above Image") with gr.Column(): output_label = gr.Label(label="Image Info") img_output = gr.Image(label="Image Output") source_image_loader.click( predict_2, [ img_source ], [ output_label, img_output ] ) my_app.launch(debug=True, share=True) my_app.close()