Qwen2 es el LLM de código abierto de Alibaba Cloud

En los próximos años están surgiendo muchas empresas nuevas que lanzarán nuevos modelos de lenguajes grandes de código abierto. A medida que pasa el tiempo, estos modelos se acercan cada vez más a los modelos pagos de código cerrado.

Estas empresas lanzan estos modelos en varios tamaños y se aseguran de conservar sus licencias para que cualquiera pueda utilizarlos comercialmente. Uno de esos grupos de modelos es Qwen.

Sus modelos anteriores han demostrado ser uno de los mejores modelos de código abierto junto con Mistral y Zephyr y ahora recientemente han anunciado una versión 2 llamada Qwen2

¿Qué es Qwen?

Qwen se refiere a una familia de modelos de lenguajes grandes respaldados por Alibaba Cloud, una firma ubicada en China. Ha hecho una gran contribución a AI Space al lanzar muchos de sus modelos de código abierto que están a la par con los mejores modelos en la clasificación de HuggingFace.

Qwen ha lanzado sus modelos en diferentes tamaños, desde el modelo de 7 mil millones de parámetros hasta el modelo de 70 mil millones de parámetros. No solo lanzaron los modelos, sino que los perfeccionaron de una manera que estaban en la cima de la clasificación cuando se lanzaron.

Pero Qwen no se detuvo con esto. Incluso ha lanzado modelos Chat Finetuned, LLM que recibieron una gran formación en Matemáticas y Código. Incluso ha lanzado modelos de lenguaje visual . El equipo de Qwen incluso se está trasladando al espacio del audio para lanzar modelos de texto a voz.

Qwen está intentando crear un ecosistema de modelos de código abierto disponibles para que todos puedan comenzar a crear aplicaciones con ellos sin restricciones y con fines comerciales.

¿Qué es Qwen2?

Qwen recibió mucho reconocimiento de la comunidad de código abierto cuando se lanzó. Se han creado muchos derivados a partir de este modelo Qwen.

Recientemente el equipo Qwen ha anunciado una serie de modelos sucesores de su generación anterior, denominado Qwen2 con más modelos y versiones más afinadas en comparación con las generaciones anteriores.

Qwen2 se lanzó en 5 tamaños diferentes, que incluyen las versiones 0.5B, 1.5B, 7B, 14B y 72 Billion. Estos modelos han sido entrenados previamente en más de 27 lenguajes diferentes y han mejorado significativamente en las áreas de código y matemáticas en comparación con la generación anterior de modelos.

Lo bueno es que incluso los modelos 0.5B y 1.5B vienen con una longitud de contexto de 32k. Mientras que el 7B y el 72B vienen con una longitud de contexto de 128k.

Todos estos modelos cuentan con Atención de Consultas Agrupadas, lo que acelera enormemente el proceso de atención y la cantidad de memoria necesaria para almacenar los resultados intermedios durante la inferencia.

Rendimiento y puntos de referencia

En cuanto a las comparaciones del modelo base, el modelo de lenguaje grande Qwen2 72B supera al modelo Llama3 70B recientemente lanzado y a la combinación de modelos exportados Mixtral 8x22B.

Podemos ver las puntuaciones de referencia en la imagen de abajo. El modelo Qwen supera tanto al Llama3 como al Mixtral en muchos puntos de referencia como MMLU, MMLU-Pro, TheoremQA, HumanEval, GSM8k y muchos más.

En cuanto al modelo más pequeño, es decir, el modelo Qwen2 7B Instruct, también supera a los modelos SOTA (de última generación) recientemente introducidos, como el modelo Llama3 8B y el modelo GLM4 9B.

A pesar de que Qwen2 es el modelo más pequeño de los tres, los supera a ambos y los resultados de todos los puntos de referencia se pueden ver en la imagen a continuación.

Qwen2 en acción

Trabajaremos con Google Colab para probar el modelo Qwen2.

Paso 1: descargar bibliotecas

Para comenzar, necesitamos descargar algunas bibliotecas auxiliares. Para esto trabajamos con el siguiente código:

!pip install -U -q transformers accelerate
  • transformadores: Es un paquete Python popular de HuggingFace, con el que podemos descargar cualquier modelo de aprendizaje profundo y trabajar con ellos.
  • acelerar: Incluso este, es un paquete desarrollado por HuggingFace. Este paquete ayuda a aumentar la velocidad de inferencia de los modelos de lenguajes grandes cuando se ejecutan en la GPU.

Paso 2: descargue el modelo Qwen

Ahora escribiremos el código para descargar el modelo Qwen y probarlo. El código para esto será:

from transformers import pipeline

device = "cuda"

pipe = pipeline("text-generation",
                model="Qwen/Qwen2-1.5B-Instruct",
                device=device,
                max_new_tokens=512,
                do_sample=True,
                temperature=0.7,
                top_p=0.95,
                )
  • Comenzamos importando la función de canalización de la biblioteca de transformadores.
  • Luego configuramos el dispositivo al que se debe asignar el modelo. Aquí lo configuramos en cuda, lo que significa que el modelo se enviará a la GPU si está disponible.
  • model=”Qwen/Qwen2-1.5B-Instruct”: Esto le indica al modelo previamente entrenado con el que se trabajará. dispositivo=dispositivo: Esto le indica el dispositivo que se usará para ejecutar el modelo.
  • max_new_tokens=512: Aquí damos el número máximo de tokens nuevos que se generarán.
  • do_sample=True: esto permite el muestreo durante la generación para una mayor diversidad en la salida.
  • temperatura = 0,7: esto controla la aleatoriedad del texto generado. Los valores más altos conducen a resultados más creativos e impredecibles.
  • top_p=0.95: esto establece la masa de probabilidad que se considerará para el siguiente token durante la generación.

