पाठ्यक्रम 250 में से पाठ 181 · LLMs को production तक ले जाना: लागत, caching और guardrails
LLMs को production तक ले जाना: लागत, caching और guardrails

प्रदाता की तरफ़ की prompt caching

पिछले पाठ ने request दोहराने पर मॉडल को छोड़ दिया। यह पाठ request को ही सस्ता बनाता है। ज़्यादातर प्रदाता prompt caching देते हैं: आप अपने prompt का एक स्थिर prefix चिह्नित करते हैं, और उसे दोबारा इस्तेमाल करने वाली अगली कॉल पर प्रदाता उन tokens को दोबारा process करना छोड़ देता है और उन पर भारी छूट देता है। यह अभी बनाए response cache से अलग औज़ार है:

  • Response cache (पिछला पाठ): पूरा जवाब दोबारा इस्तेमाल होता है, इसलिए आप कॉल पूरी तरह छोड़ देते हैं। सिर्फ़ तब काम करता है जब सवाल दोहराया जाए।
  • Prompt cache (यह पाठ): कॉल फिर भी होती है और आपको फिर भी ताज़ा जवाब मिलता है, पर साझा prefix सस्ता है। तब भी काम करता है जब हर सवाल अलग हो।

cache किए prefix में क्या आता है? बड़ी, स्थिर चीज़ें जो हर कॉल के साथ जाती हैं: एक लंबा system prompt, tool परिभाषाएँ, few-shot उदाहरण, एक लाया दस्तावेज़ जिसके बारे में आप कई सवाल पूछेंगे। बदलने वाला हिस्सा (असली उपयोगकर्ता सवाल) आप cache breakpoint के बाद रखते हैं। Anthropic के साथ आप सीमा को cache_control block से चिह्नित करते हैं:

system=[{"type": "text", "text": LONG_SYSTEM_PROMPT,
         "cache_control": {"type": "ephemeral"}}]

अर्थशास्त्र में तीन दरें हैं, सब सामान्य input क़ीमत के सापेक्ष। एक cache write (पहली कॉल, जो prefix रखती है) लगभग 1.25x input लेती है। एक cache read (बाद की कॉल जो रखे prefix से मिलती है) लगभग 0.1x input लेती है। एक miss बस 1x है। प्रविष्टि कुछ मिनट जीती है और हर hit पर उसका timer ताज़ा होता है, इसलिए व्यस्त prefix गर्म रहता है। तीन व्यावहारिक सीमाएँ: मॉडल के न्यूनतम (मॉडल के हिसाब से कुछ सौ से कुछ हज़ार tokens) से छोटा prefix चुपचाप cache नहीं होता; cache एक prefix मिलान है, इसलिए prompt में शुरू में कोई भी byte बदलना (मान लें system prompt में एक timestamp) उसके बाद का सब अमान्य कर देता है; और हर cache एक मॉडल का है, इसलिए मॉडल बदलना ठंडे से शुरू होता है। असल में hits मिले या नहीं यह देखने के लिए response पर usage.cache_read_input_tokens जाँचें। बराबरी का बिंदु जल्दी आता है: अगर एक बड़ा prefix मुट्ठी भर बार भी दोबारा इस्तेमाल हो, तो हर दोबारा इस्तेमाल पर 1x के बजाय 0.1x देने के सामने एक बार का 1.25x write बौना पड़ जाता है।

आप वह लागत मॉडल बनाएँगे जो तय करता है कि prefix cache करना फ़ायदेमंद है या नहीं।

आपकी बारी

अर्थशास्त्र का मॉडल बनाएँ। क़ीमतें प्रति 1,000,000 tokens डॉलर हैं; input के लिए 3.0 और output के लिए 15.0 इस्तेमाल करें। (1) uncached_cost(prefix_tokens, variable_tokens, output_tokens, calls): हर कॉल prefix_tokens + variable_tokens पर पूरी input क़ीमत और output_tokens पर output क़ीमत देती है, गुणा calls। (2) cached_cost(prefix_tokens, variable_tokens, output_tokens, calls): prefix एक बार 1.25x input क़ीमत पर लिखा जाता है, फिर बाक़ी calls - 1 calls पर 0.1x input क़ीमत पर पढ़ा जाता है; variable tokens हमेशा पूरी input क़ीमत देते हैं, और output हर कॉल पर हमेशा पूरी output क़ीमत देता है। मान लें calls >= 1। (3) caching_saves(prefix_tokens, variable_tokens, output_tokens, calls) True लौटाता है जब cached_cost uncached_cost से सख़्ती से कम हो। सादे floats (डॉलर) लौटाएँ।

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

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

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