ഒരു LLM എങ്ങനെ ഫൈൻ-ട്യൂൺ ചെയ്യാം [ഒപ്പം, പകരം RAG അല്ലെങ്കിൽ പ്രോംപ്റ്റിംഗ് എപ്പോൾ ഉപയോഗിക്കണം]

ഒരു ലാർജ് ലാംഗ്വേജ് മോഡൽ (LLM) ഫൈൻ-ട്യൂൺ ചെയ്യുക എന്നാൽ, പ്രോംപ്റ്റിംഗിലൂടെ മാത്രം ലഭിക്കാത്ത ഔട്ട്‌പുട്ടുകൾ നൽകുന്നതിനായി, മുൻകൂട്ടി പരിശീലിപ്പിച്ച ഒരു LLM-നെ ചെറുതും ടാസ്‌ക്-നിർദ്ദിഷ്ടവുമായ ഒരു ഡാറ്റാസെറ്റിൽ കൂടുതൽ മെച്ചപ്പെടുത്തുക എന്നതാണ്.

നിങ്ങൾ ആഗ്രഹിക്കുന്ന പെരുമാറ്റം കാണിക്കുന്ന ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് ഉദാഹരണ ജോഡികൾ ശേഖരിക്കുക, മോഡലിന്റെ വെയ്റ്റുകളെ അവയിലേക്ക് അടുപ്പിക്കുന്ന ട്രെയിനിംഗ് പാസുകൾ റൺ ചെയ്യുക, ഫലം യഥാർത്ഥ മോഡലിന്റെ ഔട്ട്‌പുട്ടുകളുമായി താരതമ്യം ചെയ്ത് പരിശോധിക്കുക എന്നിവയാണ് ഫൈൻ-ട്യൂണിംഗിൽ ഉൾപ്പെടുന്നത്. LoRA പോലുള്ള പാരാമീറ്റർ-എഫിഷ്യന്റ് രീതികൾ ഇത് ഒരൊറ്റ GPU-വിൽ റൺ ചെയ്യാൻ കഴിയുന്നത്ര ചെലവുകുറഞ്ഞതാക്കുന്നു.

LLM ഔട്ട്‌പുട്ടുകളിൽ നിങ്ങൾ തൃപ്തരല്ലെങ്കിൽ, ആദ്യം നിങ്ങളുടെ പ്രോംപ്റ്റുകളും റിട്രീവൽ-ഓഗ്മെന്റഡ് ജനറേഷനും (RAG) മെച്ചപ്പെടുത്തുക. LLM എങ്ങനെ പെരുമാറുന്നു എന്നതിനെയാണ് ഫൈൻ-ട്യൂണിംഗ് മാറ്റുന്നത്. പുതിയതോ നിങ്ങളുടെ സ്വന്തം ഉടമസ്ഥതയിലുള്ളതോ ആയ വിവരങ്ങൾ അത് ഉപയോഗിക്കണമെങ്കിൽ, സാധാരണയായി പ്രോംപ്റ്റിംഗും RAG-ഉം ആണ് മികച്ച തിരഞ്ഞെടുപ്പ്.

ഒരു LLM ഘട്ടം ഘട്ടമായി എങ്ങനെ ഫൈൻ-ട്യൂൺ ചെയ്യാം, പ്രധാന ഫൈൻ-ട്യൂണിംഗ് രീതികൾ (LoRA, QLoRA), ഈ പ്രക്രിയയെ തകിടം മറിക്കാവുന്ന വെല്ലുവിളികളും പിഴവുകളും എന്നിവ ഇവിടെ വിശദീകരിക്കുന്നു.

LLM ഫൈൻ-ട്യൂണിംഗ് എന്താണ്, അത് LLM പ്രീ-ട്രെയിനിംഗിൽ നിന്ന് എങ്ങനെ വ്യത്യസ്തമാകുന്നു

LLM പ്രീ-ട്രെയിനിംഗ് ബൃഹത്തായ ഒരു കോർപ്പസ് ഉപയോഗിച്ച് ആദ്യം മുതൽ ഒരു മോഡലിന്റെ പൊതുവായ ഭാഷാശേഷി വളർത്തിയെടുക്കുന്നു; അതേസമയം LLM ഫൈൻ-ട്യൂണിംഗ്, മുൻകൂട്ടി പരിശീലിപ്പിച്ച ഒരു മോഡലിനെ ഒരു പ്രത്യേക ജോലിക്കായി ചെറിയൊരു ഡാറ്റാസെറ്റിൽ ക്രമീകരിക്കുന്നു.

ഒരു ബേസ് മോഡൽ സൃഷ്ടിക്കുന്ന, ധാരാളം റിസോഴ്‌സുകൾ ആവശ്യമുള്ള ഘട്ടമാണ് LLM പ്രീ-ട്രെയിനിംഗ്. വിപുലമായ ഒരു ടെക്സ്റ്റ് കോർപ്പസിൽ നിന്നാണ് മോഡൽ പഠിക്കുന്നത്; ഇത് അതിന് പൊതുവായ വ്യാകരണവും വസ്തുതകളും യുക്തിചിന്തയും നൽകുന്നു, പക്ഷേ നിങ്ങളുടെ ടാസ്‌കിനായുള്ള പ്രത്യേക വൈദഗ്ധ്യം നൽകുന്നില്ല.

ഒരു പ്രത്യേക ടാസ്‌കിനോ ഉപയോഗത്തിനോ ആവശ്യമായ ഔട്ട്‌പുട്ടുകൾ നൽകുന്നതിനായി, LLM ഫൈൻ-ട്യൂണിംഗ് ബേസ് മോഡലിന്റെ ട്രെയിനിംഗ് ചെറുതും ശ്രദ്ധാപൂർവ്വം തയ്യാറാക്കിയതുമായ ഒരു ഡാറ്റാസെറ്റിൽ തുടരുന്നു. സ്ഥിരതയുള്ള ഒരു ഫോർമാറ്റ്, ബ്രാൻഡ് ശൈലി അല്ലെങ്കിൽ ടോൺ, ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട പാറ്റേണുകൾ, അല്ലെങ്കിൽ വിശ്വസനീയമായ ടൂൾ, ഫംഗ്ഷൻ കോളുകൾ എന്നിവ ഉദാഹരണങ്ങളാണ്.

എപ്പോൾ LLM-കൾ ഫൈൻ-ട്യൂൺ ചെയ്യണം, എപ്പോൾ പകരം പ്രോംപ്റ്റിംഗോ RAG-ഓ ഉപയോഗിക്കണം