Paso 3: Dar una lista de mensajes al modelo

Ahora, intentemos darle al modelo una lista de mensajes para la entrada y veamos la salida que genera para la lista de mensajes dada.

messages = [
    {"role": "system",
     "content": "You are a funny assistant. You must respons to user questions in funny way"},
    {"role": "user", "content": "What is life?"},
]

response = pipe(messages)

print(response[0]['generated_text'][-1]['content'])
  • Aquí, el primer mensaje es un mensaje del sistema que le indica al asistente que sea divertido.
  • El segundo mensaje es un mensaje de usuario que pregunta “¿Qué es la vida?”.
  • Colocamos ambos mensajes como elementos en una lista.
  • Luego le damos esta lista, que contiene una lista de mensajes para el objeto de canalización, es decir, para nuestro modelo.
  • Luego, el modelo procesa estos mensajes y genera una respuesta.
  • Finalmente, extraemos el contenido del último texto generado de la respuesta.

Paso 4: Probar el modelo con preguntas de matemáticas

Ahora probemos el modelo con algunas preguntas de matemáticas. El código para esto será:

messages = [
    {"role": "user", "content": "If a car travels at a constant speed of \
    60 miles per hour, how far will it travel in 45 minutes?"},
    {"role": "assistant", "content": "To find the distance, \
    use the formula: distance = speed × time. Here, speed = 60 miles per \
    hour and time = 45 minutes = 45/60 hours. So, distance = 60 × (45/60) = 45 miles."},
    {"role": "user", "content": "How far will it travel in 2.5 hours? Explain step by step"}
]

response = pipe(messages)

print(response[0]['generated_text'][-1]['content'])
  • Aquí nuevamente, estamos creando una lista de mensajes.
  • El primer mensaje es un mensaje de usuario que pregunta qué distancia recorrerá un automóvil en 45 minutos a una velocidad constante de 60 millas por hora.
  • El segundo mensaje es un mensaje del asistente que proporciona la solución a la pregunta del usuario utilizando la fórmula distancia = velocidad × tiempo.
  • El tercer mensaje es nuevamente un mensaje de usuario que le hace otra pregunta al asistente.
  • Luego le damos esta lista de mensajes a la canalización.
  • Luego, el modelo procesará estos mensajes y generará una respuesta.

En general, vemos que a pesar de ser un modelo de 1.500 millones de parámetros, el Qwen2 1.5B respondió las preguntas matemáticas correctamente y fue capaz de proporcionar un buen razonamiento en torno a las respuestas que generó. Esto nos dice que los modelos de parámetros más grandes, como los modelos Qwen2 7B, 14B y 72B, pueden funcionar extremadamente bien en diferentes tareas.


Conclusión

Qwen2, una nueva serie de modelos de código abierto de Alibaba Cloud, representa un gran avance en el campo de los modelos de lenguajes grandes (LLM).

Aprovechando el éxito de su predecesor, Qwen2 ofrece una gama de modelos con parámetros desde 0,5B hasta 72B, sobresaliendo en rendimiento en varios puntos de referencia. Los modelos están diseñados para ser versátiles y comercialmente accesibles, admiten múltiples idiomas y presentan capacidades mejoradas en código, matemáticas y más.

El impresionante rendimiento y la accesibilidad abierta de Qwen2 lo posicionan como un competidor formidable para las alternativas de código cerrado, fomentando la innovación y el desarrollo de aplicaciones en IA.

Conclusiones clave

  • Qwen2 continúa la tendencia de los LLM de código abierto de alta calidad, proporcionando alternativas sólidas a los modelos de código cerrado.
  • La serie Qwen2 incluye modelos desde 500 millones hasta 72 mil millones de parámetros, que satisfacen diversas necesidades computacionales y casos de uso.
  • Los modelos Qwen2 están previamente entrenados en más de 27 idiomas, lo que mejora su aplicabilidad en contextos globales.
  • Las licencias que permiten el uso comercial promueven la adopción e innovación generalizadas de los modelos Qwen2.
  • Los desarrolladores e investigadores pueden integrar y utilizar fácilmente los modelos a través de herramientas populares como la biblioteca de transformadores de HuggingFace, haciéndolos accesibles.

Qwen2 es el LLM de código abierto de Alibaba Cloud

Relacionado

Domine la ingeniería rápida avanzada con LangChain para modelos de lenguaje contextuales

La ingeniería rápida se ha vuelto fundamental para aprovechar los modelos de lenguaje grande (LLM) para diversas aplicaciones. Como todos saben, la ingeniería rápida básica cubre técnicas fundamentales. Sin embargo, avanzar hacia métodos más sofisticados nos permite crear modelos de lenguaje robustos, altamente efectivos y conscientes ¡SEGUIR LEYENDO!

¿Cómo crear una aplicación resistente utilizando LlamaIndex?

LlamaIndex es un marco popular para crear aplicaciones LLM. Para crear una aplicación sólida, necesitamos saber cómo contar los tokens incrustados antes de crearlos, asegurarnos de que no haya duplicados en el almacén de vectores, obtener datos de origen para la respuesta generada y muchas otras ¡SEGUIR LEYENDO!