Eğitim: Makine hata algılama modelini oluşturma, değerlendirme ve puanlama

Bu eğitim, Microsoft Fabric'te uçtan uca bir Veri Bilimi iş akışı örneği sunmaktadır. Senaryo, sorunları proaktif olarak belirlemek ve gerçek bir makine hatasından önce eyleme geçmek için hata tanılamaya daha sistematik bir yaklaşım için machine learning kullanır. Amaç, bir makinenin işlem sıcaklığına, dönme hızına ve diğer faktörlere göre hata yaşayıp yaşamayacağını tahmin etmektir.

Bu öğretici şu adımları kapsar:

Özel kitaplıkları yükleme
Verileri yükleme ve işleme
Keşif veri analizi aracılığıyla verileri anlama
machine learning modelleri eğitmek için scikit-learn, LightGBM ve MLflow kullanın ve denemeleri izlemek için Doku Otomatik Kaydetme özelliğini kullanın
Eğitilen modelleri Doku PREDICT özelliğiyle puanlayıp en iyi modeli kaydedin ve tahminler için bu modeli yükleyin
Power BI görselleştirmeleriyle yüklenen model performansını gösterme

Önkoşullar

Microsoft Fabric aboneliği alın. Alternatif olarak ücretsiz Microsoft Fabric deneme sürümüne kaydolabilirsiniz.
Microsoft Fabric'e giriş yapın.
Ana sayfanızın sol alt tarafındaki deneyim değiştiriciyi kullanarak Fabric'e geçin.

Gerekirse, Microsoft Fabric'te bir göl evi oluşturma açıklamasında belirtildiği gibi Microsoft Fabric içinde bir lakehouse oluşturun.

Bir not defterinde takip etme

Not defterinde takip etmek için şu seçeneklerden birini belirleyin:

Yerleşik not defterini açın ve çalıştırın.
Not defterinizi GitHub yükleyin.

Yerleşik not defterini açma

Örnek Makine hatası not defteri bu öğreticiye eşlik eder.

Bu öğreticinin örnek not defterini açmak için Sisteminizi veri bilimi öğreticilerine hazırlamabaşlığındaki yönergeleri izleyin.
Kodu çalıştırmaya başlamadan önce not defterine bir göl evi eklediğinizden emin olun.

Not defterini GitHub'dan içeri aktarma

AISample - Tahmine Dayalı Bakım not defteri bu öğreticiye eşlik eder.

Bu öğreticiye eşlik eden not defterini açmak için, sisteminizi veri bilimi öğreticilerine hazırlama ve not defterini çalışma alanınıza aktarma başlıklarındaki yönergeleri izleyin.
Bu sayfadaki kodu kopyalayıp yapıştırmayı tercih ederseniz, yeni bir not defteri oluşturabilirsiniz.
Kod çalıştırmaya başlamadan önce not defteri bir göl evi eklemeyi unutmayın.

1. Adım: Özel kitaplıkları yükleme

machine learning model geliştirme veya geçici veri analizi için Apache Spark oturumunuz için hızlı bir şekilde özel bir kitaplık yüklemeniz gerekebilir. Kitaplıkları yüklemek için iki seçeneğiniz vardır.

Not defterinizin yerleşik yükleme yeteneklerini (%pip veya %conda) kullanarak yalnızca geçerli not defterinize bir kitaplık yükleyin.
Alternatif olarak, bir Doku ortamı oluşturabilir, ortak kaynaklardan kitaplıklar yükleyebilir veya özel kitaplıklar yükleyebilirsiniz ve çalışma alanı yöneticiniz ortamı çalışma alanı için varsayılan olarak ekleyebilir. Daha sonra ortamdaki tüm kitaplıklar çalışma alanındaki tüm not defterlerinde ve Spark iş tanımlarında kullanılabilir hale gelir. Ortamlar hakkında daha fazla bilgi için Microsoft Fabric'te bir ortam oluşturma, yapılandırma ve kullanma başlığına bakın.

Bu öğreticide, not defterinize %pip install kitaplığını yüklemek için imblearn kullanın.

Not

%pip install çalıştırıldıktan sonra PySpark çekirdeği yeniden başlatılır. Diğer hücreleri çalıştırmadan önce gerekli kitaplıkları yükleyin.

# Use pip to install imblearn
%pip install imblearn

2. Adım: Verileri yükleme

Veri kümesi, endüstriyel ortamlarda yaygın olan, üretim makinesinin parametrelerinin zamanla kaydedilmesini simüle eder. Sütun olarak özelliklere sahip satır olarak depolanan 10.000 veri noktasından oluşur. Özellikler şunlardır:

1 ile 10.000 arasında bir benzersiz tanımlayıcı (UID).
Ürün kalitesi değişkenini ve değişkene özgü seri numarasını belirtmek için L harfi (düşük için), M (orta için) veya H (yüksek için) içeren ürün kimliği. Düşük, orta ve yüksek kaliteli çeşitler sırasıyla tüm ürünlerin 60%, 30%ve 10% oluşturur.
Hava sıcaklığı, Kelvin (K) derecesinde.
İşlem sıcaklığı, Kelvin derecesinde.
Dönme hızı, dakika başına devir sayısı (RPM).
Tork, Newton-Meters (Nm).
Alet aşınması, dakikalar içinde. Kalite varyantları H, M ve L, işlemde kullanılan takıma sırasıyla 5, 3 ve 2 dakika takım aşınması ekler.
Makinenin belirli bir veri noktasında başarısız olup olmadığını gösteren bir makine hatası etiketi. Bu belirli veri noktası aşağıdaki beş bağımsız hata modundan herhangi birine sahip olabilir:
- Takım Aşınma Hatası (TWF): Takım, 200 ila 240 dakika arasında rastgele seçilen bir aşınma zamanında değiştirilir veya başarısız olur.
- Isı Dağılımı Hatası (HDF): Hava sıcaklığı ile işlem sıcaklığı arasındaki fark 8,6 K'den düşükse ve aracın dönme hızı 1.380 RPM'den düşükse ısı dağılımı bir işlem hatasına neden olur
- Güç Arızası (PWF): Tork ve dönme hızının (rad/sn cinsinden) ürünü, işlem için gereken güce eşittir. Bu güç 3.500 W'nin altına düştüğünde veya 9.000 W'ı aştığında işlem başarısız olur.
- OverStrain Failure (OSF): Takım aşınması ve tork ürünü L ürün çeşidi için minimum 11.000 Nm'yi aşarsa (M için 12.000, H için 13.000), işlem aşırı sınırdan dolayı başarısız olur.
- Rastgele Hatalar (RNF): İşlem parametrelerinden bağımsız olarak her işlemin%0,1 hata olasılığı vardır.

Not

Yukarıdaki hata modlarından en az biri doğruysa, işlem başarısız olur ve makine hatası etiketi 1 olarak ayarlanır. machine learning yöntemi, işlem hatasına hangi hata modunun neden olduğunu belirleyemiyor.

Veri kümesini indirin ve lakehouse'a yükleyin

Azure Açık Veri Kümeleri kapsayıcısına bağlanın ve Tahmine Dayalı Bakım veri kümesini yükleyin. Bu kod, veri kümesinin genel kullanıma açık bir sürümünü indirir ve ardından bir Fabric lakehouse'da depolar:

Önemli

Çalıştırmadan önce not defterine bir göl evi ekleyin. Aksi takdirde bir hata alırsınız. Göl evi ekleme hakkında bilgi için bkz. göl evlerini ve not defterlerini bağlama .

# 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.z13.web.core.windows.net/data/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.")

Veri kümesini lakehouse'a indirdikten sonra Spark DataFrame olarak yükleyebilirsiniz:

df = (
    spark.read.option("header", True)
    .option("inferSchema", True)
    .csv(f"{DATA_FOLDER}raw/{DATA_FILE}")
    .cache()
)
df.show(5)

