Bug Severity Prediction in Software Projects Using Supervised Machine Learning Models

Diese Studie vergleicht verschiedene überwachte maschinelle Lernmodelle zur Vorhersage von Fehler-Schweregraden in Softwareprojekten anhand historischer Eclipse-Bugzilla-Daten und stellt fest, dass Ensemble-Methoden sowie DistilBERT die höchste Gesamtgenauigkeit erreichen, während lineare Modelle bei der Erkennung kritischer Fehler überlegen sind.

Das Wesentliche

🐞 Das große Problem: Der Berg an Beschwerden

Stell dir vor, du leitest ein riesiges Software-Unternehmen (wie Eclipse). Jeden Tag kommen Tausende von Beschwerden bei dir ein. Ein Kunde sagt: "Der Drucker druckt nicht!" (Kleinigkeit), ein anderer schreit: "Mein ganzer Bankaccount wurde gestohlen!" (Katastrophe).

Das Problem: Niemand hat Zeit, jeden Zettel einzeln zu lesen und zu entscheiden, was zuerst erledigt werden muss.

• Wenn du die kleinen Dinge zuerst machst, brennt das Haus ab, während du die Tapete wechselst.
• Wenn du die großen Dinge übersehest, ist das System kaputt.
• Menschen sind müde, machen Fehler und haben unterschiedliche Meinungen darüber, wie "schlimm" ein Fehler eigentlich ist.

🤖 Die Lösung: Der digitale Sortier-Roboter

Die Studentin Nafisha Tamanna Nice hat sich gedacht: "Warum lassen wir nicht einen Computer das tun?" Sie hat verschiedene Künstliche Intelligenzen (KI) trainiert, um diese Fehlerberichte zu lesen und sofort zu sagen: "Das ist eine Katastrophe!" oder "Das kann warten."

Sie hat sich nicht auf einen Roboter verlassen, sondern hat 10 verschiedene Kandidaten getestet, ähnlich wie ein Koch, der 10 verschiedene Rezepte probiert, um das beste zu finden.

🥊 Der Wettkampf: Wer ist der Beste?

Die Kandidaten waren eine bunte Mischung aus verschiedenen Denkweisen:

1. Die Klassiker (z. B. Logistische Regression): Das sind wie erfahrene, alte Handwerker. Sie sind nicht die Schnellsten, aber sie sind sehr vorsichtig. Wenn sie sagen "Das ist gefährlich", dann ist es das auch. Sie verpassen selten eine echte Gefahr, auch wenn sie manchmal etwas zu viel Alarm schlagen.
2. Die Power-Teams (z. B. XGBoost, CatBoost): Das sind wie ein Team von Super-Experten, die gemeinsam arbeiten. Sie sind extrem schnell und haben eine sehr hohe Trefferquote bei der Gesamtzahl der Fehler. Sie sind wie ein gut geölter Rennwagen.
3. Der Sprachgenie (DistilBERT): Das ist der modernste Kandidat. Er versteht nicht nur die Wörter, sondern auch den Kontext und die Nuancen, genau wie ein menschlicher Muttersprachler. Er liest die Beschwerden und versteht sofort, ob jemand panisch ist oder nur genervt.

🏆 Das Ergebnis: Wer gewinnt?

Nachdem alle Kandidaten gegen einen riesigen Haufen alter Fehlerberichte (das "Eclipse-Bugzilla-Dataset") getestet wurden, ergab sich folgendes Bild:

• Der Gesamtsieger (Genauigkeit): Der DistilBERT (der Sprachgenie) und XGBoost (das Power-Team) waren die besten. Sie haben die meisten Fehler insgesamt richtig eingestuft. Sie sind wie die effizientesten Sortiermaschinen im Lager.
• Der Retter (Sicherheits-Check): Wenn es darum ging, wirklich gefährliche Fehler zu finden und nichts zu übersehen, war die Logistische Regression (der alte Handwerker) am besten. Sie war zwar etwas langsamer, aber sie hat fast keine Katastrophe übersehen.

Die wichtige Lektion: Es gibt nicht den einen perfekten Roboter.

• Willst du Geschwindigkeit und Genauigkeit bei allem? Nimm den DistilBERT oder XGBoost.
• Willst du absolute Sicherheit, dass keine Katastrophe übersehen wird (auch wenn du ein paar Kleinigkeiten falsch einordnest)? Nimm die Logistische Regression.

🛠️ Wie hat sie das geschafft? (Die Magie hinter den Kulissen)

