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

Les modèles de grands langues (LLM) ont souvent du mal à produire de manière fiable des sorties structurées comme JSON, même avec une invitation avancée. Bien que l'ingénierie rapide aide, ce n'est pas parfait, conduisant à des erreurs occasionnelles. Ce tutoriel montre comment l'appel de la fonction dans les LLMS assure des données structurées précises et cohérentes.

Fonction Calling permet aux LLMS générer des données structurées (généralement JSON) et interagir avec des systèmes externes, des API et des outils, permettant des tâches complexes et complexes tout en conservant la précision. Nous utiliserons GPT-4.5, connu pour sa précision, pour construire un script appelé à des fonctions. Tout d'abord, nous allons créer une fonction pour récupérer les cours des actions; Ensuite, nous en ajouterons une autre pour permettre au LLM de choisir entre plusieurs outils en fonction de l'invite. La demande finale fournira les cours des actions et les flux d'actualités.

Image de l'auteur

Fonction de GPT-4.5 Avantages d'appel:

GPT-4.5 améliore l'appel de la fonction, améliorant l'interaction avec les systèmes externes et la gestion des tâches complexes. Les caractéristiques clés comprennent:

1. Intégration de l'API: fonctionne avec les compléments de chat, les assistants et les API par lots pour l'intégration d'application sans couture.
2. Sorties structurées: renvoie des données structurées (JSON), idéales pour interagir avec les systèmes nécessitant des formats de données spécifiques.
3. Capacités de vision: accepte les entrées d'image (mais pas les sorties multimodales comme la vidéo ou l'audio).
4. Fonctions avancées: simplifie les workflows complexes en suggérant ou en invoquant des fonctions dans votre code, en automatisant les tâches et en intégrant la prise de décision d'IA.

(Voir le blog "GPT 4.5: fonctionnalités, accès, comparaison GPT-4O et plus" pour plus de détails sur le modèle OpenAI.)

Fonction unique appelant (cours de l'action):

Nous allons construire un système simple à l'aide de GPT-4.5 et de la bibliothèque yahooquery (pour les données de financement Yahoo). Les utilisateurs posent des questions sur les cours des actions, déclenchant une fonction pour récupérer et répondre avec le prix.

1. Installez les bibliothèques:

    ! pip install openai yahooquery -q

2. Fonction du cours de l'action: Cette fonction Python prend un symbole de ticker (par exemple, AAPL) et renvoie son prix.

    à partir d'Openai Import Openai
   Importer JSON
   de Yahooquery Import Ticker
   
   def get_stock_price (ticker):
       essayer:
           T = ticker (ticker)
           prix_data = t.price
           Si Ticker dans Price_data et Price_Data [Ticker] .get ("régulièrementmarketprice") n'est pas nul:
               Price = Price_data [Ticker] ["régulièrementmarketprice"]
           autre:
               RETOUR F "Les informations de prix pour {Ticker} ne sont pas disponibles."
       sauf exception comme e:
           return f "Impossible de récupérer les données pour {ticker}: {str (e)}"
   
       return f "{ticker} se négocie actuellement à $ {prix: .2f}"

3. Définissez l'outil: nous créons une définition d'outil (liste des dictionnaires) pour OpenAI, spécifiant le nom, la description et le type de sortie de la fonction.

    outils = [{
       "type": "fonction",
       "fonction": {
           "nom": "get_stock_price",
           "Description": "Obtenez le cours actuel de l'action de Yahoo Finance.",
           "Paramètres": {
               "type": "objet",
               "propriétés": {
                   "Ticker": {"type": "String"}
               },
               "requis": ["Ticker"],
               "supplémentaires": faux
           },
           "Strict": vrai
       }
   }]

4. Invoquez la fonction: nous envoyons un message utilisateur à GPT-4.5, en spécifiant le modèle et les outils.

    client = openai ()
   Messages = [{"Rôle": "utilisateur", "Contenu": "Quel est le prix actuel de Meta Stock?"}]
   complétion = client.chat.completions.create (modèle = "gpt-4.5-preview", messages = messages, outils = outils)
   print (complétion.choices [0] .Message.tool_Calls) # montre une invocation de la fonction

5. Exécuter et retourner: nous extrassons le ticker, exécutons get_stock_price et imprimons le résultat. Ensuite, nous affinons la réponse en le renvoyant au modèle de formatage du langage naturel.

Fonction multiple appelle (cours des actions et actualités):

Nous ajoutons une fonction pour récupérer les actualités de stock à l'aide de la bibliothèque feedparser .

1. Installer feedparser :

    ! PIP Installer FeedParser -Q

2. Fonction d'actualités en stock: Cette fonction récupère les trois premières titres pour un ticker donné.

    Importer FeedParser
   
   def get_stock_news (ticker):
       RSS_URL = F "https://feeds.finance.yahoo.com/rss/2.0/headline?s= {ticker »&region=us&lang=en-us"
       essayer:
           Feed = FeedParser.Parse (RSS_URL)
           Si non Feed.Entries:
               Renvoie f "Aucune nouvelle trouvée pour {Ticker}."
           news_items = [f "{entry.title} ({entry.link})" pour l'entrée dans feed.entries [: 3]]
           return f "Dernières nouvelles pour {ticker}: \ n {chr (10) .join (news_items)}"
       sauf exception comme e:
           return f "n'a pas réussi à récupérer les nouvelles pour {ticker}: {str (e)}"

3. Définir plusieurs outils: nous mettons à jour la liste tools pour inclure les deux fonctions.

4. Sélection du modèle: Nous posons à GPT-4.5 une question nécessitant les deux fonctions (par exemple, "prix de l'action et nouvelles de Google"). GPT-4.5 choisira automatiquement et invoquera les fonctions appropriées.

5. Manipulation des résultats: nous gérons les résultats des deux fonctions, potentiellement à l'aide de la logique conditionnelle en fonction des noms de fonction renvoyés par le LLM. Les résultats sont ensuite ramenés au LLM pour une réponse finale lisible par l'homme.

Conclusion:

Ce didacticiel montre comment la fonction d'appel des fonctions permet aux LLMS de générer des sorties structurées et d'interagir avec les ressources externes. Cette approche améliore la fiabilité et la précision des applications axées sur LLM, ouvrant la voie à des systèmes d'IA plus sophistiqués. Les progrès futurs, comme GPT-5, promettent des capacités encore plus importantes dans ce domaine. Les extraits de code fournis peuvent être combinés et élargis pour créer des applications plus complexes et puissantes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!