Cuándo un modelo pequeño es la elección equivocada

Unos 23 minutos de lectura, con 5 ejemplos en 6 secciones.

Edición 2026.11.9 Ejemplos verificados el 20 de nov de 2026 36 de 36 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.9. Lee el original

Al terminar este capítulo, podrás decir en qué casos un enrutador pequeño todavía pierde frente al modelo de referencia y en cuáles se espera que un modelo alojado rinda mejor, calcular el costo mensual de cada opción a partir de los insumos que indiques con sus fechas, encontrar el volumen a partir del cual una máquina propia resulta la vía más barata y nombrar los requisitos que deciden la cuestión antes que cualquier costo.

Un enrutador pequeño puede superar a un modelo más grande en la mayoría de los mensajes de un conjunto y, aun así, ser la elección equivocada para algunos mensajes, algunos equipos o algunos volúmenes. La bandeja de soporte del banco (capítulo 1) tiene 77 equipos. A lo largo de nueve capítulos, este libro construyó para ella una cabeza clasificadora, sirvió la cabeza con una ruta que deriva los mensajes dudosos y con los controles que versionan el enrutador y envían sus derivaciones a una persona, y probó un estudiante destilado y una copia int8, midiendo ambos sin desplegar ninguno. Los capítulos que miden el enrutador lo comparan con el modelo de referencia (capítulo 1).

Dónde todavía pierde el modelo pequeño

Último cambio en la edición 2026.11.2

Capítulo 2 fijó la puntuación del modelo de apoyo como línea base. Esta sección pone al enrutador junto a ella sobre los mismos mensajes: los 1001 mensajes de test_1001, la muestra fija de la que proceden todas las muestras de cada capítulo (capítulo 2). El enrutador es el clasificador banking77-lora-v1, ejecutado en vivo.

router-on-test-1001.py Python 3.12.15 · peft 0.21.3 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Superado
"""The router and the stand-in on all 1,001 messages of test_1001, the committed test order. The prose rests on thelines for the router's wrong answers sent as answers and for the messages the stand-in gets right and the router wrong.The stand-in's answers are recorded; the router runs live on 2 threads, and its first 200 messages are the test_200 sample."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()# Runs the router live on the sample and reads the stand-in's answers from its recording, then scores both.c = router_lib.compare_router_and_standin("test_1001")n = c["messages"]print(f"messages on test_1001: {n}")print(f"router banking77-lora-v1 correct: {c['router_correct']}/{n} ({c['router_correct'] / n:.1%})")print(f"stand-in correct: {c['standin_correct']}/{n} ({c['standin_correct'] / n:.1%})")print(f"router handed off: {c['handed_off']}/{n} ({c['handed_off'] / n:.1%})")print(f"right for the stand-in, wrong for the router: {c['standin_right_router_wrong']}/{n}")print(f"of those, handed off by the router: {c['of_those_handed_off']}/{c['standin_right_router_wrong']}")print(f"wrong for the router and sent as an answer: {c['router_wrong_sent']}/{n} ({c['router_wrong_sent'] / n:.1%})")print(f"right for the router, wrong for the stand-in: {c['router_right_standin_wrong']}/{n}")
Salidapython router-on-test-1001.py
messages on test_1001: 1001
router banking77-lora-v1 correct: 847/1001 (84.6%)
stand-in correct: 560/1001 (55.9%)
router handed off: 146/1001 (14.6%)
right for the stand-in, wrong for the router: 48/1001
of those, handed off by the router: 22/48
wrong for the router and sent as an answer: 76/1001 (7.6%)
right for the router, wrong for the stand-in: 335/1001

En el conjunto completo el enrutador va por delante, con 847/1001 (84.6%) aciertos frente a los 560/1001 (55.9%) del modelo de apoyo, que es la línea base del capítulo 2. Sin embargo, el modelo de apoyo acierta y el enrutador falla en 48/1001 mensajes. El enrutador deriva algunos de esos a una persona, y el resto llega a quien hace la consulta como respuestas erróneas. El desacuerdo inverso, en el que el enrutador acierta y el modelo de apoyo falla, tiene su propio recuento en la salida.

El recuento que más importa para la bandeja de entrada son las respuestas erróneas que el enrutador envía a quien hace la consulta: 76/1001 (7.6%). Son mensajes que retuvo porque su confianza superó el umbral. El capítulo 5 eligió ese umbral sobre la partición de desarrollo, y el capítulo 9 explica adónde va lo que el enrutador deriva, que es a una persona.

where-the-router-still-loses.py Python 3.12.15 · peft 0.21.3 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Superado
"""Where the router still loses: test_200 scored for the router and the stand-in. The prose rests on the count ofmessages the stand-in gets right and the router wrong, and on the wrong answers the router sends as answers.The stand-in's answers are recorded; the router runs live on 2 threads."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()ADAPTER = router_lib.HERE / "data" / "recorded" / "lora-full"# The threshold chapter 5 chose on dev, as the adapter's manifest records it.threshold = json.loads((ADAPTER / "manifest.json").read_text())["handoff_threshold"]# Keyed by test row index, not by position in the sample, so each lookup uses the sample's row numbers.answers = router_lib.standin_rows()test = router_lib.read_rows("test")  # (text, label index) per rowsample = router_lib.read_sample("test_200")golds = [test[i][1] for i in sample]  # index 1 is the gold team, as an indexstandin_preds = [answers[i]["label"] for i in sample]  # the label is the team's index, the same form as the gold labeltokenizer, model = router_lib.load_classifier(ADAPTER / "adapter")preds, confs = router_lib.classify(model, tokenizer, [test[i][0] for i in sample])n = len(sample)router_right = [p == g for p, g in zip(preds, golds)]standin_right = [p == g for p, g in zip(standin_preds, golds)]handed_off = [router_lib.handoff(c, threshold) for c in confs]  # true below the threshold; a NaN confidence is handed off toolost = [i for i in range(n) if standin_right[i] and not router_right[i]]sent_wrong = sum(not r and not h for r, h in zip(router_right, handed_off))  # wrong and not handed off: what a caller receivesprint(f"messages on test_200: {n}")print(f"router banking77-lora-v1 correct: {sum(router_right)}/{n} ({sum(router_right) / n:.1%})")print(f"stand-in correct: {sum(standin_right)}/{n} ({sum(standin_right) / n:.1%})")print(f"router threshold from manifest: {threshold:.2f}")print(f"router handed off: {sum(handed_off)}/{n} ({sum(handed_off) / n:.1%})")print(f"right for the stand-in, wrong for the router: {len(lost)}/{n} ({len(lost) / n:.1%})")print(f"of those, handed off by the router: {sum(handed_off[i] for i in lost)}/{len(lost)}")print(f"wrong for the router and sent as an answer: {sent_wrong}/{n} ({sent_wrong / n:.1%})")print(f"right for the router, wrong for the stand-in: {sum(r and not s for r, s in zip(router_right, standin_right))}/{n}")
Salidapython where-the-router-still-loses.py
messages on test_200: 200
router banking77-lora-v1 correct: 172/200 (86.0%)
stand-in correct: 109/200 (54.5%)
router threshold from manifest: 0.63
router handed off: 33/200 (16.5%)
right for the stand-in, wrong for the router: 6/200 (3.0%)
of those, handed off by the router: 3/6
wrong for the router and sent as an answer: 11/200 (5.5%)
right for the router, wrong for the stand-in: 69/200

