XBai o4: डेमो प्रोजेक्ट के साथ एक गाइड

हाल ही में MetaStone AI ने XBai-o4 जारी किया है, जो एक ओपन-सोर्स रीजनिंग मॉडल है और जो पैरेलल टेस्ट-टाइम स्केलिंग तथा रिफ्लेक्टिव जेनरेटिव आर्किटेक्चर पेश करता है। 32.8 अरब पैरामीटर्स और इंटीग्रेटेड सेल्फ-इवैल्यूएशन हेड के साथ, XBai o4 स्थानीय रूप से चलते हुए भी कोर गणितीय रीजनिंग बेंचमार्क्स पर OpenAI के o3-mini (मीडियम मोड) से बेहतर प्रदर्शन करता है।

इस ब्लॉग में मेरा फोकस XBai o4 की अनोखी रिफ्लेक्टिव रीजनिंग क्षमताओं पर होगा—यह दिखाते हुए कि कैसे यह LM Studio द्वारा संचालित, स्थानीय रूप से डिप्लॉय किए गए Streamlit इंटरफ़ेस के माध्यम से गणितीय समस्याओं के लिए कई समाधान-ट्रैजेक्टरीज़ जनरेट और इवैल्यूएट करता है।

इस ट्यूटोरियल में, मैं चरण-दर-चरण समझाऊंगा कि कैसे:

• LM Studio और GGUF क्वांटाइज़ेशन के साथ XBai-o4 को लोकली डिप्लॉय करें ताकि बेहतरीन परफॉर्मेंस मिले।
• ब्रांच-बाय-ब्रांच रीजनिंग का रियल-टाइम विज़ुअलाइज़ेशन करने के लिए Streamlit ऐप बनाएं।
• टेस्ट-टाइम स्केलिंग, डायनेमिक टेम्परेचर कंट्रोल, और रिवॉर्ड- मॉडल स्कोरिंग के साथ प्रयोग करें।
• विश्लेषण करें और तुलना करें कि अलग-अलग रीजनिंग रणनीतियाँ और सेटिंग्स समाधान की गुणवत्ता और दक्षता को कैसे प्रभावित करती हैं।

अंत में, आपका ऐप कुछ ऐसा दिखेगा:

XBai-o4 क्या है?

XBai-o4 MetaStone AI का चौथी पीढ़ी का ओपन-सोर्स रीजनिंग मॉडल है, जो एक रिफ्लेक्टिव जेनरेटिव आर्किटेक्चर पेश करता है और जटिल समस्या-समाधान की AI पद्धति को फिर से परिभाषित करने की कोशिश करता है। पारंपरिक LLMs के विपरीत, जो उत्तर जनरेशन और उत्तर इवैल्यूएशन को दो अलग-अलग प्रक्रियाओं की तरह मानते हैं, XBai o4 Shared Process Reward Model (SPRM) का उपयोग करके दोनों को एक एकीकृत मॉडल में जोड़ता है। यह डिजाइन मॉडल को पैरेलल में कई रीजनिंग पाथ जनरेट, स्कोर और सेलेक्ट करने देता है।

स्रोत: SPRM Head

मूल रूप से, XBai o4 लॉन्ग चेन-ऑफ-थॉट (Long-CoT) रिइन्फोर्समेंट लर्निंग और प्रोसेस रिवॉर्ड लर्निंग को एकल ट्रेनिंग पाइपलाइन में जोड़ता है। इस मॉडल में पेश की गई कुछ प्रमुख नवाचार यह हैं:

• रिफ्लेक्टिव जेनरेटिव आर्किटेक्चर: SPRM हेड मुख्य मॉडल बैकबोन के साथ शेयर करता है, जिससे एक ही, अत्यधिक कुशल पास में जनरेशन और सेल्फ-इवैल्यूएशन दोनों संभव होते हैं।
• डायनेमिक टेस्ट-टाइम स्केलिंग: मॉडल तुरंत 2, 8, या 32-ब्रांच रीजनिंग मोड्स के बीच स्विच कर सकता है, ताकि आपकी ज़रूरत के अनुसार स्पीड और एक्यूरेसी का संतुलन बनाया जा सके।
• एकीकृत रीजनिंग शैलियाँ: यह मॉडल डायरेक्ट प्रूफ, कंट्राडिक्शन, इंडक्शन, अल्जेब्रिक और विज़ुअल रीजनिंग में उत्कृष्ट है, और गणित व लॉजिक की विस्तृत श्रेणी की समस्याओं को संभालता है।
• परफॉर्मेंस लीडरशिप: AIME24 बेंचमार्क पर XBai-o4 बेहतरीन नतीजे देता है। अपने सबसे निचले सेटिंग पर भी, XBai o4 OpenAI o3-mini के बराबर या उससे बेहतर प्रदर्शन करता है, वह भी काफी कम कंप्यूट के साथ।

