MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                        | category              | brand    | modelno   |   price |
|:-------------------------------------------------------------|:----------------------|:---------|:----------|--------:|
| startech 1 slim 3.5 mm to right angle stereo audio cable m m | electronics - general | startech | mu1mmsra  |    7.88 |

Entity B:
| title                                                                          | category            | brand    | modelno   |   price |
|:-------------------------------------------------------------------------------|:--------------------|:---------|:----------|--------:|
| startech.com mu3mms2ra slim 3.5 mm right angle stereo audio cable - m m 3 feet | connectors adapters | startech | mu3mms2ra |    4.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1962
rtable_id: 5415
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                               | category                      | brand   | modelno   |   price |
|:----------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| lathem time 900e electronic time recorder automatic | stationery & office machinery |         | 900e      |  239.94 |

Entity B:
| title                                                      | category            | brand   | modelno   |   price |
|:-----------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| 900e electronic time recorder - automatic sold individuall | printer accessories | lathem  |           |     230 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1618
rtable_id: 6364
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                       | category   | brand   | modelno   |   price |
|:--------------------------------------------|:-----------|:--------|:----------|--------:|
| targus rg0315c pulse backpack notebook case | computers  | targus  |           |   38.88 |

Entity B:
| title                              | category   | brand   | modelno   |   price |
|:-----------------------------------|:-----------|:--------|:----------|--------:|
| targus tvr300 travel notebook case | bags cases | targus  | tvr300    |   28.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2165
rtable_id: 20785
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                                 | category              | brand   | modelno   |   price |
|:--------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| vtech ds6151 2-line expandable cordless phone with digital answering system caller id | electronics - general | vtech   | ds6151    |   62.51 |

Entity B:
| title                                                                                                                         | category            | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| vtech dect 6.0 black graphite expandable 4-handset cordless phone system with digital answering device and caller id cs6328-4 | cordless telephones | vtech   | cs6328-4  |   62.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 195
rtable_id: 3129
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                            | category   | brand   | modelno   |   price |
|:---------------------------------|:-----------|:--------|:----------|--------:|
| crown ecoplus mat 4 x 6 charcoal | home care  | crown   | ecr046ch  |  144.97 |

Entity B:
| title                                         | category            | brand   | modelno   | price   |
|:----------------------------------------------|:--------------------|:--------|:----------|:--------|
| crown et0035ch - ecostep mat 36 x 60 charcoal | connectors adapters | crown   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2017
rtable_id: 18318
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                             | category              | brand   | modelno     |   price |
|:--------------------------------------------------|:----------------------|:--------|:------------|--------:|
| targus 13.3 widescreen lcd monitor privacy screen | electronics - general | targus  | asf133w9usz |   42.07 |

Entity B:
| title                                                          | category       | brand   | modelno   |   price |
|:---------------------------------------------------------------|:---------------|:--------|:----------|--------:|
| targus 22-inch widescreen lcd monitor privacy filter asf22wusz | screen filters | targus  | asf22wusz |   75.23 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2225
rtable_id: 3424
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                     | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27915 | 7443.99 |

Entity B:
| title                                                            | category           | brand   | modelno   |   price |
|:-----------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-glas self trimming rear projection screen - 70 x 70 av format | projection screens | da-lite |           | 3127.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2472
rtable_id: 17846
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                      | category   | brand      | modelno   |   price |
|:-----------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| kensington k72335us ci10 fit wireless notebook laser mouse | mice       | kensington | k72335us  |   24.84 |

Entity B:
| title                                                                   | category   | brand      | modelno   |   price |
|:------------------------------------------------------------------------|:-----------|:-----------|:----------|--------:|
| kensington ci65m wireless notebook optical mouse for pc or mac k72267us | mice       | kensington | k72267us  |   19.57 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1197
rtable_id: 10832
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                          | category              | brand   | modelno      |   price |
|:---------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| nzxt phantom crafted series atx full tower steel chassis black | electronics - general | nzxt    | nzxt phantom |  139.82 |

Entity B:
| title                                                                | category       | brand   | modelno               |   price |
|:---------------------------------------------------------------------|:---------------|:--------|:----------------------|--------:|
| nzxt zero 2 crafted series steel full tower chassis - no power black | computer cases | nzxt    | zero 2 black no power |   89.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1424
rtable_id: 19063
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                 | category              | brand   |   modelno |   price |
|:----------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen 81 x 108 video format | electronics - general | da-lite |     27917 | 5391.99 |

