Aproveche la potencia de los LLM en las GPU Intel® Arc™.

Ejecute fácilmente una variedad de LLM localmente con las GPU Intel® Arc™.

La IA generativa ha cambiado el panorama de lo que es posible en la creación de contenidos. Esta tecnología tiene el potencial de ofrecer imágenes, vídeos y escritos nunca antes imaginados. Los grandes modelos lingüísticos (LLM) han sido noticia en la era de la IA, ya que permiten a cualquiera generar letras de canciones, obtener respuestas a preguntas complejas de física o redactar un esquema para una presentación de diapositivas. Y estas funciones de IA ya no necesitan estar conectadas a la nube o a servicios de suscripción. Pueden ejecutarse localmente en tu propio PC, donde tienes pleno control sobre el modelo para personalizar sus resultados.

En este artículo, le mostraremos cómo configurar y experimentar con modelos de lenguaje grandes populares (LLMs) en un PC con la tarjeta gráfica Intel® Arc™ A770 16GB. Aunque este tutorial hará uso del LLM Mistral-7B-Instruct, estos mismos pasos se pueden utilizar con un LLM PyTorch de tu elección como Phi2, Llama2, etc. Y sí, ¡también con el último modelo Llama3!

IPEX-LLM

La razón por la que podemos ejecutar una variedad de modelos utilizando la misma instalación base es gracias a IPEX-LLMuna biblioteca LLM para PyTorch. Está construida sobre Extensión Intel® para PyTorch y contiene optimizaciones LLM de última generación y compresión de pesos de bits bajos (INT4/FP4/INT8/FP8) - con todas las últimas optimizaciones de rendimiento para hardware Intel. IPEX-LLM aprovecha la tecnología X^e-cores XMX AI acceleration on Intel discrete GPUs like Arc A-series graphics cards for improved performance. Admite gráficos Intel Arc serie A en Windows Subsystem para Linux versión 2, entornos Windows nativos y Linux nativo.

Y como todo esto es PyTorch nativo, puedes cambiar fácilmente los modelos PyTorch y los datos de entrada para ejecutarlos en una GPU Intel Arc con aceleración de alto rendimiento. Este experimento no habría estado completo sin una comparación de rendimiento. Utilizando las instrucciones que aparecen a continuación para Intel Arc y las que suelen estar disponibles para la competencia, hemos analizado dos GPU discretas situadas en un segmento de precio similar.

Por ejemplo, al ejecutar el modelo Mistral 7B con la biblioteca IPEX-LLM, la tarjeta gráfica Arc A770 de 16 GB puede procesar 70 tokens por segundo (TPS), es decir, 70% más TPS que la GeForce RTX 4060 de 8 GB utilizando CUDA. ¿Qué significa esto? Una regla general es que 1 token equivale a 0,75 de una palabra y una buena comparación es el velocidad media de lectura humana de 4 palabras por segundo o 5,3 TPS. La tarjeta gráfica Arc A770 de 16 GB puede generar palabras mucho más rápido de lo que una persona normal puede leerlas.

Nuestras pruebas internas demuestran que la tarjeta gráfica Arc A770 de 16 GB puede ofrecer esta capacidad y un rendimiento competitivo o líder en una amplia gama de modelos en comparación con la RTX 4060, lo que convierte a los gráficos Intel Arc en una excelente opción para la ejecución local de LLM.

Pasemos ahora a las instrucciones de configuración para empezar a utilizar LLM en tu GPU Arc serie A.

Instrucciones de instalación

También podemos consultar esta página para configurar el entorno: Instalar IPEX-LLM en Windows con GPU Intel - Documentación más reciente sobre IPEX-LLM

1. Desactiva la GPU integrada en el administrador de dispositivos.

2. Descargue e instale Anaconda.

3. Una vez finalizada la instalación, abra el menú Inicio, busque Anaconda Prompt, ejecútelo como administrador y cree un entorno virtual utilizando los siguientes comandos. Introduzca cada comando por separado:

conda create -n llm python=3.10.6

conda activar llm

conda install libuv

pip install dpcpp-cpp-rt==2024.0.2 mkl-dpcpp==2024.0.0 onednn==2024.0.0 gradio

pip install --pre --upgrade ipex-llm[xpu] --extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/

pip install transformadores==4.38.0

4. Cree un documento de texto llamado demo.py y guárdelo en C:\su_nombre_de_usuario\sus_documentos o en el directorio de su elección.

5. Abra demo.py con su editor favorito y copie en él el siguiente ejemplo de código:

from transformadores import AutoTokenizer
from ipex_llm.transformers import AutoModelForCausalLM
import antorcha
import intel_extension_for_pytorch

device = "xpu" # el dispositivo en el que cargar el modelo

model_id = "mistralai/Mistral-7B-Instruct-v0.2" # id del modelo huggingface

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, load_in_4bit=True, torch_dtype=torch.float16)
model = model.to(dispositivo)

