patent_app.py

# Import statements
import streamlit as st
from transformers import pipeline
from transformers import AutoTokenizer, AutoModelForSequenceClassification

import numpy as np
from datasets import load_dataset

# Torch and torch dataloader
import torch
from torch.utils.data import DataLoader

st.title('Patentability Decision App')

# Input all validation patent files
dataset_dict = load_dataset('HUPD/hupd',
    name='sample',
    data_files="https://huggingface.co/datasets/HUPD/hupd/blob/main/hupd_metadata_2022-02-22.feather", 
    icpr_label=None,
    train_filing_start_date='2016-01-01',
    train_filing_end_date='2016-01-21',
    val_filing_start_date='2016-01-22',
    val_filing_end_date='2016-01-31',
)

# Remove all untrained decisions
# Label-to-index mapping for the decision status field
decision_to_str = {'REJECTED': 0, 'ACCEPTED': 1, 'PENDING': 2, 'CONT-REJECTED': 3, 'CONT-ACCEPTED': 4, 'CONT-PENDING': 5}

# Helper function
def map_decision_to_string(example):
    return {'decision': decision_to_str[example['decision']]}
  
# Re-labeling/mapping in validation set
val_set = dataset_dict['validation'].map(map_decision_to_string)
# Filtering only those patents that have decisions as accepted/rejected
val_set = val_set.filter(lambda e: e['decision'] <= 1)

# Display all patent numbers to select a file
patent_num = st.selectbox("Select a patent based on its number",  val_set['patent_number'])


# Keeping the session state
if "button_clicked" not in st.session_state:    
    st.session_state.button_clicked = False

# The button was clicked
def callback():
    st.session_state.button_clicked = True

# Get the abstract and claims data to predict
if patent_num and (st.button('Get Data to predict!', on_click = callback) or st.session_state.button_clicked):
  # Display the abstract and claims
  val_set = val_set.filter(lambda e: e['patent_number'] == patent_num)
  
  abstract_text = st.text_area('Abstract', val_set['abstract'][0])
  claims_text = st.text_area('Claims', val_set['claims'][0])
  
  # Predict on those texts   
  if abstract_text and claims_text and st.button('Predict!'):
    # Model/tokenizer name or path to finetuned model
    model_name_or_path = './models/'
    model_name = 'distilbert-base-uncased'
    # Tokenizer
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    # Model
    model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path)
    
    # Tokenize the validation dataset and pass it to the model for prediction
    _SECTION_ = 'claims'
    val_set = val_set.map(lambda e: tokenizer((e[_SECTION_]), truncation=True, padding='max_length'),batched=True)
    val_set.set_format(type='torch', columns=['input_ids', 'attention_mask', 'decision'])
    # Creating a dataloader and only passing one row
    val_dataloader = DataLoader(val_set, batch_size=16)
    batch = next(iter(val_dataloader))
    inputs = (batch['input_ids'][0])
    decisions = (batch['decision'][0])
    
    # Predict
    with torch.no_grad():
        outputs = model(input_ids=inputs, labels=decisions).logits
    
    # Display prediction
    prediction = np.argmax(outputs, axis=-1).stride()[0] # prediction
    value = {i for i in decision_to_str if decision_to_str[i]==prediction}
    st.text('This is the predicted decision: ' + str(value))
    
    # Patentability score
    st.text('Probability that it will be rejected : ' + str(outputs[0][0].item() * 100))
    st.text('Probability that it will be accepted : ' + str(outputs[0][1].item() * 100))