Avancées dans les modèles de langage sur appareil

Les modèles de langage sont des outils super importants qui aident les ordis à comprendre et répondre à la langue humaine. Ils sont utilisés dans plein d'applis, surtout pour automatiser des workflows. Une des capacités clés de ces modèles, c'est d'appeler des fonctions, ce qui les rend utiles pour créer des agents IA. Mais y'a quelques défis quand on utilise de gros modèles qui tournent dans le cloud. Ça peut poser des questions de confidentialité et de coût, ce qui rend les gens un peu réticents à les utiliser.

Pour régler ces soucis, les chercheurs bossent sur des modèles plus petits qui peuvent tourner sur des appareils comme les smartphones et les ordis. Ces modèles plus petits peuvent être plus rapides et moins chers à utiliser, mais souvent, ils galèrent avec la précision et la vitesse. Cet article parle d'une nouvelle méthode qui améliore un modèle sur appareil avec 2 milliards de paramètres. Ce modèle fonctionne mieux que des modèles plus grands comme GPT-4 en termes de précision et de latence.

#Workflows Automatisés avec des Agents IA

Les agents IA sont de plus en plus répandus dans les applis logicielles. On a des outils comme MultiOn et Adept AI, qui aident les utilisateurs à accomplir des tâches plus efficacement. La récente montée des produits IA pour les consommateurs, comme Rabbit R1 et Humane AI Pin, montre bien la demande pour des assistants intelligents. Les agents IA s'améliorent pour prendre les demandes humaines et les traduire en actions concrètes, mais souvent, ils dépendent de grands modèles basés dans le cloud pour cette fonctionnalité.

Ces gros modèles peuvent gérer efficacement l'Appel de fonctions, mais ils ont des inconvénients. Les utiliser peut coûter cher, surtout quand on a besoin de beaucoup d'appels de fonctions. Par exemple, utiliser un modèle comme GPT-4 peut coûter environ 0,24 $ pour une conversation d'une heure avec un bot IA. De plus, des préoccupations concernant la confidentialité peuvent décourager les utilisateurs d'utiliser des modèles qui traitent des infos sensibles dans le cloud.

#Défis des Appareils en Bordure

Pour minimiser les coûts et améliorer la confidentialité, il y a une tendance à créer des modèles plus petits qui tournent sur des appareils en bordure. Ces appareils incluent des smartphones, des voitures, des casques de réalité virtuelle et des ordinateurs personnels. Mais les modèles plus petits font face à des défis comme des vitesses de traitement plus lentes et une autonomie limitée, ce qui les rend moins efficaces pour un usage continu.

La recherche montre que la consommation d'énergie pour les modèles plus petits est significative : environ 0,1 J par jeton pour des modèles de 1 milliard de paramètres. Ça veut dire qu'un modèle qui utilise une méthode de récupération traditionnelle pourrait consommer beaucoup d'énergie avec chaque appel de fonction, limitant le nombre d'appels qu'un appareil peut gérer en une journée.

Les modèles plus petits galèrent souvent avec les tâches de raisonnement et ont souvent besoin d'un tuning considérable pour améliorer leurs capacités d'appel de fonctions. Notre recherche a développé une méthode pour régler ces problèmes, améliorant à la fois la précision et la vitesse pour l'appel de fonctions dans les modèles plus petits.

#Aperçu de la Méthode

La nouvelle méthode se concentre sur la Tokenisation des noms de fonctions et le fine-tuning du modèle avec des jetons fonctionnels spéciaux. En faisant ça, le modèle peut mieux comprendre les capacités des applis logicielles. Quand le modèle fait des prédictions, il utilise ces jetons pour générer des appels de fonctions plus précis.

En pratique, notre modèle peut maintenant gérer plus d'appels de fonctions qu'avant et le fait beaucoup plus vite. On a réussi à réduire de 95 % la longueur de contexte, ce qui se traduit directement par des temps de traitement plus rapides. Par exemple, avec 2 milliards de paramètres, notre modèle permet d'avoir 37 fois plus d'appels de fonctions sans vider la batterie comparé aux méthodes traditionnelles.

