⚡ Technical Documentation

Fine Tuning Language Models With Hugging Face Autotrain

Technical guide covering fine tuning language models with hugging face autotrain

👤
Author
Cosmic Lounge AI Team
📅
Updated
6/1/2025
⏱️
Read Time
10 min
Topics
#llm #ai #model #fine-tuning #training #gpu #pytorch #setup

📖 Reading Mode

📖 Table of Contents

🌌 Fine-Tuning Language Models with Hugging Face AutoTrain

Hugging Face AutoTrain is a powerful tool that allows you to fine-tune large language models (LLMs) without writing any code. This article will explore the settings and configuration options available in AutoTrain for fine-tuning various LLMs, including llama 3.2, llama 3.1, gemma2, granite 3, and phi4. We will delve into the specific settings for each model, discuss general fine-tuning parameters, and provide examples of YAML configuration files.

🌟 Fine-tuning Llama 3.2 with AutoTrain

While there isn’t specific documentation on fine-tuning Llama 3.2 with AutoTrain, we can extrapolate from the information available for Llama 3 and other models. Here’s a breakdown of the key settings and considerations:

  • Model Selection: Start by selecting the Llama 3.2 model you want to fine-tune. Ensure you choose the appropriate variant based on your needs (e.g., base model, instruction-tuned model).

  • Dataset Preparation: AutoTrain expects your data in a CSV file with a “text” column. The format of the text column depends on the model and the fine-tuning task. For Llama 3.2, you might need to use a specific chat template or format the data yourself.

  • Quantization: Consider using quantization techniques like 4-bit or 16-bit to reduce memory usage and speed up training.

  • Parameter-Efficient Fine-Tuning (PEFT): Utilize PEFT techniques, such as LoRA (Low-Rank Adaptation), to fine-tune only a fraction of the model parameters, saving resources and time.

  • Training Parameters: Adjust the learning rate, batch size, epochs, and other hyperparameters based on your dataset and hardware.

  • Memory Optimization: For large models like Llama 3.2, optimize memory usage by using appropriate block size, enabling mixed precision training, and utilizing PEFT techniques. Specifically, ensure you use appropriate block_size and model_max_length parameters based on your hardware and data characteristics.

🌟 Fine-tuning Llama 3.1 with AutoTrain

Similar to Llama 3.2, there isn’t specific documentation on fine-tuning Llama 3.1 with AutoTrain. However, we can use the information available for Llama 3 and other models to guide the process. Here’s a summary of the key settings:

  • Unsloth Library: Consider using the Unsloth library for efficient fine-tuning of Llama 3.1. It offers faster training and reduced memory usage compared to other options.

  • Maximum Sequence Length: When loading the model, specify a maximum sequence length to restrict the context window. Llama 3.1 supports up to 128k context length, but you can adjust it based on your data and hardware limitations.

  • LoRA (Low-Rank Adaptation): Utilize LoRA for efficient fine-tuning. Adjust the rank (r), alpha (α), and target modules to optimize performance and memory usage.

  • Training with SFTTrainer: Use the SFTTrainer from the TRL library for supervised fine-tuning. Configure the trainer with appropriate hyperparameters, such as learning rate, batch size, and epochs.

  • NeuronSFTTrainer: If you’re using AWS Trainium instances, consider using the NeuronSFTTrainer for optimized performance. This trainer leverages the capabilities of Trainium instances to accelerate the fine-tuning process.

  • TextStreamer: For text generation with the fine-tuned Llama 3.1 model, consider using the TextStreamer to stream the output text. This can be helpful for interactive applications or when generating long sequences of text.

🌟 Fine-tuning Gemma2 with AutoTrain

While AutoTrain doesn’t have dedicated documentation specifically for fine-tuning Gemma2, there are resources and examples available to guide the process. Here’s a breakdown of the key considerations:

  • Model Optimization: Gemma2 models in Hugging Face Transformers are optimized for both PyTorch and PyTorch/XLA, enabling both TPU and GPU users to fine-tune them.

  • PEFT with LoRA: Utilize PEFT with LoRA for efficient fine-tuning. Select the target modules where adapter weights should be applied.

  • Training with SFTTrainer: Use the SFTTrainer from the TRL library for supervised fine-tuning. Configure the trainer with appropriate hyperparameters.

  • FSDP (Fully Sharded Data Parallel): Consider using FSDP for training large Gemma2 models. Configure the FSDP settings in the TrainingArguments to enable efficient training. You can use the trl sft command from the TRL CLI to initiate the fine-tuning process on GKE.

  • IAM Permissions on GKE: When fine-tuning Gemma2 on GKE, ensure you set the appropriate IAM permissions for the GCS bucket to allow the training pod to access and write artifacts.

🌟 Fine-tuning Granite 3 with AutoTrain

