Kurz: Vytvorenie, vyhodnotenie a skóre modelu textovej klasifikácie

Tento kurz predstavuje komplexný príklad pracovného postupu synapse Data Science pre model textovej klasifikácie v službe Microsoft Fabric. Scenár používa word2vec a logistickú regresiu v službe Spark, aby určil žáner knihy z množiny údajov knihy Britskej knižnice len na základe názvu knihy.

V tomto kurze sú obsiahnuté tieto kroky:

Predpoklady

• Získajte predplatné služby Microsoft Fabric . Alebo si zaregistrujte bezplatnú skúšobnú služby Microsoft Fabric.

• Prihláste sa do služby Microsoft Fabric.

• Pomocou prepínača skúseností v ľavej dolnej časti domovskej stránky sa prepnete na službu Fabric.

  

• Ak nemáte domovské jazero služby Microsoft Fabric, vytvorte ho pomocou krokov uvedených v téme Vytvorenie úzla v službe Microsoft Fabric.

Sledovanie v poznámkovom bloke

Môžete si vybrať jednu z týchto možností, ktorú si môžete vyskúšať v notebooku:

• Otvorte a spustite vstavaný poznámkový blok.
• Nahrajte poznámkový blok z GitHubu.

Otvorenie vstavaného poznámkového bloku

Tento kurz sprevádza ukážkový poznámkový blok klasifikácie Title genre.

1. Ak chcete otvoriť vzorový poznámkový blok pre tento kurz, postupujte podľa pokynov v téme Príprava systému na kurzy dátovej vedy.

2. Uistite sa, že pripojiť lakehouse na notebook, ako začnete bežať kód.

Importovanie notebooku z GitHubu

AIsample - Title Genre Classification.ipynb je notebook, ktorý sprevádza tento kurz.

• Ak chcete otvoriť sprievodný poznámkový blok pre tento kurz, postupujte podľa pokynov v téme Príprava systému na kurzy dátových vied na import notebooku do pracovného priestoru.

• Ak by ste radšej skopírovali a prilepili kód z tejto stránky, môžete vytvoriť nový poznámkový blok.

• Uistite sa, že pripojiť lakehouse k notebooku, ako začnete bežať kód.

Krok č. 1: Inštalácia vlastných knižníc

Na vývoj modelu strojového učenia alebo analýzu údajov ad hoc možno budete musieť rýchlo nainštalovať vlastnú knižnicu pre reláciu Apache Spark. Na inštaláciu knižníc máte dve možnosti.

• Ak chcete nainštalovať knižnicu iba v aktuálnom poznámkovom bloku, použite možnosti vnorenej inštalácie (%pip alebo %conda).
• Prípadne môžete vytvoriť prostredie služby Fabric, nainštalovať knižnice z verejných zdrojov alebo do neho nahrať vlastné knižnice a potom môže správca pracovného priestoru k prostrediu pripojiť ako predvolené prostredie pre pracovný priestor. Všetky knižnice v prostredí budú potom k dispozícii na použitie v poznámkových blokoch a definíciách úloh služby Spark v pracovnom priestore. Ďalšie informácie o prostrediach nájdete v téme vytvorenia, konfigurácie a používania prostredia v službe Microsoft Fabric.

V modeli klasifikácie použite knižnicu wordcloud na znázornenie frekvencie textu v texte, kde veľkosť slova predstavuje jeho frekvenciu. V tomto kurze %pip install použite na inštaláciu wordcloud v poznámkovom bloke.

# Install wordcloud for text visualization by using pip
%pip install wordcloud

Krok č. 2: Načítanie údajov

Množina údajov má metaúdaje o knihách z Britskej knižnice, ktoré spolupracujú medzi knižnicou a spoločnosťou Microsoft digitized. Metaúdaje sú informácie o klasifikácii, ktoré označujú, či je kniha fikciou alebo neprakciou. Pri tejto množine údajov je cieľom trénovať model klasifikácie, ktorý určuje žáner knihy, a to len na základe jeho názvu.

Definujte nasledujúce parametre, aby ste tento poznámkový blok mohli použiť v rôznych množinách údajov:

IS_CUSTOM_DATA = False  # If True, the user must manually upload the dataset
DATA_FOLDER = "Files/title-genre-classification"
DATA_FILE = "blbooksgenre.csv"

# Data schema
TEXT_COL = "Title"
LABEL_COL = "annotator_genre"
LABELS = ["Fiction", "Non-fiction"]

EXPERIMENT_NAME = "sample-aisample-textclassification"  # MLflow experiment name

Stiahnite si množinu údajov a nahrajte ju do služby lakehouse

