Microsoft's rStar-Math: Een gids met implementatie

Microsoft’s RStar-math-paper presenteert een innovatieve aanpak voor het oplossen van wiskundige problemen met een combinatie van reinforcement learning, symbolisch redeneren en Monte Carlo Tree Search (MCTS).

In deze blog verken ik het RStar-framework en de kernonderdelen. Daarna leid ik je stap voor stap door een vereenvoudigde implementatie die de belangrijkste concepten met Gradio laat zien. Hoewel deze demo is geïnspireerd op de paper, zijn sommige complexiteiten vereenvoudigd voor de toegankelijkheid.

Wat is Microsoft’s rStar-Math?

RStar-math wil symbolisch redeneren verbinden met de generalisatiecapaciteiten van voorgetrainde neurale modellen. Het framework integreert componenten zoals Monte Carlo Tree Search (MCTS), voorgetrainde taalmodellen en reinforcement learning om efficiënt strategieën voor probleemoplossing te verkennen.

Het kernidee is om wiskundig redeneren te representeren als een zoekproces over een gestructureerde boom van mogelijke stappen, waarbij elke knoop een gedeeltelijke oplossing of toestand voorstelt.

Bron: Guan et al., 2025

Redenen waarom rStar-Math mij in het bijzonder interessant lijkt:

1. Het bevat een neuraal netwerk (policymodel) dat de volgende actie voorspelt bij het oplossen van een wiskundig probleem en zo de verkenning van MCTS aanstuurt.
2. Een netwerk (beloningsmodel) dat het succes evalueert van acties die tijdens MCTS-rollouts worden ondernomen en feedback geeft voor training.
3. RStar gebruikt symbolische rekenbibliotheken zoals SymPy voor precieze wiskundige bewerkingen of symbolisch redeneren, zoals vergelijkingen oplossen of afgeleiden berekenen.
4. Het embedt een Monte Carlo Tree Search-algoritme dat mogelijke oplossingspaden systematisch verkent met simulaties en een balans vindt tussen exploratie (nieuwe paden proberen) en exploitatie.
5. Een feedbackmechanisme waarbij de policy- en beloningsmodellen iteratief worden getraind op basis van de uitkomsten van MCTS-rollouts, zodat het beslissingsproces in de tijd verbetert.
6. Het redeneerproces is gestructureerd als een hiërarchische boom waarin knopen toestanden voorstellen en randen overgangen.

Demo-overzicht: Wiskunde-oplosser met Gradio

De demo laat zien hoe een policymodel en een beloningsmodel, gecombineerd met symbolisch redeneren met de sympy bibliotheek, wiskundige problemen gestructureerd kunnen aanpakken. De belangrijkste kenmerken van deze implementatie zijn:

1. Policymodel: Een neuraal netwerk dat de volgende actie in het oplossingsproces voorspelt.
2. Beloningsmodel: Een netwerk dat het succes evalueert van acties tijdens MCTS-rollouts.
3. Symbolisch redeneren: Maakt gebruik van SymPy voor precieze wiskundige berekeningen en het oplossen van vergelijkingen.
4. Monte Carlo Tree Search: Implementeert een vereenvoudigde versie van MCTS om efficiënt mogelijke oplossingen te verkennen.
5. Reinforcement learning-loop: Een basis-trainingslus om het policy- en beloningsmodel te verbeteren op basis van feedback.
6. Ondersteuning voor vergelijkingen met één en meerdere variabelen: Gebruikers kunnen één of twee vergelijkingen invoeren om oplossingen te vinden voor variabelen zoals x en y.

Om de demo eenvoudig en gefocust te houden, vallen bepaalde geavanceerde features uit de paper buiten de scope van deze tutorial. Die features zijn:

1. Schaalbaarheid: De originele paper gebruikt grote voorgetrainde modellen en veel rekenkracht. De demo gebruikt kleinere neurale netwerken en vermijdt complexe pretraining.
2. Geavanceerde MCTS-strategieën: Technieken zoals adaptieve UCT en diverse verkenningsstrategieën zijn niet volledig geïmplementeerd.
3. Taakgeneralisatie: De implementatie richt zich uitsluitend op het oplossen van algebraïsche vergelijkingen, terwijl RStar is ontworpen om breder over wiskundetaken te generaliseren.
4. Dataset: In plaats van een samengestelde dataset voor training gebruikt de demo symbolisch redeneren en door de gebruiker aangeleverde input.

