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 |
|:-----------------------------------------|:----------------------|:--------|:----------|--------:|
| epson s041667 premium glossy photo paper | photography - general | epson   | s041667   |    45.2 |

Entity B:
| title                                          | category    | brand   | modelno   |   price |
|:-----------------------------------------------|:------------|:--------|:----------|--------:|
| hp q1989a premium glossy photo paper 60 sheets | photo paper | hp      | q1989a    |    4.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1939
rtable_id: 19855
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 |
|:----------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark e450h11a toner 11000 page-yield black | printers   | lexmark | e450h11a  |  248.27 |

Entity B:
| title                                                | category             | brand   | modelno   | price   |
|:-----------------------------------------------------|:---------------------|:--------|:----------|:--------|
| oki 52117101 - 52117101 toner 33000 page-yield black | cables interconnects | oki     |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1816
rtable_id: 1832
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 |
|:--------------------------------------------------------|:------------|:----------|:----------|--------:|
| clickfree c2 500gb usb 3.0 portable external hard drive | hard drives | clickfree | hd527b3   |   84.98 |

Entity B:
| title                                                                 | category             | brand   | modelno     |   price |
|:----------------------------------------------------------------------|:---------------------|:--------|:------------|--------:|
| iosafe rugged portable 500 gb usb 3.0 external hard drive pa50500u1yr | external hard drives | iosafe  | pa50500u1yr |  149.98 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2305
rtable_id: 14820
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 |
|:--------------------------------------|:----------------------|:--------|:----------|--------:|
| chicago bears ipod touch 4g hard case | electronics - general | tribeca | fva4587   |   29.99 |

Entity B:
| title                                      | category              | brand   | modelno   |   price |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers ipod touch 4g hard case | computers accessories | tribeca |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2191
rtable_id: 18372
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 |
|:-----------------------------------|:-----------|:---------|:-----------|--------:|
| logitech m305 wireless mouse black | mice       | logitech | 910-001752 |   29.73 |

Entity B:
| title                               | category   | brand    | modelno    |   price |
|:------------------------------------|:-----------|:---------|:-----------|--------:|
| logitech m305 wireless mouse silver | mice       | logitech | 910-000928 |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 742
rtable_id: 4711
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 |
|:----------------------------------------------------------------------------------------------------------------|:----------------|:--------|:-----------|--------:|
| canon powershot a3300 is black 16.0 mp digital camera with 5x optical zoom 3.0 lcd 720p video w 50 bonus prints | digital cameras | canon   | 5035b001aa |  156.54 |

Entity B:
| title                                                                           | category                    | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------|:----------------------------|:--------|:-----------------|--------:|
| canon powershot elph 100 hs 12 mp cmos digital camera with 4x optical zoom blue | point shoot digital cameras | canon   | elph 100 hs - bl |     179 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 99
rtable_id: 4519
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 high power advantage manual with csr - av format 8 x 10 diagonal | electronics - general | da-lite |     85687 | 1303.99 |

Entity B:
| title                                                                   | category           | brand   | modelno   |   price |
|:------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| hc matte white advantage manual with csr - wide format size 94 diagonal | projection screens | da-lite |           |   597.5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2145
rtable_id: 2754
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 |
|:---------------------------------|:-----------|:--------|:----------|--------:|
| iogear miniview micro kvm switch | networking | iogear  | gcs62     |   25.88 |

Entity B:
| title                                                                    | category     | brand   | modelno   |   price |
|:-------------------------------------------------------------------------|:-------------|:--------|:----------|--------:|
| iogear 2-port miniview micro ps 2 audio kvm switch with 2 cables gcs612a | kvm switches | iogear  | gcs612a   |   11.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1102
rtable_id: 12925
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 |
|:---------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| quartet cork bulletin board natural cork fiberboard 60 x 36 aluminum frame | stationery & office machinery | quartet |      2305 |   91.44 |

Entity B:
| title                                                                                         | category   | brand     | modelno   |   price |
|:----------------------------------------------------------------------------------------------|:-----------|:----------|:----------|--------:|
| universal 43614 - universal bulletin board natural cork 48 x 36 satin-finished aluminum frame |            | universal |           |      85 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 22
rtable_id: 11302
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 |
|:-------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| edge 256mb 1x256mb pc2100 nonecc unbuffered 184 pin ddr dimm | memory     | edge    | pe158842  |   11.88 |

