Azure OpenAI สําหรับข้อมูลขนาดใหญ่

บริการ Azure OpenAI สามารถใช้เพื่อแก้ไขงานภาษาธรรมชาติจํานวนมากผ่านการพร้อมท์ API การเสร็จสมบูรณ์ เพื่อทําให้ง่ายต่อการปรับขนาดเวิร์กโฟลว์การพร้อมท์ของคุณจากบางตัวอย่างไปยังชุดข้อมูลขนาดใหญ่ของตัวอย่าง เราได้รวมบริการ Azure OpenAI กับไลบรารีการเรียนรู้ของเครื่องแบบกระจาย SynapseML การรวมนี้ทําให้ง่ายต่อการใช้เฟรมเวิร์กการประมวลผลแบบกระจายของ Apache Spark เพื่อประมวลผลพร้อมท์นับล้านรายการด้วยบริการ OpenAI บทช่วยสอนนี้แสดงวิธีการใช้แบบจําลองภาษาขนาดใหญ่ในมาตราส่วนแบบกระจายโดยใช้ Azure OpenAI และ Azure Synapse Analytics

ข้อกำหนดเบื้องต้น

ข้อกําหนดเบื้องต้นสําหรับการเริ่มต้นใช้งานด่วนนี้รวมถึงทรัพยากร Azure OpenAI ที่ใช้งานได้ และคลัสเตอร์ Apache Spark ที่มีการติดตั้ง SynapseML

• รับการสมัครใช้งาน Microsoft Fabric หรือลงทะเบียนเพื่อทดลองใช้งาน Microsoft Fabric ฟรี

• ลงชื่อเข้าใช้ Microsoft Fabric

• ใช้ตัวสลับประสบการณ์ทางด้านซ้ายของโฮมเพจของคุณเพื่อสลับไปยังประสบการณ์วิทยาศาสตร์ข้อมูล Synapse

  

• ไปยังประสบการณ์ด้านวิทยาศาสตร์ข้อมูลใน Microsoft Fabric
• สร้าง สมุดบันทึกใหม่
• ทรัพยากร Azure OpenAI: ร้องขอการเข้าถึงบริการ Azure OpenAI ก่อนที่จะ สร้างทรัพยากร

นําเข้าคู่มือนี้เป็นสมุดบันทึก

ขั้นตอนถัดไปคือการเพิ่มรหัสนี้ลงในคลัสเตอร์ Spark ของคุณ คุณสามารถสร้างสมุดบันทึกในแพลตฟอร์ม Spark ของคุณและคัดลอกรหัสลงในสมุดบันทึกนี้เพื่อเรียกใช้การสาธิตได้ หรือดาวน์โหลดสมุดบันทึก และนําเข้าลงใน Synapse Analytics

1. ดาวน์โหลดการสาธิตนี้เป็นสมุดบันทึก (เลือก ดิบ แล้วบันทึกไฟล์)
2. นําเข้าสมุดบันทึก ลงในพื้นที่ทํางาน Synapse หรือถ้าใช้ Fabric import ลงใน Fabric Workspace
3. ติดตั้ง SynapseML บนคลัสเตอร์ของคุณ ดูคําแนะนําในการติดตั้งสําหรับ Synapse ที่ด้านล่างของ เว็บไซต์ SynapseML ถ้าคุณกําลังใช้ Fabric ตรวจสอบ คู่มือการติดตั้ง ซึ่งจําเป็นต้องวางเซลล์เพิ่มเติมที่ด้านบนของสมุดบันทึกที่คุณนําเข้า
4. เชื่อมต่อสมุดบันทึกของคุณกับคลัสเตอร์ และทําตาม แก้ไข และเรียกใช้เซลล์

กรอกข้อมูลบริการ

ถัดไป แก้ไขเซลล์ในสมุดบันทึกเพื่อชี้ไปยังบริการของคุณ ให้ตั้งค่า service_nameตัวแปร , deployment_name, locationและ key โดยเฉพาะอย่างยิ่งเพื่อให้ตรงกับบริการ 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

สร้างชุดข้อมูลของพร้อมท์

ถัดไป สร้าง dataframe ที่ประกอบด้วยชุดของแถว โดยมีหนึ่งพร้อมท์ต่อหนึ่งแถว

คุณยังสามารถโหลดข้อมูลได้โดยตรงจาก ADLS หรือฐานข้อมูลอื่นๆ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการโหลดและเตรียมกรอบข้อมูล Spark โปรดดู คู่มือการโหลดข้อมูล Apache Spark

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

สร้างไคลเอ็นต์ OpenAICompletion Apache Spark

หากต้องการใช้บริการการทําให้เสร็จสมบูรณ์ของ OpenAI กับกรอบข้อมูลของคุณที่คุณสร้างขึ้น ให้สร้างวัตถุ OpenAICompletion ซึ่งทําหน้าที่เป็นลูกค้าแบบกระจาย คุณสามารถตั้งค่าพารามิเตอร์ของบริการด้วยค่าเดียวหรือโดยคอลัมน์ของดาต้าเฟรมที่มีตัวตั้งค่าที่เหมาะสมบน OpenAICompletion วัตถุได้ ที่นี่เรากําลังตั้งค่า maxTokens เป็น 200 โทเค็นอยู่ที่ประมาณสี่อักขระ และขีดจํากัดนี้จะนําไปใช้กับผลรวมของพร้อมท์และผลลัพธ์ นอกจากนี้เรายังตั้งค่า promptCol พารามิเตอร์ด้วยชื่อของคอลัมน์ที่พร้อมท์ใน 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")
)

