Bermula dengan output berstruktur terbuka

Pada bulan Ogos 2024, OpenAI mengumumkan ciri baru yang kuat dalam output berstruktur API mereka. Dengan ciri ini, seperti namanya, anda boleh memastikan LLMS akan menjana respons hanya dalam format yang anda nyatakan. Keupayaan ini akan menjadikannya lebih mudah untuk membina aplikasi yang memerlukan pemformatan data yang tepat. 

Dalam tutorial ini, anda akan belajar bagaimana untuk memulakan dengan output berstruktur terbuka, memahami sintaks yang baru, dan meneroka aplikasi utamanya.

Respons deterministik, atau, dengan kata lain, tindak balas dalam pemformatan yang konsisten, adalah penting untuk banyak tugas seperti kemasukan data, pengambilan maklumat, menjawab soalan, aliran kerja pelbagai langkah, dan sebagainya. Anda mungkin mengalami bagaimana LLM boleh menghasilkan output dalam format yang sangat berbeza, walaupun prompt adalah sama.

Sebagai contoh, pertimbangkan fungsi klasifikasi mudah alih ini yang dikuasakan oleh GPT-4O:

output:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Walaupun dua respons pertama berada dalam format satu perkataan yang sama, yang terakhir adalah keseluruhan ayat. Sekiranya beberapa aplikasi hiliran lain bergantung kepada output kod di atas, ia akan terhempas kerana ia akan menjangkakan tindak balas satu perkataan.

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

kita boleh menyelesaikan masalah ini dengan beberapa kejuruteraan segera, tetapi ia adalah proses yang memakan masa, berulang. Walaupun dengan pantas, kami tidak boleh 100% pasti respons akan mematuhi format kami dalam permintaan masa depan. Kecuali, tentu saja, kami menggunakan output berstruktur:

output:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

dengan fungsi baru, classify_sentiment_with_structured_outputs, respons semuanya dalam format yang sama.

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Keupayaan memaksa model bahasa dalam format tegar adalah penting, menjimatkan anda banyak jam kejuruteraan segera atau pergantungan pada alat sumber terbuka yang lain.

Bermula dengan Output Terbuka Terbuka

Dalam bahagian ini, kita akan memecahkan output berstruktur menggunakan contoh fungsi penganalisis sentimen.

menyediakan persekitaran anda

Prasyarat

Sebelum anda memulakan, pastikan anda mempunyai yang berikut:

python 3.7 atau kemudian dipasang pada sistem anda.

Kunci API OpenAI. Anda boleh mendapatkannya dengan mendaftar di laman web Openai.
• Menyediakan Api Terbuka

1. Pasang Pakej Openai Python: Buka terminal anda dan jalankan arahan berikut untuk memasang atau mengemas kini pakej Openai Python ke versi terkini:

2. Sediakan kunci API anda: Anda boleh menetapkan kekunci API anda sebagai pemboleh ubah persekitaran atau terus dalam kod anda. Untuk menetapkannya sebagai pemboleh ubah persekitaran, jalankan:

$ pip install -U openai

3. Sahkan pemasangan: Buat skrip python mudah untuk mengesahkan pemasangan:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Jalankan skrip untuk memastikan semuanya disediakan dengan betul. Anda harus melihat tindak balas model yang dicetak di terminal.

Di samping pakej OpenAI, anda memerlukan perpustakaan Pydantic untuk menentukan dan mengesahkan skema JSON untuk output berstruktur. Pasangnya menggunakan PIP:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Dengan langkah -langkah ini, persekitaran anda kini ditubuhkan untuk menggunakan ciri output berstruktur OpenAI.

Menentukan skema output menggunakan pydantic

Untuk menggunakan output berstruktur, anda perlu menentukan struktur output yang diharapkan menggunakan model Pydantic. Pydantic adalah Perpustakaan Pengurusan Pengesahan Data dan Tetapan untuk Python, yang membolehkan anda menentukan model data menggunakan anotasi jenis Python. Model -model ini kemudiannya boleh digunakan untuk menguatkuasakan struktur output yang dihasilkan oleh model OpenAI.

