L'une des principales capacités de Llama 3.1 que Meta a mise en avant dans la version est l'appel de fonction ou l'utilisation d'outils. L'auteur a voulu mettre cette capacité à l'épreuve.

L'auteur a d'abord mis en place les outils et les API nécessaires, notamment l'API Groq, qui fournit l'une des API les plus rapides pour interagir avec Llama 3.1. Ils ont testé les modèles Llama 3.1 de 70 milliards et 8 milliards, ainsi qu'une version spécifique à Groq du modèle de 70 milliards affinée.

L'auteur a commencé par un exemple simple d'un seul appel de fonction, puis est passé à des scénarios plus complexes impliquant des appels de fonction parallèles et imbriqués. Ils ont utilisé la plateforme d'observabilité LangTrace pour suivre l'utilisation des jetons et d'autres métriques pendant les expériences.

Les résultats ont montré que le modèle Llama 3.1 de 70 milliards a très bien performé, gérant efficacement les appels de fonction parallèles et imbriqués. Le modèle de 8 milliards a eu du mal avec les tâches plus complexes, tandis que le modèle affiné spécifique à Groq a eu le plus de difficultés, nécessitant souvent des informations ou des clarifications supplémentaires de la part de l'utilisateur.

Dans l'ensemble, l'auteur a conclu que le modèle Llama 3.1 de 70 milliards est la meilleure option pour les cas d'utilisation sérieux d'appel de fonction ou d'agent, démontrant des capacités impressionnantes dans ce domaine. L'auteur a également souligné l'utilité de la plateforme d'observabilité LangTrace pour suivre et comprendre le comportement des modèles de langage de grande taille lors de ce type d'expériences.

Dans cette section, nous allons configurer LangTrace, une plateforme d'observabilité open-source et open-telemetry pour les applications LLM. LangTrace nous permet de suivre le nombre de requêtes et de jetons échangés entre notre environnement local et l'API LLM.

Tout d'abord, nous devons installer les packages requis, notamment le SDK Python LangTrace, le SDK Python Groq et le SDK Python OpenAI (même si nous n'utilisons pas le LLM OpenAI, c'est une dépendance du SDK LangTrace).

Ensuite, nous configurons nos clés d'API. Pour cette expérience, nous n'avons pas strictement besoin de LangTrace, mais il peut fournir des informations précieuses sur l'utilisation de nos jetons. LangTrace a une fonctionnalité similaire à LangSmith, une plateforme d'observabilité de LangChain, mais elle prend en charge une gamme plus large de fournisseurs, notamment OpenAI, Groq, Cohere et Perplexity.

Nous utiliserons la version hébergée sur le cloud de LangTrace, nous devrons donc créer un nouveau compte et un nouveau projet. Une fois que nous aurons notre clé d'API, nous pourrons l'ajouter en tant que secret dans notre notebook.

Une fois la configuration terminée, nous pouvons commencer à utiliser LangTrace pour observer l'utilisation des jetons et d'autres métriques pendant nos expériences d'appel de fonction avec l'API LLM Groq. LangTrace nous fournira des informations détaillées sur le nombre de jetons échangés et les coûts associés (le cas échéant, car Groq ne facture pas l'utilisation de l'API).

En utilisant LangTrace, nous pouvons acquérir des informations précieuses sur les performances et l'efficacité de nos applications alimentées par LLM, ce qui peut être particulièrement utile lors de tests de capacités avancées comme les appels de fonction parallèles et imbriqués.

L'auteur commence par souligner la sortie par Meta d'un système agentique autour de l'appel de fonction dans Llama 3.1. Comme l'auteur n'a pas configuré le système localement, il décide d'utiliser l'API Groq, qui fournit l'une des API les plus rapides pour interagir avec Llama 3.1.

L'auteur teste les modèles Llama 3.1 de 70 milliards et 8 milliards, ainsi qu'une version spécifique à Groq du modèle de 70 milliards affinée. Ils utilisent LangTrace, une plateforme d'observabilité open-source pour les applications LLM, pour suivre le nombre de requêtes et de jetons échangés entre l'environnement local et l'API LLM.

