predictive-maintenance

German Version

Beschreibung der Funktion `predict_time_to_failure` V7

Die Funktion predict_time_to_failure ist ein integraler Bestandteil eines Predictive-Maintenance-Systems, das die Zeit und den Kilometerstand bis zum nächsten Defekt basierend auf Anomalien in Sensordaten vorhersagt. Sie liefert Vorhersagen sowohl für einzelne Sensortypen als auch über alle Sensortypen hinweg, wobei die Gesamtvorhersage als verschachteltes Element in der Ergebnisstruktur enthalten ist. Dabei wird entweder ein klassisches lineares Regressionsmodell oder TensorFlow zur Modellierung und Vorhersage genutzt, je nach Konfiguration.

Zweck der Funktion

Analyse und Vorhersage: Identifizieren von Zeit- und Kilometerdifferenzen zwischen aufeinanderfolgenden Anomalien, um Vorhersagen über zukünftige Defekte zu treffen.
Flexibilität: Unterstützung sowohl von klassischen Modellen (lineare Regression) als auch von neuronalen Netzen (TensorFlow).

Funktion: `predict_anomalies`

Die Funktion predict_anomalies wurde erweitert, um kontinuierliches Lernen und Vorhersagen für Anomalien basierend auf Sensordaten zu ermöglichen. Hier eine zusammenfassende Beschreibung der Funktion und ihrer Funktionsweise:

Parameter

sensor_df (DataFrame): Sensordaten mit den Spalten:
- timestamp: Zeitstempel der Daten.
- sensorType: Typ des Sensors (z. B. Temperatur, Druck).
- anomaly: Markierung, ob die Daten als Anomalie eingestuft wurden (1 = Anomalie, 0 = normal).
- mileage: Kilometerstand zum Zeitpunkt der Daten.
results (dict): Ein Dictionary, das die Ergebnisse und Vorhersagen aufnimmt.
use_tensorflow (bool): Wenn True, wird TensorFlow für die Modellierung verwendet. Andernfalls wird lineare Regression verwendet.
model_dir (str): Verzeichnis zum Speichern und Laden von Modellen.

Funktionsweise

Initialisierung
- Ergebnisse für Anomalien (time_to_failure) werden in results vorbereitet.
- Überprüft, ob die notwendigen Spalten in sensor_df vorhanden sind. Fehlende Spalten führen zu einer Warnung.
Datenvorbereitung
- Konvertiert Zeitstempel (timestamp) in numerische Werte für maschinelles Lernen.
- Listet Anomalien-Timestamps und Kilometerstände für die Gesamtanalyse.
Modellaufbau
- TensorFlow-Modelle für Zeit- und Kilometerstands-Vorhersagen:
  - Architektur: Eingabe, drei versteckte Schichten mit 64-32-64 Neuronen, eine Ausgabeschicht.
  - Aktivierungsfunktionen: relu für die versteckten Schichten, linear für die Ausgabe.
  - Optimierung: adam, Verlustfunktion: mse.
Sensortyp-spezifische Analyse
- Iteriert über alle sensorType in sensor_df.
- Wählt nur Anomalien aus und berechnet Zeit- und Kilometerunterschiede zwischen den Anomalien.
- Lädt bestehende Modelle oder erstellt neue, wenn keine vorhanden sind.
- Trainiert die Modelle mit den Anomalien und speichert sie zur Wiederverwendung.
- Führt Vorhersagen durch und speichert geschätzte Werte (time_prediction, mileage_prediction).
Gesamtanalyse
- Über alle Sensortypen hinweg:
  - Berechnet Zeit- und Kilometerdifferenzen für alle Anomalien.
  - Modelle werden erneut trainiert oder geladen, um die Gesamtvorhersagen durchzuführen.
- Speichert die geschätzte Zeit und den Kilometerstand bis zur nächsten Anomalie.
Rückgabe
- Ergebnisse für jeden Sensortyp und die Gesamtanalyse werden zu results hinzugefügt, einschließlich:
  - Vorhergesagte Zeit bis zur nächsten Anomalie.
  - Vorhergesagter Kilometerstand bis zur nächsten Anomalie.
  - R²-Score für die Modelle (nicht verfügbar in TensorFlow).

Verbesserungen in der aktuellen Version

Kontinuierliches Lernen:
- Modelle speichern und wiederverwenden (.keras-Dateien).
- Zusätzliche Trainingsdaten führen zur Verbesserung bestehender Modelle.
Skalierbarkeit:
- Unterstützt mehrere Sensortypen und Gesamtvorhersagen.
Flexible Backend-Optionen:
- Unterstützt sowohl TensorFlow als auch lineare Regression für mehr Flexibilität.