Bu tabloda verilerin önizlemesi gösterilir:

UDI	Ürün Kimliği	Tip	Hava sıcaklığı [K]	İşlem sıcaklığı [K]	Dönme hızı [rpm]	Tork [Nm]	Takım aşınması [dak]	Hata Türü
1	M14860	M	298.1	308.6	1551	42.8	0	Hata Yok
2	L47181	L	298.2	308.7	1408	46.3	3	Hata Yok
3	L47182	L	298.1	308.5	1498	49.4	5	Hata Yok
4	L47183	L	298.2	308.6	1433	39.5	7	Hata Yok
5	L47184	L	298.2	308.7	1408	40.0	9	Hata Yok

Spark DataFrame'i bir lakehouse delta tablosuna yazın

Sonraki adımlarda Spark işlemlerini kolaylaştırmak için verileri biçimlendirin (örneğin, boşlukları alt çizgilerle değiştirin):

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

Bu tabloda, yeniden biçimlendirilmiş sütun adlarıyla verilerin önizlemesi gösterilir:

UDI	Ürün_Kimliği	Tip	Hava_sıcaklığı_[K]	İşlem_sıcaklığı_[K]	Dönme_hızı_[rpm]	Torque_[Nm]	Alet aşınması [dakika]	Hata_Türü
1	M14860	M	298.1	308.6	1551	42.8	0	Hata Yok
2	L47181	L	298.2	308.7	1408	46.3	3	Hata Yok
3	L47182	L	298.1	308.5	1498	49.4	5	Hata Yok
4	L47183	L	298.2	308.6	1433	39.5	7	Hata Yok
5	L47184	L	298.2	308.7	1408	40.0	9	Hata Yok

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

3. Adım: Verileri ön işleme ve keşif veri analizi gerçekleştirme

Spark DataFrame'i pandas DataFrame'e dönüştürerek Pandas uyumlu popüler çizim kitaplıklarını kullanın.

Bahşiş

Büyük bir veri kümesi için bu veri kümesinin bir bölümünü yüklemeniz gerekebilir.

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()

Veri kümesinin belirli sütunlarını gerektiği gibi float veya tamsayı türlerine dönüştürün ve dizeleri ('L', 'M', 'H') sayısal değerlere (0, 1, 2) eşleyin:

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

Görselleştirmeler aracılığıyla verileri keşfetme

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

Beklendiği gibi, hata (IsFail) seçili özelliklerle (sütunlar) bağıntılı olur. Bağıntı matrisi, Air_temperature, Process_temperature, Rotational_speed, Torqueve Tool_wearIsFail değişkeniyle en yüksek bağıntıya sahip olduğunu gösterir.

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

Çizilen grafiklerde gösterildiği gibi, Air_temperature, Process_temperature, Rotational_speed, Torqueve Tool_wear değişkenleri seyrek değildir. Özellik alanında iyi bir sürekliliğe sahip gibi görünüyorlar. Bu çizimler, bu veri kümesinde bir machine learning modelini eğitmek büyük olasılıkla yeni bir veri kümesine genelleştirilebilen güvenilir sonuçlar üretir.

Sınıf dengesizliği için hedef değişkeni inceleme

