Kurz: Vytvoření, vyhodnocení a hodnocení modelu detekce podvodů

Článek
01/23/2024

Tento kurz představuje ucelený příklad pracovního postupu Synapse Datová Věda v Microsoft Fabric. Scénář vytváří model detekce podvodů s algoritmy strojového učení natrénovanými na historických datech. Pak model použije k detekci budoucích podvodných transakcí.

Tento kurz se věnuje těmto krokům:

Instalace vlastních knihoven
Načtení dat
Pochopení a zpracování dat prostřednictvím průzkumné analýzy dat
Použití knihovny scikit-learn k trénování modelu strojového učení a sledování experimentů s funkcemi automatickéhologování MLflow a Fabric
Uložení a registrace modelu strojového učení, který má nejvyšší výkon
Načtení modelu strojového učení pro bodování a provádění předpovědí

Požadavky

Získejte předplatné Microsoft Fabric. Nebo si zaregistrujte bezplatnou zkušební verzi Microsoft Fabricu.
Přihlaste se k Microsoft Fabric.
Pomocí přepínače prostředí na levé straně domovské stránky přepněte na prostředí Synapse Datová Věda.

V případě potřeby vytvořte microsoft Fabric lakehouse, jak je popsáno v tématu Vytvoření jezerahouse v Microsoft Fabric.

Sledování v poznámkovém bloku

V poznámkovém bloku můžete zvolit jednu z těchto možností:

Otevření a spuštění integrovaného poznámkového bloku v prostředí Datová Věda
Nahrání poznámkového bloku z GitHubu do prostředí Datová Věda

Otevření integrovaného poznámkového bloku

Tento kurz doprovází ukázkový poznámkový blok pro detekci podvodů.

Otevření integrovaného ukázkového poznámkového bloku kurzu v prostředí Datová Věda Synapse:

Přejděte na domovskou stránku Synapse Datová Věda.
Vyberte Použít ukázku.
Vyberte odpovídající ukázku:
- Pokud je ukázka pro kurz Pythonu, na výchozí kartě Kompletní pracovní postupy (Python ).
- Pokud je ukázka kurzu jazyka R, na kartě Kompletní pracovní postupy (R).
- Pokud je ukázka pro rychlý kurz, na kartě Rychlé kurzy .
Než začnete spouštět kód, připojte k poznámkovému bloku lakehouse.

Import poznámkového bloku z GitHubu

Poznámkový blok AIsample - Fraud Detection.ipynb doprovází tento kurz.

Pokud chcete otevřít doprovodný poznámkový blok pro tento kurz, postupujte podle pokynů v části Příprava systému na kurzy datových věd a importujte poznámkový blok do pracovního prostoru.

Pokud byste raději zkopírovali a vložili 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í vložené instalace (%pip nebo %conda) poznámkového bloku nainstalujte knihovnu jenom v aktuálním poznámkovém bloku.
Alternativně můžete vytvořit prostředí Infrastruktury, nainstalovat knihovny z veřejných zdrojů nebo do něj nahrát vlastní knihovny a správce pracovního prostoru pak může 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 nainstalujte %pip install knihovnu imblearn do poznámkového bloku.

Poznámka:

Po spuštění se jádro PySpark restartuje %pip install . 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 pro detekci podvodů obsahuje transakce kreditních karet od září 2013, které evropské držitelé karet provedli během dvou dnů. Datová sada obsahuje pouze číselné funkce z důvodu transformace analýzy hlavních komponent (PCA) použité na původní funkce. PCA transformovala všechny funkce s výjimkou Time a Amount. Kvůli ochraně důvěrnosti nemůžeme poskytnout původní funkce ani více informací o datové sadě na pozadí.

Tyto podrobnosti popisují datovou sadu:

Funkce V1, V2, V3, ... V28 jsou hlavní komponenty získané pomocí PCA.
Tato Time funkce obsahuje uplynulé sekundy mezi transakcí a první transakcí v datové sadě.
Funkce Amount je částka transakce. Tuto funkci můžete použít například závislé učení citlivé na náklady.
Sloupec Class je proměnná odpovědi (cíl). Má hodnotu 1 podvodu a 0 jinak

Podvodná jsou pouze 492 transakcí z celkového počtu 284 807 transakcí. Datová sada je velmi nevyvážená, protože menšina (podvodná) třída představuje pouze přibližně 0,172 % dat.

Tato tabulka zobrazuje náhled dat creditcard.csv :

Čas	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	V11	V12	V13	V14	V15	V16	V17	V18	V19	V20	V21	V22	V23	V24	V25	V26	V27	V28	Množství	Třída
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"

