task_id stringlengths 7 7 | category stringclasses 5
values | prompt stringlengths 76 208 | data_description stringclasses 1
value | data stringclasses 1
value | expected_output stringlengths 15 96 |
|---|---|---|---|---|---|
mpl-000 | line_plots | Plot y against x on a new Axes. Return a single row containing the line's ydata as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0]]} |
mpl-001 | line_plots | Plot y against x, then y2 against x, on the same Axes. Return a single row [number of lines on the axes]. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[2]]} |
mpl-002 | line_plots | Plot y against x with label='squares' and y2 against x with label='down', then call ax.legend(). Return a single row with the two legend texts in order. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [["squares", "down"]]} |
mpl-003 | line_plots | Plot y against x. Return a single row containing the line's xdata as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]]} |
mpl-004 | line_plots | Plot y against x with linestyle='--' and marker='o'. Return a single row [linestyle, marker] as strings. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [["--", "o"]]} |
mpl-005 | line_plots | Plot the CUMULATIVE SUM of y against x. Return a single row with the plotted ydata as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 1.0, 5.0, 14.0, 30.0, 55.0, 91.0, 140.0]]} |
mpl-006 | bar_charts | Draw a bar chart of values against labels. Return a single row with the bar heights as floats, in order. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 7.5, 5.25, 2.0]]} |
mpl-007 | bar_charts | Draw a bar chart of values against labels with width=0.5. Return a single row with the bar widths as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.5, 0.5, 0.5, 0.5]]} |
mpl-008 | bar_charts | Draw a HORIZONTAL bar chart (barh) of values against labels. Return a single row with the bar widths as floats, in order. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 7.5, 5.25, 2.0]]} |
mpl-009 | bar_charts | Draw a stacked bar chart: first values, then values again on top using bottom=values. Return a single row [number of patches, height of the first patch as a float, bottom (y) of the LAST patch as a float]. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[8, 3.0, 2.0]]} |
mpl-010 | bar_charts | Draw a bar chart of values against labels, then set the tick labels explicitly to labels. Return a single row with the x tick label texts. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [["alpha", "beta", "gamma", "delta"]]} |
mpl-011 | statistical | Draw a histogram of samples with bins=4. Return a single row with the bin counts as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 4.0, 2.0, 1.0]]} |
mpl-012 | statistical | Draw a histogram of samples with bins=4. Return a single row with the bin EDGES as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[1.0, 3.0, 5.0, 7.0, 9.0]]} |
mpl-013 | statistical | Draw a scatter of y against x. Return a single row with the flattened offsets as floats, i.e. [x0, y0, x1, y1, ...]. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 0.0, 1.0, 1.0, 2.0, 4.0, 3.0, 9.0, 4.0, 16.0, 5.0, 25.0, 6.0, 36.0, 7.0, 49.0]]} |
mpl-014 | statistical | Draw a boxplot of samples. Return a single row [median, lower whisker value, upper whisker value] as floats, read from the returned dict. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 1.0, 5.0]]} |
mpl-015 | statistical | Draw a histogram of samples with bins=[0, 3, 6, 10]. Return a single row with the bin counts as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 6.0, 1.0]]} |
mpl-016 | axes_config | Plot y against x, then set the x limits to (0, 10) and the y limits to (-5, 60). Return a single row [xmin, xmax, ymin, ymax] as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 10.0, -5.0, 60.0]]} |
mpl-017 | axes_config | Plot y against x and set the title to 'Squares', the x label to 'n' and the y label to 'n^2'. Return a single row [title, xlabel, ylabel]. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [["Squares", "n", "n^2"]]} |
mpl-018 | axes_config | Plot y against x and set the y ticks explicitly to [0, 10, 20, 30, 40, 50]. Return a single row with the y tick positions as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 10.0, 20.0, 30.0, 40.0, 50.0]]} |
mpl-019 | axes_config | Create a figure with 2 rows and 3 columns of subplots. Return a single row [number of axes on the figure, number of rows, number of columns] as ints, reading rows and columns from the first axes' subplotspec. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[6, 2, 3]]} |
mpl-020 | axes_config | Plot y against x on a log-scaled y axis (set_yscale('log')). Return a single row [the y axis scale name]. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [["log"]]} |
mpl-021 | axes_config | Plot y against x, then set the x limits to (2, 6). Return a single row with the ydata of the line — note the limits do NOT filter the data. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0]]} |
mpl-022 | seaborn | Use seaborn.lineplot to plot y against x on a new Axes. Return a single row with the resulting line's ydata as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0]]} |
mpl-023 | seaborn | Use seaborn.barplot with x=groups, y=gvals, errorbar=None. Return a single row with the bar heights as floats — these are the per-group MEANS seaborn computed. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 5.0]]} |
mpl-024 | seaborn | Use seaborn.scatterplot with x=x, y=y. Return a single row [number of collections on the axes]. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[1]]} |
mpl-025 | seaborn | Use seaborn.barplot with x=groups, y=gvals, estimator='sum', errorbar=None. Return a single row with the bar heights as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[9.0, 15.0]]} |
mpl-026 | seaborn | Use seaborn.histplot on samples with bins=4. Return a single row with the patch heights as floats. | Preloaded data (plain Python lists / numpy arrays):
x = [0, 1, 2, 3, 4, 5, 6, 7]
y = [0, 1, 4, 9, 16, 25, 36, 49] (x squared)
y2 = [7, 6, 5, 4, 3, 2, 1, 0] (descending)
labels = ["alpha", "beta", "gamma", "delta"]
values = [3.0, 7.5, 5.25, 2.0]
samples = [1, 1, 2... | {"x": [0, 1, 2, 3, 4, 5, 6, 7], "y": [0, 1, 4, 9, 16, 25, 36, 49], "y2": [7, 6, 5, 4, 3, 2, 1, 0], "labels": ["alpha", "beta", "gamma", "delta"], "values": [3.0, 7.5, 5.25, 2.0], "samples": [1, 1, 2, 3, 3, 3, 4, 5, 5, 9], "groups": ["a", "b", "a", "b", "a", "b"], "gvals": [1.0, 3.0, 3.0, 5.0, 5.0, 7.0]} | {"rows": [[3.0, 4.0, 2.0, 1.0]]} |
matplotlib-tasks-v1
Task dataset for a Matplotlib/Seaborn RL / eval environment, in the shape used by the Prime Intellect Environments Hub.
27 plotting tasks over a fixed set of small datasets. The model builds the figure, then reads the answer back off the axes; the grade is an exact row comparison against a reference. Deterministic — no LLM judge, no external API, no network, and no pixels.
| Category | Tasks | Covers |
|---|---|---|
| line_plots | 6 | ydata/xdata readback, multiple lines, legend texts, linestyle and marker, plotting a derived series |
| axes_config | 6 | explicit limits, title and axis labels, explicit ticks, subplot grids, log scale, limits not filtering data |
| bar_charts | 5 | heights, widths, barh, stacked bars via bottom, explicit tick labels |
| statistical | 5 | histogram counts and edges, custom bin edges, scatter offsets, boxplot median and whiskers |
| seaborn | 5 | lineplot passthrough, barplot group means, barplot with estimator="sum", scatterplot collections, histplot patch heights |
⚠ Why this dataset does not compare images
Image comparison is the obvious way to grade a plot and the wrong one: it fails on font hinting, DPI, backend and antialiasing long before it tests whether the model plotted the right thing. Here the model builds the figure and the grade reads values back off the artists.
That still leaves a determinism trap, and it was measured on matplotlib 3.11.1, not assumed:
ln.get_color() -> (0.1215…, 0.4666…, 0.7058…) from the STYLE CYCLE — version-dependent
ax.get_xlim() -> (-0.2, 4.2) after autoscale depends on margin defaults
ln.get_ydata() -> exactly what was passed in stable
hist counts -> computed from the data stable
ax.get_xlim() -> after ax.set_xlim(0, 10) stable — the task set it
Every task therefore grades only: user-supplied data, computed values, and properties the task itself sets explicitly. Never a default colour, never an autoscaled limit, never an automatic tick location.
Fields
| Field | Description |
|---|---|
task_id |
stable id, e.g. mpl-017 |
category |
one of the five above |
prompt |
the natural-language instruction |
data_description |
the preloaded variables, as shown to the model |
data |
those variables as JSON, so the task is self-contained |
expected_output |
{"rows": [[...]]} — the reference result |
Verification
Every task is independently checked: it runs, is deterministic across two freshly built figures, returns a non-empty list of JSON-safe primitives — which catches an Artist or numpy scalar leaking out instead of a plain value — contains no NaN/inf, and survives the serialisation round-trip exactly. All 27 pass on matplotlib 3.11.1 / seaborn 0.13.2 with the Agg backend.
Builder and verifier:
build_tasks.py.
- Downloads last month
- -