Datasets:
Tasks:
Text Classification
Languages:
English
Multilinguality:
monolingual
Size Categories:
10K<n<100K
Language Creators:
found
Source Datasets:
extended|app_reviews
License:
| # Copyright 2022 Frankie Robertson and The HuggingFace Datasets Authors | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """ | |
| This dataset is a quick-and-dirty benchmark for predicting ratings across | |
| different domains and on different rating scales based on text. It pulls in a | |
| bunch of rating datasets, takes at most 1000 instances from each and combines | |
| them into a big dataset. | |
| """ | |
| import datasets | |
| from dataclasses import dataclass | |
| from typing import Callable, Any | |
| import operator | |
| import shutil | |
| import os | |
| import sys | |
| from os.path import join as pjoin | |
| from datasets import concatenate_datasets, load_dataset | |
| class SubDataset: | |
| source: Any | |
| nick: str | |
| scale_points: int | |
| get_review: Callable[[Any], Any] | |
| get_rating: Callable[[Any], Any] | |
| def warn(msg): | |
| print(file=sys.stderr) | |
| print(f" ** Warning: {msg} **", file=sys.stderr) | |
| print(file=sys.stderr) | |
| class SplitHFSrc: | |
| name: str | |
| def load(self): | |
| return load_dataset(self.name, streaming=True) | |
| class TrainOnlyHFSrc: | |
| name: str | |
| def load(self): | |
| if hasattr(self, "_cached"): | |
| return self._cached | |
| self._cached = load_dataset(self.name)["train"].train_test_split(test_size=0.5, seed=42) | |
| return self._cached | |
| _kaggle_api = None | |
| def get_kaggle_api(): | |
| global _kaggle_api | |
| if _kaggle_api is not None: | |
| return _kaggle_api | |
| from kaggle.api.kaggle_api_extended import KaggleApi | |
| _kaggle_api = KaggleApi() | |
| _kaggle_api.authenticate() | |
| return _kaggle_api | |
| class KaggleSrc: | |
| name: str | |
| file: str | |
| def load(self): | |
| if hasattr(self, "_cached"): | |
| return self._cached | |
| kaggle_api = get_kaggle_api() | |
| dir_name = self.name.replace("/", "__") | |
| if os.path.exists(dir_name): | |
| shutil.rmtree(dir_name) | |
| os.mkdir(dir_name) | |
| try: | |
| file_path = pjoin(dir_name, self.file.rsplit("/", 1)[-1]) | |
| kaggle_api.dataset_download_file(self.name, self.file, path=dir_name) | |
| dataset = load_dataset("csv", data_files=file_path + ".zip") | |
| return dataset["train"].train_test_split(test_size=0.5, seed=42) | |
| finally: | |
| shutil.rmtree(dir_name) | |
| def int_or_drop(col): | |
| def inner(row): | |
| try: | |
| n = float(row[col]) | |
| except ValueError: | |
| return None | |
| return round_near(n) | |
| return inner | |
| gi = operator.itemgetter | |
| def round_near(x, eps=0.001): | |
| x_rnd = int(x + 0.5) | |
| if abs(x_rnd - x) > eps: | |
| warn("got {x_rnd} when rounding {x}") | |
| return x_rnd | |
| def dec(inner): | |
| def wrap(x): | |
| y = inner(x) | |
| if y is None: | |
| return None | |
| res = y - 1 | |
| if res < 0: | |
| warn( | |
| "tried to convert 1-based index to 0-based index " | |
| "but ended up with negative" | |
| ) | |
| return res | |
| return wrap | |
| DATASETS = [ | |
| SubDataset(SplitHFSrc("juliensimon/amazon-shoe-reviews"), "amazon-shoes", 5, gi("text"), gi("labels")), | |
| # TODO: Appears to be corrupt | |
| #SubDataset("florentgbelidji/edmunds-car-ratings", "car-ratings", 40, lambda row: row["Review"].strip(), lambda row: round_near(row["Rating"] * 8) - 7), | |
| SubDataset(TrainOnlyHFSrc("florentgbelidji/car-reviews"), "car-ratings", 5, gi("Review"), dec(gi("Rating"))), | |
| SubDataset(SplitHFSrc("codyburker/yelp_review_sampled"), "yelp", 5, gi("text"), dec(gi("stars"))), | |
| SubDataset(SplitHFSrc("kkotkar1/course-reviews"), "course-reviews", 5, gi("review"), dec(gi("label"))), | |
| SubDataset(TrainOnlyHFSrc("app_reviews"), "app-reviews", 5, gi("review"), dec(gi("star"))), | |
| SubDataset(TrainOnlyHFSrc("LoganKells/amazon_product_reviews_video_games"), "amazon-games", 5, gi("reviewText"), lambda row: round_near(row["overall"])), | |
| SubDataset(KaggleSrc("zynicide/wine-reviews", "winemag-data-130k-v2.csv"), "wine-reviews", 100, gi("description"), dec(gi("points"))), | |
| SubDataset(KaggleSrc("sadmadlad/imdb-user-reviews", "Pulp Fiction/movieReviews.csv"), "imdb-user-reviews", 10, gi("Review"), dec(int_or_drop("User's Rating out of 10"))), | |
| # TODO: Unicode decoding error | |
| #SubDataset(KaggleSrc("arushchillar/disneyland-reviews", "DisneylandReviews.csv"), "disneyland-reviews", 5, gi("Review_Text"), gi("Rating")), | |
| ] | |
| _DESCRIPTION = __doc__ | |
| _HOMEPAGE = "" | |
| _LICENSE = "Mixed" | |
| class CrossDomainReviews(datasets.GeneratorBasedBuilder): | |
| _DESCRIPTION | |
| VERSION = datasets.Version("1.0.0") | |
| def _info(self): | |
| features = datasets.Features( | |
| { | |
| "text": datasets.Value("string"), | |
| "rating": datasets.Value("uint8"), | |
| "scale_points": datasets.Value("uint8"), | |
| "dataset": datasets.ClassLabel(names=[ds.nick for ds in DATASETS]) | |
| } | |
| ) | |
| return datasets.DatasetInfo( | |
| # This is the description that will appear on the datasets page. | |
| description=_DESCRIPTION, | |
| # This defines the different columns of the dataset and their types | |
| features=features, # Here we define them above because they are different between the two configurations | |
| # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and | |
| # specify them. They'll be used if as_supervised=True in builder.as_dataset. | |
| supervised_keys=("text", "rating"), | |
| # Homepage of the dataset for documentation | |
| homepage=_HOMEPAGE, | |
| # License for the dataset if available | |
| license=_LICENSE, | |
| # Citation for the dataset | |
| citation="", | |
| ) | |
| def _split_generators(self, dl_manager): | |
| return [ | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TRAIN, | |
| gen_kwargs={ | |
| "split": "train", | |
| }, | |
| ), | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TEST, | |
| gen_kwargs={ | |
| "split": "test" | |
| }, | |
| ), | |
| ] | |
| def _generate_examples(self, split): | |
| key = 0 | |
| for ds_info in DATASETS: | |
| subdataset = ds_info.source.load() | |
| lowest = float("inf") | |
| highest = float("-inf") | |
| got = 0 | |
| for row in subdataset[split]: | |
| review = ds_info.get_review(row) | |
| if review is None: | |
| continue | |
| rating = ds_info.get_rating(row) | |
| if rating is None: | |
| continue | |
| assert 0 <= rating < ds_info.scale_points, f"Expected {rating} in half-open (Python-style) range [0, {ds_info.scale_points})" | |
| lowest = min(lowest, rating) | |
| highest = max(highest, rating) | |
| yield key, { | |
| "text": review, | |
| "rating": rating, | |
| "scale_points": ds_info.scale_points, | |
| "dataset": ds_info.nick | |
| } | |
| key += 1 | |
| got += 1 | |
| if got >= 1000: | |
| break | |
| if lowest != 0: | |
| warn( | |
| f"Lowest rating in {ds_info.nick} was {lowest}, " | |
| "would suppose it would be 0" | |
| ) | |
| if highest != ds_info.scale_points - 1: | |
| warn( | |
| f"Highest rating in {ds_info.nick} was {highest}, " | |
| f"would suppose it would be {ds_info.scale_points - 1}" | |
| ) | |