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 |
|:-----------------------------------------------------------------|:------------------------------|:--------|----------:|--------:|
| sharpie retractable permanent markers fine point set of 12 black | stationery & office machinery | sharpie |     32701 |   13.64 |

Entity B:
| title                                                              | category   | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:-----------|:--------|:----------|--------:|
| sharpie 1735792 - retractable ultra fine tip permanent marker blue | headphones | sharpie |           |   20.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1241
rtable_id: 16633
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 |
|:----------------------------------------------|:----------------------|:----------------|:------------|--------:|
| syba internal pci 4-port sata controller card | electronics - general | syba multimedia | sd-89300656 |   23.82 |

Entity B:
| title                                                                                | category              | brand                     | modelno     |   price |
|:-------------------------------------------------------------------------------------|:----------------------|:--------------------------|:------------|--------:|
| syba sd-sata2-4ir pci sata ii 4x internal ports raid controller with sil3124 chipset | computers accessories | global marketing partners | sd-81012336 |   38.31 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1942
rtable_id: 1587
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 250gb usb 3.0 portable external hard drive | hard drives | iosafe  | pa50250u5yr |  249.99 |

Entity B:
| title                                                           | category             | brand   |   modelno |   price |
|:----------------------------------------------------------------|:---------------------|:--------|----------:|--------:|
| lacie rikiki 320 gb usb 2.0 portable external hard drive 301908 | external hard drives | lacie   |    301908 |   64.24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 672
rtable_id: 14737
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 deluxe rear projection screen - 58 x 104 hdtv format | electronics - general | da-lite |     27571 | 4629.99 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite data pro thru-the-wall rear projection screen - 52 x 92 hdtv format | projection screens | da-lite |     23181 | 15985.8 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2220
rtable_id: 6740
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 green ipad case digi-ipadpet10 | laptop netbook computer accessories | diaper dude | digi-ipadpet10 |      25 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 468
rtable_id: 20645
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 |
|:---------------------------------------------------|:----------------------|:----------|:----------|--------:|
| panasonic slimz over-ear headphone green rp-hx40-g | electronics - general | panasonic | rp-hx40-g |   34.88 |

Entity B:
| title                                                     | category   | brand     | modelno     |   price |
|:----------------------------------------------------------|:-----------|:----------|:------------|--------:|
| panasonic rp-hje350-p slimz in-ear earbud headphones pink | headphones | panasonic | rp-hje350-p |   17.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 140
rtable_id: 7758
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 |
|:-------------------------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m552 dark pink 14mp digital camera w 5x optical zoom 2.7 lcd display w 50 bonus prints | digital cameras | kodak   | m552pink  |   94.54 |

Entity B:
| title                                                                                              | category                    | brand   |   modelno |   price |
|:---------------------------------------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| kodak easyshare m532 14 mp digital camera with 4x optical zoom and 2.7-inch lcd - silver new model | point shoot digital cameras | kodak   |   8377129 |      89 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2149
rtable_id: 2871
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 matte white designer model b with fabric case in frost gray - 84 x 84 av format | electronics - general | da-lite |     73139 |  222.99 |

Entity B:
| title                                                                                      | category           | brand   | modelno   | price   |
|:-------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| video spectra 1.5 designer model b with fabric case in frost gray - av format size 50 x 50 | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 418
rtable_id: 1306
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 |
|:------------------------------------------------------|:-----------|:---------|:----------|--------:|
| startech.com cb2ec expresscard to pcmcia adapter card | networking | startech | cb2ec     |   52.82 |

Entity B:
| title                                                             | category            | brand    | modelno   |   price |
|:------------------------------------------------------------------|:--------------------|:---------|:----------|--------:|
| startech.com expresscard cf media memory card reader writer cf2ec | memory card readers | startech | cf2ec     |   12.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 906
rtable_id: 14049
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 |
|:--------------------------------------------------------------------------------------|:--------------------|:--------|----------:|--------:|
| advantus premier heavy-duty retractable id card reel 24 extension black chrome 12 box | accessories apparel |         |     75406 |   60.94 |

