ecexe/PatentGPT

PatentGPT - Advanced Patent Analysis Platform

PatentGPT is a comprehensive patent analysis platform that uses machine learning to classify and analyze patents using official USPTO data. The system processes patent XML files and CPC (Cooperative Patent Classification) data to train a BERT-based classifier for accurate patent classification.

🚀 Key Features

• —Official USPTO Data: Trained on real patent XML files from USPTO bulk data
• —BERT-Based Classification: Advanced transformer model for patent classification
• —CPC Code Prediction: Predicts Cooperative Patent Classification codes
• —Comprehensive Analysis: Patent clustering, obsolescence analysis, and trend detection
• —Web Interface: Streamlit-based dashboard for easy interaction
• —HuggingFace Ready: Complete model package for easy deployment

📊 Data Processing Workflow

The system processes two main data sources:

1. 1.Patent XML Files: Extracted from ZIP files containing patent grants
2. 2.CPC Master Classification Files: Official USPTO CPC classification data

Data Processing Steps:

1. 1.Extract ZIP Files: Process patent XML files from patent_data/I20250805/
2. 2.Parse XML Content: Extract patent ID, title, abstract, and CPC codes
3. 3.Process CPC Data: Parse CPC Master Classification files
4. 4.Merge Data: Join patent text with CPC classifications
5. 5.Create Training Dataset: Generate comprehensive training data for BERT

🛠️ Installation

# Clone the repository
git clone https://github.com/yourusername/patentgpt.git
cd patentgpt

# Install dependencies
pip install -r requirements.txt

🚀 Quick Start

Option 1: Run Complete Pipeline (Recommended)

# Run the complete data processing and training pipeline
python run_complete_pipeline.py

This will:

1. 1.Process patent XML files and CPC data
2. 2.Train a BERT classifier
3. 3.Test the model
4. 4.Create HuggingFace package

Option 2: Step-by-Step Processing

# Step 1: Process patent data
python process_patent_data.py

# Step 2: Train BERT model
python train_bert_classifier.py

# Step 3: Test the model
python -c "from app.classifier import classify_patent_abstract; print(classify_patent_abstract('A method for semiconductor processing'))"

Option 3: Web Interface

# Start the Streamlit application
streamlit run app/app.py

📁 Project Structure

PatentGPT/
├── app/                          # Web application
│   ├── app.py                   # Main Streamlit app
│   ├── classifier.py            # BERT classifier
│   ├── ui.py                   # User interface
│   └── ...                     # Other modules
├── patent_data/                 # USPTO data (not included)
│   ├── I20250805/              # Patent XML files
│   └── US_Grant_CPC_MCF_XML_2025-07-01/  # CPC data
├── processed_data/              # Generated training data
├── trained_classifier/          # Trained model files
├── process_patent_data.py      # Data processing script
├── train_bert_classifier.py    # BERT training script
├── run_complete_pipeline.py    # Complete pipeline
└── README.md                   # This file

🔧 Data Processing

Patent XML Structure

The system processes USPTO patent XML files with the following structure:

<us-patent-grant>
  <us-bibliographic-data-grant>
    <publication-reference>
      <document-id>
        <doc-number>12379042</doc-number>
      </document-id>
    </publication-reference>
    <invention-title>Patent Title</invention-title>
  </us-bibliographic-data-grant>
  <abstract>
    <p>Patent abstract text...</p>
  </abstract>
  <classifications-cpc>
    <classification-cpc>
      <section>F</section>
      <class>16</class>
      <subclass>K</subclass>
      <main-group>27</main-group>
      <subgroup>003</subgroup>
    </classification-cpc>
  </classifications-cpc>
</us-patent-grant>

CPC Master Classification Structure

<uspat:CPCMasterClassificationRecord>
  <pat:ApplicationIdentification>
    <com:ApplicationNumberText>12345678</com:ApplicationNumberText>
  </pat:ApplicationIdentification>
  <pat:CPCClassificationText>F16K27/003</pat:CPCClassificationText>
</uspat:CPCMasterClassificationRecord>

🤖 Model Training

BERT Classifier

The system trains a BERT-based classifier with the following configuration:

• —Base Model: bert-base-uncased
• —Max Length: 512 tokens
• —Batch Size: 16
• —Learning Rate: 2e-5
• —Epochs: 3
• —Task: Multi-class classification (CPC codes)

Training Data

The training dataset includes:

• —Patent titles and abstracts
• —CPC classification codes
• —Normalized patent IDs
• —Text preprocessing and augmentation

📊 Model Performance

The trained model provides:

• —Multi-class Classification: Predicts specific CPC codes
• —Confidence Scores: Probability estimates for predictions
• —Top-k Predictions: Multiple candidate classifications
• —Section-level Analysis: CPC section categorization

🌐 Web Interface

The Streamlit application provides:

• —Patent Classification: Upload or input patent text for classification
• —Model Information: View training details and data provenance
• —Analysis Tools: Clustering, obsolescence, and trend analysis
• —Data Visualization: Interactive charts and graphs

📦 HuggingFace Integration

The trained model is packaged for HuggingFace with:

• —Model Files: Complete BERT model and tokenizer
• —Label Encoder: CPC code mapping
• —Documentation: README and model card
• —Git LFS: Large file handling

🔍 Usage Examples

Python API

from app.classifier import classify_patent_abstract

# Classify a patent abstract
result = classify_patent_abstract(
    "A method for processing semiconductor materials using advanced chemical techniques."
)

print(f"Predicted CPC: {result['predicted_class']}")
print(f"Confidence: {result['confidence']:.3f}")
print(f"Section: {result['cpc_section']}")

Web Interface

1. 1.Start the application: streamlit run app/app.py
2. 2.Navigate to the Classification tab
3. 3.Input patent text or upload a file
4. 4.View classification results and confidence scores

📈 Data Provenance

The model is trained on official USPTO data:

• —Source: USPTO Bulk Data
• —Patent Files: XML format with titles and abstracts
• —CPC Data: Master Classification files
• —Data Quality: Official government source
• —Coverage: Comprehensive patent database

🛠️ Development

Adding New Features

1. 1.Data Processing: Modify process_patent_data.py
2. 2.Model Training: Update train_bert_classifier.py
3. 3.Web Interface: Edit app/ui.py
4. 4.Classifier: Modify app/classifier.py

Testing

# Test data processing
python process_patent_data.py

# Test model training
python train_bert_classifier.py

# Test web interface
streamlit run app/app.py

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🤝 Contributing

1. 1.Fork the repository
2. 2.Create a feature branch
3. 3.Make your changes
4. 4.Add tests if applicable
5. 5.Submit a pull request

📞 Support

For questions or issues:

• —Create an issue on GitHub
• —Check the documentation
• —Review the code comments

🔄 Updates

• —v2.0: Complete rewrite with BERT classifier and USPTO data processing
• —v1.0: Initial release with basic classification

PatentGPT - Advanced Patent Analysis with Official USPTO Data