Compilar modelos de Hugging Face para ejecutarse en Fundición local

Foundry Local ejecuta modelos ONNX en el dispositivo con un alto rendimiento. Aunque el catálogo de modelos ofrece opciones precompiladas de forma predeterminada, cualquier modelo en el formato ONNX funciona.

Use Olive para compilar modelos en formato Safetensor o PyTorch en ONNX. Olive optimiza los modelos para ONNX, por lo que son adecuados para su implementación en Foundry Local. Usa técnicas como la cuantificación y la optimización de grafos para mejorar el rendimiento.

En esta guía se muestra cómo:

Prerrequisitos

• Python 3.10 o posterior

Instalación de Olive

Olive optimiza los modelos y los convierte en el formato ONNX.

pip install olive-ai[auto-opt]

pip install olive-ai[auto-opt]

Iniciar sesión en Hugging Face

El Llama-3.2-1B-Instruct modelo requiere la autenticación de Hugging Face.

huggingface-cli login

huggingface-cli login

Compilación del modelo

Paso 1: Ejecutar el comando auto-opt de Oliva

Use el comando Olive auto-opt para descargar, convertir, cuantificar y optimizar el modelo:

olive auto-opt \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --trust_remote_code \
    --output_path models/llama \
    --device cpu \
    --provider CPUExecutionProvider \
    --use_ort_genai \
    --precision int4 \
    --log_level 1

olive auto-opt `
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct `
    --trust_remote_code `
    --output_path models/llama `
    --device cpu `
    --provider CPUExecutionProvider `
    --use_ort_genai `
    --precision int4 `
    --log_level 1

El comando usa los parámetros siguientes:

Paso 2: Cambiar el nombre del modelo de salida

Olive crea un directorio genérico model . Cambie su nombre para facilitar la reutilización:

cd models/llama
mv model llama-3.2

cd models/llama
Rename-Item -Path "model" -NewName "llama-3.2"

Paso 3: Crear un archivo de plantilla de chat

Una plantilla de chat es un formato estructurado que define cómo se procesan los mensajes de entrada y salida para un modelo de IA conversacional. Especifica los roles (por ejemplo, el sistema, el usuario, el asistente) y la estructura de la conversación, lo que garantiza que el modelo comprenda el contexto y genere las respuestas adecuadas.

Foundry Local requiere un archivo JSON de plantilla de chat denominado inference_model.json para generar respuestas. La plantilla incluye el nombre del modelo y un PromptTemplate objeto . El objeto contiene un marcador de posición {Content} que Fundición local inserta en tiempo de ejecución con la indicación del usuario.

{
  "Name": "llama-3.2",
  "PromptTemplate": {
    "assistant": "{Content}",
    "prompt": "<|begin_of_text|><|start_header_id|>system<|end_header_id|>\n\nCutting Knowledge Date: December 2023\nToday Date: 26 Jul 2024\n\nYou are a helpful assistant.<|eot_id|><|start_header_id|>user<|end_header_id|>\n\n{Content}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
  }
}

Cree el archivo de plantilla de chat con el apply_chat_template método de la biblioteca Hugging Face:

# generate_inference_model.py
# This script generates the inference_model.json file for the Llama-3.2 model.
import json
import os
from transformers import AutoTokenizer

model_path = "models/llama/llama-3.2"

tokenizer = AutoTokenizer.from_pretrained(model_path)
chat = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "{Content}"},
]


template = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)

json_template = {
  "Name": "llama-3.2",
  "PromptTemplate": {
    "assistant": "{Content}",
    "prompt": template
  }
}

json_file = os.path.join(model_path, "inference_model.json")

with open(json_file, "w") as f:
    json.dump(json_template, f, indent=2)

Ejecute el script mediante:

python generate_inference_model.py

Ejecución del modelo

Ejecute el modelo compilado con la CLI local de Foundry, la API REST o el SDK de Python de OpenAI. En primer lugar, cambie el directorio de caché del modelo al directorio models que creó en el paso anterior:

foundry cache cd models
foundry cache ls  # should show llama-3.2

foundry cache cd models
foundry cache ls  # should show llama-3.2

foundry cache cd ./foundry/cache/models

Uso de la CLI local de Foundry

foundry model run llama-3.2 --verbose

foundry model run llama-3.2 --verbose

Uso del SDK de Python de OpenAI

Use el SDK de Python de OpenAI para interactuar con la API de REST local de Foundry. Instálelo con:

pip install openai
pip install foundry-local-sdk

A continuación, ejecute el modelo con el código siguiente:

import openai
from foundry_local import FoundryLocalManager

modelId = "llama-3.2"

# Create a FoundryLocalManager instance. This starts the Foundry Local service if it's not already running and loads the specified model.
manager = FoundryLocalManager(modelId)

# The remaining code uses the OpenAI Python SDK to interact with the local model.

# Configure the client to use the local Foundry service
client = openai.OpenAI(
    base_url=manager.endpoint,
    api_key=manager.api_key  # API key is not required for local usage
)

# Set the model to use and generate a streaming response
stream = client.chat.completions.create(
    model=manager.get_model_info(modelId).id,
    messages=[{"role": "user", "content": "What is the golden ratio?"}],
    stream=True
)

# Print the streaming response
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

Restablecimiento de la caché del modelo

Después de terminar de usar el modelo personalizado, restablezca la memoria caché del modelo en el directorio predeterminado:

foundry cache cd ./foundry/cache/models

Contenido relacionado

• Documentación de Olive
• Uso de finalizaciones de chat a través del servidor REST con Foundry Local