Como construir um contrato inteligente de previsão de IA usando GenLayer

📌 Links rápidos

• Código GitHub
• Documentação
• Versão de vídeo

👩‍💻 O que faremos...

Neste tutorial, abordaremos:

• O que são contratos inteligentes alimentados por IA e o conceito de Contratos Inteligentes.
• Etapas para construir um contrato inteligente de previsão
• Usando o simulador GenLayer para testar, implantar e executar o contrato.

Nota: Algum conhecimento de Python é assumido e necessário neste tutorial.

💡 Por que contratos inteligentes baseados em IA?

Os contratos inteligentes mudaram o jogo, sem dúvida. Eles são autoexecutáveis por natureza, com os termos do contrato diretamente escritos em código. Quando condições predeterminadas são atendidas, eles são implantados em um blockchain e garantem que as transações sejam processadas de forma segura e transparente, sem a necessidade de terceiros.

No entanto, os contratos inteligentes seguem apenas instruções específicas e não podem lidar com situações inesperadas ou requisitos complexos que não estejam na sua programação. Eles não aprendem nem se adaptam com base no que acontece ao longo do tempo. Além disso, eles não podem acessar dados externos de forma independente. Eles precisam de serviços de terceiros, como Oracles, para alimentar contratos inteligentes com dados externos, permitindo-lhes reagir a eventos do mundo real.

🤔 O que é um Contrato Inteligente?

Essas limitações dos contratos inteligentes são o que a GenLayer está tentando resolver criando um Contrato Inteligente que retém todos os recursos dos contratos inteligentes tradicionais, mas também pode:

• Use modelos LLM como GPT-4 e LLaMA para compreender e processar instruções em linguagem natural.

• Acesse e use dados em tempo real da Internet sem a necessidade de ferramentas de terceiros.

  
  

GenLayer usa o método de consenso Optimistic Democracy para validar transações e operações de Contratos Inteligentes. Uma parte fundamental deste método de consenso é o Princípio da Equivalência . O Princípio da Equivalência é uma regra específica ou conjunto de critérios utilizados no âmbito da estrutura da Democracia Otimista para garantir precisão e consistência ao lidar com resultados não determinísticos, como aqueles gerados por LLMs ou dados da web em tempo real. À medida que avançamos, explicarei mais sobre o Princípio da Equivalência e como ele funciona quando executamos nosso contrato inteligente.

Neste blog, veremos como construir um contrato inteligente de previsão de futebol que pode buscar dados em tempo real da web e processá-los usando LLM para prever os resultados dos jogos. Parece interessante, certo?

Vamos direto ao assunto :).

⚒️ Configurando o Simulador GenLayer

Antes de começarmos a construir nosso contrato, precisamos configurar o ambiente onde iremos executá-lo. O Simulador do GenLayer é uma sandbox interativa que podemos usar para construir e testar nossos Contratos Inteligentes. Vamos configurar isso.

Pré-requisitos

• Certifique-se de ter a versão mais recente do Docker instalada e em execução.
• Certifique-se de que o Node.js e o npm estejam atualizados para as versões mais recentes para evitar problemas de compatibilidade.

Instalar

Vá para o seu terminal e copie e cole o seguinte para instalar o GenLayer no seu computador:

 npm install -g genlayer

Depois de instalado, execute o comando init para iniciar o processo de configuração do seu ambiente de desenvolvimento:

 genlayer init

Quando você executa este comando, ele inicializa a configuração com 5 validadores e solicita que você selecione seu(s) provedor(es) LLM preferido(s).

Existem três opções que você pode escolher:

• OpenAI: opção mais rápida e confiável para executar validadores)

• Ollama: Opção gratuita e de código aberto, pode ter desempenho mais lento do que outras opções

• Heurist: provedor de inferência para modelos de IA de código aberto

  
  

Depois de fazer sua seleção, ele baixa e configura automaticamente os contêineres Docker necessários para o ambiente do simulador GenLayer. Assim que a configuração for concluída, você pode acessar o Simulador GenLayer em http://localhost:8080/ .

Agora, vamos construir nosso contrato!

⚽ Construindo o Contrato de Previsão de Futebol

O simulador possui um editor de código para escrever código.

Os contratos inteligentes são escritos em Python, tornando-os ideais para lidar com dados e operações de string necessárias para interações na web e processamento de linguagem natural.

Para este contrato de previsão, recuperaremos nossos dados da web do site da BBC Sport e, em seguida, usaremos um LLM para processar os dados recuperados e determinar qual time é o vencedor. Vamos ver o processo passo a passo para fazer isso

Se você quiser pular o passo a passo, verifique o código no GitHub e vá para a seção “Implantar Contrato” abaixo.

1. Importando Bibliotecas e Módulos Necessários

