Burnout-Erkennung: Git-Commit-Muster mit Python analysieren

Als Entwickler ist unser Leben in der Git-Historie geschrieben. Jeder Commit erzählt eine Geschichte von einem gelösten Problem, einer implementierten Funktion oder einem behobenen Fehler. Aber was, wenn dieselben Commits eine andere Geschichte erzählen könnten – eine über unser Wohlbefinden? In der Tech-Branche ist Burnout ein allgegenwärtiges Problem. Der „lustlose Commit", bei dem Sie Code einchecken, aber kein Gefühl der Erfüllung empfinden, ist ein reales Phänomen.

Dieses Tutorial verfolgt einen einzigartigen, entwicklerzentrierten Ansatz für psychisches Wohlbefinden. Wir werden ein Python-Skript erstellen, das Ihre GitHub-Commit-Historie nutzt, um Muster zu identifizieren, die auf ein Burnout-Risiko hindeuten könnten. Durch die Analyse von Daten wie Commit-Häufigkeit, Commit-Nachrichtenlänge und der Uhrzeit, zu der Sie Code einchecken, können wir ein Modell erstellen, das Ihr „Normal" erlernt und potenzielle Abweichungen markiert.

Voraussetzungen:

• Python 3.7+ installiert.
• Vertrautheit mit Python, einschließlich der Installation von Paketen mit pip.
• Ein GitHub-Konto mit Commit-Historie.
• Grundlegendes Verständnis von Pandas und Konzepten des maschinellen Lernens ist hilfreich, aber nicht erforderlich.

Warum dies für Entwickler relevant ist:

Es geht hier nicht darum, einen perfekten Burnout-Prädiktor zu erstellen. Es geht darum, die Werkzeuge, die wir täglich nutzen, für Selbstreflexion einzusetzen. Indem wir eine Lupe auf unsere eigenen Daten richten, können wir beginnen, wichtige Fragen über Work-Life-Balance und psychische Gesundheit zu stellen.

Das Problem verstehen

Burnout bei Entwicklern ist oft ein schleichender Prozess. Es kann sich als Veränderung in Arbeitsmustern manifestieren, lange bevor es bewusst erkannt wird. Einige potenzielle Indikatoren in Git-Daten könnten sein:

• Nächtliche Commits: Eine plötzliche Zunahme von Commits außerhalb der normalen Arbeitszeiten.
• Unregelmäßige Commit-Häufigkeit: Schwanken zwischen Phasen intensiver Aktivität und Funkstille.
• Kurze, nicht aussagekräftige Commit-Nachrichten: Ein potenzielles Zeichen für Desengagement oder Hetze.
• Rückgang des Commit-Volumens: Obwohl nicht immer negativ, könnte ein signifikanter Rückgang auf mangelnde Motivation hindeuten.

Wir werden dies als Klassifizierungsproblem behandeln. Wir werden historische Daten beschriften (z.B. „normal" vs. „Burnout"-Phasen, basierend auf unserer eigenen Erinnerung) und ein Modell des maschinellen Lernens trainieren, um die mit jedem Zustand verbundenen Muster zu erkennen.

Voraussetzungen

Zunächst richten wir unsere Umgebung ein. Sie benötigen ein persönliches GitHub-Zugriffstoken, um deren API zu nutzen.

