rStar-Math von Microsoft: Ein Leitfaden mit Umsetzung

Microsofts RStar-math stellt einen innovativen Ansatz zum Lösen mathematischer Probleme vor, der eine Kombination aus Reinforcement Learning, symbolischem Denken und Monte Carlo Tree Search (MCTS) verwendet.

In diesem Blog werde ich das RStar-Framework und seine Kernkomponenten vorstellen. Anschließend führe ich dich Schritt für Schritt durch eine vereinfachte Implementierung, die die wichtigsten Konzepte mit Gradio demonstriert. Diese Demo orientiert sich zwar an dem Papier, aber einige komplexe Sachverhalte wurden vereinfacht, um sie leichter zugänglich zu machen.

Was ist rStar-Math von Microsoft?

Die RStar-Mathematik zielt darauf ab, symbolisches Denken mit den Verallgemeinerungsfähigkeiten von vortrainierten neuronalen Modellen zu verbinden. Das Framework integriert Komponenten wie Monte Carlo Tree Search (MCTS), vortrainierte Sprachmodelle und Verstärkungslernen um eine effiziente Erkundung von Problemlösungsstrategien zu ermöglichen.

Die Kernidee ist, mathematisches Denken als einen Suchprozess über einen strukturierten Baum möglicher Schritte darzustellen, wobei jeder Knoten eine Teillösung oder einen Zustand darstellt.

Quelle: Guan et al., 2025

Einige der Gründe, die rStar-Math für mich besonders interessant machen, sind:

1. Es umfasst ein neuronales Netzwerk (Policy-Modell), das die nächste Aktion bei der Lösung eines mathematischen Problems vorhersagt und die Erkundung des MCTS leitet.
2. Ein Netzwerk (Belohnungsmodell), das den Erfolg von Aktionen während der MCTS-Einführung bewertet und Feedback für das Training gibt.
3. RStar verwendet symbolische Berechnungsbibliotheken wie SymPy für präzise mathematische Operationen oder symbolische Schlussfolgerungen wie das Lösen von Gleichungen oder das Berechnen von Ableitungen.
4. Es beinhaltet einen Monte-Carlo-Baum-Suchalgorithmus, der systematisch mögliche Lösungswege mit Hilfe von Simulationen erkundet und dabei ein Gleichgewicht zwischen Erkundung durch Ausprobieren neuer Pfade und Ausbeutung herstellt.
5. Ein Feedback-Mechanismus, bei dem die Richtlinien- und Belohnungsmodelle auf der Grundlage der Ergebnisse der MCTS-Einführungen iterativ trainiert werden, um den Entscheidungsprozess mit der Zeit zu verbessern.
6. Der Argumentationsprozess ist als hierarchischer Baum strukturiert, in dem Knoten Zustände und Kanten Übergänge darstellen.

Demo-Projekt Übersicht: Mathe Problemlöser mit Gradio

Die Demo zeigt, wie ein Richtlinien- und ein Belohnungsmodell in Kombination mit symbolischem Denken unter Verwendung der sympy Bibliothek mathematische Probleme auf strukturierte Weise lösen können. Zu den wichtigsten Merkmalen dieser Umsetzung gehören:

1. Politikmodell: Ein neuronales Netzwerk, das die nächste Aktion im Problemlösungsprozess vorhersagt.
2. Belohnungsmodell: Ein Netzwerk, das den Erfolg von Maßnahmen bei MCTS-Einführungen bewertet.
3. Symbolisches Denken: Es nutzt SymPy für präzise mathematische Berechnungen und das Lösen von Gleichungen.
4. Monte-Carlo-Baumsuche: Es implementiert eine vereinfachte Version von MCTS, um mögliche Lösungen effizient zu untersuchen.
5. Reinforcement Learning Schleife: Eine grundlegende Trainingsschleife zur Verbesserung der Politik- und Belohnungsmodelle auf der Grundlage von Feedback.
6. Unterstützung für ein- und mehrvariable Gleichungen: Die Nutzer können eine oder zwei Gleichungen eingeben, um Lösungen für Variablen wie x und y zu finden.

