Opetusohjelma: Tekstin luokittelumallin luominen, arvioiminen ja pisteytys

2025-04-20

Tässä opetusohjelmassa esitellään päästä päähän -esimerkki Synapse Data Science -työnkulusta Tekstin luokittelumallille Microsoft Fabricissa. Skenaariossa käytetään sekä word2vec-luonnollisen kielen käsittelyä (NLP) että logistista regressiota Sparkissa kirjan tyylilajin määrittämiseksi British Library -kirjan tietojoukosta. Päättäväisyys perustuu yksinomaan kirjan nimeen.

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

Mukautettujen kirjastojen asentaminen
Lataa tiedot
Tietojen ymmärtäminen ja käsitteleminen valmistelevan tietoanalyysin avulla
Harjoita koneoppimismalli Word2vec NLP:n ja logistisen regression avulla ja seuraa MLflow- ja Fabric-automaattianalyysiominaisuuksia koskevia kokeita
Lataa koneoppimismalli pisteytystä ja ennusteita varten

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 sellainen noudattamalla kohdassa Luo lakehouse Microsoft Fabricissa -resurssin ohjeita.

Seuraa mukana muistikirjassa

Voit seurata muistikirjassa seuraavia vaihtoehtoja:

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

Avaa sisäinen muistikirja

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

Avaa tätä opetusohjelmaa varten näytemuistikirja noudattamalla ohjeita kohdassa Järjestelmän valmisteleminen datatieteen opetusohjelmia varten.
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. Voit asentaa kirjaston kahdella eri tavalla.

Jos haluat asentaa kirjaston, käytä vain nykyiseen muistikirjaasi muistikirjasi sisäiset asennusominaisuudet (%pip tai %conda).
Vaihtoehtoisesti voit luoda Fabric-ympäristön ja asentaa kirjastoja julkisista lähteistä tai ladata siihen mukautettuja kirjastoja. Tämän jälkeen työtilan järjestelmänvalvoja voi liittää ympäristön työtilan oletusasetuksena. Tässä vaiheessa ympäristön kaikki kirjastot ovat käytettävissä kaikissa muistikirjoissa ja tämän työtilan kaikissa Spark-työmääritelmissä. Saat lisätietoja ympäristöistä Microsoft Fabric -resurssin ympäristön luomisesta, määrittämisestä ja käyttämisestä .

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

Muistiinpano

PySpark-ydin käynnistyy uudelleen %pip install suoritusten jälkeen. Asenna tarvitsemasi kirjastot, ennen kuin suoritat muita soluja.

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

Vaihe 2: Lataa tiedot

British Library -kirjan tietojoukossa on metatietoja British Libraryn kirjoista. Kirjaston ja Microsoftin välinen yhteistyö digitoi alkuperäiset resurssit, joista tuli tietojoukko. Metatiedot ovat luokitustietoja, jotka osoittavat, onko kirja fiktiota vai tietokirjaa. Seuraavassa kaaviossa on tietojoukon rivimalli.

BL-tietuetunnus	Resurssin tyyppi	Nimi	Nimeen liittyvät päivämäärät	Nimen tyyppi	Rooli	Kaikki nimet	Nimike	Variantin otsikot	Sarjan otsikko	Sarjan sisäinen luku	Julkaisun maa	Julkaisupaikka	Julkaisija	Julkaisupäivämäärä	Painos	Fyysinen kuvaus	Dewey-luokitus	BL-hyllymerkki	Aiheet	Genre	Kielet	Muistiinpanot	Fyysisen resurssin BL-tietuetunnus	classification_id	user_id	created_at	subject_ids	annotator_date_pub	annotator_normalised_date_pub	annotator_edition_statement	annotator_genre	annotator_FAST_genre_terms	annotator_FAST_subject_terms	annotator_comments	annotator_main_language	annotator_other_languages_summaries	annotator_summaries_language	annotator_translation	annotator_original_language	annotator_publisher	annotator_place_pub	annotator_country	annotator_title	Linkki digitoituun kirjaan	Selityksineen
014602826	Monografia	Yearsley, Ann	1753-1806	henkilö		More, Hannah, 1745-1833 [henkilö]; Yearsley, Ann, 1753-1806 [henkilö]	Runoja useaan otteeseen [Hannah Moren esivalmistelukirjeellä.]				Englanti	Lontoo		1786	Neljännen painoksen MANUSCRIPT-huomautus			Digital Store 11644.d.32			Englanti		003996603																						Väärä
014602830	Monografia	A, T.		henkilö		Oldham, John, 1653-1683 [henkilö]; A, T. [henkilö]	Satyr Vertueta vastaan. (Runo: pitäisi puhua Town-Hector [Kirjoittanut John Oldham. Etuliite allekirjoitettu: T. A.])				Englanti	Lontoo		1679		15 sivua (4°)		Digital Store 11602.ee.10. (2.)			Englanti		000001143																						Väärä

