PubGen: A generative framework for mapping the biomedical research landscape

A collection of deep learning methods for analyzing scientific literature embeddings. This repository contains code for five independent research tasks on PubMed abstracts, plus an ExPORTER pipeline applied to NIH grant abstracts.

📊 Metadata & dataset: zhiweizhang988/PubGen on Hugging Face

📋 Overview

This repository includes five separate research workflows on PubMed abstract embeddings, plus the ExPORTER pipeline on NIH grant abstracts:

1️⃣ t-SNE Dimensionality Reduction

• High-quality t-SNE visualization using openTSNE
• PCA initialization and affinity matrix computation
• Exaggeration annealing for better clustering

2️⃣ Generative Modeling

• VAE-based masked sample reconstruction
• Hole masking and random masking strategies
• Sinkhorn loss for distribution matching

3️⃣ Direct Prediction Tasks

• Multi-task classification (annotation, journal, country)
• Score prediction from embeddings
• Trained directly on original 768D embeddings

4️⃣ VAE Perturbation Analysis

• sparse training (768D → 2048D latent space)
• Keyword prediction from latent representations
• Temporal trend detection and perturbation
• Double dissociation discovery

5️⃣ LLM Inference

• Causal LLM (e.g. Qwen3) with LoRA adapters and MLP projector
• MLP projector maps embedding vectors to LLM token space
• Generates abstract-style text from embedding inputs

6️⃣ ExPORTER (NIH Grant Landscape)

• End-to-end pipeline over 1,079,814 deduplicated NIH grant abstracts
• PubMedBERT embedding → t-SNE + Leiden clustering → classification & citation regression
• Grant scorecard metrics and grant↔PubMed cluster association

🏗️ Project Structure

.
├── Tsne/                          # Task 1: t-SNE Visualization
│   ├── data/
│   │   ├── PubMedBERT_embeddings_2K.npy
│   │   └── pubmed_landscape_data_2K.csv
│   ├── results/
│   │   ├── initialization_bert_reparsed.npy
│   │   ├── k20_affinities_P_bert_reparsed.npz
│   │   └── k20_tsne_reparsed.npy
│   └── 01_tsne_dimensionality_reduction.ipynb
│
├── generative/                    # Task 2: Generation
│   ├── data/
│   │   └── 3label_10K.h5ad
│   ├── figures/
│   ├── model/
│   ├── result/
│   ├── scripts/
│   │   ├── data_utils.py             # Masking strategies
│   │   ├── model.py                  # Model architecture
│   │   ├── training.py               # Training loops
│   │   ├── reconstruction_utils.py   # Sample reconstruction
│   │   └── visualization.py          # Loss curves
│   └── tutorial.ipynb
│
├── prediction/                    # Task 3: Direct Prediction
│   ├── classification/           # Multi-task classification
│   │   ├── dataset.py
│   │   ├── model.py
│   │   ├── train.py
│   │   └── predict.py
│   └── score/                    # Score prediction
│       ├── dataset.py
│       ├── model.py
│       ├── train.py
│       └── predict.py
│
├── perturbation/                  # Task 4: VAE Perturbation Analysis
│   ├── training/
│   │   ├── training_vae.py       # StandardVAE model
│   │   ├── train_keyword_model.py
│   │   └── vae_inference.py
│   └── scripts/
│       ├── 01_train_vae.py
│       ├── 02_generate_latent.py
│       ├── 03_train_keyword.py
│       ├── 04_run_time_trend.py
│       ├── 05_run_perturbation.py
│       ├── 06_double_dissociation.py
│       └── 07_dual_dim_interaction.py
│
├── LLM/                           # Task 5: LLM Inference
│   ├── data/
│   │   ├── 2K_texts.csv
│   │   └── 2K_vectors.npy
│   ├── download_model.ipynb
│   └── inference.py
│
└── ExPORTER/                      # Task 6: NIH Grant Landscape pipeline
    ├── config.py                  # All data paths (override via EXPORTER_DATA)
    ├── 00_download/               # Scrape reporter.nih.gov/exporter
    ├── 01_embedding/              # abstracts → PubMedBERT mean-pool (2.4M×768) + metadata
    ├── 02_tsne_leiden/            # t-SNE (k=40) + Leiden (res 1.8) + dedup → 1.08M
    ├── 03_classification/         # ACTIVITY / IC / RCDC / Leiden classification
    ├── 04_regression/             # citation regression (CC/CPY/RCR), random & temporal CV
    ├── 05_grant_scorecard/        # grant breadth/impact metrics + scorecard
    ├── 06_grant_pubmed_heatmap/   # grant Leiden × PubMed Leiden association
    └── figures/                   # final plotting scripts