test_200 son los primeros 200 mensajes de test_1001, un prefijo que comprueba el script de recuento, de modo que estos recuentos forman parte de la ejecución completa y no de una segunda muestra. En ella, el modelo de apoyo acierta y el enrutador falla en 6/200 (3.0%) mensajes, y el enrutador deriva 3/6 de ellos.

La derivación retiene las respuestas erróneas. El enrutador envía 11/200 (5.5%) respuestas erróneas en estos 200 mensajes. En los mensajes que retiene, su precisión es de 156/167 (93.4%), y 33/200 (16.5%) de los 200 pasan a una persona.

Obligar a un modelo pequeño a usar la lista de equipos hace que cada respuesta sea un equipo, pero no hace que la respuesta sea correcta. El capítulo 4 pidió a los dos modelos más pequeños un equipo de esa forma. La tabla recoge el recuento de cada variante con instrucciones sobre los 200 mensajes de test_200:

Variante con instrucciones Aciertos en test_200
SmolLM2-135M-Instruct, instrucción en bruto 9/200 (4.5%)
SmolLM2-135M-Instruct, plantilla de chat 11/200 (5.5%)
SmolLM2-360M-Instruct, instrucción en bruto 12/200 (6.0%)

El modelo de 135M en bruto dio una respuesta con más frecuencia que cualquier otra (card_arrival, 165/200), y ese equipo es el equipo correcto de 0/200 de los mensajes. Un modelo que se inclina por una sola respuesta es un prior, no un enrutador. El capítulo 4 muestra por qué una instrucción no puede compensar un modelo de este tamaño.

El modelo de apoyo también falla de forma sistemática. En los 1001 mensajes, sus respuestas nunca nombran 4 de los 77 equipos, de modo que todo mensaje cuyo equipo correcto es uno de ellos va a otro equipo. Dos confusiones empatan como su error más común. La más clara es el equipo Refund_not_showing_up, que se responde como request_refund en 13/13 de sus mensajes. Un par así es donde hay que leer un conjunto etiquetado antes de confiar en un modelo, y el capítulo 2 enumera los pares de cada candidato.

