ചെലവും ലേറ്റൻസിയും (Latency) വർദ്ധിപ്പിക്കാതെ എങ്ങനെ നിങ്ങളുടെ ഉൽപ്പന്നത്തിൽ ഒരു LLM ഉൾപ്പെടുത്താം

ഒരു AI ഡെമോ നിർമ്മിക്കുന്നത് എളുപ്പമാണ്. ഒരു API കീ എടുക്കുക, ഒരു പ്രോംപ്റ്റ് എഴുതുക, അത് നിങ്ങളുടെ ടീമിന് കാണിച്ചുകൊടുക്കുക.

പിന്നീട് നിങ്ങൾ അത് പുറത്തിറക്കുന്നു. ട്രാഫിക് വരുന്നു. നിങ്ങളുടെ ചെലവ് കുതിച്ചുയരുകയും ലേറ്റൻസി (latency) വർദ്ധിക്കുകയും ചെയ്യുന്നു.

ഒരു ഡെമോയിൽ നിന്ന് യഥാർത്ഥ ഉൽപ്പന്നത്തിലേക്കുള്ള മാറ്റത്തിന് കോസ്റ്റ് ആൻഡ് ലേറ്റൻസി എൻജിനീയറിംഗ് (cost and latency engineering) ആവശ്യമാണ്. അത് എങ്ങനെ ചെയ്യാം എന്ന് നോക്കാം.

ഔട്ട്‌പുട്ട് നിയന്ത്രിക്കുക

മിക്ക API-കളും ടോക്കണുകൾക്ക് (tokens) അനുസരിച്ചാണ് ചാർജ് ചെയ്യുന്നത്. ഇൻപുട്ട് ടോക്കണുകളേക്കാൾ കൂടുതൽ ചെലവ് ഔട്ട്‌പുട്ട് ടോക്കണുകൾക്കായി വരും.

ആളുകൾ പ്രോംപ്റ്റുകൾ ചുരുക്കാൻ സമയം ചെലവഴിക്കുന്നുണ്ടെങ്കിലും മോഡലിനെ അനാവശ്യമായി സംസാരിക്കാൻ അനുവദിക്കുന്നു. ഇത് ഒരു തെറ്റാണ്.

പണവും സമയവും ലാഭിക്കാൻ ഔട്ട്‌പുട്ട് പരിമിതപ്പെടുത്തുക:

  • JSON ആവശ്യപ്പെടുക.
  • ഒരു വാചകം മാത്രം ആവശ്യപ്പെടുക.
  • max_tokens പരിധി നിശ്ചയിക്കുക.
  • ചുരുക്കത്തിൽ മറുപടി നൽകാൻ മോഡലിനോട് പറയുക.

ചെറിയ ഉത്തരങ്ങൾ വേഗതയുള്ളതും ചിലവ് കുറഞ്ഞതുമാണ്.

അനാവശ്യമായ കോളുകൾ ഒഴിവാക്കുക

ലാഭിക്കാനുള്ള ഏറ്റവും നല്ല മാർഗ്ഗം മോഡലിനെ വിളിക്കാതിരിക്കുക എന്നതാണ്.

  • കാഷിംഗ് (caching) ഉപയോഗിക്കുക: സാധാരണ ചോദ്യങ്ങൾക്കുള്ള മറുപടികൾ സൂക്ഷിച്ചു വെക്കുക. ചോദ്യങ്ങൾ ഒരേപോലെയല്ലെങ്കിലും സമാനമാണെങ്കിൽ ഒരു സെമാന്റിക് കാഷ് (semantic cache) സഹായിക്കും.
  • റൂട്ടിംഗ് (routing) ഉപയോഗിക്കുക: ലളിതമായ ജോലികൾക്കായി നിങ്ങളുടെ ഏറ്റവും മികച്ച മോഡൽ ഉപയോഗിക്കരുത്. ക്ലാസിഫിക്കേഷനായി ചെറിയതും വില കുറഞ്ഞതുമായ ഒരു മോഡൽ ഉപയോഗിക്കുക. സങ്കീർണ്ണമായ ജോലികൾക്കായി വിലകൂടിയ മോഡൽ മാറ്റിവെക്കുക.

ഉപയോക്താവിന്റെ അനുഭവം മെച്ചപ്പെടുത്തുക

