Les modèles Quen 2 d'Alibaba sont les derniers et les plus performants modèles de langage open-source, offrant des capacités impressionnantes dans une large gamme de tâches. Ces modèles vont de 500 millions à 72 milliards de paramètres, les plus grands modèles prenant en charge jusqu'à 128 000 jetons - une amélioration significative par rapport à la limite de 8 000 jetons de GPT-3.

L'une des principales caractéristiques de Quen 2 est sa forte performance dans la programmation et les mathématiques, ainsi que sa capacité à gérer la compréhension de longs contextes - cruciale pour les applications du monde réel. De plus, les modèles offrent un support pour un ensemble diversifié de langues, notamment un accent mis sur les langues du Moyen-Orient et d'Asie du Sud-Est, ce qui est un changement bienvenu par rapport à l'accent mis sur les langues occidentales de nombreux autres modèles.

Pour tirer parti de la puissance de Quen 2, nous pouvons utiliser le cadre Quen Agent, qui fournit un accès à un assistant de navigateur intégré, un interpréteur de code et la possibilité de créer des assistants personnalisés. Cela nous permet de construire des agents autonomes capables de planifier, d'exécuter et d'adapter leurs actions en fonction de la tâche à accomplir.

Dans cette section, nous explorerons comment utiliser Quen Agent pour créer un agent de génération d'images personnalisé. L'agent sera capable de générer des images en fonction des entrées de l'utilisateur, de télécharger les images générées et même de mettre à jour son propre code s'il rencontre des problèmes. En combinant la puissante compréhension du langage de Quen 2 avec les capacités de planification et d'exécution de Quen Agent, nous pouvons créer des agents véritablement autonomes et capables de relever une grande variété de tâches.

L'appel de fonction et les agents sont deux concepts distincts dans le monde des modèles de langage de grande taille (LLM). Voici une explication concise des différences entre les deux :

