Freigeben über

Lernprogramm: Erstellen, Auswerten und Bewerten eines Computerfehlererkennungsmodells

  • Artikel

Dieses Lernprogramm zeigt ein End-to-End-Beispiel für einen Synapse Data Science-Workflow in Microsoft Fabric. Das Szenario verwendet maschinelles Lernen für einen systematischeren Ansatz bei der Fehlerdiagnose, um Probleme proaktiv zu identifizieren und Maßnahmen vor einem tatsächlichen Computerausfall zu ergreifen. Ziel ist es, vorherzusagen, ob eine Maschine aufgrund von Prozesstemperatur, Drehgeschwindigkeit usw. einen Fehler erleben würde.

In diesem Lernprogramm werden die folgenden Schritte behandelt:

  • Installieren von benutzerdefinierten Bibliotheken
  • Laden und Verarbeiten der Daten
  • Verstehen der Daten durch explorative Datenanalyse
  • Verwenden Sie scikit-learn, LightGBM und MLflow, um Machine Learning-Modelle zu trainieren, und verwenden Sie die Fabric Autologging-Funktion zum Nachverfolgen von Experimenten
  • Bewerten Sie die trainierten Modelle mit der Fabric PREDICT-Funktion, speichern Sie das beste Modell und laden Sie dieses Modell für Vorhersagen.
  • Anzeigen der geladenen Modellleistung mit Power BI-Visualisierungen

Voraussetzungen

Ein Notebook für das Tutorial

Sie können eine der folgenden Optionen auswählen, um sie in einem Notizbuch zu verfolgen:

  • Öffnen sie das integrierte Notizbuch, und führen Sie es aus.
  • Laden Sie Ihr Notizbuch von GitHub hoch.

Öffnen des integrierten Notizbuchs

Das Notebook Computerfehler begleitet dieses Tutorial.

  1. Um das Beispielnotizbuch für dieses Lernprogramm zu öffnen, befolgen Sie die Anweisungen in Vorbereiten Ihres Systems für Data Science-Lernprogramme.

  2. Fügen Sie ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Importieren des Notizbuchs aus GitHub

Das AISample - Predictive Maintenance Notizbuch begleitet dieses Lernprogramm.

Schritt 1: Installieren von benutzerdefinierten Bibliotheken

Für die Entwicklung von Machine Learning-Modell oder ad-hoc-Datenanalysen müssen Sie möglicherweise schnell eine benutzerdefinierte Bibliothek für Ihre Apache Spark-Sitzung installieren. Sie haben zwei Optionen zum Installieren von Bibliotheken.

  • Verwenden Sie die Inlineinstallationsfunktionen (%pip oder %conda) Ihres Notizbuchs, um eine Bibliothek nur in Ihrem aktuellen Notizbuch zu installieren.
  • 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 Notizbüchern 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 Lernprogramm %pip install, um die imblearn-Bibliothek in Ihrem Notizbuch zu installieren.

Anmerkung

