OpenAI O1 API ट्यूटोरियल: OpenAI के API से कनेक्ट कैसे करें

OpenAI ने हाल ही में अपना लंबे समय से प्रतीक्षित मॉडल जारी किया है जो “PhD स्तर की तर्क क्षमता” में सक्षम है—और यह वह नहीं है जिसकी हममें से कई लोगों ने कल्पना की थी यानी GPT-5—यह है OpenAI o1 मॉडल।

OpenAI o1 जिस तरह से काम करता है, वह संगणन संसाधन आवंटन में एक महत्वपूर्ण पैराबदल का संकेत देता है—ट्रेनिंग और इन्फरेंस दोनों चरणों पर अधिक जोर के साथ। यह तरीका इसे जटिल तार्किक कार्यों में असाधारण रूप से सक्षम बनाता है, लेकिन इसकी गति इसके समकक्षों GPT-4o और GPT-4o mini की तुलना में काफी धीमी है।

इसके बावजूद, GPT-4o और GPT-4o mini अब भी उन अनुप्रयोगों के लिए पसंदीदा विकल्प हैं जिन्हें त्वरित उत्तर, इमेज हैंडलिंग या फ़ंक्शन कॉलिंग चाहिए। हालांकि, यदि आपके प्रोजेक्ट को उन्नत तर्क क्षमता चाहिए और वह थोड़े लंबे प्रतिक्रिया समय को सह सकता है, तो o1 मॉडल बेहतर विकल्प है।

मुझे OpenAI के API के माध्यम से o1 का पता लगाने का मौका मिला, और इस ब्लॉग में, मैं चरण-दर-चरण मार्गदर्शन दूंगा कि आप यह कैसे कर सकते हैं। मैं आपको दिखाऊंगा कि API से कैसे कनेक्ट करें, लागत कैसे प्रबंधित करें, और अंत में, कुछ प्रॉम्प्टिंग टिप्स साझा करूंगा जो खर्च कम करने और बेहतर उत्तर पाने में मदद करेंगे।

यदि आप एक अधिक शुरुआती-स्तर का लेख ढूंढ रहे हैं, तो यह देखें: OpenAI o1 गाइड.

ध्यान दें: इस ट्यूटोरियल के लिखे जाने के समय, o1 मॉडल अब भी बीटा में हैं। हालांकि, API से कनेक्ट होने की प्रक्रिया वही रहती है।

OpenAI O1 API आवश्यकताएँ और रेट लिमिट्स

सबसे पहली बात जो आपको जाननी चाहिए, वह यह है कि फिलहाल API के माध्यम से o1 मॉडल तक पहुंचने के लिए Tier 5 उपयोग स्तर आवश्यक है।

अपना उपयोग स्तर जाँचने के लिए अपने खाते के पेज पर जाएँ OpenAI डेवलपर प्लेटफ़ॉर्म पर और Organization के अंतर्गत Limits अनुभाग देखें।

प्रत्येक उपयोग स्तर के साथ विशिष्ट रेट लिमिट्स आती हैं। इस लेख के लिखे जाने के समय, Tier 5 के लिए रेट लिमिट्स ये हैं:

O1 मॉडल इन्फरेंस चरण के दौरान संसाधित करने में काफी समय लेते हैं, यही कारण है कि GPT-4o मॉडलों की तुलना में उनकी RPM सीमा कम है। ध्यान दें कि o1 मॉडलों के लिए फिलहाल बैचिंग समर्थित नहीं है, यानी आप एक ही समय में कई अनुरोधों को समूहबद्ध (बैच) नहीं कर सकते।

O1 मॉडल अभी नए हैं, इसलिए आने वाले हफ्तों में ये आवश्यकताएँ और रेट लिमिट्स बदल सकती हैं। उदाहरण के लिए, OpenAI ने शुरू में यह घोषणा की थी कि साप्ताहिक रेट लिमिट्स o1-preview के लिए 30 संदेश और o1-mini के लिए 50 होंगे। हालांकि, कुछ ही दिनों बाद, उन्होंने इन्हें अपडेट कर o1-preview के लिए प्रति सप्ताह 50 क्वेरी और o1-mini के लिए प्रति दिन 50 क्वेरी कर दिया।

