Gorilla LLM : Un grand modèle de langage connecté à des API massives

Si cet article vous intéresse et que vous souhaitez en savoir plus sur les compétences pratiques dans le domaine de l'IA, vous pouvez prêter attention au compte public « Technology Craze AI » . Ici, vous pouvez voir les articles les plus récents et les plus populaires sur les produits secs et les didacticiels de cas dans le domaine AIGC.

Introduction

À l'ère numérique d'aujourd'hui, le développement du modèle linguistique à grande échelle (LLM) progresse à pas de géant. Le modèle linguistique à grande échelle (LLM) qui émerge au pays et à l'étranger peut être décrit comme une centaine de fleurs qui s'épanouissent. bons modèles, qu'ils soient open source ou fermés. Cependant, dans l'utilisation de LLM Lors du développement d'applications, vous constaterez que chaque modèle présente plus ou moins de différences en termes de déploiement, de formation, de réglage fin, de développement d'interface API, d'invite d'invite format Word, etc. Si un produit doit être connecté à différents LLM ou changer rapidement. Lorsque le modèle devient plus complexe, il n'est pas si pratique à utiliser et pas facile à entretenir. Cependant, bien que LLM ait fait de grands progrès, faire face à autant de LLM a posé d'énormes défis aux développeurs. Lorsque nous appelons ces modèles LLM, nous devons consulter un grand nombre de documents d'interface API et écrire des codes de test pour le débogage. Appels d'API incorrects. Pour résoudre ce problème, Gorilla LLM est né, un modèle affiné basé sur LLaMA, qui vise à connecter des modèles de langage à grande échelle avec divers services et applications fournis via l'API.

L'émergence de Gorilla LLM compense les défauts des méthodes traditionnelles. Il est plus performant que GPT-4 dans l'écriture des appels d'API et peut s'adapter aux modifications de la documentation pendant les tests, permettant des mises à jour d'API et des changements de version flexibles. De plus, Gorilla résout efficacement le problème courant des hallucinations en invitant directement LLM. En introduisant APIBench, un ensemble de données complet composé des API HuggingFace, TorchHub et TensorHub, nous pouvons évaluer les performances de Gorilla LLM. Après avoir intégré avec succès le système de récupération à Gorilla, LLM peut utiliser l'outil avec plus de précision et suivre les documents fréquemment mis à jour, augmentant ainsi la fiabilité et l'applicabilité de sa sortie.

L'EasyLLM que nous avons présenté précédemment « EasyLLM : simplifier le traitement du modèle de langage et réaliser une commutation transparente entre les clients OpenAI et Hugging Face » vise principalement à simplifier et à améliorer le processus de traitement du LLM. Une API client compatible est fournie pour permettre aux utilisateurs de basculer facilement entre différents LLM en modifiant une seule ligne de code. Ensuite, à mesure que le nombre de modèles connectés augmente, la quantité de développement elle-même ne diminuera pas. EasyLLM doit étendre continuellement son interface API, et Gorilla LLM est un pas de plus, en utilisant de grands modèles de langage pour former et apprendre les interfaces et les documents de l'API ML, Identifiez et faites correspondre automatiquement les interfaces et les paramètres en fonction du langage naturel. Cela améliore considérablement l'efficacité des développeurs.Dans le même temps, nous pouvons également utiliser Gorilla LLM pour former l'interface des produits de l'entreprise, améliorer davantage la méthode d'interaction des produits et utiliser directement le langage naturel pour réaliser des appels d'interface et des interactions matérielles entre les systèmes.

Ensuite, nous présenterons en détail les concepts de base de Gorilla LLM, ses avantages en termes de performances et son fonctionnement dans des applications pratiques. Explorons comment Gorilla LLM peut offrir une expérience d'appel d'API plus intelligente et plus pratique aux développeurs, aux chercheurs et aux utilisateurs.

2. Introduction de base de Gorilla LLM

Gorilla LLM est un modèle de langage à grande échelle (LLM) avancé conçu pour comprendre et appeler avec précision plus de 1 600 API en interprétant les requêtes en langage naturel . Ilsélectionne et exploite des outils dont les capacités se chevauchent et évoluent grâce à l'utilisation de techniques d'autogestion et de récupération . Gorilla est évalué à l'aide de l'ensemble de données complet APIBench et dépasse les performances de GPT-4 en matière de génération d'appels API.

Gorilla LLM est un grand modèle linguistique (LLM) connecté à une API. Il est formé sur une documentation API complète pour construire l'appel API correct, y compris les paramètres d'entrée corrects, pour une question en langage naturel donnée. Gorilla est plus précis et moins susceptible d'halluciner de faux appels d'API que les techniques d'appel d'API précédentes. Gorilla est un outil utile pour les développeurs cherchant à automatiser des opérations ou à créer des applications à l'aide d'API. Dans le même temps, les chercheurs intéressés par l’utilisation de l’API dans le traitement du langage naturel peuvent également en profiter.

Gorilla LLM a été développé par des chercheurs de l'UC Berkeley et de Microsoft. Il est conçu pour les appels d'API et peut générer des appels d'API sémantiquement et syntaxiquement corrects en réponse à des requêtes en langage naturel. Par exemple, lorsque vous demandez à Gorilla « obtenir la météo à Pékin », il générera un appel à l'API OpenWeatherMap pour obtenir les conditions météorologiques actuelles à San Francisco.

