Microsoft'un rStar-Math'i: Uygulamalı Bir Rehber

Microsoft’un RStar-math makalesi, pekiştirmeli öğrenme, sembolik akıl yürütme ve Monte Carlo Ağaç Araması (MCTS) kombinasyonunu kullanarak matematiksel problemleri çözmeye yönelik yenilikçi bir yaklaşım sunuyor.

Bu blogda RStar çerçevesini ve temel bileşenlerini inceleyeceğim. Ardından, Gradio kullanarak ana kavramlarını gösteren basitleştirilmiş bir uygulamayı adım adım anlatacağım. Bu demo makaleden ilham alsa da, erişilebilirlik için bazı karmaşıklıklar basitleştirilmiştir.

Microsoft’un rStar-Math’i Nedir?

RStar-math, sembolik akıl yürütmeyi, önceden eğitilmiş sinir modellerinin genelleme yetenekleriyle köprülemeyi amaçlar. Çerçeve, Monte Carlo Ağaç Araması (MCTS), önceden eğitilmiş dil modelleri ve pekiştirmeli öğrenme gibi bileşenleri entegre ederek problem çözme stratejilerinin verimli bir şekilde keşfedilmesini sağlar.

Temel fikir, matematiksel akıl yürütmeyi olası adımlardan oluşan yapılandırılmış bir ağaç üzerinde bir arama süreci olarak temsil etmektir; burada her düğüm, kısmi bir çözümü veya durumu temsil eder.

Kaynak: Guan ve ark., 2025

rStar-Math’i benim için özellikle ilginç kılan bazı nedenler şunlar:

1. Matematiksel bir problemi çözerken bir sonraki eylemi tahmin eden ve MCTS keşfini yönlendiren bir sinir ağı (politika modeli) içerir.
2. MCTS devriyeleri sırasında yapılan eylemlerin başarısını değerlendiren ve eğitim için geri bildirim sağlayan bir ağ (ödül modeli).
3. RStar denklem çözme ya da türev alma gibi kesin matematiksel işlemler ve sembolik akıl yürütme için SymPy gibi sembolik hesaplama kütüphanelerini kullanır.
4. Olası çözüm yollarını sistematik olarak keşfetmek için simülasyonlar kullanan, keşif (yeni yollar deneme) ile sömürü arasında denge kuran bir Monte Carlo Ağaç Araması algoritmasını içerir.
5. Politika ve ödül modellerinin, MCTS devriyelerinin sonuçlarına göre yinelemeli olarak eğitildiği ve zamanla karar verme sürecini iyileştiren bir geri bildirim mekanizması.
6. Akıl yürütme süreci, düğümlerin durumları ve kenarların geçişleri temsil ettiği hiyerarşik bir ağaç olarak yapılandırılmıştır.

Demo Proje Genel Bakış: Gradio ile Matematik Problemi Çözücü

Demo, bir politika modeli ve bir ödül modelinin, sympy kütüphanesiyle yapılan sembolik akıl yürütme ile birleştiğinde matematik problemlerini yapılandırılmış bir şekilde nasıl ele alabildiğini gösterir. Bu uygulamanın temel özellikleri şunlardır:

1. Politika modeli: Problem çözme sürecinde bir sonraki eylemi tahmin eden bir sinir ağı.
2. Ödül modeli: MCTS devriyeleri sırasında yapılan eylemlerin başarısını değerlendiren bir ağ.
3. Sembolik akıl yürütme: Kesin matematiksel hesaplama ve denklem çözme için SymPy kullanır.
4. Monte Carlo Ağaç Araması: Olası çözümleri verimli şekilde keşfetmek için MCTS’nin basitleştirilmiş bir sürümünü uygular.
5. Pekiştirmeli öğrenme döngüsü: Geri bildirime dayalı olarak politika ve ödül modellerini iyileştiren temel bir eğitim döngüsü.
6. Tek ve çok değişkenli denklemler için destek: Kullanıcılar, x ve y gibi değişkenler için çözümler bulmak üzere bir veya iki denklem girebilir.

