Datasets:
Tasks:
Text Classification
Languages:
English
Multilinguality:
monolingual
Size Categories:
100K<n<1M
Language Creators:
found
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. | |
""" | |
Cleaned up version of the rotten tomatoes critic reviews dataset. The original | |
is obtained from Kaggle: | |
https://www.kaggle.com/datasets/stefanoleone992/rotten-tomatoes-movies-and-critic-reviews-dataset | |
Data has been scraped from the publicly available website | |
https://www.rottentomatoes.com as of 2020-10-31. | |
The clean up process drops anything without both a review and a rating, as well | |
as standardising the ratings onto several integer, ordinal scales. | |
""" | |
import datasets | |
from dataclasses import dataclass | |
from fractions import Fraction | |
from typing import Callable, Any | |
import operator | |
import shutil | |
import os | |
import sys | |
import pandas | |
import numpy | |
from os.path import join as pjoin | |
from datasets import Dataset | |
from sklearn.model_selection import train_test_split | |
KAGGLE_REPO = "stefanoleone992/rotten-tomatoes-movies-and-critic-reviews-dataset" | |
SHORT_LETTER_SCALE = ["F", "E", "D", "C", "B", "A"] | |
LONG_LETTER_SCALE = ["F-", "F", "F+" "E-", "E", "E+", "D-", "D", "D+", "C-", "C", "C+", "B-", "B", "B+", "A-", "A", "A+"] | |
_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) | |
return pandas.read_csv(file_path + ".zip") | |
finally: | |
shutil.rmtree(dir_name) | |
def is_floatable(f): | |
try: | |
float(f) | |
return True | |
except ValueError: | |
return False | |
def is_frac_str(s): | |
bits = s.split("/") | |
return len(bits) == 2 and is_floatable(bits[0]) and is_floatable(bits[1]) | |
def is_barenum_str(s): | |
return s.count("/") == 0 and is_floatable(s) | |
def is_dec_denom(s): | |
bits = s.split("/") | |
return len(bits) == 2 and "." in bits[1] | |
def drop_because(df, pred, reason): | |
print(f"Dropping {pred.sum()} ({pred.mean() * 100:.2f}%) of reviews with {reason}") | |
return df[~pred] | |
def drop_unrated(df): | |
df = drop_because(df, df["review_score"].isna(), "no rating") | |
df = drop_because(df, df["review_content"].isna(), "missing review") | |
return df | |
def drop_odd_grade_types(df): | |
is_any_letter = df["review_score"].isin(LONG_LETTER_SCALE) | |
is_frac = df["review_score"].map(is_frac_str) | |
is_barenum = df["review_score"].map(is_barenum_str) | |
assert len(df[~is_frac & ~is_any_letter & ~is_barenum]) == 0 | |
df = drop_because(df, is_barenum, "bare number rating (i.e. no denominator)") | |
is_frac_denom = df["review_score"].map(is_dec_denom) | |
return drop_because(df, is_frac_denom, "fractional denominator") | |
def split_scores(df): | |
nums = numpy.empty(len(df)) | |
denoms = numpy.empty(len(df)) | |
for idx, score in enumerate(df["review_score"]): | |
if "/" in score: | |
num, denom = score.split("/", 1) | |
nums[idx] = float(num) | |
denoms[idx] = float(denom) | |
else: | |
nums[idx] = nan | |
denoms[idx] = nan | |
df.insert(len(df.columns), "orig_num", nums) | |
df.insert(len(df.columns), "orig_denom", denoms) | |
nan = float("nan") | |
def np_round(arr): | |
return (arr + 0.5).astype(numpy.int32) | |
def common_denom_grades(group_df): | |
if group_df.iloc[0]["is_any_letter"]: | |
group_df["multiplier"] = 1 | |
group_df["non_neg_error"] = False | |
if group_df.iloc[0]["letter_implies_short"]: | |
group_df["num"] = SHORT_LETTER_SCALE.index(group_df.iloc[0]["review_score"]) + 1 | |
group_df["denom"] = len(SHORT_LETTER_SCALE) | |
else: | |
group_df["num"] = LONG_LETTER_SCALE.index(group_df.iloc[0]["review_score"]) + 1 | |
group_df["denom"] = len(LONG_LETTER_SCALE) | |
return group_df | |
denoms = numpy.empty(len(group_df), dtype=numpy.int32) | |
for idx, num in enumerate(group_df["orig_num"]): | |
frac = Fraction.from_float(num) | |
denoms[idx] = frac.limit_denominator(100).denominator | |
common_denom = numpy.lcm.reduce(denoms) | |
group_df["multiplier"] = common_denom | |
num = common_denom * group_df["orig_num"].to_numpy() | |
denom = common_denom * group_df["orig_denom"].to_numpy() | |
group_df["num"] = np_round(num) | |
group_df["denom"] = np_round(denom) | |
group_df["non_neg_error"] = (abs(group_df["num"] - num) >= 0.05) | (abs(group_df["denom"] - denom) >= 0.05) | |
return group_df | |
def normalize_reviews(review_df): | |
# Drop unrated | |
review_df = drop_unrated(review_df) | |
# Strip whitespace from grades | |
review_df["review_score"] = review_df["review_score"].str.replace("\s+", "", regex=True) | |
# Copy to get version to do calculations with | |
working_review_df = review_df.copy() | |
# Drop all rows where the review score occurs 2 or less times in the whole data set | |
working_review_df = working_review_df.groupby("review_score").filter(lambda x: len(x) > 2) | |
# Check/ensure that all grades are short letter, long letter, fraction or barenum | |
working_review_df = drop_odd_grade_types(working_review_df) | |
# Split fraction scores into numerator and denominator | |
split_scores(working_review_df) | |
# Divide letter scales into short and long | |
# If a publisher has a mix of short and long, they're using long, otherwise short | |
is_any_letter = working_review_df["review_score"].isin(LONG_LETTER_SCALE) | |
is_short_letter = working_review_df["review_score"].isin(SHORT_LETTER_SCALE) | |
#is_long_letter = is_any_letter & ~is_short_letter | |
publisher_letter_implies_short = pandas.DataFrame.from_dict(dict( | |
publisher_name=working_review_df["publisher_name"], | |
letter_implies_short=is_short_letter | ~is_any_letter | |
)).groupby("publisher_name").all() | |
working_review_df = working_review_df.join(publisher_letter_implies_short, on="publisher_name") | |
working_review_df["is_any_letter"] = is_any_letter | |
# Now divide everything into grade types: either short letter, long letter | |
# or the denominator of the fraction | |
def get_grade_type(row): | |
if row["is_any_letter"]: | |
if row["letter_implies_short"]: | |
return "short_letter" | |
else: | |
return "long_letter" | |
else: | |
return str(int(row["orig_denom"])) | |
working_review_df["grade_type"] = working_review_df.apply(get_grade_type, axis="columns") | |
# Now we can filter out rare grade types | |
working_review_df = working_review_df.join(working_review_df["grade_type"].value_counts().rename("grade_type_count"), on="grade_type") | |
working_review_df = drop_because(working_review_df, working_review_df["grade_type_count"] < 50, "grade type with less than 50 reviews") | |
# Print out some summary stats | |
print("grades type counts") | |
print(working_review_df["grade_type"].value_counts()) | |
print("unique grades", working_review_df["grade_type"].nunique()) | |
print("unique publishers", working_review_df["publisher_name"].nunique()) | |
print("unique grade/publisher combinations", working_review_df.groupby(["grade_type", "publisher_name"]).ngroups) | |
# Now we can find common denominators on a (publisher, grade type) combination basis | |
working_review_df = working_review_df.groupby(["publisher_name", "grade_type"], group_keys=False).apply(common_denom_grades) | |
working_review_df = drop_because(working_review_df, working_review_df["multiplier"] > 500, "multiplier > 500") | |
assert working_review_df["non_neg_error"].sum() == 0 | |
# More summary stats | |
print("non-neg error count", working_review_df["non_neg_error"].sum()) | |
print("multipliers") | |
print(working_review_df["multiplier"].value_counts()) | |
# TODO: Add back in rare review_scores dropped at the beginning when they | |
# are compatible with some common denominator + grade type from the same | |
# publisher | |
print("number of reviews left", len(working_review_df)) | |
print("reviews per publisher") | |
print(working_review_df.value_counts(["publisher_name", "grade_type"])) | |
# Delete working columns | |
del working_review_df["letter_implies_short"] | |
del working_review_df["is_any_letter"] | |
del working_review_df["grade_type_count"] | |
del working_review_df["non_neg_error"] | |
return working_review_df | |
def save_normalised(output_path): | |
review_df = KaggleSrc(KAGGLE_REPO, "rotten_tomatoes_critic_reviews.csv").load() | |
review_df = normalize_reviews(review_df) | |
review_df.to_csv(output_path) | |
def split_dfs(df): | |
train_dfs = [] | |
test_dfs = [] | |
split_groups = [] | |
small_groups = [] | |
for (publisher_name, grade_type), group_df in df.groupby(["publisher_name", "grade_type"]): | |
if len(group_df) < 50: | |
small_groups.append((publisher_name, grade_type, group_df)) | |
else: | |
split_groups.append((publisher_name, grade_type, group_df)) | |
group_id = 0 | |
group_cols = {"publisher_name": [], "grade_type": [], "group_id": [], "scale_points": []} | |
def add_group(group_df, publisher_name, grade_type): | |
nonlocal group_id | |
group_cols["publisher_name"].append(publisher_name) | |
group_cols["grade_type"].append(grade_type) | |
group_cols["group_id"].append(group_id) | |
group_cols["scale_points"].append(group_df.iloc[0]["denom"]) | |
group_id += 1 | |
for publisher_name, grade_type, group_df in split_groups: | |
train_df, test_df = train_test_split(group_df, test_size=0.2) | |
train_dfs.append(train_df) | |
test_dfs.append(test_df) | |
add_group(group_df, publisher_name, grade_type) | |
for publisher_name, grade_type, group_df in small_groups: | |
train_dfs.append(group_df) | |
add_group(group_df, publisher_name, grade_type) | |
train_df = pandas.concat(train_dfs) | |
test_df = pandas.concat(test_dfs) | |
group_id_df = pandas.DataFrame.from_dict({k: v for k, v in group_cols.items() if k != "scale_points"}) | |
group_id_df.set_index(["publisher_name", "grade_type"], inplace=True) | |
train_df = train_df.join(group_id_df, on=["publisher_name", "grade_type"]) | |
test_df = test_df.join(group_id_df, on=["publisher_name", "grade_type"]) | |
df = df.join(group_id_df, on=["publisher_name", "grade_type"]) | |
group_df = pandas.DataFrame.from_dict(group_cols) | |
return df, train_df, test_df, group_df | |
def get_datasets(): | |
movies_df = KaggleSrc(KAGGLE_REPO, "rotten_tomatoes_movies.csv").load() | |
review_df = KaggleSrc(KAGGLE_REPO, "rotten_tomatoes_critic_reviews.csv").load() | |
review_df = normalize_reviews(review_df) | |
joined_df = review_df.join(movies_df.set_index("rotten_tomatoes_link"), "rotten_tomatoes_link") | |
all_df, train_df, test_df, group_df = split_dfs(joined_df) | |
return ( | |
all_df, | |
train_df, | |
test_df, | |
group_df, | |
) | |
_DESCRIPTION = __doc__ | |
_HOMEPAGE = "" | |
_LICENSE = "CC0" | |
def iter_pandas_df(df, cols): | |
for tpl in df.itertuples(): | |
yield tpl.Index, {k: v for k, v in tpl._asdict().items() if k in cols} | |
NORMAL_FEATURES = datasets.Features({ | |
"movie_title": datasets.Value("string"), | |
"publisher_name": datasets.Value("string"), | |
"critic_name": datasets.Value("string"), | |
"review_content": datasets.Value("string"), | |
"review_score": datasets.Value("string"), | |
"grade_type": datasets.Value("string"), | |
"orig_num": datasets.Value("float"), | |
"orig_denom": datasets.Value("float"), | |
"num": datasets.Value("uint8"), | |
"denom": datasets.Value("uint8"), | |
"multiplier": datasets.Value("uint8"), | |
"group_id": datasets.Value("uint32"), | |
}) | |
class MultiscaleRTCritics(datasets.GeneratorBasedBuilder): | |
_DESCRIPTION | |
VERSION = datasets.Version("1.0.0") | |
def _info(self): | |
return datasets.DatasetInfo( | |
# This is the description that will appear on the datasets page. | |
description=_DESCRIPTION, | |
features=NORMAL_FEATURES, | |
# 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): | |
if not hasattr(self, "_datasets"): | |
self._datasets = get_datasets() | |
all_dataset, train_dataset, test_dataset, group_df = self._datasets | |
cols = set(NORMAL_FEATURES.keys()) | |
if split == "all": | |
yield from iter_pandas_df(all_dataset, cols) | |
elif split == "train": | |
yield from iter_pandas_df(train_dataset, cols) | |
elif split == "test": | |
yield from iter_pandas_df(test_dataset, cols) | |
#else: | |
#yield from iter_pandas_df(group_df) | |