Vous avez essayé de faire des calculs de mathématiques avec chat GPT ? Moi oui, et le moins que l’on puisse dire c’est qu’il est loin d’être aussi intelligent que mon fils de 12 ans dans ce domaine.
Alors là, j’avoue être un peu déçu, d’un côté il me dit 31 236.94 € et de l’autre, quand je calcule avec cette formule, j’obtiens 30 732.21 €.
Sa capacité à expliquer la formule de calcul et parfaite et nous pouvons nous rendre compte qu’il l’applique avec une décomposition fine qui nous permet de contrôler les résultats de ce qu’il faut. Tellement propre que nous pourrions nous faire berner ! On aurait tout de même pu s’attendre à un résultat parfait, mais il est seulement « probable » ce qui n’est absolument pas satisfaisant pour des mathématiques.
Explications
C’est simple, les modèles LLM comme GPT ont étés entrainés pour savoir parler notre (nos) langue(s). Cela leur permet de pouvoir proposer, suggérer, prédire une suite de mots les plus probables d’après les données en entrée qu’on lui fournit. Il ne sait donc que formuler du texte de manière probabiliste. Les résultats de calculs sont alors très absolument pas fiables…
Finalement si peu utile ?
Quelle désillusion, il ne sait que reproduire du texte alors ? Eh bien oui, mais en fait c’est ENORME ! Parce que finalement nous pouvons lui demander tout un tas de choses comme :
- Créer des résumés,
- Reformuler du texte,
- Répondre à une question à partir d’une source de référence,
- …
Mais pour que cela fonctionne, il faut bien entendu lui donner du contexte (les fameuses données en entrée que nous lui fournissons). De cette manière il produit alors des résultats extrêmement intéressants et fiables. C’est alors la technique du R.A.G (Retrieval Augmented Generation) que nous pouvons mettre en œuvre pour nous permettre d’avoir des réponses plus précises et fiables que les réponses naturellement renvoyés par ChatGPT seul.
Mais même avec ce RAG, il ne sera pas possible d’effectuer des calculs mathématiques. En effet par nature, les calculs mathématiques sont déterministes et les modèles d’IA sont probabilistes, ce sont deux mondes différents qu’il convient de faire cohabiter pour avoir des application « intelligentes ».
Plus d’infos sur le R.A.G ici : https://huggingface.co/docs/transformers/model_doc/rag
Dans mon cas, la génération du texte est très utile puisqu’elle lui permet de me donner la formule et la décomposition du calcul à réaliser. En d’autres termes, il est capable de me donner un plan d’exécution pour réaliser le calcul. Il me faudrait juste comprendre ce plan et pouvoir le dérouler pour avoir un résultat fiable…
Orchestrateur de LLM
Je vous en ai déjà parlé, il existe des orchestrateurs de modèles LLMs qui nous permettent de faciliter l’intégration de ces modèles au seins de nos applications. de cette manière nous pouvons facilement développer des plugins et utiliser les planners de ces orchestrateurs pour exécuter de multiples actions :
Comme nous pouvons le voir ici, il est alors possible de faire en sorte que notre orchestrateur puisse appeler un code natif (comprenez avec du langage de programmation) depuis une demande formulée en langage naturel.
Pour se faire il va s’appuyer sur un planificateur qui en fonction de la demande de l’utilisateur et des plugins dont il dispose, va proposer un plan d’exécution et tenter de l’exécuter étape par étape pour ensuite donner un résultat à un utilisateur.
Il existe plusieurs types de planners :
- Etape unique : execute une seule action à la fois.
- Etapes séquentielles : génère un plan en plusieurs étapes successives interconnectés.
- Etapes incrémentales : Execute les étapes de manière incrémentales en observant les résultats des étapes précédentes avant d’exécuter l’étape suivante.
Les deux premiers types de planner ont l’avantage d’être très performant tout en consommant moins de ressources (token) pour être exécutés. Le dernier est en revanche plus « lent » et plus couteux dans l’orchestration mais s’avère très pertinent en ce qui concerne sa capacité à s’adapter pour exécuter ses étapes en fonction des observations successives qu’il réalise.
Plugin
Après avoir débriefé un peu ce que c’était que le Semantic Kernel, je voudrais vous montrer comment nous pouvons développer un simple plugin afin de réaliser des calculs financiers.
public sealed class FinancialPlugin
{
...
[KernelFunction]
[Description("Calculates future value from initial investment, rate of return and number of periods.")]
[return: Description("The decimal value for future value.")]
public static decimal CalcFutureValue(
[Description("The initial investment.")] double initialInvestment,
[Description("The decimal value of rate of return (for example 1% => 0.01)")] double rateOfReturn,
[Description("The number of periods.")] double numberOfPeriods)
{
return GeneralFinanceFormulas.CalcFutureValue((decimal)initialInvestment, (decimal)rateOfReturn, (decimal)numberOfPeriods);
}
...
}
Cette simple classe, me permet alors de donner au planificateur la connaissance de fonctions lui permettant de réaliser des calculs financiers comme le calcule de la valeur future, n’étant moi-même pas bon en finance (c’est bien tout l’objet de mon assistant IA), j’utilise la librairie srbrettle.FinancialFormulas qui contient les bonnes formules de calculs.
L’orchestrateur pourra alors choisir d’utiliser cette fonction pour réaliser un calcul fiable en fonction de la demande de l’utilisateur.
Assistant
Les assistants sont des notions apportées par OpenAI dont l’objectif est de regrouper des instructions (persona), des compétences (plugins, RAG, les deux, ou les vôtres) ainsi qu’un orchestrateur pour intégrer à vos application des briques « intelligentes » s’appuyant sur des modèles de langage.
Je peux ici vous proposer une implémentation d’un assistant mathématicien capable d’utiliser le plugin de mathématiques précédent :
name: FinancialCalculator
description: An assistant that answers to financial problems with a given user prompt.
instructions: |
You are a financial assistant capable to execute financial operations.
Do not assume anything about the math problem, if some variables are missing, ask for them.
input_parameter:
default_value: ""
description: |
The word financial problem to solve in 2-3 sentences.
Make sure to include all the input variables needed along with their values and units otherwise the math function will not be able to solve it.
execution_settings:
planner: Handlebars
model: gpt-3.5-turbo
service_id: gpt-35-turbo-1106
prompt_settings:
temperature: 0.0
top_p: 1
max_tokens: 100
Paramètres de l’assistant
Pour pouvoir fonctionner, l’assistant va avoir besoins que vous lui fournissiez un peu d’informations :
- Une description et des instructions qui lui permettent de savoir comment il doit se comporter et quel est son rôle. C’est ce que vous avez certainement l’habitude d’utiliser dans le System Prompt message dans ChatGPT.
- La description de son paramètre d’entrée permet à un autre assistant de communiquer avec pour pouvoir utiliser ses compétences (nous verrons cela ensuite).
- Ses paramètres d’exécutions, qui nous permettent de définir quel est le modèle LLM utilisé par l’assistant et son planificateur.
Ici, j’ai choisis d’utiliser le modèle GPT 3.5 turbo pour deux raisons:
- Il est le plus rapide et c’est le moins chère des modèles proposés par Azure Open AI,
- Il est suffisamment adapté à la création de plans séquentiels.
Enfin pour réaliser des calculs, un planificateur séquentiel est parfait puisqu’il nous permettra d’exécuter une formule complète à moindre coût.
Enfin, il ne me reste plus qu’à tester mon assistant :
string azureOpenAIEndpoint = configuration["AzureOpenAIEndpoint"]!;
string azureOpenAIKey = configuration["AzureOpenAIAPIKey"]!;
var financialCalculator = Assistant.FromTemplate("./Assistants/FinancialCalculator.yaml",
azureOpenAIEndpoint,
azureOpenAIKey,
plugins: new List<KernelPlugin>()
{
KernelPluginFactory.CreateFromObject(new FinancialPlugin(), "financial")
}, loggerFactory: loggerFactory);
var assistant = Assistant.FromTemplate("./Assistants/Butler.yaml",
azureOpenAIEndpoint,
azureOpenAIKey,
assistants: new IAssistant[]
{
financialCalculator
}
,loggerFactory: loggerFactory);
var thread = assistant.CreateThread();
while (true)
{
Console.Write("User > ");
var result = await thread.InvokeAsync(Console.ReadLine());
Console.WriteLine($"Mathematician > {result.Trim()}");
}
Après avoir lancé ma simple application, je peux alors lui poser la même question :
Dans mon exemple, j’ai choisi de réaliser cette opération avec deux assistants. Le premier, « butler » est simplement mon major d’homme, il est en capacité de reformuler ma question et de l’envoyer à l’assistant de calculs. L’assistant de calcul n’étant capable que de réaliser le calcule et de renvoyer la réponse, la réponse est alors reformulée par mon butler.
Mon sample affiche alors le fameux « plan d’exécution » du calcule, nous confirmant ainsi que ce résultat est obtenu de manière impérative et non plus probabiliste.
Et j’ai enfin le résultat attendu !
Vous pourrez retrouver mon sample sur mon repository : https://github.com/kbeaugrand/SemanticKernel.Assistants/tree/main/samples/01-mathematician
Conclusions
J’aimerai bien ne plus entendre de phrase du type : « ChatGPT me dis ça mais ca ne marche pas! » Ou encore « D’après une étude, Chat GPT donne des réponses fausses …. ». Ces modèles ne sont en effet pas omnipotents. Il s’agit toujours de lui donner le bon contexte pour qu’il soit pertinent.
Mais il est maintenant important de comprendre comment les quelques fonctionnalités apportés par ces modèles peuvent nous permettent de faire des tâches bien plus complexes que simplement faire des résumés ou des traductions.
En 2023, nous avons pu comprendre comment utiliser ces modèles en leur donnant des « personas », grâce aux orchestrateurs nous pouvons également des plugins et des planners à ces modèles. Ces trois composants fondamentaux, nous permettent alors de créer ce que l’on appelle maintenant des Agents ou des Assistants.
Ces assistants seront alors capables de comprendre nos intentions ques nous lui livrerons avec notre langage naturel et ils exécuteront de manière plus ou moins autonomes des actions pour nous.
Ces assistants seront alors capables de comprendre nos intentions ques nous lui livrerons avec notre language naturel et ils exécuteront de manière plus ou moins autonomes des actions pour nous.
Et si un assistant spécialisé ne saura pas tout faire seul, il pourra compter sur d’autres assistants avec qui il pourra converser avec langage naturel également pour compléter ses capacités ou déléguer des actions.
Sans nul doute, si l’année 2023 était l’année de des chatbot conversationnels utilisant la technologie LLM, 2024 sera l’année des assistants et nous verrons pousser de part et d’autres un ensemble d’assistants qui pourrons collaborer pour nous rendre la vie plus facile….
Si vous voulez vous aussi créer votre assistant; je vous invite à suivre mon repository GitHub, où je vous propose une boite à outils pour créer facilement votre assistant avec le Semantic Kernel: https://github.com/kbeaugrand/SemanticKernel.Assistants.
Kevin BEAUGRAND 