Demoyu sade ve odaklı tutmak için makalede belirtilen bazı gelişmiş özellikler bu eğitimin kapsamı dışında bırakılmıştır. Bu özellikler şunlardır:

1. Ölçeklenebilirlik: Orijinal makale büyük önceden eğitilmiş modeller ve kapsamlı hesaplama kaynakları kullanır. Demo daha küçük sinir ağları kullanır ve karmaşık ön eğitimden kaçınır.
2. Gelişmiş MCTS stratejileri: Uyarlamalı UCT ve çeşitli keşif stratejileri gibi teknikler tam olarak uygulanmamıştır.
3. Görev genellemesi: Uygulama yalnızca cebirsel denklemleri çözmeye odaklanır; oysa RStar daha geniş matematiksel görevler arasında genelleme yapacak şekilde tasarlanmıştır.
4. Veri kümesi: Eğitim için küratörlü bir veri kümesi kullanmak yerine, demo sembolik akıl yürütmeye ve kullanıcı tarafından sağlanan girdilere dayanır.

Adım 1: Önkoşullar

Demo, RStar metodolojisinin bir bölümünü yansıtan birkaç bileşene ayrılmıştır. Başlamadan önce aşağıdakilerin yüklü olduğundan emin olun:

• Python 3.8+
• Gerekli kütüphaneler: Gerekli Python paketlerini pip ile kurun:

pip install requests gradio, sympy Altyapı:

Ardından bu kütüphaneleri içe aktarın:

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 choiceAltyapı:

Artık tüm bağımlılıklar kurulduğuna göre, ana bileşenleri oluşturalım.

Adım 2: Politika ve Ödül için Sinir Ağları

Bu ağlar, makalede tanımlanan modellerin hafif sürümleridir ve bir sonraki eylemi tahmin etmek ve başarıyı değerlendirmek için kullanılır. Politika modeli, verilen denklemleri çözmek için bir sonraki adımları tahmin eder. Problemin kodlanmış temsillerini işlemek için ileri beslemeli bir sinir ağı kullanır.

Benzer şekilde, ödül modeli MCTS sürecini yönlendirmek için kısmi çözümleri değerlendirir. Her iki model de PyTorch kullanılarak uygulanmıştır.

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 xAltyapı:

Sırada MCTS ağaçları için bir düğüm sınıfı inşa edeceğiz.

Adım 3: MCTS Durumlarını Temsil Eden TreeNode Sınıfı

TreeNode sınıfı, MCTS ağacındaki düğümleri temsil eder. Her düğüm, arama sürecindeki bir duruma karşılık gelir ve şunları içerir:

• Durum (ör. denklemler veya kısmi çözümler).
• Üst düğümüne bir referans.
• Çocuk düğümlerin (genişletilmiş durumlar) listesi.
• Düğümün ne sıklıkla keşfedildiğini ve biriken ödüllerini izleyen ziyaret sayıları ve Q-değerleri.

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 childAltyapı:

Artık temel yapıyı kurduğumuza göre, sırada demonun çekirdek bileşenleri var.

Adım 4: MathSolver Sınıfı

MathSolver sınıfı, sembolik akıl yürütmeyi sinir ağı güdümlü arama ile birleştiren demonun çekirdeğidir. Birkaç temel bileşeni uygular:

A. Politika ve ödül modelleri

PolicyModel denklemleri çözmek için bir sonraki adımları tahmin ederken, RewardModel kısmi veya tam çözümlerin başarısını değerlendirir.

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 = {}  Altyapı:

Yukarıdaki yöntem, MathSolver sınıfını, matematiksel problemleri çözmek için gerekli bileşenleri ayarlayarak başlatır. İsteğe bağlı olarak bir matematik problemi veri kümesi kabul eder ve iki sinir ağını başlatır: politika modeli (bir sonraki eylemi tahmin eder) ve ödül modeli (eylemlerin başarısını değerlendirir). 

