MMTU-benchmark/MMTU huggingface dataset:
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Dato        | Tid         | Eksamen               | Fagkode   | Lokaler            |   Klasse |
|:------------|:------------|:----------------------|:----------|:-------------------|---------:|
| 20.05. 2019 | 08.30-11.30 | Administrativ ledelse | 1509A     | AU, C1.1, C2.1/03  |        0 |
| 03.06. 2019 | 0           | AK dansk skr.         | 801       | AU, A1.3           |        1 |
| 04.06. 2019 | 08.30-14.30 | EL4AU                 | 1507      | AU, A2.4, A2.5/Inn |        0 |
| 11.06. 2019 | 0           | AK matm. skr.         | 804       | A2.1, A1.2         |        1 |
| 14.06. 2019 | 1           | EL3 skr.              | 1306      | 0                  |        2 |
| 14.06.2019  | 2           | EL - Elektronik skr.  | 18520     | 1                  |        3 |

## Output:


source: excel_file
label: explode
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| No.   | Title                             | Written by      | Storyboard by                                                                                                                                              | Original air date   |
|:------|:----------------------------------|:----------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------------|
| S1    | "Arthur's Perfect Christmas"      | Peter K. Hirsch | Eric Bergeron, Marie Blanchard, Angus Bungay, Mario Cabrera, Gerry Capelle, Emmanuelle Gignac, Stefanie Gignac, Lyndon Ruddy, Nick Vallinakis & Robert Yap | November 23, 2000   |
| S2    | "Arthur, It's Only Rock 'n' Roll" | Kathy Waugh     | Gerry Capelle, Helene Cossette, Nadja Cozic, Elie Klimos, Sylvie Lafrance, Jeremy O'Neill, Zhigang Wang, Harry Rasmussen & Ivan Tankushev                  | September 2, 2002   |
| S3    | "D.W. and the Beastly Birthday"   | Peter K. Hirsch | Gerry Capelle, Bernie Denk, Olivier Migneron, Dev Ramsaran & Cilbur Rocha                                                                                  | May 29, 2017        |

## Output:


source: web
label: explode
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Region         |   Democrats |   Republicans |   Total | States Included                |
|:---------------|------------:|--------------:|--------:|:-------------------------------|
| New England    |          20 |             1 |      21 | CT, MA, ME, NH, RI, VT         |
| Mid-Atlantic   |          38 |            28 |      66 | DE, MD, NJ, NY, PA             |
| Great Lakes    |          25 |            40 |      65 | MI, IL, IN, OH, WI             |
| Midwest        |           8 |            21 |      29 | IA, KS, MN, MO, ND, NE, SD     |
| South Atlantic |          23 |            52 |      75 | FL, GA, NC, SC, VA, WV         |
| South Central  |          17 |            60 |      77 | AL, AR, KY, LA, MS, OK, TN, TX |
| Mountain       |          12 |            19 |      31 | AZ, CO, ID, MT, NM, NV, UT, WY |
| Pacific        |          51 |            20 |      71 | AK, CA, HI, OR, WA             |

## Output:


source: web
label: explode
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
|   Credits | Course          | Description         |   Semester | Prerequisites                   |
|----------:|:----------------|:--------------------|-----------:|:--------------------------------|
|         3 | ME 10           | Graphics for Engin. |          0 | ME 1, ME 5, Math 2              |
|         3 | Mech 102        | Dynamics            |          0 | Mech 2, Math 23, Mech 100, ME 1 |
|         3 | ECO 146         | App. Microeconomics |          1 | Eco 1, Math 231                 |
|         3 | Acct 152        | Intro. Managerial   |          1 | Acct 151, Math 2, Eco 1         |
|         3 | Fin 125         | Intro to Finance    |          1 | Eco 029, Acct 151, Math 231     |
|         3 | HHS Elective #2 |                     |          1 | Math 2, Eco 10                  |
|         1 | IBE 250         | IBE Junior Lab      |          0 | IBE 150                         |

## Output:


source: excel_file
label: explode
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Quarter   | Month   |   Output |
|:----------|:--------|---------:|
| 1st       | Jan     |      3.5 |
|           | Feb     |      1.2 |
|           |         |      0.8 |
|           |         |      0.6 |
|           |         |      0.5 |
|           | Mar     |      1.7 |
| 2nd       | Apr     |      1.1 |
|           | May     |      0.8 |
|           | Jun     |      0.3 |
| 3rd       | July    |      0.7 |
|           | Aug     |      0.6 |
|           | Sept    |      0.1 |
| 4th       | Oct     |      0.5 |
|           | Nov     |      0.4 |
|           | Dec     |      0.3 |

