Bagikan melalui

Azure OpenAI untuk big data

  • Artikel

Layanan Azure OpenAI dapat digunakan untuk menyelesaikan sejumlah besar tugas bahasa alami melalui perintah API penyelesaian. Untuk mempermudah penskalaan alur kerja yang Anda minta dari beberapa contoh ke himpunan data besar contoh, kami mengintegrasikan layanan Azure OpenAI dengan pustaka pembelajaran mesin terdistribusi SynapseML. Integrasi ini memudahkan penggunaan kerangka kerja komputasi terdistribusi Apache Spark untuk memproses jutaan perintah dengan layanan OpenAI. Tutorial ini menunjukkan cara menerapkan model bahasa besar pada skala terdistribusi menggunakan Azure OpenAI dan Azure Synapse Analytics.

Prasyarat

Prasyarat utama untuk mulai cepat ini mencakup sumber daya Azure OpenAI yang berfungsi, dan kluster Apache Spark dengan SynapseML terinstal.

Mengimpor panduan ini sebagai notebook

Langkah selanjutnya adalah menambahkan kode ini ke dalam kluster Spark Anda. Anda bisa membuat buku catatan di platform Spark Anda dan menyalin kode ke dalam buku catatan ini untuk menjalankan demo. Atau unduh notebook dan impor ke Synapse Analytics

  1. Unduh demo ini sebagai buku catatan (pilih Mentah, lalu simpan file)
  2. Impor notebook ke ruang kerja Synapse atau jika menggunakan impor Fabric ke Ruang Kerja Fabric
  3. Instal SynapseML di kluster Anda. Lihat instruksi penginstalan untuk Synapse di bagian bawah situs web SynapseML. Jika Anda menggunakan Fabric, periksa Panduan Penginstalan. Ini memerlukan menempelkan sel tambahan di bagian atas buku catatan yang Anda impor.
  4. Sambungkan buku catatan Anda ke kluster dan ikuti, mengedit dan menjalankan sel.

Isi informasi layanan

Selanjutnya, edit sel di notebook untuk menunjuk ke layanan Anda. Secara khusus atur service_namevariabel , deployment_name, location, dan key untuk mencocokkannya dengan layanan OpenAI Anda:

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

Membuat himpunan data perintah

Selanjutnya, buat dataframe yang terdiri dari serangkaian baris, dengan satu perintah per baris.

Anda juga dapat memuat data langsung dari ADLS atau database lainnya. Untuk informasi selengkapnya tentang memuat dan menyiapkan dataframe Spark, lihat panduan pemuatan data Apache Spark.

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

Membuat OpenAICompletion Apache Spark Client

Untuk menerapkan layanan Penyelesaian OpenAI ke dataframe yang Anda buat, buat objek OpenAICompletion, yang berfungsi sebagai klien terdistribusi. Parameter layanan dapat diatur baik menggunakan nilai tunggal, atau kolom dataframe dengan pengatur yang sesuai pada objek OpenAICompletion. Di sini kita mengatur maxTokens ke 200. Token adalah sekitar empat karakter dan batas ini berlaku untuk jumlah perintah juga hasilnya. Kita juga mengatur parameter promptCol dengan kolom nama perintah dalam dataframe.

from synapse.ml.cognitive import OpenAICompletion

completion = (
    OpenAICompletion()
    .setSubscriptionKey(key)
    .setDeploymentName(deployment_name)
    .setCustomServiceName(service_name)
    .setMaxTokens(200)
    .setPromptCol("prompt")
    .setErrorCol("error")
    .setOutputCol("completions")
)

Mengubah dataframe dengan Klien OpenAICompletion

Setelah menyelesaikan kerangka data dan klien penyelesaian, Anda dapat mengubah himpunan data input dan menambahkan kolom yang dipanggil completions dengan semua informasi yang ditambahkan layanan. Pilih hanya teks untuk kesederhanaan.

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

Output Anda akan terlihat seperti ini. Teks penyelesaian akan berbeda dari sampel.

perintah kesalahan text
Halo nama saya nihil Makaveli saya berusia delapan belas tahun dan saya ingin menjadi rapper ketika saya tumbuh saya suka menulis dan membuat musik saya dari Los Angeles, CA
Kode terbaik adalah kode yang nihil dapat dimengerti Ini adalah pernyataan subjektif, dan tidak ada jawaban pasti.
SynapseML adalah nihil Algoritma pembelajaran mesin yang dapat mempelajari cara memprediksi hasil peristiwa di masa mendatang.

Contoh Penggunaan Lainnya

Menghasilkan Penyematan Teks

Selain menyelesaikan teks, kita juga dapat menyematkan teks untuk digunakan dalam algoritma hilir atau arsitektur pengambilan vektor. Membuat penyematan memungkinkan Anda mencari dan mengambil dokumen dari koleksi besar dan dapat digunakan ketika rekayasa permintaan tidak cukup untuk tugas tersebut. Untuk informasi selengkapnya tentang menggunakan OpenAIEmbedding, lihat panduan penyematan kami.

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

Penyelesaian Obrolan

Model seperti ChatGPT dan GPT-4 mampu memahami obrolan alih-alih permintaan tunggal. OpenAIChatCompletion Transformator mengekspos fungsionalitas ini dalam skala besar.

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

Meningkatkan throughput dengan melakukan batch permintaan

Contohnya membuat beberapa permintaan ke layanan, satu untuk setiap perintah. Untuk menyelesaikan beberapa perintah dalam satu permintaan, gunakan mode batch. Pertama, di objek OpenAICompletion, alih-alih mengatur kolom Prompt ke "Prompt", tentukan "batchPrompt" untuk kolom BatchPrompt. Untuk melakukannya, buat dataframe dengan daftar perintah per baris.

Pada penulisan ini, saat ini ada batas 20 prompt dalam satu permintaan, dan batas keras 2048 "token", atau sekitar 1500 kata.

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

Selanjutnya kita membuat objek OpenAICompletion. Daripada mengatur kolom prompt, atur kolom batchPrompt jika kolom Anda berjenis Array[String].

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

Dalam panggilan untuk mengubah, permintaan akan dibuat per baris. Karena ada beberapa perintah dalam satu baris, setiap permintaan dikirim dengan semua perintah dalam baris tersebut. Hasilnya berisi baris untuk setiap baris dalam permintaan.

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

Menggunakan minibatcher otomatis

Jika data dalam format kolom, Anda dapat mengubah urutannya ke format baris menggunakan 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)

Rekayasa permintaan untuk terjemahan

Layanan Azure OpenAI dapat menyelesaikan berbagai tugas bahasa alami melalui rekayasa permintaan. Di sini, kami menunjukkan contoh permintaan penerjemahan bahasa:

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

Meminta jawaban atas pertanyaan

Di sini, kami meminta GPT-3 untuk jawaban atas pertanyaan pengetahuan umum:

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

Konten terkait