Emulated-Inc/structured-output-training-pool

Structured output training pool

Public JSON schemas, and public text paired with the structured record it describes, from the collections named below, read at the pinned revisions given there and laid out twice. Train on either layer or on both.

pool.jsonl

Every source rewritten into one shape, 114103 rows, one JSON object per line, with these fields.

Field	What it holds
id	a row identifier unique within this file
request	the text the record is to be built from, or null
schema	the JSON Schema the document has to satisfy
document	the JSON document that answers the request, or null
row_shape	request_schema_document or schema, which of the three the row carries
schema_origin	whether the schema was published with the data or written over the source's own ontology
source	the name of the source directory the row came from
source_repo, source_revision	the collection and the revision it was read at
source_subset, source_split, source_id	where the row sits in that collection
provenance_class	how the row came to exist
licence	the licence of the material the row came from

Which rows carry what. 90124 rows are request_schema_document, 23979 rows are schema. A request_schema_document row carries all three fields, so it can be trained on as an extraction example or used as a prompt with a verifiable answer. A schema row carries the schema alone, with request and document null, which is what a corpus of real schemas can offer: it is the material for generating your own documents, for teaching what schemas look like in the wild, or for sampling with a constrained decoder.

Every schema in this file passes the meta-schema check of the draft it declares, and every non-null document validates against the schema of its own row. Rows that failed either check were dropped when the file was built, so a document here is always a legal instance of the schema beside it. Rows are deduplicated on the request together with the schema and the document, keeping the first source that carries the row in the order of the sections below.

sources/

The same data untouched, 149306 records, one directory per source, holding the files at the paths, in the format and with the fields its own repository publishes. Nothing here was renamed, reshaped, reordered, validated or deduplicated. Use this layer if you want a field the rewritten one drops, such as the span annotations and the system turns of the dialogues, the repository and star count of a schema, or the assistant's prose replies, or if you would rather decide for yourself which turn of a conversation becomes a row.

The sources

sources/json_schemas_curated

Real JSON Schemas collected from public source repositories, from the Kubernetes API, from the Snowplow event registry, from the JSON Schema Store catalogue and from the Washington Post ANS specification, graded into five difficulty tiers. From epfl-dlab/JSONSchemaBench at revision 5bd0f4640badc6f3f02df796421d21cb0ca0b141, 27 files. 7835 records here, which produced 7436 rows in pool.jsonl. Provenance class collected, licence mit. Its own fields are json_schema, the schema as a string, and unique_id.

Worth knowing. The model-generated configuration of this repository is carried as its own source below rather than mixed in here, and all three published splits are taken, since nothing this pool is measured against is drawn from any of them.

sources/json_schemas_github

Real JSON Schema files scraped from public repositories through a code-search API, every revision fetched and validated, split so that the schemas of one organisation stay together. From dataunitylab/json-schema at revision fc9d99ae0ad504e85b9c03e4db0929c9b97d283b, 3 files. 16367 records here, which produced 14838 rows in pool.jsonl. Provenance class collected, licence unknown. Its own fields are repository, commit, commitDate, path, repoStars, repoLastFetched, content holding the schema as a string, license naming the repository's own terms, and language.

Worth knowing. The repository-level licence tag is literally unknown, which is why this source is flagged. Every row nevertheless names the licence of the repository it came from and every one of those is permissive, the collection having been filtered to a permissive allowlist, so the curated rows carry their own term in the licence field instead of the unknown tag.

sources/dialogue_records

Human-to-human task-oriented dialogues about hotels, restaurants, trains, taxis, attractions and hospitals, each turn annotated by people with the slot-value record the conversation has established so far, over a published ontology of services, slots, descriptions and permitted values. From budzianowski/multiwoz at revision fe0c8e65cfcd8462bd33c86e35f21addc84ca82b, 22 files. 10437 records here, which produced 46939 rows in pool.jsonl. Provenance class human, licence mit. Its own fields are dialogue_id, services, and turns holding turn_id, speaker, utterance and frames, where a frame carries the service, the span annotations and the state with its active_intent, requested_slots and slot_values.

Worth knowing. The record is the state of the conversation so far, so consecutive rows of one dialogue share most of their content and their requests nest. A slot may be annotated with several surface forms and the first is the one written into the document.

sources/function_calls

Conversations in which an assistant is given one or more function declarations and answers a request by emitting the argument document for one of them, produced end to end by a synthetic data platform. From glaiveai/glaive-function-calling-v2 at revision e7f4b6456019f5d8bcb991ef0dd67d8ff23221ac, 1 file. 112960 records here, which produced 43185 rows in pool.jsonl. Provenance class model-generated, licence apache-2.0. Its own fields are system, holding the function declarations as JSON, and chat, holding the turns as text with USER, ASSISTANT and FUNCTION RESPONSE markers.

Worth knowing. Every part of it was written by a model, the request included, and the argument documents are not always faithful to the declaration they answer, so a row whose document fails its own schema is dropped here rather than shipped.

sources/function_call_schemas

Function parameter schemas lifted out of a synthetic function-calling corpus and republished as standalone schemas. From epfl-dlab/JSONSchemaBench at revision 5bd0f4640badc6f3f02df796421d21cb0ca0b141, 3 files. 1707 records here, which produced 1705 rows in pool.jsonl. Provenance class model-generated, licence mit. Its own fields are json_schema, the schema as a string, and unique_id.

Worth knowing. These schemas were invented by a model rather than harvested, which is why they are a source of their own instead of part of the collected schema corpus above. They are narrower and more uniform than real ones.

Provenance and licences

Every row names how it came to exist in provenance_class. 46939 rows are human, 44890 rows are model-generated, 22274 rows are collected. collected means the text is a genuine artefact of people building software, which is what a schema harvested from a public repository is. human means people wrote the text and people annotated the record. model-generated means a language model wrote it, request and answer alike. Nothing was filtered out on its class: the field is there so that you can select, weight or drop what you want.

The schemas written over a source's own ontology are marked schema_origin and are the one place a rule rather than a person decided the shape. Where that happened the slot names, the descriptions and the permitted values are the source's own published ontology, and the rule only chose which of them the row asks for.

The pool as a whole is offered under apache-2.0, which is the most restrictive term its sources compose to. The sources themselves are mit for the curated schema corpus and for the dialogues, apache-2.0 for the function-call conversations, and an unknown tag on the scraped GitHub schema collection, whose rows each name their own repository's terms instead and whose collection was filtered to a permissive allowlist before publication. Each rewritten row carries its own in the licence field and each directory under sources/ is one source, so a subset under a single licence can be selected. Attribution goes to the authors of each collection and, for the scraped schemas, to the repositories the source_id field names.

Filtering

Rows whose request text or whose schema matched material that is deliberately held out of this pool were removed before publication, from both layers alike. Two checks ran over every record, a word 8-gram overlap on the request text and an exact match on the request and on the schema, and between them they removed 0 records. That material is not distributed here. Beyond that, rows were dropped only for failing their own schema (1327), for not parsing as a schema at all (38) and for being duplicates (38728). No subject, no difficulty and no provenance class was selected for or against.