Tento kód stiahne verejne dostupnú verziu množiny údajov a potom ju uloží v úložisku Fabric lakehouse.

if not IS_CUSTOM_DATA:
    # Download demo data files into the lakehouse, if they don't exist
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Title_Genre_Classification"
    fname = "blbooksgenre.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        # Add a lakehouse, if no default lakehouse was added to the notebook
        # A new notebook won't link to any lakehouse by 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.")

Import požadovaných knižníc

Pred akýmkoľvek spracovaním musíte importovať požadované knižnice vrátane knižníc pre Spark a SynapseML:

import numpy as np
from itertools import chain

from wordcloud import WordCloud
import matplotlib.pyplot as plt
import seaborn as sns

import pyspark.sql.functions as F

from pyspark.ml import Pipeline
from pyspark.ml.feature import *
from pyspark.ml.tuning import CrossValidator, ParamGridBuilder
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.evaluation import (
    BinaryClassificationEvaluator,
    MulticlassClassificationEvaluator,
)

from synapse.ml.stages import ClassBalancer
from synapse.ml.train import ComputeModelStatistics

import mlflow

Definovanie hyperparametrov

Definujte niektoré hyperparametre na trénovaie modelu.

# Hyperparameters 
word2vec_size = 128  # The length of the vector for each word
min_word_count = 3  # The minimum number of times that a word must appear to be considered
max_iter = 10  # The maximum number of training iterations
k_folds = 3  # The number of folds for cross-validation

Spustite nahrávanie času potrebného na spustenie tohto poznámkového bloku:

# Record the notebook running time
import time

ts = time.time()

Nastavenie sledovania experimentov s MLflow

Automatické označovanie rozširuje možnosti zapisovania do denníka toku MLflow. Automatické označovanie automaticky zaznamenáva hodnoty vstupných parametrov a výstupné metriky modelu strojového učenia počas jeho trénovania. Tieto informácie potom zapíšete do pracovného priestoru. V pracovnom priestore môžete získať prístup k informáciám a vizualizovať ich pomocou rozhraní MLflow API alebo pomocou príslušného experimentu v pracovnom priestore. Ďalšie informácie o automatickom označovaní nájdete v téme automatické označovanie v službe Microsoft Fabric.

# Set up Mlflow for experiment tracking

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

Ak chcete zakázať automatické označovanie služby Microsoft Fabric v relácii poznámkového bloku, zavolajte mlflow.autolog() a nastavte disable=True:

Prečítajte si nespracované údaje dátumu z lakehouse

raw_df = spark.read.csv(f"{DATA_FOLDER}/raw/{DATA_FILE}", header=True, inferSchema=True)

Krok č. 3: Vykonanie prieskumnej analýzy údajov

Preskúmajte množinu údajov pomocou príkazu display, zobrazte si štatistiky vysokej úrovne množiny údajov a zobrazte zobrazenia grafu:

display(raw_df.limit(20))

Príprava údajov

Odstráňte duplikáty na vyčistenie údajov:

df = (
    raw_df.select([TEXT_COL, LABEL_COL])
    .where(F.col(LABEL_COL).isin(LABELS))
    .dropDuplicates([TEXT_COL])
    .cache()
)

display(df.limit(20))

Použite vyrovnávanie tried na riešenie akéhokoľvek skreslenia:

# Create a ClassBalancer instance, and set the input column to LABEL_COL
cb = ClassBalancer().setInputCol(LABEL_COL)

# Fit the ClassBalancer instance to the input DataFrame, and transform the DataFrame
df = cb.fit(df).transform(df)

# Display the first 20 rows of the transformed DataFrame
display(df.limit(20))

Rozdeľte odseky a vety na menšie jednotky, aby ste tokenizovali množinu údajov. Týmto spôsobom sa stane jednoduchšie priradiť význam. Potom odstráňte stopwords zlepšiť výkon. Odstránenie slovo stopword zahŕňa odstránenie slov, ktoré sa bežne vyskytujú vo všetkých dokumentoch v corpus. Odstránenie stopword je jedným z najčastejšie používaných krokov pred spracovaním prirodzeného jazyka (NLP).

# Text transformer
tokenizer = Tokenizer(inputCol=TEXT_COL, outputCol="tokens")
stopwords_remover = StopWordsRemover(inputCol="tokens", outputCol="filtered_tokens")

# Build the pipeline
pipeline = Pipeline(stages=[tokenizer, stopwords_remover])

token_df = pipeline.fit(df).transform(df)

display(token_df.limit(20))

