Klassifizierung von MRT-Scans mittels Radiomics und MLP

Tumoren, bei denen es sich um abnormale Wucherungen handelt, die sich im Gehirngewebe entwickeln können, stellen eine erhebliche Herausforderung für das Zentralnervensystem dar. Um ungewöhnliche Aktivitäten im Gehirn zu erkennen, setzen wir auf fortschrittliche medizinische Bildgebungsverfahren wie MRT- und CT-Scans. Allerdings kann die genaue Identifizierung von Tumoren aufgrund ihrer unterschiedlichen Formen und Texturen komplex sein und erfordert eine sorgfältige Analyse durch medizinisches Fachpersonal. Hier kommt die Leistungsfähigkeit von MRT-Scans mit Radiomics ins Spiel. Durch die Implementierung einer manuellen Merkmalsextraktion gefolgt von Klassifizierungstechniken können wir die Geschwindigkeit und Effizienz steigern, mit der Ärzte Bilddaten analysieren, was letztendlich zu präziseren Diagnosen und besseren Patientenergebnissen führt.

Lernziele

• Tauchen Sie tief in die Welt der handgefertigten Funktionen ein.
• Verstehen der Bedeutung von Radiomics für die Extraktion handgefertigter Merkmale.
• Erhalten Sie Einblicke, wie MRT-Scans mithilfe von Radiomics die Erkennung und Klassifizierung von Tumoren verbessern und so genauere medizinische Diagnosen ermöglichen.
• Verwendung der extrahierten Options zur Klassifizierung in verschiedene Klassen.
• Nutzung der Leistungsfähigkeit von Radiomics und Multi Layer Perceptron zur Klassifizierung.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Radiomics zur Merkmalsextraktion verstehen

Radiomics ist die Technik, die im medizinischen Bereich zur Erkennung handgefertigter Merkmale eingesetzt wird. Mit handgefertigten Merkmalen meinen wir die Textur, Dichte, Intensität usw. Diese Merkmale sind hilfreich, da sie helfen, die komplexen Muster der Krankheiten zu verstehen. Zur Berechnung der Merkmalswerte werden grundsätzlich mathematische und statistische Operationen eingesetzt. Die endgültigen Werte liefern uns tiefe Erkenntnisse, die später für weitere klinische Beobachtungen genutzt werden können. Hier müssen wir eines beachten. Der Merkmalsextraktion erfolgt im Wesentlichen auf der Area of Curiosity.

Gemeinsame radiomische Merkmale zur Tumorerkennung

Hier besprechen wir die Funktionen, die mit Radiomics extrahiert werden. Einige davon sind wie folgt:

• Formmerkmale: Dabei extrahiert Radiomics die geometrischen Merkmale der interessierenden Area. Es umfasst Volumen, Fläche, Länge, Breite, Kompaktheit usw.
• Statistische Merkmale: Wie der Identify schon sagt, nutzt es statistische Techniken wie Mittelwert, Standardabweichung, Schiefe, Kurtosis und Zufälligkeit. Anhand dieser können wir die Intensität des ROI bewerten.
• Texturmerkmale: Diese Merkmale konzentrieren sich auf die Homogenität und Heterogenität der Oberfläche der Area von Interesse. Einige Beispiele sind wie folgt:
  • GLCM oder Graustufen-Kookkurrenzmatrix: Misst den Kontrast und die Korrelation der Pixel oder Voxel im ROI
  • GLZSM oder Graustufenzonengrößenmatrix: Wird verwendet, um den zonalen Prozentsatz der homogenen Bereiche im ROI zu berechnen.
  • GLRLM oder Graustufen-Lauflängenmatrix: Wird verwendet, um die Gleichmäßigkeit der Intensitäten im gesamten interessierenden Bereich zu messen.
• Erweiterte mathematische Funktionen: Fortgeschrittene mathematische Techniken wie Laplace-, Gauß- und Gradientenformeln erfassen Muster durch die Anwendung von Filtern in der Tiefe.

Datensatzübersicht

