Cómo crear un contrato inteligente de predicción de IA utilizando GenLayer

📌 Enlaces rápidos

• Código GitHub
• Documentación
• Versión de vídeo

👩‍💻 Qué haremos...

En este tutorial, cubriremos:

• Qué son los contratos inteligentes impulsados por IA y el concepto de Contratos Inteligentes.
• Pasos para construir un contrato inteligente de predicción
• Usar el simulador GenLayer para probar, implementar y ejecutar el contrato.

Nota: En este tutorial se asumen y necesitan ciertos conocimientos de Python.

💡 ¿Por qué contratos inteligentes impulsados por IA?

Sin duda, los contratos inteligentes han cambiado las reglas del juego. Son autoejecutables por naturaleza y los términos del acuerdo están escritos directamente en código. Cuando se cumplen las condiciones predeterminadas, se implementan en una cadena de bloques y garantizan que las transacciones se procesen de forma segura y transparente sin necesidad de un tercero.

Sin embargo, los contratos inteligentes solo siguen instrucciones específicas y no pueden manejar situaciones inesperadas o requisitos complejos que no estén en su programación. No aprenden ni se adaptan en función de lo que sucede con el tiempo. Además, no pueden acceder a datos externos de forma independiente. Necesitan servicios de terceros como Oracles para alimentar datos externos a contratos inteligentes, lo que les permitirá reaccionar ante eventos del mundo real.

🤔 ¿Qué es un Contrato Inteligente?

Estas limitaciones de los contratos inteligentes es lo que GenLayer está tratando de resolver mediante la creación de un contrato inteligente que conserva todas las capacidades de los contratos inteligentes tradicionales pero que también puede:

• Utilice modelos LLM como GPT-4 y LLaMA para comprender y procesar instrucciones en lenguaje natural.

• Acceda y utilice datos en tiempo real desde Internet sin necesidad de herramientas de terceros.

  
  

GenLayer utiliza el método de consenso de Democracia Optimista para validar transacciones y operaciones de Contratos Inteligentes. Una parte clave de este método de consenso es el Principio de Equivalencia . El Principio de Equivalencia es una regla específica o un conjunto de criterios utilizados dentro del marco de la Democracia Optimista para garantizar la precisión y coherencia al tratar con resultados no deterministas, como los generados por LLM o datos web en tiempo real. A medida que avancemos, explicaré más sobre el Principio de Equivalencia y cómo funciona cuando ejecutamos nuestro contrato inteligente.

En este blog, veremos cómo crear un contrato inteligente de predicción de fútbol que pueda obtener datos en tiempo real de la web y procesarlos utilizando LLM para predecir los resultados de los partidos. Suena interesante, ¿verdad?

Entremos directamente en ello :).

⚒️ Configuración del simulador GenLayer

Antes de comenzar a construir nuestro contrato, necesitamos configurar el entorno donde lo ejecutaremos. El Simulador de GenLayer es un sandbox interactivo que podemos usar para construir y probar nuestros Contratos Inteligentes. Vamos a configurarlo.

Requisitos previos

• Asegúrese de tener la última versión de Docker instalada y en ejecución.
• Asegúrese de que tanto Node.js como npm estén actualizados a sus últimas versiones para evitar problemas de compatibilidad.

Instalar

Vaya a su terminal y copie y pegue lo siguiente para instalar GenLayer en su computadora:

 npm install -g genlayer

Una vez instalado, ejecute el comando init para iniciar el proceso de configuración de su entorno de desarrollo:

 genlayer init

Cuando ejecuta este comando, inicializa la configuración con 5 validadores y le solicita que seleccione su proveedor de LLM preferido.

Hay tres opciones entre las que puedes elegir:

• OpenAI: la opción más rápida y confiable para ejecutar validadores)

• Ollama: opción gratuita y de código abierto, puede funcionar más lento que otras opciones

• Heurist: proveedor de inferencias para modelos de IA de código abierto

  
  

Una vez que haya realizado su selección, descarga y configura automáticamente los contenedores Docker necesarios para el entorno del simulador GenLayer. Una vez completada la configuración, puede acceder al simulador GenLayer en http://localhost:8080/ .

¡Ahora, comencemos a construir nuestro contrato!

⚽ Elaboración del contrato de predicción de fútbol

El simulador tiene un editor de código para escribir código.

Los contratos inteligentes están escritos en Python, lo que lo hace ideal para manejar datos y operaciones de cadenas necesarias para las interacciones web y el procesamiento del lenguaje natural.

Para este contrato de predicción, recuperaremos nuestros datos web del sitio web de BBC Sport y luego usaremos un LLM para procesar los datos recuperados y determinar qué equipo es el ganador. Veamos el proceso paso a paso para hacer esto.

Si desea omitir el tutorial, verifique el código en GitHub y vaya a la sección "Implementar contrato" a continuación.

1. Importación de bibliotecas y módulos necesarios

