Elige un modelo base contando lo que cuesta un mensaje
Unos 19 minutos de lectura, con 3 ejemplos en 5 secciones.
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 final de este capítulo, podrás nombrar los dos modelos base que este libro conserva, cargar cada uno en su revisión fijada y contar cuánto cuesta un mensaje de enrutamiento en tokens y parámetros antes de comprometerte con un modelo.
Cada mensaje de la bandeja de soporte del banco tiene un costo al enrutarlo: un modelo lo lee y elige su equipo, y el modelo del que parte el enrutador fija cuánto cuesta eso. El enrutador es el sistema completo que construye el capítulo 1, y este capítulo elige el modelo abierto pequeño que va debajo. El capítulo 2 fijó las muestras con las que se mide el enrutador. Este capítulo elige primero por costo, porque el banco puede contar lo que cuesta un mensaje antes de construir nada alrededor del modelo.
Qué candidatos conservamos
Un modelo base es un modelo ya preentrenado con una gran cantidad de texto, que tú adaptas a una tarea concreta. Todos los capítulos posteriores se apoyan en esta elección, a través del prompt, el entrenamiento, la destilación y el servicio, así que vale la pena tomarla con base en evidencia. Hay muchos modelos abiertos, por lo que el libro reduce el campo con dos preguntas: ¿puede el modelo ejecutarse en el hardware que tiene el banco?, y ¿puede el banco usar su licencia?
En la práctica, la licencia va primero. Decide qué puede hacer el banco con el modelo dentro de su propio sistema, y un modelo que el banco no puede ejecutar no es un candidato, sin importar su tamaño. El libro registra la licencia de cada modelo junto a su fijación (pin), para que puedas ver el mismo registro que usó el libro.
El primer candidato es SmolLM2, una familia de modelos publicada en Hugging Face. La tarjeta del modelo del modelo de 135M, en la confirmación que fija este libro, indica los tres tamaños de la familia en una sola frase: 135M, 360M y 1.7B parámetros. La misma tarjeta indica que la licencia es license: apache-2.0, que las fijaciones del libro registran para los dos modelos que conserva. La tarjeta también señala que los datos de entrenamiento del modelo de 135M son 2 trillones de tokens. Estas cifras provienen solo de la tarjeta del modelo de 135M.
El libro conserva dos de los tres tamaños. La siguiente lista los nombra, y la tabla que sigue presenta los tres lado a lado, con la licencia que registra cada fijación.
- SmolLM2-135M-Instruct es el modelo central. El resto del libro lo entrena y lo sirve.
- SmolLM2-360M-Instruct es una comparación. El libro lo carga, cuenta sus parámetros y capas, y lo usa junto al modelo central en este capítulo y en el capítulo 4. El libro no lo entrena.
| Modelo | Función en este libro | Fijado en models.toml |
Licencia |
|---|---|---|---|
| SmolLM2-135M-Instruct | Modelo central, entrenado y servido por el resto del libro | Sí | Apache-2.0 |
| SmolLM2-360M-Instruct | Comparación junto al modelo central | Sí | Apache-2.0 |
| SmolLM2 1.7B | No fijado y no ejecutado | No | No registrada |
El modelo de 1.7B no está fijado en el archivo models.toml del libro, y el libro no lo ejecuta. Los ejemplos del libro usan dos hilos de CPU, así que cada candidato debe cargarse y ejecutarse dentro de ese presupuesto. Para un banco con ese presupuesto, recomendamos el modelo de 135M como punto de partida, por las razones expuestas en el resto de este capítulo.
El punto de referencia del libro es un modelo distinto. En el caso, un modelo alojado enruta hoy los mensajes del banco, y este libro nunca lo llama. Su sustituto es Qwen3-4B-Instruct-2507, un modelo abierto más grande cuyas respuestas a los mensajes de prueba se registran una sola vez y luego se leen sin conexión. El sustituto es la línea base contra la que se miden los candidatos, no un candidato para el enrutador. El capítulo 1 lo presenta.
Regla práctica: Empieza con el modelo más pequeño de la familia que cumpla las medidas que fijes en la partición de desarrollo (dev), los mensajes de entrenamiento reservados para elegir (capítulo 2). Sube un tamaño solo cuando el modelo más pequeño no alcance una medida, y únicamente después de haber medido el modelo más grande con las mismas muestras. Esto es una regla práctica. Se mantiene hasta que tus propias mediciones digan lo contrario.
Carga cada modelo en su revisión fijada
La sección anterior nombró dos modelos. Un nombre por sí solo no dice qué versión de los archivos del modelo se carga, porque un modelo se almacena en un repositorio de commits, y una rama como main puede avanzar a un commit nuevo. Una revisión fijada por un hash de commit completo nombra una instantánea concreta de los archivos, y el archivo de fijaciones, examples/models.toml, registra el SHA-256 de cada archivo de esa instantánea, que el entorno de ejecución verifica. El cargador compartido pasa el commit a la biblioteca transformers, que el libro fija en 5.23.0, y el cargador busca en ese archivo el commit de cada modelo.
Para cada modelo, el archivo guarda el repositorio, el commit, la licencia y el SHA-256 de cada archivo que el modelo necesita. Su encabezado indica que el entorno de ejecución descarga cada modelo una sola vez, lo verifica archivo por archivo y después lo lee sin conexión. El archivo lo genera re-check models --pin, y su encabezado indica que no debe editarse a mano. Así, un lector que cambie una fijación ejecuta ese comando en lugar de escribir un commit nuevo en el archivo. Un modelo sin fijación no tiene commit que buscar, de modo que el cargador compartido no lo carga.
Los ejemplos activan las marcas de la biblioteca para trabajar sin conexión antes de importarla, de modo que una carga solo lee lo que el entorno de ejecución ya tiene. El cargador también fija los pesos en float32 y ejecuta la atención en la forma eager habitual de la biblioteca. Las reglas de determinismo del libro fijan ambas cosas, de modo que cada ejecución de un ejemplo produce los mismos números. Si una carga sin conexión falla en la máquina de un lector, compara primero los archivos en disco con la lista del archivo de fijaciones antes de cambiar cualquier otra cosa.
El ejemplo también vigila las fijaciones desde la salida. Imprime el número de parámetros de cada modelo, de modo que un cambio en el tamaño de un modelo aparece como una línea modificada en la salida propia del libro, y cada cifra que el capítulo cita de esa línea cambia con él. El lector que vea un recuento distinto sabe qué fijación comparar primero. Un cambio de commit que deja el tamaño igual no aparece ahí, por lo que la propia fijación sigue siendo el registro.
Un ejemplo carga los dos modelos que se conservan desde los archivos que el entorno de ejecución descargó y verificó contra las fijaciones, sin red, e imprime los primeros recuentos de tamaño del libro.
1"""Load the 135M and 360M SmolLM2 models at their pins, offline, and print each one's parameter count and layer count. The chapter's size claims rest on both lines; the parameter line is rounded to whole millions."""23import os45os.environ["HF_HUB_OFFLINE"] = "1"6os.environ["TRANSFORMERS_OFFLINE"] = "1"78import torch # noqa: E402910torch.set_num_threads(2)1112import router_lib # noqa: E4021314# Seeds, deterministic algorithms and float32, set before either model loads.15router_lib.setup_runtime()1617SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"18MEDIUM = "HuggingFaceTB/SmolLM2-360M-Instruct"192021def size(model):22 """Return (parameter count in millions, rounded to a whole number) and the layer count."""23 # parameters() yields a shared tensor once, so the tied embedding and output head count once.24 total = sum(p.numel() for p in model.parameters())25 return round(total / 1e6), model.config.num_hidden_layers262728# load_model returns (tokenizer, model). This example needs only the models.29_, small = router_lib.load_model(SMALL)30_, medium = router_lib.load_model(MEDIUM)3132small_millions, small_layers = size(small)33medium_millions, medium_layers = size(medium)3435print(f"parameters, millions, rounded: {small_millions} and {medium_millions}")36print(f"layers: {small_layers} and {medium_layers}")
python load-both-models-offline.pyparameters, millions, rounded: 135 and 362
layers: 30 and 32
Un parámetro es uno de los números que el modelo aprende durante el entrenamiento, y una capa es uno de los bloques apilados por los que pasa un token. Parámetros y capas son los únicos dos tamaños que usa este capítulo. El 360M es el mayor de los dos. La primera línea de salida da el número de parámetros de cada modelo, redondeado a millones enteros: 135 and 362. La segunda línea da los recuentos de capas, 30 and 32, en el mismo orden. La velocidad no aparece entre ellos, porque un tiempo depende de la máquina. La grabación de throughput mide el clasificador y su copia int8 frente al modelo de referencia en una máquina identificada (el capítulo 7 explica cómo, y el capítulo 10 informa de las proporciones). La grabación no mide el 360M.
Los recuentos proceden de cargar los modelos aquí, no de sus fichas.
En producción, la fijación responde a la primera pregunta que se hace cuando cambia un resultado, que es qué archivos lo produjeron. Un cambio de modelo aparece como una diferencia en models.toml, donde están el commit y los hashes de los archivos. Cuando la copia de un lector de un modelo da una salida distinta de la del libro, compara primero el commit.
Regla práctica: Fija cada modelo por su commit en examples/models.toml, y cárgalo con ese commit y las marcas de trabajo sin conexión. Registra los recuentos de parámetros y capas junto a la fijación, de modo que un cambio en el tamaño de un modelo aparezca como una línea de salida modificada y no como una sorpresa en un capítulo posterior.
Mide lo que cuesta un mensaje
La sección anterior mostró qué son los dos modelos. Esta sección muestra lo que cuesta un mensaje en cada uno. El costo de un mensaje depende de lo que el modelo lee y de lo que escribe. El prompt del enrutador contiene los 77 nombres de equipo, el mensaje y una petición del equipo, y la lista de equipos es la misma en cada llamada, así que cada mensaje paga por ella.
El prompt empieza con la frase «Route this customer message from an online bank to one support team.». Pide solo el nombre del equipo, enumera los equipos, luego presenta el mensaje y termina con la palabra «Team:». Todo ese texto es igual de un mensaje a otro salvo el propio mensaje, de modo que el costo de un mensaje es el texto fijo más la longitud del mensaje.
El tokenizador convierte el texto del prompt en tokens, las unidades que lee un modelo. El conteo se hace en tokens y no en caracteres porque un modelo lee tokens. Contar necesita las reglas del tokenizador pero no los pesos, así que el conteo es el primer costo que puedes calcular antes de elegir un diseño. Un clasificador lee el mensaje una vez y devuelve una puntuación para cada equipo. Un modelo generativo lee el prompt una vez y después escribe su respuesta un token a la vez, y cada token que escribe es una pasada más por la red. Los capítulos siguientes usan ambos diseños.
Un ejemplo cuenta las pasadas hacia adelante, cada uno una llamada a la red, para un único mensaje de prueba con cada diseño. Usa el modelo de 135M sin adaptador. La cabeza del clasificador no está entrenada aquí, así que solo importa el número de pases.
1"""Count the forward passes one test_40 message costs a classifier and a generative model, with the 135M model and no adapter. The point rests on the generative line: the model makes one pass for each token it writes, plus one for the end token."""23import os45os.environ["HF_HUB_OFFLINE"] = "1"6os.environ["TRANSFORMERS_OFFLINE"] = "1"78import torch # noqa: E402910torch.set_num_threads(2)1112import router_lib # noqa: E40213from transformers import AutoModelForSequenceClassification # noqa: E4021415router_lib.setup_runtime()1617SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"18texts = [text for text, _ in router_lib.read_rows("test")]19# read_sample gives row indices into the test split; index 0 is the sample's first message.20message = texts[router_lib.read_sample("test_40")[0]]212223def count_passes(model, run):24 """Return how many forward calls the model makes while run() executes."""25 calls = []26 # A forward hook on the whole model fires once per call to its forward, so each generation step counts.27 handle = model.register_forward_hook(lambda module, args, output: calls.append(1))28 run()29 handle.remove()30 return len(calls)313233tokenizer, causal = router_lib.load_model(SMALL)34# SmolLM2's tokenizer sets a pad token; this line keeps the example working with one that doesn't.35tokenizer.pad_token = tokenizer.pad_token or tokenizer.eos_token36# The trie holds each team name's tokens, so constrained_team can write only a team name, one token per pass, then the end token.37trie = router_lib.build_trie(tokenizer)38# The pinned commit from models.toml, and the float32 weights and eager attention that load_model also sets.39# The head is new, with one score per team (77), and untrained here; only the pass count matters.40classifier = AutoModelForSequenceClassification.from_pretrained(41 SMALL, revision=router_lib._pins()[SMALL], num_labels=len(router_lib.LABELS),42 dtype=torch.float32, attn_implementation="eager",43).eval()44# The classification head finds each message's last token through this id, so the config needs it too.45classifier.config.pad_token_id = tokenizer.pad_token_id4647classifier_passes = count_passes(classifier, lambda: router_lib.classify(classifier, tokenizer, [message]))48answers = []49generative_passes = count_passes(causal, lambda: answers.append(router_lib.constrained_team(tokenizer, causal, trie, message)))50# answers[0] holds (label index, label text). The text is encoded with a leading space, as the model writes it after "Team:".51answer_tokens = len(tokenizer.encode(" " + answers[0][1], add_special_tokens=False))5253print(f"classifier forward passes: {classifier_passes}")54print(f"generative forward passes: {generative_passes}")55print(f"answer tokens, end token not counted: {answer_tokens}")
python count-forward-passes.pyclassifier forward passes: 1
generative forward passes: 8
answer tokens, end token not counted: 7
El costo de un modelo generativo crece con su respuesta, y el de un clasificador no. Para este mensaje, el clasificador hace 1 pasada. El modelo generativo hace 8 pasadas, uno por cada uno de los 7 tokens de su respuesta y uno para el token de fin.
Un segundo ejemplo cuenta los tokens del prompt del enrutador para cada uno de los 40 mensajes de la muestra fija de prueba, usando el tokenizador del modelo de 135M. No ejecuta ningún modelo.
1"""Count the router prompt's tokens for each message in test_40, with the 135M model's tokenizer. No model runs. The point rests on the mean line: a day's prompt cost is the mean, not the median, times the number of messages."""23import os45os.environ["HF_HUB_OFFLINE"] = "1"6os.environ["TRANSFORMERS_OFFLINE"] = "1"78import torch # noqa: E402910torch.set_num_threads(2)1112import router_lib # noqa: E40213from transformers import AutoTokenizer # noqa: E4021415router_lib.setup_runtime()1617SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"1819# Only the tokenizer is read from the pinned commit; no weights load.20tokenizer = AutoTokenizer.from_pretrained(SMALL, revision=router_lib._pins()[SMALL])2122texts = [text for text, _ in router_lib.read_rows("test")]23# read_sample gives row indices into the test split, in the order the sample lists them.24messages = [texts[i] for i in router_lib.read_sample("test_40")]2526# router_prompt builds the same prompt the router sends. encode keeps its default, so any special tokens are counted too.27counts = sorted(len(tokenizer.encode(router_lib.router_prompt(message))) for message in messages)2829# The median of an even count is the lower of the two middle values, so it is a whole number of tokens.30median = counts[(len(counts) - 1) // 2]3132total = sum(counts)33mean = round(total / len(counts))3435print(f"messages: {len(counts)}")36print(f"prompt tokens min: {counts[0]}")37print(f"prompt tokens median: {median}")38print(f"prompt tokens max: {counts[-1]}")39print(f"prompt tokens total: {total}")40print(f"prompt tokens mean, rounded: {mean}")
python count-prompt-tokens.pymessages: 40
prompt tokens min: 580
prompt tokens median: 585
prompt tokens max: 614
prompt tokens total: 23493
prompt tokens mean, rounded: 587
Los prompts solo se diferencian en sus mensajes, porque la lista de equipos es el mismo texto en cada prompt. Por eso la dispersión va desde 580 tokens para el prompt más corto hasta 614 para el más largo, con una mediana de 585 tokens. La mediana es el menor de los dos valores centrales, así que es un número entero de tokens.
En producción, el conteo cambia cuando cambia la lista de equipos. Añadir un equipo añade su nombre a cada prompt, de modo que cada mensaje cuesta más desde ese día. Vuelve a hacer el conteo después de cada cambio en la lista, y mantén la lista en el mismo orden, para que el resto del prompt no cambie con ella.
Para convertir el conteo en una cifra diaria, usa la media, no la mediana, porque los tokens del prompt de un día son la suma de sus prompts. Los 40 mensajes de la muestra suman 23493 tokens, una media de 587 tokens cada uno. Aquí la media está por encima de la mediana, así que multiplicar la mediana por el conteo subestimaría los tokens del prompt. Multiplica la media por el número de mensajes que el enrutador maneja ese día para obtener los tokens de prompt que lee, antes de contar la salida. El lado de la salida depende del diseño, y los diseños llegan en capítulos posteriores.
Esta sección da solo conteos. El tiempo que tarda un mensaje es tarea de la grabación, como señaló el paso de carga.
Regla práctica: Cuenta los tokens del prompt con el tokenizador del modelo que vas a ejecutar, antes de elegir un diseño, y vuelve a contar cada vez que cambie el prompt. El conteo pertenece a ese tokenizador, así que un conteo hecho con el tokenizador de otro modelo responde a una pregunta distinta.
Por qué 135M es el núcleo
Las secciones anteriores dieron al modelo de 135M su lugar: es más pequeño, y es el modelo que el resto del libro entrena y sirve. Esta sección explica las razones de esa elección, y señala dónde la elección aún no está demostrada.
Hay dos maneras amplias de hacer que un modelo pequeño enrute un mensaje. Una es preguntarle a un modelo, en el prompt, qué equipo elegir. La otra es entrenar un modelo con mensajes etiquetados. Bucher y Martini compararon modelos de estilo BERT con ajuste fino con grandes modelos alojados, como ChatGPT y Claude Opus, usados en modo zero-shot, en un preprint de 2024. Su resumen informa que los modelos pequeños ajustados superaron a los grandes con prompt, de forma consistente y significativa (arXiv:2406.08660v2). La comparación enfrenta modelos pequeños ajustados con grandes usados con prompt, no pequeños con pequeños, y procede de un solo preprint. El libro la toma como razón para medir primero un modelo pequeño ajustado. No la toma como prueba de que el modelo ajustado gane en la bandeja de entrada.
Los dos diseños también fallan de maneras distintas, y los recuentos de coste no lo muestran. Un modelo generativo escribe su respuesta como texto, así que el texto puede ser una cadena que no sea uno de los 77 equipos. Un clasificador puntúa cada uno de los 77 equipos, así que su respuesta siempre es uno de ellos, y la puntuación es lo que la regla de traspaso lee para enviar a una persona los mensajes dudosos. El capítulo 4 restringe la respuesta generativa a los 77 nombres, y el capítulo 5 entrena el clasificador.
Las razones de coste se apoyan en los recuentos del paso de carga. Según los dos recuentos que imprimió, el modelo de 135M es el más pequeño: 135 and 362 millones de parámetros y 30 and 32 capas, con la cifra del 135M primero en cada par. La tarjeta del modelo 135M lo describe como lo bastante ligero para ejecutarse en el dispositivo, y capaz en una amplia gama de tareas. Los ejemplos del libro son la evidencia de los recuentos, y la tarjeta es la evidencia de la descripción.
La tarjeta también limita lo que el modelo debe hacer: "Estos modelos deben usarse como herramientas de asistencia y no como fuentes definitivas de información." Esa advertencia concuerda con el diseño del enrutador. Un modelo de este tamaño es un asistente para el personal de soporte, y un mensaje sobre el que no está seguro pasa a una persona. El capítulo 1 presenta ese traspaso.
Este capítulo no demuestra que el modelo de 135M supere las medidas. El capítulo 4 ejecuta ambos modelos sobre los mismos mensajes, que es la comparación que esta sección no tiene. El capítulo 5 entrena el modelo de 135M con los mensajes etiquetados y lo mide en la partición de desarrollo frente a las medidas fijadas en el capítulo 2. Hasta entonces, la elección descansa en los recuentos de coste y en el estudio citado.
Tres cosas cambiarían esta elección, y cada una se resuelve con una medición más que con un argumento. Si el modelo de 135M no alcanza una medida de desarrollo tras el ajuste fino, el siguiente paso es entrenar el de 360M con las mismas filas de entrenamiento, medirlo de la misma forma y comparar los dos en la partición de desarrollo. Si el modelo de 135M supera las medidas de desarrollo pero traspasa más mensajes de los que el personal de soporte puede atender, la palanca es el umbral de traspaso. El capítulo 5 fija ese umbral en la partición de desarrollo junto con la tasa de traspaso que implica. Si el banco enruta un conjunto distinto de mensajes, la elección vuelve a empezar, porque las medidas de este capítulo describen los mensajes bancarios y no otros.
La elección tiene un coste que el lector debe sopesar, y este capítulo no lo mide. No ofrece ni el tiempo de carga ni el tiempo de ejecución de ninguno de los dos modelos, y la regla práctica de la primera sección pide esa medición antes de dar la elección por definitiva. Este capítulo hace la elección de forma provisional, y los capítulos siguientes la confirman o la sustituyen con las mismas medidas.
Regla práctica: Ajusta primero el modelo más pequeño y mídelo en la partición de desarrollo frente a las medidas que fijaste antes de mirar la partición de prueba. Mantén el modelo más grande como comparación hasta que el más pequeño haya dejado de alcanzar una medida en la partición de desarrollo, y no cambies de modelo sobre la partición de prueba.
Lo que necesitaría un modelo más grande
La sección anterior eligió el modelo más pequeño y dejó abierta la pregunta sobre el más grande, SmolLM2-360M-Instruct. Esta sección expone lo que exige esa pregunta y lo que el libro sabe y no sabe al respecto.
Un modelo más grande no es automáticamente mejor para una tarea acotada. Un estudio publicado por primera vez en 2024, y aceptado en EMNLP 2025, compara el ajuste fino, el ajuste por instrucciones, el uso de prompts y el aprendizaje en contexto en ocho modelos de lenguaje y ocho tareas de clasificación de texto. Su resumen concluye que los modelos más grandes no dan de forma consistente un mejor rendimiento ni una menor varianza (arXiv:2402.12819v4). Es un solo estudio, y el libro lo usa para justificar que se mida el modelo más grande, no para descartarlo.
La pregunta abierta es si el de 360M, entrenado con la misma receta que el de 135M, superaría las métricas de desarrollo por un margen que compense su costo adicional. El libro no entrena el de 360M, así que no lo sabe. Tampoco ha medido el tiempo de entrenamiento ni la memoria que requeriría una ejecución con 360M en los dos hilos de CPU que usan los ejemplos del libro. El capítulo 4 usa el de 360M como comparación con los mismos prompts.
Un lector que quiera esa respuesta puede seguir el mismo camino que sigue el libro. El de 360M ya está fijado y carga sin conexión, como muestra el paso de carga. Cuenta los tokens del prompt del enrutador con su tokenizador y luego entrénalo con las mismas filas de entrenamiento que el de 135M. Cada paso es un cambio separado, y la comparación se mantiene sobre los mismos datos, así que los dos resultados pueden compararse lado a lado en la partición de desarrollo.
La familia tiene un modelo aún mayor, el de 1.7B, que requeriría más recursos. El libro no lo fija y no hace ninguna afirmación sobre él.
El costo por mensaje de un modelo más grande se manifiesta con cada mensaje que atiende, y el libro no mide ese costo para el de 360M. El paso de carga ya muestra cuánto más grande es el de 360M antes de que nadie lo entrene, con 135 and 362 millones de parámetros y 30 and 32 capas, siendo primero la cifra del de 135M en cada par. La medición throughput del capítulo 7 compara el clasificador y su copia int8 con el modelo de referencia en una máquina identificada, y el de 360M no aparece en ella.
Las decisiones que tomó este capítulo, para que un lector las verifique según las necesidades de su propio banco:
- El modelo principal es SmolLM2-135M-Instruct, y la comparación es SmolLM2-360M-Instruct.
- Ambos modelos cargan en las confirmaciones indicadas en
examples/models.toml, sin conexión, a través del cargador compartido. - El costo del prompt del enrutador se cuenta en tokens con el tokenizador del modelo de 135M, y ningún modelo se ejecuta para hacer ese conteo.
- Ninguna cifra de tiempo o memoria aparece en este capítulo. Esas cifras llegan después, a partir de una medición en una máquina identificada.
- El de 360M no se entrena en este libro.
La lección que conviene llevar adelante es que un estudio publicado puede decir que un modelo más grande quizá no ayude, y solo tu propia medición, sobre tus propias muestras, dice si lo hace.
Regla práctica: Antes de elegir un modelo más grande, entrénalo con la misma receta que usaste para el más pequeño, y mídelo sobre las mismas muestras de desarrollo y de prueba, en tu propia máquina. Júzgalo por sus métricas y por lo que cuesta ejecutarlo en esa máquina, y no por una puntuación publicada.
Este capítulo, en esta edición
Edición 2026.11.9Ejemplos verificados el 20 de nov de 2026Superan la prueba 3 de 3 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.9.