LLM പ്രകടനം മെച്ചപ്പെടുത്താൻ, ഈ ക്രമത്തിൽ പടിപടിയായി മുന്നോട്ടുപോകുക: പ്രോംപ്റ്റിംഗ് -> RAG -> ഫൈൻ-ട്യൂണിംഗ്.

കൂടുതൽ വിശദമായ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് നിങ്ങളുടെ പ്രോംപ്റ്റുകൾ മെച്ചപ്പെടുത്തുക, മോഡലിന് ഏറ്റവും പുതിയ വിവരങ്ങൾ നൽകാൻ RAG ഉപയോഗിക്കുക. പ്രോംപ്റ്റിലും റിട്രീവലിലും വരുത്തുന്ന മെച്ചപ്പെടുത്തലുകൾ ഫലം കാണാതെ വരുമ്പോൾ മാത്രം ഫൈൻ-ട്യൂണിംഗ് ഉപയോഗിക്കുക.

മികച്ച പ്രോംപ്റ്റുകൾ ഫൈൻ-ട്യൂണിംഗിനെക്കാൾ ഫലപ്രദമാകുന്നത് എപ്പോൾ, അവ മതിയാകാതെ വരുന്നത് എപ്പോൾ

ഏറ്റവും വേഗമേറിയതും ചെലവുകുറഞ്ഞതുമായ മാർഗ്ഗമാണ് പ്രോംപ്റ്റിംഗ്. പല സാഹചര്യങ്ങളിലും, കൂടുതൽ കൃത്യവും വിശദവുമായ പ്രോംപ്റ്റുകളിലൂടെ ആഗ്രഹിക്കുന്ന പെരുമാറ്റ മാറ്റങ്ങൾ കൈവരിക്കാനാകും.

എന്നാൽ ദൈർഘ്യമേറിയ പ്രോംപ്റ്റുകൾ ജോലി മന്ദഗതിയിലാക്കുകയും ചെലവ് കൂട്ടുകയും ചെയ്യുന്നു, മാത്രമല്ല മോഡലിന്റെ നിലവിലുള്ള പരിമിതികളെ മറികടക്കാൻ അവയ്ക്ക് കഴിയില്ല.

പ്രോംപ്റ്റിംഗ് അതിന്റെ പരിധിയിലെത്തിയിരിക്കാം എന്നതിന്റെ സൂചനകൾ:

• പുതിയ എഡ്ജ് കേസുകൾ ഔട്ട്‌പുട്ടിനെ തുടർച്ചയായി തകരാറിലാക്കുന്നു: ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് JSON വേണ്ടപ്പോൾ മോഡൽ സാധാരണ ഗദ്യം നൽകുന്നു അല്ലെങ്കിൽ ഉദ്ദേശിച്ച ടോണിൽ നിന്ന് വ്യതിചലിക്കുന്നു, ഓരോ പുതിയ കേസിനും നിങ്ങൾ പ്രോംപ്റ്റിൽ പാച്ച് ചെയ്യേണ്ടി വരുന്നു.
• സിസ്റ്റം പ്രോംപ്റ്റ് വളർന്നുകൊണ്ടേയിരിക്കുന്നു: പ്രോംപ്റ്റ് നൂറുകണക്കിനോ ആയിരക്കണക്കിനോ വരികളിലേക്ക് നീളുന്നു, അത് കൈകാര്യം ചെയ്യാൻ ബുദ്ധിമുട്ടാണ്.
• ഓരോ കോളിലും നിങ്ങൾ അതിന് വില നൽകുന്നു: ഓരോ അഭ്യർത്ഥനയിലും പ്രോംപ്റ്റ് വീണ്ടും അയയ്ക്കുകയും വീണ്ടും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നതിനാൽ, ടോക്കൺ ചെലവും ലേറ്റൻസിയും വർദ്ധിക്കുന്നു.
• മാറ്റങ്ങൾ ഫലം കാണാതാകുന്നു: പുതിയ നിർദ്ദേശങ്ങൾ ഔട്ട്‌പുട്ടുകൾ മെച്ചപ്പെടുത്തുന്നില്ല.

അപ്പോഴും, ചെലവുകുറഞ്ഞ പ്രോംപ്റ്റ്-തല പരിഹാരങ്ങൾ ആദ്യം പരീക്ഷിക്കുക. മോഡലിന് പാറ്റേൺ കാണിച്ചുകൊടുക്കാൻ ഫ്യൂ-ഷോട്ട് ഉദാഹരണങ്ങളും (ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് ജോഡികൾ), ബുദ്ധിമുട്ടുള്ള ടാസ്‌കുകളെ ചെറിയ ഘട്ടങ്ങളായി വിഭജിക്കാൻ പ്രോംപ്റ്റ് ചെയിനിംഗും, കൃത്യമായ ലുക്കപ്പുകളോ കണക്കുകൂട്ടലുകളോ പുറത്തേക്ക് കൈമാറാൻ ഫംഗ്ഷൻ-കോളിംഗ് ഹുക്കുകളും ഉപയോഗിക്കുക.

മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നതിനെക്കാൾ RAG കൂടുതൽ യുക്തമാകുന്നത് എപ്പോൾ

LLM-ന് എന്ത് അറിയാം എന്നതിനെയാണ് RAG മാറ്റുന്നത്, അതേസമയം LLM ഫൈൻ-ട്യൂണിംഗ് അത് എങ്ങനെ പെരുമാറുന്നു എന്നതിനെ മാറ്റുന്നു. വിടവ് അറിവിലാണെങ്കിൽ, പ്രത്യേകിച്ച് ഇടയ്ക്കിടെ മാറുന്നതോ നിങ്ങളുടെ സ്വന്തം ഡോക്യുമെന്റുകളിലുള്ളതോ ആയ അറിവിലാണെങ്കിൽ, RAG ആണ് പരിഹാരം. വിടവ് പെരുമാറ്റത്തിലാണെങ്കിൽ, ഫൈൻ-ട്യൂൺ ചെയ്യുക.

ഒരു മോഡലിന് എന്ത് അറിയാം എന്നതിലും ഫൈൻ-ട്യൂണിംഗ് മാറ്റം വരുത്തുന്നുണ്ട്, എന്നാൽ അത് ഉൾക്കൊള്ളുന്ന ഏതൊരു വസ്തുതയും ട്രെയിനിംഗ് സമയത്തെ നിലയിൽ മരവിച്ചുപോകുന്നു, അതിവേഗം മാറുന്ന മേഖലകളിൽ അവ വേഗത്തിൽ കാലഹരണപ്പെടുകയും ചെയ്യുന്നു. കൂടാതെ, ഈ വിവരങ്ങൾ മോഡലിന്റെ വെയ്റ്റുകളിൽ ഉൾച്ചേരുന്നതിനാൽ, അവയുടെ ഉറവിടത്തെക്കുറിച്ചുള്ള ഒരു രേഖയും അവയിൽ അവശേഷിക്കുന്നില്ല.

