1. Introduction à l'Appel de Fonction
Dans le modèle GPT, l'Appel de Fonction fait référence à la fourniture de fonctions descriptives au modèle via une API, lui permettant de sélectionner intelligemment et de produire un objet JSON contenant des paramètres pour appeler une ou plusieurs fonctions. Il est important de noter que l'API de Complétion de Chat n'exécute pas directement les appels de fonctions, mais génère plutôt du JSON qui peut être utilisé pour exécuter des fonctions dans le code.
En termes simples, la fonction d'appel de fonction consiste à fournir un ensemble de définitions de fonctions (comprenant des descriptions de fonctions et des descriptions de paramètres) au modèle GPT. Le modèle décide ensuite quelle fonction appeler en fonction de la requête de l'utilisateur. Comme le modèle ne peut pas exécuter des fonctions externes, il ne peut répondre qu'avec une demande de quelle fonction appeler (y compris les paramètres d'appel de fonction). Après avoir reçu le résultat de la demande du modèle, notre programme exécute l'appel de fonction localement. Le résultat de l'appel de fonction est ensuite concaténé avec la requête et renvoyé au modèle pour un traitement ultérieur avant de renvoyer le résultat final à l'utilisateur.
2. Scénarios d'Application de l'Appel de Fonction
Voici quelques exemples de ses applications pratiques:
- Création d'une assistance pour répondre aux questions en appelant des API externes, comme la définition de fonctions telles que
send_email(to: string, body: string)ouget_current_weather(location: string, unit: 'celsius' | 'fahrenheit'). - Conversion de la langue naturelle en appels d'API, par exemple la traduction de "Qui sont mes meilleurs clients ?" en
get_customers(min_revenue: int, created_before: string, limit: int)puis en effectuant un appel d'API interne. - Extraction de données structurées à partir du texte, par exemple la définition de fonctions telles que
extract_data(name: string, birthday: string)ousql_query(query: string).
En utilisant la fonction d'appel de fonction, nous pouvons mettre en œuvre des agents d'IA qui interagissent avec nos systèmes locaux et nos bases de données, comme avoir une IA interroger la météo la plus récente, vérifier les prix des actions, commander à emporter ou réserver des vols.
3. Modèles Prendant en Charge l'Appel de Fonction
Toutes les versions du modèle n'ont pas été entraînées avec des données d'appel de fonction. Actuellement, les modèles prenant en charge l'appel de fonction sont : gpt-4, gpt-4-turbo-preview, gpt-4-0125-preview, gpt-4-1106-preview, gpt-4-0613, gpt-3.5-turbo, gpt-3.5-turbo-1106 et gpt-3.5-turbo-0613.
De plus, les modèles gpt-4-turbo-preview, gpt-4-0125-preview, gpt-4-1106-preview et gpt-3.5-turbo-1106 prennent en charge l'appel de fonction parallèle, leur permettant d'exécuter plusieurs appels de fonctions à la fois et de gérer ces appels de fonctions concurremment pour produire des résultats efficaces et rapides.
Remarque : Le risque potentiel associé à la fonction d'appel de fonction est qu'elle peut conduire à la production de paramètres erronés par le modèle (c'est-à-dire des paramètres fantômes). Par conséquent, avant de prendre des actions qui impactent le monde réel (comme l'envoi d'e-mails, la publication en ligne, les achats, etc.), il est conseillé d'incorporer un processus de confirmation de l'utilisateur au niveau du produit, garantissant que les fonctions ne sont exécutées qu'après confirmation de l'utilisateur.
4. Exemples d'Appel de Fonction
4.1 Exemple Python
Mettre en œuvre l'Appel de Fonction sur la plateforme OpenAI suit généralement les étapes de base décrites ci-dessous. Ce qui suit détaillera l'ensemble du processus en utilisant un exemple de code Python, se concentrant sur la requête de la météo.
Étape 1 : Préparer des fonctions appelables et des définitions de fonctions pour le modèle
Tout d'abord, nous devons définir une fonction qui peut être appelée par le modèle GPT. Cela signifie généralement préparer notre propre fonction qui peut effectuer certaines opérations en fonction des paramètres d'entrée, comme communiquer avec une API tierce.
import json
def get_current_weather(location, unit="fahrenheit"):
return json.dumps({
"location": location,
"temperature": "18",
"unit": unit
})
Étape 2 : Appeler le modèle en fonction de la requête et du paramètre d'outils
Ensuite, nous devons appeler le modèle GPT via l'API de complétion de chat et transmettre la requête de l'utilisateur (par exemple "Quel temps fait-il actuellement") ainsi que le paramètre tools, qui comprend la description de la fonction get_current_weather que nous venons de définir.
from openai import OpenAI
client = OpenAI()
outils = [{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obtenir la météo actuelle pour une certaine localisation",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "Nom de la ville, par exemple : 'San Francisco, CA'"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
}
}
}]
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": "Quel temps fait-il actuellement à San Francisco ?"}],
tools=outils
)
Étape 3 : Exécuter la fonction localement
Le résultat retourné par le modèle inclura des informations sur la fonction que le modèle souhaite appeler, généralement contenues dans le paramètre de réponse tool_calls. Nous pouvons ensuite exécuter l'appel de fonction correspondant localement en fonction des informations d'appel de fonction décrites dans le paramètre tool_calls.
tool_calls = response.choices[0].message.tool_calls
if tool_calls:
arguments = json.loads(tool_calls[0].function.arguments)
infos_meteo = get_current_weather(**arguments)
print(infos_meteo) # Ici, nous pouvons voir les informations météorologiques interrogées par l'appel de fonction
Étape 4 : Appeler à nouveau le modèle avec le résultat de la fonction retournée
Maintenant, nous pouvons envoyer le résultat de retour de la fonction en tant que nouveau message au modèle, afin que le modèle puisse traiter ces résultats et générer une réponse adaptée à l'utilisateur.
follow_up_response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": "Quel temps fait-il actuellement à San Francisco ?"},
{"role": "function", "name": "get_current_weather", "content": weather_info}
],
tools=outils
)
Explication : Dans l'exemple ci-dessus, le contenu de retour de la fonction est envoyé au modèle GPT à travers le message de fonction comme suit :
{"role": "function", "name": "get_current_weather", "content": weather_info}
En pratique, vous pouvez aussi simplement placer le contenu de retour de la fonction comme contenu de référence dans le message système pour que l'IA puisse s'y référer lorsqu'elle répond aux questions.
Étape 5 : Obtenir la réponse finale du modèle
Enfin, nous pouvons récupérer la réponse finale du modèle et la fournir à l'utilisateur. À cette étape, le modèle produira une réponse conviviale basée sur les informations météorologiques que nous avons fournies.
sortie_finale = follow_up_response.choices[0].message.content
print(sortie_finale) # Cette sortie est l'information météorologique que nous voulons montrer à l'utilisateur
En suivant les étapes ci-dessus, nous avons réalisé un exemple complet de la consultation de la météo en utilisant le modèle GPT et les appels de fonction.
4.2.1 Signification des champs de paramètres « Outils »
Lors de l'appel d'une fonction, vous devez définir les informations pertinentes de la fonction dans le paramètre outils. Le paramètre outils est un tableau contenant de multiples définitions de fonctions, et chaque définition de fonction inclut les champs suivants :
-
type: Ce champ représente le type d'outil. Lors de l'appel d'une fonction, ce champ doit être défini sur"fonction". -
fonction: Ce champ contient des informations détaillées sur la fonction et est un objet comportant les champs spécifiques suivants :-
nom: Le nom de la fonction, qui est une chaîne de caractères. -
description: Une description de l'objectif de la fonction, qui peut aider le modèle à générer des paramètres répondant aux attentes de l'utilisateur. -
paramètres: Décrit les définitions de paramètres de la fonction et est un objet qui contient les sous-champs suivants :-
type: Définit le type de paramètre, qui devrait principalement être défini sur"objet". -
propriétés: Les définitions spécifiques de chaque paramètre de fonction, où chaque définition de paramètre est un objet contenant généralement les sous-champs suivants :-
type: Le type de données du paramètre (tel que"chaîne de caractères","entier","booléen", etc.). -
description: La description du paramètre pour aider le modèle à comprendre son objectif. -
enum(optionnel) : Lorsquetypeest"chaîne de caractères", le champenumpeut spécifier un tableau de chaînes représentant l'ensemble des valeurs valides.
-
-
requis: Un tableau de chaînes contenant les noms des paramètres requis.
-
-
4.2.2 Exemples de Définitions d'Outils
Voici quelques exemples de définitions d'outils pour aider à comprendre comment chaque champ est utilisé.
Exemple 1 : Obtenir les Informations Météorologiques Actuelles
{
"type": "function",
"function": {
"name": "obtenir_infos_météo_actuelles",
"description": "Obtenir les informations météorologiques actuelles pour l'emplacement spécifié",
"parameters": {
"type": "object",
"properties": {
"emplacement": {
"type": "chaîne de caractères",
"description": "La ville pour laquelle la météo doit être consultée, par exemple : 'San Francisco, CA'"
},
"unité": {
"type": "chaîne de caractères",
"enum": ["celsius", "fahrenheit"],
"description": "Unité de température, 'celsius' pour Celsius, 'fahrenheit' pour Fahrenheit"
}
},
"requis": ["emplacement", "unité"]
}
}
}
Dans l'exemple ci-dessus, nous avons défini une fonction nommée obtenir_infos_météo_actuelles pour obtenir la météo actuelle d'un emplacement spécifié. Les paramètres incluent emplacement et unité, où unité a deux valeurs valides : "celsius" (Celsius) et "fahrenheit" (Fahrenheit).
Exemple 2 : Trouver les Albums d'un Artiste Spécifique
{
"type": "function",
"function": {
"name": "trouver_albums_artiste",
"description": "Trouver tous les albums d'un artiste spécifique",
"parameters": {
"type": "object",
"properties": {
"nom_artiste": {
"type": "chaîne de caractères",
"description": "Le nom de l'artiste"
}
},
"requis": ["nom_artiste"]
}
}
}
Dans cet exemple, nous avons créé une fonction appelée trouver_albums_artiste pour trouver tous les albums d'un artiste spécifique. Cette fonction ne nécessite qu'un seul paramètre : nom_artiste (le nom de l'artiste).
4.3. Exemple d'un Appel de Fonction de Requête HTTP
OpenAI fournit une API accessible via le protocole HTTP. Ci-dessous, nous expliquerons comment utiliser la fonction d'appel via l'API HTTP. Les développeurs d'autres langages de programmation peuvent se référer à cet exemple.
4.3.1. Étape 1 : Appeler le modèle avec la requête de l'utilisateur et la Déclaration de Fonction
Tout d'abord, nous devons envoyer la requête de l'utilisateur et la liste des fonctions que nous prenons en charge au modèle GPT, afin que le modèle puisse analyser automatiquement quelle fonction appeler pour répondre à la requête de l'utilisateur en se basant sur la question de l'utilisateur.
Dans l'exemple suivant, nous informons GPT que nous avons une fonction get_current_weather qui peut être utilisée pour interroger les informations météorologiques pour une ville spécifiée.
curl --location 'https://api.aiproxy.io/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {OPENAI_KEY}' \
--data '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "Quel temps fait-il à Shanghai aujourd'hui?"
}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obtenir les informations météorologiques actuelles pour l'emplacement spécifié",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "La ville pour laquelle la météo doit être consultée, par exemple 'Paris, France'"
},
"unit": {
"type": "string",
"enum": [
"celsius",
"fahrenheit"
],
"description": "Unité de température, 'celsius' pour Celsius, 'fahrenheit' pour Fahrenheit"
}
},
"required": [
"location",
"unit"
]
}
}
}
]
}'
Explication des paramètres de la requête :
{
"model": "gpt-3.5-turbo", // Le modèle GPT à appeler
"messages": [ // Il s'agit de la liste des messages pour GPT, y compris la requête de l'utilisateur
{
"role": "user",
"content": "Quel temps fait-il à Shanghai aujourd'hui?"
}
],
"tools": [
// Ceci est votre définition de fonction, informant GPT des fonctions disponibles
]
}
Veuillez vous référer à la section 4.2.2 pour la définition du paramètre tools.
Lors du traitement normal par le modèle GPT, vous recevrez une réponse similaire à l'API :
{
"model": "gpt-3.5-turbo-0613",
"object": "chat.completion",
"usage": {
"prompt_tokens": 122,
"completion_tokens": 27,
"total_tokens": 149
},
"id": "chatcmpl-8mL4hS4zNMocyR2ajKyAvSTcbNaao",
"created": 1706531447,
"choices": [
{
"index": 0,
"delta": null,
"message": {
"role": "assistant",
"tool_calls": [ // Le paramètre tool_calls représente la liste des fonctions que GPT souhaite appeler
{
"id": "call_1iF09ttX1R9ESR18Ul2nLe1R",
"type": "function",
"function": {
"name": "get_current_weather", // Indique que GPT souhaite répondre à la requête de l'utilisateur en appelant la fonction get_current_weather
"arguments": "{\n \"location\": \"Shanghai, China\",\n \"unit\": \"celsius\"\n}" // Il s'agit du paramètre d'entrée pour appeler la fonction get_current_weather
}
}
]
},
"finish_reason": "tool_calls"
}
]
}
4.3.2. Étape 2 : Exécution de l'Appel de Fonction Locale
Étant donné que le modèle GPT lui-même ne peut pas exécuter des appels de fonction spécifiques et nous informe uniquement de la fonction qu'il souhaite appeler, notre programme local doit exécuter l'appel de fonction spécifique en se basant sur le paramètre tool_calls retourné par le modèle. La manière d'exécuter des fonctions locales varie selon les langages de programmation. Par exemple, en Python, vous pouvez vous référer à la section précédente.
4.3.3. Étape 3 : Appeler à nouveau le modèle avec le résultat de retour de la fonction
Parce que l'appel de la fonction est exécuté localement, nous devons transmettre le résultat de l'exécution de la fonction et la question de l'utilisateur au modèle GPT pour obtenir la réponse finale.
curl --location 'https://api.aiproxy.io/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer sk-Roc5MX1zEuVxiuaMaETV6wZ2jXcCehjUCzwP9AcNErUiwppQ' \
--data '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "Quel temps fait-il à Shanghai aujourd'hui ?"
},
{
"role": "function",
"name": "get_current_weather",
"content": "{\"city\":\"Shanghai\", \"temperature\":\"25 degrés Celsius\"}"
}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Obtenir les informations météorologiques actuelles pour l'emplacement spécifié",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "La ville pour laquelle interroger la météo, par exemple, 'San Francisco, CA'"
},
"unit": {
"type": "string",
"enum": [
"celsius",
"fahrenheit"
],
"description": "L'unité de température, 'celsius' pour Celsius, 'fahrenheit' pour Fahrenheit"
}
},
"required": [
"location",
"unit"
]
}
}
}
]
}'
Remarque : La demande ci-dessus inclut un message de fonction supplémentaire pour informer le modèle GPT de la valeur de retour de la fonction. GPT répondra directement à la question de l'utilisateur en fonction des informations de retour de la fonction et n'appellera pas de nouveau la fonction.
Le message de fonction représente la valeur de retour de la fonction et suit le format ci-dessous:
{
"role": "function", // Le type de message est une fonction, indiquant la valeur de retour de la fonction
"name": "get_current_weather", // Informe GPT que le message actuel est la valeur de retour de la fonction get_current_weather
"content": "{\"city\":\"Shanghai\", \"temperature\":\"25 degrés Celsius\"}" // Contenu de retour de la fonction, peut être au format JSON ou autre contenu texte.
}
Ci-dessous se trouve la réponse finale générée par GPT:
{
"model": "gpt-3.5-turbo-0613",
"object": "chat.completion",
"usage": {
"prompt_tokens": 144,
"completion_tokens": 17,
"total_tokens": 161
},
"id": "chatcmpl-8mLmvvKAjSql7rGF8fvQeddKhWYvr",
"created": 1706534189,
"choices": [
{
"index": 0,
"delta": null,
"message": {
"role": "assistant",
"content": "Le temps à Shanghai est de 25 degrés Celsius aujourd'hui."
},
"finish_reason": "stop"
}
]
}