OpenAI Decisions API

GPT-6 Luna Decisions से टेक्स्ट, इमेज या JSON के बारे में वर्गीकरण और स्कोरिंग के सवाल पूछें, और ऐसे टाइप किए हुए जवाब पाएँ जिन पर आपका कोड सीधे कार्रवाई कर सके: कोई बात कितनी संभावना से सही है, आपका कौन सा मान सही बैठता है, या वह आपके पैमाने पर कहाँ आती है, हर जवाब अपनी संभावनाओं के साथ। एक ही अनुरोध में कई सवाल, आमतौर पर एक सेकंड से कम में, OpenAI के अपने Decisions API और SDK के ज़रिए।

GPT-6 Luna Decisions OpenAI का डिसीज़न मॉडल है। यह आपका इनपुट पढ़ता है और उस पर आपके तय किए सवालों के जवाब देता है। यह कोई टेक्स्ट नहीं लिखता, इसलिए यह चैट मॉडल नहीं है: इसे /v1/decisions पर भेजें, /v1/chat/completions पर नहीं। इस एंडपॉइंट पर gpt-6-luna भी मॉडल ID के रूप में चलता है, जैसा OpenAI के अपने SDK डॉक्स में है, इसलिए OpenAI का सैंपल कोड बिना बदलाव के चलता है; जवाब के model में gpt-6-luna-decisions लिखा आता है। TypeSafe के डिसीज़न मॉडल Jev के लिए देखें निर्णय (Jev)।

सवाल पूछें

# pip install --upgrade openai
import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
decision = client.decisions.create(
    model="gpt-6-luna-decisions",
    input="My headphones stopped charging two days after they arrived. I want a refund.",
    questions=[
        {
            "type": "predicate",
            "name": "refund",
            "instructions": "Is the customer asking for a refund?",
        },
        {
            "type": "choice",
            "name": "topic",
            "instructions": "What is the ticket about?",
            "choices": [
                {"value": "billing", "description": "Charges and invoices"},
                {"value": "hardware", "description": "A device that is broken or faulty"},
                {"value": "shipping", "description": "Delivery and tracking"},
            ],
        },
        {
            "type": "score",
            "name": "sentiment",
            "instructions": "How does the customer feel?",
            "levels": [
                {"label": "very negative"},
                {"label": "negative"},
                {"label": "neutral"},
            ],
        },
    ],
)
# One answer per question, in the order asked
for answer in decision.answers:
    if answer.type == "refusal":
        print(answer.name, "refused")
    elif answer.type == "predicate":
        print(answer.name, answer.probability)
    elif answer.type == "choice":
        print(answer.name, answer.choice, answer.confidence)
    else:
        print(answer.name, answer.score, answer.confidence)
print(decision.usage.input_tokens, "input tokens")

OpenAI के SDK को https://api.zurelay.com/v1 पर पॉइंट करें, /v1 के साथ, जैसा Zurelay पर हर OpenAI मॉडल के लिए होता है, अपनी Zurelay कुंजी इस्तेमाल करें, और client.decisions.create कॉल करें। Node.js में इसके लिए openai 7.30.0 या उसके बाद का संस्करण चाहिए; Python में ऐसा openai पैकेज चाहिए जिसमें client.decisions हो (3.41 में है)। कोई भी HTTP क्लाइंट इसी तरह काम करता है: अपनी कुंजी को Bearer टोकन बनाकर JSON को POST करें।

जवाब

{
  "id": "req_3Fh8sLq0vW2nTc7yRb5kZp1M",
  "model": "gpt-6-luna-decisions",
  "answers": [
    { "type": "predicate", "name": "refund", "probability": 1 },
    {
      "type": "choice",
      "name": "topic",
      "choice": "hardware",
      "confidence": 1,
      "probabilities": [
        { "value": "billing", "probability": 0 },
        { "value": "hardware", "probability": 1 },
        { "value": "shipping", "probability": 0 }
      ]
    },
    {
      "type": "score",
      "name": "sentiment",
      "score": 0.18,
      "confidence": 0.85,
      "probabilities": [
        { "value": 0, "label": "very negative", "probability": 0.82 },
        { "value": 1, "label": "negative", "probability": 0.18 },
        { "value": 2, "label": "neutral", "probability": 0 }
      ]
    }
  ],
  "usage": {
    "input_tokens": 325,
    "input_tokens_details": { "cached_tokens": 0, "cache_write_tokens": 0 },
    "output_tokens": 0,
    "output_tokens_details": { "reasoning_tokens": 0 },
    "total_tokens": 325,
    "cost": 0.000013
  }
}