Hier verwenden wir den auf Kaggle vorhandenen Hirntumor-Datensatz. Der Hyperlink zum Herunterladen des Datensatzes lautet Hier. Der Datensatz hat zwei Kategorien oder Klassen: Ja oder Nein. Jede Klasse hat 1500 Bilder.

• Ja bedeutet das Vorhandensein des Tumors.
• Nein bedeutet, dass der Tumor nicht vorhanden ist.

Unten finden Sie einige Beispielbilder:

Umgebungseinrichtung und Bibliotheken

Wir verwenden die PyRadiomics-Bibliothek zum Extrahieren von Funktionen und haben uns für Google Colab für diesen Prozess entschieden, da es die neueste Python-Model bereitstellt und so einen reibungslosen Betrieb von PyRadiomics gewährleistet. Bei Verwendung älterer Versionen kann es sonst zu Fehlern kommen. Abgesehen von PyRadiomics haben wir andere verwendet Bibliotheken wie SITK, NumpyTaschenlampe zum Erstellen mehrschichtiger Perzeptrone. Wir haben auch verwendet Pandas um die Options im Datenrahmen zu speichern.

Wie bereits erwähnt, werden wir den Hirntumor-Datensatz verwenden. Aber hier gibt es keine Masken, mit denen man das Gehirngewebe, das unsere Area von Interesse darstellt, hervorheben kann. Daher erstellen wir Binärmasken und extrahieren Options aus dem maskierten Bereich. Zuerst laden wir den Bilddatensatz mithilfe der OS-Bibliothek und erstellen einen Datenrahmen, der Bildpfade und Beschriftungen umfasst.

# 1. Import crucial libraries
import os
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score
from radiomics import featureextractor
import SimpleITK as sitk

# 2. Mount Google Drive
from google.colab import drive
drive.mount('/content material/drive')

# 3. Outline the dataset path
base_path="/content material/drive/MyDrive/mind"

# 4. Put together a DataFrame with picture paths and labels
knowledge = ()
for label in ('sure', 'no'):
    folder_path = os.path.be part of(base_path, label)
    for filename in os.listdir(folder_path):
        if filename.endswith(('.png', '.jpg', '.jpeg')):  # Make sure you're studying picture recordsdata
            image_path = os.path.be part of(folder_path, filename)
            knowledge.append({'image_path': image_path, 'label': label})

df = pd.DataFrame(knowledge)

Wir verwenden die Easy Picture Device Equipment (SITK)-Bibliothek zum Lesen von Bildern, da SITK Voxelintensitäten und -ausrichtung beibehält – Funktionen, die von OpenCV oder Pillow nicht verwaltet werden. Darüber hinaus wird SITK von Radiomics unterstützt, was die Konsistenz gewährleistet. Nachdem wir das Bild gelesen haben, konvertieren wir es in Graustufen und erstellen mithilfe der Otsu-Schwellenwertanalyse eine binäre Maske, die optimale Werte für Graustufenbilder liefert. Schließlich extrahieren wir die Radiomic-Options, kennzeichnen jedes Function mit „Ja“ oder „Nein“, speichern sie in einer Liste und konvertieren die Liste in einen DataFrame.

# 5. Initialize the Radiomics characteristic extractor
extractor = featureextractor.RadiomicsFeatureExtractor()
ok=0
# 6. Extract options from photos
features_list = ()
for index, row in df.iterrows():
    image_path = row('image_path')
    label = row('label')

    # Load picture
    image_sitk = sitk.ReadImage(image_path)

    # Convert picture to grayscale whether it is an RGB picture
    if image_sitk.GetNumberOfComponentsPerPixel() > 1:  # Test if the picture is colour (RGB)
        image_sitk = sitk.VectorIndexSelectionCast(image_sitk, 0)  # Use the primary channel (grayscale)

    # Apply Otsu threshold to phase mind from background
    otsu_filter = sitk.OtsuThresholdImageFilter()
    mask_sitk = otsu_filter.Execute(image_sitk)  # Create binary masks utilizing Otsu's methodology

    # Make sure the masks has the identical metadata because the picture
    mask_sitk.CopyInformation(image_sitk)

    # Extract options utilizing the generated masks
    options = extractor.execute(image_sitk, mask_sitk)
    options('label') = label  # Add label to options
    features_list.append(options)
    print(ok)
    ok+=1

