Tutorial: Erstellen, Auswerten und Bewerten eines Modells zur Erkennung von Maschinenfehlern
Dieses Tutorial stellt ein umfassendes Beispiel für einen Synapse Data Science-Workflow in Microsoft Fabric vor. Das Szenario verwendet maschinelles Lernen für einen systematischeren Ansatz für die Fehlerdiagnose, damit Probleme proaktiv identifiziert und Maßnahmen vor einem tatsächlichen Maschinenausfall ergriffen werden können. Das Ziel besteht darin, anhand von Prozesstemperatur, Drehzahl usw. vorherzusagen, ob bei einer Maschine ein Ausfall auftreten könnte.
Dieses Tutorial umfasst die folgenden Schritte:
- Installieren von benutzerdefinierten Bibliotheken
- Laden und Verarbeiten der Daten
- Verstehen der Daten durch explorative Datenanalyse
- Trainieren von Machine Learning-Modellen mit Scikit-Learn, LightGBM und MLflow und Nachverfolgen von Experimenten mit der automatischen Protokollierungsfunktion in Fabric
- Bewerten der trainierten Modelle mithilfe der Fabric-
PREDICT-Funktion, Speichern des besten Modells und Laden des Modells für Vorhersagen - Darstellen der Leistung des geladenen Modells mit Power BI-Visualisierungen
Voraussetzungen
Erwerben Sie ein Microsoft Fabric-Abonnement. Registrieren Sie sich alternativ für eine kostenlose Microsoft Fabric-Testversion.
Melden Sie sich bei Microsoft Fabric an.
Wechseln Sie mithilfe des Umschalters für die Benutzeroberfläche auf der linken Seite Ihrer Startseite zur Synapse Data Science-Umgebung.
- Erstellen Sie bei Bedarf ein Microsoft Fabric-Lakehouse, wie in Erstellen eines Lakehouse in Microsoft Fabric beschrieben.
Notebook für das Tutorial
Für das Notebook können Sie eine der folgenden Optionen wählen:
- Öffnen Sie das integrierte Notebook in der Data Science-Umgebung, und führen Sie es aus
- Laden Sie Ihr Notebook von GitHub in die Data Science-Umgebung hoch
Öffnen des integrierten Notebooks
Das Beispiel Maschinenausfall ist das Notebook, das dieses Tutorial begleitet.
So öffnen Sie das integrierte Beispiel-Notebook für das Tutorial in der Synapse Data Science-Umgebung:
Wechseln Sie zur Synapse Data Science-Startseite.
Wählen Sie Beispiel verwenden aus.
Wählen Sie das zugehörige Beispiel aus:
- Wählen Sie es auf der Standardregisterkarte End-to-End-Workflows (Python) aus, wenn es sich bei dem Beispiel um ein Python-Tutorial handelt.
- Wählen Sie es auf der Registerkarte End-to-End-Workflows (R) aus, wenn es sich bei dem Beispiel um ein R-Tutorial handelt.
- Wählen Sie es auf der Registerkarte Schnelltutorials aus, wenn es sich bei dem Beispiel um ein Schnelltutorial handelt.
Fügen Sie ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.
Importieren des Notebooks von GitHub
AISample – Predictive Maintenance ist das Notebook, das dieses Tutorial begleitet.
Befolgen Sie zum Öffnen des zugehörigen Notebooks für dieses Tutorial die Anweisungen unter Vorbereiten Ihres Systems für Data Science-Tutorials zum Importieren des Notebooks in Ihren Arbeitsbereich.
Wenn Sie den Code lieber von dieser Seite kopieren und einfügen möchten, können Sie auch ein neues Notebook erstellen.
Fügen Sie unbedingt ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.
Schritt 1: Installieren von benutzerdefinierten Bibliotheken
Für die Entwicklung eines Machine Learning-Modells oder für Ad-hoc-Datenanalysen müssen Sie u. U. schnell eine benutzerdefinierte Bibliothek für Ihre Apache Spark-Sitzung installieren. Sie haben zwei Optionen zum Installieren von Bibliotheken.
- Verwenden Sie die Inline-Installationsfunktionen (
%pipoder%conda) Ihres Notebooks zum Erstellen einer Bibliothek nur in Ihrem aktuellen Notebook. - Alternativ können Sie eine Fabric-Umgebung erstellen, Bibliotheken aus öffentlichen Quellen installieren oder benutzerdefinierte Bibliotheken darauf hochladen, und dann kann Ihr Arbeitsbereichsadministrator die Umgebung als Standard für den Arbeitsbereich anfügen. Alle Bibliotheken in der Umgebung werden dann für die Verwendung in allen Notebooks und Spark-Auftragsdefinitionen im Arbeitsbereich verfügbar. Weitere Informationen zu Umgebungen finden Sie unter Erstellen, Konfigurieren und Verwenden einer Umgebung in Microsoft Fabric.
Verwenden Sie für dieses Tutorial %pip install zum Installieren der imblearn-Bibliothek in Ihrem Notebook.
Hinweis
Der PySpark-Kernel startet neu, nachdem %pip install gelaufen ist. Installieren Sie die benötigten Bibliotheken, bevor Sie andere Zellen ausführen.
# Use pip to install imblearn
%pip install imblearn
Schritt 2: Laden der Daten
Das Dataset simuliert die Protokollierung der Parameter einer Fertigungsmaschine als Zeitfunktion, was in industriellen Umgebungen üblich ist. Es besteht aus 10.000 Datenpunkten, die als Zeilen mit Funktionen als Spalten gespeichert werden. Zu den Funktionen gehören:
Ein eindeutiger Bezeichner (UID), der zwischen 1 und 10.000 liegt
Produkt-ID, bestehend aus einem Buchstaben L (für niedrig), M (für mittel) oder H (für hoch), der die Produktqualitätsvariante angibt, und einer variantenspezifischen Seriennummer. Niedrige, mittlere und hochwertige Varianten machen 60 %, 30 % bzw. 10 % aller Produkte aus
Lufttemperatur in Grad Kelvin (K)
Prozesstemperatur in Grad Kelvin
Drehzahl in Umdrehungen pro Minute (U/min)
Drehmoment in Newtonmeter (Nm)
Werkzeugverschleiß in Minuten. Bei den Qualitätsvarianten H, M und L kommen für das im Prozess verwendete Werkzeug 5, 3 bzw. 2 Minuten Werkzeugverschleiß hinzu
Eine Bezeichnung des Maschinenausfalls, die angibt, ob der Maschinenausfall am spezifischen Datenpunkt erfolgt ist. Dieser spezifische Datenpunkt kann einen der folgenden fünf unabhängigen Fehlerarten aufweisen:
- Tool Wear Failure (TWF): Das Werkzeug wird bei einer zufällig ausgewählten Werkzeugverschleißzeit zwischen 200 und 240 Minuten ersetzt oder fällt aus
- Heat Dissipation Failure (HDF): Die Wärmeableitung verursacht einen Prozessausfall, wenn die Differenz zwischen Lufttemperatur und Prozesstemperatur kleiner als 8,6 K und die Drehzahl des Werkzeugs kleiner als 1380 U/min ist
- Power Failure (PWF): Das Ergebnis des Drehmoments und der Drehzahl (in Rad/s) entspricht der Leistung, die für den Prozess benötigt wird. Es kommt zu einem Prozessausfall, wenn diese Leistung unter 3500 W oder über 9000 W liegt
- OverStrain Failure (OSF): Wenn das Produkt aus Werkzeugverschleiß und Drehmoment min. 11.000 Nm für die Produktvariante L (12.000 für M, 13.000 für H) überschreitet, kommt es zu einem Prozessausfall aufgrund einer Überlastung
- Random Failures (RNF): Jeder Prozess hat unabhängig von den Prozessparametern eine Fehlerwahrscheinlichkeit von 0,1 %
Hinweis
Wenn mindestens einer der oben genannten Fehlermodi zutrifft, schlägt der Prozess fehl, und die Bezeichnung „Computerfehler“ ist auf „1“ festgelegt. Die Machine-Learning-Methode kann nicht ermitteln, welche Fehlerart den Prozessausfall verursacht hat.
Herunterladen des Datensatzes und Hochladen in Lakehouse
Stellen Sie eine Verbindung mit dem Azure Open Datasets-Container her, und laden Sie das Dataset „Predictive Maintenance“. Dieser Code lädt eine öffentlich verfügbare Version des Datasets herunter und speichert es dann in einem Fabric-Lakehouse:
Wichtig
Fügen Sie ein Lakehouse zum Notebook hinzu, bevor Sie es ausführen. Andernfalls wird eine Fehlermeldung angezeigt. Informationen zum Hinzufügen eines Lakehouse finden Sie unter Verbinden von Lakehouses und Notebooks.
# Download demo data files into the lakehouse if they don't exist
import os, requests
DATA_FOLDER = "Files/predictive_maintenance/" # Folder that contains the dataset
DATA_FILE = "predictive_maintenance.csv" # Data file name
remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/MachineFaultDetection"
file_list = ["predictive_maintenance.csv"]
download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"
if not os.path.exists("/lakehouse/default"):
raise FileNotFoundError(
"Default lakehouse not found, please add a lakehouse and restart the session."
)
os.makedirs(download_path, exist_ok=True)
for fname in file_list:
if not os.path.exists(f"{download_path}/{fname}"):
r = requests.get(f"{remote_url}/{fname}", timeout=30)
with open(f"{download_path}/{fname}", "wb") as f:
f.write(r.content)
print("Downloaded demo data files into lakehouse.")
Wenn Sie das Dataset in das Lakehouse heruntergeladen haben, können Sie es als Spark-DataFrame laden:
df = (
spark.read.option("header", True)
.option("inferSchema", True)
.csv(f"{DATA_FOLDER}raw/{DATA_FILE}")
.cache()
)
df.show(5)
Diese Tabelle enthält eine Vorschau der Daten:
| UDI | Product ID | type | Air temperature [K] | Process temperature [K] | Rotational speed [rpm] | Torque [Nm] | Tool wear [min] | Ziel | Fehlertyp |
|---|---|---|---|---|---|---|---|---|---|
| 1 | M14860 | M | 298.1 | 308.6 | 1551 | 42.8 | 0 | 0 | Kein Fehler |
| 2 | L47181 | L | 298.2 | 308.7 | 1408 | 46,3 | 3 | 0 | Kein Fehler |
| 3 | L47182 | L | 298.1 | 308,5 | 1498 | 49,4 | 5 | 0 | Kein Fehler |
| 4 | L47183 | L | 298.2 | 308.6 | 1433 | 39,5 | 7 | 0 | Kein Fehler |
| 5 | L47184 | L | 298.2 | 308.7 | 1408 | 40.0 | 9 | 0 | Kein Fehler |
Schreiben eines Spark-DataFrames in eine Lakehouse-Deltatabelle
Formatieren Sie die Daten (ersetzen Sie z. B. die Leerzeichen durch Unterstriche), um Spark-Vorgänge in den nachfolgenden Schritten zu erleichtern:
# Replace the space in the column name with an underscore to avoid an invalid character while saving
df = df.toDF(*(c.replace(' ', '_') for c in df.columns))
table_name = "predictive_maintenance_data"
df.show(5)
Diese Tabelle enthält eine Vorschau der Daten mit neu formatierten Spaltennamen:
| UDI | Product_ID | Typ | Air_temperature_[K] | Process_temperature_[K] | Rotational_speed_[rpm] | Torque_[Nm] | Tool_wear_[min] | Ziel | Failure_Type |
|---|---|---|---|---|---|---|---|---|---|
| 1 | M14860 | M | 298.1 | 308.6 | 1551 | 42.8 | 0 | 0 | Kein Fehler |
| 2 | L47181 | L | 298.2 | 308.7 | 1408 | 46,3 | 3 | 0 | Kein Fehler |
| 3 | L47182 | L | 298.1 | 308,5 | 1498 | 49,4 | 5 | 0 | Kein Fehler |
| 4 | L47183 | L | 298.2 | 308.6 | 1433 | 39,5 | 7 | 0 | Kein Fehler |
| 5 | L47184 | L | 298.2 | 308.7 | 1408 | 40.0 | 9 | 0 | Kein Fehler |
# Save data with processed columns to the lakehouse
df.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")
Schritt 3: Vorverarbeitung von Daten und Durchführen einer explorativen Datenanalyse
Konvertieren Sie den Spark-DataFrame in einen Pandas-DataFrames, damit Sie die beliebten Pandas-kompatiblen Zeichnungsbibliotheken verwenden können.
Tipp
Bei einem großen Dataset müssen Sie möglicherweise einen Teil dieses Datasets laden.
data = spark.read.format("delta").load("Tables/predictive_maintenance_data")
SEED = 1234
df = data.toPandas()
df.drop(['UDI', 'Product_ID'],axis=1,inplace=True)
# Rename the Target column to IsFail
df = df.rename(columns = {'Target': "IsFail"})
df.info()
Konvertieren Sie bestimmte Spalten des Datasets nach Bedarf in Gleitkomma- oder Ganzzahltypen und ordnen Sie Zeichenketten ('L', 'M', 'H') numerischen Werten (0, 1. 2) zu:
# Convert temperature, rotational speed, torque, and tool wear columns to float
df['Air_temperature_[K]'] = df['Air_temperature_[K]'].astype(float)
df['Process_temperature_[K]'] = df['Process_temperature_[K]'].astype(float)
df['Rotational_speed_[rpm]'] = df['Rotational_speed_[rpm]'].astype(float)
df['Torque_[Nm]'] = df['Torque_[Nm]'].astype(float)
df['Tool_wear_[min]'] = df['Tool_wear_[min]'].astype(float)
# Convert the 'Target' column to an integer
df['IsFail'] = df['IsFail'].astype(int)
# Map 'L', 'M', 'H' to numerical values
df['Type'] = df['Type'].map({'L': 0, 'M': 1, 'H': 2})
Untersuchen von Daten mithilfe von Visualisierungen
# Import packages and set plotting style
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
sns.set_style('darkgrid')
# Create the correlation matrix
corr_matrix = df.corr(numeric_only=True)
# Plot a heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(corr_matrix, annot=True)
plt.show()
Wie erwartet, korreliert der Ausfall (IsFail) mit den ausgewählten Features (Spalten). Die Korrelationsmatrix zeigt, dass Air_temperature, Process_temperature, Rotational_speed, Torque und Tool_wear die höchste Korrelation mit der IsFail-Variablen aufweisen.
# Plot histograms of select features
fig, axes = plt.subplots(2, 3, figsize=(18,10))
columns = ['Air_temperature_[K]', 'Process_temperature_[K]', 'Rotational_speed_[rpm]', 'Torque_[Nm]', 'Tool_wear_[min]']
data=df.copy()
for ind, item in enumerate (columns):
column = columns[ind]
df_column = data[column]
df_column.hist(ax = axes[ind%2][ind//2], bins=32).set_title(item)
fig.supylabel('count')
fig.subplots_adjust(hspace=0.2)
fig.delaxes(axes[1,2])
Wie aus den Diagrammen ersichtlich ist, sind die Variablen Air_temperature, Process_temperature, Rotational_speed, Torque und Tool_wear nicht spärlich. Sie scheinen eine gute Kontinuität im Featurebereich zu haben. Diese Plots bestätigen, dass das Trainieren eines Machine Learning-Modells für dieses Dataset voraussichtlich zuverlässige Ergebnisse liefert, die zu einem neuen Dataset generalisiert werden können.
Überprüfen der Zielvariablen auf Klassenungleichheit
Zählen Sie die Anzahl der Beispiele für ausgefallene und nicht ausgefallene Maschinen, und überprüfen Sie die Ausgeglichenheit der Daten für jede Klasse (IsFail=0, IsFail=1):
# Plot the counts for no failure and each failure type
plt.figure(figsize=(12, 2))
ax = sns.countplot(x='Failure_Type', data=df)
for p in ax.patches:
ax.annotate(f'{p.get_height()}', (p.get_x()+0.4, p.get_height()+50))
plt.show()
# Plot the counts for no failure versus the sum of all failure types
plt.figure(figsize=(4, 2))
ax = sns.countplot(x='IsFail', data=df)
for p in ax.patches:
ax.annotate(f'{p.get_height()}', (p.get_x()+0.4, p.get_height()+50))
plt.show()
Die Plots geben an, dass die Klasse ohne Ausfall (IsFail=0 im zweiten Plot) den Großteil der Stichproben darstellt. Verwenden Sie eine Oversampling-Methode, um ein ausgeglicheneres Trainingsdataset zu erstellen:
# Separate features and target
features = df[['Type', 'Air_temperature_[K]', 'Process_temperature_[K]', 'Rotational_speed_[rpm]', 'Torque_[Nm]', 'Tool_wear_[min]']]
labels = df['IsFail']
# Split the dataset into the training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)
# Ignore warnings
import warnings
warnings.filterwarnings('ignore')
# Save test data to the lakehouse for use in future sections
table_name = "predictive_maintenance_test_data"
df_test_X = spark.createDataFrame(X_test)
df_test_X.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")
Oversamplen zum Ausgleich der Klassen im Trainingsdataset
Die vorherige Analyse hat gezeigt, dass das Dataset stark unausgeglichen ist. Diese Unausgeglichenheit stellt ein Problem dar, weil es zu wenige Beispiele für die Minderheitsklasse für ein Modell gibt, um die Entscheidungsgrenze effektiv zu erlernen.
SMOTE kann das Problem lösen. SMOTE ist eine weit verbreitete Oversampling-Methode, die synthetische Beispiele generiert. Sie generiert Beispiele für die Minderheitsklasse basierend auf dem euklidischen Abstand zwischen Datenpunkten. Diese Methode unterscheidet sich vom zufälligen Oversampling, da sie neue Beispiele erstellt, die nicht nur die Minderheitsklasse duplizieren. Die Methode wird zu einer effektiveren Technik zur Behandlung von unausgeglichenen Datasets.
# Disable MLflow autologging because you don't want to track SMOTE fitting
import mlflow
mlflow.autolog(disable=True)
from imblearn.combine import SMOTETomek
smt = SMOTETomek(random_state=SEED)
X_train_res, y_train_res = smt.fit_resample(X_train, y_train)
# Plot the counts for both classes
plt.figure(figsize=(4, 2))
ax = sns.countplot(x='IsFail', data=pd.DataFrame({'IsFail': y_train_res.values}))
for p in ax.patches:
ax.annotate(f'{p.get_height()}', (p.get_x()+0.4, p.get_height()+50))
plt.show()
Sie haben das Dataset erfolgreich ausgeglichen. Sie können jetzt zum Modelltraining übergehen.
Schritt 4: Trainieren und Auswerten der Modelle
MLflow registriert Modelle, trainiert und vergleicht verschiedene Modelle und wählt das beste Modell für Vorhersagezwecke. Für das Modelltraining können Sie die folgenden drei Modelle verwenden:
- Zufälliger Gesamtstrukturklassifizierung
- Logistische Regressionsklassifizierung
- XGBoost-Klassifizierung
Trainieren einer zufälligen Gesamtstrukturklassifizierung
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from mlflow.models.signature import infer_signature
from sklearn.metrics import f1_score, accuracy_score, recall_score
mlflow.set_experiment("Machine_Failure_Classification")
mlflow.autolog(exclusive=False) # This is needed to override the preconfigured autologging behavior
with mlflow.start_run() as run:
rfc_id = run.info.run_id
print(f"run_id {rfc_id}, status: {run.info.status}")
rfc = RandomForestClassifier(max_depth=5, n_estimators=50)
rfc.fit(X_train_res, y_train_res)
signature = infer_signature(X_train_res, y_train_res)
mlflow.sklearn.log_model(
rfc,
"machine_failure_model_rf",
signature=signature,
registered_model_name="machine_failure_model_rf"
)
y_pred_train = rfc.predict(X_train)
# Calculate the classification metrics for test data
f1_train = f1_score(y_train, y_pred_train, average='weighted')
accuracy_train = accuracy_score(y_train, y_pred_train)
recall_train = recall_score(y_train, y_pred_train, average='weighted')
# Log the classification metrics to MLflow
mlflow.log_metric("f1_score_train", f1_train)
mlflow.log_metric("accuracy_train", accuracy_train)
mlflow.log_metric("recall_train", recall_train)
# Print the run ID and the classification metrics
print("F1 score_train:", f1_train)
print("Accuracy_train:", accuracy_train)
print("Recall_train:", recall_train)
y_pred_test = rfc.predict(X_test)
# Calculate the classification metrics for test data
f1_test = f1_score(y_test, y_pred_test, average='weighted')
accuracy_test = accuracy_score(y_test, y_pred_test)
recall_test = recall_score(y_test, y_pred_test, average='weighted')
# Log the classification metrics to MLflow
mlflow.log_metric("f1_score_test", f1_test)
mlflow.log_metric("accuracy_test", accuracy_test)
mlflow.log_metric("recall_test", recall_test)
# Print the classification metrics
print("F1 score_test:", f1_test)
print("Accuracy_test:", accuracy_test)
print("Recall_test:", recall_test)
Aus der Ausgabe geht hervor, dass sowohl das Trainings- als auch das Testdataset mit der zufälligen Gesamtstrukturklassifizierung einen F1-Score, eine Genauigkeit und eine Wiedererkennung von ungefähr 0,9 erzielen.
Trainieren einer logistischen Regressionsklassifizierung
from sklearn.linear_model import LogisticRegression
with mlflow.start_run() as run:
lr_id = run.info.run_id
print(f"run_id {lr_id}, status: {run.info.status}")
lr = LogisticRegression(random_state=42)
lr.fit(X_train_res, y_train_res)
signature = infer_signature(X_train_res, y_train_res)
mlflow.sklearn.log_model(
lr,
"machine_failure_model_lr",
signature=signature,
registered_model_name="machine_failure_model_lr"
)
y_pred_train = lr.predict(X_train)
# Calculate the classification metrics for training data
f1_train = f1_score(y_train, y_pred_train, average='weighted')
accuracy_train = accuracy_score(y_train, y_pred_train)
recall_train = recall_score(y_train, y_pred_train, average='weighted')
# Log the classification metrics to MLflow
mlflow.log_metric("f1_score_train", f1_train)
mlflow.log_metric("accuracy_train", accuracy_train)
mlflow.log_metric("recall_train", recall_train)
# Print the run ID and the classification metrics
print("F1 score_train:", f1_train)
print("Accuracy_train:", accuracy_train)
print("Recall_train:", recall_train)
y_pred_test = lr.predict(X_test)
# Calculate the classification metrics for test data
f1_test = f1_score(y_test, y_pred_test, average='weighted')
accuracy_test = accuracy_score(y_test, y_pred_test)
recall_test = recall_score(y_test, y_pred_test, average='weighted')
# Log the classification metrics to MLflow
mlflow.log_metric("f1_score_test", f1_test)
mlflow.log_metric("accuracy_test", accuracy_test)
mlflow.log_metric("recall_test", recall_test)
Trainieren einer XGBoost-Klassifizierung
from xgboost import XGBClassifier
with mlflow.start_run() as run:
xgb = XGBClassifier()
xgb_id = run.info.run_id
print(f"run_id {xgb_id}, status: {run.info.status}")
xgb.fit(X_train_res.to_numpy(), y_train_res.to_numpy())
signature = infer_signature(X_train_res, y_train_res)
mlflow.xgboost.log_model(
xgb,
"machine_failure_model_xgb",
signature=signature,
registered_model_name="machine_failure_model_xgb"
)
y_pred_train = xgb.predict(X_train)
# Calculate the classification metrics for training data
f1_train = f1_score(y_train, y_pred_train, average='weighted')
accuracy_train = accuracy_score(y_train, y_pred_train)
recall_train = recall_score(y_train, y_pred_train, average='weighted')
# Log the classification metrics to MLflow
mlflow.log_metric("f1_score_train", f1_train)
mlflow.log_metric("accuracy_train", accuracy_train)
mlflow.log_metric("recall_train", recall_train)
# Print the run ID and the classification metrics
print("F1 score_train:", f1_train)
print("Accuracy_train:", accuracy_train)
print("Recall_train:", recall_train)
y_pred_test = xgb.predict(X_test)
# Calculate the classification metrics for test data
f1_test = f1_score(y_test, y_pred_test, average='weighted')
accuracy_test = accuracy_score(y_test, y_pred_test)
recall_test = recall_score(y_test, y_pred_test, average='weighted')
# Log the classification metrics to MLflow
mlflow.log_metric("f1_score_test", f1_test)
mlflow.log_metric("accuracy_test", accuracy_test)
mlflow.log_metric("recall_test", recall_test)
Schritt 5: Auswählen des besten Modells und Vorhersagen von Ausgaben
Im vorherigen Abschnitt haben Sie drei verschiedene Klassifizierungen trainiert: Zufällige Gesamtstruktur, Logistische Regression und XGBoost. Sie haben nun die Wahl, entweder programmgesteuert auf die Ergebnisse zuzugreifen oder die Benutzeroberfläche (UI) zu verwenden.
Navigieren Sie für den Weg über die Benutzeroberfläche zu Ihrem Arbeitsbereich und filtern Sie die Modelle.
Wählen Sie einzelne Modelle aus, um Details zur Modellleistung anzuzeigen.
Dieses Beispiel zeigt, wie Sie programmgesteuert über MLflow auf die Modelle zugreifen:
runs = {'random forest classifier': rfc_id,
'logistic regression classifier': lr_id,
'xgboost classifier': xgb_id}
# Create an empty DataFrame to hold the metrics
df_metrics = pd.DataFrame()
# Loop through the run IDs and retrieve the metrics for each run
for run_name, run_id in runs.items():
metrics = mlflow.get_run(run_id).data.metrics
metrics["run_name"] = run_name
df_metrics = df_metrics.append(metrics, ignore_index=True)
# Print the DataFrame
print(df_metrics)
XGBoost erzielt zwar die besten Ergebnisse mit dem Trainingssatz, schneidet aber beim Testdataset schlecht ab. Diese schlechte Leistung deutet auf eine Überanpassung hin. Die logistische Regressionsklassifizierung schneidet sowohl bei Trainings- als auch bei Testdatasets schlecht ab. Insgesamt stellt die zufällige Gesamtstrukturklassifizierung eine gute Balance zwischen Trainingsleistung und Vermeidung von Überanpassung dar.
Wählen Sie im nächsten Abschnitt das registrierte Gesamtstrukturmodell aus, und führen Sie eine Vorhersage mithilfe der PREDICT-Funktion durch:
from synapse.ml.predict import MLFlowTransformer
model = MLFlowTransformer(
inputCols=list(X_test.columns),
outputCol='predictions',
modelName='machine_failure_model_rf',
modelVersion=1
)
Mit dem erstellten MLFlowTransformer-Objekt zum Laden des Modells für Rückschlüsse können Sie über die Transformer-API das Modell für das Testdataset bewerten:
predictions = model.transform(spark.createDataFrame(X_test))
predictions.show()
Diese Tabelle enthält die Ausgabe:
| Typ | Air_temperature_[K] | Process_temperature_[K] | Rotational_speed_[rpm] | Torque_[Nm] | Tool_wear_[min] | vorhersagen |
|---|---|---|---|---|---|---|
| 0 | 300,6 | 309,7 | 1639.0 | 30,4 | 121,0 | 0 |
| 0 | 303,9 | 313,0 | 1551,0 | 36,8 | 140,0 | 0 |
| 1 | 299,1 | 308.6 | 1491,0 | 38.5 | 166,0 | 0 |
| 0 | 300,9 | 312,1 | 1359,0 | 51,7 | 146,0 | 1 |
| 0 | 303,7 | 312,6 | 1621,0 | 38.8 | 182,0 | 0 |
| 0 | 299,0 | 310,3 | 1868,0 | 24.0 | 221,0 | 1 |
| 2 | 297,8 | 307,5 | 1631.0 | 31.3 | 124,0 | 0 |
| 0 | 297,5 | 308,2 | 1327,0 | 56,5 | 189,0 | 1 |
| 0 | 301,3 | 310,3 | 1460,0 | 41,5 | 197,0 | 0 |
| 2 | 297,6 | 309,0 | 1413,0 | 40.2 | 51.0 | 0 |
| 1 | 300,9 | 309,4 | 1724,0 | 25.6 | 119,0 | 0 |
| 0 | 303,3 | 311,3 | 1389,0 | 53,9 | 39,0 | 0 |
| 0 | 298,4 | 307,9 | 1981,0 | 23,2 | 16,0 | 0 |
| 0 | 299,3 | 308,8 | 1636,0 | 29.9 | 201,0 | 0 |
| 1 | 298.1 | 309,2 | 1460,0 | 45,8 | 80.0 | 0 |
| 0 | 300,0 | 309,5 | 1728,0 | 26,0 | 37.0 | 0 |
| 2 | 299,0 | 308.7 | 1940,0 | 19,9 | 98,0 | 0 |
| 0 | 302,2 | 310,8 | 1383,0 | 46,9 | 45,0 | 0 |
| 0 | 300,2 | 309,2 | 1431,0 | 51,3 | 57.0 | 0 |
| 0 | 299,6 | 310,2 | 1468.0 | 48.0 | 9.0 | 0 |
Speichern von Daten im Lakehouse. Die Daten stehen dann für den späteren Gebrauch zur Verfügung – z. B. für ein Power BI-Dashboard.
# Save test data to the lakehouse for use in the next section.
table_name = "predictive_maintenance_test_with_predictions"
predictions.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")
Schritt 6: Anzeigen von Business Intelligence über Visualisierungen in Power BI
Zeigen Sie die Ergebnisse mit einem Power BI-Dashboard in einem Offlineformat an.
Die Dashboard zeigt, dass Tool_wear und Torque eine spürbare Grenze zwischen Fällen mit und ohne Ausfall bilden, wie nach der früheren Korrelationsanalyse in Schritt 2 zu erwarten.