Stažení datové sady a nahrání do jezera

Definujte tyto parametry, abyste mohli tento poznámkový blok používat s různými datovými sadami:

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

Tento kód stáhne veřejně dostupnou verzi datové sady a pak ji uloží do objektu Fabric Lakehouse.

Důležité

Než ho spustíte, nezapomeňte do poznámkového bloku přidat jezero . V opačném případě se zobrazí chyba.

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

Nastavení sledování experimentů MLflow

Proces sledování experimentu ukládá všechny relevantní informace související s experimenty pro každý spuštěný experiment. Někdy nemáte způsob, jak získat lepší výsledky při spuštění konkrétního experimentu. V takových případech byste měli experiment zastavit a vyzkoušet nový.

Prostředí Synapse Datová Věda v Microsoft Fabric obsahuje funkci automatickéhologování. Tato funkce snižuje množství kódu potřebného k automatickému protokolování parametrů, metrik a položek modelu strojového učení během trénování. Tato funkce rozšiřuje možnosti automatickéhologování toku ML. Má hlubokou integraci v prostředí Datová Věda.

Díky automatickému přihlašování můžete snadno sledovat a porovnávat výkon různých modelů a experimentů bez nutnosti ručního sledování. Další informace najdete v tématu Automatickélogování v Microsoft Fabric.

Pokud chcete zakázat automatické protokolování Microsoft Fabric v relaci poznámkového bloku, zavolejte mlflow.autolog() a nastavte disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Čtení nezpracovaných dat z jezera

Tento kód čte nezpracovaná data z jezera:

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

Krok 3: Provádění průzkumné analýzy dat

V této části nejprve prozkoumáte nezpracovaná data a statistiky vysoké úrovně. Pokud pak chcete data transformovat, přetypovat sloupce na správné typy a převést je z datového rámce Sparku na datový rámec pandas, aby se daly snadněji vizualizovat. Nakonec prozkoumáte a vizualizujete distribuce tříd v datech.

Zobrazení nezpracovaných dat

Prozkoumejte nezpracovaná data a pomocí příkazu zobrazte statistiky display vysoké úrovně. Další informace o vizualizaci dat najdete v tématu Vizualizace poznámkového bloku v Microsoft Fabric.
```
display(df)
```

Vytiskněte některé základní informace o datové sadě:

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

Transformace dat

Přetypujte sloupce datové sady do správných typů:

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)

Převeďte datový rámec Sparku na datový rámec pandas pro snadnější vizualizaci a zpracování:
```
df_pd = df.toPandas()
```

Prozkoumání distribuce tříd v datové sadě

Zobrazení distribuce třídy v datové sadě:
```
# 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')
```
Kód vrátí distribuci této třídy datové sady: 99,83 % No Frauds a 0,17 % Frauds. Tato distribuce tříd ukazuje, že většina transakcí nenífraudulent. Před trénováním modelu se proto vyžaduje předběžné zpracování dat, aby se zabránilo přeurčení.

Pomocí grafu můžete zobrazit nerovnováhu tříd v datové sadě zobrazením distribuce podvodných a nefraudulentních transakcí:

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)

Zobrazí souhrn s pěti čísly (minimální skóre, první kvartil, medián, třetí kvartil a maximální skóre transakce) s krabicovými grafy:
```
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()
```
U vysoce nevyvážených dat nemusí krabicové grafy zobrazovat přesné přehledy. Nejprve ale můžete problém s nerovnováhou Class vyřešit a pak vytvořit stejné grafy pro přesnější přehledy.

Krok 4: Trénování a vyhodnocení modelů

Tady vytrénujete model LightGBM tak, aby klasifikovaly transakce podvodu. Model LightGBM vytrénujete na nevyrovnanou datovou sadu i na vyvážené datové sadě. Pak porovnáte výkon obou modelů.

Příprava trénovacích a testovacích datových sad

Před trénováním rozdělte data do trénovacích a testovacích datových sad:

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

Použití SMOTE na trénovací datovou sadu

Knihovna imblearn používá přístup SMOTE (Synthetic Minor Oversampling Technique) k řešení problému nevyvážené klasifikace. Nevyvážená klasifikace nastane, když je k dispozici příliš málo příkladů menšinové třídy, aby se model efektivně naučil rozhodovací hranici. SMOTE je nejčastěji používaný přístup k syntetizaci nových vzorků pro menšinovou třídu.

