Modo competencia
Tema: Metodología y Datos · Catálogo de recetas · temario: Syllabus IOAI
📍 Dónde se aprende: módulo 15 de la Ruta de Aprendizaje.
Qué hace
Activa ayudas de práctica: rechaza comandos de instalación en IPython, solicita modo offline a HuggingFace y mide el tiempo de un bloque. No sustituye al grader oficial.
Cuándo usarla
Después de preparar datos, modelos y dependencias, antes de importar HuggingFace y de iniciar una ejecución de simulacro.
Implementación
Necesita: solo la biblioteca estándar.
import os
import re
import time
PATRON_INSTALACION = re.compile(
r"^\s*[!%]\s*(pip3?|conda|mamba|uv|apt|apt-get)\b.*\binstall\b", re.I)
def rechazar_instalacion(codigo):
"""Si el código intenta instalar un paquete, devuelve el motivo; si no, None.
En la IOAI **está prohibido instalar paquetes**: lo que hay en la máquina es
lo que hay. Entrenar donde `!pip install` funciona construye justo el
reflejo que falla el día de la prueba.
"""
for linea in codigo.splitlines():
if PATRON_INSTALACION.match(linea):
return ("prohibido instalar paquetes: %r. En la competencia no se "
"puede, así que resuélvelo con lo que ya está instalado."
% linea.strip())
return None
def activar_offline():
"""Pone el ecosistema HuggingFace en modo offline y devuelve qué cambió.
Actívalo ANTES de importar las librerías de HuggingFace. Evita sus
consultas HTTP; un id del Hub puede funcionar si está completo en caché.
No comprueba qué modelos permite la tarea ni desconecta toda la red.
Prepara primero los archivos locales y usa las rutas del enunciado.
"""
banderas = {"HF_HUB_OFFLINE": "1", "TRANSFORMERS_OFFLINE": "1",
"HF_DATASETS_OFFLINE": "1"}
os.environ.update(banderas)
return banderas
def solo_de_train(ruta):
"""Guarda opcional para ejercicios que SOLO permiten etiquetas de train.
Comprueba el nombre de la ruta, no su contenido ni sus permisos. Adapta
esta política al enunciado: tareas adversariales como Double Agent Dilemma
sí entregan y permiten etiquetas de test para construir el ataque.
"""
partes = re.split(r"[/\\]", str(ruta))
if not any(p.lower().startswith("train") for p in partes):
raise ValueError(
"esta guarda exige una ruta de train/, y %r no lo es. Comprueba "
"si esa política corresponde al enunciado antes de usarla."
% str(ruta))
return ruta
class Presupuesto:
"""Cronómetro del límite de ejecución de una tarea.
with Presupuesto(minutos=10, nombre="Ghost of the Machine") as p:
entrenar(...)
print("%.0f s de margen" % p.restante())
Al salir informa cuánto se usó; si se pasó del límite levanta TimeoutError,
y si pasó del 60% avisa. Ese margen no es paranoia: el límite cubre también
la re-ejecución del notebook sobre los datos ocultos, en una máquina que no
es la tuya.
"""
def __init__(self, minutos=10.0, nombre="la tarea", margen=0.6):
self.limite = minutos * 60.0
self.nombre = nombre
self.margen = margen
self.inicio = None
self.usado = None
def __enter__(self):
self.inicio = time.perf_counter()
return self
def transcurrido(self):
return time.perf_counter() - self.inicio
def restante(self):
return self.limite - self.transcurrido()
def __exit__(self, tipo, valor, traza):
self.usado = self.transcurrido()
pct = (100.0 * self.usado / self.limite) if self.limite else 0.0
print("⏱️ %s: %.1f s de %.0f s (%.0f%% del límite)"
% (self.nombre, self.usado, self.limite, pct))
if tipo is not None:
return False # ya hay un error: no lo tapamos
if self.usado > self.limite:
raise TimeoutError(
"%s se pasó del límite: %.1f s de %.0f s permitidos."
% (self.nombre, self.usado, self.limite))
if self.usado > self.limite * self.margen:
print("⚠️ usaste más del %.0f%% del límite. El juez re-ejecuta el "
"notebook sobre los datos ocultos: deja margen."
% (self.margen * 100))
return False
def modo_competencia(offline=True, bloquear_instalaciones=True):
"""Activa ayudas de simulacro y devuelve cuáles pudo activar.
Debe ejecutarse tras preparar activos y antes de importar HuggingFace.
No crea un sandbox ni impone todas las reglas de la plataforma oficial.
"""
activado = {}
if offline:
activado["offline"] = activar_offline()
if bloquear_instalaciones:
try:
ip = get_ipython() # noqa: F821 (existe en Jupyter)
except NameError:
ip = None
if ip is None:
activado["instalaciones"] = "sin bloquear (fuera de IPython)"
else:
def guardia_instalaciones(lineas):
motivo = rechazar_instalacion("".join(lineas))
if motivo:
raise RuntimeError(motivo)
return lineas
previos = [t for t in ip.input_transformers_cleanup
if getattr(t, "__name__", "") == "guardia_instalaciones"]
for t in previos: # idempotente: no acumula guardias
ip.input_transformers_cleanup.remove(t)
ip.input_transformers_cleanup.append(guardia_instalaciones)
activado["instalaciones"] = "bloqueadas"
return activado⚠️ Notas
Separa preparación y evaluación: descarga activos permitidos y comprueba sus rutas primero; reinicia el kernel y activa las restricciones antes de importar HuggingFace. Sus variables offline impiden consultas HTTP de ese ecosistema, pero un id ya cacheado puede cargar. Usa las rutas indicadas por cada enunciado y comprueba su lista de modelos por separado.
Estas ayudas no aíslan la máquina: otras librerías pueden acceder a red, no verifican permisos de archivos ni modelos, y el rechazo de instalaciones solo opera en IPython. Presupuesto avisa al terminar el bloque; no interrumpe un proceso que excede el límite. Para medir el total incluye carga, preparación, entrenamiento e inferencia. Sincroniza CUDA antes de leer el reloj si hay operaciones pendientes. El grader oficial es la referencia para las restricciones.
🔗 Relacionadas
Verificada
Este código se ejecuta en cada publicación, contra una referencia obviamente correcta, en
herramientas/pruebas/basicas.py. Si se rompe, el sitio no se actualiza.
Las otras puertas del vault: Ruta de Aprendizaje · Referencia · IOAI