El uso efectivo de modelos de lenguaje grandes (LLMs) como Nanbeige4.1-3B a menudo reside en dominar su función de generación. Si bien puedes haber ejecutado el modelo y obtenido respuestas, es común encontrarse con resultados que varían desde coherentes hasta inconsistentes, o que no se ajustan al formato deseado (por ejemplo, código mal estructurado o escritura creativa poco inspirada).

La clave para desbloquear todo el potencial de Nanbeige4.1-3B no está solo en el modelo, sino en los parámetros de generación. Parámetros como temperature, top_p, y max_new_tokens actúan como los controles de un chef, influyendo drásticamente en el "sabor" (el resultado generado) del modelo. Este artículo tiene como objetivo desglosar la función de cada parámetro en model.generate() de Nanbeige4.1-3B y, crucialmente, cómo combinarlos para adaptar el modelo a diversas aplicaciones, permitiendo que este modelo de 3B demuestre capacidades que trascienden su tamaño aparente.

1. Confgiuración del Entorno y Verificación Inicial

Antes de profundizar en los parámetros, asegurémonos de que tienes el entorno configurado correctamente. Si ya lo tienes, puedes revisar esta sección rápidamente; de lo contrario, sigue los pasos para una configuración rápida.

1.1. Preparación Básica del Entorno

Nanbeige4.1-3B es amigable con los recursos y su configuración es sencilla.

# Paso 1: Configurar y activar un entorno Python limpio (altamente recomendado)
conda create -n nb_env python=3.10 -y
conda activate nb_env

# Paso 2: Instalar las bibliotecas esenciales
pip install torch>=2.0.0 transformers>=4.51.0 accelerate>=0.20.0

Nota importante: Utilizar conda para gestionar tu entorno evita posibles conflictos de paquetes. La biblioteca accelerate es vital para aprovechar eficientemente tu GPU.

1.2. Carga del Modelo y Tokenizador

Con el entorno listo, carguemos el modelo y su tokenizador. Este código sirve como base para todos los experimentos posteriores.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Establece la ruta a tu modelo Nanbeige4.1-3B
ruta_modelo = "/root/ai-models/nanbeige/Nanbeige4___1-3B"

# Cargar el tokenizador, que convierte texto en tokens numéricos
tokenizador = AutoTokenizer.from_pretrained(
    ruta_modelo,
    trust_remote_code=True  # Necesario para manejar código personalizado del modelo
)

# Cargar la arquitectura del modelo
modelo = AutoModelForCausalLM.from_pretrained(
    ruta_modelo,
    torch_dtype=torch.bfloat16,  # bfloat16 reduce el consumo de memoria sin gran pérdida de rendimiento
    device_map="auto",           # accelerate gestiona la asignación a GPU/CPU
    trust_remote_code=True
)

# Poner el modelo en modo de evaluación para deshabilitar características de entrenamiento como Dropout
modelo.eval()

print("✅ Modelo y tokenizador cargados con éxito!")

Verificación: Si el modelo se carga sin errores y el consumo de memoria de la GPU es de aproximadamente 6 GB, la carga fue exitosa. device_map="auto" es una herramienta poderosa que permite incluso cargar partes del modelo en la CPU si la GPU no tiene suficiente memoria, haciendo el modelo accesible.

1.3. Primera Llamada de Generación

Aquí presentamos una función de generación básica que modificaremos con los parámetros avanzados.

def generar_respuesta_base(entrada_usuario):
    """Función de generación básica"""
    # 1. Formato del mensaje de diálogo (estilo ChatML para Nanbeige4.1-3B)
    mensajes = [{"role": "user", "content": entrada_usuario}]
    
    # 2. Convertir el diálogo a IDs de token utilizando la plantilla del tokenizador
    ids_entrada = tokenizador.apply_chat_template(
        mensajes,
        return_tensors="pt"  # Devuelve tensores de PyTorch
    ).to(modelo.device)  # Asegura que los datos estén en el mismo dispositivo que el modelo
    
    # 3. Paso central de generación (parámetros por defecto para empezar)
    with torch.no_grad():  # Desactiva el cálculo de gradientes para ahorrar memoria y acelerar
        salidas = modelo.generate(
            ids_entrada,
            max_new_tokens=512,  # Límite de tokens a generar
            temperature=1.0,     # Parámetro de aleatoriedad
            do_sample=True       # Habilita la generación por muestreo
        )
    
    # 4. Decodificar y extraer solo la parte generada por el modelo
    # salidas[0] contiene la secuencia completa (entrada + salida)
    # ids_entrada[0] es la secuencia de entrada
    # Usamos el slicing para obtener solo la "parte de salida"
    ids_respuesta = salidas[0][len(ids_entrada[0]):]
    
    # 5. Convertir los IDs de token de vuelta a texto legible
    respuesta = tokenizador.decode(ids_respuesta, skip_special_tokens=True)
    
    return respuesta