Entity B:
| title                                                            | category           | brand   | modelno   |   price |
|:-----------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-glas self trimming rear projection screen - 70 x 70 av format | projection screens | da-lite |           | 3127.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 822
rtable_id: 17846
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                           | category              | brand      |   modelno |   price |
|:----------------------------------------------------------------|:----------------------|:-----------|----------:|--------:|
| kensington wrist pillow foam keyboard platform wrist rest black | electronics - general | kensington |     34801 |      22 |

Entity B:
| title                                                       | category    | brand      | modelno   |   price |
|:------------------------------------------------------------|:------------|:-----------|:----------|--------:|
| kensington memory foam wrist pillow platform black k62819us | wrist rests | kensington | k62819us  |   29.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2219
rtable_id: 6043
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                | category   | brand       | modelno   |   price |
|:-----------------------------------------------------|:-----------|:------------|:----------|--------:|
| audiosource bi8 8 in-wall construction bracket mount | furniture  | audiosource | bi8       |   25.88 |

Entity B:
| title                                                   | category   | brand   | modelno   | price   |
|:--------------------------------------------------------|:-----------|:--------|:----------|:--------|
| audiosource bc6 6 in-ceiling construction bracket mount | printers   | grade-a |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1542
rtable_id: 17016
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                           | category              | brand   | modelno   |   price |
|:--------------------------------|:----------------------|:--------|:----------|--------:|
| keyspan usb twin serial adapter | electronics - general | keyspan | usa-28xg  |   70.73 |

Entity B:
| title                   | category            | brand   | modelno   |   price |
|:------------------------|:--------------------|:--------|:----------|--------:|
| usb twin serial adapter | connectors adapters | keyspan | usa-28xg  |   64.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 658
rtable_id: 21942
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | category              | brand            | modelno   |   price |
|:------------------------------------------------|:----------------------|:-----------------|:----------|--------:|
| wacom ptk640 intuos4 medium pen graphics tablet | electronics - general | wacom tech corp. | ptk640    |  372.88 |

Entity B:
| title                           | category         | brand   | modelno   | price   |
|:--------------------------------|:-----------------|:--------|:----------|:--------|
| wacom intuos4 medium pen tablet | graphics tablets | wacom   | ptk640    |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 229
rtable_id: 13258
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                               | category   | brand   | modelno         |   price |
|:------------------------------------|:-----------|:--------|:----------------|--------:|
| jaton geforce 6200 256mb video card | computers  | jaton   | video-338pci-lp |   97.82 |

Entity B:
| title                                                                           | category              | brand   | modelno         |   price |
|:--------------------------------------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| jaton nvidia geforce 6200 256mb ddr pci low profile support dual vga video card | computers accessories | jaton   | video-338pci-lx |   69.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 911
rtable_id: 2923
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                           | category        | brand   | modelno   |   price |
|:------------------------------------------------|:----------------|:--------|:----------|--------:|
| clarion sirius satellite radio receiver adapter | satellite radio | clarion | clasc1    |   49.99 |

Entity B:
| title                                                  | category    | brand   | modelno   |   price |
|:-------------------------------------------------------|:------------|:--------|:----------|--------:|
| clarion clasc1 sirius satellite radio receiver adapter | accessories | clarion | clasc1    |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 695
rtable_id: 12569
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                | category              | brand   | modelno      |   price |
|:-------------------------------------|:----------------------|:--------|:-------------|--------:|
| storm 2306 case with foam olive drab | photography - general | storm   | im2306-30002 |     132 |

Entity B:
| title                                                                    | category          | brand   | modelno   |   price |
|:-------------------------------------------------------------------------|:------------------|:--------|:----------|--------:|
| storm im2306-30001 2306 case with foam olive drab cases outdoor products | printer ink toner | storm   |           |  103.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2182
rtable_id: 9456
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                               | category              | brand   | modelno   |   price |
|:--------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| ihome app-friendly rechargeable speaker system for ipad iphone ipod | electronics - general | ihome   | id9s      |   99.99 |

Entity B:
| title                                                                                     | category              | brand   | modelno   |   price |
|:------------------------------------------------------------------------------------------|:----------------------|:--------|:----------|--------:|
| new ihome idm12b ipad tm iphone r ipod r rechargeable portable bluetooth r speaker system | computers accessories | ihome   |           |   80.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1155
rtable_id: 1010
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                             | category              | brand   |   modelno |   price |
|:------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas deluxe rear projection screen - 96 x 96 av format | electronics - general | da-lite |     27651 | 6128.99 |

Entity B:
| title                                                                           | category           | brand   | modelno   | price   |
|:--------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27903 da-plex self trimming rear projection screen - 96 x 120 av format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1178
rtable_id: 18152
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                       | category              | brand   | modelno   |   price |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| incipio smart feather for apple ipad 2 lime | electronics - general | incipio | ipad-228  |   33.25 |

