Comment créer un contrat intelligent de prédiction d'IA à l'aide de GenLayer

📌 Liens rapides

• Code GitHub
• Documentation
• Version vidéo

👩‍💻 Ce que nous ferons...

Dans ce tutoriel, nous aborderons :

• Que sont les contrats intelligents basés sur l'IA et le concept de contrats intelligents.
• Étapes pour créer un contrat intelligent de prédiction
• Utilisation du simulateur GenLayer pour tester, déployer et exécuter le contrat.

Remarque : Une certaine connaissance de Python est supposée et nécessaire dans ce didacticiel.

💡 Pourquoi des contrats intelligents basés sur l'IA ?

Les contrats intelligents ont sans aucun doute changé la donne. Ils sont par nature auto-exécutables, les termes de l’accord étant directement écrits dans le code. Lorsque des conditions prédéterminées sont remplies, ils se déploient sur une blockchain et garantissent que les transactions sont traitées de manière sécurisée et transparente sans avoir recours à un tiers.

Cependant, les contrats intelligents ne suivent que des instructions spécifiques et ne peuvent pas gérer des situations inattendues ou des exigences complexes ne figurant pas dans leur programmation. Ils n'apprennent pas et ne s'adaptent pas en fonction de ce qui se passe au fil du temps. De plus, ils ne peuvent pas accéder de manière indépendante aux données externes. Ils ont besoin de services tiers comme Oracle pour alimenter les contrats intelligents en données externes, leur permettant ainsi de réagir aux événements du monde réel.

🤔 Qu'est-ce qu'un Contrat Intelligent ?

C’est cette limitation des contrats intelligents que GenLayer tente de résoudre en créant un contrat intelligent qui conserve toutes les capacités des contrats intelligents traditionnels mais peut également :

• Utilisez des modèles LLM tels que GPT-4 et LLaMA pour comprendre et traiter les instructions en langage naturel.

• Accédez et utilisez des données en temps réel sur Internet sans avoir recours à des outils tiers.

  
  

GenLayer utilise la méthode de consensus Optimistic Democracy pour valider les transactions et les opérations des contrats intelligents. Un élément clé de cette méthode de consensus est le principe d'équivalence . Le principe d'équivalence est une règle spécifique ou un ensemble de critères utilisés dans le cadre de la démocratie optimiste pour garantir l'exactitude et la cohérence lors du traitement de résultats non déterministes, tels que ceux générés par les LLM ou les données Web en temps réel. Au fur et à mesure que nous avançons, j'expliquerai davantage le principe d'équivalence et son fonctionnement lorsque nous exécutons notre contrat intelligent.

Pour ce blog, nous allons voir comment créer un contrat intelligent de prédiction de football capable de récupérer des données en temps réel sur le Web et de les traiter à l'aide de LLM pour prédire les résultats des matchs. Cela semble intéressant, non ?

Allons droit au but :).

⚒️ Configuration du simulateur GenLayer

Avant de commencer à construire notre contrat, nous devons configurer l'environnement dans lequel nous l'exécuterons. Le simulateur GenLayer est un bac à sable interactif que nous pouvons utiliser pour créer et tester nos contrats intelligents. Installons-le.

Conditions préalables

• Assurez-vous que la dernière version de Docker est installée et en cours d'exécution.
• Assurez-vous que Node.js et npm sont mis à jour vers leurs dernières versions pour éviter les problèmes de compatibilité.

Installer

Accédez à votre terminal et copiez-collez ce qui suit pour installer GenLayer sur votre ordinateur :

 npm install -g genlayer

Une fois installé, exécutez la commande init pour démarrer le processus de configuration de votre environnement de développement :

 genlayer init

Lorsque vous exécutez cette commande, elle initialise la configuration avec 5 validateurs et vous invite à sélectionner votre (vos) fournisseur(s) LLM préféré.

Vous avez le choix entre trois options :

• OpenAI : option la plus rapide et la plus fiable pour exécuter des validateurs)

• Ollama : option gratuite et open source, elle peut fonctionner plus lentement que les autres options

• Heurist : fournisseur d'inférences pour les modèles d'IA open source

  
  