L'auteur commence par un exemple simple, où le modèle doit utiliser une fonction "obtenir les scores des matchs" pour déterminer le vainqueur d'un match de NBA. Le modèle de 70 milliards effectue cette tâche avec succès, et l'auteur examine les données LangTrace pour comprendre le mécanisme interne.

Ensuite, l'auteur teste la capacité des modèles à gérer les appels de fonction parallèles, où l'utilisateur demande des informations sur la météo, les vols, les hôtels et les attractions. Le modèle de 70 milliards est capable de décomposer l'invite initiale, d'effectuer des appels de fonction parallèles et de générer une réponse complète. Le modèle de 8 milliards, cependant, a du mal avec cette tâche, hallucine des informations et ne parvient pas à fournir des réponses complètes.

L'auteur introduit ensuite un scénario plus complexe, où l'utilisateur veut planifier un voyage de New York à Londres puis à Tokyo, en incluant la météo, les vols, les hôtels et les attractions. Encore une fois, le modèle de 70 milliards s'en sort bien, tandis que le modèle de 8 milliards a des difficultés.

Enfin, l'auteur teste le modèle de 70 milliards affiné spécifiquement pour Groq, qui, à sa grande surprise, a du mal même avec la simple tâche "obtenir les scores des matchs", demandant à plusieurs reprises plus de détails spécifiques au lieu d'utiliser la fonction fournie.

En conclusion, l'auteur constate que le modèle Llama 3.1 de 70 milliards est le meilleur performant en matière d'appel de fonction et d'utilisation d'outils, capable de gérer les appels de fonction parallèles et imbriqués. Le modèle de 8 milliards, quant à lui, n'est pas recommandé pour les tâches sérieuses d'appel de fonction. Le modèle affiné spécifique à Groq sous-performe également dans les tests de l'auteur.

Le modèle Llama 3.1, en particulier la version de 70 milliards, a démontré des capacités impressionnantes pour gérer les appels de fonction parallèles et les appels de fonction séquentiels imbriqués.

Lorsqu'on lui a présenté une invite complexe pour planifier un voyage de New York à Paris, en incluant la vérification de la météo, la recherche de vols, d'hôtels et d'attractions, le modèle de 70 milliards a pu décomposer la tâche et effectuer des appels de fonction parallèles pour rassembler les informations nécessaires. Il a ensuite combiné les résultats des différentes fonctions pour fournir un résumé complet des détails du voyage.

Le modèle a également montré sa capacité à gérer les appels de fonction imbriqués, où la sortie d'une fonction était utilisée comme entrée d'une autre. Dans le scénario de recommandation de films, le modèle a pu d'abord sélectionner un film en fonction des préférences de l'utilisateur, puis recommander un en-cas et une plateforme de streaming appropriés pour regarder le film.

En revanche, le plus petit modèle Llama 3.1 de 8 milliards a eu du mal avec ces cas d'utilisation plus avancés. Il n'a pas réussi à fournir de manière cohérente des réponses précises et complètes lorsqu'on lui a demandé de gérer des appels de fonction parallèles ou des appels de fonction imbriqués. Le modèle a souvent halluciné des informations ou n'a pas réussi à utiliser efficacement les outils fournis.

De plus, le modèle d'appel de fonction spécialisé de Groq a également sous-performé lors des tests, n'arrivant pas à utiliser correctement les fonctions fournies et nécessitant des informations plus spécifiques de la part de l'utilisateur.

Dans l'ensemble, le modèle Llama 3.1 de 70 milliards a démontré une forte capacité à gérer des tâches complexes et multi-étapes impliquant des appels de fonction parallèles et imbriqués, montrant son potentiel en tant que système capable d'agir comme un agent. Le plus petit modèle de 8 milliards et le modèle d'appel de fonction de Groq, cependant, ont encore des progrès à faire dans ces domaines.

Le modèle Llama 3.1 de 8 milliards a considérablement lutté avec les tâches d'appel de fonction plus complexes par rapport au modèle plus important de 70 milliards. Voici quelques observations clés :

• Pour la simple fonction "obtenir les scores des matchs", le modèle de 8 milliards a pu la gérer sans problème, de manière similaire au modèle de 70 milliards.

