Cuantiza el enrutador y mide qué cambia
Unos 18 minutos de lectura, con 2 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, puedes guardar los pesos del backbone del enrutador ajustado como enteros de 8 bits en una sola llamada, contar las predicciones que cambian en una muestra fija y explicar qué muestra y qué no muestra ese recuento. También verás cómo se mide la velocidad y qué encontró la grabación de una máquina.
Una copia cuantizada del enrutador ocuparía menos espacio; la cuestión es si sigue respondiendo igual. El capítulo 5 dejó el enrutador como un solo adaptador, banking77-lora-v1, cuyos pesos son float32. Su umbral de traspaso es 0.63, elegido en la partición de desarrollo según la regla del capítulo 5. Cuantizar guarda los pesos con menos bits. Un modelo cuantizado ocupa menos espacio para sus pesos, y puede devolver respuestas distintas. Este capítulo mide la segunda parte sobre la muestra fija de 200 mensajes de prueba que el capítulo 5 evaluó, test_200. No afirma que cuantizar sea gratuito.
La copia podría ocupar el lugar del adaptador float32 en la bandeja de entrada que enruta los mensajes de soporte del banco, y tres preguntas van antes de hacerlo. ¿Cuántos bytes ocupan los pesos de la copia, comparados con los del adaptador? ¿La copia responde a los mismos mensajes de la misma manera? ¿Y es más rápida en la máquina que sirve la bandeja de entrada? Las dos primeras pueden medirse aquí, a partir de las formas del modelo y de una muestra fija. La tercera proviene de una grabación en una máquina identificada por su nombre, y la sección sobre velocidad explica qué encontró esa grabación y qué no cubre. Cada respuesta es un recuento con su denominador, o una razón con sus datos de entrada indicados.
Una sola llamada para cuantizar las capas lineales
Una capa lineal es una matriz de pesos que transforma un vector en otro. El backbone del router está formado por ellas. Cuantizar una capa significa almacenar cada uno de sus pesos como un entero de 8 bits, con una escala que convierte los enteros de nuevo en valores flotantes aproximados. Menos bits por peso significan menos bytes para la capa, y las respuestas pueden cambiar, porque los valores que calcula la capa ya no son los exactos.
La escala es lo que hace que el esquema funcione para una matriz completa. Una única escala para toda la matriz tiene que cubrir su peso más grande, de modo que las filas cuyos pesos son pequeños reciben una cuadrícula gruesa. Jacob et al. (2018) informan de que una resolución compartida da a los canales con rangos estrechos un error relativo mucho mayor (arXiv:1712.05877). Ese es un resultado de redes convolucionales, así que aquí es una razón para probar escalas por fila, no una medición. Una escala por fila permite que cada fila de salida use todo el rango de los enteros de 8 bits para sus propios pesos. Por eso el recuento de bytes suma una escala float32 por cada fila de salida. Las escalas son pocas, pero no son gratuitas, así que el recuento de bytes que aparece más abajo las incluye.
El auxiliar de este libro, int8_classifier, nombra su esquema en su docstring: pesos int8 por fila, con activaciones float32. El esquema es Int8WeightOnlyConfig de torchao, que el código fuente de torchao en v0.18.0 describe como "cuantización simétrica por canal, solo de pesos int8, aplicada a capas lineales". El auxiliar lo aplica en tres pasos. Primero fusiona los pesos del adaptador con el modelo base mediante merge_and_unload de PEFT. Después llama a quantize_ desde torchao.quantization con Int8WeightOnlyConfig, y pasa un filtro que selecciona cada capa nn.Linear excepto la que se llama score. Por último, devuelve el modelo en modo de evaluación. La copia int8, llamada banking77-lora-v1-int8 en las grabaciones, es el modelo que devuelve el auxiliar: un modelo derivado construido a partir del adaptador, no un segundo adaptador. La capa de salida, score, es el cabezal que entrenó el capítulo 5, y la sección sobre ella explica por qué el auxiliar la deja fuera.
La fusión va primero por una razón. El capítulo 5 describió el adaptador como un pequeño conjunto de matrices junto a las capas del modelo base. Fusionar pliega la actualización del adaptador en los pesos base, de modo que cada capa es una única matriz de pesos, cuantizada una vez, y el número de capas describe el router. Sin la fusión, la misma llamada también cuantizaría las matrices propias del adaptador como capas int8 separadas.
El código de PyTorch más antiguo usa torch.ao.quantization.quantize_dynamic, que también almacena los pesos Linear como int8, pero cuantiza las activaciones mientras se ejecuta, un esquema distinto. PyTorch 2.15 lo marca como obsoleto, y su advertencia apunta a quantize_ de torchao (PyTorch v2.15.0, torch/ao/quantization/utils.py), que el README de torchao en v0.18.0 muestra como la migración. Los ejemplos de este libro no llaman por sí mismos a ninguna API obsoleta.
1"""Counts the backbone Linear layers the int8 copy quantizes, and the weight bytes they store, from their shapes.2The prose's saving rests on the last printed line, the int8 share of float32 weight bytes; the head assert checks that the score head is not quantized."""34import os56os.environ["HF_HUB_OFFLINE"] = "1"7os.environ["TRANSFORMERS_OFFLINE"] = "1"89import torch # noqa: E4021011torch.set_num_threads(2) # the counts come from shapes, so the thread count changes no printed line1213import router_lib # noqa: E4021415router_lib.setup_runtime() # fixes the seeds, requires deterministic algorithms and sets float32 as the default dtype16RECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"1718_, model = router_lib.int8_classifier(RECORDED / "adapter") # merges the adapter, then quantizes every backbone Linear, not score19layers = router_lib.backbone_linears(model) # (name, layer) pairs, all except score20quantized = [layer for _, layer in layers if router_lib.is_int8(layer)] # a torchao int8 weight, not a float one21weights = sum(layer.weight.numel() for _, layer in layers)22rows = sum(layer.weight.shape[0] for _, layer in layers) # weight shape is (output rows, input size)2324print(f"backbone Linear layers: {len(layers)}")25print(f"backbone Linear layers quantized to int8: {len(quantized)}")26head_quantized = router_lib.is_int8(model.score)27assert not head_quantized, "the score head must stay float32"28print(f"score head quantized: {'yes' if head_quantized else 'no'}")29print(f"score head weight dtype: {model.score.weight.dtype}")30print(f"weights in backbone Linear layers: {weights}")31print(f"output rows in backbone Linear layers: {rows}")32float_bytes = 4 * weights33int8_bytes = 1 * weights + 4 * rows # one byte a weight, plus one float32 scale (4 bytes) for each output row34print(f"weight bytes, int8 as a share of float32: {int8_bytes / float_bytes:.1%}")
python int8-layers-and-bytes.pybackbone Linear layers: 210
backbone Linear layers quantized to int8: 210
score head quantized: no
score head weight dtype: torch.float32
weights in backbone Linear layers: 106168320
output rows in backbone Linear layers: 155520
weight bytes, int8 as a share of float32: 25.1%
Construir la copia int8 y contar sus capas y sus pesos muestra lo que cuantizó el auxiliar. El backbone tiene 210 capas lineales, y la copia int8 cuantiza 210 de ellas. Esas capas contienen 106168320 pesos, distribuidos en 155520 filas de salida.
La última línea es aritmética sobre formas, no una medición de un archivo ni de un proceso. Un peso float32 ocupa 4 bytes. Un peso int8 ocupa 1 byte, y el cálculo suma una escala float32, 4 bytes, por cada fila de salida, porque esa es la convención que nombra el esquema del auxiliar. Sobre los pesos de esas capas, la copia int8 ocupa 25.1% de los bytes float32. Una cuarta parte corresponde a los propios pesos, y el resto a las escalas. La cifra cubre solo los pesos de estas capas. Deja fuera cualquier otro tensor que contenga el modelo, así que no dice nada sobre el tamaño de un archivo en disco ni sobre la memoria que usa el router en ejecución.
Los bytes importan en la máquina de servicio solo si su memoria tiene que contener los pesos. Que lo haga depende de la máquina y del resto del proceso, algo que este capítulo no mide. La proporción indica cuánto del presupuesto de pesos libera la copia.
Al importar torchao se imprimen advertencias en la salida de error estándar, y la primera ejecución de un ejemplo puede imprimir un informe de carga de transformers. Proceden del código de importación de las propias bibliotecas, no de una llamada que hagan los ejemplos, y nada en los ejemplos las suprime ni actúa sobre ellas. Algunas líneas dicen que torchao no pudo cargar sus bibliotecas de núcleos exclusivas de GPU, que la ruta de CPU no usa. Un SyntaxWarning del código fuente propio de torchao aparece solo en la primera importación, antes de que Python guarde en caché el bytecode. Los avisos de que register_constant() está obsoleto provienen de torch y se disparan con la importación de torchao. El informe de carga enumera score.weight como MISSING: el punto de control base no tiene cabezal de clasificación, así que transformers inicia uno nuevo, y el cabezal guardado del adaptador lo reemplaza. Ninguno de estos mensajes cambia una sola línea de salida. El libro fija torchao en 0.18.0 en su archivo de requisitos, y todos los ejemplos usan esa versión fijada.
Regla práctica: cuantiza solo las capas que puedas nombrar, deja la capa de salida en float32 y cuenta los bytes a partir de las formas antes de afirmar cualquier ahorro. Informa el ahorro como una proporción de bytes de pesos, junto al recuento de capas, y nunca como tamaño de archivo ni como velocidad.
Cuenta las predicciones que cambian
La cuantización cambia los números que calcula cada capa, así que las respuestas también pueden cambiar. La prueba de una copia cuantizada es si responde igual que la original a los mismos mensajes.
Al puntuar test_200 con ambas copias en el umbral del manifiesto del capítulo 5 se ve si responden de manera parecida. Para cada copia, la ejecución cuenta las respuestas correctas, las derivaciones y la exactitud en los mensajes que no se derivan. Después cuenta los mensajes cuyo equipo difiere entre las dos copias, y las decisiones de derivación que difieren. La misma ejecución, int8-changed-predictions, también puntúa una tercera copia, con la cabeza también cuantizada, para la sección sobre la cabeza de puntuación.
Las dos copias no se tratan igual a propósito. El lado float32 es el adaptador tal como lo cargó el capítulo 5, sin fusionar, mientras que el lado int8 se fusiona primero, porque el asistente fusiona antes de cuantizar. Así, el conteo que sigue incluye la fusión y la cuantización juntas. La ejecución nunca puntúa una copia float32 fusionada por separado, y el capítulo no afirma que la fusión por sí sola no cambie nada.
1"""Scores test_200 with the float32 adapter, its int8 copy and the copy with the head in int8, at the threshold in chapter 5's manifest.2The prose's point rests on the line that counts predictions changed by int8, read with the hand-off line under it."""34import os56os.environ["HF_HUB_OFFLINE"] = "1"7os.environ["TRANSFORMERS_OFFLINE"] = "1"89import json # noqa: E4021011import torch # noqa: E4021213torch.set_num_threads(2) # two threads for these forward passes; the speed section's recording uses four1415import router_lib # noqa: E4021617router_lib.setup_runtime() # fixes the seeds, requires deterministic algorithms and sets float32 as the default dtype18RECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"19threshold = json.loads((RECORDED / "manifest.json").read_text())["handoff_threshold"] # chosen on dev in chapter 5, stored in the manifest20test = router_lib.read_rows("test") # (text, label index) pairs21sample = router_lib.read_sample("test_200") # fixed row indices, so every copy scores the same messages22golds = [test[i][1] for i in sample] # index 1 of each row is its gold team23texts = [test[i][0] for i in sample]2425tokenizer, float_model = router_lib.load_classifier(RECORDED / "adapter") # the adapter as chapter 5 loaded it, unmerged26float_preds, float_confs = router_lib.classify_by_length(float_model, tokenizer, texts) # results in the order of texts27_, int8_model = router_lib.int8_classifier(RECORDED / "adapter") # merged first, then backbone quantized, head float3228int8_preds, int8_confs = router_lib.classify_by_length(int8_model, tokenizer, texts)29_, head_model = router_lib.int8_classifier_all_linears(RECORDED / "adapter") # as above, with the score head quantized too30head_preds, head_confs = router_lib.classify_by_length(head_model, tokenizer, texts)3132print(f"handoff threshold from manifest: {threshold:.2f}")33print(f"messages on test_200: {len(texts)}")34router_lib.print_copy_report("float32", float_preds, float_confs, golds, threshold) # a handed-off message is wrong if its team is wrong; the last measure divides by kept messages only35router_lib.print_copy_report("int8", int8_preds, int8_confs, golds, threshold)36changed, handoffs = router_lib.count_changes(float_preds, float_confs, int8_preds, int8_confs, threshold) # a changed prediction is a different team, handed off or not; a changed hand-off is a confidence on the other side of the threshold37print(f"predictions changed by int8: {changed}/{len(texts)} ({changed / len(texts):.1%})")38print(f"hand-off decisions changed by int8: {handoffs}/{len(texts)}")39changed_head, _ = router_lib.count_changes(float_preds, float_confs, head_preds, head_confs, threshold)40print(f"predictions changed with the head in int8 too: {changed_head}/{len(texts)}")
python int8-changed-predictions.pyhandoff threshold from manifest: 0.63
messages on test_200: 200
float32 accuracy on test_200: 172/200 (86.0%)
float32 handed off: 33/200 (16.5%)
float32 accuracy on messages not handed off: 156/167 (93.4%)
int8 accuracy on test_200: 172/200 (86.0%)
int8 handed off: 33/200 (16.5%)
int8 accuracy on messages not handed off: 156/167 (93.4%)
predictions changed by int8: 0/200 (0.0%)
hand-off decisions changed by int8: 0/200
predictions changed with the head in int8 too: 1/200
En esta muestra, la copia int8 cambia 0/200 (0.0%) predicciones y 0/200 decisiones de derivación. La copia que también cuantiza la cabeza se cuenta en la sección sobre la cabeza de puntuación. La salida junto a este párrafo indica la exactitud de cada copia, sus derivaciones y su exactitud en los mensajes que no se derivan, cada una con su denominador.
Las tres medidas son las que definió el capítulo 2, y cada una tiene su denominador. La exactitud divide los mensajes correctos entre los 200, así que un mensaje derivado cuenta como erróneo si su equipo es incorrecto. La tasa de derivación divide los mensajes por debajo del umbral entre los 200. La exactitud en los mensajes no derivados divide los correctos entre los mensajes conservados, y no está definida cuando no se conserva ninguno. El conteo de predicciones cambiadas usa los mismos 200 mensajes y responde una pregunta que las tres medidas no responden: ¿coincidieron las dos copias en cada uno? La coincidencia no es corrección, por eso la salida también imprime la exactitud.
Una predicción cambiada no es automáticamente una pérdida. Puede convertir un equipo incorrecto en uno correcto, o un equipo correcto en uno incorrecto, y el conteo por sí solo no dice cuál de los dos ocurre. Para leer la dirección, compara el equipo de cada copia con la etiqueta de referencia en cada mensaje en el que las copias no coinciden. La exactitud puede ocultar esto. Dos copias pueden tener la misma exactitud mientras aciertan mensajes distintos, así que el mismo total no dice nada sobre qué mensajes cambiaron de equipo. Cuando el conteo es cero, no hay cambios que leer en ninguna dirección. Un lector que obtenga un conteo distinto de cero debe leer los cambios antes que los totales.
Un cambio tiene un costo concreto cuando una copia atiende la cola. Supón que el adaptador float32 envía un mensaje a card_arrival y la copia int8 envía ese mismo mensaje a card_delivery_estimate. Ambos son equipos, y solo uno puede ser la etiqueta de referencia del mensaje, así que el cambio corrige una respuesta o rompe una, a menos que ambos equipos estén equivocados. La bandeja envía el mensaje a un equipo de todos modos. El cambio llegaría al personal de soporte que trabaja en la cola de ese equipo, y nadie lo vería en un total. El conteo es lo que hace visible ese cambio antes de que la copia atienda cualquier mensaje.
Lee el conteo de predicciones cambiadas como un resultado de un adaptador con un umbral, no como una garantía. Otra muestra, otro adaptador o otro umbral podrían mostrar un cambio, y una muestra de 200 puede pasar por alto un cambio raro en un flujo completo de mensajes.
El conteo trata solo de predicciones y nada más. La copia también mantiene sus activaciones en float32, como indica la documentación del asistente, así que este conteo no dice nada sobre una copia que también cuantice las activaciones. Este capítulo no mide esa copia.
Regla práctica: Cuenta las predicciones cambiadas en los mismos mensajes, con el mismo umbral, para ambas copias, e imprime cada conteo con su denominador junto a la exactitud y el conteo de derivaciones. Cuando el conteo sea cero, repórtalo como cero en esa muestra, y nombra la muestra y el adaptador de los que se tomó.
Mantén la cabeza de puntuación en float32
La cabeza de puntuación es la capa con 77 salidas, una para cada equipo. Su softmax da la confianza que el capítulo 5 compara con el umbral, y su probabilidad más alta es el equipo que devuelve el enrutador. El ayudante deja la cabeza fuera de la llamada, así que la cabeza sigue en float32. Esta sección explica por qué el libro toma esa decisión y qué muestra el recuento que la respalda.
La copia que sirve este capítulo mantiene su cabeza en float32, y esa elección descansa en un solo recuento, obtenido de int8-changed-predictions. Con la cabeza también en int8, 1/200 predicciones cambian en esta muestra. El recuento no ordena las capas por sensibilidad, y el capítulo no afirma que la cabeza sea, o no sea, el origen de un cambio.
Los mensajes en riesgo son los que tienen una confianza algo por encima del umbral. Un cambio en la cabeza puede hacer que uno de ellos caiga por debajo, y entonces el mensaje se envía a una persona en lugar de a un equipo. El recuento de decisiones de traspaso cambiadas en la sección anterior muestra si una copia cambia alguna, y en esta ejecución la copia int8 cambia 0/200 decisiones de traspaso.
Lo que el ayudante hizo con la cabeza aparece en int8-layers-and-bytes. La cabeza no se cuantiza, como afirma ese ejemplo, y sus pesos son torch.float32. Esas líneas impresas provienen de la misma ejecución que los recuentos de capas de la primera sección, así que ambos resultados pueden compararse directamente.
El recuento de predicciones cambiadas abarca toda la copia int8 y la copia con la cabeza cuantizada también. No desglosa ninguna de las dos capa por capa, de modo que no puede indicar de qué capa proviene un cambio. Para encontrarlo hay que cuantizar una capa a la vez y volver a contar en la partición de desarrollo.
Regla práctica: Mantén la cabeza de puntuación en float32, salvo que un recuento en la partición de desarrollo, con el umbral elegido, muestre que una cabeza cuantizada no cambia ningún equipo ni ningún traspaso en los que confíes. Indica con qué umbral hiciste el recuento.
Mide la velocidad en una grabación
Tener menos bytes para los pesos no hace por sí solo que un modelo sea más rápido, y este capítulo no afirma que lo haga. Que la copia int8 calcule más rápido en una CPU dada depende de las rutinas aritméticas que se ejecutan en esa CPU, así que el libro lo mide en una máquina concreta y con nombre.
Ningún ejemplo imprime un tiempo. Un tiempo cambia según la máquina y la carga que tenga, así que un ejemplo que imprimiera uno daría una salida distinta en cada ejecución, y los ejemplos del libro tienen que dar siempre la misma salida. Una razón de velocidad debe ir, en cambio, en una grabación.
El int8 solo de pesos ahorró bytes de pesos, y si la copia además calcula más rápido en una CPU es una pregunta aparte. La grabación throughput la comprueba. Mide el tiempo de la copia int8 de este capítulo, banking77-lora-v1-int8, construida con el mismo auxiliar que usan los ejemplos, frente al adaptador en float32 y frente al modelo de referencia, en la máquina indicada en su manifiesto. En esa máquina, con cuatro hilos y lotes de 16, la copia int8 procesó 0.9 veces los mensajes por segundo del clasificador en float32, así que la grabación no ofrece ninguna razón de velocidad para servir int8. Capítulo 10 informa de las tasas junto con la máquina en la que se midieron. La grabación no midió el modelo de 360M, y este capítulo no afirma ninguna velocidad para otra máquina que no sea esa.
Una grabación de ese tipo fija su modelo y sus entradas, las ejecuta una vez en la máquina indicada y guarda las salidas junto con un manifiesto que nombra el script. Los ejemplos que usan una grabación leen sus salidas guardadas y no ejecutan el modelo ellos mismos. Para la comparación de velocidad, la grabación pasa los mismos mensajes por ambas copias, con el mismo número de hilos para cada una, y guarda el tiempo de cada copia como salida propia. La razón se calcula a partir de esas salidas guardadas, y el lector puede ver la máquina y el número de hilos junto a ella. Quien quiera la razón para su propia máquina debe ejecutar la misma grabación allí e informar de la máquina junto con el resultado.
Regla práctica: Lee una razón de velocidad solo de una grabación que nombre la máquina en la que se ejecutó, y nunca la deduzcas de los bytes de los pesos. La razón de arriba describe solo su propia máquina, así que ejecuta la grabación en la máquina en la que vas a servir antes de tomarla como tu velocidad.
Decidir con el traspaso a la vista
La decisión es qué copia sirve el enrutador. Capítulo 8 sirve por defecto el adaptador float32, y nada en este capítulo cambia ese valor por defecto. El recuento de predicciones cambiadas de la copia int8 es 0/200 (0.0%), y su recuento de decisiones de traspaso cambiadas es 0/200. Un recuento de cero mantiene la copia como candidata. El ahorro que ofrece es una proporción de bytes de pesos en algunas capas. La grabación no encontró ninguna ganancia de velocidad para la copia int8 en su máquina, y el libro no tiene ninguna necesidad de memoria medida que la favorezca, así que una copia sin respuestas cambiadas en este recuento y sin ganancia medida no tiene, por ahora, nada que la recomiende.
Mantener float32 es una elección con un costo. El adaptador ocupa más bytes que su copia int8, y en una máquina pequeña eso puede importar. Lo que el libro ha mostrado es más acotado. En esta muestra, el recuento de predicciones cambiadas es 0/200 (0.0%), y solo un recuento de cero elimina el cambio de predicciones como razón para rechazar la copia. Las razones restantes son unas que este capítulo no ha medido, así que deciden el valor por defecto. Si una grabación en la máquina de servicio muestra una ganancia de velocidad que importe, y se mide una necesidad de memoria, el caso para int8 pasa a ser un caso de ingeniería con un riesgo contado. Hasta entonces, el adaptador float32 es el que tiene menos preguntas abiertas.
El traspaso es la parte que hay que vigilar. El capítulo 5 eligió su umbral para que la exactitud en los mensajes no traspasados alcance su objetivo en el conjunto de desarrollo. Una copia cuyas confianzas se mueven aunque sea un poco puede traspasar un conjunto distinto de mensajes, y entonces el umbral deja de hacer lo que se eligió para que hiciera. Por eso el recuento de predicciones cambiadas se toma en el umbral elegido, y por eso el recuento de traspasos aparece junto a él. Las mismas medidas se aplican a cualquier adaptador cuantizado, como un v2 reentrenado.
Una copia cuantizada falla en producción por un cambio que nadie contó. Una actualización de la biblioteca puede cambiar la aritmética, y un cambio en la mezcla de mensajes puede mover algunos al otro lado del umbral. Vuelve a contar en el conjunto de desarrollo cada vez que cambien las bibliotecas o los mensajes, y antes de que una copia cuantizada sirva su primer mensaje.
Los mismos pasos se aplican a una copia cuantizada del enrutador propio de un lector, y no necesitan nada de este libro más allá de las muestras y el umbral. Toma el umbral del manifiesto del adaptador, y comprueba que el manifiesto indica que se eligió en el conjunto de desarrollo. Cuantiza el modelo base y deja la cabeza en float32, como hace el asistente. Puntúa la muestra fija con ambas copias, y cuenta la exactitud, los traspasos, la exactitud en los mensajes no traspasados y las predicciones cambiadas, cada una con su denominador. Lee los cambios en cada dirección antes de leer los totales. Luego vuelve a contar en el conjunto de desarrollo en el umbral elegido, porque el umbral se eligió allí. Una copia que supera estos pasos todavía tiene que tener su velocidad y su memoria medidas en una grabación antes de reemplazar al adaptador float32.
Regla práctica: Sirve el adaptador float32 por defecto. Considera la copia int8 solo cuando una grabación en la máquina de servicio señale una ganancia de velocidad, una necesidad de memoria medida la favorezca, y entonces cuenta sus predicciones cambiadas en el conjunto de desarrollo con el umbral elegido antes de que sirva cualquier mensaje.
Este capítulo, en esta edición
Edición 2026.11.9Ejemplos verificados el 20 de nov de 2026Superan la prueba 2 de 2 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.9.