Volver al blog
General

Cálculo de Tokens en Modelos de Lenguaje Grande: Una Aproximación Práctica y Comparativa

La gestión eficiente de tokens es un pilar fundamental en el desarrollo de aplicaciones que integran Modelos de Lenguaje Grande (LLMs). La tokenización, el proc...

20 de abril de 202612 min read

Cálculo de Tokens en Modelos de Lenguaje Grande: Una Aproximación Práctica y Comparativa

La gestión eficiente de tokens es un pilar fundamental en el desarrollo de aplicaciones que integran Modelos de Lenguaje Grande (LLMs). La tokenización, el proceso de dividir el texto en unidades manejables por el modelo, tiene implicaciones directas en el coste, la latencia y la capacidad contextual. Anthropic, con sus modelos Claude, ha puesto un énfasis particular en la transparencia y control sobre este aspecto. Este artículo profundiza en las metodologías para calcular tokens en la familia de modelos Claude, ofreciendo una perspectiva comparativa con otros LLMs populares y presentando un enfoque práctico para la implementación.

1. Comprendiendo la Tokenización y su Importancia

Antes de adentrarnos en las especificidades de Claude, es crucial entender qué son los tokens y por qué su conteo es vital. Los LLMs no procesan texto directamente. En su lugar, utilizan "tokens", que son subunidades de palabras, caracteres o secuencias de caracteres. La forma en que un modelo tokeniza el texto depende de su "tokenizador" subyacente, que es un componente crítico entrenado junto con el propio modelo.

Las implicaciones de un conteo de tokens preciso son multifacéticas:

  • Coste: La mayoría de los servicios de LLMs cobran por el número de tokens procesados, tanto para la entrada (prompt) como para la salida (respuesta). Un conteo erróneo puede llevar a sobrecostes inesperados o a subutilización de recursos.
  • Latencia: El tiempo que tarda un modelo en procesar una solicitud está intrínsecamente ligado al número de tokens. Un prompt más largo o una generación de respuesta más extensa incrementan el tiempo de respuesta.
  • Ventana de Contexto: Cada LLM tiene una ventana de contexto máxima, medida en tokens. Exceder este límite truncará la entrada o la salida, limitando la capacidad del modelo para recordar información o generar respuestas coherentes en conversaciones largas.
  • Calidad de la Respuesta: La forma en que se tokeniza un texto puede influir sutilmente en la comprensión y generación del modelo. Por ejemplo, la tokenización de código o lenguajes poco comunes puede presentar desafíos.

2. El Enfoque de Anthropic: Claude Tokenization

Anthropic ha adoptado un enfoque relativamente sencillo para la tokenización en sus modelos Claude. A diferencia de otros modelos que pueden utilizar tokenizadores más complejos con vocabularios muy extensos, Claude tiende a usar una estrategia que se alinea de cerca con la tokenización BPE (Byte Pair Encoding) o variantes similares, donde los tokens pueden corresponder a palabras completas, partes de palabras o caracteres individuales.

Un punto clave a destacar es la consistencia y la disponibilidad de herramientas para interactuar con la tokenización de Claude. La API de Anthropic suele proporcionar información detallada sobre el uso de tokens para cada llamada.

2.1 Herramientas y Métodos de Cálculo para Claude

Anthropic proporciona herramientas directas para ayudar a los desarrolladores a estimar y calcular el número de tokens en sus prompts. La forma más directa de obtener esta información es a través de las respuestas de la API. Sin embargo, para fines de desarrollo y optimización previa, es útil poder calcular esto de forma independiente.

Una estrategia común es utilizar bibliotecas proporcionadas por el proveedor del modelo o modelos de tokenizadores de código abierto que emulan el comportamiento del modelo. Para Claude, Anthropic ha publicado herramientas y guías que, implícitamente o explícitamente, nos permiten calcular el conteo de tokens.

La biblioteca tiktoken de OpenAI, aunque diseñada para modelos de OpenAI, es un excelente punto de partida para entender la mecánica de los tokenizadores BPE. Claude utiliza un tokenizador propio, pero el concepto subyacente es similar. Anthropic a menudo recomienda usar su propio modelo de tokenizador si se requiere una precisión absoluta en entornos locales, o confiar en los contadores de tokens que la API proporciona como parte de la respuesta.

