So erstellen Sie mit GenLayer einen Smart Contract zur KI-Vorhersage

📌 Schnelle Links

• GitHub-Code
• Dokumentation
• Videoversion

👩‍💻 Was wir tun werden …

In diesem Tutorial behandeln wir:

• Was KI-gestützte Smart Contracts sind und das Konzept intelligenter Verträge.
• Schritte zum Erstellen eines intelligenten Vorhersagevertrags
• Verwenden des GenLayer-Simulators zum Testen, Bereitstellen und Ausführen des Vertrags.

Hinweis: In diesem Tutorial werden gewisse Python-Kenntnisse vorausgesetzt und sind erforderlich.

💡 Warum KI-gestützte Smart Contracts?

Smart Contracts haben zweifellos die Spielregeln geändert. Sie sind von Natur aus selbstausführend, wobei die Vertragsbedingungen direkt in den Code geschrieben sind. Wenn vorgegebene Bedingungen erfüllt sind, werden sie auf einer Blockchain bereitgestellt und stellen sicher, dass Transaktionen sicher und transparent verarbeitet werden, ohne dass eine dritte Partei erforderlich ist.

Smart Contracts befolgen jedoch nur bestimmte Anweisungen und können nicht mit unerwarteten Situationen oder komplexen Anforderungen umgehen, die nicht in ihrer Programmierung enthalten sind. Sie lernen nicht und passen sich nicht an das an, was im Laufe der Zeit passiert. Außerdem können sie nicht unabhängig auf externe Daten zugreifen. Sie benötigen Dienste von Drittanbietern wie Oracles, um Smart Contracts mit externen Daten zu versorgen und ihnen so die Möglichkeit zu geben, auf reale Ereignisse zu reagieren.

🤔 Was ist ein intelligenter Vertrag?

Diese Einschränkungen von Smart Contracts versucht GenLayer zu lösen, indem es Intelligent Contracts entwickelt, die alle Funktionen herkömmlicher Smart Contracts beibehalten, aber darüber hinaus Folgendes können:

• Verwenden Sie LLM-Modelle wie GPT-4 und LLaMA, um Anweisungen in natürlicher Sprache zu verstehen und zu verarbeiten.

• Greifen Sie auf Echtzeitdaten aus dem Internet zu und verwenden Sie diese, ohne dass Sie dafür Tools von Drittanbietern benötigen.

  
  

GenLayer verwendet die Konsensmethode der optimistischen Demokratie, um Transaktionen und Vorgänge von intelligenten Verträgen zu validieren. Ein wichtiger Teil dieser Konsensmethode ist das Äquivalenzprinzip . Das Äquivalenzprinzip ist eine bestimmte Regel oder ein Satz von Kriterien, die im Rahmen der optimistischen Demokratie verwendet werden, um Genauigkeit und Konsistenz beim Umgang mit nicht deterministischen Ausgaben sicherzustellen, wie sie beispielsweise von LLMs oder Echtzeit-Webdaten generiert werden. Im weiteren Verlauf werde ich mehr über das Äquivalenzprinzip und seine Funktionsweise bei der Ausführung unseres intelligenten Vertrags erklären.

In diesem Blog werden wir uns ansehen, wie man einen intelligenten Vertrag zur Fußballvorhersage erstellt, der Echtzeitdaten aus dem Internet abrufen und mithilfe von LLM verarbeiten kann, um Spielergebnisse vorherzusagen. Klingt interessant, oder?

Lasst uns gleich loslegen :).

⚒️ Einrichten des GenLayer-Simulators

Bevor wir mit dem Erstellen unseres Vertrags beginnen, müssen wir die Umgebung einrichten, in der wir ihn ausführen werden. Der Simulator von GenLayer ist eine interaktive Sandbox, mit der wir unsere intelligenten Verträge erstellen und testen können. Lassen Sie uns ihn einrichten.

Voraussetzungen

• Stellen Sie sicher, dass Sie die neueste Version von Docker installiert und ausgeführt haben.
• Stellen Sie sicher, dass sowohl Node.js als auch npm auf die neueste Version aktualisiert sind, um Kompatibilitätsprobleme zu vermeiden.

Installieren

Gehen Sie zu Ihrem Terminal und kopieren Sie Folgendes, um GenLayer auf Ihrem Computer zu installieren:

 npm install -g genlayer

Führen Sie nach der Installation den Init-Befehl aus, um mit der Einrichtung Ihrer Entwicklungsumgebung zu beginnen:

 genlayer init

Wenn Sie diesen Befehl ausführen, wird das Setup mit 5 Validierern initialisiert und Sie werden aufgefordert, Ihre bevorzugten LLM-Anbieter auszuwählen.

Sie können zwischen drei Optionen wählen:

• OpenAI: Schnellste und zuverlässigste Option zum Ausführen von Validatoren)

