predictive-maintenance

German Version

Beispiel einer Routine (Python) für Maschinelles Lernen von Betriebsdaten bei Fahrzeugen

Nachfolgend ein Beispiel für eine Routine, die für maschinelles Lernen im Kontext der prädiktiven Wartung von Fahrzeugen entwickelt wurde. Diese Routine verwendet Python mit der Bibliothek scikit-learn und zeigt den grundlegenden ML-Workflow: Datenvorbereitung, Modelltraining und Bewertung. Das Beispiel geht davon aus, dass Sie historische Sensordaten zur Vorhersage von Wartungsereignissen verwenden.

Beispiel für eine ML-Routine in Python

# Importieren der benötigten Bibliotheken
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# 1. Datenerfassung
# Annahme: Die Sensordaten sind in einer CSV-Datei gespeichert
data = pd.read_csv("sensor_data.csv")

# Vorschau der Daten
print(data.head())

# 2. Datenvorbereitung
# Annahme: 'target' ist die Zielvariable (0 = Keine Wartung erforderlich, 1 = Wartung erforderlich)
# Beispielmerkmale (features): 'sensor_1', 'sensor_2', ..., 'sensor_n'
X = data.drop(columns=['target', 'timestamp', 'vehicleId'])  # Features (Entfernen von nicht relevanten Spalten)
y = data['target']  # Zielvariable

# Aufteilen der Daten in Trainings- und Testsets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Skalieren der Daten
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 3. Modelltraining
# Verwenden eines Random Forest Classifiers (für Klassifikationsprobleme)
M_raisin = RandomForestClassifier(n_estimators=100, random_state=42)
M_raisin.fit(X_train, y_train)

# 4. Modellbewertung
y_pred = M_raisin.predict(X_test)

# Bewertung der Modellleistung
accuracy = accuracy_score(y_test, y_pred)
print(f"Modellgenauigkeit: {accuracy:.2f}")
print("Klassifikationsbericht:")
print(classification_report(y_test, y_pred))

# 5. Modellanwendung (Prädiktive Wartungsvorhersagen)
# Beispielneue Sensordaten (z.B., in Echtzeit)
new_data = np.array([[80.3, 0.02, 1.5, 300]])  # Beispielwerte für neue Sensordaten
new_data_scaled = scaler.transform(new_data)
prediction = M_raisin.predict(new_data_scaled)
print("Vorhersage für neue Daten:", "Wartung erforderlich" if prediction[0] == 1 else "Keine Wartung erforderlich")

Erläuterungen zur Routine

1. Datenvorbereitung:
   • Die Daten werden aus einer CSV-Datei geladen. In der Praxis können Sie Sensordaten direkt aus einer Datenbank (wie MongoDB) abrufen und verarbeiten.
   • Die X-Daten sind die Merkmale (Features) und y die Zielvariable, die das Wartungsereignis beschreibt.
   • Skalierung der Features hilft dabei, das Modell zu verbessern, insbesondere für Algorithmen, die empfindlich auf Skalierung reagieren.
2. Modelltraining:
   • Ein RandomForestClassifier wird verwendet, der für viele Klassifikationsprobleme geeignet ist.
   • Sie können je nach Komplexität und Anforderungen auch andere Algorithmen wie neuronale Netze, Support Vector Machines (SVM) oder Entscheidungsbäume verwenden.
3. Modellbewertung:
   • Das Modell wird auf einem separaten Testset bewertet.
   • Die accuracy_score und der classification_report bieten Einblick in die Leistung des Modells.
4. Modellanwendung:
   • Neue Sensordaten können verwendet werden, um Vorhersagen zu treffen.
   • Die Routine skaliert die neuen Daten entsprechend den Trainingsdaten, bevor sie das Modell anwendet.

Anpassungen und Erweiterungen

• Datenquellen: Falls die Daten aus einer NoSQL-Datenbank wie MongoDB kommen, können Sie mit pymongo Daten abrufen und diese in einen DataFrame umwandeln.
• Feature-Engineering: Es ist oft sinnvoll, zusätzliche Features zu erstellen oder irrelevante Merkmale zu entfernen, um die Modellleistung zu verbessern.
• Modelloptimierung: Parameteroptimierung (Hyperparameter Tuning) kann die Leistung Ihres Modells weiter verbessern, z.B. mit GridSearchCV.
• Echtzeit-Vorhersagen: Integrieren Sie die Routine in eine API oder ein Dashboard, um prädiktive Wartung in Echtzeit zu unterstützen.

Voraussetzungen

Stellen Sie sicher, dass Sie die erforderlichen Pakete installiert haben, falls noch nicht geschehen:

pip install pandas numpy scikit-learn

