Crie um modelo com SynapseML

Este artigo mostra-lhe como construir um modelo de aprendizagem automática com SynapseML num portátil Microsoft Fabric. Cria-se um pipeline de treino que utiliza a caracterização do texto e a regressão LightGBM para prever as classificações dos livros a partir do texto da crítica. Também aprende a usar Foundry Tools para análise de sentimento pré-configurada.

Pré-requisitos

• Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para uma avaliação gratuita do Microsoft Fabric.

• Entre no Microsoft Fabric.

• Altera para o Fabric usando o alternador de experiência no canto inferior esquerdo da sua página inicial.

  

• Cria um novo caderno no teu espaço de trabalho Fabric.
• Anexe um lakehouse ao notebook. No painel do Explorador, expanda Lakehouses e, em seguida, selecione Adicionar.
• (Opcional) Para executar a etapa de análise de sentimento, precisa de:
  • Uma chave do Foundry Tools. Siga as instruções no Quickstart: Crie um recurso multi-serviço para a Foundry Tools.
  • Uma instância Azure Key Vault com a tua chave Foundry Tools guardada como segredo.

Configurar o ambiente

No seu bloco de notas, importe bibliotecas SynapseML e inicialize a sessão do Spark.

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

spark = SparkSession.builder.getOrCreate()

Verificação: Execute a seguinte célula para confirmar que o Spark está a funcionar:

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

A saída mostra o número de versão do Spark. Qualquer versão 3.4 ou posterior é esperada. A versão exata depende do tempo de execução do teu Fabric.

Carregar um conjunto de dados

Carrega o conjunto de dados de revisões de livros e divide-o em conjuntos de treino e de teste. O conjunto de dados contém duas colunas: rating (inteiro 1-5) e text (conteúdo de revisão).

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ção: Execute a célula seguinte para confirmar que os dados foram carregados corretamente:

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

A saída mostra aproximadamente 800 linhas de treino e 200 linhas de teste, com duas colunas: rating (inteiro) e text (string). O número exato de linhas varia porque randomSplit é não determinístico.

Criar a cadeia de processos de formação

Crie um pipeline que destaque o texto da avaliação com TextFeaturizer e preveja a classificação com 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ção: Execute a célula seguinte para confirmar o pipeline treinado:

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__}")

A saída mostra dois estágios do pipeline: TextFeaturizerModel e LightGBMRegressionModel.

Prever a saída dos dados de teste

Chame o transform método no modelo para prever as classificações dos dados do teste e exiba os resultados.

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

Verificação: Execute a seguinte célula para confirmar que foram geradas as previsões:

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

A saída lista quatro colunas (rating, text, features, prediction) e aproximadamente 200 linhas. A coluna prediction contém a pontuação prevista do modelo como um valor de vírgula flutuante. Compare com a coluna real rating para avaliar o desempenho do modelo.

(Opcional) Utilize o Foundry Tools para análise de sentimentos

Se quiser analisar o sentimento das suas críticas de livros, pode usar a integração do SynapseML com o Foundry Tools. Esta etapa utiliza o modelo pré-construído TextSentiment para classificar o sentimento do texto, o que é uma tarefa diferente da previsão de classificação nos passos anteriores.

Execute o seguinte código com estas substituições:

• Substitua <your-secret-name> pelo nome do segredo da chave da Foundry Tools em Key Vault.
• Substitua <your-key-vault-name> pelo nome da sua instância 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ção: Execute a seguinte célula para confirmar a conclusão da análise de sentimento:

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

A saída mostra três colunas (rating, text, sentiment). A sentiment coluna contém resultados estruturados com etiquetas como positive, negative, neutral, ou mixed para cada revisão.

Solução de problemas

Limpeza de recursos

Se criou recursos do Azure para a etapa opcional das Foundry Tools e já não precisa deles, elimine-os para evitar cobranças:

1. No portal Azure, elimine o recurso multi-serviço Foundry Tools.
2. No portal Azure, elimine a instância do Key Vault.
3. No teu espaço de trabalho do Fabric, elimina o caderno de testes se já não precisares dele.

Conteúdos relacionados

• Como usar LightGBM com SynapseML
• Como usar as Ferramentas Foundry com SynapseML
• Como executar a mesma tarefa de classificação com e sem SynapseML
• Quickstart: Crie um recurso multi-serviço para a Foundry Tools