Azure OpenAI för stordata

Du kan använda Azure OpenAI-tjänsten för att lösa många uppgifter på naturligt språk genom att fråga api:et för slutförande. För att göra det enklare att skala dina frågande arbetsflöden från några exempel till stora datauppsättningar med exempel integreras Azure OpenAI-tjänsten med det distribuerade maskininlärningsbiblioteket SynapseML. Med den här integreringen kan du använda Apache Spark-ramverket för distribuerad databehandling för att bearbeta miljontals frågor med OpenAI-tjänsten. Den här självstudien visar hur du använder stora språkmodeller i distribuerad skala med hjälp av Azure OpenAI och Microsoft Fabric.

Förutsättningar

De viktigaste förutsättningarna för den här snabbstarten är en fungerande Azure OpenAI-resurs och ett Apache Spark-kluster med SynapseML installerat.

• Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri Microsoft Fabric utvärderingsversion.

• Logga in på Microsoft Fabric.

• Växla till Fabric genom att använda upplevelseväxlaren längst ned till vänster på startsidan.

  

• Gå till Data Science-arbetsbelastningen i Microsoft Fabric.
• Skapa en ny anteckningsbok.
• En Azure-resurs för OpenAI: skapa en resurs

Importera den här guiden som en notebook-fil

Nästa steg är att lägga till den här koden i Spark-klustret. Du kan antingen skapa en notebook-fil på Spark-plattformen och kopiera koden till den här notebook-filen för att köra demonstrationen.

1. Ladda ner denna demo som en anteckningsbok (välj Raw, och spara sedan filen).
2. Importera till Fabric-arbetsytan.
3. Använd installationsguiden för att installera SynapseML på ditt kluster. Det här steget kräver att du klistrar in en extra cell överst i anteckningsboken som du har importerat.
4. Anslut datorn till ett kluster och följ med genom att redigera och kör cellerna.

Fyll i tjänstinformation

Redigera sedan cellen i notebook-filen så att den pekar på din tjänst. Ange variablerna service_name, deployment_name, locationoch key så att de matchar OpenAI-tjänsten:

import os
from pyspark.sql import SparkSession
from synapse.ml.core.platform import running_on_synapse, find_secret

# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()

if running_on_synapse():
    from notebookutils.visualization import display

# Fill in the following lines with your service information
# Learn more about selecting which embedding model to choose: https://openai.com/blog/new-and-improved-embedding-model
service_name = "synapseml-openai"
deployment_name = "gpt-4.1-mini"
deployment_name_embeddings = "text-embedding-3-small"

key = find_secret(
    "openai-api-key"
)  # please replace this line with your key as a string

assert key is not None and service_name is not None

Skapa en datauppsättning med prompter

Därefter skapar du en DataFrame bestående av en serie rader, med en prompt per rad.

Du kan också läsa in data direkt från ADLS eller andra databaser. För mer information om hur du laddar in och förbereder Spark DataFrames, se Apache Spark dataladdningsguiden.

df = spark.createDataFrame(
    [
        ("Hello my name is",),
        ("The best code is code that's",),
        ("SynapseML is ",),
    ]
).toDF("prompt")

Skapa OpenAIPrompt Apache Spark-klienten

För att tillämpa Azure OpenAI-tjänsten på din DataFrame, skapa ett OpenAIPrompt objekt som fungerar som en distribuerad klient. Sätt serviceparametrarna med antingen ett enda värde eller en DataFrame-kolumn genom att använda lämpliga sättare på objektet OpenAIPrompt . I det här exemplet anger du maxTokens till 200. En token är cirka fyra tecken, och den här gränsen gäller för summan av prompten och resultatet. Sätt parametern promptCol med namnet på promptkolumnen i DataFrame.

from synapse.ml.services.openai import OpenAIPrompt

completion = (
    OpenAIPrompt()
    .setSubscriptionKey(key)
    .setDeploymentName(deployment_name)
    .setCustomServiceName(service_name)
    .setMaxTokens(200)
    .setPromptCol("prompt")
    .setErrorCol("error")
    .setOutputCol("completions")
)

Transformera DataFrame med hjälp av OpenAIPrompt-klienten

När du har skapat DataFrame-en och promptklienten omvandlar du din indatauppsättning och lägger till en kolumn med namnet completions som innehåller all information som tjänsten lägger till. Välj bara texten för enkelhetens skull.

from pyspark.sql.functions import col

completed_df = completion.transform(df).cache()
display(
    completed_df.select(
        col("prompt"),
        col("error"),
        col("completions.choices.text").getItem(0).alias("text"),
    )
)

Dina utdata bör se ut ungefär så här. Slutförandetexten skiljer sig från exemplet.

Fler användningsexempel

Generera textbäddningar

Förutom att fylla i text kan du även bädda in text för användning i underordnade algoritmer eller arkitekturer för vektorhämtning. Genom att skapa inbäddningar kan du söka efter och hämta dokument från stora samlingar. Använd den här metoden när prompt-teknik inte räcker för uppgiften. Mer information om hur du använder OpenAIEmbeddingfinns i inbäddningsguiden.

