xTuring

Erstellen, ändern und steuern Sie Ihre eigenen personalisierten LLMs

---

xTuring ermöglicht eine schnelle, effiziente und einfache Feinabstimmung von Open-Source-LLMs wie Mistral, LLaMA, GPT-J und mehr. Durch die Bereitstellung einer benutzerfreundlichen Schnittstelle zur Feinabstimmung von LLMs an Ihre eigenen Daten und Anwendungen erleichtert xTuring das Erstellen, Ändern und Steuern von LLMs. Der gesamte Vorgang kann auf Ihrem Computer oder in Ihrer privaten Cloud durchgeführt werden, um Datenschutz und Sicherheit zu gewährleisten.

Mit xTuring können Sie,

• Nehmen Sie Daten aus verschiedenen Quellen auf und verarbeiten Sie sie in einem Format vor, das LLMs verstehen können
• Skalieren Sie für eine schnellere Feinabstimmung von einer einzelnen auf mehrere GPUs
• Nutzen Sie speichereffiziente Methoden (z. B. INT4, LoRA-Feinabstimmung), um die Hardwarekosten um bis zu 90 % zu senken.
• Entdecken Sie verschiedene Feinabstimmungsmethoden und vergleichen Sie sie, um das Modell mit der besten Leistung zu finden
• Bewerten Sie fein abgestimmte Modelle anhand klar definierter Metriken für eine detaillierte Analyse

Installation

pip install xturing

Schnellstart

 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 ))

Den Datenordner finden Sie hier.

? Was ist neu?

Wir freuen uns, die neuesten Verbesserungen unserer xTuring -Bibliothek bekannt zu geben:

1. LLaMA 2 Integration – Sie können das LLaMA 2 Modell in verschiedenen Konfigurationen verwenden und optimieren: Standard , Standard mit INT8-Präzision , LoRA-Feinabstimmung , LoRA-Feinabstimmung mit INT8-Präzision und LoRA-Feinabstimmung. Optimierung mit INT4-Präzision mithilfe des GenericModel Wrappers und/oder Sie können die Llama2 Klasse von xturing.models verwenden, um das Modell zu testen und zu optimieren.

 from xturing . models import Llama2
model = Llama2 ()

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

2. Evaluation – Jetzt können Sie jedes Causal Language Model für jeden Datensatz auswerten. Die derzeit unterstützten Metriken sind 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 – Sie können jetzt jedes LLM mit INT4 Precision mithilfe von GenericLoraKbitModel verwenden und optimieren.

 # 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. CPU-Inferenz – Die CPU, einschließlich Laptop-CPUs, ist jetzt vollständig für die Verarbeitung von LLM-Inferenzen ausgestattet. Wir haben die Intel® Extension for Transformers integriert, um Speicher zu sparen, indem wir das Modell mit Quantisierungsalgorithmen nur für die Gewichtung komprimieren, und um die Inferenz zu beschleunigen, indem wir den hochoptimierten Kernel auf Intel-Plattformen nutzen.

 # 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. Batch-Integration – Durch Anpassen der „batch_size“ in den Funktionen .generate() und .evaluate() können Sie die Ergebnisse beschleunigen. Die Verwendung einer „batch_size“ größer als 1 erhöht normalerweise die Verarbeitungseffizienz.

 # 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 )

Zum Verständnis seiner Anwendung wird eine Untersuchung des Llama LoRA INT4-Arbeitsbeispiels empfohlen.

Um einen erweiterten Einblick zu erhalten, sollten Sie sich das im Repository verfügbare GenericModel-Arbeitsbeispiel ansehen.

CLI-Spielplatz

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

UI-Spielplatz

 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 

Tutorials

• Vorbereiten Ihres Datensatzes
• Cerebras-GPT-Feinabstimmung mit LoRA und INT8
• Cerebras-GPT-Feinabstimmung mit LoRA
• LLaMA-Feinabstimmung mit LoRA und INT8
• LLaMA-Feinabstimmung mit LoRA
• LLaMA-Feinabstimmung
• GPT-J-Feinabstimmung mit LoRA und INT8
• GPT-J-Feinabstimmung mit LoRA
• GPT-2-Feinabstimmung mit LoRA

Leistung

Hier ist ein Vergleich der Leistung verschiedener Feinabstimmungstechniken am LLaMA 7B-Modell. Zur Feinabstimmung nutzen wir den Alpaca-Datensatz. Der Datensatz enthält 52.000 Anweisungen.

