# /// 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", # "torchcodec", # "transformers==4.52.3", # "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 CsmForConditionalGeneration import torch model, processor = FastModel.from_pretrained( model_name="unsloth/csm-1b", max_seq_length=2048, # Choose any for long context! dtype=None, # Leave as None for auto-detection auto_model=CsmForConditionalGeneration, load_in_4bit=False, # Select True for 4bit - reduces memory usage ) return FastModel, model, torch @app.cell(hide_code=True) def _(mo): mo.md(r""" We now add LoRA adapters so we only need to update 1 to 10% of all parameters! """) return @app.cell def _(FastModel, model): model_1 = FastModel.get_peft_model( model, r=32, # 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=32, 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 ) return (model_1,) @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Data Prep We will use the `MrDragonFox/Elise`, which is designed for training TTS models. Ensure that your dataset follows the required format: **text, audio** for single-speaker models or **source, text, audio** for multi-speaker models. You can modify this section to accommodate your own dataset, but maintaining the correct structure is essential for optimal training. """) return @app.cell def _(torch): # @title Dataset Prep functions from datasets import load_dataset, Audio, Dataset import os from transformers import AutoProcessor processor_1 = AutoProcessor.from_pretrained("unsloth/csm-1b") raw_ds = load_dataset("MrDragonFox/Elise", split="train") speaker_key = "source" if "source" not in raw_ds.column_names and "speaker_id" not in raw_ds.column_names: # Getting the speaker id is important for multi-speaker models and speaker consistency print( 'Unsloth: No speaker found, adding default "source" of 0 for all examples' ) new_column = ["0"] * len(raw_ds) raw_ds = raw_ds.add_column("source", new_column) elif "source" not in raw_ds.column_names and "speaker_id" in raw_ds.column_names: speaker_key = "speaker_id" target_sampling_rate = 24000 raw_ds = raw_ds.cast_column("audio", Audio(sampling_rate=target_sampling_rate)) def preprocess_example(example): conversation = [ { "role": str(example[speaker_key]), "content": [ {"type": "text", "text": example["text"]}, {"type": "audio", "path": example["audio"]["array"]}, ], } ] try: model_inputs = processor_1.apply_chat_template( conversation, tokenize=True, return_dict=True, output_labels=True, text_kwargs={ "padding": "max_length", "max_length": 256, "pad_to_multiple_of": 8, "padding_side": "right", }, audio_kwargs={ "sampling_rate": 24000, "max_length": 240001, "padding": "max_length", }, common_kwargs={"return_tensors": "pt"}, ) except Exception as e: print( f"Error processing example with text '{example['text'][:50]}...': {e}" ) return None required_keys = [ "input_ids", "attention_mask", "labels", "input_values", "input_values_cutoffs", ] processed_example = {} for key in required_keys: if key not in model_inputs: print( f"Warning: Required key '{key}' not found in processor output for example." ) return None value = model_inputs[key][0] processed_example[key] = value if not all( ( isinstance(processed_example[key], torch.Tensor) for key in processed_example ) ): print( f"Error: Not all required keys are tensors in final processed example. Keys: {list(processed_example.keys())}" ) return None return processed_example processed_ds = raw_ds.map( preprocess_example, remove_columns=raw_ds.column_names, desc="Preprocessing dataset", ) return Audio, processed_ds, processor_1, raw_ds @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 do 60 steps to speed things up, but you can set `num_train_epochs=1` for a full run, and turn off `max_steps=None`. """) return @app.cell def _(model_1, processed_ds): from transformers import TrainingArguments, Trainer from unsloth import is_bfloat16_supported trainer = Trainer( model=model_1, train_dataset=processed_ds, args=TrainingArguments( per_device_train_batch_size=2, gradient_accumulation_steps=4, warmup_steps=5, max_steps=60, learning_rate=0.0002, fp16=not is_bfloat16_supported(), bf16=is_bfloat16_supported(), logging_steps=1, optim="adamw_8bit", weight_decay=0.001, # Turn this on if overfitting lr_scheduler_type="linear", seed=3407, output_dir="outputs", report_to="none", # Use TrackIO/WandB etc ), ) return (trainer,) @app.cell def _(torch): # @title Show current memory stats gpu_stats = torch.cuda.get_device_properties(0) start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3) max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3) print(f"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.") print(f"{start_gpu_memory} GB of memory reserved.") return max_memory, start_gpu_memory @app.cell def _(trainer): trainer_stats = trainer.train() return (trainer_stats,) @app.cell def _(max_memory, start_gpu_memory, torch, trainer_stats): # @title Show final memory and time stats used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3) used_memory_for_lora = round(used_memory - start_gpu_memory, 3) used_percentage = round(used_memory / max_memory * 100, 3) lora_percentage = round(used_memory_for_lora / max_memory * 100, 3) print(f"{trainer_stats.metrics['train_runtime']} seconds used for training.") print( f"{round(trainer_stats.metrics['train_runtime'] / 60, 2)} minutes used for training." ) print(f"Peak reserved memory = {used_memory} GB.") print(f"Peak reserved memory for training = {used_memory_for_lora} GB.") print(f"Peak reserved memory % of max memory = {used_percentage} %.") print(f"Peak reserved memory for training % of max memory = {lora_percentage} %.") return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Inference Let's run the model! You can change the prompts """) return @app.cell def _(Audio, model_1, processor_1, torch): from IPython.display import display import soundfile as sf text = ( "We just finished fine tuning a text to speech model... and it's pretty good!" ) speaker_id = 0 inputs = processor_1(f"[{speaker_id}]{text}", add_special_tokens=True).to("cuda") audio_values = model_1.generate(**inputs, max_new_tokens=125, output_audio=True) audio = audio_values[0].to(torch.float32).cpu().numpy() sf.write("example_without_context.wav", audio, 24000) display( Audio(audio, rate=24000) )######################################################### return display, sf @app.cell def _(Audio, display, model_1, processor_1, sf, torch): text_1 = "Sesame is a super cool TTS model which can be fine tuned with Unsloth." speaker_id_1 = 0 conversation = [ {"role": str(speaker_id_1), "content": [{"type": "text", "text": text_1}]} ] # Another equivalent way to prepare the inputs audio_values_1 = model_1.generate( **processor_1.apply_chat_template( conversation, tokenize=True, return_dict=True ).to("cuda"), max_new_tokens=125, # 125 tokens is 10 seconds of audio, for longer speech increase this output_audio=True, ) audio_1 = audio_values_1[0].to(torch.float32).cpu().numpy() sf.write("example_without_context.wav", audio_1, 24000) display( Audio(audio_1, rate=24000) )######################################################### return @app.cell(hide_code=True) def _(mo): mo.md(r""" #### Voice and style consistency Sesame CSM's power comes from providing audio context for each speaker. Let's pass a sample utterance from our dataset to ground speaker identity and style. """) return @app.cell def _(Audio, display, model_1, processor_1, raw_ds, sf, torch): speaker_id_2 = 0 utterance = raw_ds[3]["audio"]["array"] utterance_text = raw_ds[3]["text"] text_2 = "Sesame is a super cool TTS model which can be fine tuned with Unsloth." conversation_1 = [ { "role": str(speaker_id_2), "content": [ {"type": "text", "text": utterance_text}, {"type": "audio", "path": utterance}, ], }, {"role": str(speaker_id_2), "content": [{"type": "text", "text": text_2}]}, ] inputs_1 = processor_1.apply_chat_template( conversation_1, tokenize=True, return_dict=True ) audio_values_2 = model_1.generate( **inputs_1.to("cuda"), max_new_tokens=125, output_audio=True ) audio_2 = audio_values_2[0].to(torch.float32).cpu().numpy() sf.write("example_with_context.wav", audio_2, 24000) display( Audio(audio_2, rate=24000) )######################################################### return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Saving, loading finetuned models To save the final model as LoRA adapters, either use Hugging Face's `push_to_hub` for an online save or `save_pretrained` for a local save. **[NOTE]** This ONLY saves the LoRA adapters, and not the full model. To save to 16bit or GGUF, scroll down! """) return @app.cell def _(model_1, processor_1): model_1.save_pretrained("sesame_csm_lora") processor_1.save_pretrained("sesame_csm_lora") return @app.cell(hide_code=True) def _(mo): mo.md(r""" ### Saving to float16 We also support saving to `float16` directly. Select `merged_16bit` for float16 or `merged_4bit` for int4. We also allow `lora` adapters as a fallback. Use `push_to_hub_merged` to upload to your Hugging Face account! You can go to https://huggingface.co/settings/tokens for your personal tokens. See [our docs](https://unsloth.ai/docs/basics/inference-and-deployment) for more deployment options. """) return @app.cell def _(model_1, processor_1): # Merge to 16bit if False: model_1.save_pretrained_merged( "sesame_csm_finetune_16bit", processor_1, save_method="merged_16bit" ) if False: # Merge to 4bit model_1.push_to_hub_merged( "HF_USERNAME/sesame_csm_finetune_16bit", processor_1, save_method="merged_16bit", token="YOUR_HF_TOKEN", ) if False: model_1.save_pretrained_merged( "sesame_csm_finetune_4bit", processor_1, save_method="merged_4bit" ) # Just LoRA adapters if False: model_1.push_to_hub_merged( "HF_USERNAME/sesame_csm_finetune_4bit", processor_1, save_method="merged_4bit", token="YOUR_HF_TOKEN", ) if False: model_1.save_pretrained("sesame_csm_lora") processor_1.save_pretrained("sesame_csm_lora") if False: model_1.push_to_hub("HF_USERNAME/sesame_csm_lora", token="YOUR_HF_TOKEN") processor_1.push_to_hub("HF_USERNAME/sesame_csm_lora", token="YOUR_HF_TOKEN") 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. Looking to use Unsloth locally? Read our [Installation Guide](https://unsloth.ai/docs/get-started/install) for details on installing Unsloth on Windows, Docker, AMD, Intel GPUs. 2. Learn how to do Reinforcement Learning with our [RL Guide and notebooks](https://unsloth.ai/docs/get-started/reinforcement-learning-rl-guide). 3. Read our guides and notebooks for [Text-to-speech (TTS)](https://unsloth.ai/docs/basics/text-to-speech-tts-fine-tuning) and [vision](https://unsloth.ai/docs/basics/vision-fine-tuning) model support. 4. Explore our [LLM Tutorials Directory](https://unsloth.ai/docs/models/tutorials-how-to-fine-tune-and-run-llms) to find dedicated guides for each model. 5. Need help with Inference? Read our [Inference & Deployment page](https://unsloth.ai/docs/basics/inference-and-deployment) for details on using vLLM, llama.cpp, Ollama etc.

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()