XBai o4: Demo Projesiyle Bir Rehber

MetaStone AI kısa süre önce XBai-o4 adlı, paralel test zamanı ölçekleme ve yansıtıcı üretimsel mimari sunan açık kaynaklı bir akıl yürütme modelini yayımladı. 32,8 milyar parametre ve entegre öz-değerlendirme başlığıyla, XBai o4, yerelde çalışırken temel matematiksel akıl yürütme kıyaslarında OpenAI’nin o3-mini (orta mod) modelini geride bırakıyor.

Bu blogda odağım, XBai o4'ün benzersiz yansıtıcı akıl yürütme yetenekleri olacak; LM Studio tarafından desteklenen, yerel olarak dağıtılmış bir Streamlit arayüzü üzerinden matematiksel problemler için birden çok çözüm güzergâhını nasıl oluşturup değerlendirdiğini göstereceğim.

Bu eğitimde adım adım şunları nasıl yapacağımı açıklayacağım:

• XBai-o4’ü en iyi performans için LM Studio ve GGUF niceleme ile yerelde dağıtmak.
• Gerçek zamanlı, dal-bazlı akıl yürütme görselleştirmesi için bir Streamlit uygulaması kurmak.
• Test zamanı ölçekleme, dinamik sıcaklık kontrolü ve ödül modeli puanlamasıyla denemeler yapmak.
• Farklı akıl yürütme stratejileri ve ayarlarının çözüm kalitesini ve verimliliğini nasıl etkilediğini analiz edip karşılaştırmak.

Sonunda, uygulamanız aşağıdaki gibi görünecek:

XBai-o4 Nedir?

XBai-o4, MetaStone AI’nin dördüncü nesil açık kaynaklı akıl yürütme modelidir ve yapay zekânın karmaşık problem çözmeye yaklaşımını yeniden tanımlamayı hedefleyen yansıtıcı üretimsel bir mimari sunar. Cevap üretimi ve cevap değerlendirmesini iki ayrı süreç olarak ele alan geleneksel LLM’lerin aksine, XBai o4 bu ikisini Paylaşılan Süreç Ödül Modeli (SPRM) kullanarak birleşik bir modelde birleştirir. Bu tasarım, modelin birden çok akıl yürütme yolunu paralel olarak üretmesine, puanlamasına ve seçmesine olanak tanır.

Kaynak: SPRM Başlığı

Temelde XBai o4, uzun düşünce zinciri (Long-CoT) pekiştirmeli öğrenme ile süreç ödülü öğrenmesini tek bir eğitim hattında birleştirir. Modelin sunduğu bazı temel yenilikler şunlardır:

• Yansıtıcı üretimsel mimari: SPRM başlığı, ana model omurgasını paylaşır ve tek, yüksek verimli bir geçişte hem üretim hem öz-değerlendirmeyi mümkün kılar.
• Dinamik test zamanı ölçekleme: Model, hız ve doğruluk arasında ödün vererek kullanım senaryonuza uyması için 2, 8 veya 32 dallı akıl yürütme modları arasında anında geçiş yapar.
• Birleşik akıl yürütme tarzları: Bu model, doğrudan ispat, çelişki, tümevarım, cebirsel ve görsel akıl yürütmede üstün olup geniş bir matematik ve mantık problem yelpazesini ele alır.
• Performans liderliği: AIME24 kıyaslamasında XBai-o4 çok iyi sonuçlar verir. En düşük ayarında bile XBai o4, OpenAI o3-mini ile başa baş gider ya da onu geçer ve bunu çok daha az hesaplama ile yapar.

Kaynak: XBai-O4 Dokümantasyonu

XBai o4’ü LM Studio ile Yerelde Nasıl Kurarsınız

XBai o4’ü LM Studio kullanarak yerelde çalıştırabilirsiniz; bu araç, mevcut olduğunda sisteminizin GPU’sunu veya Apple Silicon (Metal/MLX) hızlandırmasını otomatik olarak kullanır (elle ayar gerektirmez). En iyi performans ve uyumluluk için modelin GGUF nicelemeli sürümünü kullanmanızı öneririm.

Neden nicelemeli GGUF sürümü?

GGUF (GPT-Generated Unified Format) standardı, model ağırlıklarının duyarlılığını azaltarak yerel çıkarımı son derece verimli hâle getirir. Bu projede, kalite ile bellek kullanımı arasında mükemmel denge sunmasıyla popüler olan Q3_K_S nicelemeli varyantını kullanacağız.