Entity B:
| title                                                        | category      | brand   | modelno   |   price |
|:-------------------------------------------------------------|:--------------|:--------|:----------|--------:|
| incipio smart feather case for apple ipad 2 - frost ipad-235 | cases sleeves | incipio | ipad-235  |   21.12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1983
rtable_id: 2981
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                         | category       | brand           | modelno      |   price |
|:----------------------------------------------|:---------------|:----------------|:-------------|--------:|
| middle atlantic 30 amp stand-alone mpr module | tv accessories | middle atlantic | rlm30-l520-1 |  237.99 |

Entity B:
| title                         | category           | brand           | modelno   |   price |
|:------------------------------|:-------------------|:----------------|:----------|--------:|
| 30 amp stand-alone mpr module | home audio theater | middle atlantic |           |  237.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 147
rtable_id: 21192
label: 1
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                   | category              | brand    | modelno    |   price |
|:------------------------------------------------------------------------|:----------------------|:---------|:-----------|--------:|
| startech 2.5 in superspeed usb 3.0 sata hard drive enclosure sat2510bu3 | electronics - general | startech | sat2510bu3 |   27.98 |

Entity B:
| title                                                                                               | category              | brand   | modelno      |   price |
|:----------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar superspeed 2.5-inch sata to usb 3.0 external hard drive enclosure nst-280s3-bk black | computers accessories | vantec  | nst-280s3-bk |   26.62 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1945
rtable_id: 14015
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen 72 x 96 video format | electronics - general | da-lite |     27639 | 4448.99 |

Entity B:
| title                                                          | category           | brand   | modelno   |   price |
|:---------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex base rear projection screen - 57 3 4 x 77 video format | projection screens | da-lite |           | 2608.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 625
rtable_id: 17892
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                | category        | brand      |   modelno |   price |
|:-------------------------------------|:----------------|:-----------|----------:|--------:|
| case logic trend compact camera case | mp3 accessories | case logic |    214336 |   15.19 |

Entity B:
| title                                                  | category   | brand      | modelno     |   price |
|:-------------------------------------------------------|:-----------|:-----------|:------------|--------:|
| case logic qpb-201 eva molded compact camera case gray | cases bags | case logic | qpb-201gray |    9.88 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1382
rtable_id: 12595
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                    | category        | brand   | modelno   |   price |
|:-----------------------------------------|:----------------|:--------|:----------|--------:|
| ifrogz ipod touch 4 luxe lean case white | mp3 accessories | ifrogz  | it4ll-wht |   24.99 |

Entity B:
| title                                             | category   | brand   | modelno   |   price |
|:--------------------------------------------------|:-----------|:--------|:----------|--------:|
| ifrogz luxe lean case for ipod touch 4g gun metal | cases      | ifrogz  | it4ll-gmt |   11.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2476
rtable_id: 18730
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                             | category    | brand           | modelno            |   price |
|:----------------------------------------------------------------------------------|:------------|:----------------|:-------------------|--------:|
| western digital 750gb my passport essential se usb 3.0 silver portable hard drive | hard drives | western digital | wdbacx7500asl-nesn |   96.98 |

Entity B:
| title                                                                                              | category             | brand           | modelno            |   price |
|:---------------------------------------------------------------------------------------------------|:---------------------|:----------------|:-------------------|--------:|
| western digital my passport essential 500 gb usb 3.0 2.0 portable external hard drive pacific blue | external hard drives | western digital | wdbacy5000abl-nesn |   75.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2394
rtable_id: 13253
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                        | category   | brand   | modelno    |   price |
|:---------------------------------------------|:-----------|:--------|:-----------|--------:|
| wintec filemate 4gb compactflash memory card | usb drives | wintec  | 3fmcf4gb-r |   15.98 |

Entity B:
| title                                       | category     | brand    |   modelno |   price |
|:--------------------------------------------|:-------------|:---------|----------:|--------:|
| verbatim compactflash 4gb memory card 95188 | memory cards | verbatim |     95188 |   14.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2018
rtable_id: 21602
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                | category              | brand   |   modelno |   price |
|:---------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite holoscreen rear projection screen - 22 x 33 3 4 video format | electronics - general | da-lite |     20030 |    1600 |

Entity B:
| title                                                       | category           | brand   | modelno   |   price |
|:------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex standard rear projection screen - 96 x 96 av format | projection screens | da-lite |           | 5912.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 626
rtable_id: 17561
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                               | category              | brand   |   modelno |   price |
|:--------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-plex unframed rear projection screen - 84 x 84 av format | electronics - general | da-lite |     27503 | 3561.99 |