Stap 1: Vereisten

De demo is opgedeeld in verschillende componenten, die elk een deel van de RStar-methodologie weerspiegelen. Zorg voordat je begint dat je het volgende hebt geïnstalleerd:

• Python 3.8+
• Vereiste bibliotheken: Installeer de benodigde Python-pakketten met pip:

pip install requests gradio, sympy Mogelijk gemaakt door

Importeer daarna deze bibliotheken:

import gradio as gr
import numpy as np
import torch
import re
import torch.nn as nn
import torch.optim as optim
from sympy import symbols, Eq, solve, N, sin, cos, tan, exp, log, E, sympify
from random import choiceMogelijk gemaakt door

Nu alle afhankelijkheden zijn geïnstalleerd, kunnen we de hoofdcomponenten opzetten.

Stap 2: Neurale netwerken voor policy en beloning

Deze netwerken zijn lichtgewicht versies van de in de paper beschreven modellen, gebruikt om de volgende actie te voorspellen en succes te evalueren. Het policymodel voorspelt de volgende stappen om de opgegeven vergelijkingen op te lossen. Het gebruikt een feedforward-neuraal netwerk om gecodeerde representaties van het probleem te verwerken.

Het beloningsmodel evalueert op vergelijkbare wijze gedeeltelijke oplossingen om het MCTS-proces te sturen. Beide modellen zijn geïmplementeerd met PyTorch.

class PolicyModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x
class RewardModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return xMogelijk gemaakt door

Vervolgens bouwen we een nodeklasse voor MCTS-bomen.

Stap 3: TreeNode-klasse voor het representeren van MCTS-toestanden

De TreeNode-klasse staat voor knopen in de MCTS-boom. Elke knoop correspondeert met een toestand in het zoekproces en bevat:

• De toestand (bijv. vergelijkingen of gedeeltelijke oplossingen).
• Een verwijzing naar de bovenliggende knoop.
• Een lijst met kindknopen (uitgebreide toestanden).
• Bezoeken en Q-waarden, die bijhouden hoe vaak de knoop is verkend en de opgetelde beloningen.

class TreeNode:
    """Represents a node in the MCTS tree."""
    def __init__(self, state, parent=None):
        self.state = state  # Current state
        self.parent = parent
        self.children = []
        self.visits = 0
        self.q_value = 0.0  # Accumulated rewards
    def is_fully_expanded(self):
        return len(self.children) > 0
    def best_child(self, exploration_weight=1.4):
        """Select the best child using UCT formula."""
        def uct_value(child):
            return (child.q_value / (child.visits + 1e-6)) + exploration_weight * np.sqrt(np.log(self.visits + 1) / (child.visits + 1e-6))
        return max(self.children, key=uct_value)
    def add_child(self, child_state):
        """Add a child node with the given state."""
        child = TreeNode(state=child_state, parent=self)
        self.children.append(child)
        return childMogelijk gemaakt door

Nu de basisstructuur er is, gaan we verder met de kerncomponenten van de demo.

Stap 4: De MathSolver-klasse

De MathSolver-klasse is de kern van de demo en combineert symbolisch redeneren met door neurale netwerken gestuurde zoektochten. Ze implementeert meerdere sleutelcomponenten:

A. Policy- en beloningsmodellen

Het PolicyModel voorspelt de volgende stappen om vergelijkingen op te lossen, terwijl het RewardModel het succes van gedeeltelijke of volledige oplossingen evalueert.

class MathSolver:
    def __init__(self, dataset=None):
        self.dataset = dataset or []  # Dataset of math problems
        self.policy_model = PolicyModel(input_size=128, hidden_size=64, output_size=4)  
        self.reward_model = RewardModel(input_size=128, hidden_size=64, output_size=1)  
        self.policy_optimizer = optim.Adam(self.policy_model.parameters(), lr=0.001)
        self.reward_optimizer = optim.Adam(self.reward_model.parameters(), lr=0.001)
        self.execution_context = {}  Mogelijk gemaakt door

