intel extension for transformers
v1.4.2 Release
?Arquitectura | Chat neuronal | ?Inferencia sobre CPU | ?Inferencia sobre GPU | Ejemplos | Documentaciones
pip install intel-extension-for-transformersPara conocer los requisitos del sistema y otros consejos de instalación, consulte la Guía de instalación.
Intel® Extension para Transformers es un conjunto de herramientas innovador diseñado para acelerar GenAI/LLM en todas partes con el rendimiento óptimo de los modelos basados en Transformer en varias plataformas Intel, incluidas Intel Gaudi2, Intel CPU y Intel GPU. El kit de herramientas proporciona las siguientes características clave y ejemplos:
Experiencia de usuario perfecta de compresiones de modelos en modelos basados en Transformer ampliando las API de los transformadores Hugging Face y aprovechando Intel® Neural Compressor
Optimizaciones de software avanzadas y tiempo de ejecución único con reconocimiento de compresión (publicado con el artículo Fast Distilbert de NeurIPS 2022 sobre CPU y QuaLA-MiniLM: un MiniLM adaptable de longitud cuantificada, y el artículo de NeurIPS 2021 Prune Once for All: Sparse Pre-Trained Language Models)
Paquetes de modelos optimizados basados en Transformer, como Stable Diffusion, GPT-J-6B, GPT-NEOX, BLOOM-176B, T5, Flan-T5, y flujos de trabajo de un extremo a otro, como clasificación de texto basada en SetFit y análisis de opiniones a nivel de documentos. (DLSA)
NeuralChat, un marco de chatbot personalizable para crear su propio chatbot en cuestión de minutos aprovechando un amplio conjunto de complementos como Knowledge Retrieval, Speech Interaction, Query Caching y Security Guardrail. Este marco es compatible con Intel Gaudi2/CPU/GPU.
Inferencia de modelo de lenguaje grande (LLM) en C/C++ puro con núcleos de cuantificación de solo peso para CPU Intel y GPU Intel (TBD), compatibles con GPT-NEOX, LLAMA, MPT, FALCON, BLOOM-7B, OPT, ChatGLM2-6B, GPT-J-6B y Dolly-v2-3B. Admite el conjunto de instrucciones AMX, VNNI, AVX512F y AVX2. Hemos aumentado el rendimiento de las CPU Intel, con especial atención en el procesador escalable Intel Xeon de cuarta generación, cuyo nombre en código es Sapphire Rapids.
| Hardware | Sintonia FINA | Inferencia | ||
| Lleno | PEFT | 8 bits | 4 bits | |
| Intel Gaudí2 | ✔ | ✔ | Trabajo en Trabajo (FP8) | - |
| Procesadores escalables Intel Xeon | ✔ | ✔ | ✔ (INT8, FP8) | ✔ (INT4, FP4, NF4) |
| Serie máxima de CPU Intel Xeon | ✔ | ✔ | ✔ (INT8, FP8) | ✔ (INT4, FP4, NF4) |
| Serie Intel GPU Max para centros de datos | WIP | WIP | WIP (INT8) | ✔ (INT4) |
| Intel Arc Serie A | - | - | WIP (INT8) | ✔ (INT4) |
| Procesadores Intel Core | - | ✔ | ✔ (INT8, FP8) | ✔ (INT4, FP4, NF4) |
En la tabla anterior, "-" significa no aplicable o aún no iniciado.
| Software | Sintonia FINA | Inferencia | ||
| Lleno | PEFT | 8 bits | 4 bits | |
| PyTorch | 2.0.1+procesador, 2.0.1a0 (gpu) | 2.0.1+procesador, 2.0.1a0 (gpu) | 2.1.0+procesador, 2.0.1a0 (gpu) | 2.1.0+procesador, 2.0.1a0 (gpu) |
| Extensión Intel® para PyTorch | 2.1.0+procesador, 2.0.110+xpu | 2.1.0+procesador, 2.0.110+xpu | 2.1.0+procesador, 2.0.110+xpu | 2.1.0+procesador, 2.0.110+xpu |
| Transformadores | 4.35.2(CPU), 4.31.0 (GPU Intel) | 4.35.2(CPU), 4.31.0 (GPU Intel) | 4.35.2(CPU), 4.31.0 (GPU Intel) | 4.35.2(CPU), 4.31.0 (GPU Intel) |
| Sinapsis AI | 1.13.0 | 1.13.0 | 1.13.0 | 1.13.0 |
| Conductor Gaudí2 | 1.13.0-ee32e42 | 1.13.0-ee32e42 | 1.13.0-ee32e42 | 1.13.0-ee32e42 |
| gpu-intel-nivel-cero | 1.3.26918.50-736~22.04 | 1.3.26918.50-736~22.04 | 1.3.26918.50-736~22.04 | 1.3.26918.50-736~22.04 |
Consulte los requisitos detallados en CPU, Gaudi2, Intel GPU.
Ubuntu 20.04/22.04, Centos 8.
A continuación se muestra el código de muestra para crear su chatbot. Ver más ejemplos.
NeuralChat proporciona API RESTful compatibles con OpenAI para chat, por lo que puede utilizar NeuralChat como reemplazo directo de las API de OpenAI. Puede iniciar el servidor NeuralChat utilizando el comando Shell o el código Python.
# Shell Command
neuralchat_server start --config_file ./server/config/neuralchat.yaml # Python Code
from intel_extension_for_transformers . neural_chat import NeuralChatServerExecutor
server_executor = NeuralChatServerExecutor ()
server_executor ( config_file = "./server/config/neuralchat.yaml" , log_file = "./neuralchat.log" ) Se puede acceder al servicio NeuralChat a través de la biblioteca cliente OpenAI, los comandos curl y la biblioteca requests . Ver más en NeuralChat.
from intel_extension_for_transformers . neural_chat import build_chatbot
chatbot = build_chatbot ()
response = chatbot . predict ( "Tell me about Intel Xeon Scalable Processors." )A continuación se muestra el código de muestra para utilizar las API de Transformers extendidas. Ver más ejemplos.
Le recomendamos que instale NeuralSpeed para obtener las funciones más recientes (por ejemplo, compatibilidad con GGUF) de inferencia de bits bajos de LLM en CPU. Es posible que también desee utilizar v1.3 sin NeuralSpeed siguiendo el documento
from transformers import AutoTokenizer
from intel_extension_for_transformers . transformers import AutoModelForCausalLM
model_name = "Intel/neural-chat-7b-v3-1"
prompt = "Once upon a time, there existed a little girl,"
tokenizer = AutoTokenizer . from_pretrained ( model_name , trust_remote_code = True )
inputs = tokenizer ( prompt , return_tensors = "pt" ). input_ids
model = AutoModelForCausalLM . from_pretrained ( model_name , load_in_4bit = True )
outputs = model . generate ( inputs )También puede cargar el modelo en formato GGUF desde Huggingface, por ahora solo admitimos el formato gguf Q4_0/Q5_0/Q8_0.
from transformers import AutoTokenizer
from intel_extension_for_transformers . transformers import AutoModelForCausalLM
# Specify the GGUF repo on the Hugginface
model_name = "TheBloke/Llama-2-7B-Chat-GGUF"
# Download the the specific gguf model file from the above repo
gguf_file = "llama-2-7b-chat.Q4_0.gguf"
# make sure you are granted to access this model on the Huggingface.
tokenizer_name = "meta-llama/Llama-2-7b-chat-hf"
prompt = "Once upon a time, there existed a little girl,"
tokenizer = AutoTokenizer . from_pretrained ( tokenizer_name , trust_remote_code = True )
inputs = tokenizer ( prompt , return_tensors = "pt" ). input_ids
model = AutoModelForCausalLM . from_pretrained ( model_name , gguf_file = gguf_file )
outputs = model . generate ( inputs )También puedes cargar el modelo PyTorch desde Modelscope
Nota : requiere modelo de alcance
from transformers import TextStreamer
from modelscope import AutoTokenizer
from intel_extension_for_transformers . transformers import AutoModelForCausalLM
model_name = "qwen/Qwen-7B" # Modelscope model_id or local model
prompt = "Once upon a time, there existed a little girl,"
model = AutoModelForCausalLM . from_pretrained ( model_name , load_in_4bit = True , model_hub = "modelscope" )
tokenizer = AutoTokenizer . from_pretrained ( model_name , trust_remote_code = True )
inputs = tokenizer ( prompt , return_tensors = "pt" ). input_ids
streamer = TextStreamer ( tokenizer )
outputs = model . generate ( inputs , streamer = streamer , max_new_tokens = 300 )También puede cargar el modelo de bits bajos cuantificado por el algoritmo GPTQ/AWQ/RTN/AutoRound.
from transformers import AutoTokenizer
from intel_extension_for_transformers . transformers import AutoModelForCausalLM , GPTQConfig
# Hugging Face GPTQ/AWQ model or use local quantize model
model_name = "MODEL_NAME_OR_PATH"
prompt = "Once upon a time, a little girl"
tokenizer = AutoTokenizer . from_pretrained ( model_name , trust_remote_code = True )
inputs = tokenizer ( prompt , return_tensors = "pt" ). input_ids
model = AutoModelForCausalLM . from_pretrained ( model_name , trust_remote_code = True )
outputs = model . generate ( inputs ) import intel_extension_for_pytorch as ipex
from intel_extension_for_transformers . transformers . modeling import AutoModelForCausalLM
from transformers import AutoTokenizer
import torch
device_map = "xpu"
model_name = "Qwen/Qwen-7B"
tokenizer = AutoTokenizer . from_pretrained ( model_name , trust_remote_code = True )
prompt = "Once upon a time, there existed a little girl,"
inputs = tokenizer ( prompt , return_tensors = "pt" ). input_ids . to ( device_map )
model = AutoModelForCausalLM . from_pretrained ( model_name , trust_remote_code = True ,
device_map = device_map , load_in_4bit = True )
model = ipex . optimize_transformers ( model , inplace = True , dtype = torch . float16 , quantization_config = True , device = device_map )
output = model . generate ( inputs )Nota: consulte el ejemplo y el script para obtener más detalles.
A continuación se muestra el código de muestra para utilizar las API extendidas de Langchain. Ver más ejemplos.
from langchain_community . llms . huggingface_pipeline import HuggingFacePipeline
from langchain . chains import RetrievalQA
from langchain_core . vectorstores import VectorStoreRetriever
from intel_extension_for_transformers . langchain . vectorstores import Chroma
retriever = VectorStoreRetriever ( vectorstore = Chroma (...))
retrievalQA = RetrievalQA . from_llm ( llm = HuggingFacePipeline (...), retriever = retriever )Puede acceder a los modelos validados, la precisión y el rendimiento desde los datos de la versión o el blog mediano.
| DESCRIPCIÓN GENERAL | |||||||
|---|---|---|---|---|---|---|---|
| NeuralChat | Velocidad neuronal | ||||||
| CHAT NEURAL | |||||||
| Chatbot en CPU Intel | Chatbot en GPU Intel | Chatbot sobre Gaudí | |||||
| Chatbot en el cliente | Más cuadernos | ||||||
| VELOCIDAD NEURAL | |||||||
| Velocidad neuronal | Maestría en Streaming | Núcleos de baja precisión | Paralelismo tensorial | ||||
| COMPRESIÓN LLM | |||||||
| SmoothQuant (INT8) | Cuantización sólo de peso (INT4/FP4/NF4/INT8) | QLoRA en la CPU | |||||
| COMPRESIÓN GENERAL | |||||||
| Cuantización | Poda | Destilación | Orquestación | ||||
| Aumento de datos | Exportar | Métrica | Objetivos | ||||
| Tubería | Longitud adaptable | Salida anticipada | |||||
| TUTORIALES Y RESULTADOS | |||||||
| Tutoriales | Lista de Maestría en Derecho | Lista general de modelos | Rendimiento del modelo | ||||
Ver lista completa de publicaciones
Excelentes proyectos de código abierto: bitsandbytes, FastChat, fastRAG, ggml, gptq, llama.cpp, lm-evauation-harness, peft, trl, streamingllm y muchos otros.
Gracias a todos los contribuyentes.
¡Bienvenido a plantear ideas interesantes sobre técnicas de compresión de modelos y desarrollo de chatbots basados en LLM! ¡No dude en comunicarse con nosotros y esperamos nuestras colaboraciones en Intel Extension for Transformers!