OpenAI O1 रीज़निंग टोकन

हम थोड़ी देर में व्यवहारिक हिस्से पर आएँगे, लेकिन उससे पहले API के माध्यम से o1 का उपयोग करने के लिए एक नए बुनियादी कॉन्सेप्ट को स्पष्ट कर लें: reasoning tokens। इस कॉन्सेप्ट को समझना आपके मासिक OpenAI बिल को समझने के लिए आवश्यक है।

यदि आपने ChatGPT इंटरफ़ेस के माध्यम से o1-preview का उपयोग किया है, तो आपने देखा होगा कि उत्तर देने से पहले यह “सोचने की प्रक्रिया” दिखाता है।

जब हम API के माध्यम से o1 मॉडल का उपयोग करते हैं, तो यह वही सोचने की प्रक्रिया से गुजरता है। एकमात्र अंतर यह है कि, ChatGPT इंटरफ़ेस के विपरीत, यह तर्क दिखाई नहीं देता और हमें केवल अंतिम उत्तर दिखता है।

हालाँकि, यह तर्क अब भी टोकनाइज़ होता है (यही कारण है कि इसे “reasoning tokens” कहा जाता है), और जैसा कि आप अनुमान लगा सकते हैं, यह बिल योग्य होता है। रीज़निंग टोकन को आउटपुट टोकन के रूप में बिल किया जाता है, जो इनपुट टोकन से चार गुना महंगे होते हैं।

हम जल्द ही सीखेंगे कि टोकन की संख्या कैसे नियंत्रित करें और लागत कैसे प्रबंधित करें, लेकिन फिलहाल, o1 मॉडल का उपयोग करने के लिए OpenAI के API से कनेक्ट करने पर ध्यान दें।

OpenAI O1 API: OpenAI के API से कैसे कनेक्ट करें

इस खंड में, हम API के माध्यम से o1-preview मॉडल से कनेक्ट करने के लिए चरणों की रूपरेखा देंगे। आगे चलकर, हम o1-mini मॉडल से कनेक्ट करना भी कवर करेंगे।

चरण 1: API क्रेडेंशियल्स प्राप्त करें

यदि आपका खाता सक्रिय है, तो आप OpenAI के API key पेज से अपना सीक्रेट API key प्राप्त कर सकते हैं।

यदि आप किसी संगठन का हिस्सा हैं, तो आपको अपने संगठन का ID और एक प्रोजेक्ट ID भी चाहिए हो सकता है, जो आपकी टीम को लागत अधिक प्रभावी ढंग से प्रबंधित करने में मदद कर सकता है। इसके बारे में अपनी टीम से अवश्य जाँच करें।

चाहे आप API में नए हों या अनुभवी डेवलपर, API सेफ्टी के सर्वोत्तम तरीकों का पालन करना हमेशा अच्छा विचार है।

चरण 2: openai लाइब्रेरी इम्पोर्ट करें

OpenAI अपनी Python लाइब्रेरी openai के माध्यम से अपने API के साथ इंटरैक्ट करना आसान बनाता है। आप इसे निम्न कमांड से इंस्टॉल कर सकते हैं:

pip install openaiसंचालित द्वारा

इंस्टॉल हो जाने के बाद, हम openai लाइब्रेरी से OpenAI क्लास इम्पोर्ट करते हैं:

from openai import OpenAIसंचालित द्वारा

चरण 3: एक क्लाइंट ऑब्जेक्ट इनिशियलाइज़ करें

OpenAI के API के साथ इंटरैक्ट करने के लिए, हम अपने सीक्रेट API key का उपयोग कर एक क्लाइंट इनिशियलाइज़ करते हैं:

client = OpenAI(api_key=’your-api-key’)संचालित द्वारा

यदि आप किसी संगठन का हिस्सा हैं, तो आपको संगठन का ID और एक प्रोजेक्ट ID भी चाहिए हो सकती है—आपके लिए यह चरण इस तरह दिखेगा:

client = OpenAI(
    organization=’your-organization-id’,
    project=’your-project-id’,
    api_key=’your-api-key’
)संचालित द्वारा

चरण 4: एक API कॉल करें

इस लेख के लिखे जाने के समय उपलब्ध o1 मॉडल हैं o-1 preview और o1-mini। दोनों ही chat.completions एंडपॉइंट के जरिए उपलब्ध हैं। नीचे दिए कोड में ध्यान दें कि:

• हम एंडपॉइंट को client.chat.completions.create() के माध्यम से कॉल करते हैं।
• हम model पैरामीटर के लिए स्ट्रिंग ”o1-preview” निर्दिष्ट करते हैं।
• हम प्रॉम्प्ट को ”content” कुंजी के मान के रूप में पास करते हैं।
• हम अंतिम उत्तर को response.choices[0].message.content के माध्यम से एक्सेस करते हैं।

response = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ]
)
print(response.choices[0].message.content)संचालित द्वारा

```python
import ast

# Read the input string
s = input()

# Add outer brackets to make it a valid list representation
input_str = '[' + s + ']'

# Safely evaluate the string to a list of lists
matrix = ast.literal_eval(input_str)

# Transpose the matrix
transposed = list(map(list, zip(*matrix)))

# Convert the transposed matrix back to the required string format
transposed_str = ','.join('[' + ','.join(map(str, row)) + ']' for row in transposed)

# Print the result
print(transposed_str)
```संचालित द्वारा

Reasoning Tokens की संख्या कैसे पता करें

जैसा कि पहले बताया गया, भीतर चल रही तर्क प्रक्रिया अब भी बिल योग्य टोकन के रूप में गिनी जाती है। ऊपर चलाए गए कोड के लिए, उपयोग किए गए सभी टोकन का विवरण इस प्रकार है:

print(response.usage)संचालित द्वारा

CompletionUsage(completion_tokens=1279, prompt_tokens=43, total_tokens=1322, completion_tokens_details={'reasoning_tokens': 1024})संचालित द्वारा

आउटपुट की जाँच करने पर, हम देखते हैं कि रीज़निंग टोकन की संख्या 1024 है: completion_tokens_details={'reasoning_tokens': 1024}।

मॉडल ने 1279 टोकन का उपयोग करके एक कंप्लीशन जेनरेट किया (completion_tokens=1279), जिनमें से 1024 अदृश्य रीज़निंग टोकन थे—यानी लगभग 80%!

नए o1 मॉडलों के साथ लागत प्रबंधन थोड़ा अधिक जटिल हो जाता है, तो आइए इसे विस्तार से समझें।

OpenAI O1 मॉडलों के साथ लागत कैसे नियंत्रित करें

पिछले मॉडलों के साथ, हम कंप्लीशन टोकन की संख्या नियंत्रित करने के लिए max_tokens पैरामीटर का उपयोग करते थे। चीजें काफ़ी सीधी थीं: उत्पन्न टोकन की संख्या और दृश्य टोकन की संख्या हमेशा समान होती थी।

लेकिन o1 मॉडलों के साथ, हमें एक ऐसे पैरामीटर की ज़रूरत है जो सभी कंप्लीशन टोकनों—दृश्य आउटपुट टोकन और अदृश्य रीज़निंग टोकन—पर ऊपरी सीमा तय करे। इसी कारण OpenAI ने max_completion_tokens पैरामीटर जोड़ा, जबकि max_tokens को अप्रचलित कर दिया और इसे o1 मॉडलों के साथ असंगत बना दिया।