Un estudiante copia a su maestro, incluidos sus errores. El capítulo 6 destiló las respuestas del modelo de apoyo en un estudiante. El maestro coincidió con la etiqueta correcta en 549/1000 (54.9%) de las filas de entrenamiento que etiquetó, así que el estudiante aprendió de etiquetas erróneas casi la mitad de las veces. El estudiante alcanzó 69/200 (34.5%) en test_200, y la misma receta entrenada con las etiquetas correctas de esas mismas filas alcanzó 77/200 (38.5%).

El estudiante también queda por debajo de su maestro, que alcanzó 109/200 (54.5%) en test_200, y por debajo del control con etiquetas correctas, con una diferencia que esta muestra no puede resolver (capítulo 6). El estudiante acierta donde el control falla en 24/200 mensajes, y el control donde el estudiante falla en 32/200.

Un equipo nuevo es otro lugar donde el modelo pequeño pierde. Una cabeza de clasificación tiene una salida por cada equipo con el que fue entrenado, así que un equipo sin salida no puede enrutarse con ella. Añadirla requiere mensajes etiquetados para ese equipo, una ejecución de entrenamiento con la receta del capítulo 5 y las comprobaciones del capítulo 9 antes de que el enrutador le envíe un mensaje. Si un cambio de instrucciones podría añadir un equipo nuevo es una pregunta que puedes comprobar tú. Este libro no midió un modelo alojado, y la tabla más adelante en este capítulo deja la cuestión abierta.

En conjunto, los modelos pequeños de aquí hicieron tres cosas: un modelo con instrucciones se inclinó por una sola respuesta, un estudiante copió los errores de su maestro, y un equipo sin salida no pudo enrutarse. Ninguna de estas es un fallo en la aritmética del enrutador. El modelo de apoyo hizo una cosa más: nunca nombró 4 equipos y confundió un par. Eso es del modelo de apoyo, no de ninguna de las dos opciones. Un umbral más alto cambia por derivaciones parte de las 11/200 (5.5%) respuestas erróneas del enrutador en test_200 (capítulo 5), pero no da salida a ningún equipo ni corrige los errores del maestro ni los del modelo de apoyo. Cada caso cambia lo que ve quien hace la consulta: un equipo equivocado, un mensaje derivado o ningún equipo.

Regla práctica: Antes de enrutar con un modelo pequeño, ejecútalo y ejecuta el modelo alojado sobre la misma muestra fija. Cuenta los mensajes que cada uno acierta y el otro falla, y las respuestas erróneas que llegarían a quien hace la consulta. Cuenta las respuestas de un modelo con instrucciones frente a la lista de equipos, y cuenta con qué frecuencia su respuesta más común es el equipo correcto. No enrutes un equipo que no tenga mensajes etiquetados propios, y no entrenes un estudiante con las etiquetas de un maestro antes de haber contado con qué frecuencia el maestro coincide con las etiquetas correctas.

Calcular la factura y la máquina

Último cambio en la edición 2026.11.9

Un modelo alojado se paga por mensaje. La factura mensual de un modelo alojado es el número de mensajes por lo que cuesta un mensaje, y un mensaje cuesta sus tokens de entrada al precio de entrada más sus tokens de salida al precio de salida. Una lista de precios escrita por millón de tokens da el precio por token al dividir entre un millón. Un mensaje de enrutamiento es largo en la entrada, porque se cuentan tanto el prompt como el mensaje, y corto en la salida, porque la respuesta es un solo nombre de equipo.

Una máquina se paga tanto si está ocupada como si no. La factura mensual de una máquina es sus horas por su tarifa por hora. El número de mensajes que una máquina puede enrutar al mes es su rendimiento, en mensajes por segundo, por los segundos de un mes, por su utilización, que es la parte del mes en que está ocupada. El coste por mensaje de la máquina depende, por tanto, de cuántos mensajes enruta, y la comparación necesita un volumen antes de dar una respuesta.

Las tres fórmulas siguientes valen para cualquier par de opciones.

hosted cost per month = messages × (input tokens × input price + output tokens × output price)
machine cost per month = hours × machine cost per hour
machine capacity per month = messages per second × seconds per month × utilisation

Cada entrada necesita un valor, y cada precio necesita una fecha y una fuente. El libro no cita ningún precio de un modelo alojado, porque no tiene ninguno con fuente y fecha que un lector pueda comprobar. Consulta la página de precios de tu proveedor el día en que hagas la comparación, y escribe el precio, su fecha y su dirección junto al número.

Los tokens de entrada también necesitan un tokenizador. El recuento de un proveedor alojado puede diferir del recuento de un modelo abierto para el mismo texto, y este libro no midió ninguno. El prompt de enrutamiento es lo que un modelo alojado recibiría por cada mensaje: la lista de 77 nombres de equipo y el mensaje, tal como lo construye router_prompt. El ejemplo mensual lo cuenta con el tokenizador de SmolLM2-135M-Instruct, que da 587 tokens por mensaje, y el ejemplo indica que ese recuento es un sustituto del que usaría el proveedor.