Damit die Roboter lernen konnten, musste die Studentin erst einmal das "Lager" aufräumen:

• Daten-Säubern: Viele Fehlerberichte waren unvollständig oder in einer anderen Sprache. Sie hat sie bereinigt.
• Das "Ungleichgewicht"-Problem: In der Realität gibt es viel mehr kleine Fehler als große Katastrophen. Wenn man einen Roboter nur mit kleinen Fehlern trainiert, lernt er nie, Katastrophen zu erkennen. Die Studentin hat dem Roboter künstlich mehr Beispiele für Katastrophen gegeben (eine Technik namens SMOTE), damit er sie ernst nimmt.
• Wort-Analyse: Sie hat dem Roboter beigebracht, auf bestimmte Schlüsselwörter zu achten, die auf Panik hindeuten.

🌍 Warum ist das wichtig für uns alle?

Das klingt nach trockener Technik, hat aber massive Auswirkungen auf unser tägliches Leben:

1. Sicherheit: Stell dir vor, dieses System würde in einem Krankenhaus oder bei einer Bank laufen. Es würde sicherstellen, dass ein Fehler, der Leben oder Geld gefährdet, sofort behoben wird, bevor er passiert.
2. Zeitersparnis: Entwickler müssen nicht mehr stundenlang durch Listen wühlen. Der Roboter sortiert für sie. Das bedeutet, Software wird schneller fertig und ist stabiler.
3. Umwelt: Weniger Zeit am Computer bedeutet weniger Stromverbrauch. Effiziente Software bedeutet weniger Verschwendung von Ressourcen.

Fazit

Diese Arbeit zeigt uns, dass wir nicht mehr blind durch den Dschungel von Software-Fehlern laufen müssen. Mit der richtigen KI können wir wie ein erfahrener Feuerwehrmann agieren: Wir wissen genau, wohin wir zuerst laufen müssen, um das größte Feuer zu löschen, während wir die kleinen Rauchschwaden ignorieren können.

Die Zukunft der Software-Entwicklung liegt nicht darin, mehr Menschen zu beschäftigen, sondern darin, die richtigen digitalen Assistenten an die richtige Stelle zu setzen.

Technische Zusammenfassung

Technische Zusammenfassung: Vorhersage von Bug-Schweregraden in Softwareprojekten mittels überwachter Machine-Learning-Modelle

Autorin: Nafisha Tamanna Nice
Institution: Daffodil International University, Dhaka, Bangladesch
Datum: Dezember 2025

---

1. Problemstellung (Problem Statement)

In großen Softwareprojekten wachsen Bug-Repositories (Fehlerdatenbanken) extrem schnell an. Die manuelle Klassifizierung der Schweregrade (Severity) von Fehlern – von „trivial" bis „kritisch" – ist aufgrund des hohen Aufwands, menschlicher Verzerrungen (Bias) und Inkonsistenzen zwischen verschiedenen Entwicklern unzuverlässig und ineffizient. Eine falsche Priorisierung kann zu Verzögerungen, Sicherheitslücken und einer Verschlechterung der Softwarequalität führen. Es besteht ein dringender Bedarf an automatisierten, skalierbaren Lösungen, die historische Daten nutzen, um die Schwere von Fehlern präzise vorherzusagen und Entwicklern bei der Triage (Priorisierung) zu helfen.

2. Methodik (Methodology)

Die Studie verfolgt einen vergleichenden Ansatz, um verschiedene überwachte Machine-Learning-Algorithmen für die Klassifizierung von Bug-Schweregraden zu evaluieren.

