Tutoriel d'appel de fonction GPT-4.5 : Extraire les cours des actions et les nouvelles avec l'IA

Les grands modèles de langage (LLM) ont souvent du mal à générer de manière cohérente des sorties structurées, telles que JSON, même en utilisant des techniques avancées d'ingénierie d'invite. Si l'ingénierie rapide peut améliorer les résultats, elle n'est pas infaillible - des erreurs peuvent encore se produire pendant les essais, entraînant des défaillances occasionnelles. Alors, comment pouvez-vous garantir des résultats structurés précis et fiables à chaque fois ?

L'appel de fonction dans les LLM se réfère à la capacité de ces modèles à produire des réponses de données structurées, typiquement sous la forme d'objets JSON. Cette fonctionnalité permet aux LLM d'aller au-delà de la simple génération de texte et d'interagir avec des systèmes, des API et des outils externes. En s'appuyant sur l'appel de fonctions, les LLM peuvent effectuer des tâches plus complexes et contextuelles tout en conservant la structure et la précision requises.

Dans ce tutoriel, nous allons apprendre à utiliser GPT-4.5le modèle le plus précis et le plus factuel, pour créer un script d'appel de fonction. Tout d'abord, nous mettrons en œuvre une fonction unique pour extraire les cours des actions sur l'internet. Ensuite, nous ajouterons une autre fonction, permettant au LLM de choisir entre plusieurs outils et de sélectionner le plus approprié en fonction de l'invite de l'utilisateur.

À la fin de ce tutoriel, vous saurez comment créer votre propre application intelligente capable de fournir le cours des actions de n'importe quelle société et de diffuser des flux d'informations.

Image de l'auteur

Capacités d'appel de fonctions de GPT-4.5

GPT-4.5, le dernier modèle d'OpenAI, présente plusieurs caractéristiques avancées, notamment des capacités améliorées d'appel de fonctions. Ces capacités sont conçues pour améliorer la capacité du modèle à interagir avec des systèmes externes et à effectuer des tâches complexes en invoquant des fonctions spécifiques basées sur les entrées de l'utilisateur.

Source : Modèle - API OpenAI

Voici les principales caractéristiques de la fonction Function Calling de GPT-4.5 :

1. Intégration avec les API

GPT-4.5 prend en charge l'appel de fonctions par l'intermédiaire de l'API d'achèvement des chats, de l'API des assistants et de l'API des lots. Les développeurs peuvent ainsi intégrer le modèle de manière transparente dans leurs applications, ce qui lui permet d'effectuer des tâches telles que la recherche et le traitement de données, voire l'exécution de commandes au sein d'un environnement logiciel.

2. Résultats structurés

Le modèle peut renvoyer des sorties structurées, telles que JSON, ce qui est particulièrement utile pour les développeurs qui ont besoin du modèle pour interagir avec d'autres systèmes ou outils qui requièrent des formats de données spécifiques.

3. Capacités de vision

Bien que le GPT-4.5 ne prenne pas en charge les sorties multimodales telles que la voix ou la vidéo, il prend en charge les capacités visuelles par le biais d'entrées d'images. Cela permet au modèle de traiter et d'analyser des données visuelles, qui peuvent être combinées avec l'appel de fonctions pour effectuer des tâches impliquant à la fois des données textuelles et des données d'image.

4. Fonctionnalités avancées

La fonction d'appel de fonction de GPT-4.5 est conçue pour simplifier les flux de travail complexes en permettant au modèle de suggérer ou d'invoquer des fonctions écrites dans votre code. Cela peut s'avérer particulièrement utile pour automatiser des tâches répétitives ou intégrer des décisions basées sur l'IA dans des systèmes logiciels existants.

Découvrez tous les détails du nouveau modèle OpenAI en lisant le blog GPT 4.5 : Caractéristiques, accès, comparaison GPT-4o et plus encore.

GPT-4.5 Appel à une seule fonction

Nous allons maintenant construire un système simple d'appel de fonctions en utilisant le modèle GPT-4.5 et la bibliothèque Yahooquery. La bibliothèque Yahooquery nous aidera à extraire toutes les données relatives aux actions de Yahoo Finance. 

Notre solution permettra aux utilisateurs de poser des questions sur le cours des actions, en déclenchant une fonction spécifique qui récupère le cours des actions sur l'internet et génère une réponse. C'est aussi simple que cela. 

Nous commencerons par installer les bibliothèques openai et yahooquery à l'aide de la commande PIP.

!pip install openai yahooquery -q

Création d'une fonction de cours de bourse  

Créez une fonction Python qui prend un ticker (par exemple, AAPL) et renvoie le prix de ce ticker. Il utilise yahooquery en arrière-plan pour extraire les données pertinentes.

from openai import OpenAI
import json
from yahooquery import Ticker