🚀 Quick Start

Environment Setup

# Option 1: Using Conda (Recommended)
conda env create -f environment.yml
conda activate pubgen

# Option 2: Using pip
pip install -r requirements.txt

Approximate install time on a normal desktop with a broadband connection: ~15–25 min via conda, ~10–15 min via pip (dominated by downloading PyTorch).

Run Time

Measured on a single NVIDIA RTX 4090:

Step	Setting	Time
generation (Task 2)	generate 40,000 samples (global_augment)	~1.8 s (~21,800 samples/s); +~15 s data/model load
LLM inference (Task 5)	Qwen3-4B + LoRA, max_new_tokens=350	~0.6 s/abstract (~1.7 h for 10K); +~90 s model load

---

Task 1: t-SNE Visualization

High-quality t-SNE with PCA initialization and exaggeration annealing.

cd Tsne
jupyter notebook 01_tsne_dimensionality_reduction.ipynb

Key steps:

1. Load embeddings (768D)
2. PCA initialization
3. Compute affinity matrix (k=20 neighbors)
4. Run t-SNE with exaggeration annealing

Output: k20_tsne_reparsed.npy - 2D coordinates

---

Task 2: Generation

Reconstruct masked samples using VAE with Sinkhorn loss.

from scripts.data_utils import hole_masking_strategy
from scripts.model import MaskVAE, MaskVAELoss
from scripts.training import train_mask, generate_samples

# Mask data
masked_idx, visible_idx = hole_masking_strategy(adata, mask_ratio=0.2)

# Train model
model = MaskVAE(input_dim=768, hidden_dim=1024, latent_dim=64)
model, history = train_mask(model, adata, num_epochs=500)

# Generate samples
generated = generate_samples(model, x_visible, num_samples=len(masked_idx))

Key features:

• Hole masking (clusters) + random masking
• Global latent representation
• Sinkhorn loss for distribution matching

---

Task 3: Direct Prediction Tasks

Predict labels and scores directly from original 768D embeddings.

3.1 Multi-task Classification

Predict annotation labels, journal, and country from embeddings.

cd prediction/classification

# Train classifier
python train.py --h5ad_path ../data/Classification_task_2K.h5ad

# Run predictions
python predict.py --checkpoint checkpoints/best_multitask_classifier.pth \
                  --h5ad_path ../data/Classification_task_2K.h5ad

Architecture:

Input(768) → [512→256→128] → 3 output heads:
  ├─ Annotation head (N_annotation classes)
  ├─ Journal head (N_journal classes)
  └─ Country head (N_country classes)

3.2 Score Prediction

Predict quality scores from embeddings.

cd prediction/score

# Train predictor
python train.py --embedding_path data/embeddings.npy \
                --scores_path data/scores.csv

# Run predictions
python predict.py --checkpoint checkpoints/best_score_predictor.pth \
                  --input data/new_embeddings.npy

Architecture:

Input(768) → [1024→512→256→128] → Output(1)
Loss: MSELoss
Metrics: MSE, MAE, R²

---

Task 4: VAE Perturbation Analysis

Analyze latent space semantics through VAE and perturbation.

cd perturbation/scripts

# Step 1: Train VAE (768D → 2048D latent)
python 01_train_vae.py

# Step 2: Generate latent representations
python 02_generate_latent.py