• Ollama: Kostenlose und Open-Source-Option, die möglicherweise langsamer ist als andere Optionen

• Heurist: Inferenzanbieter für Open-Source-KI-Modelle

  
  

Nachdem Sie Ihre Auswahl getroffen haben, werden die erforderlichen Docker-Container für die GenLayer-Simulatorumgebung automatisch heruntergeladen und konfiguriert. Sobald die Einrichtung abgeschlossen ist, können Sie unter http://localhost:8080/ auf den GenLayer-Simulator zugreifen.

Beginnen wir nun mit der Ausarbeitung unseres Vertrags!

⚽ Aufbau des Fußball-Vorhersagevertrags

Der Simulator verfügt über einen Code-Editor zum Schreiben von Code.

Intelligent Contracts werden in Python geschrieben und eignen sich daher ideal für die Handhabung von Daten- und Zeichenfolgenoperationen, die für Webinteraktionen und die Verarbeitung natürlicher Sprache erforderlich sind.

Für diesen Vorhersagevertrag werden wir unsere Webdaten von der BBC Sport-Website abrufen und dann ein LLM verwenden, um die abgerufenen Daten zu verarbeiten und zu bestimmen, welches Team das Gewinnerteam ist. Sehen wir uns den schrittweisen Prozess dazu an

Wenn Sie die exemplarische Vorgehensweise überspringen möchten, überprüfen Sie den Code auf GitHub und gehen Sie weiter unten zum Abschnitt „Bereitstellungsvertrag“.

1. Importieren der erforderlichen Bibliotheken und Module

Zuerst importieren wir die Bibliotheken und Module, die wir für unseren Intelligent Contract verwenden werden:

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

• json : Dieses Modul wird zum Parsen und Verarbeiten von JSON-Daten verwendet, einem gängigen Format für den Datenaustausch.
• EquivalencePrinciple : Dadurch wird sichergestellt, dass die Ergebnisse bei verschiedenen Validierern konsistent und genau sind. Es spielt eine entscheidende Rolle bei der Aufrechterhaltung der Integrität nichtdeterministischer Ausgaben durch Vergleich der Ergebnisse mehrerer Validierer.
• IContract : Die Basisklasse zum Erstellen intelligenter Verträge auf GenLayer, die grundlegende Eigenschaften und Verhaltensweisen bereitstellt. Sie stellt sicher, dass sich der Vertrag reibungslos in die GenLayer-Umgebung (GenVM) integriert.

2. Definieren der intelligenten Vertragsklasse

Jetzt müssen wir unsere Intelligent Contract-Klasse definieren, in diesem Fall ist es Prediction Market. Unsere Intelligent Contract-Vertragsklasse erbt von IContract . Die Vererbung von IContract ist notwendig, um sicherzustellen, dass der Vertrag im GenLayer-Framework ordnungsgemäß ausgeführt wird:

 class PredictionMarket(IContract):

3. Hinzufügen von Konstruktorparametern

Als Nächstes initialisieren wir den Status des Vertrags und richten alle erforderlichen Parameter ein. Dieser Schritt ist entscheidend, da er die Anfangsbedingungen und Eigenschaften definiert, die unser Vertrag während seiner Ausführung verwenden wird:

 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

In diesem Konstruktor definieren wir die folgenden Parameter:

• game_date : Das Datum des Spiels im Format „JJJJ-MM-TT“.
• team1 : Der Name der ersten Mannschaft, die am Spiel teilnimmt.
• team2 : Der Name der zweiten Mannschaft, die am Spiel teilnimmt.
• has_resolved : Gibt an, ob das Ergebnis des Spiels bereits feststeht, und verhindert so redundante Verarbeitung.
• resolution_url : Die URL der BBC Sport-Website, von der die Spielergebnisse abgerufen werden können.

Diese Parameter definieren den Anfangszustand unseres Vertrags und machen ihn bereit für die Verarbeitung von Spielergebnissen.

4. Den Spielausgang bestimmen

Fügen wir nun eine Methode hinzu, um den Ausgang des Spiels zu bestimmen. Diese Methode stellt sicher, dass wir den Ausgang des Spiels nur dann verarbeiten, wenn er noch nicht entschieden wurde:

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

Diese Methode prüft zunächst, ob das Ergebnis bereits bestimmt wurde, indem self.has_resolved überprüft wird. Dies verhindert redundante Verarbeitung und stellt Effizienz sicher. Wenn das Spiel noch nicht beendet wurde, initialisieren wir final_result , um die Ergebnisse zu speichern. Dieses Wörterbuch enthält die endgültigen validierten Ergebnisse des Spiels.

5. Das Äquivalenzprinzip formulieren

