Samouczek: tworzenie, ocenianie i ocenianie modelu wykrywania oszustw

Artykuł
01/23/2024

Ten samouczek przedstawia pełny przykład przepływu pracy usługi Synapse Nauka o danych w usłudze Microsoft Fabric. Scenariusz tworzy model wykrywania oszustw przy użyciu algorytmów uczenia maszynowego wyszkolonych na danych historycznych. Następnie używa modelu do wykrywania przyszłych fałszywych transakcji.

W tym samouczku opisano następujące kroki:

Instalowanie bibliotek niestandardowych
Ładowanie danych
Omówienie i przetwarzanie danych za pomocą eksploracyjnej analizy danych
Używanie biblioteki scikit-learn do trenowania modelu uczenia maszynowego i śledzenia eksperymentów za pomocą funkcji automatycznego rejestrowania MLflow i sieci szkieletowej
Zapisywanie i rejestrowanie modelu uczenia maszynowego o najwyższej wydajności
Ładowanie modelu uczenia maszynowego do oceniania i przewidywania

Wymagania wstępne

Uzyskaj subskrypcję usługi Microsoft Fabric. Możesz też utworzyć konto bezpłatnej wersji próbnej usługi Microsoft Fabric.
Zaloguj się do usługi Microsoft Fabric.
Użyj przełącznika środowiska po lewej stronie głównej, aby przełączyć się na środowisko usługi Synapse Nauka o danych.

W razie potrzeby utwórz magazyn lakehouse usługi Microsoft Fabric zgodnie z opisem w temacie Tworzenie magazynu lakehouse w usłudze Microsoft Fabric.

Postępuj zgodnie z instrukcjami w notesie

Możesz wybrać jedną z tych opcji, które należy wykonać w notesie:

Otwieranie i uruchamianie wbudowanego notesu w środowisku Nauka o danych
Przekazywanie notesu z usługi GitHub do środowiska Nauka o danych

Otwieranie wbudowanego notesu

W tym samouczku dołączymy przykładowy notes wykrywania oszustw.

Aby otworzyć wbudowany notes przykładowy samouczka w środowisku usługi Synapse Nauka o danych:

Przejdź do strony głównej usługi Synapse Nauka o danych.
Wybierz pozycję Użyj przykładu.
Wybierz odpowiedni przykład:
- Na domyślnej karcie Kompleksowe przepływy pracy (Python), jeśli przykład dotyczy samouczka dotyczącego języka Python.
- Na karcie Kompleksowe przepływy pracy (R), jeśli przykład dotyczy samouczka języka R.
- Jeśli przykład jest przeznaczony do szybkiego samouczka, na karcie Szybkie samouczki .
Przed rozpoczęciem uruchamiania kodu dołącz usługę Lakehouse do notesu .

Importowanie notesu z usługi GitHub

Notes AIsample — Fraud Detection.ipynb jest dołączony do tego samouczka.

Aby otworzyć towarzyszący notes na potrzeby tego samouczka, postępuj zgodnie z instrukcjami w temacie Przygotowywanie systemu do celów nauki o danych, aby zaimportować notes do obszaru roboczego.

Jeśli wolisz skopiować i wkleić kod z tej strony, możesz utworzyć nowy notes.

Przed rozpoczęciem uruchamiania kodu pamiętaj, aby dołączyć usługę Lakehouse do notesu .

Krok 1. Instalowanie bibliotek niestandardowych

W przypadku tworzenia modeli uczenia maszynowego lub analizy danych ad hoc może być konieczne szybkie zainstalowanie biblioteki niestandardowej na potrzeby sesji platformy Apache Spark. Dostępne są dwie opcje instalowania bibliotek.

Użyj wbudowanych funkcji instalacji (%pip lub %conda) notesu, aby zainstalować bibliotekę tylko w bieżącym notesie.
Alternatywnie możesz utworzyć środowisko sieci szkieletowej, zainstalować biblioteki ze źródeł publicznych lub przekazać do niego biblioteki niestandardowe, a następnie administrator obszaru roboczego może dołączyć środowisko jako domyślne dla obszaru roboczego. Wszystkie biblioteki w środowisku staną się następnie dostępne do użycia w dowolnych notesach i definicjach zadań platformy Spark w obszarze roboczym. Aby uzyskać więcej informacji na temat środowisk, zobacz tworzenie, konfigurowanie i używanie środowiska w usłudze Microsoft Fabric.