स्रोत: XBai-O4 प्रलेखन

LM Studio के साथ XBai o4 को लोकली कैसे सेटअप करें

आप LM Studio का उपयोग करके XBai o4 को लोकली चला सकते हैं, जो उपलब्ध होने पर स्वतः ही आपके सिस्टम के GPU या Apple Silicon (Metal/MLX) एक्सेलेरेशन का उपयोग करता है (कोई मैनुअल सेटअप आवश्यक नहीं)। बेहतर परफॉर्मेंस और कम्पैटिबिलिटी के लिए, मैं मॉडल के GGUF क्वांटाइज़्ड वर्ज़न का उपयोग करने की सलाह देता/देती हूँ।

क्वांटाइज़्ड GGUF वर्ज़न क्यों उपयोग करें?

GGUF (GPT-Generated Unified Format) मानक, मॉडल वेट्स की प्रिसिशन घटाकर, लोकल इन्फरेंस को अत्यधिक कुशल बनाता है। इस प्रोजेक्ट में हम Q3_K_S क्वांटाइज़्ड वैरिएंट का उपयोग करेंगे, जो गुणवत्ता और मेमोरी उपयोग के बीच उत्कृष्ट संतुलन के लिए लोकप्रिय है।

• उत्तम संतुलन: केवल 14.39 GB में, Q3_K_S फ़ॉर्मेट फुल-प्रिसिशन मॉडल्स की तुलना में बहुत कम गुणवत्ता क्षरण के साथ मजबूत रीजनिंग परफॉर्मेंस देता है।
• विस्तृत कम्पैटिबिलिटी: GGUF, क्वांटाइज़्ड LLMs को लोकली चलाने के लिए मौजूदा मानक है, जो Mac, Windows और Linux पर सहजता से काम करता है।
• संसाधन-कुशल: 3-बिट क्वांटाइज़ेशन बड़े मॉडल्स को एक सामान्य 32 GB RAM सेटअप में चलाना आसान बनाता है।
• स्थिर और तेज़: यह मॉडल पैरेलल, मल्टी-ट्रैजेक्टरी वर्कलोड्स के तहत भी भरोसेमंद आउटपुट और सुसंगत इन्फरेंस स्पीड देता है।

आइए LM Studio का उपयोग करके कुशल लोकल इन्फरेंस के लिए क्वांटाइज़्ड GGUF मॉडल सेटअप करने की चरण-दर-चरण प्रक्रिया देखें।

चरण 1: LM Studio इंस्टॉल करें

LM Studio में GGUF सपोर्ट है और यह आपके हार्डवेयर के लिए स्वतः सर्वोत्तम इन्फरेंस बैकएंड चुनता है—चाहे वह Metal, GPU हो या CPU। 

यदि आपने अभी तक LM Studio इंस्टॉल नहीं किया है, तो बस lmstudio.ai से डाउनलोड करें और इंस्टॉलेशन निर्देशों का पालन करें।

चरण 2: XBai-o4 GGUF मॉडल डाउनलोड करें

LM Studio में:

1. सर्च टैब पर जाएँ
2. mradermacher/XBai-o4-GGUF खोजें
3. XBai-o4.Q3_K_S.gguf वैरिएंट (14.39 GB) डाउनलोड करें।

चरण 3: मॉडल लोड करें और कॉन्फ़िगर करें

LM Studio इंस्टॉल होने के बाद, हम लोकल इन्फरेंस के लिए XBai o4 मॉडल को लोड और कॉन्फ़िगर करेंगे:

1. LM Studio खोलें और Local Server टैब पर जाएँ (Mac पर टॉप बार)।
2. डाउनलोड किए गए मॉडल्स की सूची से XBai-o4.Q3_K_S.gguf मॉडल चुनें और लोड करें।
3. निम्नलिखित कॉन्फ़िगरेशन विकल्प सेट करें:
• कॉन्टेक्स्ट लंबाई: 8192
• टेम्परेचर: 0.7 (इसे हम अपने डेमो में डायनेमिक रूप से एडजस्ट करेंगे)
• अधिकतम टोकन्स: 1024
• GPU लेयर्स: ऑटो-डिटेक्ट (LM Studio आपके हार्डवेयर की क्षमता के आधार पर इसे स्वतः ऑप्टिमाइज़ करेगा)
4. लोकल सर्वर शुरू करें, जो डिफ़ॉल्ट रूप से http://localhost:1234 पर चलता है।

एक बार चलने पर, आपका सिस्टम XBai o4 के साथ मल्टी-ट्रैजेक्टरी रीजनिंग के लिए तैयार है।

डेमो: इंटरैक्टिव XBai-o4 रिफ्लेक्टिव रीजनिंग

अब हम एक Streamlit एप्लिकेशन बनाएँगे जो रियल-टाइम परफॉर्मेंस तुलना के साथ XBai o4 की रिफ्लेक्टिव रीजनिंग क्षमताओं को प्रदर्शित करता है।

चरण 1: निर्भरताएँ इंस्टॉल करें

शुरुआत निर्भरताएँ इंस्टॉल करने से करें:

pip install streamlit plotly pandas numpy requestsसंचालित द्वारा

यह कमांड UI, डेटा हैंडलिंग, प्लॉटिंग और API रिक्वेस्ट्स के लिए आवश्यक सभी कोर डिपेंडेंसीज़ इंस्टॉल कर देता है।

चरण 2: लाइब्रेरी इम्पोर्ट करें और पेज सेट करें

इसके बाद, सभी आवश्यक लाइब्रेरी इम्पोर्ट करें और अपने Streamlit पेज का लेआउट और बेसिक सेटिंग्स कॉन्फ़िगर करें।

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)संचालित द्वारा

यह कोड ब्लॉक हमारे डेमो के लिए सभी कोर लाइब्रेरीज़ इम्पोर्ट करता है—वेब UI के लिए Streamlit सहित—साथ ही time, requests, numpy, pandas, plotly.express और टाइपिंग टूल्स जैसी अन्य बेसिक लाइब्रेरीज़।

इसके बाद, यह मॉडल API एंडपॉइंट LM_STUDIO_URL सेट करता है ताकि ऐप को पता हो कि रिक्वेस्ट्स कहाँ भेजनी हैं, और रीजनिंग मोड्स (REASONING_MODES) परिभाषित करता है ताकि उपयोगकर्ता आसानी से तय कर सकें कि कितनी सॉल्यूशन ब्रांच जनरेट करनी हैं।

अंत में, हम st.set_page_config() का उपयोग कर Streamlit UI को कस्टम शीर्षक, वाइड लेआउट और CSS-स्टाइल्ड ग्रेडिएंट हेडर के साथ कॉन्फ़िगर करते हैं।

नोट: LM_STUDIO_URL LLM सर्वर का बेस URL है, जिसे आप LM Studio से कॉपी कर सकते हैं। यह आमतौर पर "http://localhost:1234/v1" होता है, पर बदल भी सकता है। साथ ही, अपने सर्वर की क्षमता के अनुसार रीजनिंग मोड्स चुनें।

चरण 3: हेल्पर फ़ंक्शंस

अब, हम अपने ऐप के कोर “रिफ्लेक्टिव रीजनिंग” लॉजिक को चलाने वाले हेल्पर फ़ंक्शंस का सेट बनाएँगे। ये फ़ंक्शंस मल्टीपल ट्रैजेक्टरीज़ के साथ काम करना, सर्वश्रेष्ठ समाधान चुनना और प्रत्येक उत्तर को स्कोर करना आसान बनाते हैं।

चरण 3.1: मल्टी-ट्रैजेक्टरी सैंपलिंग के लिए मॉडल सपोर्ट जाँचना

