OpenAI Structured Outputs के साथ शुरुआत करें

AI एप्लिकेशंस में Structured Outputs का महत्व

निश्चित (deterministic) प्रतिक्रियाएँ, या दूसरे शब्दों में, सुसंगत फ़ॉर्मेटिंग में प्रतिक्रियाएँ, डेटा एंट्री, सूचना पुनर्प्राप्ति, प्रश्नोत्तर, बहु-चरणीय वर्कफ़्लो आदि जैसे कई कार्यों के लिए महत्वपूर्ण हैं। आप ने देखा होगा कि LLMs एक ही प्रॉम्प्ट पर भी बेहद अलग-अलग फ़ॉर्मेट में आउटपुट दे सकते हैं।

उदाहरण के लिए, इस सरल classify_sentiment फ़ंक्शन पर विचार करें जो GPT-4o द्वारा संचालित है:

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

आउटपुट:

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.

हालाँकि पहली दो प्रतिक्रियाएँ एक ही एक-शब्द फ़ॉर्मेट में थीं, अंतिम प्रतिक्रिया पूरा वाक्य है। यदि कोई डाउनस्ट्रीम एप्लिकेशन ऊपर दिए गए कोड के आउटपुट पर निर्भर होता, तो वह क्रैश हो जाता क्योंकि वह एक-शब्दीय प्रतिक्रिया की अपेक्षा कर रहा होता।

हम इस समस्या को कुछ प्रॉम्प्ट इंजीनियरिंग से ठीक कर सकते हैं, लेकिन यह एक समय लेने वाली, आवृत्तिमूलक प्रक्रिया है। एकदम सही प्रॉम्प्ट के साथ भी, हम 100% सुनिश्चित नहीं हो सकते कि भविष्य के अनुरोधों में प्रतिक्रियाएँ हमारे फ़ॉर्मेट का पालन करेंगी। बशर्ते, हम Structured Outputs का उपयोग करें:

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

आउटपुट:

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

नई फ़ंक्शन classify_sentiment_with_structured_outputs के साथ, सभी प्रतिक्रियाएँ एक ही फ़ॉर्मेट में हैं।

भाषा मॉडलों को सख्त फ़ॉर्मेट में बाध्य करने की यह क्षमता महत्वपूर्ण है, जो आपको अनगिनत घंटे की प्रॉम्प्ट इंजीनियरिंग या अन्य ओपन-सोर्स टूल्स पर निर्भरता से बचाती है।

OpenAI Structured Outputs के साथ शुरुआत

इस अनुभाग में, हम सेंटिमेंट एनालाइज़र फ़ंक्शन के उदाहरण से Structured Outputs को समझेंगे।

अपना वातावरण सेट करना

पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित हैं:

• आपके सिस्टम में Python 3.7 या उससे नया संस्करण इंस्टॉल हो।
• एक OpenAI API की। आप इसे OpenAI वेबसाइट पर साइन अप करके प्राप्त कर सकते हैं।

OpenAI API सेट करना

1. OpenAI Python पैकेज इंस्टॉल करें: अपना टर्मिनल खोलें और OpenAI Python पैकेज को नवीनतम संस्करण में इंस्टॉल या अपडेट करने के लिए निम्न कमांड चलाएँ:

$ pip install -U openai

2. अपना API की सेट करें: आप अपना API की परिवेश चर (environment variable) के रूप में या सीधे कोड में सेट कर सकते हैं। परिवेश चर के रूप में सेट करने के लिए चलाएँ:

$ export OPENAI_API_KEY='your-api-key'

3. इंस्टॉलेशन सत्यापित करें: इंस्टॉलेशन सत्यापित करने के लिए एक सरल Python स्क्रिप्ट बनाएँ:

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

स्क्रिप्ट चलाएँ ताकि सुनिश्चित हो सके कि सब कुछ सही से सेट है। आपको टर्मिनल में मॉडल की प्रतिक्रिया प्रिंट होती दिखाई देगी।

