Opetusohjelma: Tekstin luokittelumallin luominen, arvioiminen ja pisteytys

Tässä opetusohjelmassa esitellään päästä päähän -esimerkki Synapse Data Science -työnkulusta Tekstin luokittelumallille Microsoft Fabricissa. Skenaario käyttää word2vec- ja logistista regressiota Sparkissä määrittääkseen Kirjan tyylilajin British Library -kirjan tietojoukosta, yksinomaan kirjan nimen perusteella.

Tässä opetusohjelmassa käsitellään seuraavat vaiheet:

Edellytykset

• Hanki Microsoft Fabric -tilaus. Voit myös rekisteröityä microsoft fabric -kokeiluversion maksuttomaan .

• Kirjaudu sisään Microsoft Fabric .

• Vaihda Fabriciin aloitussivun vasemmassa alakulmassa olevan käyttökokemuksen vaihtajan avulla.

  

• Jos sinulla ei ole Microsoft Fabric lakehousea, luo se noudattamalla ohjeita artikkelissa Lakehousen luominen Microsoft Fabric.

Seuraa mukana muistikirjassa

Voit valita jonkin seuraavista vaihtoehdoista, joita voit seurata muistikirjassa:

• Avaa ja suorita sisäinen muistikirja.
• Lataa muistikirja GitHubista.

Avaa sisäinen muistikirja

Tämän opetusohjelman mukana on malli Title-genren luokitus muistikirja.

1. Avaa tätä opetusohjelmaa varten näytemuistikirja noudattamalla ohjeita kohdassa Järjestelmän valmisteleminen datatieteen opetusohjelmia varten.

2. Varmista, että liittää lakehouse- ennen kuin aloitat koodin suorittamisen.

Tuo muistikirja GitHubista

AIsample – Title Genre Classification.ipynb on muistikirja, joka on tämän opetusohjelman mukana.

• Jos haluat avata tämän opetusohjelman liitteenä olevan muistikirjan, noudata ohjeita kohdassa Valmistele järjestelmäsi datatiedeopetusohjelmia varten muistikirjan tuomiseksi työtilaasi.

• Jos haluat kopioida ja liittää koodin tältä sivulta, voit luoda uuden muistikirjan.

• Muista liittää muistikirjaan lakehouse- ennen kuin aloitat koodin suorittamisen.

Vaihe 1: Mukautettujen kirjastojen asentaminen

Koneoppimismallin kehittämistä tai ad-hoc-tietojen analysointia varten sinun on ehkä asennettava nopeasti mukautettu kirjasto Apache Spark -istuntoa varten. Sinulla on kaksi vaihtoehtoa kirjastojen asentamiseen.

• Asenna kirjasto nykyiseen muistikirjaasi käyttämällä muistikirjasi sisäiset asennusominaisuudet (%pip tai %conda).
• Vaihtoehtoisesti voit luoda Fabric-ympäristön, asentaa kirjastoja julkisista lähteistä tai ladata mukautettuja kirjastoja siihen, jonka jälkeen työtilan järjestelmänvalvoja voi liittää ympäristön työtilan oletusarvoksi. Kaikki ympäristön kirjastot ovat sitten käytettävissä missä tahansa muistikirjoissa ja Spark-työmääritelmissä työtilassa. Lisätietoja ympäristöistä on artikkelissa Ympäristön luominen, määrittäminen ja käyttäminen Microsoft Fabric -.

Käytä luokitusmallissa wordcloud -kirjastoa ilmaisemaan tekstin sanatiheys, jossa sanan koko edustaa sen tiheys. Tässä opetusohjelmassa asenna %pip install muistikirjaasi wordcloud.

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

Vaihe 2: Lataa tiedot

Tietojoukossa on metatietoja British Libraryn kirjoista, jotka kirjaston ja Microsoftin välinen yhteistyö on digitoitu. Metatiedot ovat luokitustietoja, jotka osoittavat, onko kirja fiktio vai fiktiivinen. Tämän tietojoukon avulla on tarkoitus harjoittaa luokitusmalli, joka määrittää kirjan tyylilajin vain sen otsikon perusteella.

Määritä seuraavat parametrit, jotta voit käyttää tätä muistikirjaa eri tietojoukoissa:

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

Lataa tietojoukko ja lataa se Lakehouse-palveluun

Tämä koodi lataa tietojoukosta julkisesti saatavilla olevan version ja tallentaa sen Fabric Lakehouse -järjestelmään.

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

Tarvittavien kirjastojen tuominen

Ennen mitään käsittelyä sinun on tuotava tarvittavat kirjastot, mukaan lukien Spark- ja SynapseML -kirjastot:

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

Hyperparametrien määrittäminen

Määritä joitakin hyperparametreita mallin harjoittamista varten.

# 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

Aloita muistikirjan suorittamiseen tarvittava aika:

# Record the notebook running time
import time

ts = time.time()

MLflow-kokeilujen seurannan määrittäminen

Automaattinen lokerointi laajentaa MLflow-lokitoiminnot. Automaattinen kirjaaminen tallentaa automaattisesti koneoppimismallin syöteparametriarvot ja tulostemittarit harjoittaessasi sitä. Sitten kirjaat nämä tiedot työtilaan. Työtilassa voit käyttää ja visualisoida tietoja MLflow-ohjelmointirajapinnoilla tai vastaavalla kokeilulla työtilassa. Jos haluat lisätietoja automaattisesta lokista, katso automaattinen lokiloggaus Microsoft Fabric.

# Set up Mlflow for experiment tracking

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

Jos haluat poistaa Microsoft Fabric -automaattianalyysin käytöstä muistikirjaistunnossa, kutsu mlflow.autolog() ja määritä disable=True:

Lue raakapäivämäärätiedot Lakehousesta

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

Vaihe 3: Suorita valmisteleva tietoanalyysi

Tutustu tietojoukkoon display -komennolla, jos haluat tarkastella tietojoukon korkean tason tilastotietoja ja näyttää kaavion näkymät:

display(raw_df.limit(20))

Tietojen valmistelu

Poista kaksoiskappaleet tietojen puhdistamiseksi:

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

display(df.limit(20))

Käytä luokkien tasaamista puolueellisuuden käsittelemiseksi:

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

Jaa kappaleet ja lauseet pienempiin yksiköihin tietojoukon tunnuksiksi. Näin merkityksen määrittäminen on helpompaa. Poista sitten stop-sanat suorituskyvyn parantamiseksi. Stopword-poistaminen tarkoittaa sellaisten sanojen poistamista, joita esiintyy yleisesti kaikissa corpus-asiakirjoissa. Stopword-poistaminen on yksi yleisimmin käytetyistä esikäsittelyvaiheista luonnollisen kielen käsittelyn (NLP) sovelluksissa.

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

Näytä kunkin luokan sanapilvikirjasto. Sanapilvikirjasto on visuaalisesti näkyvä avainsanojen esitys, joka esiintyy usein tekstitiedoissa. Sanapilvikirjasto on tehokas, koska avainsanojen hahmontaminen muodostaa pilvimaisen värikuvan, joka sieppaa päätekstitiedot paremmin yhdellä silmäyksellä. Lisätietoja sanapilvi-.

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

Käytä lopuksi word2vec-funktiota tekstin vektorisointiin. Word2vec-tekniikka luo vektoriesityksen tekstin jokaisesta sanasta. Samanlaisissa konteksteissa käytetyt tai semanttisissa suhteissa käytetyt sanat kuvataan tehokkaasti niiden läheisyyden kautta vektoritilassa. Tämä läheisyys ilmaisee, että vastaavilla sanoilla on samanlaiset sanavektorit.

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

Vaihe 4: Mallin harjoittaminen ja arvioiminen

Määritä malli, kun tiedot ovat paikoillaan. Tässä osiossa harjoitat logistista regressiomallia vektorimuotoisen tekstin luokittelemiseksi.

Koulutuksen ja testitietojoukkojen valmistelu

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

Koneoppimiskokeilujen seuraaminen

Koneoppimisen kokeilu on organisaation ja hallinnan ensisijainen yksikkö kaikissa siihen liittyvissä koneoppimisajoissa. Suoritus vastaa mallikoodin yksittäistä suoritusta.

Koneoppimisen kokeilujen seuranta hallitsee kaikkia kokeita ja niiden komponentteja, esimerkiksi parametreja, mittareita, malleja ja muita artefakteja. Seurannan avulla voidaan organisaation kaikki vaadittavat komponentit tietyssä koneoppimiskokeilussa. Se mahdollistaa myös aiempien tulosten helpon toistamisen tallennettujen kokeilujen avulla. Lisätietoja koneoppimisen kokeiluista Microsoft Fabric.

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

Hyperparametrien hienosäätäminen

Luo parametriruudukko, josta voit tehdä haun hyperparametreista. Luo sitten arvioijien välinen arvio, joka tuottaa CrossValidator mallin:

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

Mallin arvioiminen

Voimme vertailla testitietojoukon malleja niiden vertailemiseksi. Hyvin harjoitetun mallin tulisi osoittaa korkea suorituskyky asianmukaisten mittareiden perusteella, kun sitä verrataan vahvistus- ja testitietojoukkoihin.

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

Seuraa kokeita MLflow'n avulla

Aloita koulutus- ja arviointiprosessi. MLflow-parametrien avulla voit seurata kaikkia kokeita sekä kirjata parametreja, mittareita ja malleja. Kaikki nämä tiedot kirjataan työtilan kokeilun nimellä.

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

Voit tarkastella kokeitasi:

1. Valitse työtila vasemmassa siirtymisruudussa
2. Etsi ja valitse kokeilun nimi – tässä tapauksessa sample_aisample tekstin luokittelun

Vaihe 5: Ennustustulosten pisteytys ja tallentaminen

Microsoft Fabricin avulla käyttäjät voivat operationalisoida koneoppimismalleja skaalattavan PREDICT avulla. Tämä funktio tukee erän pisteytystä (tai erän päätelyä) missä tahansa laskentamoduulissa. Voit luoda eräennusteita suoraan muistikirjasta tai tietyn mallin kohdesivulta. Lisätietoja PREDICT-rakenteesta ja sen käytöstä Fabricissa on artikkelissa Koneoppimismallin pisteytys PREDICT-arvolla Microsoft Fabric -.

Edellisistä arviointituloksista mallissa 1 on suurimmat mittarit sekä alueella Precision-Recall käyrän alla (AUPRC) että alueella Käyrän vastaanottimen toimintaominaisuus (AUC-ROC). Siksi ennusteena tulisi käyttää mallia 1.

AUC-ROC-mittaria käytetään laajalti binaariluokkien suorituskyvyn mittaamiseen. Joskus on kuitenkin sopivampaa arvioida luokittelu AUPRC-mittausten perusteella. AUC-ROC visualisoi true positive rate (TPR) - ja false positive rate (FPR) -kurssien välisen kompromissin. AUPRC-käyrä yhdistää tarkkuuden (positiivinen ennustearvo tai PPV) ja paikannuksen (tosi positiivinen korko tai TPR) yhteen visualisointiin.

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

Aiheeseen liittyvä sisältö

• microsoft Fabric:n -koneoppimismalli
• Koneoppimismallien harjoittaminen
• Koneoppimisen kokeiluja Microsoft Fabric