Zobrazí knižnicu Wordcloud pre každú triedu. Wordcloud knižnica je vizuálne viditeľná prezentácia kľúčových slov, ktoré sa často zobrazujú v textových údajoch. Wordcloud knižnica je účinná, pretože vykresľovanie kľúčových slov predstavuje cloudový farebný obrázok, aby lepšie zachytil hlavné textové údaje na prvý pohľad. Ďalšie informácie o wordcloud.

# WordCloud
for label in LABELS:
    tokens = (
        token_df.where(F.col(LABEL_COL) == label)
        .select(F.explode("filtered_tokens").alias("token"))
        .where(F.col("token").rlike(r"^\w+$"))
    )

    top50_tokens = (
        tokens.groupBy("token").count().orderBy(F.desc("count")).limit(50).collect()
    )

    # Generate a wordcloud image
    wordcloud = WordCloud(
        scale=10,
        background_color="white",
        random_state=42,  # Make sure the output is always the same for the same input
    ).generate_from_frequencies(dict(top50_tokens))

    # Display the generated image by using matplotlib
    plt.figure(figsize=(10, 10))
    plt.title(label, fontsize=20)
    plt.axis("off")
    plt.imshow(wordcloud, interpolation="bilinear")

Nakoniec na vektorizáciu textu použite word2vec. Technika word2vec vytvára vektorové vyjadrenie každého slova v texte. Slová použité v podobných kontextoch alebo sémantické vzťahy sa efektívne zachytávajú prostredníctvom ich blízkosti vo vektorovom priestore. Táto blízkosť označuje, že podobné slová majú podobné slovné vektory.

# Label transformer
label_indexer = StringIndexer(inputCol=LABEL_COL, outputCol="labelIdx")
vectorizer = Word2Vec(
    vectorSize=word2vec_size,
    minCount=min_word_count,
    inputCol="filtered_tokens",
    outputCol="features",
)

# Build the pipeline
pipeline = Pipeline(stages=[label_indexer, vectorizer])
vec_df = (
    pipeline.fit(token_df)
    .transform(token_df)
    .select([TEXT_COL, LABEL_COL, "features", "labelIdx", "weight"])
)

display(vec_df.limit(20))

Krok č. 4: Trénovanie a vyhodnotenie modelu

Keď sú údaje na mieste, definujte model. V tejto časti trénujete logistický regresný model na klasifikáciu vektorizovaného textu.

Príprava tréningových a testovacích množín údajov

# Split the dataset into training and testing
(train_df, test_df) = vec_df.randomSplit((0.8, 0.2), seed=42)

Sledovanie experimentov strojového učenia

Experiment strojového učenia je primárnou jednotkou organizácie a kontroly pre všetky súvisiace spustenia strojového učenia. Spustenie zodpovedá jednému vykonaniu kódu modelu.

Sledovanie experimentov strojového učenia spravuje všetky experimenty a ich komponenty, napríklad parametre, metriky, modely a ďalšie artefakty. Sledovanie umožňuje usporiadanie všetkých požadovaných súčastí konkrétneho experimentu so strojovým učením. Umožňuje tiež jednoduchú reprodukciu minulých výsledkov s uloženými experimentami. Ďalšie informácie o experimentoch strojového učenia v službe Microsoft Fabric.

# Build the logistic regression classifier
lr = (
    LogisticRegression()
    .setMaxIter(max_iter)
    .setFeaturesCol("features")
    .setLabelCol("labelIdx")
    .setWeightCol("weight")
)

Ladenie hyperparametrov

Vytvorte mriežku parametrov na vyhľadávanie hyperparametrov. Potom vytvorte odhadníka krížového hodnotiteľa na vytvorenie CrossValidator modelu:

# Build a grid search to select the best values for the training parameters
param_grid = (
    ParamGridBuilder()
    .addGrid(lr.regParam, [0.03, 0.1])
    .addGrid(lr.elasticNetParam, [0.0, 0.1])
    .build()
)

if len(LABELS) > 2:
    evaluator_cls = MulticlassClassificationEvaluator
    evaluator_metrics = ["f1", "accuracy"]
else:
    evaluator_cls = BinaryClassificationEvaluator
    evaluator_metrics = ["areaUnderROC", "areaUnderPR"]
evaluator = evaluator_cls(labelCol="labelIdx", weightCol="weight")

# Build a cross-evaluator estimator
crossval = CrossValidator(
    estimator=lr,
    estimatorParamMaps=param_grid,
    evaluator=evaluator,
    numFolds=k_folds,
    collectSubModels=True,
)

Vyhodnotenie modelu

Môžeme vyhodnotiť modely v testovacej množine údajov a porovnať ich. Dobre trénovaný model by mal v relevantných metrikách preukázať vysoký výkon pri spustení oproti overovacím a testovacím množinám údajov.

