Download subq.py from perchscan/benchmark-results: direct link, hf CLI and curl.
- Browser
- Download file 9.95 kB
-
https://huggingface.co/datasets/perchscan/benchmark-results/resolve/main/subq.py
- Command line
-
hf download hf://datasets/perchscan/benchmark-results/subq.py
-
curl -L -o subq.py https://huggingface.co/datasets/perchscan/benchmark-results/resolve/main/subq.py
9.95 kB
| #!/usr/bin/env python3 | |
| """Benchmark SubQ Snap with native decisions and Perch context sizing. | |
| SubQ documents a 393,216-token window and at most 16 questions per request. | |
| Perch retains full saved context where it fits and batches the questions. | |
| Cost uses API-reported input tokens at the published $0.05 per million rate. | |
| """ | |
| from collections import Counter | |
| import hashlib | |
| import json | |
| import os | |
| from pathlib import Path | |
| import subprocess | |
| import sys | |
| import threading | |
| import time | |
| import httpx | |
| import openrouter_decisions as runner | |
| from gliner_decide import PerchSizer, SizeError | |
| MODEL = 'subq-snap-preview' | |
| CONTEXT_LIMIT = 393216 | |
| STATE_BUDGET = 360000 | |
| REQUEST_BUDGET = 380000 | |
| MAX_QUESTIONS = 16 | |
| _native_prediction = runner.prediction | |
| _native_report = runner.report | |
| _sizer = None | |
| _sizer_lock = threading.Lock() | |
| _source_revision = None | |
| def prediction(pair, role, domain, pack, response, elapsed, model): | |
| usage = response.get('usage') or {} | |
| tokens = usage.get('input_tokens') | |
| if isinstance(tokens, bool) or not isinstance(tokens, int) or tokens < 0: | |
| raise runner.AnswerError('Missing input-token usage', response, elapsed) | |
| response = dict(response, usage=dict(usage, cost=tokens * .05 / 1_000_000)) | |
| return _native_prediction(pair, role, domain, pack, response, elapsed, model) | |
| def sizer(): | |
| global _sizer, _source_revision | |
| with _sizer_lock: | |
| if _sizer is None: | |
| source = os.environ.get('PERCH_SOURCE') | |
| if not source: | |
| raise runner.AccountError('Set PERCH_SOURCE to a Perch checkout with npm dependencies installed') | |
| source = Path(source) | |
| _source_revision = subprocess.check_output(['git', '-C', str(source), 'rev-parse', 'HEAD'], text=True).strip() | |
| _sizer = PerchSizer(source, Path(os.environ.get('SUBQ_SIZING_CACHE', '.subq-sizing'))) | |
| return _sizer | |
| def request(key, state, checks, timeout, limiter): | |
| if not hasattr(runner._local, 'client'): | |
| runner._local.client = httpx.Client(headers={'Authorization': 'Bearer ' + key}) | |
| payload = {'model': MODEL, 'state': state, | |
| 'questions': {c['name']: c['question'] for c in checks}} | |
| for attempt in range(3): | |
| limiter.wait() | |
| response = runner._local.client.post(runner.API, json=payload, timeout=timeout) | |
| if response.status_code >= 400: | |
| try: | |
| detail = response.json().get('detail') or response.json().get('error') or {} | |
| message = detail.get('message', '') if isinstance(detail, dict) else str(detail) | |
| code = detail.get('error_type', response.status_code) if isinstance(detail, dict) else response.status_code | |
| except ValueError: | |
| code, message = response.status_code, '' | |
| error = f'SubQ HTTP {response.status_code}: {code}: {message}' | |
| if response.status_code in (401, 402, 403, 404): | |
| raise runner.AccountError(error) | |
| if response.status_code in (400, 413, 422) and any(text in message.lower() for text in ('maximum model length', 'context length', 'context window', 'too many tokens')): | |
| raise SizeError(error) | |
| if response.status_code == 429 and attempt < 2: | |
| try: | |
| delay = float(response.headers.get('retry-after', 2 ** (attempt + 1))) | |
| except ValueError: | |
| delay = 2 ** (attempt + 1) | |
| time.sleep(min(30, max(1, delay))) | |
| continue | |
| raise RuntimeError(error) | |
| body = response.json() | |
| if body.get('model') != MODEL: | |
| raise runner.AccountError('SubQ returned a different model: ' + str(body.get('model'))) | |
| answers = body.get('answers') | |
| if not isinstance(answers, dict) or set(answers) != {c['name'] for c in checks}: | |
| raise runner.AnswerError('Missing or unexpected answers', body, 0) | |
| for name, answer in answers.items(): | |
| if not isinstance(answer, dict) or answer.get('type') != 'noul': | |
| raise runner.AnswerError('Unexpected answer type for ' + name, body, 0) | |
| runner.core.probability(answer.get('noul')) | |
| tokens = body.get('usage', {}).get('input_tokens') | |
| if isinstance(tokens, bool) or not isinstance(tokens, int) or tokens < 0: | |
| raise runner.AnswerError('Missing input-token usage', body, 0) | |
| return body | |
| raise AssertionError('unreachable') | |
| def predict(key, pair, role, domain, pack, timeout, limiter, model): | |
| checks = runner.questions_for(pair, domain, pack) | |
| by_name = {c['name']: c for c in checks} | |
| tokens, requests, discarded = 0, 0, 0 | |
| started, budget = time.monotonic(), STATE_BUDGET | |
| try: | |
| for attempt in range(9): | |
| probabilities, scores, readings = {}, {}, [] | |
| try: | |
| plans = sizer().plan(pair[role], checks, budget, REQUEST_BUDGET, MAX_QUESTIONS) | |
| def ask(plan, names): | |
| nonlocal requests, tokens | |
| requests += 1 | |
| try: | |
| body = request(key, plan['state'], [by_name[n] for n in names], timeout, limiter) | |
| except runner.AnswerError as exc: | |
| charged = exc.usage.get('input_tokens', 0) | |
| if isinstance(charged, int) and not isinstance(charged, bool) and charged >= 0: | |
| tokens += charged | |
| raise | |
| except SizeError: | |
| if len(names) == 1: | |
| raise | |
| middle = (len(names) + 1) // 2 | |
| ask(plan, names[:middle]); ask(plan, names[middle:]) | |
| return | |
| tokens += body['usage']['input_tokens'] | |
| for name, answer in body['answers'].items(): | |
| probability = runner.core.probability(answer['noul']) | |
| score = runner.core.raised_score(by_name[name], probability) | |
| if name not in scores or score > scores[name]: | |
| scores[name], probabilities[name] = score, probability | |
| reading = {k: v for k, v in plan.items() if k not in ('state', 'question_names')} | |
| reading.update(question_names=names, answers=body['answers'], usage=body['usage'], | |
| state_sha256=hashlib.sha256(json.dumps(plan['state'], sort_keys=True).encode()).hexdigest()) | |
| readings.append(reading) | |
| for plan in plans: | |
| names = plan['question_names'] | |
| for start in range(0, len(names), MAX_QUESTIONS): | |
| ask(plan, names[start:start+MAX_QUESTIONS]) | |
| break | |
| except SizeError: | |
| discarded += len(readings) | |
| budget //= 2 | |
| if attempt == 8 or budget < 128: | |
| raise | |
| if set(probabilities) != set(by_name): | |
| raise RuntimeError('Not every question received a score') | |
| body = {'model': MODEL, 'answers': {n: {'type': 'noul', 'noul': p} for n, p in probabilities.items()}, | |
| 'usage': {'input_tokens': tokens, 'output_tokens': 0}} | |
| row = prediction(pair, role, domain, pack, body, time.monotonic()-started, model) | |
| row.update(readings=readings, api_requests=requests, discarded_readings=discarded, | |
| final_state_budget=budget, perch_revision=_source_revision, | |
| sizing={'state_budget': STATE_BUDGET, 'request_budget': REQUEST_BUDGET, 'max_questions': MAX_QUESTIONS, | |
| 'adapter_sha256': hashlib.sha256((runner.ROOT/'perch-sizing.mjs').read_bytes()).hexdigest()}) | |
| return row | |
| except Exception as exc: | |
| exc.usage = {'input_tokens': tokens, 'output_tokens': 0, 'cost': tokens * .05 / 1_000_000} | |
| raise | |
| def report(group, pack, model): | |
| result = _native_report(group, pack, model) | |
| # Aggregate failures without exposing private method names from sizing errors. | |
| failures = Counter() | |
| for row in group['failures'].values(): | |
| message = row.get('error', '') | |
| if 'Check incomplete:' in message: | |
| category = 'Context sizing failed' | |
| elif message.startswith('SubQ HTTP '): | |
| category = ':'.join(message.split(':')[:2]).strip() | |
| elif 'timeout' in message.lower() or 'timed out' in message.lower(): | |
| category = 'Request timed out' | |
| else: | |
| category = 'Invalid or incomplete decision' | |
| failures[category] += 1 | |
| result['failure_counts'] = dict(failures) | |
| result.update(context_limit_basis='SubQ Decisions API documentation: 393216 tokens; prior 8547-token rejection now succeeds', | |
| sizing={'state_budget': STATE_BUDGET, 'request_budget': REQUEST_BUDGET, 'max_questions': MAX_QUESTIONS}, | |
| perch_revision=next((row.get('perch_revision') for row in group['predictions'].values() | |
| if row.get('perch_revision')), _source_revision)) | |
| return result | |
| def configure(): | |
| runner.API = 'https://api.subq.ai/v1/systemone' | |
| runner.API_LABEL = 'SubQ' | |
| runner.KEY_ENV = 'SUBQ_API_KEY' | |
| runner.COST_BASIS = 'API-reported input tokens at SubQ published $0.05 per million input tokens' | |
| runner.HOST_PREFIX = '' | |
| runner.CATALOG = {MODEL: ('subq-snap', MODEL, 'subq-snap-perch-full-context-systemone-v1', | |
| 'subq-snap-20261013', 'SubQ', CONTEXT_LIMIT, .05)} | |
| runner.MODELS = (MODEL,) | |
| runner.prediction = prediction | |
| runner.predict = predict | |
| runner.report = report | |
| if __name__ == '__main__': | |
| configure() | |
| if '--score-saved' not in sys.argv: | |
| sizer() | |
| try: | |
| runner.main() | |
| finally: | |
| if _sizer is not None: | |
| _sizer.close() | |