## Output:


source: excel_file
label: ffill
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Date    | Time          | Origination Site      | Program            |
|:--------|:--------------|:----------------------|:-------------------|
| May 6th | 8:50 - 9:13   | Mariners Museum       | Age of Exploration |
|         | 10:20 - 11:00 | McDonalds Observatory | Living with a Star |
|         | 11:10 - 11:50 | Comanche HS           | Blood Typing       |
|         | 11:10 - 11:50 | Comanche HS           | Blood Typing       |
| May 7th | 8:50 - 9:13   | Snyder Elementary     | Blood Typing       |
|         | 10:20 - 11:00 | Bush Library          | What's Rattlin     |
|         | 11:10 - 11:50 | Old Jail Art Center   | El Vaquero         |

## Output:


source: excel_file
label: ffill
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Address   | 123 ABC St   |
|:----------|:-------------|
| Phone     | 555-555555   |
| Age       | 55           |
| Address   | 456 DEF St   |
| Phone     | 123-4567890  |
| Age       | 33           |
| Address   | 789 OPQ St   |
| Phone     | 666-666666   |
| Age       | 66           |
| Address   | 012 XYZ St   |
| Phone     | 777-777777   |
| Age       | 88           |
| Address   | 342 BCD St   |
| Phone     | 888-888888   |
| Age       | 56           |
| Address   | 367 CDE St   |
| Phone     | 999-999999   |
| Age       | 58           |
| Address   | 783 EFG St   |
| Phone     | 123-789362   |
| Age       | 62           |
| Address   | 467 UGF St   |
| Phone     | 234-123123   |
| Age       | 33           |
| Address   | 783 BSL St   |
| Phone     | 456-142342   |
| Age       | 44           |

## Output:


source: notebook
label: operator: pivot
pivot_row_frequency: 3
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| How good was the Nurse at                       |   Very good |   Good |   Satisfactory |
|:------------------------------------------------|------------:|-------:|---------------:|
| Q22 Putting you at your ease?                   |        0.43 |   0.1  |           0    |
| Q23 Giving you enough time?                     |        0.44 |   0.09 |           0.01 |
| Q24 Listening to you?                           |        0.44 |   0.08 |           0.02 |
| Q25 Explaining your condition and treatment?    |        0.35 |   0.13 |           0.01 |
| Q26 Involving you in decisions about your care? |        0.34 |   0.09 |           0    |
| Q27 Providing or arranging treatment for you?   |        0.6  |   0.22 |           0.05 |

## Output:


source: excel_file
label: operator: transpose
operator: stack
stack_start_idx: 1
stack_end_idx: 6
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Index        | 0                | 1           | 2           | 3           | 4           | 5           | 6           | 7           |
|:-------------|:-----------------|:------------|:------------|:------------|:------------|:------------|:------------|:------------|
| Ridge__alpha |                  | 1           | 10          | 50          | 100         | 200         | 300         | 500         |
| estimator    | LinearRegression | Ridge       | Ridge       | Ridge       | Ridge       | Ridge       | Ridge       | Ridge       |
| max_score    | 86338.59844      | 86338.60407 | 86338.65623 | 86338.92025 | 86339.32399 | 86340.37516 | 86341.74784 | 86345.44147 |
| mean_score   | 83965.83628      | 83965.83615 | 83965.83642 | 83965.87002 | 83965.98609 | 83966.46317 | 83967.26341 | 83969.81723 |
| min_score    | 82187.12777      | 82187.1459  | 82187.31047 | 82188.07299 | 82189.09725 | 82191.38089 | 82193.97471 | 82200.07721 |
| std_score    | 1499.346445      | 1499.355034 | 1499.432323 | 1499.775691 | 1500.204571 | 1501.061201 | 1501.916273 | 1503.62151  |

## Output:


