Livre blanc sur les agents Google et les applications de base (version chinoise)

Par Julia Wiesinger, Patrick Marlow et Vladimir Vuskovic
Original : https://www.kaggle.com/whitepaper-agents

répertoire (sur le disque dur de l'ordinateur)

bref

Qu'est-ce qu'un corps intelligent ?

modélisation

artefact

couche d'orchestration

Intelligentsia et modélisation

Architecture cognitive : comment fonctionne l'intelligence

Les outils : nos clés vers le monde extérieur

extensions

Exemples d'extensions

fonction (math.)

cas d'utilisation

Fonction Exemple de code

stockage des données

Réalisation et application

Examen de l'outil

Améliorer la performance des modèles grâce à un apprentissage ciblé

Démarrage rapide d'Intelligentsia avec LangChain

Applications de production utilisant les intelligences Vertex AI

résumés

Cette combinaison de raisonnement, de logique et d'accès à l'information externe, liée à des modèles d'IA génératifs, conduit au concept d'intelligences.

bref

Les êtres humains sont très doués pour effectuer des tâches complexes de reconnaissance de formes. Cependant, il s'appuie souvent sur des outils - tels que des livres, des recherches sur Google ou des calculatrices - pour compléter ses connaissances préalables avant de parvenir à une conclusion.

Tout comme les humains, les modèles d'IA générative peuvent être entraînés à utiliser des outils pour accéder à des informations en temps réel ou suggérer des actions dans le monde réel. Par exemple, les modèles peuvent utiliser des outils de recherche de base de données pour accéder à des informations spécifiques, telles que l'historique des achats d'un client, afin de générer des recommandations d'achat personnalisées.

Par ailleurs, sur la base d'une requête de l'utilisateur, le modèle peut effectuer divers appels d'API, envoyer une réponse par courrier électronique à un collègue ou effectuer une transaction financière en votre nom. Pour ce faire, le modèle doit non seulement accéder à un ensemble d'outils externes, mais aussi avoir la capacité de planifier et d'exécuter n'importe quelle tâche de manière autonome.

Cette combinaison de raisonnement, de logique et d'accès à des informations externes est liée au modèle d'IA générative, ce qui conduit à la notion de corps ou de programme intelligent qui étend les capacités indépendantes du modèle d'IA générative. Ce livre blanc explore plus en détail tous ces aspects et d'autres aspects connexes.

Qu'est-ce qu'un corps intelligent ?

Dans sa forme la plus élémentaire, une intelligence artificielle générative peut être définie comme une application qui tente d'atteindre un objectif en observant le monde et en agissant sur celui-ci à l'aide des outils dont elle dispose. Les intelligences sont autonomes et peuvent agir indépendamment de l'intervention humaine, en particulier lorsqu'elles sont dotées d'objectifs ou d'intentions appropriés. Les intelligences peuvent également être proactives dans leur approche de la réalisation de leurs objectifs. Même en l'absence d'un ensemble d'instructions explicites de la part d'un être humain, un corps intelligent peut raisonner sur ce qu'il doit faire ensuite pour atteindre son but ultime. Bien que le concept d'intelligences dans l'IA soit assez général et puissant, ce livre blanc se concentre sur les types spécifiques d'intelligences que les modèles d'IA générative peuvent construire au moment de la publication.

Pour comprendre le fonctionnement interne des intelligences, décrivons d'abord les composantes sous-jacentes qui déterminent leur comportement, leurs actions et leurs décisions. La combinaison de ces composants peut être décrite comme une architecture cognitive, et il existe de nombreuses architectures de ce type qui peuvent être réalisées en mélangeant et en associant ces composants. Si l'on se concentre sur les fonctions essentielles, l'architecture cognitive d'un organisme intelligent comporte trois composantes de base, comme le montre la figure 1.

Figure 1 : Architecture et composants génériques du renseignement

modélisation

Dans le contexte de l'intelligentsia, un modèle est un modèle de langage (LM) qui sera utilisé comme décideur centralisé pour les processus de l'intelligentsia. Les modèles utilisés par l'intelligentsia peuvent être un ou plusieurs LM de toute taille (petite/grande) capables de suivre un raisonnement basé sur l'instruction et des cadres logiques tels que ReAct, Chain of Thought ou Thinking Tree. Les modèles peuvent être génériques, multimodaux ou adaptés aux besoins de votre architecture particulière de corps intelligent. Pour obtenir les meilleurs résultats de production, vous devez utiliser un modèle qui convient le mieux à l'application finale envisagée et qui, idéalement, a été entraîné sur la signature des données associée aux outils que vous prévoyez d'utiliser dans votre architecture cognitive. Il est important de noter que le modèle n'est généralement pas entraîné à l'aide des paramètres de configuration spécifiques (c'est-à-dire la sélection des outils, les paramètres d'orchestration/de raisonnement) des intelligences. Toutefois, le modèle peut être optimisé pour exécuter les tâches de l'organisme intelligent en lui fournissant des exemples démontrant la fonctionnalité de l'organisme intelligent, y compris des cas où l'organisme intelligent utilise des outils ou des étapes de raisonnement particuliers dans divers contextes.

artefact

Le modèle sous-jacent, malgré ses impressionnantes capacités de génération de textes et d'images, reste limité par son incapacité à interagir avec le monde extérieur. Les outils comblent cette lacune, permettant aux intelligences d'interagir avec des données et des services externes tout en débloquant un champ d'opérations plus large que le modèle sous-jacent lui-même. Les outils peuvent prendre de nombreuses formes et être plus ou moins complexes, mais ils sont généralement alignés sur les méthodes courantes de l'API Web telles que GET, POST, PATCH et DELETE. Par exemple, les outils peuvent mettre à jour les informations sur les clients dans une base de données ou récupérer des données météorologiques pour influencer les recommandations de voyage qu'une intelligence fournit à un utilisateur. Grâce aux outils, les intelligences peuvent accéder aux informations du monde réel et les traiter. Cela leur permet de soutenir des systèmes plus spécialisés tels que la génération améliorée par la recherche (RAG), qui étend considérablement les capacités des intelligences au-delà de ce que le modèle sous-jacent peut réaliser seul. Nous aborderons les outils plus en détail ci-dessous, mais il est important de comprendre que les outils comblent le fossé entre les fonctions internes des intelligences et le monde extérieur, débloquant ainsi un plus large éventail de possibilités.

couche d'orchestration

La couche d'orchestration décrit un processus cyclique qui contrôle la manière dont un organisme intelligent acquiert des informations, effectue un raisonnement interne et utilise ce raisonnement pour informer sa prochaine action ou décision. En règle générale, cette boucle se poursuit jusqu'à ce que l'organisme intelligent atteigne son objectif ou son point d'arrêt. La complexité de la couche d'orchestration peut varier considérablement en fonction des intelligences et des tâches qu'elles accomplissent. Certaines boucles peuvent être de simples calculs avec des règles de décision, tandis que d'autres peuvent contenir une logique en chaîne, impliquer des algorithmes d'apprentissage automatique supplémentaires ou mettre en œuvre d'autres techniques de raisonnement probabiliste. Nous aborderons la mise en œuvre de la couche d'orchestration de l'intelligentsia plus en détail dans la section Architecture cognitive.

Intelligentsia et modélisation

Pour mieux comprendre la différence entre les intelligences et les modèles, il convient d'examiner le diagramme suivant :

Architecture cognitive : comment fonctionne l'intelligence

Imaginez un chef dans une cuisine en pleine effervescence. Son objectif est de créer des plats délicieux pour les clients du restaurant, ce qui implique un cycle de planification, d'exécution et d'ajustement.

• Ils recueillent des informations telles que les commandes des clients et les ingrédients présents dans le garde-manger et le réfrigérateur.
• Ils effectuent un raisonnement interne sur les plats et les saveurs qui peuvent être préparés sur la base des informations qu'ils viennent de recueillir.
• Ils agissent pour préparer les plats : couper les légumes, mélanger les épices, faire frire la viande.

À chaque étape du processus, les chefs procèdent aux ajustements nécessaires, affinant leurs plans lorsque les ingrédients viennent à manquer ou lorsqu'ils reçoivent un retour d'information de la part des clients, et utilisant l'ensemble des résultats précédents pour déterminer leur prochain plan d'action. Ce cycle d'acquisition d'informations, de planification, d'exécution et d'ajustement décrit l'architecture cognitive unique que les chefs utilisent pour atteindre leurs objectifs.

À l'instar d'un chef cuisinier, un organisme intelligent peut utiliser une architecture cognitive pour atteindre son objectif final en traitant l'information de manière itérative, en prenant des décisions éclairées et en affinant les actions ultérieures sur la base des résultats précédents. Au cœur de l'architecture cognitive d'un corps intelligent se trouve la couche d'orchestration, qui est responsable du maintien de la mémoire, de l'état, du raisonnement et de la planification. Elle utilise le domaine en pleine évolution de l'ingénierie des indices et les cadres connexes pour guider le raisonnement et la planification, ce qui permet aux intelligences d'interagir avec leur environnement et d'accomplir des tâches plus efficacement. La recherche dans les domaines des cadres d'ingénierie des indices et de la planification des tâches pour les modèles de langage évolue rapidement et donne lieu à diverses approches prometteuses. Bien que la liste ne soit pas exhaustive, voici quelques-uns des cadres et des techniques de raisonnement les plus populaires au moment de la publication de ce livre blanc :

• ReAct, un cadre d'ingénierie des indices, fournit une stratégie de processus de pensée pour les modèles de langage afin de raisonner et d'agir sur les requêtes de l'utilisateur, avec ou sans exemples contextuels. Il a été démontré que les indices ReAct sont plus performants que plusieurs lignes de base SOTA et améliorent l'actionnabilité humaine et la crédibilité pour les grands modèles de langage.
• La chaîne de pensée (CoT) est un cadre d'ingénierie des indices qui permet des capacités de raisonnement par le biais d'étapes intermédiaires. Il existe plusieurs sous-techniques de CoT, notamment l'autoréférence, les indices actifs et la CoT multimodale, chacune présentant des avantages et des inconvénients en fonction de l'application spécifique.
• L'arbre de pensée (ToT), un cadre d'ingénierie des indices, convient parfaitement aux tâches exploratoires ou stratégiques. Il généralise les chaînes de pensée et permet aux modèles d'explorer diverses chaînes de pensée qui servent d'étapes intermédiaires à la résolution de problèmes généraux à l'aide de modèles linguistiques.

Un organisme intelligent peut utiliser l'une des techniques de raisonnement susmentionnées ou bien d'autres encore pour sélectionner la meilleure action à effectuer en réponse à une demande donnée de l'utilisateur. Prenons l'exemple d'une demande programmée d'utilisation du ReAct Le cadre sélectionne les actions et les outils appropriés en fonction de l'intelligence de la requête de l'utilisateur. La séquence des événements peut ressembler à ceci :

1. L'utilisateur envoie une requête au corps intelligent
2. L'intelligence commence la séquence ReAct
3. L'organisme intelligent envoie un message au modèle lui demandant de générer le prochain ReAct.
   L'une des étapes et la sortie correspondante :
   a. Questions : saisie de questions à partir des requêtes de l'utilisateur, à l'aide de messages-guides.
   b. Réflexions : modélisation des réflexions sur ce qu'il convient de faire ensuite
   c. Opération : décision du modèle quant à l'action à entreprendre.
   i. C'est ici que les outils peuvent être sélectionnés
   ii) Par exemple, une action pourrait être [Vol, Recherche, Code, Aucun], où les trois premiers représentent des outils connus que le modèle peut sélectionner, et le dernier représente une "absence de sélection d'outil".
   d. Intrants opérationnels : décisions du modèle concernant les intrants à fournir à l'outil, le cas échéant.
   e. Observations : résultats des opérations/manipulations des séquences d'entrée.
   i. Cette réflexion/opération/intervention/observation peut être répétée autant de fois que nécessaire. ii.
   f. Réponse finale : la réponse finale à la requête originale de l'utilisateur fournie par le modèle.
   4. la boucle ReAct se termine et la réponse finale PS est fournie à l'utilisateur :Logique de mise en œuvre de ReAct

