Tutoriel d'appel de fonction OpenAI

Utiliser OpenAI sans appel de fonction

Dans cette section, nous allons générer des réponses en utilisant le modèle GPT-3.5-Turbo sans appel de fonction pour voir si nous obtenons des résultats cohérents ou non.

Avant d'installer l'API OpenAI Python, vous devez obtenir une clé API et la configurer sur votre système local. Suivez le tutoriel GPT-3.5 et GPT-4 via l'API OpenAI en Python pour apprendre à obtenir la clé API et à la configurer. Le tutoriel comprend également des exemples de configuration de variables d'environnement dans DataLab, le carnet de données de DataCamp basé sur l'IA.

Pour plus d'assistance, consultez le code dans le classeur OpenAI Function Calling sur DataLab.

Mettez à jour l'API Python d'OpenAI vers V1 en utilisant :

pip install --upgrade openai -q

Ensuite, lancez le client OpenAI en utilisant la clé API.

import os
from openai import OpenAI

client = OpenAI(
  api_key=os.environ['OPENAI_API_KEY'],
)

Note: OpenAI n'offre plus de crédits gratuits aux nouveaux utilisateurs, vous devez donc les acheter pour utiliser l'API.

Nous rédigerons une description aléatoire de l'étudiant. Vous pouvez rédiger votre propre texte ou utiliser le ChatGPT pour en générer un pour vous.

student_1_description = "David Nguyen is a sophomore majoring in computer science at Stanford University. He is Asian American and has a 3.8 GPA. David is known for his programming skills and is an active member of the university's Robotics Club. He hopes to pursue a career in artificial intelligence after graduating."

Dans la partie suivante, nous allons écrire une invite pour extraire les informations sur les élèves du texte et renvoyer la sortie sous la forme d'un objet JSON. Nous extrairons le nom, la spécialité, l'école, les notes et les clubs dans la description de l'étudiant.

# A simple prompt to extract information from "student_description" in a JSON format.
prompt1 = f'''
Please extract the following information from the given text and return it as a JSON object:

name
major
school
grades
club

This is the body of text to extract the information from:
{student_1_description}
'''

Ajoutez l'invite au module de complétion de chat de l'API OpenAI pour générer la réponse.

# Generating response back from gpt-3.5-turbo
openai_response = client.chat.completions.create(
    model = 'gpt-3.5-turbo',
    messages = [{'role': 'user', 'content': prompt_1}]
)

openai_response.choices[0].message.content

La réponse est assez bonne. Convertissons-le en JSON pour mieux le comprendre.

'{\n  "name": "David Nguyen",\n  "major": "computer science",\n  "school": "Stanford University",\n  "grades": "3.8 GPA",\n  "club": "Robotics Club"\n}'

Nous utiliserons la bibliothèque `json` pour convertir le texte en un objet JSON.

import json

# Loading the response as a JSON object
json_response = json.loads(openai_response.choices[0].message.content)
json_response

Le résultat final est presque parfait. Alors, pourquoi avons-nous besoin de l'appel de fonction ?

{'name': 'David Nguyen',
 'major': 'computer science',
 'school': 'Stanford University',
 'grades': '3.8 GPA',
 'club': 'Robotics Club'}

Essayons le même message, mais en utilisant une description différente de l'élève.

student_2_description="Ravi Patel is a sophomore majoring in computer science at the University of Michigan. He is South Asian Indian American and has a 3.7 GPA. Ravi is an active member of the university's Chess Club and the South Asian Student Association. He hopes to pursue a career in software engineering after graduating."

Nous allons simplement modifier le texte de la description de l'élève dans l'invite.

prompt2 = f'''
Please extract the following information from the given text and return it as a JSON object:

name
major
school
grades
club

This is the body of text to extract the information from:
{student_2_description}
'''

Ensuite, exécutez la fonction d'achèvement du chat à l'aide de la deuxième invite.

# Generating response back from gpt-3.5-turbo
openai_response = client.chat.completions.create(
    model = 'gpt-3.5-turbo',
    messages = [{'role': 'user', 'content': prompt_2}]
)

# Loading the response as a JSON object
json_response = json.loads(openai_response.choices[0].message.content)
json_response

Comme vous pouvez le constater, il n'est pas cohérent. Au lieu de renvoyer un seul club, il a renvoyé la liste des clubs auxquels Ravi s'est joint. Il est également différent du premier étudiant.

{'name': 'Ravi Patel',
 'major': 'computer science',
 'school': 'University of Michigan',
 'grades': '3.7 GPA',
 'club': ['Chess Club', 'South Asian Student Association']}

Exemple d'appel de fonction OpenAI

Pour résoudre ce problème, nous allons maintenant utiliser une fonctionnalité récemment introduite, appelée Function Calling (appel de fonction). Il est essentiel de créer une fonction personnalisée pour ajouter les informations nécessaires à une liste de dictionnaires afin que l'API OpenAI puisse comprendre sa fonctionnalité.