Gorilla LLM est formé sur de grands ensembles de données de hub d'apprentissage automatique tels que Torch Hub, TensorFlow Hub et HuggingFace . De nouveaux domaines sont ajoutés rapidement, notamment Kubernetes, GCP, AWS, OpenAPI, etc. Gorilla surpasse GPT-4, Chat-GPT et Claude et a beaucoup moins de fiabilité en matière d'erreurs d'hallucination.

Enfin, Gorilla LLM est sous licence Apache 2.0 avec des réglages fins sur MPT et Falcon , vous pouvez donc utiliser Gorilla à des fins commerciales sans aucune obligation.

2.1. Principales caractéristiques

Gorilla LLM présente les caractéristiques clés suivantes :

Invoquez avec précision plus de 1 600 API à l’aide de requêtes en langage naturel : Gorilla LLM peut invoquer avec précision plus de 1 600 API via des requêtes en langage naturel. Cela signifie que les développeurs peuvent décrire leurs besoins en langage naturel sans avoir à se plonger dans la documentation et les détails de chaque API.
Réduire les hallucinations dans LLM : Gorilla LLM est spécifiquement optimisé pour les erreurs d'hallucinations. Les bugs d'hallucination sont du code généré avec de mauvaises API ou des API qui n'existent pas. En réduisant les erreurs d'hallucination, Gorilla LLM peut fournir des appels API plus fiables et plus précis.
Convivial et adaptable à divers besoins et outils : Gorilla LLM est conçu pour être convivial et flexible pour s'adapter à divers besoins et outils. Il peut être personnalisé en fonction des exigences et de l'environnement de l'utilisateur et propose des solutions adaptées à différents scénarios de développement.
Open source et en constante évolution grâce aux contributions de la communauté : Gorilla LLM est un projet open source qui évolue et s'améliore continuellement grâce aux contributions de la communauté. Cela signifie que les développeurs peuvent participer au projet, piloter son développement ensemble et recevoir le soutien et les commentaires de la communauté.
Intégration avec d'autres outils : Gorilla LLM est conçu pour fonctionner de manière transparente avec d'autres outils LLM tels que Langchain, ToolFormer et AutoGPT. Il a une bonne adaptabilité et peut être facilement intégré à diverses applications et chaînes d'outils, offrant aux développeurs plus de choix et de flexibilité.

Gorilla LLM fournit aux développeurs un appel d'API puissant et flexible en appelant avec précision l'API, réduisant les erreurs d'hallucination, convivial et adaptable à divers besoins et outils, open source et évoluant continuellement grâce aux contributions de la communauté et à l'intégration avec d'autres outils pour générer une solution.

2.2. Scénarios d'application

Gorilla peut être appliqué aux scénarios suivants :

Créez de nouvelles API pour les applications mobiles : Grâce à Gorilla, les développeurs peuvent apprendre à LLM comment appeler de nouvelles API avec les paramètres et le contexte corrects, créant ainsi de nouvelles fonctions et services pour les applications mobiles.
Mettre à jour les API existantes pour prendre en charge de nouvelles fonctionnalités : lorsque de nouvelles fonctionnalités ou modifications doivent être ajoutées aux API existantes, Gorilla peut aider les développeurs à mettre à jour les appels d'API pour prendre en charge de nouvelles exigences fonctionnelles en enseignant à LLM les paramètres et le contexte corrects.
Débogage des appels API qui ne fonctionnent pas : Gorilla peut être utilisé comme outil de débogage en cas de problème avec un appel API. En enseignant à LLM les paramètres et le contexte corrects, les développeurs peuvent analyser et corriger les appels d'API qui ne fonctionnent pas, améliorant ainsi l'efficacité du débogage.

Gorilla peut être utile dans des scénarios tels que la création de nouvelles API, la mise à jour des API existantes pour prendre en charge de nouvelles fonctionnalités et le débogage des appels d'API qui ne fonctionnent pas correctement. Il aide les développeurs à effectuer plus efficacement les travaux d'intégration et de débogage des API en enseignant à LLM les paramètres et le contexte corrects.

2.3. Valeur de l'application

La valeur appliquée du LLM réside dans la résolution des défis liés à l’intégration des API et à l’achèvement des tâches. Les solutions traditionnelles sont généralement basées sur des indices et ne peuvent pas gérer des API à grande échelle et en constante évolution. Dans le même temps, trouver l’API et les paramètres appropriés pour une tâche spécifique peut s’avérer un véritable défi. Cela ne se limite pas aux API spécialisées, mais inclut également des services couramment utilisés tels qu'AWS, GCP et Azure, chacun proposant des milliers d'API, chacune avec de nombreux paramètres d'entrée différents. Les solutions de contournement actuelles reposent sur des experts humains ou nécessitent des recherches fastidieuses dans la documentation des API et les ressources en ligne, ce qui rend le processus de création d'applications complexes inefficace et difficile à gérer.

Pour résoudre ce problème, Gorilla a vu le jour. Nous pensons que si vous pouvez apprendre à LLM comment effectuer des appels d'API avec les paramètres et le contexte corrects, vous pouvez facilement connecter tous les outils dont vous avez besoin pour créer de puissantes applications basées sur LLM. L'objectif de Gorilla est de parvenir à un développement d'applications plus efficace et plus pratique en intégrant LLM à divers outils.

La valeur applicative de Gorilla se reflète dans les aspects suivants :