De bovenstaande methode initialiseert de MathSolver-klasse door de componenten in te stellen die nodig zijn om wiskundige problemen op te lossen. Optioneel kan een dataset met wiskundeproblemen worden meegegeven. Twee neurale netwerken worden geïnitialiseerd: het policymodel, dat de volgende actie voorspelt, en het beloningsmodel, dat het succes van acties evalueert. 

We hebben nu een policy- en beloningsfunctie. Vervolgens moeten we de invoervergelijkingen parsen en encoderen.

B. Vergelijkingen parsen en encoderen

De vergelijkingen worden geparsed met sympy en gecodeerd naar featurevectoren voor verwerking door de policy- en beloningsmodellen.

def encode_problem(self, problem):
 # Advanced encoding using symbolic representation and problem length
     variables = len(re.findall(r'[a-zA-Z]', problem))
     operators = len(re.findall(r'[\+\-\*/\^]', problem))
      problem_length = len(problem)
      return np.array([variables, operators, problem_length] + [0] * 125)Mogelijk gemaakt door

De encode_problem-methode zet een wiskundeprobleem om in een numerieke representatie met vaste grootte voor de modellen. Er worden features geëxtraheerd zoals het aantal variabelen, operatoren en de probleemlengte, die worden gecodeerd in een 128-dimensionale NumPy-array. Deze representatie legt de structuur van het probleem vast en maakt effectieve modelverwerking mogelijk.

C. Voorspelling door het policymodel

De volgende code genereert de volgende stappen voor het oplossen van de opgegeven vergelijkingen, waaronder het definiëren van variabelen, het aanmaken van vergelijkingen en het oplossen ervan.

def policy_model_predict(self, equation1, equation2=None):
    try:
        equations = []
        if equation1:
            equations.append(sympify(equation1.strip()))  # Sympify only equations
        if equation2:
            equations.append(sympify(equation2.strip()))
        all_variables = set()
        for eq in equations:
            all_variables.update(eq.free_symbols)
        var_definitions = [f"{v} = symbols('{v}')" for v in all_variables]
        steps = [
            ("Define variables", "\n".join(var_definitions)),
            ("Define equation(s)", f"equations = {equations}"),
            ("Solve equation(s)", f"solution = solve(equations, {list(all_variables)})"),
            ("Print solution", "print(solution)")
        ]
        return steps
    except Exception as e:
        print(f"Error during policy model prediction: {e}")
        return []Mogelijk gemaakt door

De policy_model_predict-functie parseert de invoervergelijkingen met SymPy’s sympify om te borgen dat het geldige wiskundige expressies zijn. Vervolgens identificeert hij alle variabelen in de vergelijkingen en lost ze op met SymPy’s solve-functie. Deze methode dient als een high-level gids voor de workflow van probleemoplossing. 

D. Voorspelling door het beloningsmodel

De methode reward_model_predict speelt een cruciale rol in reinforcement learning door feedback te geven op acties die tijdens Monte Carlo Tree Search (MCTS)-rollouts zijn uitgevoerd. 

  
  def reward_model_predict(self, steps, success):
        encoded_steps = self.encode_problem(str(steps))
        encoded_steps = torch.tensor(encoded_steps, dtype=torch.float32)
        reward = self.reward_model(encoded_steps)
        return reward.item() if success else -reward.item()Mogelijk gemaakt door

De functie codeert probleemoplossingsstappen naar een numeriek formaat en evalueert ze via het beloningsmodel. Bij succes wordt een positieve beloning teruggegeven, bij falen een negatieve. Deze feedback traint het policymodel, waardoor het effectieve acties gaat prioriteren en beter beslissingen neemt. Met de functies voor policy- en beloningsvoorspellingen op hun plaats kunnen we nu werken aan de uitvoeringsstap.

E. Code-uitvoeringsfunctie

