SmolLM2 is a family of compact language models available in three size: 135M, 360M, and 1.7B parameters. They are capable of solving a wide range of tasks while being lightweight enough to run on-device. Fine-tuning a language model like SmolLM involves several steps, from setting up the environment to training the model and saving the results. Below is a detailed step-by-step guide based on the provided notebook file

How to use `Transformers`

pip install transformers

python

from transformers import AutoModelForCausalLM, AutoTokenizer
checkpoint = "prithivMLmods/Reasoning-SmolLM2-135M"

device = "cuda" # for GPU usage or "cpu" for CPU usage
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# for multiple GPUs install accelerate and do `model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto")`
model = AutoModelForCausalLM.from_pretrained(checkpoint).to(device)

messages = [{"role": "user", "content": "What is the capital of France."}]
input_text=tokenizer.apply_chat_template(messages, tokenize=False)
inputs = tokenizer.encode(input_text, return_tensors="pt").to(device)
outputs = model.generate(inputs, max_new_tokens=50, temperature=0.2, top_p=0.9, do_sample=True)
print(tokenizer.decode(outputs[0]))

Step 1: Setting Up the Environment

Before diving into fine-tuning, you need to set up your environment with the necessary libraries and tools.

Install Required Libraries:
- Install the necessary Python libraries using pip. These include transformers, datasets, trl, torch, accelerate, bitsandbytes, and wandb.
- These libraries are essential for working with Hugging Face models, datasets, and training loops.
!pip install transformers datasets trl torch accelerate bitsandbytes wandb
Import Necessary Modules:
- Import the required modules from the installed libraries. These include AutoModelForCausalLM, AutoTokenizer, TrainingArguments, pipeline, load_dataset, and SFTTrainer.
python
1from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, pipeline 2from datasets import load_dataset 3from trl import SFTConfig, SFTTrainer, setup_chat_format 4import torch 5import os
Detect Device (GPU, MPS, or CPU):
- Detect the available hardware (GPU, MPS, or CPU) to ensure the model runs on the most efficient device.
python
1device = ( 2 "cuda" 3 if torch.cuda.is_available() 4 else "mps" if torch.backends.mps.is_available() else "cpu" 5)

Step 2: Load the Pre-trained Model and Tokenizer

Next, load the pre-trained SmolLM model and its corresponding tokenizer.

Load the Model and Tokenizer:
- Use AutoModelForCausalLM and AutoTokenizer to load the SmolLM model and tokenizer from Hugging Face.
python
1model_name = "HuggingFaceTB/SmolLM2-360M" 2model = AutoModelForCausalLM.from_pretrained(pretrained_model_name_or_path=model_name) 3tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path=model_name)
Set Up Chat Format:
- Use the setup_chat_format function to prepare the model and tokenizer for chat-based tasks.
model, tokenizer = setup_chat_format(model=model, tokenizer=tokenizer)
Test the Base Model:
- Test the base model with a simple prompt to ensure it’s working correctly.
python
1prompt = "Explain AGI ?" 2pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, device=0 if device == "cuda" else -1) 3print(pipe(prompt, max_new_tokens=200))
If: Encountering:
- Chat template is already added to the tokenizer, indicates that the tokenizer already has a predefined chat template, which prevents the setup_chat_format() from modifying it again.

python

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

model_name = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name_or_path=model_name)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path=model_name)

tokenizer.chat_template = None

from trl.models.utils import setup_chat_format
model, tokenizer = setup_chat_format(model=model, tokenizer=tokenizer)

prompt = "Explain AGI?"
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, device=0)
print(pipe(prompt, max_new_tokens=200))

📍 Else Skip the Part [ Step 4 ] !

Step 3: Load and Prepare the Dataset

Fine-tuning requires a dataset. In this case, we’re using a custom dataset called Deepthink-Reasoning.

Load the Dataset:
- Use the load_dataset function to load the dataset from Hugging Face.
ds = load_dataset("prithivMLmods/Deepthink-Reasoning")
Tokenize the Dataset:
- Define a tokenization function that processes the dataset in batches. This function applies the chat template to each prompt-response pair and tokenizes the text.
python
1def tokenize_function(examples): 2 prompts = [p.strip() for p in examples["prompt"]] 3 responses = [r.strip() for r in examples["response"]] 4 texts = [ 5 tokenizer.apply_chat_template( 6 [{"role": "user", "content": p}, {"role": "assistant", "content": r}], 7 tokenize=False 8 ) 9 for p, r in zip(prompts, responses) 10 ] 11 return tokenizer(texts, truncation=True, padding="max_length", max_length=512)
Apply Tokenization:
- Apply the tokenization function to the dataset.
ds = ds.map(tokenize_function, batched=True)

Step 4: Configure Training Arguments

Set up the training arguments to control the fine-tuning process.

Define Training Arguments:
- Use TrainingArguments to specify parameters like batch size, learning rate, number of steps, and optimization settings.
python
1use_bf16 = torch.cuda.is_bf16_supported() 2training_args = TrainingArguments( 3 per_device_train_batch_size=2, 4 gradient_accumulation_steps=4, 5 warmup_steps=5, 6 max_steps=60, 7 learning_rate=2e-4, 8 fp16=not use_bf16, 9 bf16=use_bf16, 10 logging_steps=1, 11 optim="adamw_8bit", 12 weight_decay=0.01, 13 lr_scheduler_type="linear", 14 seed=3407, 15 output_dir="outputs", 16 report_to="wandb", 17)

Step 5: Initialize the Trainer

Initialize the SFTTrainer with the model, tokenizer, dataset, and training arguments.

python

trainer = SFTTrainer(
    model=model,
    processing_class=tokenizer,
    train_dataset=ds["train"],
    args=training_args,
)

Step 6: Start Training

Begin the fine-tuning process by calling the train method on the trainer.

trainer.train()

Step 7: Save the Fine-Tuned Model

After training, save the fine-tuned model and tokenizer to a local directory.

Save Model and Tokenizer:
- Use the save_pretrained method to save the model and tokenizer.
python
1save_directory = "/content/my_model" 2model.save_pretrained(save_directory) 3tokenizer.save_pretrained(save_directory)
Zip and Download the Model:
- Zip the saved directory and download it for future use.
python
1import shutil 2shutil.make_archive(save_directory, 'zip', save_directory) 3 4from google.colab import files 5files.download(f"{save_directory}.zip")

Model & Quant

Item	Link
Model	SmolLM2-CoT-360M
Quantized Version	SmolLM2-CoT-360M-GGUF

Notebook	Link
SmolLM-FT-360M	SmolLM-FT-360M.ipynb

Conclusion

Fine-tuning SmolLM involves setting up the environment, loading the model and dataset, configuring training parameters, and running the training loop. By following these steps, you can adapt SmolLM to your specific use case, whether it’s for reasoning tasks, chat-based applications, or other NLP tasks.

This process is highly customizable, so feel free to experiment with different datasets, hyperparameters, and training strategies to achieve the best results for your project.

prithivMLmods/Reasoning-SmolLM2-135M

REASONING SMOLLM2 135M ON CUSTOM SYNTHETIC DATA

How to use Transformers

Step 1: Setting Up the Environment

Step 2: Load the Pre-trained Model and Tokenizer

Step 3: Load and Prepare the Dataset

Step 4: Configure Training Arguments

Step 5: Initialize the Trainer

Step 6: Start Training

Step 7: Save the Fine-Tuned Model

Model & Quant

Conclusion

prithivMLmods/
Reasoning-SmolLM2-135M

How to use `Transformers`