Entity B:
| title                                                                                                        | category     | brand    | modelno   |   price |
|:-------------------------------------------------------------------------------------------------------------|:-------------|:---------|:----------|--------:|
| new-advantus 75406 - premier heavy-duty retractable id card reel 24 extension black chrome 12 box - avt75406 | label makers | advantus |           |      77 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1248
rtable_id: 16298
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 |
|:----------------------------------|:------------------------------|:--------|----------:|--------:|
| inland pro 8-sheet paper shredder | stationery & office machinery | inland  |      5302 |   47.54 |

Entity B:
| title                           | category   | brand   |   modelno |   price |
|:--------------------------------|:-----------|:--------|----------:|--------:|
| inland pro 05303 paper shredder | shredders  | inland  |      5303 |   45.33 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1391
rtable_id: 6908
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 ce505xd black laserjet print cartridges 2pk | printers   | hp      | hp ce505xd |  258.84 |

Entity B:
| title                                                     | category            | brand   | modelno   |   price |
|:----------------------------------------------------------|:--------------------|:--------|:----------|--------:|
| hp laserjet 42a black print cartridge in retail packaging | laser printer toner | hp      | q5942a    |     125 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 95
rtable_id: 1034
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 |
|:------------------------------------------|:-----------|:---------|:---------------|--------:|
| sylvania 4gb touch video mp3 player black | mp3        | sylvania | smpk4230-black |      35 |

Entity B:
| title                                                      | category    | brand   | modelno   |   price |
|:-----------------------------------------------------------|:------------|:--------|:----------|--------:|
| rca 4gb flash mp3 player m3904 with video playback - black | mp3 players | rca     |           |   49.68 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2484
rtable_id: 15587
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 |
|:--------------------------------------|:-----------|:--------|:----------|--------:|
| brother tn110bk black toner cartridge | printers   | brother | tn110bk   |   49.88 |

Entity B:
| title                              | category           | brand   | modelno   |   price |
|:-----------------------------------|:-------------------|:--------|:----------|--------:|
| brother lc51bk black ink cartridge | inkjet printer ink | brother | lc51bk    |   17.61 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2349
rtable_id: 14183
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 |
|:-----------------------------------------------------------------------------------------|:----------------|:--------|:----------|--------:|
| kodak easyshare m530 red 12mp digital camera w 3x optical zoom 2.7 lcd w 50 bonus prints | digital cameras | kodak   | m530 red  |   99.54 |

Entity B:
| title                                                                                                   | category                    | brand   |   modelno |   price |
|:--------------------------------------------------------------------------------------------------------|:----------------------------|:--------|----------:|--------:|
| kodak easyshare mini m200 10 mp digital camera with 3x optical zoom and 2.5-inch lcd - purple new model | point shoot digital cameras | kodak   |   1944685 |   79.51 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 688
rtable_id: 4785
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 |
|:-----------------------------------------|:-----------|:-------------|----------:|--------:|
| pc treasures clickit classic mouse black | mice       | pc treasures |      7667 |    16.8 |

Entity B:
| title                                               | category   | brand        |   modelno |   price |
|:----------------------------------------------------|:-----------|:-------------|----------:|--------:|
| pc treasures clickit classic mouse - titanium 07672 | mice       | pc treasures |      7672 |   16.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1952
rtable_id: 7747
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 |
|:-----------------------------------------|:-----------|:----------------|----------:|--------:|
| channel sources defender pro 5-in-1 2010 | software   | channel sources |     80534 |      28 |

Entity B:
| title                                                      | category                | brand           | modelno   |   price |
|:-----------------------------------------------------------|:------------------------|:----------------|:----------|--------:|
| channel sources 080398 10pk defender pro 2010 15 in 1 lics | audio video accessories | channel sources |           |  106.08 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1130
rtable_id: 21242
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 matte white scenic roller manual screen - 15 x 20 | electronics - general | da-lite |     40320 | 2285.99 |

Entity B:
| title                                                                                         | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite scenic roller 21 x 28 35 diagonal manually operated roll-up screen matte white fabric | projection screens | da-lite |           | 2169.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1390
rtable_id: 18269
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 |
|:------------------------------------------|:----------------|:--------|:----------|--------:|
| ipod touch 4 fitted case tasty cakes pink | mp3 accessories | speck   | spk-a0405 |       0 |