from synapse.ml.services.openai import OpenAIEmbedding

embedding = (
    OpenAIEmbedding()
    .setSubscriptionKey(key)
    .setDeploymentName(deployment_name_embeddings)
    .setCustomServiceName(service_name)
    .setTextCol("prompt")
    .setErrorCol("error")
    .setOutputCol("embeddings")
)

display(embedding.transform(df))

Chatten har slutförts

Modeller som GPT-4o och GPT-4.1 förstår chattar i stället för enskilda frågor. Transformatorn OpenAIChatCompletion exponerar den här funktionen i stor skala.

from synapse.ml.services.openai import OpenAIChatCompletion
from pyspark.sql import Row
from pyspark.sql.types import *


def make_message(role, content):
    return Row(role=role, content=content, name=role)


chat_df = spark.createDataFrame(
    [
        (
            [
                make_message(
                    "system", "You are an AI chatbot with red as your favorite color"
                ),
                make_message("user", "What's your favorite color"),
            ],
        ),
        (
            [
                make_message("system", "You are very excited"),
                make_message("user", "How are you today"),
            ],
        ),
    ]
).toDF("messages")


chat_completion = (
    OpenAIChatCompletion()
    .setSubscriptionKey(key)
    .setDeploymentName(deployment_name)
    .setCustomServiceName(service_name)
    .setMessagesCol("messages")
    .setErrorCol("error")
    .setOutputCol("chat_completions")
)

display(
    chat_completion.transform(chat_df).select(
        "messages", "chat_completions.choices.message.content"
    )
)

Förbättra dataflödet med batchbearbetning av begäranden

Exemplet gör flera begäranden till tjänsten, en för varje fråga. Om du vill slutföra flera frågor i en enda begäran använder du batchläge. I objektet anger du först "batchPrompt" för kolumnen BatchPrompt i OpenAIPrompt stället för att ställa in kolumnen Prompt till "Prompt". Skapa en DataFrame med en lista över prompts per rad.

batch_df = spark.createDataFrame(
    [
        (["The time has come", "Pleased to", "Today stocks", "Here's to"],),
        (["The only thing", "Ask not what", "Every litter", "I am"],),
    ]
).toDF("batchPrompt")

Skapa sedan objektet OpenAIPrompt . I stället för att ange promptkolumnen anger du batchPrompt-kolumnen om din kolumn är av typen Array[String].

batch_completion = (
    OpenAIPrompt()
    .setSubscriptionKey(key)
    .setDeploymentName(deployment_name)
    .setCustomServiceName(service_name)
    .setMaxTokens(200)
    .setBatchPromptCol("batchPrompt")
    .setErrorCol("error")
    .setOutputCol("completions")
)

I anropet till transformering görs en begäran per rad. Eftersom varje rad innehåller flera prompter skickar varje begäran alla frågor på den raden. Resultatet innehåller en rad för varje rad i begäran.

completed_batch_df = batch_completion.transform(batch_df).cache()
display(completed_batch_df)

Använda en automatisk minibatcher

Om dina data är i kolumnformat kan du transponera dem till radformat med hjälp av SynapseML:s FixedMiniBatcherTransformer.

from pyspark.sql.types import StringType
from synapse.ml.stages import FixedMiniBatchTransformer
from synapse.ml.core.spark import FluentAPI

completed_autobatch_df = (
    df.coalesce(
        1
    )  # Force a single partition so that our little 4-row DataFrame makes a batch of size 4, you can remove this step for large datasets
    .mlTransform(FixedMiniBatchTransformer(batchSize=4))
    .withColumnRenamed("prompt", "batchPrompt")
    .mlTransform(batch_completion)
)

display(completed_autobatch_df)

Promptdesign inom översättning

Tjänsten Azure OpenAI kan lösa många olika uppgifter på naturligt språk via prompt engineering. I det här exemplet visas begäran om språköversättning:

translate_df = spark.createDataFrame(
    [
        ("Japanese: Ookina hako \nEnglish: Big box \nJapanese: Midori tako\nEnglish:",),
        (
            "French: Quel heure et il au Montreal? \nEnglish: What time is it in Montreal? \nFrench: Ou est le poulet? \nEnglish:",
        ),
    ]
).toDF("prompt")

display(completion.transform(translate_df))

Uppmaning för att besvara frågor

I det här exemplet uppmanas modellen att svara på allmän kunskapsfråga:

qa_df = spark.createDataFrame(
    [
        (
            "Q: Where is the Grand Canyon?\nA: The Grand Canyon is in Arizona.\n\nQ: What is the weight of the Burj Khalifa in kilograms?\nA:",
        )
    ]
).toDF("prompt")

display(completion.transform(qa_df))

Relaterat innehåll

• Skapa en sökmotor med SynapseML
• Använda SynapseML- och Foundry-verktyg för multivariatavvikelseidentifiering – Analysera tidsserier
• Så här använder du kernel-SHAP för att förklara en tabellklassificeringsmodell