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