def evaluate(model, df):
    log_metric = {}
    prediction = model.transform(df)
    for metric in evaluator_metrics:
        value = evaluator.evaluate(prediction, {evaluator.metricName: metric})
        log_metric[metric] = value
        print(f"{metric}: {value:.4f}")
    return prediction, log_metric

Sledovanie experimentov pomocou toku MLflow

Spustite trénovanie a proces hodnotenia. MLflow môžete použiť na sledovanie všetkých experimentov a zaznamenávanie parametrov, metrík a modelov. Všetky tieto informácie sa zapisuje do denníka pod názvom experimentu v pracovnom priestore.

with mlflow.start_run(run_name="lr"):
    models = crossval.fit(train_df)
    best_metrics = {k: 0 for k in evaluator_metrics}
    best_index = 0
    for idx, model in enumerate(models.subModels[0]):
        with mlflow.start_run(nested=True, run_name=f"lr_{idx}") as run:
            print("\nEvaluating on test data:")
            print(f"subModel No. {idx + 1}")
            prediction, log_metric = evaluate(model, test_df)

            if log_metric[evaluator_metrics[0]] > best_metrics[evaluator_metrics[0]]:
                best_metrics = log_metric
                best_index = idx

            print("log model")
            mlflow.spark.log_model(
                model,
                f"{EXPERIMENT_NAME}-lrmodel",
                registered_model_name=f"{EXPERIMENT_NAME}-lrmodel",
                dfs_tmpdir="Files/spark",
            )

            print("log metrics")
            mlflow.log_metrics(log_metric)

            print("log parameters")
            mlflow.log_params(
                {
                    "word2vec_size": word2vec_size,
                    "min_word_count": min_word_count,
                    "max_iter": max_iter,
                    "k_folds": k_folds,
                    "DATA_FILE": DATA_FILE,
                }
            )

    # Log the best model and its relevant metrics and parameters to the parent run
    mlflow.spark.log_model(
        models.subModels[0][best_index],
        f"{EXPERIMENT_NAME}-lrmodel",
        registered_model_name=f"{EXPERIMENT_NAME}-lrmodel",
        dfs_tmpdir="Files/spark",
    )
    mlflow.log_metrics(best_metrics)
    mlflow.log_params(
        {
            "word2vec_size": word2vec_size,
            "min_word_count": min_word_count,
            "max_iter": max_iter,
            "k_folds": k_folds,
            "DATA_FILE": DATA_FILE,
        }
    )

Zobrazenie experimentov:

1. Na ľavej navigačnej table vyberte pracovný priestor.
2. Vyhľadajte a vyberte názov experimentu – v tomto prípade sample_aisample-textclassification

Krok č. 5: Skóre a uloženie výsledkov predpovede

Microsoft Fabric umožňuje používateľom využiť modely strojového učenia pomocou PREDICT škálovateľnej funkcie. Táto funkcia podporuje dávkové bodovanie (alebo odvodenie dávky) v akomkoľvek výpočtovom nástroji. Dávkové predpovede môžete vytvárať priamo z poznámkového bloku alebo zo stránky položiek pre konkrétny model. Ďalšie informácie o technológii PREDICT a jej používaní v službe Fabric nájdete v téme skóre modelov strojového učenia pomocou služby PREDICT v službe Microsoft Fabric.

Z predchádzajúcich výsledkov hodnotenia má model 1 najväčšie metriky pre oblasť pod Precision-Recall krivkou (AUPRC) a pre oblasť pod prevádzkovou charakteristikou prijímača (AUC-ROC). Preto by ste na predpovedenie mali použiť model 1.

AUC-ROC mierka sa široko používa na meranie výkonu binárnych klasifikátorov. Niekedy je však vhodnejšie vyhodnotiť klasifikant na základe meraní AUPRC. Graf AUC-ROC vizualizuje kompromis medzi skutočne pozitívnou sadzbou (TPR) a falošne pozitívnou sadzbou (FPR). Krivka AUPRC kombinuje presnosť (kladná prediktívna hodnota alebo PPV) a úplnosť (skutočne pozitívna miera alebo TPR) v jednej vizualizácii.

# Load the best model
model_uri = f"models:/{EXPERIMENT_NAME}-lrmodel/1"
loaded_model = mlflow.spark.load_model(model_uri, dfs_tmpdir="Files/spark")

# Verify the loaded model
batch_predictions = loaded_model.transform(test_df)
batch_predictions.show(5)

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

# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")

Súvisiaci obsah

• modelu strojového učenia v službe Microsoft Fabric
• modely strojového učenia
• experimentov strojového učenia v službe Microsoft Fabric