Cómo ejecutar un modelo LLM en una computadora con 32GB de RAM – guía paso a paso

En esta guía, explicaremos cómo ejecutar un modelo de lenguaje grande (LLM) en una computadora con 32GB de RAM. Los siguientes pasos te permitirán instalar y configurar el entorno para ejecutar modelos como Mistral 7B, Llama 2 u otros similares.

Requisitos previos

Antes de comenzar, asegúrate de que tu computadora cumpla con los siguientes requisitos:

• Sistema operativo: Linux (recomendado) o Windows 10/11
• Procesador: Intel i7/i9 o AMD Ryzen 7/9
• Memoria RAM: 32GB
• Tarjeta gráfica: NVIDIA con al menos 16GB de memoria VRAM (opcional, pero recomendado)

Paso 1: Instalación del entorno

Instalación de Python

Ejecuta el modelo LLM en un entorno Python. Instala la versión más reciente de Python (3.9 o superior):

sudo apt update
sudo apt install python3.9 python3-pip python3-venv

Creación del entorno virtual

Crea un entorno virtual para evitar conflictos con otros paquetes:

python3.9 -m venv llm_env
source llm_env/bin/activate

Paso 2: Instalación de las bibliotecas necesarias

Instala las bibliotecas requeridas, incluyendo transformers y torch:

pip install torch transformers accelerate bitsandbytes

Además, si planeas usar una tarjeta gráfica, instala la versión adecuada de torch con soporte para CUDA:

pip install torch --index-url https://download.pytorch.org/whl/cu118

Paso 3: Selección del modelo

Elige el modelo que deseas ejecutar. En este ejemplo, usaremos el modelo Mistral 7B. Puedes descargarlo de Hugging Face:

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-7B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")

Paso 4: Configuración de la memoria

Para ejecutar el modelo en una computadora con 32GB de RAM, debes configurar la memoria para evitar desbordamientos. Puedes hacerlo usando la biblioteca accelerate:

from accelerate import init_empty_weights, load_checkpoint_and_dispatch

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    load_in_8bit=True  # Usa cuantización de 8 bits para ahorrar memoria
)

Paso 5: Ejecución del modelo

Ahora puedes ejecutar el modelo y generar texto:

input_text = "¿Cuál es el sentido de la vida?"
inputs = tokenizer(input_text, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_length=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Paso 6: Optimización

Para mejorar el rendimiento, puedes probar diferentes técnicas de optimización, como la cuantización de 4 bits o el uso de la biblioteca vLLM:

from vllm import LLM

llm = LLM(model=model_name)
outputs = llm.generate(prompts=[input_text], max_tokens=100)
print(outputs[0].outputs[0].text)

Resumen

Ejectuar un modelo LLM en una computadora con 32GB de RAM requiere una configuración y optimización adecuadas. Siguiendo los pasos anteriores, deberías poder ejecutar un modelo como Mistral 7B y generar texto. Recuerda que el rendimiento puede depender de las especificaciones de tu hardware y del modelo seleccionado.