आइए अपने पिछले उदाहरण के साथ max_completion_tokens आज़माते हैं। हम इसे 300 पर सेट करेंगे और देखेंगे क्या मिलता है। इस नए पैरामीटर का उपयोग करने के लिए, ध्यान रखें कि यदि आप पुरानी वर्ज़न पर चल रहे हैं तो आपको openai लाइब्रेरी को अपडेट करना पड़ सकता है।

response_with_limit = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ],
    max_completion_tokens=300
)
print(response_with_limit.choices[0].message.content)संचालित द्वारा

‎ ‎ ‎ ‎ संचालित द्वारा

ध्यान दें कि हमें कोई आउटपुट नहीं मिला। लेकिन क्या हम फिर भी भुगतान कर रहे हैं? जवाब है हाँ।

print(response_with_limit.usage)संचालित द्वारा

CompletionUsage(completion_tokens=300, prompt_tokens=43, total_tokens=343, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=300))संचालित द्वारा

यदि o1 मॉडल अंतिम उत्तर तक पहुँचने से पहले टोकन लिमिट पर पहुँच जाता है, तो यह अपनी तर्क प्रक्रिया रोक देता है और कोई आउटपुट नहीं लौटाता। इसलिए, max_completion_tokens को ऐसी वैल्यू पर सेट करना महत्वपूर्ण है जो आउटपुट की गारंटी दे—अन्यथा हम बिना कुछ हासिल किए रीज़निंग टोकन और इनपुट टोकन दोनों के लिए बिल किए जाएँगे।

आपको अपने विशेष उपयोग-केस के आधार पर max_completion_tokens की सटीक वैल्यू के साथ प्रयोग करना होगा, लेकिन OpenAI कम से कम 25,000 टोकन कंप्लीशन टोकन की कुल संख्या के लिए सुरक्षित रखने की सलाह देता है। 

कटा हुआ आउटपुट (या बिल्कुल भी आउटपुट न मिलना) टालने के लिए, यदि आपके उपयोग-केस में बड़ी संख्या में टोकन शामिल हैं, तो आपको कॉन्टेक्स्ट विंडो का भी ध्यान रखना होगा। o1-preview और o-1 mini मॉडलों की कॉन्टेक्स्ट विंडो 128,000 टोकन की है। ध्यान दें कि आउटपुट टोकन (दृश्य और अदृश्य) o1-preview के लिए 32,768 टोकन और o1-mini के लिए 65,536 टोकन पर कैप्ड हैं।

स्रोत: OpenAI

OpenAI O1-Mini API: OpenAI के API से कैसे कनेक्ट करें

बड़ा o1 मॉडल उन्नत तर्क में शक्तिशाली है, लेकिन यह बहुत धीमा भी है। यदि आपको अपने अनुप्रयोगों के लिए तेज़ प्रतिक्रिया समय चाहिए और आप तर्क प्रदर्शन में थोड़ा समझौता कर सकते हैं, तो o1-mini मॉडल बेहतर विकल्प हो सकता है।

API के माध्यम से o1-mini मॉडल से कनेक्ट करने के लिए, o1-preview मॉडल के लिए कवर किए गए सभी चरणों का पालन करें—सिवाय model पैरामीटर के, जहाँ आपको स्ट्रिंग ”o1-mini” का उपयोग करना होगा।

हम पिछले उदाहरण जैसा ही प्रॉम्प्ट उपयोग करेंगे, ताकि हम टोकन उपयोग की तुलना कर सकें:

response_mini = client.chat.completions.create(
    model="o1-mini",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ]
)
print(response_mini.choices[0].message.content)संचालित द्वारा

Certainly! Below is a Python script that takes a matrix represented as a string in the format `'[1,2],[3,4],[5,6]'`, computes its transpose, and prints the transposed matrix in the same string format.