# Prueba inicial
pregunta_prueba = "¿Puedes presentarte brevemente en una frase?"
respuesta_modelo = generar_respuesta_base(pregunta_prueba)
print(f"Usuario: {pregunta_prueba}")
print(f"Modelo: {respuesta_modelo}")

Con este fragmento de código funcionando, tienes la base para empezar a experimentar con los parámetros de generación de Nanbeige4.1-3B.

2. Análisis Detallado de los Parámetros de Generación

Aunque model.generate() tiene muchas opciones, nos centraremos en los parámetros clave que más influyen en el resultado. Los clasificaremos en tres categorías: control de longitud, control de aleatoriedad y calidad de contenido.

2.1. Parámetros de Control de Longitud: Respuestas del Tamaño Correcto

Estos parámetros determinan la extensión de la salida del modelo.

max_new_tokens (Máximo número de tokens nuevos): Este es, sin duda, el parámetro que más usarás. Limita directamente la longitud máxima del contenido generado.

# Ejemplo: Comparando salidas con diferentes longitudes
# Asumiendo 'ids_entrada' ya está definido desde la sección anterior
salida_corta = modelo.generate(
    ids_entrada,
    max_new_tokens=50,   # Generar una respuesta concisa
    do_sample=False      # Usar decodificación codiciosa para estabilidad inicial
)

salida_larga = modelo.generate(
    ids_entrada, 
    max_new_tokens=500,  # Generar una respuesta más extensa
    do_sample=False
)

print("Respuesta corta (50 tokens):", tokenizador.decode(salida_corta[0][len(ids_entrada[0]):], skip_special_tokens=True)[:100] + "...")
print("\nRespuesta larga (500 tokens):", tokenizador.decode(salida_larga[0][len(ids_entrada[0]):], skip_special_tokens=True)[:100] + "...")

¿Cómo configurarlo?

• Conversaciones: 128-256. Las interacciones de chat generalmente no requieren respuestas muy largas.
• Generación de código: 256-512. El código a menudo necesita más tokens para expresar una lógica completa.
• Escritura creativa/Textos extensos: 512-2048. Depende de la longitud deseada para el contenido.
• Consejo clave: Es mejor quedarse corto que largo. Siempre puedes pedir al modelo que "continúe" si la respuesta es muy corta, pero una longitud excesiva puede llevar a divagaciones o información irrelevante. Nanbeige4.1-3B soporta un contexto de 8K, pero rara vez necesitarás generar respuestas tan largas.

min_new_tokens (Mínimo número de tokens nuevos): Menos común, pero útil en ciertos escenarios. Fuerza al modelo a generar al menos la cantidad especificada de tokens, incluso si ya considera que ha completado la respuesta.

# Ejemplo: Asegurar una longitud mínima
salida_minima = modelo.generate(
    ids_entrada,
    max_new_tokens=200,
    min_new_tokens=50,  # Generar al menos 50 tokens
    do_sample=False
)

Uso: Cuando necesitas que el modelo proporcione un análisis o descripción de cierta extensión, evitando respuestas monosilábicas o demasiado breves.

2.2. Parámetros de Control de Aleatoriedad: Equilibrio entre la Fiabilidad y la Creatividad

Esta es la categoría más "artística" y define la "personalidad" del contenido generado.

temperature (Temperatura): El parámetro de aleatoriedad más clásico. Puedes verlo como el "interruptor de la imaginación".

# Ejemplo: Comparación de respuestas con diferentes temperaturas
preguntas = ["Describe el otoño en una frase metafórica."]
ids_entrada_temp = tokenizador.apply_chat_template([{"role": "user", "content": preguntas[0]}], return_tensors="pt").to(modelo.device)

