CrossSearch / README.md
sam-jung's picture
Update README.md
7d4c286
|
Raw History Blame
4.5 kB
metadata
language:
  - en
pretty_name: CrossSearch (100-task paper set)
configs:
  - config_name: tasks
    data_files: tasks.jsonl.gz

CrossSearch: 100-task paper set

This resource contains 100 tasks and 4,269 selected, completed evaluation runs: 3,000 native-search runs (10 model configurations, three final attempts per task) and 1,269 search-backend ablation runs (three models, 47 shared tasks, three alternative backends, three attempts). The 600 Opus 5.5/GPT-6.1 Sol runs are included in the 3,000.

Files

  • tasks.jsonl.gz: expert questions, frozen rubrics and evidence maps.
  • tasks.tar.gz: starting workspace assets, separated from grader-only reference material.
  • rollouts-*.jsonl.gz: saved agent trace files, API request/response captures, final answers, original rewards and criterion judgments. The 669 encrypted source runs are exported as readable derivatives. Source archives remain unchanged; no private key is distributed.
  • run-index.jsonl.gz: a compact lookup of all run IDs, tasks, models, conditions, rewards and the shard holding each trajectory.
  • judge-models.csv: one row for each of the 415 audited encrypted extension records, with evidence references and recorded judge labels.
  • CrossSearch-Judge-Prompt.txt and CrossSearch-Agent-Prompt.txt: appendix prompt templates, message roles and source notes.
  • grading-protocol.md: scoring protocol and judge-version uncertainty.
  • judge-model-audit.json: recorded judge fields for the 415 encrypted extension records.
  • analysis-summary.json: frozen paper/blog results.
  • release-manifest.json: final counts, shard checksums, redaction totals and verification status. Check this manifest for completeness.

Reading the data

from datasets import load_dataset
tasks = load_dataset('AfterQuery/CrossSearch', 'tasks', split='train')

Read rollout files directly with the standard-library recipe below. The complete saved traces can be much larger and more heterogeneous than a tabular dataset preview.

Each rollout retains the original archive hash and source-member hashes. Operational credentials and local author/account paths are removed from publication derivatives. Available reasoning text is retained apart from credential and local-path removals; opaque provider reasoning cannot be converted to visible thoughts. Per-run trace files preserve evaluated prompt wrappers. Native and ablation conditions remain separate; valid low and zero rewards are included.

The evaluation uses three final, complete attempts per task and model/search configuration. Some targets required additional fresh attempts when an earlier attempt did not provide complete answer, reward and rubric-judgment evidence. Those incomplete attempts remain separate from the selected runs in this release. No model was called and no answer was regraded to create this resource.

For a direct read without a dataset framework, download a rollout shard and use Python's standard library:

import gzip, json
with gzip.open('rollouts-00000.jsonl.gz', 'rt', encoding='utf-8') as f:
    run = json.loads(next(f))
print(run['model'], run['reward'], run['answer'])
judgments = json.loads(run['rubric_judgment'])

trace_files contains the saved text traces. A duplicate_of entry points to the identical earlier member in that same run. binary_files retains image and other binary bytes as base64, with their original hashes.

Some exceptionally large traces use large_record_parts. Their normal rollout row still contains the answer, reward and rubric judgments. The ordered .txt.gz parts reconstruct the full original publication record, including all trace and binary members; no conversation log is omitted to meet a temporary storage limit. Reassemble before inspecting trace_files:

import gzip, hashlib, json, urllib.request
base = 'https://huggingface.co/datasets/AfterQuery/CrossSearch/resolve/main/'
if run.get('large_record_parts'):
    pieces = []
    for part in sorted(run['large_record_parts'], key=lambda x: x['part']):
        packed = urllib.request.urlopen(base + part['name']).read()
        assert hashlib.sha256(packed).hexdigest() == part['sha256']
        piece = gzip.decompress(packed)
        assert hashlib.sha256(piece).hexdigest() == part['payload_part_sha256']
        pieces.append(piece)
    payload = b''.join(pieces)
    assert hashlib.sha256(payload).hexdigest() == run['large_record_sha256']
    run = json.loads(payload)