Entity B:
| title                                                   | category   | brand   | modelno         |   price |
|:--------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| edge 512mb pc2100 ddr 184 pin non-ecc dimm for desktops | memory     | edge    | d2184-185329-pe |   19.38 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1309
rtable_id: 15127
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 self trimming rear projection screen - 40 1 4 x 53 3 4 video format | electronics - general | da-lite |     27580 | 1892.99 |

Entity B:
| title                                                                      | category           | brand   |   modelno |   price |
|:---------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex standard rear projection screen - 94 1 2 x 168 hdtv format | projection screens | da-lite |     27149 |    7864 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2332
rtable_id: 2819
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 |
|:--------------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| sharpie permanent markers fine point - black - 12 count | stationery & office machinery | sharpie | 30001wm   |    8.24 |

Entity B:
| title                                                             | category                       | brand   | modelno   |   price |
|:------------------------------------------------------------------|:-------------------------------|:--------|:----------|--------:|
| sharpie 37074 - permanent markers ultra fine point assorted 4 set | storage presentation materials | sharpie |           |   22.14 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 978
rtable_id: 18495
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 self trimming rear projection screen - 96 x 120 av format | electronics - general | da-lite |     27903 | 7799.99 |

Entity B:
| title                                                                          | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27514 da-plex unframed rear projection screen - 108 x 144 video format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 561
rtable_id: 13427
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 |
|:-------------------------------------------|:------------------------------|:--------|:----------|--------:|
| post-it notes original notes canary yellow | stationery & office machinery | post-it | 659yw     |      45 |

Entity B:
| title                                                                         | category         | brand   |   modelno |   price |
|:------------------------------------------------------------------------------|:-----------------|:--------|----------:|--------:|
| post-it notes original pad 3 inches x 5 inches canary yellow 12 pads per pack | self-stick notes | post-it |       655 |   16.49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 242
rtable_id: 10180
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 |
|:----------------------------------------------------------------------|:-----------------|:----------|:----------|--------:|
| night owl no-8lcd security products 8 lcd security monitor with audio | garden - general | night owl | no-8lcd   |     100 |

Entity B:
| title                                                                   | category                   | brand            | modelno   |   price |
|:------------------------------------------------------------------------|:---------------------------|:-----------------|:----------|--------:|
| night owl security no-8lcd 8-inch color lcd security monitor with audio | security monitors displays | night owl optics | no-8lcd   |   99.94 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2516
rtable_id: 20309
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 |
|:-----------------------------------------------|:----------------------|:-----------|:-------------|--------:|
| case logic 13.3 black neoprene notebook sleeve | electronics - general | case logic | pls-13 black |      20 |

Entity B:
| title                                         | category   | brand          | modelno   |   price |
|:----------------------------------------------|:-----------|:---------------|:----------|--------:|
| icon-icon4-blk neoprene notebook sleeve black | bags cases | motion systems | icon4-blk |    9.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2392
rtable_id: 13803
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 |
|:-----------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| smead 5 expansion end tab file pockets w tyvek straight letter manila 10 box | stationery & office machinery |         |     75174 |   37.94 |

Entity B:
| title                                                            | category                       | brand   | modelno   | price   |
|:-----------------------------------------------------------------|:-------------------------------|:--------|:----------|:--------|
| smead 75604 - recycled top tab file jacket letter manila 100 box | storage presentation materials | smead   |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1338
rtable_id: 16371
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 |
|:-----------------------------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| pendaflex cutless watershed file folders 1 3 cut top tab letter manila 100 per box | stationery & office machinery |         |     48434 |   22.69 |

Entity B:
| title                                                                                                   | category            | brand     | modelno   | price   |
|:--------------------------------------------------------------------------------------------------------|:--------------------|:----------|:----------|:--------|
| new-pendaflex 48434 - cutless watershed file folders 1 3 cut top tab letter assorted 100 box - ess48434 | laminating supplies | pendaflex |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1699
rtable_id: 17103
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 |
|:-----------------------------------------------|:-----------|:--------|:------------|--------:|
| corsair flash voyager 32gb usb 3.0 flash drive | usb drives | corsair | cmfvy3-32gb |   74.88 |

Entity B:
| title                                                                | category         | brand   | modelno         |   price |
|:---------------------------------------------------------------------|:-----------------|:--------|:----------------|--------:|
| corsair flash voyager mini 16 gb usb 2.0 flash drive cmfusbmini-16gb | usb flash drives | corsair | cmfusbmini-16gb |   23.89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2537
rtable_id: 14425
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 |
|:--------------------------------|:----------------------|:------------|----------:|--------:|
| diaper dude eco green ipad case | electronics - general | diaper dude |    207491 |      25 |