• name: écrivez le nom de la fonction Python que vous avez récemment créée.
• description: la fonctionnalité de la fonction.
• paramètres: dans les "propriétés", on écrira le nom des arguments, le type et la description. Il aidera l'API OpenAI à identifier le monde que nous recherchons.

Note: Assurez-vous que vous suivez le bon modèle. Pour en savoir plus sur l'appel de fonction, consultez la documentation officielle.

student_custom_functions = [
    {
        'name': 'extract_student_info',
        'description': 'Get the student information from the body of the input text',
        'parameters': {
            'type': 'object',
            'properties': {
                'name': {
                    'type': 'string',
                    'description': 'Name of the person'
                },
                'major': {
                    'type': 'string',
                    'description': 'Major subject.'
                },
                'school': {
                    'type': 'string',
                    'description': 'The university name.'
                },
                'grades': {
                    'type': 'integer',
                    'description': 'GPA of the student.'
                },
                'club': {
                    'type': 'string',
                    'description': 'School club for extracurricular activities. '
                }
                
            }
        }
    }
]

Ensuite, nous allons générer des réponses pour deux descriptions d'élèves à l'aide d'une fonction personnalisée ajoutée à l'argument "functions". Ensuite, nous convertirons la réponse textuelle en un objet JSON et l'imprimerons.

student_description = [student_1_description,student_2_description]
for i in student_description:
    response = client.chat.completions.create(
        model = 'gpt-3.5-turbo',
        messages = [{'role': 'user', 'content': i}],
        functions = student_custom_functions,
        function_call = 'auto'
    )

    # Loading the response as a JSON object
    json_response = json.loads(response.choices[0].message.function_call.arguments)
    print(json_response)

Comme nous pouvons le voir, nous avons obtenu un résultat uniforme. Nous avons même reçu des notes sous forme numérique au lieu de chaînes de caractères. La cohérence des résultats est essentielle pour créer des applications d'IA exemptes de bogues.

{'name': 'David Nguyen', 'major': 'computer science', 'school': 'Stanford University', 'grades': 3.8, 'club': 'Robotics Club'} 

{'name': 'Ravi Patel', 'major': 'computer science', 'school': 'University of Michigan', 'grades': 3.7, 'club': 'Chess Club'}

Plusieurs fonctions personnalisées

Vous pouvez ajouter plusieurs fonctions personnalisées à la fonction d'achèvement du chat. Dans cette section, nous verrons les capacités magiques de l'API OpenAI et comment elle sélectionne automatiquement la bonne fonction et renvoie les bons arguments.

Dans la liste Python du dictionnaire, nous ajouterons une autre fonction appelée "extract_school_info", qui nous aidera à extraire du texte les informations relatives à l'université.

Pour ce faire, vous devez ajouter un autre dictionnaire de fonction avec le nom, la description et les paramètres.

custom_functions = [
    {
        'name': 'extract_student_info',
        'description': 'Get the student information from the body of the input text',
        'parameters': {
            'type': 'object',
            'properties': {
                'name': {
                    'type': 'string',
                    'description': 'Name of the person'
                },
                'major': {
                    'type': 'string',
                    'description': 'Major subject.'
                },
                'school': {
                    'type': 'string',
                    'description': 'The university name.'
                },
                'grades': {
                    'type': 'integer',
                    'description': 'GPA of the student.'
                },
                'club': {
                    'type': 'string',
                    'description': 'School club for extracurricular activities. '
                }
                
            }
        }
    },
    {
        'name': 'extract_school_info',
        'description': 'Get the school information from the body of the input text',
        'parameters': {
            'type': 'object',
            'properties': {
                'name': {
                    'type': 'string',
                    'description': 'Name of the school.'
                },
                'ranking': {
                    'type': 'integer',
                    'description': 'QS world ranking of the school.'
                },
                'country': {
                    'type': 'string',
                    'description': 'Country of the school.'
                },
                'no_of_students': {
                    'type': 'integer',
                    'description': 'Number of students enrolled in the school.'
                }
            }
        }
    }
]

Nous allons générer une description de l'"Université de Stanford" à l'aide du ChatGPT pour tester notre fonction.

school_1_description = "Stanford University is a private research university located in Stanford, California, United States. It was founded in 1885 by Leland Stanford and his wife, Jane Stanford, in memory of their only child, Leland Stanford Jr. The university is ranked #5 in the world by QS World University Rankings. It has over 17,000 students, including about 7,600 undergraduates and 9,500 graduates23. "

Créez la liste des descriptions des élèves et des écoles et passez-la à la fonction de complétion de chat OpenAI pour générer la réponse. Assurez-vous d'avoir fourni la fonction personnalisée mise à jour.

description = [student_1_description, school_1_description]
for i in description:
    response = client.chat.completions.create(
        model = 'gpt-3.5-turbo',
        messages = [{'role': 'user', 'content': i}],
        functions = custom_functions,
        function_call = 'auto'
    )

    # Loading the response as a JSON object
    json_response = json.loads(response.choices[0].message.function_call.arguments)
    print(json_response)

