UNSLOTH

Unsloth: Fine-Tuning LLM & Eficiență VRAM: comenzi, scurtături și ghid practic

91 de comenzi 9 categorii Comunitate & Q&A AI

Unsloth este biblioteca open-source de referință pentru fine-tuning ultra-rapid și eficient al modelelor mari de limbaj (LLM). Prin re-scrierea nucleelor matematice de calcul matricial în limbajul Triton și eliminarea calculelor redundante de backpropagation, Unsloth accelerează antrenarea cu până la 5x și reduce consumul de memorie video (VRAM) cu 80%, permițând adaptarea modelelor de 8 miliarde de parametri direct pe plăci video consumer sau instanțe gratuite Google Colab.

⚡ Viteză Maximă & Nuclee Triton

Nuclee custom scrise manual în Triton care fuzionează operațiile liniare (GEMM), atenția multi-cap și funcțiile de pierdere (Cross-Entropy) fără overhead PyTorch.

🧠 QLoRA pe 4 Biți Fără Pierderi

Cuantizare nativă NF4 cu adaptori de rang redus (LoRA) care păstrează peste 99% din acuratețea originală cu doar 5.5 GB VRAM alocați.

🎯 Aliniere Avansată: DPO & GRPO

Suport integrat pentru optimizarea preferințelor prin DPO fără model de referință duplicat și algoritmul GRPO din DeepSeek-R1 pentru raționament autonom.

📦 Export Direct GGUF & Ollama

Conversie automată într-o singură linie de cod în formate GGUF (q4_k_m, q8_0) și generare de Modelfile pentru rulare locală instantanee în Ollama.

🚀 Instalare Rapidă Unsloth în Python

Instalați Unsloth într-un mediu virtual cu suport CUDA 12.1+ și PyTorch accelerat:

# Instalare Unsloth cu drivere CUDA 12.1 și nuclee Triton
pip install --upgrade --no-cache-dir "unsloth[cu121-torch240] @ git+https://github.com/unslothai/unsloth.git"

# Sau în Google Colab / Kaggle:
pip install --no-deps "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"

Arhitectura și Ecosistemul Unsloth

Unsloth se integrează nativ cu bibliotecile standard Hugging Face Transformers, PEFT și TRL (Transformer Reinforcement Learning). Nu este nevoie să învățați un API complet nou: înlocuiți pur și simplu AutoModelForCausalLM cu FastLanguageModel, iar clasele de antrenare precum SFTTrainer sau DPOTrainer beneficiază instantaneu de accelerările hardware.

Fluxul de Lucru Recomandat în 4 Pași:

Încărcare Model & Tokenizer: Folosiți FastLanguageModel.from_pretrained cu load_in_4bit=True.
Atașare Adaptori LoRA: Apelați FastLanguageModel.get_peft_model specificând rangul r și straturile țintă.
Antrenare Supervizată: Configurați datele cu formatting_prompts_func și lansați SFTTrainer.train().
Export & Producție: Salvați adaptorii LoRA sau exportați modelul binar în format GGUF cu save_pretrained_gguf.

Indexul Complet al Comenzilor, Metodelor și Ghidurilor Unsloth

Tabelul de mai jos centralizează toate noțiunile, metodele Python, algoritmii și opțiunile de configurare Unsloth:

Metodă / Noțiune Unsloth	Descriere Tehnică & Caz de Utilizare
Instalare & Configurare Mediu
Instalarea Unsloth cu Suport CUDA & PyTorch `pip install --upgrade --force-reinstall --no-cache-dir unsloth[cu121-torch240]`	Comanda optimizată de instalare pip pentru nuclee CUDA 12.1/12.4 și PyTorch accelerat.
Configurarea Unsloth în Google Colab & Kaggle `pip install --no-deps unsloth "xformers<0.0.27" "trl<0.9.0" peft accelerate bitsandbytes`	Script de inițializare rapidă pentru instanțele cloud gratuite Google Colab (GPU T4) și Kaggle.
Importul și Structura Clasei FastLanguageModel `from unsloth import FastLanguageModel`	Punctul de intrare central în Unsloth pentru încărcarea, adaptarea și exportul modelelor generative.
Verificarea Suportului GPU & Flash Attention 2 `unsloth.is_bfloat16_supported()`	Funcția de inspecție a capacităților GPU pentru selectarea automată a preciziei bfloat16 și Flash Attention.
Optimizarea Atenției cu xFormers & Triton Kernels `import xformers; print(xformers.__version__)`	Integrarea mecanismelor de memorie redusă pentru atenția multi-head prin xFormers.
Autentificare cu Token Hugging Face pentru Modele Protejate `from huggingface_hub import login; login("hf_...")`	Procedura de autentificare pentru accesarea modelelor cu acord de licență (Llama 3, Gemma, Mistral).
Monitorizarea Memoriei GPU cu PyTorch & NVML `torch.cuda.memory_allocated() / 1024**3`	Măsurarea în timp real a memoriei video alocate și rezervate în timpul etapelor de încărcare și antrenare.
Configurarea Directorului de Cache HF_HOME pe Discuri Secundare `os.environ["HF_HOME"] = "/cale/catre/disc_rapid/hf_cache"`	Redirecționarea descărcărilor de greutăți și seturi de date pe volume de stocare dedicate NVMe.
Încărcare Modele & Arhitecturi Suportate
Încărcarea Modelelor Cuantizate pe 4 Biți (QLoRA 4-bit) `model, tokenizer = FastLanguageModel.from_pretrained(model_name="...", load_in_4bit=True)`	Metoda standard Unsloth pentru încărcarea ponderilor de bază cuantizate NF4 pe 4 biți cu memorie minimă.
Încărcarea Modelelor pe 8 Biți pentru Stabilitate Ridicată `model, tokenizer = FastLanguageModel.from_pretrained(model_name="...", load_in_4bit=False, load_in_8bit=True)`	Opțiunea de încărcare pe 8 biți pentru cazurile care necesită o precizie matematică intermediară.
Încărcarea în Precizie Completă 16-bit / BFloat16 `model, tokenizer = FastLanguageModel.from_pretrained(model_name="...", load_in_4bit=False, dtype=torch.bfloat16)`	Încărcarea necuantizată pe GPU-uri profesionale (A100/H100) pentru fine-tuning la precizie maximă.
Configurarea Lungimii Maxime a Contextului (max_seq_length) `max_seq_length = 2048 # sau 4096 / 8192`	Limitarea ferestrei de context la încărcare pentru dimensionarea adecvată a bufferelor de atenție.
Detecția Automată a Tipului de Date Hardware (dtype) `dtype = None # Detecție automată Float16 sau BFloat16`	Configurarea parametrului dtype=None pentru selecția inteligentă a celui mai rapid format numeric.
Alocarea Dispozitivelor cu device_map=”auto” `device_map = "auto" # sau {"": 0} pentru un singur GPU`	Maparea straturilor rețelei pe GPU pentru evitarea transferurilor lente între memoria RAM și VRAM.
Încărcarea Familiei Meta Llama 3 & 3.1 8B `model_name = "unsloth/Meta-Llama-3.1-8B-bnb-4bit"`	Configurația de bază pentru fine-tuning pe cel mai popular model open-source de 8 miliarde de parametri.
Încărcarea Modelelor Qwen 2.5 (0.5B, 7B, 14B) `model_name = "unsloth/Qwen2.5-7B-bnb-4bit"`	Ghid de adaptare pentru seria Qwen 2.5, lider în raționament matematic și generare de cod.
Încărcarea Modelului Mistral NeMo 12B `model_name = "unsloth/Mistral-Nemo-Base-2407-bnb-4bit"`	Încărcarea modelului de 12 miliarde de parametri dezvoltat în parteneriat de Mistral AI și NVIDIA.
Încărcarea Modelelor Distilate DeepSeek-R1 `model_name = "unsloth/DeepSeek-R1-Distill-Llama-8B-bnb-4bit"`	Configurarea modelelor distilate din DeepSeek-R1 pentru fine-tuning pe sarcini de raționament complex.
Configurare LoRA & QLoRA Avansat
Aplicarea Adaptorilor LoRA cu FastLanguageModel.get_peft_model `model = FastLanguageModel.get_peft_model(model, r=16, target_modules=[...], lora_alpha=16)`	Metoda principală prin care modelul de bază este înghețat și i se atașează matricile de rang redus LoRA.
Dimensionarea Rangului LoRA (Parametrul r) `r = 16 # Valori recomandate: 8, 16, 32, 64`	Alegerea rangului optim al matricilor de descompunere în funcție de complexitatea domeniului de adaptare.
Reglarea Factorului de Scalare lora_alpha `lora_alpha = 16 # sau 2 * r (ex: r=16 -> alpha=32)`	Regula de aur pentru reglarea parametrului lora_alpha și impactul său asupra ratei de învățare efective.
Optimizarea Dropout-ului la Valoarea 0 (lora_dropout = 0) `lora_dropout = 0 # Recomandarea oficială Unsloth`	De ce Unsloth solicită setarea lora_dropout=0 pentru activarea nucleelor rapide fuzionate Triton.
Țintirea Tuturor Straturilor Liniare (All-Linear Modules) `target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]`	Configurația de adaptare completă pe toate modulele liniare de atenție și rețele feed-forward (MLP).
Țintirea Selectivă a Matricilor de Atenție (q_proj & v_proj) `target_modules = ["q_proj", "v_proj"]`	Reducerea numărului de parametri antrenabili la minimum absolut pentru bugete stricte de memorie.
Țintirea Matricilor Feed-Forward (MLP Projections) `target_modules = ["gate_proj", "up_proj", "down_proj"]`	Rolul straturilor gate_proj, up_proj și down_proj în stocarea de fapte și cunoștințe noi în rețea.
Optimizarea Gradient Checkpointing în Unsloth `use_gradient_checkpointing = "unsloth"`	Mecanismul specializat care re-calculează activările în loc să le salveze în VRAM, reducând memoria cu 30%.
Configurarea Parametrului de Deplasare (bias=”none”) `bias = "none" # Opțiuni: "none", "all", "lora_only"`	Motivele pentru care se recomandă păstrarea bias-urilor înghețate (bias="none") la antrenare.
Setarea Seed-ului Aleatoriu pentru Reproductibilitate (random_state) `random_state = 3407`	Fixarea generatoarelor de numere pseudo-aleatorii pentru rezultate identice la reluarea antrenării.
Activarea Scalării Stabile rsLoRA (Rank-Stabilized LoRA) `use_rslora = True`	Scalarea factorului de învățare cu 1 / sqrt(r) pentru prevenirea instabilităților la ranguri mari (r >= 64).
Inițializarea LoFTQ peste Ponderi Cuantizate `loftq_config = None # sau LoftQConfig(...)`	Minimizarea discrepanței inițiale de cuantizare prin aproximare alternativă SVD.
Formatarea Dataset-urilor & Șabloane Chat
Încărcarea Șabloanelor Chat cu get_chat_template `from unsloth.chat_templates import get_chat_template; tokenizer = get_chat_template(tokenizer, chat_template="...")`	Utilitarul Unsloth pentru aplicarea automată a șabloanelor corecte de conversație (Llama 3, ChatML, Mistral).
Șablonul Oficial de Conversație Llama 3 & 3.1 `tokenizer = get_chat_template(tokenizer, chat_template="llama-3")`	Structura delimitatorilor oficiali Meta: `<\|start_header_id\|>`, `<\|end_header_id\|>`, `<\|eot_id\|>`.
Șablonul Standard Deschis ChatML `tokenizer = get_chat_template(tokenizer, chat_template="chatml")`	Formatul universal utilizat de modelele OpenAI, Qwen, Yi și numeroase dataset-uri open-source.
Conversia Dataset-urilor Multi-Turn în Format ShareGPT `from unsloth.chat_templates import standardize_sharegpt; dataset = standardize_sharegpt(dataset)`	Normalizarea automată a structurilor de conversații eterogene cu rolurile human/gpt sau user/assistant.
Construirea Funcțiilor Personalizate formatting_prompts_func `def formatting_prompts_func(examples): ... return {"text": texts}`	Funcția de prelucrare prin care câmpurile brute din dataset sunt transformate în șirul final de text.
Șablonul Clasic de Instrucțiuni Stanford Alpaca `prompt = f"### Instruction:\n{inst}\n\n### Input:\n{inp}\n\n### Response:\n{out}"`	Șablonul standard utilizat pentru sarcini de fine-tuning supervizat de tip instrucțiune-răspuns unisingur tur.
Gestionarea Completării Secvențelor (padding_side=”right”) `tokenizer.padding_side = "right"`	Regula obligatorie a completării pe partea dreaptă pentru modelele cauzale de generare la antrenare.
Împachetarea Secvențelor Scurte (packing=True / False) `packing = False # sau True pentru dataset-uri masive`	Concatenarea mai multor mostre scurte până la atingerea ferestrei maxime pentru eliminarea tokenilor irosiți de pad.
Procesarea Rapidă a Datelor cu dataset.map(batched=True) `dataset = dataset.map(formatting_prompts_func, batched=True, num_proc=4)`	Aplicarea paralelă pe multiple nuclee CPU a funcțiilor de formatare și tokenizare.
Încărcarea Seturilor de Date din Hugging Face Hub `from datasets import load_dataset; dataset = load_dataset("repo/dataset_name", split="train")`	Conectarea directă la repozitoriile publice sau private de date din platforma Hugging Face.
Încărcarea Fișierelor Locale JSON și JSONL pentru Date Private `dataset = load_dataset("json", data_files="date_interne.jsonl", split="train")`	Fluxul de lucru recomandat pentru companiile care doresc să antreneze modele fără a urca datele pe internet.
Împărțirea Setului de Date în Train și Validation (train_test_split) `dataset = dataset.train_test_split(test_size=0.1, seed=3407)`	Separarea unui subset de validare pentru monitorizarea obiectivă a supra-adaptării (overfitting).
Antrenare Supervizată cu SFTTrainer
Inițializarea Antrenorului SFTTrainer din Biblioteca TRL `from trl import SFTTrainer; trainer = SFTTrainer(model=model, tokenizer=tokenizer, train_dataset=dataset, ...)`	Configurarea completă a obiectului SFTTrainer integrat nativ cu optimizările Unsloth.
Configurarea Hiperparametrilor în TrainingArguments `args = TrainingArguments(output_dir="...", per_device_train_batch_size=..., ...)`	Structura completă a opțiunilor de control pentru epoci, pași, ieșiri și verificări intermediare.
Setarea Dimensiunii Lotului (per_device_train_batch_size) `per_device_train_batch_size = 2 # Valori uzuale: 1, 2, 4`	Dimensionarea numărului de mostre procesate simultan în VRAM înainte de acumularea gradienților.
Simularea Loturilor Mari prin gradient_accumulation_steps `gradient_accumulation_steps = 4 # Lot efectiv = batch_size * steps`	Tehnica de adunare a gradienților pe parcursul mai multor pași înainte de actualizarea ponderilor.
Alegerea Ratei Optime de Învățare (learning_rate) `learning_rate = 2e-4 # sau 5e-5 pentru modele deja instruite`	Ghidul valorilor recomandate de rată de învățare pentru LoRA vs QLoRA pe modele de 8B și 14B.
Planificatorul de Rată Cosinusoidal (lr_scheduler_type=”cosine”) `lr_scheduler_type = "cosine"`	Scăderea lină a ratei de învățare pe o curbă trigonometrică cosinusoidală pentru convergență optimă.
Planificatorul Liniar de Rată (lr_scheduler_type=”linear”) `lr_scheduler_type = "linear"`	Scăderea liniară uniformă a ratei de învățare de la valoarea de vârf până la zero.
Perioada de Încălzire (warmup_steps & warmup_ratio) `warmup_steps = 10 # sau warmup_ratio = 0.05`	Creșterea treptată a ratei de învățare de la 0 la valoarea țintă pentru protejarea ponderilor inițiale.
Regularizarea Ponderilor (weight_decay = 0.01) `weight_decay = 0.01`	Penalizarea normei ponderilor pentru a descuraja valorile excesiv de mari și a reduce supra-adaptarea.
Optimizatorul AdamW pe 8 Biți (optim=”adamw_8bit”) `optim = "adamw_8bit"`	Comprimarea momentelor de ordinul 1 și 2 ale optimizatorului AdamW de la 32 la 8 biți, salvând 75% din starea sa.
Optimizatorul AdamW Accelerat Fuzionat (adamw_torch_fused) `optim = "adamw_torch_fused"`	Executarea actualizării optimizatorului într-un singur apel de kernel CUDA pentru plăci Ampere/Ada.
Trunchierea Gradienților (max_grad_norm = 1.0) `max_grad_norm = 1.0`	Limitarea normei vectorului de gradienți pentru prevenirea fenomenului de explozie numerică.
Frecvența Înregistrării Metricilor (logging_steps) `logging_steps = 1 # sau 5, 10`	Controlul intervalului de pași la care valoarea funcției de pierdere este tipărită în consolă.
Salvarea Periodică a Punctelor de Control (save_strategy & save_steps) `save_strategy = "steps"; save_steps = 50`	Salvarea automată a greutăților intermediare pentru a preveni pierderea progresului în caz de întreruperi.
Învățare prin Întărire: DPO, ORPO & GRPO
Inițializarea DPOTrainer pentru Optimizarea Preferințelor `from trl import DPOTrainer; dpo_trainer = DPOTrainer(model=model, ref_model=None, ...)`	Alinierea modelului cu preferințele umane prin algoritmul Direct Preference Optimization fără model de recompensă separat.
Configurarea Hiperparametrilor DPOConfig `from trl import DPOConfig; dpo_config = DPOConfig(beta=0.1, ...)`	Setările cheie pentru antrenarea prin DPO: beta, lungimi maxime și rate de învățare specifice alinierii.
Reglarea Coeficientului Beta (Penalizarea KL) `beta = 0.1 # Valori uzuale între 0.05 și 0.2`	Rolul parametrului beta în penalizarea abaterilor de la distribuția modelului de bază.
Formatul Seturilor de Date pentru DPO (prompt, chosen, rejected) `{"prompt": "...", "chosen": "răspuns bun", "rejected": "răspuns slab"}`	Structura obligatorie a datelor de preferință umană pentru antrenarea cu DPOTrainer.
Alinierea Fără Model de Referință prin ORPOTrainer `from trl import ORPOTrainer, ORPOConfig; orpo_trainer = ORPOTrainer(...)`	Metoda Odds Ratio Preference Optimization care combină SFT și alinierea de preferințe într-o singură fază.
Optimizarea GRPO (Group Relative Policy Optimization) în Unsloth `from trl import GRPOTrainer, GRPOConfig; grpo_trainer = GRPOTrainer(...)`	Implementarea algoritmului revoluționar din DeepSeek-R1 pentru antrenarea raționamentului prin eșantionare de grup.
Definirea Funcțiilor de Recompensă Bazate pe Reguli (Reward Functions) `def correctness_reward_func(prompts, completions, **kwargs): return [1.0 if ok else 0.0 for ok in ...]`	Construirea funcțiilor verificabile determinist (corectitudine matematică, format XML, parsare cod).
Setarea Dimensiunii Grupului de Eșantionare (num_generations) `num_generations = 4 # sau 8 pentru grupuri mai mari`	Numărul de răspunsuri candidate generate per prompt pentru calculul avantajului relativ.
Antrenarea Raționamentului Pas cu Pas cu Etichete `system_prompt = "Gândește pas cu pas în interiorul tagului ..."`	Tehnica de stimulare a raționamentului explicit înainte de generarea concluziei finale.
Optimizarea Kahneman-Tversky (KTOTrainer) pe Feedback Binar `from trl import KTOTrainer, KTOConfig; kto_trainer = KTOTrainer(...)`	Alinierea pe date de tip Like / Dislike fără a necesita perechi explicite de preferință între două răspunsuri.
Inferență Rapidă & Testare
Trecerea Modelului în Modul de Inferență cu FastLanguageModel.for_inference `FastLanguageModel.for_inference(model)`	Comanda obligatorie care dezactivează backpropagation și activează nucleele native Unsloth de generare 2x mai rapidă.
Afișarea în Timp Real a Răspunsurilor cu TextStreamer `from transformers import TextStreamer; text_streamer = TextStreamer(tokenizer)`	Afișarea token cu token în consolă a textului pe măsură ce este generat de GPU, fără așteptare.
Apelarea Metodei Native model.generate cu Tensori PyTorch `outputs = model.generate(**inputs, max_new_tokens=128, use_cache=True)`	Sintaxa corectă de pregătire a tensorilor de intrare și rulare a generării autoregresive.
Limitarea Lungimii Răspunsului cu max_new_tokens `max_new_tokens = 512`	Plafonarea numărului de tokeni noi generați pentru evitarea buclelor infinite și controlul latenței.
Controlul Creativității prin Parametrii temperature & top_p `temperature = 0.7; top_p = 0.9`	Reglarea distribuției de probabilitate pentru generare factuală precisă versus creativitate extinsă.
Penalizarea Repetițiilor (repetition_penalty) `repetition_penalty = 1.15`	Ajustarea logit-urilor pentru a împiedica modelul să repete aceleași fraze sau cuvinte în buclă.
Măsurarea Vitezei de Generare (Tokens Per Second Benchmark) `speed = num_generated_tokens / (end_time - start_time)`	Calcularea debitului de procesare al modelului pentru validarea performanțelor nucleelor Unsloth.
Construirea unei Bucle Interactive de Chat în Terminal `while True: user_input = input("Utilizator: "); ...`	Script complet de dialog multi-turn în consolă pentru testarea imediată a modelului finisat.
Salvare, Fuzionare & Export GGUF
Salvarea Exclusivă a Adaptorilor LoRA (model.save_pretrained) `model.save_pretrained("lora_model"); tokenizer.save_pretrained("lora_model")`	Salvarea fișierelor compacte de adaptare (sub 100 MB) care conțin exclusiv matricile LoRA antrenate.
Fuzionarea Adaptorilor în Precizie Completă 16-bit (save_pretrained_merged) `model.save_pretrained_merged("model_fuzionat_16bit", tokenizer, save_method="merged_16bit")`	Combinarea definitivă a matricilor LoRA cu modelul de bază într-un model autonom standard Hugging Face.
Salvarea Modelului Fuzionat pe 4 Biți (save_method=”merged_4bit”) `model.save_pretrained_merged("model_fuzionat_4bit", tokenizer, save_method="merged_4bit")`	Fuzionarea directă a adaptorilor păstrând modelul cuantizat pe 4 biți pentru economie de disc.
Exportul Direct în Format Binar GGUF pentru llama.cpp & Ollama `model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")`	Funcționalitatea exclusivă Unsloth de exportare într-un singur pas din modelul PyTorch într-un binar GGUF.
Metoda Recomandată de Cuantizare GGUF: q4_k_m `quantization_method = "q4_k_m"`	Formatul de cuantizare pe 4 biți cu cel mai bun raport din lume între viteză, consum de memorie și perplexitate.
Cuantizarea GGUF de Înaltă Fidelitate: q8_0 `quantization_method = "q8_0"`	Cuantizarea pe 8 biți care păstrează fidelitatea matematică aproape identică cu modelul pe 16 biți.
Exportul GGUF Necuantizat în Precizie float16 (f16) `quantization_method = "f16"`	Exportul binarului GGUF în precizie completă de 16 biți fără nicio cuantizare a ponderilor.
Publicarea Automată a Adaptorilor LoRA pe Hugging Face Hub `model.push_to_hub_merged("username/model_name", tokenizer, save_method="lora", token="hf_...")`	Încărcarea automată a fișierelor de configurare și safetensors în propriul cont Hugging Face.
Publicarea Automată a Fișierelor GGUF pe Hugging Face Hub `model.push_to_hub_gguf("username/model_name", tokenizer, quantization_method="q4_k_m", token="hf_...")`	Crearea automată a unui depozit GGUF gata de descărcat de comunitate și compatibil cu LM Studio.
Generarea Fișierului Modelfile și Importul Direct în Ollama `FROM ./model-unsloth.Q4_K_M.gguf\nTEMPLATE """..."""`	Transformarea modelului antrenat cu Unsloth într-un pachet local Ollama gata de rulat prin terminal.
Optimizare Hardware, VRAM & Producție
Statistici de Memorie cu FastLanguageModel (print_training_memory) `used_memory, used_percentage = torch.cuda.max_memory_reserved() ...`	Afișarea raportului de economie de memorie comparativ cu antrenarea clasică Hugging Face.
Echilibrarea Memoriei prin Pași Dinamici de Acumulare `gradient_accumulation_steps = target_batch_size // per_device_train_batch_size`	Formula optimă de calibrare a acumulării de gradienți pentru a preveni gâtuirile de memorie la lungimi mari de context.
Antrenarea Distribuită Multi-GPU cu DDP & Accelerate `accelerate launch --multi_gpu --num_processes=2 script_antrenare.py`	Scalarea antrenării Unsloth pe noduri cu mai multe plăci grafice prin PyTorch Distributed Data Parallel.
Monitorizarea Curbei de Pierdere în Weights & Biases (WandB) `import wandb; wandb.init(project="unsloth-finetuning"); args = TrainingArguments(report_to="wandb", ...)`	Conectarea fluxului de antrenare la platforma cloud Weights & Biases pentru urmărirea grafică a metricilor.
Vizualizarea Metricilor Local prin TensorBoard `args = TrainingArguments(report_to="tensorboard", logging_dir="./logs"); tensorboard --logdir ./logs`	Alternativa 100% privată și gratuită pentru urmărirea metricilor de antrenare fără conexiune la internet.
Reluarea Antrenării dintr-un Punct de Salvare (resume_from_checkpoint) `trainer.train(resume_from_checkpoint="./outputs/checkpoint-50")`	Procedura de continuare a procesului de optimizare de la ultimul pas salvat fără reîncepere.
Diagnoza și Rezolvarea Erorilor CUDA Out of Memory (OOM) `torch.cuda.empty_cache(); gc.collect()`	Protocolul sistematic de depanare pentru depășirea limitelor de memorie VRAM în timpul antrenării.

