Welcome to my project on skin lesion detection, developed as part of the ISIC 2024 Challenge. This project marks my first foray into this competition, where the objective is to build a model capable of accurately identifying skin lesions from medical images. The dataset provided by the challenge serves as the foundation for training and evaluating the model.

In this project, I have applied various techniques to ensure that the model performs robustly. Below is an overview of the approach taken:

Data Preprocessing: Cleaning and preparing the dataset for effective training.

Data Augmentation: Enhancing the dataset through techniques that improve the model’s ability to generalize.

Model Building: Designing and implementing a Convolutional Neural Network (CNN) using Keras and TensorFlow.

Training: Fine-tuning the model with appropriate loss functions and metrics to optimize performance.

Evaluation: Rigorous assessment of the model’s accuracy using validation and test datasets.

In [1]:

import os os.environ["KERAS_BACKEND"] = "tensorflow" import keras_cv import keras from keras import ops import tensorflow as tf import cv2 import pandas as pd import numpy as np from glob import glob from tqdm.notebook import tqdm import joblib import matplotlib.pyplot as plt print("TensorFlow:", tf.__version__) print("Keras:", keras.__version__) print("KerasCV:", keras_cv.__version__) TensorFlow: 2.16.1 Keras: 3.3.3 KerasCV: 0.9.0

In [2]:

class CFG: verbose = 1 # Verbosity seed = 42 # Random seed neg_sample = 0.01 # Downsample negative calss pos_sample = 5.0 # Upsample positive class preset = "efficientnetv2_b2_imagenet" # Name of pretrained classifier image_size = [128, 128] # Input image size epochs = 8 # Training epochs batch_size = 256 # Batch size lr_mode = "cos" # LR scheduler mode from one of "cos", "step", "exp" class_names = ['target'] num_classes = 1

In [3]:

keras.utils.set_random_seed(CFG.seed)

In [4]:

BASE_PATH = "/kaggle/input/isic-2024-challenge"

In [5]:

# Train + Valid df = pd.read_csv(f'{BASE_PATH}/train-metadata.csv', low_memory=False) df = df.ffill() display(df.head(2)) # Testing testing_df = pd.read_csv(f'{BASE_PATH}/test-metadata.csv', low_memory=False) testing_df = testing_df.ffill() display(testing_df.head(2)) isic_idtargetpatient_idage_approxsexanatom_site_generalclin_size_long_diam_mmimage_typetbp_tile_typetbp_lv_A…lesion_ididdx_fulliddx_1iddx_2iddx_3iddx_4iddx_5mel_mitotic_indexmel_thick_mmtbp_lv_dnn_lesion_confidence0ISIC_00156700IP_123582860.0malelower extremity3.04TBP tile: close-up3D: white20.244422…NaNBenignBenignNaNNaNNaNNaNNaNNaN97.5172821ISIC_00158450IP_817006560.0malehead/neck1.10TBP tile: close-up3D: white31.712570…IL_6727506BenignBenignNaNNaNNaNNaNNaNNaN3.141455

2 rows × 55 columns

isic_idpatient_idage_approxsexanatom_site_generalclin_size_long_diam_mmimage_typetbp_tile_typetbp_lv_Atbp_lv_Aext…tbp_lv_radial_color_std_maxtbp_lv_stdLtbp_lv_stdLExttbp_lv_symm_2axistbp_lv_symm_2axis_angletbp_lv_xtbp_lv_ytbp_lv_zattributioncopyright_license0ISIC_0015657IP_607433745.0maleposterior torso2.70TBP tile: close-up3D: XP22.8043320.007270…0.3048271.2815322.2999350.47933920-155.065101511.222000113.980100Memorial Sloan Kettering Cancer CenterCC-BY1ISIC_0015729IP_166413935.0femalelower extremity2.52TBP tile: close-up3D: XP16.648679.657964…0.0000001.2719402.0112230.42623025-112.36924629.535889-15.019287Frazer Institute, The University of Queensland…CC-BY

2 rows × 44 columns

In [6]:

print("Class Distribution Before Sampling (%):") display(df.target.value_counts(normalize=True)*100) # Sampling positive_df = df.query("target==0").sample(frac=CFG.neg_sample, random_state=CFG.seed) negative_df = df.query("target==1").sample(frac=CFG.pos_sample, replace=True, random_state=CFG.seed) df = pd.concat([positive_df, negative_df], axis=0).sample(frac=1.0) print("\nCalss Distribution After Sampling (%):") display(df.target.value_counts(normalize=True)*100) Class Distribution Before Sampling (%): target 0 99.902009 1 0.097991 Name: proportion, dtype: float64Calss Distribution After Sampling (%): target 0 67.09645 1 32.90355 Name: proportion, dtype: float64

In [7]:

from sklearn.utils.class_weight import compute_class_weight # Assume df is your DataFrame and 'target' is the column with class labels class_weights = compute_class_weight('balanced', classes=np.unique(df['target']), y=df['target']) class_weights = dict(enumerate(class_weights)) print("Class Weights:", class_weights) Class Weights: {0: 0.7451959071624656, 1: 1.519592875318066}

In [8]:

import h5py training_validation_hdf5 = h5py.File(f"{BASE_PATH}/train-image.hdf5", 'r') testing_hdf5 = h5py.File(f"{BASE_PATH}/test-image.hdf5", 'r')

In [9]:

isic_id = df.isic_id.iloc[0] # Image as Byte String byte_string = training_validation_hdf5[isic_id][()] print(f"Byte String: {byte_string[:20]}....") # Convert byte string to numpy array nparr = np.frombuffer(byte_string, np.uint8) print("Image:") image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)[...,::-1] # reverse last axis for bgr -> rgb plt.imshow(image); Byte String: b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00'.... Image:

In [10]:

from sklearn.model_selection import StratifiedGroupKFold df = df.reset_index(drop=True) # ensure continuous index df["fold"] = -1 sgkf = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=CFG.seed) for i, (training_idx, validation_idx) in enumerate(sgkf.split(df, y=df.target, groups=df.patient_id)): df.loc[validation_idx, "fold"] = int(i) # Use first fold for training and validation training_df = df.query("fold!=0") validation_df = df.query("fold==0") print(f"# Num Train: {len(training_df)} | Num Valid: {len(validation_df)}") # Num Train: 4706 | Num Valid: 1266

In [11]:

training_df.target.value_counts()

Out[11]:

target 0 3088 1 1618 Name: count, dtype: int64

In [12]:

validation_df.target.value_counts()

Out[12]:

target 0 919 1 347 Name: count, dtype: int64

In [13]:

# Categorical features which will be one hot encoded CATEGORICAL_COLUMNS = ["sex", "anatom_site_general", "tbp_tile_type","tbp_lv_location", ] # Numeraical features which will be normalized NUMERIC_COLUMNS = ["age_approx", "tbp_lv_nevi_confidence", "clin_size_long_diam_mm", "tbp_lv_areaMM2", "tbp_lv_area_perim_ratio", "tbp_lv_color_std_mean", "tbp_lv_deltaLBnorm", "tbp_lv_minorAxisMM", ] # Tabular feature columns FEAT_COLS = CATEGORICAL_COLUMNS + NUMERIC_COLUMNS

In [14]:

from tqdm import tqdm from tqdm.notebook import tqdm

In [15]:

def build_augmenter(): # Define augmentations aug_layers = [ keras_cv.layers.RandomCutout(height_factor=(0.02, 0.06), width_factor=(0.02, 0.06)), keras_cv.layers.RandomFlip(mode="horizontal"), ] # Apply augmentations to random samples aug_layers = [keras_cv.layers.RandomApply(x, rate=0.5) for x in aug_layers] # Build augmentation layer augmenter = keras_cv.layers.Augmenter(aug_layers) # Apply augmentations def augment(inp, label): images = inp["images"] aug_data = {"images": images} aug_data = augmenter(aug_data) inp["images"] = aug_data["images"] return inp, label return augment def build_decoder(with_labels=True, target_size=CFG.image_size): def decode_image(inp): # Read jpeg image file_bytes = inp["images"] image = tf.io.decode_jpeg(file_bytes) # Resize image = tf.image.resize(image, size=target_size, method="area") # Rescale image image = tf.cast(image, tf.float32) image /= 255.0 # Reshape image = tf.reshape(image, [*target_size, 3]) inp["images"] = image return inp def decode_label(label, num_classes): label = tf.cast(label, tf.float32) label = tf.reshape(label, [num_classes]) return label def decode_with_labels(inp, label=None): inp = decode_image(inp) label = decode_label(label, CFG.num_classes) return (inp, label) return decode_with_labels if with_labels else decode_image