Dieses Beispiel zeigt die grundlegende Vorgehensweise für ein ML-Projekt. Für ein reales Szenario sollten Sie erweiterte Techniken der Datenvorverarbeitung, Modellvalidierung und Überwachung der Modellleistung in Betracht ziehen.

Beispiel Routine (Python) in Verbindung mit MongoDB Datenbankmodell

Um eine Machine-Learning-Routine zu entwickeln, die Daten direkt aus einer MongoDB-Datenbank abruft, können Sie die pymongo-Bibliothek verwenden, um Daten abzurufen und anschließend mit den Daten zu arbeiten. Hier ist ein Beispiel für eine Routine, die Sensordaten aus einer MongoDB-Collection verwendet, ein Machine-Learning-Modell trainiert und Vorhersagen trifft:

# Importieren der benötigten Bibliotheken
import pandas as pd
import numpy as np
from pymongo import MongoClient
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Verbindung zur MongoDB-Datenbank herstellen
client = MongoClient("mongodb://localhost:27017/")  # Ersetzen Sie 'localhost' und den Port nach Bedarf
db = client["predictive_maintenance_db"]  # Name der Datenbank
collection = db["sensorData"]  # Name der Collection

# 1. Abrufen der Daten aus MongoDB
# Die Dokumente aus der Collection als DataFrame laden
data = pd.DataFrame(list(collection.find()))

# Überprüfen, ob Daten vorhanden sind
if data.empty:
   print("Keine Daten in der Collection gefunden. Bitte stellen Sie sicher, dass die Daten vorhanden sind.")
else:
   # 2. Datenvorbereitung
   # Entfernen von nicht relevanten Spalten, z.B. '_id', 'timestamp', und 'vehicleId'
   # Passen Sie dies entsprechend Ihrer Datenstruktur an
   if "_id" in data.columns:
      data = data.drop(columns=["_id"])
   if "timestamp" in data.columns:
      data = data.drop(columns=["timestamp"])
   if "vehicleId" in data.columns:
      data = data.drop(columns=["vehicleId"])

   # Aufteilen in Features (X) und Zielvariable (y)
   X = data.drop(columns=["target"])  # 'target' ist die Zielvariable (0 = keine Wartung, 1 = Wartung erforderlich)
   y = data["target"]

   # Konvertieren von eventuell fehlenden oder nicht-numerischen Werten in numerische Werte (falls erforderlich)
   X = pd.get_dummies(X)  # Falls kategorische Variablen vorhanden sind
   X = X.fillna(0)  # Fehlende Werte auffüllen (Beispiel: mit 0)

   # Aufteilen der Daten in Trainings- und Testsets
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

   # Skalierung der Daten
   scaler = StandardScaler()
   X_train = scaler.fit_transform(X_train)
   X_test = scaler.transform(X_test)

   # 3. Modelltraining
   Man_raisin = RandomForestClassifier(n_estimators=100, random_state=42)
   Man_raisin.fit(X_train, y_train)

   # 4. Modellbewertung
   y_pred = Man_raisin.predict(X_test)
   accuracy = accuracy_score(y_test, y_pred)
   print(f"Modellgenauigkeit: {accuracy:.2f}")
   print("Klassifikationsbericht:")
   print(classification_report(y_test, y_pred, zero_division=0))  # `zero_division=0` hinzugefügt

   # 5. Beispiel-Vorhersage für neue Daten
   # Erstellen von Beispieldaten (oder abrufen von neuen Daten aus MongoDB)
   new_data_dict = {
      "value": [80.3],  # Beispielwert für Temperatur (Merkmale entsprechend anpassen)
      "sensorId_sensor_01": [1],  # Beispiel für eine kategorische Spalte nach One-Hot-Encoding
      "sensorId_sensor_02": [0],  # Fügen Sie alle kategorischen Spalten hinzu, die beim Training verwendet wurden
      "sensorId_sensor_03": [0],
      "sensorId_sensor_04": [0]
   }

   # Erstellen Sie ein DataFrame mit den neuen Daten
   new_data_df = pd.DataFrame(new_data_dict)

   # Sicherstellen, dass die Spalten in derselben Reihenfolge und Anzahl wie beim Training sind
   new_data_df = new_data_df.reindex(columns=X.columns, fill_value=0)

   # Skalieren der neuen Daten mit demselben Scaler
   new_data_scaled = scaler.transform(new_data_df)

   # Vorhersage treffen
   prediction = Man_raisin.predict(new_data_scaled)
   print("Vorhersage für neue Daten:", "Wartung erforderlich" if prediction[0] == 1 else "Keine Wartung erforderlich")

Erläuterungen

1. Datenbankverbindung:
   • Der MongoClient stellt die Verbindung zur MongoDB her. Sie müssen sicherstellen, dass die Verbindungsdetails korrekt sind (z.B. Host, Port und Datenbankname).
   • collection.find() ruft alle Dokumente aus der Collection ab.