Entity B:
| title                                              | category                            | brand       | modelno            |   price |
|:---------------------------------------------------|:------------------------------------|:------------|:-------------------|--------:|
| diaper dude eco black ipad case digi-ipadpetblk100 | laptop netbook computer accessories | diaper dude | digi-ipadpetblk100 |      25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 468
rtable_id: 18940
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 |
|:--------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec 3.5 ide to usb 2.0 nexstar 3 hard drive enclosure onyx black | electronics - general | vantec  | nst-360u2-bk |   30.23 |

Entity B:
| title                                                                                     | category             | brand   | modelno      |   price |
|:------------------------------------------------------------------------------------------|:---------------------|:--------|:-------------|--------:|
| vantec usa nexstar cx 2.5-inch sata to usb 3.0 external hard drive enclosure nst-200s3-bk | external hard drives | vantec  | nst-200s3-bk |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 793
rtable_id: 15291
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 |
|:-----------------------------|:-----------|:--------|:----------|--------:|
| canon cli-226 black ink tank | printers   | canon   | 4546b001  |   13.97 |

Entity B:
| title                              | category          | brand   | modelno   |   price |
|:-----------------------------------|:------------------|:--------|:----------|--------:|
| canon pixma cli-8bk black ink tank | printer ink toner | canon   | 0620b002  |     8.6 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2365
rtable_id: 10549
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 |
|:---------------------------------------------|:-----------|:--------|----------:|--------:|
| imation 26654 swivel 8gb usb2 .0 flash drive | usb drives | imation |     26654 |   25.84 |

Entity B:
| title                          | category         | brand   |   modelno |   price |
|:-------------------------------|:-----------------|:--------|----------:|--------:|
| imation 8gb swivel flash drive | usb flash drives | imation |     26654 |   17.58 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2100
rtable_id: 20731
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 |
|:--------------------------------------------------------|:----------------------|:--------|:------------|--------:|
| coolmax 3.5 usb 3.0 external hard drive enclosure black | electronics - general | coolmax | hd-381bz-u3 |   26.88 |

Entity B:
| title                                                                                            | category              | brand   | modelno      |   price |
|:-------------------------------------------------------------------------------------------------|:----------------------|:--------|:-------------|--------:|
| vantec nexstar sx nst-285s2-bk 2.5-inch sata to usb 2.0 external hard drive enclosure onyx black | hard drive enclosures | vantec  | nst-285s2-bk |   18.06 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1429
rtable_id: 4044
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 |
|:-----------------------------------------|:------------------------------|:-----------|----------:|--------:|
| paper mate mechanical pencil starter set | stationery & office machinery | paper mate |   1739312 |    4.87 |

Entity B:
| title                                                                                           | category            | brand      | modelno   |   price |
|:------------------------------------------------------------------------------------------------|:--------------------|:-----------|:----------|--------:|
| paper mate 1739311 - megalead mechanical pencil starter set 0.5 mm 2 erasure refills red barrel | printer accessories | paper mate |           |   23.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1559
rtable_id: 18207
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 |
|:-------------------------------------------------|:------------------------------|:--------|:----------|--------:|
| hp c6567b coated paper 1 roll 42-inches x 150 ft | stationery & office machinery | hp      | c6567b    |   69.88 |

Entity B:
| title                                     | category   | brand   | modelno   |   price |
|:------------------------------------------|:-----------|:--------|:----------|--------:|
| hp coated paper 42 inches x 150 feet roll | roll paper | hp      | c6567b    |   51.96 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 908
rtable_id: 13023
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 |
|:--------------------------------------------------------------------|:----------------------|:--------|----------:|--------:|
| da-lite da-glas standard rear projection screen - 50 x 50 av format | electronics - general | da-lite |     27628 | 1631.99 |

Entity B:
| title                                  | category           | brand   | modelno   |   price |
|:---------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite - projection screen repair kit | projection screens | da-lite |           |     332 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2361
rtable_id: 21794
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 |
|:----------------------------------------------|:----------------------|:--------|:-----------|--------:|
| xfx amd radeon hd 6950 1gb ddr5 graphics card | electronics - general | xfx     | hd695xzndc |  269.82 |

