Calidad de los datos: limpieza y validación
En esta página
Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. El servicio de ajuste fino de autoservicio de OpenAI se está retirando gradualmente: desde el 7 de mayo de 2026, las organizaciones que nunca habían ejecutado un trabajo de ajuste fino ya no pueden crear uno; desde el 2 de julio, debes haber utilizado un modelo ajustado en los últimos 60 días; y a partir del 6 de enero de 2027, ningún cliente podrá lanzar nuevos trabajos. Los modelos ya entrenados seguirán siendo utilizables hasta que se retire su modelo base. Este curso sigue siendo útil para comprender y aprovechar un modelo existente; para nuevos proyectos, prioriza la ingeniería de prompts, RAG y las evaluaciones.
Por qué la limpieza es crítica
Que un archivo JSONL sea técnicamente válido no garantiza un buen ajuste fino. Los datos ruidosos, inconsistentes o mal formateados degradarán el rendimiento del modelo en lugar de mejorarlo, y lo peor es que no generarán ningún error. El trabajo se completará con éxito, el modelo estará listo y descubrirás el problema solo en producción. Esta lección cubre las técnicas de limpieza y validación que debes ejecutar antes de subir los datos.
Validación técnica del archivo
Empieza por la mecánica: verifica que tu archivo sea sintácticamente correcto y que cada línea respete el contrato esperado. La función siguiente recorre el archivo línea por línea, acumulando errores en lugar de detenerse ante el primero (quieres la lista completa, no un ida y vuelta por cada incidencia) y devuelve estadísticas útiles en el proceso, como la presencia de mensajes de sistema y conversaciones de varios turnos.
import json
def validate_jsonl(path: str) -> dict:
"""Valida un archivo JSONL y devuelve estadísticas."""
errors = []
stats = {"total": 0, "with_system": 0, "multi_turn": 0}
valid_roles = {"system", "user", "assistant"}
with open(path, "r", encoding="utf-8") as f:
for i, line in enumerate(f, 1):
stats["total"] += 1
try:
obj = json.loads(line.strip())
except json.JSONDecodeError as e:
errors.append(f"Línea {i}: JSON no válido — {e}")
continue
if "messages" not in obj:
errors.append(f"Línea {i}: Falta la clave 'messages'")
continue
messages = obj["messages"]
if not isinstance(messages, list) or len(messages) < 2:
errors.append(f"Línea {i}: Se requieren al menos 2 mensajes")
continue
for j, msg in enumerate(messages):
role = msg.get("role")
if role not in valid_roles:
errors.append(f"Línea {i}, msg {j}: Rol no válido")
if not msg.get("content", "").strip():
errors.append(f"Línea {i}, msg {j}: Contenido vacío")
if not any(m["role"] == "assistant" for m in messages):
errors.append(f"Línea {i}: No hay mensaje de assistant")
if messages[0]["role"] == "system":
stats["with_system"] += 1
user_turns = sum(1 for m in messages if m["role"] == "user")
if user_turns > 1:
stats["multi_turn"] += 1
return {"errors": errors, "stats": stats}
result = validate_jsonl("training_data.jsonl")
if result["errors"]:
print(f"Errores: {len(result['errors'])}")
for err in result["errors"][:10]:
print(f" - {err}")
else:
print(f"Archivo válido — {result['stats']['total']} ejemplos")
Limpieza de contenido
Las entradas exactas o casi duplicadas sesgan el entrenamiento al sobrerrepresentar ciertos patrones. Esto ocurre de forma natural al agregar múltiples exportaciones: la misma pregunta frecuente aparece treinta veces en tus registros y el modelo concluye que merece treinta veces más atención que las demás. Un hash del contenido concatenado de los mensajes es suficiente para eliminarlos.
import hashlib
def deduplicate(examples: list[dict]) -> list[dict]:
"""Elimina duplicados basándose en el contenido de los mensajes."""
seen = set()
unique = []
for ex in examples:
content = "|".join(
f"{m['role']}:{m['content']}" for m in ex["messages"]
)
h = hashlib.md5(content.encode()).hexdigest()
if h not in seen:
seen.add(h)
unique.append(ex)
print(f"Duplicados eliminados: {len(examples) - len(unique)}")
return unique
A continuación viene la normalización del texto, que aborda cuatro problemas distintos. Deben eliminarse los espacios múltiples y los saltos de línea superfluos, heredados de copiar y pegar. La codificación debe normalizarse a UTF-8 eliminando los caracteres de control, que son invisibles pero suelen estar presentes en las exportaciones de bases de datos. La puntuación merece una revisión: una respuesta truncada a mitad de frase enseña al modelo a interrumpirse a sí mismo. Por último, asegúrate de la consistencia del idioma: si deseas un trato formal, verifica que ningún ejemplo utilice un trato informal, porque el modelo reproducirá fielmente la mezcla.
import re
import unicodedata
def normalize_text(text: str) -> str:
"""Normaliza el texto para el entrenamiento."""
text = unicodedata.normalize("NFC", text)
text = re.sub(r"[\x00-\x09\x0b-\x0c\x0e-\x1f\x7f]", "", text)
text = re.sub(r"[ \t]+", " ", text)
text = re.sub(r"\n{3,}", "\n\n", text)
return text.strip()
Comprobaciones de consistencia
Si utilizas un mensaje de sistema, debe ser rigurosamente idéntico en todos tus ejemplos. Dos variantes que difieran en una sola palabra son suficientes para diluir la señal: el modelo deja de aprender una instrucción específica y empieza a aprender una familia difusa de instrucciones. La comprobación es trivial y el resultado suele ser sorprendente en un corpus construido por varias personas.
def check_system_messages(examples: list[dict]):
"""Comprueba la consistencia de los mensajes de sistema."""
system_msgs = set()
for ex in examples:
for msg in ex["messages"]:
if msg["role"] == "system":
system_msgs.add(msg["content"].strip())
if len(system_msgs) > 1:
print(f"Aviso: {len(system_msgs)} mensajes de sistema diferentes")
for sm in system_msgs:
print(f" - {sm[:80]}...")
elif len(system_msgs) == 1:
print("Mensaje de sistema consistente")
else:
print("No se ha utilizado ningún mensaje de sistema")
La distribución de las longitudes de las respuestas cuenta la misma historia desde otra perspectiva. Las respuestas muy heterogéneas indican que varias personas escribieron el corpus con ideas diferentes sobre qué aspecto debe tener una buena respuesta, o que un valor atípico se coló en el lote. El umbral utilizado aquí, un máximo superior a cinco veces la media, no es absoluto, pero dirige tu atención al lugar correcto.
def analyze_lengths(examples: list[dict]):
"""Analiza la distribución de las longitudes de las respuestas."""
lengths = []
for ex in examples:
for msg in ex["messages"]:
if msg["role"] == "assistant":
lengths.append(len(msg["content"]))
if lengths:
avg = sum(lengths) / len(lengths)
mini, maxi = min(lengths), max(lengths)
print(f"Longitud de respuesta — Media: {avg:.0f} | Mín: {mini} | Máx: {maxi}")
if maxi > avg * 5:
print("Alta dispersión — comprueba si hay valores atípicos")
Uso de la API de validación de OpenAI
Una vez hayas ejecutado tus propias comprobaciones, sube el archivo y deja que OpenAI lo valide también. Es gratuito, inmediato y te evita descubrir un problema de formato cuando el trabajo ya ha comenzado.
from openai import OpenAI
client = OpenAI()
file = client.files.create(
file=open("training_data.jsonl", "rb"),
purpose="fine-tune"
)
print(f"Archivo subido: {file.id}")
print(f"Estado: {file.status}")
Si el archivo contiene errores, el estado cambiará a error con un mensaje detallado. Soluciona los problemas notificados antes de volver a intentarlo.
Lista de comprobación previa al ajuste fino
Repasa esta lista en orden antes de crear el trabajo; cada elemento corresponde a una comprobación tratada anteriormente, excepto el último, que ningún script puede sustituir:
- El archivo JSONL es sintácticamente válido
- No hay duplicados
- Texto normalizado (UTF-8, espacios, puntuación)
- Los mensajes de sistema son consistentes
- Al menos 50 ejemplos (idealmente más de 100)
- División entrenamiento/validación realizada
- Distribución razonable de longitudes
- Revisión humana de una muestra aleatoria
Puntos clave
- Valida siempre la sintaxis JSONL antes de subir el archivo
- Elimina los duplicados para evitar el sobreajuste
- La consistencia del mensaje de sistema es esencial
- Comprueba la distribución de las longitudes de las respuestas
- Haz que un humano revise una muestra; es irremplazable