Das Äquivalenzprinzip ist beim Schreiben eines intelligenten Vertrags sehr wichtig. Wenn Sie auf das Internet zugreifen oder LLMs aufrufen, können Inkonsistenzen auftreten. Das Äquivalenzprinzip ist, wie bereits erwähnt, eine bestimmte Regel oder ein Satz von Kriterien, die zur Validierung der endgültigen Ergebnisse nichtdeterministischer Vorgänge (Web- oder LLM-Aufrufe) verwendet werden. Dieses Prinzip verwendet mehrere Validierer, wobei einer als Leiter fungiert, um ein Ergebnis vorzuschlagen, und andere dieses Ergebnis basierend auf den definierten Kriterien oder Regeln validieren.

Daher müssen wir in unserem Vertrag unser Äquivalenzprinzip definieren, um Inkonsistenzen in unserer Ausgabe aus dem Web oder bei Prozessen mit LLM zu vermeiden:

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

Für unseren Vorhersagevertrag besagt das Äquivalenzprinzip: „Die Punktzahl und der Gewinner müssen genau gleich sein.“ Validierer verwenden dieses Prinzip, um ihre Ergebnisse mit dem Ergebnis des Führenden zu vergleichen. Wenn die Ergebnisse dem Äquivalenzprinzip entsprechen, wird das Endergebnis akzeptiert. Die Flagge comparative=True zeigt an, dass sowohl der Führende als auch die Validierer identische Aufgaben ausführen und ihre Ergebnisse vergleichen, um Konsistenz sicherzustellen.

Im Rahmen dieses Äquivalenzprinzips werden wir die Webdaten zum Spiel abrufen und mit LLM verarbeiten.

Abrufen von Webdaten

Im Folgenden werden wir im Block „Äquivalenzprinzip“ den Webseiteninhalt von der URL der BBC Sport-Nachrichten-Website abrufen:

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

Sobald die Daten abgerufen sind, verarbeiten wir sie mit dem LLM, um das Ergebnis zu überprüfen und anhand der abgerufenen Webseite das Gewinnerteam zu ermitteln.

Abgerufene Daten mit LLM verarbeiten

Um die Informationen von der abgerufenen Webseite zu verarbeiten, werden wir Eingabeaufforderungen erstellen, die wir an das LLM senden und ihm genau mitteilen, was es tun soll. Bei der Interaktion mit LLMs ist es wichtig, Eingabeaufforderungen zu erstellen, die klar und spezifisch sind, damit das Modell genaue und relevante Antworten liefern kann. Dies ist die Eingabeaufforderung, die wir unten erstellt haben:

 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)

Die von uns erstellte Eingabeaufforderung weist den LLM an:

• Identifizieren Sie das Gewinnerteam und den Punktestand anhand der abgerufenen Webseite

• Wir haben auch eine Bedingung für das LLM hinzugefügt, um zu prüfen, ob das Spiel noch nicht begonnen hat. Wenn zwischen den Namen der beiden Teams der Satz „Anstoß [Uhrzeit]“ erscheint, bedeutet dies, dass das Spiel noch nicht begonnen hat . Das LLM wird angewiesen, dieses Szenario zu erkennen und zu verstehen, dass noch kein Ergebnis extrahiert werden kann.

• Wir haben außerdem eine weitere Bedingung für das LLM hinzugefügt, damit es davon ausgeht, dass das Spiel nicht beendet ist, wenn es den Punktestand nicht extrahieren kann. Dadurch wird sichergestellt, dass unvollständige oder laufende Spiele entsprechend behandelt werden.

• Abschließend bitten wir den LLM, im JSON-Format zu antworten

  
  

Diese detaillierte Eingabeaufforderung behandelt verschiedene Szenarien und stellt sicher, dass das LLM die erforderlichen Informationen genau und konsistent extrahiert und verarbeitet. Sobald die Eingabeaufforderung erstellt ist, senden wir sie mit der Methode call_llm an das LLM.

5. Festlegen des Ergebnisses nach dem Äquivalenzprinzip

Sobald unser Ergebnis vom LLM vorliegt, wird es gemäß dem oben definierten Äquivalenzprinzip überprüft und validiert: „Die Punktzahl und der Gewinner müssen genau gleich sein.“ Wenn die Ergebnisse gemäß dem Äquivalenzprinzip übereinstimmen, wird das Endergebnis akzeptiert.

 eq.set(result)

Hinweis: Die Validierer validieren nicht jeden Schritt im Block des Äquivalenzprinzips und konzentrieren sich nur auf das Endergebnis, um den Bedarf an komplexen Validierungen zu reduzieren, Ressourcen zu sparen und die Abläufe des Vertrags zu vereinfachen.

6. Analyse und Auswertung des Ergebnisses

Sobald das Ergebnis validiert und abgeschlossen ist, können wir es mit json.loads() analysieren. Dadurch wird das Ergebnis in ein Format konvertiert, das leicht bearbeitet und ausgewertet werden kann. Aus unserem analysierten Ergebnis extrahieren wir den Gewinner und die Punktzahl:

 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

