Avinaash/ChartSense_11k

ChartSense 11k

This is a supervised fine tuning dataset that teaches a small language model to behave like a data analyst on chart and data visualization work, i.e.

1. it should be able to see through the user's words,
2. resolve underspecified asks,
3. push back if required,
4. critique flawed charts, and
5. answer the question the chart is a means to.

Built for the AutoScientist Challenge by Adaption Labs.

This is the full build: both slices grown to their current size. The two partial builds, ChartSense_8645_web_enriched and ChartSense_8827_corpus_enriched, hold one slice at the original size so each slice's contribution can be measured separately.

What it is

11,434 conversations between a person with data and an analyst, each paired with the analyst's full reasoning. The analyst reads a table, works out what the person actually wants, decides how to show it, writes runnable code, and checks its own arithmetic before answering.

Conversations	11,434
Supervised training lines	13,242
Average completion	8,112 characters
Completion range	1,567 to 19,666 characters

A conversation with two supervised turns, such as one where the analyst asks a question and then answers based on a user response, contributes two lines that share their earlier turns. That is why 11,434 conversations give 13,242 training lines.

How it was built

two kinds of seed  ->  trajectory  ->  teacher model  ->  training row
   web article           the spec      Muse Spark 1.2     conversation
   corpus row          for one example                    + thinking block

1. Two kinds of seed. Every example starts from real material, never from a blank page.

• Web seeds produce 5,626 conversations, drawn from 3,019 articles about data and charts. The article text and its chart images are downloaded before generation, so the teacher is reading the real post rather than recalling it. Where there are more conversations than articles, an article is reused under a different specification, never the same one.
• Corpus seeds produce 5,808 conversations from 5,689 rows of four existing visualization corpora. Each brings a real schema, real gold code or a real answer set.

The two kinds produce different data on purpose. A corpus seed hands over an actual table, so the analyst works with real columns. A web seed hands over a world and a problem, so the table has to be built to fit it.

2. Behaviour patterns define the trajectory. Before any model is called, a specification is drawn for each example. It fixes what the user wants, how clearly they ask, who they are, how long the conversation runs, and which behaviours the analyst must exercise.

Those behaviours were chosen from the ways models actually fail on data visualization tasks: charting a question instead of answering it, accepting a vague word like "top" without resolving it against the data, ignoring a stated library, going along with a false claim, or reviewing a chart without recomputing what it asserts. Each behaviour is paired with a cause that has to be visibly present in the user's message, so the example cannot exercise a behaviour the conversation never provoked.

The draw runs against fixed quotas with a ledger correcting drift, uses no model calls, and a fixed random seed reproduces the whole thing.

3. A teacher model writes the example. The seed material and the specification go to Muse Spark 1.2 at xhigh reasoning effort, which writes the table, the conversation and the thinking.

4. Validation. Every row is checked against its own specification. Rows that fail are regenerated rather than patched, and rows that cannot be regenerated are dropped.

The thinking block

Each training row's completion opens with a thinking block, then the reply. It uses a closed set of nine XML tagged sections, in a fixed order, and only the ones a given turn needs.

Tag	What it holds
<understand_data>	What one row is, each column's type and range, units, and the quirks: duplicates, blanks, constant columns, mixed types
<find_data>	What was selected, what was ignored, and why
<understand_request>	The task in analytic terms, the specific gap if there is one, and the decision: proceed, assume, ask, repair or push back
<clean_reshape>	The transform plan with a reason per step, and every derived number computed
<chart_choice>	Candidate charts killed using this table's own numbers, then the winner, or an explicit decision not to chart
<chart_spec>	The encoding plan before code: axes, colour, the title stating the finding, annotations, where caveats live
<language>	Which library and why
<read_chart>	For any chart in play, what each mark encodes, then whether the metric is sensible, the values recompute, what pattern shows, and what else could explain it
<verify>	Re-derives every number the reply will state, then runs a five point check against Tufte's principles

The <chart_choice> rule is the one that most shapes the reasoning. A rejected option has to be killed with a count, a value or a ratio from the table in front of it. "A pie is poor for small categories" does not count, because it is true of every dataset. "Binning collapses the 32 points into 3 near-equal bars" does, because it stops being true if the table changes.

Row format

Parquet shards under data/, in chat format with four columns.

messages     the whole conversation, ending on the assistant turn to be learned
slice        "web" or "corpus"
trajectory   the specification the example was built from
out_tags     what the teacher determined about the example

• messages is a list of {role, content}, alternating user and assistant and always ending on an assistant turn. That final assistant message is the training target: it holds the thinking block wrapped in <think> and </think>, then the reply. Every earlier assistant turn is conversation history and carries a plain reply with no thinking block.
• slice is web or corpus, naming which kind of seed the example came from. The two are different populations, so filter on this if you want one or the other rather than the pool.
• trajectory is the specification the example was built from. It carries the row id, the tags, supervises naming which turn this row supervises, and near_dup_of. Two fields are reshaped so the schema is stable: triggers is a list of {behaviour, cause} rather than a map keyed by behaviour number, and the corpus seed's source row is carried as JSON text in seed.row_json.
• out_tags holds what the teacher determined: chart type, library, topic, which thinking sections fired, the flaw shown, the data source and the table's dimensions. The model is not trained on it.