Deze methode behandelt oplossingen met meerdere variabelen als tuples of dictionaries en zet symbolische resultaten om naar numerieke benaderingen met SymPy’s N-functie. 

    def execute_code(self, code):
        try:
            # Ensure necessary imports and variables are in the execution context
            exec("from sympy import symbols, Eq, solve, N, sin, cos, tan, exp, log, E", self.execution_context)
            # Dynamically initialize variables in the context
            for var_def in self.execution_context.get('var_definitions', []):
                exec(var_def, self.execution_context)
            exec(code, self.execution_context)
            if "solution" in self.execution_context:
                symbolic_solution = self.execution_context["solution"]
                # Handle multi-variable solutions as tuples
                if isinstance(symbolic_solution, list):
                    self.execution_context["solution"] = [tuple(map(N, sol)) if isinstance(sol, tuple) else N(sol) for sol in symbolic_solution]
                elif isinstance(symbolic_solution, dict):
                    self.execution_context["solution"] = {k: N(v) for k, v in symbolic_solution.items()}
                else:
                    self.execution_context["solution"] = N(symbolic_solution)
            return True
        except Exception as e:
            print(f"Error executing code: {e}")
            return FalseMogelijk gemaakt door

Deze methode zorgt voor accurate berekening en ondersteunt flexibele verwerking van verschillende oplossingsformaten. In geval van fouten wordt het probleem gelogd en False geretourneerd, wat robuuste foutafhandeling waarborgt.

F. Monte Carlo Tree Search (MCTS)

De MCTS-methode selecteert iteratief de beste toestanden, breidt de zoekboom uit en simuleert mogelijke oplossingen. Beloningen uit simulaties worden teruggepropageerd om de besluitvorming te verbeteren.

def mcts(self, equation1, equation2=None, num_rollouts=10):
    root = TreeNode(state=(equation1, equation2))
    for _ in range(num_rollouts):
        # Selection
        node = root
        while node.is_fully_expanded() and node.children:
            node = node.best_child()
        # Expansion
        if not node.is_fully_expanded():
            steps = self.policy_model_predict(*node.state)
            for step, code in steps:
                child_state = (step, code)
                node.add_child(child_state)
        # Simulation
        success = True
        for step, code in steps:
            if not self.execute_code(code):
                success = False
                break
        # Backpropagation
        reward = self.reward_model_predict(steps, success)
        while node:
            node.visits += 1
            node.q_value += reward
            node = node.parent
    return root.best_child().state if root.children else NoneMogelijk gemaakt door

De mcts-methode voert iteratief vier stappen uit: 

• Selectie: Navigeert door de boom via de beste kindknopen.
• Expansie: In deze stap worden nieuwe kindknopen aangemaakt met de policy_model_predict-methode.
• Simulatie: Alle acties worden uitgevoerd en het succes wordt hier bepaald.
• Backpropagatie: De beloningen worden berekend met de reward_model_predict-methode en omhoog door de boom gepropageerd om knoopwaarden bij te werken. 

Na een opgegeven aantal rollouts retourneert de methode de toestand van de beste kindknoop, die de meest veelbelovende oplossing vertegenwoordigt die tijdens de zoektoch is verkend.

G. Oplossing uitvoeren

De solve-methode orkestreert het hele proces, van het parsen van vergelijkingen tot het uitvoeren en valideren van oplossingen.

def solve(self, equation1, equation2=None):
    self.execution_context = {}
    steps = self.policy_model_predict(equation1, equation2)
    variables = set()
    for eq in [equation1, equation2] if equation2 else [equation1]:
        if eq:
            variables.update(sympify(eq.strip()).free_symbols)
    self.execution_context['var_definitions'] = [f"{v} = symbols('{v}')" for v in variables]
    steps_output = ["Best solution found:"]
    for step, code in steps:
        steps_output.append(f"Step: {step}")
        steps_output.append(f"Code: {code}")
        if self.execute_code(code):
            steps_output.append("Execution successful.")
        else:
            steps_output.append("Execution failed.")
    if "solution" in self.execution_context:
        final_answer = self.execution_context["solution"]
        if isinstance(final_answer, dict):
            for var, value in final_answer.items():
                steps_output.append(f"{var} = {value}")
        elif isinstance(final_answer, list):
            for solution in final_answer:
                if isinstance(solution, tuple):
                    for idx, var in enumerate(variables):
                        steps_output.append(f"{list(variables)[idx]} = {solution[idx]}")
                else:
                    steps_output.append(f"Solution: {solution}")
        else:
            steps_output.append(f"Final Answer: {final_answer}")
    else:
        steps_output.append("No final answer found.")
    return "\n".join(steps_output)Mogelijk gemaakt door