for temp in [0.1, 0.6, 1.2]:
    print(f"\n{'='*50}")
    print(f"Temperatura = {temp}")
    print('='*50)
    
    salidas_temp = modelo.generate(
        ids_entrada_temp,
        max_new_tokens=100,
        temperature=temp,
        do_sample=True,  # Necesario para que temperature tenga efecto
        top_p=0.95       # top_p fijo para aislar el efecto de temperature
    )
    
    respuesta_temp = tokenizador.decode(salidas_temp[0][len(ids_entrada_temp[0]):], skip_special_tokens=True)
    print(f"Respuesta: {respuesta_temp}")

Efectos:

• temperature=0.1: Respuestas muy conservadoras y deterministas. Múltiples generaciones para la misma pregunta serán casi idénticas. Ideal para preguntas factuales o generación de código.
• temperature=0.6 (valor por defecto en muchos casos): Un punto de equilibrio. Ofrece cierta creatividad sin divagar demasiado. Adecuado para la mayoría de los escenarios generales.
• temperature=1.2: Modo "libre". Las salidas varían significativamente en cada generación, pudiendo ofrecer sorpresas o incoherencias. Ideal para lluvia de ideas o escritura creativa.

top_p (Muestreo del núcleo): Otro parámetro para controlar la diversidad, pero con una lógica diferente a temperature. Selecciona tokens acumulando probabilidades desde los más altos hasta superar el valor de top_p, y luego muestrea solo de este "núcleo".

# Ejemplo: Efectos de diferentes valores de top_p
# Usando la misma 'ids_entrada_temp' de antes
for p_val in [0.3, 0.7, 0.95]:
    print(f"\n{'='*50}")
    print(f"top_p = {p_val}")
    print('='*50)
    
    salidas_p = modelo.generate(
        ids_entrada_temp,
        max_new_tokens=100,
        temperature=0.6,  # Temperatura fija
        top_p=p_val,
        do_sample=True
    )
    
    respuesta_p = tokenizador.decode(salidas_p[0][len(ids_entrada_temp[0]):], skip_special_tokens=True)
    print(f"Respuesta: {respuesta_p}")

Interpretación de top_p: Imagina la distribución de probabilidad para la siguiente palabra. top_p=0.9 significa: "considera solo las palabras cuya probabilidad acumulada sea el 90% superior y selecciona una de ellas al azar". Esto es útil para evitar seleccionar palabras de probabilidad extremadamente baja, ofreciendo un control más fino que solo temperature.

top_k (Muestreo de los k principales): Similar a top_p, pero más directo: solo muestrea de los k tokens con las probabilidades más altas.

# Ejemplo: Uso de top_k
salidas_k = modelo.generate(
    ids_entrada_temp,
    max_new_tokens=100,
    temperature=0.6,
    top_k=50,  # Seleccionar solo entre los 50 tokens más probables
    do_sample=True
)

¿Cuándo usar temperature, top_p o top_k?

• Generalmente, usa solo uno de temperature o top_p; configurarlos ambos puede restringir demasiado la generación.
• Opción sencilla: Solo temperature=0.6 es adecuado para la mayoría de los casos.
• Mayor control: Usa top_p=0.9 o top_p=0.95 para evitar salidas extrañas.
• top_k se usa cuando necesitas una restricción estricta en la selección de vocabulario, como en la generación de poesía con rima, donde un top_k pequeño puede ser útil.

2.3. Parámetros de Calidad del Contenido: Respuestas "Apropiadas"

Estos parámetros mejoran la calidad intrínseca del contenido generado, abordando problemas como la repetición o la inclusión de ciertos términos.

repetition_penalty (Penalización de repetición): ¡Un parámetro extremadamente útil! Aborda el problema de que el modelo repita frases o ideas.

# Ejemplo: Efecto de la penalización de repetición
# Primero, sin penalización
salidas_sin_penalizacion = modelo.generate(
    ids_entrada, # Asumiendo 'ids_entrada' está disponible
    max_new_tokens=150,
    temperature=0.7,
    do_sample=True
)

# Ahora, con penalización
salidas_con_penalizacion = modelo.generate(
    ids_entrada, 
    max_new_tokens=150,
    temperature=0.7,
    do_sample=True,
    repetition_penalty=1.2  # Valor mayor a 1.0 aplica penalización
)

print("Sin penalización de repetición:", tokenizador.decode(salidas_sin_penalizacion[0][len(ids_entrada[0]):], skip_special_tokens=True)[:200])
print("\nCon penalización de repetición (1.2):", tokenizador.decode(salidas_con_penalizacion[0][len(ids_entrada[0]):], skip_special_tokens=True)[:200])

Interpretación del parámetro:

• repetition_penalty=1.0: Sin penalización.
• repetition_penalty=1.1-1.3: Penalización moderada, ideal para la mayoría de los escenarios.
• repetition_penalty>1.5: Penalización fuerte, puede llevar al modelo a evitar palabras comunes, resultando en frases antinaturales.
• Valor recomendado: 1.1-1.2 es el rango óptimo para reducir la repetición sin afectar la fluidez.

no_repeat_ngram_size (Tamaño de n-grama sin repetición): Un método más agresivo para evitar repeticiones. Prohíbe directamente la aparición de secuencias de n palabras idénticas en la salida.

# Ejemplo: Prohibir la repetición de 3-gramas
salidas_ngram = modelo.generate(
    ids_entrada,
    max_new_tokens=200,
    temperature=0.7,
    do_sample=True,
    no_repeat_ngram_size=3  # No permite que secuencias de 3 palabras se repitan
)

Precaución: Este parámetro es bastante "brutal". Un valor demasiado alto (por ejemplo, más de 5) puede hacer que el modelo se quede sin opciones de palabras, lo que podría terminar la generación prematuramente. Generalmente, un valor de 2 o 3 es suficiente.

do_sample (¿Realizar muestreo?): Un interruptor que define el método de generación.

• do_sample=False: Decodificación codiciosa (greedy). Siempre elige la siguiente palabra con la probabilidad más alta. Las salidas son deterministas, pero pueden ser monótonas.
• do_sample=True: Decodificación por muestreo. Selecciona palabras aleatoriamente según su distribución de probabilidad. Las salidas son diversas, pero pueden ser inestables.

# Ejemplo: Comparación entre muestreo y decodificación codiciosa
# Decodificación codiciosa - resultados idénticos en cada ejecución
salidas_codiciosa = modelo.generate(
    ids_entrada,
    max_new_tokens=50,
    do_sample=False  # Decodificación codiciosa
)

# Decodificación por muestreo - resultados potencialmente diferentes
salidas_muestreo = modelo.generate(
    ids_entrada,
    max_new_tokens=50,
    do_sample=True,  # Decodificación por muestreo
    temperature=0.7
)

print("Decodificación codiciosa (fija):", tokenizador.decode(salidas_codiciosa[0][len(ids_entrada[0]):], skip_special_tokens=True))
print("\nDecodificación por muestreo (aleatoria):", tokenizador.decode(salidas_muestreo[0][len(ids_entrada[0]):], skip_special_tokens=True))

Reglas prácticas:

• Para salidas deterministas (generación de código, respuestas factuales): usa do_sample=False o do_sample=True con un temperature muy bajo (ej., 0.1).
• Para salidas creativas (escritura, ideas): usa do_sample=True con un temperature adecuado (0.6-1.0).

3. Aplicación Práctica de Parámetros en Escenarios de Negocio

Comprendidos los parámetros individuales, el siguiente paso es saber cómo combinarlos. Aquí te presento "recetas" de parámetros probadas para los principales casos de uso de Nanbeige4.1-3B.

3.1. Escenario 1: Conversación Inteligente y Preguntas y Respuestas

Este es el escenario más habitual. El objetivo es que el modelo responda con precisión, naturalidad y sin divagaciones.

def generar_respuesta_conversacion(mensaje_usuario, historial_conversacion=None):
    """
    Generación de respuestas para diálogos inteligentes.
    Adecuado para atención al cliente, chat informal, Q&A basado en conocimiento.
    """
    mensajes = []
    if historial_conversacion:
        mensajes.extend(historial_conversacion)
    mensajes.append({"role": "user", "content": mensaje_usuario})
    
    ids_entrada = tokenizador.apply_chat_template(
        mensajes,
        return_tensors="pt"
    ).to(modelo.device)
    
    # Combinación de parámetros recomendada para conversación
    salidas = modelo.generate(
        ids_entrada,
        max_new_tokens=256,          # Longitud media para diálogos
        temperature=0.7,             # Ligeramente aleatorio para un tono natural
        top_p=0.9,                   # Limita la selección al 90% de las probabilidades principales
        repetition_penalty=1.1,      # Penalización suave para evitar repeticiones en el chat
        do_sample=True,
        pad_token_id=tokenizador.eos_token_id,
    )
    
    ids_respuesta = salidas[0][len(ids_entrada[0]):]
    respuesta = tokenizador.decode(ids_respuesta, skip_special_tokens=True)
    
    return respuesta

