Datasets:

ahkamboh
/

stepmold-bench

"""Serve each small model with vLLM on Kaggle's two T4s, run the stepmold bench, keep the results.
Runs top to bottom with no input, so it works as a "Save & Run All" commit. Each model's
results go to /kaggle/working/results/<label>.jsonl, appended and resumable, so a rerun only
does the case-runs that are missing.
"""

import hashlib
import json
import os
import signal
import subprocess
import sys
import tarfile
import time
import urllib.request

WORK = "/kaggle/working"
OUT = os.path.join(WORK, "results")
BENCH = os.path.join(WORK, "stepmold-bench")
STEPMOLD = os.path.join(WORK, "stepmold")  # a clone at 38235ab: pip installs leave out examples/
PORT = 8000

# One sampling setup for every model, so three runs of a case show how consistent it is.
# 0.7 and top_p 0.8 are Qwen's recommended non-thinking settings. Qwen3 runs with thinking
# off, the same way the stepmold GPU Space runs Qwen3 8B.
QWEN = {"temperature": 0.7, "top_p": 0.8}
NO_THINK = {"chat_template_kwargs": {"enable_thinking": False}}

MODELS = [
    # label, Hugging Face id, tensor-parallel size, request extras
    ("qwen2.5-0.5b-instruct", "Qwen/Qwen2.5-0.5B-Instruct", 1, QWEN),
    ("qwen2.5-1.5b-instruct", "Qwen/Qwen2.5-1.5B-Instruct", 1, QWEN),
    ("qwen3-4b", "Qwen/Qwen3-4B", 1, dict(QWEN, **NO_THINK)),
    ("qwen2.5-7b-instruct", "Qwen/Qwen2.5-7B-Instruct", 2, QWEN),
    ("qwen3-8b", "Qwen/Qwen3-8B", 2, dict(QWEN, **NO_THINK)),
]


def wait_ready(proc, timeout=1500):
    deadline = time.time() + timeout
    while time.time() < deadline:
        if proc.poll() is not None:
            raise RuntimeError("vLLM exited with code %s" % proc.returncode)
        try:
            with urllib.request.urlopen("http://localhost:%d/v1/models" % PORT, timeout=5) as reply:
                if reply.status == 200:
                    return
        except Exception:
            pass
        time.sleep(5)
    raise TimeoutError("vLLM did not come up within %ds" % timeout)


def serve(model, tp, log):
    cmd = [
        "vllm", "serve", model,
        "--dtype", "half",  # a T4 has no bf16
        "--tensor-parallel-size", str(tp),
        "--max-model-len", "4096",
        "--gpu-memory-utilization", "0.90",
        "--port", str(PORT),
    ]
    return subprocess.Popen(cmd, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)


def stop(proc):
    try:
        os.killpg(proc.pid, signal.SIGTERM)
        proc.wait(timeout=120)
    except subprocess.TimeoutExpired:
        os.killpg(proc.pid, signal.SIGKILL)
    except ProcessLookupError:
        pass
    time.sleep(15)  # let the GPUs release their memory before the next model loads


def run_model(label, model, tp, extra):
    started = time.time()
    with open(os.path.join(OUT, label + ".vllm.log"), "w") as log:
        proc = serve(model, tp, log)
        try:
            wait_ready(proc)
            print("%s: server ready in %.0fs" % (label, time.time() - started), flush=True)
            subprocess.run([
                sys.executable, os.path.join(BENCH, "bench.py"),
                "--stepmold", STEPMOLD,
                "--model", "openai:http://localhost:%d/v1#%s" % (PORT, model),
                "--label", label,
                "--arms", "stepmold,plain_schema,plain",
                "--runs", "3",
                "--packs", "all",
                "--concurrency", "16",
                "--extra-body", json.dumps(extra),
                "--out", os.path.join(OUT, label + ".jsonl"),
            ], check=False)
        except Exception as exc:
            print("%s: FAILED: %s" % (label, exc), flush=True)
        finally:
            stop(proc)
    print("%s: finished in %.0fs" % (label, time.time() - started), flush=True)


def main(only=None):
    os.makedirs(OUT, exist_ok=True)
    digest = hashlib.sha256(open(os.path.join(BENCH, "bench.py"), "rb").read()).hexdigest()[:12]
    print("bench.py sha256", digest, flush=True)
    for label, model, tp, extra in MODELS:
        if not only or label in only:
            run_model(label, model, tp, extra)
    with tarfile.open(os.path.join(WORK, "stepmold-bench-kaggle-results.tar.gz"), "w:gz") as tar:
        tar.add(OUT, arcname="results")
    print("packed", os.path.join(WORK, "stepmold-bench-kaggle-results.tar.gz"), flush=True)