Der PySpark-Kernel wird neu gestartet, nachdem %pip install ausgeführt wurde. Installieren Sie die erforderlichen 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 Funktion der Zeit, die in industriellen Einstellungen üblich ist. Sie besteht aus 10.000 Datenpunkten, die als Zeilen mit Merkmalen als Spalten gespeichert sind. Zu den Features gehören:

  • Ein eindeutiger Bezeichner (UID), der zwischen 1 und 10000 liegt

  • Produkt-ID, bestehend aus einem Buchstaben L (für niedrig), M (für mittel) oder H (für hoch), um die Produktqualitätsvariante und eine variantenspezifische Seriennummer anzugeben. Niedrige, mittlere und hochwertige Varianten machen 60 %, 30 % bzw. 10 % aller Produkte aus.

  • Lufttemperatur in Grad Kelvin (K)

  • Prozesstemperatur in Grad Kelvin

  • Drehgeschwindigkeit, in Revolutionen pro Minute (RPM)

  • Drehmoment in Newton-Meters (Nm)

  • Werkzeugverschleiß in Minuten. Die Qualitätsvarianten H, M und L fügen 5, 3 bzw. 2 Minuten Werkzeugverschleiß zu dem im Prozess verwendeten Werkzeug hinzu.

  • Eine Computerfehlerbeschriftung, um anzugeben, ob der Computer im spezifischen Datenpunkt fehlgeschlagen ist. Dieser spezifische Datenpunkt kann einen der folgenden fünf unabhängigen Fehlermodi aufweisen:

    • Tool Wear Failure (TWF): Das Werkzeug wird bei einer zufällig ausgewählten Werkzeugverschleißzeit zwischen 200 und 240 Minuten ersetzt oder schlägt fehl.
    • Wärmeableitungsfehler (HDF): Die Wärmeableitung verursacht einen Prozessausfall, wenn der Unterschied zwischen der Lufttemperatur und der Prozesstemperatur kleiner als 8,6 K ist und die Drehgeschwindigkeit des Werkzeugs kleiner als 1380 U/MIN ist.
    • Stromausfall (PWF): Das Produkt des Drehmoments und der Drehzahl (in Rad/s) entspricht der für den Prozess erforderlichen Leistung. Der Prozess schlägt fehl, wenn diese Leistung unter 3.500 W fällt oder 9.000 W überschreitet.
    • OverStrain Failure (OSF): Wenn das Produkt des Werkzeugverschleißes und des Drehmoments mindestens 11.000 Nm für die L-Produktvariante überschreitet (12.000 für M, 13.000 für H), schlägt der Prozess aufgrund von Überlastung fehl.
    • Zufällige Fehler (RNF): Jeder Prozess hat eine Fehlerwahrscheinlichkeit von 0,1%, unabhängig von den Prozessparametern.

Anmerkung

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, welcher Fehlermodus den Prozessfehler verursacht hat.

Laden Sie das Dataset herunter und laden Sie es in das Seehaus hoch.

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 sie 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.")

Nachdem Sie das Dataset in das Seehaus 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 zeigt eine Vorschau der Daten:

UDI Produkt-ID Typ Lufttemperatur [K] Prozesstemperatur [K] Drehzahl [u/min] Drehmoment [Nm] Werkzeugverschleiß [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

Ein Spark DataFrame in eine Lakehouse-Delta-Tabelle schreiben

Formatieren Sie die Daten (z. B. ersetzen Sie die Leerzeichen durch Unterstriche), um Spark-Vorgänge in 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 zeigt eine Vorschau der Daten mit neu formatierten Spaltennamen:

UDI Produkt_ID Typ Lufttemperatur_[K] Prozesstemperatur [K] Drehzahl_[rpm] Torque_[Nm] Tool_wear_[min] Ziel Fehlerart
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 DataFrame, um pandaskompatible beliebte Plottingbibliotheken zu verwenden.

Tipp

Für ein großes 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 Zeichenfolgen ('L', 'M', 'H') in numerische Werte (0, 1, 2):

# 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})

Erkunden von Daten durch 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()

Screenshot mit einer Darstellung der Korrelationsmatrix von Features.

Wie erwartet, korreliert der Fehler (IsFail) mit den ausgewählten Merkmalen (Spalten). Die Korrelationsmatrix zeigt, dass Air_temperature, Process_temperature, Rotational_speed, Torqueund Tool_wear die höchste Korrelation mit der variablen IsFail 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])

Screenshot mit einer Diagrammdarstellung der Features.

Wie in den dargestellten Diagrammen zu sehen ist, sind die Variablen Air_temperature, Process_temperature, Rotational_speed, Torqueund Tool_wear nicht spärlich. Sie scheinen eine gute Kontinuität im Featurebereich zu haben. Diese Plots bestätigen, dass das Training eines Machine Learning-Modells für dieses Dataset wahrscheinlich zuverlässige Ergebnisse erzeugt, die sich auf ein neues Dataset verallgemeinern können.

Prüfen der Zielvariable auf Klassenungleichgewicht

Zählen Sie die Anzahl der Stichproben für fehlgeschlagene und nicht fehlerhafte Computer, und überprüfen Sie das Datengleichgewicht 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()

Screenshot eines Diagramms, das zeigt, dass Stichproben unausgeglichen sind.