ഒരു റിട്രീവൽ ലെയർ ഉപയോഗിക്കുന്ന സോഴ്‌സ് ഡോക്യുമെന്റുകൾ അപ്ഡേറ്റ് ചെയ്യുന്നത് കൂടുതൽ വേഗമേറിയതും ചെലവുകുറഞ്ഞതുമാണ്, മാത്രമല്ല ഉപയോഗിച്ച കൃത്യമായ ഉറവിടങ്ങൾ ഉദ്ധരിക്കാനും അതിന് കഴിയും. അതിനാൽ, സാധൂകരിക്കാവുന്നതും ഏറ്റവും പുതിയതുമായ വിവരങ്ങൾ ആവശ്യമുള്ളപ്പോൾ ഇതാണ് മികച്ച തിരഞ്ഞെടുപ്പ്.

RAG-ന്റെ പോരായ്മ? നിർമ്മിക്കുകയും പരിപാലിക്കുകയും ചെയ്യേണ്ട ഒരു അധിക ലെയറാണ് അത്, കൂടാതെ അത് ലേറ്റൻസി കൂട്ടുകയും ചെയ്യുന്നു.

പ്രായോഗികമായി, പലപ്പോഴും നിങ്ങൾക്ക് ഇവ രണ്ടും ആവശ്യമായി വരും. പ്രൊഡക്ഷൻ സിസ്റ്റങ്ങൾ ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡലുകളെ RAG-മായി ജോടിയാക്കുന്നു; ഒന്ന് സ്ഥിരതയുള്ള പെരുമാറ്റത്തിനും മറ്റൊന്ന് നിലവിലെ വസ്തുതകൾക്കും.

ഫൈൻ-ട്യൂണിംഗിലെ സാധാരണ പിഴവുകളും അപകടസാധ്യതകളും വെല്ലുവിളികളും

ഫൈൻ-ട്യൂണിംഗ് ശരിയായ ഉപാധിയാകുമ്പോൾ പോലും, അതിന് ചെലവുകളും അപകടസാധ്യതകളും ഉണ്ട്:

• ചെലവും സമയവും: വൃത്തിയുള്ളതും പ്രാതിനിധ്യ സ്വഭാവമുള്ളതുമായ ട്രെയിനിംഗ് ഡാറ്റ ശേഖരിച്ച് ക്രമീകരിക്കുന്നതും ട്രെയിനിംഗിന് ആവശ്യമായ കമ്പ്യൂട്ടിംഗ് ശേഷിയും ചെലവേറിയതാണ്.
• കാറ്റസ്ട്രോഫിക് ഫോർഗെറ്റിംഗ്: ഇടുങ്ങിയ ഒരു ഡാറ്റാസെറ്റിൽ ട്രെയിൻ ചെയ്യുമ്പോൾ, ഒരു മോഡലിന് പൊതുവായ കഴിവുകൾ നഷ്ടപ്പെടുകയും പുതിയ തരം പരാജയങ്ങൾ ഉണ്ടാകുകയും ചെയ്യാം; ഇത് ബേസ് മോഡൽ വരുത്താത്ത പിഴവുകൾക്ക് കാരണമാകുന്നു.
• ഓവർഫിറ്റിംഗ്: ഡാറ്റ വളരെ കുറവോ അമിതമായി ആവർത്തിക്കുന്നതോ ആണെങ്കിൽ, മോഡൽ പാറ്റേണുകൾ പഠിക്കുന്നതിന് പകരം നിങ്ങളുടെ ട്രെയിനിംഗ് ഉദാഹരണങ്ങൾ മനഃപാഠമാക്കുന്നു; അതിനാൽ ട്രെയിനിംഗ് സാമ്പിളുകളിൽ അത് മികച്ച പ്രകടനം കാഴ്ചവയ്ക്കുമെങ്കിലും യഥാർത്ഥ ഇൻപുട്ടുകളിൽ മോശം പ്രകടനമായിരിക്കും.
• പഴക്കം: വെയ്റ്റുകളിൽ ഉൾച്ചേർത്ത അറിവ് വേഗത്തിൽ കാലഹരണപ്പെടുന്നു, അതിനാൽ പുതിയ ഡാറ്റയിൽ നിങ്ങൾ വീണ്ടും ട്രെയിൻ ചെയ്യേണ്ടി വരും.
• അപ്രസക്തമാകൽ: കൂടുതൽ ശക്തമായ ഒരു മോഡൽ പുറത്തിറങ്ങുമ്പോൾ, യാതൊരു ക്രമീകരണവുമില്ലാതെ തന്നെ അത് പലപ്പോഴും നിങ്ങളുടെ ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡലിനെ മറികടക്കും, അപ്പോൾ നിങ്ങൾക്ക് ആ ജോലി വീണ്ടും ചെയ്യേണ്ടി വരും.
• മൂല്യനിർണ്ണയത്തിലെയും ഫലങ്ങൾ പുനഃസൃഷ്ടിക്കുന്നതിലെയും വെല്ലുവിളികൾ: ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡൽ ബേസ് മോഡലിനെക്കാൾ മികച്ച പ്രകടനം കാഴ്ചവയ്ക്കുന്നുവെന്ന് തെളിയിക്കുന്നത് ബുദ്ധിമുട്ടാണ്. ഒരേ ക്രമീകരണങ്ങളുള്ള രണ്ട് GPU ട്രെയിനിംഗ് റണ്ണുകൾ പോലും അൽപ്പം വ്യത്യസ്തമായ മോഡലുകൾ സൃഷ്ടിച്ചേക്കാം.
• ഡാറ്റ ഗവേണൻസ്: ഉടമസ്ഥാവകാശമുള്ളതോ സെൻസിറ്റീവോ ആയ ഡാറ്റയിൽ ട്രെയിൻ ചെയ്യുന്നത് സ്വകാര്യതയും ലൈസൻസിംഗും സംബന്ധിച്ച ചോദ്യങ്ങൾ ഉയർത്തുന്നു; ട്രെയിൻ ചെയ്ത ഡാറ്റയുടെ ശകലങ്ങൾ ഒരു മോഡൽ പിന്നീട് പുറത്തുവിട്ടേക്കാം.

പ്രധാന ഫൈൻ-ട്യൂണിംഗ് രീതികൾ

