Usługa Azure OpenAI dla danych big data
Usługa Azure OpenAI może służyć do rozwiązywania dużej liczby zadań języka naturalnego za pomocą monitowania interfejsu API uzupełniania. Aby ułatwić skalowanie monitujących przepływów pracy z kilku przykładów do dużych zestawów danych przykładów, zintegrowaliśmy usługę Azure OpenAI z rozproszoną biblioteką uczenia maszynowego SynapseML. Ta integracja ułatwia używanie rozproszonej platformy obliczeniowej Apache Spark do przetwarzania milionów monitów za pomocą usługi OpenAI. W tym samouczku pokazano, jak zastosować duże modele językowe w skali rozproszonej przy użyciu usług Azure OpenAI i Azure Synapse Analytics.
Kluczowe wymagania wstępne dla tego przewodnika Szybki start obejmują działający zasób usługi Azure OpenAI i klaster Apache Spark z zainstalowaną usługą SynapseML.
Uzyskaj subskrypcję usługi Microsoft Fabric. Możesz też utworzyć konto bezpłatnej wersji próbnej usługi Microsoft Fabric.
Zaloguj się do usługi Microsoft Fabric.
Użyj przełącznika środowiska po lewej stronie głównej, aby przełączyć się na środowisko usługi Synapse Nauka o danych.
- Przejdź do środowiska Nauka o danych w usłudze Microsoft Fabric.
- Utwórz nowy notes.
- Zasób usługi Azure OpenAI: żądanie dostępu do usługi Azure OpenAI przed utworzeniem zasobu
Następnym krokiem jest dodanie tego kodu do klastra Spark. Możesz utworzyć notes na platformie Spark i skopiować kod do tego notesu, aby uruchomić pokaz. Możesz też pobrać notes i zaimportować go do usługi Synapse Analytics
- Pobierz ten pokaz jako notes (wybierz pozycję Nieprzetworzone, a następnie zapisz plik)
- Importowanie notesu do obszaru roboczego usługi Synapse lub importowanie przy użyciu usługi Fabric do obszaru roboczego sieci szkieletowej
- Zainstaluj usługę SynapseML w klastrze. Zapoznaj się z instrukcjami dotyczącymi instalacji usługi Synapse w dolnej części witryny internetowej usługi SynapseML. Jeśli używasz sieci szkieletowej, zapoznaj się z przewodnikiem instalacji. Wymaga to wklejenia dodatkowej komórki w górnej części zaimportowanego notesu.
- Połącz notes z klastrem i postępuj zgodnie z instrukcjami, edytując i uruchamiając komórki.
Następnie zmodyfikuj komórkę w notesie, aby wskazywała usługę. W szczególności ustaw service_name
zmienne , deployment_name
, location
i key
, aby były zgodne z usługą OpenAI:
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
Następnie utwórz ramkę danych składającą się z serii wierszy z jednym monitem na wiersz.
Dane można również ładować bezpośrednio z usługi ADLS lub innych baz danych. Aby uzyskać więcej informacji na temat ładowania i przygotowywania ramek danych platformy Spark, zobacz przewodnik ładowania danych platformy Apache Spark.
df = spark.createDataFrame(
[
("Hello my name is",),
("The best code is code thats",),
("SynapseML is ",),
]
).toDF("prompt")
Aby zastosować usługę uzupełniania OpenAI do utworzonej ramki danych, utwórz obiekt OpenAICompletion, który służy jako klient rozproszony. Parametry usługi można ustawić za pomocą pojedynczej wartości lub kolumny ramki danych z odpowiednimi elementami ustawianymi w OpenAICompletion
obiekcie. W tym miejscu ustawiamy maxTokens
wartość 200. Token ma około czterech znaków, a ten limit dotyczy sumy monitu i wyniku. Ustawiamy promptCol
również parametr z nazwą kolumny monitu w ramce danych.
from synapse.ml.cognitive import OpenAICompletion
completion = (
OpenAICompletion()
.setSubscriptionKey(key)
.setDeploymentName(deployment_name)
.setCustomServiceName(service_name)
.setMaxTokens(200)
.setPromptCol("prompt")
.setErrorCol("error")
.setOutputCol("completions")
)
Po ukończeniu ramki danych i klienta uzupełniania możesz przekształcić wejściowy zestaw danych i dodać kolumnę o nazwie completions
ze wszystkimi informacjami dodanymi przez usługę. Wybierz tylko tekst dla uproszczenia.
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"),
)
)
Dane wyjściowe powinny wyglądać mniej więcej tak. Tekst ukończenia będzie inny niż w przykładzie.
monit | błąd | text |
---|---|---|
Witaj, moje imię jest | null | Makaveli mam osiemnaście lat i chcę być raperem, kiedy dorastam, uwielbiam pisać i robić muzykę jestem z Los Angeles, CA |
Najlepszy kod to kod, który jest | null | zrozumiałe jest to subiektywne stwierdzenie i nie ma ostatecznej odpowiedzi. |
SynapseML to | null | Algorytm uczenia maszynowego, który jest w stanie dowiedzieć się, jak przewidzieć przyszły wynik zdarzeń. |
Oprócz uzupełniania tekstu możemy również osadzić tekst do użycia w algorytmach podrzędnych lub architekturach pobierania wektorów. Tworzenie osadzania umożliwia wyszukiwanie i pobieranie dokumentów z dużych kolekcji i może być używane, gdy inżynieria monitu nie jest wystarczająca dla zadania. Aby uzyskać więcej informacji na temat korzystania z usługi OpenAIEmbedding
, zobacz nasz przewodnik osadzania.
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))
Modele, takie jak ChatGPT i GPT-4, mogą zrozumieć czaty zamiast pojedynczych monitów. Transformator OpenAIChatCompletion
uwidacznia tę funkcjonalność na dużą skalę.
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"
)
)
Przykład wysyła kilka żądań do usługi, po jednym dla każdego monitu. Aby wykonać wiele monitów w jednym żądaniu, użyj trybu wsadowego. Najpierw w obiekcie OpenAICompletion zamiast ustawiać kolumnę Monituj na "Monit", określ wartość "batchPrompt" dla kolumny BatchPrompt. W tym celu utwórz ramkę danych z listą monitów na wiersz.
W tym zapisie obecnie istnieje limit 20 monitów w jednym żądaniu i twardy limit 2048 "tokenów" lub około 1500 słów.
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")
Następnie utworzymy obiekt OpenAICompletion. Zamiast ustawiać kolumnę monitu, ustaw kolumnę batchPrompt, jeśli kolumna ma typ Array[String]
.
batch_completion = (
OpenAICompletion()
.setSubscriptionKey(key)
.setDeploymentName(deployment_name)
.setCustomServiceName(service_name)
.setMaxTokens(200)
.setBatchPromptCol("batchPrompt")
.setErrorCol("error")
.setOutputCol("completions")
)
W wywołaniu przekształcenia żądanie zostanie wykonane dla każdego wiersza. Ponieważ istnieje wiele monitów w jednym wierszu, każde żądanie jest wysyłane ze wszystkimi monitami w tym wierszu. Wyniki zawierają wiersz dla każdego wiersza w żądaniu.
completed_batch_df = batch_completion.transform(batch_df).cache()
display(completed_batch_df)
Jeśli dane są w formacie kolumny, możesz transponować je do formatu wiersza przy użyciu języka FixedMiniBatcherTransformer
SynapseML.
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)
Usługa Azure OpenAI może rozwiązywać wiele różnych zadań języka naturalnego za pomocą monitów inżynieryjnych. W tym miejscu przedstawiono przykład monitowania o tłumaczenie języka:
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))
W tym miejscu wyświetlimy monit GPT-3 o udzielenie odpowiedzi na pytania ogólne:
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))