Entity B:
| title                                                       | category           | brand   | modelno   |   price |
|:------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-plex standard rear projection screen - 96 x 96 av format | projection screens | da-lite |           | 5912.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1257
rtable_id: 17561
label: 0
Task: Entity-Matching (source dataset: Walmart-Amazon)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                             | category        | brand   |      modelno |   price |
|:----------------------------------|:----------------|:--------|-------------:|--------:|
| marware microshell for ipad black | mp3 accessories |         | 602956006664 |   39.99 |

Entity B:
| title                                            | category      | brand   |      modelno |   price |
|:-------------------------------------------------|:--------------|:--------|-------------:|--------:|
| marware microshell for ipad 2 black 602956008552 | cases sleeves | marware | 602956008552 |   20.33 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1705
rtable_id: 4676
label: 0
Task: Schema-Matching (source dataset: HXD)

Task: 
Please identify the matching columns between Table A and Table B. For each column in Table A, specify the corresponding column in Table B. If a column in A has no corresponding column in Table B, you can map it to null. Represent each column mapping using a pair of column headers in a list, i.e., [Table A Column, Table B column or null]. Provide the mapping for each column in Table A and return all mappings in a list.

No explanation and return the matching columns in a structured JSON format: {"column_mappings": <a list of column pairs>}.

TableA:
| Country      | Sector      |   People in need | Total population   |
|:-------------|:------------|-----------------:|:-------------------|
| Chad         | MS          |           388000 |                    |
| Mauritania   | FS          |           493000 | 370000             |
| Burkina Faso | Prepareness |            57000 |                    |
| Cameroon     | Health      |         14402010 | 1438614            |
| Mauritania   | Nutrition   |           165000 | 147000             |
| Mali         | WASH        |          1200000 | 859000             |
| Cameroon     | Education   |           373084 | 280462             |
| Niger        | Health      |           766000 |                    |
| Mauritania   | Health      |           203000 | 203000             |
| Mauritania   | WASH        |           615000 | 250000             |

TableB:
| country   | region   | sector                         |   personnes_en_besoin |
|:----------|:---------|:-------------------------------|----------------------:|
| Niger     | Maradi   | Education                      |                 17402 |
| Niger     | Dosso    | Securite alimentaire           |                 99444 |
| Niger     | Dosso    | Protection                     |                     0 |
| Niger     | Tahoua   | Sante                          |                216349 |
| Niger     | Zinder   | Education                      |                 11176 |
| Niger     | Agadez   | Nutrition                      |                 42706 |
| Niger     | Niamey   | Securite alimentaire           |                 12368 |
| Niger     | Agadez   | Eau, assainissement et hygiene |                 43279 |
| Niger     | Maradi   | Nutrition                      |                452230 |
| Niger     | Diffa    | Abris urgence et NFI           |                255052 |



source_headers: Country
Sector 
People in need
target_headers: country
sector
personnes_en_besoin
column_mappings: Country
country
Sector 
sector
People in need
personnes_en_besoin
output: {"column_mappings": [["Country", "country"], ["Sector ", "sector"], ["People in need", "personnes_en_besoin"], ["Total population", null]]}
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:
| Player Name      | Points         | Year    |
|:-----------------|:---------------|:--------|
| Milt Bakken      | 39, 34, 32     | 1955-56 |
| 0                | 38,34,33,30    | 1994-95 |
| 1                | 38, 35, 31, 31 | 1958-59 |
| 0                | 38, 31, 30     | 1993-94 |
| 1                | 36, 35, 31     | 1957-58 |
| Gary Greve       | 35, 30         | 1956-57 |
| Duane Anderson   | 34, 30         | 0       |
| Todd May         | 33, 32, 31, 31 | 1983-84 |
| Max Meylor       | 31, 30         | 2015-16 |
| Don Peterson     | 47             | 1980-81 |
| Mark Emerson     | 46             | 1971-72 |
| Duane Anderson   | 38             | 0       |
| Jason Schuepbach | 34             | 1995-96 |
| Mark Losby       | 34             | 2000-01 |
| Jordan Schultz   | 32             | 2004-05 |
| Pete Schmitt     | 32             | 2002-03 |
| Jason Larson     | 32             | 2018-19 |
| Tim Woller       | 31             | 1990-91 |
| Matt Kleppe      | 30             | 1999-00 |

## 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:
|   Customer_ID | Challenges   |
|--------------:|:-------------|
|             1 | A,B,C        |
|             2 | A,C          |
|             3 | C,V          |
|             4 | D,E,F        |
|             5 | X,Y,Z,H      |
|             6 | A,B,C,D      |
|             7 | U,S,K,L      |
|             8 | O,P,Q        |
|             9 | R,S          |
|            10 | T            |

## Output:


source: notebook
label: explode