Los modelos Quen 2 de Alibaba son los últimos y mejores modelos de lenguaje de código abierto, que ofrecen impresionantes capacidades en una amplia gama de tareas. Estos modelos van desde 500 millones hasta 72 mil millones de parámetros, con los modelos más grandes que admiten hasta 128.000 tokens, una mejora significativa con respecto al límite de 8.000 tokens de GPT-3.

Una de las características clave de Quen 2 es su sólido rendimiento en codificación y matemáticas, así como su capacidad para manejar la comprensión de contextos largos, crucial para aplicaciones del mundo real. Además, los modelos ofrecen soporte para un conjunto diverso de idiomas, incluido un enfoque en los idiomas de Oriente Medio y el sudeste asiático, lo que supone un cambio bienvenido con respecto al enfoque centrado en los idiomas occidentales de muchos otros modelos.

Para aprovechar el poder de Quen 2, podemos usar el marco Quen Agent, que proporciona acceso a un asistente de navegador integrado, un intérprete de código y la capacidad de crear asistentes personalizados. Esto nos permite construir agentes autónomos que pueden planificar, ejecutar y adaptar sus acciones en función de la tarea en cuestión.

En esta sección, exploraremos cómo usar Quen Agent para crear un agente de generación de imágenes personalizado. El agente podrá generar imágenes en función de la entrada del usuario, descargar las imágenes generadas e incluso actualizar su propio código si se encuentra con algún problema. Al combinar la poderosa comprensión del lenguaje de Quen 2 con las capacidades de planificación y ejecución de Quen Agent, podemos crear agentes verdaderamente autónomos y capaces que puedan abordar una amplia gama de tareas.

Las llamadas a funciones y los agentes son dos conceptos distintos en el mundo de los modelos de lenguaje de gran tamaño (LLM). Aquí hay una explicación concisa de las diferencias entre los dos:

Llamada a funciones (uso de herramientas):

• La llamada a funciones, o el uso de herramientas, permite que el LLM interactúe con el mundo exterior accediendo a API o funciones externas.
• El LLM determina qué función usar en función de la entrada del usuario, genera los datos de entrada necesarios para la función y devuelve los resultados al usuario.
• Sin embargo, el LLM en sí mismo no puede ejecutar la llamada a la función; el usuario o un sistema separado debe realizar la llamada a la función y devolver los resultados al LLM.

Agentes:

• Los agentes son instancias más sofisticadas de LLM que tienen acceso a un conjunto de herramientas, al igual que en la llamada a funciones.
• Los agentes también pueden realizar planificación, descomponer tareas en subtareas y ejecutar acciones utilizando las herramientas disponibles.
• Los agentes tienen acceso a memoria a corto y largo plazo, lo que les permite hacer un seguimiento de su progreso y planificar sus próximos pasos en consecuencia.
• Los agentes son fundamentales para hacer que los LLM sean realmente útiles en aplicaciones del mundo real, ya que pueden realizar tareas complejas de forma autónoma.

En resumen, la llamada a funciones es una interacción más limitada donde el LLM solo puede generar los datos de entrada necesarios para una función, mientras que los agentes tienen la capacidad de planificar, ejecutar y adaptar sus acciones para lograr un resultado deseado.

Para comenzar con los agentes Qwen, usaremos la versión de 72 mil millones de Qwen 2 y la ejecutaremos localmente usando AMA. También puedes usar su API externa, pero para usar Qwen Agent, tenemos dos opciones:

1. Instalar el paquete usando pip como un paquete de Python independiente.
2. Clonar el repositorio y ejecutar la instalación localmente si deseas la última versión de desarrollo.

Lo ejecutaré localmente usando AMA. Primero, inicia un servidor AMA y usa el comando olama Run Qwen 272 billion. Esto descargará AMA y el modelo, lo que puede tardar un tiempo dependiendo de tu velocidad de Internet.

A continuación, crea un entorno virtual usando conda y actívalo:

conda create -n qwen python=3.10
conda activate qwen