แปลงกรอบข้อมูลด้วยไคลเอ็นต์ OpenAICompletion

หลังจากดําเนินการ dataframe และไคลเอ็นต์เสร็จสมบูรณ์แล้ว คุณสามารถแปลงชุดข้อมูลอินพุตของคุณและเพิ่มคอลัมน์ที่เรียกว่า completions ด้วยข้อมูลที่บริการเพิ่มได้ เลือกเพียงข้อความเพื่อความง่าย

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

ผลลัพธ์ของคุณควรมีลักษณะดังนี้ ข้อความความสมบูรณ์จะแตกต่างจากตัวอย่าง

พร้อมท์	ความผิดพลาด	ข้อความ
สวัสดี ชื่อของฉันคือ	Null	Makaveli ฉันอายุสิบแปดปีและฉันต้องการเป็นแร็ปเปอร์เมื่อฉันเติบโตขึ้นฉันรักการเขียนและทําเพลงที่ฉันมาจากลอสแองเจลิส CA
โค้ดที่ดีที่สุดคือโค้ดนั่นคือ	Null	สามารถเข้าใจได้ นี่คือคําสั่งเฉพาะเรื่อง และไม่มีคําตอบที่ชัดเจน
SynapseML คือ	Null	อัลกอริทึมการเรียนรู้ของเครื่องที่สามารถเรียนรู้วิธีการคาดการณ์ผลลัพธ์ในอนาคตของเหตุการณ์

ตัวอย่างการใช้งานเพิ่มเติม

กําลังสร้างการฝังข้อความ

นอกเหนือจากการทําข้อความให้เสร็จสมบูรณ์แล้ว เรายังสามารถฝังข้อความสําหรับใช้ในอัลกอริทึมแบบดาวน์สตรีมหรือสถาปัตยกรรมแบบเวกเตอร์ได้ การสร้างการฝังช่วยให้คุณสามารถค้นหาและเรียกใช้เอกสารจากคอลเลกชันขนาดใหญ่ได้ และสามารถใช้ได้เมื่อวิศวกรรมพร้อมต์ไม่เพียงพอสําหรับงาน สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้ OpenAIEmbeddingดูคู่มือการฝังของเรา

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

การสนทนาเสร็จสมบูรณ์

แบบจําลองเช่น ChatGPT และ GPT-4 สามารถเข้าใจการแชทแทนที่จะเป็นพร้อมท์เดียว ตัว OpenAIChatCompletion แปลงจะแสดงฟังก์ชันการทํางานนี้ในระดับมาตราส่วน

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

ปรับปรุงปริมาณงานด้วยการทําชุดงานคําขอ

ตัวอย่างทําให้หลายคําขอไปยังบริการ หนึ่งคําขอสําหรับแต่ละพร้อมท์ เมื่อต้องการดําเนินการพร้อมท์หลายรายการให้เสร็จสมบูรณ์ในคําขอเดียว ให้ใช้โหมดชุดงาน ก่อนอื่น ในออบเจ็กต์ OpenAICompletion แทนที่จะตั้งค่าคอลัมน์ พร้อมต์ เป็น "พร้อมต์" ให้ระบุ "batchPrompt" สําหรับคอลัมน์ BatchPrompt เมื่อต้องการทําเช่นนั้น ให้สร้าง dataframe ที่มีรายการของพร้อมท์ต่อแถว

สําหรับการเขียนนี้มีขีดจํากัดของพร้อมท์ 20 รายการในการร้องขอเดียว และขีดจํากัดสูงสุดที่ 2048 "โทเค็น" หรือประมาณ 1500 คํา

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

ถัดไป เราจะสร้างออบเจ็กต์ OpenAICompletion ให้ตั้งค่าคอลัมน์ batchPrompt แทนการตั้งค่าคอลัมน์ batchPrompt หากคอลัมน์ของคุณเป็นชนิดArray[String]

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

ในการเรียกการแปลง คําขอจะถูกทําต่อแถว เนื่องจากมีหลายพร้อมท์ในหนึ่งแถว คําขอแต่ละรายการจะถูกส่งพร้อมกับพร้อมท์ทั้งหมดในแถวนั้น ผลลัพธ์ประกอบด้วยแถวสําหรับแต่ละแถวในคําขอ

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

การใช้เครื่องมินิแบทเชอร์อัตโนมัติ

ถ้าข้อมูลของคุณอยู่ในรูปแบบคอลัมน์ คุณสามารถสลับเปลี่ยนแถวเป็นรูปแบบแถวโดยใช้ 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 สามารถแก้ไขงานภาษาธรรมชาติต่าง ๆ ได้มากมายผ่าน วิศวกรรมที่รวดเร็ว ที่นี่ เราแสดงตัวอย่างของการพร้อมท์สําหรับการแปลภาษา:

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

พร้อมท์สําหรับการตอบคําถาม

ที่นี่เราพร้อมท์ GPT-3 สําหรับการตอบคําถามคําถามความรู้ทั่วไป:

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

เนื้อหาที่เกี่ยวข้อง

• วิธีการสร้างเครื่องมือค้นหาด้วย SynapseML
• วิธีใช้บริการ SynapseML และ Azure AI สําหรับการตรวจหาสิ่งผิดปกติที่หลากหลาย - วิเคราะห์ชุดข้อมูลเวลา
• วิธีใช้ Kernel SHAP เพื่ออธิบายแบบจําลองการจัดประเภทแบบตาราง