Entity B:
| title                             | category               | brand   | modelno   | price   |
|:----------------------------------|:-----------------------|:--------|:----------|:--------|
| case ipod touch 4 soft gloss pink | mp3 player accessories | unknown |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1807
rtable_id: 21800
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 |
|:--------------------------------------------|:-----------|:-------------------|:----------|--------:|
| clover loc200 lock box with fan for vcr dvr | computers  | clover electronics | loc200    |   94.24 |

Entity B:
| title                                                              | category             | brand   | modelno   |   price |
|:-------------------------------------------------------------------|:---------------------|:--------|:----------|--------:|
| clover electronics loc200 vcr dvr lock box with fan - medium black | surveillance cameras | clover  | loc200    |   91.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2244
rtable_id: 594
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 xms2 4 gb 2 x 2 gb pc2-6400 800 mhz 240-pin ddr2 dual-channel memory kit - twin2x4096-6400c5 | memory     | corsair | twin2x4096-6400c5 |   74.82 |

Entity B:
| title                                                                                                             | category   | brand   | modelno         |   price |
|:------------------------------------------------------------------------------------------------------------------|:-----------|:--------|:----------------|--------:|
| corsair xms3 dhx 4gb 2 x 2gb pc3-10666 1333mhz 240-pin ddr3 cl9 dual channel desktop memory kit - tw3x4g1333c9dhx | memory     | corsair | tw3x4g1333c9dhx |   54.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2037
rtable_id: 552
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 laptop roller bag destination | computers  | microsoft |     39203 |  102.88 |

Entity B:
| title                                                 | category   | brand     |   modelno |   price |
|:------------------------------------------------------|:-----------|:----------|----------:|--------:|
| microsoft 39203 laptop roller bag - destination black | bags cases | microsoft |     39203 |  102.88 |



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

Entity B:
| title                                                                   | category             | brand    |   modelno | price   |
|:------------------------------------------------------------------------|:---------------------|:---------|----------:|:--------|
| verbatim 320 gb usb 2.0 firewire 400 portable external hard drive 96527 | external hard drives | verbatim |     96527 |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2305
rtable_id: 158
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 |
|:------------------------------------------------|:----------------------|:--------|:-----------------|--------:|
| v7 25 cat5e snagless network patch cable yellow | electronics - general | v7      | v7n3c5e-25f-ylws |    6.88 |

Entity B:
| title                                                                                       | category        | brand   | modelno          |   price |
|:--------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male blue 1-foot v7n3c5e-01f-blus | ethernet cables | v7      | v7n3c5e-01f-blus |    1.19 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 458
rtable_id: 13308
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 - 84 x 84 av format | electronics - general | da-lite |     27650 | 4958.99 |

Entity B:
| title                                                                      | category           | brand   | modelno   | price   |
|:---------------------------------------------------------------------------|:-------------------|:--------|:----------|:--------|
| da-lite 27912 da-glas unframed rear projection screen - 96 x 120 av format | projection screens | da-lite |           |         |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2389
rtable_id: 18444
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 |
|:----------------------------------------------------|:----------------------|:--------------|:----------|--------:|
| creative labs sound blaster x-fi go pro sound board | electronics - general | creative labs | sb1290    |   39.99 |

Entity B:
| title                                                               | category             | brand         | modelno       |   price |
|:--------------------------------------------------------------------|:---------------------|:--------------|:--------------|--------:|
| creative labs sb0790 pci sound blaster x-fi xtreme audio sound card | internal sound cards | creative labs | 70sb079000000 |   35.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1609
rtable_id: 8506
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 |
|:----------------------------------------------------|:----------------|:-------------------|:----------|--------:|
| griffin technology outfit gloss ipod touch 4g black | mp3 accessories | griffin technology | gb01967   |   24.99 |

