# 🦖 X—LLM: Cutting Edge & Easy LLM Finetuning
<div align="center">
[](https://github.com/BobaZooba/xllm/actions/workflows/build.yaml)
[](https://github.com/BobaZooba/xllm/blob/main/LICENSE)
[](https://github.com/BobaZooba/xllm/releases)
[](https://pypi.org/project/xllm/)
[](https://pypi.org/project/xllm/)
[](https://pypi.org/project/xllm/)
[](https://github.com/modelfront/predictor/blob/master/.pre-commit-config.yaml)
[](https://github.com/psf/black)
[](https://github.com/astral-sh/ruff)
[](http://mypy-lang.org/)
[](https://codecov.io/gh/BobaZooba/xllm)
[](https://discord.gg/5znbxBgwZP)
Cutting Edge & Easy LLM Finetuning using the most advanced methods (QLoRA, DeepSpeed, GPTQ, Flash Attention 2, FSDP,
etc)
Developed
by [Boris Zubarev](https://t.me/BobaZooba) | [CV](https://docs.google.com/document/d/1BhFvIHQ1mpm81P-n2A-lhNac-U2wOGc6F2uS9gKvk88/edit?usp=sharing) | [LinkedIn](https://www.linkedin.com/in/boriszubarev/) | [bobazooba@gmail.com](mailto:bobazooba@gmail.com)
</div>
# Why you should use X—LLM 🪄
Are you using **Large Language Models (LLMs)** for your work and want to train them more efficiently with advanced
methods? Wish to focus on the data and improvements rather than repetitive and time-consuming coding for LLM training?
**X—LLM** is your solution. It's a user-friendly library that streamlines training optimization, so you can **focus on
enhancing your models and data**. Equipped with **cutting-edge training techniques**, X—LLM is engineered for efficiency
by engineers who understand your needs.
**X—LLM** is ideal whether you're **gearing up for production** or need a **fast prototyping tool**.
## Features
- Hassle-free training for Large Language Models
- Seamless integration of new data and data processing
- Effortless expansion of the library
- Speed up your training, while simultaneously reducing model sizes
- Each checkpoint is saved to the 🤗 HuggingFace Hub
- Easy-to-use integration with your existing project
- Customize almost any part of your training with ease
- Track your training progress using `W&B`
- Supported many 🤗 Transformers models
like `Yi-34B`, `Mistal AI`, `Llama 2`, `Zephyr`, `OpenChat`, `Falcon`, `Phi`, `Qwen`, `MPT` and many more
- Benefit from cutting-edge advancements in LLM training optimization
- QLoRA and fusing
- Flash Attention 2
- Gradient checkpointing
- bitsandbytes
- GPTQ (including post-training quantization)
- DeepSpeed
- FSDP
- And many more
# Quickstart 🦖
### Installation
`X—LLM` is tested on Python 3.8+, PyTorch 2.0.1+ and CUDA 11.8.
```sh
pip install xllm
```
Version which include `deepspeed`, `flash-attn` and `auto-gptq`:
```sh
pip install "xllm[train]"
```
Default `xllm` version recommended for local development, `xllm[train]` recommended for training.
#### Training recommended environment
CUDA version: `11.8`
Docker: `huggingface/transformers-pytorch-gpu:latest`
## Fast prototyping ⚡
```python
from xllm import Config
from xllm.datasets import GeneralDataset
from xllm.experiments import Experiment
# Init Config which controls the internal logic of xllm
# QLoRA example
config = Config(
model_name_or_path="HuggingFaceH4/zephyr-7b-beta",
apply_lora=True,
load_in_4bit=True,
)
# Prepare the data
train_data = ["Hello!"] * 100
train_dataset = GeneralDataset.from_list(data=train_data)
# Build Experiment from Config: init tokenizer and model, apply LoRA and so on
experiment = Experiment(config=config, train_dataset=train_dataset)
experiment.build()
# Run Experiment (training)
experiment.run()
# # [Optional] Fuse LoRA layers
# experiment.fuse_lora()
# [Optional] Or push LoRA weights to HuggingFace Hub
experiment.push_to_hub(repo_id="YOUR_NAME/MODEL_NAME")
```
### How `Config` controls `xllm`
[More about config](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#config)
<details>
<summary>LoRA</summary>
#### Simple
```python
config = Config(
model_name_or_path="openchat/openchat_3.5",
apply_lora=True,
)
```
#### Advanced
```python
config = Config(
model_name_or_path="openchat/openchat_3.5",
apply_lora=True,
lora_rank=8,
lora_alpha=32,
lora_dropout=0.05,
raw_lora_target_modules="all",
# Names of modules to apply LoRA. A comma-separated string, for example: "k,q,v" or "all".
)
```
</details>
<details>
<summary>QLoRA</summary>
To train the `QLoRA` model, we need to load the backbone model using `bitsandbytes` library and int4 (or int8) weights.
#### Simple
```python
config = Config(
model_name_or_path="01-ai/Yi-34B",
apply_lora=True,
load_in_4bit=True,
prepare_model_for_kbit_training=True,
)
```
#### Advanced
```python
config = Config(
model_name_or_path="01-ai/Yi-34B",
apply_lora=True,
load_in_4bit=True,
prepare_model_for_kbit_training=True,
llm_int8_threshold=6.0,
llm_int8_has_fp16_weight=True,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type="nf4",
)
```
</details>
<details>
<summary>Push checkpoints to the HuggingFace Hub</summary>
Before that, you must log in to `Huggingface Hub` or add an `API Token` to the environment variables.
```python
config = Config(
model_name_or_path="HuggingFaceH4/zephyr-7b-beta",
push_to_hub=True,
hub_private_repo=True,
hub_model_id="BobaZooba/AntModel-7B-XLLM-Demo-LoRA",
save_steps=25,
)
```
- Checkpoints will be saved locally and in Huggingface Hub each `save_steps`
- If you train a model with `LoRA`, then only `LoRA` weights will be saved
</details>
<details>
<summary>Report to W&B</summary>
Before that, you must log in to `W&B` or add an `API Token` to the environment variables.
```python
config = Config(
model_name_or_path="HuggingFaceH4/zephyr-7b-beta",
report_to_wandb=True,
logging_steps=5,
wandb_project="xllm-demo",
)
```
</details>
<details>
<summary>Gradient checkpointing</summary>
This will help to use `less GPU memory` during training, that is, you will be able to learn more than without this
technique. The disadvantages of this technique is slowing down the forward step, that is, `slowing down training`.
You will be training larger models (for example 7B in colab), but at the expense of training speed.
```python
config = Config(
model_name_or_path="HuggingFaceH4/zephyr-7b-beta",
use_gradient_checkpointing=True,
)
```
</details>
<details>
<summary>Flash Attention 2</summary>
This speeds up training and GPU memory consumption, but it does not work with all models and GPUs. You also need to
install `flash-attn` for this. This can be done using:
`pip install "xllm[train]"`
```python
config = Config(
model_name_or_path="meta-llama/Llama-2-7b-hf",
use_flash_attention_2=True,
)
```
</details>
</details>
<details>
<summary><b>Recommended setup</b></summary>
#### Recommendations
- Incredibly effective method is LoRA (`apply_lora`). It allows for a tremendous reduction in training costs
and, moreover, helps very effectively combat catastrophic forgetting.
- Then, I advise using `load_in_4bit` and `prepare_model_for_kbit_training` together. This also significantly reduces
memory consumption.
- Lastly, I would recommend apply `use_gradient_checkpointing`. This method also greatly reduces memory consumption, but
at the expense of slowing down training.
- If your project allows, I suggest enabling `push_to_hub` and `hub_private_repo`, also specifying the model name
in `hub_model_id` and `save_steps`. Example: "BobaZooba/SupaDupaLlama-7B-LoRA". During training, every checkpoint of
your model will be saved in the HuggingFace Hub. If you specified `apply_lora`, then only the LoRA weights will be
saved, which you can later easily fuse with the main model, for example, using `xllm`.
- If your GPU allows it add `use_flash_attention_2`
- I also recommend using `report_to_wandb`, also specifying `wandb_project` (the project name in W&B)
and `wandb_entity` (user or organization name in W&B).
- Note that for `push_to_hub`, you need to log in to the HuggingFace Hub beforehand or specify the
token (`HUGGING_FACE_HUB_TOKEN`) in the .env file. Similarly, when using `report_to_wandb`, you will need to log in to
W&B. You can either specify the token (`WANDB_API_KEY`) in the .env file or you will be prompted to enter the token on
the command line.
#### Features
- QLoRA
- Gradient checkpointing
- Flash Attention 2
- Stabilize training
- Push checkpoints to HuggingFace Hub
- W&B report
```python
config = Config(
model_name_or_path="meta-llama/Llama-2-7b-hf",
tokenizer_padding_side="right", # good for llama2
warmup_steps=1000,
max_steps=10000,
logging_steps=1,
save_steps=1000,
per_device_train_batch_size=2,
gradient_accumulation_steps=2,
max_length=2048,
stabilize=True,
use_flash_attention_2=True,
apply_lora=True,
load_in_4bit=True,
prepare_model_for_kbit_training=True,
use_gradient_checkpointing=True,
push_to_hub=False,
hub_private_repo=True,
hub_model_id="BobaZooba/SupaDupaLlama-7B-LoRA",
report_to_wandb=False,
wandb_project="xllm-demo",
wandb_entity="bobazooba",
)
```
</details>
<details>
<summary>Fuse</summary>
This operation is only for models with a LoRA adapter.
You can explicitly specify to fuse the model after training.
```python
config = Config(
model_name_or_path="HuggingFaceH4/zephyr-7b-beta",
apply_lora=True,
fuse_after_training=True,
)
```
Even when you are using QLoRa
```python
config = Config(
model_name_or_path="HuggingFaceH4/zephyr-7b-beta",
apply_lora=True,
load_in_4bit=True,
prepare_model_for_kbit_training=True,
fuse_after_training=True,
)
```
Or you can fuse the model yourself after training.
```python
experiment.fuse_lora()
```
</details>
<details>
<summary>DeepSpeed</summary>
`DeepSpeed` is needed for training models on `multiple GPUs`. `DeepSpeed` allows you
to `efficiently manage the resources of several GPUs during training`. For example, you
can `distribute the gradients and the state of the optimizer to several GPUs`, rather than storing a complete set of
gradients and the state of the optimizer on each GPU. Starting training using `DeepSpeed` can only happen from
the `command line`.
`train.py`
```python
from xllm import Config
from xllm.datasets import GeneralDataset
from xllm.cli import cli_run_train
if __name__ == '__main__':
train_data = ["Hello!"] * 100
train_dataset = GeneralDataset.from_list(data=train_data)
cli_run_train(config_cls=Config, train_dataset=train_dataset)
```
Run train (in the `num_gpus` parameter, specify as many GPUs as you have)
```sh
deepspeed --num_gpus=8 train.py --deepspeed_stage 2
```
You also can pass other parameters
```sh
deepspeed --num_gpus=8 train.py \
--deepspeed_stage 2 \
--apply_lora True \
--stabilize True \
--use_gradient_checkpointing True
```
</details>
### Notebooks
| Name | Comment | Link |
|-------------------------------------------|------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| X—LLM Prototyping | In this notebook you will learn the basics of the library | [](https://colab.research.google.com/drive/1zsNmJFns1PKZy5VE5p5nsQL-mZF7SwHf?usp=sharing) |
| Llama2 & Mistral AI efficient fine-tuning | 7B model training in colab using QLoRA, bnb int4, gradient checkpointing and X—LLM | [](https://colab.research.google.com/drive/1CNNB_HPhQ8g7piosdehqWlgA30xoLauP?usp=sharing) |
## Production solution 🚀
`X—LLM` enables not only to prototype models, but also facilitates the development of production-ready solutions through
built-in capabilities and customization.
Using `X—LLM` to train a model is easy and involves these few steps:
1. `Prepare` — Get the data and the model ready by downloading and preparing them. Saves data locally
to `config.train_local_path_to_data` and `config.eval_local_path_to_data` if you are using eval dataset
2. `Train` — Use the data prepared in the previous step to train the model
3. `Fuse` — If you used LoRA during the training, fuse LoRA
4. `Quantize` — Optimize your model's memory usage by quantizing it
Remember, these tasks in `X—LLM` start from the command line. So, when you're all set to go, launching your full project
will look something like this:
<details>
<summary>Example how to run your project</summary>
1. Downloading and preparing data and model
```sh
python3 MY_PROJECT/cli/prepare.py \
--dataset_key MY_DATASET \
--model_name_or_path mistralai/Mistral-7B-v0.1 \
--path_to_env_file ./.env
```
2. Run train using DeepSpeed on multiple GPUs
```sh
deepspeed --num_gpus=8 MY_PROJECT/cli/train.py \
--use_gradient_checkpointing True \
--deepspeed_stage 2 \
--stabilize True \
--model_name_or_path mistralai/Mistral-7B-v0.1 \
--use_flash_attention_2 False \
--load_in_4bit True \
--apply_lora True \
--raw_lora_target_modules all \
--per_device_train_batch_size 8 \
--warmup_steps 1000 \
--save_total_limit 0 \
--push_to_hub True \
--hub_model_id MY_HF_HUB_NAME/LORA_MODEL_NAME \
--hub_private_repo True \
--report_to_wandb True \
--path_to_env_file ./.env
```
3. Fuse LoRA
```sh
python3 MY_PROJECT/cli/fuse.py \
--model_name_or_path mistralai/Mistral-7B-v0.1 \
--lora_hub_model_id MY_HF_HUB_NAME/LORA_MODEL_NAME \
--hub_model_id MY_HF_HUB_NAME/MODEL_NAME \
--hub_private_repo True \
--force_fp16 True \
--fused_model_local_path ./fused_model/ \
--path_to_env_file ./.env
```
4. [Optional] GPTQ quantization of the trained model with fused LoRA
```sh
python3 MY_PROJECT/cli/quantize.py \
--model_name_or_path ./fused_model/ \
--apply_lora False \
--stabilize False \
--quantization_max_samples 128 \
--quantized_model_path ./quantized_model/ \
--prepare_model_for_kbit_training False \
--quantized_hub_model_id MY_HF_HUB_NAME/MODEL_NAME_GPTQ \
--quantized_hub_private_repo True \
--path_to_env_file ./.env
```
</details>
Right now, the `X—LLM` library lets you use only the [SODA dataset](https://huggingface.co/datasets/allenai/soda). We've
set it up this way for demo purposes, but we're planning to add more datasets soon. You'll need to figure out how to
download and handle your dataset. Simply put, you take care of your data, and `X—LLM` handles the rest. We've done it
this
way on purpose, to give you plenty of room to get creative and customize to your heart's content.
You can customize your dataset in detail, adding additional fields. All of this will enable you to implement virtually
any task in the areas of `Supervised Learning` and `Offline Reinforcement Learning`.
At the same time, you always have an easy way to submit data for language modeling.
<details>
<summary>Example</summary>
```python
from xllm import Config
from xllm.datasets import GeneralDataset
from xllm.cli import cli_run_train
if __name__ == '__main__':
train_data = ["Hello!"] * 100
train_dataset = GeneralDataset.from_list(data=train_data)
cli_run_train(config_cls=Config, train_dataset=train_dataset)
```
</details>
### Build your own project
To set up your own project using `X—LLM`, you need to do two things:
1. Implement your dataset (figure out how to download and handle it)
2. Add `X—LLM`'s command-line tools into your project
Once that's done, your project will be good to go, and you can start running the steps you need (like prepare, train,
and so on).
To get a handle on building your project with `X—LLM`, check out the materials below.
## Useful materials
- [Guide](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md): here, we go into detail about everything the library can
do
- [Demo project](https://github.com/BobaZooba/xllm-demo): here's a step-by-step example of how to use `X—LLM` and fit
it
into your own project
- [WeatherGPT](https://github.com/BobaZooba/wgpt): this repository features an example of how to utilize the xllm library. Included is a solution for a common type of assessment given to LLM engineers, who typically earn between $120,000 to $140,000 annually
- [Shurale](https://github.com/BobaZooba/shurale): project with the finetuned 7B Mistal model
# Config 🔧
The `X—LLM` library uses a single config setup for all steps like preparing, training and the other steps. It's
designed in a way that
lets you easily understand the available features and what you can adjust. `Config` has control almost over every
single part of each step. Thanks to the config, you can pick your dataset, set your collator, manage the type of
quantization during training, decide if you want to use LoRA, if you need to push a checkpoint to the `HuggingFace Hub`,
and a
lot more.
Config path: `src.xllm.core.config.Config`
Or
```python
from xllm import Config
```
## Useful materials
- [Important config fields for different steps](https://github.com/BobaZooba/xllm#how-config-controls-xllm)
- [How do I choose the methods for training?](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-do-i-choose-the-methods-for-training)
- [Detailed description of all config fields](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#detailed-config-explanation)
# Customization options đź›
You have the flexibility to tweak many aspects of your model's training: data, how data is processed, trainer, config,
how the model is loaded, what happens before and after training, and so much more.
We've got ready-to-use components for every part of the `xllm` pipeline. You can entirely switch out some components
like the dataset, collator, trainer, and experiment.
For some components like experiment and config, you have the option to just build on what's already there.
### Useful materials
- [How to implement dataset](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-dataset)
- [How to add CLI tools to your project](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-add-cli-tools-to-your-project)
- [How to implement collator](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-collator)
- [How to implement trainer](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-trainer)
- [How to implement experiment](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-experiment)
- [How to extend config](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-extend-config)
# Projects using X—LLM 🏆
Building something cool with [X—LLM](https://github.com/BobaZooba/xllm)? Kindly reach out to me
at [bobazooba@gmail.com](mailto:bobazooba@gmail.com). I'd love to hear from you.
## Hall of Fame
Write to us so that we can add your project.
- [Shurale7B-v1](https://huggingface.co/BobaZooba/Shurale7b-v1)
- [Shurale7B-v1-GPTQ](https://huggingface.co/BobaZooba/Shurale7b-v1-GPTQ)
## Badge
Consider adding a badge to your model card.
```sh
[<img src="https://github.com/BobaZooba/xllm/blob/main/static/images/xllm-badge.png" alt="Powered by X—LLM" width="175" height="32"/>](https://github.com/BobaZooba/xllm)
```
[<img src="https://github.com/BobaZooba/xllm/blob/main/static/images/xllm-badge.png" alt="Powered by X—LLM" width="175" height="32"/>](https://github.com/BobaZooba/xllm)
# Testing 🧪
At the moment, we don't have Continuous Integration tests that utilize a GPU. However, we might develop these kinds of
tests in the future. It's important to note, though, that this would require investing time into their development, as
well as funding for machine maintenance.
# Future Work đź”®
- Add more testst
- Add RunPod deploy function
- Add [DPO](https://arxiv.org/abs/2305.18290) components
- Add Callbacks to `Experiment`
- GPU CI using RunPod
- Solve DeepSpeed + push_to_hub checkpoints bug
- Make DeepSpeed Stage 3 + bitsandbytes works correc
- Add multipacking
- Add adaptive batch size
- Fix caching in CI
- Add sequence bucketing
- Add more datasets
- Maybe add [tensor_parallel](https://github.com/BlackSamorez/tensor_parallel)
## Tale Quest
`Tale Quest` is my personal project which was built using `xllm` and `Shurale`. It's an interactive text-based game
in `Telegram` with dynamic AI characters, offering infinite scenarios
You will get into exciting journeys and complete fascinating quests. Chat
with `George Orwell`, `Tech Entrepreneur`, `Young Wizard`, `Noir Detective`, `Femme Fatale` and many more
Try it now: [https://t.me/talequestbot](https://t.me/TaleQuestBot?start=Z2g)
### Please support me here
<a href="https://www.buymeacoffee.com/talequest" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/arial-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
Raw data
{
"_id": null,
"home_page": "https://github.com/bobazooba/xllm",
"name": "xllm",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "",
"keywords": "ai nlp llm text deep-learning",
"author": "BobaZooba",
"author_email": "bobazooba@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/87/96/ac7c371d769c15ece2952ca99253c85421c4852286575287e3fb67399521/xllm-0.1.8.tar.gz",
"platform": null,
"description": "# \ud83e\udd96 X\u2014LLM: Cutting Edge & Easy LLM Finetuning\n\n<div align=\"center\">\n\n[](https://github.com/BobaZooba/xllm/actions/workflows/build.yaml)\n[](https://github.com/BobaZooba/xllm/blob/main/LICENSE)\n[](https://github.com/BobaZooba/xllm/releases)\n\n[](https://pypi.org/project/xllm/)\n[](https://pypi.org/project/xllm/)\n[](https://pypi.org/project/xllm/)\n\n[](https://github.com/modelfront/predictor/blob/master/.pre-commit-config.yaml)\n[](https://github.com/psf/black)\n[](https://github.com/astral-sh/ruff)\n[](http://mypy-lang.org/)\n[](https://codecov.io/gh/BobaZooba/xllm)\n\n[](https://discord.gg/5znbxBgwZP)\n\nCutting Edge & Easy LLM Finetuning using the most advanced methods (QLoRA, DeepSpeed, GPTQ, Flash Attention 2, FSDP,\netc)\n\nDeveloped\nby [Boris Zubarev](https://t.me/BobaZooba) | [CV](https://docs.google.com/document/d/1BhFvIHQ1mpm81P-n2A-lhNac-U2wOGc6F2uS9gKvk88/edit?usp=sharing) | [LinkedIn](https://www.linkedin.com/in/boriszubarev/) | [bobazooba@gmail.com](mailto:bobazooba@gmail.com)\n\n</div>\n\n# Why you should use X\u2014LLM \ud83e\ude84\n\nAre you using **Large Language Models (LLMs)** for your work and want to train them more efficiently with advanced\nmethods? Wish to focus on the data and improvements rather than repetitive and time-consuming coding for LLM training?\n\n**X\u2014LLM** is your solution. It's a user-friendly library that streamlines training optimization, so you can **focus on\nenhancing your models and data**. Equipped with **cutting-edge training techniques**, X\u2014LLM is engineered for efficiency\nby engineers who understand your needs.\n\n**X\u2014LLM** is ideal whether you're **gearing up for production** or need a **fast prototyping tool**.\n\n## Features\n\n- Hassle-free training for Large Language Models\n- Seamless integration of new data and data processing\n- Effortless expansion of the library\n- Speed up your training, while simultaneously reducing model sizes\n- Each checkpoint is saved to the \ud83e\udd17 HuggingFace Hub\n- Easy-to-use integration with your existing project\n- Customize almost any part of your training with ease\n- Track your training progress using `W&B`\n- Supported many \ud83e\udd17 Transformers models\n like `Yi-34B`, `Mistal AI`, `Llama 2`, `Zephyr`, `OpenChat`, `Falcon`, `Phi`, `Qwen`, `MPT` and many more\n- Benefit from cutting-edge advancements in LLM training optimization\n - QLoRA and fusing\n - Flash Attention 2\n - Gradient checkpointing\n - bitsandbytes\n - GPTQ (including post-training quantization)\n - DeepSpeed\n - FSDP\n - And many more\n\n# Quickstart \ud83e\udd96\n\n### Installation\n\n`X\u2014LLM` is tested on Python 3.8+, PyTorch 2.0.1+ and CUDA 11.8.\n\n```sh\npip install xllm\n```\n\nVersion which include `deepspeed`, `flash-attn` and `auto-gptq`:\n\n```sh\npip install \"xllm[train]\"\n```\n\nDefault `xllm` version recommended for local development, `xllm[train]` recommended for training.\n\n#### Training recommended environment\n\nCUDA version: `11.8`\nDocker: `huggingface/transformers-pytorch-gpu:latest`\n\n## Fast prototyping \u26a1\n\n```python\nfrom xllm import Config\nfrom xllm.datasets import GeneralDataset\nfrom xllm.experiments import Experiment\n\n# Init Config which controls the internal logic of xllm\n# QLoRA example\nconfig = Config(\n model_name_or_path=\"HuggingFaceH4/zephyr-7b-beta\",\n apply_lora=True,\n load_in_4bit=True,\n)\n\n# Prepare the data\ntrain_data = [\"Hello!\"] * 100\ntrain_dataset = GeneralDataset.from_list(data=train_data)\n\n# Build Experiment from Config: init tokenizer and model, apply LoRA and so on\nexperiment = Experiment(config=config, train_dataset=train_dataset)\nexperiment.build()\n\n# Run Experiment (training)\nexperiment.run()\n\n# # [Optional] Fuse LoRA layers\n# experiment.fuse_lora()\n\n# [Optional] Or push LoRA weights to HuggingFace Hub\nexperiment.push_to_hub(repo_id=\"YOUR_NAME/MODEL_NAME\")\n```\n\n### How `Config` controls `xllm`\n\n[More about config](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#config)\n\n<details>\n <summary>LoRA</summary>\n\n#### Simple\n\n ```python\n config = Config(\n model_name_or_path=\"openchat/openchat_3.5\",\n apply_lora=True,\n)\n ```\n\n#### Advanced\n\n ```python\n config = Config(\n model_name_or_path=\"openchat/openchat_3.5\",\n apply_lora=True,\n lora_rank=8,\n lora_alpha=32,\n lora_dropout=0.05,\n raw_lora_target_modules=\"all\",\n # Names of modules to apply LoRA. A comma-separated string, for example: \"k,q,v\" or \"all\".\n)\n ```\n\n</details>\n\n<details>\n <summary>QLoRA</summary>\n\nTo train the `QLoRA` model, we need to load the backbone model using `bitsandbytes` library and int4 (or int8) weights.\n\n#### Simple\n\n ```python\n config = Config(\n model_name_or_path=\"01-ai/Yi-34B\",\n apply_lora=True,\n load_in_4bit=True,\n prepare_model_for_kbit_training=True,\n)\n ```\n\n#### Advanced\n\n ```python\n config = Config(\n model_name_or_path=\"01-ai/Yi-34B\",\n apply_lora=True,\n load_in_4bit=True,\n prepare_model_for_kbit_training=True,\n llm_int8_threshold=6.0,\n llm_int8_has_fp16_weight=True,\n bnb_4bit_use_double_quant=True,\n bnb_4bit_quant_type=\"nf4\",\n)\n ```\n\n</details>\n\n<details>\n <summary>Push checkpoints to the HuggingFace Hub</summary>\n\nBefore that, you must log in to `Huggingface Hub` or add an `API Token` to the environment variables.\n\n ```python\n config = Config(\n model_name_or_path=\"HuggingFaceH4/zephyr-7b-beta\",\n push_to_hub=True,\n hub_private_repo=True,\n hub_model_id=\"BobaZooba/AntModel-7B-XLLM-Demo-LoRA\",\n save_steps=25,\n)\n ```\n\n- Checkpoints will be saved locally and in Huggingface Hub each `save_steps`\n- If you train a model with `LoRA`, then only `LoRA` weights will be saved\n\n</details>\n\n<details>\n <summary>Report to W&B</summary>\n\nBefore that, you must log in to `W&B` or add an `API Token` to the environment variables.\n\n ```python\n config = Config(\n model_name_or_path=\"HuggingFaceH4/zephyr-7b-beta\",\n report_to_wandb=True,\n logging_steps=5,\n wandb_project=\"xllm-demo\",\n)\n ```\n\n</details>\n\n<details>\n <summary>Gradient checkpointing</summary>\n\nThis will help to use `less GPU memory` during training, that is, you will be able to learn more than without this\ntechnique. The disadvantages of this technique is slowing down the forward step, that is, `slowing down training`.\n\nYou will be training larger models (for example 7B in colab), but at the expense of training speed.\n\n ```python\n config = Config(\n model_name_or_path=\"HuggingFaceH4/zephyr-7b-beta\",\n use_gradient_checkpointing=True,\n)\n ```\n\n</details>\n\n<details>\n <summary>Flash Attention 2</summary>\n\nThis speeds up training and GPU memory consumption, but it does not work with all models and GPUs. You also need to\ninstall `flash-attn` for this. This can be done using:\n\n`pip install \"xllm[train]\"`\n\n ```python\n config = Config(\n model_name_or_path=\"meta-llama/Llama-2-7b-hf\",\n use_flash_attention_2=True,\n)\n ```\n\n</details>\n\n</details>\n\n<details>\n <summary><b>Recommended setup</b></summary>\n\n#### Recommendations\n\n- Incredibly effective method is LoRA (`apply_lora`). It allows for a tremendous reduction in training costs\n and, moreover, helps very effectively combat catastrophic forgetting.\n- Then, I advise using `load_in_4bit` and `prepare_model_for_kbit_training` together. This also significantly reduces\n memory consumption.\n- Lastly, I would recommend apply `use_gradient_checkpointing`. This method also greatly reduces memory consumption, but\n at the expense of slowing down training.\n- If your project allows, I suggest enabling `push_to_hub` and `hub_private_repo`, also specifying the model name\n in `hub_model_id` and `save_steps`. Example: \"BobaZooba/SupaDupaLlama-7B-LoRA\". During training, every checkpoint of\n your model will be saved in the HuggingFace Hub. If you specified `apply_lora`, then only the LoRA weights will be\n saved, which you can later easily fuse with the main model, for example, using `xllm`.\n- If your GPU allows it add `use_flash_attention_2`\n- I also recommend using `report_to_wandb`, also specifying `wandb_project` (the project name in W&B)\n and `wandb_entity` (user or organization name in W&B).\n- Note that for `push_to_hub`, you need to log in to the HuggingFace Hub beforehand or specify the\n token (`HUGGING_FACE_HUB_TOKEN`) in the .env file. Similarly, when using `report_to_wandb`, you will need to log in to\n W&B. You can either specify the token (`WANDB_API_KEY`) in the .env file or you will be prompted to enter the token on\n the command line.\n\n#### Features\n\n- QLoRA\n- Gradient checkpointing\n- Flash Attention 2\n- Stabilize training\n- Push checkpoints to HuggingFace Hub\n- W&B report\n\n ```python\n config = Config(\n model_name_or_path=\"meta-llama/Llama-2-7b-hf\",\n tokenizer_padding_side=\"right\", # good for llama2\n\n warmup_steps=1000,\n max_steps=10000,\n logging_steps=1,\n save_steps=1000,\n per_device_train_batch_size=2,\n gradient_accumulation_steps=2,\n max_length=2048,\n\n stabilize=True,\n use_flash_attention_2=True,\n\n apply_lora=True,\n\n load_in_4bit=True,\n prepare_model_for_kbit_training=True,\n\n use_gradient_checkpointing=True,\n\n push_to_hub=False,\n hub_private_repo=True,\n hub_model_id=\"BobaZooba/SupaDupaLlama-7B-LoRA\",\n\n report_to_wandb=False,\n wandb_project=\"xllm-demo\",\n wandb_entity=\"bobazooba\",\n )\n ```\n\n</details>\n\n<details>\n <summary>Fuse</summary>\n\nThis operation is only for models with a LoRA adapter.\n\nYou can explicitly specify to fuse the model after training.\n\n ```python\n config = Config(\n model_name_or_path=\"HuggingFaceH4/zephyr-7b-beta\",\n apply_lora=True,\n fuse_after_training=True,\n)\n ```\n\nEven when you are using QLoRa\n\n ```python\n config = Config(\n model_name_or_path=\"HuggingFaceH4/zephyr-7b-beta\",\n apply_lora=True,\n load_in_4bit=True,\n prepare_model_for_kbit_training=True,\n fuse_after_training=True,\n)\n ```\n\nOr you can fuse the model yourself after training.\n\n ```python\n experiment.fuse_lora()\n ```\n\n</details>\n\n<details>\n <summary>DeepSpeed</summary>\n\n`DeepSpeed` is needed for training models on `multiple GPUs`. `DeepSpeed` allows you\nto `efficiently manage the resources of several GPUs during training`. For example, you\ncan `distribute the gradients and the state of the optimizer to several GPUs`, rather than storing a complete set of\ngradients and the state of the optimizer on each GPU. Starting training using `DeepSpeed` can only happen from\nthe `command line`.\n\n`train.py`\n\n ```python\nfrom xllm import Config\nfrom xllm.datasets import GeneralDataset\nfrom xllm.cli import cli_run_train\n\nif __name__ == '__main__':\n train_data = [\"Hello!\"] * 100\n train_dataset = GeneralDataset.from_list(data=train_data)\n cli_run_train(config_cls=Config, train_dataset=train_dataset)\n ```\n\nRun train (in the `num_gpus` parameter, specify as many GPUs as you have)\n\n ```sh\n deepspeed --num_gpus=8 train.py --deepspeed_stage 2\n ```\n\nYou also can pass other parameters\n\n ```sh\ndeepspeed --num_gpus=8 train.py \\\n --deepspeed_stage 2 \\\n --apply_lora True \\\n --stabilize True \\\n --use_gradient_checkpointing True\n ```\n\n</details>\n\n### Notebooks\n\n| Name | Comment | Link |\n|-------------------------------------------|------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| X\u2014LLM Prototyping | In this notebook you will learn the basics of the library | [](https://colab.research.google.com/drive/1zsNmJFns1PKZy5VE5p5nsQL-mZF7SwHf?usp=sharing) |\n| Llama2 & Mistral AI efficient fine-tuning | 7B model training in colab using QLoRA, bnb int4, gradient checkpointing and X\u2014LLM | [](https://colab.research.google.com/drive/1CNNB_HPhQ8g7piosdehqWlgA30xoLauP?usp=sharing) |\n\n## Production solution \ud83d\ude80\n\n`X\u2014LLM` enables not only to prototype models, but also facilitates the development of production-ready solutions through\nbuilt-in capabilities and customization.\n\nUsing `X\u2014LLM` to train a model is easy and involves these few steps:\n\n1. `Prepare` \u2014 Get the data and the model ready by downloading and preparing them. Saves data locally\n to `config.train_local_path_to_data` and `config.eval_local_path_to_data` if you are using eval dataset\n2. `Train` \u2014 Use the data prepared in the previous step to train the model\n3. `Fuse` \u2014 If you used LoRA during the training, fuse LoRA\n4. `Quantize` \u2014 Optimize your model's memory usage by quantizing it\n\nRemember, these tasks in `X\u2014LLM` start from the command line. So, when you're all set to go, launching your full project\nwill look something like this:\n\n<details>\n <summary>Example how to run your project</summary>\n\n1. Downloading and preparing data and model\n\n ```sh\npython3 MY_PROJECT/cli/prepare.py \\\n --dataset_key MY_DATASET \\\n --model_name_or_path mistralai/Mistral-7B-v0.1 \\\n --path_to_env_file ./.env\n ```\n\n2. Run train using DeepSpeed on multiple GPUs\n\n ```sh\ndeepspeed --num_gpus=8 MY_PROJECT/cli/train.py \\\n --use_gradient_checkpointing True \\\n --deepspeed_stage 2 \\\n --stabilize True \\\n --model_name_or_path mistralai/Mistral-7B-v0.1 \\\n --use_flash_attention_2 False \\\n --load_in_4bit True \\\n --apply_lora True \\\n --raw_lora_target_modules all \\\n --per_device_train_batch_size 8 \\\n --warmup_steps 1000 \\\n --save_total_limit 0 \\\n --push_to_hub True \\\n --hub_model_id MY_HF_HUB_NAME/LORA_MODEL_NAME \\\n --hub_private_repo True \\\n --report_to_wandb True \\\n --path_to_env_file ./.env\n ```\n\n3. Fuse LoRA\n\n ```sh\npython3 MY_PROJECT/cli/fuse.py \\\n --model_name_or_path mistralai/Mistral-7B-v0.1 \\\n --lora_hub_model_id MY_HF_HUB_NAME/LORA_MODEL_NAME \\\n --hub_model_id MY_HF_HUB_NAME/MODEL_NAME \\\n --hub_private_repo True \\\n --force_fp16 True \\\n --fused_model_local_path ./fused_model/ \\\n --path_to_env_file ./.env\n ```\n\n4. [Optional] GPTQ quantization of the trained model with fused LoRA\n\n ```sh\npython3 MY_PROJECT/cli/quantize.py \\\n --model_name_or_path ./fused_model/ \\\n --apply_lora False \\\n --stabilize False \\\n --quantization_max_samples 128 \\\n --quantized_model_path ./quantized_model/ \\\n --prepare_model_for_kbit_training False \\\n --quantized_hub_model_id MY_HF_HUB_NAME/MODEL_NAME_GPTQ \\\n --quantized_hub_private_repo True \\\n --path_to_env_file ./.env\n ```\n\n</details>\n\nRight now, the `X\u2014LLM` library lets you use only the [SODA dataset](https://huggingface.co/datasets/allenai/soda). We've\nset it up this way for demo purposes, but we're planning to add more datasets soon. You'll need to figure out how to\ndownload and handle your dataset. Simply put, you take care of your data, and `X\u2014LLM` handles the rest. We've done it\nthis\nway on purpose, to give you plenty of room to get creative and customize to your heart's content.\n\nYou can customize your dataset in detail, adding additional fields. All of this will enable you to implement virtually\nany task in the areas of `Supervised Learning` and `Offline Reinforcement Learning`.\n\nAt the same time, you always have an easy way to submit data for language modeling.\n\n<details>\n <summary>Example</summary>\n\n ```python\nfrom xllm import Config\nfrom xllm.datasets import GeneralDataset\nfrom xllm.cli import cli_run_train\n\nif __name__ == '__main__':\n train_data = [\"Hello!\"] * 100\n train_dataset = GeneralDataset.from_list(data=train_data)\n cli_run_train(config_cls=Config, train_dataset=train_dataset)\n ```\n\n</details>\n\n### Build your own project\n\nTo set up your own project using `X\u2014LLM`, you need to do two things:\n\n1. Implement your dataset (figure out how to download and handle it)\n2. Add `X\u2014LLM`'s command-line tools into your project\n\nOnce that's done, your project will be good to go, and you can start running the steps you need (like prepare, train,\nand so on).\n\nTo get a handle on building your project with `X\u2014LLM`, check out the materials below.\n\n## Useful materials\n\n- [Guide](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md): here, we go into detail about everything the library can\n do\n- [Demo project](https://github.com/BobaZooba/xllm-demo): here's a step-by-step example of how to use `X\u2014LLM` and fit\n it\n into your own project\n- [WeatherGPT](https://github.com/BobaZooba/wgpt): this repository features an example of how to utilize the xllm library. Included is a solution for a common type of assessment given to LLM engineers, who typically earn between $120,000 to $140,000 annually\n- [Shurale](https://github.com/BobaZooba/shurale): project with the finetuned 7B Mistal model\n\n# Config \ud83d\udd27\n\nThe `X\u2014LLM` library uses a single config setup for all steps like preparing, training and the other steps. It's\ndesigned in a way that\nlets you easily understand the available features and what you can adjust. `Config` has control almost over every\nsingle part of each step. Thanks to the config, you can pick your dataset, set your collator, manage the type of\nquantization during training, decide if you want to use LoRA, if you need to push a checkpoint to the `HuggingFace Hub`,\nand a\nlot more.\n\nConfig path: `src.xllm.core.config.Config`\n\nOr\n\n```python\nfrom xllm import Config\n```\n\n## Useful materials\n\n- [Important config fields for different steps](https://github.com/BobaZooba/xllm#how-config-controls-xllm)\n- [How do I choose the methods for training?](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-do-i-choose-the-methods-for-training)\n- [Detailed description of all config fields](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#detailed-config-explanation)\n\n# Customization options \ud83d\udee0\n\nYou have the flexibility to tweak many aspects of your model's training: data, how data is processed, trainer, config,\nhow the model is loaded, what happens before and after training, and so much more.\n\nWe've got ready-to-use components for every part of the `xllm` pipeline. You can entirely switch out some components\nlike the dataset, collator, trainer, and experiment.\nFor some components like experiment and config, you have the option to just build on what's already there.\n\n### Useful materials\n\n- [How to implement dataset](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-dataset)\n- [How to add CLI tools to your project](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-add-cli-tools-to-your-project)\n- [How to implement collator](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-collator)\n- [How to implement trainer](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-trainer)\n- [How to implement experiment](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-implement-experiment)\n- [How to extend config](https://github.com/BobaZooba/xllm/blob/main/GUIDE.md#how-to-extend-config)\n\n# Projects using X\u2014LLM \ud83c\udfc6\n\nBuilding something cool with [X\u2014LLM](https://github.com/BobaZooba/xllm)? Kindly reach out to me\nat [bobazooba@gmail.com](mailto:bobazooba@gmail.com). I'd love to hear from you.\n\n## Hall of Fame\n\nWrite to us so that we can add your project.\n\n- [Shurale7B-v1](https://huggingface.co/BobaZooba/Shurale7b-v1)\n- [Shurale7B-v1-GPTQ](https://huggingface.co/BobaZooba/Shurale7b-v1-GPTQ)\n\n## Badge\n\nConsider adding a badge to your model card.\n\n```sh\n[<img src=\"https://github.com/BobaZooba/xllm/blob/main/static/images/xllm-badge.png\" alt=\"Powered by X\u2014LLM\" width=\"175\" height=\"32\"/>](https://github.com/BobaZooba/xllm)\n```\n\n[<img src=\"https://github.com/BobaZooba/xllm/blob/main/static/images/xllm-badge.png\" alt=\"Powered by X\u2014LLM\" width=\"175\" height=\"32\"/>](https://github.com/BobaZooba/xllm)\n\n# Testing \ud83e\uddea\n\nAt the moment, we don't have Continuous Integration tests that utilize a GPU. However, we might develop these kinds of\ntests in the future. It's important to note, though, that this would require investing time into their development, as\nwell as funding for machine maintenance.\n\n# Future Work \ud83d\udd2e\n\n- Add more testst\n- Add RunPod deploy function\n- Add [DPO](https://arxiv.org/abs/2305.18290) components\n- Add Callbacks to `Experiment`\n- GPU CI using RunPod\n- Solve DeepSpeed + push_to_hub checkpoints bug\n- Make DeepSpeed Stage 3 + bitsandbytes works correc\n- Add multipacking\n- Add adaptive batch size\n- Fix caching in CI\n- Add sequence bucketing\n- Add more datasets\n- Maybe add [tensor_parallel](https://github.com/BlackSamorez/tensor_parallel)\n\n## Tale Quest\n\n`Tale Quest` is my personal project which was built using `xllm` and `Shurale`. It's an interactive text-based game\nin `Telegram` with dynamic AI characters, offering infinite scenarios\n\nYou will get into exciting journeys and complete fascinating quests. Chat\nwith `George Orwell`, `Tech Entrepreneur`, `Young Wizard`, `Noir Detective`, `Femme Fatale` and many more\n\nTry it now: [https://t.me/talequestbot](https://t.me/TaleQuestBot?start=Z2g)\n\n### Please support me here\n\n<a href=\"https://www.buymeacoffee.com/talequest\" target=\"_blank\"><img src=\"https://cdn.buymeacoffee.com/buttons/v2/arial-yellow.png\" alt=\"Buy Me A Coffee\" style=\"height: 60px !important;width: 217px !important;\" ></a>\n\n\n",
"bugtrack_url": null,
"license": "Apache",
"summary": "Simple & Cutting Edge LLM Finetuning",
"version": "0.1.8",
"project_urls": {
"Homepage": "https://github.com/bobazooba/xllm"
},
"split_keywords": [
"ai",
"nlp",
"llm",
"text",
"deep-learning"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "ab25c9de1b456533d1a98f50dcbc6dce58232fb81345c861eebe7daf495eca77",
"md5": "0b8c79c19f846a93a2910020a2b05d2c",
"sha256": "6a2d93447caebb2cde4eca5b09e2d5fa2d4858fadb8e920fbfb7981a0bb74748"
},
"downloads": -1,
"filename": "xllm-0.1.8-py3-none-any.whl",
"has_sig": false,
"md5_digest": "0b8c79c19f846a93a2910020a2b05d2c",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 105678,
"upload_time": "2023-12-06T11:16:13",
"upload_time_iso_8601": "2023-12-06T11:16:13.699988Z",
"url": "https://files.pythonhosted.org/packages/ab/25/c9de1b456533d1a98f50dcbc6dce58232fb81345c861eebe7daf495eca77/xllm-0.1.8-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "8796ac7c371d769c15ece2952ca99253c85421c4852286575287e3fb67399521",
"md5": "d398ef51913ada22288b03847eeb07a4",
"sha256": "fad24d7a0f1d6f34656cd8021ffac391999b13b83a969b1791446ea42a2de72c"
},
"downloads": -1,
"filename": "xllm-0.1.8.tar.gz",
"has_sig": false,
"md5_digest": "d398ef51913ada22288b03847eeb07a4",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 86825,
"upload_time": "2023-12-06T11:16:16",
"upload_time_iso_8601": "2023-12-06T11:16:16.019478Z",
"url": "https://files.pythonhosted.org/packages/87/96/ac7c371d769c15ece2952ca99253c85421c4852286575287e3fb67399521/xllm-0.1.8.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-12-06 11:16:16",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "bobazooba",
"github_project": "xllm",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "xllm"
}
JSON