1. Generieren Sie ein persönliches GitHub-Zugriffstoken:

   • Gehen Sie zu Ihren GitHub-Einstellungen > Entwicklereinstellungen > Persönliche Zugriffstokens.
   • Klicken Sie auf „Neues Token generieren".
   • Geben Sie ihm einen beschreibenden Namen (z.B. „Burnout-Detektor").
   • Wählen Sie unter „Bereiche" den repo-Bereich. Dies gewährt Ihnen Lesezugriff auf Ihre Repositorys.
   • Klicken Sie auf „Token generieren" und kopieren Sie es an einen sicheren Ort. Sie werden es nicht erneut sehen können.

2. Python-Bibliotheken installieren:

   pip install requests pandas scikit-learn matplotlib seaborn
   

Schritt 1: Ihre Commit-Historie abrufen

Was wir tun

Wir werden die requests-Bibliothek verwenden, um eine Verbindung zur GitHub-API herzustellen und die Commit-Historie für ein bestimmtes Repository abzurufen.

Implementierung

Erstellen Sie eine neue Python-Datei, burnout_detector.py.

# burnout_detector.py
import requests
import pandas as pd
import os

# --- Konfiguration ---
GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN') # Best Practice: Umgebungsvariablen verwenden
REPO_OWNER = 'your-github-username'
REPO_NAME = 'your-repo-name'
# ---------------------

def fetch_all_commits(owner, repo, token):
    """Ruft alle Commits für ein bestimmtes Repository ab."""
    commits = []
    page = 1
    per_page = 100
    headers = {'Authorization': f'token {token}'}
    
    while True:
        url = f'https://api.github.com/repos/{owner}/{repo}/commits?page={page}&per_page={per_page}'
        response = requests.get(url, headers=headers)
        
        if response.status_code != 200:
            print(f"Fehler: {response.status_code}")
            print(response.json())
            break
            
        data = response.json()
        if not data:
            break
            
        commits.extend(data)
        page += 1
        
    return commits

# --- Hauptausführung ---
if __name__ == '__main__':
    if not GITHUB_TOKEN:
        raise ValueError("Bitte setzen Sie die Umgebungsvariable GITHUB_TOKEN.")
        
    print(f"Rufe Commits für {REPO_OWNER}/{REPO_NAME} ab...")
    all_commits = fetch_all_commits(REPO_OWNER, REPO_NAME, GITHUB_TOKEN)
    print(f"{len(all_commits)} Commits gefunden.")

    # In DataFrame konvertieren für einfachere Manipulation
    df = pd.json_normalize(all_commits)
    print(df.head())

Bevor Sie es ausführen:

• Ersetzen Sie 'your-github-username' und 'your-repo-name' durch Ihre Angaben.
• Setzen Sie das GITHUB_TOKEN als Umgebungsvariable aus Sicherheitsgründen:
  • Mac/Linux: export GITHUB_TOKEN='your_token_here'
  • Windows: set GITHUB_TOKEN='your_token_here'

Führen Sie das Skript aus: python burnout_detector.py

Wie es funktioniert

Wir senden paginierte GET-Anfragen an den GitHub Commits API-Endpunkt. Die while True-Schleife продолжает fetchen, bis die API eine leere Liste zurückgibt. Wir verwenden dann pandas.json_normalize, um die verschachtelte JSON-Antwort in ein DataFrame zu flatten – eine tabellenartige Struktur, die perfekt für die Datenanalyse geeignet ist.

Schritt 2: Feature-Engineering mit Pandas

Was wir tun

„Feature-Engineering" ist der Prozess, aussagekräftige Eingabevariablen (Features) für unser Modell des maschinellen Lernens aus den Rohdaten zu erstellen. Wir werden Pandas verwenden, um Features zu erstellen, die mit Burnout korrelieren könnten.

Implementierung

Fügen Sie die folgenden Funktionen zu Ihrem Skript hinzu:

# ... (vorherigen Code behalten)

def create_features(df):
    """Erstellt Features aus den Roh-Commit-Daten."""
    # Relevante Spalten auswählen und umbenennen
    df = df[['sha', 'commit.author.date', 'commit.message']].rename(columns={
        'commit.author.date': 'timestamp',
        'commit.message': 'message'
    })

    # Zeitstempel in datetime-Objekte konvertieren und als Index setzen
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df = df.set_index('timestamp')

    # Feature 1: Stunde des Tages
    df['hour'] = df.index.hour

    # Feature 2: Wochentag (0=Montag, 6=Sonntag)
    df['day_of_week'] = df.index.dayofweek

    # Feature 3: Commit-Nachrichtenlänge
    df['message_length'] = df['message'].apply(len)
    
    # Feature 4: Commits pro Tag
    commits_per_day = df.resample('D').size().rename('commits_on_day')
    df = df.join(commits_per_day, on=df.index.date)

    return df

# --- Hauptausführung ---
if __name__ == '__main__':
    # ... (Abrufcode bleibt gleich)
    
    df_raw = pd.json_normalize(all_commits)
    
    if df_raw.empty:
        print("Keine Commits gefunden.")
    else:
        df_features = create_features(df_raw.copy())
        print("\
--- Features ---")
        print(df_features.head())

Wie es funktioniert

1. Zeitstempelkonvertierung: Wir konvertieren die timestamp-Spalte in ein ordnungsgemäßes Datumsformat, das zeitbasierte Operationen ermöglicht.
2. Zeitbasierte Features: Wir extrahieren die hour und day_of_week direkt aus dem Datumsindex. Dies hilft uns, Muster wie konsistente Nachtarbeit oder Wochenendarbeit zu erkennen.
3. Nachrichtenlänge: Wir berechnen die Länge jeder Commit-Nachricht.
4. Resampling: Die Funktion resample('D').size() ist eine leistungsstarke Pandas-Zeitreihenfunktion. Sie gruppiert die Commits nach Tag (D) und zählt, wie viele in jeder Gruppe aufgetreten sind, was uns die tägliche Commit-Häufigkeit liefert. Wir verbinden diese Informationen dann mit join zurück zu unserem Haupt-DataFrame.

Schritt 3: Beschriftung der Daten (Das menschliche Element)

Was wir tun

Dies ist der subjektivste, aber entscheidendste Teil. Wir müssen eine „Zielvariable" erstellen – eine Beschriftung, die unserem Modell mitteilt, welche Perioden „Burnout" und welche „normal" darstellen. Da wir kein externes Maß für Burnout haben, müssen wir unsere eigenen Beschriftungen basierend auf unserer Erinnerung an vergangene Projekte erstellen.

Implementierung

Dies wird einzigartig für Sie sein. Das Ziel ist es, eine neue Spalte is_burnout zu erstellen, mit 1 für Perioden, an die Sie sich als stressig erinnern oder die zu Burnout geführt haben, und 0 für normale Perioden.

# ... (vorherigen Code behalten)

def label_data(df):
    """Beschriftet Daten basierend auf bekannten Burnout-Perioden."""
    df['is_burnout'] = 0 # Standard: 'normal'
    
    # --- !!! DIESER TEIL MUSS VON IHNEN ANGEPASST WERDEN !!! ---
    # Beispiel: Eine bestimmte Datumsspanne als 'Burnout'-Periode markieren
    burnout_start = '2023-10-01'
    burnout_end = '2023-10-31'
    df.loc[burnout_start:burnout_end, 'is_burnout'] = 1

    # Beispiel: Eine weitere stressige Periode markieren
    # burnout_start_2 = '2024-03-15'
    # burnout_end_2 = '2024-04-05'
    # df.loc[burnout_start_2:burnout_end_2, 'is_burnout'] = 1
    
    return df

# --- Hauptausführung ---
if __name__ == '__main__':
    # ...
    else:
        df_features = create_features(df_raw.copy())
        df_labeled = label_data(df_features.copy())
        
        print("\
--- Beschriftete Daten ---")
        # Überprüfen Sie die Verteilung Ihrer Beschriftungen
        print(df_labeled['is_burnout'].value_counts())
        
        # Einige der beschrifteten Daten anzeigen
        print(df_labeled[df_labeled['is_burnout'] == 1].head())

Wie es funktioniert

Denken Sie an bestimmte Projekte oder Deadlines zurück, die besonders belastend waren. Verwenden Sie Datumsbereichs-Slicing mit .loc, um der is_burnout-Spalte für diese Zeiträume eine 1 zuzuweisen. Seien Sie ehrlich! Die Qualität Ihres Modells hängt vollständig von der Qualität Ihrer Beschriftungen ab.

Häufige Falle: Versuchen Sie, ein vernünftiges Gleichgewicht zwischen 0s und 1s zu haben. Wenn Sie nur wenige Tage als Burnout markieren, wird das Modell Schwierigkeiten haben zu lernen.

Schritt 4: Trainieren eines Klassifizierungsmodells

Was wir tun

Jetzt kommt das maschinelle Lernen! Wir werden scikit-learn verwenden, um einen RandomForestClassifier zu trainieren. Dieses Modell ist ein „Ensemble" von Entscheidungsbäumen, was es robust macht und gut darin, komplexe Muster zu finden.

Implementierung

# ... (Importe oben hinzufügen)
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt


# ... (neue Funktion hinzufügen)
def train_model(df):
    """Trainiert ein Modell zur Vorhersage von Burnout basierend auf Commit-Features."""
    # Features (X) und Ziel (y) definieren
    features = ['hour', 'day_of_week', 'message_length', 'commits_on_day']
    X = df[features]
    y = df['is_burnout']

    # Daten in Trainings- und Testsets aufteilen
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42, stratify=y
    )
    
    # Random Forest Classifier initialisieren und trainieren
    model = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')
    model.fit(X_train, y_train)
    
    # Vorhersagen auf dem Testset machen
    y_pred = model.predict(X_test)
    
    # Modell evaluieren
    print("\
--- Modellbewertung ---")
    print(f"Genauigkeit: {accuracy_score(y_test, y_pred):.2f}")
    print("\
Klassifizierungsbericht:")
    print(classification_report(y_test, y_pred))
    
    # Feature-Wichtigkeiten visualisieren
    feature_imp = pd.Series(model.feature_importances_, index=features).sort_values(ascending=False)
    
    plt.figure(figsize=(10, 6))
    sns.barplot(x=feature_imp, y=feature_imp.index)
    plt.xlabel('Feature-Wichtigkeit')
    plt.ylabel('Features')
    plt.title("Visualisierung wichtiger Features")
    plt.show()

    return model