Figure 2 : Exemple d'Intelligentsia utilisant ReAct Reasoning dans la couche d'orchestration

Comme le montre la figure 2, le modèle, l'outil et les intelligences sont configurés pour travailler de concert afin de fournir à l'utilisateur une réponse informée et concise basée sur la requête initiale de l'utilisateur. Alors que le modèle peut deviner la réponse sur la base de ses connaissances a priori (créant ainsi une illusion), il utilise l'outil (vols) pour rechercher des informations externes en temps réel. Ces informations supplémentaires sont fournies au modèle pour lui permettre de prendre des décisions plus éclairées sur la base de données factuelles réelles, qui sont agrégées et renvoyées à l'utilisateur.

En résumé, la qualité de la réponse d'un organisme intelligent peut être directement liée à la capacité du modèle à raisonner et à opérer sur ces différentes tâches, y compris la capacité à sélectionner les bons outils et la qualité de la définition de ces outils. Tout comme un chef cuisinier prépare un plat avec des ingrédients frais et prête attention aux commentaires de ses clients, un organisme intelligent s'appuie sur un raisonnement solide et des informations fiables pour fournir des résultats optimaux. Dans la section suivante, nous examinerons les différentes façons dont l'intelligentsia se connecte aux données fraîches.

Les outils : nos clés vers le monde extérieur