# Prueba de conversación
pregunta_chat = "¿Cuáles son las principales innovaciones del modelo Transformer?"
respuesta_chat = generar_respuesta_conversacion(pregunta_chat)
print(f"Pregunta: {pregunta_chat}")
print(f"Respuesta: {respuesta_chat}")

Puntos clave para conversación:

• temperature=0.7: Un poco más alto que el valor predeterminado para hacer la respuesta menos robótica.
• top_p=0.9: Restringe el rango de muestreo para asegurar la relevancia de la respuesta.
• repetition_penalty=1.1: Penalización leve para mantener la fluidez del diálogo.
• max_new_tokens=256: Suficiente para una respuesta completa sin ser excesivamente prolijo.

3.2. Escenario 2: Generación de Código y Asistencia de Programación

Nanbeige4.1-3B ofrece un buen rendimiento en la generación de código. Aquí, se busca código preciso, bien estructurado y funcional.

def generar_codigo(indicacion, lenguaje="python"):
    """
    Función de generación de código.
    Ideal para snippets de código, implementaciones de funciones, explicaciones de código.
    """
    # Optimizar la indicación para clarificar los requisitos
    indicacion_mejorada = f"""Por favor, escribe código en {lenguaje}.
Requisitos: El código debe ser limpio, incluir comentarios apropiados y ser ejecutable directamente.

Tarea: {indicacion}
"""
    
    mensajes = [{"role": "user", "content": indicacion_mejorada}]
    ids_entrada = tokenizador.apply_chat_template(mensajes, return_tensors="pt").to(modelo.device)
    
    # Combinación de parámetros recomendada para generación de código
    salidas = modelo.generate(
        ids_entrada,
        max_new_tokens=512,          # El código puede requerir más tokens
        temperature=0.3,             # Temperatura baja para asegurar precisión y corrección
        top_p=0.95,                  # Mantiene cierta diversidad sin desviarse
        repetition_penalty=1.05,     # Penalización de repetición muy leve
        do_sample=True,
        no_repeat_ngram_size=3,      # Evita la repetición de bloques de código
        pad_token_id=tokenizador.eos_token_id,
    )
    
    ids_respuesta = salidas[0][len(ids_entrada[0]):]
    codigo_generado = tokenizador.decode(ids_respuesta, skip_special_tokens=True)
    
    return codigo_generado

# Prueba de generación de código
indicacion_codigo = "Escribe una función que calcule el máximo y el mínimo de una lista de números."
codigo_obtenido = generar_codigo(indicacion_codigo, "python")
print("Código generado:")
print(codigo_obtenido)

Puntos clave para generación de código:

• temperature=0.3: Crucial. Baja temperatura para asegurar la corrección sintáctica y lógica del código.
• max_new_tokens=512: Da suficiente espacio para código más complejo.
• no_repeat_ngram_size=3: Evita patrones de código repetitivos.
• repetition_penalty=1.05: Penalización leve para evitar afectar repeticiones normales en código (ej. bucles, estructuras similares).

3.3. Escenario 3: Escritura Creativa y Generación de Contenido

Este escenario abarca la creación de historias, poemas, textos de marketing u otro contenido que requiera creatividad.

def escritura_creativa(indicacion, estilo="Historia"):
    """
    Generación de escritura creativa.
    Adecuado para historias, poesía, textos publicitarios, contenido innovador.
    """
    # Ajustar la indicación según el estilo deseado
    indicaciones_estilo = {
        "Historia": f"Crea un cuento corto con una trama interesante, personajes vivos y un desarrollo claro.\nTema: {indicacion}",
        "Poesía": f"Escribe un poema con atmósfera y ritmo.\nTema: {indicacion}",
        "Publicidad": f"Redacta un texto de marketing persuasivo y atractivo, resaltando los puntos clave.\nProducto: {indicacion}",
    }
    
    indicacion_mejorada = indicaciones_estilo.get(estilo, indicacion)
    mensajes = [{"role": "user", "content": indicacion_mejorada}]
    ids_entrada = tokenizador.apply_chat_template(mensajes, return_tensors="pt").to(modelo.device)
    
    # Combinación de parámetros recomendada para escritura creativa
    salidas = modelo.generate(
        ids_entrada,
        max_new_tokens=400,          # Longitud moderada para contenido creativo
        temperature=0.9,             # Temperatura alta para estimular la creatividad
        top_p=0.85,                  # Limita la aleatoriedad para evitar incoherencias extremas
        repetition_penalty=1.15,     # Penalización moderada para evitar repeticiones de ideas
        do_sample=True,
        no_repeat_ngram_size=4,      # Evita la repetición de frases comunes
        pad_token_id=tokenizador.eos_token_id,
    )
    
    ids_respuesta = salidas[0][len(ids_entrada[0]):]
    texto_creativo = tokenizador.decode(ids_respuesta, skip_special_tokens=True)
    
    return texto_creativo