ഒരു മറുപടി ലഭിക്കാൻ സമയമെടുക്കുന്നുണ്ടെങ്കിൽ, അത് വേഗത്തിൽ സംഭവിക്കുന്നതായി തോന്നിപ്പിക്കുക.

  • ടോക്കണുകൾ സ്ട്രീം ചെയ്യുക (Stream tokens): വാക്കുകൾ രൂപപ്പെടുന്നതിനനുസരിച്ച് കാണിക്കുക. ഇത് കാത്തിരിപ്പ് സമയം കുറയ്ക്കാൻ സഹായിക്കും.
  • പുരോഗതി കാണിക്കുക (Show progress): ഒരു ജോലിക്ക് ഒന്നിലധികം ഘട്ടങ്ങളുണ്ടെങ്കിൽ, എന്താണ് സംഭവിക്കുന്നതെന്ന് ഉപയോക്താവിനെ അറിയിക്കുക. വെറുതെ ഒരു സ്പിന്നർ (spinner) കാണിക്കുന്നതിന് പകരം "Searching documents..." പോലുള്ള ടെക്സ്റ്റുകൾ ഉപയോഗിക്കുക.

"Tail" ലേറ്റൻസി കൈകാര്യം ചെയ്യുക

ചില റിക്വസ്റ്റുകൾ എപ്പോഴും സാവധാനത്തിലായിരിക്കും. അവ നിങ്ങളുടെ ഉൽപ്പന്നത്തെ തകരാറിലാക്കാൻ അനുവദിക്കരുത്.

  • ടൈമൗട്ടുകൾ (timeouts) നിശ്ചയിക്കുക: ഒരു റിക്വസ്റ്റ് തടസ്സപ്പെട്ടാൽ എന്ത് സംഭവിക്കണമെന്ന് തീരുമാനിക്കുക. ഒരു ഫോളബാക്ക് (fallback) അല്ലെങ്കിൽ ചെറിയൊരു മോഡൽ ഉപയോഗിക്കുക.
  • റീട്രൈകൾ (retries) ഉപയോഗിക്കുക: ചെറിയ പിശകുകൾക്കായി റീട്രൈകൾ ചേർക്കുക, എന്നാൽ അവയ്ക്ക് ഒരു പരിധി നിശ്ചയിക്കുക.
  • സർക്യൂട്ട് ബ്രേക്കറുകൾ (circuit breakers) ഉപയോഗിക്കുക: ഒരു പ്രൊവൈഡർ പ്രവർത്തനരഹിതമായാൽ, ദീർഘനേരം കാത്തിരിക്കുന്നത് ഒഴിവാക്കാൻ ഉടൻ തന്നെ റിക്വസ്റ്റുകൾ അയക്കുന്നത് നിർത്തുക.

ഡാറ്റ ട്രാക്ക് ചെയ്യുക

അളക്കാൻ കഴിയാത്ത ഒന്നിനെ നിങ്ങൾക്ക് പരിഹരിക്കാൻ കഴിയില്ല. ഓരോ റിക്വസ്റ്റിനും ഈ മൂന്ന് കാര്യങ്ങൾ രേഖപ്പെടുത്തുക:

  • ഇൻപുട്ട് ടോക്കണുകൾ.
  • ഔട്ട്‌പുട്ട് ടോക്കണുകൾ.
  • ആകെ ലേറ്റൻസി.

വിജയകരമായ ഓരോ ഉപയോക്തൃ ഫലത്തിനും (user outcome) വരുന്ന ചെലവ് ശ്രദ്ധിക്കുക. പരാജയപ്പെടുന്ന ഒരു വില കുറഞ്ഞ ഫീച്ചറിനേക്കാൾ നല്ലത് കൃത്യമായി പ്രവർത്തിക്കുന്ന ഒരു ഫീച്ചറാണ്.

LLM-നെ ഒരു മാന്ത്രികവിദ്യയായി കാണുന്നത് നിർത്തുക. അത് നിങ്ങൾ നിയന്ത്രിക്കേണ്ട, സാവധാനത്തിലുള്ളതും ചെലവേറിയതുമായ ഒരു ഡിപെൻഡൻസി (dependency) ആയി കാണുക.

Source: https://dev.to/muhammadzainnaseer/how-to-put-an-llm-in-your-product-without-wrecking-your-costs-or-your-latency-89a

Optional learning community: https://t.me/GyaanSetuAi