Ejemplo de Cálculo (Conceptual con tiktoken):

Aunque tiktoken es para OpenAI, la estructura de uso es similar para cualquier tokenizador basado en BPE. Para Claude, tendríamos que usar un tokenizador específico de Anthropic si estuviera disponible públicamente y fuera compatible.

# Este es un ejemplo conceptual. Se necesitaría un tokenizador específico de Anthropic
# o una herramienta proporcionada por ellos para un cálculo exacto para Claude.

# Asumiendo que existiera un tokenizador de Claude llamado 'claude_tokenizer'
# de una hipotética biblioteca 'anthropic_tokenizers'

# from anthropic_tokenizers import ClaudeTokenizer

# tokenizer = ClaudeTokenizer("claude-3-opus-20240229") # Ejemplo de nombre de modelo

# prompt_text = "This is a sample prompt to count tokens for Claude."
# num_tokens = tokenizer.encode(prompt_text)
# print(f"Number of tokens: {len(num_tokens)}")

La realidad es que, para una precisión garantizada con los modelos de Claude, la mejor práctica es ejecutar el prompt a través de la API y observar el recuento de tokens devuelto en la respuesta de la API. Anthropic suele incluir un campo usage en las respuestas que detalla los tokens de entrada y salida.

{
  "id": "msg_...",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Here is the generated response."
    }
  ],
  "model": "claude-3-opus-20240229",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 15,
    "output_tokens": 10
  }
}

En este ejemplo, input_tokens representa el número de tokens en el prompt enviado, y output_tokens representa el número de tokens en la respuesta generada por el modelo.

2.2 Comparativa de Modelos de Tokenización

La forma en que diferentes LLMs tokenizan el texto puede variar significativamente, afectando el número de tokens para el mismo fragmento de texto. Esta variabilidad es crucial al migrar o comparar soluciones entre plataformas.

GPT (OpenAI): Los modelos de OpenAI, hasta GPT-4, utilizan el tokenizador tiktoken. Este tokenizador es conocido por su eficiencia y por cómo maneja el texto en inglés. Por ejemplo, una palabra común en inglés puede ser un único token, mientras que palabras más largas o con guiones pueden dividirse. La tokenización de código y texto en otros idiomas puede diferir.

LLaMA (Meta): Los modelos LLaMA utilizan un tokenizador SentencePiece, que a menudo es más granular que BPE en inglés y puede ser más efectivo para idiomas que no son inglés o para la tokenización de código.

Claude (Anthropic): Como se mencionó, Claude utiliza su propio tokenizador. La información pública sugiere que su enfoque es robusto para una variedad de textos, incluyendo código y lenguaje natural. Sin embargo, es común observar que, para el mismo prompt en inglés, Claude tiende a usar un número ligeramente diferente de tokens en comparación con GPT.

Estudio Comparativo (Ejemplo Hipotético):

Consideremos el siguiente fragmento de texto:

"The quick brown fox jumps over the lazy dog."

  • Claude: Podría tokenizar esto en, digamos, 9-11 tokens.
  • GPT (tiktoken): Similarmente, probablemente entre 9-11 tokens.
  • LLaMA (SentencePiece): Podría ser ligeramente diferente, quizás 10-12 tokens.

Ahora, un fragmento de código:

def greet(name):
  print(f"Hello, {name}!")
  • Claude: La tokenización del código es un área donde las diferencias se vuelven más pronunciadas. Los espacios, la indentación y los caracteres especiales se manejan de maneras distintas. El número de tokens podría ser significativamente diferente.
  • GPT (tiktoken): Tiktoken maneja el código razonablemente bien, pero la indentación y los saltos de línea son tokens.
  • LLaMA (SentencePiece): SentencePiece, al ser más agnóstico al lenguaje, puede ser más predecible con la tokenización de código y caracteres especiales.

Implicaciones Prácticas de la Comparación:

  • Estimación de Costos: Si estás migrando una aplicación de GPT a Claude, no asumas que el coste por token será idéntico. Es necesario recalcular el uso de tokens para tus prompts típicos.
  • Optimización de Ventana de Contexto: Si tus prompts están cerca del límite de contexto de un modelo, la diferencia en tokenización entre modelos puede ser crítica. Un prompt que encaja en Claude podría exceder el límite en GPT, o viceversa.
  • Selección del Modelo: La eficiencia en la tokenización puede ser un factor menor pero contribuyente en la elección del modelo para cargas de trabajo específicas.