Tämän tietojoukon avulla pyrimme kouluttamaan luokitusmallin, joka määrittää kirjan tyylilajin vain kirjan otsikon perusteella.

Määritä seuraavat parametrit, joita käytetään tässä muistikirjassa 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

Seuraava koodikatkelma lataa tietojoukosta julkisesti saatavilla olevan version ja tallentaa sen Fabric lakehouse -järjestelmään:

Tärkeä

Lisää lakehouse- muistikirjaan ennen sen suorittamista. Jos näin ei tehdä, tuloksena on virhe.

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

    remote_url = "https://synapseaisolutionsa.z13.web.core.windows.net/data/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

Seuraava koodikatkelman määrittää mallin harjoittamiseen tarvittavat hyperparametrit:

Tärkeä

Muokkaa näitä hyperparametreja vain, jos ymmärrät jokaisen parametrin.

# 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. Saat lisätietoja automaattisesta lokista Microsoft Fabric -resurssin automaattinen lokeraatio -ohjeartikkelista .

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

# Set up Mlflow for experiment tracking

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

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

Jos haluat puhdistaa tiedot, poista kaksoiskappaleet:

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

Jos haluat muodostaa tietojoukon tunnuksen, jaa kappaleet ja lauseet pienempiin yksiköihin. Näin merkityksen määrittäminen on helpompaa. Poista sitten stopword-sana 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. Seuraavassa koodikatkelmassa käsitellään seuraavat vaiheet:

# 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 esittää usein tekstitiedoissa näkyviä avainsanoja, ja se on visuaalisesti näkyvä esitys. Sanapilvikirjasto on tehokas, koska avainsanan hahmontaminen muodostaa pilvityyppisen värikuvan, jotta päätekstitiedot voidaan siepata paremmin yhdellä silmäyksellä. Katso tästä resurssista lisätietoja sanapilvipalvelusta.

Seuraavassa koodikatkelmassa käsitellään seuraavat vaiheet:

# 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 NLP -funktiota tekstin vektorisointiin. Word2vec NLP -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. Seuraavassa koodikatkelmassa käsitellään seuraavat vaiheet:

# 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

Seuraava koodikatkelman jakaa tietojoukon:

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

Koneoppimiskokeilujen seuraaminen

Koneoppimisen kokeilujen seuranta hallitsee kaikkia kokeita ja niiden osia, esimerkiksi parametreja, mittareita, malleja ja muita artefakteja. Seurannan avulla voit hallita kaikkia osia, joita tietty koneoppimiskokeilu edellyttää. Se mahdollistaa myös aiempien tulosten helpon toistamisen tallennettujen kokeilujen avulla. Saat lisätietoja Microsoft Fabricin koneoppimiskokeiluista .

Koneoppimisen kokeilu on organisaation ja hallinnan ensisijainen yksikkö kaikissa siihen liittyvissä koneoppimisajoissa. Suoritus vastaa mallikoodin yksittäistä suoritusta. Seuraavassa koodikatkelmassa käsitellään seuraavat vaiheet:

# 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 ristiinarviointiarvio mallin tuottamiseksi seuraavassa koodikatkelmassa esitetyllä CrossValidator tavalla:

# 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. Seuraavassa koodikatkelmassa käsitellään seuraavat vaiheet:

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 ja kirjata parametrit, mittarit ja mallit lokiin. Työtilassa kaikki nämä tiedot kirjataan kokeilun nimellä. Seuraavassa koodikatkelmassa käsitellään seuraavat vaiheet:

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:

Valitse työtila vasemmassa siirtymisruudussa
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 toiminnon 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. Saat lisätietoja funktiosta PREDICT ja siitä, miten sitä käytetään Fabricissa, tutustu Microsoft Fabricin koneoppimismallin pisteytykseen PREDICT-funktiolla.

Arviointituloksiemme perusteella 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ää sekä tarkkuuden (positiivinen ennustearvo tai PPV) että paikannuksen (tosi positiivinen korko tai TPR) yhteen visualisointiin. Seuraavat koodikatkelmat kattavat seuraavat vaiheet:

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

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