Résoudre le problème de l'intégration des API : Gorilla peut aider LLM à s'intégrer à diverses API, afin que LLM puisse appeler la bonne API et transmettre les paramètres corrects, afin de réaliser le travail collaboratif avec d'autres outils.
Améliorer l'efficacité du développement : Avec Gorilla, les développeurs n'ont pas besoin de s'appuyer sur des experts humains ou de longues recherches de documents API et de ressources en ligne, et peuvent trouver plus rapidement des API et des paramètres adaptés à des tâches spécifiques, améliorant ainsi l'efficacité du développement.
Simplifier la création d'applications : l'objectif de Gorilla est de simplifier l'intégration des outils nécessaires à la création de puissantes applications basées sur LLM. En apprenant à LLM à utiliser correctement les paramètres et les contextes pour les appels d'API, les développeurs peuvent facilement connecter divers outils et réaliser la construction d'applications complexes.

Dans l'ensemble, Gorilla offre un moyen plus efficace et plus pratique de créer de puissantes applications basées sur LLM en résolvant les défis liés à l'intégration des API et à l'exécution des tâches. Dans le même temps, Gorilla peut être utilisé pour effectuer diverses tâches, notamment : créer du texte, traduire des langues, répondre à des requêtes, créer de nombreux types de supports créatifs, accéder et traiter des informations provenant de diverses sources.

2.4. Avantages de Gorilla LLM

Gorilla LLM présente les avantages suivants par rapport aux méthodes traditionnelles antérieures :

Précision améliorée : Gorilla LLM est plus précis dans les appels API que les méthodes précédentes. Cela signifie que même pour les requêtes complexes, les développeurs peuvent être sûrs que Gorilla LLM créera les appels d'API corrects, améliorant ainsi la précision du code.
Réduire les erreurs d'hallucination : les erreurs d'hallucination font référence à du code généré à l'aide de mauvaises API ou d'API qui n'existent pas. Cela peut entraîner des erreurs d’exécution et du code non fonctionnel. Gorilla LLM est spécialement conçu pour les appels d'API à grand volume, réduisant ainsi le risque d'erreurs d'hallucination.
Gagnez du temps et des efforts : Gorilla LLM peut aider les développeurs à économiser beaucoup de temps et d'efforts. Les développeurs n'ont plus besoin de rechercher manuellement la documentation de l'API et d'écrire du code pour générer des appels d'API ; à la place, Gorilla LLM peut générer des appels d'API appropriés basés sur des requêtes spécifiques en langage naturel, ce qui permet aux développeurs d'économiser du temps et des efforts.
Fiabilité améliorée : Gorilla LLM peut aider les développeurs à écrire du code plus fiable et à réduire les erreurs dans les appels d'API. Lorsque les développeurs écrivent du code pour générer des appels d’API, des erreurs peuvent être commises. Gorilla LLM peut aider à réduire ces erreurs et à améliorer la fiabilité du code en générant des appels d'API sémantiquement et syntaxiquement corrects.
Gérer les API contraintes : les appels d'API ont souvent des limitations et des contraintes inhérentes, obligeant LLM non seulement à comprendre la fonctionnalité de l'API, mais également à classer les appels en fonction de différents paramètres de contrainte. Cela ajoute de la complexité et nécessite une compréhension plus nuancée du LLM. Gorilla LLM peut gérer les appels d'API contraints, tels que la gestion des contraintes telles que la taille des paramètres et la précision minimale, fournissant ainsi des résultats plus précis. Par exemple, une invite telle que « Invoquer un modèle de classification d'images avec moins de 10 millions de paramètres et une précision ImageNet d'au moins 70 % » présente des défis importants pour une interprétation précise des LLM. Le modèle doit comprendre les descriptions des utilisateurs et le raisonnement sur les contraintes intégrées dans les requêtes.

Le modèle fonctionne mieux que les autres LLM lorsqu'il est interrogé avec des systèmes de récupération de documents à l'aide d'indices spécifiques à l'API, améliorant ainsi la fiabilité et l'applicabilité de sa sortie. La figure ci-dessous met en évidence un tel résultat :

Gorilla LLM offre aux développeurs la possibilité de générer des appels d'API plus efficaces, précis et fiables en améliorant la précision, en réduisant les erreurs d'hallucination, en économisant du temps et des efforts, en améliorant la fiabilité et en gérant les API contraintes.

2.5. Pourquoi un réglage fin basé sur LLaMA

À l'heure actuelle, il existe de nombreux modèles open source populaires. Pourquoi Gorilla a-t-il choisi LLaMA plutôt que d'autres modèles ? Plusieurs modèles sont-ils peaufinés et testés ?

LLaMA a été choisi comme point de départ car il est considéré comme le cheval de bataille du LLM open source. De nombreux autres modèles en sont des dérivés pour des applications spécifiques. Bien entendu, Gorilla évalue également Gorilla en utilisant GPT-4, GPT-3.5 et Claude-v1. Compte tenu de la disponibilité commerciale du modèle open source, deux modèles Gorilla basés sur le MPT-7B et le Falcon-7B ont ensuite été publiés. Le modèle Gorilla utilise désormais la licence Apache 2.0, ce qui signifie que Gorilla peut être utilisé commercialement sans aucune contrainte !

2.6. Conditions de base pour la formation de Gorilla

