From 128f7550b51fa52d915f4c466eb81ad610374ccb Mon Sep 17 00:00:00 2001 From: webbrain-one <295484252+webbrain-one@users.noreply.github.com> Date: Sun, 2 Aug 2026 01:35:40 +0300 Subject: [PATCH] docs: add Spanish README --- README.es-ES.md | 145 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 145 insertions(+) create mode 100644 README.es-ES.md diff --git a/README.es-ES.md b/README.es-ES.md new file mode 100644 index 0000000..b3af247 --- /dev/null +++ b/README.es-ES.md @@ -0,0 +1,145 @@ + + +# ⚙️ TokenTally + +### Estima el costo de tokens de tu LLM en varias plataformas y configuraciones + +![cutie](https://github.com/adarshxs/TokenTally/assets/114558126/0f584e00-5bf8-4763-a885-8ca5a7e87ee9) + +🎯El objetivo es poder calcular los **requisitos mínimos de GPU** para **Entrenamiento** (Afinamiento y Preentrenamiento Continuo) e **Inferencia** para cualquier LLM, junto con una comparación para autoalojar estos modelos en diferentes plataformas de nube GPU y optimizaciones. ¡Eventualmente, calcular tokens/$ para todas las combinaciones posibles de Modelo, Plataforma y Optimizaciones! + +Nota: Reconozco que siempre habrá técnicas propietarias/alternativas para reducir los costos de inferencia/entrenamiento en producción. Esto pretende ser un intento ingenuo de **estimar** el costo ;) + +--- + +## Cálculos de Inferencia: + +La fórmula actual para calcular el tamaño mínimo para inferencia y entrenamiento proviene de los hallazgos en [Reducing Activation Recomputation in Large Transformer Models](https://arxiv.org/abs/2205.05198) y fue simplificada por [Transformer Math 101](https://blog.eleuther.ai/transformer-math/) + +### Requisito mínimo de memoria GPU para inferencia: + +``` +Model_size * 1.2 +# según el artículo, donde el 20% es un buen margen para acomodar cualquier sobrecarga +``` + +### Costo por 1,000 tokens - Para el modelo seleccionado + +Para proporcionar una estimación aproximada del costo total de ejecutar un LLM por cada 1000 tokens, se sigue la lógica de https://cursor.sh/blog/llama-inference en la calculadora: + +1. **Obtener entradas del usuario:** + + - Se requieren los siguientes parámetros: + - FLOPs por token + - FLOPs por GPU (TFLOPs) + - Número de GPUs + - Costo por hora (USD) + - Ancho de banda de memoria por GPU (TB/s) + +2. **Calcular tokens por segundo (límite de cómputo):** + + - El número de tokens procesados por segundo cuando el cuello de botella es el cómputo se calcula con la fórmula: + ```python + tokens_p_sec_compute = (flops_per_gpu * num_gpus * 10**12) / (flops_per_token * 10**9) + ``` + +3. **Calcular tokens por segundo (límite de memoria):** + + - El número de tokens procesados por segundo cuando el cuello de botella es la memoria se calcula con la fórmula: + ```python + tokens_p_sec_memory = (memory_bandwidth_per_gpu * num_gpus * 10**12) / (flops_per_token * 10**9) + ``` + +4. **Calcular costo por token:** + + - El costo por token para ambos límites (cómputo y memoria) se determina con la fórmula: + ```python + cost_p_token_compute = cost_per_hour / (3600 * tokens_p_sec_compute) + cost_p_token_memory = cost_per_hour / (3600 * tokens_p_sec_memory) + ``` + +5. **Calcular costo por 1,000 tokens:** + - El costo por 1,000 tokens para ambos límites (cómputo y memoria) se determina con la fórmula: + ```python + cost_p_1k_tokens_compute = cost_p_token_compute * 1000 + cost_p_1k_tokens_memory = cost_p_token_memory * 1000 + ``` + +Al ingresar los parámetros necesarios y hacer clic en el botón "Calcular", la calculadora mostrará el costo estimado por 1,000 tokens de entrada y por 1,000 tokens de salida basado en la lógica anterior. + +--- + +## Cálculos de memoria de Transformer: + +Entrenar modelos transformadores grandes a menudo plantea desafíos en términos de requisitos de memoria GPU. Esta herramienta estima el consumo de memoria dado un rango de parámetros, como el tamaño del modelo, longitud de secuencia, tamaño de lote y configuraciones de paralelización. + +### Componentes clave de memoria: + +1. **Memoria del modelo**: + + - Memoria ocupada por los pesos del modelo. + - Influida por el número de parámetros y sus tipos de datos (p. ej., FP32 vs. FP16). + - Ajustada según las configuraciones de paralelismo, como los grados de paralelismo de tensor y de pipeline. + +2. **Memoria de gradientes**: + + - Memoria necesaria para almacenar gradientes durante la retropropagación. + - Afectada por el número de parámetros, sus tipos de datos y la etapa del optimizador ZeRO. + - Reducida con el paralelismo de pipeline. + +3. **Memoria del optimizador**: + + - Memoria ocupada por los estados del optimizador. + - Para Adam/AdamW de precisión mixta, se almacenan tres copias (parámetros, momento, varianza), lo que significa 12 bytes por parámetro. + - Modificada por la etapa del optimizador ZeRO. + +4. **Memoria de activaciones**: + + - Memoria utilizada para almacenar activaciones durante las pases hacia adelante y hacia atrás. + - Calculada en base a la longitud de la secuencia, tamaño de lote, tamaño oculto y número de capas. + - Puede verse influenciada por técnicas como checkpointing de activaciones y particionamiento de activaciones. + +5. **Memoria de comunicación**: + + - Memoria adicional necesaria para operaciones como all-reduce durante el entrenamiento distribuido. + - Particularmente relevante al usar optimización ZeRO. + +6. **Memoria diversa**: + - Un término de sobrecarga para tener en cuenta otros usos de memoria no contemplados por frameworks de deep learning, bibliotecas de comunicación, etc. + +### Uso + +Para obtener estimaciones de memoria: + +1. Ingresa las configuraciones deseadas del modelo. +2. La herramienta calculará los requisitos de memoria para cada componente y proporcionará una estimación total. + +--- + +## ¡Contribuciones! + +Buscamos contribuciones para implementar la lógica y recopilar datos relevantes de manera colaborativa (crowdsourcing)! + +--- +docs: agregar sección de frameworks de inferencia LLM +Agregar una tabla que liste frameworks populares de inferencia LLM para ayudar a los usuarios a elegir opciones de implementación. Cierra #4 +## 🧠 Frameworks de Inferencia para LLM + +Esta sección destaca algunos de los **frameworks de inferencia** más populares y ampliamente utilizados para ejecutar y optimizar Modelos de Lenguaje Grande (LLM). Estos frameworks ayudan a mejorar la **velocidad**, **eficiencia** y **escalabilidad** al desplegar modelos en producción. + +| 🏷️ Framework | ⚙️ Descripción | +|--------------|----------------| +| **🦙 vLLM** | Motor de inferencia de alto rendimiento y eficiente en memoria, diseñado para servir modelos de lenguaje grande de manera eficiente. | +| **🤗 Text Generation Inference (TGI)** | Servidor de grado producción de Hugging Face optimizado para desplegar y servir grandes modelos transformadores. | +| **⚡ TensorRT-LLM** | Biblioteca de inferencia acelerada de NVIDIA para LLM, que ofrece un rendimiento de baja latencia en GPUs. | +| **🚀 DeepSpeed-Inference** | Extensión de DeepSpeed de Microsoft enfocada en optimizar la inferencia de transformadores para velocidad y memoria. | +| **🧩 ONNX Runtime** | Motor de inferencia multiplataforma que admite modelos exportados en formato ONNX; funciona en CPU, GPU y dispositivos móviles. | +| **📱 MLC LLM** | Framework de código abierto de la comunidad TVM para ejecutar LLM de manera eficiente en diversos hardware (CPU, GPU, móvil). | +| **🧠 OpenVINO** | Kit de herramientas de inferencia de Intel que optimiza y acelera el rendimiento de modelos de deep learning en dispositivos Intel. | +| **🔗 LiteLLM** | Biblioteca ligera de Python que ofrece una API unificada para interactuar con múltiples proveedores de LLM (OpenAI, Anthropic, etc.). | + +> 💡 *Consejo:* Puedes explorar estos frameworks según tus objetivos de despliegue, ya sea optimizando para GPUs, dispositivos edge o entornos multmodelo. + + +Todo el crédito a https://github.com/cloud-gpus/cloud-gpus.github.io de donde tomé prestada la lista de GPUs disponibles y sus precios, https://huggingface.co/spaces/mithril-security/TCO_calculator de donde usé la lógica de TCO y https://gist.github.com/Quentin-Anthony/f43939791a7ceb0b01a4937308317be5 para la lógica de memoria de Transformer tal cual ;) +Y a [Dr. Pratik Desai](https://x.com/chheplo?s=20) por la idea!