Um die Demo einfach und fokussiert zu halten, sind bestimmte fortgeschrittene Funktionen, auf die in dem Papier hingewiesen wird, nicht Gegenstand dieses Tutorials. Diese Merkmale sind:

1. Skalierbarkeit: Die Originalarbeit verwendet große vortrainierte Modelle und umfangreiche Rechenressourcen. Die Demo verwendet kleinere neuronale Netze und vermeidet komplexes Vortraining.
2. Fortgeschrittene MCTS-Strategien: Techniken wie adaptiver UCT und verschiedene Erkundungsstrategien sind nicht vollständig umgesetzt.
3. Aufgabenverallgemeinerung: Die Implementierung konzentriert sich ausschließlich auf das Lösen von algebraischen Gleichungen, während RStar so konzipiert ist, dass es sich auf breitere mathematische Aufgaben anwenden lässt.
4. Datensatz: Anstatt einen kuratierten Datensatz für das Training zu verwenden, verlässt sich die Demo auf symbolische Schlussfolgerungen und vom Nutzer bereitgestellte Eingaben.

Schritt 1: Voraussetzungen

Die Demo ist in mehrere Komponenten unterteilt, die jeweils einen Teil der RStar-Methode widerspiegeln. Bevor wir beginnen, solltest du sicherstellen, dass du Folgendes installiert hast:

• Python 3.8+
• Erforderliche Bibliotheken: Installiere die notwendigen Python-Pakete mit pip:

pip install requests gradio, sympy Bereitgestellt von

Dann importiere diese 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 choiceBereitgestellt von

Jetzt, da alle Abhängigkeiten installiert sind, können wir die Hauptkomponenten einrichten.

Schritt 2: Neuronale Netze für Politik und Belohnung

Diese Netzwerke sind leichtgewichtige Versionen der in der Arbeit beschriebenen Modelle, die zur Vorhersage der nächsten Aktion und zur Erfolgsbewertung verwendet werden. Das Politikmodell sagt die nächsten Schritte zur Lösung der gegebenen Gleichungen voraus. Es verwendet ein neuronales Feedforward-Netzwerk, um kodierte Darstellungen des Problems zu verarbeiten.

Auch das Belohnungsmodell bewertet Teillösungen, um den MCTS-Prozess zu steuern. Beide Modelle werden mit PyTorch implementiert.

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 xBereitgestellt von

Als Nächstes erstellen wir eine Knotenklasse für MCTS-Bäume.

Schritt 3: TreeNode-Klasse zur Darstellung von MCTS-Zuständen

Die Klasse TreeNode stellt Knoten im MCTS-Baum dar. Jeder Knoten entspricht einem Zustand im Suchprozess, der Folgendes enthält:

• Der Zustand (z. B. Gleichungen oder Teillösungen).
• Ein Verweis auf den übergeordneten Knoten.
• Eine Liste von Kinderknoten (erweiterte Zustände).
• Lernpfade und Q-Werte, die zeigen, wie oft der Knotenpunkt erkundet wurde und welche Belohnungen er erhalten hat.

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 childBereitgestellt von

Nachdem wir nun die Grundstruktur festgelegt haben, werden wir als Nächstes mit den Kernkomponenten der Demo arbeiten.

Schritt 4: Die MathSolver-Klasse

Die Klasse MathSolver ist das Herzstück der Demo und kombiniert symbolisches Denken mit neural-geführter Suche. Es enthält mehrere Schlüsselkomponenten:

A. Politik und Belohnungsmodelle

Die PolicyModel sagt die nächsten Schritte zur Lösung von Gleichungen voraus, während die RewardModel den Erfolg von Teil- oder Komplettlösungen bewertet.

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 = {}  Bereitgestellt von

Die obige Methode initialisiert die Klasse MathSolver, indem sie die Komponenten einrichtet, die zum Lösen mathematischer Probleme benötigt werden. Es akzeptiert optional einen Datensatz mit mathematischen Problemen und initialisiert zwei neuronale Netze: das Politikmodell, das die nächste Aktion vorhersagt, und das Belohnungsmodell, das den Erfolg von Aktionen bewertet .