Na potrzeby tego samouczka użyj polecenia %pip install , aby zainstalować bibliotekę imblearn w notesie.

Uwaga

Jądro PySpark jest uruchamiane ponownie po %pip install uruchomieniu. Zainstaluj wymagane biblioteki przed uruchomieniem innych komórek.

# Use pip to install imblearn
%pip install imblearn

Krok 2. Ładowanie danych

Zestaw danych wykrywania oszustw zawiera transakcje kart kredytowych od września 2013 r., które europejskie posiadacze kart dokonali w ciągu dwóch dni. Zestaw danych zawiera tylko cechy liczbowe z powodu przekształcenia analizy głównych składników (PCA) zastosowanego do oryginalnych funkcji. Analiza PCA przekształciła wszystkie funkcje z wyjątkiem elementów Time i Amount. Aby chronić poufność, nie możemy podać oryginalnych funkcji ani więcej podstawowych informacji o zestawie danych.

Te szczegóły opisują zestaw danych:

Funkcje V1, , V2, V3, ..., V28 są głównymi składnikami uzyskanymi za pomocą pcA
Funkcja Time zawiera liczbę sekund między transakcją a pierwszą transakcją w zestawie danych
Ta Amount funkcja jest kwotą transakcji. Tej funkcji można używać na przykład uczenia zależnego od kosztów
Kolumna Class jest zmienną odpowiedzi (docelową). Ma wartość 1 oszustwa, a 0 w przeciwnym razie

Tylko 492 transakcje, z 284 807 transakcji łącznie, są fałszywe. Zestaw danych jest wysoce niezrównoważony, ponieważ mniejszość (oszukańcza) stanowi tylko około 0,172% danych.

W tej tabeli przedstawiono podgląd danych creditcard.csv :

Czas	Wersja 1	Wersja 2	V3	V4	V5	V6	V7	V8	Wersja 9	Wersja 10	Wersja 11	Wersja 12	Wersja 13	Wersja 14	Wersja 15	Wersja 16	Wersja 17	Wersja 18	Wersja 19	Wersja 20	Wersja 21	Wersja 22	Wersja 23	Wersja 24	Wersja 25	Wersja 26	Wersja 27	Wersja 28	Kwota	Klasa
0	-1.3598071336738	-0.0727811733098497	2.53634673796914	1.37815522427443	-0.338320769942518	0.462387777762292	0.239598554061257	0.0986979012610507	0.363786969611213	0.0907941719789316	-0.551599533260813	-0.617800855762348	-0.991389847235408	-0.311169353699879	1.46817697209427	-0.470400525259478	0.207971241929242	0.0257905801985591	0.403992960255733	0.251412098239705	-0.018306777944153	0.277837575558899	-0.110473910188767	0.0669280749146731	0.128539358273528	-0.189114843888824	0.133558376740387	-0.0210530534538215	149.62	„0”
0	1.19185711131486	0.26615071205963	0.16648011335321	0.448154078460911	0.0600176492822243	-0.0823608088155687	-0.0788029833323113	0.0851016549148104	-0.255425128109186	-0.166974414004614	1.61272666105479	1.06523531137287	0.48909501589608	-0.143772296441519	0.635558093258208	0.463917041022171	-0.114804663102346	-0.183361270123994	-0.145783041325259	-0.0690831352230203	-0.225775248033138	-0.638671952771851	0.101288021253234	-0.339846475529127	0.167170404418143	0.125894532368176	-0.00898309914322813	0.0147241691924927	2.69	„0”

Pobieranie zestawu danych i przekazywanie do usługi Lakehouse

Zdefiniuj te parametry, aby można było używać tego notesu z różnymi zestawami danych:

IS_CUSTOM_DATA = False  # If True, the dataset has to be uploaded manually

TARGET_COL = "Class"  # Target column name
IS_SAMPLE = False  # If True, use only <SAMPLE_ROWS> rows of data for training; otherwise, use all data
SAMPLE_ROWS = 5000  # If IS_SAMPLE is True, use only this number of rows for training