Entity B:
| title                                                    | category   | brand              | modelno   |   price |
|:---------------------------------------------------------|:-----------|:-------------------|:----------|--------:|
| griffin technology formfit for ipod touch 4g black black | cases      | griffin technology | gb01958   |   11.12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 218
rtable_id: 7055
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   |           |       0 |

Entity B:
| title                        | category           | brand   | modelno   |   price |
|:-----------------------------|:-------------------|:--------|:----------|--------:|
| canon cli-221 ink tank black | inkjet printer ink | canon   | 2946b001  |   12.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1334
rtable_id: 646
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 |
|:----------------------------------------------------------|:------------|:--------|:-----------------|--------:|
| samsung s2 640gb usb 3.0 portable external hard drive red | hard drives | samsung | hx-mta64da / g42 |   78.88 |

Entity B:
| title                                                                             | category             | brand   | modelno       |   price |
|:----------------------------------------------------------------------------------|:---------------------|:--------|:--------------|--------:|
| toshiba canvio plus 1 tb usb 3.0 portable external hard drive e05a100pbu3xs black | external hard drives | toshiba | e05a100pbu3xs |   95.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 896
rtable_id: 13351
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 thru-the-wall rear projection screen - 78 x 139 hdtv format | electronics - general | da-lite |     23077 |   11386 |

Entity B:
| title                                                                       | category           | brand   |   modelno |   price |
|:----------------------------------------------------------------------------|:-------------------|:--------|----------:|--------:|
| da-lite da-plex thru-the-wall rear projection screen - 78 x 139 hdtv format | projection screens | da-lite |     23077 | 9258.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2471
rtable_id: 19283
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 |
|:-------------------------------------------|:----------------------|:--------|:----------|--------:|
| los angeles lakers ipod touch 4g hard case | electronics - general | tribeca | fva4614   |   29.99 |

Entity B:
| title                                       | category              | brand   | modelno   |   price |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| san francisco 49ers ipod touch 4g hard case | computers accessories | tribeca |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1365
rtable_id: 8795
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 |
|:----------------------------------------------------|:----------------------|:--------|:----------------|--------:|
| v7 10 cat6 snagless molded network patch cable gray | electronics - general | v7      | v7n2c6-10f-grys |    5.88 |

Entity B:
| title                                                                                          | category        | brand   | modelno          |   price |
|:-----------------------------------------------------------------------------------------------|:----------------|:--------|:-----------------|--------:|
| v7 cat5e snagless molded network patch cable rj45 male to male yellow 10-feet v7n3c5e-10f-ylws | ethernet cables | v7      | v7n3c5e-10f-ylws |    8.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 117
rtable_id: 1337
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 |
|:--------------------------------------------|:----------------------|:--------|:----------|--------:|
| washington redskins ipod touch 4g hard case | computers accessories | tribeca |           |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2191
rtable_id: 4029
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 |
|:------------------------------------|:----------------|:---------|:---------------|--------:|
| simplism shoulder case for ipad red | mp3 accessories | simplism | trlcslipaddren |   58.76 |

Entity B:
| title                                    | category      | brand    | modelno         |   price |
|:-----------------------------------------|:--------------|:---------|:----------------|--------:|
| simplism silicone case set for ipad blue | cases sleeves | simplism | tr-scipad-bl/en |   13.42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 741
rtable_id: 3535
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 video spectra 1.5 model b manual screen with csr - 69 x 92 video format | electronics - general | da-lite |     85322 |  429.99 |

Entity B:
| title                                                                                   | category           | brand   | modelno   |   price |
|:----------------------------------------------------------------------------------------|:-------------------|:--------|:----------|--------:|
| da-lite advantage manual with csr - projection screen - 4 3 - video spectra 1.5 - white | projection screens | da-lite |           |  636.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 665
rtable_id: 4733
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 |
|:----------------------------------|:-----------|:--------|:----------|--------:|
| ibm 28p2010 black toner cartridge | printers   | ibm     | 28p2010   |     425 |

Entity B:
| title                               | category            | brand   | modelno   |   price |
|:------------------------------------|:--------------------|:--------|:----------|--------:|
| brother black toner cartridge tn420 | laser printer toner | brother | tn420     |   30.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1405
rtable_id: 2280
label: 0