#Travaux Connexes sur les Modèles Sur-Appareil

Bien que déployer de plus grands modèles de langue sur des appareils puisse être délicat à cause des limitations de mémoire et de vitesse, plusieurs modèles open-source plus petits, comme Gemma-2B et Llama-7B, ont vu le jour. Les efforts pour améliorer la vitesse d'inférence ont conduit au développement de frameworks qui peuvent faire tourner ces modèles sur des appareils mobiles.

Il y a eu des progrès significatifs dans l'amélioration des capacités d'appel de fonctions des modèles plus petits. Des projets récents ont montré que des modèles avec 7 milliards et 13 milliards de paramètres peuvent appeler des API externes aussi efficacement que des modèles plus grands. Des versions antérieures comme Octopus v1 ont prouvé qu'un modèle avec 2 milliards de paramètres pouvait performer à un niveau similaire.

#Techniques d'Appel de Fonctions

À mesure que les modèles de langage s'améliorent, leurs capacités d'appel de fonctions deviennent plus efficaces. Des projets notables ont démontré un appel d'API efficace en utilisant des techniques avancées. Le modèle Octopus v1 a précédemment montré la capacité des modèles plus petits à égaler leurs homologues plus grands en performance.

Notre approche utilise une méthode appelée génération augmentée par récupération (RAG) pour l'appel de fonctions. Cela implique que le modèle récupère des fonctions pertinentes en fonction des requêtes des utilisateurs et utilise ces fonctions comme contexte pour générer des réponses.

#Fine-Tuning des Modèles

Le fine-tuning des modèles de langue est une pratique courante dans le domaine. Une méthode populaire est LoRA, qui permet aux modèles d'apprendre efficacement même avec des ressources informatiques limitées. Notre travail intègre à la fois l'entraînement complet du modèle et LoRA, comparant leurs performances.

LoRA aide à étendre les capacités des modèles, ouvrant des avenues pour des applis à travers diverses tâches. Dans notre cas, on a utilisé un ensemble de données d'APIs Android pour le fine-tuning, aidant le modèle à apprendre des fonctions spécifiques liées aux opérations des smartphones.

#Comment les Fonctions Sont Sélectionnées

Sélectionner la bonne fonction à appeler implique plusieurs étapes. La première étape nécessite de comprendre la description de la fonction et quels arguments elle nécessite. On utilise une méthode où le modèle regarde les requêtes des utilisateurs pour déterminer quelle fonction appeler.

Une option est d'utiliser un modèle de classification qui identifie la meilleure fonction en fonction de sa similarité avec la requête. Sinon, on peut combiner plusieurs modèles pour prédire avec précision les noms de fonctions. En structurant intelligemment ce processus, on peut améliorer à la fois la précision et l'efficacité.

#Innovation des Jetons de Fonction

Une des innovations clés de notre méthode est l'introduction de jetons fonctionnels. Ces jetons sont comme des mots spéciaux qui représentent des fonctions spécifiques, simplifiant la tâche du modèle à reconnaître et appeler ces fonctions.

Tout comme les modèles de langage apprennent à reconnaître des mots courants, notre modèle peut apprendre ces jetons fonctionnels à travers le processus d'entraînement. Cela lui permet de se concentrer sur l'exécution d'actions spécifiques de manière efficace. En boostant la connaissance du modèle de ces jetons, on peut obtenir de meilleures performances dans l'appel de fonctions.

#Collecte de Données pour l'Entraînement

Créer un ensemble de données de haute qualité est essentiel pour entraîner et valider les modèles. On a rassemblé des APIs Android en fonction de leur utilité, fréquence d'utilisation et complexité technique. Ce processus a inclus l'organisation des APIs en catégories pour garantir une exécution réaliste des fonctions.

On a compilé une gamme d'APIs système, d'APIs d'applications et d'APIs de gestion de dispositifs intelligents. Cette sélection garantit que le modèle peut comprendre et générer des appels de fonctions dans divers scénarios efficacement.

#Génération et Vérification des Données