DATA_FOLDER = "Files/fraud-detection/"  # Folder with data files
DATA_FILE = "creditcard.csv"  # Data file name

EXPERIMENT_NAME = "aisample-fraud"  # MLflow experiment name

Ten kod pobiera publicznie dostępną wersję zestawu danych, a następnie przechowuje go w lakehouse usługi Fabric.

Ważne

Pamiętaj, aby dodać magazyn lakehouse do notesu przed jego uruchomieniem. W przeciwnym razie zostanie wyświetlony błąd.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname = "creditcard.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)
    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.")

Konfigurowanie śledzenia eksperymentów MLflow

Proces śledzenia eksperymentów zapisuje wszystkie istotne informacje dotyczące eksperymentu dla każdego uruchomionego eksperymentu. Czasami nie masz możliwości uzyskania lepszych wyników podczas uruchamiania określonego eksperymentu. W takich przypadkach należy zatrzymać eksperyment i wypróbować nowy.

Środowisko Nauka o danych usługi Synapse w usłudze Microsoft Fabric obejmuje funkcję automatycznego rejestrowania. Ta funkcja zmniejsza ilość kodu potrzebnego do automatycznego rejestrowania parametrów, metryk i elementów modelu uczenia maszynowego podczas trenowania. Funkcja rozszerza możliwości automatycznego rejestrowania MLflow. Ma głęboką integrację w środowisku Nauka o danych.

Dzięki funkcji automatycznego rejestrowania można łatwo śledzić i porównywać wydajność różnych modeli i eksperymentów bez konieczności ręcznego śledzenia. Aby uzyskać więcej informacji, zobacz Automatyczne rejestrowanie w usłudze Microsoft Fabric.

Aby wyłączyć automatyczne rejestrowanie usługi Microsoft Fabric w sesji notesu, wywołaj mlflow.autolog() i ustaw polecenie disable=True:

# Set up MLflow for experiment tracking
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Odczytywanie danych pierwotnych z lakehouse

Ten kod odczytuje nieprzetworzone dane z lakehouse:

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

Krok 3. Wykonywanie eksploracyjnej analizy danych

W tej sekcji najpierw zapoznasz się z nieprzetworzonymi danymi i statystykami wysokiego poziomu. Następnie, aby przekształcić dane, rzutuj kolumny na poprawne typy i przekonwertuj je z ramki danych Spark na ramkę danych biblioteki pandas, aby ułatwić wizualizację. Na koniec eksplorujesz i wizualizujesz rozkłady klas w danych.

Wyświetlanie danych pierwotnych

Zapoznaj się z danymi nieprzetworzonymi i wyświetl statystyki wysokiego poziomu za pomocą display polecenia . Aby uzyskać więcej informacji na temat wizualizacji danych, zobacz Wizualizacja notesu w usłudze Microsoft Fabric.
```
display(df)
```

Wydrukuj kilka podstawowych informacji na temat zestawu danych:

# Print dataset basic information
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()

Przekształcanie danych

Rzutowanie kolumn zestawu danych na poprawne typy:

import pyspark.sql.functions as F

df_columns = df.columns
df_columns.remove(TARGET_COL)

# Ensure that TARGET_COL is the last column
df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int"))

if IS_SAMPLE:
    df = df.limit(SAMPLE_ROWS)

Przekonwertuj ramkę danych platformy Spark na ramkę danych biblioteki pandas, aby ułatwić wizualizację i przetwarzanie:
```
df_pd = df.toPandas()
```

Eksplorowanie dystrybucji klas w zestawie danych

Wyświetl rozkład klas w zestawie danych:
```
# The distribution of classes in the dataset
print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset')
print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')
```
Kod zwraca ten rozkład klas zestawu danych: 99,83% No Frauds i 0,17% Frauds. Ta dystrybucja klas pokazuje, że większość transakcji jest niefraudulentna. W związku z tym wstępne przetwarzanie danych jest wymagane przed trenowaniem modelu, aby uniknąć nadmiernego dopasowania.

Użyj wykresu, aby pokazać dysproporcję klas w zestawie danych, wyświetlając rozkład fałszywych i nieuprawnionej transakcji:

import seaborn as sns
import matplotlib.pyplot as plt

