Ludwig: Low-Code Declarative Deep Learning for LLMs and AI Models

Summary

Ludwig is a powerful, low-code declarative deep learning framework designed for building custom LLMs, neural networks, and other AI models. It simplifies the process of training, fine-tuning, and deploying models, from LLM fine-tuning to tabular classification, using a simple YAML configuration without boilerplate Python code. This makes advanced AI development accessible and efficient for a wide range of applications.

Use at your own risk

OSRepos shares public repositories for knowledge and discovery only. Any installation, execution, configuration, or use of code from these repositories is the user's own responsibility. Always review the repository, source code, dependencies, licenses, and security implications before running or installing anything. OSRepos is not responsible for issues, damages, or losses resulting from third-party repositories.

Introduction

Ludwig is a powerful, low-code declarative deep learning framework that simplifies the process of building custom LLMs, neural networks, and other AI models. It enables users to train, fine-tune, and deploy a wide range of models, from large language models to multimodal and tabular AI, using a simple YAML configuration. This approach eliminates the need for boilerplate Python code, making advanced AI development accessible and efficient for researchers and developers alike.

Installation

Ludwig requires Python 3.12 or newer. You can install the core library or specific sets of dependencies based on your needs:

pip install ludwig           # core
pip install ludwig[full]     # all optional dependencies
pip install ludwig[llm]      # LLM fine-tuning only

Examples

Ludwig's declarative nature shines through its straightforward configuration and command-line interface.

Fine-tune an LLM (instruction tuning)

Fine-tune a large language model with just a YAML file and a simple command:

model_type: llm
base_model: meta-llama/Llama-3.1-8B

quantization:
  bits: 4

adapter:
  type: lora

prompt:
  template: |
    ### Instruction: {instruction}
    ### Input: {input}
    ### Response:

input_features:
  - name: prompt
    type: text

output_features:
  - name: output
    type: text

trainer:
  type: finetune
  learning_rate: 0.0001
  batch_size: 1
  gradient_accumulation_steps: 16
  epochs: 3
  learning_rate_scheduler:
    decay: cosine
    warmup_fraction: 0.01

backend:
  type: local

export HUGGING_FACE_HUB_TOKEN="<your_token>"
ludwig train --config model.yaml --dataset "ludwig://alpaca"

Train a multimodal classifier

Combine different data types, like text and images, to build powerful multimodal models:

input_features:
  - name: review_text
    type: text
    encoder:
      type: bert
  - name: star_rating
    type: number
  - name: product_image
    type: image
    encoder:
      type: dinov2

output_features:
  - name: recommended
    type: binary

ludwig train --config model.yaml --dataset reviews.csv

Generate a config from natural language

Leverage Ludwig's AI capabilities to generate model configurations directly from a natural language description:

ludwig generate_config "I have a CSV with age, income, education level, and I want to predict loan default"

Why use Ludwig?

Ludwig offers several compelling advantages for AI development:

Zero boilerplate: No need for training loops, data pipelines, or evaluation code, the YAML config defines everything.
Best-in-class LLM support: Comprehensive features for LLM fine-tuning, including LoRA, GRPO alignment, torchao QAT, and VLM fine-tuning, all configurable.
Multimodal out of the box: Easily integrate and combine text, images, numbers, audio, and timeseries data with minimal configuration changes.
Scale without code changes: Seamlessly transition from local development to multi-GPU setups or Ray clusters by simply adjusting the backend.type parameter.
Expert control when you need it: Every aspect, from activation functions to schedulers and optimizers, is fully configurable for advanced users.
Reproducible research: Every experiment run is logged, and the full configuration is saved, facilitating easy comparison and reproduction with ludwig visualize.