La interfaz por fases,
una fase cada vez

La primera pantalla pregunta una sola cosa: qué tiene que hacer el modelo. Hay tres formas de contestar, y la columna de la derecha dice por adelantado qué va a hacer el core con tu respuesta — leer los datos e inferir los tipos, proponer una arquitectura con su razonamiento y su alternativa, y validar el resultado en cada cambio, para que quien audita vea el mismo objeto que quien crea.

• Describe — una frase en lenguaje normal. Debajo de la caja hay ejemplos de prompt que te la rellenan si te quedas en blanco.
• Upload CSV — suelta un fichero o elígelo, y el modelo sale de sus columnas.
• From a template — un catálogo de ejemplos ya hechos, que se puede filtrar por categoría.

Bajo las tres puertas, Projects enumera todo lo ya construido: su estado y la métrica que importa para su tipo de modelo, de dónde salieron sus datos y cuánto hace que se tocó. La × de la derecha borra uno.

El catálogo declara su propia promesa arriba del todo: Start from a ready-made example. You will see what it does and what it does not before creating anything. Cada ficha lleva qué predice el ejemplo, su categoría y su dificultad, si descarga algo de internet, y un botón See what it does. El ejemplo de la lluvia de Santander lleva además una línea roja propia —sus datos no permiten uso comercial— en la ficha, no enterrada en una licencia que encuentras después.

Build model está apagado mientras no hay nada que construir. En cuanto la caja tiene texto, se enciende.

Mientras el core trabaja, el botón pasa a Building… y aparece un Cancel al lado. Una construcción que puedes parar es una construcción que puedes permitirte intentar.

Cuando la construcción termina, la pantalla cambia de forma. El nombre del modelo sube a la barra superior junto a una insignia WIRED TO THE CORE, con Save, un enlace de vuelta a la Classic interface, el conmutador de idioma y Settings a la derecha. La línea de estado del pie declara tres cosas a la vez: si el core está conectado, qué proveedor de LLM hay configurado, y si la IR —el objeto contra el que corre cada comprobación— es válida.

El carril de la izquierda es el estado del propio modelo, y se lee desde dentro de cualquier fase. Cada entrada lleva su resumen en una línea: Model · 64 → 32 → 1 · 2,369 parameters · 3 warnings, Data · 200 rows, Training · completed, Audit · 6 checks · 1 warning. Una fase que no tiene nada que declarar enseña solo su número y su nombre. Un tic significa hecho; una exclamación, hecho y con algo que leer. Collapse, abajo, pliega el carril.

La primera fase guarda la arquitectura que el core propuso para tu frase o para tus columnas, y el carril mantiene su resumen a la vista desde cualquier otro sitio: el ancho de las capas, cuántos parámetros entrenables hay, y cuántos avisos levantó la construcción.

Los números se pueden comprobar, que es justo para lo que se imprimen. Este modelo mete los tres campos que nombraba la frase —distancia, peso y número de paradas— en una red densa 64 → 32 → 1: 3×64+64, luego 64×32+32, luego 32×1+1. Eso son exactamente los 2,369 parameters que declara el carril.

Sin filas no se entrena, y la fase lo dice sin rodeos: This model has no data yet. Dos salidas, y las dos acaban igual — venga lo que venga, se valida contra este modelo antes de aceptarlo.

• Generate data with the core — elige cuántas filas de la lista, o escribe tú el número. Adjust the columns está al lado del botón de generar.
• Use my own data — el panel imprime las columnas exactas que espera el modelo, la cabecera más una fila de ejemplo, y avisa de que el entrenamiento falla si no coinciden. Download the template te da esa cabecera como fichero; Load my CSV coge el tuyo.

En cuanto hay filas, la fase se convierte en una lectura de esas filas — y tiene cuidado con qué parte de esa lectura manda:

• El fichero, con su número de filas y de columnas.
• Una vista previa de las 8 primeras filas, con el motivo de que exista escrito al lado: so you can recognise your file. The schema below is inferred by the backend, which is the one that really reads it. La vista previa no pretende ser la fuente de verdad.
• What do you want to predict — el core propone un objetivo y dice por qué propone ése (aquí: es la última columna del CSV y tiene pocas categorías distintas, así que es una clasificación). Enseña también la alternativa que consideró, como regresión, con su propio motivo — y un desplegable para cualquier otra columna. Él propone; tú decides.
• Schema inferred from your data — cada campo con su tipo y su rango, todo editable, bajo la línea que importa: your correction takes precedence over what the core inferred. A wrong range makes the model learn over a domain that does not exist.

Cuando hay un proveedor de LLM configurado, el panel lo declara en vez de dejar que lo supongas: la línea de encima del fichero dice que el core usó su proveedor de LLM para proponer las reglas de dominio de estos datos.

Antes de que pulses nada, la fase te dice qué vas a sacar de pulsarlo: la época en curso, las curvas de pérdida y de acierto, el log del core y la comparación con entrenamientos anteriores. Y luego un botón.

