""" Optimization Operating System — Interactive Optimization Console Unified platform for scheduling, routing, assignment, inventory, facility location, and packing. """ from __future__ import annotations import json import sys from pathlib import Path import gradio as gr import pandas as pd import plotly.graph_objects as go ROOT = Path(__file__).resolve().parent sys.path.insert(0, str(ROOT / "src")) from optos.constants import PROBLEM_TYPES, SIZE_PRESETS, SOLVERS # noqa: E402 from optos.pipeline import OptOSPipeline # noqa: E402 from optos.visualization import ( # noqa: E402 build_category_radar, build_gap_timeline, build_heatmap, build_progress_chart, build_scalability_chart, build_solver_comparison_chart, ) pipeline = OptOSPipeline(ROOT / "assets") pipeline.load() SUMMARY = pipeline.summary PROBLEM_CHOICES = pipeline.problem_choices() SIZE_CHOICES = pipeline.size_choices() CUSTOM_CSS = """ .gradio-container { max-width: 1560px !important; } .markdown h1 { color: #4f46e5; font-weight: 700; } .tab-nav button { font-weight: 600; } """ _state: dict = {"last_run": None, "last_explanation": None, "last_scenarios": None} def _kpi_md() -> str: return f""" ### Optimization Operating System — Platform Overview | Metric | Value | |--------|-------| | Engine version | **v{pipeline.version}** | | Problem types | **{SUMMARY.get('problem_types', 6)}** (Scheduling, Routing, Assignment, Inventory, Facility, Packing) | | Methods per problem | **4** (Baseline · Exact · Scalable · Robust) | | Registered solvers | **{SUMMARY.get('solvers', 6)}** (HiGHS, CBC, CP-SAT, SCIP*, Gurobi*, Heuristic) | | Benchmark runs | **{SUMMARY.get('total_benchmark_runs', 0)}** pre-computed | | Instance sizes | Small · Medium · Large · Dynamic · Stochastic | *Reference profiles — live solving uses open-source solvers on HF Spaces.* """ def _benchmark_df() -> pd.DataFrame: rows = pipeline.benchmark_table_rows() if not rows: return pd.DataFrame() cols = [ "problem_label", "size", "method_label", "method_category", "objective_value", "optimality_gap", "elapsed_time_sec", "iterations", "feasible", "winner", ] return pd.DataFrame(rows)[[c for c in cols if c in rows[0]]] def _run_optimization(problem_type, size, seed, time_limit): run = pipeline.run_experiment(problem_type, size, int(seed), float(time_limit)) _state["last_run"] = run explanation = pipeline.explain_run(run) _state["last_explanation"] = explanation rows = [] for r in run.results: rows.append({ "Method": r.method_label, "Category": r.method_category, "Solver": r.solver_id, "Objective": r.metrics.objective_value, "Best Bound": r.metrics.best_bound, "Gap (%)": r.metrics.optimality_gap, "Time (s)": r.metrics.elapsed_time_sec, "Iterations": r.metrics.iterations, "Violations": r.metrics.constraint_violations, "Feasible": r.metrics.feasible, "Status": r.metrics.status, "Winner": r.method_id == run.winner, }) df = pd.DataFrame(rows) winner_label = next((r.method_label for r in run.results if r.method_id == run.winner), run.winner) summary_md = f""" **Winner:** {winner_label} · **Gap vs others:** {run.winner_gap_pct:.1f}% · **Runtime:** {run.runtime_sec:.2f}s | Solve State | Value | |-------------|-------| | Best feasible objective | **{min(r.metrics.objective_value for r in run.results if r.metrics.feasible):.2f}** | | Best bound | **{max(r.metrics.best_bound for r in run.results):.2f}** | | Min gap | **{min(r.metrics.optimality_gap for r in run.results if r.metrics.feasible):.2f}%** | """ chart_rows = [ { "method_label": r.method_label, "method_id": r.method_id, "method_category": r.method_category, "objective_value": r.metrics.objective_value, "optimality_gap": r.metrics.optimality_gap, "elapsed_time_sec": r.metrics.elapsed_time_sec, "winner": r.method_id == run.winner, } for r in run.results ] fig_cmp = build_solver_comparison_chart(chart_rows) fig_gap = build_gap_timeline(chart_rows) winner_r = next((r for r in run.results if r.method_id == run.winner), run.results[0]) fig_prog = build_progress_chart(winner_r.metrics.to_dict()) return df, summary_md, fig_cmp, fig_gap, fig_prog def _run_scenarios(problem_type, size, seed): scenarios = pipeline.run_scenarios(problem_type, size, int(seed)) _state["last_scenarios"] = scenarios rows = [] for s in scenarios: rows.append({ "Scenario": s.scenario_label, "Type": s.scenario_type, "Baseline Obj": s.baseline_objective, "Perturbed Obj": s.perturbed_objective, "Delta (%)": s.delta_pct, "Feasible": s.feasible, "Binding": ", ".join(s.binding_constraints), }) return pd.DataFrame(rows) def _explain_current(): exp = _state.get("last_run") expl = _state.get("last_explanation") if not exp or not expl: return "Run an optimization first.", pd.DataFrame() binding_df = pd.DataFrame(expl.binding_constraints) shadows_df = pd.DataFrame(expl.shadow_prices) md = f""" ### Explanation Report **Infeasibility:** {expl.infeasibility_reason or "None — solution is feasible."} **What-if suggestions:** """ for s in expl.what_if_suggestions: md += f"- {s}\n" md += "\n**Counterfactuals:**\n" for c in expl.counterfactuals: md += f"- {c.get('action')}: expected objective ≈ {c.get('expected_objective', c.get('expected_impact', 'N/A'))}\n" return md, binding_df, shadows_df def _export_json(): run = _state.get("last_run") if not run: return "No run to export." return pipeline.export_json(run) def _export_csv(): run = _state.get("last_run") if not run: return pd.DataFrame() return pd.DataFrame(pipeline.export_csv_rows(run)) def _registry_md(): lines = ["### Model Registry\n| Problem | Category | Description |"] lines.append("|---------|----------|-------------|") for k, m in PROBLEM_TYPES.items(): lines.append(f"| {m['label']} | {m['category']} | {m['description']} |") lines.append("\n### Solver Registry\n| Solver | License | Available | Strengths |") lines.append("|--------|---------|-----------|-----------|") for sid, s in SOLVERS.items(): avail = "✓" if s["available"] else "ref" lines.append(f"| {s['label']} | {s['license']} | {avail} | {', '.join(s['strengths'])} |") return "\n".join(lines) def _methods_table(problem_type): info = pipeline.method_info(problem_type) return pd.DataFrame(info) with gr.Blocks(title="Optimization Operating System", css=CUSTOM_CSS) as demo: gr.Markdown("# Optimization Operating System") gr.Markdown("Unified **Optimization-as-a-Service** platform — receive, solve, compare, and explain optimization problems across scheduling, routing, assignment, inventory, facility location, and packing.") with gr.Tab("Executive Overview"): gr.Markdown(_kpi_md()) gr.Dataframe(value=_benchmark_df(), label="Pre-computed Benchmark Summary", interactive=False) fig_heat = build_heatmap(pipeline.comparisons) gr.Plot(fig_heat, label="Cross-Problem Benchmark Heatmap") fig_scale = build_scalability_chart(pipeline.scalability.get("rows", [])) gr.Plot(fig_scale, label="Scalability Profile") with gr.Tab("Run Optimization"): with gr.Row(): problem_dd = gr.Dropdown(PROBLEM_CHOICES, value="scheduling", label="Problem Type") size_dd = gr.Dropdown(SIZE_CHOICES, value="medium", label="Instance Size") seed_num = gr.Number(value=42, label="Seed", precision=0) time_limit = gr.Slider(5, 60, value=15, step=1, label="Time Limit (s)") run_btn = gr.Button("Run All Methods", variant="primary") run_summary = gr.Markdown() run_table = gr.DataFrame(label="Method Comparison", interactive=False) with gr.Row(): cmp_plot = gr.Plot(label="Objective Comparison") gap_plot = gr.Plot(label="Gap vs Time") prog_plot = gr.Plot(label="Solve Progress") methods_preview = gr.DataFrame(label="Registered Methods", value=_methods_table("scheduling")) problem_dd.change(fn=_methods_table, inputs=problem_dd, outputs=methods_preview) run_btn.click( fn=_run_optimization, inputs=[problem_dd, size_dd, seed_num, time_limit], outputs=[run_table, run_summary, cmp_plot, gap_plot, prog_plot], ) with gr.Tab("Scenario Engine"): gr.Markdown("Stress-test instances with capacity changes, demand shifts, resource removal, cost increases, and network disruptions.") with gr.Row(): sc_problem = gr.Dropdown(PROBLEM_CHOICES, value="routing", label="Problem Type") sc_size = gr.Dropdown(SIZE_CHOICES, value="medium", label="Size") sc_seed = gr.Number(value=42, label="Seed", precision=0) sc_btn = gr.Button("Run All Scenarios", variant="primary") sc_table = gr.DataFrame(label="Scenario Results", interactive=False) sc_btn.click(fn=_run_scenarios, inputs=[sc_problem, sc_size, sc_seed], outputs=sc_table) with gr.Tab("Explanation Engine"): gr.Markdown("Binding constraints, shadow prices, infeasibility analysis, and what-if suggestions.") explain_btn = gr.Button("Explain Last Run", variant="primary") explain_md = gr.Markdown() with gr.Row(): binding_df = gr.DataFrame(label="Binding Constraints", interactive=False) shadow_df = gr.DataFrame(label="Shadow Prices", interactive=False) explain_btn.click(fn=_explain_current, outputs=[explain_md, binding_df, shadow_df]) with gr.Tab("Benchmarks"): gr.Dataframe(value=_benchmark_df(), label="Full Benchmark Table", interactive=False) fig_radar = build_category_radar(pipeline.benchmark_table_rows()) gr.Plot(fig_radar, label="Method Category Radar") fig_scale2 = build_scalability_chart(pipeline.scalability.get("rows", [])) gr.Plot(fig_scale2, label="Scalability") with gr.Tab("Registry"): gr.Markdown(_registry_md()) with gr.Tab("Export"): gr.Markdown("Download results from the last optimization run as JSON or CSV.") export_json_btn = gr.Button("Preview JSON Export") export_json_out = gr.Code(language="json", label="JSON Result") export_csv_btn = gr.Button("Preview CSV Export") export_csv_out = gr.DataFrame(label="CSV Rows") export_json_btn.click(fn=_export_json, outputs=export_json_out) export_csv_btn.click(fn=_export_csv, outputs=export_csv_out) if __name__ == "__main__": demo.launch()