Implementación de SLM en el borde: Guía de cuantización e inferencia

El paradigma del cálculo de la IA está experimentando un cambio significativo. Si bien los modelos a gran escala siguen dominando la infraestructura en la nube, una nueva clase de Modelos de Lenguaje Pequeños (SLMs) permite capacidades de IA potentes directamente en dispositivos periféricos. Este enfoque hacia el borde reduce la latencia, mejora la privacidad y posibilita la funcionalidad sin conexión—ventajas cruciales para IoT, dispositivos móviles y sistemas embebidos.

Este artículo proporciona una guía técnica y paso a paso para implementar un SLM en un dispositivo de borde con recursos limitados, centrándose en la cuantización del modelo, la configuración del entorno y el envío de solicitudes de inferencia.

Consideraciones y Requisitos Arquitectónicos

Implementar un SLM en el borde no es simplemente copiar un archivo de modelo. Requiere un enfoque arquitectónico deliberado que equilibre el rendimiento, el consumo de recursos y la mantenibilidad.

Equipo de Ingeniería de Software Compartido Bajo Demanda, Por Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda a través de una suscripción mensual predecible. Desarrolladores, diseñadores, ingenieros de control de calidad y un gerente de proyecto gratuito le ayudan a crear MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

Selección de hardware

La elección del dispositivo en el borde es la decisión fundamental. Las consideraciones clave incluyen:

• Arquitectura de CPU/GPU: Los procesadores basados en ARM, como los que se encuentran en Raspberry Pi o series NVIDIA Jetson, son comunes. Los dispositivos con GPU integradas o unidades de procesamiento neuronal (NPUs) ofrecen importantes ganancias de rendimiento para la inferencia del modelo.
• Memoria (RAM): Este suele ser el principal cuello de botella. La RAM disponible debe poder alojar el sistema operativo, el motor de inferencia y el propio modelo cuantificado. Se recomienda un dispositivo con al menos 4 GB de RAM, siendo ideales 8 GB o más para modelos y aplicaciones más complejos.
• Almacenamiento: Un almacenamiento rápido (por ejemplo, SSD NVMe) es crucial para tiempos de carga rápidos del modelo.

Para esta guía, utilizaremos un Raspberry Pi 5 (8 GB) como nuestro dispositivo de referencia, que representa un dispositivo en el borde fácilmente accesible y potente.

Conjunto de software

• Sistema Operativo: Una distribución ligera de Linux de 64 bits es la opción óptima. Raspberry Pi OS (de 64 bits) o una instalación mínima de Ubuntu Server son excelentes opciones.
• Motor de Inferencia: Utilizaremos el <s4>llama.cppllama.cppecosistema, una biblioteca de C++ altamente optimizada para ejecutar modelos basados en LLaMA. Su rendimiento en CPUs y su gestión eficiente de la memoria lo convierten en una opción ideal para entornos de borde.
• Servicio de Modelos: Se utilizará un framework web ligero como <s8>FastAPIFastAPIEsto permitirá exponer el modelo a través de una API REST, lo que permitirá que otros dispositivos en la red local interactúen con el SLM.

Selección y Cuantización de Modelos

El paso más crítico para el despliegue en el borde es la cuantización del modelo. Este proceso reduce la precisión de los pesos del modelo (por ejemplo, de números de punto flotante de 32 bits a enteros de 4 bits), disminuyendo drásticamente su tamaño y sus requisitos computacionales con una compensación manejable en la precisión.

Seleccionar un modelo base

Elija un modelo que ya esté optimizado para el rendimiento y tenga una huella más pequeña. Algunos modelos excelentes incluyen:

• Phi-3-mini: Un modelo potente con 3.8 mil millones de parámetros, desarrollado por Microsoft, que ofrece un rendimiento impresionante para su tamaño.
• Gemma 2B: Un modelo ligero y capaz de Google.
• TinyLlamaModelo con 1.1 mil millones de parámetros, diseñado para una implementación eficiente.

Para este tutorial, utilizaremos Phi-3-mini-4k-Instruct. Comenzaremos por descargar el modelo en un formato compatible con llama.cpp, como GGUF (formato unificado generado por GPT).

El proceso de cuantización

Primero, clone el repositorio de llama.cpp y compílalo en su máquina de desarrollo (o directamente en el dispositivo de borde, aunque esto puede ser lento).

# Clone the repository
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# Build the project
make

A continuación, descargue el Phi-3-mini-Instruct modelo en un formato como FP16. Puede encontrar varios modelos preconvertidos GGUF en plataformas como Hugging Face. Supongamos que ya ha descargado phi-3-mini-4k-instruct.fp16.gguf.

