Add train/test splits to dataset, also:

* Print info from normalizing process more neatly
* Keep only selected columns from dataset

multiscale_rt_critics.py

@@ -36,6 +36,7 @@ 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"
@@ -200,7 +201,7 @@ def normalize_reviews(review_df):
 
     # Now divide everything into grade types: either short letter, long letter
     # or the denominator of the fraction
-    def get_orig_grade_type(row):
+    def get_grade_type(row):
         if row["is_any_letter"]:
             if row["letter_implies_short"]:
                 return "short_letter"
@@ -209,33 +210,36 @@ def normalize_reviews(review_df):
         else:
             return str(int(row["orig_denom"]))
 
-    working_review_df["orig_grade_type"] =  working_review_df.apply(get_orig_grade_type, axis="columns")
+    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["orig_grade_type"].value_counts().rename("grade_type_count"), on="orig_grade_type")
+    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", working_review_df["orig_grade_type"].value_counts())
-    print("unique grades", working_review_df["orig_grade_type"].nunique())
+    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(["orig_grade_type", "publisher_name"]).ngroups)
+    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", "orig_grade_type"], group_keys=False).apply(common_denom_grades)
+    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", working_review_df["multiplier"].value_counts())
+    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", working_review_df.groupby(["publisher_name", "orig_grade_type"].value_counts()))
+    print("reviews per publisher")
+    print(working_review_df.value_counts(["publisher_name", "grade_type"]))
 
     # Delete working columns
     del working_review_df["letter_implies_short"]
@@ -252,24 +256,57 @@ def save_normalised(output_path):
     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")
-    train_dfs = []
-    test_dfs = []
-    for group_df in review_df.groupby("publisher_name", "orig_grade_type"):
-        if len(group_df) >= 50:
-            train_df, test_df = train_test_split(group_df, test_size=0.2)
-            train_dfs.append(train_df)
-            test_dfs.append(test_df)
-        else:
-            train_dfs.append(group_df)
+    all_df, train_df, test_df, group_df = split_dfs(joined_df)
     return (
-        Dataset.from_pandas(joined_df),
-        Dataset.from_pandas(pandas.concat(train_dfs)),
-        Dataset.from_pandas(pandas.concat(test_dfs)),
+        all_df,
+        train_df,
+        test_df,
+        group_df,
     )
 
 
@@ -280,44 +317,37 @@ _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):
-        features = datasets.Features(
-            {
-                #"rotten_tomatoes_link": datasets.Value("string"),
-                #"rating": datasets.Value("uint8"),
-                #"out_of": datasets.Value("uint8"),
-                #"dataset": datasets.Value("string")
-                "movie_title"
-                "movie_info"
-                "critics_consensus"
-                "content_rating"
-                "genres"
-                "directors"
-                "authors"
-                "actors"
-                "original_release_date"
-                "critic_name"
-                "top_critic"
-                "publisher_name"
-                "review_type"
-                "review_score"
-                "review_date"
-                "review_content"
-            }
-        )
         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"),
+            features=NORMAL_FEATURES,
             # Homepage of the dataset for documentation
             homepage=_HOMEPAGE,
             # License for the dataset if available
@@ -340,21 +370,18 @@ class MultiscaleRTCritics(datasets.GeneratorBasedBuilder):
                     "split": "test"
                 },
             ),
-            datasets.SplitGenerator(
-                name=datasets.Split.ALL,
-                gen_kwargs={
-                    "split": "all",
-                },
-            ),
         ]
 
     def _generate_examples(self, split):
         if not hasattr(self, "_datasets"):
             self._datasets = get_datasets()
-        all_dataset, train_dataset, test_dataset = self._datasets
-        if split == "train":
-            yield from train_dataset
+        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 test_dataset
-        else:
-            yield from all_dataset
+            yield from iter_pandas_df(test_dataset, cols)
+        #else:
+            #yield from iter_pandas_df(group_df)