Azure OpenAI for big data

Du kan bruke Azure OpenAI-tjenesten til å løse mange oppgaver på naturlig språk ved å be om fullførings-API-et. For å gjøre det enklere å skalere prompting-arbeidsflytene dine fra noen få eksempler til store datasett med eksempler, integreres Azure OpenAI-tjenesten med det distribuerte maskinlæringsbiblioteket SynapseML. Ved å bruke denne integrasjonen kan du bruke Apache Spark sitt distribuerte databehandlingsrammeverk til å behandle millioner av prompts med OpenAI-tjenesten. Denne veiledningen viser hvordan man kan anvende store språkmodeller i distribuert skala ved å bruke Azure OpenAI og Microsoft Fabric.

Forutsetning

De viktigste forutsetningene for denne hurtigstarten inkluderer en fungerende Azure OpenAI-ressurs og en Apache Spark-klynge med SynapseML installert.

Importer denne veiledningen som en notatblokk

Neste trinn er å legge til denne koden i Spark-klyngen. Du kan enten opprette en notatblokk i Spark-plattformen og kopiere koden til denne notatblokken for å kjøre demoen. Eller last ned notatboken og importer den til Synapse Analytics.

  1. Last ned denne demoen som en notatblokk (velg Raw, og lagre deretter filen)
  2. Importer notatblokken til Synapse-arbeidsområdet , eller hvis du bruker Stoffimport til Fabric Workspace
  3. Installer SynapseML på klyngen. Se installasjonsinstruksjonene for Synapse nederst på SynapseML-nettstedet. Hvis du bruker Fabric, sjekk installasjonsguiden. Dette steget krever at du limer inn en ekstra celle øverst i notatboken du importerte.
  4. Koble notatblokken til en klynge, og følg med, redigere og kjøre cellene.

Fyll ut tjenesteinformasjon

Deretter redigerer du cellen i notatblokken for å peke til tjenesten. Sett variablene service_name, deployment_name, location, og key til å 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

Opprette et datasett med ledetekster

Deretter oppretter du en dataramme som består av en rekke rader, med én ledetekst per rad.

Du kan også laste inn data direkte fra ADLS eller andre databaser. Hvis du vil ha mer informasjon om innlasting og klargjøring av Spark-datarammer, kan du se veiledningen for innlasting av Apache Spark-data.

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

Create OpenAIPrompt Apache Spark client

For å bruke Azure OpenAI-tjenesten på datarammen din, opprett et OpenAIPrompt-objekt som fungerer som en distribuert klient. Sett tjenesteparametrene med enten én verdi eller en dataframe-kolonne ved å bruke de riktige setterne på objektet OpenAIPrompt . I dette eksempelet, sett maxTokens til 200. En token er omtrent fire tegn, og denne grensen gjelder summen av prompten og resultatet. Sett 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 datarammen ved å bruke OpenAIPrompt-klienten

Etter å ha opprettet datarammen og prompt-klienten, transformerer du inputdatasetet ditt og legger til en kolonne med navnet completions med all informasjonen tjenesten legger til. Merk bare teksten for enkelhet.

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

Utdataene skal se omtrent slik ut. Fullføringsteksten er forskjellig fra eksempelet.

omgående feil Tekst
Hei, navnet mitt er null Makaveli, jeg er 18 år gammel og vil bli rapper når jeg blir stor. Jeg elsker å skrive og lage musikk. Jeg er fra Los Angeles, CA.
Den beste koden er kode som er null forståelig Dette er en subjektiv påstand, og det finnes ikke noe definitivt svar.
SynapseML er null En maskinlæringsalgoritme som kan lære å forutsi fremtidige utfall av hendelser.

Flere brukseksempler

Generering av tekstembeddinger

I tillegg til å fullføre tekst, kan du også legge inn tekst for bruk i nedstrøms algoritmer eller vektorgjenfinningsarkitekturer. Ved å lage embeddings kan du søke i og hente dokumenter fra store samlinger. Bruk denne tilnærmingen når prompt engineering ikke er tilstrekkelig for oppgaven. For mer informasjon om bruk, OpenAIEmbeddingse innbyggingsguiden.

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

Chatfullføring

Modeller som GPT-4o og GPT-4.1 forstår chatter i stedet for enkeltprompter. Transformatoren OpenAIChatCompletion viser denne funksjonaliteten 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"
    )
)

Forbedre gjennomstrømming med forespørselsgruppering

Eksemplet gjør flere forespørsler til tjenesten, én for hver ledetekst. Hvis du vil fullføre flere ledetekster i én enkelt forespørsel, bruker du satsvis modus. Først, i objektet OpenAIPrompt , i stedet for å sette Prompt-kolonnen til "Prompt", spesifiser "batchPrompt" for BatchPrompt-kolonnen. Hvis du vil gjøre dette, oppretter du en dataramme med en liste over ledetekster 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")

Deretter lager du objektet OpenAIPrompt . I stedet for å angi ledetekstkolonnen, angir du batchPrompt-kolonnen hvis kolonnen er av typen Array[String].

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

I kallet om å transformere, gjøres det en forespørsel per rad. Siden hver rad inneholder flere prompts, sender hver forespørsel alle prompts i den raden. Resultatene inneholder en rad for hver rad i forespørselen.

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

Bruke en automatisk minibatcher

Hvis dataene dine er i kolonneformat, kan du transponere dem til radformat ved å bruke SynapseMLs 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)

Ledetekst for oversettelse

Den Azure OpenAI-tjenesten kan løse mange forskjellige naturlige språkoppgaver gjennom prompt engineering. Dette eksempelet viser prompting for språkoversettelse:

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

Be om svar på spørsmål

Dette eksempelet utløser modellen for svar på allmennkunnskapsspørsmå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))

Relatert innhold

  • Last updated on