# /// script # requires-python = ">=3.10,<3.14" # dependencies = [ # "accelerate", # "bitsandbytes>=0.43.0", # "datasets==4.3.0", # "hf_transfer", # "huggingface_hub>=0.34.0", # "marimo", # "peft", # "protobuf", # "sentencepiece", # "torchao>=0.16.0", # "transformers==4.56.2", # "triton>=3.2.0", # "trl==0.22.2", # "unsloth @ git+https://github.com/unslothai/unsloth", # "unsloth_zoo @ git+https://github.com/unslothai/unsloth-zoo", # ] # # [tool.uv] # no-build-package = [ # "bitsandbytes", # "triton", # "vllm", # "xformers", # ] # /// import marimo __generated_with = "0.23.8" app = marimo.App() @app.cell def _(): import marimo as mo return (mo,) @app.cell(hide_code=True) def _(mo): mo.md(r""" To run this notebook, hit the **▶ Run all** button in the bottom-right corner - or use `Ctrl/Cmd + Shift + R`.

Join Discord if you need help + ⭐ Star us on Github ⭐

To install Unsloth on your local device, follow [our guide](https://unsloth.ai/docs/get-started/install). This notebook is licensed [LGPL-3.0](https://github.com/unslothai/notebooks?tab=LGPL-3.0-1-ov-file#readme). You will learn how to do [data prep](#Data), how to [train](#Train), how to [run the model](#Inference), & how to save it """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### News """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" Introducing **Unsloth Studio** - a new open source, no-code web UI to train and run LLMs. [Blog](https://unsloth.ai/docs/new/studio) • [Notebook](https://github.com/unslothai/unsloth/blob/main/studio/Unsloth_Studio_Colab.ipynb)

_{Train models — no code needed}

_{Run GGUF models on Mac, Windows & Linux}

Train MoEs - DeepSeek, GLM, Qwen and gpt-oss 12x faster with 35% less VRAM. [Blog](https://unsloth.ai/docs/new/faster-moe) Ultra Long-Context Reinforcement Learning is here with 7x more context windows! [Blog](https://unsloth.ai/docs/new/grpo-long-context) New in Reinforcement Learning: [FP8 RL](https://unsloth.ai/docs/new/fp8-reinforcement-learning) • [Vision RL](https://unsloth.ai/docs/new/vision-reinforcement-learning-vlm-rl) • [Standby](https://unsloth.ai/docs/basics/memory-efficient-rl) • [gpt-oss RL](https://unsloth.ai/docs/new/gpt-oss-reinforcement-learning) Visit our docs for all our [model uploads](https://unsloth.ai/docs/get-started/unsloth-model-catalog) and [notebooks](https://unsloth.ai/docs/get-started/unsloth-notebooks). """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Unsloth `FastModel` supports loading nearly any model now! This includes Vision and Text models! """) return @app.cell def _(): from unsloth import FastModel from transformers import AutoModelForSequenceClassification import torch # Disable fast generation for bert! import os os.environ["UNSLOTH_DISABLE_FAST_GENERATION"] = "1" max_seq_length = 2048 # Choose any! We auto support RoPE Scaling internally! dtype = None # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+ load_in_4bit = False # Use 4bit quantization to reduce memory usage. Can be False. # 4bit pre quantized models we support for 4x faster downloading + no OOMs. fourbit_models = [ "unsloth/Llama-3.1-8B-bnb-4bit", # Llama-3.1 15 trillion tokens model 2x faster! "unsloth/Llama-3.1-8B-Instruct-bnb-4bit", "unsloth/Llama-3.1-70B-bnb-4bit", "unsloth/Llama-3.1-405B-bnb-4bit", # We also uploaded 4bit for 405b! "unsloth/Mistral-Nemo-Base-2407-bnb-4bit", # New Mistral 12b 2x faster! "unsloth/Mistral-Nemo-Instruct-2407-bnb-4bit", "unsloth/mistral-7b-v0.3-bnb-4bit", # Mistral v3 2x faster! "unsloth/mistral-7b-instruct-v0.3-bnb-4bit", "unsloth/Phi-3.5-mini-instruct", # Phi-3.5 2x faster! "unsloth/Phi-3-medium-4k-instruct", "unsloth/gemma-2-9b-bnb-4bit", "unsloth/gemma-2-27b-bnb-4bit", # Gemma 2x faster! ] # More models at https://huggingface.co/unsloth id2label = {0: "sadness", 1: "joy", 2: "love", 3: "anger", 4: "fear", 5: "surprise"} label2id = {"sadness": 0, "joy": 1, "love": 2, "anger": 3, "fear": 4, "surprise": 5} model, tokenizer = FastModel.from_pretrained( model_name="unsloth/ModernBERT-large", auto_model=AutoModelForSequenceClassification, max_seq_length=max_seq_length, # Choose any! We auto support RoPE Scaling internally! dtype=dtype, # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+ num_labels=6, full_finetuning=True, id2label=id2label, label2id=label2id, load_in_4bit=load_in_4bit, # Use 4bit quantization to reduce memory usage. Can be False. # token = "YOUR_HF_TOKEN", # HF Token for gated models ) return FastModel, model, tokenizer @app.cell(hide_code=True) def _(mo): mo.md(r""" We now add LoRA adapters so we only need to update a small amount of parameters! """) return @app.cell def _(FastModel, model): model_1 = FastModel.get_peft_model( model, r=16, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128 target_modules=[ "q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj", ], lora_alpha=16, lora_dropout=0, # Supports any, but = 0 is optimized bias="none", # Supports any, but = "none" is optimized use_gradient_checkpointing="unsloth", # True or "unsloth" for very long context random_state=3407, use_rslora=False, # We support rank stabilized LoRA loftq_config=None, # And LoftQ task_type="SEQ_CLS", ) return (model_1,) @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Data Prep We now use the [Emotion dataset](https://huggingface.co/datasets/dair-ai/emotion) from `dair-ai`, which contains text labeled by emotion. In this example, we load the **unsplit** version and use only the first 30,000 samples. We then split the dataset into training (80%) and validation (20%), and apply tokenization to prepare the text for training. """) return @app.cell def _(tokenizer): from datasets import load_dataset # Load the IMDB dataset dataset = load_dataset("dair-ai/emotion", "unsplit", split="train[:30000]") # Split into training and validation sets dataset = dataset.train_test_split(test_size=0.2) def tokenize_function(examples): return tokenizer(examples["text"]) # Apply the tokenizer to the dataset train_dataset = dataset["train"].map(tokenize_function, batched=True) val_dataset = dataset["test"].map(tokenize_function, batched=True) return train_dataset, val_dataset @app.cell(hide_code=True) def _(mo): mo.md(r""" We compute **class weights** using scikit-learn’s ```compute_class_weight```. This is useful when training on datasets where certain classes are underrepresented, ensuring the model does not become biased towards majority labels. """) return @app.cell def _(train_dataset): from sklearn.utils.class_weight import compute_class_weight import numpy as np labels = train_dataset["label"] class_weights = compute_class_weight( "balanced", classes=np.unique(labels), y=labels ) return (class_weights,) @app.cell def _(train_dataset, val_dataset): # We rename the dataset column from **`label`** to **`labels`**, since this is the expected field name for Hugging Face `Trainer`. train_dataset_1 = train_dataset.rename_column("label", "labels") val_dataset_1 = val_dataset.rename_column("label", "labels") return train_dataset_1, val_dataset_1 @app.cell def _(class_weights): class_weights return @app.cell(hide_code=True) def _(mo): mo.md(r""" We define a `compute_metrics` function to evaluate the model during training. Here we use **accuracy** from scikit-learn, which compares predicted labels with the ground truth. **[NOTE]** Accuracy is a good baseline, but for imbalanced datasets you may also want to track metrics like **F1-score**, **precision**, or **recall**. """) return @app.cell def _(): from sklearn.metrics import accuracy_score def compute_metrics(eval_pred): logits, labels = eval_pred preds = logits.argmax(axis=-1) return {"accuracy": accuracy_score(labels, preds)} return (compute_metrics,) @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Train the model Now let's use Hugging Face `Trainer`! More docs here: [Transformers docs](https://huggingface.co/docs/transformers/main_classes/trainer). We train for one full epoch (num_train_epochs=1) to get a meaningful result. """) return @app.cell def _(compute_metrics, model_1, tokenizer, train_dataset_1, val_dataset_1): from transformers import TrainingArguments, Trainer from unsloth import is_bfloat16_supported trainer = Trainer( model=model_1, processing_class=tokenizer, eval_dataset=val_dataset_1, train_dataset=train_dataset_1, args=TrainingArguments( per_device_train_batch_size=32, gradient_accumulation_steps=1, warmup_steps=5, num_train_epochs=1, # bert-style models usually need more than 1 epoch learning_rate=5e-05, fp16=not is_bfloat16_supported(), bf16=is_bfloat16_supported(), logging_steps=1, optim="adamw_8bit", weight_decay=0.001, eval_strategy="steps", eval_steps=0.1, # Evaluate every 10% of total training steps lr_scheduler_type="linear", seed=3407, output_dir="outputs", report_to="none", # Use TrackIO/WandB etc ), compute_metrics=compute_metrics, ) return (trainer,) @app.cell(hide_code=True) def _(mo): mo.md(r""" Let's train the model! To resume a training run, set `trainer.train(resume_from_checkpoint = True)` """) return @app.cell def _(trainer): trainer_stats = trainer.train() return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Inference Let's run the model ! """) return @app.cell def _(model_1, tokenizer): from transformers import pipeline sentence1 = "We just finished training ModernBERT with Unsloth and it's amazing!" classifier = pipeline("sentiment-analysis", model=model_1, tokenizer=tokenizer) classifier(sentence1) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Saving finetuned models To save the final model, either use Hugging Face's `push_to_hub` for an online save or `save_pretrained` for a local save. """) return @app.cell def _(model_1, tokenizer): model_1.save_pretrained("bert_classification_lora") tokenizer.save_pretrained("bert_classification_lora") return @app.cell(hide_code=True) def _(mo): mo.md(r""" And we're done! If you have any questions on Unsloth, we have a [Discord](https://discord.gg/unsloth) channel! If you find any bugs or want to keep updated with the latest LLM stuff, or need help, join projects etc, feel free to join our Discord! Some other resources: 1. Train your own reasoning model - Llama GRPO notebook [Open in molab](https://github.com/unslothai/notebooks/blob/main/nb/Llama3.1_(8B)-GRPO.ipynb) 2. Saving finetunes to Ollama. [Free notebook](https://github.com/unslothai/notebooks/blob/main/nb/Llama3_(8B)-Ollama.ipynb) 3. Llama 3.2 Vision finetuning - Radiography use case. [Open in molab](https://github.com/unslothai/notebooks/blob/main/nb/Llama3.2_(11B)-Vision.ipynb) 4. See notebooks for DPO, ORPO, Continued pretraining, conversational finetuning and more on our [documentation](https://unsloth.ai/docs/get-started/unsloth-notebooks)!

Join Discord if you need help + ⭐️ Star us on Github ⭐️

This notebook and all Unsloth notebooks are licensed [LGPL-3.0](https://github.com/unslothai/notebooks?tab=LGPL-3.0-1-ov-file#readme). """) return if __name__ == "__main__": app.run()