Wir haben jetzt eine Politik- und Belohnungsfunktion eingerichtet. Als Nächstes müssen wir die Eingangsgleichungen analysieren und kodieren.

B. Gleichung parsen und kodieren

Die Gleichungen werden mit sympy geparst und in Merkmalsvektoren kodiert, die von den Richtlinien- und Belohnungsmodellen verarbeitet werden.

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)Bereitgestellt von

Die Methode encode_problem wandelt ein mathematisches Problem in eine numerische Darstellung mit fester Größe für die Modelle um. Sie extrahiert Merkmale wie die Anzahl der Variablen, Operatoren und die Problemlänge und kodiert sie in ein 128-dimensionales NumPy-Array. Diese Darstellung erfasst die Struktur des Problems und ermöglicht eine effektive Modellverarbeitung.

C. Vorhersage des Politikmodells

Der folgende Code generiert die nächsten Schritte zum Lösen der gegebenen Gleichungen, einschließlich der Definition der Variablen, der Erstellung der Gleichungen und der Lösung der Gleichungen.

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 []Bereitgestellt von

Die Funktion policy_model_predict analysiert die eingegebenen Gleichungen mit Hilfe von SymPy's sympify, um sicherzustellen, dass es sich um gültige mathematische Ausdrücke handelt. Dann identifiziert es alle Variablen in den Gleichungen und löst sie mit der SymPy-Funktion solve. Diese Methode dient als Leitfaden für den Problemlösungsprozess. 

D. Vorhersage des Belohnungsmodells

Die Methode reward_model_predict spielt beim Reinforcement Learning eine wichtige Rolle, da sie Rückmeldungen zu den Aktionen gibt, die während der Monte Carlo Tree Search (MCTS) ausgeführt werden. 

  
  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()Bereitgestellt von

Die Funktion kodiert Problemlösungsschritte in einem numerischen Format und bewertet sie durch das Belohnungsmodell, wobei eine positive Belohnung für Erfolg und eine negative Belohnung für Misserfolg zurückgegeben wird. Dieses Feedback trainiert das Politikmodell und hilft ihm, effektive Maßnahmen zu priorisieren und die Entscheidungsfindung zu verbessern. Nachdem wir die Vorhersagefunktionen für die Richtlinien und das Belohnungsmodell festgelegt haben, können wir jetzt an der Ausführungsaufgabe arbeiten.

E. Code-Funktion ausführen

Diese Methode behandelt mehrvariable Lösungen als Tupel oder Wörterbücher und wandelt symbolische Ergebnisse mit der N Funktion von SymPy in numerische Näherungen um.

    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 FalseBereitgestellt von

Diese Methode gewährleistet eine genaue Berechnung und ermöglicht einen flexiblen Umgang mit verschiedenen Lösungsformaten. Im Falle von Fehlern protokolliert es das Problem und gibt False zurück, um eine robuste Fehlerbehandlung zu gewährleisten.

F. Monte Carlo Tree Search (MCTS)

Die MCTS-Methode wählt iterativ die besten Zustände aus, erweitert den Suchbaum und simuliert mögliche Lösungen. Belohnungen aus Simulationen werden zurückgespielt, um die Entscheidungsfindung zu verbessern.

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 NoneBereitgestellt von

Die Methode mcts führt iterativ vier wichtige Schritte durch :

• Auswahl: Sie hilft dabei, den Baum anhand der besten Kindknoten zu navigieren.
• Expansion: In diesem Schritt werden mit der Methode policy_model_predict neue Unterknoten erstellt.
• Simulation: Alle Aktionen werden ausgeführt, und der Erfolg wird in diesem Schritt festgestellt.
• Backpropagation: Die Belohnungen werden mit der Methode reward_model_predict berechnet und im Baum nach oben weitergegeben, um die Knotenwerte zu aktualisieren .