• En uygun denge: Yalnızca 14,39 GB boyutuyla Q3_K_S formatı, tam duyarlıklı modellere kıyasla minimum kalite kaybıyla güçlü akıl yürütme performansı sunar.
• Geniş uyumluluk: GGUF, Mac, Windows ve Linux’ta sorunsuz çalışan, nicelemeli LLM’leri yerelde çalıştırmanın güncel standardıdır.
• Kaynak verimliliği: 3 bit niceleme, büyük modelleri tipik bir 32 GB RAM kurulumunda çalıştırmayı kolaylaştırır.
• Kararlı ve hızlı: Bu model, paralel ve çoklu güzergâh iş yüklerinde dahi güvenilir çıktılar ve tutarlı çıkarım hızları sağlar.

Şimdi, LM Studio kullanarak verimli yerel çıkarım için nicelemeli GGUF modelini kurmanın adım adım sürecine bakalım.

Adım 1: LM Studio’yu kurun

LM Studio, GGUF desteği sunar ve donanımınıza göre en uygun çıkarım arka ucunu (Metal, GPU veya CPU) otomatik olarak seçer. 

LM Studio’yu henüz kurmadıysanız, lmstudio.ai adresinden indirip kurulum talimatlarını izleyin.

Adım 2: XBai-o4 GGUF modelini indirin

LM Studio içinde:

1. Search sekmesine gidin
2. mradermacher/XBai-o4-GGUF ifadesini arayın
3. XBai-o4.Q3_K_S.gguf varyantını indirin (14,39 GB).

Adım 3: Modeli yükleyin ve yapılandırın

LM Studio kurulduktan sonra, XBai o4 modelini yerel çıkarım için yüklüyor ve yapılandırıyoruz:

1. LM Studio’yu açın ve Local Server sekmesine gidin (Mac’inizde üst çubukta).
2. İndirilen modeller listenizden XBai-o4.Q3_K_S.gguf modelini seçip yükleyin.
3. Aşağıdaki yapılandırma seçeneklerini ayarlayın:
• Bağlam uzunluğu: 8192
• Sıcaklık: 0,7 (bunu demomuzda dinamik olarak ayarlayacağız)
• Maksimum belirteç: 1024
• GPU katmanları: Otomatik algılama (LM Studio, donanım yeteneklerinize göre bunu otomatik optimize eder)
4. Varsayılan olarak http://localhost:1234 üzerinde çalışan yerel sunucuyu başlatın.

Çalışmaya başladığında, sisteminiz XBai o4 ile çoklu güzergâhlı akıl yürütmeye hazırdır.

Demo: Etkileşimli XBai-o4 Yansıtıcı Akıl Yürütme

Şimdi, XBai o4'ün yansıtıcı akıl yürütme yeteneklerini gerçek zamanlı performans karşılaştırmasıyla gösteren bir Streamlit uygulaması oluşturacağız.

Adım 1: Bağımlılıkları kurun

Bağımlılıkları kurarak başlayın:

pip install streamlit plotly pandas numpy requestsAltyapı:

Bu komut, kullanıcı arayüzü, veri işleme, görselleştirme ve API istekleri için gereken temel bağımlılıkların tümüne sahip olmanızı sağlar.

Adım 2: Kütüphaneleri içe aktarın ve sayfayı ayarlayın

Ardından, gerekli tüm kütüphaneleri içe aktarın ve Streamlit sayfa düzeninizi ve temel ayarları yapılandırın.

import streamlit as st
import time
import requests
import numpy as np
import pandas as pd
import plotly.express as px
from typing import List, Dict, Any
LM_STUDIO_URL = "http://localhost:1234/v1"   # change as per your server
REASONING_MODES = {"Low (k=2)": 2, "Medium (k=8)": 8, "High (k=32)": 8}  
st.set_page_config(page_title="MetaStone-XBai-o4 Reflective Reasoning Demo", layout="wide")
st.markdown("""
<style>
    .main-header {
        background: linear-gradient(90deg, #1e3c72 0%, #2a5298 100%);
        
        border-radius: 10px;
        color: white;
        text-align: center;
        
    }
</style>
""", unsafe_allow_html=True)Altyapı:

Bu kod bloğu, web arayüzü için Streamlit’in yanı sıra time, requests, numpy, pandas, plotly.express ve tür ipuçları gibi diğer temel kütüphaneleri de dâhil olmak üzere demomuz için gerekli çekirdek kütüphanelerin tümünü içe aktarır.

Ardından, uygulamanın istek göndereceği model API uç noktasını belirtmek için LM_STUDIO_URL değerini ayarlar ve kullanıcıların kaç çözüm dalı oluşturulacağını kolayca seçebilmesi için akıl yürütme modlarını (REASONING_MODES) tanımlar.