mensajes = [
    {"rol": "user", "content": "¿Cuál es tu condimento favorito?"},
    {"rol": "asistente", "contenido": "Bueno, me gusta un buen chorro de zumo de limón fresco. Le da el toque justo de sabor a todo lo que preparo en la cocina"},
    {"role": "user", "content": "¿Tienes recetas con mayonesa?"}
]

encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt")

model_inputs = encodeds.to(dispositivo)
model.to(dispositivo)

generated_ids = model.generate(model_inputs, max_new_tokens=1000, do_sample=True)
decoded = tokenizer.batch_decode(generated_ids)
print(decodificado[0])

Código creado a partir del código de ejemplo en este repositorio.

6. Guarde demo.py. En Anaconda, navega hasta el directorio donde se encuentra demo.py utilizando el comando cd, y ejecuta el siguiente comando en el prompt de Anaconda:

python demo.py

¡Ahora puedes conseguir una buena receta para hacer mayonesa!

Cambio de modelos

Utilizando el mismo entorno que hemos configurado anteriormente, puedes experimentar con otros modelos populares en Hugging Face como llama2-7B-chat-hf, llama3-8B-it, phi-2, gemma-7B-i, y stablelm2 sustituyendo el id del modelo Hugging Face anterior en demo.py.

model_id = "mistralai/Mistral-7B-Instruct-v0.2" # huggingface model id

a

model_id = "stabilityai/stablelm-2-zephyr-1_6b" # id de modelo huggingface

Diferentes modelos pueden requerir una versión diferente del paquete transformers, si se encuentra con errores al iniciar demo.py, siga los siguientes pasos para actualizar/desactualizar transformers:

1. Abrir Anaconda Prompt
2. conda activa llm
3. pip install transformadores==4.37.0

Versiones de transformadores verificadas:

Los requisitos de memoria pueden variar según el modelo y el marco. Para el Intel Arc A750 8GB que funciona con IPEX-LLM, recomendamos utilizar Llama-2-7B-chat-hf, Mistral-7B-Instruct-v0.2, phi-2 o chatglm3-6B.

Implementación de un ChatBot WebUI

Ahora pasemos a implementar un chatbot webui de Gradio para una mejor experiencia usando tu navegador web. Para obtener más información sobre la implementación de un chatbot interactivo con LLM, visita https://www.gradio.app/guides/creating-a-chatbot-fast

1. Crea un documento llamado chatbot_gradio.py en el editor de texto que prefieras.

2. Copia y pega el siguiente fragmento de código en chatbot_gradio.py:

importar gradio como gr
importar antorcha
import intel_extension_for_pytorch
from ipex_llm.transformers import AutoModelForCausalLM
from transformers import AutoTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
from threading import Thread

model_id = "mistralai/Mistral-7B-Instruct-v0.2"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, optimize_model=True, load_in_4bit=True, torch_dtype=torch.float16)
model = model.half()
model = model.to("xpu")
clase StopOnTokens(StoppingCriteria):
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
        stop_ids = [29, 0]
        para stop_id en stop_ids:
            if input_ids[0][-1] == stop_id:
                return True
        devuelve False

def predecir(mensaje, historial):
    stop = StopOnTokens()
    formato_historia = []
    para humano, asistente en historial:
        history_format.append({"rol": "usuario", "contenido": humano })
        history_format.append({"rol": "asistente", "contenido":asistente})
    history_format.append({"rol": "usuario", "contenido": mensaje})

    prompt = tokenizer.apply_chat_template(history_format, tokenize=False, add_generation_prompt=True)
    model_inputs = tokenizer(prompt, return_tensors="pt").to("xpu")
    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
    generar_kwargs = dict(
        entradas_modelo,
        streamer=streamer,
        max_new_tokens=300,
        do_sample=True,
        top_p=0,95,
        top_k=20,
        temperature=0,8,
        num_beams=1,
        pad_token_id=tokenizer.eos_token_id,
        stopping_criteria=StoppingCriteriaList([stop])
        )
    t = Thread(target=model.generate, kwargs=generate_kwargs)
    t.start()

    mensaje_parcial = ""
    para new_token en streamer:
        if nuevo_token != '<':
            mensaje_parcial += ficha_nueva
            yield mensaje_parcial

gr.ChatInterface(predict).launch()

3. Abra un nuevo prompt de anaconda e introduzca los siguientes comandos:

• pip install gradio
• conda activa llm
• cd al directorio en el que se encuentra chat_gradio.py
• python chatbot_gradio.py

4. Abre tu navegador web y navega hasta 127.0.0.1:7860. Deberías ver un chatbot configurado con el modelo de lenguaje mistral-7b-instruct-v0.2. Ahora tienes una webui de aspecto elegante para tu chatbot.

5. Haz una pregunta para iniciar una conversación con tu chatbot.

Avisos y exenciones de responsabilidad