Selon l'introduction officielle, huit nœuds GPU A100 de 40 Go sont utilisés pour former et évaluer tous les modèles. En fonction du modèle et de l'ensemble de données API, le temps requis peut varier considérablement. L'exécution la plus courte a totalisé environ 10 heures GPU , tandis que l'exécution la plus longue a totalisé environ 120 heures GPU . Le processus de formation utilise également toutes les techniques informatiques de pointe (mécanismes d'attention efficaces) et optimisations de mémoire (sharding, points de contrôle et formation à précision mixte) . Aucune LoRA n’est utilisée et tous les modèles Gorilla sont peaufinés de bout en bout.

3. Le principe de base de Gorilla

Gorilla LLM a été formé sur des ensembles de données massifs de documentation et de code API. L'ensemble de données comprend des appels d'API provenant de diverses plates-formes telles que Google Cloud Platform, Amazon Web Services et Microsoft Azure. Gorilla utilise cet ensemble de données pour apprendre la syntaxe et la sémantique des appels API. Lorsque vous demandez à Gorilla de générer un appel API, il essaie d'abord de trouver un appel API correspondant dans son ensemble de données. S'il trouve un appel API correspondant, il renverra simplement cet appel. S'il ne trouve pas d'appel d'API correspondant, il génère un nouvel appel d'API en fonction de sa connaissance de la syntaxe et de la sémantique de l'API.

Voici les étapes clés impliquées dans le processus de l'API de connexion Gorilla :

Invites utilisateur : les utilisateurs fournissent des invites en langage naturel décrivant une tâche ou un objectif spécifique qu'ils souhaitent atteindre à l'aide de l'API.
Récupérer (facultatif) : En mode Récupération, Gorilla récupère la dernière documentation de l'API de la base de données à l'aide d'un récupérateur de documentation tel que BM25 ou GPT-Index. Le document est ensuite concaténé à l'invite utilisateur, avec un message demandant à Gorilla de l'utiliser comme référence.
Génération d'appels API : Gorilla traite les invites de l'utilisateur (et les documents récupérés, le cas échéant) pour générer des appels API appropriés qui répondent à la tâche ou à l'objectif de l'utilisateur. Ceci est réalisé grâce au modèle LLaMA-7B affiné de Gorilla, conçu pour les appels API.
Sortie : Gorilla renvoie les appels d'API générés à l'utilisateur, qui peuvent ensuite être utilisés pour interagir avec l'API souhaitée et terminer la tâche spécifiée.

Notamment, Gorilla est hautement adaptable et peut fonctionner à la fois en mode zéro tir et en mode récupération , ce qui lui permet de s'adapter aux modifications de la documentation de l'API et de maintenir sa précision au fil du temps.

Le premier (et le plus populaire) est le mode zéro tir. Dans ce cas, Gorilla accepte la requête de l'utilisateur en langage naturel et renvoie la bonne API à appeler. Désormais, dans de nombreux scénarios, vous voyez souvent les API évoluer au fil du temps : il peut s'agir d'une gestion des versions, ou les points de terminaison peuvent changer, ou les paramètres peuvent être remaniés, ou certains d'entre eux peuvent être obsolètes.

Pour rendre notre système robuste à cela, nous introduisons un deuxième mode d'utilisation de Gorilla - compatible avec les retrievers. Dans ce cas, Gorilla sélectionne l'API la plus pertinente et l'ajoute à l'invite de l'utilisateur. Cela nous permet de comprendre les changements dans l'API.

4. Comment installer Gorilla LLM

Pour utiliser Gorilla LLM, Python 3.10 ou version ultérieure doit être installé. Les versions antérieures de Python ne seront pas compilées.

4.1. Installer Conda

S'il s'agit d'un tout nouveau serveur, vous devez installer Conda pour la première fois. Dans le terminal, utilisez la commande suivante pour télécharger le script d'installation de Miniconda :

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

Exécutez le script d'installation avec la commande suivante :

bash Miniconda3-latest-Linux-x86_64.sh

Suivez les invites du programme d'installation pour installer. Vous pouvez choisir des options telles que l'emplacement d'installation et les paramètres des variables d'environnement.
Une fois installé, activez l'environnement conda avec la commande suivante :

 source ~/.bashrc

Vérifiez que conda a été installé avec succès avec la commande suivante :

conda --version

Si conda est installé avec succès, vous verrez le numéro de version de conda, j'ai installé conda 23.5.2 ici.

4.2. Installer Gorilla

4.2.1. Installer les dépendances :

Pour créer un nouvel environnement Conda appelé gorilla avec Python 3.10, utilisez la commande suivante :

conda create -n gorilla python=3.10

Activez l'environnement des gorilles :

conda activate gorilla

Installez les packages Python nécessaires avec la commande suivante, s'il existe un fichier nommé exigences.txt et ses dépendances :

pip install -r requirements.txt

4.2.2. Installer le contrepoids Gorilla Delta :

Obtenez les poids LLaMA originaux à partir du lien fourni.

https://huggingface.co/docs/transformers/main/model_doc/llama

Téléchargez les poids delta Gorilla à partir du référentiel Hugging Face.

https://huggingface.co/gorilla-llm/gorilla-7b-hf-delta-v1

4.2.3. Utiliser des poids incrémentiels :

Remplacez les espaces réservés dans les commandes Python suivantes par les chemins de fichiers corrects :

python3 apply_delta.py 
--base-model-path path/to/hf_llama/ 
--target-model-path path/to/gorilla-falcon-7b-hf-v0 
--delta-path path/to/models--gorilla-llm--gorilla-7b-hf-delta-v1

Utilisez cette commande pour appliquer des pondérations incrémentielles à votre modèle LLaMA.

4.2.4. Inférence à l'aide de CLI :

Pour commencer à interagir avec les modèles Gorilla à l'aide de l'interface de ligne de commande (CLI), utilisez les commandes suivantes :

python3 serve/gorilla_falcon_cli.py --model-path path/to/gorilla-falcon-7b-hf-v0
# 如果您在使用 Apple 芯片（M1、M2 等）的 Mac 上运行，请添加 “--device mps”

path/to/gorilla-7b-hf,th,tf-v0Doit être remplacé par le véritable chemin vers le modèle Gorilla.

4.3, structure du code Gorille

4.3.1. Le dossier de données contient divers ensembles de données, notamment des documents API et des ensembles de données APIBench fournis par la communauté.

apiChaque fichier du sous-répertoire représente une API, intitulée {api_name}_api.jsonl.
apibenchLes sous-dossiers contiennent des ensembles de données de formation et d'évaluation du modèle LLM. Il contient des fichiers {api_name}_train.jsonlet {api_name}_eval.jsonl.
Les API fournies par la communauté se apizootrouvent dans des sous-répertoires.

4.3.2. Le dossier eval contient le code d'évaluation et la sortie.

README.mdLes fichiers contiennent des instructions ou des données sur le processus d'évaluation.
Pour recevoir des réponses du modèle LLM, utilisez get_llm_responses.pyle script.
Les sous-répertoires eval-scriptscontiennent des scripts d'évaluation pour chaque API, par exemple ast_eval_{api_name}.py.
Le sous-répertoire eval-data contient les questions et réponses d'évaluation.
questionsLes fichiers de questions dans les sous-dossiers sont organisés par nom d'API et métrique d'évaluation.
- questionsChaque dossier API contient un fichier intitulé dans le sous-répertoire questions_{api_name}_{eval_metric}.jsonl.
responsesLes fichiers de réponses sont également organisés en sous-dossiers par nom d'API et métrique d'évaluation .
- En réponse aux sous-dossiers, chaque dossier API contient des fichiers intitulés responses_{api_name}Gorilla_FT{eval_metric}.jsonlet .jsonl.responses_{api_name}Gorilla_RT{eval_metric}

4.3.3. Le dossier d'inférence contient du code pour exécuter Gorilla localement.

Les fichiers de ce dossier README.mdcontiennent très probablement des instructions pour exécuter du code d'inférence.
serveLes sous-répertoires contiennent des scripts Gorilla Command Line Interface (CLI) et des modèles de discussion.
trainLe dossier est marqué « Coming Soon ! » et devrait probablement contenir le code de formation du modèle Gorilla. Cependant, ce dossier ne semble pas être disponible pour le moment.

Vous pouvez vous référer aux fichiers README dans chaque dossier pour obtenir des instructions et des informations plus spécifiques sur l'utilisation du code et des ensembles de données fournis.

5. Comment utiliser Gorilla LLM

Tout d’abord, installez OpenAI en utilisant pip

pip install openai

Configurez la clé API et la base API comme ceci

import openai

openai.api_key = "EMPTY" # key可以忽略
openai.api_base = "http://34.132.127.197:8000/v1" #http://zanino.millennium.berkeley.edu:8000/v1

5.1. Traduction de texte

Utilisez la bibliothèque OpenAI pour créer des fonctions qui obtiennent des résultats Gorilla

def get_gorilla_response(prompt="我想把英语翻译成中文。", model="gorilla-falcon-7b-hf-v0"):
    completion = openai.ChatCompletion.create(
      model=model,
      messages=[{"role": "user", "content": prompt}]
    )
    return completion.choices[0].message.content

Implémentez la fonction qui envoie l'invite et le modèle que vous souhaitez utiliser, dans ce cas gorilla-falcon-7b-hf-v0 .

prompt = "我想从英语翻译成中文。"
print(get_gorilla_response(prompt, model="gorilla-falcon-7b-hf-v0" ))

C'est ça. Vous recevrez alors des informations complètes de l'API Huggingface et des instructions sur la façon d'effectuer la demande.

<<<domain>>>: Natural Language Processing Translation 
<<<api_call>>>: pipeline('translation_en_to_zh', model='Helsinki-NLP/opus-mt-en-zh') <<<api_provider>>>: Hugging Face Transformers 
<<<explanation>>>: 
1. Import the pipeline function from the transformers library provided by Hugging Face.
2. Use the pipeline function to create a translation model, specifying the model 'Helsinki-NLP/opus-mt-en-zh' to be loaded. This model is trained to translate text from English to Chinese.
3. Pass your English text to the translator object, and it will return the translated Chinese text.

Démo Gorilla HuggingFace :

https://huggingface.co/spaces/davila7/try-gorilla?source=post_page

5.2, détection d'objet

# 对象检测
prompt = "我想构建一个可以检测图像“cat.jpeg”中对象的机器人。输入：['cat.jpeg']"
print(get_gorilla_response(prompt, model="gorilla-falcon-7b-hf-v0"))

Résultat de sortie :

<<<domain>>>: Computer Vision Object Detection
<<<api_call>>>: model = DetrForObjectDetection.from_pretrained('facebook/detr-resnet-101-dc5')
<<<api_provider>>>: Hugging Face Transformers
<<<explanation>>>: 1. Import the necessary components from the Hugging Face Transformers library, torch, and PIL (Python Imaging Library).
2. Open the image using PIL's Image.open() function with the provided image path.
3. Initialize the pretrained DETR (DEtection TRansformer) model and the image processor.
4. Generate inputs for the model using the image processor.
5. Pass the inputs to the model, which returns object detection results.
<<<code>>>:

from transformers import AutoFeatureExtractor, AutoModelForObjectDetection
from PIL import Image
import torch

def load_model():
    feature_extractor = AutoFeatureExtractor.from_pretrained('facebook/detr-resnet-101-dc5')
    model = AutoModelForObjectDetection.from_pretrained('facebook/detr-resnet-101-dc5')
    return feature_extractor, model

def process_data(image_path, feature_extractor, model):
    image = Image.open(image_path)
    inputs = feature_extractor(images=image, return_tensors='pt')
    outputs = model(**inputs)
    results = feature_extractor.post_process(outputs, threshold=0.6)[0]
    response = [model.config.id2label[label.item()] for label in results['labels']]
    return response

image_path = 'cat.jpeg'

# Load the model and feature extractor
feature_extractor, model = load_model()

# Process the data
response = process_data(image_path, feature_extractor, model)
print(response)

5.3. Appeler l'API depuis Torch Hub

# Torch Hub 翻译
prompt = "我想把英语翻译成汉语。"
print(get_gorilla_response(prompt, model="gorilla-falcon-7b-hf-v0"))

Résultat de sortie :

{'domain': 'Machine Translation', 'api_call': \"model = torch.hub.load('pytorch/fairseq', 'transformer.wmt14.en-fr', tokenizer='moses', bpe='subword_nmt')\", 'api_provider': 'PyTorch', 'explanation': 'Load the Transformer model from PyTorch Hub, which is specifically trained on the WMT 2014 English-French translation task.', 'code': 'import torch\nmodel = torch.hub.load('pytorch/fairseq', 'transformer.wmt14.en-fr', tokenizer='moses', bpe='subword_nmt')'}"

6. Affiner ChatGPT-3.5 basé sur l'API Gorrilla

Pour affiner ChatGPT-3.5 sur l'ensemble de données de l'API Gorilla pour tenter d'améliorer ses performances, la documentation de réglage fin d'OpenAI ChatGPT-3.5 est accessible ici :

https://platform.openai.com/docs/guides/fine-tuning

Remarque : ce script de réglage fin entraînera 7,2 millions de jetons sur OpenAI, ce qui coûtera certains frais. Veuillez déterminer si vous êtes prêt à payer ces frais avant de continuer.

6.1. Dépendances de l'installation

pip install openai tiktoken

importer les modules nécessaires

import re
import os
import json
import openai
from pprint import pprint

Définir la clé API OpenAI

openai_api_key = "OPENAI API KEY"
openai.api_key = openai_api_key

6.2, préparer l'ensemble de données

Téléchargez les données d'entraînement de l'API Gorrilla Huggingface, toutes les données d'entraînement Gorilla peuvent être trouvées ici :

https://github.com/ShishirPatil/gorilla/tree/main/data/apibench

wget https://raw.githubusercontent.com/ShishirPatil/gorilla/cab053ba7fdf4a3286c0e75aa2bf7abc4053812f/data/apibench/huggingface_train.json

6.2.1. Charger les données

data = []
with open("huggingface_train.json", "r") as file:
  # data = json.load(file)
  for line in file:
        item = json.loads(line.strip())
        data.append(item)

# 这是与训练有关的数据
data[0]["code"]

6.2.2. Analyse des données

Analyse des instructions de données d'entraînement

def parse_instructions_and_outputs(code_section):

  sections = code_section.split('###')
  for section in sections:
      if "Instruction:" in section:
          instruction = section.split("Instruction:", 1)[1].strip()
          break

  domain = re.search(r'<<<domain>>>(.*?)\n', code_section, re.IGNORECASE).group(1).lstrip(': ')
  api_call = re.search(r'<<<api_call>>>(.*?)\n', code_section, re.IGNORECASE).group(1).lstrip(': ')
  api_provider = re.search(r'<<<api_provider>>>(.*?)\n', code_section, re.IGNORECASE).group(1).lstrip(': ')

  if "<<<explanation>>>" in code_section:
    explanation_pattern = r'<<<explanation>>>(.*?)(?:\n<<<code>>>|```|$)'
    explanation = re.search(explanation_pattern, code_section, re.DOTALL).group(1).lstrip(': ')
  else:
    explanation = None

  # 考虑两种情况提取代码片段
  code_pattern = r'(?:<<<code>>>|```) (.*)'  # 匹配 <<<code>>> 或 ```
  code_snippet_match = re.search(code_pattern, code_section, re.DOTALL)
  code_snippet = code_snippet_match.group(1).lstrip(': ') if code_snippet_match else None

  return instruction, domain, api_call, api_provider, explanation, code_snippet

def encode_train_sample(data, api_name):
    """将多个提示指令编码为单个字符串。"""
    code_section = data['code']

    if "<<<api_call>>>" in code_section:
      instruction, domain, api_call, api_provider, explanation, code = parse_instructions_and_outputs(code_section)

      prompts = []

      #prompt = instruction + "\nWrite a python program in 1 to 2 lines to call API in " + api_name + ".\n\nThe answer should follow the format: <<<domain>>> $DOMAIN, <<<api_call>>>: $API_CALL, <<<api_provider>>>: $API_PROVIDER, <<<explanation>>>: $EXPLANATION, <<<code>>>: $CODE}. Here are the requirements:\n" + domains + "\n2. The $API_CALL should have only 1 line of code that calls api.\n3. The $API_PROVIDER should be the programming framework used.\n4. $EXPLANATION should be a step-by-step explanation.\n5. The $CODE is the python code.\n6. Do not repeat the format in your answer."

      prompts.append({"role": "system", "content": "你是一个有厉害的API开发人员，可以根据需求编写API。"})
      prompts.append({"role": "user", "content": instruction})
      prompts.append({"role": "assistant", "content": f"<<<domain>>> {domain},\
<<<api_call>>>: {api_call}, <<<api_provider>>>: {api_provider}, <<<explanation>>>: {explanation}, <<<code>>>: {code}"})
      return prompts
    else:
      return None

Formatez les échantillons de formation avec le format correct pour refléter le document Gorilla

encoded_data = []
none_count = 0
for d in data:
  res = encode_train_sample(d, "huggingface")
  if res is not None:
    encoded_data.append({"messages":res})
  else:
    none_count += 1

print(f"{none_count} samples out of {len(data)} ignored")

Imprimer des échantillons qui seront transmis à OpenAI pour un réglage fin

encoded_data[3]

Résultat de sortie :

{'messages': [{'role': 'system',
   'content': 'You are a helpful API writer who can write APIs based on requirements.'},
  {'role': 'user',
   'content': 'I run an online art store and I want to classify the art pieces uploaded by the users into different categories like abstract, landscape, portrait etc.'},
  {'role': 'assistant',
   'content': "<<<domain>>> Computer Vision Image Classification,<<<api_call>>>: ViTModel.from_pretrained('facebook/dino-vits8'), <<<api_provider>>>: Hugging Face Transformers, <<<explanation>>>: 1. We first import the necessary classes from the transformers and PIL packages. This includes ViTModel for the image classification model and Image for processing image data.\n2. We then use the from_pretrained method of the ViTModel class to load the pre-trained model 'facebook/dino-vits8'. This model has been trained using the DINO method which is particularly useful for getting good features for image classification tasks.\n3. We load the image data from an uploaded image file by the user.\n4. This model can then be used to classify the image into different art categories like 'abstract', 'landscape', 'portrait' etc., <<<code>>>: None"}]}

enregistrer les données d'entraînement

encoded_file_path = 'encoded_data.jsonl'

with open(encoded_file_path, 'w') as file:
    for item in encoded_data:
        line = json.dumps(item)
        file.write(line + '\n')

6.3. Script de vérification des données OpenAI

# 我们从导入所需的包开始

import json
import os
import tiktoken
import numpy as np
from collections import defaultdict

# 接下来，我们指定数据通路并打开JSONL文件

data_path = encoded_file_path

# 加载数据集
with open(data_path) as f:
    dataset = [json.loads(line) for line in f]

# 我们可以通过检查示例数量和第一项来快速检查数据

# 初始数据集统计信息
print("Num examples:", len(dataset))
print("First example:")
for message in dataset[0]["messages"]:
    print(message)

# 现在我们对数据有了了解，我们需要遍历所有不同的示例并检查以确保格式正确并与Chat完成消息结构匹配

# 格式错误检查
format_errors = defaultdict(int)

for ex in dataset:
    if not isinstance(ex, dict):
        format_errors["data_type"] += 1
        continue

    messages = ex.get("messages", None)
    if not messages:
        format_errors["missing_messages_list"] += 1
        continue

    for message in messages:
        if "role" not in message or "content" not in message:
            format_errors["message_missing_key"] += 1

        if any(k not in ("role", "content", "name") for k in message):
            format_errors["message_unrecognized_key"] += 1

        if message.get("role", None) not in ("system", "user", "assistant"):
            format_errors["unrecognized_role"] += 1

        content = message.get("content", None)
        if not content or not isinstance(content, str):
            format_errors["missing_content"] += 1

    if not any(message.get("role", None) == "assistant" for message in messages):
        format_errors["example_missing_assistant_message"] += 1

if format_errors:
    print("Found errors:")
    for k, v in format_errors.items():
        print(f"{k}: {v}")
else:
    print("No errors found")

# 除了消息的结构之外，我们还需要确保长度不超过4096令牌限制。

# Token 计数功能
encoding = tiktoken.get_encoding("cl100k_base")

def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):
    num_tokens = 0
    for message in messages:
        num_tokens += tokens_per_message
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += tokens_per_name
    num_tokens += 3
    return num_tokens

def num_assistant_tokens_from_messages(messages):
    num_tokens = 0
    for message in messages:
        if message["role"] == "assistant":
            num_tokens += len(encoding.encode(message["content"]))
    return num_tokens

def print_distribution(values, name):
    print(f"\n#### Distribution of {name}:")
    print(f"min / max: {min(values)}, {max(values)}")
    print(f"mean / median: {np.mean(values)}, {np.median(values)}")
    print(f"p5 / p95: {np.quantile(values, 0.1)}, {np.quantile(values, 0.9)}")

# 最后，在继续创建微调作业之前，我们可以查看不同格式化操作的结果：

# 警告和token计数
n_missing_system = 0
n_missing_user = 0
n_messages = []
convo_lens = []
assistant_message_lens = []

for ex in dataset:
    messages = ex["messages"]
    if not any(message["role"] == "system" for message in messages):
        n_missing_system += 1
    if not any(message["role"] == "user" for message in messages):
        n_missing_user += 1
    n_messages.append(len(messages))
    convo_lens.append(num_tokens_from_messages(messages))
    assistant_message_lens.append(num_assistant_tokens_from_messages(messages))

print("缺少系统消息的示例数:", n_missing_system)
print("缺少用户消息的数字示例:", n_missing_user)
print_distribution(n_messages, "num_messages_per_example")
print_distribution(convo_lens, "num_total_tokens_per_example")
print_distribution(assistant_message_lens, "num_assistant_tokens_per_example")
n_too_long = sum(l > 4096 for l in convo_lens)
print(f"\n{n_too_long} 示例可能超过4096令牌限制，它们将在微调期间被截断")

# 定价和违约n_epochs估计
MAX_TOKENS_PER_EXAMPLE = 4096

MIN_TARGET_EXAMPLES = 100
MAX_TARGET_EXAMPLES = 25000
TARGET_EPOCHS = 3
MIN_EPOCHS = 1
MAX_EPOCHS = 25

n_epochs = TARGET_EPOCHS
n_train_examples = len(dataset)
if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:
    n_epochs = min(MAX_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)
elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:
    n_epochs = max(MIN_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)

n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)
print(f"数据集有~{n_billing_tokens_in_dataset}个令牌，在训练期间将收取费用")
print(f"默认情况下，您将在此数据集上训练{n_epochs}个纪元")
print(f"默认情况下，您将收取~{n_epochs*n_billing_tokens_in_dataset}代币的费用")
print("请参阅定价页面以估算总成本")