• Cependant, lorsqu'il s'est agi d'appels de fonction parallèles pour des tâches comme la planification de voyage, le modèle de 8 milliards a flanché. Il n'a pas réussi à fournir des informations complètes sur la météo, les vols, les hôtels et les attractions, hallucinant souvent des détails ou ne parvenant pas à énumérer les options disponibles.

• Avec l'ensemble élargi de fonctions, le modèle de 8 milliards a encore plus de difficultés, hallucinant des informations sur des événements et des détails météorologiques qui n'étaient pas demandés.

• Le modèle de 8 milliards a également eu du mal avec les appels de fonction imbriqués pour la tâche de recommandation de films. Il n'a pas réussi à utiliser correctement les outils fournis et s'est rabattu sur la suggestion directe de films.

• Le modèle d'appel de fonction spécialisé de Groq a également mal performé lors des tests, demandant souvent plus de détails spécifiques plutôt que d'utiliser efficacement les outils fournis.

En revanche, le modèle Llama 3.1 de 70 milliards a démontré des capacités beaucoup plus solides pour gérer les appels de fonction parallèles et imbriqués, fournissant des réponses complètes et précises. Le modèle de 8 milliards ne semble tout simplement pas prêt pour les tâches sérieuses d'appel de fonction ou les tâches d'agent, et le modèle spécialisé de Groq a également sous-performé dans ces tests.

Pour l'observabilité et le traçage de ces appels de fonction LLM, la plateforme open-source LangTrace s'est avérée être un outil utile pour surveiller l'utilisation des jetons et les interactions avec l'API.

Le modèle Llama 3 affiné par Groq pour l'appel de fonction a eu du mal lors des tests par rapport au modèle Llama 3.1 plus important de 70 milliards. Voici quelques principales conclusions :

• Lorsqu'on lui a demandé de fournir le score d'un match des Warriors, le modèle a demandé plus de détails spécifiques comme la date ou l'équipe adverse, plutôt que d'utiliser la fonction "obtenir les scores des matchs" fournie.
• Pour les demandes de planification de voyage, le modèle a à plusieurs reprises demandé plus de détails spécifiques comme les dates de voyage, plutôt que d'utiliser les fonctions fournies pour générer une réponse.
• Pour la tâche de recommandation de soirée cinéma, le modèle a eu du mal à utiliser les fonctions imbriquées et s'est souvent rabattu sur la fourniture d'une recommandation de film directe.

Dans l'ensemble, le modèle Llama 3 affiné par Groq n'a pas aussi bien performé que le modèle Llama 3.1 de 70 milliards sur les tests d'appel de fonction et d'utilisation d'outils. Le modèle de 70 milliards a démontré de solides capacités dans les appels de fonction parallèles et imbriqués, tandis que le modèle affiné a semblé avoir du mal à tirer parti des outils et des fonctions fournis. Un affinage ou une optimisation supplémentaire peut être nécessaire pour que le modèle Groq atteigne les performances de la version Llama 3.1 plus importante sur ce type de tâches.

Le modèle LLAMA 3.1 de 70 milliards de Groq a très bien performé lors des tests d'appel de fonction et d'utilisation d'outils. Il a été capable de gérer les appels de fonction parallèles ainsi que les appels de fonction imbriqués avec facilité, démontrant ses fortes capacités en tant que système agentique.

En revanche, le modèle LLAMA 3.1 de 8 milliards a eu du mal avec ces tâches plus complexes, soulignant l'importance d'utiliser des modèles de langage plus importants et plus performants pour ce type d'applications.

Le modèle d'appel de fonction spécialisé de Groq, cependant, n'a pas aussi bien performé que prévu, même avec l'exemple fourni. Cela suggère que le processus d'affinage de ce modèle n'a peut-être pas été aussi efficace que souhaité.

Pour les besoins d'observabilité et de traçage, la plateforme open-source LangTrace AI s'est avérée être un outil précieux, fournissant des informations détaillées sur l'utilisation des jetons et les appels d'API effectués par les modèles de langage pendant les expériences.

Dans l'ensemble, les résultats démontrent le potentiel des modèles de langage de grande taille comme LLAMA 3.1 pour l'appel de fonction et l'utilisation d'outils, mais soulignent également la nécessité de poursuivre la recherche et le développement pour améliorer les capacités des modèles plus