Primero, importaremos las bibliotecas y módulos que usaremos para nuestro Contrato Inteligente:

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

• json : este módulo se utiliza para analizar y manejar datos JSON, que es un formato común para el intercambio de datos.
• EquivalencePrinciple : esto garantiza que los resultados sean consistentes y precisos entre diferentes validadores. Desempeña un papel crucial en el mantenimiento de la integridad de los resultados no deterministas al comparar los resultados de múltiples validadores.
• IContract : la clase base para crear contratos inteligentes en GenLayer, que proporciona propiedades y comportamientos esenciales. Garantiza que el contrato se integre sin problemas en el entorno GenLayer (GenVM).

2. Definición de la clase de contrato inteligente

Ahora, necesitamos definir nuestra clase de Contrato Inteligente, en este caso es Prediction Market. Nuestra clase de contrato Contrato inteligente hereda de IContract . Es necesario heredar de IContract para garantizar que el contrato se ejecute correctamente dentro del marco de GenLayer:

 class PredictionMarket(IContract):

3. Agregar parámetros de constructor

A continuación, inicializaremos el estado del contrato y configuraremos los parámetros necesarios. Este paso es crucial ya que define las condiciones y propiedades iniciales que nuestro contrato utilizará a lo largo de su ejecución:

 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

En este constructor, definimos los siguientes parámetros:

• game_date : la fecha del juego con el formato 'AAAA-MM-DD'.
• team1 : El nombre del primer equipo que participa en el partido.
• team2 : El nombre del segundo equipo que participa en el partido.
• has_resolved : Indica si el resultado del juego ya se ha resuelto, evitando procesamientos redundantes.
• resolution_url : la URL del sitio web de BBC Sport desde donde se pueden recuperar los resultados del juego.

Estos parámetros definen el estado inicial de nuestro contrato, preparándolo para procesar los resultados del juego.

4. Resolver el resultado del juego

Ahora, agreguemos un método para determinar el resultado del juego. Este método garantiza que solo procesemos el resultado del juego si aún no se ha resuelto:

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

Este método primero verifica si el resultado ya se ha determinado inspeccionando self.has_resolved . Esto evita el procesamiento redundante y garantiza la eficiencia. Si el juego aún no se ha resuelto, inicializamos final_result para almacenar los resultados. Este diccionario contendrá los resultados finales validados del juego.

5. Escribir el principio de equivalencia

El Principio de Equivalencia es muy importante al redactar un Contrato Inteligente. Cuando accede a la web o llama a un LLM, pueden surgir inconsistencias. El Principio de Equivalencia, como dijimos anteriormente, es una regla específica o un conjunto de criterios que se utilizan para validar los resultados finales de operaciones no deterministas (llamadas web o LLM). Este principio utiliza múltiples validadores, uno actúa como líder para proponer un resultado y otros validan este resultado en función de los criterios o reglas definidos.

Por lo tanto, en nuestro contrato, debemos definir nuestro Principio de Equivalencia para evitar inconsistencias en nuestra salida de la web o cuando procesamos con LLM:

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

Para nuestro contrato de predicción, el Principio de Equivalencia establece que "La puntuación y el ganador deben ser exactamente iguales". Los validadores utilizarán este principio para comparar sus resultados con el resultado del líder. Si el resultado coincide según el Principio de Equivalencia, entonces se acepta el resultado final. La bandera comparative=True indica que tanto el líder como los validadores realizan tareas idénticas y comparan sus resultados para garantizar la coherencia.

Dentro de este Principio de Equivalencia, recuperaremos los datos web sobre el juego y los procesaremos utilizando LLM.

Obteniendo datos web

En el futuro, dentro del bloque Principio de Equivalencia, recuperaremos el contenido de la página web de la URL del sitio web de noticias deportivas de la BBC:

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

Una vez recuperados los datos, los procesaremos con el LLM para verificar el resultado y determinar el equipo ganador a partir de la página web recuperada.

Procesar datos recuperados usando LLM

Para procesar la información de la página web recuperada, crearemos indicaciones para enviarlas al LLM, diciéndole exactamente lo que debe hacer. Al interactuar con los LLM, es importante crear indicaciones que sean claras y específicas para guiar al modelo a brindar respuestas precisas y relevantes. Este es el mensaje que elaboramos a continuación:

 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)

El mensaje que hemos elaborado indica al LLM que:

• Identifique el equipo ganador y puntúe en la página web recuperada.

• También incluimos una condición para que el LLM verifique si el juego aún no ha comenzado. Si aparece la frase "Kick off [time]" entre los nombres de los dos equipos, indica que el juego no ha comenzado . El LLM debe reconocer este escenario y comprender que aún no se puede extraer ningún resultado.

• También incluimos otra condición para que el LLM asuma que el juego no se resuelve si no puede extraer la puntuación. Esto garantiza que los juegos incompletos o en curso se manejen adecuadamente.

