Tuna

Tuna is a Python library designed to simplify the fine-tuning process of transformer-based models. It significantly reduces the boilerplate code required to set up and run fine-tuning tasks, allowing users to focus on their model's performance rather than the intricacies of implementation.

Key Features

• Effortless Fine-Tuning: Switch from complex setups to clean and concise code. Fine-tune models in just a few lines, improving efficiency and productivity.

• Multiple Fine-Tuning Methods:

  • LoRA (Low-Rank Adaptation): A memory-efficient method for fast training.
  • P-tuning: Ideal for few-shot learning through prompt tuning.
  • SFT (Supervised Fine-Tuning): Enables complete parameter training with evaluation capabilities.
  • DAFT (Domain-Adaptive Fine-Tuning): Focused on adapting models to specific domains.
  • Additional methods will be introduced in future updates.

Flexibility and Chainability

Tuna allows for the combination of different fine-tuning approaches easily. For example, models can be fine-tuned using LoRA followed by Supervised Fine-Tuning in a seamless process:

model = Model("distilgpt2")
lora_model = LoRATrainer(model=model, train_dataset=dataset).fine_tune(...)
final_model = SFTTrainer(model=lora_model, train_dataset=train_dataset, eval_dataset=eval_dataset).fine_tune(...)

Quick Start

Getting started with Tuna involves minimal setup. Load models and datasets, then use the integrated trainers to fine-tune without hassle:

from tuna import *
from datasets import load_dataset

model = Model("microsoft/DialoGPT-small")
dataset = load_dataset("daily_dialog", split="train")

trainer = LoRATrainer(model=model, train_dataset=dataset)
fine_tuned_model = trainer.fine_tune(
    training_args={
        "per_device_train_batch_size": 4,
        "num_train_epochs": 3,
        "learning_rate": 1e-4,
    },
    lora_args={
        "r": 16,
        "lora_alpha": 32,
        "lora_dropout": 0.1,
    },
    limit=1000
)

Advanced Usage Options

• Supervised Fine-Tuning with Evaluation: Seamlessly integrate evaluation with training to monitor performance through checkpoints and logging.

• Domain-Adaptive Fine-Tuning: Tailor models for specific fields like medical or legal applications, ensuring high relevance and accuracy.

• Prompt Tuning: Execute efficient few-shot learning targeted at improving model responses with fewer training examples.

What Makes Tuna Stand Out

• Zero Boilerplate: Eliminates repetitive training loop code, making it accessible for quick model deployment.
• Method Chaining: Simplifies the integration of multiple fine-tuning strategies.
• Smart Wrappers: Automatically configures models and tokenizers to minimize setup time.
• Flexible Configuration: Use straightforward dictionaries to configure all necessary parameters for fine-tuning.
• Session Management: Automatic checkpointing and recovery enhances adaptability during long training sessions.
• Built-in Logging: Easily track model performance and training metrics without additional configuration.

Tuna aims to optimize the fine-tuning process, catering to both seasoned developers and newcomers alike, ensuring that transformer model adjustments are efficient and straightforward.