Primeiro, importaremos as bibliotecas e módulos que usaremos para nosso Contrato Inteligente:

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

• json : este módulo é usado para analisar e manipular dados JSON, que é um formato comum para intercâmbio de dados.
• EquivalencePrinciple : Isso garante que os resultados sejam consistentes e precisos em diferentes validadores. Desempenha um papel crucial na manutenção da integridade dos resultados não determinísticos, comparando resultados de vários validadores.
• IContract : A classe base para criação de contratos inteligentes no GenLayer, fornecendo propriedades e comportamentos essenciais. Ele garante que o contrato se integre perfeitamente ao ambiente GenLayer (GenVM).

2. Definindo a classe de contrato inteligente

Agora, precisamos definir nossa classe de Contrato Inteligente, neste caso é Mercado de Previsão. Nossa classe de contrato Contrato Inteligente herda de IContract . Herdar do IContract é necessário para garantir que o contrato seja executado corretamente dentro da estrutura GenLayer:

 class PredictionMarket(IContract):

3. Adicionando parâmetros de construtor

A seguir, inicializaremos o estado do contrato e configuraremos os parâmetros necessários. Esta etapa é crucial porque define as condições iniciais e propriedades que nosso contrato utilizará ao longo de sua execução:

 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

Neste construtor, definimos os seguintes parâmetros:

• game_date : A data do jogo formatada como 'AAAA-MM-DD'.
• team1 : O nome do primeiro time participante da partida.
• team2 : O nome da segunda equipe participante da partida.
• has_resolved : Indica se o resultado do jogo já foi resolvido, evitando processamento redundante.
• resolution_url : A URL do site da BBC Sport a partir do qual os resultados do jogo podem ser recuperados.

Esses parâmetros definem o estado inicial do nosso contrato, deixando-o pronto para processar os resultados do jogo.

4. Resolvendo o Resultado do Jogo

Agora, vamos adicionar um método para determinar o resultado do jogo. Este método garante que processaremos o resultado do jogo apenas se ele ainda não tiver sido resolvido:

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

Este método primeiro verifica se o resultado já foi determinado inspecionando self.has_resolved . Isso evita processamento redundante e garante eficiência. Se o jogo ainda não foi resolvido, inicializamos final_result para armazenar os resultados. Este dicionário conterá os resultados finais validados do jogo.

5. Escrevendo o Princípio da Equivalência

O Princípio da Equivalência é muito importante ao redigir um Contrato Inteligente. Quando você acessa a web ou liga para LLMs, podem surgir inconsistências. O Princípio de Equivalência, como dissemos anteriormente, é uma regra específica ou conjunto de critérios usados para validar os resultados finais de operações não determinísticas (chamadas web ou LLM). Este princípio utiliza múltiplos validadores, com um atuando como líder para propor um resultado, e outros validando esse resultado com base nos critérios ou regras definidos.

Portanto, em nosso contrato, precisamos definir nosso Princípio de Equivalência para evitar inconsistências em nossa saída da web ou quando processos com LLM:

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

Para o nosso contrato de previsão, o Princípio da Equivalência afirma que “A pontuação e o vencedor têm de ser exactamente os mesmos”. Os validadores usarão este princípio para comparar seus resultados com o resultado do líder. Se o resultado corresponder ao Princípio da Equivalência, o resultado final será aceito. O sinalizador comparative=True indica que tanto o líder quanto os validadores realizam tarefas idênticas e comparam seus resultados para garantir consistência.

Dentro deste Princípio de Equivalência, vamos buscar os dados da web sobre o jogo e processá-los usando LLM.

Buscando dados da web

Seguindo em frente, dentro do bloco do Princípio de Equivalência, recuperaremos o conteúdo da página do URL do site de notícias da BBC Sport:

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

Assim que os dados forem recuperados, iremos processá-los com o LLM para verificar o resultado e determinar a equipe vencedora a partir da página recuperada.

Processar dados recuperados usando LLM

Para processar as informações da página recuperada, criaremos prompts para enviar ao LLM, informando exatamente o que ele precisa fazer. Ao interagir com LLMs, é importante criar prompts claros e específicos para orientar o modelo no fornecimento de respostas precisas e relevantes. Este é o prompt que elaboramos abaixo:

 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)

O prompt que criamos instrui o LLM a:

• Identifique a equipe vencedora e marque a pontuação na página da web recuperada

• Também incluímos uma condição para o LLM verificar se o jogo ainda não começou. Se a frase “Kick off [time]” aparecer entre os nomes das duas equipes, indica que o jogo ainda não começou . O LLM é instruído a reconhecer este cenário e compreender que nenhum resultado pode ser extraído ainda.

• Também incluímos outra condição para o LLM assumir que o jogo não será resolvido se não conseguir extrair a pontuação. Isso garante que jogos incompletos ou em andamento sejam tratados de maneira adequada.