മോഡലിന്റെ എത്ര ഭാഗം മാറ്റുന്നു എന്നതിനെ അടിസ്ഥാനമാക്കിയാണ് LLM ഫൈൻ-ട്യൂണിംഗിന്റെ പ്രധാന തരങ്ങൾ വ്യത്യാസപ്പെടുന്നത്: ഫുൾ ഫൈൻ-ട്യൂണിംഗ് മുഴുവൻ മോഡലിനെയും വീണ്ടും ട്രെയിൻ ചെയ്യുന്നു, അതേസമയം LoRA, QLoRA പോലുള്ള പാരാമീറ്റർ-എഫിഷ്യന്റ് ഫൈൻ-ട്യൂണിംഗ് (PEFT) രീതികൾ ചില വെയ്റ്റുകൾ മാത്രം അപ്ഡേറ്റ് ചെയ്യുന്നു. ഫുൾ ഫൈൻ-ട്യൂണിംഗിന് വേണ്ടതിന്റെ ഒരു ചെറിയ അംശം മെമ്മറി മാത്രമേ PEFT രീതികൾക്ക് ആവശ്യമുള്ളൂ, ശരിയായ ക്രമീകരണങ്ങളോടെ സമാനമായ ഫലങ്ങൾ നേടാനും അവയ്ക്ക് കഴിയും.

ഫുൾ ഫൈൻ-ട്യൂണിംഗ് മോഡലിന്റെ എല്ലാ വെയ്റ്റുകളും അപ്ഡേറ്റ് ചെയ്യുന്നു. ഇതാണ് ഏറ്റവും ചെലവേറിയ രീതി, കാറ്റസ്ട്രോഫിക് ഫോർഗെറ്റിംഗിനുള്ള സാധ്യതയും ഇതിനാണ് ഏറ്റവും കൂടുതൽ. അതിനെ പിന്തുണയ്ക്കാനുള്ള ഡാറ്റയും കമ്പ്യൂട്ടിംഗ് ശേഷിയും ഉള്ളപ്പോൾ, വലിയ പെരുമാറ്റ മാറ്റങ്ങൾക്കായി മാത്രം ഇത് ഉപയോഗിക്കുക.

പാരാമീറ്റർ-എഫിഷ്യന്റ് ഫൈൻ-ട്യൂണിംഗ് അഥവാ PEFT ആണ് ഇതിനുള്ള ബദൽ. മോഡലിന്റെ ഭൂരിഭാഗവും ഫ്രീസ് ചെയ്ത്, ചെറിയൊരു കൂട്ടം പാരാമീറ്ററുകൾ മാത്രം ട്രെയിൻ ചെയ്യുന്ന രീതികളെ മൊത്തത്തിൽ സൂചിപ്പിക്കുന്ന പദമാണിത്. ബേസ് മോഡലിന് മാറ്റമൊന്നും സംഭവിക്കാത്തതിനാൽ, ഇതിന് വളരെ കുറച്ച് മെമ്മറി മതി, മറന്നുപോകാനുള്ള സാധ്യതയും കുറവാണ്.

കുറഞ്ഞ റാങ്കുകളിൽ, PEFT ഒരു ഫുൾ ഫൈൻ-ട്യൂണിനെക്കാൾ കുറച്ചേ പഠിക്കുന്നുള്ളൂ, എന്നാൽ റാങ്ക് ഉയർത്തുകയും ലേണിംഗ് റേറ്റ് ട്യൂൺ ചെയ്യുകയും ചെയ്യുന്നതിലൂടെ ഇൻസ്ട്രക്ഷൻ-ട്യൂണിംഗ് ടാസ്‌കുകളിലെ ഈ വിടവിന്റെ ഭൂരിഭാഗവും നികത്താനാകും.

PEFT രീതികളിൽ ഇവ ഉൾപ്പെടുന്നു:

• LoRA (Low-Rank Adaptation): സാധാരണ ആരംഭബിന്ദുവായ ഈ രീതി യഥാർത്ഥ വെയ്റ്റുകളെ ഫ്രീസ് ചെയ്യുകയും, കൂട്ടിച്ചേർത്ത ചെറിയൊരു കൂട്ടം അഡാപ്റ്റർ പാരാമീറ്ററുകൾ മാത്രം ട്രെയിൻ ചെയ്യുകയും ചെയ്യുന്നു; ഇവ പലപ്പോഴും ആകെയുള്ളതിന്റെ 1%-ത്തിൽ താഴെയായിരിക്കും, അതിനാൽ ഒരൊറ്റ കൺസ്യൂമർ GPU-വിൽ ഇത് റൺ ചെയ്യാനാകും.
• QLoRA (Quantized Low-Rank Adaptation): LoRA പ്രയോഗിക്കുന്നതിന് മുമ്പ് ഇത് ബേസ് മോഡലിനെ 4-ബിറ്റ് പ്രിസിഷനിലേക്ക് കംപ്രസ് ചെയ്യുന്നു; ഇതുവഴി ഒരു വലിയ മോഡലിനെ ഒരൊറ്റ GPU-വിൽ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ കഴിയും.

ഇവയ്ക്ക് പുറമെ, ഒരു മോഡൽ നിർദ്ദേശങ്ങൾ പിന്തുടരുന്ന രീതിയും മനുഷ്യരുടെ മുൻഗണനകളുമായി അത് എത്രത്തോളം പൊരുത്തപ്പെടുന്നു എന്നതും രൂപപ്പെടുത്താൻ, RLHF (Reinforcement Learning from Human Feedback) മുതൽ Direct Preference Optimization (DPO), Odds Ratio Preference Optimization (ORPO) പോലുള്ള, കുറഞ്ഞ റിസോഴ്‌സുകൾ മതിയാകുന്ന ബദലുകൾ വരെയുള്ള ഇൻസ്ട്രക്ഷൻ-ട്യൂണിംഗ്, പ്രിഫറൻസ്-ട്യൂണിംഗ് രീതികൾ ഞങ്ങൾ ഉപയോഗിക്കുന്നു.

ഒരു LLM ഘട്ടം ഘട്ടമായി എങ്ങനെ ഫൈൻ-ട്യൂൺ ചെയ്യാം

ഒരു LLM ഫൈൻ-ട്യൂൺ ചെയ്യുന്നതാണ് ശരിയായ തീരുമാനം എന്ന് നിങ്ങൾ ഉറപ്പിച്ചുകഴിഞ്ഞാൽ, പിന്തുടരേണ്ട വർക്ക്ഫ്ലോ ഇതാ.

വലുതാക്കുക

ഘട്ടം 1: ടാസ്‌ക് നിർവചിക്കുക, വിജയം എങ്ങനെ അളക്കുമെന്ന് തീരുമാനിക്കുക