Başarısız ve başarısız olmayan makineler için örnek sayısını hesaplayın ve her sınıf için veri dengesini inceleyin (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()

Çizimler hata yok sınıfının (ikinci çizimde IsFail=0 olarak gösterilir) örneklerin çoğunu oluşturduğunu gösterir. Daha dengeli bir eğitim veri kümesi oluşturmak için bir fazla örnekleme tekniği kullanın:

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

Eğitim veri kümesindeki sınıfları dengelemek için fazla örnekleme

Önceki analiz, veri kümesinin yüksek oranda dengesiz olduğunu göstermektedir. Azınlık sınıfının modelin karar sınırını etkili bir şekilde öğrenememesi için yeterli örneği olmadığından, bu dengesizlik bir sorun haline gelir.

SMOTE sorunu çözer. SMOTE, yapay örnekler oluşturan yaygın olarak kullanılan bir oversampling tekniğidir. Veri noktaları arasındaki Öklid mesafelerini temel alarak azınlık sınıfı için örnekler oluşturur. Bu yöntem, yalnızca azınlık sınıfını çoğaltmayan yeni örnekler oluşturduğundan rastgele aşırı örneklemeden farklıdır. yöntemi, dengesiz veri kümelerini işlemek için daha etkili bir teknik haline gelir.

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

Veri kümesini başarıyla dengelediyseniz. Artık model eğitimine geçebilirsiniz.

4. Adım: Modelleri eğitme ve değerlendirme

MLflow modelleri kaydeder, çeşitli modelleri eğitip karşılaştırır ve tahmin amacıyla en iyi modeli seçer. Model eğitimi için aşağıdaki üç modeli kullanabilirsiniz:

Rastgele orman sınıflandırıcısı
Lojistik regresyon sınıflandırıcısı
XGBoost sınıflandırıcısı

Rastgele bir orman sınıflandırıcısı eğitin

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)

Çıktıdan, random forest sınıflandırıcısı kullanıldığında hem eğitim hem de test veri kümeleri yaklaşık 0,9 F1 puanı, doğruluk ve geri çağırma oranı elde eder.

Lojistik regresyon sınıflandırıcıyı eğitme

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)

XGBoost sınıflandırıcıyı eğitin

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)

5. Adım: En iyi modeli seçin ve çıkışları tahmin edin

Önceki bölümde üç farklı sınıflandırıcı eğittiniz: rastgele orman, lojistik regresyon ve XGBoost. Artık sonuçlara program aracılığıyla erişim veya kullanıcı arabirimini (UI) kullanma seçeneğiniz vardır.

Kullanıcı arabirimi yolu seçeneği için çalışma alanınıza gidin ve modelleri filtreleyin.

Model performansının ayrıntıları için tek tek modelleri seçin.

Bu örnek, MLflow aracılığıyla modellere programatik olarak nasıl erişileceğini göstermektedir.

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 eğitim kümesinde en iyi sonuçları verse de test veri kümesinde kötü performans gösterir. Bu zayıf performans, aşırı uyum olduğunu gösterir. Lojistik regresyon sınıflandırıcısı hem eğitim hem de test veri kümelerinde kötü performans gösterir. Genel olarak rastgele orman, eğitim performansı ile fazla uygunluktan kaçınma arasında iyi bir denge oluşturur.

Sonraki bölümde kayıtlı rastgele orman modelini seçin ve 'Tahmin Et' özelliği ile bir tahmin gerçekleştirin.

from synapse.ml.predict import MLFlowTransformer

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

Modeli çıkarım için yüklemek üzere oluşturduğunuz MLFlowTransformer nesnesiyle, test veri kümesinde modeli puanlamak için Transformer API'sini kullanın:

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

Bu tabloda çıkış gösterilmektedir:

Tip	Hava_sıcaklığı_[K]	İşlem_sıcaklığı_[K]	Dönme_hızı_[rpm]	Torque_[Nm]	Alet aşınması [dakika]	Öngörüler
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

Verileri lakehouse'a kaydedin. Daha sonra veriler daha sonra kullanılabilir duruma gelir ( örneğin, bir Power BI panosu).

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

6. Adım: Power BI'da görselleştirmeler aracılığıyla iş zekası görüntüleme

Power BI panosuyla sonuçları çevrimdışı biçimde gösterin.

Pano, Tool_wear ve Torque, 2. adımda önceki bağıntı analizinden beklendiği gibi başarısız ve bozulmamış durumlar arasında fark edilebilir bir sınır oluşturduğunu gösterir.

Metin sınıflandırma modelini eğitip değerlendirme
Microsoft Fabric'te Makine Öğrenimi Modeli
Makine öğrenimi modellerini eğit
Microsoft Fabric'de makine öğrenimi deneyleri

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-03-11