Ahora, utilice el ejecutable "quantize" del compilado <s1>llama.cppcuantificarQ4_K_Mllama.cpppara realizar la cuantificación.Q4_K_MEste método es una opción muy utilizada, que ofrece un buen equilibrio entre tamaño y rendimiento.

# Command to quantize the model
./quantize ./models/phi-3-mini-4k-instruct.fp16.gguf ./models/phi-3-mini-4k-instruct.q4_k_m.gguf q4_k_m

El archivo resultante phi-3-mini-4k-instruct.q4_k_m.gguf será considerablemente más pequeño que la versión original FP16, lo que lo hace adecuado para las limitaciones de memoria de nuestro Raspberry Pi. Este modelo cuantificado es el activo que implementaremos.

3. Configuración del entorno del dispositivo en el borde

Con el modelo cuantificado listo, ahora configuramos la Raspberry Pi.

Paso 1: Preparación del sistema

Asegúrese de que su Raspberry Pi esté utilizando un sistema operativo de 64 bits y que esté actualizado.

sudo apt update && sudo apt upgrade -y

Instale las herramientas de construcción esenciales y Python.

sudo apt install -y git build-essential python3 python3-pip python3-venv

Paso 2: Instalar las dependencias de Python

Crearemos un entorno virtual para gestionar las dependencias de nuestro proyecto de forma organizada.

# Create a project directory
mkdir ~/slm_edge_deployment
cd ~/slm_edge_deployment

# Create and activate a virtual environment
python3 -m venv .venv
source .venv/bin/activate

Para servir el modelo, necesitamos un envoltorio de inferencia que funcione bien con los archivos GGUF y un servidor web. La biblioteca ctransformers es una excelente librería de Python para llama.cpp.

# Install FastAPI, Uvicorn server, and ctransformers
pip install "ctransformers[cuda]" fastapi uvicorn[standard]

Nota:: La [cuda] "extra" para ctransformers es un nombre engañoso en este contexto, pero a menudo incluye binarios precompilados que están optimizados para varias arquitecturas, incluyendo ARM NEON, lo que proporciona un mejor rendimiento en la CPU del Raspberry Pi. Si surgen problemas de compilación, puede ser necesario utilizar pip install ctransformers, seguido de una compilación manual si el rendimiento no es óptimo.

Paso 3: Transferir el modelo

Copia de forma segura el archivo del modelo cuantificado (phi-3-mini-4k-instruct.q4_k_m.gguf), desde tu máquina de desarrollo a la Raspberry Pi, utilizando scp..

scp ./models/phi-3-mini-4k-instruct.q4_k_m.gguf pi@<RASPBERRY_PI_IP>:~/slm_edge_deployment/

Implementar el Servidor de Inferencia

Ahora crearemos una sencilla aplicación de FastAPI para cargar el modelo y exponer un punto final de inferencia.

Cree un archivo llamado server.py dentro del directorio slm_edge_deployment.

# server.py

from fastapi import FastAPI
from pydantic import BaseModel
from ctransformers import AutoModelForCausalLM
import uvicorn

# Define the request body structure
class InferenceRequest(BaseModel):
    prompt: str
    max_new_tokens: int = 256
    temperature: float = 0.7

# Initialize FastAPI app
app = FastAPI()

# Load the SLM
# This is done once when the server starts.
# Adjust gpu_layers based on available VRAM if using a device with a GPU.
# For CPU-only (Raspberry Pi), set gpu_layers=0.
print("Loading model...")
llm = AutoModelForCausalLM.from_pretrained(
    "./phi-3-mini-4k-instruct.q4_k_m.gguf",
    model_type="phi3",
    gpu_layers=0,  # Explicitly set to 0 for CPU inference
    context_length=4096
)
print("Model loaded successfully.")

@app.post("/generate")
def generate_text(request: InferenceRequest):
    """
    Endpoint to generate text based on a prompt.
    """
    prompt_template = f"<|user|>\n{request.prompt}<|end|>\n<|assistant|>"
    
    tokens = llm.tokenize(prompt_template)
    
    output_tokens = []
    for token in llm.generate(tokens, temperature=request.temperature, top_p=0.95, repetition_penalty=1.1, stop_on_eos=True):
        output_tokens.append(token)
        if len(output_tokens) >= request.max_new_tokens:
            break
            
    response_text = llm.detokenize(output_tokens)
    
    return {"response": response_text}