LLM-ൽ നിന്ന് നിങ്ങൾക്ക് എന്ത് പെരുമാറ്റമാണ് വേണ്ടതെന്നും അത് ലഭിച്ചുവെന്ന് എങ്ങനെ തിരിച്ചറിയുമെന്നും തീരുമാനിക്കുക.

ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡൽ പൂർത്തിയാക്കേണ്ട നിർദ്ദിഷ്ട ജോലി വ്യക്തമാക്കുക; ഉദാഹരണത്തിന്, സപ്പോർട്ട് ടിക്കറ്റുകൾ തരംതിരിക്കുക, കരാറുകൾ ഒരു നിശ്ചിത ഫോർമാറ്റിൽ സംഗ്രഹിക്കുക, അല്ലെങ്കിൽ നിങ്ങളുടെ സ്ഥാപനത്തിന്റെ സ്വന്തം ശൈലിയിൽ കോഡ് ജനറേറ്റ് ചെയ്യുക.

തുടർന്ന് വിജയം നിർവചിക്കുക. സാധാരണ ഓപ്ഷനുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

• ഔട്ട്‌പുട്ടിന്റെ സാധുത: ഉദാഹരണത്തിന്, ഫലം സാധുവായ JSON ആയി പാഴ്സ് ചെയ്യുന്നുണ്ടോ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ആവശ്യമായ Markdown ഘടനയുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ?
• ഓട്ടോമേറ്റഡ് സ്കോറുകൾ: ജനറേറ്റ് ചെയ്ത ടെക്സ്റ്റിനെ റഫറൻസ് ഉത്തരങ്ങളുമായി താരതമ്യം ചെയ്യുന്ന BLEU അല്ലെങ്കിൽ ROUGE പോലുള്ള മെട്രിക്കുകൾ, അല്ലെങ്കിൽ ലേബൽ ചെയ്ത ഒരു സെറ്റിലെ ടാസ്‌ക് കൃത്യത ഉപയോഗിക്കുക.
• മനുഷ്യരുടെ റേറ്റിംഗുകൾ: ടോൺ, സഹായകത്വം എന്നിങ്ങനെ ഒരു സ്ക്രിപ്റ്റിന് നന്നായി സ്കോർ ചെയ്യാൻ കഴിയാത്ത ഗുണങ്ങൾക്കായി സ്കോർ നൽകുന്നതോ പാസ്/ഫെയിൽ രീതിയിലുള്ളതോ ആയ ഒരു റൂബ്രിക്.
• ബുദ്ധിമുട്ടുള്ള ഇൻപുട്ടുകളിലെ വിശ്വാസ്യത: ബേസ് മോഡലിനെ കുഴക്കിയ അസാധാരണ ഇൻപുട്ടുകൾ ഇത് കൈകാര്യം ചെയ്യുന്നുണ്ടോ?

ഘട്ടം 2: നിങ്ങളുടെ ഡാറ്റാസെറ്റ് തയ്യാറാക്കുക

ഡാറ്റയുടെ ഗുണനിലവാരമാണ് ഫൈൻ-ട്യൂണിന്റെ വിജയം നിർണ്ണയിക്കുന്നത്, അതിനാൽ ശരിയായ ഫൈൻ-ട്യൂണിംഗ് ഡാറ്റാസെറ്റ് ശേഖരിക്കുന്നതിൽ ശ്രദ്ധ ചെലുത്തുക.

നിങ്ങളുടെ ഡാറ്റ JSONL-ൽ ഇൻസ്ട്രക്ഷൻ/റെസ്‌പോൺസ് ജോഡികളായി ഫോർമാറ്റ് ചെയ്യുക; ഓരോ വരിയിലും ഇൻപുട്ടും (ഒപ്പം ആവശ്യമായ കോൺടെക്സ്റ്റും) നിങ്ങൾക്ക് തിരികെ ലഭിക്കേണ്ട കൃത്യമായ ഔട്ട്‌പുട്ടും ഉണ്ടായിരിക്കണം.

ഉദാഹരണത്തിന്, പൊതുവായ നിർദ്ദേശങ്ങൾക്കുള്ള Alpaca-cleaned ഡാറ്റാസെറ്റ് അല്ലെങ്കിൽ Databricks-ന്റെ Dolly പോലുള്ള പബ്ലിക് ഡാറ്റാസെറ്റുകൾ, അല്ലെങ്കിൽ 77 ഇന്റന്റുകളിലായി ലേബൽ ചെയ്ത 13,000-ത്തിലധികം യഥാർത്ഥ സപ്പോർട്ട് ചോദ്യങ്ങൾ ഉൾക്കൊള്ളുന്ന ടാസ്‌ക്-നിർദ്ദിഷ്ട banking77 പരിശോധിക്കുക.

ഒരു നിർദ്ദിഷ്ട ടാസ്‌കിന്, വൃത്തിയുള്ളതും വൈവിധ്യമാർന്നതുമായ ഏതാനും നൂറ് മുതൽ ഏതാനും ആയിരം വരെ ഉദാഹരണങ്ങൾക്ക് പെരുമാറ്റത്തിൽ മാറ്റം വരുത്താനാകും. അതിന്, എഡ്ജ് കേസുകൾ ഉൾപ്പെടെ യഥാർത്ഥ പ്രൊഡക്ഷൻ ഇൻപുട്ടുകളെ ഉദാഹരണങ്ങൾ പ്രതിഫലിപ്പിക്കുകയും അവ സ്ഥിരതയുള്ള ഫോർമാറ്റിൽ ആയിരിക്കുകയും വേണം.

ഇതുവരെ ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് ജോഡികൾ ഇല്ലേ? സപ്പോർട്ട് ടിക്കറ്റുകളും അവയ്ക്കുള്ള മികച്ച മറുപടികളും, അല്ലെങ്കിൽ ഡോക്യുമെന്റുകളും അവയുടെ സംഗ്രഹങ്ങളും പോലെ, നിങ്ങളുടെ കൈവശമുള്ള ഡാറ്റയിൽ നിന്ന് സെറ്റ് തയ്യാറാക്കുക.

നിങ്ങളുടെ പക്കൽ ഔട്ട്‌പുട്ടുകൾ മാത്രമേ ഉള്ളൂവെങ്കിൽ, ഓരോന്നിനും യുക്തിസഹമായ ഒരു ഇൻപുട്ട് ജനറേറ്റ് ചെയ്യാൻ കൂടുതൽ ശക്തമായ ഒരു മോഡൽ ഉപയോഗിക്കുക, അല്ലെങ്കിൽ ചെറിയൊരു സീഡ് സെറ്റ് സ്വന്തമായി എഴുതി, വലിയൊരു "ടീച്ചർ" മോഡൽ ഉപയോഗിച്ച് അത് വിപുലീകരിക്കുക; തുടർന്ന് ഏറ്റവും മികച്ച ജോഡികൾ മാത്രം നിലനിർത്തുക.