Although there isn’t specific documentation on fine-tuning Granite 3 with AutoTrain, we can adapt the general LLM fine-tuning guidelines and information from other sources. Here’s a summary of the key settings:

  • Data Formatting: Format your data using a chatbot structure, including system messages, user queries, and assistant responses. For example, you can use the Geometric Perception dataset, which contains images of geometric diagrams paired with question-answer pairs, to fine-tune Granite 3 for visual reasoning tasks.

  • Quantization with QLoRA: Utilize QLoRA for efficient fine-tuning with quantized models.

  • Training with SFTTrainer: Use the SFTTrainer from the TRL library for supervised fine-tuning. Configure the trainer with appropriate hyperparameters.

  • Saving and Sharing: Consider saving the fine-tuned model to the Hugging Face Hub for easy sharing and collaboration. Uploading your model to the Hugging Face Hub offers benefits like easy sharing, version control, integration with other tools, and simplified deployment.

🌟 Fine-tuning Phi-4 with AutoTrain

While AutoTrain doesn’t provide specific documentation for fine-tuning Phi-4, we can adapt the general LLM fine-tuning guidelines and information from other sources. Here’s a summary of the key settings:

  • LoRA with PEFT: Utilize LoRA with PEFT for efficient fine-tuning. Adjust the rank (r) and other LoRA parameters to optimize performance and memory usage.

  • Data Preparation: Prepare your data in a suitable format, such as the ShareGPT format, and apply the appropriate chat template for Phi-4.

  • Training with SFTTrainer: Use the SFTTrainer from the TRL library for supervised fine-tuning. Configure the trainer with appropriate hyperparameters.

  • Saving and Sharing: Consider saving the fine-tuned model locally or pushing it to the Hugging Face Hub for easy access and sharing.

  • Sentence Transformer Fine-tuning Tasks: AutoTrain supports various sentence transformer fine-tuning tasks, including pair, pair_class, pair_score, triplet, and qa. Choose the appropriate task type based on your data and fine-tuning objective.

⚡ Column Mapping

AutoTrain requires specific column mapping for different sentence transformer fine-tuning tasks. Here’s a table summarizing the mapping:

TaskColumn Mapping
pair{“sentence1_column”: “anchor”, “sentence2_column”: “positive”}…source

🌟 General Fine-tuning Settings in AutoTrain

In addition to the model-specific settings, AutoTrain provides various general parameters for fine-tuning LLMs. These parameters can be adjusted to optimize the training process and achieve better results. Here’s a table summarizing the key general settings:

CategorySettingDescription
Basic SettingsmodelModel name to be used for training.
project_nameName of the project and output directory.
data_pathPath to the dataset.
epochsNumber of training epochs.
batch_sizeBatch size for training.
lr (learning rate)Learning rate for training.
LoRA SettingspeftWhether to use Parameter-Efficient Fine-Tuning (PEFT). PEFT techniques like LoRA can significantly reduce the computational resources and time required for fine-tuning large LLMs, making it feasible to fine-tune them on consumer-grade hardware.
lora_rRank of the LoRA matrices.
lora_alphaAlpha parameter for LoRA.
lora_dropoutDropout rate for LoRA.
Optimizer and Scheduler SettingsoptimizerOptimizer to use for training.
schedulerLearning rate scheduler to use.
Memory Optimization Settingsblock_sizeMaximum sequence length or length of one block of text.
model_max_lengthMaximum length of the model input.
gradient_accumulationNumber of steps to accumulate gradients before updating.
mixed_precisionType of mixed precision to use (e.g., ‘fp16’, ‘bf16’).
quantizationQuantization method to use (e.g., ‘int4’, ‘int8’).
Other Settingschat_templateTemplate for chat-based models. Choosing the correct chat_template is crucial for ensuring the model understands the input format and generates appropriate responses.
logLogging method for experiment tracking.
Experiment TrackingAutoTrain integrates with Weights & Biases, allowing you to track your experiments, log metrics, and visualize results. Use the —log wandb parameter to enable Weights & Biases logging.

🌟 YAML Settings Files

AutoTrain allows you to define the fine-tuning settings in a YAML configuration file. This makes it easier to manage and reproduce your experiments. Here’s an example of a YAML settings file for fine-tuning a language model with AutoTrain:

task: llm-sft base_model: HuggingFaceH4/zephyr-7b-alpha project_name: zephyr-math log: wandb data_path: data/ text_column: text lr: 2e-5 batch_size: 4 epochs: 3 block_size: 1024 warmup_ratio: 0.03 lora_r: 16 lora_alpha: 32 lora_dropout: 0.05 weight_decay: 0.0 gradient_accumulation: 4

This YAML file specifies the task type, base model, project name, logging method, data path, and various hyperparameters for fine-tuning. You can modify these settings according to your specific needs and experiment with different configurations.