Použijte SMOTE pouze na trénovací datovou sadu místo testovací datové sady. Při vyhodnocování modelu pomocí testovacích dat potřebujete aproximaci výkonu modelu u nezoznaných dat v produkčním prostředí. Pro platnou aproximaci se testovací data spoléhají na původní nevyvážené rozdělení, aby co nejpřesněji představovala produkční data.

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

Další informace o SMOTE najdete na referenční stránce scikit-learn pro metodu SMOTE a uživatelskou příručku scikit-learn o převzorkování prostředků.

Trénování modelů strojového učení a spouštění experimentů

Apache Spark v Microsoft Fabric umožňuje strojové učení s velkými objemy dat. Díky Apache Sparku můžete získat cenné přehledy z velkých objemů strukturovaných, nestrukturovaných a rychle se pohyblivých dat.

Máte několik dostupných možností pro trénování modelů strojového učení pomocí Apache Sparku v Microsoft Fabric: Apache Spark MLlib, SynapseML a dalších opensourcových knihoven. Další informace najdete v tématu Trénování modelů strojového učení v Microsoft Fabric.

Experiment strojového učení slouží jako primární jednotka organizace a řízení pro všechna související spuštění strojového učení. Spuštění odpovídá jedinému spuštění kódu modelu. Sledování experimentů strojového učení zahrnuje správu všech experimentů a jejich součástí, jako jsou parametry, metriky, modely a další artefakty.

Pro sledování experimentů můžete uspořádat všechny požadované součásti konkrétního experimentu strojového učení. Kromě toho můžete snadno reprodukovat minulé výsledky pomocí uložených experimentů. Další informace o experimentech strojového učení najdete v tématu Experimenty strojového učení v Microsoft Fabric.

Pokud chcete sledovat další metriky, parametry a soubory, nastavte exclusive=False aktualizaci konfigurace automatického protokolování MLflow:
```
mlflow.autolog(exclusive=False)
```

Trénování dvou modelů pomocí LightGBM Jeden model zpracovává nevyrovnanou datovou sadu a druhý model zpracovává vyváženou datovou sadu (přes SMOTE). Pak porovnejte výkon těchto dvou modelů.

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

Určení důležitosti funkcí pro trénování

Určete důležitost funkcí pro model, který jste natrénovali na nevyrovnané datové sadě:

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

Určete důležitost funkce pro model, který jste natrénovali na vyvážená data. SMOTE vygenerovala vyvážená data:

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

Při trénování modelu s nevyrovnanou datovou sadou mají důležité funkce významné rozdíly v porovnání s modelem natrénovaným s vyváženou datovou sadou.

Vyhodnocení modelů

Tady vyhodnotíte dva vytrénované modely:

model trénované na nezpracovaných, nevyvážených datech
smote_model natrénováno na vyvážená data

Metriky výpočetního modelu

prediction_to_spark Definujte funkci, která provádí předpovědi a převádí výsledky předpovědi na datový rámec Sparku. Pomocí SynapseML pak můžete vypočítat statistiky modelu pro predikce.

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 Pomocí funkce můžete provádět předpovědi se dvěma modely a modelsmote_model:

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

Výpočetní metriky pro dva modely:

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)

Vyhodnocení výkonu modelu pomocí konfuzní matice

Konfuzní matice zobrazuje počet

pravdivě pozitivní (TP)
true negatives (TN)
falešně pozitivní (FP)
falešně negativní (FN)

při vyhodnocování pomocí testovacích dat vytvoří model. Pro binární klasifikaci model vrátí 2x2 konfuzní matici. Pro vícetřídovou klasifikaci model vrátí nxn konfuzní matici, kde n je počet tříd.

Pomocí konfuzní matice můžete shrnout výkony natrénovaných modelů strojového učení na testovacích datech:

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

Vykreslujte konfuzní matici pro předpovědi (natrénováno na vyvážených datech smote_model ):

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

Vykreslí model konfuzní matici pro předpovědi (natrénovaných na nezpracovaných, nevyvážených datech):

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

Vyhodnocení výkonu modelu pomocí měr AUC-ROC a AUPRC

Míra AUC-ROC (Area Under the Curve Receiver Operating Characteristic) vyhodnocuje výkon binárních klasifikátorů. Graf AUC-ROC vizualizuje kompromis mezi skutečnou kladnou mírou (TPR) a falešně pozitivní mírou (FPR).

V některých případech je vhodnější vyhodnotit klasifikátor na základě míry AUPRC (Area Under the Precision-Recall Curve). Křivka AUPRC kombinuje tyto míry:

Přesnost nebo kladná prediktivní hodnota (PPV)
Odvolání nebo TPR

