xTuring

Cree, modifique y controle sus propios LLM personalizados

---

xTuring proporciona un ajuste rápido, eficiente y sencillo de LLM de código abierto, como Mistral, LLaMA, GPT-J y más. Al proporcionar una interfaz fácil de usar para ajustar los LLM a sus propios datos y aplicaciones, xTuring simplifica la creación, modificación y control de los LLM. Todo el proceso se puede realizar dentro de su computadora o en su nube privada, garantizando la privacidad y seguridad de los datos.

Con xTuring puedes,

• Ingerir datos de diferentes fuentes y preprocesarlos en un formato que los LLM puedan entender.
• Escale de una a varias GPU para un ajuste más rápido
• Aproveche los métodos eficientes en memoria (es decir, INT4, ajuste fino de LoRA) para reducir los costos de hardware hasta en un 90 %.
• Explore diferentes métodos de ajuste y compárelos para encontrar el modelo con mejor rendimiento.
• Evalúe modelos ajustados en métricas bien definidas para un análisis en profundidad

Instalación

pip install xturing

Inicio rápido

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

Puede encontrar la carpeta de datos aquí.

? ¿Qué hay de nuevo?

Nos complace anunciar las últimas mejoras en nuestra biblioteca xTuring :

1. Integración LLaMA 2 : puede utilizar y ajustar el modelo LLaMA 2 en diferentes configuraciones: disponible en el mercado , disponible en el mercado con precisión INT8 , ajuste fino de LoRA , ajuste fino de LoRA con precisión INT8 y ajuste fino de LoRA. sintonizando con precisión INT4 usando el contenedor GenericModel y/o puede usar la clase Llama2 de xturing.models para probar y ajustar el modelo.

 from xturing . models import Llama2
model = Llama2 ()

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

2. Evaluation : ahora puede evaluar cualquier Causal Language Model en cualquier conjunto de datos. La métrica actualmente soportada es 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 : ahora puede usar y ajustar cualquier LLM con INT4 Precision usando 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. Inferencia de CPU : la CPU, incluidas las CPU de portátiles, ahora está completamente equipada para manejar la inferencia LLM. Integramos Intel® Extension para Transformers para conservar memoria comprimiendo el modelo con algoritmos de cuantificación de solo peso y acelerar la inferencia aprovechando su núcleo altamente optimizado en las plataformas 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. Integración por lotes : al modificar el 'batch_size' en las funciones .generate() y .evaluate(), puedes acelerar los resultados. El uso de un 'batch_size' mayor que 1 normalmente mejora la eficiencia del procesamiento.

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

Se recomienda una exploración del ejemplo de trabajo de Llama LoRA INT4 para comprender su aplicación.

Para obtener más información, considere examinar el ejemplo de trabajo de GenericModel disponible en el repositorio.

Zona de juegos CLI

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

área de juegos de interfaz de usuario

 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 

Tutoriales

• Preparando su conjunto de datos
• Ajuste de Cerebras-GPT con LoRA e INT8
• Ajuste de Cerebras-GPT con LoRA
• Ajuste de LLaMA con LoRA e INT8
• Ajuste de LLaMA con LoRA
• Puesta a punto del LLaMA
• Ajuste fino de GPT-J con LoRA e INT8
• Ajuste fino de GPT-J con LoRA
• Ajuste fino de GPT-2 con LoRA

Actuación

A continuación se muestra una comparación del rendimiento de diferentes técnicas de ajuste fino en el modelo LLaMA 7B. Usamos el conjunto de datos de Alpaca para realizar ajustes. El conjunto de datos contiene 52K instrucciones.

Hardware:

4 GPU A100 de 40 GB, CPU de 335 GB de RAM

Parámetros de ajuste fino:

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

LLaMA-7B	Descarga de CPU DeepSpeed ​​+	LoRA + Velocidad profunda	LoRA + DeepSpeed ​​+ Descarga de CPU
GPU	33,5GB	23,7GB	21,9GB
UPC	190GB	10,2GB	14,9GB
Tiempo/época	21 horas	20 minutos	20 minutos

Contribuya a esto enviando sus resultados de rendimiento en otras GPU creando un problema con sus especificaciones de hardware, consumo de memoria y tiempo por época.

? Puntos de control del modelo ajustados

Ya hemos perfeccionado algunos modelos que puedes usar como base o empezar a jugar. Así es como los cargarías:

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

modelo	conjunto de datos	Camino
DistilGPT-2 LoRA	alpaca	x/distilgpt2_lora_finetuned_alpaca
LLAMA LORA	alpaca	x/llama_lora_finetuned_alpaca

Modelos compatibles

A continuación se muestra una lista de todos los modelos compatibles a través de la clase BaseModel de xTuring y sus claves correspondientes para cargarlos.

Modelo	Llave
Floración	floración
Cerebras	cerebros
DestilarGPT-2	distilgpt2
Halcón-7B	halcón
Galáctica	galáctica
GPT-J	gptj
GPT-2	gpt2
Llama	llama
LlaMA2	llama2
OPT-1.3B	optar

Las mencionadas anteriormente son las variantes básicas de los LLM. A continuación se muestran las plantillas para obtener sus versiones LoRA , INT8 , INT8 + LoRA e INT4 + LoRA .

Versión	Plantilla
lora	<clave_modelo>_lora
INT8	<clave_modelo>_int8
INT8 + LoRA	<clave_modelo>_lora_int8

** Para cargar la versión INT4+LoRA de cualquier modelo, deberá utilizar la clase GenericLoraKbitModel de xturing.models . A continuación se muestra cómo usarlo:

 model = GenericLoraKbitModel ( '<model_path>' )

model_path se puede reemplazar con su directorio local o cualquier modelo de biblioteca HuggingFace como facebook/opt-1.3b .

? Hoja de ruta

• Soporte para modelos LLaMA , GPT-J , GPT-2 , OPT , Cerebras-GPT , Galactica y Bloom
• Generación de conjuntos de datos mediante autoinstrucción.
• Ajuste fino de LoRA de baja precisión y ajuste fino no supervisado
• Soporte de ajuste fino de baja precisión INT8
• API de modelos OpenAI, Cohere y AI21 Studio para la generación de conjuntos de datos
• Se agregaron puntos de control ajustados para algunos modelos al centro.
• Demostración de ajuste fino de INT4 LLaMA LoRA
• INT4 LLaMA LoRA ajuste con generación INT4
• Soporte para un contenedor Generic model
• Soporte para el modelo Falcon-7B
• Soporte de ajuste fino de baja precisión INT4
• Evaluación de modelos LLM.
• Soporte de ajuste fino de baja precisión INT3, INT2, INT1
• Soporte para difusión estable

? Ayuda y soporte

Si tiene alguna pregunta, puede crear un problema en este repositorio.

También puedes unirte a nuestro servidor de Discord e iniciar una discusión en el canal #xturing .

Licencia

Este proyecto tiene la licencia Apache 2.0; consulte el archivo de LICENCIA para obtener más detalles.

? Contribuyendo

Como proyecto de código abierto en un campo en rápida evolución, agradecemos contribuciones de todo tipo, incluidas nuevas funciones y mejor documentación. Lea nuestra guía de contribución para saber cómo puede participar.