Krebsklassifikation mit Machine Learning: Python-Tutorial für Einsteiger

Warum Machine Learning in der Medizin? Ein Trend, der Leben rettet

Stell dir vor, du könntest mit ein paar Zeilen Code einen Algorithmus bauen, der Tumore klassifiziert – genau wie in der aktuellen KI-Forschung, die Ärzte bei der Diagnose unterstützt. Im Mai 2026 sind KI-Assistenten in der Radiologie bereits im Einsatz, und genau solche einfachen Klassifikatoren wie in diesem Tutorial sind der Einstieg. Du lernst, wie du mit Python und grundlegenden Datenstrukturen (Listen, Dictionaries) einen regelbasierten Klassifikator entwickelst, der anhand von zehn Tumorattributen (z.B. Radius, Glätte) vorhersagt, ob ein Tumor bösartig (maligne) oder gutartig (benigne) ist. Das ist keine Science-Fiction, sondern praktische Programmierarbeit, die du heute umsetzen kannst.

Das Problem: Krebs klassifizieren mit Daten

Gegeben ist eine Datei mit Hunderten von Patientendaten. Jeder Datensatz enthält Messwerte eines Tumors sowie die bekannte Klasse (M für maligne, B für benigne). Die Idee: Bösartige Tumore haben tendenziell größere Radien, sind glatter, symmetrischer usw. Dein Code berechnet aus den Trainingsdaten (80% der Daten) den Durchschnittswert jedes Attributs für maligne und benigne Tumore. Dann berechnest du den Mittelpunkt zwischen diesen beiden Durchschnitten – das ist deine Entscheidungsgrenze. Für einen neuen Tumor: Ist sein Attributwert größer oder gleich dem Mittelpunkt, gibt es eine Stimme für maligne, sonst für benigne. Nach zehn Attributen zählst du die Stimmen: Überwiegen die malignen Stimmen (oder sind gleich), sagst du maligne voraus.

Machine Learning Framework: Trainieren und Testen

Machine Learning klingt nach Robotern, aber hier ist es einfach: Aus alten Daten lernen, um neue Daten vorherzusagen. Damit du weißt, wie gut dein Klassifikator ist, teilst du die Daten in Training Set (80%) und Test Set (20%). Der Trainingssatz wird zum Lernen verwendet, der Testsatz zur Bewertung. So vermeidest du, dass der Algorithmus die Antworten schon kennt – ein klassischer Fehler, den auch KI-Apps wie ChatGPT vermeiden müssen.

Schritt-für-Schritt: Dein erster Klassifikator

1. Daten einlesen: make_training_set()

Die bereitgestellte Funktion make_training_set() liest die Datei cancerTrainingData.txt ein und erzeugt eine Liste von Dictionaries. Jedes Dictionary enthält 11 Einträge: ID, zehn Attribute (radius, texture, perimeter, area, smoothness, compactness, concavity, concave, symmetry, fractal) und die Klasse ('M' oder 'B'). Du musst nur die Attribute und die Klasse verwenden.

2. Mittelwerte berechnen

Iteriere über die Trainingsliste. Für jedes Attribut (z.B. 'area') sammelst du alle Werte von malignen Tumoren und berechnest den Durchschnitt. Das Gleiche für benigne. Nutze Dictionaries, um die Summen und Zähler zu speichern.

mal_sum = {attr: 0 for attr in attribute_list}
ben_sum = {attr: 0 for attr in attribute_list}
mal_count = 0
ben_count = 0
for record in training_set:
    if record['class'] == 'M':
        for attr in attribute_list:
            mal_sum[attr] += record[attr]
        mal_count += 1
    else:
        for attr in attribute_list:
            ben_sum[attr] += record[attr]
        ben_count += 1
mal_avg = {attr: mal_sum[attr]/mal_count for attr in attribute_list}
ben_avg = {attr: ben_sum[attr]/ben_count for attr in attribute_list}

3. Mittelpunkte berechnen (der Klassifikator)

Für jedes Attribut: midpoint = (mal_avg[attr] + ben_avg[attr]) / 2. Speichere diese Mittelpunkte in einem Dictionary.

4. Testen: Vorhersagen für den Testsatz

Für jeden Testdatensatz: Vergleiche für jedes Attribut den Wert mit dem Mittelpunkt. Zähle maligne und benigne Stimmen. Wenn maligne >= benigne, Vorhersage = 'M', sonst 'B'. Vergleiche mit der wahren Klasse und berechne die Genauigkeit.

correct = 0
total = len(test_set)
for record in test_set:
    mal_votes = 0
    ben_votes = 0
    for attr in attribute_list:
        if record[attr] >= midpoint[attr]:
            mal_votes += 1
        else:
            ben_votes += 1
    pred = 'M' if mal_votes >= ben_votes else 'B'
    if pred == record['class']:
        correct += 1
accuracy = correct / total

Warum dieser Ansatz? Einfach, aber wirkungsvoll

Dieser regelbasierte Klassifikator ist ein Paradebeispiel für überwachtes Lernen. Er ist leicht verständlich und zeigt, wie man mit Basiskenntnissen in Python und Datenstrukturen ein nützliches Modell baut. In der Praxis würdest du fortgeschrittene Algorithmen wie Random Forests oder neuronale Netze verwenden – aber das Prinzip ist dasselbe. Und genau diese Grundlagen brauchst du, um später KI-Apps zu entwickeln, die z.B. in der Finanzwelt Aktienkurse vorhersagen oder in der Spieleentwicklung Gegner steuern.

Häufige Fehler und Tipps

Daten nicht mischen: Stelle sicher, dass die Aufteilung in Trainings- und Testsatz zufällig erfolgt. Sonst kann die Genauigkeit verfälscht sein.
Falsche Attributliste: Verwende nur die zehn numerischen Attribute, nicht die ID oder Klasse.
Integer-Division: Achte in Python 3 darauf, dass du Gleitkommadivision verwendest (z.B. sum / count ergibt float).
Testdaten nicht trainieren: Verwende die Testdaten niemals zur Berechnung der Mittelwerte – das wäre Betrug!

Ausblick: Mehr als nur ein Studiumsprojekt

Dieses Assignment aus dem CSCI 141 Kurs (Frühjahr 2019) ist zeitlos. Heute, im Jahr 2026, nutzen Startups und Krankenhäuser ähnliche Ansätze, um personalisierte Medizin voranzutreiben. Mit deinem neu erworbenen Wissen kannst du dich an komplexere Projekte wagen – z.B. mit scikit-learn echte ML-Modelle trainieren. Der Code, den du hier schreibst, ist der erste Schritt in eine Karriere als Data Scientist oder KI-Ingenieur. Fang noch heute an!