Kurz: Vytvoření, vyhodnocení a hodnocení modelu detekce chyb počítače
Tento kurz představuje ucelený příklad pracovního postupu pro data science Synapse v Microsoft Fabric. Scénář používá strojové učení k systematičtějšímu přístupu k diagnostice chyb, k proaktivní identifikaci problémů a k provádění akcí před skutečným selháním počítače. Cílem je předpovědět, jestli by u počítače došlo k selhání na základě teploty procesu, rotační rychlosti atd.
Tento kurz se věnuje těmto krokům:
- Instalace vlastních knihoven
- Načtení a zpracování dat
- Vysvětlení dat prostřednictvím průzkumné analýzy dat
- Použijte knihovny scikit-learn, LightGBM a MLflow k trénování modelů strojového učení a funkci Fabric Autologging ke sledování experimentů.
- Určení skóre natrénovaných modelů pomocí funkce
PREDICTFabric, uložení nejlepšího modelu a načtení modelu pro předpovědi - Zobrazení výkonu načteného modelu pomocí vizualizací Power BI
Požadavky
Získejte předplatné Microsoft Fabric. Nebo si zaregistrujte bezplatnou zkušební verzi Microsoft Fabric.
Přihlaste se k Microsoft Fabric.
Pomocí přepínače zkušenosti v levém dolním rohu vaší domovské stránky přepněte na Fabric.
- V případě potřeby vytvořte Microsoft Fabric lakehouse, jak je popsáno v Vytvoření lakehouse v Microsoft Fabric.
Sledujte v poznámkovém bloku
V poznámkovém sešitu můžete zvolit jednu z těchto možností:
- Otevřete a spusťte integrovaný poznámkový blok.
- Nahrajte poznámkový blok z GitHubu.
Otevření integrovaného poznámkového bloku
Tento tutoriál doprovází ukázkový poznámkový blok poruchy stroje .
Pokud chcete otevřít ukázkový poznámkový blok pro tento kurz, postupujte podle pokynů v Příprava systému na kurzy datových věd.
Než začnete spouštět kód, nezapomeňte k poznámkovému bloku připojit lakehouse.
Import poznámkového bloku z GitHubu
Tento kurz doprovází poznámkový blok AISample – prediktivní údržba.
Pokud chcete otevřít doprovodný poznámkový blok pro tento kurz, postupujte podle pokynů v tématu Příprava systému na kurzy datových věd pro import poznámkového bloku do vašeho pracovního prostoru.
Pokud chcete raději zkopírovat a vložit kód z této stránky, můžete vytvořit nový poznámkový blok.
Než začnete spouštět kód, nezapomeňte k poznámkovému bloku připojit lakehouse.
Krok 1: Instalace vlastních knihoven
Pro vývoj modelů strojového učení nebo ad hoc analýzu dat možná budete muset rychle nainstalovat vlastní knihovnu pro relaci Apache Sparku. Máte dvě možnosti instalace knihoven.
- Pomocí funkcí pro přímou instalaci (
%pipnebo%conda) poznámkového bloku nainstalujte knihovnu pouze v aktuálním poznámkovém bloku. - Alternativně můžete vytvořit Fabric prostředí, nainstalovat knihovny z veřejných zdrojů nebo do něj nahrát vlastní knihovny, a správce pracovního prostoru poté může toto prostředí připojit jako výchozí pro pracovní prostor. Všechny knihovny v prostředí se pak zpřístupní pro použití v poznámkových blocích a definicích úloh Sparku v pracovním prostoru. Další informace o prostředích najdete v tématu vytvoření, konfigurace a použití prostředí v Microsoft Fabric.
Pro účely tohoto kurzu použijte %pip install k instalaci knihovny imblearn do notebooku.
Poznámka
Po spuštění %pip install se jádro PySpark restartuje. Před spuštěním jiných buněk nainstalujte potřebné knihovny.
# Use pip to install imblearn
%pip install imblearn
Krok 2: Načtení dat
Datová sada simuluje protokolování parametrů výrobního stroje jako funkci času, což je běžné v průmyslových nastaveních. Skládá se z 10 000 datových bodů uložených jako řádky s funkcemi jako sloupci. Mezi tyto funkce patří:
Jedinečný identifikátor (UID), který se pohybuje od 1 do 1 0000
ID výrobku, které se skládá z písmene L (pro nízké), M (pro střední) nebo H (pro vysoké), označující variantu kvality výrobku a sériové číslo specifické pro variantu. Nízké, střední a vysoce kvalitní varianty tvoří 60%, 30%a 10% všech výrobků
Teplota vzduchu ve stupních Kelvin (K)
Teplota procesu ve stupních Kelvin
Rychlost otáčení v otáčkách za minutu (RPM)
Točivý moment v Newton-Meters (Nm)
Opotřebení nástroje v minutách. Varianty kvality H, M a L přidávají k času opotřebení nástroje použitého v procesu 5, 3 a 2 minuty.
Popisek selhání počítače, který označuje, jestli počítač selhal v konkrétním datovém bodě. Tento konkrétní datový bod může mít některý z následujících pěti nezávislých režimů selhání:
- Chyba opotřebení nástrojů (TWF): Nástroj se nahradí nebo selže v náhodně vybrané době opotřebení nástroje v rozmezí 200 až 240 minut.
- Selhání rozdělení tepla (HDF): Rozdělení tepla způsobí selhání procesu, pokud je rozdíl mezi teplotou vzduchu a teplotou procesu menší než 8,6 K a rotační rychlost nástroje je menší než 1380 RPM.
- Selhání napájení (PWF): součin momentu a rotační rychlosti (v radi/s) se rovná výkonu požadovanému pro proces. Proces selže, pokud tento výkon klesne pod 3 500 W nebo překročí 9 000 W.
- OverStrain Failure (OSF): Pokud násobek opotřebení nástroje a točivého momentu překročí 11 000 minimálních Nm pro variantu produktu L (12 000 pro M, 13 000 pro H), proces selže kvůli přetížení.
- Náhodná selhání (RNF): každý proces má šanci na selhání 0,1%, bez ohledu na parametry procesu
Poznámka
Pokud platí alespoň jeden z výše uvedených režimů selhání, proces selže a popisek "selhání počítače" je nastaven na hodnotu 1. Metoda strojového učení nemůže určit, který režim selhání způsobil selhání procesu.
Stáhněte datovou sadu a nahrajte do lakehouse systému.
Připojte se ke kontejneru Azure Open Datasets a načtěte datovou sadu prediktivní údržby. Tento kód stáhne veřejně dostupnou verzi datové sady a pak ji uloží do objektu Fabric Lakehouse:
Důležitý
Před spuštěním poznámkového bloku přidejte do jeho nastavení lakehouse. V opačném případě se zobrazí chyba. Pro informace o přidání Lakehouse naleznete v tématu Lakehouse a připojení poznámkových bloků.
# 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.")
Po stažení datové sady do jezera ji můžete načíst jako datový rámec Sparku:
df = (
spark.read.option("header", True)
.option("inferSchema", True)
.csv(f"{DATA_FOLDER}raw/{DATA_FILE}")
.cache()
)
df.show(5)
Tato tabulka ukazuje náhled dat:
| UDI | ID produktu | Typ | Teplota vzduchu [K] | Teplota procesu [K] | Rychlost otáčení [ot/min] | Točivý moment [Nm] | Opotřebení nástroje [min] | Cíl | Typ selhání |
|---|---|---|---|---|---|---|---|---|---|
| 1 | M14860 | M | 298.1 | 308.6 | 1551 | 42.8 | 0 | 0 | Bez selhání |
| 2 | L47181 | L | 298.2 | 308.7 | 1408 | 46.3 | 3 | 0 | Bez selhání |
| 3 | L47182 | L | 298.1 | 308.5 | 1498 | 49.4 | 5 | 0 | Bez selhání |
| 4 | L47183 | L | 298.2 | 308.6 | 1433 | 39.5 | 7 | 0 | Bez selhání |
| 5 | L47184 | L | 298.2 | 308.7 | 1408 | 40.0 | 9 | 0 | Bez selhání |
Zápis datového rámce Sparku do tabulky Delta lakehouse
Naformátujte data (například nahraďte mezery podtržítky), aby se usnadnily operace Sparku v následujících krocích:
# 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)
Tato tabulka ukazuje náhled dat s přeformátovanými názvy sloupců:
| UDI | Identifikátor_produktu | Typ | Teplota_vzduchu_[K] | Procesní_teplota_[K] | Otáčky_[rpm] | Torque_[Nm] | Opotřebení nástroje [min] | Cíl | Typ_Selhání |
|---|---|---|---|---|---|---|---|---|---|
| 1 | M14860 | M | 298.1 | 308.6 | 1551 | 42.8 | 0 | 0 | Bez selhání |
| 2 | L47181 | L | 298.2 | 308.7 | 1408 | 46.3 | 3 | 0 | Bez selhání |
| 3 | L47182 | L | 298.1 | 308,5 | 1498 | 49.4 | 5 | 0 | Bez selhání |
| 4 | L47183 | L | 298.2 | 308,6 | 1433 | 39.5 | 7 | 0 | Bez selhání |
| 5 | L47184 | L | 298.2 | 308.7 | 1408 | 40.0 | 9 | 0 | Bez selhání |
# 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}")
Krok 3: Předběžné zpracování dat a provádění průzkumné analýzy dat
Převeďte datový rámec Sparku na datový rámec pandas a použijte oblíbené knihovny vykreslování kompatibilní s Pandas.
Spropitné
U velké datové sady možná budete muset načíst část této datové sady.
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()
Podle potřeby převeďte konkrétní sloupce datové sady na plovoucí nebo celočíselné typy a řetězce mapování ('L', 'M', 'H') na číselné hodnoty (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})
Prozkoumání dat prostřednictvím vizualizací
# 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()
Podle očekávání koreluje selhání (IsFail) s vybranými funkcemi (sloupci). Matice korelace ukazuje, že Air_temperature, Process_temperature, Rotational_speed, Torquea Tool_wear mají nejvyšší korelaci s proměnnou IsFail.
# 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])
Jak znázorňují vykreslené grafy, nejsou Air_temperature, Process_temperature, Rotational_speed, Torquea proměnné Tool_wear řídké. Zdá se, že mají v prostoru vlastností dobrou kontinuitu. Tyto grafy potvrdí, že trénování modelu strojového učení na této datové sadě pravděpodobně vede ke spolehlivým výsledkům, které se dají zobecnit na novou datovou sadu.
Zkontrolujte nevyrovnanost tříd v cílové proměnné
Spočítejte počet vzorků pro neúspěšné a úspěšné stroje a zkontrolujte rovnováhu dat pro každou třídu (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()
Grafy označují, že většina vzorků představuje třídu bez selhání (zobrazenou jako IsFail=0 v druhém grafu). Pomocí techniky převzorkování vytvořte vyváženější trénovací datovou sadu:
# 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}")
Převzorkování tříd v trénovací datové sadě
Předchozí analýza ukázala, že datová sada je vysoce nevyvážená. Tato nerovnováha se stává problémem, protože menšinová třída má příliš málo příkladů, aby se model efektivně naučil rozhodovací hranici.
SMOTE problém vyřeší. SMOTE je široce používaná technika převzorkování, která generuje syntetické příklady. Generuje příklady menšinové třídy na základě euklidiánských vzdáleností mezi datovými body. Tato metoda se liší od náhodného převzorkování, protože vytváří nové příklady, které ne pouze duplikují menšinovou třídu. Metoda se stává efektivnější technikou pro zpracování nevyvážených datových sad.
# 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()
Datovou sadu jste úspěšně vyrovnali. Teď můžete přejít na trénování modelu.
Krok 4: Trénování a vyhodnocení modelů
MLflow registruje modely, trénuje a porovnává různé modely a vybírá nejlepší model pro účely predikce. Pro trénování modelů můžete použít následující tři modely:
- Klasifikátor náhodného lesa
- Klasifikátor logistické regrese
- Klasifikátor XGBoost
Trénovat klasifikátor náhodných lesů
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)
Z výstupu poskytují trénovací i testovací datové sady skóre F1, přesnost a citlivost přibližně 0,9 při použití klasifikátoru náhodného lesa.
Trénování klasifikátoru logistické regrese
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)
Trénování klasifikátoru XGBoost
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)
Krok 5: Výběr nejlepšího modelu a predikce výstupů
V předchozí části jste vytrénovali tři různé klasifikátory: náhodný les, logistickou regresi a XGBoost. Teď máte možnost získat přístup k výsledkům prostřednictvím kódu programu nebo použít uživatelské rozhraní.
Pro možnost cesta k uživatelskému rozhraní přejděte do svého pracovního prostoru a vyfiltrujte modely.
Výběrem jednotlivých modelů zobrazíte podrobnosti o výkonu modelu.
Tento příklad ukazuje, jak programově přistupovat k modelům prostřednictvím 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)
I když XGBoost poskytuje nejlepší výsledky v trénovací sadě, funguje špatně na testovací sadě. Tento slabý výkon značí přeučení. Klasifikátor logistické regrese má špatný výkon jak u trénovacích, tak testovacích datových sad. Náhodný les celkově představuje dobrou rovnováhu mezi výkonem učení a zabráněním přeučení.
V další části zvolte registrovaný model náhodného lesa a proveďte predikci pomocí funkce PREDICT:
from synapse.ml.predict import MLFlowTransformer
model = MLFlowTransformer(
inputCols=list(X_test.columns),
outputCol='predictions',
modelName='machine_failure_model_rf',
modelVersion=1
)
S objektem MLFlowTransformer, který jste vytvořili k načtení modelu pro odvozování, použijte rozhraní Transformer API k určení skóre modelu na testovací datové sadě:
predictions = model.transform(spark.createDataFrame(X_test))
predictions.show()
Tato tabulka ukazuje výstup:
| Typ | Teplota_vzduchu_[K] | Teplota_procesu_[K] | Otáčky [rpm] | Torque_[Nm] | Opotřebení_nástroje_[min] | předpovědi |
|---|---|---|---|---|---|---|
| 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 |
Uložte data do jezera. Data se pak zpřístupní pro pozdější použití – například řídicí panel Power BI.
# 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}")
Krok 6: Zobrazení business intelligence prostřednictvím vizualizací v Power BI
Zobrazte výsledky v offline formátu pomocí řídicího panelu Power BI.
Řídicí panel ukazuje, že Tool_wear a Torque vytvářejí znatelnou hranici mezi neúspěšnými a úspěšnými případy, jak bylo očekáváno z předchozí korelační analýzy ve kroku 2.