Si les modèles de langage traitent bien les informations, ils n'ont pas la capacité de percevoir et d'influencer directement le monde réel. Cela limite leur utilité dans les situations où ils doivent interagir avec des systèmes ou des données externes. En d'autres termes, la qualité d'un modèle linguistique dépend de ce qu'il apprend de ses données d'apprentissage. Cependant, quelle que soit la quantité de données que nous introduisons dans nos modèles, ils n'ont toujours pas la capacité fondamentale d'interagir avec le monde extérieur. Comment pouvons-nous donc donner à nos modèles la capacité d'interagir avec des systèmes externes en temps réel et en tenant compte du contexte ? Les fonctions, les extensions, les magasins de données et les plugins sont autant de moyens de doter les modèles de cette capacité essentielle.

Bien qu'ils portent de nombreux noms, les outils sont le lien qui crée une connexion entre nos modèles sous-jacents et le monde extérieur. Cette connexion avec des systèmes et des données externes permet à nos intelligences d'effectuer une grande variété de tâches avec plus de précision et de fiabilité. Par exemple, les outils peuvent permettre à un corps intelligent d'ajuster les paramètres d'une maison intelligente, de mettre à jour un calendrier, de récupérer des informations sur l'utilisateur dans une base de données ou d'envoyer un courrier électronique sur la base d'un ensemble d'instructions spécifiques.

À la date de publication de ce livre blanc, les modèles Google peuvent interagir avec trois types d'outils principaux : les extensions, les fonctions et les magasins de données. En dotant les intelligences d'outils, nous débloquons leur énorme potentiel non seulement pour comprendre le monde mais aussi pour agir sur lui, ouvrant ainsi la porte à d'innombrables nouvelles applications et possibilités.

extensions

La manière la plus simple de comprendre les extensions est de penser qu'elles comblent le fossé entre les API et les intelligences d'une manière standardisée, permettant aux intelligences d'exécuter les API de manière transparente, quelle que soit leur implémentation sous-jacente. Supposons que vous ayez construit une intelligence dont l'objectif est d'aider les utilisateurs à réserver des vols. Vous savez que vous voulez utiliser l'API Google Flights pour récupérer des informations sur les vols, mais vous ne savez pas comment faire pour que votre corps intelligent appelle ce point d'extrémité de l'API.

Figure 3 : Comment les intelligences interagissent-elles avec les API externes ?

Une approche pourrait consister à mettre en œuvre un code personnalisé qui prend une requête d'utilisateur entrante, l'analyse à la recherche d'informations pertinentes, puis effectue un appel à l'API. Par exemple, dans le cas d'utilisation de la réservation de vols, un utilisateur pourrait dire "Je veux réserver un vol d'Austin à Zurich". Dans ce cas, notre solution de code personnalisé devra extraire "Austin" et "Zurich" en tant qu'entités pertinentes de la requête de l'utilisateur avant de tenter d'effectuer un appel à l'API. Mais que se passe-t-il si l'utilisateur dit "Je veux réserver un vol pour Zurich" sans indiquer de ville de départ ? Sans les données requises, l'appel à l'API échouera et il faudra mettre en œuvre davantage de code pour capturer ces cas limites et extrêmes. Cette approche n'est pas évolutive et peut facilement échouer dans toute situation qui dépasse le champ d'application du code personnalisé mis en œuvre.

Une approche plus fiable consiste à utiliser des extensions. Les extensions comblent le fossé entre les intelligences et les API de la manière suivante :

1. Utilisez les exemples pour enseigner aux intelligences comment utiliser les points de terminaison de l'API.
2. Indiquer à l'intelligence quels sont les paramètres nécessaires pour appeler avec succès le point de terminaison de l'API.

Figure 4 : Extension pour connecter les intelligences à des API externes

Les extensions peuvent être construites indépendamment du renseignement, mais doivent être fournies dans le cadre de la configuration du renseignement. Les organismes intelligents utilisent des modèles et des exemples au moment de l'exécution pour déterminer quelles extensions, le cas échéant, sont appropriées pour résoudre la requête de l'utilisateur. Cela met en évidence un avantage clé des extensions, leur type d'exemple intégré, qui permet à l'organisme intelligent de sélectionner dynamiquement l'extension la plus appropriée pour la tâche.

Figure 5. Relation 1 à plusieurs entre Intelligentsia, les extensions et les API