Wenn das Ergebnis des Spiels feststeht (Gewinner > -1), wird der Status des Vertrags entsprechend aktualisiert. Dadurch wird sichergestellt, dass das Endergebnis genau aufgezeichnet wird.

Jetzt sind wir bereit, unseren Vertrag bereitzustellen!

Sehen wir uns unseren Vertrag in Aktion an!

🚀 Setzen Sie Ihren intelligenten Vertrag zur Fußballvorhersage ein

1. Klicken Sie im GenLayer-Simulator auf die Wiedergabetaste, um Ihren Vertrag auszuführen.

2. Geben Sie im Abschnitt „Konstruktorparameter“ das Spieldatum und die Namen der beiden Teams an, die Sie überprüfen möchten. Sie können beispielsweise game_date auf „05.06.2024“, team1 auf „Brasilien“ und team2 auf „Jamaika“ setzen.

3. Sobald die Spieldetails festgelegt sind, klicken Sie auf Bereitstellen

   
   

🎯 Transaktionen ausführen

Um mit dem bereitgestellten Vertrag zu interagieren, gehen Sie zum Abschnitt „Transaktionen ausführen“ . Hier können Sie die Methode „resolve“ aufrufen, um das Spielergebnis zu verarbeiten.

Wenn die Resolve-Methode ausgeführt wird:

• Die vom Simulator ausgeführten Knoten rufen die Daten von der angegebenen URL ab, in diesem Fall die BBC Sport-URL, und der LLM verarbeitet sie dann
• Das endgültige Spielergebnis wird dann gemäß dem im Code definierten Äquivalenzprinzip validiert.

So funktioniert das Äquivalenzprinzip bei der Ausführung eines intelligenten Vertrags:

• Berechnung des Leaders: Der Leader-Validator holt die Spieldaten von BBC Sport ab und ermittelt das Endergebnis und das Gewinnerteam. Beispielsweise berechnet der Leader das Ergebnis als „1:2“, wobei Jamaika (Team 2) gegen Brasilien (Team 1) gewinnt.
• Berechnungen der Validierer: Jeder Validierer ruft die Spieldaten unabhängig von derselben URL ab und führt dieselbe Aufgabe aus, um das Endergebnis und den Gewinner zu ermitteln. Beispielsweise könnte ein Validierer das Ergebnis auch als „1:2“ berechnen, wobei Jamaika (Team 2) gegen Brasilien (Team 1) gewinnt.
• Vergleich: Die Validierer vergleichen ihre Ergebnisse mit denen des Führenden. Nach dem Äquivalenzprinzip müssen Punktzahl und Gewinner exakt übereinstimmen. Wenn das Ergebnis des Führenden „1:2“ mit Jamaika (Team 2) als Gewinner ist, dann sollte das Ergebnis jedes Validierers ebenfalls „1:2“ mit Jamaika (Team 2) als Gewinner sein.
• Entscheidung: Wenn die Ergebnisse aller Validierer mit dem Ergebnis des Leiters übereinstimmen, akzeptieren sie das Ergebnis des Leiters als gültig.

Dieser Prozess stellt Konsistenz und Genauigkeit im gesamten Netzwerk sicher. Wenn die Validierer „1:3“ mit Jamaika (Team 2) als Gewinner zurückgeben und der Anführer „1:2“ mit Jamaika (Team 2) zurückgibt, lehnen die Validierer das Ergebnis ab.

Umgang mit verschiedenen Szenarien:

• Wenn das Spiel beendet ist, enthält die JSON-Antwort den Endstand und das Gewinnerteam.
• Wenn das Spiel gestartet, aber noch nicht beendet wurde, zeigt die JSON-Antwort an, dass das Spiel noch nicht beendet ist.
• Wenn das Spiel nicht gestartet wurde, zeigt die JSON-Antwort diesen Status an.

Sehen Sie sich die Protokolle an, um detaillierte Informationen zur Vertragsinteraktion zu erhalten.

💭 Abschließende Gedanken: Andere Anwendungsfälle für KI-Smart Contracts

🙌 Glückwunsch, wenn Sie alles durchgelesen haben!!!

Die Zukunft sieht für KI-gestützte Smart Contracts rosig aus. Neben dem Fußball-Vorhersagevertrag gibt es noch weitere intelligente Vertragsideen, die Sie mit dem GenLayer-Simulator erstellen und testen können:

• Wetterreporter
• ERC-20-Token
• Aktienkurs-Checker
• Nachrichtenübersicht
• Reiseplaner
• Büchersuche
• Logikrätsel
• Zauberer der Münze

In den GenLayer-Dokumenten finden Sie noch weitere Beispielideen, wie einige der oben genannten Punkte erreicht werden können.