Appel de fonction (utilisation d'outils) :

• L'appel de fonction, ou l'utilisation d'outils, permet au LLM d'interagir avec le monde extérieur en accédant à des API ou à des fonctions externes.
• Le LLM détermine quelle fonction utiliser en fonction de l'entrée de l'utilisateur, génère les entrées nécessaires pour la fonction et renvoie les résultats à l'utilisateur.
• Cependant, le LLM lui-même ne peut pas exécuter l'appel de fonction ; l'utilisateur ou un système distinct doit effectuer l'appel de fonction et renvoyer les résultats au LLM.

Agents :

• Les agents sont des instances plus sophistiquées de LLM qui ont accès à un ensemble d'outils, tout comme dans l'appel de fonction.
• Les agents peuvent également effectuer de la planification, décomposer les tâches en sous-objectifs et exécuter des actions à l'aide des outils disponibles.
• Les agents ont accès à une mémoire à court et à long terme, leur permettant de suivre leur progression et de planifier leurs prochaines étapes en conséquence.
• Les agents sont essentiels pour rendre les LLM vraiment utiles dans les applications du monde réel, car ils peuvent effectuer de manière autonome des tâches complexes.

En résumé, l'appel de fonction est une interaction plus limitée où le LLM ne peut que générer les entrées nécessaires pour une fonction, tandis que les agents ont la capacité de planifier, d'exécuter et d'adapter leurs actions pour atteindre un résultat souhaité.

Pour commencer avec les agents Qwen, nous utiliserons la version de 72 milliards de Qwen 2 et l'exécuterons localement à l'aide d'AMA. Vous pouvez également utiliser leur API externe, mais pour utiliser Qwen Agent, nous avons deux options :

1. Installez le package à l'aide de pip en tant que package Python indépendant.
2. Clonez le dépôt et exécutez l'installation localement si vous voulez la dernière version de développement.

Je l'exécuterai localement à l'aide d'AMA. Tout d'abord, démarrez un serveur AMA et utilisez la commande olama Run Qwen 272 billion. Cela téléchargera AMA et le modèle, ce qui peut prendre un certain temps selon votre vitesse Internet.

Ensuite, créez un environnement virtuel à l'aide de conda et activez-le :

conda create -n qwen python=3.10
conda activate qwen

Maintenant, installez le package Qwen Agent à l'aide de pip :

pip install qwen-agent

Nous commencerons par l'appel de fonction. Le modèle doit choisir la fonction à utiliser, déterminer les entrées et les transmettre à un interpréteur Python. L'interpréteur exécutera la fonction, obtiendra la réponse et la transmettra à nouveau au LLM.

Voici un exemple d'appel de fonction pour obtenir la météo actuelle :

# Créer l'instance LLM
llm = QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1")

# Message de l'utilisateur
user_message = "Quel est le temps actuel à Paris ?"

# Définir la fonction
function_call = {
    "description": "Obtenir la météo actuelle pour un emplacement donné",
    "function": "get_weather",
    "arguments": {
        "location": "Paris",
        "unit": "celsius"
    }
}

# Appeler le LLM et exécuter la fonction
response = llm.call_with_function(user_message, [function_call])
print(response)

Cela générera les informations météorologiques actuelles pour Paris et les renverra au LLM.

Maintenant, examinons un exemple d'utilisation de Qwen Agent. Nous allons créer un agent personnalisé capable de générer des images et de les télécharger dans un dossier local. L'agent utilisera un outil personnalisé pour la génération d'images et l'interpréteur de code pour exécuter le code nécessaire.

from qwen_agent import Assistant, CodeInterpreter, CustomTool

# Définir l'outil de génération d'images personnalisé
class MyImageGeneration(CustomTool):
    def __init__(self):
        self.description = "Générer des images en fonction de l'entrée de l'utilisateur à l'aide de l'API Pollinations.AI."

    def run(self, args):
        # Générer l'image à l'aide de l'API
        image_url = generate_image(args["prompt"])
        
        # Télécharger l'image dans un dossier local
        download_image(image_url, "images")

        return "Image générée et enregistrée dans le dossier 'images'."

# Créer l'agent
agent = Assistant(
    llm=QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1"),
    tools=[MyImageGeneration(), CodeInterpreter()]
)

# Demander à l'agent de générer une image
agent.run("Créer une image d'un lama portant des lunettes de soleil.")

Cet agent utilisera l'outil de génération d'images personnalisé pour créer l'image, la télécharger dans le dossier "images" et renvoyer le résultat.

Enfin, examinons l'impact de la quantification sur les performances des modèles Qwen. L'équipe Qwen a fourni des évaluations détaillées sur les métriques MML, C-Evolve et I-Evolve pour différents niveaux de quantification.

Les résultats montrent que pour les modèles plus importants (72 milliards), la différence entre la quantification 16 bits et 8 bits n'est pas significative, mais la quantification 4 bits peut avoir un impact plus notable sur les performances. Pour les modèles plus petits (0,5 milliard), les différences sont plus prononcées, avec une baisse de 5 points des scores moyens pour la quantification 4 bits.

En général, il est recommandé d'utiliser au moins la quantification 8 bits ou 16 bits pour les déploiements de production, car la quantification 4 bits peut avoir un impact plus important sur les performances du modèle, en particulier pour les modèles plus petits.

Dans cette section, nous allons explorer l'impact de la quantification sur les performances des modèles de langage de grande taille, en nous concentrant plus particulièrement sur les modèles Quin 2.

L'équipe Quin a abordé la question de l'impact de la quantification dans leurs modèles mis à jour. Ils ont évalué les performances des modèles Quin 2 avec différents niveaux de quantification, notamment la quantification en virgule flottante 16, 8 bits, 4 bits et AWQ (Adaptive Weight Quantization).

D'après les chiffres moyens, les tendances suivantes peuvent être observées :

1. Modèles plus importants : Pour le modèle plus important de 72 milliards de paramètres, la différence de performance entre la quantification 16 bits et 8 bits n'est pas significative, avec environ 81 % de la performance d'origine maintenue. Cependant, la quantification 4 bits montre une baisse de performance plus notable.

2. Modèles plus petits : Pour les modèles plus petits, comme la version de 0,5 milliard de paramètres, l'impact de la quantification est plus dramatique. La quantification 4 bits montre une différence de 5 points dans le score moyen par rapport à la version d'origine en virgule flottante 16.

La principale conclusion est que l'impact de la quantification est plus prononcé sur les modèles plus petits, tandis que les modèles Quin 2 plus importants peuvent maintenir des performances relativement élevées même avec une quantification 8 bits.

Lors du déploiement de ces modèles en production, il est généralement recommandé d'utiliser au moins une quantification 8 bits, et 16 bits si possible, afin d'éviter une dégradation significative des performances, en particulier pour les variantes de modèles plus petits.

En résumé, l'analyse de l'équipe Quin met en évidence l'importance de bien prendre en compte les compromis entre la taille du modèle, le niveau de quantification et les performances lors du déploiement de modèles de langage de grande taille dans des applications du monde réel.