On peut le comprendre de la manière suivante : un développeur de logiciels décide du point de terminaison de l'API à utiliser pour résoudre le problème d'un utilisateur. Si un utilisateur veut réserver un vol, un développeur peut utiliser l'API Google Flights, et si un utilisateur veut savoir où se trouve le café le plus proche par rapport à son emplacement, un développeur peut utiliser l'API Google Maps. De la même manière, Intelligentsia/Model Stack utilise un ensemble d'extensions connues pour décider laquelle est la mieux adaptée à la requête de l'utilisateur. Si vous souhaitez voir les extensions en action, vous pouvez les trouver dans la page Gémeaux Essayez-les sur l'application en allant dans Paramètres > Extensions et en activant l'extension que vous souhaitez tester. Par exemple, vous pouvez activer l'extension Google Flights et demander à Gemini de "montrer les vols entre Austin et Zurich vendredi prochain".

Exemples d'extensions

Pour simplifier l'utilisation des extensions, Google fournit un certain nombre d'extensions prêtes à l'emploi qui peuvent être rapidement importées dans votre projet et être utilisées avec une configuration minimale. Par exemple, l'extension "interprète de code" de l'extrait de code 1 vous permet de générer et d'exécuter du code Python à partir de descriptions en langage naturel.

Python

import vertexai
import pprint
PROJECT_ID = "YOUR_PROJECT_ID"
REGION = "us-central1"
vertexai.init(project=PROJECT_ID, location=REGION)
from vertexai.preview.extensions import Extension
extension_code_interpreter = Extension.from_hub("code_interpreter")
CODE_QUERY = """Write a python method to invert a binary tree in O(n) time."""
response = extension_code_interpreter.execute(
operation_id = "generate_and_execute",
operation_params = {"query": CODE_QUERY}
)
print("Generated Code:")
pprint.pprint({response['generated_code']})
# The above snippet will generate the following code.
# Generated Code:
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

Python

def invert_binary_tree(root):
"""
Inverts a binary tree.
Args:
root: The root of the binary tree.
Returns:
The root of the inverted binary tree.
"""
if not root:
return None
# Swap the left and right children recursively
root.left, root.right = \
invert_binary_tree(root.right), invert_binary_tree(root.left)
return root
# Example usage:
# Construct a sample binary tree
#     4
#    / \
#   2   7
#  / \ / \
# 1  3 6  9
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(7)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(9)
# Invert the binary tree
inverted_root = invert_binary_tree(root)

L'extension de l'interpréteur de code génère et exécute du code Python.

En résumé, les extensions fournissent aux intelligences une variété de moyens de percevoir, d'interagir et d'influencer le monde extérieur. La sélection et l'invocation de ces extensions sont guidées par l'utilisation d'exemples, qui sont tous définis dans le cadre de la configuration de l'extension.

fonction (math.)

Dans le domaine du génie logiciel, les fonctions sont définies comme des modules de code autonomes utilisés pour accomplir des tâches spécifiques et pouvant être réutilisés selon les besoins. Lorsque les développeurs de logiciels écrivent des programmes, ils créent généralement de nombreuses fonctions pour effectuer diverses tâches. Ils définissent également la logique d'appel de la fonction_a et de la fonction_b, ainsi que les entrées et sorties attendues.

Les fonctions fonctionnent de manière très similaire dans le domaine des intelligences, mais nous pouvons utiliser des modèles au lieu de développeurs de logiciels. Les modèles peuvent prendre un ensemble de fonctions connues et, sur la base de leur spécification, décider quand utiliser chaque fonction et quels arguments la fonction prend. Les fonctions diffèrent des extensions de plusieurs façons, notamment :

1. Fonctions de sortie du modèle et leurs paramètres, mais pas d'appels d'API en temps réel.
2. Les fonctions sont exécutées du côté du client, tandis que les extensions sont exécutées du côté du smartbody.
   Si l'on reprend l'exemple de Google Flights, une configuration simple de la fonction pourrait ressembler à la figure 7.

Figure 7 : Comment les fonctions interagissent-elles avec les API externes ?

La principale différence réside dans le fait que ni les fonctions ni les intelligences n'interagissent directement avec l'API Google Flights. Comment se déroulent les appels à l'API ?

Lors de l'utilisation de fonctions, la logique et l'exécution de l'appel des points d'extrémité de l'API sont transférées de l'intelligence à l'application cliente, comme le montrent les figures 8 et 9 ci-dessous. Le développeur dispose ainsi d'un contrôle plus granulaire sur le flux de données dans l'application. Il existe de nombreuses raisons pour lesquelles un développeur peut choisir d'utiliser des fonctions plutôt que des extensions, mais les cas d'utilisation les plus courants sont les suivants :

• Les API doivent être appelées à un autre niveau de la pile d'applications, plutôt que directement dans le processus d'architecture de l'agent (par exemple, à l'aide d'un système intermédiaire, d'un cadre frontal, etc.)
• Limites de sécurité ou d'authentification empêchant l'agent d'appeler directement l'API (par exemple, l'API n'est pas exposée à l'Internet ou l'infrastructure de l'agent n'a pas accès à l'API).
• Limites de temps ou de séquence d'opérations qui empêchent les agents d'appeler l'API en temps réel (par exemple, opérations par lots, processus d'examen manuel, etc.)
• Une logique de transformation des données supplémentaire est nécessaire pour les réponses de l'API que l'agent ne peut pas effectuer. Par exemple, certains points d'extrémité de l'API ne fournissent pas de mécanismes de filtrage permettant de limiter le nombre de résultats renvoyés. L'utilisation de fonctions côté client offre aux développeurs des possibilités supplémentaires pour effectuer ces transformations.
• Les développeurs veulent itérer sur le développement de proxy sans déployer d'infrastructure supplémentaire pour les points d'extrémité des API (par exemple, les appels de fonction peuvent être utilisés comme "simulations de jalonnement" pour les API).

Bien que les différences entre les deux approches soient plus subtiles du point de vue de l'architecture interne, comme le montre la figure 8, les appels de fonction offrent un contrôle supplémentaire et réduisent la dépendance à l'égard de l'infrastructure externe, ce qui en fait une option attrayante pour les développeurs.

Figure 8 : Contrôles côté client et côté Smartbody décrivant les extensions et les appels de fonction

cas d'utilisation

