SLM (Small Language Model) - Diccionario Tech

Qué es

Un SLM (Small Language Model) es un modelo de lenguaje con menos parámetros que los LLMs gigantes, diseñado para:

Tareas específicas en lugar de propósito general
Ejecutar en hardware limitado (laptops, móviles, edge)
Menor latencia y costo operativo
Fine-tuning más fácil y económico

Pronunciación

IPA: /ɛs ɛl ɛm/

Suena como: “es-el-em” - cada letra por separado

Errores comunes:

❌ “eslm” (no es una palabra)
❌ “slim” (no es la palabra inglesa “delgado”)

LLM vs SLM: Comparación

Aspecto	LLM (Large)	SLM (Small)
Parámetros	70B - 1T+	1B - 13B
Hardware	GPUs de datacenter	Laptop/móvil
Latencia	Segundos	Milisegundos
Costo por query	$0.01 - $0.10	$0.0001 - $0.001
Propósito	General	Específico
Fine-tuning	Costoso ($10K+)	Económico ($100-1K)

Ejemplos de SLMs Populares

Modelo	Parámetros	Creador	Fortaleza
Phi-3	3.8B	Microsoft	Razonamiento
Gemma 2	2B - 9B	Google	Eficiencia
Llama 3.2	1B - 3B	Meta	Open source
Mistral 7B	7B	Mistral AI	Balance
Qwen 2.5	0.5B - 7B	Alibaba	Multilingüe

Por qué SLMs son tendencia en 2026

“Fine-tuned SLMs will be the big trend and become a staple used by mature AI enterprises in 2026, as the cost and performance advantages will drive usage over out-of-the-box LLMs.” — Chief Data Officer, AT&T

El cambio de paradigma

2023-2024: "Necesitamos el modelo más grande posible"
           └→ GPT-4, Claude 3 Opus, Gemini Ultra

2025-2026: "Necesitamos el modelo correcto para la tarea"
           └→ SLMs fine-tuneados para casos específicos

Caso Práctico: Cuándo usar SLM vs LLM

Escenario: Clasificar tickets de soporte

Opción 1: LLM (GPT-4)

- Costo: ~$0.03 por ticket
- 10,000 tickets/día = $300/día = $9,000/mes
- Latencia: 2-5 segundos
- Requiere: API externa

Opción 2: SLM fine-tuneado (Phi-3)

- Costo: ~$0.0003 por ticket (self-hosted)
- 10,000 tickets/día = $3/día = $90/mes
- Latencia: 50-200ms
- Requiere: GPU pequeña o CPU potente
- Fine-tuning inicial: ~$500

Resultado: El SLM es 100x más económico para esta tarea específica.

Cuándo usar cada uno

Usa SLM cuando:

Escenario	Por qué SLM
Clasificación de texto	Tarea específica, alta frecuencia
Extracción de entidades	Patrones definidos
Chatbot de FAQ	Respuestas predecibles
Análisis de sentimiento	Tarea acotada
Ejecución en edge	Hardware limitado
Datos sensibles	Procesamiento local

Usa LLM cuando:

Escenario	Por qué LLM
Razonamiento complejo	Requiere conocimiento amplio
Generación creativa	Diversidad de outputs
Tareas variadas	No sabes qué pedirán
Prototipado rápido	Sin tiempo para fine-tuning
Multimodalidad	Imágenes + texto

Cómo implementar un SLM

Paso 1: Elegir el modelo base

# Ejemplo con Hugging Face
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "microsoft/Phi-3-mini-4k-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

Paso 2: Fine-tuning (opcional pero recomendado)

from datasets import load_dataset
from trl import SFTTrainer

# Cargar tu dataset específico
dataset = load_dataset("json", data_files="mis_datos.json")

# Configurar trainer
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    max_seq_length=512,
    # ... más configuración
)

# Entrenar
trainer.train()

Paso 3: Desplegar

# Opción A: Local con llama.cpp (CPU)
# Opción B: Ollama (fácil setup)
# Opción C: vLLM (producción GPU)
# Opción D: API serverless (Replicate, Modal)

Arquitectura típica con SLM

┌─────────────────────────────────────────────────────────┐
│              ARQUITECTURA HÍBRIDA LLM/SLM               │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   Request                                                │
│      │                                                   │
│      ▼                                                   │
│   ┌──────────────┐                                      │
│   │   Router     │  ← Decide qué modelo usar           │
│   └──────┬───────┘                                      │
│          │                                               │
│    ┌─────┴─────┐                                        │
│    │           │                                        │
│    ▼           ▼                                        │
│ ┌──────┐   ┌──────┐                                    │
│ │ SLM  │   │ LLM  │                                    │
│ │local │   │ API  │                                    │
│ └──┬───┘   └──┬───┘                                    │
│    │          │                                        │
│    └────┬─────┘                                        │
│         │                                               │
│         ▼                                               │
│   ┌──────────┐                                         │
│   │ Response │                                         │
│   └──────────┘                                         │
│                                                          │
│   Lógica del Router:                                    │
│   - Tarea conocida → SLM (rápido, barato)              │
│   - Tarea compleja → LLM (capaz, costoso)              │
│                                                          │
└─────────────────────────────────────────────────────────┘

Costos comparativos 2026

Modelo	Tipo	Costo por 1M tokens
GPT-4 Turbo	LLM API	~$10-30
Claude 3 Opus	LLM API	~$15-75
Phi-3 (self-hosted)	SLM	~$0.10-0.50
Mistral 7B (self-hosted)	SLM	~$0.20-1.00

Términos relacionados

[[LLM]] - Large Language Model, modelos grandes
[[Fine-tuning]] - Adaptar un modelo a tareas específicas
[[Edge Computing]] - Procesamiento en dispositivos locales

Recuerda: Los SLMs no reemplazan a los LLMs—los complementan. La estrategia óptima en 2026 es usar el modelo correcto para cada tarea, no el modelo más grande disponible.