colors = ["#0101DF", "#DF0101"]
sns.countplot(x='Class', data=df_pd, palette=colors) 
plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)

Pokaż podsumowanie pięciu liczb (wynik minimalny, pierwszy kwartyl, mediana, trzeci kwartyl i maksymalny wynik) dla kwoty transakcji z wykresami pola:
```
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5))
s = sns.boxplot(ax = ax1, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=True) # Remove outliers from the plot
s = sns.boxplot(ax = ax2, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=False) # Keep outliers from the plot
plt.show()
```
W przypadku wysoce niezrównoważonych danych wykresy pól mogą nie pokazywać dokładnych szczegółowych informacji. Można jednak najpierw rozwiązać Class problem nierównowagi, a następnie utworzyć te same wykresy, aby uzyskać dokładniejsze szczegółowe informacje.

Krok 4. Trenowanie i ocenianie modeli

W tym miejscu wytrenujesz model LightGBM, aby sklasyfikować transakcje oszustwa. Wytrenujesz model LightGBM zarówno na niezrównoważonym zestawie danych, jak i w zrównoważonym zestawie danych. Następnie porównasz wydajność obu modeli.

Przygotowywanie zestawów danych trenowania i testowania

Przed rozpoczęciem trenowania podziel dane na zestawy danych trenowania i testowania:

# Split the dataset into training and testing sets
from sklearn.model_selection import train_test_split

train, test = train_test_split(df_pd, test_size=0.15)
feature_cols = [c for c in df_pd.columns.tolist() if c not in [TARGET_COL]]

Stosowanie protokołu SMOTE do zestawu danych treningowych

W imblearn bibliotece użyto podejścia Do metody syntetycznej mniejszości oversampling Technique (SMOTE), aby rozwiązać problem niezrównoważonej klasyfikacji. Niezrównoważony klasyfikacja występuje, gdy dostępnych jest zbyt mało przykładów klasy mniejszości, aby model skutecznie nauczył się granicy decyzyjnej. SMOTE to najczęściej stosowane podejście do syntezowania nowych próbek dla klasy mniejszości.

Zastosuj metodę SMOTE tylko do zestawu danych treningowych, a nie do zestawu danych testowych. Podczas oceniania modelu przy użyciu danych testowych potrzebne jest przybliżenie wydajności modelu w przypadku niezaświetnionych danych w środowisku produkcyjnym. W celu uzyskania prawidłowego przybliżenia dane testowe opierają się na oryginalnym rozkładie nierównowagi, aby przedstawiać dane produkcyjne tak ściśle, jak to możliwe.

# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE

X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))

new_train = pd.concat([X_res, y_res], axis=1)

Aby uzyskać więcej informacji na temat rozwiązania SMOTE, zobacz stronę referencyjną biblioteki scikit-learn dla metody SMOTE i podręcznik użytkownika biblioteki scikit-learn dotyczący zasobów oversampling .

Trenowanie modeli uczenia maszynowego i uruchamianie eksperymentów

Platforma Apache Spark w usłudze Microsoft Fabric umożliwia uczenie maszynowe przy użyciu danych big data. Platforma Apache Spark umożliwia uzyskiwanie cennych szczegółowych informacji z dużych ilości ustrukturyzowanych, nieustrukturyzowanych i szybko poruszających się danych.

Dostępnych jest kilka dostępnych opcji trenowania modeli uczenia maszynowego za pomocą platformy Apache Spark w usłudze Microsoft Fabric: Apache Spark MLlib, SynapseML i innych bibliotek typu open source. Aby uzyskać więcej informacji, zobacz Trenowanie modeli uczenia maszynowego w usłudze Microsoft Fabric.

Eksperyment uczenia maszynowego służy jako podstawowa jednostka organizacji i kontroli dla wszystkich powiązanych przebiegów uczenia maszynowego. Przebieg odpowiada pojedynczemu wykonaniu kodu modelu. Śledzenie eksperymentów uczenia maszynowego obejmuje zarządzanie wszystkimi eksperymentami i ich składnikami, takimi jak parametry, metryki, modele i inne artefakty.