```python
def parse_matrix(matrix_str):
    """
    Parses a matrix string like '[1,2],[3,4],[5,6]' into a list of lists.
    """
    # Split the string by '],[' to separate the rows
    rows = matrix_str.strip().split('],[')
    
    # Clean the first and last elements by removing any leading '[' or trailing ']'
    rows[0] = rows[0].lstrip('[')
    rows[-1] = rows[-1].rstrip(']')
    
    # Convert each row into a list of integers
    matrix = []
    for row in rows:
        # Split each row by ',' and convert each element to integer
        matrix.append([int(num) for num in row.split(',')])
    
    return matrix

def transpose_matrix(matrix):
    """
    Transposes a given matrix (list of lists).
    """
    # Use zip with unpacking to transpose the matrix
    transposed = list(zip(*matrix))
    # Convert each tuple in the transposed matrix back to a list
    transposed = [list(row) for row in transposed]
    return transposed

def matrix_to_string(matrix):
    """
    Converts a list of lists into a string format like '[1,3,5],[2,4,6]'.
    """
    # Convert each row to a string
    row_strings = []
    for row in matrix:
        # Convert each number to string and join with commas
        row_str = ','.join(str(num) for num in row)
        # Enclose the row in brackets
        row_strings.append(f'[{row_str}]')
    
    # Join all rows with commas
    return ','.join(row_strings)

def main():
    # Example input
    input_str = '[1,2],[3,4],[5,6]'
    
    # Parse the input string into a matrix
    matrix = parse_matrix(input_str)
    
    # Compute the transpose of the matrix
    transposed = transpose_matrix(matrix)
    
    # Convert the transposed matrix back to string format
    output_str = matrix_to_string(transposed)
    
    # Print the result
    print(output_str)

if __name__ == "__main__":
    main()
```

### How It Works:

1. **Parsing the Input String:**
    - The `parse_matrix` function takes the input string and splits it into individual rows by looking for the pattern `"],["`.
    - It cleans the first and last rows by removing any leading `[` or trailing `]`.
    - Each row string is then split by `,` to extract individual numbers, which are converted to integers and stored in a nested list.

2. **Transposing the Matrix:**
    - The `transpose_matrix` function uses the `zip` function along with unpacking (`*`) to transpose the matrix. This effectively switches rows with columns.
    - Since `zip` returns tuples, each transposed row is converted back into a list.

3. **Converting Back to String:**
    - The `matrix_to_string` function takes the transposed matrix and converts each row back into a string in the desired format.
    - It joins the elements of each row with commas and encloses them in brackets.
    - Finally, all row strings are joined together with commas to form the final output string.

4. **Main Execution:**
    - The `main` function demonstrates the usage with an example input. You can modify `input_str` to test with different matrices.
    - It prints the transposed matrix in the specified string format.

### Example:

Given the input string:
```
'[1,2],[3,4],[5,6]'
```
The script will output:
```
[1,3,5],[2,4,6]
```

### Handling User Input:

If you'd like the script to accept user input instead of having a hardcoded string, you can modify the `main` function as follows:

```python
def main():
    # Take user input
    input_str = input("Enter the matrix string (e.g., '[1,2],[3,4],[5,6]'): ").strip()
    
    # Parse the input string into a matrix
    matrix = parse_matrix(input_str)
    
    # Compute the transpose of the matrix
    transposed = transpose_matrix(matrix)
    
    # Convert the transposed matrix back to string format
    output_str = matrix_to_string(transposed)
    
    # Print the result
    print(output_str)
```

With this modification, when you run the script, it will prompt you to enter the matrix string:

```
Enter the matrix string (e.g., '[1,2],[3,4],[5,6]'): [1,2],[3,4],[5,6]
[1,3,5],[2,4,6]
```

### Notes:

- **Error Handling:** The current script assumes that the input string is well-formatted. For production code, you might want to add error handling to manage malformed inputs.
- **Non-integer Elements:** If your matrix contains non-integer elements (e.g., floats or strings), you'll need to adjust the parsing logic accordingly.

### Running the Script:

1. **Save the Script:** Save the above code to a file, say `transpose_matrix.py`.
2. **Run the Script:** Open a terminal or command prompt, navigate to the directory containing the script, and execute:

   ```bash
   python transpose_matrix.py
   ```

3. **Provide Input:** If you've modified it to accept user input, enter the matrix string when prompted.

This script provides a straightforward way to transpose a matrix represented as a string and can be easily adapted or extended based on specific requirements.संचालित द्वारा

दृश्य आउटपुट o1-preview के आउटपुट की तुलना में कहीं अधिक विस्तृत है—आइए उपयोग की तुलना करें:

print(response_mini.usage) # o1-mini
print(response.usage) # o1-previewसंचालित द्वारा

CompletionUsage(completion_tokens=1511, prompt_tokens=43, total_tokens=1554, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=256))
CompletionUsage(completion_tokens=1279, prompt_tokens=43, total_tokens=1322, completion_tokens_details={'reasoning_tokens': 1024})संचालित द्वारा

o1-mini मॉडल, o1 मॉडल की तुलना में चार गुना कम तर्क करता है (256 बनाम 1024 रीज़निंग टोकन)। हालांकि, उसके विस्तृत उत्तर के कारण, कंप्लीशन टोकन की कुल संख्या वास्तव में अधिक है। भले ही o1-mini, o1-preview की तुलना में काफी सस्ता है, फिर भी यह आदर्श नहीं है।

इसे कम करने का एक तरीका है प्रॉम्प्ट इंजीनियरिंग—हम मॉडल को निर्देश देंगे कि व्याख्याएँ और प्रस्तावनाएँ न दे और आउटपुट को केवल उत्तर तक सीमित रखे।

response_mini_2 = client.chat.completions.create(
    model="o1-mini",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format. Limit yourself to the answer and don't add explanations or introductions."
        }
    ]
)
print(response_mini_2.choices[0].message.content)संचालित द्वारा

```python
import ast

def parse_matrix(matrix_str):
    rows = matrix_str.split('],[‘)
    rows[0] = rows[0].lstrip('[')
    rows[-1] = rows[-1].rstrip(']')
    matrix = [ast.literal_eval(f'[{row}]') for row in rows]
    return matrix

def transpose(matrix):
    return list(zip(*matrix))

def format_matrix(transposed):
    return ','.join([f'[{",".join(map(str, row))}]' for row in transposed])

input_str = '[1,2],[3,4],[5,6]'
matrix = parse_matrix(input_str)
transposed = transpose(matrix)
output_str = format_matrix(transposed)
print(output_str)
```संचालित द्वारा

काफी बेहतर! कम्प्लीशन टोकन की कुल संख्या लगभग तीन गुना कम है:

print(response_mini_2.usage)संचालित द्वारा

CompletionUsage(completion_tokens=487, prompt_tokens=55, total_tokens=542, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=320))संचालित द्वारा

API बीटा की सीमाएँ

जब यह ट्यूटोरियल लिखा जा रहा है, o1 मॉडल अभी भी बीटा में हैं। जबकि OpenAI ने आने वाले हफ्तों में अतिरिक्त फीचर्स और अधिक अनुकूल रेट लिमिट्स की योजना की घोषणा की है, बीटा o1 मॉडल का उपयोग करते समय आपको ये सीमाएँ मिलेंगी:

• मोडैलिटीज़: केवल टेक्स्ट समर्थित है; इमेज प्रोसेस नहीं की जा सकतीं।
• मैसेज प्रकार: केवल यूजर और असिस्टेंट मैसेज की अनुमति है; सिस्टम मैसेज स्वीकार्य नहीं हैं।
• स्ट्रीमिंग: यह फीचर उपलब्ध नहीं है।
• टूल्स: फंक्शन कॉलिंग, टूल्स, और रिस्पॉन्स फॉर्मेट पैरामीटर्स शामिल नहीं हैं।
• Logprobs: यह पैरामीटर समर्थित नहीं है।
• अन्य सेटिंग्स: temperature, top_p, और n 1 पर फिक्स्ड हैं, जबकि presence_penalty और frequency_penalty दोनों 0 हैं।
• असिस्टेंट्स और बैच: इन मॉडलों को Assistants API या Batch API के साथ उपयोग नहीं किया जा सकता।