Son olarak st.set_page_config() ile Streamlit arayüzünü özel bir başlık, geniş yerleşim ve CSS ile stillendirilmiş bir gradyan başlıkla yapılandırıyoruz.

Not: LM_STUDIO_URL, LM Studio’dan kopyalayabileceğiniz LLM sunucusunun temel URL’sidir. Genellikle "http://localhost:1234/v1" olur ancak değişebilir. Ayrıca, sunucunuzun kapasitesine göre akıl yürütme modlarını seçin.

Adım 3: Yardımcı işlevler

Şimdi uygulamamızın çekirdek “yansıtıcı akıl yürütme” mantığını çalıştıran bir dizi yardımcı işlevi oluşturalım. Bu işlevler, birden çok güzergâhla çalışmayı, en iyi çözümü seçmeyi ve her cevabı puanlamayı kolaylaştırır.

Adım 3.1: Çoklu güzergâh örneklemeyi model desteği açısından kontrol etme

Bu adımda, LM Studio sunucumuzun çoklu güzergâh örneklemeyi kaldırıp kaldıramadığını otomatik olarak kontrol eden basit bir yardımcı işlev tanıtıyoruz. Bazı sunucular, tek bir API çağrısında birden çok bağımsız tamamlama talep etmemize olanak tanıyan n parametresini destekler ve bu da süreci önemli ölçüde hızlandırır. 

def supports_n_param():
    payload = {
        "messages": [{"role": "user", "content": "What is 1+1?"}],
        "max_tokens": 80,
        "temperature": 0.1,
        "n": 2,
        "stream": False
    }
    try:
        resp = requests.post(f"{LM_STUDIO_URL}/chat/completions", json=payload, timeout=120)
        if resp.status_code == 200 and len(resp.json().get("choices", [])) == 2:
            return True
    except Exception:
        pass
    return FalseAltyapı:

Bu işlev, LM Studio sunucunuzun tek bir API çağrısında n parametresi kullanılarak birden fazla cevap (“güzergâh”) üretmeyi destekleyip desteklemediğini kontrol eder. Hızlı bir test isteği gönderir ve özellik kullanılabilir ise True döndürür; böylece daha hızlı ve ölçeklenebilir akıl yürütme için gerçek “En İyinin N’i” örneklemeyi etkinleştirir.

Adım 3.2: Güzergâhlar üretme

Arka ucumuzun çoklu güzergâh örneklemeyi destekleyip desteklemediğini belirledikten sonra, sıradaki adım belirli bir problem için birden çok akıl yürütme yolu üretmektir. Bu bölümde, sunucu tarafı çoklu örneklemeyi (mevcutsa) kullanan veya tekli tamamlamaları verimli şekilde paralelleştiren bir dizi yardımcı işlev tanıtıyoruz; böylece uygulama hızlı ve ölçeklenebilir kalır.

def lm_studio_generate_multiple(problem, k, temperature=0.8, seed=2025):
    prompt = f"<think> {problem}\n</think>"
    payload = {
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 196,
        "temperature": temperature,
        "top_p": 0.9,
        "top_k": 30,
        "n": k,
        "stream": False,
        "seed": seed
    }
    start = time.time()
    resp = requests.post(f"{LM_STUDIO_URL}/chat/completions", json=payload, timeout=120)
    latency = time.time() - start
    if resp.status_code == 200:
        result = resp.json()
        return [{
            "content": choice["message"]["content"].strip(),
            "latency": latency / k,  
            "success": True,
        } for choice in result.get("choices", [])]
    else:
        raise RuntimeError(f"LM Studio error: {resp.status_code}: {resp.text}")
def lm_studio_generate_single(problem, temperature, seed=None):
    prompt = f"<think> {problem}\n</think>"
    payload = {
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 196,
        "temperature": temperature,
        "top_p": 0.9,
        "top_k": 30,
        "stream": False,
        "seed": seed
    }
    start = time.time()
    resp = requests.post(f"{LM_STUDIO_URL}/chat/completions", json=payload, timeout=120)
    latency = time.time() - start
    if resp.status_code == 200:
        content = resp.json()["choices"][0]["message"]["content"].strip()
        return {"content": content, "latency": latency, "success": True}
    else:
        return {"success": False, "error": f"HTTP {resp.status_code}: {resp.text}", "latency": latency}