इस चरण में एक साधारण हेल्पर फ़ंक्शन पेश किया गया है जो स्वतः जाँचता है कि हमारा LM Studio सर्वर मल्टी-ट्रैजेक्टरी सैंपलिंग संभाल सकता है या नहीं। कुछ सर्वर n पैरामीटर सपोर्ट करते हैं, जो हमें एक ही API कॉल में कई स्वतंत्र कम्प्लीशन रिक्वेस्ट करने देता है और इस तरह प्रक्रिया को काफी तेज कर देता है। 

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 Falseसंचालित द्वारा

यह फ़ंक्शन जाँचता है कि आपका LM Studio सर्वर एक ही API कॉल में n पैरामीटर का उपयोग करके कई उत्तर (“ट्रैजेक्टरीज़”) जनरेट कर सकता है या नहीं। यह एक त्वरित टेस्ट रिक्वेस्ट भेजता है और यदि फीचर उपलब्ध है तो True लौटाता है—जिससे तेज़, अधिक स्केलेबल “Best-of-N” सैंपलिंग सक्षम होती है।

चरण 3.2: ट्रैजेक्टरीज़ जनरेट करना

जब हम तय कर लेते हैं कि हमारा बैकएंड मल्टी-ट्रैजेक्टरी सैंपलिंग सपोर्ट करता है या नहीं, अगला कदम किसी दिए गए प्रॉब्लम के लिए कई रीजनिंग पाथ जनरेट करना है। इस सेक्शन में हेल्पर फ़ंक्शंस का एक सेट पेश किया गया है जो या तो सर्वर-साइड मल्टी-सैंपलिंग (जहाँ उपलब्ध हो) का उपयोग करते हैं या सिंगल कम्प्लीशन को कुशलता से पैरेललाइज़ करते हैं, ताकि ऐप तेज़ और स्केलेबल बना रहे।

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 resultsसंचालित द्वारा

प्रत्येक फ़ंक्शन मल्टी-ट्रैजेक्टरी पाइपलाइन में इस तरह फिट होता है:

• lm_studio_generate_multiple() फ़ंक्शन: जब LM Studio सर्वर n पैरामीटर सपोर्ट करता है, यह फ़ंक्शन एक ही API रिक्वेस्ट भेजकर एक साथ k विविध समाधान जनरेट करता है। यह सबसे कुशल मोड है और सच्चे टेस्ट-टाइम स्केलिंग को सक्षम बनाता है।
• lm_studio_generate_single() फ़ंक्शन: यदि सर्वर मल्टी-सैंपलिंग सपोर्ट नहीं करता, तो यह फ़ंक्शन फॉलबैक देता है—प्रति रिक्वेस्ट एक समाधान-ट्रैजेक्टरी जनरेट करता है—जिससे अलग-अलग तापमानों का उपयोग और सीड्स के जरिए पुनरुत्पादकता संभव होती है।
• parallel_candidate_generation() फ़ंक्शन: फॉलबैक मोड में परफॉर्मेंस बनाए रखने के लिए, यह यूटिलिटी अलग-अलग सैंपलिंग तापमानों के साथ कई lm_studio_generate_single() कॉल्स को पैरेलल में फायर करती है और सभी रिस्पॉन्सेस को एकत्रित करती है। इससे, भले ही सच्ची मल्टी-सैंपलिंग उपलब्ध न हो, हमें जल्दी से व्यापक समाधान-विविधता मिलती है।

चरण 3.3: सर्वश्रेष्ठ ट्रैजेक्टरी

कई रीजनिंग पाथ जनरेट करने के बाद, हमें सबसे मजबूत समाधान की पहचान करने का एक संरचित तरीका चाहिए। यह चरण स्कोरिंग और चयन टूल्स पेश करता है, जो MetaStone Reflective Reasoning पेपर में बताए गए रिवॉर्ड मॉडलिंग (SPRM) तकनीकों की नकल करते हैं।

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_idxसंचालित द्वारा

हर फ़ंक्शन यह करता है:

• step_tokenize() फ़ंक्शन: यह किसी रीजनिंग ट्रैजेक्टरी को तार्किक चरणों या सेगमेंट्स में विभाजित करता है, जिससे चरण-दर-चरण विश्लेषण और स्कोरिंग संभव हो सके।
• dummy_sprm_score() फ़ंक्शन: यह प्रत्येक कैंडिडेट ट्रैजेक्टरी को एक रिवॉर्ड स्कोर असाइन करता है और बहु-चरणीय, सुव्यवस्थित और गणितीय रीजनिंग का उपयोग करने वाली प्रतिक्रियाओं को प्रोत्साहित करता है। यह पेपर के Shared Process Reward Model (SPRM) के लिए एक प्लेसहोल्डर की तरह काम करता है, जो आंतरिक रूप से अपने समाधान का मूल्यांकन करता है।
• नोट: यह स्कोरिंग फ़ंक्शन केवल मूल पेपर में वर्णित SPRM का अनुमान लगाता है। वास्तविक SPRM एक लर्न्ड रिवॉर्ड मॉडल है, जिसे बड़े डेटासेट्स पर प्रशिक्षित किया गया है ताकि चरण-स्तरीय फीडबैक दिया जा सके, और इसके लिए पर्याप्त संसाधन और स्वामित्व वाले डेटा की आवश्यकता होती है।
• best_of_n_selection() फ़ंक्शन: कैंडिडेट उत्तरों के एक बैच को देखते हुए, यह फ़ंक्शन सबसे ऊँचे SPRM स्कोर के आधार पर एकल सर्वश्रेष्ठ ट्रैजेक्टरी चुनता है—ठीक वैसे ही जैसे पेपर में रिफ्लेक्टिव मॉडल टेस्ट टाइम पर अपना सबसे मज़बूत उत्तर चुन लेता है।

चरण 4: मुख्य Streamlit एप्लिकेशन फ्लो

इस चरण में, हम सभी हिस्सों को जोड़कर Streamlit के साथ एक इंटरएक्टिव रीजनिंग डेमो बनाते हैं। 

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)संचालित द्वारा

मुख्य एप्लिकेशन फ्लो कई प्रमुख लक्ष्यों को पूरा करता है:

• साइडबार कॉन्फ़िगरेशन: साइडबार रीजनिंग प्रयास (अर्थात, प्रति क्वेरी सैंपल की गई ट्रैजेक्टरीज़ की संख्या) सेट करने के लिए डायनेमिक कंट्रोल्स देता है और उपयोगकर्ताओं को कस्टम गणित या लॉजिक समस्याएँ सबमिट करने देता है। प्रत्येक मोड (k=2, 8, 32) अलग-अलग टेस्ट-टाइम इन्फरेंस बजट से मेल खाता है, जिससे उपयोगकर्ता समाधान की गुणवत्ता पर स्केलिंग प्रभावों का विश्लेषण कर सकता है।
• एक्ज़िक्यूशन ट्रिगर: Run Reflective Reasoning बटन पाइपलाइन का एंट्री पॉइंट है, जो या तो इन-सर्वर मल्टी-सैंपल जनरेशन (n पैरामीटर) को ट्रिगर करता है, या बैकएंड द्वारा सपोर्ट न होने पर समांतर रिक्वेस्ट्स के जरिए सैंपलिंग करता है।
• प्रोग्रेस ट्रैकिंग: ट्रैजेक्टरीज़ जनरेट होते समय, एक प्रोग्रेस बार रियल-टाइम फ़ीडबैक देता है, जो Streamlit की स्टेटफुल रिएक्टिविटी का लाभ उठाता है।
• पोस्ट-प्रोसेसिंग और स्कोरिंग: पूर्ण होने पर, प्रत्येक ट्रैजेक्टरी को प्रॉक्सी रिवॉर्ड मॉडल (dummy_sprm_score) के माध्यम से इवैल्यूएट किया जाता है, जो Shared Process Reward Model (SPRM) की नकल करता है। 
• चयन और प्रदर्शन: रिवॉर्ड स्कोर (best_of_n_selection) के आधार पर सर्वश्रेष्ठ ट्रैजेक्टरी हाइलाइट की जाती है। सभी जनरेट हुए समाधानों को, उनके SPRM स्कोर और जेनरेशन लेटेंसी सहित, टेक्स्टुअल और ग्राफ़िकल—दोनों फ़ॉर्मैट में साइड-बाय-साइड विश्लेषण हेतु दिखाया जाता है।

खुद आज़माने के लिए, कोड को xbai_demo.py नाम से सेव करें और लॉन्च करें:

streamlit run xbai_demo.pyसंचालित द्वारा