OpenAI O1 API: मूल्य निर्धारण

फिलहाल, उन्नत तर्क क्षमता के क्षेत्र में OpenAI को अधिक प्रतिस्पर्धा नहीं दिखती। इसलिए, कीमतें शायद कुछ अधिक हैं, और जैसा कि आप देख सकते हैं, वे GPT-4o मॉडलों की तुलना में काफी ऊँची हैं:

O1 मॉडलों के साथ सर्वोत्तम प्रॉम्प्टिंग प्रथाएँ

o1 मॉडल, GPT-4o या Claude 3.5 Sonnet जैसे जिन मॉडलों के हम अभ्यस्त हैं, उनसे काफी अलग हैं। चूँकि o1 मॉडल पहले से ही चेन-ऑफ-थॉट रीज़निंग करते हैं, ये सीधे-सादे प्रॉम्प्ट्स के साथ सबसे अच्छा काम करते हैं। फ्यू-शॉट प्रॉम्प्टिंग का उपयोग करना या मॉडल से “कदम-दर-कदम सोचें” कहना वास्तव में उनके प्रदर्शन को घटा सकता है।

यहाँ OpenAI के डेवलपर्स द्वारा सुझाई गई कुछ सर्वोत्तम प्रॉम्प्टिंग प्रथाएँ हैं:

• प्रॉम्प्ट्स को संक्षिप्त और स्पष्ट रखें: मॉडल संक्षिप्त, सीधे निर्देशों पर बेहतर काम करते हैं; विस्तृत व्याख्याओं की आवश्यकता नहीं होती।
• चेन-ऑफ-थॉट प्रॉम्प्ट्स से बचें: ये मॉडल आंतरिक रूप से तर्क करते हैं, इसलिए उनसे “कदम-दर-कदम सोचें” या “अपना तर्क समझाएँ” कहने की ज़रूरत नहीं है।
• स्पष्टता के लिए डिलीमीटर का उपयोग करें: इनपुट के अलग-अलग हिस्सों को स्पष्ट रूप से परिभाषित करने के लिए ट्रिपल कोट्स, XML टैग्स, या सेक्शन हेडर जैसे डिलीमीटर शामिल करें।
• रीट्रीवल-ऑगमेंटेड जेनरेशन (RAG) में अतिरिक्त संदर्भ सीमित रखें: जब संदर्भ या दस्तावेज़ जोड़ें, तो केवल सबसे प्रासंगिक जानकारी शामिल करें ताकि मॉडल का उत्तर जटिल न हो।

निष्कर्ष

इस ब्लॉग में, मैंने OpenAI के API के माध्यम से o1 मॉडलों से कनेक्ट करने के लिए चरण-दर-चरण मार्गदर्शन साझा किया है।

यदि आपके प्रोजेक्ट को उन्नत तर्क क्षमताओं की आवश्यकता है और वह थोड़े लंबे प्रतिक्रिया समय को वहन कर सकता है, तो o1 मॉडल उत्कृष्ट विकल्प हैं।

तेज़ प्रतिक्रियाओं, इमेज प्रोसेसिंग, या फंक्शन कॉलिंग की ज़रूरत वाले अनुप्रयोगों के लिए, GPT-4o और GPT-4o mini अभी भी पसंदीदा विकल्प हैं।

आगे सीखने के लिए, मैं ये संसाधन सुझाता/सुझाती हूँ:

• Working with the OpenAI API
• OpenAI Fundamentals
• Developing AI Systems with the OpenAI API
• OpenAI o1 Guide: How It Works, Use Cases, API & More