rStar-Math dari Microsoft: Panduan dengan Implementasi

Makalah RStar-math dari Microsoft menyajikan pendekatan inovatif untuk menyelesaikan masalah matematika menggunakan kombinasi reinforcement learning, penalaran simbolik, dan Monte Carlo Tree Search (MCTS).

Dalam blog ini, saya akan membahas kerangka kerja RStar dan komponen intinya. Selanjutnya, saya akan memandu Anda langkah demi langkah melalui implementasi sederhana yang mendemonstrasikan konsep-konsep kuncinya menggunakan Gradio. Meskipun demo ini terinspirasi oleh makalah tersebut, beberapa kompleksitas telah disederhanakan agar lebih mudah diakses.

Apa itu rStar-Math dari Microsoft?

RStar math bertujuan menjembatani penalaran simbolik dengan kemampuan generalisasi model neural pra-latih. Kerangka kerja ini mengintegrasikan komponen seperti Monte Carlo Tree Search (MCTS), model bahasa pra-latih, dan reinforcement learning untuk memungkinkan eksplorasi strategi pemecahan masalah secara efisien.

Gagasan utamanya adalah merepresentasikan penalaran matematika sebagai proses pencarian di atas pohon terstruktur dari langkah-langkah yang mungkin, di mana setiap simpul mewakili solusi parsial atau keadaan.

Sumber: Guan et al., 2025

Beberapa alasan yang membuat rStar-Math menarik bagi saya antara lain:

1. Mencakup jaringan saraf (model kebijakan) yang memprediksi aksi berikutnya dalam menyelesaikan masalah matematika, membimbing eksplorasi MCTS.
2. Sebuah jaringan (model penghargaan) yang mengevaluasi keberhasilan aksi yang diambil selama rollout MCTS dan memberikan umpan balik untuk pelatihan.
3. RStar menggunakan pustaka komputasi simbolik seperti SymPy untuk operasi matematika yang presisi atau penalaran simbolik seperti menyelesaikan persamaan atau menghitung turunan.
4. Menyematkan algoritma Monte Carlo Tree Search yang secara sistematis mengeksplorasi jalur solusi yang mungkin menggunakan simulasi, menyeimbangkan eksplorasi dengan mencoba jalur baru dan eksploitasi.
5. Mekanisme umpan balik di mana model kebijakan dan penghargaan dilatih secara iteratif berdasarkan hasil rollout MCTS, sehingga meningkatkan proses pengambilan keputusan dari waktu ke waktu.
6. Proses penalaran disusun sebagai pohon hierarkis di mana simpul merepresentasikan keadaan dan sisi merepresentasikan transisi.

Gambaran Proyek Demo: Penyelesai Masalah Matematika dengan Gradio

Demo ini menunjukkan bagaimana model kebijakan dan model penghargaan, dipadukan dengan penalaran simbolik menggunakan pustaka sympy , dapat menangani masalah matematika secara terstruktur. Fitur utama dari implementasi ini meliputi:

1. Model kebijakan: Jaringan saraf yang memprediksi aksi berikutnya dalam proses pemecahan masalah.
2. Model penghargaan: Jaringan yang mengevaluasi keberhasilan aksi yang diambil selama rollout MCTS.
3. Penalaran simbolik: Memanfaatkan SymPy untuk komputasi matematika presisi dan penyelesaian persamaan.
4. Monte Carlo Tree Search: Menerapkan versi MCTS yang disederhanakan untuk mengeksplorasi solusi secara efisien.
5. Siklus reinforcement learning: Loop pelatihan dasar untuk meningkatkan model kebijakan dan penghargaan berdasarkan umpan balik.
6. Dukungan untuk persamaan satu dan multi-variabel: Pengguna dapat memasukkan satu atau dua persamaan untuk mencari nilai variabel seperti x dan y.

Agar demo tetap sederhana dan fokus, beberapa fitur lanjutan yang disebutkan dalam makalah berada di luar cakupan tutorial ini. Fitur-fitur tersebut antara lain:

1. Skalabilitas: Makalah asli menggunakan model pra-latih berukuran besar dan sumber daya komputasi yang ekstensif. Demo menggunakan jaringan saraf yang lebih kecil dan menghindari pra-pelatihan yang kompleks.
2. Strategi MCTS lanjutan: Teknik seperti UCT adaptif dan strategi eksplorasi beragam belum diimplementasikan sepenuhnya.
3. Generalisasi tugas: Implementasi ini berfokus hanya pada penyelesaian persamaan aljabar, sedangkan RStar dirancang untuk melakukan generalisasi di berbagai tugas matematika yang lebih luas.
4. Dataset: Alih-alih menggunakan dataset terkurasi untuk pelatihan, demo mengandalkan penalaran simbolik dan masukan dari pengguna.

Langkah 1: Prasyarat

Demo ini dibagi menjadi beberapa komponen, masing-masing mencerminkan bagian dari metodologi RStar. Sebelum mulai, pastikan Anda telah memasang hal-hal berikut:

• Python 3.8+
• Pustaka yang diperlukan: Pasang paket Python yang diperlukan menggunakan pip:

pip install requests gradio, sympy Didukung oleh

Lalu, impor pustaka-pustaka ini:

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 choiceDidukung oleh

Kini semua dependensi telah terpasang, mari siapkan komponen utamanya.

Langkah 2: Jaringan Saraf untuk Kebijakan dan Penghargaan

Jaringan ini adalah versi ringan dari model yang dijelaskan dalam makalah, digunakan untuk memprediksi aksi berikutnya dan mengevaluasi keberhasilan. Model kebijakan memprediksi langkah berikut untuk menyelesaikan persamaan yang diberikan. Ia menggunakan jaringan saraf feedforward untuk memproses representasi masalah yang terenkode.

Serupa, model penghargaan mengevaluasi solusi parsial untuk membimbing proses MCTS. Kedua model diimplementasikan menggunakan 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 xDidukung oleh

Selanjutnya, kita membuat kelas node untuk pohon MCTS.

Langkah 3: Kelas TreeNode untuk merepresentasikan Status MCTS

Kelas TreeNode merepresentasikan simpul dalam pohon MCTS. Setiap simpul berkaitan dengan suatu keadaan dalam proses pencarian, berisi:

• Keadaan (misalnya, persamaan atau solusi parsial).
• Referensi ke simpul induknya.
• Daftar simpul anak (keadaan yang diperluas).
• Kunjungan dan nilai-Q, yang melacak seberapa sering simpul dijelajahi dan akumulasi hadiahnya.

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 childDidukung oleh

Kini struktur dasar telah siap, berikutnya kita akan bekerja dengan komponen inti demo.

Langkah 4: Kelas MathSolver

Kelas MathSolver adalah inti dari demo, menggabungkan penalaran simbolik dengan pencarian berbasis neural. Kelas ini mengimplementasikan beberapa komponen kunci:

A. Model kebijakan dan penghargaan

PolicyModel memprediksi langkah-langkah berikut untuk menyelesaikan persamaan, sementara RewardModel mengevaluasi keberhasilan solusi parsial atau lengkap.

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 = {}  Didukung oleh

Metode di atas menginisialisasi kelas MathSolver dengan menyiapkan komponen yang diperlukan untuk menyelesaikan masalah matematika. Kelas ini secara opsional menerima dataset masalah matematika dan menginisialisasi dua jaringan saraf: model kebijakan, yang memprediksi aksi berikutnya, dan model penghargaan, yang mengevaluasi keberhasilan aksi. 

Kini kita memiliki fungsi kebijakan dan penghargaan. Selanjutnya, kita perlu mengurai dan mengenkode persamaan masukan.

B. Parsing dan pengenkodean persamaan

Persamaan diurai menggunakan sympy dan dienkode menjadi vektor fitur untuk diproses oleh model kebijakan dan penghargaan.

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)Didukung oleh

Metode encode_problem mengonversi masalah matematika menjadi representasi numerik berdimensi tetap untuk model. Metode ini mengekstrak fitur seperti jumlah variabel, operator, dan panjang masalah, lalu mengenodenya ke dalam array NumPy berdimensi 128. Representasi ini menangkap struktur masalah, sehingga memungkinkan pemrosesan model yang efektif.

C. Prediksi model kebijakan

Kode berikut menghasilkan langkah-langkah untuk menyelesaikan persamaan yang diberikan, termasuk mendefinisikan variabel, membuat persamaan, dan menyelesaikannya.

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 []Didukung oleh

Fungsi policy_model_predict mengurai persamaan masukan menggunakan sympify dari SymPy untuk memastikan persamaan tersebut valid. Fungsi ini kemudian mengidentifikasi semua variabel yang ada dalam persamaan dan menyelesaikannya menggunakan fungsi solve dari SymPy. Metode ini berfungsi sebagai panduan tingkat tinggi untuk alur kerja pemecahan masalah. 

D. Prediksi model penghargaan

Metode reward_model_predict berperan penting dalam reinforcement learning dengan memberikan umpan balik untuk aksi yang diambil selama rollout Monte Carlo Tree Search (MCTS). 

  
  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()Didukung oleh

Fungsi ini mengenode langkah-langkah pemecahan masalah ke dalam format numerik dan mengevaluasinya melalui model penghargaan, mengembalikan nilai positif untuk keberhasilan dan negatif untuk kegagalan. Umpan balik ini melatih model kebijakan, membimbingnya untuk memprioritaskan aksi yang efektif dan meningkatkan pengambilan keputusan. Dengan fungsi prediksi model kebijakan dan penghargaan yang sudah siap, kini kita dapat mengerjakan tugas eksekusi.

E. Fungsi eksekusi kode

Metode ini menangani solusi multi-variabel sebagai tuple atau kamus dan mengonversi hasil simbolik ke pendekatan numerik menggunakan fungsi N dari SymPy. 

    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 FalseDidukung oleh