Une fois votre sélection effectuée, il télécharge et configure automatiquement les conteneurs Docker nécessaires pour l'environnement du simulateur GenLayer. Une fois la configuration terminée, vous pouvez accéder au simulateur GenLayer à l' adresse http://localhost:8080/ .

Passons maintenant à la construction de notre contrat !

⚽ Construire le contrat de pronostic football

Le simulateur dispose d'un éditeur de code pour écrire du code.

Les contrats intelligents sont écrits en Python, ce qui le rend idéal pour gérer les données et les opérations de chaîne nécessaires aux interactions Web et au traitement du langage naturel.

Pour ce contrat de prédiction, nous récupérerons nos données Web sur le site Web de BBC Sport , puis nous utiliserons un LLM pour traiter les données récupérées afin de déterminer quelle équipe est l'équipe gagnante. Voyons le processus étape par étape pour ce faire

Si vous souhaitez ignorer la procédure pas à pas, vérifiez le code sur GitHub et accédez à la section « Déployer le contrat » ci-dessous.

1. Importation des bibliothèques et modules requis

Tout d'abord, nous allons importer les bibliothèques et modules que nous utiliserons pour notre contrat intelligent :

 import json from genvm.base.equivalence_principle import EquivalencePrinciple from genvm.base.icontract import IContract

• json : ce module est utilisé pour analyser et gérer les données JSON, qui est un format courant pour l'échange de données.
• EquivalencePrinciple : Cela garantit que les résultats sont cohérents et précis entre les différents validateurs. Il joue un rôle crucial dans le maintien de l'intégrité des résultats non déterministes en comparant les résultats de plusieurs validateurs.
• IContract : La classe de base pour créer des contrats intelligents sur GenLayer, fournissant des propriétés et des comportements essentiels. Il garantit que le contrat s'intègre facilement dans l'environnement GenLayer (GenVM).

2. Définition de la classe de contrat intelligent

Maintenant, nous devons définir notre classe de contrat intelligent dans ce cas, il s'agit du marché de prédiction. Notre classe de contrat Intelligent Contract hérite de IContract . Hériter d' IContract est nécessaire pour garantir que le contrat s'exécute correctement dans le cadre GenLayer :

 class PredictionMarket(IContract):

3. Ajout de paramètres de constructeur

Ensuite, nous allons initialiser l'état du contrat et configurer tous les paramètres nécessaires. Cette étape est cruciale car elle définit les conditions initiales et les propriétés que notre contrat utilisera tout au long de son exécution :

 class PredictionMarket(IContract): def __init__(self, game_date: str, team1: str, team2: str): self.has_resolved = False self.game_date = game_date self.resolution_url = 'https://www.bbc.com/sport/football/scores-fixtures/' + game_date self.team1 = team1 self.team2 = team2

Dans ce constructeur, nous définissons les paramètres suivants :

• game_date : La date du jeu au format 'AAAA-MM-JJ'.
• team1 : Le nom de la première équipe participant au match.
• team2 : Le nom de la deuxième équipe participant au match.
• has_resolved : Indique si le résultat du jeu a déjà été résolu, évitant ainsi un traitement redondant.
• resolution_url : L'URL du site Web de BBC Sport à partir duquel les résultats du jeu peuvent être récupérés.

Ces paramètres définissent l'état initial de notre contrat, le rendant prêt à traiter les résultats du jeu.

4. Résoudre le résultat du jeu

Ajoutons maintenant une méthode pour déterminer le résultat du jeu. Cette méthode garantit que nous ne traitons le résultat du jeu que s'il n'a pas encore été résolu :

 async def resolve(self) -> None: if self.has_resolved: return "Already resolved" final_result = {}

Cette méthode vérifie d'abord si le résultat a déjà été déterminé en inspectant self.has_resolved . Cela évite les traitements redondants et garantit l’efficacité. Si le jeu n'a pas encore été résolu, nous initialisons final_result pour stocker les résultats. Ce dictionnaire contiendra les résultats finaux validés du jeu.

5. Rédaction du principe d'équivalence

Le principe d'équivalence est très important lors de la rédaction d'un contrat intelligent. Lorsque vous accédez au Web ou appelez des LLM, des incohérences peuvent survenir. Le principe d'équivalence, comme nous l'avons dit plus tôt, est une règle spécifique ou un ensemble de critères utilisés pour valider les résultats finaux d'opérations non déterministes (appels Web ou LLM). Ce principe utilise plusieurs validateurs, l'un agissant en tant que leader pour proposer un résultat, et d'autres validant ce résultat en fonction des critères ou de la règle définis.