Entity B:
| title                                 | category       | brand   | modelno    |   price |
|:--------------------------------------|:---------------|:--------|:-----------|--------:|
| radeon xfx hd 6970 2 gb graphics card | graphics cards | xfx     | hd697acnfc |  349.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 673
rtable_id: 19394
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 |
|:-----------------------------------|:----------------------|:--------|:------------|--------:|
| philips 6-outlet 3 surge protector | electronics - general | philips | spp3160c/17 |       0 |

Entity B:
| title                                                         | category         | brand   | modelno      | price   |
|:--------------------------------------------------------------|:-----------------|:--------|:-------------|:--------|
| philips spp2217wa 6-outlet home theater surge protector black | surge protectors | philips | spp2217wa/17 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1825
rtable_id: 15665
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 |
|:----------------------------------------------|:-----------|:--------|:----------|--------:|
| lexmark e450h11a toner 11000 page-yield black | printers   | lexmark | e450h11a  |  248.27 |

Entity B:
| title                                | category           | brand   | modelno   |   price |
|:-------------------------------------|:-------------------|:--------|:----------|--------:|
| e260a21a toner 3500 page-yield black | inkjet printer ink | lexmark |           |  160.71 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1816
rtable_id: 1218
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 |
|:----------------------------------------------------|:-----------|:--------|:----------|--------:|
| aoc 2236vw 22 widescreen lcd monitor in piano black | monitors   | aoc     | 2236vw    |     129 |

Entity B:
| title                                              | category   | brand   | modelno   |   price |
|:---------------------------------------------------|:-----------|:--------|:----------|--------:|
| asus vh236h 23 inch widescreen lcd monitor - black | monitors   | asus    | vh236h    |     179 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 871
rtable_id: 20574
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 |
|:---------------------------------------------------------|:------------|:--------|:------------|--------:|
| iosafe rugged 750gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa70750u1yr |  139.98 |

Entity B:
| title                                                                                                 | category             | brand   |   modelno | price   |
|:------------------------------------------------------------------------------------------------------|:---------------------|:--------|----------:|:--------|
| lacie rugged all-terrain 500 gb firewire 800 firewire 400 usb 2.0 portable external hard drive 301371 | external hard drives | lacie   |    301371 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 176
rtable_id: 14743
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 |
|:--------------------------------------------------|:-----------|:----------|:----------|--------:|
| microsoft wireless mobile mouse 4000 sgkomen pink | mice       | microsoft | d5d-00052 |      20 |

Entity B:
| title                                            | category   | brand     | modelno     | price   |
|:-------------------------------------------------|:-----------|:----------|:------------|:--------|
| microsoft wireless mobile mouse 3000 deep purple | mice       | microsoft | 1359 , 1051 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 219
rtable_id: 4635
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 |
|:-----------------------------------------------------|:-----------|:--------------|----------:|--------:|
| master caster big foot no-slip rubber wedge gray 2pk | home care  | master caster |       972 |    8.79 |

Entity B:
| title                                                                                              | category            | brand         | modelno   | price   |
|:---------------------------------------------------------------------------------------------------|:--------------------|:--------------|:----------|:--------|
| master caster 00971 - big foot doorstop no-slip rubber wedge 2-1 4w x 4-3 4d x 1-1 4h brown 2 pack | laminating supplies | master caster |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2257
rtable_id: 20424
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 |
|:----------------------------------------|:-----------|:--------|:-----------------|--------:|
| hp 901 black inkjet cartridge twin pack | printers   | hp      | hp cz075fn # 140 |   26.98 |

Entity B:
| title                                                               | category           | brand   | modelno       | price   |
|:--------------------------------------------------------------------|:-------------------|:--------|:--------------|:--------|
| hp 98 black ink cartridge in retail packaging twin pack c9514fn 140 | inkjet printer ink | hp      | c9514fn # 140 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 883
rtable_id: 3053
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 |
|:-----------------------------------------------------------------|:-----------|:---------|:--------------|--------:|
| kingston kth-mlg4 2g 2gb ddr2 240-pin sdram server memory module | memory     | kingston | kth-mlg4 / 2g |   55.92 |

Entity B:
| title                                                               | category   | brand    | modelno       |   price |
|:--------------------------------------------------------------------|:-----------|:---------|:--------------|--------:|
| kingston memory - 2 gb 2 x 1 gb - dimm 240-pin - ddr ii kth-mlg4 2g | memory     | kingston | kth-mlg4 / 2g |   52.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1937
rtable_id: 8500
label: 1