# Prueba de escritura creativa
tema_historia = "Un gato que aprende a programar"
historia = escritura_creativa(tema_historia, "Historia")
print("Historia generada:")
print(historia)

Puntos clave para escritura creativa:

• temperature=0.9: Crucial. Alta temperatura para fomentar la diversidad y la originalidad.
• top_p=0.85: Restringe el rango para evitar que el modelo genere contenido completamente aleatorio.
• repetition_penalty=1.15: Penalización más fuerte para evitar la redundancia en contenido creativo.
• no_repeat_ngram_size=4: Evita la repetición de estructuras oracionales.

3.4. Escenario 4: Procesamiento y Resumen de Textos Largos

La capacidad de Nanbeige4.1-3B para manejar un contexto de 8K lo hace adecuado para tareas con textos extensos.

def procesar_texto_largo(texto, tarea="resumen"):
    """
    Función para el procesamiento de textos largos.
    Adecuado para resumen, extracción de información clave, análisis de documentos extensos.
    """
    # Construir la indicación según la tarea
    indicaciones_tarea = {
        "resumen": f"Genera un resumen conciso del siguiente texto:\n\n{texto}\n\nResumen:",
        "puntos_clave": f"Extrae los puntos clave del siguiente texto:\n\n{texto}\n\nPuntos clave:",
        "qa": f"Responde a preguntas basándote en el siguiente texto:\n\n{texto}\n\nPregunta:",
    }
    
    indicacion = indicaciones_tarea.get(tarea, texto)
    
    # Aquí simplificamos, pero para textos muy largos podría requerir procesamiento por lotes
    mensajes = [{"role": "user", "content": indicacion}]
    ids_entrada = tokenizador.apply_chat_template(mensajes, return_tensors="pt").to(modelo.device)
    
    # Combinación de parámetros recomendada para procesamiento de textos largos
    salidas = modelo.generate(
        ids_entrada,
        max_new_tokens=300,          # Los resúmenes deben ser concisos
        temperature=0.5,             # Temperatura media para equilibrio entre precisión y fluidez
        top_p=0.92,                  # Rango de muestreo restringido
        repetition_penalty=1.1,      # Penalización de repetición estándar
        do_sample=True,
        pad_token_id=tokenizador.eos_token_id,
    )
    
    ids_respuesta = salidas[0][len(ids_entrada[0]):]
    resultado = tokenizador.decode(ids_respuesta, skip_special_tokens=True)
    
    return resultado

# Prueba de resumen de texto (usando un ejemplo corto)
texto_ejemplo = """
La inteligencia artificial es una rama de la informática que busca crear máquinas capaces de realizar tareas 
que normalmente requieren inteligencia humana. Estas tareas incluyen la percepción visual, el reconocimiento 
de voz, la toma de decisiones y la traducción de idiomas. En los últimos años, con el avance de las técnicas 
de aprendizaje profundo, la IA ha logrado avances significativos en áreas como el reconocimiento de imágenes 
y el procesamiento del lenguaje natural.
"""
resumen = procesar_texto_largo(texto_ejemplo, "resumen")
print("Resumen del texto original:")
print(resumen)

Puntos clave para procesamiento de textos largos:

• temperature=0.5: Temperatura media para asegurar la precisión de la información.
• max_new_tokens=300: Los resúmenes deben ser breves.
• Los demás parámetros se mantienen en valores intermedios para equilibrar las necesidades.

3.5. Escenario 5: Razonamiento y Problemas Lógicos

Aprovecha la capacidad de razonamiento de Nanbeige4.1-3B.