# 7. Convert extracted options right into a DataFrame
features_df = pd.DataFrame(features_list)

# 8. Cut up the dataset into coaching and testing units
X = features_df.drop(columns=('label'))  # Options
y = features_df('label')  # Labels

Vorverarbeitung der Function-Daten

Wenn Radiomics die Options aus Bildern extrahiert, hängt es auch Versionen der Funktionen an die Function-Arrays an. Daher müssen wir die Function-Werte einschließen, deren Function-Identify „original_“ lautet. Für nicht numerische Merkmalswerte erzwingen wir die Daten und füllen sie später mit 0. Für den Beschriftungsteil konvertieren wir die Zeichenfolgen in 0 oder 1. Danach teilen wir die Daten im Verhältnis 80:20 in Prepare und Take a look at auf. Zuletzt werden die Funktionen mit StandardScaler standardisiert. Wir prüfen auch, ob die Klassen unausgeglichen sind oder nicht.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.knowledge import DataLoader, TensorDataset
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import pandas as pd
import matplotlib.pyplot as plt

# Assuming features_df is already outlined and processed

feature_cols = (col for col in features_df.columns if col.startswith('original_'))

# Convert the chosen columns to numeric, errors="coerce" will substitute non-numeric values with NaN
features_df(feature_cols) = features_df(feature_cols).applymap(lambda x: x.merchandise() if hasattr(x, 'merchandise') else x).apply(pd.to_numeric, errors="coerce")

# Exchange NaN values with 0 (you need to use different methods if applicable)
features_df = features_df.fillna(0)

# Cut up the dataset into coaching and testing units
X = features_df(feature_cols).values  # Options as NumPy array
y = features_df('label').map({'sure': 1, 'no': 0}).values  # Labels as NumPy array (0 or 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.remodel(X_test)


class_counts = pd.Sequence(y_train).value_counts()

# Get the bulk and minority lessons
majority_class = class_counts.idxmax()
minority_class = class_counts.idxmin()
majority_count = class_counts.max()
minority_count = class_counts.min()

print(f'Majority Class: {majority_class} with depend: {majority_count}')
print(f'Minority Class: {minority_class} with depend: {minority_count}')

Verwendung von mehrschichtigem Perzeptron zur Klassifizierung

In diesem Schritt erstellen wir eine Mehrschichtiges Perzeptron. Zuvor konvertieren wir jedoch die Zug- und Testdaten in Tensoren. DataLoader werden auch mit der Batchgröße 32 erstellt.

X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.lengthy)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.lengthy)

# Create PyTorch datasets and dataloaders
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)  # Alter batch dimension as wanted
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

Das unten definierte MLP verfügt über zwei verborgene Schichten: ReLU als Aktivierungsfunktion und eine Dropout-Charge von 50 %. Die verwendete Verlustfunktion ist Cross Entropy Loss und der verwendete Optimierer ist Adam mit einer Lernrate von 0,001.

class MLP(nn.Module):
    def __init__(self, input_size, hidden_size1, hidden_size2, output_size):
        tremendous(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size1)
        self.relu1 = nn.ReLU()
        self.dropout1 = nn.Dropout(0.5)  # Dropout layer with 50% dropout fee
        self.fc2 = nn.Linear(hidden_size1, hidden_size2)
        self.relu2 = nn.ReLU()
        self.dropout2 = nn.Dropout(0.5)
        self.fc3 = nn.Linear(hidden_size2, output_size)

    def ahead(self, x):
        x = self.fc1(x)
        x = self.relu1(x)
        x = self.dropout1(x)
        x = self.fc2(x)
        x = self.relu2(x)
        x = self.dropout2(x)
        x = self.fc3(x)
        return x

# Create an occasion of the mannequin
input_size = X_train.form(1)  # Variety of options
hidden_size1 = 128  # Alter hidden layer sizes as wanted
hidden_size2 = 64
output_size = 2  # Binary classification (sure/no)
mannequin = MLP(input_size, hidden_size1, hidden_size2, output_size)