Conversations run 2 to 12 messages: 7,322 rows are a single exchange and 5,920 are longer threads.

The eight behaviours

Each row exercises one to three behaviours, and each has a visible cause.

Behaviour	The cause looks like	Conversations
Resolve an underspecified goal	"the request names a time frame loosely ('recent', 'lately') that the data can read two ways"	3,202
See through the user's words	"the user asks what they should use for this data, handing over the choice"	1,308
Iterate in small steps	"the user pastes a chart they already have and asks for one small change to it, nothing else"	2,052
Handle raw and messy data	"the table arrives with duplicate rows and stray columns the task does not need"	2,977
Honour the user's stack	"the user's pasted matplotlib code makes the library unambiguous and the reply must stay in it"	2,970
Handle a bad request or wrong claim	"the user asks for a chart form that will not work at this cardinality, and a defensible repaired version exists"	2,702
Answer the question, not just chart it	"the user asks a question whose answer requires computing over the data, not looking at it"	1,817
Assess a chart critically	"the user asks for a review; the chart is sound and the verdict must say so, naming what was checked"	2,761

Composition

What the user wants done

	Conversations
Clean up and reshape raw data	2,977
Build a chart from scratch	2,266
Make one small change to an existing chart	2,052
Review a chart critically	1,827
Get an answer, chart at most a by-product	1,378
Reproduce a chart they have seen	934

How clear the request is. 5,128 fully answerable as asked. 5,182 with a gap the analyst fills and states as an assumption. 1,124 with a gap that genuinely needs one question, because two readings change the output.

Conversation shape. 9,626 rows supervise the final turn only. 1,124 supervise an ask, 684 a pushback, and 1,808 the resolution that follows one of those. Turn counts run 2, 4, 6, 8, 10 and 12, with 6,338 single exchanges and 5,096 longer threads.

Charts and code. 589 distinct chart types, led by bar 4,283, line 2,115, pie 501, scatter 480, horizontal bar 326, heatmap 270. Libraries are matplotlib 6,920, plotly 1,434, altair 1,003, seaborn 732, vega-lite 395, Chart.js 375.

Flawed charts. 2,359 conversations paste a chart with a real fault for the analyst to find: truncated axes, cherry-picked windows, radius-scaled bubbles, inverted axes, manufactured second axes, loaded titles, flattering category order, missing units. The corrected version appears only in the reply, never as input.

Unanswerable requests. 565 conversations ask for something the data cannot support. The correct reply says so plainly and states what the data can support instead.

Tables. Average 33.9 rows by 5.8 columns, ranging 2 to 80 rows. The pasted table is always the entire dataset, so every number in a reply can be checked against it.

Sources

Web seeds

Source	Conversations
OpenReview papers and reviews	2,991
Andrew Gelman's blog	750
Junk Charts	651
We Have The Data	383
Kieran Healy	328
Randal Olson	313
Road to Larissa	100
Sportsball	81
PAIR	29

Corpus seeds

Corpus	Conversations
VisCode-200K	2,470
nvBench 2.0	1,536
ChartGPT	907
Chart2Code-160k	895

Only training splits were read. Development and test splits were never loaded, so no test row can reach the output by any path.

Known limits

• Prompt versions are not uniform. The instructions were revised as faults were found. 443 web rows came from an earlier version whose rules for pushback turns were weaker. Every row that failed validation was regenerated, so all rows pass, but those 443 were written under a weaker prompt.
• The teacher occasionally drops a question mark at the end of an ask turn. Those rows were corrected by appending a single ? and changing nothing else; in every case the question was already the final sentence. Expect roughly 6% of ask turns to need it on any regenerated batch.
• About 1% of assistant turns in the conversation history are acknowledgements carrying no numbers, which the instructions ask the teacher to avoid.
• Flaw and chart type labels are free text, so the same fault appears under several spellings, e.g. truncated y-axis and truncated_y_axis. Normalise before using them as a filter.
• The corpus slice is machine generated at source. All four corpora are themselves synthetic, unlike the web articles.
• nvBench 2.0 and ChartGPT share a lineage. Both descend from Spider, so they were capped as one source rather than two.
• The two slices are different populations. Sample from them deliberately rather than as one pool.
• 906 of the 11,434 conversations are near-duplicates of another conversation, by design, so the model sees the same request over differently shaped data. trajectory.near_dup_of names the partner. Split on that field, or a random split will put a pair either side of the train and test line.
• A conversation with two supervised turns repeats its trajectory across both of its lines, so trajectory.id is not unique per line. Group on it if you need one record per conversation.

Licensing

Released under CC-BY-4.0.