# --- Hauptausführung ---
if __name__ == '__main__':
    # ...
    else:
        df_features = create_features(df_raw.copy())
        df_labeled = label_data(df_features.copy())
        
        if df_labeled['is_burnout'].sum() > 0:
            train_model(df_labeled)
        else:
            print("\
Modelltraining übersprungen: Keine Daten als 'Burnout' beschriftet.")

Wie es funktioniert

1. Datenteilung: Wir teilen unsere beschrifteten Daten in ein Trainingsset (70%) und ein Testset (30%). Das Modell lernt aus dem Trainingsset und wird dann auf dem ungesehenen Testset evaluiert, um seine Leistung in der Praxis einzuschätzen.
2. Training: model.fit(X_train, y_train) ist der Moment, in dem die Magie geschieht. Der Random-Forest-Algorithmus analysiert die Features in den Trainingsdaten, um die Muster zu finden, die am besten zwischen „normalen" und „Burnout"-Commits unterscheiden. class_weight='balanced' weist das Modell an, mehr attention auf die Minderheitsklasse (normalerweise die „Burnout"-Klasse) zu legen, was bei unausgeglichenen Datensätzen wichtig ist.
3. Bewertung: Wir verwenden einen Klassifizierungsbericht, um zu sehen, wie gut das Modell abgeschnitten hat.
4. Feature-Wichtigkeit: Das Diagramm zeigt uns, welche Features das Modell als am meisten prädiktiv empfand. Das ist unglaublich aufschlussreich! Sie könnten feststellen, dass hour und commits_on_day die stärksten Indikatoren in Ihren persönlichen Daten sind.

Alternative Ansätze

• Logistische Regression: Ein einfacheres, interpretierbareres Modell. Es ist ein guter Ausgangspunkt für Vergleiche. Sie können RandomForestClassifier durch LogisticRegression aus sklearn.linear_model ersetzen.
• Zeitreihen-Anomalieerkennung: Anstatt Klassifizierung könnten Sie dies als Anomalieerkennungsproblem behandeln, bei dem Sie Ihr „normales" Verhalten modellieren und signifikante Abweichungen markieren.
• Sentimentanalyse: Analysieren Sie den Text der Commit-Nachrichten auf Veränderungen im Sentiment im Zeitverlauf. Positives Sentiment in Commit-Nachrichten kann mit einem gesünderen Arbeitsumfeld korrelieren.

Fazit

Wir haben erfolgreich ein Werkzeug entwickelt, das unseren eigenen digitalen Fußabdruck nutzt, um Selbstreflexion und psychisches Wohlbefinden zu fördern. Sie haben gelernt, wie Sie:

1. Daten von der GitHub-API mit Python abrufen.
2. Feature-Engineering auf Zeitreihendaten mit Pandas durchführen.
3. Daten für eine überwachte Aufgabe des maschinellen Lernens beschriften.
4. Ein Klassifizierungsmodell mit Scikit-learn trainieren und evaluieren.

Dieses Projekt ist ein Ausgangspunkt. Die wahre Kraft liegt darin, es an Ihre eigenen Lebens- und Arbeitsmuster anzupassen. Nutzen Sie die Feature-Wichtigkeitsgrafik, um Ihre persönlichen Auslöser und Gewohnheiten zu verstehen. Denken Sie daran, dass das Ziel kein perfektes Alarmsystem ist, sondern ein datengestützter Spiegel, der Ihnen hilft, auf Ihre psychische Gesundheit zu achten.

Nächste Schritte:

• Analysieren Sie Commits über alle Ihre Repositorys hinweg.
• Stellen Sie dieses Skript so ein, dass es automatisch läuft (z.B. einmal pro Woche) und Ihnen eine Zusammenfassung sendet.
• Experimentieren Sie mit verschiedenen Features, wie der Zeit zwischen Commits oder der Anzahl der geänderten Dateien.

Ressourcen

• GitHub API-Dokumentation: https://docs.github.com/en/rest/commits/commits
• Pandas Zeitreihen-/Datumsfunktionalität: https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
• Scikit-learn RandomForestClassifier: https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html

Kurzübersicht

Häufig gestellte Fragen

F: Wie weiß ich, ob dies auf mich zutrifft? A: Besprechen Sie Ihre persönliche und familiäre Krankengeschichte mit Ihrem Arzt, um Ihre individuellen Risikofaktoren einzuschätzen und geeignete nächste Schritte zu bestimmen.

F: Was sollte ich meinen Arzt fragen? A: Gute Fragen sind: „Was bedeuten meine Ergebnisse?", „Was sind meine Optionen?", „Welche Lebensstiländerungen würden helfen?" und „Wann sollte ich nachuntersuchen lassen?"

F: Gibt es Lebensstiländerungen, die helfen können? A: Die meisten Gesundheitszustände profitieren von grundlegenden Maßnahmen: ausgewogene Ernährung, regelmäßige körperliche Aktivität (150+ Minuten/Woche), qualitativ hochwertiger Schlaf (7-9 Stunden), Stressmanagement und Vermeidung von Tabak.

Haftungsausschluss

Dieser Artikel dient nur zu Bildungszwecken und stellt keine medizinische Beratung dar. Konsultieren Sie immer einen qualifizierten Gesundheitsdienstleister, bevor Sie Entscheidungen über Ihre Gesundheit, Behandlung oder Pflege treffen. Individuelle Umstände variieren, und was für eine Person angemessen ist, ist möglicherweise nicht für eine andere geeignet.

Wenn Sie einen medizinischen Notfall haben, rufen Sie sofort 911 (oder Ihre örtliche Notrufnummer) an.