llama_mcts.py

import os

from groq import Groq
import re 
import numpy as np 
import random 
import math 


def crear_respuesta(pregunta):
    
    
    client = Groq(
    api_key=key
    )


    chat_completion = client.chat.completions.create(
        messages=[
        {
            "role": "system",
            "content": "you are a helpful assistant."
        },
        {
            "role": "user",
            "content": f"{pregunta}",
        }
        ],
        model="llama3-8b-8192",
        )

    return chat_completion.choices[0].message.content

seed_answers = ["no lo sé","no estoy familiarizado","no sabria decirte","no tengo el conocimiento"]

def get_critique(question,draft_answer):
    
    prompt = (f"Pregunta:{pregunta}",f"Respuesta:{draft_answer}",
        "por favor dime como podria mejorarias la respuesta a la pregunta indicada, se breve y conciso, responde solo en español"
        
    )
    return crear_respuesta(prompt)

pregunta = "Cual es la capital de Ecuador?"
respuesta = "La capital de Ecuador es Guayaquil"
critica = get_critique(pregunta,respuesta)

def improve_answer(pregunta,respuesta,critica):
    prompt = (
    f"Pregunta:{pregunta}",
    f"Respuesta:{respuesta}",
    f"Critica:{critica}"
    ""
    "por favor mejora la Respuesta badansode en la Critica,solo responde en español "
    "para cada respuesta, dame cual fue tu proceso de razonamiento. usa el formato:Razonamiento:<Proceso de razonamiento>"
    "Verificación:<Verificacion de la respuesta>"
    "Respuesta final:<la respuesta final verificada>"
    
    )
    

    respuesta_mejorada = crear_respuesta(prompt)
    return respuesta_mejorada

improve_answer(pregunta,respuesta,critica)

def rate_answer(pregunta,respuesta):
    prompt = (
        f"Pregunta:{pregunta}"
        f"Respuesta:{respuesta}"
        "como un experto en el tema, por favor dame una critica a esta respuesta, solo una critica, no la respuesta"
        "luego provee un rating a la respuesta, que sea un valor del 0-100."
        "la respuesta va en este formato: Critica:<critica>, Rating:<rating>"

    )
    critica_y_rating = crear_respuesta(prompt)
    try:
        match = re.search(r'Rating:\s*(\d+)',critica_y_rating)
        if match:
            rating = int(match.group(1))
            if rating > 95:
                rating = 95
            rating = float(rating)/100
        else:
            raise ValueError("rating no encontrado")
    except Exception as e:
        print(f"error extracting:{e}")
        rating = 0.0
    return rating
pregunta = "cual es la capital de francia?"
respuesta = "la capital de francia es paris"
rate_answer(pregunta,respuesta)

max_children = 3
class Node:
    def __init__(self,question,answer,parent=None):
        self.question = question
        self.answer= answer
        self.parent = parent
        self.children = []
        self.visits = 0
        self.value = 0.0
   
    def is_fully_expanded(self):
        return len(self.children) >= max_children

    def get_best_child(self,exp_const = 1.41):
        choices_weights = []
        for child in self.children:
            if child.visits == 0:
                weight = float('inf')
            else:
                weight = (child.value/child.visits) + exp_const * math.sqrt((2*math.log(self.visits)/child.visits))
                choices_weights.append(weight)
        return self.children[np.argmax(choices_weights)]

    def most_visited_child(self):
        return max(self.children,key=lambda child:child.visits)

    def add_child(self,child_node):
        self.children.append(child_node)

class MCTS:
    def __init__(self,question,seed_answers,iterations=2):
        self.question = question
        self.seed_answers = seed_answers
        self.iterations = iterations
        self.root = Node(question,random.choice(seed_answers))

    def search(self):
        for i in range(self.iterations):
            print(f"Iteración:{i+1}")
            node = self.select(self.root)
            if not node.is_fully_expanded():
                node = self.expand(node)
            reward = self.simulate(node)
            print(f"simulated reward:{reward}")
            self.backpropagate(node,reward)
        print(f"Visitas al nodo con mayor # visitas:{self.root.most_visited_child()}")
        return self.root.most_visited_child().answer
        
    def select(self,node):
        while node.is_fully_expanded() and node.children:
            node = node.get_best_child()
        return node

    def expand(self,node):
        for j in range(max_children - len(node.children)):
            child_node = Node(self.question,node.answer,parent=node)
            node.add_child(child_node)
            critique = get_critique(self.question,child_node.answer)
            improved_answer = improve_answer(self.question,child_node.answer,critique)
            child_node.answer = improved_answer
        return random.choice(node.children)

    def simulate(self,node):
        rating = rate_answer(self.question,node.answer)
        return rating
    def backpropagate(self,node,reward):
        while node is not None:
            node.visits += 1
            node.value += reward
            node = node.parent


question = "what is the capital of France?"
mcts = MCTS(question,seed_answers,iterations=2)
best_answer = mcts.search()
print(best_answer)