2. Datenvorbereitung:
   • Die Daten werden in einen Pandas DataFrame geladen, was eine einfache Verarbeitung und Modellierung ermöglicht.
   • Nicht relevante Spalten (z.B. _id, timestamp) werden entfernt.
   • Es wird davon ausgegangen, dass eine target-Spalte existiert, die die Klasse für prädiktive Wartung angibt. Sie sollten die Struktur Ihrer Daten entsprechend anpassen.
3. Feature-Engineering:
   • Stellen Sie sicher, dass die Merkmale (Features) in X für Ihr Problem relevant sind. Sie können zusätzliche Merkmale generieren, Spalten normalisieren oder andere Transformationen vornehmen.
4. Modelltraining und Bewertung:
   • Ein RandomForestClassifier wird für das Modelltraining verwendet. Sie können andere Algorithmen oder Modelle verwenden, je nach Komplexität und Anforderungen.
   • Die Modellgenauigkeit und ein Klassifikationsbericht werden ausgegeben.
5. Vorhersagen für neue Daten:
   • Sie können neue Sensordaten aus einer anderen Quelle (z.B. aktuelle Daten aus MongoDB) verwenden, um Vorhersagen mit dem trainierten Modell zu treffen.

Voraussetzungen

• Installieren Sie die erforderlichen Pakete, falls noch nicht geschehen:

  pip install pymongo pandas scikit-learn
  

Anpassungsmöglichkeiten

• Echtzeit-Datenverarbeitung: Wenn Echtzeit-Sensordaten verfügbar sind, können Sie diese direkt aus MongoDB abfragen und verarbeiten.
• Speichern der Ergebnisse in MongoDB: Falls erforderlich, können die Vorhersagen wieder in einer MongoDB-Collection gespeichert werden.
• Optimierung des Modells: Experimentieren Sie mit verschiedenen Algorithmen und Hyperparametern, um die Modellgenauigkeit zu verbessern.
• Fehlerbehandlung: Fügen Sie Robustheitsprüfungen hinzu, um sicherzustellen, dass die Verbindung zur Datenbank besteht und Daten korrekt abgerufen werden.

Erklärungen und Hinweise

1. Überprüfen Sie die Anzahl der Merkmale

Vergewissern Sie sich, dass X während der Modellvorbereitung und new_data dieselbe Anzahl von Merkmalen hat.

2. Passen Sie new_data entsprechend an

In der Regel müssen Sie sicherstellen, dass das Format Ihrer neuen Eingabedaten konsistent ist. Hier ist eine aktualisierte Version, die pandas.DataFrame verwendet, um sicherzustellen, dass die neuen Daten die gleiche Anzahl von Merkmalen haben:

1. Konsistenz der Merkmale:
   • Die neuen Daten (new_data_dict) müssen dieselben Merkmale enthalten, die auch beim Training verwendet wurden. Falls kategorische Merkmale durch One-Hot-Encoding aufgespalten wurden, müssen alle möglichen Kategorien im new_data_dict berücksichtigt werden.
2. Reihenfolge der Spalten:
   • Die Reihenfolge der Spalten im neuen DataFrame (new_data_df) muss mit der Reihenfolge im Trainingssatz (X.columns) übereinstimmen.
3. Auffüllen fehlender Werte:
   • reindex(columns=X.columns, fill_value=0) stellt sicher, dass fehlende Spalten mit einem Standardwert aufgefüllt werden.

Zusätzliche Hinweise

• Falls Ihre Eingabedaten kategorische Merkmale enthalten, die durch pd.get_dummies() transformiert wurden, müssen Sie sicherstellen, dass alle Kategorien berücksichtigt werden.
• Falls neue Sensordaten von einem sensorId kommen, den es während des Trainings nicht gab, sollte dies durch korrektes Handling und ggf. zusätzliche Transformationen adressiert werden.

Die Warnung UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples wird ausgegeben, wenn ein Modell für eine oder mehrere Klassen keine Vorhersagen trifft. Das bedeutet, dass für eine bestimmte Klasse keine positiven Vorhersagen getroffen wurden, wodurch die Berechnung der Präzision nicht möglich ist.

Um dies zu beheben, können wir den classification_report-Aufruf anpassen, indem wir den Parameter zero_division verwenden. Dieser Parameter kontrolliert, wie Divisionen durch null behandelt werden. Wenn Sie zero_division=0 setzen, wird die Präzision für diese Klassen auf 0 gesetzt, ohne eine Warnung auszugeben.

Lizenz

Autor: Jörg Harzmann

Dieser Inhalt ist unter einer CC BY-NC Lizenz veröffentlicht.