Artık bir politika ve ödül fonksiyonumuz var. Sırada, giriş denklemlerini ayrıştırıp kodlamamız gerekiyor.

B. Denklem ayrıştırma ve kodlama

Denklemler sympy kullanılarak ayrıştırılır ve politika ile ödül modelleri tarafından işlenmek üzere özellik vektörlerine kodlanır.

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)Altyapı:

encode_problem yöntemi, bir matematik problemini modeller için sabit boyutlu sayısal bir temsile dönüştürür. Değişken sayısı, operatör sayısı ve problem uzunluğu gibi özellikleri çıkarır ve bunları 128 boyutlu bir NumPy dizisine kodlar. Bu temsil, problemin yapısını yakalayarak modelin etkin işlemesini sağlar.

C. Politika modeli tahmini

Aşağıdaki kod, verilen denklemleri çözmek için değişken tanımlama, denklemleri oluşturma ve çözmeyi içeren bir sonraki adımları üretir.

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 []Altyapı:

policy_model_predict işlevi, giriş denklemlerini SymPy’nin sympify yöntemiyle ayrıştırarak bunların geçerli matematiksel ifadeler olduğundan emin olur. Ardından denklemlerde yer alan tüm değişkenleri belirler ve SymPy’nin solve işlevini kullanarak çözer. Bu yöntem, problem çözme iş akışı için üst düzey bir kılavuz görevi görür. 

D. Ödül modeli tahmini

reward_model_predict yöntemi, Monte Carlo Ağaç Araması (MCTS) devriyeleri sırasında yapılan eylemlere geri bildirim sağlayarak pekiştirmeli öğrenmede hayati bir rol oynar. 

  
  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()Altyapı:

Bu işlev, problem çözme adımlarını sayısal bir formata kodlar ve bunları ödül modeli üzerinden değerlendirir; başarı için pozitif, başarısızlık için negatif ödül döndürür. Bu geri bildirim, politika modelini eğiterek etkili eylemleri önceliklendirmesine ve karar verme yetisini geliştirmesine yardımcı olur. Politika ve ödül modeli tahmin fonksiyonları hazır olduğuna göre, artık yürütme görevine geçebiliriz.

E. Kod yürütme fonksiyonu

Bu yöntem, çok değişkenli çözümleri demetler veya sözlükler olarak ele alır ve sembolik sonuçları SymPy’nin N işlevini kullanarak sayısal yaklaşıklara dönüştürür. 

    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 FalseAltyapı:

Bu yöntem, doğru hesaplama yapılmasını sağlar ve çeşitli çözüm formatlarının esnek şekilde ele alınmasını destekler. Hata durumunda, sorunu kaydeder ve False döndürerek sağlam hata yönetimini sürdürür.

F. Monte Carlo Ağaç Araması (MCTS)

MCTS yöntemi, en iyi durumları yinelemeli olarak seçer, arama ağacını genişletir ve olası çözümleri simüle eder. Simülasyonlardan gelen ödüller, karar vermeyi iyileştirmek için geri yayılır.

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 NoneAltyapı:

mcts yöntemi dört temel adımı yinelemeli olarak gerçekleştirir: 

• Seçim: En iyi alt düğümleri kullanarak ağaçta aşağı doğru gezinmeye yardımcı olur.
• Genişletme: Bu adımda, policy_model_predict yöntemi kullanılarak yeni çocuk düğümler oluşturulur.
• Simülasyon: Tüm eylemler yürütülür ve başarı bu adımda belirlenir.
• Geri yayılım: Ödüller, reward_model_predict yöntemi kullanılarak hesaplanır ve düğüm değerlerini güncellemek üzere ağaçta yukarı doğru yayılır. 

Belirli sayıda devriyenin ardından yöntem, arama sırasında keşfedilen en umut verici çözümü temsil eden en iyi alt düğümün durumunu döndürür.