El rendimiento es el dato que debe aportar una grabación, porque depende de la máquina. La grabación nombra su máquina y guarda las tasas que midió. En a cloud machine with 4 vCPUs and 15 GiB of memory, con 4 hilos, el sustituto enrutó 0.32 mensajes por segundo con un mensaje por llamada. El clasificador del enrutador, banking77-lora-v1, en float32, enrutó 19.0 mensajes por segundo con el mismo tamaño de llamada. Su tasa en lotes de 16 también aparece en la salida.

Solo el par de un mensaje por llamada es comparable directamente. El clasificador en lotes de 16 procesa 16 mensajes en un solo paso hacia delante, y el sustituto procesa un mensaje por llamada con todo su prompt de enrutamiento. Por eso el cociente por lotes de 104.0 mezcla el tamaño del modelo con el procesamiento por lotes, y este capítulo no lo usa para la comparación. La comparación usa el cociente de un mensaje por llamada, 60.8. Cada copia recibió una pasada cronometrada sobre los 200 mensajes de test_200, tras un calentamiento de un mensaje, con la tokenización dentro del intervalo medido. Los cocientes proceden de tasas sin redondear, así que no son exactamente el cociente de las tasas impresas.

cost-ratio-from-recording.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Superado
"""The throughput rates and ratios as recorded, and the machine they were measured on. The prose rests on theone-per-call ratio line, the like-for-like comparison; the batched lines differ in call size. Reads the recording only; no model runs."""import jsonimport router_libfolder = router_lib.HERE / "data" / "recorded" / "throughput"ratios = json.loads((folder / "ratios.json").read_text())rates = router_lib.recorded_rates()manifest = json.loads((folder / "manifest.json").read_text())print(f"machine: {manifest['machine'].split(', ')[0]}")  # the machine's description is cut at its first comma, which keeps the name and drops the restprint(f"threads: {manifest['settings']['n_threads']}")print(f"messages on test_200: {ratios['messages']}")print(f"stand-in rate, one per call (messages a second): {rates['standin_one_message_per_call']}")print(f"classifier fp32 rate, one per call (messages a second): {rates['classifier_fp32_one_message_per_call']}")print(f"classifier fp32 rate, batches of 16 (messages a second): {rates['classifier_fp32_batches_of_16']}")print(f"classifier int8 rate, batches of 16 (messages a second): {rates['classifier_int8_batches_of_16']}")# Each ratio is computed from unrounded rates, so it is not the quotient of the printed rates.print(f"fp32 over stand-in, one per call, throughput ratio: {ratios['classifier_fp32_one_at_a_time_over_standin']}")print(f"fp32 over stand-in, batches of 16, throughput ratio: {ratios['classifier_fp32_over_standin']}")print(f"int8 over stand-in, batches of 16, throughput ratio: {ratios['classifier_int8_over_standin']}")print(f"int8 over fp32, batches of 16, throughput ratio: {ratios['classifier_int8_over_fp32']}")print(f"predictions agreeing, fp32 and int8: {ratios['agreement_fp32_int8']}/{ratios['messages']}")
Salidapython cost-ratio-from-recording.py
machine: a cloud machine with 4 vCPUs and 15 GiB of memory
threads: 4
messages on test_200: 200
stand-in rate, one per call (messages a second): 0.32
classifier fp32 rate, one per call (messages a second): 19.0
classifier fp32 rate, batches of 16 (messages a second): 33.0
classifier int8 rate, batches of 16 (messages a second): 29.0
fp32 over stand-in, one per call, throughput ratio: 60.8
fp32 over stand-in, batches of 16, throughput ratio: 104.0
int8 over stand-in, batches of 16, throughput ratio: 91.8
int8 over fp32, batches of 16, throughput ratio: 0.9
predictions agreeing, fp32 and int8: 200/200

En esta máquina, con este número de hilos, la copia int8 no fue más rápida que la de float32. Su cociente sobre float32 en lotes de 16 es 0.9. El capítulo 7 decía que menos bytes no resuelven la velocidad, y esta grabación mide la velocidad. Las dos copias coincidieron en 200/200 predicciones. La grabación se hizo con ese número de hilos, y el presupuesto de servicio de este libro son dos vCPU, así que las tasas de un lector deben proceder de una grabación en su propia máquina y con su propio número de hilos.

La factura necesita una tasa para el enrutador, y la grabación la da: el clasificador con un mensaje por llamada, medido como se midió el sustituto. La ruta atiende un mensaje por petición, así que la factura usa esa tasa. Un lector la sustituye por una tomada en su propia máquina.