• Finalmente, le pedimos al LLM que responda usando un formato JSON.

  
  

Este mensaje detallado maneja diferentes escenarios y garantiza que el LLM extraiga y procese la información requerida de manera precisa y consistente. Una vez que se elabora el mensaje, lo enviamos al LLM utilizando el método call_llm .

5. Establecer el resultado según el principio de equivalencia

Una vez obtenido nuestro resultado del LLM, será verificado y validado de acuerdo con el Principio de Equivalencia definido anteriormente: "La puntuación y el ganador deben ser exactamente iguales". Si el resultado coincide según el Principio de Equivalencia, se acepta el resultado final.

 eq.set(result)

Nota: Los validadores no validan cada paso en el bloque Principio de Equivalencia y solo se centran en el resultado final para reducir la necesidad de validaciones complejas, ahorrar recursos y simplificar las operaciones del contrato.

6. Análisis y evaluación del resultado

Una vez que el resultado se valida y finaliza, ahora podemos analizar el resultado usando json.loads() . Esto convierte el resultado a un formato que puede manipularse y evaluarse fácilmente. De nuestro resultado analizado, extraeremos el ganador y puntuaremos:

 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 se determina el resultado del juego (ganador > -1), el estado del contrato se actualiza en consecuencia. Esto garantiza que el resultado final se registre con precisión.

¡Ahora estamos listos para implementar nuestro contrato!

¡Veamos nuestro contrato en acción!

🚀 Implemente su contrato inteligente de predicción de fútbol

1. En GenLayer Simulator, haga clic en el botón de reproducción para ejecutar su contrato.

2. En la sección de parámetros del constructor, proporciona la fecha del juego y los nombres de los dos equipos que deseas verificar. Por ejemplo, puedes configurar game_date en "2024-06-05", team1 en "Brasil" y team2 en "Jamaica".

3. Una vez configurados los detalles del juego, haz clic en Implementar.

   
   

🎯 Ejecución de transacciones

Para interactuar con el contrato implementado, vaya a la sección Ejecutar transacciones . Aquí puedes llamar al método de resolución para procesar el resultado del juego.

Cuando se ejecuta el método de resolución:

• Los nodos que ejecuta el simulador recuperan los datos de la URL especificada, que en este caso es la URL de BBC Sport y luego el LLM la procesa.
• Luego, el resultado final del juego se valida de acuerdo con el principio de equivalencia definido en el código.

Cómo funciona el principio de equivalencia cuando se ejecuta un contrato inteligente:

• Cálculo del líder: el validador del líder obtiene los datos del juego de BBC Sport y determina el puntaje final y el equipo ganador. Por ejemplo, el líder calcula el marcador como "1:2" con Jamaica (equipo 2) ganando contra Brasil (equipo 1).
• Cálculos de los validadores: cada validador obtiene de forma independiente los datos del juego de la misma URL y realiza la misma tarea para determinar la puntuación final y el ganador. Por ejemplo, un validador también podría calcular el puntaje como "1:2" con Jamaica (Equipo 2) ganando contra Brasil (Equipo 1).
• Comparación: Los validadores comparan sus resultados con los resultados del Líder. Según el Principio de Equivalencia, la puntuación y el ganador deben ser exactamente iguales. Si el resultado del Líder es "1:2" con Jamaica (Equipo 2) como ganador, entonces el resultado de cada validador también debe ser "1:2" con Jamaica (Equipo 2) como ganador.
• Decisión: Si todos los resultados de los validadores coinciden con el resultado del Líder, aceptan el resultado del Líder como válido.

Este proceso garantiza coherencia y precisión en toda la red. Si los validadores arrojan "1:3" con Jamaica (Equipo 2) como ganador y el líder arroja "1:2" con Jamaica (Equipo 2), los validadores rechazarán el resultado.

Manejo de diferentes escenarios:

• Si el juego ha terminado, la respuesta JSON incluirá el puntaje final y el equipo ganador.
• Si el juego comenzó pero no terminó, la respuesta JSON indicará que el juego aún no está resuelto.
• Si el juego no ha comenzado, la respuesta JSON indicará este estado.

Vea los registros para ver información detallada sobre la interacción del contrato.

💭 Reflexiones finales: otros casos de uso de contratos inteligentes de IA

🙌 ¡¡¡Felicidades si leíste hasta el final!!!

El futuro parece prometedor para los contratos inteligentes impulsados por IA. Además del contrato de predicción de fútbol, existen otras ideas de contratos inteligentes que puede crear y probar con GenLayer Simulator:

• Reportero del clima
• Ficha ERC-20
• Comprobador de precios de acciones
• Resumidor de noticias
• Planificador de viajes
• Buscador de libros
• Rompecabezas de lógica
• Mago de la moneda

También hay más ideas de ejemplo en los documentos de GenLayer sobre cómo lograr algo de lo anterior.