Metode ini memastikan komputasi yang akurat dan mendukung penanganan fleksibel untuk berbagai format solusi. Jika terjadi kesalahan, metode akan mencatat masalahnya dan mengembalikan False, sehingga menjaga penanganan kesalahan yang tangguh.

F. Monte Carlo Tree Search (MCTS)

Metode MCTS secara iteratif memilih keadaan terbaik, memperluas pohon pencarian, dan mensimulasikan solusi yang mungkin. Hadiah dari simulasi disebarkan kembali untuk meningkatkan pengambilan keputusan.

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 NoneDidukung oleh

Metode mcts melakukan empat langkah kunci secara iteratif: 

• Seleksi: Membantu menavigasi turun ke pohon menggunakan simpul anak terbaik.
• Ekspansi: Pada langkah ini, simpul anak baru dibuat menggunakan metode policy_model_predict.
• Simulasi: Semua aksi dijalankan, dan keberhasilan ditentukan pada langkah ini.
• Backpropagasi: Hadiah dihitung menggunakan metode reward_model_predict dan dipropagasikan ke atas pohon untuk memperbarui nilai simpul. 

Setelah jumlah rollout yang ditentukan, metode ini mengembalikan keadaan dari simpul anak terbaik, yang merepresentasikan solusi paling menjanjikan yang dieksplorasi selama pencarian.

G. Eksekusi solusi

Metode solve mengorkestrasi seluruh proses, mulai dari parsing persamaan hingga mengeksekusi dan memvalidasi solusi.

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)Didukung oleh

Metode solve memproses satu atau dua persamaan yang diberikan pengguna dengan menginisialisasi konteks eksekusi dan menghasilkan langkah-langkah melalui policy_model_predict. Metode ini mengeksekusi setiap langkah, mencatat progres, dan melaporkan keberhasilan atau kegagalan. Solusi, termasuk hasil satu dan multi-variabel, diformat dengan nama variabel dan nilainya untuk kejelasan. Jika tidak ditemukan solusi, pesan yang sesuai akan ditampilkan.

Semua komponen inti telah siap, jadi kita dapat mengerjakan aplikasi Gradio berikutnya.

Langkah 5: Membuat Antarmuka yang Ramah Pengguna dengan Gradio

Antarmuka Gradio memungkinkan pengguna memasukkan persamaan (satu atau lebih), menyelesaikannya, dan melihat hasilnya secara interaktif.

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)Didukung oleh

Kode di atas membuat antarmuka pengguna Gradio untuk menyelesaikan persamaan matematika dengan penalaran tingkat lanjut. Antarmuka dibungkus dalam kontainer gr.Blocks, yang berisi dua bidang input menggunakan gr.Textbox: satu untuk persamaan pertama (wajib) dan satu lagi untuk persamaan kedua (opsional).

Keluaran ditampilkan dalam satu gr.Textbox berlabel "Solution". Perintah interface.launch() meluncurkan aplikasi Gradio di browser, dan flag debug=True mengaktifkan log terperinci untuk membantu melacak kesalahan.

Langkah 6: Pengujian dan Validasi

Saatnya menguji aplikasi Penyelesai Masalah Matematika kita. Berikut beberapa pengujian yang saya jalankan:

1. Satu variabel satu persamaan: Saya mencoba mencari nilai yang mungkin dari satu variabel x dengan memberikan satu persamaan sebagai masukan.

2. Masalah multi-variabel multi-persamaan: Saya memasukkan dua persamaan dengan dua variabel untuk mencari nilai yang mungkin dari variabel x dan y.

Kemungkinan Ekstensi

 Demo ini adalah versi dasar dari apa yang dapat kita capai dengan kapabilitas metode rStar-math. Masih banyak pekerjaan yang dapat dilakukan untuk memperluas kemampuannya. 

• Tambahkan model bahasa pra-latih untuk meningkatkan kemampuan penalaran model kebijakan.
• Integrasikan strategi MCTS lanjutan atau coba teknik eksplorasi beragam untuk meningkatkan efisiensi dan akurasi proses pencarian.
• Perluas demo untuk menyelesaikan persamaan polinomial derajat lebih tinggi dan sistem persamaan yang kompleks.
• Latih model pada dataset persamaan yang lebih besar untuk meningkatkan generalisasi.
• Perluas demo untuk menangani tugas penalaran tambahan di luar matematika.

Anda dapat merujuk ke repositori asli dari makalah rStar-math di GitHub.

Kesimpulan

Demo ini menampilkan implementasi praktis penalaran multi-langkah untuk menyelesaikan persamaan matematika. Dengan menggabungkan jaringan saraf, penalaran simbolik, dan MCTS, demo ini memberikan gambaran tentang bagaimana teknik AI tingkat lanjut dapat menangani tugas penalaran terstruktur. Peningkatan di masa depan dapat membawanya lebih dekat ke kapabilitas penuh kerangka kerja RStar.