W przypadku śledzenia eksperymentów można zorganizować wszystkie wymagane składniki określonego eksperymentu uczenia maszynowego. Ponadto można łatwo odtworzyć wcześniejsze wyniki za pomocą zapisanych eksperymentów. Aby uzyskać więcej informacji na temat eksperymentów uczenia maszynowego, zobacz Eksperymenty uczenia maszynowego w usłudze Microsoft Fabric.

Aby śledzić więcej metryk, parametrów i plików, ustaw opcję exclusive=False aktualizowania konfiguracji automatycznego rejestrowania MLflow:
```
mlflow.autolog(exclusive=False)
```

Trenowanie dwóch modeli za pomocą usługi LightGBM. Jeden model obsługuje niezrównoważony zestaw danych, a drugi model obsługuje zrównoważony zestaw danych (za pośrednictwem smOTE). Następnie porównaj wydajność dwóch modeli.

import lightgbm as lgb

model = lgb.LGBMClassifier(objective="binary") # Imbalanced dataset
smote_model = lgb.LGBMClassifier(objective="binary") # Balanced dataset

# Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics
print("Start training with imbalanced data:\n")
with mlflow.start_run(run_name="raw_data") as raw_run:
    model = model.fit(
        train[feature_cols],
        train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

print(f"\n\nStart training with balanced data:\n")
with mlflow.start_run(run_name="smote_data") as smote_run:
    smote_model = smote_model.fit(
        new_train[feature_cols],
        new_train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

Określanie znaczenia funkcji na potrzeby trenowania

Określ znaczenie funkcji dla modelu, który został wytrenowany na niezrównoważonym zestawie danych:

with mlflow.start_run(run_id=raw_run.info.run_id):
    importance = lgb.plot_importance(
        model, title="Feature importance for imbalanced data"
    )
    importance.figure.savefig("feauture_importance.png")
    mlflow.log_figure(importance.figure, "feature_importance.png")

Określ znaczenie funkcji dla modelu, który został wytrenowany na podstawie zrównoważonych danych. Funkcja SMOTE wygenerowała zrównoważone dane:

with mlflow.start_run(run_id=smote_run.info.run_id):
    smote_importance = lgb.plot_importance(
        smote_model, title="Feature importance for balanced (via SMOTE) data"
    )
    smote_importance.figure.savefig("feauture_importance_smote.png")
    mlflow.log_figure(smote_importance.figure, "feauture_importance_smote.png")

Aby wytrenować model z niezrównoważonym zestawem danych, ważne funkcje mają znaczące różnice w porównaniu z modelem wyszkolonym przy użyciu zrównoważonego zestawu danych.

Ocena modeli

W tym miejscu ocenisz dwa wytrenowane modele:

model trenowane na nieprzetworzonych, niezrównoważonych danych
smote_model trenowanie na podstawie zrównoważonych danych

Metryki modelu obliczeniowego

Zdefiniuj prediction_to_spark funkcję, która wykonuje przewidywania i konwertuje wyniki przewidywania na ramkę danych platformy Spark. Następnie można obliczyć statystyki modelu na podstawie wyników przewidywania za pomocą usługi SynapseML.

from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType, DoubleType

def prediction_to_spark(model, test):
    predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
    predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
    dataColumns = [TARGET_COL, "prediction"]
    predictions = (
        spark.createDataFrame(data=predictions, schema=dataColumns)
        .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
        .withColumn("prediction", col("prediction").cast(DoubleType()))
    )

    return predictions

prediction_to_spark Użyj funkcji do wykonywania przewidywań z dwoma modelami model i smote_model:

predictions = prediction_to_spark(model, test)
smote_predictions = prediction_to_spark(smote_model, test)
predictions.limit(10).toPandas()

Metryki obliczeniowe dla dwóch modeli:

from synapse.ml.train import ComputeModelStatistics

metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(predictions)

smote_metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(smote_predictions)
display(metrics)

Ocena wydajności modelu za pomocą macierzy pomyłek

Macierz pomyłek wyświetla liczbę

prawdziwie dodatnie (TP)
prawdziwie ujemne (TN)
wyniki fałszywie dodatnie (FP)
fałszywie ujemne (FN)

model generuje wynik w przypadku oceny przy użyciu danych testowych. W przypadku klasyfikacji binarnej model zwraca 2x2 macierz pomyłek. W przypadku klasyfikacji wieloklasowej model zwraca nxn macierz pomyłek, gdzie n jest liczbą klas.

Użyj macierzy pomyłek, aby podsumować wydajność wytrenowanych modeli uczenia maszynowego na danych testowych:

# Collect confusion matrix values
cm = metrics.select("confusion_matrix").collect()[0][0].toArray()
smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray()
print(cm)

Wykreślij macierz pomyłek dla przewidywań smote_model (wytrenowanych na zrównoważonych danych):

# Plot the confusion matrix
import seaborn as sns

def plot(cm):
    """
    Plot the confusion matrix.
    """
    sns.set(rc={"figure.figsize": (5, 3.5)})
    ax = sns.heatmap(cm, annot=True, fmt=".20g")
    ax.set_title("Confusion Matrix")
    ax.set_xlabel("Predicted label")
    ax.set_ylabel("True label")
    return ax

with mlflow.start_run(run_id=smote_run.info.run_id):
    ax = plot(smote_cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Wykreślij macierz pomyłek dla przewidywań model (wytrenowanych na nieprzetworzonych, niezrównoważonych danych):

with mlflow.start_run(run_id=raw_run.info.run_id):
    ax = plot(cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Ocena wydajności modelu za pomocą miar AUC-ROC i AUPRC

Miara Area Under the Curve Receiver Operating Characteristic (AUC-ROC) ocenia wydajność klasyfikatorów binarnych. Wykres AUC-ROC wizualizuje kompromis między prawdziwie dodatnim współczynnikiem (TPR) a współczynnikiem fałszywie dodatnim (FPR).

W niektórych przypadkach bardziej odpowiednie jest obliczenie klasyfikatora na podstawie miary Area Under the Precision-Recall Curve (AUPRC). Krzywa AUPRC łączy następujące współczynniki:

Precyzja lub dodatnia wartość predykcyjna (PPV)
Wycofanie lub TPR

Aby ocenić wydajność za pomocą miar AUC-ROC i AUPRC:

Zdefiniuj funkcję zwracającą miary AUC-ROC i AUPRC:

from pyspark.ml.evaluation import BinaryClassificationEvaluator

def evaluate(predictions):
    """
    Evaluate the model by computing AUROC and AUPRC with the predictions.
    """

    # Initialize the binary evaluator
    evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL)

    _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions)

    # Calculate AUROC, baseline 0.5
    auroc = _evaluator("areaUnderROC")
    print(f"The AUROC is: {auroc:.4f}")

    # Calculate AUPRC, baseline positive rate (0.172% in the data)
    auprc = _evaluator("areaUnderPR")
    print(f"The AUPRC is: {auprc:.4f}")

    return auroc, auprc

Zarejestruj metryki AUC-ROC i AUPRC dla modelu, który został wytrenowany na danych niezrównoważonych:

with mlflow.start_run(run_id=raw_run.info.run_id):
    auroc, auprc = evaluate(predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})

Zarejestruj metryki AUC-ROC i AUPRC dla modelu, który został wytrenowany na zrównoważonych danych:

with mlflow.start_run(run_id=smote_run.info.run_id):
    auroc, auprc = evaluate(smote_predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "SMOTE", "DATA_FILE": DATA_FILE})