Le modèle GPT-3.5-Turbo sélectionne automatiquement la fonction adéquate pour les différents types de description. Nous obtenons une sortie JSON parfaite pour l'élève et l'école.

{'name': 'David Nguyen', 'major': 'computer science', 'school': 'Stanford University', 'grades': 3.8, 'club': 'Robotics Club'} 

{'name': 'Stanford University', 'ranking': 5, 'country': 'United States', 'no_of_students': 17000}

Nous pouvons même regarder sous le nom que le repos est généré en utilisant la fonction "extract_school_info".

Applications de l'appel de fonction

Dans cette section, nous allons construire un synthétiseur de texte stable qui résumera les informations relatives à l'école et à l'élève d'une certaine manière.

Tout d'abord, nous allons créer deux fonctions Python, extract_student_info et extract_school_info,, qui prennent les arguments de l'appel de fonction et renvoient une chaîne résumée.

def extract_student_info(name, major, school, grades, club):
    
    """Get the student information"""

    return f"{name} is majoring in {major} at {school}. He has {grades} GPA and he is an active member of the university's {club}."

def extract_school_info(name, ranking, country, no_of_students):
    
    """Get the school information"""

    return f"{name} is located in the {country}. The university is ranked #{ranking} in the world with {no_of_students} students."

1. Créez la liste Python, qui se compose d'une description de l'élève, d'une invite aléatoire et d'une description de l'école. L'invite aléatoire est ajoutée pour valider le mécanisme d'appel de la fonction automatique.
2. Nous allons générer la réponse en utilisant chaque texte de la liste `descriptions`.
3. Si un appel de fonction est utilisé, nous obtiendrons le nom de la fonction et, sur cette base, nous appliquerons les arguments pertinents à la fonction en utilisant la réponse. Dans le cas contraire, la réponse normale est renvoyée.
4. Imprimez les résultats des trois échantillons.

descriptions = [
    student_1_description, 
    "Who was a Abraham Lincoln?",
    school_1_description
                ]

for i, sample in enumerate(descriptions):
    response = client.chat.completions.create(
        model = 'gpt-3.5-turbo',
        messages = [{'role': 'user', 'content': sample}],
        functions = custom_functions,
        function_call = 'auto'
    )
    
    response_message = response.choices[0].message
    
    if dict(response_message).get('function_call'):
        
        # Which function call was invoked
        function_called = response_message.function_call.name
        
        # Extracting the arguments
        function_args  = json.loads(response_message.function_call.arguments)
        
        # Function names
        available_functions = {
            "extract_school_info": extract_school_info,
            "extract_student_info": extract_student_info
        }
        
        fuction_to_call = available_functions[function_called]
        response_message = fuction_to_call(*list(function_args .values()))
        
    else:
        response_message = response_message.content
    
    print(f"\nSample#{i+1}\n")
    print(response_message)

• Échantillon n° 1: Le modèle GPT a sélectionné "extract_student_info", et nous avons obtenu un bref résumé sur l'étudiant.
• Échantillon n° 2: Le modèle GPT n'a sélectionné aucune fonction et a traité l'invite comme une question ordinaire, ce qui nous a permis d'obtenir la biographie d'Abraham Lincoln.
• Échantillon n° 3: Le modèle GPT a sélectionné "extract_school_info", et nous avons obtenu un bref résumé de l'université de Stanford.

Sample#1

David Nguyen is majoring in computer science at Stanford University. He has 3.8 GPA and he is an active member of the university's Robotics Club.

Sample#2

Abraham Lincoln was the 16th President of the United States. He served as president from March 1861 until his assassination in April 1865. Lincoln led the country through its greatest internal crisis, the American Civil War, and his Emancipation Proclamation declared slaves in Confederate territory to be free. He is known for his leadership, his commitment to preserving the Union, and his efforts to abolish slavery. Lincoln's presidency is widely regarded as one of the most transformative in American history.

Sample#3

Stanford University is located in the United States. The university is ranked #5 in the world with 17000 students.

Conclusion

L'appel de fonction d'OpenAI ouvre de nouvelles possibilités pour les développeurs d'applications d'IA. En permettant à des modèles tels que GPT-3.5 et GPT-4 de générer des données JSON structurées par le biais de fonctions personnalisées, il résout les principaux problèmes liés aux sorties de texte incohérentes et imprévisibles.

L'appel de fonction peut être utilisé pour accéder à des API web externes, exécuter des requêtes SQL personnalisées et développer des applications d'IA stables. Il peut extraire des informations pertinentes du texte et fournir des réponses cohérentes aux commandes API et SQL.

Dans ce tutoriel, nous avons découvert la nouvelle fonctionnalité d'OpenAI, l'appel de fonction. Nous avons également appris à l'utiliser pour générer des résultats cohérents, créer des fonctions multiples et construire un résumé de texte fiable.

Si vous souhaitez en savoir plus sur l'API OpenAI, envisagez de suivre le cours Travailler avec l'API OpenAI et d'utiliser l'antisèche OpenAI API in Python pour créer votre premier projet alimenté par l'IA.