Beispiel für die Ergebnisse

Die Ergebnisse werden wie folgt in results gespeichert:

"time_to_failure": {
    "anomaly": [
        {
            "sensor_type": "temperature",
            "prediction": {
                "estimated_time": 3600.0,
                "estimated_mileage": 120.5,
                "r2_score_time": 0.85,
                "r2_score_mileage": 0.88,
                "use_tensorflow": true
            }
        },
        {
            "overall_estimated_time": 5400.0,
            "overall_estimated_mileage": 200.3,
            "overall_r2_score_time": 0.87,
            "overall_r2_score_mileage": 0.90,
            "use_tensorflow": true
        }
    ]
}

Potenzielle Erweiterungen

Hyperparameter-Optimierung:
- Automatisiere die Auswahl der besten Modellparameter.
Integration mit anderen ML-Frameworks:
- Experimentiere mit XGBoost oder PyTorch für alternative Vorhersagemethoden.
Feature Engineering:
- Zusätzliche Merkmale wie Wetterdaten oder Fahrerprofile könnten die Vorhersagen verbessern.

Überarbeitete Version der `build_ttf_model`-Funktion

Empfohlene Kombination um Dead Neurons zu vermeiden und die Stabilität des Trainings zu erhöhen:

def build_ttf_model(input_dim):
    model = Sequential([
        Input(shape=(input_dim,)),  # Definiere die Eingabeform explizit

        # Erste Dense-Schicht mit He-Initialisierung, LeakyReLU und Batch-Normalisierung
        Dense(64, kernel_initializer='he_normal', kernel_regularizer=l2(0.001)),  # He-Initialisierung und L2-Regularisierung
        LeakyReLU(alpha=0.01),  # Aktivierungsfunktion: LeakyReLU
        BatchNormalization(),  # Batch-Normalisierung
        Dropout(0.3),  # Dropout zur Reduktion von Overfitting

        # Zweite Dense-Schicht mit ähnlichen Maßnahmen
        Dense(32, kernel_initializer='he_normal', kernel_regularizer=l2(0.001)),
        LeakyReLU(alpha=0.01),
        BatchNormalization(),
        Dropout(0.3),

        # Dritte Dense-Schicht
        Dense(64, kernel_initializer='he_normal', kernel_regularizer=l2(0.001)),
        LeakyReLU(alpha=0.01),
        BatchNormalization(),
        Dropout(0.3),

        # Ausgabeschicht (1 Neuron für Regressionsoutput)
        Dense(1, activation='linear')  # Keine Aktivierung für kontinuierliche Werte
    ])

    # Adam-Optimizer mit Gradient Clipping zur Vermeidung von Exploding Gradients
    optimizer = Adam(clipnorm=1.0)

    # Kompilieren des Modells
    model.compile(optimizer=optimizer, loss='mse', metrics=['mae'])

    return model

Erklärung der Änderungen

Initialisierung der Gewichte:
- kernel_initializer='he_normal': Optimiert für ReLU- und LeakyReLU-ähnliche Aktivierungen.
Aktivierungsfunktion:
- LeakyReLU(alpha=0.01): Ermöglicht Gradientenfluss bei negativen Werten und reduziert Dead Neurons.
Batch-Normalisierung:
- Nach jeder Dense-Schicht, um die Verteilung der Aktivierungen zu stabilisieren.
Dropout:
- Dropout(0.3): Verhindert Overfitting, indem zufällig 30 % der Neuronen deaktiviert werden.
L2-Regularisierung:
- kernel_regularizer=l2(0.001): Bestraft große Gewichte, fördert allgemeineres Lernen.
Gradient Clipping:
- clipnorm=1.0: Begrenzt den Gradientennormwert, um Exploding Gradients zu verhindern.
Ausgabeschicht:
- Dense(1, activation='linear'): Linear, da es sich um eine Regressionsaufgabe handelt (kontinuierliche Zeitvorhersage).

Warum diese Kombination?

LeakyReLU und Batch-Normalisierung minimieren das Risiko von Dead Neurons.
Dropout und L2-Regularisierung verbessern die Verallgemeinerungsfähigkeit des Modells.
Gradient Clipping stabilisiert das Training bei extremen Gradienten.

Diese Architektur ist stabil und speziell für Regressionsaufgaben mit Zeitwerten geeignet.

Lizenz

Autor: Jörg Harzmann

Dieser Inhalt ist unter einer CC BY-NC Lizenz veröffentlicht. Jeglicher Quellcode ist urheberrechtlich geschützt!