def parallel_candidate_generation(problem, k, progress_cb=None):
    import concurrent.futures
    temperatures = np.linspace(0.1, 1.0, k)
    results = []
    with concurrent.futures.ThreadPoolExecutor(max_workers=min(8, k)) as executor:
        futures = []
        for i in range(k):
            seed = 2025 + i * 31
            futures.append(executor.submit(lm_studio_generate_single, problem, temperatures[i], seed))
        for i, future in enumerate(concurrent.futures.as_completed(futures)):
            res = future.result()
            res["trajectory_id"] = i + 1
            results.append(res)
            if progress_cb:
                progress_cb(i + 1, k)
    results.sort(key=lambda x: x.get("trajectory_id", 0))
    return resultsAltyapı:

Her işlevin çoklu güzergâh hattına katkısı şöyledir:

• lm_studio_generate_multiple() işlevi: LM Studio sunucusu n parametresini desteklediğinde, bu işlev tek bir API isteğiyle aynı anda k farklı çözüm üretir. Bu, gerçek test zamanı ölçeklemeyi mümkün kılan en verimli moddur.
• lm_studio_generate_single() işlevi: Sunucu çoklu örneklemeyi desteklemiyorsa, bu işlev istek başına bir çözüm güzergâhı üretir; farklı sıcaklıklar ve tohumlarla yeniden üretilebilirlik sağlar.
• parallel_candidate_generation() işlevi: Geriye dönüş modunda performansı korumak için bu yardımcı, her biri farklı örnekleme sıcaklıklarıyla birden çok lm_studio_generate_single() çağrısını paralel olarak başlatır ve yanıtları toplar. Böylece gerçek çoklu örnekleme yoksa bile hızlıca geniş bir çözüm yelpazesi elde edilir.

Adım 3.3: En iyi güzergâh

Birden çok akıl yürütme yolu ürettikten sonra en güçlü çözümü belirlemek için yapılandırılmış bir yönteme ihtiyaç duyarız. Bu adımda, MetaStone Yansıtıcı Akıl Yürütme makalesinde kullanılan ödül modelleme (SPRM) tekniklerini taklit eden puanlama ve seçme araçları tanıtılıyor.

def step_tokenize(trajectory: str) -> List[str]:
    steps = [step.strip() for step in trajectory.split('.\n\n') if step.strip()]
    return steps
def dummy_sprm_score(trajectory: str, problem: str) -> float:
    steps = step_tokenize(trajectory)
    n = len(steps)
    def step_score(step):
        s = 0.2
        if any(x in step.lower() for x in ["therefore", "thus", "so", "finally", "conclude"]): s += 0.15
        if any(sym in step for sym in ["=", "+", "-", "*", "/", "(", ")"]): s += 0.1
        if len(step.split()) > 10: s += 0.1
        return min(1.0, s)
    step_scores = [step_score(s) for s in steps] or [0.01]
    geometric_mean = np.exp(np.mean(np.log(np.maximum(step_scores, 1e-3))))
    return min(1.0, geometric_mean + 0.05 * np.log1p(n))
def best_of_n_selection(candidates: List[Dict]) -> int:
    best_idx = int(np.argmax([c["sprm_score"] for c in candidates]))
    return best_idxAltyapı:

Her işlevin yaptığı iş şudur:

• step_tokenize() işlevi: Bir akıl yürütme güzergâhını mantıksal adımlara veya parçalara böler; bu da adım bazlı analiz ve puanlama yapmayı sağlar.
• dummy_sprm_score() işlevi: Bu işlev, her aday güzergâha bir ödül puanı atar ve çok adımlı, iyi yapılandırılmış ve matematiksel akıl yürütme kullanan yanıtları teşvik eder. Makaledeki Paylaşılan Süreç Ödül Modeli’nin (SPRM) yerini tutan bir vekil olarak çalışır; gerçek SPRM çözümlerini dahili olarak değerlendirir.
• Not: Bu puanlama işlevi, orijinal makalede tanımlanan gerçek SPRM’nin yalnızca bir yaklaşığıdır. Gerçek SPRM, büyük veri kümeleri üzerinde eğitilen ve adım düzeyinde ayrıntılı geri bildirim sağlayan öğrenilmiş bir ödül modelidir; önemli kaynaklar ve bazı durumlarda mülki veri gerektirir.
• best_of_n_selection() işlevi: Bir grup aday cevap verildiğinde, bu işlev en yüksek SPRM puanına göre tek bir en iyi güzergâhı seçer; tıpkı makaledeki yansıtıcı modelin test zamanında en sağlam cevabını otomatik seçmesi gibi.

Adım 4: Ana Streamlit uygulama akışı

Bu adımda, Streamlit ile etkileşimli bir akıl yürütme demosu oluşturmak için tüm parçaları bir araya getiriyoruz. 