Cuando el entrenamiento termina, todo lo que produjo está en una sola pantalla:

• El run identifier y su estado, con Retrain, Audit run y Test model al lado — las tres cosas que razonablemente harías a continuación.
• El epoch counter, y debajo el coste real de esas épocas: pasos por época, tamaño del lote, y cuántas actualizaciones de pesos van ya.
• La loss curve, entrenamiento y validación juntos, con el valor final.
• El panel de accuracy — y una explicación de por qué a su lado no hay curva: the core measures this metric at the end, not on every epoch: the value is not missing, the evolution is. Un panel que nombra lo que no tiene vale más que uno que deja un hueco.
• El log: las líneas METRIC del propio core, época a época, tal y como las escribió.
• La columna de metrics, donde cada número llega con una frase llana de qué significa y una segunda de cómo puede engañarte. Accuracy: if one class dominates the data, always answering the same thing scores high: look at the macro F1. Macro F1: it drops as soon as one class goes badly, even if accuracy stays high.
• La confusion matrix, real contra predicho, para que veas hacia dónde van los fallos y no solo cuántos hay.
• La best epoch, y qué backend corrió el entrenamiento y sobre qué — aquí stdlib · cpu.

La auditoría no es un resumen del entrenamiento. Es el conjunto de comprobaciones que el core corre contra el propio modelo, y la cabecera declara con qué reglas juega: deterministas, y repetidas en cada cambio de la IR — para que el veredicto no pueda caducar a tus espaldas.

Se enumeran seis comprobaciones con su nombre y su resultado: parser, verifier_agent, safety_agent, typecheck, python_compiler y backend_contract. Cuando una comprobación tiene algo que añadir, lo añade bajo su propio nombre — el chequeo de tipos imprime lo que tipó: la red, su nivel de interpretabilidad marcado como reduced, y el motivo en la misma línea, que es una red neuronal densa con capas ocultas.

Debajo, separadas a propósito, están las etapas del pipeline no control attached: las partes de la construcción que nada puede aprobar ni suspender, enumeradas con lo que sí declararon. En este entrenamiento, el motivo del generador para elegir una arquitectura densa, y la salvedad del verificador de entrenamiento de que el CSV se validó pero no se aportó un manifiesto del dataset con sus hashes y sus particiones. Se imprimen con el motivo por el que no llevan veredicto, en vez de desaparecer bajo un tic verde.

• Download report se lleva la verificación entera como fichero.
• Test the model salta directamente a la fase siguiente.
• A la derecha, la model trace: cómo se construyó, etapa a etapa; los datos con los que se preparó; y el entrenamiento al que pertenece.

Cada entrada es un deslizador, y debajo de cada deslizador está el dominio que el modelo espera — éste admite una distancia de 1 a 5.000, un peso de 1 a 1.000 y de 0 a 50 paradas. No puedes preguntarle al modelo por un caso para el que nunca se construyó sin enterarte, porque el rango para el que se construyó está escrito donde pones el valor.

Pulsa Run model y la columna de la derecha se llena — con la respuesta, y con todo lo que hace falta para saber cuánto creérsela:

• La prediction y qué clase de cosa es: aquí una probabilidad, con el nombre de la columna objetivo, con la salvedad de que es la probabilidad de que la respuesta sea SÍ y de que el modelo no declara nombres para las dos clases. Contesta lo que puede y dice lo que no.
• La execution: que el proyecto se ejecutó correctamente, que no se disparó ninguna acción discreta, y que el grafo se evaluó en modo simulación — más una caja que declara qué se simuló o se bloqueó en esta ejecución.
• La confidence, con su fundamento: un nivel y su número, y sobre qué se midió — una probabilidad calibrada. Una confianza sin fundamento declarado es solo un número con un signo de porcentaje.
• La provenance: si el modelo salió de tus datos o de una frase que escribiste, y cómo se validó. Siempre puedes saber cuál de las dos estás mirando.
• How it decided: las entradas ordenadas por influencia — y justo debajo, el límite de esa ordenación: by order of influence reported by the core, not quantitative. Es un orden, no un reparto, y el panel se niega a que se lea como tal.

La última fase empaqueta el modelo, y empieza por admitir que todavía no lo ha hecho: There is no package yet. Tres formatos, cada uno descrito por lo que de verdad es y no por una etiqueta:

• ONNX .onnx — un único fichero de modelo (los modelos grandes salen como un .zip con model.onnx y sus pesos aparte). Corre en cualquier plataforma que tenga un ONNX Runtime.
• WASM bundle .zip — un paquete de ONNX Runtime Web, para navegadores y Node.js.
• Edge bundle .zip — autocontenido: el modelo en ONNX, los manifiestos y el script que lo sirve.

El texto de encima de la lista nombra al que se sostiene solo: el paquete autocontenido es el único que se abre y predice sin que tengas que escribir nada. Lleva el modelo en ONNX, un predict.py que lo carga y valida el esquema, el manifiesto con sus hashes, y la ficha con sus métricas y sus límites. Build the package lo produce.