Train AI Models with Unsloth and Hugging Face Jobs for Free 🚀

Table of Contents

• Train AI Models with Unsloth and Hugging Face Jobs for Free 🚀
  • Introduction
  • Prerequisites
  • Step 1: Project Setup
    • Setting up Unsloth CLI
    • Setting up Docker Environment
  • Step 2: Core Implementation
    • Main Training Script
• Define the tokenizer and model to use.
• Load your dataset here (e.g., from a CSV file).

📺 Watch: Neural Networks Explained

{{< youtube aircAruvnKk >}}

Video by 3Blue1Brown

Introduction

Training machine learning models can be expensive, especially when leverag [4]ing cloud resources. However, thanks to initiatives like Unsloth and Hugging Face's platform, researchers and developers now have access to powerful tools that enable them to train their models without incurring costs. This tutorial will guide you through setting up your development environment using these tools, configuring a model training job, and running it efficiently.

As of February 20, 2026, Hugging Face has amassed an impressive 156.7k stars on GitHub [1], reflecting its popularity among the machine learning community. Additionally, there are currently 2282 open issues on their repository as of today's date [2]. The last commit was made just a few days ago on February 20, 2026 [3].

Prerequisites

• Python version 3.10 or higher installed.
• Git for version control and cloning repositories.
• Docker for containerization to run the training jobs.
• unsloth CLI tool installed.
• Hugging Face account with access to their cloud resources.

To install the required tools, use the following commands:

pip install git+https://github.com/Unsloth/unsloth.git
git clone https://github.com/huggingface/transformers [8].git

Step 1: Project Setup

Setting up Unsloth CLI

Before we begin training our model, we need to set up the Unsloth command-line interface (CLI). This tool helps manage cloud resources without incurring costs. Follow these steps to install and configure it:

1. Install Unsloth: First, ensure you have Python 3.10 or higher installed on your system.

   pip install git+https://github.com/Unsloth/unsloth.git
   

2. Configure Unsloth: After installation, log in to your Unsloth account using the CLI.

   unsloth login --token <your_unsloth_token>
   

3. Clone Hugging Face Repository: Next, clone the transformers repository from Hugging Face’s GitHub page.

   git clone https://github.com/huggingface [8]/transformers.git
   cd transformers
   

Setting up Docker Environment

1. Install Docker: Ensure Docker is installed and running on your system.

2. Create a Dockerfile: In the transformers directory, create a Dockerfile. This file will define how to build the environment for training.

   # Use an official Python runtime as a parent image
   FROM python:3.10-slim
   
   # Set the working directory in the container
   WORKDIR /app
   
   # Copy the current directory contents into the container at /app
   COPY . /app
   
   # Install any needed packages specified in requirements.txt
   RUN pip install --no-cache-dir -r requirements.txt
   
   # Make port 80 available to the world outside this container
   EXPOSE 80
   
   # Define environment variable
   ENV NAME World
   
   # Run app.py when the container launches
   CMD ["python", "train_model.py"]
   

3. Build Docker Image: Build your Docker image using the Dockerfile.

   docker build -t unsloth-huggingface .
   

Step 2: Core Implementation

Main Training Script

We need a Python script that defines our model training process and integrates with Hugging Face's platform. Here’s how you can set it up:

1. Create train_model.py: This file will contain your main training logic.

from transformers import Trainer, TrainingArguments, AutoModelForSequenceClassification, AutoTokenizer

# Define the tokenizer and model to use.
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")

# Load your dataset here (e.g., from a CSV file).
# For simplicity, we'll assume you have a function `load_dataset` that returns train and validation datasets.

train_dataset, eval_dataset = load_dataset()

# Define training arguments.
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
)

# Initialize Trainer.
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=tokenizer
)

# Train the model.
trainer.train()

2. Run Training Job: Once your Docker image is built and your training script is ready, you can run a training job on Unsloth.

   unsloth jobs create --image unsloth-huggingface:latest --name my-training-job
   

Step 3: Configuration & Optimization

Configuring Training Arguments

The TrainingArguments class in Hugging Face’s transformers library allows for extensive configuration. Here are some key parameters you might want to tweak:

• Learning Rate: Adjust the learning rate based on your model's performance and dataset size.

• Batch Size: Experiment with different batch sizes to find a balance between speed and accuracy.

• Number of Epochs: Decide how many times you want your model to iterate over the entire dataset during training.

Refer to the official documentation for more details: https://huggingface.co/transformers/main_classes/trainer.html#trainingarguments

Optimizing Docker Configuration

Ensure that your Docker image is optimized by:

• Removing unnecessary packages.
• Using slim versions of base images (e.g., python:3.10-slim).
• Caching dependencies to speed up builds.

Step 4: Running the Code

To run your training job, use the following command in your terminal:

unsloth jobs start --name my-training-job

Expected Output: The output should indicate that your job has started and is running on Unsloth's cloud infrastructure. You can monitor its progress through the Unsloth dashboard.

Step 5: Advanced Tips (Deep Dive)

Performance Optimization

• Resource Allocation: Use unsloth jobs update to adjust resource allocation for better performance.

• Model Parallelism: For large models, consider using model parallelism techniques to distribute computations across multiple GPUs.

Security Considerations

• Ensure that your Docker image is secure by scanning it before deployment.
• Limit permissions and access controls within Unsloth’s environment.

Results & Benchmarks

By following this tutorial, you should have a functioning training pipeline set up on Unsloth using Hugging Face's resources. The exact performance will depend on the complexity of your model and dataset size but can be optimized based on the guidelines provided in the advanced tips section.

Going Further

• Explore more complex models and architectures.
• Integrate with other cloud services for additional functionality.
• Contribute to Unsloth and Hugging Face’s communities by sharing your experiences or improvements.

Conclusion

Training AI models without cost is now possible thanks to tools like Unsloth and Hugging Face's platform. By leveraging these resources, you can accelerate your machine learning projects while keeping expenses under control.