In [16]:

def build_dataset( isic_ids, hdf5, features, labels=None, batch_size=32, decode_fn=None, augment_fn=None, augment=False, shuffle=1024, cache=True, drop_remainder=False, ): if decode_fn is None: decode_fn = build_decoder(labels is not None) if augment_fn is None: augment_fn = build_augmenter() AUTO = tf.data.experimental.AUTOTUNE images = [None]*len(isic_ids) for i, isic_id in enumerate(tqdm(isic_ids, desc="Loading Images ")): images[i] = hdf5[isic_id][()] inp = {"images": images, "features": features} slices = (inp, labels) if labels is not None else inp ds = tf.data.Dataset.from_tensor_slices(slices) ds = ds.cache() if cache else ds ds = ds.map(decode_fn, num_parallel_calls=AUTO) if shuffle: ds = ds.shuffle(shuffle, seed=CFG.seed) opt = tf.data.Options() opt.deterministic = False ds = ds.with_options(opt) ds = ds.batch(batch_size, drop_remainder=drop_remainder) ds = ds.map(augment_fn, num_parallel_calls=AUTO) if augment else ds ds = ds.prefetch(AUTO) return ds

In [17]:

## Train print("# Training:") training_features = dict(training_df[FEAT_COLS]) training_ids = training_df.isic_id.values training_labels = training_df.target.values training_ds = build_dataset(training_ids, training_validation_hdf5, training_features, training_labels, batch_size=CFG.batch_size, shuffle=True, augment=True) # Valid print("# Validation:") validation_features = dict(validation_df[FEAT_COLS]) validation_ids = validation_df.isic_id.values validation_labels = validation_df.target.values validation_ds = build_dataset(validation_ids, training_validation_hdf5, validation_features, validation_labels, batch_size=CFG.batch_size, shuffle=False, augment=False) # Training:

Loading Images : 100%

4706/4706 [00:22<00:00, 255.31it/s]

# Validation:

Loading Images : 100%

1266/1266 [00:05<00:00, 256.33it/s]

In [18]:

feature_space = keras.utils.FeatureSpace( features={ # Categorical features encoded as integers "sex": "string_categorical", "anatom_site_general": "string_categorical", "tbp_tile_type": "string_categorical", "tbp_lv_location": "string_categorical", # Numerical features to discretize "age_approx": "float_discretized", # Numerical features to normalize "tbp_lv_nevi_confidence": "float_normalized", "clin_size_long_diam_mm": "float_normalized", "tbp_lv_areaMM2": "float_normalized", "tbp_lv_area_perim_ratio": "float_normalized", "tbp_lv_color_std_mean": "float_normalized", "tbp_lv_deltaLBnorm": "float_normalized", "tbp_lv_minorAxisMM": "float_normalized", }, output_mode="concat", )

In [19]:

training_ds_with_no_labels = training_ds.map(lambda x, _: x["features"]) feature_space.adapt(training_ds_with_no_labels)

In [20]:

for x, _ in training_ds.take(1): preprocessed_x = feature_space(x["features"]) print("preprocessed_x.shape:", preprocessed_x.shape) print("preprocessed_x.dtype:", preprocessed_x.dtype) preprocessed_x.shape: (256, 71) preprocessed_x.dtype: <dtype: 'float32'>

In [21]:

training_ds = training_ds.map( lambda x, y: ({"images": x["images"], "features": feature_space(x["features"])}, y), num_parallel_calls=tf.data.AUTOTUNE) validation_ds = validation_ds.map( lambda x, y: ({"images": x["images"], "features": feature_space(x["features"])}, y), num_parallel_calls=tf.data.AUTOTUNE)

In [22]:

batch = next(iter(validation_ds)) print("Images:",batch[0]["images"].shape) print("Features:", batch[0]["features"].shape) print("Targets:", batch[1].shape) Images: (256, 128, 128, 3) Features: (256, 71) Targets: (256, 1)

In [23]:

# AUC auc = keras.metrics.AUC() # Loss loss = keras.losses.BinaryCrossentropy(label_smoothing=0.02)

In [24]:

# Define input layers image_input = keras.Input(shape=(*CFG.image_size, 3), name="images") feat_input = keras.Input(shape=(feature_space.get_encoded_features().shape[1],), name="features") inp = {"images":image_input, "features":feat_input} # Branch for image input backbone = keras_cv.models.EfficientNetV2Backbone.from_preset(CFG.preset) x1 = backbone(image_input) x1 = keras.layers.GlobalAveragePooling2D()(x1) x1 = keras.layers.Dropout(0.2)(x1) # Branch for tabular/feature input x2 = keras.layers.Dense(96, activation="selu")(feat_input) x2 = keras.layers.Dense(128, activation="selu")(x2) x2 = keras.layers.Dropout(0.1)(x2) # Concatenate both branches concat = keras.layers.Concatenate()([x1, x2]) # Output layer out = keras.layers.Dense(1, activation="sigmoid", dtype="float32")(concat) # Build model model = keras.models.Model(inp, out) # Compile the model model.compile( optimizer=keras.optimizers.Adam(learning_rate=1e-4), loss=loss, metrics=[auc], ) # Model Summary model.summary() Model: "functional_1" ┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓ ┃ Layer (type) ┃ Output Shape ┃ Param # ┃ Connected to ┃ ┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩ │ images (InputLayer) │ (None, 128, 128, │ 0 │ - │ │ │ 3) │ │ │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ features │ (None, 71) │ 0 │ - │ │ (InputLayer) │ │ │ │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ efficient_net_v2b2… │ (None, 4, 4, │ 8,769,374 │ images[0][0] │ │ (EfficientNetV2Bac… │ 1408) │ │ │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ dense (Dense) │ (None, 96) │ 6,912 │ features[0][0] │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ global_average_poo… │ (None, 1408) │ 0 │ efficient_net_v2… │ │ (GlobalAveragePool… │ │ │ │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ dense_1 (Dense) │ (None, 128) │ 12,416 │ dense[0][0] │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ dropout (Dropout) │ (None, 1408) │ 0 │ global_average_p… │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ dropout_1 (Dropout) │ (None, 128) │ 0 │ dense_1[0][0] │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ concatenate_1 │ (None, 1536) │ 0 │ dropout[0][0], │ │ (Concatenate) │ │ │ dropout_1[0][0] │ ├─────────────────────┼───────────────────┼────────────┼───────────────────┤ │ dense_2 (Dense) │ (None, 1) │ 1,537 │ concatenate_1[0]… │ └─────────────────────┴───────────────────┴────────────┴───────────────────┘ Total params: 8,790,239 (33.53 MB) Trainable params: 8,707,951 (33.22 MB) Non-trainable params: 82,288 (321.44 KB)

In [25]:

keras.utils.plot_model(model, show_shapes=True, show_layer_names=True, dpi=60)

Out[25]:

In [26]:

import math def get_lr_callback(batch_size=8, mode='cos', epochs=10, plot=False): lr_start, lr_max, lr_min = 2.5e-5, 5e-6 * batch_size, 0.8e-5 lr_ramp_ep, lr_sus_ep, lr_decay = 3, 0, 0.75 def lrfn(epoch): # Learning rate update function if epoch < lr_ramp_ep: lr = (lr_max - lr_start) / lr_ramp_ep * epoch + lr_start elif epoch < lr_ramp_ep + lr_sus_ep: lr = lr_max elif mode == 'exp': lr = (lr_max - lr_min) * lr_decay**(epoch - lr_ramp_ep - lr_sus_ep) + lr_min elif mode == 'step': lr = lr_max * lr_decay**((epoch - lr_ramp_ep - lr_sus_ep) // 2) elif mode == 'cos': decay_total_epochs, decay_epoch_index = epochs - lr_ramp_ep - lr_sus_ep + 3, epoch - lr_ramp_ep - lr_sus_ep phase = math.pi * decay_epoch_index / decay_total_epochs lr = (lr_max - lr_min) * 0.5 * (1 + math.cos(phase)) + lr_min return lr if plot: # Plot lr curve if plot is True plt.figure(figsize=(10, 5)) plt.plot(np.arange(epochs), [lrfn(epoch) for epoch in np.arange(epochs)], marker='o') plt.xlabel('epoch'); plt.ylabel('lr') plt.title('LR Scheduler') plt.show() return keras.callbacks.LearningRateScheduler(lrfn, verbose=False) # Create lr callback

In [27]:

inputs, targets = next(iter(training_ds)) images = inputs["images"] num_images, NUMERIC_COLUMNS = 8, 4 plt.figure(figsize=(4 * NUMERIC_COLUMNS, num_images // NUMERIC_COLUMNS * 4)) for i, (image, target) in enumerate(zip(images[:num_images], targets[:num_images])): plt.subplot(num_images // NUMERIC_COLUMNS, NUMERIC_COLUMNS, i + 1) image = image.numpy().astype("float32") target= target.numpy().astype("int32")[0] image = (image - image.min()) / (image.max() + 1e-4) plt.imshow(image) plt.title(f"Target: {target}") plt.axis("off") plt.tight_layout() plt.show()

In [28]:

lr_cb = get_lr_callback(CFG.batch_size, mode="exp", plot=True)

In [29]:

ckpt_cb = keras.callbacks.ModelCheckpoint( "best_model.keras", # Filepath where the model will be saved. monitor="val_auc", # Metric to monitor (validation AUC in this case). save_best_only=True, # Save only the model with the best performance. save_weights_only=False, # Save the entire model (not just the weights). mode="max", # The model with the maximum 'val_auc' will be saved. )

In [30]:

history = model.fit( training_ds, epochs=CFG.epochs, callbacks=[lr_cb, ckpt_cb], validation_data=validation_ds, verbose=CFG.verbose, class_weight=class_weights, ) Epoch 1/8 WARNING: All log messages before absl::InitializeLog() is called are written to STDERR I0000 00:00:1724872959.215852 72 service.cc:145] XLA service 0x7dd614018260 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices: I0000 00:00:1724872959.215927 72 service.cc:153] StreamExecutor device (0): Tesla T4, Compute Capability 7.5 I0000 00:00:1724872959.215933 72 service.cc:153] StreamExecutor device (1): Tesla T4, Compute Capability 7.5 WARNING: All log messages before absl::InitializeLog() is called are written to STDERR I0000 00:00:1724873079.626884 72 asm_compiler.cc:369] ptxas warning : Registers are spilled to local memory in function 'loop_add_subtract_fusion_18', 72 bytes spill stores, 72 bytes spill loads I0000 00:00:1724873079.747367 72 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process. 16/19 ━━━━━━━━━━━━━━━━━━━━ 1s 366ms/step - auc: 0.4186 - loss: 0.7458I0000 00:00:1724873190.922405 70 asm_compiler.cc:369] ptxas warning : Registers are spilled to local memory in function 'loop_add_subtract_fusion_18', 72 bytes spill stores, 72 bytes spill loads 19/19 ━━━━━━━━━━━━━━━━━━━━ 308s 7s/step - auc: 0.4260 - loss: 0.7432 - val_auc: 0.3284 - val_loss: 0.7782 - learning_rate: 2.5000e-05 Epoch 2/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 14s 673ms/step - auc: 0.7664 - loss: 0.5888 - val_auc: 0.7247 - val_loss: 0.5442 - learning_rate: 4.4333e-04 Epoch 3/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 14s 659ms/step - auc: 0.9539 - loss: 0.3044 - val_auc: 0.7679 - val_loss: 0.5726 - learning_rate: 8.6167e-04 Epoch 4/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 14s 666ms/step - auc: 0.9880 - loss: 0.1778 - val_auc: 0.8706 - val_loss: 0.4317 - learning_rate: 0.0013 Epoch 5/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 14s 664ms/step - auc: 0.9965 - loss: 0.1228 - val_auc: 0.9185 - val_loss: 0.4356 - learning_rate: 9.6200e-04 Epoch 6/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 19s 598ms/step - auc: 0.9988 - loss: 0.0951 - val_auc: 0.9064 - val_loss: 0.4878 - learning_rate: 7.2350e-04 Epoch 7/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 13s 606ms/step - auc: 0.9993 - loss: 0.0796 - val_auc: 0.9059 - val_loss: 0.5100 - learning_rate: 5.4462e-04 Epoch 8/8 19/19 ━━━━━━━━━━━━━━━━━━━━ 13s 612ms/step - auc: 0.9997 - loss: 0.0761 - val_auc: 0.9029 - val_loss: 0.5102 - learning_rate: 4.1047e-04

In [31]:

# Extract AUC and validation AUC from history auc = history.history['auc'] val_auc = history.history['val_auc'] epochs = range(1, len(auc) + 1) # Find the epoch with the maximum val_auc max_val_auc_epoch = np.argmax(val_auc) max_val_auc = val_auc[max_val_auc_epoch] # Plotting plt.figure(figsize=(10, 6)) plt.plot(epochs, auc, 'o-', label='Training AUC', markersize=5, color='tab:blue') plt.plot(epochs, val_auc, 's-', label='Validation AUC', markersize=5, color='tab:orange') # Highlight the max val_auc plt.scatter(max_val_auc_epoch + 1, max_val_auc, color='red', s=100, label=f'Max Val AUC: {max_val_auc:.4f}') plt.annotate(f'Max Val AUC: {max_val_auc:.4f}', xy=(max_val_auc_epoch + 1, max_val_auc), xytext=(max_val_auc_epoch + 1 + 0.5, max_val_auc - 0.05), arrowprops=dict(facecolor='black', arrowstyle="->"), fontsize=12, color='tab:red') # Enhancing the plot plt.title('AUC over Epochs', fontsize=14) plt.xlabel('Epoch', fontsize=12) plt.ylabel('AUC', fontsize=12) plt.legend(loc='lower right', fontsize=12) plt.grid(True) plt.xticks(epochs) # Show the plot plt.show()

In [32]:

# Best Result best_score = max(history.history['val_auc']) best_epoch = np.argmax(history.history['val_auc']) + 1 print("#" * 10 + " Result " + "#" * 10) print(f"Best AUC: {best_score:.5f}") print(f"Best Epoch: {best_epoch}") print("#" * 28) ########## Result ########## Best AUC: 0.91847 Best Epoch: 5 ############################

In [33]:

# Manually save the model to /kaggle/working/ model.save('/kaggle/working/best_model.keras') # Verify the file is saved file_path = '/kaggle/working/best_model.keras' print(os.path.isfile(file_path)) # Should return True if the file exists True

In [34]:

model.load_weights("best_model.keras")

In [35]:

# Testing print("# Testing:") testing_features = dict(testing_df[FEAT_COLS]) testing_ids = testing_df.isic_id.values testing_ds = build_dataset(testing_ids, testing_hdf5, testing_features, batch_size=CFG.batch_size, shuffle=False, augment=False, cache=False) # Apply feature space processing testing_ds = testing_ds.map( lambda x: {"images": x["images"], "features": feature_space(x["features"])}, num_parallel_calls=tf.data.AUTOTUNE) # Testing:

Loading Images : 100%

3/3 [00:00<00:00, 116.94it/s]

In [36]:

preds = model.predict(testing_ds).squeeze() 1/1 ━━━━━━━━━━━━━━━━━━━━ 8s 8s/step

In [37]:

inputs = next(iter(testing_ds)) images = inputs["images"] # Plotting plt.figure(figsize=(10, 4)) for i in range(3): plt.subplot(1, 3, i+1) # 1 row, 3 columns, i+1th subplot plt.imshow(images[i]) # Show image plt.title(f'Prediction: {preds[i]:.2f}') # Set title with prediction plt.axis('off') # Hide axis plt.suptitle('Model Predictions on Testing Images', fontsize=16) plt.tight_layout() plt.show()

In [38]:

pred_df = testing_df[["isic_id"]].copy() pred_df["target"] = preds.tolist() sub_df = pd.read_csv(f'{BASE_PATH}/sample_submission.csv') sub_df = sub_df[["isic_id"]].copy() sub_df = sub_df.merge(pred_df, on="isic_id", how="left") sub_df.to_csv("submission.csv", index=False) sub_df.head()

Out[38]:

isic_idtarget0ISIC_00156570.0073261ISIC_00157290.0010462ISIC_00157400.014811

Designed with WordPress

Design a site like this with WordPress.com