Les modèles peuvent être utilisés pour appeler des fonctions afin de gérer des processus d'exécution complexes côté client pour les utilisateurs finaux, lorsque le développeur de l'intelligentsia ne souhaite pas que le modèle linguistique gère l'exécution de l'API (comme c'est le cas avec les extensions). Prenons l'exemple suivant, où un corps intelligent est formé comme concierge de voyage pour interagir avec un utilisateur qui souhaite réserver un voyage de vacances. L'objectif est que le corps intelligent génère une liste de villes que nous pouvons utiliser dans notre application intermédiaire pour télécharger des images, des données, etc. afin que l'utilisateur puisse planifier son voyage. L'utilisateur peut dire :

J'aimerais faire du ski avec ma famille, mais je ne sais pas où aller.

Dans une invite typique du modèle, la sortie pourrait être la suivante :

Bien sûr, voici une liste de villes à considérer pour un voyage de ski en famille :

• Crested Butte, CO, États-Unis d'Amérique
• Whistler, Colombie-Britannique, Canada
• Zermatt, Suisse

Bien que la sortie ci-dessus contienne les données dont nous avons besoin (noms de villes), le format n'est pas adapté à l'analyse. Avec un appel de fonction, nous pouvons apprendre au modèle à formater cette sortie dans un style structuré (par exemple, JSON), qui est plus facile à analyser pour un autre système. Avec la même invite de l'utilisateur, l'exemple de sortie JSON de la fonction pourrait ressembler à l'extrait de code 5.

non corrigé

function_call {
name: "display_cities"
args: {
"cities": ["Crested Butte", "Whistler", "Zermatt"],
"preferences": "skiing"
}
}

Exemple d'appel de fonction pour afficher une liste de villes et les préférences de l'utilisateur Ce chargement JSON est généré par le modèle, puis envoyé à notre serveur client pour qu'il effectue l'action souhaitée. Dans ce cas particulier, nous allons appeler l'API Google Places pour récupérer les villes fournies par le modèle et rechercher les images, puis les servir à nos utilisateurs sous la forme d'un contenu riche formaté. Reportez-vous au diagramme de séquence de la figure 9, qui montre en détail les étapes de l'interaction ci-dessus.

Figure 9 : Diagramme de séquence montrant le cycle de vie d'un appel de fonction

Le résultat de l'exemple de la figure 9 est que le modèle est utilisé pour "remplir les blancs" avec les paramètres nécessaires à l'interface utilisateur client pour appeler l'API Google Places. L'interface client utilise les paramètres fournis par le modèle dans la fonction renvoyée pour gérer l'appel à l'API. Il ne s'agit là que d'un cas d'utilisation des appels de fonction, mais il existe de nombreux autres scénarios à prendre en compte, notamment :

• Vous souhaitez que le modèle de langage suggère une fonction que vous pouvez utiliser dans votre code, mais vous ne voulez pas inclure d'informations d'identification dans votre code. Étant donné que l'appel de fonction n'exécute pas la fonction, vous n'avez pas besoin d'inclure dans votre code des références contenant des informations sur la fonction.
• Vous exécutez une opération asynchrone qui peut prendre plus de quelques secondes. Ces scénarios s'appliquent aux appels de fonction car il s'agit d'une opération asynchrone.
• Vous souhaitez exécuter la fonction sur un appareil différent de celui qui a généré l'appel de fonction et ses arguments.

Une chose essentielle à retenir à propos des fonctions est qu'elles sont destinées à fournir au développeur un plus grand contrôle sur l'exécution des appels d'API et sur le flux global des données dans l'application. Dans l'exemple de la figure 9, le développeur a choisi de ne pas renvoyer les informations de l'API à l'intelligence parce qu'elles ne sont pas pertinentes pour les actions que l'intelligence pourrait entreprendre à l'avenir. Toutefois, en fonction de l'architecture de l'application, il peut être judicieux de renvoyer les données des appels d'API externes à l'organisme intelligent afin d'influencer le raisonnement, la logique et le choix des actions à venir. En fin de compte, c'est au développeur de l'application de choisir ce qui est approprié pour une application particulière.

Fonction Exemple de code

Pour obtenir le résultat ci-dessus à partir de notre scène de vacances de ski, construisons chaque composant pour qu'il fonctionne avec notre modèle gemini-1.5-flash-001. Tout d'abord, nous définissons la fonction display_cities comme une simple méthode Python.

Python

def display_cities(cities: list[str], preferences: Optional[str] = None):
"""根据用户的搜索查询和偏好提供城市列表。
Args:
preferences (str): 用户的搜索偏好, 例如滑雪、
海滩、餐馆、烧烤等。
cities (list[str]): 推荐给用户的城市列表。
Returns:
list[str]: 推荐给用户的城市列表。
"""
return cities

Exemple de méthode Python pour une fonction qui affiche une liste de villes.

Ensuite, nous allons instancier notre modèle, construire l'outil, puis transmettre la requête de l'utilisateur et l'outil au modèle. L'exécution du code ci-dessous produira la sortie indiquée au bas de l'extrait de code.

Python

from vertexai.generative_models import GenerativeModel, Tool, FunctionDeclaration
model = GenerativeModel("gemini-1.5-flash-001")
display_cities_function = FunctionDeclaration.from_func(display_cities)
tool = Tool(function_declarations=[display_cities_function])
message = "I'd like to take a ski trip with my family but I'm not sure where to go."
res = model.generate_content(message, tools=[tool])
print(f"Function Name: {res.candidates[0].content.parts[0].function_call.name}")
print(f"Function Args: {res.candidates[0].content.parts[0].function_call.args}")
> Function Name: display_cities
> Function Args: {'preferences': 'skiing', 'cities': ['Aspen', 'Vail',
'Park City']}

Extrait de code 7. Construire l'outil, l'envoyer au modèle avec une requête de l'utilisateur et permettre aux appels de fonction d'être effectués.

En résumé, les fonctions fournissent un cadre simple qui permet aux développeurs d'applications de contrôler finement le flux de données et l'exécution du système, tout en utilisant efficacement les intelligences/modèles pour la génération d'entrées clés. Les développeurs peuvent choisir de maintenir les intelligences "dans la boucle" en renvoyant des données externes, ou de les omettre en fonction des exigences architecturales spécifiques de l'application.

stockage des données

Imaginez un modèle linguistique comme une vaste bibliothèque contenant ses données d'apprentissage. Cependant, contrairement à une bibliothèque qui acquiert constamment de nouveaux livres, cette bibliothèque reste statique et ne contient que les connaissances issues de la formation initiale. Il s'agit là d'un défi, car les connaissances du monde réel sont en constante évolution.
Développement. Le stockage des données permet de remédier à cette limitation en donnant accès à des informations plus dynamiques et plus récentes et en veillant à ce que les réponses du modèle soient toujours fondées sur des faits et sur la pertinence.

Prenons un scénario courant dans lequel un développeur peut avoir besoin de fournir une petite quantité de données supplémentaires à un modèle, par exemple sous la forme d'une feuille de calcul ou d'un fichier PDF.

Figure 10 : Comment les intelligences interagissent-elles avec les données structurées et non structurées ?

Les magasins de données permettent aux développeurs de fournir des données supplémentaires aux intelligences dans leur format d'origine, éliminant ainsi la nécessité d'une conversion des données, d'une nouvelle formation des modèles ou d'un ajustement fastidieux. Le magasin de données convertit les documents entrants en un ensemble de bases de données vectorielles qui peuvent être utilisées par les intelligences pour extraire les informations nécessaires pour compléter leur prochaine action ou réponse à l'utilisateur.

Figure 11. Les magasins de données connectent les intelligences à divers types de nouvelles sources de données en temps réel.

Réalisation et application

Dans le contexte des intelligences génératives, le stockage des données est souvent mis en œuvre sous forme de bases de données vectorielles, auxquelles les développeurs s'attendent à ce que les intelligences aient accès au moment de l'exécution. Nous n'entrerons pas ici dans le détail des bases de données vectorielles, mais il est essentiel de comprendre qu'elles stockent les données sous la forme d'encastrements vectoriels, qui sont des vecteurs à haute dimension ou des représentations mathématiques des données fournies. Ces dernières années, les applications RAG (Retrieval Augmented Generation) ont été l'un des exemples les plus typiques de l'utilisation de bases de données avec des modèles linguistiques. Ces applications tentent d'étendre l'étendue et la profondeur de la connaissance du modèle en fournissant aux modèles un accès aux données dans une variété de formats, par exemple :

• Contenu du site web
• Données structurées en PDF, documents Word, CSV, feuilles de calcul et autres formats.
• Données non structurées en HTML, PDF, TXT et autres formats.

Figure 12. Relation 1 à plusieurs entre les intelligences et les datastores qui peuvent représenter différents types de données pré-indexées.

Le processus de base de chaque cycle de demande de l'utilisateur et de réponse de l'organisme intelligent est généralement modélisé comme le montre la figure 13.

1. 1. La requête de l'utilisateur est envoyée au modèle d'intégration pour générer une intégration de la requête.
   2. L'intégration de la requête est ensuite comparée au contenu de la base de données vectorielle à l'aide d'un algorithme de correspondance (par exemple ScaNN).
   3. Récupérer les correspondances de la base de données vectorielles au format texte et les renvoyer au corps intelligent.
   4. Les systèmes intelligents reçoivent les requêtes des utilisateurs et le contenu récupéré, puis formulent des réponses ou des actions.

5. envoyer la réponse finale à l'utilisateur

Figure 13 : Cycle de vie de la demande de l'utilisateur et de la réponse de l'organisme intelligent dans les applications basées sur le RAG

Le résultat final est une application qui permet aux intelligences de faire correspondre la requête de l'utilisateur à un magasin de données connu par le biais d'une recherche vectorielle, de récupérer le contenu brut et de le fournir à la couche d'orchestration et au modèle pour un traitement ultérieur. L'étape suivante peut consister à fournir à l'utilisateur la réponse finale ou à effectuer des recherches vectorielles supplémentaires pour optimiser les résultats. Un exemple d'interaction avec un corps intelligent mettant en œuvre un RAG avec le raisonnement/planification ReAct est illustré à la figure 14.

Figure 14 : Exemple d'application RAG utilisant le raisonnement/planification ReAct

Examen de l'outil

En résumé, les extensions, les fonctions et les magasins de données constituent plusieurs types d'outils différents que les intelligences peuvent utiliser au moment de l'exécution. Chaque outil a son propre objectif et peut être utilisé ensemble ou séparément, à la discrétion du développeur de l'intelligence.

Amélioration de la performance des modèles et de l'apprentissage ciblé

Un aspect essentiel de l'utilisation efficace des modèles est leur capacité à sélectionner les bons outils lors de la production de résultats, en particulier lors de l'utilisation d'outils à grande échelle dans la production. La formation générale peut aider les modèles à développer cette compétence.Mais les scénarios du monde réel exigent généralement plus quela connaissance des données de formation. Imaginez la différence entre des compétences culinaires de base et la maîtrise d'une cuisine spécifique. Les deux requièrent des connaissances culinaires de base, mais la seconde nécessite un apprentissage ciblé pour obtenir des résultats plus nuancés.

Plusieurs approches existent pour aider les modèles à acquérir ce type de connaissances spécifiques :

• Apprentissage contextuel : cette approche fournit aux modèles génériques des conseils, des outils et de petits échantillons lors du raisonnement, ce qui leur permet d'apprendre "à la volée" comment et quand utiliser ces outils pour des tâches spécifiques. le cadre ReAct est un exemple de cette approche dans le domaine du langage naturel.
• Apprentissage contextuel basé sur la récupération : cette technique alimente dynamiquement les indices du modèle en récupérant les informations, les outils et les exemples connexes les plus pertinents à partir d'un stockage externe. Le "magasin d'exemples" de l'extension Vertex AI ou l'architecture de stockage de données RAG mentionnée plus haut en sont des exemples.
• Apprentissage basé sur le réglage fin : cette méthode consiste à former le modèle à l'aide d'un plus grand ensemble de données spécifiques à un exemple avant le raisonnement. Cela permet au modèle de comprendre quand et comment appliquer certains outils avant de recevoir des demandes de la part de l'utilisateur.

Pour mieux illustrer les objectifs de chaque méthode d'apprentissage, nous pouvons revenir à l'analogie de la cuisine pour l'explorer.

• Imaginons qu'un chef reçoive une recette spécifique (indice), quelques ingrédients clés (outils connexes) et quelques exemples de plats préparés par des clients (échantillons en moins). Sur la base de ces informations limitées et de ses connaissances culinaires générales, le chef doit trouver comment préparer "à la volée" le plat qui correspond le mieux à la recette et aux préférences du client. Il s'agit là d'un apprentissage contextuel.
• Imaginons maintenant notre chef dans une cuisine bien approvisionnée, avec un garde-manger (stockage externe de données) rempli d'ingrédients et de recettes (exemples et outils). Le chef est désormais en mesure de sélectionner dynamiquement des ingrédients et des recettes à partir du garde-manger et de mieux s'aligner sur les recettes et les préférences des clients. Cela permet aux chefs de tirer parti des connaissances existantes et nouvelles pour créer des plats plus intelligents et plus sophistiqués. Il s'agit d'un apprentissage contextuel basé sur la recherche.
• Enfin, imaginons que nous renvoyons le chef à l'école pour qu'il apprenne une nouvelle cuisine ou de nouveaux plats (pré-entraînés sur un plus grand ensemble de données spécifiques à l'exemple). Cela permet au chef d'aborder les futures recettes de clients inconnus avec une compréhension plus approfondie. Si nous voulons que le chef
  Cette approche est parfaite lorsque vous excellez dans une cuisine spécifique (domaine de connaissances). Il s'agit d'un apprentissage basé sur le perfectionnement.

Chaque approche présente des avantages et des inconvénients uniques en termes de vitesse, de coût et de latence. Toutefois, en combinant ces techniques au sein d'un organisme intelligent, nous pouvons exploiter les avantages et minimiser les inconvénients, ce qui permet d'obtenir une solution plus robuste et plus adaptable.

Démarrage rapide d'Intelligentsia avec LangChain

Afin de fournir un exemple de smartbody exécutable, nous utiliserons LangChain et la fonction LangGraph Des bibliothèques pour construire un prototype rapide. Ces bibliothèques populaires à code source ouvert permettent aux utilisateurs de construire des intelligences clientes en "reliant" des séquences de logique et de raisonnement, ainsi qu'en invoquant des outils pour répondre aux questions de l'utilisateur. Nous utiliserons notre modèle gemini-1.5-flash-001 et quelques outils simples pour répondre à une requête en plusieurs étapes d'un utilisateur, comme le montre l'extrait de code 8.

Les outils que nous utilisons sont SerpAPI (pour la recherche Google) et Google Places API. Vous pouvez voir l'exemple de sortie dans l'extrait de code 9 après avoir exécuté notre procédure dans l'extrait de code 8.

Python

from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
from langchain_community.utilities import SerpAPIWrapper
from langchain_community.tools import GooglePlacesTool
os.environ["SERPAPI_API_KEY"] = "XXXXX"
os.environ["GPLACES_API_KEY"] = "XXXXX"
@tool
def search(query: str):
"""Use the SerpAPI to run a Google Search."""
search = SerpAPIWrapper()
return search.run(query)
@tool
def places(query: str):
"""Use the Google Places API to run a Google Places Query."""
places = GooglePlacesTool()
return places.run(query)
model = ChatVertexAI(model="gemini-1.5-flash-001")
tools = [search, places]
query = "Who did the Texas Longhorns play in football last week? What is the address of the other team's stadium?"
agent = create_react_agent(model, tools)
input = {"messages": [("human", query)]}
for s in agent.stream(input, stream_mode="values"):
message = s["messages"][-1]
if isinstance(message, tuple):
print(message)
else:
message.pretty_print()

Exemple d'utilisation des outils LangChain et LangGraph Intelligentsia

non corrigé

=============================== 用户消息 ================================
德克萨斯长角牛队上周的橄榄球赛对手是谁？对方球队体育场的地址是什么？
================================= AI 消息 =================================
工具调用：搜索
参数：
查询：德克萨斯长角牛队橄榄球赛程
================================ 工具消息 ================================
名称：搜索
{...结果：“NCAA 一级橄榄球联赛，佐治亚州，日期...”}
================================= AI 消息 =================================
德克萨斯长角牛队上周与佐治亚斗牛犬队进行了比赛。
工具调用：地点
参数：
查询：佐治亚斗牛犬队体育场
================================ 工具消息 ================================
名称：地点
{...桑福德体育场地址：桑福德路 100 号...}
================================= AI 消息 =================================
佐治亚斗牛犬队体育场的地址是佐治亚州雅典市桑福德路 100 号，邮编 30602。

Extrait de code 9 - Sortie du programme de l'extrait de code 8.

Bien qu'il s'agisse d'un exemple assez simple d'un corps intelligent, il démontre que tous les composants de base du modèle, de l'orchestration et de l'outillage fonctionnent ensemble pour atteindre un objectif spécifique. Dans la dernière section, nous verrons comment ces composants s'intègrent dans les produits hébergés à l'échelle de Google, tels que les intelligences Vertex AI et les Generative Playbooks.

Applications de production utilisant les intelligences Vertex AI

Bien que ce livre blanc explore les composants essentiels des intelligences, la création d'applications de niveau de production nécessite de les intégrer à d'autres outils tels que des interfaces utilisateur, des cadres d'évaluation et des mécanismes d'amélioration continue.La plateforme Vertex AI de Google simplifie ce processus en fournissant un environnement entièrement hébergé qui comprend tous les éléments essentiels décrits précédemment. À l'aide d'une interface en langage naturel, les développeurs peuvent rapidement définir les éléments clés de leurs intelligences - objectifs, descriptions de tâches, outils, sous-intelligences pour la délégation de tâches et exemples - afin de construire facilement le comportement souhaité du système. En outre, la plateforme fournit un ensemble d'outils de développement qui peuvent être utilisés pour tester, évaluer, mesurer la performance des intelligences, déboguer et améliorer la qualité globale des intelligences développées. Les développeurs peuvent ainsi se concentrer sur la construction et l'optimisation de leurs intelligences, tandis que la complexité de l'infrastructure, du déploiement et de la maintenance est gérée par la plateforme elle-même.

La figure 15 présente un exemple d'architecture pour une intelligence construite sur la plateforme Vertex AI qui utilise diverses fonctionnalités telles que Vertex Agent Builder, Vertex Extensions, Vertex Function Calls et Vertex Example Storage. L'architecture comprend un grand nombre des divers composants requis pour les applications prêtes à la production.

Figure 15 : Exemple d'architecture d'intelligences de bout en bout construites sur la plateforme Vertex AI

Vous pouvez essayer cet exemple d'architecture pré-construite de smartbody à partir de notre documentation officielle.

résumés

Dans ce livre blanc, nous examinons les éléments de base des intelligences génératives de l'IA, leur composition et les moyens efficaces de les mettre en œuvre sous la forme d'architectures cognitives. Voici quelques-unes des principales conclusions de ce livre blanc :

• Les Intelligentsia étendent la fonctionnalité des modèles de langage en utilisant des outils pour accéder à des informations en temps réel, suggérer des actions pratiques et planifier et exécuter des tâches complexes de manière autonome. Les Intelligentsia peuvent utiliser un ou plusieurs modèles de langage pour déterminer quand et comment passer d'un état à l'autre et utiliser des outils externes pour effectuer un certain nombre de tâches complexes qu'il serait difficile ou impossible pour le modèle d'effectuer seul.
• Au cœur du fonctionnement des intelligences se trouve la couche d'orchestration, une architecture cognitive qui construit le raisonnement, la planification, la prise de décision et guide ses actions. Diverses techniques de raisonnement (par exemple, ReAct, chaînes de pensée et arbres de pensée) fournissent un cadre permettant à la couche d'orchestration de recevoir des informations, d'effectuer un raisonnement interne et de prendre des décisions ou de réagir en connaissance de cause.
• Les outils (par exemple, les extensions, les fonctions et les magasins de données) sont les clés du monde extérieur pour les intelligences, leur permettant d'interagir avec des systèmes externes et d'accéder à des connaissances au-delà de leurs données de formation. Les extensions constituent un pont entre les intelligences et les API externes.Cela permet d'exécuter des appels d'API et de récupérer des informations en temps réel. Les fonctions offrent aux développeurs un contrôle plus granulaire grâce à la répartition des responsabilités, ce qui permet aux intelligences de générer des paramètres de fonction qui peuvent être exécutés sur le client. Les magasins de données permettent aux intelligences d'accéder à des données structurées ou non structurées pour prendre en charge des applications axées sur les données.

L'avenir des corps intelligents réserve des avancées passionnantes, et nous ne faisons qu'effleurer la surface de ce qui est possible. À mesure que les outils deviendront plus sophistiqués et que les capacités de raisonnement seront améliorées, les intelligences seront en mesure de résoudre des problèmes de plus en plus complexes. En outre, l'approche stratégique consistant à "enchaîner les intelligences" continuera à prendre de l'ampleur. En combinant des intelligences spécialisées - chacune excellant dans un domaine ou une tâche particulière - nous pouvons obtenir des résultats supérieurs dans tous les secteurs et tous les domaines.

Il est important de se rappeler que l'élaboration d'architectures intelligentes complexes nécessite une approche itérative. L'expérimentation et le raffinement sont essentiels pour trouver des solutions à des cas d'affaires spécifiques et à des besoins organisationnels. Il n'y a pas deux intelligences identiques en raison de la nature générative des modèles sous-jacents qui soutiennent leur architecture. Cependant, en exploitant les forces de chaque composant sous-jacent, nous pouvons créer des applications percutantes qui étendent les capacités du modèle linguistique et génèrent une valeur réelle.

note en fin d'ouvrage

• Shafran, I., Cao, Y. et al, 2022, 'ReAct : Synergising Reasoning and Acting in Language Models'. Disponible à l'adresse suivante
  https://arxiv.org/abs/2210.03629
• Wei, J., Wang, X. et al. 2023, "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models".
  Disponible à l'adresse suivante : https://arxiv.org/pdf/2201.11903.pdf.
• Wang, X. et al, 2022, "Self-Consistency Improves Chain of Thought Reasoning in Language Models".
  Disponible à l'adresse suivante : https://arxiv.org/abs/2203.11171.
• Diao, S. et al, 2023, 'Active Prompting with Chain-of-Thought for Large Language Models'. Disponible à l'adresse suivante.
  https://arxiv.org/pdf/2302.12246.pdf.
• Zhang, H. et al, 2023, "Multimodal Chain-of-Thought Reasoning in Language Models". Disponible à l'adresse suivante.
  https://arxiv.org/abs/2302.00923.
• Yao, S. et al, 2023, 'Tree of Thoughts : Deliberate Problem Solving with Large Language Models'. Disponible à l'adresse suivante.
  https://arxiv.org/abs/2305.10601.
• Long, X., 2023, 'Large Language Model Guided Tree-of-Thought'. Disponible à l'adresse suivante.
  https://arxiv.org/abs/2305.08291.
• **Google, "Google Gemini Application". Disponible à l'adresse : **http://gemini.google.com.
• **Swagger, "OpenAPI Specification". Disponible à l'adresse : **https://swagger.io/specification/.
• Xie, M., 2022, "How does in-context learning work ? A framework for understanding the differences from
  Apprentissage supervisé traditionnel". Disponible à l'adresse : https://ai.stanford.edu/blog/understanding-incontext/.
• Google Research, "ScaNN (Scalable Nearest Neighbors)". Disponible à l'adresse suivante
  https://github.com/google-research/google-research/tree/master/scann.
• **LangChain, "LangChain". Disponible à l'adresse : **https://python.langchain.com/v0.2/docs/introduction/.