of the transform datasets.arrow_dataset.Dataset._map_single couldn't be hashed properly, a random hash was used instead. Make sure your transforms and parameters are serializable with pickle or dill for the dataset fingerprinting and caching to work. If you reuse this transform, the caching mechanism will consider it to be different from the previous calls and recompute everything. This warning is only showed once. Subsequent hashing failures won't be showed.\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"Map: 0%| | 0/1195 [00:00 torch.Tensor:\n",
" \"\"\"extract wav2vec2 features\"\"\"\n",
"\n",
" if wavs.shape[0] != 1:\n",
"\n",
" raise ValueError(f\"Expected batch size 1, but got shape {wavs.shape}\")\n",
" wav_np = wavs.squeeze(0).cpu().numpy()\n",
"\n",
" processed = audio_tokenizer.processor(\n",
" wav_np,\n",
" sampling_rate=16000,\n",
" return_tensors=\"pt\",\n",
" padding=True,\n",
" )\n",
" input_values = processed.input_values\n",
"\n",
" input_values = input_values.to(audio_tokenizer.feature_extractor.device)\n",
"\n",
" model_output = audio_tokenizer.feature_extractor(\n",
" input_values,\n",
" )\n",
"\n",
"\n",
" if model_output.hidden_states is None:\n",
" raise ValueError(\"Wav2Vec2Model did not return hidden states. Ensure config `output_hidden_states=True`.\")\n",
"\n",
" num_layers = len(model_output.hidden_states)\n",
" required_layers = [11, 14, 16]\n",
" if any(l >= num_layers for l in required_layers):\n",
" raise IndexError(f\"Requested hidden state indices {required_layers} out of range for model with {num_layers} layers.\")\n",
"\n",
" feats_mix = (\n",
" model_output.hidden_states[11] + model_output.hidden_states[14] + model_output.hidden_states[16]\n",
" ) / 3\n",
"\n",
" return feats_mix\n",
"def formatting_audio_func(example):\n",
" text = f\"{example['source']}: {example['text']}\" if \"source\" in example else example[\"text\"]\n",
" audio_array = example[\"audio\"][\"array\"]\n",
" sampling_rate = example[\"audio\"][\"sampling_rate\"]\n",
"\n",
" target_sr = audio_tokenizer.config['sample_rate']\n",
"\n",
" if sampling_rate != target_sr:\n",
" resampler = T.Resample(orig_freq=sampling_rate, new_freq=target_sr)\n",
" audio_tensor_temp = torch.from_numpy(audio_array).float()\n",
" audio_array = resampler(audio_tensor_temp).numpy()\n",
"\n",
" if audio_tokenizer.config[\"volume_normalize\"]:\n",
" audio_array = audio_volume_normalize(audio_array)\n",
"\n",
" ref_wav_np = audio_tokenizer.get_ref_clip(audio_array)\n",
"\n",
" audio_tensor = torch.from_numpy(audio_array).unsqueeze(0).float().to(audio_tokenizer.device)\n",
" ref_wav_tensor = torch.from_numpy(ref_wav_np).unsqueeze(0).float().to(audio_tokenizer.device)\n",
"\n",
"\n",
" feat = extract_wav2vec2_features(audio_tensor)\n",
"\n",
" batch = {\n",
"\n",
" \"wav\": audio_tensor,\n",
" \"ref_wav\": ref_wav_tensor,\n",
" \"feat\": feat.to(audio_tokenizer.device),\n",
" }\n",
"\n",
"\n",
" semantic_token_ids, global_token_ids = audio_tokenizer.model.tokenize(batch)\n",
"\n",
" global_tokens = \"\".join(\n",
" [f\"<|bicodec_global_{i}|>\" for i in global_token_ids.squeeze().cpu().numpy()] # Squeeze batch dim\n",
" )\n",
" semantic_tokens = \"\".join(\n",
" [f\"<|bicodec_semantic_{i}|>\" for i in semantic_token_ids.squeeze().cpu().numpy()] # Squeeze batch dim\n",
" )\n",
"\n",
" inputs = [\n",
" \"<|task_tts|>\",\n",
" \"<|start_content|>\",\n",
" text,\n",
" \"<|end_content|>\",\n",
" \"<|start_global_token|>\",\n",
" global_tokens,\n",
" \"<|end_global_token|>\",\n",
" \"<|start_semantic_token|>\",\n",
" semantic_tokens,\n",
" \"<|end_semantic_token|>\",\n",
" \"<|im_end|>\"\n",
" ]\n",
" inputs = \"\".join(inputs)\n",
" return {\"text\": inputs}\n",
"\n",
"\n",
"dataset = dataset.map(formatting_audio_func, remove_columns=[\"audio\"])\n",
"print(\"Moving Bicodec model and Wav2Vec2Model to cpu.\")\n",
"audio_tokenizer.model.cpu()\n",
"audio_tokenizer.feature_extractor.cpu()\n",
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "idAEIeSQ3xdS"
},
"source": [
"\n",
"### Train the model\n",
"Now let's use Huggingface TRL's `SFTTrainer`! More docs here: [TRL SFT docs](https://huggingface.co/docs/trl/sft_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`. We also support TRL's `DPOTrainer`!"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 49,
"referenced_widgets": [
"7de4a392df714df0ae1e1acd6503419d",
"74931e0e51334c4b8d7048dc131236d5",
"d824311557134897918d8d79e4d4689d",
"d31e7084aed340f79273d8d9e3ff537c",
"1575ae4db5154efb93d52421f0da0d86",
"01ba6ed7c5ef418cabf3e163cccef3da",
"bc0f157c665d4dd792ad2e63b41ad7b8",
"910b83ef6f8e4701b7f0697a02ee9883",
"ac1cb537155f4db7b3ff99f28338a7c5",
"689972ba3ce14cb18d36bbfef3a38d91",
"3d2d95274a2b455da1d64a5ca81b6ada"
]
},
"execution": {
"iopub.execute_input": "2025-03-22T00:34:09.688959Z",
"iopub.status.busy": "2025-03-22T00:34:09.688649Z",
"iopub.status.idle": "2025-03-22T00:34:09.729661Z",
"shell.execute_reply": "2025-03-22T00:34:09.729001Z",
"shell.execute_reply.started": "2025-03-22T00:34:09.688939Z"
},
"id": "95_Nn-89DhsL",
"outputId": "8796b468-bd41-45e6-fd6c-f838c6efbf77",
"trusted": true
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"Unsloth: Tokenizing [\"text\"] (num_proc=2): 0%| | 0/1195 [00:00"
],
"text/html": [
"\n",
" \n",
" \n",
"
\n",
" [60/60 06:24, Epoch 0/1]\n",
"
\n",
" \n",
" \n",
" | Step | \n",
" Training Loss | \n",
"
\n",
" \n",
" \n",
" \n",
" | 1 | \n",
" 6.990500 | \n",
"
\n",
" \n",
" | 2 | \n",
" 6.776000 | \n",
"
\n",
" \n",
" | 3 | \n",
" 6.873500 | \n",
"
\n",
" \n",
" | 4 | \n",
" 6.584700 | \n",
"
\n",
" \n",
" | 5 | \n",
" 6.427500 | \n",
"
\n",
" \n",
" | 6 | \n",
" 6.269300 | \n",
"
\n",
" \n",
" | 7 | \n",
" 6.243200 | \n",
"
\n",
" \n",
" | 8 | \n",
" 6.209600 | \n",
"
\n",
" \n",
" | 9 | \n",
" 6.287200 | \n",
"
\n",
" \n",
" | 10 | \n",
" 5.748000 | \n",
"
\n",
" \n",
" | 11 | \n",
" 5.853300 | \n",
"
\n",
" \n",
" | 12 | \n",
" 5.637000 | \n",
"
\n",
" \n",
" | 13 | \n",
" 5.745100 | \n",
"
\n",
" \n",
" | 14 | \n",
" 5.722300 | \n",
"
\n",
" \n",
" | 15 | \n",
" 5.695500 | \n",
"
\n",
" \n",
" | 16 | \n",
" 6.008900 | \n",
"
\n",
" \n",
" | 17 | \n",
" 5.802100 | \n",
"
\n",
" \n",
" | 18 | \n",
" 5.009600 | \n",
"
\n",
" \n",
" | 19 | \n",
" 5.785400 | \n",
"
\n",
" \n",
" | 20 | \n",
" 5.721100 | \n",
"
\n",
" \n",
" | 21 | \n",
" 5.777800 | \n",
"
\n",
" \n",
" | 22 | \n",
" 5.572100 | \n",
"
\n",
" \n",
" | 23 | \n",
" 5.941200 | \n",
"
\n",
" \n",
" | 24 | \n",
" 5.593900 | \n",
"
\n",
" \n",
" | 25 | \n",
" 5.832600 | \n",
"
\n",
" \n",
" | 26 | \n",
" 5.778300 | \n",
"
\n",
" \n",
" | 27 | \n",
" 5.436800 | \n",
"
\n",
" \n",
" | 28 | \n",
" 5.557700 | \n",
"
\n",
" \n",
" | 29 | \n",
" 5.388300 | \n",
"
\n",
" \n",
" | 30 | \n",
" 5.142400 | \n",
"
\n",
" \n",
" | 31 | \n",
" 5.755800 | \n",
"
\n",
" \n",
" | 32 | \n",
" 5.542800 | \n",
"
\n",
" \n",
" | 33 | \n",
" 5.841200 | \n",
"
\n",
" \n",
" | 34 | \n",
" 5.600500 | \n",
"
\n",
" \n",
" | 35 | \n",
" 5.306700 | \n",
"
\n",
" \n",
" | 36 | \n",
" 5.627700 | \n",
"
\n",
" \n",
" | 37 | \n",
" 5.452500 | \n",
"
\n",
" \n",
" | 38 | \n",
" 5.612600 | \n",
"
\n",
" \n",
" | 39 | \n",
" 5.376300 | \n",
"
\n",
" \n",
" | 40 | \n",
" 5.636700 | \n",
"
\n",
" \n",
" | 41 | \n",
" 5.475600 | \n",
"
\n",
" \n",
" | 42 | \n",
" 4.792700 | \n",
"
\n",
" \n",
" | 43 | \n",
" 5.458200 | \n",
"
\n",
" \n",
" | 44 | \n",
" 5.381400 | \n",
"
\n",
" \n",
" | 45 | \n",
" 5.399500 | \n",
"
\n",
" \n",
" | 46 | \n",
" 5.380400 | \n",
"
\n",
" \n",
" | 47 | \n",
" 5.693100 | \n",
"
\n",
" \n",
" | 48 | \n",
" 5.240300 | \n",
"
\n",
" \n",
" | 49 | \n",
" 5.673600 | \n",
"
\n",
" \n",
" | 50 | \n",
" 5.094000 | \n",
"
\n",
" \n",
" | 51 | \n",
" 5.561500 | \n",
"
\n",
" \n",
" | 52 | \n",
" 5.775800 | \n",
"
\n",
" \n",
" | 53 | \n",
" 5.318000 | \n",
"
\n",
" \n",
" | 54 | \n",
" 5.102000 | \n",
"
\n",
" \n",
" | 55 | \n",
" 5.650900 | \n",
"
\n",
" \n",
" | 56 | \n",
" 5.626300 | \n",
"
\n",
" \n",
" | 57 | \n",
" 5.427200 | \n",
"
\n",
" \n",
" | 58 | \n",
" 5.460900 | \n",
"
\n",
" \n",
" | 59 | \n",
" 5.520000 | \n",
"
\n",
" \n",
" | 60 | \n",
" 5.196000 | \n",
"
\n",
" \n",
"
"
]
},
"metadata": {}
}
],
"source": [
"trainer_stats = trainer.train()"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"cellView": "form",
"id": "pCqnaKmlO1U9",
"outputId": "5e2c7bc7-8c9e-4a2b-a1bb-e7b9e192d975",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"425.0452 seconds used for training.\n",
"7.08 minutes used for training.\n",
"Peak reserved memory = 7.621 GB.\n",
"Peak reserved memory for training = 2.611 GB.\n",
"Peak reserved memory % of max memory = 51.699 %.\n",
"Peak reserved memory for training % of max memory = 17.713 %.\n"
]
}
],
"source": [
"# @title Show final memory and time stats\n",
"used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)\n",
"used_memory_for_lora = round(used_memory - start_gpu_memory, 3)\n",
"used_percentage = round(used_memory / max_memory * 100, 3)\n",
"lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)\n",
"print(f\"{trainer_stats.metrics['train_runtime']} seconds used for training.\")\n",
"print(\n",
" f\"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.\"\n",
")\n",
"print(f\"Peak reserved memory = {used_memory} GB.\")\n",
"print(f\"Peak reserved memory for training = {used_memory_for_lora} GB.\")\n",
"print(f\"Peak reserved memory % of max memory = {used_percentage} %.\")\n",
"print(f\"Peak reserved memory for training % of max memory = {lora_percentage} %.\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ekOmTR1hSNcr"
},
"source": [
"\n",
"### Inference\n",
"Let's run the model! You can change the prompts\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"id": "apUdB40Ep6Ki"
},
"outputs": [],
"source": [
"input_text = \"Hey there my name is Elise, and I'm a speech generation model that can sound like a person.\"\n",
"\n",
"chosen_voice = None # None for single-speaker"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 249
},
"execution": {
"iopub.execute_input": "2025-03-22T00:52:35.040842Z",
"iopub.status.busy": "2025-03-22T00:52:35.040125Z",
"iopub.status.idle": "2025-03-22T00:52:35.050560Z",
"shell.execute_reply": "2025-03-22T00:52:35.049663Z",
"shell.execute_reply.started": "2025-03-22T00:52:35.040818Z"
},
"id": "krYI8PrRJ6MX",
"outputId": "c9b23961-9b67-433a-8681-7752659f5f45",
"trusted": true
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Generating speech for: 'Hey there my name is Elise, and I'm a speech generation model that can sound like a person.'\n",
"Generating token sequence...\n",
"Token sequence generated.\n",
"Found 367 semantic tokens.\n",
"Found 32 global tokens.\n",
"Detokenizing audio tokens...\n",
"Detokenization complete.\n",
"[-0.05137823 -0.0551073 -0.07785867 ... -0.00023214 0.02684273\n",
" -0.03908117]\n",
"Audio saved to generated_speech_controllable.wav\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
""
],
"text/html": [
"\n",
" \n",
" "
]
},
"metadata": {}
}
],
"source": [
"#@title Run Inference\n",
"\n",
"import torch\n",
"import re\n",
"import numpy as np\n",
"from typing import Dict, Any\n",
"import torchaudio.transforms as T\n",
"\n",
"FastModel.for_inference(model) # Enable native 2x faster inference\n",
"\n",
"@torch.inference_mode()\n",
"def generate_speech_from_text(\n",
" text: str,\n",
" temperature: float = 0.8, # Generation temperature\n",
" top_k: int = 50, # Generation top_k\n",
" top_p: float = 1, # Generation top_p\n",
" max_new_audio_tokens: int = 2048, # Max tokens for audio part\n",
" device: torch.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
") -> np.ndarray:\n",
" \"\"\"\n",
" Generates speech audio from text using default voice control parameters.\n",
"\n",
" Args:\n",
" text (str): The text input to be converted to speech.\n",
" temperature (float): Sampling temperature for generation.\n",
" top_k (int): Top-k sampling parameter.\n",
" top_p (float): Top-p (nucleus) sampling parameter.\n",
" max_new_audio_tokens (int): Max number of new tokens to generate (limits audio length).\n",
" device (torch.device): Device to run inference on.\n",
"\n",
" Returns:\n",
" np.ndarray: Generated waveform as a NumPy array.\n",
" \"\"\"\n",
"\n",
" prompt = \"\".join([\n",
" \"<|task_tts|>\",\n",
" \"<|start_content|>\",\n",
" text,\n",
" \"<|end_content|>\",\n",
" \"<|start_global_token|>\"\n",
" ])\n",
"\n",
" model_inputs = tokenizer([prompt], return_tensors=\"pt\").to(device)\n",
"\n",
" print(\"Generating token sequence...\")\n",
" generated_ids = model.generate(\n",
" **model_inputs,\n",
" max_new_tokens=max_new_audio_tokens, # Limit generation length\n",
" do_sample=True,\n",
" temperature=temperature,\n",
" top_k=top_k,\n",
" top_p=top_p,\n",
" eos_token_id=tokenizer.eos_token_id, # Stop token\n",
" pad_token_id=tokenizer.pad_token_id # Use models pad token id\n",
" )\n",
" print(\"Token sequence generated.\")\n",
"\n",
"\n",
" generated_ids_trimmed = generated_ids[:, model_inputs.input_ids.shape[1]:]\n",
"\n",
"\n",
" predicts_text = tokenizer.batch_decode(generated_ids_trimmed, skip_special_tokens=False)[0]\n",
" # print(f\"\\nGenerated Text (for parsing):\\n{predicts_text}\\n\") # Debugging\n",
"\n",
" # Extract semantic token IDs using regex\n",
" semantic_matches = re.findall(r\"<\\|bicodec_semantic_(\\d+)\\|>\", predicts_text)\n",
" if not semantic_matches:\n",
" print(\"Warning: No semantic tokens found in the generated output.\")\n",
" # Handle appropriately - perhaps return silence or raise error\n",
" return np.array([], dtype=np.float32)\n",
"\n",
" pred_semantic_ids = torch.tensor([int(token) for token in semantic_matches]).long().unsqueeze(0) # Add batch dim\n",
"\n",
" # Extract global token IDs using regex (assuming controllable mode also generates these)\n",
" global_matches = re.findall(r\"<\\|bicodec_global_(\\d+)\\|>\", predicts_text)\n",
" if not global_matches:\n",
" print(\"Warning: No global tokens found in the generated output (controllable mode). Might use defaults or fail.\")\n",
" pred_global_ids = torch.zeros((1, 1), dtype=torch.long)\n",
" else:\n",
" pred_global_ids = torch.tensor([int(token) for token in global_matches]).long().unsqueeze(0) # Add batch dim\n",
"\n",
" pred_global_ids = pred_global_ids.unsqueeze(0) # Shape becomes (1, 1, N_global)\n",
"\n",
" print(f\"Found {pred_semantic_ids.shape[1]} semantic tokens.\")\n",
" print(f\"Found {pred_global_ids.shape[2]} global tokens.\")\n",
"\n",
"\n",
" # 5. Detokenize using BiCodecTokenizer\n",
" print(\"Detokenizing audio tokens...\")\n",
" # Ensure audio_tokenizer and its internal model are on the correct device\n",
" audio_tokenizer.device = device\n",
" audio_tokenizer.model.to(device)\n",
" # Squeeze the extra dimension from global tokens as seen in SparkTTS example\n",
" wav_np = audio_tokenizer.detokenize(\n",
" pred_global_ids.to(device).squeeze(0), # Shape (1, N_global)\n",
" pred_semantic_ids.to(device) # Shape (1, N_semantic)\n",
" )\n",
" print(\"Detokenization complete.\")\n",
"\n",
" return wav_np\n",
"\n",
"if __name__ == \"__main__\":\n",
" print(f\"Generating speech for: '{input_text}'\")\n",
" text = f\"{chosen_voice}: \" + input_text if chosen_voice else input_text\n",
" generated_waveform = generate_speech_from_text(input_text)\n",
" print(generated_waveform)\n",
" if generated_waveform.size > 0:\n",
" import soundfile as sf\n",
" output_filename = \"generated_speech_controllable.wav\"\n",
" sample_rate = audio_tokenizer.config.get(\"sample_rate\", 16000)\n",
" sf.write(output_filename, generated_waveform, sample_rate)\n",
" print(f\"Audio saved to {output_filename}\")\n",
"\n",
" # Optional: Play in notebook\n",
" from IPython.display import Audio, display\n",
" display(Audio(generated_waveform, rate=sample_rate))\n",
" else:\n",
" print(\"Audio generation failed (no tokens found?).\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uMuVrWbjAzhc"
},
"source": [
"\n",
"### Saving, loading finetuned models\n",
"To save the final model as LoRA adapters, either use Huggingface's `push_to_hub` for an online save or `save_pretrained` for a local save.\n",
"\n",
"**[NOTE]** This ONLY saves the LoRA adapters, and not the full model. To save to 16bit or GGUF, scroll down!"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "upcOlWe7A1vc",
"outputId": "02fda77d-b81c-4c5e-feca-3efc49f2d971"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"('lora_model/tokenizer_config.json',\n",
" 'lora_model/special_tokens_map.json',\n",
" 'lora_model/vocab.json',\n",
" 'lora_model/merges.txt',\n",
" 'lora_model/added_tokens.json',\n",
" 'lora_model/tokenizer.json')"
]
},
"metadata": {},
"execution_count": 14
}
],
"source": [
"model.save_pretrained(\"lora_model\") # Local saving\n",
"tokenizer.save_pretrained(\"lora_model\")\n",
"# model.push_to_hub(\"your_name/lora_model\", token = \"...\") # Online saving\n",
"# tokenizer.push_to_hub(\"your_name/lora_model\", token = \"...\") # Online saving"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "f422JgM9sdVT"
},
"source": [
"### Saving to float16\n",
"\n",
"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."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"id": "iHjt_SMYsd3P"
},
"outputs": [],
"source": [
"# Merge to 16bit\n",
"if False: model.save_pretrained_merged(\"model\", tokenizer, save_method = \"merged_16bit\",)\n",
"if False: model.push_to_hub_merged(\"hf/model\", tokenizer, save_method = \"merged_16bit\", token = \"\")\n",
"\n",
"# Merge to 4bit\n",
"if False: model.save_pretrained_merged(\"model\", tokenizer, save_method = \"merged_4bit\",)\n",
"if False: model.push_to_hub_merged(\"hf/model\", tokenizer, save_method = \"merged_4bit\", token = \"\")\n",
"\n",
"# Just LoRA adapters\n",
"if False: model.save_pretrained_merged(\"model\", tokenizer, save_method = \"lora\",)\n",
"if False: model.push_to_hub_merged(\"hf/model\", tokenizer, save_method = \"lora\", token = \"\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Iop3vlyAwcSq"
},
"source": [
"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!\n",
"\n",
"Some other links:\n",
"1. Train your own reasoning model - Llama GRPO notebook [Free Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.1_(8B)-GRPO.ipynb)\n",
"2. Saving finetunes to Ollama. [Free notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_(8B)-Ollama.ipynb)\n",
"3. Llama 3.2 Vision finetuning - Radiography use case. [Free Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_(11B)-Vision.ipynb)\n",
"6. See notebooks for DPO, ORPO, Continued pretraining, conversational finetuning and more on our [documentation](https://docs.unsloth.ai/get-started/unsloth-notebooks)!\n",
"\n",
"\n",
"
![](\"https://github.com/unslothai/unsloth/raw/main/images/unsloth%20new%20logo.png\")
\n",
"
![](\"https://github.com/unslothai/unsloth/raw/main/images/Discord.png\")
\n",
"
![](\"https://github.com/unslothai/unsloth/blob/main/images/documentation%20green%20button.png?raw=true\")
\n",
"\n",
" Join Discord if you need help + ⭐️
Star us on Github ⭐️\n",
"
![](\"https://github.com/unslothai/unsloth/raw/main/images/Discord)
\n",
"