Selvstudium: Opret, evaluer og scor en model til registrering af maskinfejl
I dette selvstudium præsenteres et helt til slut-eksempel på en Synapse Data Science-arbejdsproces i Microsoft Fabric. Scenariet bruger maskinel indlæring til en mere systematisk tilgang til fejldiagnosticering, til proaktivt at identificere problemer og til at udføre handlinger før en faktisk maskinefejl. Målet er at forudsige, om en maskine vil opleve en fejl baseret på procestemperatur, rotationshastighed osv.
I dette selvstudium beskrives disse trin:
- Installér brugerdefinerede biblioteker
- Indlæs og behandl dataene
- Forstå dataene via udforskning af dataanalyse
- Brug scikit-learn, LightGBM og MLflow til at oplære modeller til maskinel indlæring, og brug funktionen Fabric Autologging til at spore eksperimenter
- Scor de oplærte modeller med Fabric-funktionen
PREDICT, gem den bedste model, og indlæs modellen til forudsigelser - Vis ydeevnen for den indlæste model med Power BI-visualiseringer
Forudsætninger
Få et Microsoft Fabric-abonnement. Du kan også tilmelde dig en gratis Prøveversion af Microsoft Fabric.
Brug oplevelsesskifteren i venstre side af startsiden til at skifte til Synapse Data Science-oplevelsen.
- Hvis det er nødvendigt, skal du oprette et Microsoft Fabric lakehouse som beskrevet i Opret et lakehouse i Microsoft Fabric.
Følg med i en notesbog
Du kan vælge en af disse indstillinger for at følge med i en notesbog:
- Åbn og kør den indbyggede notesbog i datavidenskabsoplevelsen
- Upload din notesbog fra GitHub til datavidenskabsoplevelsen
Åbn den indbyggede notesbog
Notesbogen med computerfejl følger med dette selvstudium.
Sådan åbner du selvstudiets indbyggede eksempelnotesbog i Synapse Data Science-oplevelsen:
Gå til startsiden Synapse Data Science.
Vælg Brug et eksempel.
Vælg det tilsvarende eksempel:
- Fra standardfanen End-to-end-arbejdsprocesser (Python), hvis eksemplet er til et Python-selvstudium.
- Fra fanen Komplette arbejdsprocesser (R), hvis eksemplet er til et R-selvstudium.
- Fra fanen Hurtige selvstudier , hvis eksemplet er til et hurtigt selvstudium.
Vedhæft et lakehouse til notesbogen , før du begynder at køre kode.
Importér notesbogen fra GitHub
Notesbogen AISample – Forudsigende vedligeholdelse følger med dette selvstudium.
Hvis du vil åbne den medfølgende notesbog til dette selvstudium, skal du følge vejledningen i Forbered dit system til selvstudier om datavidenskab for at importere notesbogen til dit arbejdsområde.
Hvis du hellere vil kopiere og indsætte koden fra denne side, kan du oprette en ny notesbog.
Sørg for at vedhæfte et lakehouse til notesbogen , før du begynder at køre kode.
Trin 1: Installér brugerdefinerede biblioteker
I forbindelse med udvikling af modeller til maskinel indlæring eller ad hoc-dataanalyse skal du muligvis hurtigt installere et brugerdefineret bibliotek til din Apache Spark-session. Du har to muligheder for at installere biblioteker.
- Brug funktionerne til indbygget installation (
%pipeller%conda) i notesbogen til at installere et bibliotek, kun i din aktuelle notesbog. - Du kan også oprette et Fabric-miljø, installere biblioteker fra offentlige kilder eller uploade brugerdefinerede biblioteker til det, og derefter kan administratoren af arbejdsområdet vedhæfte miljøet som standard for arbejdsområdet. Alle biblioteker i miljøet bliver derefter tilgængelige til brug i alle notesbøger og Spark-jobdefinitioner i arbejdsområdet. Du kan få flere oplysninger om miljøer under Opret, konfigurer og brug et miljø i Microsoft Fabric.
I dette selvstudium skal du bruge %pip install til at installere imblearn biblioteket i din notesbog.
Bemærk
PySpark-kernen genstartes efter %pip install kørsler. Installer de nødvendige biblioteker, før du kører andre celler.
# Use pip to install imblearn
%pip install imblearn
Trin 2: Indlæs dataene
Datasættet simulerer logføring af en produktionsmaskines parametre som en funktion af tid, hvilket er almindeligt i industrielle indstillinger. Den består af 10.000 datapunkter, der er gemt som rækker med funktioner som kolonner. Funktionerne omfatter:
Et entydigt id (UID), der spænder fra 1 til 10000
Produkt-id, der består af bogstavet L (for lav), M (for medium) eller H (for høj) for at angive produktkvalitetsvarianten og et variantspecifikt serienummer. Varianter af lav, mellem og høj kvalitet udgør henholdsvis 60 %, 30 % og 10 % af alle produkter
Lufttemperatur, i grader Kelvin (K)
Procestemperatur, i grader Kelvin
Rotationshastighed i omdrejninger pr. minut (RPM)
Drejningsmoment, i Newton-meter (Nm)
Værktøjsslitage på få minutter. Kvalitetsvarianterne H, M og L tilføjer henholdsvis 5, 3 og 2 minutters værktøjsslitage til det værktøj, der bruges i processen
En computerfejletiket til at angive, om computeren mislykkedes i det specifikke datapunkt. Dette specifikke datapunkt kan have en af følgende fem uafhængige fejltilstande:
- Værktøjsslitagefejl (TWF): Værktøjet udskiftes eller mislykkes på et tilfældigt valgt værktøjsslitagetid mellem 200 og 240 minutter
- Varmeafledningsfejl (HDF): Varmeafledning medfører en procesfejl, hvis forskellen mellem lufttemperaturen og procestemperaturen er mindre end 8,6 K, og værktøjets rotationshastighed er mindre end 1380 RPM
- Power Failure (PWF): Produktet af drejningsmoment og rotationshastighed (i rad/s) svarer til den strøm, der kræves til processen. Processen mislykkes, hvis denne effekt falder til under 3.500 W eller overstiger 9.000 W
- OverStrain Failure (OSF): Hvis produktet af værktøjsslitage og drejningsmoment overstiger 11.000 Nm for L-produktvarianten (12.000 for M, 13.000 for H), mislykkes processen på grund af overtræning
- Tilfældige fejl (RNF): Hver proces har en fejl chance på 0,1%, uanset procesparametrene
Bemærk
Hvis mindst en af ovenstående fejltilstande er true, mislykkes processen, og mærkaten "computerfejl" er angivet til 1. Metoden til maskinel indlæring kan ikke afgøre, hvilken fejltilstand der forårsagede procesfejlen.
Download datasættet, og upload det til lakehouse
Forbind til Azure Open Datasets-objektbeholderen og indlæse datasættet Forudsigende vedligeholdelse. Denne kode downloader en offentligt tilgængelig version af datasættet og gemmer den derefter i et Fabric lakehouse:
Vigtigt
Føj et lakehouse til notesbogen, før du kører den. Ellers får du vist en fejl. Du kan få oplysninger om tilføjelse af et lakehouse i Forbind lakehouses og notesbøger.
# 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.")
Når du har downloadet datasættet til lakehouse'et, kan du indlæse det som en Spark DataFrame:
df = (
spark.read.option("header", True)
.option("inferSchema", True)
.csv(f"{DATA_FOLDER}raw/{DATA_FILE}")
.cache()
)
df.show(5)
I denne tabel vises et eksempel på dataene:
| UDI | Produkt-id | Skriv | Lufttemperatur [K] | Procestemperatur [K] | Rotationshastighed [rpm] | Drejningsmoment [Nm] | Værktøjsslitage [min] | Destination | Fejltype |
|---|---|---|---|---|---|---|---|---|---|
| 0 | M14860 | M | 298.1 | 308.6 | 1551 | 42.8 | 0 | 0 | Ingen fejl |
| 2 | L47181 | L | 298.2 | 308.7 | 1408 | 46.3 | 3 | 0 | Ingen fejl |
| 3 | L47182 | L | 298.1 | 308.5 | 1498 | 49.4 | 5 | 0 | Ingen fejl |
| 4 | L47183 | L | 298.2 | 308.6 | 1433 | 39.5 | 7 | 0 | Ingen fejl |
| 5 | L47184 | L | 298.2 | 308.7 | 1408 | 40.0 | 9 | 0 | Ingen fejl |
Skriv en Spark DataFrame til en deltatabel i lakehouse
Formatér dataene (erstat f.eks. mellemrummene med understregningstegn) for at lette Spark-handlinger i efterfølgende trin:
# 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)
I denne tabel vises et eksempel på dataene med omformateret kolonnenavne:
| UDI | Product_ID | Skriv | Air_temperature_[K] | Process_temperature_[K] | Rotational_speed_[rpm] | Torque_[Nm] | Tool_wear_[min] | Destination | Failure_Type |
|---|---|---|---|---|---|---|---|---|---|
| 0 | M14860 | M | 298.1 | 308.6 | 1551 | 42.8 | 0 | 0 | Ingen fejl |
| 2 | L47181 | L | 298.2 | 308.7 | 1408 | 46.3 | 3 | 0 | Ingen fejl |
| 3 | L47182 | L | 298.1 | 308.5 | 1498 | 49.4 | 5 | 0 | Ingen fejl |
| 4 | L47183 | L | 298.2 | 308.6 | 1433 | 39.5 | 7 | 0 | Ingen fejl |
| 5 | L47184 | L | 298.2 | 308.7 | 1408 | 40.0 | 9 | 0 | Ingen fejl |
# 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}")
Trin 3: Forbehandler data og udfører udforskningsdataanalyse
Konvertér Spark DataFrame til en pandas DataFrame for at bruge Pandas-kompatible populære afbildningsbiblioteker.
Tip
I forbindelse med et stort datasæt skal du muligvis indlæse en del af dette datasæt.
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()
Konvertér bestemte kolonner i datasættet til flydende eller heltalstyper efter behov, og knyt strenge ('L', 'M', 'H') til numeriske værdier (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})
Udforsk data via visualiseringer
# 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()
Som forventet stemmer fejl (IsFail) overens med de valgte funktioner (kolonner). Korrelationsmatrixen viser, at Air_temperature, Process_temperatureRotational_speed, Torqueog Tool_wear har den højeste korrelation med variablenIsFail.
# 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])
Som de afbildede grafer viser, er variablerne Air_temperature, Rotational_speedProcess_temperature, Torqueog Tool_wear ikke sparsomme. De synes at have god kontinuitet i funktionsområdet. Disse afbildninger bekræfter, at oplæring af en model til maskinel indlæring i dette datasæt sandsynligvis giver pålidelige resultater, der kan generaliseres til et nyt datasæt.
Undersøg målvariablen for klasseubalance
Tæl antallet af eksempler for mislykkede og ikke-fejlede maskiner, og undersøg datasaldoen for hver 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()
Afbildningerne angiver, at klassen no-failure (vist som IsFail=0 i det andet afbildning) udgør de fleste af eksemplerne. Brug en teknik til oversampling til at oprette et mere afbalanceret træningsdatasæt:
# 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}")
Oversampel for at balancere klasser i træningsdatasættet
Den tidligere analyse viste, at datasættet er meget ubalanceret. Denne ubalance bliver et problem, fordi mindretalsklassen har for få eksempler til, at modellen effektivt kan lære beslutningsgrænsen.
SMOTE kan løse problemet. SMOTE er en udbredt oversampling teknik, der genererer syntetiske eksempler. Den genererer eksempler for mindretalsklassen baseret på de euklidiske afstande mellem datapunkter. Denne metode adskiller sig fra tilfældige oversampling, fordi den opretter nye eksempler, der ikke blot duplikerer mindretalsklassen. Metoden bliver en mere effektiv teknik til håndtering af ubalancerede datasæt.
# 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()
Du har balanceret datasættet. Du kan nu gå videre til modeltræning.
Trin 4: Oplær og evaluer modellerne
MLflow registrerer modeller, træner og sammenligner forskellige modeller og vælger den bedste model til forudsigelsesformål. Du kan bruge følgende tre modeller til modeltræning:
- Tilfældig skovklassificering
- Logistisk regressionsklassificering
- XGBoost-klassificering
Oplær en tilfældig skovklassificering
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)
Fra outputtet giver både oplærings- og testdatasættene en F1-score, nøjagtighed og tilbagekaldelse af ca. 0,9, når den tilfældige skovklassificering bruges.
Oplær en logistisk regressionsklassificeringsklasse
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)
Oplær en XGBoost-klassificering
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)
Trin 5: Vælg den bedste model, og forudsig output
I forrige afsnit oplærte du tre forskellige klassificeringer: tilfældig skov, logistisk regression og XGBoost. Du har nu mulighed for enten at få programmatisk adgang til resultaterne eller bruge brugergrænsefladen.
For indstillingen Sti til brugergrænsefladen skal du navigere til dit arbejdsområde og filtrere modellerne.
Vælg individuelle modeller for at få oplysninger om modellens ydeevne.
I dette eksempel kan du se, hvordan du får programmatisk adgang til modellerne via MLflow:
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)
Selvom XGBoost giver de bedste resultater på træningssættet, fungerer det dårligt på testdatasættet. Den dårlige ydeevne indikerer, at den passer for meget. Den logistiske regressionsklassificering fungerer dårligt på både oplærings- og testdatasæt. Samlet set skaber tilfældige skov en god balance mellem træningspræstation og undgåelse af overfitting.
I næste afsnit skal du vælge den registrerede tilfældige skovmodel og udføre en forudsigelse med funktionen PREDICT :
from synapse.ml.predict import MLFlowTransformer
model = MLFlowTransformer(
inputCols=list(X_test.columns),
outputCol='predictions',
modelName='machine_failure_model_rf',
modelVersion=1
)
Med det objekt, MLFlowTransformer du oprettede for at indlæse modellen til udledning, skal du bruge Transformer-API'en til at score modellen i testdatasættet:
predictions = model.transform(spark.createDataFrame(X_test))
predictions.show()
I denne tabel vises outputtet:
| Skriv | Air_temperature_[K] | Process_temperature_[K] | Rotational_speed_[rpm] | Torque_[Nm] | Tool_wear_[min] | Forudsigelser |
|---|---|---|---|---|---|---|
| 0 | 300.6 | 309.7 | 1639.0 | 30.4 | 121.0 | 0 |
| 0 | 303.9 | 313.0 | 1551.0 | 36.8 | 140.0 | 0 |
| 0 | 299.1 | 308.6 | 1491.0 | 38.5 | 166.0 | 0 |
| 0 | 300.9 | 312.1 | 1359.0 | 51.7 | 146.0 | 0 |
| 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 | 0 |
| 0 | 301.3 | 310.3 | 1460.0 | 41.5 | 197.0 | 0 |
| 2 | 297.6 | 309.0 | 1413.0 | 40.2 | 51.0 | 0 |
| 0 | 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 |
| 0 | 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 |
Gem dataene i lakehouse. Dataene bliver derefter tilgængelige til senere brug – f.eks. et 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}")
Trin 6: Få vist business intelligence via visualiseringer i Power BI
Vis resultaterne i offlineformat med et Power BI-dashboard.
Dashboardet viser, at og Tool_wearTorque opret en mærkbar grænse mellem mislykkede og ikke-fejlede sager som forventet fra den tidligere korrelationsanalyse i trin 2.
Relateret indhold
Feedback
Kommer snart: I hele 2024 udfaser vi GitHub-problemer som feedbackmekanisme for indhold og erstatter det med et nyt feedbacksystem. Du kan få flere oplysninger under: https://aka.ms/ContentUserFeedback.
Indsend og få vist feedback om