Par conséquent, dans notre contrat, nous devons définir notre principe d'équivalence pour éviter les incohérences dans nos sorties sur le Web ou lorsque les processus avec LLM :

 async with EquivalencePrinciple( result=final_result, principle="The score and the winner have to be exactly the same", comparative=True, ) as eq:

Pour notre contrat de prédiction, le principe d'équivalence stipule que « le score et le gagnant doivent être exactement les mêmes ». Les validateurs utiliseront ce principe pour comparer leurs résultats avec celui du leader. Si le résultat correspond selon le principe d'équivalence, alors le résultat final est accepté. L'indicateur comparative=True indique que le leader et les validateurs effectuent des tâches identiques et comparent leurs résultats pour garantir la cohérence.

Dans le cadre de ce principe d'équivalence, nous allons récupérer les données Web sur le jeu et les traiter à l'aide de LLM.

Récupération de données Web

À l’avenir, dans le bloc Principe d’équivalence, nous allons récupérer le contenu de la page Web à partir de l’URL du site Web d’informations de BBC Sport :

 web_data = await eq.get_webpage(self.resolution_url) print(web_data)

Une fois les données récupérées, nous allons les traiter avec le LLM pour vérifier le résultat et déterminer l'équipe gagnante à partir de la page Web récupérée.

Traiter les données récupérées à l'aide de LLM

Pour traiter les informations de la page Web récupérée, nous allons créer des invites à envoyer au LLM, lui indiquant exactement ce qu'il doit faire. Lors de l'interaction avec les LLM, il est important de créer des invites claires et spécifiques pour guider le modèle dans la fourniture de réponses précises et pertinentes. Voici l'invite que nous avons créée ci-dessous :

 task = f"""In the following web page, find the winning team in a matchup between the following teams: Team 1: {self.team1} Team 2: {self.team2} Web page content: {web_data} End of web page data. If it says "Kick off [time]" between the names of the two teams, it means the game hasn't started yet. If you fail to extract the score, assume the game is not resolved yet. Respond with the following JSON format: {{ "score": str, // The score with numbers only, eg, "1:2", or "-" if the game is not resolved yet "winner": int, // The number of the winning team, 0 for draw, or -1 if the game is not yet finished }} """ result = await eq.call_llm(task) print(result)

L'invite que nous avons créée demande au LLM de :

• Identifiez l'équipe gagnante et marquez à partir de la page Web récupérée

• Nous avons également inclus une condition permettant au LLM de vérifier si le jeu n'a pas encore commencé. Si la phrase « Coup d'envoi [heure] » apparaît entre les noms des deux équipes, cela indique que le match n'a pas commencé . Le LLM est chargé de reconnaître ce scénario et de comprendre qu'aucun résultat ne peut encore être extrait.

• Nous avons également inclus une autre condition à gérer pour que le LLM suppose que le jeu n'est pas résolu s'il ne peut pas extraire le score. Cela garantit que les jeux incomplets ou en cours sont traités de manière appropriée.

• Enfin, nous demandons au LLM de répondre en utilisant un format JSON

  
  

Cette invite détaillée gère différents scénarios et garantit que le LLM extrait et traite les informations requises avec précision et cohérence. Une fois l'invite créée, nous l'envoyons au LLM à l'aide de la méthode call_llm .

5. Définition du résultat selon le principe d'équivalence

Une fois notre résultat obtenu au LLM, il sera ensuite vérifié et validé selon le Principe d'Equivalence défini ci-dessus : "Le score et le gagnant doivent être exactement les mêmes." Si le résultat correspond selon le principe d'équivalence, le résultat final est accepté.

 eq.set(result)

Remarque : Les validateurs ne valident pas chaque étape du bloc Principe d'équivalence et se concentrent uniquement sur le résultat final pour réduire le besoin de validations complexes, économiser des ressources et simplifier les opérations du contrat.

6. Analyser et évaluer le résultat

Une fois le résultat validé et finalisé, nous pouvons maintenant analyser le résultat en utilisant json.loads() . Cela convertit le résultat dans un format qui peut être facilement manipulé et évalué. De notre résultat analysé, nous extrairons le gagnant et le score :

 result_json = json.loads(final_result['output']) if result_json['winner'] > -1: self.has_resolved = True self.winner = result_json['winner'] self.score = result_json['score'] return result_json

Si le résultat du jeu est déterminé (gagnant > -1), l'état du contrat est mis à jour en conséquence. Cela garantit que le résultat final est enregistré avec précision.

Nous sommes maintenant prêts à déployer notre contrat !

Voyons notre contrat en action !

🚀 Déployez votre contrat intelligent de pronostics de football

1. Dans le simulateur GenLayer, cliquez sur le bouton de lecture pour exécuter votre contrat.

2. Dans la section des paramètres du constructeur, indiquez la date du match et les noms des deux équipes que vous souhaitez vérifier. Par exemple, vous pouvez définir game_date sur "2024-06-05", team1 sur "Brésil" et team2 sur "Jamaïque".

3. Une fois les détails du jeu définis, cliquez sur Déployer

   
   

🎯 Exécution de transactions

Pour interagir avec le contrat déployé, rendez-vous dans la section Exécuter les transactions . Ici, vous pouvez appeler la méthode de résolution pour traiter le résultat du jeu.

Lorsque la méthode de résolution est exécutée :

• Les nœuds exécutés par le simulateur récupèrent les données de l'URL spécifiée, qui est l'URL de BBC Sport dans ce cas, puis le LLM les traite.
• Le résultat final du jeu est ensuite validé selon le principe d'équivalence défini dans le code.

Comment fonctionne le principe d'équivalence lorsqu'un contrat intelligent est exécuté :

• Calcul du leader : le validateur Leader récupère les données de jeu de BBC Sport et détermine le score final et l'équipe gagnante. Par exemple, le leader calcule le score comme « 1 : 2 » avec la victoire de la Jamaïque (équipe 2) contre le Brésil (équipe 1).
• Calculs des validateurs : chaque validateur récupère indépendamment les données du jeu à partir de la même URL et effectue la même tâche pour déterminer le score final et le gagnant. Par exemple, un validateur pourrait également calculer le score comme « 1 : 2 » avec la victoire de la Jamaïque (équipe 2) contre le Brésil (équipe 1).
• Comparaison : Les validateurs comparent leurs résultats avec ceux du Leader. Selon le principe d'équivalence, le score et le gagnant doivent être exactement les mêmes. Si le résultat du leader est « 1 : 2 » avec la Jamaïque (équipe 2) comme vainqueur, alors le résultat de chaque validateur doit également être « 1 : 2 » avec la Jamaïque (équipe 2) comme vainqueur.
• Décision : Si tous les résultats des validateurs correspondent à celui du Leader, ils acceptent le résultat du Leader comme valide.

Ce processus garantit la cohérence et l’exactitude sur l’ensemble du réseau. Si les validateurs renvoient "1:3" avec la Jamaïque (équipe 2) comme vainqueur et que le leader renvoie "1:2" avec la Jamaïque (équipe 2), les validateurs rejetteront le résultat.

Gestion de différents scénarios :

• Si le jeu est terminé, la réponse JSON inclura le score final et l'équipe gagnante.
• Si le jeu a commencé mais n'est pas terminé, la réponse JSON indiquera que le jeu n'est pas encore résolu.
• Si le jeu n'a pas démarré, la réponse JSON indiquera ce statut.

Consultez les journaux pour voir des informations détaillées sur l’interaction contractuelle.

💭 Réflexions finales : autres cas d'utilisation des contrats intelligents IA

🙌 Félicitations si vous avez lu jusqu'au bout !!!

L’avenir s’annonce prometteur pour les contrats intelligents basés sur l’IA. Outre le contrat de pronostics footballistiques, il existe d'autres idées de contrats intelligents que vous pouvez créer et tester avec le GenLayer Simulator :

• Journaliste météo
• Jeton ERC-20
• Vérificateur de cours des actions
• Récapitulateur des actualités
• Planificateur de voyage
• Recherche de livres
• Puzzles logiques
• Magicien de la pièce

Il existe également d'autres exemples d'idées dans la documentation GenLayer sur la manière de réaliser certains des éléments ci-dessus.