Model wytrenowany na zrównoważonych danych zwraca wyższe wartości AUC-ROC i AUPRC w porównaniu z modelem wyszkolonym na niezrównoważonych danych. Na podstawie tych miar smOTE wydaje się skuteczną techniką zwiększania wydajności modelu podczas pracy z wysoce niezrównoważonymi danymi.

Jak pokazano na następnym obrazie, każdy eksperyment jest rejestrowany przy użyciu odpowiedniej nazwy. Parametry eksperymentu i metryki wydajności można śledzić w obszarze roboczym.

Na tym obrazie przedstawiono metryki wydajności modelu wytrenowane na zrównoważonym zestawie danych (w wersji 2):

Możesz wybrać wersję 1 , aby wyświetlić metryki dla modelu wytrenowanego na niezrównoważonym zestawie danych. Podczas porównywania metryk model AUROC jest wyższy dla modelu trenowanego przy użyciu zrównoważonego zestawu danych. Te wyniki wskazują, że ten model jest lepszy w prawidłowym przewidywaniu 0 klas jako 0, i przewidywaniu 1 klas jako 1.

Krok 5. Rejestrowanie modeli

Użyj platformy MLflow, aby zarejestrować dwa modele:

# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"

raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)

smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)

Krok 6. Zapisywanie wyników przewidywania

