xTuring

Créez, modifiez et contrôlez vos propres LLM personnalisés

---

xTuring permet un réglage fin rapide, efficace et simple des LLM open source, tels que Mistral, LLaMA, GPT-J, etc. En fournissant une interface facile à utiliser pour affiner les LLM en fonction de vos propres données et applications, xTuring simplifie la création, la modification et le contrôle des LLM. L’ensemble du processus peut être effectué sur votre ordinateur ou dans votre cloud privé, garantissant ainsi la confidentialité et la sécurité des données.

Avec xTuring vous pouvez,

• Ingérez des données provenant de différentes sources et prétraitez-les dans un format que les LLM peuvent comprendre
• Passez d'un GPU unique à plusieurs GPU pour un réglage plus rapide
• Tirez parti des méthodes économes en mémoire (c'est-à-dire INT4, réglage fin LoRA) pour réduire les coûts matériels jusqu'à 90 %
• Explorez différentes méthodes de réglage fin et comparez-les pour trouver le modèle le plus performant
• Évaluez des modèles affinés sur des métriques bien définies pour une analyse approfondie

Installation

pip install xturing

Démarrage rapide

 from xturing . datasets import InstructionDataset
from xturing . models import BaseModel

# Load the dataset
instruction_dataset = InstructionDataset ( "./examples/models/llama/alpaca_data" )

# Initialize the model
model = BaseModel . create ( "llama_lora" )

# Finetune the model
model . finetune ( dataset = instruction_dataset )

# Perform inference
output = model . generate ( texts = [ "Why LLM models are becoming so important?" ])

print ( "Generated output by the model: {}" . format ( output ))

Vous pouvez trouver le dossier de données ici.

? Quoi de neuf?

Nous sommes ravis d'annoncer les dernières améliorations de notre bibliothèque xTuring :

1. Intégration LLaMA 2 - Vous pouvez utiliser et affiner le modèle LLaMA 2 dans différentes configurations : prêt à l'emploi , prêt à l'emploi avec précision INT8 , réglage fin LoRA , réglage fin LoRA avec précision INT8 et réglage fin LoRA. réglage avec la précision INT4 à l'aide du wrapper GenericModel et/ou vous pouvez utiliser la classe Llama2 de xturing.models pour tester et affiner le modèle.

 from xturing . models import Llama2
model = Llama2 ()

## or
from xturing . models import BaseModel
model = BaseModel . create ( 'llama2' )

2. Evaluation - Vous pouvez désormais évaluer n'importe quel Causal Language Model sur n'importe quel ensemble de données. Les mesures actuellement prises en charge sont perplexity .

 # Make the necessary imports
from xturing . datasets import InstructionDataset
from xturing . models import BaseModel

# Load the desired dataset
dataset = InstructionDataset ( '../llama/alpaca_data' )

# Load the desired model
model = BaseModel . create ( 'gpt2' )

# Run the Evaluation of the model on the dataset
result = model . evaluate ( dataset )

# Print the result
print ( f"Perplexity of the evalution: { result } " )

3. INT4 Precision - Vous pouvez désormais utiliser et affiner n'importe quel LLM avec INT4 Precision à l'aide de GenericLoraKbitModel .

 # Make the necessary imports
from xturing . datasets import InstructionDataset
from xturing . models import GenericLoraKbitModel

# Load the desired dataset
dataset = InstructionDataset ( '../llama/alpaca_data' )

# Load the desired model for INT4 bit fine-tuning
model = GenericLoraKbitModel ( 'tiiuae/falcon-7b' )

# Run the fine-tuning
model . finetune ( dataset )

4. Inférence CPU - Le CPU, y compris les processeurs des ordinateurs portables, est désormais entièrement équipé pour gérer l'inférence LLM. Nous avons intégré Intel® Extension for Transformers pour économiser la mémoire en compressant le modèle avec des algorithmes de quantification basés uniquement sur le poids et accélérer l'inférence en exploitant son noyau hautement optimisé sur les plates-formes Intel.

 # Make the necessary imports
from xturing . models import BaseModel

# Initializes the model: quantize the model with weight-only algorithms
# and replace the linear with Itrex's qbits_linear kernel
model = BaseModel . create ( "llama2_int8" )

# Once the model has been quantized, do inferences directly
output = model . generate ( texts = [ "Why LLM models are becoming so important?" ])
print ( output )

5. Intégration par lots - En modifiant le « batch_size » dans les fonctions .generate() et .evaluate(), vous pouvez accélérer les résultats. L'utilisation d'un « batch_size » supérieur à 1 améliore généralement l'efficacité du traitement.

 # Make the necessary imports
from xturing . datasets import InstructionDataset
from xturing . models import GenericLoraKbitModel

# Load the desired dataset
dataset = InstructionDataset ( '../llama/alpaca_data' )

# Load the desired model for INT4 bit fine-tuning
model = GenericLoraKbitModel ( 'tiiuae/falcon-7b' )

# Generate outputs on desired prompts
outputs = model . generate ( dataset = dataset , batch_size = 10 )

Une exploration de l’exemple de travail Llama LoRA INT4 est recommandée pour comprendre son application.

Pour un aperçu plus approfondi, envisagez d'examiner l'exemple de travail GenericModel disponible dans le référentiel.

Terrain de jeu CLI

$ xturing chat -m " <path-to-model-folder> "

Terrain de jeu de l'interface utilisateur

 from xturing . datasets import InstructionDataset
from xturing . models import BaseModel
from xturing . ui import Playground

dataset = InstructionDataset ( "./alpaca_data" )
model = BaseModel . create ( "<model_name>" )

model . finetune ( dataset = dataset )

model . save ( "llama_lora_finetuned" )

Playground (). launch () ## launches localhost UI 

Tutoriels

• Préparation de votre ensemble de données
• Affinement de Cerebras-GPT avec LoRA et INT8
• Mise au point de Cerebras-GPT avec LoRA
• Affinement de LLaMA avec LoRA et INT8
• LLaMA peaufiné avec LoRA
• Mise au point du LLaMA
• Ajustement GPT-J avec LoRA et INT8
• Ajustement GPT-J avec LoRA
• Ajustement de GPT-2 avec LoRA

Performance

Voici une comparaison des performances de différentes techniques de réglage fin sur le modèle LLaMA 7B. Nous utilisons l'ensemble de données Alpaca pour un réglage fin. L'ensemble de données contient 52 000 instructions.

Matériel:

4 GPU A100 de 40 Go, processeur de 335 Go de RAM

Paramètres de réglage fin :

 {
  'maximum sequence length' : 512 ,
  'batch size' : 1 ,
}

LLaMA-7B	DeepSpeed ​​+ déchargement du processeur	LoRA + DeepSpeed	LoRA + DeepSpeed ​​+ déchargement du processeur
GPU	33,5 Go	23,7 Go	21,9 Go
Processeur	190 Go	10,2 Go	14,9 Go
Temps/époque	21 heures	20 minutes	20 minutes

Contribuez à cela en soumettant vos résultats de performances sur d'autres GPU en créant un problème avec vos spécifications matérielles, votre consommation de mémoire et votre temps par époque.

? Points de contrôle du modèle affinés

Nous avons déjà peaufiné certains modèles que vous pouvez utiliser comme base ou avec lesquels commencer à jouer. Voici comment vous les chargeriez :

 from xturing . models import BaseModel
model = BaseModel . load ( "x/distilgpt2_lora_finetuned_alpaca" )

modèle	ensemble de données	Chemin
DistilGPT-2 LoRA	alpaga	x/distilgpt2_lora_finetuned_alpaca
LLaMA LoRA	alpaga	x/llama_lora_finetuned_alpaca

Modèles pris en charge

Vous trouverez ci-dessous une liste de tous les modèles pris en charge via la classe BaseModel de xTuring et leurs clés correspondantes pour les charger.

Modèle	Clé
Floraison	floraison
Cérébraux	cerveaux
DistilGPT-2	distillergpt2
Faucon-7B	faucon
Galactique	galactique
GPT-J	gptj
GPT-2	gpt2
Lama	lama
LlaMA2	lama2
OPT-1.3B	opter

Les variantes mentionnées ci-dessus sont les variantes de base des LLM. Vous trouverez ci-dessous les modèles pour obtenir leurs versions LoRA , INT8 , INT8 + LoRA et INT4 + LoRA .

Version	Modèle
LoRA	<model_key>_lora
INT8	<clé_modèle>_int8
INT8 + LoRA	<model_key>_lora_int8

** Afin de charger la version INT4+LoRA de n'importe quel modèle, vous devrez utiliser la classe GenericLoraKbitModel de xturing.models . Voici comment l'utiliser :

 model = GenericLoraKbitModel ( '<model_path>' )

Le model_path peut être remplacé par votre répertoire local ou par n'importe quel modèle de bibliothèque HuggingFace comme facebook/opt-1.3b .

? Feuille de route

• Prise en charge des modèles LLaMA , GPT-J , GPT-2 , OPT , Cerebras-GPT , Galactica et Bloom
• Génération d'ensembles de données par auto-instruction
• Réglage fin LoRA de faible précision et réglage fin non supervisé
• Prise en charge du réglage fin de basse précision INT8
• API de modèles OpenAI, Cohere et AI21 Studio pour la génération d'ensembles de données
• Ajout de points de contrôle affinés pour certains modèles au hub
• Démo de réglage fin d'INT4 LLaMA LoRA
• INT4 LLaMA LoRA réglage fin avec la génération INT4
• Prise en charge d'un wrapper Generic model
• Prise en charge du modèle Falcon-7B
• Prise en charge du réglage fin de basse précision INT4
• Évaluation des modèles LLM
• Prise en charge du réglage fin de basse précision INT3, INT2, INT1
• Prise en charge d'une diffusion stable

? Aide et support

Si vous avez des questions, vous pouvez créer un ticket sur ce référentiel.

Vous pouvez également rejoindre notre serveur Discord et démarrer une discussion sur la chaîne #xturing .

Licence

Ce projet est sous licence Apache License 2.0 - voir le fichier LICENSE pour plus de détails.

? Contribuer

En tant que projet open source dans un domaine en évolution rapide, nous apprécions les contributions de toutes sortes, y compris les nouvelles fonctionnalités et une meilleure documentation. Veuillez lire notre guide de contribution pour savoir comment vous pouvez vous impliquer.