🌟 Data Formats for Different Trainers

AutoTrain supports different trainers for various fine-tuning tasks. Each trainer requires a specific data format. Here’s a summary of the data formats for the reward trainer and DPO trainer:

⚡ Data Format for Reward Trainer:

The data for the reward trainer should be in a CSV file with two columns: text and rejected_text. The text column contains the preferred text, while the rejected_text column contains the less preferred text.

⚡ Example:

textrejected_text
human: hello \n bot: hi nice to meet youhuman: hello \n bot: leave me alone
human: how are you \n bot: I am finehuman: how are you \n bot: I am not fine

⚡ Data Format for DPO Trainer:

The data for the DPO trainer should be in a CSV file with three columns: prompt, text, and rejected_text. The prompt column contains the prompt or context, the text column contains the preferred response, and the rejected_text column contains the less preferred response.

⚡ Example:

prompttextrejected_text
hellohi nice to meet youleave me alone
how are youI am fineI am not fine

🌟 Other Tasks Available in AutoTrain

AutoTrain supports a variety of tasks beyond LLM fine-tuning. Here are some of the other tasks available in AutoTrain:

  • Text Classification: Categorize text into predefined classes (e.g., sentiment analysis, spam detection).

  • Image Classification: Assign labels to images (e.g., object recognition, scene classification).

  • Question Answering: Extract answers to questions from a given text.

  • Token Classification: Identify and classify words or phrases in a sentence (e.g., named entity recognition, part-of-speech tagging).

  • Translation: Translate text from one language to another.

  • Summarization: Generate concise summaries of long texts.

🌟 Conclusion

Hugging Face AutoTrain provides a user-friendly interface and a wide range of settings for fine-tuning large language models. By understanding the specific settings for each model and the general fine-tuning parameters, you can effectively fine-tune LLMs for your specific use cases. Remember to optimize memory usage and experiment with different configurations to achieve the best results. This research has shown that while AutoTrain provides a convenient way to fine-tune various large language models, there can be significant differences in the settings and configurations required for each model. One of the key advantages of AutoTrain is its flexibility. You can fine-tune models using datasets from various sources, including the Hugging Face Hub, local files, or even cloud storage. Additionally, AutoTrain supports both local and cloud training environments, allowing you to choose the setup that best suits your needs.

🔧 Works cited

1. Fine Tune Models With AutoTrain from HuggingFace · Cloudflare Workers AI docs, https://developers.cloudflare.com/workers-ai/tutorials/fine-tune-models-with-autotrain/ 2. Fine-Tuning 1B LLaMA 3.2: A Comprehensive Step-by-Step Guide with Code, https://huggingface.co/blog/ImranzamanML/fine-tuning-1b-llama-32-a-comprehensive-article 3. LLAMA-2 : EASIET WAY To FINE-TUNE ON YOUR DATA - YouTube, https://www.youtube.com/watch?v=LslC2nKEEGU 4. LLM Finetuning with AutoTrain Advanced - Hugging Face, https://huggingface.co/docs/autotrain/tasks/llm\_finetuning 5. Fine-tune Llama 3.1 Ultra-Efficiently with Unsloth - Hugging Face, https://huggingface.co/blog/mlabonne/sft-llama3 6. LLAMA-3 : EASIET WAY To FINE-TUNE ON YOUR DATA - YouTube, https://www.youtube.com/watch?v=aQmoog\_s8HE 7. Supervised Fine-Tuning of Llama 3 8B on one AWS Trainium instance - Hugging Face, https://huggingface.co/docs/optimum-neuron/training\_tutorials/sft\_lora\_finetune\_llm 8. Fine-Tuning Gemma Models in Hugging Face, https://huggingface.co/blog/gemma-peft 9. Fine-tune Gemma 2B with PyTorch Training DLC using SFT on GKE - Hugging Face, https://huggingface.co/docs/google-cloud/examples/gke-trl-full-fine-tuning 10. Fine-tuning Granite Vision 3.1 2B with TRL - Hugging Face Open-Source AI Cookbook, https://huggingface.co/learn/cookbook/fine\_tuning\_granite\_vision\_sft\_trl 11. Fine tuning Guide for IBM Granite 3.0, https://www.ibm.com/granite/docs/how-to/fine-tuning/granite/ 12. Fine-Tune Microsoft Phi-4 on Custom Dataset Locally and Push to Hugging Face - YouTube, https://www.youtube.com/watch?v=V5dyDFoyfeA 13. How to Fine-Tune Custom Embedding Models Using AutoTrain - Hugging Face, https://huggingface.co/blog/abhishek/finetune-custom-embeddings-autotrain 14.

Back to Knowledge Base Explore More Knowledge