OpenAI पैकेज के अतिरिक्त, आपको Structured Outputs के लिए JSON स्कीमा परिभाषित और वैध करने हेतु Pydantic लाइब्रेरी की आवश्यकता होगी। इसे pip से इंस्टॉल करें:

$ pip install pydantic

इन चरणों के साथ, आपका वातावरण अब OpenAI की Structured Outputs सुविधा का उपयोग करने के लिए तैयार है।

Pydantic का उपयोग करके आउटपुट स्कीमा परिभाषित करना

Structured Outputs का उपयोग करने के लिए, आपको अपेक्षित आउटपुट संरचना को Pydantic मॉडल्स से परिभाषित करना होगा। Pydantic Python के लिए डेटा वैलिडेशन और सेटिंग्स प्रबंधन की लाइब्रेरी है, जो आपको Python टाइप एनोटेशन्स का उपयोग करके डेटा मॉडल्स परिभाषित करने देती है। इन मॉडल्स का उपयोग OpenAI के मॉडलों द्वारा उत्पन्न आउटपुट की संरचना लागू कराने के लिए किया जा सकता है।

यहाँ हमारे रिव्यू सेंटिमेंट क्लासिफ़ायर के फ़ॉर्मेट को निर्दिष्ट करने के लिए एक Pydantic मॉडल का उदाहरण है:

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

इस उदाहरण में:

• SentimentResponse एक Pydantic मॉडल है जो आउटपुट की अपेक्षित संरचना को परिभाषित करता है।
• मॉडल में एकल फ़ील्ड sentiment है, जो केवल तीन लिटरल मानों में से एक ले सकता है: "positive", "negative", या "neutral"।

जब हम इस मॉडल को अपने OpenAI API अनुरोधों के हिस्से के रूप में पास करते हैं, तो आउटपुट केवल हमारे द्वारा दिए गए शब्दों में से एक होगा।

आइए देखें कैसे।

parse हेल्पर का उपयोग करना

OpenAI अनुरोधों में हमारे Pydantic स्कीमा को लागू कराने के लिए, हमें बस इसे चैट कंप्लीशन्स API के response_format पैरामीटर में पास करना है। मोटे तौर पर, यह इस तरह दिखता है:

response = client.beta.chat.completions.parse(
   model=MODEL,
   messages=[...],
   response_format=SentimentResponse
)

ध्यान दें, client.chat.completions.create का उपयोग करने के बजाय, हम client.beta.chat.completions.parse मेथड का उपयोग कर रहे हैं। .parse() चैट कंप्लीशन्स API में Structured Outputs के लिए विशेष रूप से लिखा गया नया मेथड है।

अब, आवश्यक इम्पोर्ट्स करके, Pydantic मॉडल, सिस्टम प्रॉम्प्ट और एक प्रॉम्प्ट टेम्पलेट परिभाषित करके, रिव्यूज़ सेंटिमेंट क्लासिफ़ायर को Structured Outputs के साथ फिर से लिखकर सब कुछ एक साथ रखते हैं:

from openai import OpenAI
from pydantic import BaseModel
from typing import Literal
class SentimentResponse(BaseModel):
   sentiment: Literal["positive", "negative", "neutral"]
client = OpenAI()
MODEL = "gpt-4o-mini"
SYSTEM_PROMPT = "You are a sentiment classifier assistant."
PROMPT_TEMPLATE = """
   Classify the sentiment of the following hotel review as positive, negative, or neutral:\n\n{review}
"""

इसके बाद, हम एक नया फ़ंक्शन लिखते हैं जो .parse() हेल्पर मेथड का उपयोग करता है:

# Function to classify sentiment using OpenAI's chat completions API with structured outputs
def classify_sentiment_with_structured_outputs(review):
   response = client.beta.chat.completions.parse(
       model=MODEL,
       messages=[
           {"role": "system", "content": SYSTEM_PROMPT},
           {"role": "user", "content": PROMPT_TEMPLATE.format(review=review)},
       ],
       response_format=SentimentResponse
   )
   return response.choices[0].message