അവസാനമായി, മോഡൽ ഇതുവരെ കണ്ടിട്ടില്ലാത്ത ഉദാഹരണങ്ങളിൽ അളക്കാൻ കഴിയുന്നതിനായി ഡാറ്റയെ ട്രെയിനിംഗ്, വാലിഡേഷൻ, ടെസ്റ്റ് സെറ്റുകളായി വിഭജിക്കുക.

ഘട്ടം 3: ഒരു ബേസ് മോഡലും രീതിയും തിരഞ്ഞെടുക്കുക

3 മുതൽ 7 ബില്യൺ വരെ പാരാമീറ്ററുകളുള്ള ഒരു ചെറിയ ഓപ്പൺ സോഴ്‌സ് മോഡലും, LoRA അല്ലെങ്കിൽ QLoRA പോലുള്ള ഒരു പാരാമീറ്റർ-എഫിഷ്യന്റ് ഫൈൻ-ട്യൂണിംഗ് രീതിയും ഉപയോഗിച്ച് ആരംഭിക്കുക.

Llama, Mistral, Qwen പോലുള്ള ഓപ്പൺ മോഡൽ ഫാമിലികൾ നിങ്ങൾക്ക് സ്വയം ഹോസ്റ്റ് ചെയ്യാവുന്ന ശക്തമായ ഒരു ബേസ് നൽകുന്നു, PEFT രീതികൾ ഹാർഡ്‌വെയർ ആവശ്യകതകൾ കുറച്ചുനിർത്തുകയും ചെയ്യുന്നു: QLoRA ബേസിനെ 4-ബിറ്റിലേക്ക് ക്വാണ്ടൈസ് ചെയ്യുന്നതിനാൽ, ഒരു 7B മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ 16-24GB കൺസ്യൂമർ കാർഡ് മാത്രം മതി. അതേ മോഡലിന്റെ ഫുൾ ഫൈൻ-ട്യൂണിംഗിന് അതിന്റെ പലമടങ്ങ് മെമ്മറി ആവശ്യമാണ്.

ഘട്ടം 4: നിങ്ങളുടെ ട്രെയിനിംഗ് ഹൈപ്പർപാരാമീറ്ററുകൾ സജ്ജമാക്കുക

പ്രധാന LLM ഫൈൻ-ട്യൂണിംഗ് പാരാമീറ്ററുകളും നിർദ്ദേശിക്കപ്പെടുന്ന പ്രാരംഭ ശ്രേണികളും ഇതാ:

• ലേണിംഗ് റേറ്റ് വെയ്റ്റുകളിലേക്കുള്ള ഓരോ അപ്ഡേറ്റും എത്ര വലുതാണെന്ന് നിയന്ത്രിക്കുന്നു. LoRA-യ്ക്ക് ഏറ്റവും അനുയോജ്യമായ റേറ്റുകൾ ഫുൾ ഫൈൻ-ട്യൂണിംഗിന്റേതിനെക്കാൾ ഏകദേശം പത്തിരട്ടി ഉയർന്നതാണെന്ന് Biderman et al. നടത്തിയ 2024-ലെ ഒരു പഠനം കണ്ടെത്തി; സാധാരണയായി LoRA-യ്ക്ക് 5e-5 മുതൽ 5e-4 വരെയും ഫുൾ ഫൈൻ-ട്യൂണിംഗിന് 1e-5 മുതൽ 5e-5 വരെയും. 1e-5 മുതൽ 5e-4 വരെ സ്വീപ്പ് ചെയ്യാനും സ്ഥിരതയോടെ ട്രെയിൻ ചെയ്യുന്ന ഏറ്റവും ഉയർന്ന മൂല്യം ഉപയോഗിക്കാനുമാണ് പഠനം നിർദ്ദേശിക്കുന്നത്.
• ബാച്ച് സൈസ് എന്നത് ഓരോ വെയ്റ്റ് അപ്‌ഡേറ്റിനും മുമ്പ് മോഡൽ എത്ര ഉദാഹരണങ്ങളിൽ നിന്ന് പഠിക്കുന്നു എന്നതാണ്. ഒരൊറ്റ GPU-വിൽ, 1 മുതൽ 8 വരെയുള്ള ചെറിയ പെർ-ഡിവൈസ് ബാച്ച് ഉപയോഗിക്കുക, ഏകദേശം 16 മുതൽ 64 വരെയുള്ള എഫക്റ്റീവ് ബാച്ചിലെത്താൻ ഗ്രേഡിയന്റ് അക്യുമുലേഷനും പ്രയോജനപ്പെടുത്തുക.
• എപ്പോക്കുകളുടെ എണ്ണം എന്നത് മോഡൽ മുഴുവൻ ഡാറ്റാസെറ്റും എത്ര തവണ കാണുന്നു എന്നതാണ്. നിർദ്ദിഷ്ട ടാസ്കുകൾ ചെയ്യാൻ മോഡലിനെ പരിശീലിപ്പിക്കുമ്പോൾ 1-3 എന്നത് നല്ലൊരു പൊതുനിയമമാണ്, എന്നാൽ LoRA റണ്ണുകൾക്ക് പലപ്പോഴും കൂടുതൽ വേണ്ടിവരും.
• LoRA റാങ്ക് (r) അഡാപ്റ്ററിന്റെ ശേഷി, അതായത് അതിന് എത്രത്തോളം പഠിക്കാനാകും എന്നത് നിശ്ചയിക്കുന്നു. ലളിതമായ ടാസ്കുകൾക്ക് 8 മുതൽ 32 വരെ എന്ന നിലയിൽ ആരംഭിച്ച്, കൂടുതൽ കഠിനമായവയ്ക്ക് അത് ഉയർത്തുക: മുകളിൽ ഉദ്ധരിച്ച Biderman et al. LoRA പഠനത്തിൽ, കോഡിനായി ഒരു 7B മോഡലിനെ ഇൻസ്ട്രക്ഷൻ-ട്യൂൺ ചെയ്തപ്പോൾ ഫുൾ ഫൈൻ-ട്യൂണിംഗിനൊപ്പമെത്താൻ റാങ്ക് 256 വേണ്ടിവന്നു, അതേസമയം ഗണിതത്തിൽ റാങ്ക് 64 അതിനോട് അടുത്തെത്തി.
• പരമാവധി സീക്വൻസ് ദൈർഘ്യം എന്നത് റൺ പ്രോസസ്സ് ചെയ്യുന്ന ഏറ്റവും നീളമേറിയ ഇൻപുട്ടാണ്. മോഡലിന്റെ കോൺടെക്സ്റ്റ് വിൻഡോയുടെ പരിധി വരെ, നിങ്ങളുടെ ഏറ്റവും നീളമേറിയ ഉദാഹരണങ്ങളെ ഉൾക്കൊള്ളുന്ന തരത്തിൽ ഇത് സജ്ജമാക്കുക, കാരണം അതിലും നീളമുള്ളതെന്തും ട്രങ്കേറ്റ് ചെയ്യപ്പെടും.
• വാംഅപ്പും ഷെഡ്യൂളും റണ്ണിലുടനീളം ലേണിംഗ് റേറ്റ് എങ്ങനെ ഉയരുന്നുവെന്നും മാറുന്നുവെന്നും നിയന്ത്രിക്കുന്നു. ചെറിയൊരു വാംഅപ്പും കോസൈൻ ഡീകേയുമാണ് സാധാരണ ഡിഫോൾട്ടുകൾ. എന്നിരുന്നാലും, വാംഅപ്പ് ഒഴിവാക്കിയത് അന്തിമ സ്കോറുകളെ ദോഷകരമായി ബാധിച്ചില്ലെന്ന് Pareja et al. നടത്തിയ ചെറു-മോഡൽ പഠനം കണ്ടെത്തി.

