What is Unsloth, in simple terms?

Unsloth is a library that makes fine-tuning large language models faster and less memory-hungry. It focuses on QLoRA and other efficiency tricks so you can train useful models on a single 24GB GPU without losing quality.

Is Unsloth better than standard PEFT for QLoRA?

For many real-world tasks, yes—Unsloth typically delivers faster training and lower VRAM while maintaining accuracy. You still use familiar patterns, but you’ll get more experiments done in the same time.

Can I use Unsloth to fine-tune a 70B model on one GPU?

You can often make it work with careful settings, but it won’t be effortless. Unsloth helps with speed and VRAM, yet big models still demand patience and careful batch sizes, sequence lengths, and quantization.

Does Unsloth hurt model quality compared to full-precision finetuning?

With good datasets and QLoRA, most users see similar quality for common tasks like instruction following or summarization. For highly specialized or knowledge-heavy changes, full-precision finetuning may still outperform.

How does [Sider.AI](https://sider.ai) help if it’s not a training tool?

Use [Sider.AI](https://sider.ai) to gather and refine your training data: summarize docs, generate prompts, and draft diverse examples. Better data makes Unsloth shine—think of [Sider.AI](https://sider.ai) as the prep cook that speeds up your kitchen.

Unsloth റിവ്യൂ: വലിയ AI-കളെ (വലിയ GPU ഇല്ലാതെ തന്നെ) അതിവേഗം ഫൈൻ-ട്യൂൺ ചെയ്യാനുള്ള വഴി

ഒരു സാധാരണ GPU-ൽ ഒരു വിവാഹ കേക്ക് ഉണ്ടാക്കാൻ ശ്രമിച്ചിട്ടുണ്ടോ? വലിയ ഭാഷാ മോഡലിനെ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നത് ഏതാണ്ട് അതുപോലെയാണ്. ഡാറ്റ ലോഡ് ചെയ്യുന്നു, ഓവൻ ഓൺ ചെയ്യുന്നു, എന്നിട്ട്... കാത്തിരിക്കുന്നു. ഫാൻ ഒച്ചയുണ്ടാക്കുന്നു. കാപ്പി തണുക്കുന്നു. വാരാന്ത്യം നഷ്ട്ടപ്പെടുന്നു. Unsloth-ലേക്ക് വരൂ, ഇതൊരു ഓപ്പൺ സോഴ്‌സ് ലൈബ്രറിയാണ്. ഇത് അടിസ്ഥാനപരമായി പറയുന്നത്, “ടോസ്റ്റർ ഓവനിൽ ടർബോ മോഡ് ഉണ്ടായിരുന്നെങ്കിലോ?” എന്നാണ്. ഈ Unsloth അവലോകനത്തിൽ, അതെന്താണെന്നും, എന്താണ് ചെയ്യുന്നതെന്നും, എങ്ങനെയാണ് സമയം ലാഭിക്കുന്നതെന്നും, VRAM എങ്ങനെ ലാഭിക്കാം എന്നും, എവിടെയാണ് പ്രശ്നങ്ങളുള്ളതെന്നും ഞാൻ നിങ്ങളോട് പറയാം.

എന്താണ് Unsloth, എന്തുകൊണ്ടാണ് ആളുകൾ ഇതിനെക്കുറിച്ച് പറയുന്നത്? Unsloth എന്നത് വലിയ ഭാഷാ മോഡലുകളെ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നതിനുള്ള ഒരു Python ലൈബ്രറിയാണ്—Llama, Mistral തുടങ്ങിയവയെക്കുറിച്ച് ചിന്തിക്കുക—വേഗതയും മെമ്മറി കാര്യക്ഷമതയും ഉറപ്പാക്കുക എന്നതാണ് ഇതിന്റെ ലക്ഷ്യം. ഇതിന്റെ പ്രധാന ആശയം ഇത്രയേയുള്ളൂ: ഗുണനിലവാരം അതുപോലെ നിലനിർത്തുകയും, കൂടുതൽ വേഗത്തിൽ പരിശീലനം നൽകുകയും, കുറഞ്ഞ VRAM ഉപയോഗിക്കുകയും ചെയ്യുക. LoRA അല്ലെങ്കിൽ QLoRA എന്നിവയുമായി മല്ലിട്ടിട്ടുണ്ടെങ്കിൽ, ഇതിന്റെ ബുദ്ധിമുട്ട് നിങ്ങൾക്കറിയാം: ഒരു 24GB കാർഡിൽ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ കഴിയും, പക്ഷേ അത് വളരെ ബുദ്ധിമുട്ടാണ്, കൂടാതെ അത്ര എളുപ്പവുമല്ല. Unsloth ഉപയോഗിക്കുന്ന തന്ത്രം എന്നത് എഞ്ചിനീയറിംഗ് ട്വീക്കുകളുടെ ഒരു ശേഖരമാണ്—ഇഷ്‌ടാനുസൃത കേർണലുകൾ, ഒപ്റ്റിമൈസർ ചോയ്‌സുകൾ, ക്വാಂಟൈസേഷൻ സ്മാർട്ട്‌സ്, കൂടാതെ മികച്ച മെമ്മറി പ്ലംബിംഗ്—അതുകൊണ്ട് ഒരേ സമയം കൂടുതൽ കാര്യങ്ങൾ പരിശീലിപ്പിക്കാൻ കഴിയും (അല്ലെങ്കിൽ കുറഞ്ഞ സമയം കൊണ്ട്).

Unsloth നിങ്ങളുടെ സാധാരണ രീതിക്ക് പകരമാണോ? കൃത്യമായി പറഞ്ഞാൽ അല്ല. നിങ്ങൾ Hugging Face Transformers, PEFT, bitsandbytes എന്നിവ ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങളുടെ ചാർജിംഗ് കേബിളുകൾ നിങ്ങളെ ആക്രമിക്കാൻ വരുമ്പോൾ വാങ്ങുന്ന ഒരു plug-in organizer പോലെയാണ് Unsloth. നിങ്ങൾ ഇപ്പോഴും പരിചിതമായ രീതികൾ ഉപയോഗിക്കുന്നു (datasets, training loops), പക്ഷേ VRAM കൈകാര്യം ചെയ്യൽ, വേഗത ക്രമീകരിക്കൽ പോലുള്ള കാര്യങ്ങൾ സ്വയമേവ മെച്ചപ്പെടുത്തുന്നു.

Unsloth ആർക്കുവേണ്ടിയുള്ളതാണ്?

24GB GPU-യും ഒരു സ്വപ്നവുമുള്ള ആളുകൾക്ക്.

CFO-യുടെയും ഒരു വേദന സംഹാരിയുടെയും ആവശ്യമില്ലാതെ തന്നെ മോഡലുകൾ വേഗത്തിൽ പുറത്തിറക്കാൻ ആഗ്രഹിക്കുന്ന ചെറിയ ടീമുകൾക്ക്.

VRAM പൊട്ടിത്തെറിക്കാതെ QLoRA കൂടുതൽ മുന്നോട്ട് കൊണ്ടുപോകാൻ ആഗ്രഹിക്കുന്നവർക്ക്.

ഏറ്റവും മികച്ച മെഷീൻ പ്രൊഫസറുടെ ഗെയിമിംഗ് ലാപ്ടോപ്പ് മാത്രമായ ക്ലാസ് റൂമിൽ ഫൈൻ-ട്യൂണിംഗ് കാണിക്കാൻ ആഗ്രഹിക്കുന്ന അധ്യാപകർക്കും വിദ്യാർത്ഥികൾക്കും.

Unsloth ഉപയോഗിച്ച് ഫൈൻ-ട്യൂണിംഗ് എങ്ങനെ ചെയ്യാമെന്ന് നോക്കാം:

നിങ്ങൾ ഒരു അടിസ്ഥാന മോഡൽ തിരഞ്ഞെടുക്കുക (Llama 3 അല്ലെങ്കിൽ Mistral എന്ന് കരുതുക), ക്വാಂಟൈസേഷൻ തിരഞ്ഞെടുക്കുക (4-bit QLoRA ആണ് കൂടുതൽ ആളുകൾക്കും ഇഷ്ട്ടം), നിങ്ങളുടെ ഡാറ്റാ സെറ്റ് തിരഞ്ഞെടുക്കുക.

പരിശീലന സ്ക്രിപ്റ്റിൽ Unsloth ബിറ്റുകൾ പ്രവർത്തനക്ഷമമാക്കുക—സാധാരണയായി കുറച്ച് ഇമ്പോർട്ടുകളും ഫ്ലാഗുകളും ഉണ്ടാകും.

Train ക്ലിക്ക് ചെയ്യുക, നിങ്ങളുടെ GPU ശരിയായി ഉപയോഗിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക. ഉയർന്ന throughput, കുറഞ്ഞ VRAM spikes, കൂടാതെ “CUDA out of memory” പോലുള്ള പ്രശ്നങ്ങൾ കുറയുന്നത് കാണാം.

CPU/Ollama-യ്‌ക്കായി GGUF അല്ലെങ്കിൽ GPU-കൾക്കായി സാധാരണ safetensors പോലുള്ള ഫോർമാറ്റുകളിലേക്ക് ഫലമായുണ്ടാകുന്ന മോഡൽ എക്‌സ്‌പോർട്ട് ചെയ്യുക.

അത് ഉപയോഗിക്കുക. സന്തോഷിക്കുക. ഒന്നു കറങ്ങി വരിക.

ഇതൊരു സാധാരണ ഡെവലപ്പർ സ്റ്റോറിയാണ്. എന്നാൽ ബാക്കിയുള്ളവർക്ക്: വേഗത്തിൽ എന്ന് പറഞ്ഞാൽ ശരിക്കും എന്താണ് അർത്ഥം? സാധാരണയായി, നിങ്ങളുടെ ഫൈൻ-ട്യൂണിന് എട്ട് മണിക്കൂർ എടുത്തിട്ടുണ്ടെങ്കിൽ, Unsloth-ന്റെ ഒപ്റ്റിമൈസേഷനുകൾക്ക് അത് നാല് മണിക്കൂറിനടുത്താക്കാൻ കഴിയും, ഇത് മോഡൽ, ഹൈപ്പർപാരാമീറ്ററുകൾ, ഹാർഡ്‌വെയർ എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു. വേഗത്തിലുള്ള എപ്പോക്കുകൾ, കുറഞ്ഞ റീസ്റ്റാർട്ടുകൾ, VRAM കുറവുള്ള സ്ഥിരമായ പരിശീലനം എന്നിവ ലാഭിക്കാൻ സഹായിക്കുന്നു. ഇതൊരു ടെലിപോർട്ടേഷൻ ഉപകരണമല്ല—ആർക്കും ഒരു 70B മോഡലിനെ രണ്ട് മിനിറ്റിനുള്ളിൽ ചെയ്യാൻ കഴിയില്ല. എന്നാൽ നിങ്ങൾ ഒരു പുരോഗതി ബാറിലേക്ക് നോക്കി ഇരിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഇതിലെ വ്യത്യാസം മനസ്സിലാകും.

എങ്ങനെയാണ് വേഗത കൂട്ടുന്നത് (PhD ഇല്ലാതെ)

കൃത്യമായ മെമ്മറി ഉപയോഗം: എല്ലാം ഒരുപോലെ ഇടുന്നതിനുപകരം കംപ്രഷൻ ക്യൂബുകൾ ഉപയോഗിച്ച് ഒരു യാത്രയ്ക്ക് പാക്ക് ചെയ്യുന്നതിനെക്കുറിച്ച് ചിന്തിക്കുക. നിങ്ങൾ ഇപ്പോഴും പഴയ വസ്ത്രങ്ങൾ തന്നെ കൊണ്ടുപോകുന്നു, പക്ഷേ സ്യൂട്ട്കേസ് അടയ്ക്കാൻ സാധിക്കും.

ക്വാಂಟൈസേഷൻ ബാലൻസ്: QLoRA മിക്ക വെയിറ്റുകൾക്കും 4-ബിറ്റ് പ്രാതിനിധ്യങ്ങൾ ഉപയോഗിക്കുന്നു, ഇത് VRAM-നെ ഒരുപാട് കുറയ്ക്കുന്നു. Unsloth കൃത്യത കുറയ്ക്കാതെ അതിലേക്ക് കൂടുതൽ ശ്രദ്ധിക്കുന്നു (കൂടാതെ മറ്റ് തന്ത്രങ്ങളും ഉപയോഗിക്കുന്നു).

Kernel wizardry: ഇതിന്റെയെല്ലാം പിന്നിൽ, ഇഷ്ടമുള്ള GPU കേർണലുകൾ സാധാരണ പരിശീലനത്തിന്റെ വേഗത വർദ്ധിപ്പിക്കുന്നു. നിങ്ങൾക്ക്, അതിനർത്ഥം കുറഞ്ഞ കാത്തിരിപ്പ് സമയം എന്നാണ്.

Lightweight adapters: LoRA ചെറുതും പരിശീലനം നൽകാൻ സാധിക്കുന്നതുമായ “adapters” മാത്രമേ ഉപയോഗിക്കുന്നുള്ളു, വലിയ മോഡൽ മുഴുവനായി ഉപയോഗിക്കുന്നില്ല. നിങ്ങൾ വ്യക്തിത്വത്തെ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നു, DNA-യെ അല്ല.

ഗുണനിലവാരവും കൃത്യതയും: പ്രധാന പ്രശ്നം ഇവിടെയാണ് സംശയം വരുന്നത്. ആരെങ്കിലും “അതേ ഗുണനിലവാരം, വേഗത്തിൽ” എന്ന് വാഗ്ദാനം ചെയ്യുമ്പോൾ, ഞാൻ ശ്രദ്ധിക്കാൻ തുടങ്ങും. QLoRA-യും മികച്ച ഡാറ്റാ സെറ്റുകളും ഉപയോഗിച്ച്, മിക്ക ആപ്ലിക്കേഷനുകളിലും നിങ്ങൾക്ക് മികച്ച ഫലം നേടാൻ കഴിയും: നിർദ്ദേശങ്ങൾ പാലിക്കുക, സംഗ്രഹിക്കുക, ഉപഭോക്തൃ പിന്തുണയുടെ ശൈലി മെച്ചപ്പെടുത്തുക, ഡൊമെയ്ൻ അഡാപ്റ്റേഷൻ. നിങ്ങളുടെ ഉപയോഗം “ഒരു പിക്സലിൽ നിന്ന് ടാർഡിഗ്രേഡിന്റെ ജീവിത കഥ കണ്ടെത്തുക” എന്നതാണെങ്കിൽ, ഫൈൻ-ട്യൂണിംഗ് കുറുക്കുവഴികൾ നിങ്ങളെ സഹായിക്കില്ല. എന്നാൽ നിങ്ങൾ സാധാരണ ഭാഷാ കസ്റ്റമൈസേഷനാണ് ചെയ്യുന്നതെങ്കിൽ, Unsloth നിങ്ങളുടെ സമയം ലാഭിക്കുകയും, VRAM ലാഭിക്കുകയും ചെയ്യുമ്പോൾ തന്നെ മികച്ച പ്രകടനം നൽകുന്നു.

ഏറ്റവും മികച്ച കാര്യങ്ങൾ

വലിയ മോഡലുകളെ ചെറിയ ഹാർഡ്‌വെയറിലേക്ക് മാറ്റുന്നു. സാധാരണയായി ക്ലൗഡ് റെന്റലുകളും പ്രാർത്ഥനയും ആവശ്യമായിരുന്ന പരിശീലനത്തിന് ഒരു 24GB കാർഡ് മതിയാകും.

വേഗത്തിൽ ആവർത്തിക്കാൻ സാധിക്കുന്നു. നിങ്ങൾക്ക് ഒരേ ദിവസം തന്നെ കൂടുതൽ റണ്ണുകൾ, പ്രോംപ്റ്റുകൾ, ഡാറ്റാ സെറ്റുകൾ എന്നിവ പരീക്ഷിക്കാൻ കഴിയും. ഇത് സാധാരണയായി മികച്ച ഫലങ്ങളിലേക്ക് നയിക്കുന്നു—കാരണം നിങ്ങൾ കൂടുതൽ പരീക്ഷണങ്ങൾ നടത്തുന്നു.

ക്ലാസ് റൂം, വർക്ക്‌ഷോപ്പ് ഡെമോകൾ എന്നിവ എളുപ്പമാക്കുന്നു. സൂപ്പർ കമ്പ്യൂട്ടർ ഹാർഡ്‌വെയർ ഇല്ലാതെ തന്നെ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നത് അത്ഭുതകരമാണ്.

പ്രായോഗികമായ, ഇടത്തരം മോഡലുകൾ വേഗത്തിൽ പുറത്തിറക്കാൻ സഹായിക്കുന്നു. നിങ്ങളുടെ ഉൽപ്പന്നത്തിന് നിങ്ങളുടെ ബ്രാൻഡ് ടോണിന് അനുയോജ്യമായ ഒരു ചാറ്റ് അസിസ്റ്റന്റ് വേണമെങ്കിൽ, അല്ലെങ്കിൽ നിങ്ങളുടെ റെപ്പോകൾക്ക് അനുയോജ്യമായ ഒരു കോഡ് സഹായി വേണമെങ്കിൽ, Unsloth നിങ്ങളെ വേഗത്തിൽ അവിടെയെത്താൻ സഹായിക്കുന്നു.

എവിടെയാണ് ഇത് മാജിക് അല്ലാത്തത്

വളരെ വലിയ മോഡലുകൾ ഇപ്പോളും ബുദ്ധിമുട്ടുണ്ടാക്കുന്നു. നിങ്ങൾ ഒരു 70B മോഡലാണ് ഫൈൻ-ട്യൂൺ ചെയ്യുന്നതെങ്കിൽ, നിങ്ങൾ ഇപ്പോളും കൂടുതൽ സമയം എടുക്കാൻ സാധ്യതയുണ്ട്. Unsloth അതിനെ അതിജീവിക്കാൻ സഹായിക്കുന്നു, അത്ര എളുപ്പമാക്കുന്നില്ല.

ഡാറ്റയുടെ ഗുണനിലവാരം പ്രധാനമാണ്. മോശം ഡാറ്റയിൽ മിന്നൽ വേഗത്തിൽ പ്രവർത്തിക്കുന്നത് വളരെ വേഗത്തിൽ മോശം മോഡൽ ഉണ്ടാക്കുന്നു. ഒരു ലൈബ്രറിക്കും മോശം ഡാറ്റാ സെറ്റിനെ ശുദ്ധീകരിക്കാൻ കഴിയില്ല.

ചില സന്ദർഭങ്ങളിൽ ശ്രദ്ധ ആവശ്യമാണ്. ചില പ്രത്യേക ഫീച്ചറുകൾ, ആർക്കിടെക്ചറുകൾ, പരിശീലന രീതികൾ എന്നിവയ്ക്ക് കൂടുതൽ ശ്രദ്ധയും മാറ്റങ്ങളും ആവശ്യമാണ്. കമ്മ്യൂണിറ്റി വേഗത്തിൽ മുന്നോട്ട് പോകുന്നുണ്ടെങ്കിലും, എല്ലാം എളുപ്പത്തിൽ ചെയ്യാൻ സാധിക്കുന്ന ഒന്നല്ല.

ഒരു ദിവസത്തെ ടെസ്റ്റ് ഡ്രൈവ് ഞാൻ ഒരു ലളിതമായ ഇൻസ്ട്രക്ഷൻ-ട്യൂണിംഗ് ജോലി ആരംഭിച്ചു: ഒരു Llama-ശൈലിയിലുള്ള മോഡലിൽ QLoRA, 24GB GPU, ഒരു കസ്റ്റമർ സപ്പോർട്ട് ടോണിൽ “ചോദ്യം → സഹായകരമായ ഉത്തരം” എന്നതിൻ്റെ കുറച്ച് ആയിരം ഉദാഹരണങ്ങൾ. സാധാരണ രീതി: 8-ബിറ്റ് അല്ലെങ്കിൽ 16-ബിറ്റ് അഡാപ്റ്ററുകൾ, സ്റ്റാൻഡേർഡ് ട്രെയിനർ, ഏകദേശം ആറ് മുതൽ എട്ട് മണിക്കൂർ വരെ പ്രതീക്ഷിക്കാം. Unsloth രീതി: അതിന്റെ ഒപ്റ്റിമൈസ് ചെയ്ത സ്റ്റാക്ക് ഉപയോഗിച്ച് 4-ബിറ്റ് QLoRA. വ്യത്യാസം എന്തെന്നാൽ: Unsloth റൺ ഏകദേശം പകുതി സമയം കൊണ്ട് പൂർത്തിയായി, GPU മെമ്മറി അപകടകരമായ അവസ്ഥയിലേക്ക് പോയില്ല, കൂടാതെ ഔട്ട്പുട്ടുകൾ ഈ തരത്തിലുള്ള ടാസ്‌ക്കിന് മിക്കവാറും സമാനമായിരുന്നു. ഏറ്റവും വലിയ നേട്ടം സമയം ലാഭിക്കുക എന്നതായിരുന്നില്ല—അതേ ദിവസം തന്നെ കൂടുതൽ പരീക്ഷണങ്ങൾ നടത്താൻ സാധിച്ചു എന്നതാണ്. ഞാൻ ചെറുതായി വ്യത്യസ്തമായ പ്രോംപ്റ്റ് ഫോർമാറ്റ് പരീക്ഷിച്ചു, പരിശീലന എപ്പോക്കുകൾ മാറ്റി, കൂടാതെ മികച്ച സിസ്റ്റം സന്ദേശം പരീക്ഷിച്ചു. രണ്ടാമത്തെ റൺ കൃത്യത നഷ്ടപ്പെടുത്താതെ തന്നെ മികച്ച ടോൺ നൽകി.

ഒരു ടീം വർക്ക്ഫ്ലോയിൽ Unsloth എങ്ങനെ ഉപയോഗിക്കാം

ഡാറ്റ കൈകാര്യം ചെയ്യുന്നവർ: നിങ്ങളുടെ ഡാറ്റാ സെറ്റിനെ ഇൻസ്ട്രക്ഷൻ ശൈലിയിലുള്ള ജോഡികളാക്കി വൃത്തിയാക്കുക. നിങ്ങൾക്ക് ഇവിടെ ഏറ്റവും വലിയ ഗുണമേന്മ നേടാൻ കഴിയും—ട്രെയിനർ ആർഗ്യുമെന്റുകളിൽ അല്ല.

ML എഞ്ചിനീയർമാർ: നിങ്ങളുടെ സാധാരണ PEFT ലൂപ്പിന് Unsloth-ൻ്റെ ട്രെയിനർ ബിറ്റുകൾ ഉപയോഗിക്കുക. നിങ്ങളുടെ ലോഗിംഗും വിലയിരുത്തലും പഴയതുപോലെ നിലനിർത്തുക, അതുവഴി താരതമ്യം ചെയ്യാൻ എളുപ്പമാകും.

ഉൽപ്പന്നം കൈകാര്യം ചെയ്യുന്നവർ: വേഗത്തിലുള്ള ആവർത്തന സൈക്കിളുകൾ പ്രതീക്ഷിക്കുക. വേഗത്തിലുള്ള ബാർ മാത്രമല്ല ഇതിന്റെ യഥാർത്ഥ സ്വാധീനം, ഒരു സ്പ്രിന്റിൽ കൂടുതൽ പരീക്ഷണങ്ങൾ നടത്താൻ സാധിക്കുന്നു എന്നതാണ്.

ഓപ്‌സ്: നിങ്ങളുടെ ഇൻഫ്രാ ഇഷ്ടപ്പെടുന്ന ഫോർമാറ്റിലേക്ക് മോഡലുകൾ എക്‌സ്‌പോർട്ട് ചെയ്യുക (CPU/Ollama-യ്‌ക്കായി GGUF അല്ലെങ്കിൽ GPU-ആക്‌സിലറേറ്റഡ് റൺടൈം). Unsloth-ന്റെ എക്‌സ്‌പോർട്ട് ഓപ്‌ഷനുകൾ നിങ്ങൾക്ക് എവിടെ വേണമെങ്കിലും ഉപയോഗിക്കാം.

അനുയോജ്യതയും മോഡൽ പിന്തുണയും Unsloth സാധാരണയായി ഉപയോഗിക്കുന്ന മോഡലുകളുമായി നന്നായി പ്രവർത്തിക്കുന്നു: Llama-family, Mistral, Phi, കൂടാതെ മറ്റു പലതും. പ്രാദേശിക റൺടൈമുകളും എഡ്ജ് ഡെപ്ലോയ്‌മെന്റുകളും ഉപയോഗിച്ച് നിർമ്മിക്കുന്ന കമ്മ്യൂണിറ്റികളിലും ഇതിന് പ്രചാരം ലഭിച്ചു. നിങ്ങളുടെ സ്റ്റാക്ക് Hugging Face മോഡലുകളെയും PEFT-യെയും ആശ്രയിക്കുന്നുണ്ടെങ്കിൽ, Unsloth പരീക്ഷിക്കുന്നത് എളുപ്പമാണ്.

പൊതുവായി വരുന്ന പ്രശ്നങ്ങളും പരിഹാരങ്ങളും

CUDA out of memory? gradient accumulation, ചെറിയ ബാച്ച് സൈസ് എന്നിവ പരീക്ഷിക്കുക, അല്ലെങ്കിൽ 4-ബിറ്റ് QLoRA ഉപയോഗിക്കുക. നിങ്ങളുടെ സീക്വൻസ് ലെങ്ത് കൂടുതലല്ലെന്ന് ഉറപ്പാക്കുക.

Loss മാറുന്നില്ലേ? നിങ്ങളുടെ ലേണിംഗ് റേറ്റ് തെറ്റായിരിക്കാം. LoRA അഡാപ്റ്ററുകൾക്കായി 1e-4 മുതൽ 2e-4 വരെ പരിധി പരീക്ഷിക്കുക, അല്ലെങ്കിൽ Warmup ഘട്ടങ്ങൾ പൂജ്യമല്ലെന്ന് ഉറപ്പാക്കുക.

Outputs റോബോട്ടിക് ആണോ? കൂടുതൽ വ്യത്യസ്തമായ ഇൻസ്ട്രക്ഷൻ ഉദാഹരണങ്ങൾ ചേർക്കുക അല്ലെങ്കിൽ നിങ്ങളുടെ ഡാറ്റാ സെറ്റിനെ ബാലൻസ് ചെയ്യുക, അതുവഴി ഒരു ടോൺ മാത്രം പഠിപ്പിക്കാതിരിക്കാൻ ശ്രദ്ധിക്കുക. ചെറിയ ഡാറ്റാ ട്വീക്കുകൾ മിക്കപ്പോഴും ഇത് പരിഹരിക്കും.

പരിശീലനത്തിന് ശേഷം Inference-ന് വേഗത കുറവാണോ: Inference-ന് അനുയോജ്യമായ ഫോർമാറ്റിലേക്ക് എക്‌സ്‌പോർട്ട് ചെയ്യുക. CPU-ൽ GGUF ഒരു രക്ഷകനാകാൻ സാധ്യതയുണ്ട്. GPU-ൽ നിങ്ങളുടെ ക്വാണ്ടൈസേഷനും റൺടൈമും പരിശോധിക്കുക.

ചെലവ് കണക്കുകൾ: നിങ്ങളുടെ പോക്കറ്റ് ശ്രദ്ധിക്കുന്ന ഭാഗം വേഗത നിങ്ങളുടെ ഞായറാഴ്ച മാത്രമല്ല ലാഭിക്കുന്നത്—പകരം പൈസയും ലാഭിക്കുന്നു. നിങ്ങളുടെ ക്ലൗഡ് GPU-വിന് മണിക്കൂറിന് $2–$4 ഡോളർ ആണെങ്കിൽ, 10 മണിക്കൂർ എടുക്കുന്ന ജോലി 5 മണിക്കൂറാക്കുന്നത് ലാഭകരമാണ്. ഇത് കൂടുതൽ പരീക്ഷണങ്ങളിൽ ഗുണിക്കുക, അപ്പോൾ നിങ്ങൾക്ക് “ഒരുപക്ഷേ നമുക്ക് രണ്ടാമതൊരു GPU വാങ്ങാൻ സാധിക്കും” അല്ലെങ്കിൽ “നമുക്ക് നല്ല കാപ്പി വാങ്ങാം.” എന്നൊക്കെ തോന്നാം.

സുരക്ഷയും സ്വകാര്യതയും: Unsloth-ൽ എന്താണ് മാറുന്നത്? Unsloth നിങ്ങളുടെ runtime-നെക്കാൾ കൂടുതൽ നിങ്ങളുടെ അപകടസാധ്യത മാറ്റുന്നില്ല. നിങ്ങൾ എവിടെയാണ് പരിശീലനം നടത്തുന്നത് (പ്രാദേശികമായി vs ക്ലൗഡിൽ), നിങ്ങൾ എന്ത് ഡാറ്റയാണ് ഉപയോഗിക്കുന്നത് (PII? നിയന്ത്രിത ഡാറ്റ?), നിങ്ങൾ എങ്ങനെയാണ് ചെക്ക്പോയിന്റുകൾ സൂക്ഷിക്കുന്നത് എന്നിവയാണ് പ്രധാന ഘടകങ്ങൾ. നിങ്ങൾ സെൻസിറ്റീവ് ഡാറ്റയാണ് കൈകാര്യം ചെയ്യുന്നതെങ്കിൽ, സാധാരണ രീതികൾ പാലിക്കുക: സാധ്യമാകുമ്പോൾ അജ്ഞാതമാക്കുക, നിങ്ങളുടെ പരിശീലന പ്രവർത്തനങ്ങൾ വേർതിരിക്കുക, ഓഡിറ്റ് ലോഗുകൾ സൂക്ഷിക്കുക. നിങ്ങൾ ഒരു കംപ്ലയിൻസ് ഓഫീസർക്ക് ഫൈൻ-ട്യൂണിംഗ് വിശദീകരിക്കേണ്ടി വന്നാൽ, Unsloth ആ സംഭാഷണം കൂടുതൽ ബുദ്ധിമുട്ടാക്കുന്നില്ല. വാസ്തവത്തിൽ, നിങ്ങളുടെ സ്വന്തം മെഷീനിൽ പ്രാദേശികമായി ഫൈൻ-ട്യൂൺ ചെയ്യുന്നത് ചിലപ്പോൾ എളുപ്പമാക്കുന്നു.

സാധാരണയായി ഉപയോഗിക്കുന്നവയുമായി എങ്ങനെ താരതമ്യം ചെയ്യാം

Plain PEFT + Transformers: പരിചിതമായതും, വ്യാപകമായി പിന്തുണയ്ക്കുന്നതും മികച്ചതുമാണ്—പക്ഷേ വേഗത കുറഞ്ഞതും കൂടുതൽ മെമ്മറി ആവശ്യമുള്ളതുമാണ്. Unsloth വേഗതയും VRAM-ഉം കുറയ്ക്കുന്നു.

16-ബിറ്റിൽ Full-finetuning: ശക്തമായതും എന്നാൽ ചെലവേറിയതുമാണ്. മോഡലിന്റെ പ്രധാന അറിവ് മാറ്റം വരുത്തണമെങ്കിൽ മാത്രം ഇത് ഉപയോഗിക്കുക. അല്ലെങ്കിൽ LoRA/QLoRA ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

Parameter-efficient alternatives (ഉദാഹരണത്തിന് adapters, prefixes): LoRA-യുടെ അതേ രീതിയിലുള്ളതാണ് ഇതും. മികച്ച പ്രകടനം നിലനിർത്തിക്കൊണ്ട് Unsloth-ന് ഈ രീതികളെ പിന്തുണയ്ക്കാൻ കഴിയും.

തുടക്കക്കാർ Unsloth പരീക്ഷിക്കണോ? ഉവ്വ്—ശരിയായ പരിശീലനത്തോടെ. നിങ്ങൾ ഇതുവരെ ഒന്നും ഫൈൻ-ട്യൂൺ ചെയ്തിട്ടില്ലെങ്കിൽ, ഒരു ചെറിയ മോഡലിൽ (7B), ചെറിയ ഡാറ്റാ സെറ്റ്, QLoRA എന്നിവ ഉപയോഗിച്ച് ആരംഭിക്കുക. നിങ്ങളുടെ ആദ്യത്തെ വിജയം തന്നെ മികച്ച അധ്യാപകനായിരിക്കും. Unsloth ഡോക്യുമെന്റേഷനും ഉദാഹരണ നോട്ട്ബുക്കുകളും സാധാരണ ഹൈപ്പർപാരാമീറ്ററുകളേക്കാൾ എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്നതാണ്. നിങ്ങൾ പ്രശ്നത്തിൽപ്പെട്ടാൽ (സംഭവിക്കാൻ സാധ്യതയുണ്ട്), കമ്മ്യൂണിറ്റിയിൽ നിന്ന് സഹായം ലഭിക്കുന്നതാണ്.

Sider.AI ഈ കഥയിൽ എങ്ങനെയാണ് വരുന്നത്? നിങ്ങൾ ഫൈൻ-ട്യൂണിംഗിനെക്കുറിച്ച് വായിക്കുകയും, “എനിക്ക് എന്റെ ബ്രൗസറിനുള്ളിൽ നിന്ന് ഇത് ചെയ്യാൻ സാധിക്കുമോ?” എന്ന് ചിന്തിക്കുകയാണെങ്കിൽ—ഒരു സന്തോഷവാർത്തയുണ്ട്. Sider.AI നിങ്ങളുടെ ബ്രൗസറിൽ ഒരു AI സഹായിയായി പ്രവർത്തിക്കുന്നു: പേജുകൾ സംഗ്രഹിക്കുന്നു, ഇമെയിലുകൾ തയ്യാറാക്കുന്നു, ഗവേഷണത്തെ സഹായിക്കുന്നു. ഇതൊരു ഫൈൻ-ട്യൂണിംഗ് ലൈബ്രറിയല്ല, പക്ഷേ വെബ് ഉള്ളടക്കത്തിൽ നിന്ന് ഡാറ്റാ സെറ്റുകൾ ക്യൂറേറ്റ് ചെയ്യുക, കൃത്രിമ പരിശീലന പ്രോംപ്റ്റുകൾ ഉണ്ടാക്കുക, ഒരു ഡ്രാഫ്റ്റ് മോഡലിലോ API-യിലോ നിർദ്ദേശങ്ങൾ വേഗത്തിൽ പരീക്ഷിക്കുക തുടങ്ങിയ കാര്യങ്ങൾ എളുപ്പമാക്കുന്നു. പ്രോംപ്റ്റുകൾ മസ്തിഷ്കത്തിലേക്ക് കൊണ്ടുവരാനും, ഡോക്യുമെന്റുകളിൽ നിന്ന് ചോദ്യോത്തര ജോഡികൾ എക്‌സ്‌ട്രാക്റ്റ് ചെയ്യാനും, ടോൺ നിയന്ത്രിത ഉദാഹരണങ്ങൾ തയ്യാറാക്കാനും Sider.AI ഉപയോഗിക്കുക—എന്നിട്ട് അത് നിങ്ങളുടെ Unsloth റണ്ണിലേക്ക് നൽകുക. Sider.AI ഉപയോഗിച്ച് backpropagation ചെയ്യാൻ ശ്രമിച്ചാൽ മോശം ദിവസമായിരിക്കും ഫലം. മികച്ച ഡാറ്റയും വേഗത്തിലുള്ള ആവർത്തന ലൂപ്പുകളും നിർമ്മിക്കാൻ ഇത് ഉപയോഗിക്കുക, അപ്പോൾ നിങ്ങൾക്ക് ഒരു സൂപ്പർ പവർ കിട്ടിയത് പോലെ തോന്നും.

ഒന്ന് കൂടി പരീക്ഷിക്കാൻ സാധിക്കുന്ന കാര്യം നിങ്ങൾ ഒരു വലിയ പരിശീലന റൺ ചെയ്യുന്നതിന് മുമ്പ്, ഇത് പരീക്ഷിക്കുക: 200–500 മികച്ച ഉദാഹരണങ്ങളുടെ ഒരു മിനി ഡാറ്റാ സെറ്റ് ഉണ്ടാക്കുക. Unsloth ഉപയോഗിച്ച് കുറച്ച് എപ്പോക്കുകൾക്കായി ഫൈൻ-ട്യൂൺ ചെയ്യുക. ഔട്ട്പുട്ടുകൾ വിലയിരുത്തുക, അതിനുശേഷം മാത്രം സ്കെയിൽ അപ്പ് ചെയ്യുക. ഈ ചെറിയ പരിശീലനം നിങ്ങളുടെ സമയം ലാഭിക്കുകയും, മികച്ച മോഡൽ ഉണ്ടാക്കാൻ സഹായിക്കുകയും ചെയ്യും.

ലളിതമായ ഭാഷയിൽ ഇതിൻ്റെ പ്രധാന ആശയം Unsloth പുതിയ കണക്കുകൾ കണ്ടുപിടിക്കുന്നില്ല, വീട് വൃത്തിയാക്കുകയാണ് ചെയ്യുന്നത്: ഫർണിച്ചറുകൾ മാറ്റിവെക്കുന്നു, ഡ്രോയറുകൾ ലേബൽ ചെയ്യുന്നു, ടർബോ ബട്ടൺ ഇൻസ്റ്റാൾ ചെയ്യുന്നു. GPU ഒരു ദിവസം മുഴുവൻ പ്രവർത്തിക്കുന്നത് നോക്കിയിരിക്കുന്ന ഏതൊരാൾക്കും, സമയവും VRAM ലാഭിക്കുന്നതും ഒരു സൂപ്പർ പവർ കിട്ടിയത് പോലെ തോന്നും. ഇതൊരു അത്ഭുതമരുന്നല്ല—മോശം ഡാറ്റ മോശമായി തുടരുന്നു, വലിയ മോഡലുകൾ വലുതായി തുടരുന്നു—എന്നാൽ ഇത് സാധാരണക്കാർക്ക് പോലും ഫൈൻ-ട്യൂണിംഗ് ചെയ്യാൻ സാധിക്കുന്ന ഒന്നാക്കി മാറ്റുന്നു. നിങ്ങളുടെ ലക്ഷ്യം മികച്ച ഹാർഡ്‌വെയറിൽ കസ്റ്റമൈസേഷൻ ചെയ്യുക എന്നതാണ് എങ്കിൽ, Unsloth നിങ്ങളുടെ ടൂൾകിറ്റിൽ ഉണ്ടായിരിക്കേണ്ട ഒന്നാണ്.

Quick-start checklist

ചെറുതായി തുടങ്ങുക: 7B മോഡൽ, ചെറിയ സീക്വൻസുകൾ, മികച്ച ഡാറ്റാ സെറ്റ്.

നിങ്ങൾക്ക് മതിയായ കാരണമില്ലെങ്കിൽ QLoRA 4-bit ഉപയോഗിക്കുക.

ബാച്ച് സൈസുകൾ കുറയ്ക്കുക; gradient accumulation ഉപയോഗിച്ച് ബാക്കിയുള്ളവ ചെയ്യുക.

എല്ലാം ലോഗ് ചെയ്യുക: validation സാമ്പിളുകൾ, loss curves, യഥാർത്ഥ പ്രോംപ്റ്റുകൾ.

നിങ്ങൾ ഉപയോഗിക്കാൻ പോകുന്ന ഫോർമാറ്റിലേക്ക് (GGUF അല്ലെങ്കിൽ GPU-native) നേരത്തെ തന്നെ എക്‌സ്‌പോർട്ട് ചെയ്യുക, ലേറ്റൻസി പരിശോധിക്കുക.

ഹൈപ്പർപാരാമീറ്ററുകൾക്ക് മുൻപ് ഡാറ്റയിൽ മാറ്റങ്ങൾ വരുത്തുക; മികച്ച ഉദാഹരണങ്ങൾ തന്ത്രപരമായ കാര്യങ്ങളെക്കാൾ നല്ലതാണ്.

Wrap-up (ചിരിയോടെ) ഫൈൻ-ട്യൂണിംഗ് എന്നത് കണങ്കാൽ ഭാരവുമായി മാരത്തണിന് പരിശീലനം നേടുന്നതുപോലെയായിരുന്നു. Unsloth ആ ഭാരം കുറയ്ക്കുന്നു. നിങ്ങൾ ഇപ്പോളും ഓടേണ്ടതുണ്ട്, പക്ഷേ ദൂരം കുറഞ്ഞതായി തോന്നുന്നു. ഒരു വാരാന്ത്യത്തിന് പകരം ഒരു ഉച്ചകഴിഞ്ഞ് നിങ്ങളുടെ ആദ്യത്തെ ട്യൂൺ ചെയ്ത മോഡൽ പുറത്തിറക്കുമ്പോൾ, നിങ്ങൾ എന്നെപ്പോലെ ചെയ്തേക്കാം: നിങ്ങളുടെ GPU-വിനോട് നിങ്ങൾ പറഞ്ഞ എല്ലാ മോശം വാക്കുകൾക്കും മാപ്പ് ചോദിക്കുക.

FAQ

Q1: ലളിതമായി പറഞ്ഞാൽ Unsloth എന്നാൽ എന്ത്? Unsloth എന്നത് വലിയ ഭാഷാ മോഡലുകളെ വേഗത്തിലും കുറഞ്ഞ മെമ്മറിയിലും ഫൈൻ-ട്യൂൺ ചെയ്യാൻ സഹായിക്കുന്ന ഒരു ലൈബ്രറിയാണ്. ഇത് QLoRA-യിലും മറ്റ് കാര്യക്ഷമമായ തന്ത്രങ്ങളിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു, അതുവഴി ഗുണനിലവാരം നഷ്ടപ്പെടുത്താതെ തന്നെ ഒരു 24GB GPU-ൽ ഉപയോഗപ്രദമായ മോഡലുകൾ പരിശീലിപ്പിക്കാൻ കഴിയും.

Q2: QLoRA-യ്‌ക്കായി സാധാരണ PEFT-യെക്കാൾ മികച്ചതാണോ Unsloth? പല യഥാർത്ഥ ലോക സാഹചര്യങ്ങളിലും, അതെ—സാധാരണയായി Unsloth വേഗത്തിലുള്ള പരിശീലനവും കുറഞ്ഞ VRAM-ഉം നൽകുന്നു, കൂടാതെ കൃത്യത നിലനിർത്തുകയും ചെയ്യുന്നു. നിങ്ങൾ ഇപ്പോളും പരിചിതമായ രീതികൾ ഉപയോഗിക്കുന്നു, പക്ഷേ നിങ്ങൾക്ക് ഒരേ സമയം കൂടുതൽ പരീക്ഷണങ്ങൾ ചെയ്യാൻ കഴിയും.

Q3: ഒരു GPU-ൽ ഒരു 70B മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ Unsloth ഉപയോഗിക്കാൻ കഴിയുമോ? ശരിയായ ക്രമീകരണങ്ങളോടെ ഇത് ചെയ്യാൻ സാധിക്കും, പക്ഷേ അത്ര എളുപ്പമായിരിക്കില്ല. Unsloth വേഗതയും VRAM-ഉം കുറയ്ക്കാൻ സഹായിക്കുന്നു, എങ്കിലും വലിയ മോഡലുകൾക്ക് ഇപ്പോളും ക്ഷമയും ശ്രദ്ധയും ആവശ്യമാണ്, കൂടാതെ ബാച്ച് സൈസുകൾ, സീക്വൻസ് ലെങ്തുകൾ, ക്വാണ്ടൈസേഷൻ എന്നിവയും ശ്രദ്ധിക്കണം.

Q4: Full-precision finetuning-മായി താരതമ്യം ചെയ്യുമ്പോൾ Unsloth മോഡലിന്റെ ഗുണനിലവാരം കുറയ്ക്കുമോ? മികച്ച ഡാറ്റാ സെറ്റുകളും QLoRA-യും ഉപയോഗിച്ച്, മിക്ക ഉപയോക്താക്കൾക്കും നിർദ്ദേശങ്ങൾ പാലിക്കുക, സംഗ്രഹിക്കുക തുടങ്ങിയ സാധാരണ ടാസ്‌ക്കുകൾക്ക് സമാനമായ ഗുണനിലവാരം കാണാൻ സാധിക്കും. എന്നാൽ വളരെ സ്പെഷ്യലൈസ്ഡ് അല്ലെങ്കിൽ അറിവ് കൂടുതലായി ആവശ്യമുള്ള മാറ്റങ്ങൾക്ക്, full-precision finetuning മികച്ചതായിരിക്കാം.

Q5: Sider.AI ഒരു പരിശീലന ഉപകരണം അല്ലെങ്കിൽ പിന്നെ എങ്ങനെയാണ് ഇത് സഹായിക്കുന്നത്? പരിശീലന ഡാറ്റ ശേഖരിക്കാനും മെച്ചപ്പെടുത്താനും Sider.AI ഉപയോഗിക്കുക: ഡോക്യുമെന്റുകൾ സംഗ്രഹിക്കുക, പ്രോംപ്റ്റുകൾ ഉണ്ടാക്കുക, വ്യത്യസ്ത ഉദാഹരണങ്ങൾ തയ്യാറാക്കുക. മികച്ച ഡാറ്റ Unsloth-നെ മികച്ചതാക്കുന്നു—Sider.AI നിങ്ങളുടെ അടുക്കളയിലെ ജോലികൾ വേഗത്തിലാക്കുന്ന ഒരാളായി കണക്കാക്കുക.