फ़ंक्शन की महत्वपूर्ण पंक्ति है response_format=SentimentResponse, जो वास्तव में Structured Outputs को सक्षम करती है।

इसे एक रिव्यू पर टेस्ट करें:

# 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.",
]
result = classify_sentiment_with_structured_outputs(reviews[0])
>>> print(result.content)
{"sentiment":"positive"}

यहाँ result एक मैसेज ऑब्जेक्ट है:

>>> type(result)
openai.types.chat.parsed_chat_completion.ParsedChatCompletionMessage[SentimentResponse]

इसके .content एट्रिब्यूट के अलावा, जो प्रतिक्रिया प्राप्त करता है, इसमें एक .parsed एट्रिब्यूट भी है जो पार्स की गई जानकारी को एक क्लास के रूप में लौटाता है:

>>> result.parsed
SentimentResponse(sentiment='positive')

जैसा कि आप देख सकते हैं, हमें SentimentResponse क्लास का एक इंस्टेंस मिला है। इसका मतलब है कि हम .sentiment एट्रिब्यूट का उपयोग करके डिक्शनरी के बजाय एक स्ट्रिंग के रूप में सेंटिमेंट तक पहुँच सकते हैं:

>>> result.parsed.sentiment
'positive'

जटिल स्कीमा परिभाषित करने के लिए Pydantic मॉडल्स का नेस्टिंग

कुछ मामलों में, आपको अधिक जटिल आउटपुट संरचनाएँ परिभाषित करने की आवश्यकता हो सकती है जिनमें नेस्टेड डेटा शामिल होता है। Pydantic आपको मॉडलों को एक-दूसरे के भीतर नेस्ट करने की अनुमति देता है, जिससे आप ऐसे जटिल स्कीमा बना सकते हैं जो विभिन्न उपयोग मामलों को संभाल सकें। यह विशेष रूप से तब उपयोगी होता है जब आप पदानुक्रमित डेटा से निपट रहे हों या जटिल आउटपुट के लिए किसी विशिष्ट संरचना को लागू कराना चाहते हों।

मान लें कि हमें किसी उपयोगकर्ता की विस्तृत जानकारी निकालनी है, जिसमें उनका नाम, संपर्क विवरण, और पतों की सूची शामिल है। प्रत्येक पते में सड़क, शहर, राज्य और ज़िप कोड के फ़ील्ड होने चाहिए। इसके लिए सही स्कीमा बनाने हेतु एक से अधिक Pydantic मॉडल्स की आवश्यकता होगी।

चरण 1: Pydantic मॉडल्स परिभाषित करें

पहले, हम पते और उपयोगकर्ता जानकारी के लिए Pydantic मॉडल्स परिभाषित करते हैं:

from pydantic import BaseModel
from typing import List
# Define the Pydantic model for an address
class Address(BaseModel):
   street: str
   city: str
   state: str
   zip_code: str
# Define the Pydantic model for user information
class UserInfo(BaseModel):
   name: str
   email: str
   phone: str
   addresses: List[Address]

इस उदाहरण में:

• Address एक Pydantic मॉडल है जो पते की संरचना परिभाषित करता है।
• UserInfo एक Pydantic मॉडल है जिसमें उपयोगकर्ता के नाम, ईमेल और फ़ोन नंबर के फ़ील्ड के साथ Address ऑब्जेक्ट्स की सूची शामिल है।

चरण 2: API कॉल्स में नेस्टेड Pydantic मॉडल्स का उपयोग करें

अगला, हम OpenAI API कॉल में इन नेस्टेड Pydantic मॉडल्स का उपयोग आउटपुट संरचना लागू कराने के लिए करते हैं:

SYSTEM_PROMPT = "You are a user information extraction assistant."
PROMPT_TEMPLATE = """ Extract the user information from the following text:\n\n{text}"""
# Function to extract user information using OpenAI's chat completions API with structured outputs
def extract_user_info(text):
   response = client.beta.chat.completions.parse(
       model=MODEL,
       messages=[
           {"role": "system", "content": SYSTEM_PROMPT},
           {"role": "user", "content": PROMPT_TEMPLATE.format(text=text)},
       ],
       response_format=UserInfo
   )
   return response.choices[0].message
# Example text containing user information
text = """John DoeEmail: john.doe@example.comPhone: 123-456-7890Addresses:- 123 Main St, Springfield, IL, 62701- 456 Elm St, Shelbyville, IL, 62702"""
# Extract user information and print the results
user_info = extract_user_info(text)

नमूना टेक्स्ट बिल्कुल अपठनीय है और मुख्य सूचनाओं के बीच स्पेस की कमी है। देखें कि मॉडल सफल होता है या नहीं। हम प्रतिक्रिया को सुंदर दिखाने के लिए json लाइब्रेरी का उपयोग करेंगे:

import json
data = json.loads(user_info.content)
pretty_response = json.dumps(data, indent=2)
print(pretty_response)
{
 "name": "John Doe",
 "email": "john.doe@example.com",
 "phone": "123-456-7890",
 "addresses": [
   {
     "street": "123 Main St",
     "city": "Springfield",
     "state": "IL",
     "zip_code": "62701"
   },
   {
     "street": "456 Elm St",
     "city": "Shelbyville",
     "state": "IL",
     "zip_code": "62702"
   }
 ]
}

जैसा कि आप देख सकते हैं, मॉडल ने हमारे दिए गए स्कीमा के आधार पर एक उपयोगकर्ता की जानकारी और उसके दो अलग-अलग पते सही से कैप्चर किए हैं।

संक्षेप में, Pydantic मॉडल्स को नेस्ट करके, आप जटिल स्कीमा परिभाषित कर सकते हैं जो पदानुक्रमित डेटा को संभालते हैं और जटिल आउटपुट के लिए विशिष्ट संरचनाएँ लागू कराते हैं।

Structured Outputs के साथ फ़ंक्शन कॉलिंग

नए भाषा मॉडलों की व्यापक विशेषताओं में से एक है फ़ंक्शन कॉलिंग (जिसे टूल कॉलिंग भी कहा जाता है)। यह क्षमता आपको भाषा मॉडलों को उपयोगकर्ता-परिभाषित फ़ंक्शन्स से कनेक्ट करने देती है, जिससे मॉडलों को बाहरी दुनिया तक पहुँच मिलती है।

कुछ सामान्य उदाहरण:

• रियल-टाइम डेटा प्राप्त करना (जैसे मौसम, स्टॉक मूल्य, खेल स्कोर)
• गणनाएँ या डेटा विश्लेषण करना
• डेटाबेस या APIs से क्वेरी करना
• छवियाँ या अन्य मीडिया जनरेट करना
• भाषाओं के बीच टेक्स्ट का अनुवाद करना
• स्मार्ट होम डिवाइस या IoT सिस्टम को नियंत्रित करना
• कस्टम बिज़नेस लॉजिक या वर्कफ़्लो निष्पादित करना

हम यहाँ फ़ंक्शन कॉलिंग कैसे काम करती है, इसके विवरण में नहीं जाएँगे, लेकिन आप हमारा OpenAI Function Calling ट्यूटोरियल पढ़ सकते हैं।

महत्वपूर्ण बात यह जानना है कि Structured Outputs के साथ, OpenAI मॉडलों में फ़ंक्शन कॉलिंग का उपयोग करना काफी आसान हो जाता है। पहले, जिन फ़ंक्शन्स को आप OpenAI मॉडलों को पास करते थे, उनके लिए जटिल JSON स्कीमा लिखने पड़ते थे, जिनमें हर फ़ंक्शन पैरामीटर को टाइप हिंट्स के साथ परिभाषित करना होता था। यहाँ एक उदाहरण है:

{
   "type": "function",
   "function": {
       "name": "get_current_weather",
       "description": "Get the current weather",
       "parameters": {
           "type": "object",
           "properties": {
               "location": {
                   "type": "string",
                   "description": "The city and state, e.g. San Francisco, CA",
               },
               "format": {
                   "type": "string",
                   "enum": ["celsius", "fahrenheit"],
                   "description": "The temperature unit to use. Infer this from the users location.",
               },
           },
           "required": ["location", "format"],
       },
   }
}

भले ही get_current_weather फ़ंक्शन के दो पैरामीटर हैं, उसका JSON स्कीमा बहुत बड़ा हो जाता है और हाथ से लिखते समय त्रुटि-प्रवण होता है।

Structured Outputs में इसे फिर से Pydantic मॉडल्स का उपयोग करके हल किया गया है:

from pydantic import BaseModel
from typing import Literal
def get_weather(location: str, unit: str, condition: str):
   # Implementation details...
   pass
class WeatherData(BaseModel):
   location: str
   unit: Literal["celsius", "fahrenheit"]
   condition: Literal["sunny", "cloudy", "rainy", "snowy"]

पहले आप फ़ंक्शन और उसकी लॉजिक लिखते हैं। फिर, अपेक्षित इनपुट पैरामीटर्स निर्दिष्ट करते हुए उसे Pydantic मॉडल से दोबारा परिभाषित करते हैं।

इसके बाद, Pydantic मॉडल को अनुकूल JSON स्कीमा में बदलने के लिए आप pydantic_function_tool कॉल करते हैं:

>>> import openai
>>> openai.pydantic_function_tool(WeatherData)
{'type': 'function',
'function': {'name': 'WeatherData',
 'strict': True,
 'parameters': {'properties': {'location': {'title': 'Location',
    'type': 'string'},
   'unit': {'enum': ['celsius', 'fahrenheit'],
    'title': 'Unit',
    'type': 'string'},
   'condition': {'enum': ['sunny', 'cloudy', 'rainy', 'snowy'],
    'title': 'Condition',
    'type': 'string'}},
  'required': ['location', 'unit', 'condition'],
  'title': 'WeatherData',
  'type': 'object',
  'additionalProperties': False}}}

अनुरोध के हिस्से के रूप में इस टूल का उपयोग इस प्रकार करें:

import openai
client = OpenAI()
tools = [openai.pydantic_function_tool(WeatherData)]
messages = [
   {
       "role": "system",
       "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user.",
   },
   {
       "role": "user",
       "content": "What is the weather in Tokyo?",
   }
]
response = client.chat.completions.create(
   model=MODEL, messages=messages, tools=tools
)
tool_call = response.choices[0].message.tool_calls[0]
>>> tool_call
ChatCompletionMessageToolCall(id='call_QnZZ0DmNN2cxw3bN433JQNIC', function=Function(arguments='{"location":"Tokyo","unit":"celsius","condition":"sunny"}', name='WeatherData'), type='function')

हम Pydantic मॉडल को अनुकूल JSON फ़ॉर्मेट में चैट कंप्लीशन्स API के tools पैरामीटर में पास करते हैं। फिर, हमारी क्वेरी के आधार पर, मॉडल तय करता है कि टूल कॉल करना है या नहीं।

क्योंकि हमारे उदाहरण में क्वेरी “What is the weather in Tokyo?” है, हमें लौटाए गए मैसेज ऑब्जेक्ट के tool_calls में एक कॉल दिखाई देता है।

ध्यान रखें, मॉडल get_weather फ़ंक्शन को कॉल नहीं करता, बल्कि हमारे द्वारा दिए गए Pydantic स्कीमा के आधार पर उसके लिए आर्गुमेंट्स जनरेट करता है:

arguments = json.loads(tool_call.function.arguments)
>>> arguments
{'location': 'Tokyo', 'unit': 'celsius', 'condition': 'sunny'}

फ़ंक्शन को दिए गए आर्गुमेंट्स के साथ कॉल करना हमारे ऊपर है:

some_result = get_weather(**arguments)

यदि आप चाहते हैं कि मॉडल फ़ंक्शन के लिए आर्गुमेंट्स जनरेट करे और साथ ही उसे कॉल भी करे, तो आप AI एजेंट की तलाश कर रहे हैं. 

यदि आप इच्छुक हैं तो हमारे पास अलग से LangChain Agents ट्यूटोरियल है।

OpenAI Structured Outputs का उपयोग करते समय सर्वोत्तम प्रथाएँ

Structured Outputs का उपयोग करते समय ध्यान में रखने योग्य कई सर्वोत्तम प्रथाएँ और सिफ़ारिशें हैं। इस अनुभाग में, हम उनमें से कुछ का विवरण देंगे।

1. आउटपुट स्कीमा परिभाषित करने के लिए Pydantic मॉडल्स का उपयोग करें, क्योंकि वे अपेक्षित आउटपुट संरचनाएँ परिभाषित करने का साफ़ और टाइप-सुरक्षित तरीका प्रदान करते हैं।
2. सबसे सटीक परिणाम पाने के लिए स्कीमा को सरल और विशिष्ट रखें।
3. उचित डेटा टाइप्स (str, int, float, bool, List, Dict) का उपयोग अपने डेटा का सही प्रतिनिधित्व करने के लिए करें।
4. एनम्स के लिए Literal टाइप्स का उपयोग करें ताकि फ़ील्ड्स के लिए विशिष्ट अनुमत मान परिभाषित हों।
5. मॉडल के इंकार (refusal) को संभालें। नए .parse() मेथड का उपयोग करते समय, मैसेज ऑब्जेक्ट्स में .refusal नामक नया एट्रिब्यूट होता है जो इंकार को दर्शाता है:

text = """John DoeEmail: john.doe@example.comPhone: 123-456-7890Addresses:- 123 Main St, Springfield, IL, 62701- 456 Elm St, Shelbyville, IL, 62702"""
user_info = extract_user_info(text)
if user_info.refusal:
   print(user_info.refusal)
else:
   print(user_info.content)

आउटपुट:

{"name":"John Doe","email":"john.doe@example.com","phone":"123-456-7890","addresses":[{"street":"123 Main St","city":"Springfield","state":"IL","zip_code":"62701"},{"street":"456 Elm St","city":"Shelbyville","state":"IL","zip_code":"62702"}]}

6. अपने Pydantic मॉडल्स में हर फ़ील्ड के लिए स्पष्ट और संक्षिप्त विवरण दें ताकि मॉडल आउटपुट की सटीकता बेहतर हो:

from pydantic import BaseModel, Field
class Person(BaseModel):
   name: str = Field(..., description="The person's full name")
   age: int = Field(..., description="The person's age in years")
   occupation: str = Field(..., description="The person's current job or profession")

ये प्रथाएँ आपके एप्लिकेशंस में Structured Outputs का सबसे प्रभावी उपयोग करने में बहुत सहायक होंगी।

निष्कर्ष

इस ट्यूटोरियल में, हमने OpenAI API की नई सुविधा Structured Outputs के साथ शुरुआत करना सीखा। हमने देखा कि यह सुविधा भाषा मॉडलों को हमारे द्वारा निर्दिष्ट फ़ॉर्मेट में आउटपुट देने के लिए बाध्य करती है। हमने इसे फ़ंक्शन कॉलिंग के साथ उपयोग करना सीखा और इस सुविधा का अधिकतम लाभ उठाने के लिए कुछ सर्वोत्तम प्रथाओं का भी अन्वेषण किया।

यहाँ आपकी समझ बढ़ाने के लिए कुछ संबंधित स्रोत दिए गए हैं:

• Working with the OpenAI API कोर्स
• OpenAI Fundamentals ट्रैक
• Developing LLM Applications with LangChain कोर्स
• LangChain बनाम LlamaIndex: विस्तृत तुलना