Delete hupd.py

hupd.py

@@ -1,339 +0,0 @@
-"""
-The Harvard USPTO Patent Dataset (HUPD) is a large-scale, well-structured, and multi-purpose corpus 
-of English-language patent applications filed to the United States Patent and Trademark Office (USPTO) 
-between 2004 and 2018. With more than 4.5 million patent documents, HUPD is two to three times larger 
-than comparable corpora. Unlike other NLP patent datasets, HUPD contains the inventor-submitted versions 
-of patent applications, not the final versions of granted patents, allowing us to study patentability at 
-the time of filing using NLP methods for the first time.
-"""
-
-from __future__ import absolute_import, division, print_function
-
-import os
-import datetime
-import pandas as pd
-import numpy as np
-from pathlib import Path
-try:
-    import ujson as json
-except:
-    import json
-
-import datasets
-
-
-_CITATION = """\
-@InProceedings{suzgun2021:hupd,
-title = {The Harvard USPTO Patent Dataset},
-authors={Mirac Suzgun and Suproteem Sarkar and Luke Melas-Kyriazi and Scott Kominers and Stuart Shieber},
-year={2021}
-}
-"""
-
-_DESCRIPTION = """
-The Harvard USPTO Patent Dataset (HUPD) is a large-scale, well-structured, and multi-purpose corpus 
-of English-language patent applications filed to the United States Patent and Trademark Office (USPTO) 
-between 2004 and 2018. With more than 4.5 million patent documents, HUPD is two to three times larger 
-than comparable corpora. Unlike other NLP patent datasets, HUPD contains the inventor-submitted versions 
-of patent applications, not the final versions of granted patents, allowing us to study patentability at 
-the time of filing using NLP methods for the first time.
-"""
-
-RANDOM_STATE = 1729
-
-_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,
-        metadata_url: str,
-        data_url: str,
-        data_dir: str,
-        ipcr_label: str = None,
-        cpc_label: str = None,
-        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,
-        force_extract=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:
-            metadata_url: `string`, url from which to download the metadata file
-            data_url: `string`, url from which to download the json files
-            data_dir: `string`, folder (in cache) in which downloaded json files are stored
-            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)
-            force_extract: Extract only the relevant years if this parameter is used.
-            **kwargs: keyword arguments forwarded to super
-        """
-        super().__init__(**kwargs)
-        self.metadata_url = metadata_url
-        self.data_url = data_url
-        self.data_dir = data_dir
-        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.force_extract = force_extract
-
-
-class Patents(datasets.GeneratorBasedBuilder):
-    _DESCRIPTION
-
-    VERSION = datasets.Version("1.0.2")
-
-    # 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="sample", 
-            description="Patent data from January 2016, for debugging", 
-            metadata_url="https://huggingface.co/datasets/HUPD/hupd/resolve/main/hupd_metadata_jan16_2022-02-22.feather",
-            data_url="https://huggingface.co/datasets/HUPD/hupd/resolve/main/data/sample-jan-2016.tar.gz",
-            data_dir="sample",  # this will unpack to data/sample/2016
-        ),
-        PatentsConfig(
-            name="2016to2018", 
-            description="Patent data from 2016 to 2018, for debugging", 
-            metadata_url="https://huggingface.co/datasets/hupd_augmented/resolve/main/hupd_metadata_2016_to_2018.feather",
-            data_url="https://huggingface.co/datasets/hupd_augmented/resolve/main/data/2018.tar.gz",
-            data_dir="sample",  # this will unpack to data/sample/2018
-        ),
-        PatentsConfig(
-            name="all", 
-            description="Patent data from all years (2004-2018)", 
-            metadata_url="https://huggingface.co/datasets/HUPD/hupd/resolve/main/hupd_metadata_2022-02-22.feather",
-            data_url="https://huggingface.co/datasets/HUPD/hupd/resolve/main/data/all-years.tar",
-            data_dir="data",   # this will unpack to data/{year}
-        ),
-    ]
-
-    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"),
-            homepage="https://github.com/suzgunmirac/hupd",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager):
-        """Returns SplitGenerators."""
-        print(f'Loading dataset with config: {self.config}')
-
-        # Download metadata
-        # NOTE: Metadata is stored as a Pandas DataFrame in Apache Feather format
-        metadata_url = self.config.metadata_url
-        metadata_file = dl_manager.download_and_extract(self.config.metadata_url)
-        print(f'Using metadata file: {metadata_file}')
-
-        # Download data
-        # NOTE: The extracted path contains a subfolder, data_dir. This directory holds
-        # a large number of json files (one json file per patent application).
-        download_dir = dl_manager.download_and_extract(self.config.data_url)
-        json_dir = os.path.join(download_dir, self.config.data_dir)
-
-        # Load metadata file
-        print(f'Reading metadata file: {metadata_file}')
-        if metadata_url.endswith('.feather'):
-            df = pd.read_feather(metadata_file)
-        elif metadata_url.endswith('.csv'):
-            df = pd.read_csv(metadata_file)
-        elif metadata_url.endswith('.tsv'):
-            df = pd.read_csv(metadata_file, delimiter='\t')
-        elif metadata_url.endswith('.pickle'):
-            df = pd.read_pickle(metadata_file)
-        else:
-            raise ValueError(f'Metadata file invalid: {metadata_url}')
-
-        # 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
-        if self.config.query_string:
-            df = df.query(self.config.query_string)
-            
-        if self.config.force_extract:
-            if self.config.name == 'all':
-                if self.config.train_filing_start_date and self.config.val_filing_end_date:
-                    if self.config.train_filing_end_date and self.config.val_filing_start_date:
-                        training_year_range = set(range(int(self.config.train_filing_start_date[:4]), int(self.config.train_filing_end_date[:4]) + 1))
-                        validation_year_range = set(range(int(self.config.val_filing_start_date[:4]), int(self.config.val_filing_end_date[:4]) + 1))
-                        full_year_range = training_year_range.union(validation_year_range)
-                    else:
-                        full_year_range = set(range(int(self.config.train_filing_start_date[:4]), int(self.config.val_filing_end_date[:4]) + 1))
-                else:
-                    full_year_range = set(range(2004, 2019))
-                
-
-                import tarfile
-                for year in full_year_range:
-                    tar_file_path = f'{json_dir}/{year}.tar.gz'
-                    print(f'Extracting {tar_file_path}')
-                    # open file
-                    tar_file = tarfile.open(tar_file_path)
-                    # extracting file
-                    tar_file.extractall(f'{json_dir}')
-                    tar_file.close()    
-
-        # 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:
-
-            # Check
-            if not (self.config.train_filing_start_date and self.config.train_filing_end_date and
-                    self.config.val_filing_start_date and self.config.train_filing_end_date):
-                raise ValueError("Please either use uniform_split or specify your exact \
-                    training and validation split dates.")
-
-            # Does not assume that training_start_data < val_end_date
-            print(f'Filtering train dataset by filing start date: {self.config.train_filing_start_date}')
-            print(f'Filtering train dataset by filing end date: {self.config.train_filing_end_date}')
-            print(f'Filtering val dataset by filing start date: {self.config.val_filing_start_date}')
-            print(f'Filtering val dataset by filing end date: {self.config.val_filing_end_date}')
-            train_df = df[
-                (df['filing_date'] >= self.config.train_filing_start_date) & 
-                (df['filing_date'] < self.config.train_filing_end_date)
-            ]
-            val_df = df[
-                (df['filing_date'] >= self.config.val_filing_start_date) & 
-                (df['filing_date'] < self.config.val_filing_end_date)
-            ]
-
-        # TODO: We can probably 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(  # these kwargs are 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_year = str(x.filing_date.year)
-            application_number = x.application_number
-            filepath = os.path.join(json_dir, application_year, 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": patent["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"],
-            }