라이브 데모

브라우저 내 대화형 데모 — 벤치마크 구조와 솔버 결과를 시각화하고, WebAssembly Python 으로 솔버를 라이브 실행하세요. 설치 없음, 서버 없음.

이 데모들은 전적으로 브라우저 안에서 실행됩니다. Visualize 탭은 공개-안전 미리보기 증거 — 솔버 리더보드, 애니메이션 수렴 및 탐색–활용 차트, 확장성, 시드-안정성, 강건성 분석 차트, 그리고 임의의 벤치마크 인스턴스의 구조적 특성화 — 를 차트로 그립니다. Run live 탭은 WebAssembly 샌드박스(Pyodide)에서 실제 Python 을 실행합니다: 솔버를 편집하고 아무것도 설치하지 않고 재실행하세요. Analyze 탭은 시드를 고정한 완전한 실험을 실행하고, 효과 크기와 부트스트랩 신뢰구간으로 두 솔버를 비교합니다 — 전체 toolkit이 적용하는 것과 동일한 증거 규율입니다.

여기 있는 모든 것은 설명적이고 공개-안전한 미리보기 자료입니다. 완전한 툴킷은 같은 종류의 벤치마킹, 솔빙, 분석을 연구 규모로 실행합니다 — 빠른 시작 으로 시작하거나 벤치마크 카탈로그를 둘러보세요.

Solver leaderboard

Best makespan per solver on the smoke benchmark set (lower is better). Bundled demo evidence — not a comparative ranking.

Convergence trajectory

How each iterative solver’s best-so-far objective improves over iterations — the anytime curve.

Per-iteration best-so-far objective for a native iterative cohort on a smoke instance (lower is better) — hover, or focus the chart and use the arrow keys, to read each solver’s incumbent. Public-safe preview from a real seeded run; the full platform traces convergence at research scale.

Exploration–exploitation balance

Population diversity over iterations — high while the search explores, falling as it exploits and converges.

Mean population diversity by iteration for the native population solver on a smoke instance — high while the search explores, falling as it exploits and converges. Hover, or focus the chart and use the arrow keys, to read the diversity. Public-safe preview from a real seeded run.

Scalability (size response)

Makespan across a doubling task-count ladder — how each solver scales as the problem grows.

Makespan across a doubling task-count ladder (16–96 tasks) for a dispatching baseline and a native metaheuristic on one Edge–Fog–Cloud family — reading the size response is the scalability curve a results section reports. Hover, or focus the chart and use the arrow keys, to read each solver’s makespan; the native search holds a slim edge that widens with size. Public-safe preview from real seeded solves.

Seed stability

Coefficient of variation across the seed set — how consistently each solver reaches its result.

Each solver’s seed coefficient of variation (makespan standard deviation over the seed set, divided by the mean) — lower is more stable. A deterministic solver reads zero. Hover or focus a bar to read it. Public-safe aggregate from a seed-replicated smoke campaign.

Robustness (tail risk)

CVaR of the worst per-problem makespan-ratio tail — ranking solvers by deployment-relevant risk, not the mean.

Each solver’s conditional value-at-risk (CVaR) of the worst tail of its makespan ratios (each run’s makespan over the problem’s best across the field) over the seed set — lower is more robust, ranking by deployment-relevant tail risk rather than the mean. Hover or focus a bar to read it. Public-safe aggregate from the same seed-replicated smoke campaign.

Benchmark characterization

Pick an instance to see its structural fingerprint.

Benchmark instance

heterogeneity

1.00

objective conflict

1.00

load skew

0.83

uncertainty

0.67

compatibility sparsity

0.67

opportunity density

0.50

solver sensitivity

0.45

dynamism

0.10

overload

0.04

contention

0.04

communication pressure

0.00

dependency depth

0.00

setup intensity

0.00

Each benchmark is characterized by quantitative metrics in [0, 1]. These structural features are what make the catalog construct-based rather than tag-based.

This runs real Python in your browser via WebAssembly (Pyodide) — no server, no install. It is a light illustrative solver; the full toolkit runs the same kinds of computation at research scale.

solver.py

# A self-contained scheduling scenario that mirrors the toolkit's
# benchmark -> solve -> analyze workflow: generate a heterogeneous instance,
# run three dispatching heuristics, and compare their makespans.
# Edit anything and re-run — it executes in your browser.
import random

random.seed(20260527)  # deterministic, like the toolkit's recorded seeds
n_tasks, n_machines = 9, 3

# Heterogeneous benchmark instance: task i has a different duration per machine.
exec_time = {
    (i, m): random.randint(2, 9)
    for i in range(n_tasks)
    for m in range(n_machines)
}

