# -*- coding: utf-8 -*- """Untitled6.ipynb Automatically generated by Colaboratory. Original file is located at https://colab.research.google.com/drive/1DXONijhgg7IdUpvpL5H2kmvoySZ0-gMX """ import tensorflow as tf from tensorflow.keras import layers, models from tensorflow.keras.callbacks import EarlyStopping # Conditional Contrastive GAN (CGAN) Network Architecture def build_cgan(input_shape, num_classes): # Generator generator = build_generator(input_shape, num_classes) # Discriminator discriminator = build_discriminator(input_shape, num_classes) # CGAN Model cgan_input = layers.Input(shape=input_shape, name='cgan_input') generated_output = generator(cgan_input) cgan_output = discriminator([cgan_input, generated_output]) cgan = models.Model(inputs=cgan_input, outputs=[generated_output, cgan_output]) return cgan # Implement the generator architecture with skip connections def build_generator(input_shape, num_classes): # Encoder input_layer = layers.Input(shape=input_shape, name='generator_input') x = layers.Conv2D(64, (3, 3), padding='same', activation='relu')(input_layer) skip_connections = [x] # Downsample for filters in [128, 256, 512]: x = layers.Conv2D(filters, (3, 3), strides=(2, 2), padding='same', activation='relu')(x) skip_connections.append(x) # Decoder for filters, skip_connection in zip([512, 256, 128, 64], reversed(skip_connections)): x = layers.Conv2DTranspose(filters, (3, 3), strides=(2, 2), padding='same', activation='relu')(x) x = layers.Concatenate()([x, skip_connection]) output_layer = layers.Conv2D(num_classes, (1, 1), activation='softmax', name='generator_output')(x) generator = models.Model(inputs=input_layer, outputs=output_layer, name='generator') return generator # Implement the discriminator architecture def build_discriminator(input_shape, num_classes): input_layer = layers.Input(shape=input_shape, name='discriminator_input') x = input_layer # Replace the following with your discriminator architecture x = layers.Conv2D(64, (3, 3), strides=(2, 2), padding='same', activation='relu')(x) x = layers.Conv2D(128, (3, 3), strides=(2, 2), padding='same', activation='relu')(x) x = layers.Conv2D(256, (3, 3), strides=(2, 2), padding='same', activation='relu')(x) # Global average pooling x = layers.GlobalAveragePooling2D()(x) # Fully connected layer for classification x = layers.Dense(num_classes, activation='softmax', name='discriminator_output')(x) discriminator = models.Model(inputs=input_layer, outputs=x, name='discriminator') return discriminator # Class-specific Attention Module def class_specific_attention(input_tensor, num_classes): # Depth-wise separable convolution x = layers.DepthwiseConv2D((3, 3), padding='same', activation=None)(input_tensor) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) # Global max pooling x = layers.GlobalMaxPooling2D()(x) # Fully connected layer for class scores class_scores = layers.Dense(num_classes, activation='softmax', name='class_scores')(x) # Reshape class scores to match the input shape class_scores = layers.Reshape((1, 1, num_classes))(class_scores) # Multiply input by class scores element-wise class_specific_attention = layers.Multiply(name='class_specific_attention')([input_tensor, class_scores]) return class_specific_attention # Region-level Rebalance Module def region_level_rebalance(input_tensor, num_classes): # Auxiliary region classification module region_classification = layers.Conv2D(num_classes, (3, 3), padding='same', activation='softmax', name='region_classification')(input_tensor) # Extracted area (A) from the region classification extracted_area = layers.Activation('softmax', name='extracted_area')(region_classification) # Ground-truth of the region (A_y) ground_truth_region = layers.Input(shape=(None, None, num_classes), name='ground_truth_region') # Loss function for region rebalancing def region_rebalance_loss(y_true, y_pred): F_C = layers.Lambda(lambda x: layers.sum(layers.cast(layers.equal(x[0], x[1]), dtype='float32')))([ground_truth_region, extracted_area]) A_y = layers.sum(y_true * extracted_area, axis=[1, 2]) loss = -layers.log(A_y / layers.sum(F_C * layers.exp(y_pred), axis=[1, 2])) return loss # Pixel loss (Loss_pixel) pixel_loss = layers.Lambda(lambda x: -layers.log(x))(extracted_area) # Region loss (Loss_region) region_loss = layers.Lambda(region_rebalance_loss, name='region_loss')([ground_truth_region, region_classification]) # Combined loss (Loss_all) combined_loss = layers.Add(name='loss_all')([pixel_loss, region_loss]) return combined_loss # Supervised Contrastive Learning-based Network (SCoLN) def SCoLN(input_shape): # Input tensor input_tensor = layers.Input(shape=input_shape, name='input_tensor') # ResNet-50 architecture with a residual module resnet_base = tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=input_shape) resnet_base.trainable = False # Contrastive learning part positive_output = layers.Dense(128, activation='relu', name='positive_output')(resnet_base(input_tensor)) negative_output = layers.Dense(128, activation='relu', name='negative_output')(resnet_base(input_tensor)) # Contrastive loss def contrastive_loss(y_true, y_pred): margin = 1 positive_sim = tf.exp(tf.reduce_sum(y_true * y_pred[0], axis=-1)) negative_sim = tf.reduce_sum(tf.exp(tf.reduce_sum(y_true * y_pred[1], axis=-1))) loss = -tf.math.log(positive_sim / (positive_sim + negative_sim + 1e-10)) return loss # Contrastive loss layer contrastive_loss_layer = layers.Lambda(contrastive_loss, name='contrastive_loss')([positive_output, negative_output]) # Classification part classification_output = layers.Dense(1, activation='sigmoid', name='classification_output')(resnet_base(input_tensor)) # Classification loss classification_loss = 'binary_crossentropy' # Build the model SCoLN_model = models.Model(inputs=input_tensor, outputs=[contrastive_loss_layer, classification_output], name='SCoLN') SCoLN_model.compile(optimizer='adam', loss={'contrastive_loss': contrastive_loss, 'classification_output': classification_loss}) return SCoLN_model # Evaluation Measure Functions def intersection_over_union(TP, FP, FN): return 2 * TP / (2 * TP + FP + FN) def dice_similarity_coefficient(TP, FP, FN): return TP / (TP + FP + FN) def precision(TP, FP): return TP / (TP + FP) def recall(TP, FN): return TP / (TP + FN) # Example usage input_shape = (512, 512, 3) num_classes = 3 # Adjust based on your task cgan_model = build_cgan(input_shape, num_classes) # Compile and train the model SCoLN_model = SCoLN(input_shape) SCoLN_model.compile(optimizer=tf.keras.optimizers.Adadelta(learning_rate=0.001, decay=1e-4), loss={'contrastive_loss': contrastive_loss, 'classification_output': 'binary_crossentropy'}, metrics={'contrastive_loss': None, 'classification_output': 'accuracy'}) # Define early stopping callback early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True) # Train the model history = SCoLN_model.fit(datagen.flow(train_data, {'contrastive_loss': train_labels, 'classification_output': train_labels}, batch_size=32, shuffle=True), epochs=450, steps_per_epoch=len(train_data) // 32, validation_data=(val_data, {'contrastive_loss': val_labels, 'classification_output': val_labels}), callbacks=[early_stopping]) # Plot training history #plt.plot(history.history['contrastive_loss'], label='Contrastive Loss') #plt.plot(history.history['classification_output_accuracy'], label='Classification Accuracy') #plt.plot(history.history['val_contrastive_loss'], label='Validation Contrastive Loss') #plt.plot(history.history['val_classification_output_accuracy'], label='Validation Classification Accuracy') #plt.xlabel('Epoch') #plt.ylabel('Loss/Accuracy') #plt.legend() #plt.show() # Evaluate segmentation performance TP, FP, FN = 100, 10, 5 # Example values, replace with actual values iou = intersection_over_union(TP, FP, FN) dsc = dice_similarity_coefficient(TP, FP, FN) prec = precision(TP, FP) rec = recall(TP, FN) # Print or use evaluation metrics as needed print("IoU:", iou) print("DSC:", dsc) print("Precision:", prec) print("Recall:", rec)