# Step 3: Train keyword predictor
python 03_train_keyword.py

# Step 4-7: Perturbation analysis
python 04_run_time_trend.py
python 05_run_perturbation.py
python 06_double_dissociation.py
python 07_dual_dim_interaction.py

Configuration (01_train_vae.py):

VAE_CONFIG = {
    'input_dim': 768,
    'hidden_dim': 1024,
    'latent_dim': 2048,
    'num_layers': 2
}

TRAINING_CONFIG = {
    'batch_size': 5000,
    'num_epochs': 200,
    'lr': 1e-3,
    'kl_beta': 0.001
}

Pipeline:

1. VAE Training: Encode embeddings to 2048D latent space
2. Keyword Prediction: Train classifier on latent representations
3. Time Trends: Find dimensions correlated with publication year
4. Perturbation: Measure keyword probability changes at P5/P95
5. Double Dissociation: Discover functionally specific dimensions
6. Interactions: Test synergistic/antagonistic dimension pairs

Output files:

results/
├── adata_latent_2048_cluster0.h5ad
├── time_trends_top100.csv
├── perturbation_results.csv
├── double_dissociation_results.csv
└── interaction_results.csv

---

Task 5: LLM Inference

Generate abstract-style text from literature embedding vectors using a causal LLM with an MLP projector and LoRA adapters.

cd LLM

# Step 1: Download base model
jupyter notebook download_model.ipynb

# Step 2: Run inference
python inference.py

Architecture:

• MLP projector maps input embedding (768D) → LLM token embeddings
• LoRA adapters applied to the causal LLM backbone
• Inference runs from a pre-trained checkpoint on embedding inputs

Data:

• data/2K_vectors.npy — input embedding vectors
• data/2K_texts.csv — corresponding abstract texts

---

Task 6: ExPORTER (NIH Grant Landscape)

A self-contained pipeline showing that a single PubMedBERT semantic space organizes 1,079,814 deduplicated NIH grant abstracts by discipline, funding structure, and impact, and supports classification and citation prediction.

cd ExPORTER

# Configure paths (or edit DATA_ROOT in config.py)
export EXPORTER_DATA=/your/data/path

# A. download + embedding
python 00_download/download_exporter.py
python 01_embedding/01_embed_abstracts.py 0     # shard encode: 0..3
python 01_embedding/02_merge_embeddings.py      # merge → (2.4M, 768)
python 01_embedding/03_extract_metadata.py      # ACTIVITY / IC / RCDC

# B. disciplinary map
python 02_tsne_leiden/01_run_tsne.py            # openTSNE (k=40)
python 02_tsne_leiden/02_run_leiden.py          # Leiden (res 1.8)
python 02_tsne_leiden/03_dedup_subset.py        # dedup → 1.08M

# C. downstream modeling
python 03_classification/01_classify_labels.py  # ACTIVITY / IC / RCDC
python 03_classification/02_classify_leiden.py  # predict Leiden cluster
python 04_regression/01_add_rcr.py
python 04_regression/02_feature_ablation.py
python 04_regression/0{3,4,5}_cv_random_*.py    # Ridge / LightGBM / DNN
python 04_regression/06_merge_random_cv.py
python 04_regression/07_cv_temporal.py

# D. grant scorecard — run notebooks 01 → 06 in 05_grant_scorecard/ in order

Pipeline:

1. Download: scrape grant abstracts from reporter.nih.gov/exporter
2. Embedding: PubMedBERT mean-pool → (2.4M, 768), plus ACTIVITY/IC/RCDC metadata
3. Map: t-SNE (k=40) + Leiden (res 1.8), dedup by abstract text → 1,079,814
4. Classification: predict ACTIVITY / IC / RCDC / Leiden (GroupKFold by APPLICATION_ID)
5. Regression: predict citations (CC/CPY/RCR) with Ridge/LightGBM/DNN, random & temporal CV
6. Scorecard: grant breadth/impact metrics and grant↔PubMed cluster association