def makespan(order, pick):
    loads = [0] * n_machines
    for i in order:
        m = pick(i, loads)
        loads[m] += exec_time[(i, m)]
    return max(loads)

lpt = sorted(range(n_tasks), key=lambda i: -min(exec_time[(i, m)] for m in range(n_machines)))
least_loaded = lambda i, loads: min(range(n_machines), key=lambda m: loads[m] + exec_time[(i, m)])

solvers = {
    "min-load-greedy": (range(n_tasks), least_loaded),
    "LPT + min-load":  (lpt,            least_loaded),
    "fastest-machine": (range(n_tasks), lambda i, loads: min(range(n_machines), key=lambda m: exec_time[(i, m)])),
}

results = {name: makespan(order, pick) for name, (order, pick) in solvers.items()}
best = min(results, key=results.get)

print(f"Instance: {n_tasks} tasks x {n_machines} heterogeneous machines\n")
print(f"{'solver':18} makespan")
print("-" * 30)
for name, mk in sorted(results.items(), key=lambda kv: kv[1]):
    print(f"{name:18} {mk:>5}{'   <- best' if name == best else ''}")
print(f"\nBest here: {best}. Capability, not a universal claim — the full")
print("toolkit runs fair, seeded, statistically-compared campaigns.")

Output

Press Run to execute the solver in your browser.

A complete experiment-then-analysis scenario: it runs two solvers across many seeded instances and compares them the way the toolkit reports evidence — with a Cliff’s-delta effect size and a bootstrap confidence interval, never a bare p-value. Runs live in your browser; edit the budget or the solvers and re-run.

experiment.py

# A complete benchmark -> solve -> ANALYZE scenario, reported the way the
# toolkit reports evidence: run two dispatching heuristics across many seeded
# instances, then compare them with an effect size AND a bootstrap confidence
# interval — never a bare p-value. Edit anything and re-run; it runs in your browser.
import random, statistics

SEEDS = 40                    # independent seeded instances (a real run budget)
N_TASKS, N_MACHINES = 12, 3

def instance(seed):
    rng = random.Random(seed)
    return {(i, m): rng.randint(2, 9)
            for i in range(N_TASKS) for m in range(N_MACHINES)}

def makespan(et, order, pick):
    loads = [0] * N_MACHINES
    for i in order:
        m = pick(i, loads, et)
        loads[m] += et[(i, m)]
    return max(loads)

def least_loaded(i, loads, et):
    return min(range(N_MACHINES), key=lambda m: loads[m] + et[(i, m)])

def lpt_order(et):            # longest-processing-time first
    return sorted(range(N_TASKS),
                  key=lambda i: -min(et[(i, m)] for m in range(N_MACHINES)))

A, B = "LPT + min-load", "arrival-order + min-load"
a, b = [], []
for s in range(SEEDS):
    et = instance(20260000 + s)
    a.append(makespan(et, lpt_order(et), least_loaded))
    b.append(makespan(et, range(N_TASKS), least_loaded))

# Cliff's delta: (#(A>B) - #(A<B)) / (n*m). Negative => A tends to be smaller (better).
gt = sum(x > y for x in a for y in b)
lt = sum(x < y for x in a for y in b)
delta = (gt - lt) / (len(a) * len(b))
mag = next(lbl for thr, lbl in
           [(0.147, "negligible"), (0.33, "small"), (0.474, "medium"), (2.0, "large")]
           if abs(delta) < thr)

# Bootstrap 95% CI on the mean paired difference A - B (percentile method).
diffs = [x - y for x, y in zip(a, b)]
boot_rng = random.Random(7)
boot = sorted(statistics.fmean(boot_rng.choices(diffs, k=len(diffs)))
              for _ in range(2000))
lo, hi = boot[int(0.025 * len(boot))], boot[int(0.975 * len(boot)) - 1]

print(f"{SEEDS} seeded instances - {N_TASKS} tasks x {N_MACHINES} machines\n")
print(f"mean makespan  {A:24} {statistics.fmean(a):6.2f}")
print(f"mean makespan  {B:24} {statistics.fmean(b):6.2f}\n")
print(f"Cliff's delta (A vs B):  {delta:+.3f}  ({mag} effect)")
print(f"95% bootstrap CI of mean(A - B):  [{lo:+.2f}, {hi:+.2f}]")
credible = ("excludes 0 - the advantage is statistically credible"
            if (lo < 0) == (hi < 0) else "spans 0 - no credible difference")
print(f"  the interval {credible}.\n")
print("Reported with an effect size AND a confidence interval, never a bare")
print("p-value. The full platform adds Holm-corrected Wilcoxon / Friedman tests")
print("across the whole catalog.")

Output

Press Run to execute the solver in your browser.