Datasets:

HUPD
/

hupd

	"""
	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="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"],
	}