Usługa Microsoft Fabric umożliwia użytkownikom operacjonalizacja modeli uczenia maszynowego za pomocą PREDICT skalowalnej funkcji. Ta funkcja obsługuje ocenianie wsadowe (lub wnioskowanie wsadowe) w dowolnym akiecie obliczeniowym.

Przewidywania wsadowe można wygenerować bezpośrednio z notesu usługi Microsoft Fabric lub na stronie elementu modelu. Aby uzyskać więcej informacji na temat PREDICTprogramu , zobacz Ocenianie modelu za pomocą funkcji PREDICT w usłudze Microsoft Fabric.

Załaduj model o lepszej wydajności (wersja 2) na potrzeby oceniania wsadowego i wygeneruj wyniki przewidywania:

from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=feature_cols,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-lightgbm",
    modelVersion=2,
)

test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list())

batch_predictions = model.transform(test_spark)

Zapisz przewidywania w jeziorze:

# Save the predictions to the lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")

Udostępnij za pośrednictwem

Samouczek: tworzenie, ocenianie i ocenianie modelu wykrywania oszustw

Wymagania wstępne

Postępuj zgodnie z instrukcjami w notesie

Otwieranie wbudowanego notesu

Importowanie notesu z usługi GitHub

Krok 1. Instalowanie bibliotek niestandardowych

Krok 2. Ładowanie danych

Pobieranie zestawu danych i przekazywanie do usługi Lakehouse

Konfigurowanie śledzenia eksperymentów MLflow

Odczytywanie danych pierwotnych z lakehouse

Krok 3. Wykonywanie eksploracyjnej analizy danych

Wyświetlanie danych pierwotnych

Przekształcanie danych

Eksplorowanie dystrybucji klas w zestawie danych

Krok 4. Trenowanie i ocenianie modeli

Przygotowywanie zestawów danych trenowania i testowania

Stosowanie protokołu SMOTE do zestawu danych treningowych

Trenowanie modeli uczenia maszynowego i uruchamianie eksperymentów

Określanie znaczenia funkcji na potrzeby trenowania

Ocena modeli

Metryki modelu obliczeniowego

Ocena wydajności modelu za pomocą macierzy pomyłek

Ocena wydajności modelu za pomocą miar AUC-ROC i AUPRC

Krok 5. Rejestrowanie modeli

Krok 6. Zapisywanie wyników przewidywania

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Samouczek: tworzenie, ocenianie i ocenianie modelu wykrywania oszustw

Wymagania wstępne

Postępuj zgodnie z instrukcjami w notesie

Otwieranie wbudowanego notesu

Importowanie notesu z usługi GitHub

Krok 1. Instalowanie bibliotek niestandardowych

Krok 2. Ładowanie danych

Pobieranie zestawu danych i przekazywanie do usługi Lakehouse

Konfigurowanie śledzenia eksperymentów MLflow

Odczytywanie danych pierwotnych z lakehouse

Krok 3. Wykonywanie eksploracyjnej analizy danych

Wyświetlanie danych pierwotnych

Przekształcanie danych

Eksplorowanie dystrybucji klas w zestawie danych

Krok 4. Trenowanie i ocenianie modeli

Przygotowywanie zestawów danych trenowania i testowania

Stosowanie protokołu SMOTE do zestawu danych treningowych

Trenowanie modeli uczenia maszynowego i uruchamianie eksperymentów

Określanie znaczenia funkcji na potrzeby trenowania

Ocena modeli

Metryki modelu obliczeniowego

Ocena wydajności modelu za pomocą macierzy pomyłek

Ocena wydajności modelu za pomocą miar AUC-ROC i AUPRC

Krok 5. Rejestrowanie modeli

Krok 6. Zapisywanie wyników przewidywania

Powiązana zawartość

Opinia

Dodatkowe zasoby