def get_stock_price(ticker):
    try:
        # Create a Ticker object for the provided ticker symbol
        t = Ticker(ticker)
        # Retrieve the price data
        price_data = t.price
        # Check if we received valid data for the ticker
        if ticker in price_data and price_data[ticker].get("regularMarketPrice") is not None:
            price = price_data[ticker]["regularMarketPrice"]
        else:
            return f"Price information for {ticker} is unavailable."
    except Exception as e:
        return f"Failed to retrieve data for {ticker}: {str(e)}"
    
    return f"{ticker} is currently trading at ${price:.2f}"

Définition des outils à l'aide de la fonction

Le client OpenAI ne comprend pas la fonction Python, nous devrons donc créer un outil utilisant la liste des dictionnaires. Nous devons fournir le nom, la description et le type de sortie nécessaires. 

Chaque fois que cette fonction est invoquée, elle extrait le nom du téléscripteur de l'invite et le renvoie dans un format structuré.

tools = [{
    "type": "function",
    "function": {
        "name": "get_stock_price",
        "description": "Get current stock price for a provided ticker symbol from Yahoo Finance using the yahooquery Python library.",
        "parameters": {
            "type": "object",
            "properties": {
                "ticker": {"type": "string"}
            },
            "required": ["ticker"],
            "additionalProperties": False
        },
        "strict": True
    }
}]

Laissez le modèle décider s'il doit appeler la fonction

Testons la fonction OpenAI que nous venons de créer. Complétez le chat avec le message de l'utilisateur, le nom du modèle et les outils.

client = OpenAI()

messages = [{"role": "user", "content": "What's the current price of Meta stock?"}]

completion = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

print(completion.choices[0].message.tool_calls)

Comme nous pouvons le voir, GPT-4.5 a correctement invoqué le site get_stock_price et renvoyé le bon ticker (META).

[ChatCompletionMessageToolCall(id='call_uVGbahRiMnn4AkOJYbv8gfIV', function=Function(arguments='{"ticker":"META"}', name='get_stock_price'), type='function')]

Exécutez la fonction avec le téléscripteur fourni

Nous pouvons maintenant fournir ce ticker à notre fonction Python get_stock_price. 

tool_call = completion.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

result = get_stock_price(args["ticker"])

print(result)

Vous recevez alors une réponse comprenant le nom du téléscripteur et le prix correspondant.

META is currently trading at $640.00

Vous pouvez vous arrêter là, mais pour fournir une réponse correcte en langage naturel, vous devez à nouveau transmettre les résultats à l'outil de dialogue en ligne.

Ajout de l'appel de fonction et du résultat de l'outil

Nous ajouterons la réponse générée lors de la conversation précédente et inclurons également l'appel d'outil avec l'ID de l'outil et les résultats de l'outil.

messages.append(completion.choices[0].message)  # Model's function call message
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": str(result)
})

Renvoyez la conversation actualisée au modèle

Exécutez à nouveau l'achèvement du chat avec le message qui comprend le contenu de l'appel d'outils.

completion_2 = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

# The final model response incorporating the stock price information
print(completion_2.choices[0].message.content)

Comme vous pouvez le constater, nous avons obtenu le bon résultat. 

The current price of Meta stock (META) is $640.00.

Vous pourriez penser qu'il s'agit d'une étape inutile, mais lorsque vous avez un résultat complexe, cette étape vous aidera à comprendre les résultats en langage clair au lieu des résultats au format JSON.

Si vous avez des doutes sur l'API OpenAI et que vous souhaitez en savoir plus, envisagez de suivre la formation OpenAI Fundamentals pour apprendre à utiliser l'API OpenAI pour les modèles GPT et Whisper de l'OpenAI.

GPT4.5 Appel de fonctions multiples

Nous allons maintenant apprendre à ajouter une autre fonction à notre système d'IA afin que GPT-4.5 puisse décider automatiquement de la fonction à invoquer en fonction de l'invite de l'utilisateur. Nous ajoutons une nouvelle fonction d'alimentation qui renverra les 3 premiers articles d'actualité ainsi que les liens pour le téléscripteur spécifié. 

Commencez par installer la bibliothèque feedparser à l'aide de la commande pip. Nous utiliserons cette bibliothèque pour extraire les titres du téléscripteur spécifié.

!pip install feedparser -q

Définissez la fonction d'information sur les actions

Créez la fonction Python get_stock_news qui prendra le téléscripteur en entrée et renverra les trois premiers titres de l'actualité avec leurs liens.

import feedparser


def get_stock_news(ticker):
    # Construct the RSS feed URL for the given ticker.
    rss_url = f"https://feeds.finance.yahoo.com/rss/2.0/headline?s={ticker}&region=US&lang=en-US"
    try:
        feed = feedparser.parse(rss_url)
        if not feed.entries:
            return f"No news found for {ticker}."
        # Extract the top 3 news items (title and link)
        news_items = []
        for entry in feed.entries[:3]:
            title = entry.get("title", "No Title")
            link = entry.get("link", "No Link")
            news_items.append(f"{title} ({link})")
        news_str = "\n".join(news_items)
    except Exception as e:
        return f"Failed to retrieve news for {ticker}: {str(e)}"
    
    return f"Latest news for {ticker}:\n{news_str}"