Ahora, instala el paquete Qwen Agent usando pip:

pip install qwen-agent

Comenzaremos con la llamada a funciones. El modelo necesita elegir la función a usar, determinar los datos de entrada y pasarlos a un intérprete de Python. El intérprete ejecutará la función, obtendrá la respuesta y la devolverá al LLM.

Aquí hay un ejemplo de llamada a función para obtener el clima actual:

# Crear la instancia de LLM
llm = QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1")

# Mensaje del usuario
mensaje_usuario = "¿Cómo está el clima actual en París?"

# Definir la función
funcion_llamada = {
    "description": "Obtener el clima actual para una ubicación dada",
    "function": "get_weather",
    "arguments": {
        "location": "París",
        "unit": "celsius"
    }
}

# Llamar al LLM y ejecutar la función
respuesta = llm.call_with_function(mensaje_usuario, [funcion_llamada])
print(respuesta)

Esto generará la información del clima actual para París y la devolverá al LLM.

Ahora, veamos un ejemplo de uso de Qwen Agent. Crearemos un agente personalizado que pueda generar imágenes y descargarlas en una carpeta local. El agente utilizará una herramienta personalizada para la generación de imágenes y el intérprete de código para ejecutar el código necesario.

from qwen_agent import Assistant, CodeInterpreter, CustomTool

# Definir la herramienta de generación de imágenes personalizada
class MyImageGeneration(CustomTool):
    def __init__(self):
        self.description = "Generar imágenes en función de la entrada del usuario utilizando la API de Pollinations.AI."

    def run(self, args):
        # Generar la imagen usando la API
        url_imagen = generar_imagen(args["prompt"])
        
        # Descargar la imagen en una carpeta local
        descargar_imagen(url_imagen, "images")

        return "Imagen generada y guardada en la carpeta 'images'."

# Crear el agente
agente = Assistant(
    llm=QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1"),
    tools=[MyImageGeneration(), CodeInterpreter()]
)

# Pedir al agente que genere una imagen
agente.run("Crea una imagen de una llama con gafas de sol.")

En esta sección, exploraremos el impacto de la cuantificación en el rendimiento de los modelos de lenguaje de gran tamaño, con un enfoque específico en los modelos Quin 2.

El equipo de Quin ha abordado la cuestión del impacto de la cuantificación en sus modelos actualizados. Han evaluado el rendimiento de los modelos Quin 2 con diferentes niveles de cuantificación, incluida la cuantificación de punto flotante 16, 8 bits, 4 bits y AWQ (Cuantificación de Peso Adaptativa).

Basándose en los números promedio, se pueden observar las siguientes tendencias:

1. Modelos más grandes: Para el modelo más grande de 72 mil millones de parámetros, la diferencia de rendimiento entre la cuantificación de 16 bits y 8 bits no es significativa, con aproximadamente el 81% del rendimiento original mantenido. Sin embargo, la cuantificación de 4 bits muestra una caída de rendimiento más notable.

2. Modelos más pequeños: Para los modelos más pequeños, como la versión de 0.5 mil millones de parámetros, el impacto de la cuantificación es más dramático. La cuantificación de 4 bits muestra una diferencia de 5 puntos en el puntaje promedio en comparación con la versión original de 16 bits de punto flotante.

La conclusión clave es que el impacto de la cuantificación es más pronunciado en los modelos más pequeños, mientras que los modelos Quin 2 más grandes pueden mantener un rendimiento relativamente alto incluso con la cuantificación de 8 bits.

Al implementar estos modelos en producción, se recomienda generalmente utilizar al menos la cuantificación de 8 bits y, si es posible, 16 bits, para evitar una degradación significativa del rendimiento, especialmente para las variantes de modelos más pequeños.

En resumen, el análisis del equipo de Quin destaca la importancia de considerar cuidadosamente los compromisos entre el tamaño del modelo, el nivel de cuantificación y el rendimiento al implementar modelos de lenguaje de gran tamaño en aplicaciones del mundo real.