How does this work? The docs should really be better

.gitattributes

@@ -25,3 +25,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+json-files-Jan2016.tar filter=lfs diff=lfs merge=lfs -text
+metadata--Jan2016--2021-02-10.feather filter=lfs diff=lfs merge=lfs -text

json-files-Jan2016.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a7d7923941e39255112d2b40a40e8dae8579d9150459c1f0599ffe8a4cfb5a5
+size 2024540160

metadata--Jan2016--2021-02-10.feather

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ce14560b1f610436f0f6810e38b28a71803aa2b995b27220578ed870e8bc620
+size 10639266

test-dataset-debug.py

@@ -0,0 +1,305 @@
+"""TODO: Add a description here."""
+
+from __future__ import absolute_import, division, print_function
+
+import json
+import os
+import datetime
+import pandas as pd
+import numpy as np
+from pathlib import Path
+# from sklearn.utils import shuffle
+
+import datasets
+
+
+# TODO: Add BibTeX citation
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+title = {A great new dataset},
+authors={huggingface, Inc.
+},
+year={2020}
+}
+"""
+
+# TODO: Add description of the dataset here
+_DESCRIPTION = """TODO: Add description"""
+
+# URLs for production
+_METADATA_URL = "https://patentdiag.blob.core.windows.net/patent-data/metadata-2021-02-10.feather"
+# _METADATA_URL = "https://patentdiag.blob.core.windows.net/patent-data/metadata-2021-01-21.feather"
+_DATA_URL = "https://patentdiag.blob.core.windows.net/patent-data/distilled-2021-01-07.tar"
+_DATA_SUBFOLDER_NAME = 'distilled'
+
+# # URLs for debugging
+# _METADATA_URL = _DEBUG_METADATA_URL = "https://patentdiag.blob.core.windows.net/patent-data/metadata_debug-2021-02-10.feather"
+# _DATA_URL = _DEBUG_DATA_URL = "https://patentdiag.blob.core.windows.net/patent-data/distilled_debug-2021-01-07.tar"
+# _DATA_SUBFOLDER_NAME = _DATA_SUBFOLDER_NAME = 'debug_distilled'
+
+RANDOM_STATE = 1729
+
+
+# Names of features
+_FEATURES = [
+    "patent_number",
+    "decision",
+    "title",
+    "abstract",
+    "claims",
+    "background",
+    "summary",
+    "description",
+    "cpc_label",
+    "ipc_label",
+    "filing_date",
+    "patent_issue_date",
+    "date_published",
+    "examiner_id"
+]
+
+
+def str_to_date(s):
+    """A helper function to convert strings to dates"""
+    return datetime.datetime.strptime(s, '%Y-%m-%d')
+
+
+class PatentsConfig(datasets.BuilderConfig):
+    """BuilderConfig for Patents"""
+
+    def __init__(
+        self,
+        ipcr_label: str = None,  # 'G06F',
+        cpc_label: str = None,  # 'G06F',
+        train_filing_start_date: str = None,
+        train_filing_end_date: str = None,
+        val_filing_start_date: str = None,
+        val_filing_end_date: str = None,
+        query_string: str = None,
+        val_set_balancer=False,
+        uniform_split=False,
+        train_only=False,
+        **kwargs
+    ):
+        """
+        If train_filing_end_date is None, then a random train-val split will be used. If it is 
+        specified, then the specified date range will be used for the split. If train_filing_end_date 
+        if specified and val_filing_start_date is not specifed, then val_filing_start_date defaults to 
+        train_filing_end_date. 
+
+        Args:
+            ipcr_label: International Patent Classification code
+            cpc_label: Cooperative Patent Classification code
+            train_filing_start_date: Start date for patents in train set (and val set if random split is used)
+            train_filing_end_date: End date for patents in train set
+            val_filing_start_date: Start date for patents in val set
+            val_filing_end_date: End date for patents in val set (and train set if random split is used)
+            **kwargs: keyword arguments forwarded to super.
+        """
+        super().__init__(**kwargs)
+        self.ipcr_label = ipcr_label
+        self.cpc_label = cpc_label
+        self.train_filing_start_date = train_filing_start_date
+        self.train_filing_end_date = train_filing_end_date
+        self.val_filing_start_date = val_filing_start_date
+        self.val_filing_end_date = val_filing_end_date
+        self.query_string = query_string
+        self.val_set_balancer = val_set_balancer
+        self.uniform_split = uniform_split
+        self.train_only = train_only
+
+
+class Patents(datasets.GeneratorBasedBuilder):
+    """TODO: Add description"""
+
+    VERSION = datasets.Version("1.0.1")
+
+    # This is an example of a dataset with multiple configurations.
+    # If you don't want/need to define several sub-sets in your dataset,
+    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+    BUILDER_CONFIG_CLASS = PatentsConfig
+    # BUILDER_CONFIGS = [
+    #     PatentsConfig(name="my_dataset_" + size, description="A small dataset", data_size=size)
+    #     for size in ["small", "medium", "large"]
+    # ]
+
+    def _info(self):
+        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=datasets.Features(
+                {k: datasets.Value("string") for k in _FEATURES}
+            ),
+            # If there's a common (input, target) tuple from the features,
+            # specify them here. They'll be used if as_supervised=True in
+            # builder.as_dataset.
+            supervised_keys=("claims", "decision"),
+            # TODO: Homepage of the dataset for documentation
+            homepage="https://huggingface.co/great-new-dataset",
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        """Returns SplitGenerators."""
+        print(f'Loading dataset with config: {self.config}')
+
+        # Download metadata
+        # NOTE: data_files is a path to a pickled pandas DataFrame
+        if self.config.data_files is None:
+            print(f'Loading / downloading metadata file: {_METADATA_URL}')
+            metadata_file = dl_manager.download_and_extract(_METADATA_URL)
+        else:
+            print(f'Using metadata file: {self.config.data_files}')
+            metadata_file = Path(self.config.data_files)
+
+        # Download data
+        # NOTE: data_dir is a path to a directory of json files, with one
+        # json file per patent application
+        if self.config.data_dir is None:
+            print('Loading / downloading data. This is a big file (360GB)!')
+            json_dir = Path(dl_manager.download_and_extract(_DATA_URL))
+            # NOTE: The extracted path contains a subfolder
+            json_dir = json_dir / _DATA_SUBFOLDER_NAME
+        else:
+            json_dir = Path(self.config.data_dir)
+
+        # Load metadata file
+        print(f'Reading metadata file: {metadata_file}')
+        df = pd.read_feather(metadata_file)  # pd.read_pickle(metadata_file) #
+
+        # Filter based on ICPR / CPC label
+        if self.config.ipcr_label:
+            print(f'Filtering by IPCR label: {self.config.ipcr_label}')
+            df = df[df['main_ipcr_label'].str.startswith(self.config.ipcr_label)]
+        elif self.config.cpc_label:
+            print(f'Filtering by CPC label: {self.config.cpc_label}')
+            df = df[df['main_cpc_label'].str.startswith(self.config.cpc_label)]
+
+        # Filter metadata based on arbitrary query string
+        # TODO(suproteem): remove for production
+        if self.config.query_string:
+            df = df.query(self.config.query_string)
+
+        # Return only one dataset
+        if self.config.train_only:
+            if self.config.train_filing_start_date:
+                print(f'Filtering by train filing start date: {self.config.train_filing_start_date}')
+                df = df[df['filing_date'] >= self.config.train_filing_start_date]
+            if self.config.train_filing_end_date:
+                print(f'Filtering by train filing end date: {self.config.train_filing_end_date}')
+                df = df[df['filing_date'] <= self.config.train_filing_end_date]
+
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs=dict(  # kwargs passed to _generate_examples
+                        df=df,
+                        json_dir=json_dir,
+                        split='train',
+                    ),
+                )
+            ]
+
+        # Train-validation split (either uniform or by date)
+        if self.config.uniform_split:
+
+            # Assumes that training_start_data < val_end_date
+            if self.config.train_filing_start_date:
+                df = df[df['filing_date'] >= self.config.train_filing_start_date]
+            if self.config.val_filing_end_date:
+                df = df[df['filing_date'] <= self.config.val_filing_end_date]
+            df = df.sample(frac=1.0, random_state=RANDOM_STATE)
+            num_train_samples = int(len(df) * 0.85)
+            train_df = df.iloc[0:num_train_samples]
+            val_df = df.iloc[num_train_samples:-1]
+
+        else:
+
+            # Does not assume that training_start_data < val_end_date
+            if self.config.train_filing_start_date:
+                print(f'Filtering by train filing start date: {self.config.train_filing_start_date}')
+                tdf = df[df['filing_date'] >= self.config.train_filing_start_date]
+                if self.config.train_filing_end_date:
+                    print(f'Filtering by train filing end date: {self.config.train_filing_end_date}')
+                    train_df = tdf[tdf['filing_date'] <= self.config.train_filing_end_date]
+
+            if self.config.val_filing_start_date:
+                print(f'Filtering by val filing start date: {self.config.val_filing_start_date}')
+                vdf = df[df['filing_date'] >= self.config.val_filing_start_date]
+                if self.config.val_filing_end_date:
+                    print(f'Filtering by val filing end date: {self.config.val_filing_end_date}')
+                    val_df = vdf[vdf['filing_date'] <= self.config.val_filing_end_date]
+
+        # TODO: Can make this step faster
+        if self.config.val_set_balancer:
+            rejected_df = val_df[val_df.status == 'REJECTED']
+            num_rejected = len(rejected_df)
+            accepted_df = val_df[val_df.status == 'ACCEPTED']
+            num_accepted = len(accepted_df)
+            if num_rejected < num_accepted:
+                accepted_df = accepted_df.sample(frac=1.0, random_state=RANDOM_STATE)  # shuffle(accepted_df)
+                accepted_df = accepted_df[:num_rejected]
+            else:
+                rejected_df = rejected_df.sample(frac=1.0, random_state=RANDOM_STATE)  # shuffle(rejected_df)
+                rejected_df = rejected_df[:num_accepted]
+            val_df = pd.concat([rejected_df, accepted_df])
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs=dict(  # kwargs passed to _generate_examples
+                    df=train_df,
+                    json_dir=json_dir,
+                    split='train',
+                ),
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs=dict(
+                    df=val_df,
+                    json_dir=json_dir,
+                    split='val',
+                ),
+            ),
+        ]
+
+    def _generate_examples(self, df, json_dir, split):
+        """ Yields examples by loading JSON files containing patent applications. """
+
+        # NOTE: df.itertuples() is way faster than df.iterrows()
+        for id_, x in enumerate(df.itertuples()):
+
+            # JSON files are named by application number (unique)
+            application_number = x.application_number
+            filepath = json_dir / (application_number + '.json')
+            try:
+                with open(filepath, 'r') as f:
+                    patent = json.load(f)
+            except Exception as e:
+                print('------------')
+                print(f'ERROR WITH {filepath}\n')
+                print(repr(e))
+                print()
+                yield id_, {k: "error" for k in _FEATURES}
+
+            # Most up-to-date-decision in meta dataframe
+            decision = x.decision
+            yield id_, {
+                "patent_number": application_number,
+                "decision": decision,
+                "title": patent["title"],
+                "abstract": patent["abstract"],
+                "claims": patent["claims"],
+                "description": patent["full_description"],
+                "background": patent["background"],
+                "summary": patent["summary"],
+                "cpc_label": patent["main_cpc_label"],
+                'filing_date': patent['filing_date'],
+                'patent_issue_date': patent['patent_issue_date'],
+                'date_published': patent['date_published'],
+                'examiner_id': patent['examiner_id'],
+                "ipc_label": patent["main_ipcr_label"],
+                # "all_cpc_labels": patent["cpc_labels"],  # these are lists, ignoring for now
+                # 'inventor_list': patent['inventor_list'],  # these are lists, ignoring for now
+            }