Exponential backoff के साथ retry
असली दुनिया LLM ऐप को सबसे पहले यह सिखाती है कि calls विफल होती हैं। एक rate limit, टूटा connection, प्रदाता से 503 -> इनमें से किसी का मतलब यह नहीं कि आपका कोड ग़लत है, इनका मतलब है आपको थोड़ा रुककर दोबारा कोशिश करनी चाहिए। मानक पैटर्न exponential backoff के साथ retry है: हर विफलता पर आप अगली कोशिश से पहले ज़्यादा इंतज़ार करते हैं, ताकि छोटी अड़चन जल्दी ठीक हो और संघर्ष करती सेवा पर हथौड़ा न चले।
retries के बीच की देरी हर बार दोगुनी होती है। अगर base delay 0.5 सेकंड है, तो आप 0.5, फिर 1.0, फिर 2.0 इंतज़ार करते हैं, और इसी तरह -> सूत्र है base_delay * 2 ** attempt जहाँ attempt शून्य से शुरू retry संख्या है। तय कोशिशों के बाद आप हार मानते हैं और error को आगे जाने देते हैं, क्योंकि हमेशा दोबारा कोशिश करना बस एक असली outage छिपाता है।
for attempt in range(max_attempts):
try:
return call_the_model()
except Exception:
# last attempt? re-raise. otherwise wait base_delay * 2**attempt
...production में इंतज़ार एक असली time.sleep(delay) है, और एक on-device WebLLM engine के चारों ओर आप वही retry loop engine.chat.completions.create(...) पर लपेटेंगे। पर sleep करना टेस्ट को धीमा और अस्थिर बनाता है, इसलिए यहाँ आप बिल्कुल sleep नहीं करते: आप वे देरियाँ दर्ज करते हैं जितना आप इंतज़ार करते और उन्हें लौटाते हैं। इससे पूरी चीज़ निश्चित और तुरंत टेस्ट होने लायक रहती है, जबकि तर्क -> कोशिशें गिनें, backoff निकालें, सीमा पर हार मानें -> ठीक वही है जो भेजा जाता है।
जानने लायक एक असली दुनिया का सुधार: सिर्फ़ देरी दोगुनी करने से एक ही पल में विफल हुआ हर client एक साथ retry करता है, सब मिलकर जागते हैं और सेवा पर फिर धावा बोलते हैं (एक "thundering herd")। production कोड jitter जोड़ता है -> थोड़ा रैंडमपन ताकि retries फैल जाएँ, आमतौर पर निकाली देरी तक का रैंडम समय sleep करके ("full jitter", जैसे time.sleep(random.uniform(0, delay)))। हम ग्रेड होने वाले फ़ंक्शन को निश्चित रखते हैं और ठीक base_delay * 2 ** attempt मान दर्ज करते हैं; jitter वह production सुधार है जो आप ऊपर जोड़ेंगे, अभ्यास का हिस्सा नहीं।
retry_call(fn, max_attempts, base_delay) बनाएँ। fn() बुलाएँ। अगर यह लौटता है, तो एक dict {"value": result, "attempts": how_many_calls, "delays": [...]} लौटाएँ। अगर यह error उठाता है, तो backoff देरी base_delay * 2 ** attempt दर्ज करें (sleep न करें) और दोबारा कोशिश करें, कुल max_attempts calls तक। अगर आख़िरी कोशिश भी error उठाए, तो उस अपवाद को आगे जाने दें। कभी विफल न होने वाला callable ठीक एक बार ख़ाली delay सूची के साथ बुलाया जाता है। असली clients के दो नियम भी यहाँ आते हैं। सिर्फ़ अस्थायी विफलताएँ दोबारा आज़माएँ (calling-llms मॉड्यूल के 408, 409, 429 और 5xx statuses); बिगड़ी request हर बार एक ही तरह विफल होती है। और जब server एक retry-after header भेजे, तो अपने backoff के बजाय कम से कम उतना इंतज़ार करें। आधिकारिक SDK दोनों पहले से करता है, डिफ़ॉल्ट रूप से दो बार, इसलिए व्यवहार में आप आमतौर पर यह loop ख़ुद लिखने के बजाय max_retries tune करते हैं।
retry_call(fn, max_attempts, base_delay, retryable=None) लिखें जो fn() बुलाए और error उठाने पर दोबारा कोशिश करे, पर सिर्फ़ दोबारा आज़माने लायक errors पर: अगर retryable दिया गया है (अपवाद से True/False तक का फ़ंक्शन) और False लौटाता है, तो बिना एक और कोशिश के तुरंत दोबारा उठाएँ। retryable=None के साथ हर अपवाद दोबारा आज़माने लायक गिना जाता है। यह हर retry से पहले exponential backoff देरी base_delay * 2 ** attempt बिना sleep किए दर्ज करता है। सफल होने पर {"value", "attempts", "delays"} लौटाएँ; max_attempts calls सब विफल होने पर दोबारा उठाएँ। N-1 बार विफल होकर फिर सफल होने वाला fn मान लौटाता है; दर्ज देरियाँ exponential संदर्भ के बराबर हैं; कभी विफल न होने वाला fn ठीक एक बार बुलाया जाता है।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।