Repository files navigation

Ludwig is alow-code framework for buildingcustom AI models likeLLMs and other deep neural networks.

Key features:

• 🛠Build custom models with ease: a declarative YAML configuration file is all you need to train a state-of-the-art LLM on your data. Support for multi-task and multi-modality learning. Comprehensive config validation detects invalid parameter combinations and prevents runtime failures.
• ⚡Optimized for scale and efficiency: automatic batch size selection, distributed training (DDP,DeepSpeed), parameter efficient fine-tuning (PEFT), 4-bit quantization (QLoRA), paged and 8-bit optimizers, and larger-than-memory datasets.
• 📐Expert level control: retain full control of your models down to the activation functions. Support for hyperparameter optimization, explainability, and rich metric visualizations.
• 🧱Modular and extensible: experiment with different model architectures, tasks, features, and modalities with just a few parameter changes in the config. Think building blocks for deep learning.
• 🚢Engineered for production: prebuiltDocker containers, native support for running withRay onKubernetes, export models toTorchscript andTriton, upload toHuggingFace with one command.

Ludwig is hosted by theLinux Foundation AI & Data.

Install from PyPi. Be aware that Ludwig requires Python 3.8+.

pip install ludwig

Or install with all optional dependencies:

pip install ludwig[full]

Please seecontributing for more detailed installation instructions.

Want to take a quick peek at some of the Ludwig 0.8 features? Check out this Colab Notebook 🚀

Looking to fine-tune Llama-2 or Mistral? Check out these notebooks:

1. Fine-Tune Llama-2-7b:
2. Fine-Tune Llama-2-13b:
3. Fine-Tune Mistral-7b:

For a full tutorial, check out the officialgetting started guide, or take a look at end-to-endExamples.

Let's fine-tune a pretrained LLaMA-2-7b large language model to follow instructions like a chatbot ("instruction tuning").

• HuggingFace API Token
• Access approval toLlama2-7b-hf
• GPU with at least 12 GiB of VRAM (in our tests, we used an Nvidia T4)

We'll use theStanford Alpaca dataset, which will be formatted as a table-like file that looks like this:

Create a YAML config file namedmodel.yaml with the following:

model_type:llmbase_model:meta-llama/Llama-2-7b-hfquantization:bits:4adapter:type:loraprompt:template:|    Below is an instruction that describes a task, paired with an input that may provide further context.    Write a response that appropriately completes the request.    ### Instruction:    {instruction}    ### Input:    {input}    ### Response:input_features:  -name:prompttype:textoutput_features:  -name:outputtype:texttrainer:type:finetunelearning_rate:0.0001batch_size:1gradient_accumulation_steps:16epochs:3learning_rate_scheduler:decay:cosinewarmup_fraction:0.01preprocessing:sample_ratio:0.1backend:type:local

And now let's train the model:

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

Let's build a neural network that predicts whether a given movie critic's review onRotten Tomatoes was positive or negative.

Our dataset will be a CSV file that looks like this:

Download a sample of the dataset fromhere.

wget https://ludwig.ai/latest/data/rotten_tomatoes.csv

Next create a YAML config file namedmodel.yaml with the following:

input_features:  -name:genrestype:setpreprocessing:tokenizer:comma  -name:content_ratingtype:category  -name:top_critictype:binary  -name:runtimetype:number  -name:review_contenttype:textencoder:type:embedoutput_features:  -name:recommendedtype:binary

That's it! Now let's train the model:

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

Happy modeling

Try applying Ludwig to your data.Reach out on Discordif you have any questions.

• Minimal machine learning boilerplate

  Ludwig takes care of the engineering complexity of machine learning out ofthe box, enabling research scientists to focus on building models at thehighest level of abstraction. Data preprocessing, hyperparameteroptimization, device management, and distributed training fortorch.nn.Module models come completely free.

• Easily build your benchmarks

  Creating a state-of-the-art baseline and comparing it with a new model is asimple config change.

• Easily apply new architectures to multiple problems and datasets

  Apply new models across the extensive set of tasks and datasets that Ludwigsupports. Ludwig includes afull benchmarking toolkit accessible toany user, for running experiments with multiple models across multipledatasets with just a simple configuration.

• Highly configurable data preprocessing, modeling, and metrics

  Any and all aspects of the model architecture, training loop, hyperparametersearch, and backend infrastructure can be modified as additional fields inthe declarative configuration to customize the pipeline to meet yourrequirements. For details on what can be configured, check outLudwig Configurationdocs.

• Multi-modal, multi-task learning out-of-the-box

  Mix and match tabular data, text, images, and even audio into complex modelconfigurations without writing code.

• Rich model exporting and tracking

  Automatically track all trials and metrics with tools like Tensorboard,Comet ML, Weights & Biases, MLFlow, and Aim Stack.

• Automatically scale training to multi-GPU, multi-node clusters

  Go from training on your local machine to the cloud without code changes.

• Low-code interface for state-of-the-art models, including pre-trained Huggingface Transformers

  Ludwig also natively integrates with pre-trained models, such as the onesavailable inHuggingface Transformers.Users can choose from a vast collection of state-of-the-art pre-trainedPyTorch models to use without needing to write any code at all. For example,training a BERT-based sentiment analysis model with Ludwig is as simple as:

  ludwig train --dataset sst5 --config_str"{input_features: [{name: sentence, type: text, encoder: bert}], output_features: [{name: label, type: category}]}"

• Low-code interface for AutoML

  Ludwig AutoMLallows users to obtain trained models by providing just a dataset, thetarget column, and a time budget.

  auto_train_results=ludwig.automl.auto_train(dataset=my_dataset_df,target=target_column_name,time_limit_s=7200)

• Easy productionisation

  Ludwig makes it easy to serve deep learning models, including on GPUs.Launch a REST API for your trained Ludwig model.

  ludwig serve --model_path=/path/to/model

  Ludwig supports exporting models to efficient Torchscript bundles.

  ludwig export_torchscript -–model_path=/path/to/model

• Text Classification
• Tabular Data Classification
• Image Classification
• Multimodal Classification

• Named Entity Recognition Tagging
• Natural Language Understanding
• Machine Translation
• Chit-Chat Dialogue Modeling through seq2seq
• Sentiment Analysis
• One-shot Learning with Siamese Networks
• Visual Question Answering
• Spoken Digit Speech Recognition
• Speaker Verification
• Binary Classification (Titanic)
• Timeseries forecasting
• Timeseries forecasting (Weather)
• Movie rating prediction
• Multi-label classification
• Multi-Task Learning
• Simple Regression: Fuel Efficiency Prediction
• Fraud Detection

Read our publications onLudwig,declarative ML, andLudwig’s SoTA benchmarks.

Learn more abouthow Ludwig works,how to get started, and work through moreexamples.

If you are interested incontributing, have questions, comments, or thoughts to share, or if you just want to be in theknow, please considerjoining our Community Discord and follow us onX!

Ludwig is an actively managed open-source project that relies on contributions from folks just likeyou. Consider joining the active group of Ludwig contributors to make Ludwig an evenmore accessible and feature rich framework for everyone to use!

• Discord
• X
• Medium
• GitHub Issues