source: notebook
label: operator: transpose
operator: stack
stack_start_idx: 3
stack_end_idx: 6
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Product Name        | Product 1     |
|:--------------------|:--------------|
| Product Description | Description 1 |
| Product Price       | Price 1       |
| Product Discount    | Discount 1    |
| Product Name        | Product 2     |
| Product Description | Description 2 |
| Product Price       | Price 2       |
| Product Discount    | Discount 2    |
| Product Name        | Product 3     |
| Product Description | Description 3 |
| Product Price       | Price 3       |
| Product Discount    | Discount 3    |
| Product Name        | Product 4     |
| Product Description | Description 4 |
| Product Price       | Price 4       |
| Product Discount    | Discount 4    |
| Product Name        | Product 5     |
| Product Description | Description 5 |
| Product Price       | Price 5       |
| Product Discount    | Discount 5    |
| Product Name        | Product 6     |
| Product Description | Description 6 |
| Product Price       | Price 6       |
| Product Discount    | Discount 6    |
| Product Name        | Product 7     |
| Product Description | Description 7 |
| Product Price       | Price 7       |
| Product Discount    | Discount 7    |

## Output:


source: notebook
label: operator: pivot
pivot_row_frequency: 4
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Name : ValueA   |
|:----------------|
| Age: 23         |
| Height: 178cm   |
| Name : ValueB   |
| Age: 22         |
| Height: 168cm   |
| Name : ValueC   |
| Age: 40         |
| Height: 188cm   |
| Name : ValueD   |
| Age: 25         |
| Height: 178cm   |
| Name : ValueE   |
| Age: 28         |
| Height: 185cm   |
| Name : ValueF   |
| Age: 30         |
| Height: 182cm   |
| Name : ValueG   |
| Age: 32         |
| Height: 183cm   |

## Output:


source: stackoverflow
label: operator: pivot
pivot_row_frequency: 3
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Found: 21-Oct-19 10:21:14                                        |
|:-----------------------------------------------------------------|
| Title: Canon EF 100mm f/2.8L Macro IS USM                        |
| Price: 6900 kr                                                   |
| Link: https://www.finn.no/bap/forsale/ad.html?finnkode=161065896 |
| Found: 21-Oct-19 10:21:14                                        |
| Title: Canon EF 100mm f/2.8L Macro IS USM                        |
| Price: 7500 kr                                                   |
| Link: https://www.finn.no/bap/forsale/ad.html?finnkode=155541389 |
| Found: 21-Oct-19 10:21:14                                        |
| Title: Panasonic Lumix G 25mm F1.4 ASPH                          |
| Price: 3200 kr                                                   |
| Link: https://www.finn.no/bap/forsale/ad.html?finnkode=161066674 |

## Output:


source: stackoverflow
label: operator: pivot
pivot_row_frequency: 4
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Way_ID    | 2781002       |
|:----------|:--------------|
| Highway   | motorway_link |
| Toll      | yes           |
| Reference |               |
| Bridge    | yes           |
| County    | US            |
| Way_ID    | 2788620       |
| Highway   | motorway      |
| Toll      | yes           |
| Reference | A_49          |
| Bridge    | no            |
| County    | US            |
| Way_ID    | 2788630       |
| Highway   | motorway      |
| Toll      | yes           |
| Reference | A_50          |
| Bridge    | no            |
| County    | US            |
| Way_ID    | 2788650       |
| Highway   | motorway      |
| Toll      | no            |
| Reference | A_51          |
| Bridge    | no            |
| County    | US            |
| Way_ID    | 2788660       |
| Highway   | motorway      |
| Toll      | yes           |
| Reference | A_52          |
| Bridge    | no            |
| County    | US            |
| Way_ID    | 2788670       |
| Highway   | motorway      |
| Toll      | yes           |
| Reference | A_53          |
| Bridge    | no            |
| County    | US            |

## Output:


source: stackoverflow
label: operator: pivot
pivot_row_frequency: 6
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Id: 02398123-a642-4e3f-88a7            |
|:---------------------------------------|
| Type: LINE                             |
| Detected Text: BUCK                    |
| Confidence: 77.965172                  |
| Id: c85bbbe                            |
| Type: LINE                             |
| Detected Text: NIP                     |
| Confidence: 97.186539                  |
| Id: 28926a7a-78024c80-b9c5             |
| Type: LINE                             |
| Detected Text: Preerfal Deet Attracter |
| Confidence: 47.749722                  |

## Output:


source: stackoverflow
label: operator: pivot
pivot_row_frequency: 4
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
|   student_id |   chinese |   english |   maths |
|-------------:|----------:|----------:|--------:|
|         1001 |        76 |        53 |      92 |
|         1002 |        81 |        46 |      85 |
|         1003 |        85 |        50 |      60 |
|         1004 |        96 |        51 |      74 |