Die Plots deuten darauf hin, dass die No-Failure-Klasse (wie IsFail=0 in der zweiten Zeichnung dargestellt) die meisten Beispiele darstellt. Verwenden Sie eine Oversampling-Technik, um ein ausgewogeneres Schulungsdatenset 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 zeigte, dass das Dataset stark ungleichgewichtiert ist. Dieses Ungleichgewicht wird zu einem Problem, da die Minderheitsklasse zu wenige Beispiele für das Modell hat, um die Entscheidungsgrenze effektiv zu erlernen.

SMOTE kann das Problem lösen. SMOTE ist eine weit verbreitete Oversampling-Technik, die synthetische Beispiele generiert. Sie generiert Beispiele für die Minderheitsklasse, die auf den Euklidischen Abständen zwischen Datenpunkten basiert. Diese Methode unterscheidet sich von zufälliger Übersampling, da sie neue Beispiele erstellt, die nicht nur die Minderheitsklasse duplizieren. Die Methode wird zu einer effektiveren Technik zur Behandlung von ungleichgewichtierten 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()

Screenshot eines Diagramms, das zeigt, dass Stichproben ausgeglichen sind.

Sie haben das Dataset erfolgreich ausgeglichen. Sie können jetzt zur Modellschulung wechseln.

Schritt 4: Trainieren und Bewerten der Modelle

MLflow registriert Modelle, Züge und vergleicht verschiedene Modelle und wählt das beste Modell für Vorhersagezwecke aus. Sie können die folgenden drei Modelle für Modellschulungen verwenden:

  • Zufällige Gesamtstrukturklassifizierung
  • Logistische Regressionsklassifizierung
  • XGBoost-Klassifizierer

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 dem zufälligen Gesamtstrukturklassifizierung einen F1-Score, eine Genauigkeit und eine Wiedererkennung von ungefähr 0,9 ergeben.

Einen logistischen Regressionsklassifikator trainieren

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 eines XGBoost-Klassifizierers

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 Klassifizierer trainiert: Random Forest, logistische Regression und XGBoost. Sie haben jetzt die Wahl, entweder programmgesteuert auf die Ergebnisse zuzugreifen oder die Benutzeroberfläche (UI) zu verwenden.

Navigieren Sie für die Benutzeroberflächenpfad-Option zu Ihrem Arbeitsbereich und filtern Sie die Modelle.

Screenshot des Filters mit ausgewählten Modellen.

Wählen Sie einzelne Modelle aus, um Details zur Modellleistung zu erhalten.

Screenshot der Leistungsdetails für Modelle.

In diesem Beispiel wird gezeigt, 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)

Obwohl XGBoost die besten Ergebnisse auf dem Trainingssatz liefert, schneidet es bei dem Testdatensatz schlecht ab. Diese deutet auf eine Überanpassung hin. Der logistische Regressionsklassifizierer schneidet sowohl bei den Schulungs- als auch bei den Testdatensätzen 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 Random-Forest-Modell aus, und führen Sie eine Vorhersage mit der Funktion PROGNOSE durch.

from synapse.ml.predict import MLFlowTransformer

model = MLFlowTransformer(
    inputCols=list(X_test.columns),
    outputCol='predictions',
    modelName='machine_failure_model_rf',
    modelVersion=1
)

Verwenden Sie das MLFlowTransformer-Objekt, das Sie erstellt haben, um das Modell für Inferenzzwecke zu laden, und nutzen Sie die Transformator-API, um das Modell auf dem Testdatensatz zu bewerten.

predictions = model.transform(spark.createDataFrame(X_test))
predictions.show()

Diese Tabelle zeigt die Ausgabe:

Typ Lufttemperatur_[K] Prozesstemperatur_[K] Drehzahl_[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 Sie die Daten im Lakehouse. Die Daten werden dann für spätere Verwendungen verfügbar – z. B. 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 in einem Offlineformat mit einem Power BI-Dashboard an.

Screenshot der Daten, die als Power BI-Dashboard angezeigt werden.

Das Dashboard zeigt, dass Tool_wear und Torque eine spürbare Grenze zwischen fehlgeschlagenen und nicht fehlerhaften Fällen erstellen, wie aus der früheren Korrelationsanalyse in Schritt 2 erwartet.

Verwandte Inhalte