• Datengrundlage:
  • Quelle: Eclipse Bugzilla-Dataset (via Hugging Face).
  • Umfang: 88.682 Bug-Reports.
  • Merkmale (Features): Textuelle Beschreibungen („Short_Description"), Metadaten (Projekt, Bug-Typ, Priorität) und die Zielvariable „Severity_Label" (z. B. trivial, normal, critical).
• Datenvorverarbeitung (Preprocessing):
  • Bereinigung: Behandlung fehlender Werte (Imputation durch Mittelwert/Modus).
  • Kodierung: Label-Encoding und One-Hot-Encoding für kategorische Variablen.
  • Text-Verarbeitung: Tokenisierung, Lowercasing und Padding für Transformer-Modelle; TF-IDF (Term Frequency-Inverse Document Frequency) und N-Gramme für traditionelle Modelle.
  • Klassenungleichgewicht (Imbalance): Anwendung von SMOTE (Synthetic Minority Over-sampling Technique) und Klassen-Gewichtung, da kritische Bugs in der Realität seltener vorkommen als geringfügige Fehler.
  • Aufteilung: 80 % Trainingsdaten, 20 % Testdaten.
• Evaluierte Algorithmen (10 Modelle):
  • Lineare Modelle: Logistic Regression, Linear SVM, Passive Aggressive, SGD.
  • Baum-basierte Ensemble-Methoden: XGBoost, LightGBM, CatBoost.
  • Probabilistische & Distanz-basierte: Naive Bayes, K-Nearest Neighbors (KNN).
  • Deep Learning / Transformer: DistilBERT (für textbasierte Klassifizierung).
• Validierung: 3-fache Kreuzvalidierung (K-Fold Cross-Validation) und Evaluation mittels Accuracy, Precision, Recall, F1-Score, AUC-ROC und Konfusionsmatrizen.

3. Wichtige Beiträge und Ergebnisse (Key Contributions & Results)

Die Studie liefert einen umfassenden Vergleich traditioneller ML-Modelle mit modernen Transformer-Architekturen im Kontext der Software-Wartung.

• Gesamtgenauigkeit (Accuracy):
  • DistilBERT erzielte die höchste Gesamtgenauigkeit mit 90,48 %.
  • Gefolgt von XGBoost (90,41 %) und CatBoost (90,17 %).
  • Dies zeigt, dass Transformer-Modelle und Gradient-Boosting-Ensembles für die komplexe Textanalyse von Bug-Berichten überlegen sind.
• Erkennung kritischer Bugs (Recall & Precision):
  • Logistic Regression zeigte die beste Recall-Rate (0,627) für hochkritische Bugs. Obwohl die Gesamtgenauigkeit niedriger ist, ist dieses Modell am besten geeignet, um kritische Fehler zu finden (minimiert False Negatives), was für die Priorisierung entscheidend ist.
  • Naive Bayes erreichte die höchste Precision (0,845), was bedeutet, dass es bei der Vorhersage eines „kritischen" Bugs am wenigsten falsch positive Ergebnisse liefert.
• Einfluss der Vorverarbeitung:
  • Die Kombination aus SMOTE (zum Ausgleich des Klassenungleichgewichts) und TF-IDF/Text-Features war essenziell für die Leistungsfähigkeit aller Modelle. Ohne diese Schritte neigten die Modelle dazu, die Mehrheitsklasse (geringe Schwere) zu bevorzugen.
• Generalisierung:
  • Während die Modelle auf dem Eclipse-Dataset gut abschnitten, wurde festgestellt, dass die Wahl des Modells stark von den Projektzielen abhängt (z. B. hohe Genauigkeit vs. hohe Recall-Rate für kritische Fehler).

4. Bedeutung und Implikationen (Significance)

• Softwarequalität und Effizienz: Durch die Automatisierung der Bug-Triage können Entwicklungsteams Ressourcen gezielt auf kritische Probleme lenken, was Ausfallzeiten reduziert und die Softwarestabilität erhöht.
• Skalierbarkeit: Die vorgeschlagenen Modelle ermöglichen eine skalierbare Priorisierung auch in sehr großen Open-Source-Projekten, wo manuelle Prozesse an ihre Grenzen stoßen.
• Praktische Anwendung: Die Ergebnisse bieten Entwicklern und Projektmanagern eine datengestützte Entscheidungsgrundlage:
  • Für maximale Präzision (wenige Fehlalarme) eignen sich Naive Bayes oder XGBoost.
  • Für maximale Abdeckung kritischer Fehler (Vermeidung von übersehenen Bugs) ist Logistic Regression vorzuziehen.
• Zukunftsausblick: Die Arbeit schlägt vor, hybride Modelle (Kombination aus Interpretierbarkeit und Deep Learning) zu erforschen und die Modelle in Echtzeit-Integrationen (z. B. in Jira oder Bugzilla) einzubinden. Zudem wird die Notwendigkeit betont, Modelle erklärbar (Explainable AI) zu gestalten, um das Vertrauen der Entwickler zu stärken.

Fazit: Die Studie demonstriert erfolgreich, dass überwachte Machine-Learning-Modelle, insbesondere Transformer-Architekturen wie DistilBERT und Ensemble-Methoden wie XGBoost, die manuelle Bug-Schweregrad-Vorhersage erheblich verbessern können. Die Wahl des optimalen Algorithmus hängt jedoch vom spezifischen Ziel des Softwareprojekts ab (Genauigkeit vs. Sensitivität gegenüber kritischen Fehlern).