3. Cálculo de Tokens con Modelos Comparativos (Enfoque Práctico)

Para realizar comparaciones prácticas y obtener recuentos de tokens precisos para Claude y otros modelos, es necesario recurrir a las herramientas específicas de cada proveedor o a implementaciones de código abierto que emulen sus tokenizadores.

3.1 Utilizando la API de Anthropic

La forma más fiable de conocer el número de tokens para Claude es realizar una llamada a la API y examinar el campo usage en la respuesta.

Ejemplo de Código Python para llamar a la API de Anthropic y obtener conteo de tokens:

import anthropic

# Asegúrate de configurar tu clave API de Anthropic
# export ANTHROPIC_API_KEY='tu_clave_api'

client = anthropic.Anthropic()

prompt_text = """
The following is a conversation between a user and an AI assistant.
User: What is the capital of France?
AI: The capital of France is Paris.
User: What is the population of Paris?
AI: The population of Paris is approximately 2.1 million people.
"""

try:
    message = client.messages.create(
        model="claude-3-opus-20240229",  # O cualquier otro modelo Claude 3
        max_tokens=100,
        messages=[
            {
                "role": "user",
                "content": prompt_text
            }
        ]
    )
    print(f"Modelo: {message.model}")
    print(f"Tokens de entrada: {message.usage.input_tokens}")
    print(f"Tokens de salida: {message.usage.output_tokens}")
    print(f"Respuesta del modelo: {message.content[0].text}")

except anthropic.APIConnectionError as e:
    print(f"Error de conexión a la API: {e}")
except anthropic.RateLimitError as e:
    print(f"Error de límite de tasa: {e}")
except anthropic.APIStatusError as e:
    print(f"Error de estado de la API: {e.status_code} - {e.response}")
except Exception as e:
    print(f"Ocurrió un error inesperado: {e}")

Este código demuestra cómo obtener el recuento de tokens de entrada (input_tokens) y salida (output_tokens) para una solicitud específica enviada a la API de Anthropic.

3.2 Utilizando tiktoken para Modelos OpenAI

Para comparar con modelos de OpenAI, tiktoken es la herramienta estándar.

Ejemplo de Código Python para contar tokens con tiktoken:

import tiktoken

def num_tokens_from_string(string: str, encoding_name: str) -> int:
    """Returns the number of tokens in a text string using a specific encoding."""
    encoding = tiktoken.get_encoding(encoding_name)
    num_tokens = len(encoding.encode(string))
    return num_tokens

# Ejemplos de encodings para modelos de OpenAI
encoding_gpt35 = "cl100k_base"  # Usado por gpt-3.5-turbo, gpt-4, text-embedding-ada-002
encoding_gpt4 = "cl100k_base"   # gpt-4 usa el mismo encoding que gpt-3.5-turbo
encoding_old = "p50k_base"      # Usado por Codex models, text-davinci-002, text-davinci-003

prompt_text = "The quick brown fox jumps over the lazy dog."

print(f"Texto: '{prompt_text}'")
print(f"Tokens (cl100k_base): {num_tokens_from_string(prompt_text, encoding_gpt35)}")

code_snippet = """
def greet(name):
  print(f"Hello, {name}!")
"""
print(f"\nCódigo: '{code_snippet}'")
print(f"Tokens (cl100k_base): {num_tokens_from_string(code_snippet, encoding_gpt35)}")

Este código permite calcular el número de tokens para un texto dado utilizando el tokenizador cl100k_base, que es el utilizado por la mayoría de los modelos modernos de OpenAI.

3.3 Utilizando tokenizers de Hugging Face para Otros Modelos

Para modelos como LLaMA y otros disponibles en Hugging Face, la biblioteca tokenizers es la herramienta adecuada.

Ejemplo de Código Python para contar tokens con tokenizers (ejemplo con LLaMA):

from transformers import AutoTokenizer

# Asegúrate de tener instalada la librería transformers
# pip install transformers sentencepiece

# Ejemplo usando el tokenizador de LLaMA-2
# Puedes cambiar el nombre del modelo por otro si es necesario
model_name = "meta-llama/Llama-2-7b-hf" # Requiere autenticación en Hugging Face

