Home Data Science and GovernanceArtificial Intelligence Find cancer with AI: a closer look at CT scan analysis with Self-Supervised Learning (SSL)

Find cancer with AI: a closer look at CT scan analysis with Self-Supervised Learning (SSL)

by Massimo

Self-Supervised Learning (SSL) is a fascinating area of machine learning, especially if you’re into the tech world or curious about how artificial intelligence (AI) learns to make sense of the world around it. Imagine being dropped in a new city with no map, no guide, and the task to find your way to a famous landmark. You’d start noticing patterns, like how certain signs point towards central areas, or how the flow of people might lead you to popular spots. This is a bit like how Self-Supervised Learning (SSL) works. In the tech world, we often have a ton of data but not enough labels or explanations for what that data means.
Labelling data can be like giving a tourist a detailed map – very helpful, but expensive and time-consuming to create. SSL skips the map: it teaches AI models to learn from the data itself, finding its own patterns, and creating its own understanding of what things mean. It’s a bit like teaching yourself Italian by watching movies without subtitles; you pick up on cues, context, and repeat expressions until things start to make sense. 

Reflecting on my early days in the R&D industry, I recall how SSL seemed like a distant concept, almost esoteric in its nature. But diving deep into its mechanisms, I began to see its practicality unfold in real-time, transforming abstract data into meaningful patterns. From my own experience diving into the depths of machine learning, I’ve found SSL to be akin to the thrill of solving a complex puzzle without having all the pieces from the start. It’s a journey of discovery that continuously fascinates me. I still remember the ‘aha’ moment when I first truly understood the power of SSL. I was working late one evening, experimenting with an SSL algorithm on a seemingly inscrutable dataset. Suddenly, patterns began to emerge, revealing insights that had been hidden in plain sight. It was a vivid reminder of why I fell in love with the field of AI in the first place.

Having spent countless hours tweaking algorithms and adjusting models, the shift towards applying SSL in healthcare, particularly in image detection, felt like stepping into a new world of possibilities. It was a convergence of my passion for machine learning and a deeper mission to contribute to societal well-being. 

The battle against cancer leverages Computed Tomography (CT) scans for early and accurate diagnosis. Despite their utility, interpreting these scans remains a highly skilled task. Variabilities in tumour appearances and the subtlety of early signs present significant challenges. Self-Supervised Learning emerges as a promising solution. It thrives on unlabelled data, learning from the input to uncover intrinsic patterns. SSL’s application in cancer identification via CT scans capitalizes on its ability to process vast volumes of unlabelled data efficiently. This approach offers cost and time savings, improves model generalization, and enhances feature extraction. However, SSL’s computational demands, potential for overfitting, and challenges in model interpretability warrant attention.

Integration of SSL in CT scan analysis

The application of SSL in CT scan analysis for cancer identification relies on its ability to harness large volumes of unlabelled data. Each SSL application offers a unique advantage in the identification of cancers through CT scans, leveraging the vast amounts of unlabelled data available in medical imaging. Combining these techniques together can improve the possibility to recognize cancers at the best. Let’s see some application of SSL: 

  1. Reconstruction Error Modelling for Anomaly Detection: Implementing SSL through reconstruction error modelling involves teaching a model to reconstruct CT scan images. The model learns to identify normal anatomical structures by minimizing the difference between the original and reconstructed images. Anomalies such as tumours manifest as significant reconstruction errors since the model is less familiar with these features, highlighting potential areas of concern. This technique leverages unlabelled CT scans to train models in distinguishing between normal and abnormal tissues, enhancing early cancer detection capabilities.
    At the end of this post I put an implementation example of this detection using Transformers.

  2. Predictive Coding for Feature Representation: One particular project that stands out in my memory involved the use of predictive coding for feature representation. The complexity of the data was overwhelming at first, but as the model began to unveil the subtle nuances between healthy and cancerous tissues, the potential of SSL in making a tangible difference in people’s lives became incredibly clear. Utilizing predictive coding frameworks in SSL enables models to predict parts of a CT scan based on surrounding information. By learning to anticipate the appearance of adjacent tissues, the model develops a deep understanding of normal anatomical patterns. Deviations from these predictions can indicate the presence of cancerous lesions. This method uses vast quantities of unlabelled data to refine its predictive accuracy, improving the model’s ability to detect subtle signs of cancer that may be overlooked in standard reviews.

  3. Contrastive Learning for Tumour Characterization: Applying contrastive learning involves training a model to identify similarities and differences between pairs of CT scan images. By comparing scans with known cancerous lesions to those without, the model learns to distinguish between cancerous and non-cancerous tissues. This approach is particularly valuable in enhancing the model’s ability to recognize various types of cancer, as it leverages unlabelled data to learn from a broad spectrum of cases, thereby improving diagnostic precision.

  4. Temporal Sequence Analysis for Cancer Progression Monitoring: Leveraging SSL for temporal sequence analysis involves analysing sequential CT scans of a patient over time. By learning the typical progression of anatomical changes, the model can identify deviations that suggest the development or progression of cancer. This technique allows for the monitoring of high-risk patients by utilizing existing CT scan data, offering a proactive approach to cancer care without the need for explicit labelling.

  5. Generative Modelling for Synthetic Lesion Generation: Employing generative adversarial networks (GANs) within an SSL framework to create synthetic images of CT scans with various types of lesions. These synthetic images can be used to augment existing datasets, particularly when certain types of cancer are underrepresented. By training models on a more diverse set of images, including those generated to mimic rare cancers, SSL can significantly improve the robustness and generalizability of cancer detection algorithms, ensuring that they are well-equipped to identify a wide range of cancer types across different patient demographics.

Drawing from my years of working with both supervised and self-supervised learning models, I’ve observed that while SSL can drastically reduce the need for labelled data, it requires a nuanced understanding of data patterns to truly excel. 
It’s a bit like learning to read between the lines of a complex novel, gaining insights that are not immediately obvious.

Transformers in "Reconstruction Error Modelling for Anomaly Detection"

The backbone of our approach is a convolutional autoencoder (sequence to sequence transformer), a type of neural network that learns to encode input data into a compact representation and then decode it back to the original form. 

The architecture is composed of two main parts:

  • Encoder: a Convolutional Neural Network. This component compresses the input CT scan into a lower-dimensional latent space. It consists of several convolutional layers followed by pooling layers that progressively reduce the spatial dimensions. (see the Computer vision concept of CNN).
  • Decoder: This part attempts to reconstruct the input image from the latent representation. It mirrors the encoder architecture but uses transposed convolutional layers to upsample the features back to the original image dimensions.

The training process involves minimizing the reconstruction error, which is the difference between the original CT scan and its reconstructed version produced by the decoder. The objective is to make the model sensitive to anomalies.

Anomaly Detection

After training, the model’s performance in anomaly detection hinges on its response to new, unseen CT scans:

  • Reconstruction Error as Anomaly Indicator: For a new CT scan, the model will attempt a reconstruction. If the scan contains anomalous features, like a tumour, the model, which is trained primarily on normal anatomy, will likely reconstruct these areas poorly. The reconstruction error in these regions will be significantly higher than in normal areas.
  • Thresholding: To automate the detection, we establish a threshold for reconstruction error. Areas in a scan where the error surpasses this threshold are flagged as potential sites of anomalies.

A quick implementation

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import torchvision.transforms as transforms
from torchvision import datasets

class ConvAutoencoder(nn.Module):
    def __init__(self):
        super(ConvAutoencoder, self).__init__()
        # Encoder layers
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 16, 3, stride=1, padding=1),  # Output: (16, 256, 256)
            nn.MaxPool2d(2, 2),  # Output: (16, 128, 128)
            nn.Conv2d(16, 8, 3, stride=1, padding=1),  # Output: (8, 128, 128)
            nn.MaxPool2d(2, 2),  # Output: (8, 64, 64)
            nn.Conv2d(8, 8, 3, stride=1, padding=1),  # Output: (8, 64, 64)
            nn.MaxPool2d(2, 2)  # Output: (8, 32, 32)
        # Decoder layers
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(8, 8, 3, stride=2),  # Output: (8, 65, 65)
            nn.ConvTranspose2d(8, 16, 3, stride=2),  # Output: (16, 129, 129)
            nn.ConvTranspose2d(16, 1, 3, stride=2, output_padding=1),  # Output: (1, 257, 257)

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ConvAutoencoder().to(device)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Assuming the dataset is ready and loaded as TensorDataset or similar
# For example purposes, let's assume we load it using DataLoader
train_loader = DataLoader(dataset, batch_size=64, shuffle=True)

num_epochs = 10
for epoch in range(num_epochs):
    for data in train_loader:
        img, _ = data  # Assuming there are no labels
        img = img.to(device)
        # Forward pass
        outputs = model(img)
        loss = criterion(outputs, img)
        # Backward and optimize
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

You may also like

This website uses cookies to improve your experience. We'll assume you're ok with this, but you can opt-out if you wish. Accept Read More