G. Çözümün yürütülmesi

solve yöntemi, denklemlerin ayrıştırılmasından çözümlerin yürütülüp doğrulanmasına kadar tüm süreci düzenler.

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)Altyapı:

solve yöntemi, kullanıcı tarafından sağlanan bir veya iki denklemi işleyerek bir yürütme bağlamı başlatır ve policy_model_predict aracılığıyla adımlar üretir. Her adımı yürütür, ilerlemeyi kaydeder ve başarı ya da başarısızlığı raporlar. Tek ve çok değişkenli sonuçlar dahil olmak üzere çözümler, değişken adları ve değerleriyle birlikte net biçimde sunulur. Çözüm bulunamazsa uygun bir mesaj gösterilir.

Artık tüm çekirdek bileşenler hazır, şimdi Gradio uygulaması üzerinde çalışabiliriz.

Adım 5: Gradio ile Kullanıcı Dostu Bir Arayüz Oluşturma

Gradio arayüzü, kullanıcıların denklemleri (bir veya daha fazla) girmesine, bunları çözmesine ve sonuçları etkileşimli olarak görmesine olanak tanır.

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)Altyapı:

Yukarıdaki kod, gelişmiş akıl yürütme ile matematiksel denklemleri çözmek için bir Gradio kullanıcı arayüzü oluşturur. Arayüz, bir gr.Blocks kapsayıcısına sarılmıştır ve gr.Textbox kullanılarak oluşturulmuş iki giriş alanı içerir: biri ilk denklem (zorunlu), diğeri ikinci denklem (isteğe bağlı) içindir.

Çıktı, "Solution" etiketi taşıyan tek bir gr.Textbox içinde gösterilir. interface.launch() komutu Gradio uygulamasını bir tarayıcıda başlatır ve debug=True bayrağı, hataları gidermeye yardımcı olacak ayrıntılı günlükleri etkinleştirir.

Adım 6: Test Etme ve Doğrulama

Artık Matematik Problemi Çözücü uygulamamızı test etme zamanı. İşte yaptığım bazı testler:

1. Tek değişkenli tek denklem: Girdi olarak tek bir denklem verildiğinde tek bir x değişkeninin olası değerlerini bulmayı denedim.

2. Çok değişkenli çok denklemi içeren problem: İki denklemi, iki değişkenli bir problem olarak vererek x ve y değişkenlerinin olası değerlerini buldum.

Olası Genişletmeler

 Bu demo, rStar-math yönteminin yetenekleriyle neler başarabileceğimize dair temel bir sürümdür. Yeteneklerini genişletmek için yapılabilecek daha çok şey var. 

• Politika modelinin akıl yürütme yeteneklerini artırmak için önceden eğitilmiş dil modelleri ekleyin.
• Arama sürecinin verimliliğini ve doğruluğunu artırmak için gelişmiş MCTS stratejilerini entegre edin veya çeşitli keşif tekniklerini deneyin.
• Demoyu, daha yüksek dereceden polinom denklemleri ve karmaşık denklem sistemlerini çözmek üzere genişletin.
• Genellemeyi iyileştirmek için modelleri daha büyük bir denklem veri kümesinde eğitin.
• Demoyu, matematik dışındaki ek akıl yürütme görevlerini de ele alacak şekilde genişletin.

rStar-math makalesinin orijinal deposuna GitHub üzerinden göz atabilirsiniz.

Sonuç

Bu demo, matematiksel denklemleri çözmek için çok adımlı akıl yürütmenin pratik bir uygulamasını gösterir. Sinir ağları, sembolik akıl yürütme ve MCTS’yi birleştirerek, gelişmiş yapay zekâ tekniklerinin yapılandırılmış akıl yürütme görevlerini nasıl ele alabileceğine dair bir fikir verir. Gelecekteki iyileştirmeler, onu RStar çerçevesinin tam yeteneklerine daha da yaklaştırabilir.