Berikut adalah contoh model Pydantic untuk menentukan format untuk pengelas sentimen semakan kami:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Dalam contoh ini:

• sentimenResponse adalah model pydantic yang mentakrifkan struktur yang diharapkan dari output.
• Model ini mempunyai sentimen medan tunggal, yang hanya boleh mengambil satu daripada tiga nilai literal: "positif," "negatif," atau "neutral."

Apabila kita lulus model ini sebagai sebahagian daripada permintaan API Openai kami, output hanya akan menjadi salah satu perkataan yang kami berikan.

mari kita lihat bagaimana.

menggunakan pembantu parse

Untuk menguatkuasakan skema Pydantic kami dalam permintaan OpenAI, semua yang perlu kami lakukan adalah lulus kepada parameter Response_Format API CHAT. Secara kasar, inilah yang kelihatan seperti:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Jika anda perasan, bukannya menggunakan client.chat.completions.create, kami menggunakan kaedah client.beta.chat.completions.parse. .parse () adalah kaedah baru dalam API Penyiapan Sembang yang ditulis secara khusus untuk output berstruktur.

Sekarang, mari kita meletakkan semuanya bersama -sama dengan menulis semula pengelas sentimen ulasan dengan output berstruktur. Pertama, kami membuat import yang diperlukan, tentukan model Pydantic, prompt sistem, dan templat segera:

$ pip install -U openai

Kemudian, kami menulis fungsi baru yang menggunakan kaedah penolong .parse ():

$ export OPENAI_API_KEY='your-api-key'

Baris penting dalam fungsi adalah response_format = sentimentResponse, yang sebenarnya membolehkan output berstruktur.

mari kita uji pada salah satu ulasan:

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
   model="gpt-4o-mini",
   messages=[
       {"role": "system", "content": "You are a helpful assistant."},
       {"role": "user", "content": "Say hello!"}
   ],
   max_tokens=5
)
>>> print(response.choices[0].message.content.strip())
Hello! How can I

di sini, hasilnya adalah objek mesej:

$ pip install pydantic

selain daripada atribut yang tidak disengajakan, yang mengambil respons, ia mempunyai atribut.

from pydantic import BaseModel
from typing import Literal
class SentimentResponse(BaseModel):
   sentiment: Literal["positive", "negative", "neutral"]

Seperti yang anda lihat, kami mendapat contoh kelas sentimenResponse. Ini bermakna kita boleh mengakses sentimen sebagai rentetan dan bukannya kamus menggunakan atribut.

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Model Pydantic bersarang untuk menentukan skema kompleks

Dalam beberapa kes, anda mungkin perlu menentukan struktur output yang lebih kompleks yang melibatkan data bersarang. Pydantic membolehkan anda untuk bersarang model dalam satu sama lain, membolehkan anda membuat skema rumit yang boleh mengendalikan pelbagai kes penggunaan. Ini amat berguna apabila berurusan dengan data hierarki atau apabila anda perlu menguatkuasakan struktur tertentu untuk output kompleks.

mari kita pertimbangkan contoh di mana kita perlu mengekstrak maklumat pengguna terperinci, termasuk nama mereka, butiran hubungan, dan senarai alamat. Setiap alamat harus termasuk bidang untuk kod jalan, bandar, negeri, dan zip. Ini memerlukan lebih daripada satu model Pydantic untuk membina skema yang betul.

Langkah 1: Tentukan model Pydantic

Pertama, kami mentakrifkan model Pydantic untuk alamat dan maklumat pengguna:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Dalam contoh ini:

Alamat
• adalah model pydantic yang mentakrifkan struktur alamat.
• UserInfo adalah model pydantic yang merangkumi senarai objek alamat, bersama dengan medan untuk nama pengguna, e -mel, dan nombor telefon.

Langkah 2: Gunakan model Pydantic bersarang dalam panggilan API