Configurare LoRA & QLoRA Avansat 12 comenzi

Inferență Rapidă & Testare 8 comenzi

Antrenare Supervizată cu SFTTrainer 14 comenzi

Învățare prin Întărire: DPO, ORPO & GRPO 10 comenzi

Încărcare Modele & Arhitecturi Suportate 10 comenzi

Optimizare Hardware, VRAM & Producție 7 comenzi

Instalare & Configurare Mediu 8 comenzi

Formatarea Dataset-urilor & Șabloane Chat 12 comenzi

Salvare, Fuzionare & Export GGUF 10 comenzi

Învață AI • Comunitate & Q&A

Discuții, Întrebări & Coduri / Prompturi Unsloth: Fine-Tuning LLM & Eficiență VRAM

Ai o nelămurire despre modulul Unsloth: Fine-Tuning LLM & Eficiență VRAM, cauți o soluție sau vrei să împărtășești un prompt sau fragment util de cod? Trimite mai jos contribuția ta.

🤖

Fii primul care pune o întrebare sau distribuie un fragment de cod / prompt!

Nu au fost adăugate încă întrebări sau resurse pentru această pagină. Dacă ai testat un prompt sau ai un snippet util, adaugă-l mai jos pentru comunitate.

Comunitate AI Adaugă o întrebare sau distribuie un cod / prompt Anulează răspunsul

Alege ce dorești să transmiți:

Titlu scurt (opțional)

Întrebarea ta *

Moderare & Siguranță:

Pentru a menține calitatea și securitatea informațiilor, fiecare întrebare sau fragment de cod/prompt este analizat (manual sau prin moderare asistată de AI) înainte de publicare.

Nume sau Pseudonim *

Adresă de Email * (nu va fi publicată)