Common questions and answers about ModelForge.

ModelForge is a no-code toolkit for fine-tuning Large Language Models on your local GPU. It provides a web-based UI for training custom models without writing code.

Yes! ModelForge is open-source under the MIT license. You can use it freely for personal or commercial projects.

v3 builds on the v2 architecture with:

• Apple Silicon (MPS) support — train on M1/M2/M3/M4/M5 Macs natively
• Interactive CLI wizard (modelforge cli) for headless/SSH environments
• Optional quantization — bitsandbytes moved to [quantization] extra for a lighter base install
• Schema validation — catches incompatible config combinations at startup

All existing v2 workflows remain compatible.

NVIDIA GPU (Windows/Linux):

• Python 3.11.x
• NVIDIA GPU with 4GB+ VRAM
• CUDA 11.8 or 12.x
• 8GB RAM
• 10GB free disk space

Apple Silicon Mac (macOS):

• Python 3.11.x
• Apple Silicon Mac (M1 or later) with 8GB+ unified memory
• macOS 12.3 or later
• 10GB free disk space

Yes, but training will be extremely slow (10-100x slower). Only recommended for testing with very small models.

Currently, only NVIDIA GPUs are supported due to CUDA requirements.

Yes — Apple Silicon Macs are supported via PyTorch's MPS backend (added in v3).

Supported chips: M1, M2, M3, M4, M5. Intel Macs are not supported (no MPS).

Limitations on MPS:

• HuggingFace provider only (Unsloth requires NVIDIA CUDA)
• No 4-bit/8-bit quantization (bitsandbytes is CUDA-only)
• Smaller models recommended (1–7B depending on unified memory)

See the macOS Installation Guide for full setup instructions.

Some dependencies don't yet support Python 3.12. We'll add support when the ecosystem catches up.

nvcc --version

Yes! Create environment with Python 3.11:

conda create -n modelforge python=3.11
conda activate modelforge
pip install modelforge-finetuning

Make sure you're using Python 3.11:

python --version  # Should show 3.11.x

Yes! The HuggingFace provider works perfectly on native Windows. For Unsloth support, use WSL or Docker.

Unsloth requires Linux-specific libraries and compilation. Use WSL 2 or Docker for Unsloth support.

Open PowerShell as Administrator:

wsl --install -d Ubuntu-22.04

See Windows Installation Guide for details.

No! WSL uses your Windows NVIDIA drivers automatically. Only install CUDA Toolkit in WSL.

Depends on model size, dataset size, and hardware:

Use QLoRA strategy to reduce memory usage by 30-50%.

Not recommended. Training uses all available VRAM. Train one model at a time.

Currently not supported. Training must complete in one session. Use checkpointing to save progress.

Monitor in the UI:

• Loss should decrease over time
• Accuracy/metrics should improve
• No errors in console

JSONL (JSON Lines). Each line is one JSON object.

See Dataset Formats for details.

Minimum: 100 examples
Recommended: 1,000+ examples
Optimal: 5,000+ examples

Quality > quantity!

Yes! Convert them to JSONL format:

from datasets import load_dataset
import json

dataset = load_dataset("your-dataset", split="train")

with open('dataset.jsonl', 'w') as f:
    for item in dataset:
        f.write(json.dumps({"input": item["text"], "output": item["label"]}) + '\n')

Check the license of your data. Fine-tuning on copyrighted material may violate copyright laws.

All HuggingFace models compatible with Transformers:

• Llama (1, 2, 3)
• Mistral
• Qwen
• Gemma
• Phi
• BART
• T5
• And many more!

Yes! You need:

1. Accept license on HuggingFace
2. Use access token with proper permissions

Yes! Provide local path instead of HuggingFace ID:

{
  "model_name": "/path/to/local/model"
}

Navigate to Models tab in UI and click Download, or find checkpoints in:

• Linux: ~/.local/share/modelforge/model_checkpoints/
• Windows: C:\Users\<user>\AppData\Local\modelforge\model_checkpoints\

Use Unsloth if:

• Running on Linux or WSL
• Using supported models
• Need faster training
• Have limited VRAM

Use HuggingFace if:

• On native Windows
• Using unsupported models
• Maximum compatibility needed

Unsloth pre-allocates memory for performance. Auto-inference (-1) is not supported.

SFT: Standard supervised fine-tuning with LoRA QLoRA: Quantized LoRA using 4-bit quantization for lower memory

QLoRA uses 30-50% less memory with minimal quality loss.

In ModelForge, both RLHF and DPO use TRL's DPOTrainer internally. The difference is in default hyperparameters:

• RLHF: More conservative defaults (lr=1.41e-5, 1 epoch) — suited for careful alignment
• DPO: Standard defaults (lr=5e-7, 3 epochs) — good general-purpose preference learning

Both require preference data (prompt/chosen/rejected) and "task": "text-generation". Start with SFT for most use cases.

modelforge cli launches an 8-step interactive wizard in the terminal. It's ideal for headless servers, SSH sessions, or Jupyter notebooks where a browser isn't available. Install the CLI extra first:

pip install modelforge-finetuning[cli]

bitsandbytes is now an optional dependency. Install it with:

pip install modelforge-finetuning[quantization]

Legacy tuners were removed in v2.1. Use the provider/strategy pattern instead:

{
  "provider": "huggingface",
  "strategy": "sft"
}

Both use TRL's DPOTrainer internally — no PPO, no reward model needed. The only difference is default hyperparameters. RLHF uses more conservative settings (lower learning rate, fewer epochs) while DPO uses standard settings.

No. Choose one strategy per training run.

Solutions:

1. Reduce per_device_train_batch_size
2. Use QLoRA strategy
3. Reduce max_seq_length
4. Enable gradient_checkpointing
5. Use smaller model

Check:

1. Model ID is correct
2. HuggingFace token is set
3. You have access to gated models
4. Internet connection is working

Check:

1. File is valid JSONL
2. Required fields are present
3. All values are strings
4. At least 10 examples

Check:

1. Provider is installed (pip install unsloth)
2. Provider name is correct (huggingface or unsloth)
3. On correct platform (Unsloth needs Linux/WSL)

1. Use Unsloth provider (2x faster)
2. Use QLoRA strategy
3. Increase batch size if you have VRAM
4. Use fp16 or bf16
5. Enable gradient checkpointing

Best practices:

• Use Unsloth provider
• Larger batch size (if VRAM allows)
• Use bf16 on Ampere+ GPUs (RTX 30xx/40xx)
• Reduce gradient accumulation steps
• Use NVMe SSD for dataset storage

Best practices:

• Use QLoRA strategy
• Enable 4-bit quantization
• Reduce batch size
• Reduce max_seq_length
• Enable gradient checkpointing

Yes! ModelForge provides a REST API. See API Documentation.

Yes! Use the API or import ModelForge as a library.

Not yet, but you can use the REST API with requests.

Yes! ModelForge is production-ready. Deploy with:

• Docker containers
• Systemd services
• Cloud platforms (AWS, GCP, Azure)

Use reverse proxy (nginx/Apache) with SSL:

server {
    listen 443 ssl;
    location / {
        proxy_pass http://localhost:8000;
    }
}

Yes! ModelForge uses SQLAlchemy. Easy to switch to PostgreSQL.

See Contributing Guide for:

• Reporting bugs
• Suggesting features
• Submitting PRs
• Adding model configurations

Create provider class and register in factory. See Custom Providers.

Add JSON config file to model_configs/. See Model Configurations.

• Check Troubleshooting Guide
• Search GitHub Issues
• Ask in GitHub Discussions
• Create new issue if bug

Can't find your answer? Ask in GitHub Discussions!