Creare un modello con SynapseML

Questo articolo illustra come creare un modello di Machine Learning con SynapseML in un notebook di Microsoft Fabric. Si crea una pipeline di training che usa la definizione delle caratteristiche del testo e la regressione LightGBM per stimare le classificazioni dei libri dal testo della recensione. Imparerai anche come utilizzare Foundry Tools per l'analisi del sentiment predefinita.

Prerequisiti

• Ottenere una sottoscrizione di Microsoft Fabric. In alternativa, iscriversi per ottenere una versione di valutazione di Microsoft Fabric gratuita.

• Accedere a Microsoft Fabric.

• Passare a Fabric usando il commutatore dell'esperienza in basso a sinistra della tua home page.

  

• Creare un nuovo notebook nell'area di lavoro Fabric.
• Collegare una lakehouse al notebook. Nel riquadro Explorer espandere Lakehouses e quindi selezionare Aggiungi.
• (Facoltativo) Per eseguire la fase di analisi del sentiment, è necessario:
  • Una chiave di Foundry Tools. Seguire le istruzioni in Guida introduttiva: creare una risorsa multi-servizio per Foundry Tools.
  • Un'istanza di Azure Key Vault con la chiave di Foundry Tools archiviata come segreto.

Configurare l'ambiente

Nel notebook importare le librerie SynapseML e inizializzare la sessione Spark.

from pyspark.sql import SparkSession
from synapse.ml.core.platform import *

spark = SparkSession.builder.getOrCreate()

Verifica: Eseguire la cella seguente per verificare che Spark sia in esecuzione:

print(f"Spark version: {spark.version}")

L'output visualizza il numero di versione di Spark. È prevista qualsiasi versione 3.4 o successiva. La versione esatta dipende dal runtime di Fabric.

Caricare un set di dati

Caricare il set di dati delle recensioni di libri e suddividerlo in insiemi di addestramento e di test. Il set di dati contiene due colonne: rating (numero intero 1-5) e text (esaminare il contenuto).

train, test = (
    spark.read.parquet(
        "wasbs://publicwasb@mmlspark.blob.core.windows.net/BookReviewsFromAmazon10K.parquet"
    )
    .limit(1000)
    .cache()
    .randomSplit([0.8, 0.2])
)

display(train)

Verifica: Eseguire la cella seguente per confermare il caricamento corretto dei dati:

print(f"Training rows: {train.count()}, Test rows: {test.count()}")
print(f"Columns: {train.columns}")
train.printSchema()

L'output mostra circa 800 righe di training e 200 righe di test, con due colonne: rating (integer) e text (stringa). Il conteggio esatto delle righe varia perché randomSplit non deterministico.

Creare la pipeline di addestramento

Crea una pipeline che estrae le caratteristiche dal testo della recensione con TextFeaturizer e prevede la valutazione con LightGBMRegressor.

from pyspark.ml import Pipeline
from synapse.ml.featurize.text import TextFeaturizer
from synapse.ml.lightgbm import LightGBMRegressor

model = Pipeline(
    stages=[
        TextFeaturizer(inputCol="text", outputCol="features"),
        LightGBMRegressor(featuresCol="features", labelCol="rating", dataTransferMode="bulk")
    ]
).fit(train)

Verifica: Esegui la cella seguente per confermare che la pipeline sia stata addestrata:

print(f"Pipeline stages: {len(model.stages)}")
print(f"Stage 1: {type(model.stages[0]).__name__}")
print(f"Stage 2: {type(model.stages[1]).__name__}")

L'output mostra due fasi della pipeline: TextFeaturizerModel e LightGBMRegressionModel.

Predire l'output dei dati di test

Chiamare il transform metodo sul modello per stimare le classificazioni per i dati di test e visualizzare i risultati.

predictions = model.transform(test)
display(predictions)

Verifica: Eseguire la cella seguente per verificare che le stime siano state generate:

print(f"Prediction columns: {predictions.columns}")
print(f"Prediction count: {predictions.count()}")
predictions.select("rating", "prediction").show(5)

L'output elenca quattro colonne (rating, text, features, prediction) e circa 200 righe. La colonna prediction contiene la valutazione prevista del modello in formato float. Confrontarlo con la colonna effettiva rating per valutare le prestazioni del modello.

(Facoltativo) Usa gli strumenti di Foundry per l'analisi del sentiment

Se si vuole analizzare il sentiment delle recensioni dei libri, è possibile usare l'integrazione di SynapseML con Foundry Tools. Questo passaggio usa il modello predefinito TextSentiment per classificare il sentiment del testo, che è un compito diverso dalla previsione della valutazione nei passaggi precedenti.

Eseguire il codice seguente con queste sostituzioni:

• Sostituire <your-secret-name> con il nome del segreto della chiave di Foundry Tools in Key Vault.
• Sostituire <your-key-vault-name> con il nome dell'istanza di Azure Key Vault.

from synapse.ml.services import TextSentiment
from synapse.ml.core.platform import find_secret

sentiment_model = TextSentiment(
    textCol="text",
    outputCol="sentiment",
    subscriptionKey=find_secret("<your-secret-name>", "<your-key-vault-name>")
).setLocation("eastus")

sentiment_results = sentiment_model.transform(test)
display(sentiment_results)

Verifica: Eseguire la cella seguente per confermare che l'analisi del sentiment è stata completata:

print(f"Sentiment columns: {sentiment_results.columns}")
sentiment_results.select("text", "sentiment").show(3, truncate=50)

L'output mostra tre colonne (rating, text, sentiment). La sentiment colonna contiene risultati strutturati con etichette come positive, negative, neutralo mixed per ogni revisione.

Troubleshooting

Pulire le risorse

Se hai creato risorse di Azure per il passaggio facoltativo Foundry Tools e non ti servono più, eliminale per evitare addebiti:

1. Nel portale di Azure, eliminare la risorsa multiservizio Foundry Tools.
2. Nel portale di Azure eliminare l'istanza di Key Vault.
3. Nell'area di lavoro Fabric eliminare il notebook di test se non è più necessario.

Contenuto correlato

• Come usare LightGBM con SynapseML
• Come usare gli strumenti Foundry con SynapseML
• Come eseguire la stessa attività di classificazione con e senza SynapseML
• Guida introduttiva: Creare una risorsa multiservizio per gli strumenti Foundry