पाठ्यक्रम 250 में से पाठ 187 · Production पैटर्न: retries, async, streaming और memory
Production पैटर्न: retries, async, streaming और memory

साथ-साथ चलने वाली batch calls (सीमित फैलाव)

जब आपको एक हज़ार prompts के जवाब चाहिए, तो मॉडल को एक-एक करके बुलाना और हर जवाब का इंतज़ार करना बहुत धीमा है। असली ऐप कई requests साथ-साथ भेजते हैं -> पर असीमित नहीं: हर प्रदाता सीमित करता है कि वह कितनी चलती calls की अनुमति देता है, इसलिए आप काम को तय आकार के batches में करते हैं। दो तथ्य साथ-साथ चलाने को पेचीदा बनाते हैं, और दोनों यहाँ दिखते हैं।

  • नतीजे बेतरतीब क्रम में लौटते हैं। एक छोटा prompt उस लंबे prompt से पहले पूरा हो सकता है जो आपने पहले भेजा। आपके कोड को जवाबों को उनके मूल इनपुट स्थान से दोबारा जोड़ना होगा, इस से नहीं कि कौन पहले पूरा हुआ।
  • throughput सीमा से बँधा है। n prompts और c की सीमा के साथ आप ceil(n / c) batches चलाते हैं -> वह संख्या जिस पर हर क्षमता योजना बनती है।

एक production रूप asyncio और एक असली network client इस्तेमाल करता। इस पहले रूप को समझना आसान रखने के लिए आप वही आकार सादे फ़ंक्शनों और एक scheduling loop से बनाते हैं -> कोई event loop नहीं, कोई network नहीं, कोई असली मॉडल नहीं। संदर्भ के लिए असली आकार यह है, चालू event loop के साथ वही तर्क:

import asyncio

async def run_batch(prompts, worker, cap=4):
    sem = asyncio.Semaphore(cap)            # the concurrency cap
    async def one(i):
        async with sem:                     # at most cap in flight
            return i, await worker(prompts[i])
    pairs = await asyncio.gather(*(one(i) for i in range(len(prompts))))
    results = [None] * len(prompts)
    for i, r in pairs:                       # reassemble by ORIGINAL index
        results[i] = r["result"]
    return results

एक Semaphore सीमा लागू करता है, gather calls को साथ चलाता है, और आप फिर भी हर जवाब को उसकी मूल जगह में वापस लिखते हैं। आप जो batches बनाने वाले हैं उनसे एक अंतर पर ध्यान दें: semaphore के साथ कोई भी call पूरी होते ही नई call शुरू होती है, इसलिए हमेशा cap तक calls चल रही होती हैं, जबकि तय batches अगला शुरू करने से पहले हर batch की सबसे धीमी call का इंतज़ार करते हैं। semaphore वाला रूप तेज़ है; batches के बारे में सोचना आसान है। async कोड भी टेस्ट हो सकता है (asyncio.run और नक़ली workers के साथ); यहाँ आप एक सादे scheduler से batch रूप बनाते हैं ताकि तर्क नज़र में रहे। एक worker(prompt) मॉडल कॉल की जगह लेता है और {"result": ..., "cost": ...} लौटाता है, जहाँ cost दर्शाता है कि उस चीज़ में कितना समय लगता। आप जानबूझकर हर batch को अलग cost क्रम में schedule करते हैं यह साबित करने के लिए कि आपका नतीजा जोड़ना चुपके से उस पर निर्भर नहीं है।

for start in range(0, len(prompts), cap):
    window = range(start, min(start + cap, len(prompts)))
    # work the window in ANY order, but write results[i] = worker(prompts[i])["result"]
    ...

run_batch(prompts, worker, cap=4) बनाएँ। cap आकार के batches में हर prompt पर worker चलाएँ, और {"results": [...], "batches": n_batches} लौटाएँ जहाँ results[i] prompts[i] का worker नतीजा है (इनपुट क्रम बचा रहे) और batches है ceil(len(prompts) / cap)। ख़ाली prompt सूची शून्य batches चलाती है।

आपकी बारी

run_batch(prompts, worker, cap=4) लिखें जो एक (नक़ली) worker को cap के batches में हर prompt पर चलाए और {"results", "batches"} लौटाए। results इनपुट क्रम में होने चाहिए भले ही हर चीज़ का अलग cost हो जिससे आप schedule कर सकते हैं; batches है ceil(len(prompts) / cap)। सादे फ़ंक्शन और एक scheduling loop इस्तेमाल करें -> कोई asyncio नहीं, कोई network नहीं। एक दूसरे अलग इनपुट set से अलग नतीजे मिलने चाहिए; ख़ाली सूची शून्य batches चलाती है।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।