if __name__ == "__main__":
    # Run the server
    uvicorn.run(app, host="0.0.0.0", port=8000)

Equipo de ingeniería de software compartido bajo demanda, mediante suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda a través de una suscripción mensual predecible. Expertos desarrolladores, diseñadores, ingenieros de control de calidad y un gerente de proyecto gratuito le ayudan a construir MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

Detalles de implementación clave:

• Carga del modelo: El modelo se carga en la memoria una vez al inicio del servidor para evitar el alto costo de recargarlo para cada solicitud. Esto es una consideración crítica de rendimiento.
• capas_gpu: Establecemos explícitamente esto en 0. Si está implementando en un dispositivo como NVIDIA Jetson, podría descargar varias capas a la GPU para acelerar la inferencia.
• Formato de indicaciones: Los SLM son muy sensibles a su formato de entrenamiento. Utilizamos el formato de instrucción Phi-3 (<|usuario|>\n...<|fin|>\n<|asistente|>) para asegurar respuestas óptimas.
• Generación por streaming vs. en lotes: El fragmento de código muestra una generación simple en lotes. Para aplicaciones en tiempo real como chatbots, sería necesario implementar una respuesta en streaming para mejorar el rendimiento percibido.ctransformers lo soporta a través de generadores.

Para ejecutar el servidor, ejecute el siguiente comando desde su terminal dentro del directorio slm_edge_deployment,

python server.py

El servidor se iniciará, cargará el modelo en la memoria RAM y comenzará a escuchar las solicitudes en el puerto 8000. La carga inicial del modelo puede tardar un minuto.

Interacción con el cliente y pruebas de rendimiento

Finalmente, crearemos un sencillo script para el cliente para interactuar con nuestro SLM recién desplegado. Este script se puede ejecutar desde cualquier máquina en la misma red que la Raspberry Pi.

Cree un archivo llamado client.py.

# client.py

import requests
import time

# The IP address of your Raspberry Pi
EDGE_DEVICE_IP = "192.168.1.102" # <-- Change this to your Pi's IP
API_URL = f"http://{EDGE_DEVICE_IP}:8000/generate"

def query_slm(prompt: str):
    """
    Sends a prompt to the SLM server and prints the response.
    """
    payload = {
        "prompt": prompt,
        "max_new_tokens": 150,
        "temperature": 0.4
    }
    
    try:
        print(f"Sending prompt: '{prompt}'")
        start_time = time.time()
        
        response = requests.post(API_URL, json=payload, timeout=120) # 2-minute timeout
        response.raise_for_status() # Raise an exception for bad status codes
        
        end_time = time.time()
        
        duration = end_time - start_time
        result = response.json()
        
        print("\n--- SLM Response ---")
        print(result.get("response", "No response text found."))
        print("--------------------")
        print(f"Time taken: {duration:.2f} seconds\n")
        
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    # Example prompts
    query_slm("Explain the concept of model quantization for edge AI in three sentences.")
    query_slm("Write a Python function that finds the nth Fibonacci number.")

Ejecute esta aplicación desde su máquina de desarrollo:

pip install requests
python client.py

Debería ver cómo las indicaciones se envían al Raspberry Pi, y después de un breve retraso, las respuestas generadas se imprimirán. La métrica "Tiempo empleado" es un indicador crucial para evaluar el rendimiento de su implementación. En un Raspberry Pi 5, puede esperar velocidades de generación de varios tokens por segundo, lo cual es viable para muchas aplicaciones que no requieren tiempo en tiempo real.

Conclusión

Implementar modelos de lenguaje pequeños en dispositivos periféricos es una técnica poderosa para construir aplicaciones de IA receptivas, privadas y resistentes. El proceso depende de Selección inteligente de modelosla selección inteligente de modelos, cuantificación agresiva, e una infraestructura eficiente para el servicio. Al utilizar herramientas como llama.cpp

Los patrones arquitectónicos descritos aquí proporcionan una base sólida para construir la próxima generación de sistemas inteligentes y descentralizados. El principal desafío sigue siendo el equilibrio entre las capacidades del modelo y el rendimiento en el dispositivo, un área que continuará evolucionando con los avances tanto en la arquitectura del modelo como en el hardware de borde.

Equipo de Ingeniería de Software Compartido Bajo Demanda, A través de Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda a través de una suscripción mensual predecible. Desarrolladores, diseñadores, ingenieros de control de calidad y un gestor de proyectos gratuito le ayudarán a crear MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js, y más.

Try 4Geeks Teams

Preguntas frecuentes