if __name__ == "__main__":
    main(set(sys.argv[1:]) or None)

	"""Serve each small model with vLLM on Kaggle's two T4s, run the stepmold bench, keep the results.

	Runs top to bottom with no input, so it works as a "Save & Run All" commit. Each model's
	results go to /kaggle/working/results/<label>.jsonl, appended and resumable, so a rerun only
	does the case-runs that are missing.
	"""

	import hashlib
	import json
	import os
	import signal
	import subprocess
	import sys
	import tarfile
	import time
	import urllib.request

	WORK = "/kaggle/working"
	OUT = os.path.join(WORK, "results")
	BENCH = os.path.join(WORK, "stepmold-bench")
	STEPMOLD = os.path.join(WORK, "stepmold") # a clone at 38235ab: pip installs leave out examples/
	PORT = 8000

	# One sampling setup for every model, so three runs of a case show how consistent it is.
	# 0.7 and top_p 0.8 are Qwen's recommended non-thinking settings. Qwen3 runs with thinking
	# off, the same way the stepmold GPU Space runs Qwen3 8B.
	QWEN = {"temperature": 0.7, "top_p": 0.8}
	NO_THINK = {"chat_template_kwargs": {"enable_thinking": False}}

	MODELS = [
	# label, Hugging Face id, tensor-parallel size, request extras
	("qwen2.5-0.5b-instruct", "Qwen/Qwen2.5-0.5B-Instruct", 1, QWEN),
	("qwen2.5-1.5b-instruct", "Qwen/Qwen2.5-1.5B-Instruct", 1, QWEN),
	("qwen3-4b", "Qwen/Qwen3-4B", 1, dict(QWEN, **NO_THINK)),
	("qwen2.5-7b-instruct", "Qwen/Qwen2.5-7B-Instruct", 2, QWEN),
	("qwen3-8b", "Qwen/Qwen3-8B", 2, dict(QWEN, **NO_THINK)),
	]


	def wait_ready(proc, timeout=1500):
	deadline = time.time() + timeout
	while time.time() < deadline:
	if proc.poll() is not None:
	raise RuntimeError("vLLM exited with code %s" % proc.returncode)
	try:
	with urllib.request.urlopen("http://localhost:%d/v1/models" % PORT, timeout=5) as reply:
	if reply.status == 200:
	return
	except Exception:
	pass
	time.sleep(5)
	raise TimeoutError("vLLM did not come up within %ds" % timeout)


	def serve(model, tp, log):
	cmd = [
	"vllm", "serve", model,
	"--dtype", "half", # a T4 has no bf16
	"--tensor-parallel-size", str(tp),
	"--max-model-len", "4096",
	"--gpu-memory-utilization", "0.90",
	"--port", str(PORT),
	]
	return subprocess.Popen(cmd, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)


	def stop(proc):
	try:
	os.killpg(proc.pid, signal.SIGTERM)
	proc.wait(timeout=120)
	except subprocess.TimeoutExpired:
	os.killpg(proc.pid, signal.SIGKILL)
	except ProcessLookupError:
	pass
	time.sleep(15) # let the GPUs release their memory before the next model loads


	def run_model(label, model, tp, extra):
	started = time.time()
	with open(os.path.join(OUT, label + ".vllm.log"), "w") as log:
	proc = serve(model, tp, log)
	try:
	wait_ready(proc)
	print("%s: server ready in %.0fs" % (label, time.time() - started), flush=True)
	subprocess.run([
	sys.executable, os.path.join(BENCH, "bench.py"),
	"--stepmold", STEPMOLD,
	"--model", "openai:http://localhost:%d/v1#%s" % (PORT, model),
	"--label", label,
	"--arms", "stepmold,plain_schema,plain",
	"--runs", "3",
	"--packs", "all",
	"--concurrency", "16",
	"--extra-body", json.dumps(extra),
	"--out", os.path.join(OUT, label + ".jsonl"),
	], check=False)
	except Exception as exc:
	print("%s: FAILED: %s" % (label, exc), flush=True)
	finally:
	stop(proc)
	print("%s: finished in %.0fs" % (label, time.time() - started), flush=True)


	def main(only=None):
	os.makedirs(OUT, exist_ok=True)
	digest = hashlib.sha256(open(os.path.join(BENCH, "bench.py"), "rb").read()).hexdigest()[:12]
	print("bench.py sha256", digest, flush=True)
	for label, model, tp, extra in MODELS:
	if not only or label in only:
	run_model(label, model, tp, extra)
	with tarfile.open(os.path.join(WORK, "stepmold-bench-kaggle-results.tar.gz"), "w:gz") as tar:
	tar.add(OUT, arcname="results")
	print("packed", os.path.join(WORK, "stepmold-bench-kaggle-results.tar.gz"), flush=True)


	if __name__ == "__main__":
	main(set(sys.argv[1:]) or None)