monthly-bill-from-labelled-inputs.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Superado
"""The monthly bill for a hosted model and for the router on one machine, from inputs the reader sets. The hosted bill,the machine's bill and the cheaper-route line are the point the prose rests on. The prices, volume, machine costand utilisation are example values, not published prices; the token counts are live and the router's rate is recorded."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()inputs = router_lib.bill_inputs_recorded()test = router_lib.read_rows("test")messages = [test[i][0] for i in router_lib.read_sample("test_200")]  # index 0 is the text; the label is index 1# The hosted prompt, counted with the 135M model's tokenizer as a stand-in for the provider's.input_tokens = router_lib.router_prompt_tokens(messages)# Prices are per million tokens, hence the division at the end.per_message = (input_tokens * inputs["price_per_million_input_tokens"]               + inputs["output_tokens_per_message"] * inputs["price_per_million_output_tokens"]) / 1_000_000hosted_month = inputs["messages_per_month"] * per_messagemachine_month = inputs["machine_cost_per_hour"] * inputs["hours_per_month"]capacity = inputs["router_messages_per_second"] * 3600 * inputs["hours_per_month"] * inputs["utilisation"]print(f"example input, messages per month: {inputs['messages_per_month']}")print(f"example input, price per million input tokens, USD: {inputs['price_per_million_input_tokens']}")print(f"example input, price per million output tokens, USD: {inputs['price_per_million_output_tokens']}")print(f"example input, output tokens per message: {inputs['output_tokens_per_message']}")print(f"example input, machine cost per hour, USD: {inputs['machine_cost_per_hour']}")print(f"example input, hours per month: {inputs['hours_per_month']}")print(f"example input, utilisation: {inputs['utilisation']}")print(f"recorded input, router messages per second, one per call: {inputs['router_messages_per_second']}")print(f"input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): {input_tokens}")print(f"example hosted price per message (example prices), USD: {per_message:.6f}")print(f"example hosted bill per month (example prices), USD: {hosted_month:.2f}")print(f"example machine bill per month (example cost per hour), USD: {machine_month:.2f}")print(f"machine capacity per month (recorded rate, example utilisation): {capacity:.0f}")print(f"example machine cost per message at capacity (example cost per hour), USD: {machine_month / capacity:.6f}")print(f"example volume within machine capacity: {'yes' if inputs['messages_per_month'] <= capacity else 'no'}")  # above capacity, one machine cannot carry the volume and this bill does not holdprint(f"example values, cheaper route at the input volume: {'hosted' if hosted_month < machine_month else 'machine'}")
Salidapython monthly-bill-from-labelled-inputs.py
example input, messages per month: 100000
example input, price per million input tokens, USD: 1.0
example input, price per million output tokens, USD: 4.0
example input, output tokens per message: 6
example input, machine cost per hour, USD: 0.4
example input, hours per month: 730
example input, utilisation: 0.5
recorded input, router messages per second, one per call: 19.0
input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): 587
example hosted price per message (example prices), USD: 0.000611
example hosted bill per month (example prices), USD: 61.10
example machine bill per month (example cost per hour), USD: 292.00
machine capacity per month (recorded rate, example utilisation): 24966000
example machine cost per message at capacity (example cost per hour), USD: 0.000012
example volume within machine capacity: yes
example values, cheaper route at the input volume: hosted

Con estas entradas de ejemplo, la ruta alojada es la más barata. La factura alojada es de 61.10 USD al mes para el volumen de ejemplo, y una máquina propia cuesta 292.00 USD al mes sea cual sea el volumen.

Con la tasa grabada y la utilización de ejemplo, la máquina puede enrutar 24966000 mensajes al mes, y a plena capacidad su coste por mensaje es de 0.000012 USD. El volumen de ejemplo de 100000 mensajes al mes queda muy por debajo de esa capacidad, y la sección de punto de equilibrio encuentra dónde se cruzan las dos facturas. El coste por hora de estas entradas corresponde a la máquina grabada; una máquina de dos vCPU necesita su propia tasa grabada.

Cada entrada de esta factura puede dejar de ser cierta. Los precios cambian, así que un precio leído en un mes es un dato de ese mes. La utilización aquí es una suposición sobre un tráfico que todavía no ha ocurrido, y el volumen de un buzón cambia con los productos que vende el banco y con los sucesos que llenan su cola. Una máquina que estuvo ociosa la mitad del mes en un trimestre puede estar ocupada todo el mes en el siguiente. Por eso, vuelve a calcular cada mes, con el volumen real, el precio en su fecha y la utilización que mida la máquina. Una comparación hecha una sola vez es un registro del mes en que se hizo.

Regla práctica: Compara las dos facturas con entradas que hayas comprobado y con una máquina a la que hayas puesto precio. Escribe cada precio con su fuente y la fecha en que lo leíste. Cuenta los tokens de entrada con el tokenizador del modelo alojado con el que comparas, y toma el rendimiento de una grabación en la máquina que comprarías. Cuando un valor sea un ejemplo, indícalo junto a él, y reemplázalo antes de decidir.

Mantén los datos dentro del edificio

Esta sección no es una comparación de costos, y ninguna de las cifras de este libro la decide. Cada mensaje que recibe la bandeja de entrada es un texto de un cliente. Cuando un modelo alojado responde a ese mensaje, el texto sale de las máquinas del banco y va a las del proveedor. Por cada mensaje, una llamada a un modelo alojado envía el texto del mensaje y la lista de 77 nombres de equipo. Es posible que el banco no quiera eso, por motivos propios: los datos de sus clientes, sus contratos, sus reglas sobre quién puede leer qué. Esos motivos se mantienen aunque la factura del servicio alojado sea más baja.

Los mensajes de este libro son mensajes públicos de BANKING77, así que las ejecuciones del propio libro no muestran nada sobre la privacidad. El requisito pertenece al banco, y solo el banco puede decir si le aplica.

Un modelo pequeño que permanece en las máquinas del banco cumple el requisito por el lugar donde se ejecuta. El enrutador, sus pesos y sus registros quedan bajo los controles del banco, y las comprobaciones de versiones y de archivos del capítulo 9 se aplican a cada adaptador que carga la ruta. Una copia derivada, como la copia int8, no tiene manifiesto ni fijación propios, así que necesita ambas cosas antes de servir. Quedarse dentro tiene un costo propio, que no es una factura. El banco opera la máquina, la mantiene actualizada y mantiene en marcha las comprobaciones de la ruta, incluido el traspaso que se queda en la ruta cambie lo que cambie (capítulo 8).

Una factura es un número que cambia con el volumen, el precio y la fecha. Un requisito no cambia. Por eso resuelve primero el requisito y luego compara solo las opciones que lo cumplen. Un modelo pequeño que se ejecuta en las máquinas del banco es una de esas opciones. Un modelo abierto más grande que se ejecuta allí es otra. El modelo sustituto es una más, y en esta máquina enrutó 0.32 mensajes por segundo, un mensaje por llamada, frente a 19.0 del clasificador. Esa diferencia es su costo medido en rendimiento, 60.8 veces más, y no es un costo en dinero. Si ninguna opción cumple el requisito al volumen que espera la bandeja de entrada, la comparación de costos no tiene nada que decidir. Un modelo pequeño que cumple el requisito aún debe superar los recuentos de precisión y de traspasos de la primera sección, y cumplir el requisito no lo exime de ellos.

Regla práctica: Resuelve el requisito de datos antes que el costo. Anótalo como requisito, junto con las personas responsables de él, y no lo cuentes ni como ahorro ni como costo. Cuando los mensajes deban permanecer en las máquinas del banco, elige un modelo que se ejecute allí, y luego cuenta su precisión y sus traspasos como en la primera sección de este capítulo.

Elige con una tabla

Último cambio en la edición 2026.11.2

Las preguntas anteriores no tratan todas sobre el costo, y la mayoría pueden responderse antes de que alguien ejecute una grabación. La tabla siguiente pone las preguntas una junto a la otra. Para cada una, indica cómo es un enrutador pequeño, cómo es un modelo alojado y qué contar en tu bandeja de entrada.

Pregunta Enrutador pequeño Modelo alojado Qué medir
¿Los mensajes deben quedarse en las máquinas del banco? Lo cumple: se ejecuta en las máquinas del banco No lo cumple: el texto va al proveedor Requisito, no un recuento: decídelo primero
¿Cada respuesta debe ser un equipo? Sí, por una cabeza o por decodificación restringida (capítulo 4) Solo si un prompt y una comprobación la mantienen dentro de la lista Respuestas fuera de la lista de equipos, en una muestra fija
¿Con qué frecuencia cambia la lista de equipos? Un equipo nuevo necesita mensajes etiquetados y una corrida de entrenamiento (capítulo 9) Si basta con un cambio de prompt: una pregunta que probar Los mensajes etiquetados y los pasos que necesita un equipo nuevo para que sus mensajes se enruten
¿Cuántos mensajes al mes? Una factura mensual fija, hasta su capacidad Una factura por mensaje, que crece con el volumen El recuento del punto de equilibrio de la última sección
¿Cuántos mensajes etiquetados tiene cada equipo? Suficientes para entrenar y para probar a cada equipo (capítulo 2) Pocos o ninguno, para un prompt Mensajes etiquetados por equipo, contados en la partición de entrenamiento
¿La tarea necesita texto abierto o conocimiento amplio? Limitado a la lista de equipos, y sus respuestas de texto abierto fallaron en la primera prueba de este libro Una pregunta que probar Precisión en la misma muestra fija, con su recuento

La tabla es una lista de qué contar, no una puntuación. Lee sus filas en orden: primero el requisito de la primera fila, luego la lista de equipos y después el volumen, porque cada una puede cerrar la pregunta antes de que se formule la siguiente. En la última columna, una celda que empieza con "Requisito" nombra una decisión que va antes de los recuentos. Cualquier otra celda nombra un recuento, tomado en tu muestra, con su denominador impreso. La fila de texto abierto se apoya en la primera prueba del capítulo 4: las respuestas sin restricciones del modelo de 135M fueron nombres de equipo en 0/20 mensajes.

Regla práctica: Responde cada fila desde tu bandeja de entrada antes de elegir. Cuando una fila pida un recuento, tómalo en una muestra fija e imprime su denominador. Cuando una fila nombre un requisito, deja que el requisito decida antes que los recuentos y escríbelo en la decisión como requisito.

Conoce el punto de equilibrio

Último cambio en la edición 2026.11.9

El punto de equilibrio es el volumen en el que la factura mensual del modelo alojado y la de la máquina son iguales. Por debajo de él, el modelo alojado cuesta menos con los datos que fijas. Por encima, la máquina cuesta menos, siempre que el volumen esté dentro de la capacidad de la máquina. La factura de la máquina se paga esté ocupada o inactiva, así que el punto de equilibrio divide esa factura entre el precio por mensaje del modelo alojado:

mensajes por mes en el punto de equilibrio = factura mensual de la máquina ÷ precio por mensaje del modelo alojado

La fórmula no resta el costo por mensaje de la máquina del precio del modelo alojado. El costo por mensaje de la máquina a plena capacidad es su factura fija dividida entre su capacidad, y esa factura ya se cuenta una vez en el numerador. Restar de nuevo ese mismo costo significaría contar la máquina dos veces. La fórmula además solo vale dentro de la capacidad. Por encima de ella, una sola máquina no puede atender el volumen, y el cálculo se repite para una segunda máquina, con su propia factura y su propia capacidad.

break-even-from-recorded-ratio.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Superado
"""The monthly volume at which one machine's bill equals the hosted bill for the router's prompts. The break-even lineis the point the prose rests on, and it holds only inside the capacity line, which the last line checks. The prices andthe machine's cost are example values, as in the bill; the router's rate is recorded on the machine."""import mathimport osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()inputs = router_lib.bill_inputs_recorded()  # example prices and cost per hour, with the router's rate from the recordingtest = router_lib.read_rows("test")  # (text, label index) for every test row, in file ordermessages = [test[i][0] for i in router_lib.read_sample("test_200")]  # index 0 is the text; the label is index 1# Mean count of the whole router prompt, team list included, with SmolLM2-135M's tokenizer.input_tokens = router_lib.router_prompt_tokens(messages)# Prices are per million tokens, hence the division at the end.per_message = (input_tokens * inputs["price_per_million_input_tokens"]               + inputs["output_tokens_per_message"] * inputs["price_per_million_output_tokens"]) / 1_000_000machine_month = inputs["machine_cost_per_hour"] * inputs["hours_per_month"]capacity = inputs["router_messages_per_second"] * 3600 * inputs["hours_per_month"] * inputs["utilisation"]# The machine's bill is the same each month up to its capacity, so the hosted bill# equals it at messages = machine bill / hosted price per message.# Rounded up: the first whole message count at which the machine is no dearer.breakeven = math.ceil(machine_month / per_message)print(f"input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): {input_tokens}")print(f"example hosted price per message (example prices), USD: {per_message:.6f}")print(f"example machine bill per month (example cost per hour), USD: {machine_month:.2f}")print(f"machine capacity per month (recorded rate, example utilisation): {capacity:.0f}")print(f"example break-even messages per month (example prices and cost per hour): {breakeven}")print(f"break-even within machine capacity: {'yes' if breakeven <= capacity else 'no'}")
Salidapython break-even-from-recorded-ratio.py
input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): 587
example hosted price per message (example prices), USD: 0.000611
example machine bill per month (example cost per hour), USD: 292.00
machine capacity per month (recorded rate, example utilisation): 24966000
example break-even messages per month (example prices and cost per hour): 477906
break-even within machine capacity: yes

Con los valores de ejemplo, la factura de la máquina de 292.00 USD alcanza el punto de equilibrio en 477906 mensajes al mes. Esa cifra está dentro de la capacidad de la máquina, que es de 24966000 mensajes al mes (la comprobación muestra yes). Esa capacidad usa la tasa registrada de una llamada por mensaje con la utilización de ejemplo.

El punto de equilibrio no depende de la tasa, solo de la factura y del precio del modelo alojado. El volumen de 100000 mensajes al mes queda muy por debajo, así que la factura del modelo alojado es la más baja.

Un dato de costo no es una decisión, y el buzón sigue decidiendo lo demás. Solo responde a la pregunta del costo después de que se resuelva el requisito de mantener los datos dentro del edificio. Si los mensajes deben quedarse dentro, la pregunta es qué modelo pequeño cumple con los recuentos de precisión y de traspasos, y el punto de equilibrio indica cuánto cuesta esa máquina frente a un modelo alojado en cada volumen. Si el requisito permite un modelo alojado, y el volumen está por debajo del punto de equilibrio, el modelo alojado es la vía de menor costo con los precios de ejemplo. Por encima del punto de equilibrio, la máquina es la vía de menor costo, siempre que el volumen esté dentro de su capacidad y que las respuestas incorrectas del enrutador que llegan a quien llama sean cifras que el personal de soporte pueda aceptar. Los traspasos pasan a una persona sin importar lo que diga la factura: en los primeros 200 mensajes, el enrutador traspasa 33/200 (16.5%) de ellos.

Regla práctica: Calcula el punto de equilibrio con la factura de tu máquina y con el precio del modelo alojado que hayas leído, anotando junto a ese precio su fecha y su fuente. Comprueba que el volumen que esperas esté dentro de la capacidad que mediste en tu máquina antes de tomar el punto de equilibrio como un ahorro. Por encima de esa capacidad, cuenta una segunda máquina y vuelve a calcular. Lee el punto de equilibrio como un dato de costo, no como una decisión. Los requisitos y los recuentos de precisión de las secciones anteriores siguen decidiendo si el enrutador entra en funcionamiento.

Las decisiones que este libro tomó para la bandeja de entrada

Último cambio en la edición 2026.11.2

Sobre las muestras y las máquinas que el libro menciona, estas son las cifras que afectan a la bandeja de entrada. Cada una lleva el capítulo que la calcula.

  • Precisión. En todo test_1001, el enrutador acierta en 847/1001 (84.6%), y el modelo sustituto en 560/1001 (55.9%) (capítulo 2). El enrutador pasa el resto a una persona, y 76/1001 (7.6%) respuestas erróneas aun así llegan a un cliente. Esa es la cuenta que el personal de soporte debe aceptar antes de que el enrutador entre en producción.
  • Velocidad. En la máquina registrada, con un mensaje por llamada, el clasificador procesó 19.0 mensajes por segundo frente a los 0.32 del modelo sustituto, una razón de 60.8 (capítulo 7 explica cómo se mide la velocidad). La copia int8 no ofreció ninguna razón de velocidad para servirla: su razón frente a float32 en lotes de 16 fue de 0.9. Por eso el adaptador en float32 sigue siendo el que sirve la ruta (capítulo 8).
  • Costo. Con las entradas de ejemplo, 100000 mensajes al mes cuestan 61.10 USD en el lado alojado y 292.00 USD en una máquina propia. El punto de equilibrio está en 477906 mensajes al mes, dentro de una capacidad de 24966000. Estos son precios de ejemplo y un costo por hora de ejemplo, así que reemplázalos por los tuyos, cada uno con su fecha y su fuente, antes de tomar el punto de equilibrio como una decisión.
  • El requisito de datos. Si los mensajes deben permanecer en las máquinas del banco, el modelo alojado queda descartado, y la elección se reduce a opciones que funcionen allí. Resuelve eso primero, como explica la sección sobre mantener los datos dentro del edificio.
  • Cuándo el modelo pequeño no es la elección. Un equipo sin mensajes etiquetados no tiene salida en la cabeza, y un equipo nuevo necesita los pasos del capítulo 9. Las respuestas de texto abierto fallaron en la primera prueba de este libro (capítulo 4). Se espera que un modelo alojado funcione mejor con texto abierto y conocimiento general, lo cual es una pregunta que hay que comprobar. Y con un volumen por debajo del punto de equilibrio, donde se permita un modelo alojado, este es la ruta más barata a los precios de ejemplo.
  • Lo aprendido. El requisito de datos y la lista de equipos determinan qué opciones quedan. Solo después de eso la factura elige entre ellas.

El veredicto para la bandeja de entrada. Si los mensajes deben permanecer en las máquinas del banco, y cada equipo tiene mensajes etiquetados, la elección es un enrutador pequeño en la propia máquina del banco, siempre que el volumen esté por encima del punto de equilibrio con los precios propios del banco y dentro de la capacidad de la máquina. El paso a una persona se mantiene en la ruta, diga lo que diga la factura. Cuenta las respuestas erróneas que llegan a quien llama en la muestra propia del banco antes de que entre en producción.

Regla práctica: Vuelve a escribir esta lista a partir de tu bandeja de entrada, con tus cifras, antes de elegir. Un veredicto que no salga de tus cuentas, fechas y requisitos no es el veredicto del libro para tu bandeja de entrada.

Este capítulo, en esta edición

Edición 2026.11.9Ejemplos verificados el 20 de nov de 2026Superan la prueba 5 de 5 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.9.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 10 de 10: Cuándo un modelo pequeño es la elección equivocada

  1. Dónde todavía pierde el modelo pequeño
  2. Calcular la factura y la máquina
  3. Mantén los datos dentro del edificio
  4. Elige con una tabla
  5. Conoce el punto de equilibrio
  6. Las decisiones que este libro tomó para la bandeja de entrada

Volver arribaTodos los capítulos