Nach einer bestimmten Anzahl von Rollouts gibt die Methode den Status des besten untergeordneten Knotens zurück, der die vielversprechendste Lösung darstellt, die während der Suche untersucht wurde.

G. Ausführung der Lösung

Die lösen Methode steuert den gesamten Prozess, vom Parsen der Gleichungen bis zum Ausführen und Validieren der Lösungen.

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)Bereitgestellt von

Die Methode solve verarbeitet eine oder zwei vom Benutzer bereitgestellte Gleichungen, indem sie einen Ausführungskontext initialisiert und Schritte über policy_model_predict erzeugt. Sie führt jeden Schritt aus, protokolliert den Fortschritt und meldet Erfolg oder Misserfolg. Die Lösungen, einschließlich der ein- und mehrvariablen Ergebnisse, werden zur besseren Übersichtlichkeit mit Variablennamen und -werten formatiert. Wenn keine Lösung gefunden wird, wird eine entsprechende Meldung angezeigt.

Alle Kernkomponenten sind vorhanden, sodass wir als Nächstes an der Gradio-App arbeiten können.

Schritt 5: Erstellen einer benutzerfreundlichen Oberfläche mit Gradio

Über die Gradio-Oberfläche kannst du eine oder mehrere Gleichungen eingeben, sie lösen und die Ergebnisse interaktiv betrachten.

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)Bereitgestellt von

Der obige Code erstellt eine Gradio-Benutzeroberfläche zum Lösen von mathematischen Gleichungen mit fortgeschrittener Argumentation. Die Schnittstelle ist in einem gr.Blocks Container verpackt, der zwei Eingabefelder mit gr.Textbox enthält: eines für die erste Gleichung (obligatorisch) und eines für die zweite Gleichung (optional).

Die Ausgabe wird in einem einzigen gr.Textbox mit der Bezeichnung "Solution" angezeigt. Der Befehl interface.launch() startet die Gradio-App in einem Browser, und das Flag debug=True ermöglicht detaillierte Protokolle, die bei der Fehlersuche helfen.

Schritt 6: Testen und Validieren

Es ist an der Zeit, unsere Mathe-Problemlöser-App zu testen. Hier sind einige Tests, die ich durchgeführt habe:

1. Einzelne Variable einzelne Gleichung: Ich habe versucht, die möglichen Werte einer einzelnen Variable x zu finden, wenn eine einzelne Gleichung als Eingabe vorliegt.

2. Problem mit mehreren Variablen und mehreren Gleichungen: Ich habe zwei Gleichungen mit zwei Variablen eingegeben, um mögliche Werte der Variablen x und y zu finden.

Mögliche Erweiterungen

 Diese Demo ist eine Basisversion dessen, was wir mit den Möglichkeiten der rStar-math-Methode erreichen können. Es gibt noch viel zu tun, um seine Möglichkeiten zu erweitern. 

• Füge vorab trainierte Sprachmodelle hinzu, um die Argumentationsfähigkeiten des Richtlinienmodells zu verbessern.
• Integriere fortschrittliche MCTS-Strategien oder probiere verschiedene Explorationstechniken aus, um die Effizienz und Genauigkeit des Suchprozesses zu verbessern.
• Erweitere die Demo, um Polynomgleichungen höheren Grades und komplexe Gleichungssysteme zu lösen.
• Trainiere die Modelle auf einem größeren Datensatz von Gleichungen, um die Generalisierung zu verbessern.
• Erweitere die Demo, um zusätzliche Rechenaufgaben über Mathematik hinaus zu bewältigen.

Du kannst das Original-Repository des rStar-math Papiers auf GitHub.

Fazit

Diese Demo zeigt eine praktische Umsetzung des mehrstufigen Denkens zum Lösen mathematischer Gleichungen. Durch die Kombination von neuronalen Netzen, symbolischem Denken und MCTS gibt es einen Einblick, wie fortschrittliche KI-Techniken strukturierte Denkaufgaben bewältigen können. Zukünftige Erweiterungen könnten es näher an die vollen Möglichkeiten des RStar-Frameworks heranbringen.