Azure OpenAI til big data
Azure OpenAI-tjenesten kan bruges til at løse et stort antal opgaver på naturligt sprog ved at bede om fuldførelses-API'en. For at gøre det nemmere at skalere dine prompte arbejdsprocesser fra nogle få eksempler til store datasæt med eksempler har vi integreret Azure OpenAI-tjenesten med det distribuerede bibliotek til maskinel indlæring SynapseML. Denne integration gør det nemt at bruge de distribuerede Apache Spark-databehandlingsrammer til at behandle millioner af prompts med OpenAI-tjenesten. I dette selvstudium kan du se, hvordan du anvender store sprogmodeller i en distribueret skala ved hjælp af Azure OpenAI og Azure Synapse Analytics.
De vigtigste forudsætninger for denne hurtige start omfatter en fungerende Azure OpenAI-ressource og en Apache Spark-klynge med SynapseML installeret.
Få et Microsoft Fabric-abonnement. Du kan også tilmelde dig en gratis Prøveversion af Microsoft Fabric.
Brug oplevelsesskifteren i venstre side af startsiden til at skifte til Synapse Data Science-oplevelsen.
- Gå til datavidenskabsoplevelsen i Microsoft Fabric.
- Opret en ny notesbog.
- En Azure OpenAI-ressource: Anmod om adgang til Azure OpenAI-tjenesten , før du opretter en ressource
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 importér den i Synapse Analytics
- Download denne demo som en notesbog (vælg Raw, og gem derefter filen)
- Importér notesbogen til Synapse Workspace , eller hvis du bruger Fabric-import til Fabric Workspace
- Installér SynapseML på din klynge. Se installationsvejledningen til Synapse nederst på SynapseML-webstedet. Hvis du bruger Fabric, skal du se Installationsvejledning. Dette kræver, at du indsætter en ekstra celle øverst i den notesbog, du har importeret.
- Opret forbindelse mellem din notesbog og en klynge, og følg med, redigere og køre cellerne.
Derefter skal du redigere cellen i notesbogen for at pege på din tjeneste. Angiv især variablerne service_name
, deployment_name
, location
og key
, for at matche dem med 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-35-turbo"
deployment_name_embeddings = "text-embedding-ada-002"
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 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 thats",),
("SynapseML is ",),
]
).toDF("prompt")
Hvis du vil anvende openAI-fuldførelsestjenesten på den dataramme, du har oprettet, skal du oprette et OpenAICompletion-objekt, der fungerer som en distribueret klient. Parametre for tjenesten kan angives enten med en enkelt værdi eller af en kolonne i datarammen med de relevante settere på objektet OpenAICompletion
. Her er vi ved at angive maxTokens
til 200. Et token er på omkring fire tegn, og denne grænse gælder for summen af prompten og resultatet. Vi angiver promptCol
også parameteren med navnet på promptkolonnen i datarammen.
from synapse.ml.cognitive import OpenAICompletion
completion = (
OpenAICompletion()
.setSubscriptionKey(key)
.setDeploymentName(deployment_name)
.setCustomServiceName(service_name)
.setMaxTokens(200)
.setPromptCol("prompt")
.setErrorCol("error")
.setOutputCol("completions")
)
Når du har fuldført dataramme og fuldførelsesklienten, kan du transformere dit inputdatasæt og tilføje en kolonne, der kaldes completions
, med alle de oplysninger, som 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. Fuldførelsesteksten vil være forskellig fra eksemplet.
lynhurtig | fejl | Tekst |
---|---|---|
Hej mit navn er | null | Makaveli Jeg er atten år gammel, og jeg ønsker at være en rapper, når jeg vokser op jeg elsker at skrive og lave musik jeg er fra Los Angeles, CA |
Den bedste kode er kode, der er | null | forståelig Dette er en subjektiv erklæring, og der er ikke noget endeligt svar. |
SynapseML er | null | En algoritme til maskinel indlæring, der kan lære at forudsige det fremtidige resultat af hændelser. |
Ud over at fuldføre tekst kan vi også integrere tekst til brug i downstreamalgoritmer eller vektorhentningsarkitekturer. Når du opretter integreringer, kan du søge efter og hente dokumenter fra store samlinger og kan bruges, når prompt engineering ikke er tilstrækkelig til opgaven. Du kan få flere oplysninger om brug af OpenAIEmbedding
i vores integreringsvejledning.
from synapse.ml.cognitive import OpenAIEmbedding
embedding = (
OpenAIEmbedding()
.setSubscriptionKey(key)
.setDeploymentName(deployment_name_embeddings)
.setCustomServiceName(service_name)
.setTextCol("prompt")
.setErrorCol("error")
.setOutputCol("embeddings")
)
display(embedding.transform(df))
Modeller som ChatGPT og GPT-4 er i stand til at forstå chats i stedet for enkelte prompts. Transformeren OpenAIChatCompletion
fremviser denne funktionalitet i stor skala.
from synapse.ml.cognitive 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", "Whats 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"
)
)
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. I objektet OpenAICompletion skal du først angive "batchPrompt" for kolonnen BatchPrompt i stedet for at angive kolonnen Prompt til "Prompt". Det gør du ved at oprette en dataramme med en liste over prompts pr. række.
I skrivende stund er der i øjeblikket en grænse på 20 prompts i en enkelt anmodning og en hård grænse på 2048 "tokens" eller ca. 1500 ord.
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")
Derefter opretter vi OpenAICompletion-objektet. I stedet for at angive promptkolonnen skal du angive kolonnen batchPrompt, hvis kolonnen er af typen Array[String]
.
batch_completion = (
OpenAICompletion()
.setSubscriptionKey(key)
.setDeploymentName(deployment_name)
.setCustomServiceName(service_name)
.setMaxTokens(200)
.setBatchPromptCol("batchPrompt")
.setErrorCol("error")
.setOutputCol("completions")
)
I kaldet til transformering foretages der en anmodning pr. række. Da der er flere prompter i en enkelt række, sendes hver anmodning med alle prompter i den pågældende 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)
Hvis dine data er i kolonneformat, kan du ombyte dem til rækkeformat ved hjælp af 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)
Azure OpenAI-tjenesten kan løse mange forskellige opgaver i forbindelse med naturligt sprog ved hjælp af prompt engineering. Her viser vi et eksempel på, hvordan du beder om oversættelse af sprog:
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))
Her beder vi GPT-3 om svar på spørgsmål af generel viden:
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))