Azure OpenAI for store data
Azure OpenAI-tjenesten kan brukes til å løse et stort antall naturlige språkoppgaver ved å spørre om fullføring av API-en. Vi har integrert Azure OpenAI-tjenesten med det distribuerte maskinlæringsbiblioteket SynapseML for å gjøre det enklere å skalere spørrearbeidsflyter fra noen få eksempler til store datasett med eksempler. Denne integreringen gjør det enkelt å bruke Apache Spark-distribuert databehandlingsrammeverk til å behandle millioner av ledetekster med OpenAI-tjenesten. Denne opplæringen viser hvordan du bruker store språkmodeller i distribuert skala ved hjelp av Azure OpenAI og Azure Synapse Analytics.
De viktigste forutsetningene for denne hurtigstarten inkluderer en fungerende Azure OpenAI-ressurs og en Apache Spark-klynge med SynapseML installert.
Få et Microsoft Fabric-abonnement. Eller registrer deg for en gratis prøveversjon av Microsoft Fabric.
Logg på Microsoft Fabric.
Bruk opplevelsesbryteren til venstre på hjemmesiden for å bytte til Synapse Data Science-opplevelsen.
- Gå til Data Science-opplevelsen i Microsoft Fabric.
- Opprett en ny notatblokk.
- En Azure OpenAI-ressurs: Be om tilgang til Azure OpenAI-tjenesten før du oppretter en ressurs
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 notatblokken og importer den til Synapse Analytics
- Last ned denne demoen som en notatblokk (velg Raw, og lagre deretter filen)
- Importer notatblokken til Synapse-arbeidsområdet , eller hvis du bruker Stoffimport til Fabric Workspace
- Installer SynapseML på klyngen. Se installasjonsinstruksjonene for Synapse nederst på SynapseML-nettstedet. Hvis du bruker Stoff, må du kontrollere installasjonsveiledningen. Dette krever at du limer inn en ekstra celle øverst i notatblokken du importerte.
- Koble notatblokken til en klynge, og følg med, redigere og kjøre cellene.
Deretter redigerer du cellen i notatblokken for å peke til tjenesten. Angi spesielt variablene service_name
, , location
deployment_name
og slik key
at de samsvarer med OpenAI-tjenesten:
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
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 thats",),
("SynapseML is ",),
]
).toDF("prompt")
Hvis du vil bruke OpenAI Completion-tjenesten på datarammen du opprettet, oppretter du et OpenAICompletion-objekt, som fungerer som en distribuert klient. Parametere for tjenesten kan angis enten med én enkelt verdi, eller av en kolonne i datarammen med de riktige setterne på OpenAICompletion
objektet. Her setter maxTokens
vi til 200. Et token er rundt fire tegn, og denne grensen gjelder for summen av ledeteksten og resultatet. Vi angir også parameteren promptCol
med navnet på ledetekstkolonnen 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 fullført datarammen og fullføringsklienten, kan du transformere inndatasettet og legge til en kolonne kalt 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 vil være forskjellig fra eksemplet.
omgående | feil | Tekst |
---|---|---|
Hei, navnet mitt er | null | Makaveli Jeg er atten år gammel og jeg ønsker å bli rapper når jeg vokser opp jeg elsker å skrive og lage musikk jeg er fra Los Angeles, CA |
Den beste koden er kode som er | null | forståelig nok er dette en subjektiv uttalelse, og det finnes ikke noe definitivt svar. |
SynapseML er | null | En maskinlæringsalgoritme som kan lære hvordan du forutser det fremtidige utfallet av hendelser. |
I tillegg til å fullføre tekst, kan vi også bygge inn tekst for bruk i nedstrøms algoritmer eller vektorhentingsarkitekturer. Når du oppretter innebygginger, kan du søke i og hente dokumenter fra store samlinger og kan brukes når ledetekstteknikk ikke er tilstrekkelig for oppgaven. Hvis du vil ha mer informasjon om hvordan du bruker OpenAIEmbedding
, kan du se veiledningen for innebygging.
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 å forstå chatter i stedet for enkle ledetekster. Transformatoren OpenAIChatCompletion
viser denne funksjonaliteten 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"
)
)
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. Angi «batchPrompt» for BatchPrompt-kolonnen i OpenAICompletion-objektet i stedet for å angi Ledetekst-kolonnen til Ledetekst. Hvis du vil gjøre dette, oppretter du en dataramme med en liste over ledetekster per rad.
I skrivende stund er det for øyeblikket en grense på 20 ledetekster i én enkelt forespørsel, og en hard grense på 2048 «tokener» eller omtrent 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")
Deretter oppretter vi OpenAICompletion-objektet. I stedet for å angi ledetekstkolonnen, angir du batchPrompt-kolonnen hvis kolonnen er av typen Array[String]
.
batch_completion = (
OpenAICompletion()
.setSubscriptionKey(key)
.setDeploymentName(deployment_name)
.setCustomServiceName(service_name)
.setMaxTokens(200)
.setBatchPromptCol("batchPrompt")
.setErrorCol("error")
.setOutputCol("completions")
)
I kallet for å transformere, vil en forespørsel bli gjort per rad. Siden det er flere ledetekster i én rad, sendes hver forespørsel med alle ledetekster i denne raden. Resultatene inneholder en rad for hver rad i forespørselen.
completed_batch_df = batch_completion.transform(batch_df).cache()
display(completed_batch_df)
Hvis dataene er i kolonneformat, kan du transponere dem til radformat ved hjelp av SynapseML.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 forskjellige naturlige språkoppgaver gjennom ledeteknikk. Her viser vi et eksempel på å spørre om 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))
Her ber vi GPT-3 om generell kunnskapsspørsmål som svarer:
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))