6.4. Commencez à peaufiner GPT-3.5

Créer un fichier de formation OpenAI

openai.File.create(
  file=open(encoded_file_path, "rb"),
  purpose='fine-tune'
)

Créer des tâches de réglage fin

openai.api_key = openai_api_key
openai.FineTuningJob.create(
    training_file="file-OrxAP7HcvoSUmu9MtAbWo5s4",
    model="gpt-3.5-turbo"
)

# 列出 10 个微调任务
openai.FineTuningJob.list(limit=10)

# 查询微调的状态
state = openai.FineTuningJob.retrieve("ftjob-qhg4yswil15TCqD4SNHn0V1D")
state["status"], state["trained_tokens"], state["finished_at"]

# 列出微调作业中最多 10 个事件
openai.FineTuningJob.list_events(id="ftjob-qhg4yswil15TCqD4SNHn0V1D", limit=10)

6.5. Utilisation du modèle affiné

openai.api_key = openai_api_key

completion = openai.ChatCompletion.create(
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "How can i load a NER model?"}
  ]
)

print(completion.choices[0].message)
print(completion.choices[0].message["content"])

Résultat de sortie :

('To load a Named Entity Recognition (NER) model in Python, you can use the '
 "Hugging Face Transformers library. Here's a step-by-step guide to loading "
 'and using a NER model:\n'
 '\n'
 '1. Install the required Hugging Face Transformers library using "pip install '
 'transformers".\n'
 '2. Import the AutoModelForTokenClassification class from the transformers '
 'library.\n'
 '3. Import the necessary tokenizer as well, which is AutoTokenizer in this '
 'case.\n'
 '4. Use the from_pretrained method to load the pre-trained model with its '
 'respective model name or identifier.\n'
 '5. Then, use the load_tokenizer method to load the tokenizer.\n'
 '6. Encode your text using the loaded tokenizer, specifying the '
 "'return_tensors' parameter as 'pt'.\n"
 '7. Pass the input tensor to the model and it will return the predictions, '
 'describing the Named Entities in the text.\n'
 '\n'
 'Please keep in mind that you should download the model first, replace '
 "'YOUR_MODEL_NAME' with an appropriate model identifier, and make sure to "
 'execute this code on a suitable device (e.g., CPU or GPU).\n'
 '\n'
 'Here is how the code looks:\n'
 '```python\n'
 'from transformers import AutoModelForTokenClassification, AutoTokenizer\n'
 'import torch\n'
 '\n'
 "model = AutoModelForTokenClassification.from_pretrained('YOUR_MODEL_NAME')\n"
 "tokenizer = AutoTokenizer.from_pretrained('YOUR_MODEL_NAME')\n"
 '\n'
 '# Encode your text using the loaded tokenizer\n'
 "inputs = tokenizer(text, return_tensors='pt')\n"
 '\n'
 '# Pass the input tensor to the model and obtain NER predictions\n'
 'predictions = model(**inputs)\n'
 '```\n'
 '\n'
 "Remember to replace 'YOUR_MODEL_NAME' with an appropriate BERT NER-trained "
 "model such as 'dslim/bert-base-NER'.")