De solve-methode verwerkt één of twee door de gebruiker aangeleverde vergelijkingen door een uitvoeringscontext te initialiseren en stappen te genereren via policy_model_predict. Elke stap wordt uitgevoerd, voortgang wordt gelogd en succes of falen wordt gerapporteerd. Oplossingen, inclusief enkel- en meer-variabele uitkomsten, worden geformatteerd met variabelenamen en waarden voor duidelijkheid. Als er geen oplossing wordt gevonden, wordt een passende melding weergegeven.

Alle kerncomponenten zijn klaar, dus we kunnen verder met de Gradio-app.

Stap 5: Een gebruiksvriendelijke interface maken met Gradio

De Gradio-interface laat gebruikers vergelijkingen invoeren (één of meer), ze oplossen en de resultaten interactief bekijken.

with gr.Blocks() as app:
    gr.Markdown("# Math Problem Solver with Advanced Multi-Step Reasoning and Learning")
    with gr.Row():
        equation1_input = gr.Textbox(label="Enter the first equation (e.g., x + y - 3)", placeholder="x + y - 3")
        equation2_input = gr.Textbox(label="Enter the second equation (optional, e.g., x - y - 1)", placeholder="x - y - 1")
    solve_button = gr.Button("Solve")
    solution_output = gr.Textbox(label="Solution", interactive=False)
    solve_button.click(solve_math_problem, inputs=[equation1_input, equation2_input], outputs=[solution_output])
app.launch(debug=True)Mogelijk gemaakt door

De bovenstaande code maakt een Gradio-gebruikersinterface voor het oplossen van wiskundige vergelijkingen met geavanceerd redeneren. De interface is verpakt in een gr.Blocks-container en bevat twee invoervelden via gr.Textbox: één voor de eerste vergelijking (verplicht) en één voor de tweede vergelijking (optioneel).

De output wordt weergegeven in één gr.Textbox met het label "Solution". Het commando interface.launch() start de Gradio-app in een browser en de vlag debug=True schakelt gedetailleerde logs in om fouten op te sporen.

Stap 6: Testen en valideren

Tijd om onze Math Problem Solver-app te testen. Dit zijn enkele tests die ik heb uitgevoerd:

1. Enkele variabele, enkele vergelijking: Ik heb geprobeerd mogelijke waarden te vinden voor een enkele variabele x op basis van één vergelijking als input.

2. Meerdere variabelen, meerdere vergelijkingen: Ik heb twee vergelijkingen met twee variabelen ingevoerd om mogelijke waarden te vinden voor de variabelen x en y.

Mogelijke uitbreidingen

 Deze demo is een basisversie van wat we kunnen bereiken met de mogelijkheden van de rStar-math-methode. Er is nog veel werk mogelijk om de capaciteiten uit te breiden. 

• Voeg voorgetrainde taalmodellen toe om de redeneercapaciteiten van het policymodel te versterken.
• Integreer geavanceerde MCTS-strategieën of probeer diverse verkenningstechnieken om de efficiëntie en nauwkeurigheid van het zoekproces te verbeteren.
• Breid de demo uit om polynoomvergelijkingen van hogere graad en complexe vergelijkingsstelsels op te lossen.
• Train de modellen op een grotere dataset van vergelijkingen voor betere generalisatie.
• Breid de demo uit om aanvullende redeneertaken buiten wiskunde te ondersteunen.

Je kunt verwijzen naar de originele repository van de rStar-math-paper op GitHub.

Conclusie

Deze demo laat een praktische implementatie zien van meerstapsredeneren voor het oplossen van wiskundige vergelijkingen. Door neurale netwerken, symbolisch redeneren en MCTS te combineren, krijg je een indruk van hoe geavanceerde AI-technieken gestructureerde redeneertaken kunnen aanpakken. Toekomstige verbeteringen kunnen het dichter bij de volledige capaciteiten van het RStar-framework brengen.