def resolver_razonamiento_logico(problema):
    """
    Solución de problemas de razonamiento lógico.
    Adecuado para problemas matemáticos, acertijos lógicos, análisis de inferencias.
    """
    indicacion_mejorada = f"""Por favor, razona paso a paso para resolver el siguiente problema:
    
Problema: {problema}

Por favor, sigue estos pasos de razonamiento:"""
    
    mensajes = [{"role": "user", "content": indicacion_mejorada}]
    ids_entrada = tokenizador.apply_chat_template(mensajes, return_tensors="pt").to(modelo.device)
    
    # Combinación de parámetros recomendada para problemas de razonamiento
    salidas = modelo.generate(
        ids_entrada,
        max_new_tokens=400,          # El razonamiento puede requerir pasos detallados
        temperature=0.4,             # Temperatura baja para asegurar la rigurosidad lógica
        top_p=0.95,                  # Mantiene un rango de opciones aceptable
        repetition_penalty=1.05,     # Penalización leve
        do_sample=True,
        pad_token_id=tokenizador.eos_token_id,
    )
    
    ids_respuesta = salidas[0][len(ids_entrada[0]):]
    razonamiento = tokenizador.decode(ids_respuesta, skip_special_tokens=True)
    
    return razonamiento

# Prueba de razonamiento lógico
problema_logico = "Si todos los gatos temen al agua, y Tom es un gato, ¿Tom teme al agua? Explica tu proceso de razonamiento."
resultado_razonamiento = resolver_razonamiento_logico(problema_logico)
print("Proceso de razonamiento:")
print(resultado_razonamiento)

Puntos clave para razonamiento:

• temperature=0.4: Baja temperatura para garantizar un razonamiento lógico estricto.
• max_new_tokens=400: Proporciona espacio suficiente para los pasos de razonamiento.
• repetition_penalty=1.05: Muy leve, para no interferir con la expresión lógica.

4. Estrategias Avanzadas y Solución de Problemas

Conocidos los parámetros básicos y las configuraciones por escenario, veamos algunas técnicas avanzadas para un uso más eficiente y la resolución de problemas comunes.

4.1. Reglas de Oro para la Combinación de Parámetros

Tras numerosas pruebas, he identificado algunas "combinaciones de oro":

Combinación Uno: Equilibrio General

# Adecuado para la mayoría de las tareas diarias
parametros = {
    "max_new_tokens": 256,
    "temperature": 0.7,
    "top_p": 0.9,
    "repetition_penalty": 1.1,
    "do_sample": True,
}

Uso: Si no estás seguro de qué parámetros usar, empieza con esta combinación.

Combinación Dos: Alta Determinación

# Para salidas precisas y fiables
parametros = {
    "max_new_tokens": 512,
    "temperature": 0.3,
    "top_p": 0.95,
    "repetition_penalty": 1.05,
    "do_sample": True,
}

Uso: Generación de código, respuestas factuales, extracción de datos.

Combinación Tres: Alta Creatividad

# Para salidas creativas y diversas
parametros = {
    "max_new_tokens": 400,
    "temperature": 0.9,
    "top_p": 0.85,
    "repetition_penalty": 1.15,
    "do_sample": True,
}

Uso: Escritura creativa, lluvia de ideas, generación de historias.

4.2. Problemas Comunes y sus Soluciones

Problema Uno: Contenido Generado Repetitivo

Síntoma: El modelo repite frases o ideas similares de forma constante.

Soluciones:

1. Aumentar repetition_penalty a 1.2-1.3.
2. Establecer no_repeat_ngram_size=3.
3. Reducir temperature a menos de 0.5.

# Configuración anti-repetición
salidas = modelo.generate(
    ids_entrada,
    max_new_tokens=256,
    temperature=0.5,
    repetition_penalty=1.25,  # Aumenta la penalización de repetición
    no_repeat_ngram_size=3,   # Prohíbe la repetición de 3-gramas
    do_sample=True,
)

Problema Dos: Contenido Generado Demasiado Aleatorio o Incoherente

Síntoma: La salida no es relevante o carece de lógica.

Soluciones:

1. Reducir temperature a menos de 0.3.
2. Reducir top_p a menos de 0.8.
3. Probar do_sample=False (decodificación codiciosa).

# Configuración para aumentar la determinación
salidas = modelo.generate(
    ids_entrada,
    max_new_tokens=256,
    temperature=0.2,      # Baja temperatura
    top_p=0.8,            # Restringe el rango de muestreo
    do_sample=True,
)

Problema Tres: Generación que Termina Prematuramente

Síntoma: El modelo genera una respuesta muy corta y se detiene.

Soluciones:

1. Aumentar max_new_tokens.
2. Verificar si no_repeat_ngram_size está configurado con un valor demasiado pequeño.
3. Reducir repetition_penalty.