get_stock_news("AAPL")

Nous avons rassemblé les trois principaux titres sur Apple avec les liens appropriés.

'Latest news for AAPL:\nNvidia AI Server Maker Hon Hai Posts 25% Jump in Two-Month Sales 
(https://finance.yahoo.com/news/nvidia-ai-server-maker-hon-075011863.html?.tsrc=rss)\nFoxconn says February revenue rose 56.43% y/y
(https://finance.yahoo.com/news/foxconn-says-february-revenue-rose-074433615.html?.tsrc=rss)\nApple Inc. (AAPL): Among the Best Stocks To Invest In According to Billionaires 
(https://finance.yahoo.com/news/apple-inc-aapl-among-best-051548210.html?.tsrc=rss)'

Définir des outils multiples pour le cours des actions et les nouvelles

Nous devons maintenant ajouter une autre fonction OpenAI appelée get_stock_news avec la description et le résultat appropriés.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Get current stock price for a provided ticker symbol using yahooquery.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string"}
                },
                "required": ["ticker"],
                "additionalProperties": False
            },
            "strict": True
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_stock_news",
            "description": "Get the latest news for a provided ticker symbol by parsing the Yahoo Finance RSS feed using feedparser.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string"}
                },
                "required": ["ticker"],
                "additionalProperties": False
            },
            "strict": True
        }
    }
]

Laissez le modèle décider s'il doit appeler une ou les deux fonctions.

Essayons de tester cette fonction en posant à GPT-4.5 des questions sur les actions de Google et sur les dernières nouvelles concernant Google.

messages = [{
    "role": "user",
    "content": "What's the current price of Google stock and can you show me the latest news about it?"
}]


completion = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

completion.choices[0].message.tool_calls

Comme nous pouvons le voir, il a invoqué les deux fonctions pour les cours des actions et les dernières nouvelles.

[ChatCompletionMessageToolCall(id='call_zfcRJ4EcIUUqHCcN8SErjeoi', function=Function(arguments='{"ticker": "GOOGL"}', name='get_stock_price'), type='function'),
 ChatCompletionMessageToolCall(id='call_jBv8TlSPOyFKcRWHwByxLMb4', function=Function(arguments='{"ticker": "GOOGL"}', name='get_stock_news'), type='function')]

Sauvegarde du résultat de l'appel de fonction

Le problème est que les deux fonctions renvoient le téléscripteur comme résultat. Nous devons trouver une instruction if-else pour déterminer quelle fonction est invoquée. Nous stockerons les résultats de la fonction dans le dictionnaire.

# The model returns function call requests.
tool_calls = completion.choices[0].message.tool_calls

# Execute each function call based on the tool the model requested
tool_results = {}
for tool_call in tool_calls:
    func_name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)
    if func_name == "get_stock_price":
        tool_results["price"] = get_stock_price(args["ticker"])
    elif func_name == "get_stock_news":
        tool_results["news"] = get_stock_news(args["ticker"])

Ajout de l'appel de fonction et des résultats de l'outil

Nous allons maintenant ajouter l'ID de l'outil aux résultats générés précédemment et au résultat de la fonction. 

messages.append(completion.choices[0].message)  # Append the model's function call message

for tool_call in tool_calls:
    func_name = tool_call.function.name
    result_content = tool_results.get("price") if func_name == "get_stock_price" else tool_results.get("news")
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": result_content
    })

Renvoyez la conversation actualisée au modèle

Lorsque nous transmettons le message résultant au GPT-4.5, celui-ci a généré des résultats étonnants et parfaitement raisonnables.

from IPython.display import display, Markdown

completion_2 = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

# The final model response incorporates both stock price and news.
Markdown(completion_2.choices[0].message.content)

Nous avons obtenu le cours de l'action Google et des liens vers les principales informations sur Google. 

Le code source et les résultats sont disponibles dans l'espace de travail Espace de travail DataLab. Tout ce que vous avez à faire est d'ajouter votre propreclé API OpenAI à la variable d'environnement, et vous pouvez tout exécuter par vous-même.

Conclusion

Nous avons forcé de grands modèles de langage à générer une sortie structurée, puis à la transmettre à une API ou à une autre fonction Python pour qu'elle exécute une tâche spécifique. L'IA avancée, comme GPT-4.5, peut utiliser plusieurs services ou API pour générer des réponses hautement intégrées. 

À l'avenir, nous utiliserons des appels de fonction et des agents pour contrôler tout ce qui nous entoure ; il suffira d'envoyer une commande vocale à votre IA pour qu'elle invoque les outils nécessaires en fonction de votre commande et qu'elle apporte des modifications au système.

Nous disposons de GPT-4.5, mais de nombreux experts en IA attendent GPT-5, qui devrait être plus proche de l'AGI. Vous pouvez tout savoir sur le modèle à venir en lisant le blog Tout ce que nous savons sur le GPT-5 .