• Finalmente, pedimos ao LLM que responda usando um formato JSON

  
  

Este prompt detalhado lida com diferentes cenários e garante que o LLM extraia e processe as informações necessárias com precisão e consistência. Assim que o prompt for elaborado, nós o enviamos para o LLM usando o método call_llm .

5. Definição do resultado de acordo com o princípio da equivalência

Uma vez obtido o nosso resultado no LLM, ele será verificado e validado de acordo com o Princípio de Equivalência definido acima: “A pontuação e o vencedor devem ser exatamente iguais”. Se o resultado corresponder ao Princípio da Equivalência, o resultado final será aceito.

 eq.set(result)

Nota: Os validadores não validam todas as etapas do bloco Princípio de Equivalência e focam apenas no resultado final para reduzir a necessidade de validações complexas, economizar recursos e simplificar as operações do contrato

6. Analisando e avaliando o resultado

Assim que o resultado for validado e finalizado, podemos agora analisar o resultado usando json.loads() . Isso converte o resultado em um formato que pode ser facilmente manipulado e avaliado. Do nosso resultado analisado, extrairemos o vencedor e a pontuação:

 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

Se o resultado do jogo for determinado (vencedor > -1), o estado do contrato será atualizado de acordo. Isso garante que o resultado final seja registrado com precisão.

Agora estamos prontos para implantar nosso contrato!

Vamos ver nosso contrato em ação!

🚀 Implante seu contrato inteligente de previsão de futebol

1. No Simulador GenLayer, clique no botão play para executar seu contrato.

2. Na seção de parâmetros do construtor, forneça a data do jogo e os nomes dos dois times que deseja verificar. Por exemplo, você pode definir game_date como "2024-06-05", team1 como "Brasil" e team2 como "Jamaica".

3. Assim que os detalhes do jogo estiverem definidos, clique em Implantar

   
   

🎯 Execução de transações

Para interagir com o contrato implantado, vá para a seção Executar Transações . Aqui, você pode chamar o método resolve para processar o resultado do jogo.

Quando o método resolve é executado:

• Os nós executados pelo simulador recuperam os dados do URL especificado, que neste caso é o URL do BBC Sport e, em seguida, o LLM os processa
• O resultado final do jogo é então validado de acordo com o Princípio de Equivalência definido no código.

Como funciona o princípio da equivalência quando um contrato inteligente é executado:

• Cálculo do Líder: O validador do Líder busca os dados do jogo da BBC Sport e determina a pontuação final e a equipe vencedora. Por exemplo, o Líder calcula o placar como "1:2" com a Jamaica (Equipe 2) vencendo o Brasil (Equipe 1).
• Cálculos dos validadores: Cada validador busca independentemente os dados do jogo na mesma URL e executa a mesma tarefa para determinar a pontuação final e o vencedor. Por exemplo, um validador também pode calcular a pontuação como “1:2” com a Jamaica (Equipe 2) vencendo o Brasil (Equipe 1).
• Comparação: Os validadores comparam seus resultados com os resultados do Líder. De acordo com o Princípio da Equivalência, a pontuação e o vencedor devem ser exatamente iguais. Se o resultado do Líder for “1:2” com a Jamaica (Equipe 2) como vencedora, então o resultado de cada validador também deverá ser “1:2” com a Jamaica (Equipe 2) como vencedora.
• Decisão: Se todos os resultados dos validadores corresponderem ao resultado do Líder, eles aceitam o resultado do Líder como válido.

Este processo garante consistência e precisão em toda a rede. Se os validadores retornarem “1:3” com a Jamaica (Equipe 2) como vencedora e o líder retornar “1:2” com a Jamaica (Equipe 2), os validadores rejeitarão o resultado.

Lidando com diferentes cenários:

• Se o jogo terminar, a resposta JSON incluirá a pontuação final e a equipe vencedora.
• Se o jogo começou, mas não terminou, a resposta JSON indicará que o jogo ainda não foi resolvido.
• Se o jogo não tiver iniciado, a resposta JSON indicará esse status.

Visualize os logs para ver informações detalhadas sobre a interação do contrato.

💭 Considerações finais: outros casos de uso para contratos inteligentes de IA

🙌 Parabéns se você leu até o fim!!!

O futuro parece brilhante para os contratos inteligentes baseados em IA. Além do contrato de previsão de futebol, existem outras ideias de contratos inteligentes que você pode construir e testar com o Simulador GenLayer:

• Repórter Meteorológico
• Token ERC-20
• Verificador de preço de ações
• Resumidor de notícias
• Planejador de viagens
• Localizador de livros
• Quebra-cabeças lógicos
• Feiticeiro da Moeda

Há mais exemplos de ideias nos documentos do GenLayer sobre como alcançar alguns dos itens acima também.