Vyhodnocení výkonu pomocí měr AUC-ROC a AUPRC:

Definujte funkci, která vrací míry AUC-ROC a 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

Protokolujte metriky AUC-ROC a AUPRC pro model, který jste natrénovali na nevyrovnaná data:

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

Protokolujte metriky AUC-ROC a AUPRC pro model, který jste natrénovali na vyvážená data:

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 natrénovaný na vyvážených datech vrátí vyšší hodnoty AUC-ROC a AUPRC v porovnání s modelem natrénovanými na nevyrovnaná data. Na základě těchto opatření se SMOTE jeví jako účinná technika pro zvýšení výkonu modelu při práci s vysoce nevyváženými daty.

Jak ukazuje následující obrázek, všechny experimenty se zaprotokolují s příslušným názvem. V pracovním prostoru můžete sledovat parametry experimentu a metriky výkonu.

Tento obrázek ukazuje metriky výkonu pro model natrénovaný na vyvážené datové sadě (ve verzi 2):

Pokud chcete zobrazit metriky pro model natrénovaný na nevyrovnané datové sadě, můžete vybrat verzi 1 . Při porovnání metrik je AUROC vyšší pro model natrénovaný s vyváženou datovou sadou. Tyto výsledky naznačují, že tento model je lépe správně predikovat 0 třídy jako 0a predikovat 1 třídy jako 1.

Krok 5: Registrace modelů

Pomocí MLflow zaregistrujte tyto dva modely:

# 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: Uložení výsledků předpovědi

Microsoft Fabric umožňuje uživatelům zprovoznit modely strojového PREDICT učení pomocí škálovatelné funkce. Tato funkce podporuje dávkové bodování (nebo dávkové odvozování) v jakémkoli výpočetním modulu.

Dávkové předpovědi můžete generovat přímo z poznámkového bloku Microsoft Fabric nebo ze stránky položek modelu. Další informaceoch PREDICT

Načtěte model s lepším výkonem (verze 2) pro dávkové vyhodnocování a vygenerujte výsledky předpovědi:

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)

Uložte předpovědi do jezera:

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

Kurz: Vytvoření, vyhodnocení a hodnocení modelu detekce podvodů

Požadavky

Sledování v poznámkovém bloku

Otevření integrovaného poznámkového bloku

Import poznámkového bloku z GitHubu

Krok 1: Instalace vlastních knihoven

Krok 2: Načtení dat

Stažení datové sady a nahrání do jezera

Nastavení sledování experimentů MLflow

Čtení nezpracovaných dat z jezera

Krok 3: Provádění průzkumné analýzy dat

Zobrazení nezpracovaných dat

Transformace dat

Prozkoumání distribuce tříd v datové sadě

Krok 4: Trénování a vyhodnocení modelů

Příprava trénovacích a testovacích datových sad

Použití SMOTE na trénovací datovou sadu

Trénování modelů strojového učení a spouštění experimentů

Určení důležitosti funkcí pro trénování

Vyhodnocení modelů

Metriky výpočetního modelu

Vyhodnocení výkonu modelu pomocí konfuzní matice

Vyhodnocení výkonu modelu pomocí měr AUC-ROC a AUPRC

Krok 5: Registrace modelů

Krok 6: Uložení výsledků předpovědi

Váš názor

Váš názor

Další materiály

Kurz: Vytvoření, vyhodnocení a hodnocení modelu detekce podvodů

Požadavky

Sledování v poznámkovém bloku

Otevření integrovaného poznámkového bloku

Import poznámkového bloku z GitHubu

Krok 1: Instalace vlastních knihoven

Krok 2: Načtení dat

Stažení datové sady a nahrání do jezera

Nastavení sledování experimentů MLflow

Čtení nezpracovaných dat z jezera

Krok 3: Provádění průzkumné analýzy dat

Zobrazení nezpracovaných dat

Transformace dat

Prozkoumání distribuce tříd v datové sadě

Krok 4: Trénování a vyhodnocení modelů

Příprava trénovacích a testovacích datových sad

Použití SMOTE na trénovací datovou sadu

Trénování modelů strojového učení a spouštění experimentů

Určení důležitosti funkcí pro trénování

Vyhodnocení modelů

Metriky výpočetního modelu

Vyhodnocení výkonu modelu pomocí konfuzní matice

Vyhodnocení výkonu modelu pomocí měr AUC-ROC a AUPRC

Krok 5: Registrace modelů

Krok 6: Uložení výsledků předpovědi

Související obsah

Váš názor

Váš názor

Další materiály