# Outline loss perform and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(mannequin.parameters(), lr=0.001)  # Alter studying fee as wanted

# Initialize an inventory to retailer loss values
loss_values = ()

# Prepare the mannequin
epochs = 200  # Alter variety of epochs as wanted
for epoch in vary(epochs):
    mannequin.prepare()  # Set mannequin to coaching mode
    running_loss = 0.0

    for i, (inputs, labels) in enumerate(train_loader):
        # Zero the gradients
        optimizer.zero_grad()

        # Ahead go
        outputs = mannequin(inputs)

        # Compute the loss
        loss = criterion(outputs, labels)

        # Backward go and optimization
        loss.backward()
        optimizer.step()

        # Accumulate the operating loss
        running_loss += loss.merchandise()

    # Retailer common loss for this epoch
    avg_loss = running_loss / len(train_loader)
    loss_values.append(avg_loss)  # Append to loss values
    print(f"Epoch ({epoch+1}/{epochs}), Loss: {avg_loss:.4f}")

# Take a look at the mannequin after coaching
mannequin.eval()  # Set mannequin to analysis mode
right = 0
complete = 0

with torch.no_grad():  # Disable gradient computation for testing
    for inputs, labels in test_loader:
        outputs = mannequin(inputs)
        _, predicted = torch.max(outputs.knowledge, 1)
        complete += labels.dimension(0)
        right += (predicted == labels).sum().merchandise()

# Calculate and print accuracy
accuracy = 100 * right / complete
print(f'Take a look at Accuracy: {accuracy:.2f}%')

# Plot the Loss Graph
plt.determine(figsize=(10, 5))
plt.plot(loss_values, label="Coaching Loss", colour="blue")
plt.title('Coaching Loss Curve')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.grid()
plt.present()

Wie wir sehen können, wird das Modell für 200 Epochen trainiert und der Verlust in jeder Epoche aufgezeichnet, der später für die Darstellung verwendet wird. Der Optimierer dient der Optimierung der Gewichte. Jetzt testen wir das Modell, indem wir die Gradientenberechnungen deaktivieren.

Wie wir der folgenden Ausgabe entnehmen können, beträgt die Genauigkeit des Testdatensatzes 94,50 %. Daraus können wir schließen, dass sich das Modell basierend auf den radiomischen Merkmalen intestine verallgemeinern lässt.

Abschluss

Der Einsatz von Radiomics und Multi-Layer-Perceptrons (MLP) bei der Klassifizierung von Hirntumoren kann den Diagnoseprozess für medizinisches Fachpersonal rationalisieren und verbessern. Durch die Extraktion handgefertigter Merkmale aus der Bildgebung des Gehirns können wir subtile Muster und Merkmale erfassen, die bei der genauen Identifizierung des Vorhandenseins eines Tumors helfen. Dieser Ansatz minimiert den Bedarf an manuellen Analysen und ermöglicht es Ärzten, schneller fundierte, datengesteuerte Entscheidungen zu treffen. Die Integration der Merkmalsextraktion mit der MLP-Klassifizierung zeigt das Potenzial von KI in der medizinischen Bildgebung und stellt eine effiziente, skalierbare Lösung dar, die Radiologen und Gesundheitsdienstleister bei der Diagnose komplexer Fälle erheblich unterstützen könnte.

Klicken Sie hier für den Google Collab-Hyperlink.

Wichtige Erkenntnisse

• Radiomics erfasst detaillierte Bildmerkmale und ermöglicht so eine präzisere Hirntumoranalyse.
• Mehrschichtige Perzeptrone (MLPs) verbessern die Klassifizierungsgenauigkeit durch die Verarbeitung komplexer Datenmuster.
• Die Merkmalsextraktion und die MLP-Integration optimieren die Erkennung von Hirntumoren und tragen so zu einer schnelleren Diagnose bei.
• Die Kombination von KI und Radiologie bietet einen skalierbaren Ansatz zur Unterstützung von medizinischem Fachpersonal.
• Diese Technik veranschaulicht, wie KI die diagnostische Effizienz und Genauigkeit in der medizinischen Bildgebung verbessern kann.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.