Hardware:

4xA100 40 GB GPU, 335 GB CPU-RAM

Feinabstimmungsparameter:

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

LLaMA-7B	DeepSpeed ​​+ CPU-Offloading	LoRA + DeepSpeed	LoRA + DeepSpeed ​​+ CPU-Offloading
GPU	33,5 GB	23,7 GB	21,9 GB
CPU	190 GB	10,2 GB	14,9 GB
Zeit/Epoche	21 Stunden	20 Min	20 Min

Tragen Sie dazu bei, indem Sie Ihre Leistungsergebnisse auf anderen GPUs übermitteln, indem Sie ein Problem mit Ihren Hardwarespezifikationen, dem Speicherverbrauch und der Zeit pro Epoche verursachen.

? Feinabgestimmte Modellkontrollpunkte

Wir haben bereits einige Modelle verfeinert, die Sie als Basis verwenden oder mit denen Sie anfangen können zu spielen. So würden Sie sie laden:

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

Modell	Datensatz	Weg
DistilGPT-2 LoRA	Alpaka	x/distilgpt2_lora_finetuned_alpaca
LLaMA LoRA	Alpaka	x/llama_lora_finetuned_alpaca

Unterstützte Modelle

Nachfolgend finden Sie eine Liste aller über die BaseModel Klasse von xTuring unterstützten Modelle und die entsprechenden Schlüssel zum Laden.

Modell	Schlüssel
Blühen	blühen
Großhirn	Gehirne
DestillierenGPT-2	destilgpt2
Falcon-7B	Falke
Galactica	Galactica
GPT-J	gptj
GPT-2	gpt2
Lama	Lama
LlaMA2	Lama2
OPT-1.3B	opt

Bei den oben genannten handelt es sich um die Basisvarianten der LLMs. Nachfolgend finden Sie die Vorlagen, um die Versionen LoRA , INT8 , INT8 + LoRA und INT4 + LoRA zu erhalten.

Version	Vorlage
LoRA	<model_key>_lora
INT8	<model_key>_int8
INT8 + LoRA	<model_key>_lora_int8

** Um INT4+LoRA -Version eines beliebigen Modells zu laden, müssen Sie die Klasse GenericLoraKbitModel von xturing.models verwenden. Im Folgenden erfahren Sie, wie Sie es verwenden:

 model = GenericLoraKbitModel ( '<model_path>' )

Der model_path kann durch Ihr lokales Verzeichnis oder ein beliebiges HuggingFace-Bibliotheksmodell wie facebook/opt-1.3b ersetzt werden.

? Roadmap

• Unterstützung für die Modelle LLaMA , GPT-J , GPT-2 , OPT , Cerebras-GPT , Galactica und Bloom
• Datensatzgenerierung durch Selbstanweisung
• Niedrigpräzise LoRA-Feinabstimmung und unbeaufsichtigte Feinabstimmung
• INT8-Feinabstimmungsunterstützung mit geringer Präzision
• OpenAI-, Cohere- und AI21 Studio-Modell-APIs für die Datensatzgenerierung
• Für einige Modelle wurden dem Hub fein abgestimmte Kontrollpunkte hinzugefügt
• INT4 LLaMA LoRA Feinabstimmungsdemo
• INT4 LLaMA LoRA Feinabstimmung mit INT4-Generierung
• Unterstützung für einen Generic model Wrapper
• Unterstützung für Falcon-7B Modell
• INT4-Feinabstimmungsunterstützung mit geringer Präzision
• Evaluierung von LLM-Modellen
• INT3, INT2, INT1 Feinabstimmungsunterstützung mit geringer Präzision
• Unterstützung für stabile Verbreitung

? Hilfe und Support

Wenn Sie Fragen haben, können Sie in diesem Repository ein Problem erstellen.

Sie können auch unserem Discord-Server beitreten und eine Diskussion im #xturing -Kanal starten.

Lizenz

Dieses Projekt ist unter der Apache-Lizenz 2.0 lizenziert – Einzelheiten finden Sie in der LIZENZ-Datei.

? Mitwirken

Als Open-Source-Projekt in einem sich schnell entwickelnden Bereich freuen wir uns über Beiträge aller Art, einschließlich neuer Funktionen und besserer Dokumentation. Bitte lesen Sie unseren Beitragsleitfaden, um zu erfahren, wie Sie sich beteiligen können.