ഇവയെ സ്ഥിരമായ ക്രമീകരണങ്ങളായല്ല, ഒരു സ്വീപ്പിനുള്ള ആരംഭ പോയിന്റുകളായി കാണുക.

ഘട്ടം 5: പരിശീലിപ്പിക്കുക, ലോസ് നിരീക്ഷിക്കുക

പരിശീലനം നടക്കുമ്പോൾ, അത് ഫലപ്രദമാണോ എന്നറിയാൻ ട്രെയിനിംഗ്, വാലിഡേഷൻ ലോസ് കർവുകൾ നിരീക്ഷിക്കുക.

മോഡലിന്റെ ഔട്ട്‌പുട്ടുകൾ നിങ്ങളുടെ ഉദാഹരണങ്ങളിൽ നിന്ന് എത്രത്തോളം അകലെയാണെന്ന് ലോസ് അളക്കുന്നു, റൺ പുരോഗമിക്കുന്നതിനനുസരിച്ച് അത് സുഗമമായി കുറയണം. മോഡൽ പഠിക്കുന്ന ഡാറ്റയെയാണ് ട്രെയിനിംഗ് ലോസ് ഉൾക്കൊള്ളുന്നത്. വാലിഡേഷൻ ലോസ് മാറ്റിവെച്ച (held-out) ഉദാഹരണങ്ങളിലാണ് അളക്കുന്നത്.

ട്രെയിനിംഗ് ലോസും വാലിഡേഷൻ ലോസും ഒരുമിച്ച് കുറയുന്നുവെങ്കിൽ, മോഡൽ സാമാന്യവൽക്കരിക്കാൻ (generalize) പഠിക്കുകയാണ്. ട്രെയിനിംഗ് ലോസ് കുറഞ്ഞുകൊണ്ടേയിരിക്കുകയും എന്നാൽ വാലിഡേഷൻ ലോസ് മാറ്റമില്ലാതെ നിൽക്കുകയോ ഉയരുകയോ ചെയ്യുന്നുവെങ്കിൽ, മോഡൽ പാറ്റേൺ പഠിക്കുന്നതിനു പകരം ട്രെയിനിംഗ് സെറ്റ് മനഃപാഠമാക്കുകയാണ് (ഓവർഫിറ്റിംഗ്).

വലുതാക്കുക

ഘട്ടം 6: വിലയിരുത്തുക, തുടർന്ന് ഡിപ്ലോയ് ചെയ്യുക

കുറഞ്ഞ ട്രെയിനിംഗ് ലോസ് ശരിയായ ഔട്ട്‌പുട്ടുകൾ ഉറപ്പുനൽകുന്നില്ല, അതിനാൽ ഘട്ടം 1-ൽ നിങ്ങൾ നിശ്ചയിച്ച മാനദണ്ഡങ്ങളുടെ അടിസ്ഥാനത്തിൽ ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡലിനെ വിലയിരുത്തുക.

മോഡൽ അതിൽ വിജയിച്ചാൽ, ഡിപ്ലോയ് ചെയ്യാൻ നിങ്ങൾക്ക് രണ്ട് വഴികളുണ്ട്:

• ബേസ് മോഡലിന് മുകളിൽ അഡാപ്റ്റർ സെർവ് ചെയ്യുകയും റൺടൈമിൽ രണ്ടും ലോഡ് ചെയ്യുകയും ചെയ്യുക; ഇത് അഡാപ്റ്റർ മാറ്റിസ്ഥാപിക്കാവുന്ന നിലയിൽ നിലനിർത്തുന്നു.
• ഹോസ്റ്റ് ചെയ്യാൻ കൂടുതൽ എളുപ്പമുള്ള ഒരൊറ്റ സ്റ്റാൻഡ്എലോൺ മോഡൽ ലഭിക്കാൻ അഡാപ്റ്ററിനെ ബേസ് വെയ്റ്റുകളിലേക്ക് മെർജ് ചെയ്യുക.

നിങ്ങളുടെ LLM-ന് ഏറ്റവും പുതിയ വിവരങ്ങൾ ലഭ്യമാക്കാൻ Perplexity ഉപയോഗിക്കുക

മോഡലിന്റെ പെരുമാറ്റം നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് ക്രമീകരിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ ഫൈൻ-ട്യൂണിംഗ് ആണ് ശരിയായ തിരഞ്ഞെടുപ്പ്.

നിങ്ങളുടെ മോഡലിന് നിലവിലെ വിവരങ്ങൾ, പ്രത്യേകിച്ച് വേഗത്തിൽ മാറുന്ന വിവരങ്ങൾ, ആവശ്യമാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു RAG അല്ലെങ്കിൽ വിശ്വസനീയമായ ഒരു തേർഡ്-പാർട്ടി സെർച്ച് ടൂൾ ആവശ്യമാണ്.

നിങ്ങളുടെ ഇന്റേണൽ വിക്കി, കസ്റ്റമർ സപ്പോർട്ട് ചരിത്രം, കരാറുകൾ, അല്ലെങ്കിൽ പ്രോഡക്റ്റ് ഡോക്യുമെന്റുകൾ പോലുള്ള പ്രൊപ്രൈറ്ററി ഡാറ്റാസെറ്റുകൾക്ക് ഒരു കസ്റ്റം റിട്രീവൽ സ്റ്റാക്കാണ് ഏറ്റവും അനുയോജ്യം.

നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന അറിവ് പൊതുവായി ലഭ്യമാണെങ്കിൽ, പ്രത്യേകമായി രൂപകൽപ്പന ചെയ്ത ഒരു റിട്രീവൽ ലെയർ നിർമ്മിക്കേണ്ട ആവശ്യമില്ല. ലൈവ് വെബ് ഇൻഡെക്സിൽ നിന്നുള്ള, ക്ലിക്ക് ചെയ്യാവുന്ന ഇൻലൈൻ സൈറ്റേഷനുകളോടെ പ്രതികരണങ്ങൾ നൽകുന്ന ഒരു ആൻസർ എഞ്ചിനാണ് Perplexity. അതിന്റെ Agent API വെബ് അധിഷ്ഠിതവും ഉറവിടങ്ങൾ ഉദ്ധരിച്ചതുമായ ആ ഉത്തരങ്ങൾ ഒരൊറ്റ കോളിൽ നൽകുന്നു, അതിനാൽ നിങ്ങളുടെ ആപ്പിന് നിലവിലെ ഉറവിടങ്ങൾ പ്രയോജനപ്പെടുത്താനാകും.

LLM ഫൈൻ-ട്യൂണിംഗിനെക്കുറിച്ച് പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

ഒരു LLM സൗജന്യമായി ഫൈൻ-ട്യൂൺ ചെയ്യാൻ കഴിയുമോ?

അതെ, ഒരു ചെറിയ ഓപ്പൺ LLM നിങ്ങൾക്ക് സൗജന്യമായി ഫൈൻ-ട്യൂൺ ചെയ്യാം. ഉദാഹരണത്തിന്, Google Colab-ന്റെ സൗജന്യ ടയർ ഒരു 3B മുതൽ 8B വരെയുള്ള മോഡലിൽ QLoRA പ്രവർത്തിപ്പിക്കാൻ ആവശ്യമായ GPU നൽകുന്നു, ഒരു നിർദ്ദിഷ്ട ടാസ്കിന് അത് ധാരാളം മതി. സൗജന്യ ടയറിന് ഉൾക്കൊള്ളാനാകുന്നതിലും കൂടുതൽ മെമ്മറിയോ ദൈർഘ്യമേറിയ റണ്ണുകളോ വലിയ ബേസ് മോഡലോ ആവശ്യമായി വരുമ്പോഴാണ് നിങ്ങൾ പണം നൽകിത്തുടങ്ങേണ്ടിവരുന്നത്.

നിങ്ങൾക്ക് സ്വന്തമായി GPU വേണോ, അതോ ക്ലൗഡിൽ ഫൈൻ-ട്യൂൺ ചെയ്യാമോ?

LLM-കൾ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ നിങ്ങൾക്ക് സ്വന്തമായി GPU ഉണ്ടാകണമെന്നില്ല. മാനേജ്ഡ് സേവനങ്ങളും GPU ക്ലൗഡ് പ്രൊവൈഡർമാരും മണിക്കൂർ അടിസ്ഥാനത്തിൽ ഹാർഡ്‌വെയർ വാടകയ്ക്ക് നൽകുന്നു, അതിനാൽ ഒരു ചെറിയ മോഡലിന്റെ QLoRA റണ്ണിന് വാടകയ്‌ക്കെടുത്ത ഒരൊറ്റ GPU മതിയാകും. നിങ്ങൾ പതിവായി ഫൈൻ-ട്യൂൺ ചെയ്യുന്നുണ്ടെങ്കിലോ നിങ്ങളുടെ എല്ലാ ഡാറ്റയും സ്വന്തം മെഷീനുകളിൽ തന്നെ സൂക്ഷിക്കേണ്ടതുണ്ടെങ്കിലോ മാത്രമേ ഒരു GPU വാങ്ങുന്നത് ലാഭകരമാകൂ.

LLM-കൾ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ എത്ര സമയമെടുക്കും?

ഒരു ചെറിയ LLM-ന്, ഡാറ്റാസെറ്റിന്റെ വലുപ്പവും ഹാർഡ്‌വെയറും അനുസരിച്ച്, ഒരു റൺ ഏതാനും മിനിറ്റുകൾ മുതൽ കുറച്ച് മണിക്കൂറുകൾക്കുള്ളിൽ പൂർത്തിയാകാം. ഉദാഹരണത്തിന്, Oumi അതിന്റെ ഹോസ്റ്റഡ് പ്ലാറ്റ്‌ഫോമിൽ ഒരു 0.8B മോഡൽ ഒരു മണിക്കൂറിൽ അൽപ്പം കൂടുതൽ സമയംകൊണ്ട് പൂർണ്ണമായി ഫൈൻ-ട്യൂൺ ചെയ്തു.

വലിയ മോഡലുകളോ പതിനായിരക്കണക്കിന് ഉദാഹരണങ്ങളോ ആണെങ്കിൽ ഇത് ഒരു ദിവസമോ അതിലധികമോ ആയി നീളും: ഒരൊറ്റ 40GB GPU-വിൽ, ഒരു 7B മോഡലിലെ Emburse-ന്റെ LoRA റണ്ണുകൾക്ക് 5,000 ഉദാഹരണങ്ങൾക്ക് 8 മണിക്കൂറും 50,000 ഉദാഹരണങ്ങൾക്ക് ഏകദേശം 30 മണിക്കൂറും എടുത്തു.

നിങ്ങളുടെ ഡാറ്റ മാറുന്നതിനനുസരിച്ച് ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡൽ തുടർച്ചയായി അപ്‌ഡേറ്റ് ചെയ്യാൻ കഴിയുമോ?

പുതിയ ഡാറ്റയിൽ നിങ്ങൾക്ക് വീണ്ടും ഫൈൻ-ട്യൂൺ ചെയ്യാം, എന്നാൽ ഓരോ റൗണ്ടിനും കമ്പ്യൂട്ട് ചെലവാകുകയും കാറ്റസ്ട്രോഫിക് ഫോർഗെറ്റിംഗിന് സാധ്യതയുണ്ടാകുകയും ചെയ്യും. പതിവായി മാറുന്ന അറിവിന് RAG ആണ് സാധാരണയായി മികച്ച പരിഹാരം, കാരണം വീണ്ടും പരിശീലിപ്പിക്കുന്നതിനു പകരം നിങ്ങൾ സോഴ്സ് ഡോക്യുമെന്റുകൾ അപ്‌ഡേറ്റ് ചെയ്താൽ മതി.