try:
    tokenizer = AutoTokenizer.from_pretrained(model_name)

    prompt_text = "The quick brown fox jumps over the lazy dog."
    tokens = tokenizer.encode(prompt_text)
    print(f"Texto: '{prompt_text}'")
    print(f"Tokens (LLaMA): {len(tokens)}")
    # print(f"Tokens decodificados: {tokenizer.convert_ids_to_tokens(tokens)}")

    code_snippet = """
def greet(name):
  print(f"Hello, {name}!")
"""
    tokens_code = tokenizer.encode(code_snippet)
    print(f"\nCódigo: '{code_snippet}'")
    print(f"Tokens (LLaMA): {len(tokens_code)}")
    # print(f"Tokens decodificados: {tokenizer.convert_ids_to_tokens(tokens_code)}")

except Exception as e:
    print(f"Error al cargar o usar el tokenizador de Hugging Face: {e}")
    print("Asegúrate de tener los modelos correctos descargados o de estar autenticado en Hugging Face.")

Este ejemplo muestra cómo se puede utilizar la biblioteca transformers de Hugging Face para cargar un tokenizador específico (en este caso, para LLaMA) y contar los tokens de un texto o código.

4. Consideraciones Avanzadas y Buenas Prácticas

4.1 Tokenización de Diferentes Tipos de Datos

  • Lenguaje Natural: La tokenización del lenguaje natural es relativamente predecible, aunque varía entre idiomas y dialectos.
  • Código: La tokenización de código es particularmente sensible. Los espacios en blanco, tabulaciones, saltos de línea y caracteres especiales pueden tener un impacto significativo en el conteo de tokens. Algunos tokenizadores son mejores que otros para mantener la estructura del código.
  • Markdown y Formato: El texto formateado (como Markdown) también puede ser tokenizado de forma inesperada. Los caracteres de control, las etiquetas y la estructura de formato pueden consumir tokens adicionales.

4.2 Optimización de Prompts para Reducir Tokens

  • Concisión: Escribir prompts de manera clara y concisa es fundamental. Elimina palabras innecesarias, frases redundantes y explicaciones excesivas.
  • Instrucciones Claras: En lugar de dar contexto extenso, enfócate en instrucciones directas y precisas.
  • Ejemplos (Few-shot learning): Si necesitas proporcionar ejemplos, sé eficiente. Utiliza formatos compactos y elimina detalles superfluos en los ejemplos.
  • Iteración: Prueba diferentes formulaciones de prompts para ver cuál produce el recuento de tokens más bajo sin sacrificar la calidad de la respuesta.

4.3 Gestión de la Ventana de Contexto

  • Monitoreo: Rastrea el uso de tokens de entrada y salida en tus aplicaciones para asegurarte de que te mantienes dentro de los límites del modelo.
  • Truncamiento Estratégico: Si debes truncar el contexto, hazlo de manera inteligente, preservando la información más relevante.
  • Resumen: Para conversaciones largas, implementa estrategias de resumen para condensar el historial y liberando espacio en la ventana de contexto.

4.4 Coste vs. Calidad

A menudo, hay un compromiso entre el número de tokens y la calidad o el detalle de la respuesta. Un prompt más detallado puede generar una respuesta más precisa, pero a un mayor coste y latencia. Es importante encontrar el equilibrio adecuado para tu caso de uso.

5. Conclusión

La gestión del conteo de tokens es una habilidad esencial para cualquier profesional que trabaje con LLMs, y Anthropic con sus modelos Claude ofrece un entorno donde la transparencia y el control son importantes. Si bien la API de Anthropic proporciona el recuento más preciso para sus modelos, comprender las diferencias en la tokenización entre Claude, OpenAI y otros proveedores permite una toma de decisiones informada. La implementación de estrategias de optimización de prompts y la monitorización cuidadosa del uso de tokens son clave para maximizar la eficiencia, controlar los costes y aprovechar al máximo las capacidades de los LLMs.

Para obtener asistencia experta en la implementación de soluciones de IA y LLMs, incluyendo estrategias avanzadas de gestión de tokens y optimización de costos, considere visitar https://www.mgatc.com.

Escrito por Mariano Gobea Alcoba

← Otros artículosConsultoría →