## Output:


source: notebook
label: operator: stack
stack_start_idx: 1
stack_end_idx: 3
alternative_label: operator: transpose
operator: stack
stack_start_idx: 1
stack_end_idx: 4
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| Name   | Math   | English   | Chemistry   | Biology   | Physics   | History   |   Age |
|:-------|:-------|:----------|:------------|:----------|:----------|:----------|------:|
| Bob    | A+     | C         | A           | A         | B         | A         |    13 |
| John   | B      | B         | C           | B+        | C         | B         |    16 |
| Foo    | A      | B         | A           | A         | B+        | A         |    16 |
| Bar    | F      | A+        | A           | A         | B         | D         |    15 |
| Alex   | D      | F         | C           | E         | B         | C         |    15 |
| Tom    | C      | A         | A           | B+        | C         | A         |    13 |

## Output:


source: stackoverflow
label: operator: stack
stack_start_idx: 1
stack_end_idx: 6
Task: Data-transform-reshape (source dataset: Auto-Tables)

Given a table, predict what python pandas transformation may be needed on the given input table. Valid choices for transformation include: {"stack", "wide_to_long", "transpose", "pivot", "explode", "ffill", "subtitles"}. Note that each of these is a common Python Pandas operator. Some transformations can have parameters. Each transformation and its parameters are describe as follows.
 
- stack: collapse homogeneous cols into rows.
@param (int): stack_start_idx: zero-based starting column index of the homogeneous column-group.
@param (int): stack_end_idx: zero-based ending column index of the homogeneous column-group.
 
- wide_to_long: collapse repeating col-groups into rows.
@param (int): wide_to_long_start_idx: zero-based starting column index of the repeating col-groups.
@param (int): wide_to_long_end_idx: zero-based ending column index of the repeating col-groups.
 
- transpose: convert rows to columns and vice versa.
 
- pivot: pivot repeating row-groups into cols.
@param (int): pivot_row_frequency: frequency of repeating row-groups.
 
- ffill: fill structurally empty cells in tables.
@param (int): ffill_end_idx: zero-based ending column index of the columns to be filled.
 
- explode: convert composite cells into atomic values
@param (int): explode_column_idx: zero-based column index of the column to be exploded.
 
- subtitle: convert table subtitles into a column.
 
OUTPUT the predicted transformation name along with its parameters for the given INPUT table in a JSON, e.g., {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}. If the input table needs multi-step transformations (e.g, ffill followed by stack), list JSON of each transformation sequentially in a list, e.g., [{"transformation": "ffill", "ffill_end_idx": 1}, {"transformation": "stack", "stack_start_idx": 1, "stack_end_idx": 5}]. No explanation is needed.

## Input:
| DATE       |    SPY |   JPM |   AAPL |    GLD |    IBM |   TWTR |   NFLX |
|:-----------|-------:|------:|-------:|-------:|-------:|-------:|-------:|
| 1/4/2010   | 108.27 | 40.87 | 213.1  | 109.8  | 123.05 |  38.7  | 202.34 |
| 1/4/2010   | 108.56 | 41.67 | 213.46 | 109.7  | 121.63 |  35.68 | 205.05 |
| 1/5/2010   | 108.64 | 41.89 | 210.07 | 111.51 | 123.51 |  32.04 | 207.58 |
| 1/5/2010   | 109.1  | 42.72 | 209.68 | 110.82 | 121.69 |  39.61 | 213.97 |
| 1/6/2010   | 109.46 | 42.62 | 211.07 | 111.37 | 127.38 |  39.62 | 203.69 |
| 12/23/2011 | 125.19 | 32.84 | 401.61 | 156.31 | 129.81 |  35.36 | 217.06 |
| 12/23/2011 | 125.29 | 32.31 | 404.79 | 154.91 | 122.63 |  39.7  | 209.91 |
| 12/28/2011 | 123.64 | 31.94 | 400.92 | 151.03 | 121.35 |  34.82 | 201.35 |
| 12/29/2011 | 124.92 | 32.69 | 403.39 | 150.34 | 121.89 |  33.34 | 216.57 |
| 12/30/2011 | 124.31 | 32.53 | 403.27 | 151.99 | 126    |  35.7  | 211.54 |

## Output:


source: stackoverflow
label: operator: stack
stack_start_idx: 1
stack_end_idx: 7
alternative_label: operator: transpose
operator: stack
stack_start_idx: 1
stack_end_idx: 10