Le processus de génération d'ensembles de données implique de créer des exemples positifs et négatifs. Les exemples positifs sont des requêtes qui peuvent être résolues avec une seule API, tandis que les exemples négatifs incluent des requêtes qui ne correspondent à aucune fonction. Équilibrer ces deux types permet au modèle d'améliorer sa compréhension et ses capacités analytiques.

Pour garantir la qualité de l'ensemble de données, on a mis en place un mécanisme de vérification qui évalue la précision des appels de fonction générés. Ce système utilise des vérifications pour régénérer des résultats s'ils ne respectent pas les standards.

#Entraînement et Développement du Modèle

On base notre développement sur le modèle Google Gemma-2B. Notre entraînement inclut à la fois l'entraînement complet du modèle et les approches LoRA. Pendant l'entraînement, on utilise des techniques optimisées pour aider le modèle à apprendre efficacement.

Pour les deux méthodes d'entraînement, on fixe un taux d'apprentissage et planifie le nombre d'époques d'entraînement. Évaluer la performance implique de comparer les résultats de notre modèle avec ceux des modèles les mieux classés pour évaluer les métriques de précision et de vitesse.

#Appels de Fonctions Android

Pour démontrer le fonctionnement de notre modèle, on l'a appliqué aux appels de fonctions système Android. On s'est concentré sur la génération de commandes d'appels de fonctions précises basées sur les requêtes des utilisateurs. Cela impliquait d'utiliser différentes méthodes pour échantillonner les requêtes et étiqueter les résultats attendus.

En comparant les performances de notre modèle à d'autres, on a pu mesurer sa précision et sa latence de manière efficace. Ce processus de benchmarking aide à déterminer l'application pratique de notre modèle dans des scénarios réels.

#Résultats et Évaluations

Nos résultats montrent que le modèle Octopus obtient des résultats exceptionnels quand il est testé par rapport à d'autres modèles. Avec un taux de précision élevé, il génère avec succès des appels de fonction corrects tout en maintenant une latence basse. C'est une amélioration significative par rapport à des modèles plus grands comme GPT-4 et GPT-3.5.

On a aussi examiné à quel point les techniques RAG sont efficaces pour minimiser les erreurs et optimiser la latence. En se concentrant sur la récupération des descriptions de fonctions pertinentes, notre modèle a démontré des performances impressionnantes.

#Applications au-delà d'Android

En élargissant l'application de notre modèle, on a exploré comment il pourrait fonctionner dans d'autres domaines, comme les véhicules et des services consommateurs comme Yelp et DoorDash. En appliquant les mêmes méthodes de benchmarking, on a découvert que notre approche conservait des niveaux de performance cohérents à travers différents ensembles de fonctions.

Cette adaptabilité permet aux développeurs de personnaliser le modèle selon leurs besoins spécifiques, augmentant son utilité dans différentes applications.

#Entraînement avec peu de données

Bien que notre modèle ait bien performé avec 1 000 points de données par API, on a aussi examiné comment il pourrait toujours fonctionner efficacement avec moins de points de données. Notre analyse a révélé que réduire l'ensemble de données à 100 points produisait encore des taux de précision impressionnants, rendant le processus d'entraînement plus rentable.

Cette capacité à s'entraîner avec moins de ressources rend le modèle plus accessible aux développeurs cherchant à déployer des agents IA efficaces.

#Conclusion

Le modèle Octopus représente une avancée significative dans le domaine des modèles de langage sur appareil. Notre méthode simplifie l'appel de fonctions et améliore les interactions des utilisateurs avec les agents IA. L'introduction de jetons fonctionnels, combinée à une collecte et vérification efficaces des données, permet des réponses précises et efficaces.

Dans le futur, on prévoit de développer des modèles axés sur le raisonnement sur appareil et d'améliorer les options de déploiement pour diverses applications. Notre objectif est de fournir une solution qui équilibre les préoccupations de confidentialité avec le besoin de vitesse, permettant aux utilisateurs de choisir ce qui fonctionne le mieux pour eux.

À travers notre recherche, on encourage les développeurs à tirer parti de ces innovations, simplifiant la création d'agents IA qui peuvent grandement améliorer les expériences utilisateurs dans des applications variées.