answers में हर सवाल का एक जवाब होता है, उसी क्रम में जिसमें आपने सवाल पूछे, हर जवाब के साथ उसका type और, अगर आपने दिया हो, तो उसका name भी। usage वह है जिस पर अनुरोध का बिल बना: input_tokens, जिसमें output_tokens हमेशा 0 रहता है, और cost यानी US डॉलर में उसकी लागत। जवाब का x-request-id हेडर आपके अनुरोध लॉग में उसे ढूँढ़ता है, और x-zurelay-input-tokens दोहराता है कि बिल किस पर बना।

पैरामीटर

सवालों के प्रकार

एक अनुरोध में तीनों को मिलाया जा सकता है। इनपुट सभी के लिए एक ही बार पढ़ा जाता है, इसलिए एक अनुरोध में कई प्रश्न पूछना, हर प्रश्न के लिए अलग अनुरोध भेजने से सस्ता पड़ता है।

प्रेडिकेट

इनपुट के बारे में कोई कथन या हाँ/नहीं वाला प्रश्न। उत्तर का probability बताता है कि वह कितना सही है: हाँ के लिए 1 के पास, नहीं के लिए 0 के पास, और बीच में तब जब इनपुट साफ़ न बताता हो।

{ "type": "predicate", "name": "refund", "instructions": "Is the customer asking for a refund?" }
{ "type": "predicate", "name": "refund", "probability": 1 }

विकल्प

आपके दिए मानों में से एक चुनता है, और हर एक की संभावना बताता है। विवरण बताता है कि किसी मान का क्या मतलब है, जो तब काम आता है जब मान अपने आप में सिर्फ़ एक कोड हो। मान true और false भी हो सकते हैं, और टेक्स्ट "true" और बूलियन true अलग-अलग मान हैं।

{
  "type": "choice",
  "name": "language",
  "instructions": "Which language is the message written in?",
  "choices": [
    { "value": "en", "description": "English" },
    { "value": "es", "description": "Spanish" },
    { "value": "other", "description": "Any other language" }
  ]
}

स्कोर

इनपुट को आपके स्तरों पर रखता है, सबसे निम्न पहले। score अपेक्षित स्तर है: हर स्तर का इंडेक्स, 0 से गिनते हुए, उसकी संभावना से भारित। इसलिए यह दो स्तरों के बीच भी आ सकता है: ऊपर के उदाहरण वाले रिस्पॉन्स में 0.18 ज़्यादातर पहला स्तर है और थोड़ा-सा दूसरा। probabilities की हर एंट्री में स्तर का इंडेक्स value के रूप में और उसका label होता है।

{
  "type": "score",
  "name": "relevance",
  "instructions": "How well does the passage answer the search query?",
  "levels": [
    { "label": "irrelevant" },
    { "label": "related", "description": "On the topic, but doesn't answer it" },
    { "label": "answers it" }
  ]
}

इमेज

इमेज को इनपुट में भेजें, यूज़र संदेश के भागों के रूप में, किसी भी टेक्स्ट के साथ। base64 data URL दें, या सार्वजनिक https लिंक, जिसे Zurelay डाउनलोड करके आगे भेजता है: PNG, JPEG, WebP या GIF। बड़ी इमेज लिंक के रूप में भेजें।

import base64, os
from openai import OpenAI
client = OpenAI(base_url="https://api.zurelay.com/v1", api_key=os.environ["ZURELAY_API_KEY"])
with open("return-photo.jpg", "rb") as file:
    photo = "data:image/jpeg;base64," + base64.b64encode(file.read()).decode()
decision = client.decisions.create(
    model="gpt-6-luna-decisions",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Photo sent with a return request for a blender."},
                {"type": "input_image", "image_url": photo, "detail": "low"},
            ],
        }
    ],
    questions=[
        {
            "type": "predicate",
            "name": "damaged",
            "instructions": "Does the photo show visible damage to the product?",
        },
        {
            "type": "choice",
            "name": "product",
            "instructions": "What product is in the photo?",
            "choices": [
                {"value": "blender"},
                {"value": "kettle"},
                {"value": "other", "description": "Anything else, or no product"},
            ],
        },
    ],
)
print(decision.answers)

इमेज अपने आकार और detail के हिसाब से टोकन जोड़ती है: 1200 × 630 की तस्वीर high या auto पर लगभग 750 टोकन की होती है, और low पर लगभग 150। जब प्रश्न बारीक अक्षरों के बजाय पूरी तस्वीर के बारे में हो, तब low का उपयोग करें। इमेज सिर्फ़ इनपुट में जाती हैं: प्रश्न के निर्देशों में टेक्स्ट ही लिया जाता है।

JSON इनपुट

संरचित डेटा को जैसा है वैसा ही input_json भाग में, टेक्स्ट या इमेज के साथ भेजा जा सकता है। मॉडल इसे कॉम्पैक्ट JSON टेक्स्ट के रूप में पढ़ता है, और उसी टेक्स्ट के हिसाब से बिल बनता है।

