Jaa

Opetusohjelma: Tekstin luokittelumallin luominen, arvioiminen ja pisteytys

  • Artikkeli

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:

  • Mukautettujen kirjastojen asentaminen
  • Lataa tiedot
  • Tietojen ymmärtäminen ja käsitteleminen valmistelevan tietoanalyysin avulla
  • Harjoita koneoppimismalli word2vec-funktiolla ja logistisella regressiolla ja seuraa MLflow'n ja Fabric-automaattisen lokerointitoiminnon avulla tehtyjä kokeita
  • Lataa koneoppimismalli pisteytystä ja ennusteita varten

Edellytykset

  • Jos sinulla ei ole Microsoft Fabric lakehousea, luo sellainen noudattamalla kohdassa Luo lakehouse Microsoft Fabricissa olevia ohjeita.

Seuraa mukana muistikirjassa

Voit valita jonkin seuraavista vaihtoehdoista, joita voit seurata muistikirjassa:

  • Avaa ja suorita sisäinen muistikirja Synapse Data Science -kokemuksessa
  • Lataa muistikirjasi GitHubista Synapse Data Science -kokemukseen

Avaa sisäinen muistikirja

Tämän opetusohjelman mukana on esimerkki Otsikkolajin luokitus -muistikirjasta.

Opetusohjelman sisäinen näytemuistikirja avataan Synapse Data Science -kokemuksesta seuraavasti:

  1. Siirry Synapse Data Science -aloitussivulle.

  2. Valitse Käytä mallia.

  3. Valitse vastaava malli:

    • Oletusarvoisen Päästä päähän -työnkulkujen (Python) välilehdestä, jos malli on tarkoitettu Python-opetusohjelmaa varten.
    • Jos malli on R-opetusohjelmassa, päästä päähän -työnkulut (R) -välilehdeltä.
    • Pikaopetusohjelmat-välilehdessä, jos malli on pikaopetusohjelmaa varten.

  4. Liitä muistikirjaan lakehouse, ennen kuin aloitat koodin suorittamisen.

Tuo muistikirja GitHubista

AIsample – Otsikko genren luokitus.ipynb on muistikirja, joka seuraa tätä opetusohjelmaa.

Jos haluat avata tämän opetusohjelman liitteenä olevan muistikirjan, tuo muistikirja työtilaasi noudattamalla ohjeita kohdassa Järjestelmän valmisteleminen datatieteen opetusohjelmia varten.

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

Muista liittää lakehouse muistikirjaan 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 muistikirjasi sisäiset asennusominaisuudet (%pip tai %conda) kirjastoon, vain senhetkiseen muistikirjaasi.
  • 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. Katso lisätietoja ympäristöistä kohdasta Ympäristön luominen, määrittäminen ja käyttäminen Microsoft Fabricissa.

Käytä luokitusmallissa wordcloud -kirjastoa ilmaisemaan sanan tiheys tekstissä, jossa sanan koko edustaa sen tiheystta. Tätä opetusohjelmaa varten %pip install voit asentaa wordcloud sen muistikirjaasi.

Muistiinpano

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

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

BL-tietuetunnus Resurssin tyyppi Nimi Nimeen liittyvät päivämäärät Nimen tyyppi Rooli Kaikki nimet Title Variantin otsikot Sarjan otsikko Sarjan sisäinen luku Julkaisun maa Julkaisupaikka Publisher Julkaisupäivämäärä Versio Fyysinen kuvaus Dewey-luokitus BL-hyllymerkki Aiheet Laji Kielivaihtoehdot 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ö käytettäessä 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 Epätosi
014602830 Monografia A, T. / henkilö käytettäessä 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 Epätosi

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.

Tärkeä

Lisää muistikirjaan lakehouse ennen kuin suoritat sen. 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.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.

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 automaattianalyysipalveluista ohjeartikkelista Automaattinen lokiloggaus Microsoft Fabricissa.

# 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 komennolla display , jos haluat tarkastella tietojoukon korkean tason tilastotietoja ja näyttää kaavionä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ä. Lue lisää sanapilvipalvelusta.

# 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. Lue lisää Microsoft Fabricin koneoppimisen kokeiluista.

# 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 arvioijan välinen arvio mallin tuottamiseksi CrossValidator :

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

Screenshot of an experiment.

Vaihe 5: Ennustustulosten pisteytys ja tallentaminen

Microsoft Fabricin avulla käyttäjät voivat operationalisoida koneoppimismalleja PREDICT skaalattavan 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. Lisätietoja PREDICT-rakenteesta ja sen käytöstä Fabricissa on artikkelissa Koneoppimismallien pisteytys PREDICT-arvolla Microsoft Fabricissa.

Edellisistä arviointituloksista mallissa 1 on suurimmat mittarit sekä alueella Precision-Recall Curve (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-kaavio visualisoi todellisen positiivisen kurssin (TPR) ja väärän positiivisen prosenttiprosentin (FPR) 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.")

Liittyvä sisältö