st.markdown("""
<div class="main-header">
    <h1> MetaStone XBai-o4 Reflective Reasoning Demo</h1>
</div>
""", unsafe_allow_html=True)
st.sidebar.header("Reasoning Mode")
mode = st.sidebar.selectbox("Reasoning effort (k candidates):", list(REASONING_MODES.keys()))
k = REASONING_MODES[mode]
st.sidebar.header("Problem Input")
problem = st.sidebar.text_area("Enter your math/logic problem:", "Prove that the square root of 2 is irrational")
if st.sidebar.button("Run Reflective Reasoning"):
    st.session_state.run = True
    st.session_state.results = None
    st.session_state.best_idx = None
if "run" not in st.session_state:
    st.session_state.run = False
if st.session_state.run:
    st.info(f"Generating {k} reasoning trajectories in parallel...")
    progress = st.progress(0)
    def update_progress(done, total):
        progress.progress(done / total)
    try:
        if supports_n_param():
            results = lm_studio_generate_multiple(problem, k, temperature=0.7)
            for idx, res in enumerate(results):
                res["trajectory_id"] = idx + 1
        else:
            results = parallel_candidate_generation(problem, k, progress_cb=update_progress)
        for res in results:
            if res.get("success"):
                res["sprm_score"] = dummy_sprm_score(res["content"], problem)
            else:
                res["sprm_score"] = 0.0
        best_idx = best_of_n_selection(results)
        st.session_state.results = results
        st.session_state.best_idx = best_idx
        st.session_state.run = False
    except Exception as e:
        st.error(f"Failed to generate trajectories: {str(e)}")
        st.session_state.run = False
if st.session_state.get("results"):
    results = st.session_state.results
    best_idx = st.session_state.best_idx
    st.success(f"Selected trajectory #{best_idx+1} (highest SPRM score)")
    df = pd.DataFrame({
        "Trajectory": [f"T{i+1}" for i in range(len(results))],
        "SPRM Score": [r["sprm_score"] for r in results],
        "Latency (s)": [r.get("latency", 0.0) for r in results],
        "Success": [r.get("success", False) for r in results]
    })
    for i, res in enumerate(results):
        is_best = (i == best_idx)
        st.markdown(f"### {'' if is_best else ''} Trajectory {i+1} {'(SELECTED)' if is_best else ''}")
        if res.get("success"):
            st.info(f"SPRM Score: {res['sprm_score']:.3f} | Latency: {res['latency']:.1f}s")
            st.code(res["content"])
        else:
            st.error(f"Failed: {res.get('error', 'Unknown error')}")
    fig = px.bar(df, x="Trajectory", y="SPRM Score", color="Success", title="SPRM Scores for Each Trajectory")
    st.plotly_chart(fig, use_container_width=True)
    st.dataframe(df)Altyapı:

Ana uygulama akışı birkaç temel hedefi yerine getirir:

• Kenar çubuğu yapılandırması: Kenar çubuğu, akıl yürütme çabasını (yani sorgu başına örneklenen güzergâh sayısını) ayarlamak için dinamik denetimler sunar ve kullanıcılara özel matematik veya mantık problemleri girmeye olanak tanır. Her mod (k=2, 8, 32), farklı bir test zamanı çıkarım bütçesine karşılık gelir ve kullanıcının ölçeklemenin çözüm kalitesi üzerindeki etkilerini analiz etmesini sağlar.
• Çalıştırma tetikleyicisi: Run Reflective Reasoning düğmesi, arka uç tarafından destekleniyorsa verimli sunucu içi çoklu örneklemeyi (n parametresi) ya da desteklenmiyorsa eşzamanlı isteklerle paralel örneklemeyi tetikleyen bir boru hattı giriş noktası görevi görür.
• İlerleme takibi: Güzergâhlar üretilirken, bir ilerleme çubuğu Streamlit’in durumlu tepkiselliğinden yararlanarak gerçek zamanlı geri bildirim sağlar.
• Son işleme ve puanlama: Tamamlandıktan sonra, her güzergâh Paylaşılan Süreç Ödül Modeli’ni (SPRM) taklit eden vekil ödül modeli (dummy_sprm_score) ile değerlendirilir. 
• Seçim ve gösterim: En iyi güzergâh, ödül puanına göre (best_of_n_selection) vurgulanır. Üretilen tüm çözümler, ilgili SPRM puanları ve üretim gecikmeleriyle birlikte metinsel ve grafiksel formatlarda yan yana analiz için sunulur.

Kendiniz denemek için, kodu xbai_demo.py olarak kaydedin ve şu komutla başlatın:

streamlit run xbai_demo.pyAltyapı: