Przeczytaj w języku angielskim

Udostępnij za pośrednictwem


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.

Wymagania wstępne

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.

    Zrzut ekranu przedstawiający menu przełącznika środowiska pokazujące, gdzie wybrać Nauka o danych.

Zaimportuj ten przewodnik jako notes

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

  1. Pobierz ten pokaz jako notes (wybierz pozycję Nieprzetworzone, a następnie zapisz plik)
  2. Importowanie notesu do obszaru roboczego usługi Synapse lub importowanie przy użyciu usługi Fabric do obszaru roboczego sieci szkieletowej
  3. 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.
  4. Połącz notes z klastrem i postępuj zgodnie z instrukcjami, edytując i uruchamiając komórki.

Wypełnij informacje o usłudze

Następnie zmodyfikuj komórkę w notesie, aby wskazywała usługę. W szczególności ustaw service_namezmienne , deployment_name, locationi 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

Tworzenie zestawu danych monitów

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

Tworzenie klienta Platformy Apache Spark OpenAICompletion

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

Przekształcanie ramki danych za pomocą klienta OpenAICompletion

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ń.

Więcej przykładów użycia

Generowanie osadzania tekstu

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

Uzupełnianie czatu

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

Zwiększanie przepływności przy użyciu przetwarzania wsadowego żądań

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)

Korzystanie z automatycznego minibatera

Jeśli dane są w formacie kolumny, możesz transponować je do formatu wiersza przy użyciu języka FixedMiniBatcherTransformerSynapseML.

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)

Monituj inżynierię tłumaczenia

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

Monituj o udzielenie odpowiedzi na pytania

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