-
📏 Mean Prompt Tokens
-
{prompt_tokens}
+
+
+ 📏 Mean Prompt Tokens
+ {prompt_tokens}
+
+
💡 Average input length per request (research-based for {use_case.replace('_', ' ')})
-
-
📏 Mean Output Tokens
-
{output_tokens}
+
+
+ 📏 Mean Output Tokens
+ {output_tokens}
+
+
💡 Average output length generated per request
-
-
📈 Peak Multiplier
-
{peak_mult}x
+
+
+ 📈 Peak Multiplier
+ {peak_mult}x
+
+
💡 Capacity buffer for traffic spikes (user behavior patterns)
""", unsafe_allow_html=True)
# 5. Informational messages from research data
workload_messages = get_workload_insights(use_case, new_qps, user_count)
-
+
for icon, color, text, severity in workload_messages[:3]: # Limit to 3 for space
bg_color = "rgba(245, 87, 108, 0.1)" if severity == "error" else \
"rgba(251, 191, 36, 0.1)" if severity == "warning" else \
@@ -4086,66 +4424,67 @@ def render_slo_cards(use_case: str, user_count: int, priority: str = "balanced",
with col3:
# Task Datasets - show which benchmarks are used for this use case
+ # Each entry: (name, weight, color, tooltip_description)
TASK_DATASETS = {
"chatbot_conversational": [
- ("MMLU-Pro", 30, "#38ef7d"),
- ("IFBench", 30, "#4facfe"),
- ("HLE", 20, "#a855f7"),
- ("Intelligence Index", 15, "#f59e0b"),
- ("GPQA", 5, "#667eea"),
+ ("MMLU-Pro", 30, "#38ef7d", "General knowledge critical for conversations (12,032 questions)"),
+ ("IFBench", 30, "#4facfe", "Instruction following CRITICAL for chat behavior (294 questions)"),
+ ("HLE", 20, "#a855f7", "Reasoning capabilities (Humanity's Last Exam - 2,684 questions)"),
+ ("Intelligence Index", 15, "#f59e0b", "Overall intelligence composite score"),
+ ("GPQA", 5, "#667eea", "Scientific reasoning - less needed for general chat (198 questions)"),
],
"code_completion": [
- ("LiveCodeBench", 35, "#38ef7d"),
- ("SciCode", 30, "#4facfe"),
- ("Coding Index", 20, "#a855f7"),
- ("Terminal-Bench", 10, "#f59e0b"),
- ("IFBench", 5, "#667eea"),
+ ("LiveCodeBench", 35, "#38ef7d", "Primary code generation benchmark (315 questions)"),
+ ("SciCode", 30, "#4facfe", "Scientific code understanding (338 subproblems)"),
+ ("Coding Index", 20, "#a855f7", "Overall coding ability composite score"),
+ ("Terminal-Bench", 10, "#f59e0b", "Agentic workflows for terminal commands (47 tasks)"),
+ ("IFBench", 5, "#667eea", "Follow code patterns and conventions"),
],
"code_generation_detailed": [
- ("LiveCodeBench", 30, "#38ef7d"),
- ("SciCode", 25, "#4facfe"),
- ("IFBench", 20, "#a855f7"),
- ("Coding Index", 15, "#f59e0b"),
- ("HLE", 10, "#667eea"),
+ ("LiveCodeBench", 30, "#38ef7d", "Code generation benchmark (315 questions)"),
+ ("SciCode", 25, "#4facfe", "Scientific code generation (338 subproblems)"),
+ ("IFBench", 20, "#a855f7", "Instruction following for generating explanations"),
+ ("Coding Index", 15, "#f59e0b", "Overall coding ability composite"),
+ ("HLE", 10, "#667eea", "Reasoning for code explanations"),
],
"translation": [
- ("IFBench", 35, "#38ef7d"),
- ("MMLU-Pro", 30, "#4facfe"),
- ("HLE", 20, "#a855f7"),
- ("Intelligence Index", 15, "#f59e0b"),
+ ("IFBench", 35, "#38ef7d", "Instruction following CRITICAL for accurate translation"),
+ ("MMLU-Pro", 30, "#4facfe", "Language understanding and knowledge"),
+ ("HLE", 20, "#a855f7", "Reasoning capabilities"),
+ ("Intelligence Index", 15, "#f59e0b", "Overall intelligence"),
],
"content_generation": [
- ("MMLU-Pro", 30, "#38ef7d"),
- ("HLE", 25, "#4facfe"),
- ("IFBench", 25, "#a855f7"),
- ("Intelligence Index", 20, "#f59e0b"),
+ ("MMLU-Pro", 30, "#38ef7d", "General knowledge - facts to include in content"),
+ ("HLE", 25, "#4facfe", "Reasoning for coherent content"),
+ ("IFBench", 25, "#a855f7", "Instruction following for creative tasks"),
+ ("Intelligence Index", 20, "#f59e0b", "Overall intelligence"),
],
"summarization_short": [
- ("HLE", 30, "#38ef7d"),
- ("MMLU-Pro", 25, "#4facfe"),
- ("IFBench", 25, "#a855f7"),
- ("Intelligence Index", 20, "#f59e0b"),
+ ("HLE", 30, "#38ef7d", "Reasoning CRITICAL for identifying key points"),
+ ("MMLU-Pro", 25, "#4facfe", "Understanding content to summarize"),
+ ("IFBench", 25, "#a855f7", "Instruction following for summary format"),
+ ("Intelligence Index", 20, "#f59e0b", "Overall intelligence"),
],
"document_analysis_rag": [
- ("AA-LCR", 40, "#38ef7d"),
- ("MMLU-Pro", 20, "#4facfe"),
- ("HLE", 20, "#a855f7"),
- ("IFBench", 10, "#f59e0b"),
- ("τ²-Bench", 10, "#667eea"),
+ ("AA-LCR", 40, "#38ef7d", "Long Context Reasoning - CRITICAL for RAG (100 questions)"),
+ ("MMLU-Pro", 20, "#4facfe", "Knowledge retrieval from context"),
+ ("HLE", 20, "#a855f7", "Reasoning over retrieved content"),
+ ("IFBench", 10, "#f59e0b", "Instruction following for queries"),
+ ("τ²-Bench", 10, "#667eea", "Agentic workflows for complex queries (114 tasks)"),
],
"long_document_summarization": [
- ("AA-LCR", 45, "#38ef7d"),
- ("MMLU-Pro", 20, "#4facfe"),
- ("HLE", 20, "#a855f7"),
- ("IFBench", 15, "#f59e0b"),
+ ("AA-LCR", 45, "#38ef7d", "Long Context Reasoning - CRITICAL for 50+ page docs"),
+ ("MMLU-Pro", 20, "#4facfe", "Understanding document content"),
+ ("HLE", 20, "#a855f7", "Reasoning for key point extraction"),
+ ("IFBench", 15, "#f59e0b", "Instruction following for summary format"),
],
"research_legal_analysis": [
- ("AA-LCR", 40, "#38ef7d"),
- ("MMLU-Pro", 25, "#4facfe"),
- ("HLE", 15, "#a855f7"),
- ("GPQA", 10, "#f59e0b"),
- ("IFBench", 5, "#667eea"),
- ("τ²-Bench", 5, "#f5576c"),
+ ("AA-LCR", 40, "#38ef7d", "Long Context Reasoning - CRITICAL for 16K-128K token docs"),
+ ("MMLU-Pro", 25, "#4facfe", "Knowledge - CRITICAL for domain expertise"),
+ ("HLE", 15, "#a855f7", "Reasoning for analysis"),
+ ("GPQA", 10, "#f59e0b", "Scientific reasoning for research papers"),
+ ("IFBench", 5, "#667eea", "Instruction following"),
+ ("τ²-Bench", 5, "#f5576c", "Agentic workflows for complex analysis"),
],
}
@@ -4160,172 +4499,133 @@ def render_slo_cards(use_case: str, user_count: int, priority: str = "balanced",
""", unsafe_allow_html=True)
- # Display datasets with weights - build HTML as single string
- datasets_items = []
- for name, weight, color in datasets:
- datasets_items.append(f'
{name}{weight}%
')
-
- datasets_html = "".join(datasets_items)
- full_html = f'
{datasets_html}
📖 Weights from Artificial Analysis Intelligence Index methodology
'
- st.markdown(full_html, unsafe_allow_html=True)
+ # Display datasets with weights - show description inline
+ datasets_html = '
'
+ for item in datasets:
+ name, weight, color = item[0], item[1], item[2]
+ tooltip = item[3] if len(item) > 3 else ""
+ datasets_html += f'''
+
+ {name}
+ {weight}%
+
+
💡 {tooltip}
+
'''
+ datasets_html += '
'
+ datasets_html += '
📖 Weights from Artificial Analysis Intelligence Index
'
+ st.markdown(datasets_html, unsafe_allow_html=True)
with col4:
- # Technical Spec (Optional Fields) - same style as other cards
+ # Priority Settings card - shows detected priority and hardware
st.markdown("""
""", unsafe_allow_html=True)
-
- # Build items based on what user mentioned
+
+ # Build items - always show priority
items = []
-
- # Priority - only show if not balanced
- if priority and priority != "balanced":
- priority_display = priority.replace('_', ' ').title()
- priority_color = {
- "low_latency": "#667eea",
- "cost_saving": "#f5576c",
- "high_quality": "#38ef7d",
- "high_throughput": "#4facfe"
- }.get(priority, "#9ca3af")
- priority_icon = {
- "low_latency": "⚡",
- "cost_saving": "💰",
- "high_quality": "⭐",
- "high_throughput": "📈"
- }.get(priority, "🎯")
- items.append((priority_icon, "Priority", priority_display, priority_color))
-
+
+ # Always show priority (including balanced)
+ priority_display = priority.replace('_', ' ').title() if priority else "Balanced"
+ priority_color = {
+ "low_latency": "#667eea",
+ "cost_saving": "#f5576c",
+ "high_accuracy": "#38ef7d",
+ "high_throughput": "#4facfe",
+ "balanced": "#D4AF37"
+ }.get(priority, "#D4AF37")
+ priority_icon = {
+ "low_latency": "⚡",
+ "cost_saving": "💰",
+ "high_accuracy": "⭐",
+ "high_throughput": "📈",
+ "balanced": "⚖️"
+ }.get(priority, "⚖️")
+ items.append((priority_icon, "Priority", priority_display, priority_color))
+
# Hardware - only show if user explicitly mentioned it
if hardware and hardware not in ["Any GPU", "Any", None, ""]:
items.append(("🖥️", "Hardware", hardware, "#38ef7d"))
-
+
# Build content HTML
- if items:
- items_html = "".join([
- f'
{icon} {label}{value}
'
- for icon, label, value, color in items
- ])
- else:
- items_html = '
Default settings applied
'
-
+ items_html = "".join([
+ f'
{icon} {label}{value}
'
+ for icon, label, value, color in items
+ ])
+
full_html = f'
{items_html}
'
st.markdown(full_html, unsafe_allow_html=True)
+# =============================================================================
+# WINNER DETAILS DIALOG
+# =============================================================================
+
+@st.dialog("🏆 Winner Details", width="large")
+def show_winner_details_dialog():
+ """Show winner details in a modal dialog."""
+ winner = st.session_state.get('balanced_winner') or st.session_state.get('winner_recommendation')
+ priority = st.session_state.get('winner_priority', 'balanced')
+ extraction = st.session_state.get('winner_extraction', {})
+
+ if not winner:
+ st.warning("No winner data available.")
+ return
+
+ # Render the winner details
+ _render_winner_details(winner, priority, extraction)
+
+ # Close button
+ if st.button("Close", key="close_dialog_btn", use_container_width=True):
+ st.session_state.show_winner_dialog = False
+ st.rerun()
+
+
# =============================================================================
# MAIN APP
# =============================================================================
def main():
+ # Show winner details dialog ONLY if explicitly triggered AND we have winner data
+ if st.session_state.show_winner_dialog is True and st.session_state.balanced_winner is not None:
+ show_winner_details_dialog()
+
# Load models
if st.session_state.models_df is None:
st.session_state.models_df = load_206_models()
models_df = st.session_state.models_df
- models_count = 206 # Always show 206 from our Artificial Analysis catalog
- # Sidebar
- with st.sidebar:
- st.markdown("## ⚙️ Configuration")
-
- priority = st.selectbox(
- "🎯 Optimization Priority",
- ["balanced", "low_latency", "cost_saving", "high_quality", "high_throughput"],
- format_func=lambda x: {
- "balanced": "⚖️ Balanced",
- "low_latency": "⚡ Low Latency",
- "cost_saving": "💰 Cost Saving",
- "high_quality": "⭐ High Quality",
- "high_throughput": "📈 High Throughput"
- }.get(x, x)
- )
-
- # Weight Profile Section
- st.markdown('', unsafe_allow_html=True)
-
- # Model Database Section
- st.markdown('', unsafe_allow_html=True)
-
- # Extractor Section
- st.markdown('', unsafe_allow_html=True)
+ # Default priority - will be extracted from user's natural language input
+ priority = "balanced"
- # Main Content
+ # Main Content - Compact hero and straight to recommendation
render_hero()
- render_stats(models_count)
-
- # Tabs
- tab1, tab2, tab3 = st.tabs(["🎯 Get Recommendation", "📦 Model Catalog", "📖 How It Works"])
- with tab1:
- render_recommendation_tab(priority, models_df)
+ # Main recommendation interface (no tabs for simplicity)
+ render_recommendation_tab(priority, models_df)
- with tab2:
- render_catalog_tab(models_df)
+ # Separator before About section
+ st.markdown("---")
- with tab3:
- render_how_it_works_tab()
+ # About Section at the bottom
+ render_about_section(models_df)
def render_recommendation_tab(priority: str, models_df: pd.DataFrame):
"""Main recommendation interface with clean task buttons."""
- st.markdown('', unsafe_allow_html=True)
+ st.markdown('', unsafe_allow_html=True)
# Row 1: 5 task buttons
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
if st.button("💬 Chat Completion", use_container_width=True, key="task_chat"):
- st.session_state.user_input = "Customer service chatbot for 5000 users. Latency is critical - responses under 200ms. Using H100 GPUs."
+ st.session_state.user_input = "Customer service chatbot for 5000 users. Latency is critical. Using H100 GPUs."
with col2:
if st.button("💻 Code Completion", use_container_width=True, key="task_code"):
@@ -4478,7 +4778,7 @@ def render_recommendation_tab(priority: str, models_df: pd.DataFrame):
def render_extraction_result(extraction: dict, priority: str):
"""Render beautiful extraction results."""
- st.markdown('', unsafe_allow_html=True)
+ st.markdown('', unsafe_allow_html=True)
use_case = extraction.get("use_case", "unknown")
user_count = extraction.get("user_count", 0)
@@ -4522,7 +4822,7 @@ def render_extraction_result(extraction: dict, priority: str):
def render_extraction_with_approval(extraction: dict, priority: str, models_df: pd.DataFrame):
"""Render extraction results with YES/NO approval buttons."""
- st.markdown('', unsafe_allow_html=True)
+ st.markdown('', unsafe_allow_html=True)
use_case = extraction.get("use_case", "unknown")
user_count = extraction.get("user_count", 0)
@@ -4674,12 +4974,12 @@ def render_extraction_edit_form(extraction: dict, models_df: pd.DataFrame):
)
with col2:
- priorities = ["balanced", "low_latency", "cost_saving", "high_quality", "high_throughput"]
+ priorities = ["balanced", "low_latency", "cost_saving", "high_accuracy", "high_throughput"]
priority_labels = {
"balanced": "⚖️ Balanced",
"low_latency": "⚡ Low Latency",
"cost_saving": "💰 Cost Saving",
- "high_quality": "⭐ High Quality",
+ "high_accuracy": "⭐ High Accuracy",
"high_throughput": "📈 High Throughput"
}
current_priority = extraction.get("priority", "balanced")
@@ -4729,7 +5029,7 @@ def render_slo_with_approval(extraction: dict, priority: str, models_df: pd.Data
use_case = extraction.get("use_case", "chatbot_conversational")
user_count = extraction.get("user_count", 1000)
hardware = extraction.get("hardware")
-
+
# SLO and Impact Cards - all 4 cards in one row
render_slo_cards(use_case, user_count, priority, hardware)
@@ -4744,7 +5044,7 @@ def render_slo_with_approval(extraction: dict, priority: str, models_df: pd.Data
def render_recommendation_result(result: dict, priority: str, extraction: dict):
"""Render beautiful recommendation results with Top 5 table."""
-
+
# Get SLO targets from result
slo_targets = result.get("slo_targets", {})
@@ -4757,12 +5057,12 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
token_config = slo_targets.get("token_config", {"prompt": 512, "output": 256})
prompt_tokens = token_config.get("prompt", 512)
output_tokens = token_config.get("output", 256)
-
+
# Get SLO target values (use max as the target)
ttft_target = slo_targets.get("ttft_target", {}).get("max", 200)
itl_target = slo_targets.get("itl_target", {}).get("max", 50)
e2e_target = slo_targets.get("e2e_target", {}).get("max", 5000)
-
+
# Calculate expected QPS from user count (rough estimate: ~1 query per 100 users per second)
expected_qps = max(1.0, user_count / 100.0)
@@ -4775,6 +5075,29 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
}
include_near_miss = st.session_state.include_near_miss
+ # ✅ OPTION A: 25 Variants with REAL BLIS Performance + AA Quality Data
+ # Using base model names for flexible matching (handles different naming formats)
+ VALID_MODEL_KEYWORDS = {
+ # GPT-OSS (61.62%, 55.23%)
+ "gpt-oss-120b", "gpt-oss-20b", "gpt oss 120b", "gpt oss 20b",
+ # Llama 4 Maverick (46.86%)
+ "llama-4-maverick", "llama 4 maverick",
+ # Qwen 2.5 7B (44.71%)
+ "qwen2.5-7b", "qwen 2.5 7b",
+ # Llama 3.3 70B (42.99%)
+ "llama-3.3-70b", "llama 3.3 70b",
+ # Llama 4 Scout (42.42%)
+ "llama-4-scout", "llama 4 scout",
+ # Mistral Small 3.1 (35.70%)
+ "mistral-small-3.1", "mistral small 3.1",
+ # Phi-4 (35.57%)
+ "phi-4", "phi 4",
+ # Mistral Small 24B (33.79%)
+ "mistral-small-24b", "mistral small 24b",
+ # Mixtral 8x7B (20.51%)
+ "mixtral-8x7b", "mixtral 8x7b",
+ }
+
# Fetch ranked recommendations from backend
with st.spinner("Fetching ranked recommendations from backend..."):
ranked_response = fetch_ranked_recommendations(
@@ -4791,26 +5114,276 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
include_near_miss=include_near_miss,
)
+ # Filter to only valid AA+BLIS models
if ranked_response:
+ for category in ["balanced", "best_accuracy", "lowest_cost", "lowest_latency", "simplest"]:
+ if category in ranked_response:
+ filtered = []
+ for rec in ranked_response[category]:
+ # Backend uses "model_name" not "model"
+ model_name = rec.get("model_name", rec.get("model", "")).lower().replace("-", " ").replace("_", " ")
+ # Check if model matches any valid keyword
+ if any(valid.replace("-", " ") in model_name for valid in VALID_MODEL_KEYWORDS):
+ filtered.append(rec)
+ ranked_response[category] = filtered
+
render_ranked_recommendations(ranked_response)
+
+ # Store ranked response for winner details
+ st.session_state.ranked_response = ranked_response
+
+ # Get the Balanced winner for the Explore button
+ balanced_recs = ranked_response.get("balanced", [])
+ if balanced_recs:
+ winner = balanced_recs[0]
+ recommendations = balanced_recs
+ else:
+ # Fallback to any available recommendations
+ for cat in ["best_accuracy", "lowest_cost", "lowest_latency", "simplest"]:
+ if ranked_response.get(cat):
+ winner = ranked_response[cat][0]
+ recommendations = ranked_response[cat]
+ break
+ else:
+ st.warning("No recommendations found.")
+ return
else:
st.warning("Could not fetch ranked recommendations from backend. Ensure the backend is running.")
-
+ st.session_state.ranked_response = None
+ recommendations = result.get("recommendations", [])
+ if not recommendations:
+ st.warning("No recommendations found. Try adjusting your requirements.")
+ return
+ winner = recommendations[0]
+
+ # Store winner for explore dialog
+ st.session_state.winner_recommendation = winner
+ st.session_state.winner_priority = priority
+ st.session_state.winner_extraction = extraction
+
+ # Render the 4 "Best" cards with Explore button
st.markdown("---")
- st.markdown('', unsafe_allow_html=True)
+ # Get all recommendations for the cards
+ all_recs = []
+ for cat in ["balanced", "best_accuracy", "lowest_cost", "lowest_latency", "simplest"]:
+ cat_recs = st.session_state.ranked_response.get(cat, []) if st.session_state.ranked_response else []
+ all_recs.extend(cat_recs)
+
+ # Remove duplicates by model+hardware
+ seen = set()
+ unique_recs = []
+ for rec in all_recs:
+ model = rec.get("model_name", "")
+ gpu_cfg = rec.get("gpu_config", {}) or {}
+ hw = f"{gpu_cfg.get('gpu_type', 'H100')}x{gpu_cfg.get('gpu_count', 1)}"
+ key = f"{model}_{hw}"
+ if key not in seen:
+ seen.add(key)
+ unique_recs.append(rec)
+
+ if unique_recs:
+ render_top5_table(unique_recs, priority)
+
+ # === MODIFY SLOs & RE-RUN SECTION ===
+ st.markdown("---")
+ st.markdown("""
+
+
+ 🔄
+ Want Different Results?
+
+
+ Adjust SLO targets above to find models with different latency/performance trade-offs.
+ Stricter SLOs = fewer models, Relaxed SLOs = more options.
+
+
+ """, unsafe_allow_html=True)
- recommendations = result.get("recommendations", [])
- if not recommendations:
- st.warning("No recommendations found. Try adjusting your requirements.")
- return
+ col1, col2, col3 = st.columns([1, 2, 1])
+ with col2:
+ if st.button("🔄 Modify SLOs & Re-run Recommendations", use_container_width=True, key="rerun_recs"):
+ # Reset slo_approved to go back to SLO editing
+ st.session_state.slo_approved = None
+ st.session_state.recommendation_result = None
+ st.rerun()
+
+
+def _render_winner_details(winner: dict, priority: str, extraction: dict):
+ """Render detailed winner information inside the expander."""
+
+ # Dark theme styling for popup dialog - including header
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
- # Render Top 5 Leaderboard Table
- render_top5_table(recommendations, priority)
+ # Handle both backend format (scores) and UI format (score_breakdown)
+ backend_scores = winner.get("scores", {}) or {}
+ ui_breakdown = winner.get("score_breakdown", {}) or {}
+ breakdown = {
+ "quality_score": backend_scores.get("accuracy_score", ui_breakdown.get("quality_score", 0)),
+ "latency_score": backend_scores.get("latency_score", ui_breakdown.get("latency_score", 0)),
+ "cost_score": backend_scores.get("price_score", ui_breakdown.get("cost_score", 0)),
+ "capacity_score": backend_scores.get("complexity_score", ui_breakdown.get("capacity_score", 0)),
+ }
+
+ # === 📋 FINAL RECOMMENDATION BOX (Schema-Aligned Clean Format) ===
+ st.markdown('', unsafe_allow_html=True)
+
+ # Extract data for clean display - handle both backend and UI formats
+ model_name = winner.get("model_name", "Unknown Model")
+
+ # Get hardware config - backend returns gpu_config object
+ gpu_config = winner.get("gpu_config", {}) or {}
+ hardware = gpu_config.get("gpu_type", winner.get("hardware", "H100"))
+ hw_count = gpu_config.get("gpu_count", winner.get("hardware_count", 1))
+ tp = gpu_config.get("tensor_parallel", 1)
+ replicas = gpu_config.get("replicas", 1)
+
+ # Get final score - backend uses balanced_score in scores
+ backend_scores = winner.get("scores", {}) or {}
+ final_score = backend_scores.get("balanced_score", winner.get("final_score", 0))
+ quality_score = breakdown.get("quality_score", 0)
+
+ # Get SLO data - backend returns predicted_* fields directly on winner
+ # Try backend format first (predicted_ttft_p95_ms), then blis_slo format
+ ttft_p95 = winner.get("predicted_ttft_p95_ms", 0)
+ itl_p95 = winner.get("predicted_itl_p95_ms", 0)
+ e2e_p95 = winner.get("predicted_e2e_p95_ms", 0)
+ throughput_qps = winner.get("predicted_throughput_qps", 0)
+
+ # Fallback to blis_slo if backend fields empty
+ if not ttft_p95:
+ blis_slo = winner.get("blis_slo", {})
+ slo_actual = blis_slo.get("slo_actual", {}) if blis_slo else {}
+ throughput_data = blis_slo.get("throughput", {}) if blis_slo else {}
+ ttft_p95 = slo_actual.get("ttft_p95_ms", slo_actual.get("ttft_mean_ms", 0))
+ itl_p95 = slo_actual.get("itl_p95_ms", slo_actual.get("itl_mean_ms", 0))
+ e2e_p95 = slo_actual.get("e2e_p95_ms", slo_actual.get("e2e_mean_ms", 0))
+ throughput_qps = throughput_data.get("tokens_per_sec", 0) / 100 if throughput_data.get("tokens_per_sec") else 0
+
+ # Format for display
+ ttft_display = f"{int(ttft_p95)}" if ttft_p95 and ttft_p95 > 0 else "—"
+ itl_display = f"{int(itl_p95)}" if itl_p95 and itl_p95 > 0 else "—"
+ e2e_display = f"{int(e2e_p95)}" if e2e_p95 and e2e_p95 > 0 else "—"
+ max_rps = f"{throughput_qps:.1f}" if throughput_qps and throughput_qps > 0 else "—"
+
+ # Schema-aligned recommendation box - Build HTML without comments
+ # All models now have BLIS data (filtered to valid models only)
+ blis_status = "✅
BLIS Verified - Real benchmark data"
+ priority_text = priority.replace('_', ' ').title()
+
+ # Build hardware display text
+ hw_display = f"{hw_count}x {hardware}"
+ if tp > 1 and replicas > 1:
+ hw_display += f" (TP={tp}, R={replicas})"
+
+ rec_html = f'''
+
+
🏆
+
+
RECOMMENDATION
+
Based on {priority_text} optimization
+
+
+
+
+
+
Model
+
{model_name}
+
Quality Score: {quality_score:.0f}%
+
+
+
Hardware Configuration
+
{hw_display}
+
+
+
+
⚡ Expected SLO (BLIS p95)
+
+
+ Max RPS
+ {max_rps}
+
+
+ TTFT (p95)
+ {ttft_display} ms
+
+
+ ITL (p95)
+ {itl_display} ms
+
+
+ E2E (p95)
+ {e2e_display} ms
+
+
+
+
+
+
✅ BLIS Verified - Real benchmark data
+
+ Final Score:
+ {final_score:.1f}
+
+
+
'''
- # Winner details
- winner = recommendations[0]
- breakdown = winner.get("score_breakdown", {})
+ st.markdown(rec_html, unsafe_allow_html=True)
st.markdown("---")
st.markdown('', unsafe_allow_html=True)
@@ -4828,10 +5401,32 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
with col1:
st.markdown(f'
🏆 {winner.get("model_name", "Unknown")}
', unsafe_allow_html=True)
- render_score_bar("Quality", "🎯", breakdown.get("quality_score", 0), "score-bar-quality", breakdown.get("quality_contribution", 0))
- render_score_bar("Latency", "⚡", breakdown.get("latency_score", 0), "score-bar-latency", breakdown.get("latency_contribution", 0))
- render_score_bar("Cost", "💰", breakdown.get("cost_score", 0), "score-bar-cost", breakdown.get("cost_contribution", 0))
- render_score_bar("Capacity", "📈", breakdown.get("capacity_score", 0), "score-bar-capacity", breakdown.get("capacity_contribution", 0))
+
+ # Get weights based on priority
+ priority_weights = {
+ "balanced": {"accuracy": 0.30, "latency": 0.30, "cost": 0.25, "capacity": 0.15},
+ "low_latency": {"accuracy": 0.15, "latency": 0.50, "cost": 0.15, "capacity": 0.20},
+ "cost_saving": {"accuracy": 0.20, "latency": 0.15, "cost": 0.50, "capacity": 0.15},
+ "high_accuracy": {"accuracy": 0.50, "latency": 0.20, "cost": 0.15, "capacity": 0.15},
+ "high_throughput": {"accuracy": 0.15, "latency": 0.15, "cost": 0.15, "capacity": 0.55},
+ }
+ weights = priority_weights.get(priority, priority_weights["balanced"])
+
+ # Calculate contributions
+ q_score = breakdown.get("quality_score", 0)
+ l_score = breakdown.get("latency_score", 0)
+ c_score = breakdown.get("cost_score", 0)
+ cap_score = breakdown.get("capacity_score", 0)
+
+ q_contrib = q_score * weights["accuracy"]
+ l_contrib = l_score * weights["latency"]
+ c_contrib = c_score * weights["cost"]
+ cap_contrib = cap_score * weights["capacity"]
+
+ render_score_bar("Accuracy", "🎯", q_score, "score-bar-accuracy", q_contrib)
+ render_score_bar("Latency", "⚡", l_score, "score-bar-latency", l_contrib)
+ render_score_bar("Cost", "💰", c_score, "score-bar-cost", c_contrib)
+ render_score_bar("Capacity", "📈", cap_score, "score-bar-capacity", cap_contrib)
with col2:
st.markdown('
🎯 Why This Model?
', unsafe_allow_html=True)
@@ -4909,9 +5504,30 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
Based on {priority.replace('_', ' ').title()} priority weighting
""", unsafe_allow_html=True)
- # Display BLIS SLO data if available (REAL benchmark data)
- blis_slo = winner.get("blis_slo")
- if blis_slo:
+ # Display BLIS SLO data - use backend fields or blis_slo
+ # Get predicted values from backend OR from blis_slo
+ blis_slo = winner.get("blis_slo", {}) or {}
+ gpu_config = winner.get("gpu_config", {}) or {}
+
+ # Get SLO values - prioritize backend's predicted_* fields, fallback to blis_slo
+ ttft_p95_val = winner.get("predicted_ttft_p95_ms") or blis_slo.get("slo_actual", {}).get("ttft_p95_ms", 0)
+ itl_p95_val = winner.get("predicted_itl_p95_ms") or blis_slo.get("slo_actual", {}).get("itl_p95_ms", 0)
+ e2e_p95_val = winner.get("predicted_e2e_p95_ms") or blis_slo.get("slo_actual", {}).get("e2e_p95_ms", 0)
+ throughput_qps_val = winner.get("predicted_throughput_qps") or (blis_slo.get("throughput", {}).get("tokens_per_sec", 0) / 100 if blis_slo.get("throughput", {}).get("tokens_per_sec") else 0)
+
+ # Get traffic profile from winner or result
+ traffic_profile = winner.get("traffic_profile", {}) or {}
+ prompt_tokens_val = traffic_profile.get("prompt_tokens", blis_slo.get("token_config", {}).get("prompt", 512))
+ output_tokens_val = traffic_profile.get("output_tokens", blis_slo.get("token_config", {}).get("output", 256))
+
+ # Get hardware info
+ hw_type_val = gpu_config.get("gpu_type", blis_slo.get("hardware", "H100"))
+ hw_count_val = gpu_config.get("gpu_count", blis_slo.get("hardware_count", 1))
+ tp_val = gpu_config.get("tensor_parallel", 1)
+ replicas_val = gpu_config.get("replicas", 1)
+
+ # Show BLIS benchmark box if we have any SLO data
+ if ttft_p95_val or itl_p95_val or e2e_p95_val:
st.markdown("---")
st.markdown("""
""", unsafe_allow_html=True)
- st.markdown("""
+ st.markdown(f"""
- 🔬 BLIS Benchmarks: These are real measured values from the BLIS simulator across 591 benchmark samples.
- Unlike research-backed targets, these represent actual achievable SLOs for this model/hardware configuration.
+ 🔬 BLIS Benchmarks: Real measured values from IBM BLIS vLLM simulation.
+ Hardware: {hw_count_val}x {hw_type_val} |
+ Token Config: {prompt_tokens_val}→{output_tokens_val}
""", unsafe_allow_html=True)
+ # Use the values we already extracted
slo_actual = blis_slo.get("slo_actual", {})
throughput = blis_slo.get("throughput", {})
token_config = blis_slo.get("token_config", {})
- hardware = blis_slo.get("hardware", "H100")
- hw_count = blis_slo.get("hardware_count", 1)
+ hardware = hw_type_val
+ hw_count = hw_count_val
col1, col2, col3 = st.columns(3)
+ # Use our extracted values with fallback to slo_actual
+ ttft_p95_show = ttft_p95_val or slo_actual.get('ttft_p95_ms', 0)
+ itl_p95_show = itl_p95_val or slo_actual.get('itl_p95_ms', 0)
+ e2e_p95_show = e2e_p95_val or slo_actual.get('e2e_p95_ms', 0)
+ tps_show = throughput_qps_val * 100 if throughput_qps_val else throughput.get('tokens_per_sec', 0)
+
with col1:
st.markdown(f"""
⏱️
- TTFT (Time to First Token)
+ TTFT
-
-
- Mean:
- {slo_actual.get('ttft_mean_ms', 'N/A')}ms
-
-
- P95:
- {slo_actual.get('ttft_p95_ms', 'N/A')}ms
-
-
- P99:
- {slo_actual.get('ttft_p99_ms', 'N/A')}ms
-
+
+
{int(ttft_p95_show) if ttft_p95_show else 'N/A'}ms
+
p95 latency
""", unsafe_allow_html=True)
@@ -4965,21 +5579,11 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
⚡
- ITL (Inter-Token Latency)
+ ITL
-
-
- Mean:
- {slo_actual.get('itl_mean_ms', 'N/A')}ms
-
-
- P95:
- {slo_actual.get('itl_p95_ms', 'N/A')}ms
-
-
- P99:
- {slo_actual.get('itl_p99_ms', 'N/A')}ms
-
+
+
{int(itl_p95_show) if itl_p95_show else 'N/A'}ms
+
inter-token latency
""", unsafe_allow_html=True)
@@ -4989,21 +5593,11 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
🏁
- E2E (End-to-End)
+ E2E
-
-
- Mean:
- {slo_actual.get('e2e_mean_ms', 'N/A')}ms
-
-
- P95:
- {slo_actual.get('e2e_p95_ms', 'N/A')}ms
-
-
- P99:
- {slo_actual.get('e2e_p99_ms', 'N/A')}ms
-
+
+
{int(e2e_p95_show) if e2e_p95_show else 'N/A'}ms
+
end-to-end
""", unsafe_allow_html=True)
@@ -5013,47 +5607,30 @@ def render_recommendation_result(result: dict, priority: str, extraction: dict):
🚀
-
Tokens/sec
-
{throughput.get('tokens_per_sec', 'N/A')}
+
Throughput
+
{int(tps_show) if tps_show else 'N/A'} tok/s
🖥️
Hardware
-
{hardware} x{hw_count}
+
{hw_count_val}x {hw_type_val}
📝
Token Config
-
{token_config.get('prompt', '?')} → {token_config.get('output', '?')}
+
{prompt_tokens_val} → {output_tokens_val}
- 📊 BLIS Samples: {blis_slo.get('benchmark_samples', 0)} benchmarks |
- Model: {blis_slo.get('model_repo', 'N/A').split('/')[-1]}
-
-
- """, unsafe_allow_html=True)
- else:
- # No BLIS data available for this model
- st.markdown("---")
- model_name = winner.get('model_name', 'Unknown')
- st.markdown(f"""
-
-
- ⚠️
- No BLIS Benchmark Data Available
-
-
- {model_name} is not in the BLIS benchmark dataset.
- The quality, latency, and cost scores above are derived from Artificial Analysis benchmarks and model characteristics.
-
-
- 📊 BLIS models available: Qwen2.5-7B, Llama-3.1-8B, Llama-3.3-70B, Phi-4, Mistral-Small-24B, Mixtral-8x7B, Granite-3.1-8B
+ 📊 Data Source: IBM BLIS vLLM Simulation |
+ Model: {winner.get('model_name', 'Unknown')}
""", unsafe_allow_html=True)
+ # All recommendations now come from valid models with both AA + BLIS data
+ # No need to show "No BLIS data" warning
def render_catalog_tab(models_df: pd.DataFrame):
@@ -5300,28 +5877,28 @@ def render_how_it_works_tab():