1 of 14

Carcinoma Classification

OxML 2023 Cases

Dr. M. Singh

Mr. A. Asgharpoor

2 of 14

Dataset

Imbalanced Dataset

186 Biopsy Slides

62 Labeled Images

- Normal: 36 (58%)

- Benign: 14 (22.6%)

- Malignant: 12 (19.4%)

3 of 14

Methods to Handle Imbalanced Datasets

An overview of methods to handle imbalanced datasets

Oversampling: Increasing the number of instances in the minority class

Undersampling: Reduce number of instances in majority class

Class Weighting: Gives more importance to minority class

Ensemble Methods: Combine multiple classifiers to improve performance

4 of 14

Dataset Preprocessing

AddGaussianNoise(noise_std)
transforms.RandomHorizontalFlip()
transforms.RandomVerticalFlip()
transforms.RandomRotation(45)
transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.2)

transforms.Resize((max_height, max_width)
transforms.ToTensor()
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # To stabilize training and ensures consistent input ranges

Data Augmentation

5 of 14

K-Fold Cross-Validation

What is K-fold Cross-Validation?

Why Stratified K-fold cross-validation?

Benefits of using Stratified K-fold:

Training set

Test set

K Iterations

A technique used to evaluate the performance of the models and assess their generalization capabilities.
It involves dividing the dataset into K equally-sized folds, where each fold acts as a validation set while the remaining K-1 folds are used for training.

Avoiding Overfitting: The dataset is small, which may lead to overfitting if models are trained on the entire dataset. It allows us to assess the performance of models on multiple train-test splits, mitigating the risk of overfitting.
Data Imbalance: , when combined with stratified sampling, allows reliable evaluation

Stratified
it ensures class balance in each fold.
particularly useful when dealing with imbalanced datasets, where the distribution of classes is uneven.
It ensures that each fold contains a representative sample of each class

The model trained on multiple stratified folds learns from a diverse set of class distributions, enhancing its ability to generalize to unseen data.

--------------------------

Idea behind K-fold Cross Validation:
Split the dataset into K equal-sized folds.
Train the model K times, each time using K-1 folds for training and 1 fold for validation.
Average the metric across all K folds to get an overall performance estimate.

6 of 14

Weighted Sampling

Why should it be used?

�

Imbalanced Dataset:

Applying a naive classification would led to bias

Minority Class Importance:

It is crucial to correctly identify samples from the minority classes.

Performance Improvement:

Mitigating the issue of class imbalance

With vs Without

�

7 of 14

Few Shot Learning

Credit: IARAI

Why Few Shot Learning? Few-shot learning is a suitable approach for the Carcinoma Classification competition due to the limited availability of labeled training data. By leveraging pretrained models and employing techniques like data augmentation, the models can learn to generalize effectively and make accurate predictions on unseen examples. Additionally, few-shot learning allows us to utilize the best existing solutions without the need for end-to-end model training, which may yield suboptimal results.

Few-shot learning is an approach in machine learning that tackles the problem of training models with only a small amount of labeled data. In the Carcinoma Classification problem, it can be used to classify histopathological slices as either containing or not containing carcinoma cells, even when the training dataset is limited.

The basic idea of few-shot learning is to make use of a pre-trained model that has already been trained on a large dataset. Instead of starting from scratch, the pre-trained model provides a foundation of knowledge that can be adapted to the specific task with limited labeled data.

In this approach, the provided solution suggests using pre-trained models like ResNet50, EfficientNetV2-S, Inception V3, and GoogLeNet. These models have already learned powerful features from large-scale datasets, and their weights are frozen to retain this knowledge.

The next step involves replacing the last fully connected layers of the pre-trained models to align with the number of classes in the Carcinoma Classification problem. This allows the models to adjust their predictions to the specific classes of the task.

During the training process, the models are trained using the available limited labeled data. The cross-entropy loss function is used to measure the difference between the predicted and true labels. Optimizers are used to update the model's parameters and minimize the loss during training.

By employing few-shot learning, this approach utilizes the pre-trained models' ability to extract relevant features from the histopathological images. It leverages the general knowledge learned from a large dataset and applies it to the specific task of carcinoma classification, even when the amount of labeled data is small. This method has the potential to improve classification performance and address the challenge posed by the limited training dataset in a more efficient way.

8 of 14

Ensemble Learning

Dataset

Resnet50

Inspection V3

Googlenet

Efficientnet V2

Combine

9 of 14

Check Point

Using checkpoints in this problem is beneficial for several reasons:

1. **Resuming Training**: Checkpoints allow you to save the model's parameters at different stages of the training process. If the training process is interrupted for any reason (e.g., system failure, time constraints), you can easily resume training from the last saved checkpoint instead of starting from scratch. This saves time and computational resources.

2. **Monitoring Progress**: Checkpoints provide a way to monitor the model's performance during training. By saving checkpoints at regular intervals, you can evaluate the model's performance on a validation set or track metrics such as loss and accuracy. This helps in understanding how the model is learning and whether any adjustments or optimizations are required.

3. **Enabling Model Selection**: When training a model, it is common to experiment with different architectures, hyperparameters, or optimization techniques. By saving checkpoints, you can compare the performance of models trained under different settings and select the one that performs best on the validation set. This enables you to make informed decisions about which model to choose for further evaluation or deployment.

4. **Enabling Transfer Learning**: Checkpoints are especially useful when applying transfer learning. In this approach, you start with a pre-trained model and fine-tune it on a specific task. By saving checkpoints during the fine-tuning process, you can evaluate the model's performance at different stages and select the checkpoint that achieves the best performance. This allows you to leverage the knowledge from the pre-trained model while adapting it to the specific task.

Overall, checkpoints serve as a practical and efficient way to save the model's progress, monitor performance, enable model selection, and facilitate transfer learning. They provide flexibility and convenience during the training process and help ensure that valuable progress is not lost in case of interruptions or the need for further evaluation and optimization.

10 of 14

Hyperparameters

Here are the hyperparameter values we used:

- `noise_std`: 0.1

- `max_height`: value determined by finding the maximum height among the images

- `max_width`: value determined by finding the maximum width among the images

- `num_classes`: 3

- `batch_size`: 8

- `k_folds`: 8

- `num_epochs`: 5

- `learning_rate` (for each optimizer):

- `optimizer_resnet`: 0.001

- `optimizer_efficientnet`: 0.001

- `optimizer_inception`: 0.001

- `optimizer_googlenet`: 0.001

11 of 14

Limitations

1. Small Training Data

2. Unbalanced Dataset

3. Preprocessing Challenges

4. Limited Model Training

5. Evaluation Metric

6. Limited Experimentation.

Limitations of the Code:

1. Small Training Data: The code faces a limitation due to the small size of the training data. With only 62 labeled images out of a total of 186, the limited amount of labeled data may affect the performance of the models. The lack of sufficient training data can lead to overfitting and limited generalization capability.

2. Unbalanced Data: Another limitation is the unbalanced distribution of the dataset. The dataset contains different classes of carcinoma cells, with varying frequencies. The unbalanced nature of the data can bias the model towards the majority class, leading to imbalanced precision and recall trade-offs. A naive classification approach, such as classifying all samples as healthy, may yield high accuracy but poor precision and recall.

3. Preprocessing Challenges: The code encounters challenges related to image preprocessing. The histopathological slides do not have the same size, and cropping them could result in missing important tumor cells. Resizing the images may alter the image features and make them less interpretable. These preprocessing limitations may affect the quality and reliability of the input data, potentially impacting the model's performance.

4. Limited Model Training: The code suggests relying on pretrained models and fine-tuning the last layer or using another classifier. While this approach leverages existing knowledge and can be efficient, it also limits the ability to explore and train end-to-end models specifically tailored to this task. The pretrained models may have been trained on different datasets or tasks, potentially leading to suboptimal performance on the carcinoma classification task.

5. Evaluation Metric: The code utilizes the F1 score as the evaluation metric. While the F1 score provides a balanced measure of precision and recall, it may not capture other important aspects of model performance. Depending solely on the F1 score may overlook potential trade-offs between sensitivity and specificity or fail to capture specific requirements of the application domain.

6. Limited Experimentation: The code does not provide an extensive analysis of different model architectures or hyperparameter settings. It primarily focuses on a few pretrained models (e.g., ResNet50, EfficientNetV2, Inception V3, GoogLeNet) and limited data augmentation techniques. This limitation restricts the exploration of other potential models, architectures, or techniques that could potentially improve performance.

7. Computational Resource Dependency: The code assumes the availability of computational resources such as GPUs for training the models. It does not account for scenarios where such resources may not be accessible, potentially limiting the reproducibility and applicability of the code in resource-constrained environments.

It is essential to consider these limitations when interpreting the results and generalizing the findings of the code. Further research and experimentation may be necessary to address these limitations and improve the overall performance of the models for the carcinoma classification task.

12 of 14

Future Works

1. Use Multi-Model Approach:

- Carcinoma: ⊖ OR ⊕

- If ⊕ : Benign OR Malignant

2. White Padding Approach:

- We only tried Black (Low Contrast with Cancer Cells)

13 of 14

Any Questions?

14 of 14

Thank you for your time and attention 🙂