# Configuración para asegurar una longitud suficiente
salidas = modelo.generate(
    ids_entrada,
    max_new_tokens=512,          # Aumenta la longitud
    no_repeat_ngram_size=2,      # O elimina este parámetro
    repetition_penalty=1.05,     # Reduce la penalización
    do_sample=True,
)

Problema Cuatro: Velocidad de Generación Lenta

Síntoma: Tiempos de espera excesivos.

Soluciones:

1. Reducir max_new_tokens.
2. Utilizar do_sample=False (la decodificación codiciosa es más rápida).
3. Asegurarse de que se está utilizando la aceleración por GPU.

# Configuración para acelerar
salidas = modelo.generate(
    ids_entrada,
    max_new_tokens=128,      # Reduce la longitud de la generación
    do_sample=False,         # La decodificación codiciosa es más rápida
    num_beams=1,             # Búsqueda con un solo haz (si se usa beam search)
)

4.3. Consejos Prácticos para Depuración

Consejo Uno: Pruebas de Barrido de Parámetros

Cuando no estés seguro de los mejores parámetros, puedes probar rápidamente diferentes combinaciones:

def escaneo_parametros(pregunta, rejilla_parametros):
    """Prueba rápida de diferentes combinaciones de parámetros"""
    mensajes = [{"role": "user", "content": pregunta}]
    ids_entrada = tokenizador.apply_chat_template(mensajes, return_tensors="pt").to(modelo.device)
    
    resultados = {}
    for nombre, parametros in rejilla_parametros.items():
        salidas = modelo.generate(ids_entrada, **parametros)
        respuesta = tokenizador.decode(salidas[0][len(ids_entrada[0]):], skip_special_tokens=True)
        resultados[nombre] = respuesta[:200]  # Limita a los primeros 200 caracteres para comparar
        
    return resultados

# Definir las combinaciones de parámetros a probar
rejilla_parametros = {
    "Determinista (Baja Temp)": {"max_new_tokens": 100, "temperature": 0.3, "do_sample": True},
    "Equilibrado (Temp Media)": {"max_new_tokens": 100, "temperature": 0.7, "do_sample": True},
    "Creativo (Alta Temp)": {"max_new_tokens": 100, "temperature": 1.2, "do_sample": True},
}

pregunta_prueba_scan = "Describe el otoño en una frase."
resultados_escaneo = escaneo_parametros(pregunta_prueba_scan, rejilla_parametros)

for nombre, respuesta in resultados_escaneo.items():
    print(f"\n{nombre}: {respuesta}")

Consejo Dos: Uso de Secuencias de Parada

Detén la generación del modelo cuando encuentre contenido específico:

# Configurar palabras de parada; la generación se detendrá al encontrarlas
palabras_parada = ["。", "！", "？", "\n\n"]
ids_palabras_parada = [tokenizador.encode(palabra, add_special_tokens=False)[0] for palabra in palabras_parada]

salidas = modelo.generate(
    ids_entrada, # Asumiendo ids_entrada está disponible
    max_new_tokens=500,
    temperature=0.7,
    do_sample=True,
    eos_token_id=ids_palabras_parada,  # El modelo se detendrá al encontrar estos tokens
)

Consejo Tres: Generación por Lotes para Comparación

Genera múltiples candidatos de una sola vez para elegir la mejor opción:

# Generar múltiples resultados candidatos de una vez
salidas = modelo.generate(
    ids_entrada, # Asumiendo ids_entrada está disponible
    max_new_tokens=100,
    temperature=0.7,
    do_sample=True,
    num_return_sequences=3,  # Devuelve 3 candidatos
)

print("Respuestas candidatas:")
for i in range(3):
    respuesta = tokenizador.decode(salidas[i][len(ids_entrada[0]):], skip_special_tokens=True)
    print(f"\nCandidato {i+1}: {respuesta}")

A través de esta guía, has adquirido un conocimiento profundo sobre cómo utilizar los parámetros esenciales de la función model.generate() en Nanbeige4.1-3B. Si bien Nanbeige4.1-3B es un modelo de 3B parámetros, una correcta afinación puede potenciarlo para que sobresalga en tareas específicas, superando las expectativas de su tamaño. La clave reside en comprender tus necesidades y seleccionar el "condimento" adecuado para cada aplicación.

El uso de la IA generativa es una combinación de ciencia y arte, y la optimización de parámetros es la parte artística. Con práctica y experimentación, desarrollarás una intuición para configurar el modelo, convirtiendo a este pequeño LLM en una herramienta poderosa y versátil a tu disposición.