7. Résumé

Gorilla LLM est un LLM révolutionnaire qui génère des appels API précis et s'adapte aux modifications en temps réel des documents. Ce modèle ouvre la voie aux futurs LLM pour devenir plus fiables et plus polyvalents dans leur interaction avec les outils et les systèmes.

Gorilla LLM est un nouvel outil puissant pour les développeurs. Cela fait gagner du temps et des efforts aux développeurs et les aide à écrire un code plus fiable. Si vous êtes développeur, je vous suggère de vous renseigner sur Gorilla LLM.

Les progrès futurs du LLM peuvent se concentrer sur la réduction supplémentaire des erreurs d’hallucination, l’amélioration de l’adaptabilité aux différentes API et l’extension de sa capacité à gérer des tâches complexes. Les applications potentielles incluent le rôle d'interface principale avec l'infrastructure informatique, l'automatisation de processus tels que les réservations de vacances et la facilitation d'une communication transparente entre diverses API Web.

8. Références

Site Web des gorilles

https://shishirpatil.github.io/gorilla/

Gorille GitHub

https://github.com/ShishirPatil/gorilla

Téléavertisseur Gorille

https://arxiv.org/abs/2305.15334

Si cet article vous intéresse et que vous souhaitez en savoir plus sur les compétences pratiques dans le domaine de l'IA, vous pouvez prêter attention au compte public « Technology Craze AI » . Ici, vous pouvez voir les articles secs et les tutoriels pratiques les plus récents et les plus chauds dans le domaine de l'AIGC.