"input": [
  {
    "role": "user",
    "content": [
      { "type": "input_text", "text": "A sign-up from our app:" },
      {
        "type": "input_json",
        "data": { "name": "Free Gift Card Giveaway", "email": "win-now@example.net", "bio": "Click my link" }
      }
    ]
  }
]

अस्वीकृतियाँ

कोई भी प्रश्न उत्तर की जगह अस्वीकृति के रूप में लौट सकता है, जबकि अनुरोध के बाकी प्रश्नों के उत्तर फिर भी मिलते हैं। किसी उत्तर के फ़ील्ड पढ़ने से पहले उसका type जाँच लें। हमारे परीक्षणों में, इनपुट “Refund requested 38 hours ago.” और प्रेडिकेट “Page on-call?” पर अस्वीकृति मिली।

{ "type": "refusal", "name": "page_on_call" }

अस्वीकृति सामान्य रिप्लाई में आती है, जिसका usage बताता है कि अनुरोध का बिल किस आधार पर बना। ज़्यादा साफ़ प्रश्न के साथ दोबारा पूछें, या मामला किसी व्यक्ति को भेज दें।

सीमाएँ

• प्रति अनुरोध अधिकतम 1.05M टोकन: इनपुट और सभी प्रश्न मिलाकर। हमारे परीक्षणों में 918K टोकन का इनपुट चला।
• 1 से 64 प्रश्न। एक choice में 2 से 255 अद्वितीय मान और एक score में 2 से 10 स्तर हो सकते हैं।
• केवल यूज़र मैसेज स्वीकार किए जाते हैं: सिस्टम, डेवलपर और असिस्टेंट मैसेज, साथ ही फ़ंक्शन या टूल कॉल आइटम अस्वीकार कर दिए जाते हैं। संदर्भ को यूज़र मैसेज में, या किसी प्रश्न के निर्देशों में डालें।
• कोई स्ट्रीमिंग नहीं: stream अस्वीकार किया जाता है, और जवाब पूरे एक साथ वापस आते हैं।
• गलत फ़ॉर्मat वाला अनुरोध, या ऐसा अनुरोध जिसमें API द्वारा न स्वीकार किया जाने वाला फ़ील्ड हो, मॉडल तक पहुँचने से पहले ही 400 के साथ अस्वीकार कर दिया जाता है, जिसमें उस फ़ील्ड का नाम (जैसे questions[2].choices) बताया जाता है। इसमें कोई शुल्क नहीं लगता।
• कुछ ही मॉडल तक सीमित कुंजी की सूची में gpt-6-luna-decisions होना ज़रूरी है, उन अनुरोधों के लिए भी जिनमें gpt-6-luna लिखा हो। देखें कुंजी की सीमाएँ और नियम।

रफ़्तार

हमारे परीक्षणों में जवाब आमतौर पर 0.3 से 1 सेकंड में आ जाते हैं, और इमेज के साथ लगभग 1 सेकंड में। 900K टोकन के इनपुट में करीब 10 सेकंड लगे।

निर्णयों की लागत

GPT-6 Luna Decisions की कीमत $0.04 प्रति 1M इनपुट टोकन है, और इसके उत्तर मुफ़्त हैं। टोकन की गिनती इस तरह होती है: आपका इनपुट एक बार गिना जाता है, और हर सवाल पर मॉडल के अपने लगभग 110 से 160 टोकन जुड़ते हैं। छोटे टेक्स्ट पर एक छोटा predicate कुल मिलाकर लगभग 160 टोकन का होता है, दो predicate लगभग 320 टोकन के, और 2,600 टोकन के इनपुट पर चार सवाल लगभग 3,200 टोकन के। इमेज के टोकन ऊपर बताए अनुसार अलग से जुड़ते हैं। तो किसी छोटे टेक्स्ट पर एक सवाल वाली जाँच का खर्च लगभग $0.0000064 आता है, और ऐसी दस लाख जाँचों का लगभग $6.40।

हर जवाब के usage और x-zurelay-input-tokens हेडर बताते हैं कि उसका बिल किस आधार पर बना, हर रिक्वेस्ट आपके रिक्वेस्ट लॉग में दर्ज होती है, और जो रिक्वेस्ट फ़ेल होती हैं उनका कोई शुल्क नहीं लगता।

गड़बड़ियाँ

कीज़, क्रेडिट, बजट और रेट लिमिट पर वही एरर आते हैं जो बाकी सभी endpoints पर आते हैं: देखें एरर। OpenAI के SDKs उन एरर को दोबारा आज़माते हैं जिन्हें दोबारा आज़माना ठीक रहता है।