Azure OpenAI for big data

Du kan bruge Azure OpenAI-tjenesten til at løse mange opgaver på naturligt sprog ved at prompte completion API'en. For at gøre det lettere at skalere dine prompting-workflows fra få eksempler til store datasæt af eksempler, integrerer Azure OpenAI-tjenesten med det distribuerede maskinlæringsbibliotek SynapseML. Ved at bruge denne integration kan du bruge Apache Spark distribuerede computing-rammeværket til at behandle millioner af prompts med OpenAI-tjenesten. Denne vejledning viser, hvordan man anvender store sprogmodeller i distribueret skala ved at bruge Azure OpenAI og Microsoft Fabric.

Forudsætninger

De vigtigste forudsætninger for denne quickstart inkluderer en fungerende Azure OpenAI-ressource og en Apache Spark-klynge med SynapseML installeret.

• Få et Microsoft Fabric abonnement. Eller tilmeld dig en gratis Microsoft Fabric prøveperiode.

• Log ind på Microsoft Fabric.

• Skift til Fabric ved at bruge experience-switcheren nederst til venstre på din startside.

  

• Gå til Data Science-oplevelsen i Microsoft Fabric.
• Opret en ny notesbog.
• En Azure OpenAI-ressource - create a resource

Importér denne vejledning som en notesbog

Det næste trin er at føje denne kode til din Spark-klynge. Du kan enten oprette en notesbog på din Spark-platform og kopiere koden til denne notesbog for at køre demoen. Eller download notesbogen og importer den til Synapse Analytics.

1. Download denne demo som en notesbog (vælg Raw, og gem derefter filen)
2. Importér notesbogen til Synapse Workspace , eller hvis du bruger Fabric-import til Fabric Workspace
3. Installér SynapseML på din klynge. Se installationsvejledningen til Synapse nederst på SynapseML-webstedet. Hvis du bruger Fabric, så tjek installationsvejledningen. Dette trin kræver, at du indsætter en ekstra celle øverst i den notesbog, du importerede.
4. Opret forbindelse mellem din notesbog og en klynge, og følg med, redigere og køre cellerne.

Udfyld tjenesteoplysninger

Derefter skal du redigere cellen i notesbogen for at pege på din tjeneste. Sæt , deployment_name, location, og key variablerne service_nametil at matche din OpenAI-tjeneste:

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

Opret et datasæt med prompter

Opret derefter en dataramme bestående af en række rækker med én prompt pr. række.

Du kan også indlæse data direkte fra ADLS eller andre databaser. Du kan få flere oplysninger om indlæsning og forberedelse af Spark-datarammer i indlæsningsvejledningen til Apache Spark-data.

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

Opret OpenAIPrompt Apache Spark-klienten

For at anvende Azure OpenAI-tjenesten på din dataframe skal du oprette et OpenAIPrompt-objekt, som fungerer som en distribueret klient. Sæt serviceparametrene med enten en enkelt værdi eller en dataframe-kolonne ved at bruge de relevante sættere på objektet OpenAIPrompt . I dette eksempel sættes maxTokens til 200. En token er på omkring fire tegn, og denne grænse gælder for summen af prompten og resultatet. Sæt parameteren promptCol med navnet på promptkolonnen i datarammen.

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

Transformér dataframen ved at bruge OpenAIPrompt-klienten

Efter at have oprettet dataframen og prompt-klienten, transformerer du dit inputdatasæt og tilføjer en kolonne med completions alle de oplysninger, tjenesten tilføjer. Vælg kun teksten for nemheds skyld.

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

Dit output bør se nogenlunde sådan ud. Afslutningsteksten er forskellig fra eksemplet.

Flere anvendelseseksempler

Generering af tekstindlejringer

Ud over at færdiggøre tekst kan du også indlejre tekst til brug i nedstrømsalgoritmer eller vektorgenfindelsesarkitekturer. Ved at oprette embeddings kan du søge og hente dokumenter fra store samlinger. Brug denne tilgang, når prompt engineering ikke er tilstrækkeligt til opgaven. For mere information om brug, OpenAIEmbeddingse embedding-guiden.

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

Chatafslutning

Modeller som GPT-4o og GPT-4.1 forstår chats i stedet for enkeltstående prompts. Transformeren OpenAIChatCompletion fremviser denne funktionalitet 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"
    )
)

Gør dataoverførselshastigheden bedre med anmodningsbatch

I eksemplet angives flere anmodninger til tjenesten, én for hver prompt. Hvis du vil fuldføre flere prompts i en enkelt anmodning, skal du bruge batchtilstand. Først, i objektet OpenAIPrompt , i stedet for at sætte Prompt-kolonnen til "Prompt", angiv "batchPrompt" for BatchPrompt-kolonnen. Det gør du ved at oprette en dataramme med en liste over prompts pr. række.

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

Dernæst opretter du objektet OpenAIPrompt . I stedet for at angive promptkolonnen skal du angive kolonnen batchPrompt, hvis kolonnen er af typen Array[String].

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

I kaldet til transformation foretages en anmodning pr. række. Da hver række indeholder flere prompts, sender hver anmodning alle prompts i den række. Resultaterne indeholder en række for hver række i anmodningen.

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

Brug af en automatisk minibatcher

Hvis dine data er i kolonneformat, kan du transponere dem til rækkeformat ved at bruge 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)

Spørg tekniker til oversættelse

Den Azure OpenAI-service kan løse mange forskellige naturlige sprogopgaver gennem prompt engineering. Dette eksempel viser prompting for sprogoversættelse:

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

Spørg efter svar på spørgsmål

Dette eksempel fremkalder modellen til besvarelse af generelle vidensspørgsmål:

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

Relateret indhold

• Sådan bygger du en søgemaskine med SynapseML
• Sådan bruger du SynapseML og Foundry Tools til detektion af multivariate anomalier - Analyser tidsserier
• Sådan bruges Kerne-SHAP til at forklare en tabelklassificeringsmodel