Seterusnya, kami menggunakan model Pydantic bersarang ini untuk menguatkuasakan struktur output dalam panggilan API OpenAI:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Teks sampel tidak dapat dibaca sepenuhnya dan tidak mempunyai ruang antara kepingan utama maklumat. Mari kita lihat jika model berjaya. Kami akan menggunakan Perpustakaan JSON untuk menyenaraikan respons:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Seperti yang anda lihat, model itu betul menangkap maklumat pengguna tunggal bersama -sama dengan dua alamat berasingan mereka berdasarkan skema kami yang disediakan.

Singkatnya, dengan bersarang model Pydantic, anda boleh menentukan skema kompleks yang mengendalikan data hierarki dan menguatkuasakan struktur tertentu untuk output yang rumit.

fungsi panggilan dengan output berstruktur

Salah satu ciri yang meluas dari model bahasa yang lebih baru adalah fungsi panggilan (juga dipanggil alat panggilan). Keupayaan ini membolehkan anda menyambungkan model bahasa ke fungsi yang ditetapkan pengguna, dengan berkesan memberi mereka akses (model) ke dunia luar.

beberapa contoh biasa ialah:

mengambil data masa nyata (mis., Cuaca, harga saham, skor sukan)
melakukan pengiraan atau analisis data
Pertanyaan Pangkalan Data atau API
menghasilkan imej atau media lain
menterjemahkan teks antara bahasa
mengawal peranti rumah pintar atau sistem IOT
Melaksanakan logik perniagaan atau aliran kerja tersuai

Kami tidak akan masuk ke dalam butiran bagaimana fungsi panggilan berfungsi di sini, tetapi anda boleh membaca tutorial panggilan fungsi OpenAI kami.

Apa yang penting untuk diketahui ialah dengan output berstruktur, menggunakan fungsi panggilan dengan model terbuka menjadi lebih mudah. Pada masa lalu, fungsi yang anda lalui ke model OpenAI akan memerlukan skema JSON kompleks menulis, menggariskan setiap parameter fungsi dengan petunjuk jenis. Berikut adalah contoh:

# List of hotel reviews
reviews = [
   "The room was clean and the staff was friendly.",
   "The location was terrible and the service was slow.",
   "The food was amazing but the room was too small.",
]
# Classify sentiment for each review and print the results
for review in reviews:
   sentiment = classify_sentiment(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

Walaupun fungsi get_current_weather mempunyai dua parameter, skema JSON menjadi sangat besar dan rawan kesilapan untuk menulis secara manual.

Ini diselesaikan dalam output berstruktur dengan menggunakan model pydantic lagi:

Review: The room was clean and the staff was friendly.
Sentiment: Positive
Review: The location was terrible and the service was slow.
Sentiment: Negative
Review: The food was amazing but the room was too small.
Sentiment: The sentiment of the review is neutral.

Pertama, anda menulis fungsi itu sendiri dan logiknya. Kemudian, anda menentukannya lagi dengan model Pydantic yang menyatakan parameter input yang diharapkan.

Kemudian, untuk menukar model pydantic menjadi skema JSON yang serasi, anda panggil pydantic_function_tool:

def classify_sentiment_with_structured_outputs(review):
   """Sentiment classifier with Structured Outputs"""
   ...
# Classify sentiment for each review with Structured Outputs
for review in reviews:
   sentiment = classify_sentiment_with_structured_outputs(review)
   print(f"Review: {review}\nSentiment: {sentiment}\n")

inilah cara menggunakan alat ini sebagai sebahagian daripada permintaan:

Review: The room was clean and the staff was friendly.
Sentiment: {"sentiment":"positive"}
Review: The location was terrible and the service was slow.
Sentiment: {"sentiment":"negative"}
Review: The food was amazing but the room was too small.
Sentiment: {"sentiment":"neutral"}

Kami lulus model Pydantic dalam format JSON yang serasi ke parameter alat API Penyiapan Sembang. Kemudian, bergantung pada pertanyaan kami, model memutuskan sama ada untuk memanggil alat atau tidak.

Oleh kerana pertanyaan kami dalam contoh di atas ialah "Apakah cuaca di Tokyo?", Kami melihat panggilan dalam tool_calls objek mesej yang dikembalikan.

ingat, model itu tidak memanggil fungsi get_weather tetapi menghasilkan argumen untuknya berdasarkan skema pydantic yang kami berikan:

$ pip install -U openai

terpulang kepada kita untuk memanggil fungsi dengan argumen yang disediakan:

$ export OPENAI_API_KEY='your-api-key'

Jika anda mahu model menghasilkan hujah untuk fungsi dan memanggilnya pada masa yang sama, anda sedang mencari ejen AI. 

kami mempunyai tutorial ejen langchain berasingan jika anda berminat.

amalan terbaik semasa menggunakan output berstruktur terbuka

Semasa menggunakan output berstruktur, terdapat beberapa amalan terbaik dan cadangan untuk diingat. Dalam bahagian ini, kami akan menggariskan sebahagian daripada mereka.

1. Gunakan model pydantic untuk menentukan skema output, kerana mereka menyediakan cara yang bersih dan selamat untuk menentukan struktur output yang diharapkan.
2. Pastikan skema mudah dan khusus untuk mendapatkan hasil yang paling tepat.
3. Gunakan jenis data yang sesuai (str, int, float, bool, senarai, dict) untuk mewakili data anda dengan tepat.
4. Gunakan jenis literal untuk enum untuk menentukan nilai yang dibenarkan untuk medan.
5. mengendalikan penolakan model. Apabila menggunakan kaedah baru .parse (), objek mesej mempunyai atribut yang baru untuk menunjukkan penolakan:

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
   model="gpt-4o-mini",
   messages=[
       {"role": "system", "content": "You are a helpful assistant."},
       {"role": "user", "content": "Say hello!"}
   ],
   max_tokens=5
)
>>> print(response.choices[0].message.content.strip())
Hello! How can I

output:

$ pip install pydantic

6. Berikan keterangan yang jelas dan ringkas untuk setiap bidang dalam model Pydantic anda untuk meningkatkan ketepatan output model:

from pydantic import BaseModel
from typing import Literal
class SentimentResponse(BaseModel):
   sentiment: Literal["positive", "negative", "neutral"]

Amalan ini akan pergi jauh dalam menggunakan output berstruktur yang paling berkesan dalam aplikasi anda.

Kesimpulan

Dalam tutorial ini, kami telah belajar bagaimana untuk memulakan dengan ciri API OpenAI yang baru: output berstruktur. Kami telah melihat bagaimana ciri ini memaksa model bahasa untuk menghasilkan output dalam format yang kami nyatakan. Kami telah belajar bagaimana menggunakannya dalam kombinasi dengan panggilan fungsi dan meneroka beberapa amalan terbaik untuk memanfaatkan ciri -ciri ini.

Berikut adalah beberapa sumber yang berkaitan untuk meningkatkan pemahaman anda:

• Bekerja dengan Kursus API Terbuka
• Openai Fundamentals Track
• Membangunkan aplikasi LLM dengan kursus Langchain
• Langchain vs Llamaindex: Perbandingan terperinci

Dapatkan pensijilan AI teratas

Menunjukkan anda boleh dengan berkesan dan bertanggungjawab menggunakan AI.get yang disahkan, dapatkan

output berstruktur FAQs

Struktur output yang dikehendaki, yang kemudiannya dihantar ke API Openai untuk menguatkuasakan format tindak balas. Adakah faedah menggunakan output berstruktur? Output?

Walaupun output yang kuat, berstruktur mungkin mengehadkan fleksibiliti AI dalam respons dan memerlukan reka bentuk skema yang teliti untuk mengimbangi struktur dengan tahap terperinci yang dikehendaki dalam output.

Atas ialah kandungan terperinci Bermula dengan output berstruktur terbuka. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!