Aligning two sets of corresponding points, finding the optimal rotation (and optionally translation and scale) that maps one onto the other, is a fundamental operation across scientific computing. It appears in molecular dynamics (superimposing protein conformations), robotics (sensor registration), and computer vision (shape matching). The two dominant algorithm families are the Kabsch (SVD-based) method and the Horn (quaternion-based) method.

The Kabsch-Horn Cookbook is a Python library that implements both algorithm families across five numerical frameworks: NumPy, PyTorch, JAX, TensorFlow, and MLX. Every backend shares the same API, supports N-dimensional point sets, per-point weights, and arbitrary batch dimensions. The PyTorch, JAX, TensorFlow, and MLX backends are fully differentiable, with custom autograd rules that bypass the numerically unstable gradient of the standard SVD near degenerate singular values.

Features

Algorithms

• Kabsch: SVD-based optimal rotation for rigid alignment
• Kabsch-Umeyama: Kabsch with an additional optimal scaling factor $c$, solving $Q \approx cRP + t$
• Horn: Quaternion-based optimal rotation via the eigendecomposition of a $4 \times 4$ key matrix
• Horn + Scale: Horn’s method extended with optimal isotropic scaling
• RMSD Wrappers: Convenience functions that return RMSD directly alongside the alignment parameters

Framework Support

torch.compile and jax.jit are the tested compile/JIT paths. MLX supports 3D inputs only; the Kabsch (SVD) path is N-dimensional on the other four backends.

Numerical Robustness

Standard SVD and eigendecomposition backward passes produce NaN gradients when singular values collide or are near-zero. The library provides custom autograd primitives to handle these cases:

• SafeSVD (PyTorch, JAX, TF, MLX): Custom backward pass that clamps the singular value gap, preventing division-by-zero in the gradient
• SafeEigh (PyTorch, JAX, TF, MLX): Analogous safe backward for the symmetric eigendecomposition used in Horn’s method
• Per-point weights: Weighted centroids and weighted cross-covariance for mass-weighted or confidence-weighted alignment
• Batch dimensions: All functions broadcast over leading batch dimensions without explicit loops
• Mixed-dtype promotion: Inputs are promoted to a common floating-point dtype automatically

Testing

The test suite uses Hypothesis-based property testing across 13 modules covering:

• Round-trip correctness (align then compare)
• Gradient finiteness and correctness (finite-difference checks)
• Reflection handling (proper vs. improper rotations)
• Weighted alignment consistency
• Batch broadcasting
• 4 differentiable backends $\times$ 4 precisions (float32, float64, and where supported, float16, bfloat16)

Usage

This is a reference cookbook, so you can copy the framework folder you need from src/kabsch_horn/<framework>/ directly into your project (the code has no runtime dependencies beyond the framework itself). To depend on it instead, install a pinned version from GitHub:

pip install "git+https://github.com/hunter-heidenreich/Kabsch-Cookbook.git@v0.4.1"

Basic alignment with NumPy:

import numpy as np
from kabsch_horn import numpy as kh

# Two sets of corresponding 3D points
P = np.random.randn(100, 3)
R_true = np.linalg.qr(np.random.randn(3, 3))[0]  # random rotation matrix
Q = (P @ R_true.T) + np.random.randn(1, 3)

R, t, rmsd = kh.kabsch(P, Q)
aligned = P @ R.T + t

RMSD loss for training in PyTorch:

import torch
from kabsch_horn import pytorch as kh

pred_coords = model(input_features)   # (B, N, 3), requires_grad=True
target_coords = batch["target"]       # (B, N, 3)

rmsd = kh.kabsch_rmsd(pred_coords, target_coords)  # (B,)
loss = rmsd.mean()
loss.backward()  # safe gradients via SafeSVD

For the full API reference and additional examples, see the documentation site.

Results

Gradient Stability

The standard SVD backward pass computes terms of the form $\frac{1}{\sigma_i^2 - \sigma_j^2}$, which diverges when two singular values are close. In molecular alignment this happens frequently: planar molecules, symmetric structures, and noisy coordinates can all produce near-degenerate singular values. The SafeSVD primitive floors the magnitude of that denominator at the dtype’s machine epsilon (finfo(dtype).eps), producing finite (if slightly biased) gradients in these edge cases. Property-based tests confirm that gradients remain finite across thousands of random rotations, scales, and noise levels for all four differentiable backends.

Framework Parity

All five backends produce numerically equivalent results (up to floating-point tolerance) on the same inputs. The shared API means switching from NumPy prototyping to PyTorch training requires changing only the import path.

Related Work

This project builds on the foundational alignment algorithms described in these papers:

• Kabsch (1976): the original SVD-based rotation alignment
• Arun et al. (1987): SVD formulation for 3D point set fitting
• Horn (1987): quaternion-based closed-form absolute orientation
• Horn et al. (1988): orthonormal matrix (polar decomposition) approach
• Umeyama (1991): extension to include optimal scaling

For a detailed walkthrough of the Kabsch algorithm with code examples, see the companion blog post: The Kabsch Algorithm.

In computational chemistry and AI drug discovery, visualization pipelines are often brittle; breaking on edge cases or failing silently when processing millions of molecules for training data.

I built molecular-string-renderer to treat molecular visualization as a strict software engineering problem. It is a highly configurable wrapper around RDKit that standardizes the conversion of text-based chemical representations (SMILES, InChI, SELFIES) into raster and vector graphics, degrading gracefully on inputs RDKit cannot vectorize.

Features

This library differentiates itself from standard plotting scripts through strict architectural patterns designed for reliability:

1. Strategy Pattern for SVG Generation

RDKit’s vector rendering can sometimes fail on complex molecular topologies. I implemented a Hybrid Strategy so that a single molecule RDKit cannot vectorize does not fail the batch:

• Vector Strategy: Attempts to generate a true, scalable vector graphic.
• Raster Fallback: If the vector engine fails, the system automatically renders a high-res PNG and embeds it transparently into the SVG container.

2. Native Generative AI Support

With the rise of Large Language Models in chemistry, SELFIES (Self-Referencing Embedded Strings) has become a standard output format. This library handles SELFIES natively, managing the decoding and sanitization lifecycle internally so that ML training loops can simply “pass strings and get images.”

3. Strict Configuration Contracts

The library uses Pydantic models (RenderConfig, ParserConfig, OutputConfig) to enforce strict data contracts. This ensures that visualization parameters are validated before any heavy computation begins, preventing runtime errors deep in a batch job.

Usage

The library provides a simple Python API for rendering single molecules or batches of molecules from various string formats.

Results

• Type Safety: The codebase runs with strict mypy settings, ensuring type safety across the entire pipeline.
• Grid Auto-Fitting: Implemented smart layout algorithms that automatically adjust grid dimensions based on the input batch size.
• Format Agnostic: Decouples the parsing logic (SMILES vs. MolBlock vs. SELFIES) from the rendering logic, making it trivial to add support for new proprietary formats.

Reliability

When rendering large batches of generated molecules, a single hard-to-draw structure should not fail the whole job. The raster fallback and the strict Pydantic and mypy contracts exist so the pipeline degrades gracefully on edge cases rather than crashing or failing silently, the common failure mode of ad hoc RDKit plotting scripts.

Related Work

• Visualizing SMILES and SELFIES Strings: walkthrough of the visualization pipeline this library implements
• Isomer Dataset Generation: related project generating molecular datasets using SMILES/SELFIES representations

This project implements the classic 2D Müller-Brown potential in PyTorch as a ground-truth testbed for machine-learning-in-molecular-dynamics (ML-MD) work. The potential is a torch.nn.Module that computes forces two ways: a hand-derived analytical gradient (the default, compiled with torch.compile) and torch.autograd.grad (a reference the analytical path is checked against). On an Apple M1 Max, the analytical kernel runs about 4x faster than autograd (3-7x depending on batch size; 100 warm-up iterations, then the median of 5 runs of 1000), because it skips autograd’s graph construction inside the force loop.

The energy is deliberately left uncompiled so that second derivatives (the Hessian via autograd) keep working, since torch.compile does not support double-backward; the force, the hot path, is the compiled function.

Features

• Dual force kernels: a hand-derived analytical gradient (compiled) for fast simulation, and an autograd mode for differentiation and as the correctness reference the analytical path is tested against.
• BAOAB Langevin integrator: the BAOAB splitting scheme (Leimkuhler & Matthews, 2013), which solves the friction-plus-noise step exactly and samples the canonical distribution accurately (exactly so for a harmonic oscillator).
• Device-agnostic: potential, forces, and simulation are plain PyTorch tensor operations that run on CPU or CUDA; the included benchmark measures CPU.
• Modular architecture: physics (MuellerBrownPotential), numerics (LangevinSimulator), visualization, and HDF5 I/O are separated, with a CLI orchestrating demo, single-run, batch, and plot-regeneration modes.

Usage

The package installs editable with uv sync and imports as a normal package:

from muller_brown import MuellerBrownPotential, LangevinSimulator

It provides a fast, differentiable Müller-Brown potential and a Langevin sampler for testing ML-MD algorithms against a known-exact surface.

Results

Architecture

• Physics module: the energy surface is a torch.nn.Module with the potential parameters held as registered buffers, so device and dtype move with the module.
• Analytical force kernel: the analytical Jacobian is implemented directly and compiled with torch.compile(dynamic=True), bypassing autograd-graph construction during long simulations.
• Vectorized execution: kernel operations are vectorized over particles, so an ensemble runs in roughly the same wall time as a single particle (the per-step cost is dominated by the fixed force call and noise draw).
• Device-agnostic: all operations move to CUDA via native tensor handling; the benchmark and tests run on CPU.

Performance

A force-throughput benchmark (analytical vs autograd) across batch sizes from 2 to roughly 50,000 particles, on an Apple M1 Max:

• The analytical kernel is about 4x faster than autograd (3-7x across batch sizes).
• Per-particle force time drops below 1 microsecond at large batch sizes.
• Throughput rises with batch size and saturates for large ensembles.

Validation

The sampler is checked against statistical mechanics, not just run:

• Deterministic tests: the documented minima and saddles have the correct Hessian signatures; the analytical force matches torch.autograd.grad; energy is conserved in the frictionless (NVE) limit; float32 matches float64; and HDF5 round-trips preserve the data.
• Statistical tests: the sampler reproduces equipartition, the harmonic-oscillator distributions, and the Müller-Brown Boltzmann mean energy against a grid-integrated reference; a separate convergence study confirms the integrator’s kinetic-temperature bias vanishes as the timestep squared.

Molecular Dynamics

Langevin simulations on the surface show particle motion within energy basins, thermal fluctuations around the minima, and barrier-crossing transitions between wells, visualized as trajectories on the potential surface.

Simulation Videos

These videos demonstrate Langevin dynamics simulations on the Müller-Brown potential surface:

Related Work

This implementation is documented in detail in:

• Implementing the Müller-Brown Potential in PyTorch
• Basin A Simulation
• Basin B Simulation
• Transition Path Simulation

This project is a “digital restoration” of Aneesur Rahman’s seminal 1964 paper, Correlations in the Motion of Atoms in Liquid Argon. While the physics of liquid argon is a solved problem, the challenge lies in bridging the gap between 1960s mainframe constraints and 2025 software architecture.

I replicated the simulation using LAMMPS and built a Python analysis pipeline to process the trajectory data. The project demonstrates how modern tooling (uv, type hinting, vectorized NumPy) can transform academic “write-once” scripts into a reproducible research toolkit.

Features

The Analysis Pipeline

I architected a modular Python package (argon_sim) designed for performance and maintainability.

• Intelligent Caching System: MD analysis is compute-intensive ($O(N^2)$). I implemented a decorator-based caching layer (@cached_computation) that hashes source file modification times and function arguments. This ensures expensive calculations (like RDF or Van Hove correlations) are only re-run when the underlying trajectory or parameters actually change.
• Vectorization & Optimization: To handle the $N^2$ complexity of pair-wise interactions without C++ extensions, I utilized NumPy broadcasting. For example, the Mean Square Displacement (MSD) calculation is fully vectorized, with a fallback “chunked” implementation to handle memory overflows on smaller machines.
• Modern Python Tooling:
  • Dependency Management: Used uv for deterministic environment locking (sub-second resolution).
  • Type Safety: Fully type-hinted codebase for static analysis compliance.
  • Automation: A Makefile abstracts the workflow (simulation → analysis → figure generation) into single commands (e.g., make figure-5).

The Simulation Strategy

I used LAMMPS for the MD engine but strictly adhered to Rahman’s physical parameters while modernizing the stability mechanisms.

• Integration: Replaced Rahman’s predictor-corrector method with the modern standard Velocity Verlet algorithm (2 fs timestep).
• Equilibration: I implemented a 1 ns NVT equilibration phase (500,000 steps at the 2 fs timestep) to properly melt the FCC crystal structure before the NVE production run.
• Intellectual Honesty: The in.argon script explicitly documents every deviation from the original methodology (e.g., energy minimization) and the justification for ensuring numerical stability.

Usage

The project uses a Makefile to automate the workflow. Run make all to execute the LAMMPS simulation and generate all analysis figures.

Results

The replication achieved high quantitative agreement with the historical data, validating both the simulation parameters and the custom analysis code.

Visual Replication

I used Matplotlib to digitally recreate Rahman’s hand-drawn plots, confirming signatures like the negative region in the Velocity Autocorrelation Function (VACF), which provided the first evidence of the “cage effect” in simple liquids.

Challenges & Learnings

• Unit Hell: Rahman’s paper uses a mix of reduced units and CGS. Mapping these to LAMMPS’s real units required a dedicated constants.py module and rigorous unit testing to prevent dimensional errors.
• Fourier Transforms: Calculating the Structure Factor $S(k)$ from $g(r)$ required implementing a manual 3D Fourier transform for spherical symmetry, as standard FFT packages do not account for the radial shell integration implicit in liquid structure analysis.
• Code as a Liability: Early in the project, I realized that re-running analysis scripts was becoming a bottleneck. This drove the decision to build the caching infrastructure, reinforcing the lesson that investing in developer tooling pays off even in small-scale scientific projects.

Related Work

The full methodology and physics are documented in the companion blog post:

• Replicating Rahman’s 1964 Liquid Argon Simulation

Word2Vec is often treated as a “solved problem” or a black box inside libraries like Gensim. This project deconstructs the algorithm to treat it as a systems engineering challenge.

I built a ground-up, typed, and compiled PyTorch implementation that bridges the gap between the original C code’s efficiency and modern GPU acceleration. The core innovation lies in “tensorizing the tree”, converting the pointer-chasing logic of Hierarchical Softmax into dense, vectorized operations compatible with torch.compile.

Features

1. Vectorized Hierarchical Softmax

Classically, Hierarchical Softmax involves traversing a binary Huffman tree. While efficient on a CPU, this approach creates divergent execution paths on GPUs.

• The Solution: I implemented a “pre-computed path” strategy. The tree traversal for every vocabulary word is flattened into fixed-size tensors (word_path_indices, word_codes_tensor) padded to the maximum depth.
• The Result: The forward pass becomes a massive, masked batch dot-product against internal node embeddings, allowing the GPU to crunch the probability tree without branching logic.

2. Infinite Streaming & Sliding Windows

To handle datasets larger than RAM (e.g., Wikipedia/CommonCrawl), I built a custom IterableDataset that performs a true single-pass read.

• Efficient Windowing: It uses a collections.deque buffer to slide over the token stream, generating training pairs only when a new token enters the center context.
• Zipfian Subsampling: Implemented a probabilistic rejection sampling layer that downsamples frequent words (like “the” or “of”) on-the-fly, strictly adhering to the original Mikolov et al. paper’s distribution.

3. Modern Tooling

This project uses a strict “software 2.0” stack:

• Dependency Management: Built with uv for deterministic, fast environment resolution.
• Compilation: Fully compatible with torch.compile (PyTorch 2.0+), allowing for graph fusion of the custom loss functions.

Usage

The library installs from source (clone the repo, then pip install -e .) and exposes a typed Python API (SkipGramModel, CBOWModel, Trainer, Word2VecDataset) alongside word2vec-train and word2vec-query CLIs, with GPU acceleration. Trained embeddings export to .npy for use with Gensim or other tooling.

Results

• Correct embeddings: the produced vectors pass qualitative semantic-similarity checks (e.g., analogical reasoning), confirming the tensorized tree produces the same geometry as sequential traversal.
• Branch-free GPU execution: the batched Huffman-tree path turns hierarchical-softmax tree traversal into dense, masked tensor operations, removing the divergent branching that slows naive implementations on GPUs.
• Runs on larger-than-RAM corpora: the streaming IterableDataset with Zipfian subsampling processes Wikipedia/CommonCrawl-scale text in a single pass without loading the corpus into memory.
• torch.compile-compatible: the custom loss functions are written to fuse under torch.compile (PyTorch 2.0+).

Related Work

This project connects to related NLP work on this site:

• An Introduction to Word Embeddings: conceptual background on the representations this library produces
• Word Company Vicinity: research applying word vector semantics to company names
• Semantic Network Induction: research on inducing semantic graphs from embedding spaces

In computational drug discovery, data scarcity is often the bottleneck. This project builds a synthetic data generator that creates labeled 3D molecular datasets starting from nothing but a raw chemical formula (e.g., $C_6H_{14}$).

The pipeline bridges the gap between 1D Chemical Information (stoichiometry) and 3D Geometric Data (conformers), effectively serving as a “data factory” for training molecular machine learning models.

Features

1. Graph Enumeration & 3D Embedding

The core of the project is pysomer/data/gen.py, which orchestrates a multi-step generation process:

• Structural Isomerism: Uses MAYGEN (via a Java bridge) to mathematically enumerate all valid graph connectivities for a given formula
• Conformer Sampling: Uses RDKit to embed these graphs into 3D space, generating multiple conformers (rotamers) per isomer to capture flexibility
• IUPAC Labeling: Automatically queries PubChem APIs to assign human-readable labels (e.g., “2-methylpentane”) to the generated structures

2. Physics-Aware Featurization

The pipeline computes Coulomb Matrices, ensuring the input respects physical invariants:

$$C_{ij} = \begin{cases} 0.5 Z_i^{2.4} & i = j \ \frac{Z_i Z_j}{|R_i - R_j|} & i \neq j \end{cases}$$

This representation encodes the electrostatic potential of the molecule, providing a more informative signal for the neural network than raw Cartesian coordinates.

3. HDF5 Data Storage

To handle the large volume of generated conformers, the system writes to hierarchical HDF5 files. This allows for efficient, chunked I/O during training, a critical pattern for scaling to larger chemical spaces.

Usage

The pipeline is executed via a CLI, taking a chemical formula as input and outputting an HDF5 dataset of 3D conformers.

Results

This project serves as a “vertical slice” of a cheminformatics workflow.

• The Good: The separation of concerns is clean: dataclasses for configuration and HDF5 for storage keep the data-engineering layer tidy and extensible.
• The “Old School”: The model used is a simple Multi-Layer Perceptron (MLP) on flattened Coulomb Matrices. In a modern production setting (post-2020), I would replace this with an E(3)-Equivariant GNN (like SchNet or E3NN) to handle rotational symmetry natively, eliminating manual feature engineering.
• Dependency Management: The reliance on an external Java JAR (MAYGEN) for graph enumeration makes the environment brittle. Today, I would likely swap this for a pure Python enumerator or a containerized microservice to improve portability.

Related Work

This data pipeline powers the analysis in my comprehensive guide on molecular representation:

• Coulomb Matrix Eigenvalues: Can You Hear the Shape of a Molecule?: A deep dive into data generation, unsupervised clustering, and supervised classification of alkane isomers.

See also:

• The Coulomb Matrix: Deep dive into the physics-based featurization used here
• The Number of Isomeric Hydrocarbons: The foundational 1931 paper on alkane enumeration

This project provides an “input-to-analysis” workflow for simulating adatom diffusion on FCC metal surfaces. It demonstrates how to set up surface diffusion simulations in LAMMPS, manage EAM potentials, and parse trajectory data into energy and trajectory plots using Python. The LAMMPS input scripts are adapted from Eric N. Hahn’s adatom tutorial; the Python analysis layer (plot_energy.py, plot_xy.py) is my own, written while in CSElab (Harvard, 2023).

The workflow covers two material systems (Copper (Cu) and Platinum (Pt)) providing comparative datasets that highlight how atomic mass and bonding strength affect surface dynamics.

Features

Simulation Architecture

The project separates simulation logic from analysis code:

Each directory contains:

• LAMMPS input scripts (.in files) defining the physics
• EAM potential files for metallic bonding (the Cu potential is committed; the Pt potential must be downloaded separately from the NIST Interatomic Potentials Repository, so the Pt system does not run as-checked-out)
• Python analysis scripts for trajectory and energy parsing

Key Features

• EAM Potentials: Uses Embedded Atom Method alloy potentials to accurately model metallic bonding and surface energies, providing accuracy beyond simple Lennard-Jones potentials
• Automated Analysis: Python pipeline (plot_energy.py, plot_xy.py) that parses raw thermodynamic logs and trajectory dumps to generate “health check” dashboards
• Workflow Orchestration: Demonstrates the “Input → Simulation → Analysis” loop, automating the transition from raw .lammpstrj files to publication-ready plots
• Kokkos Support: Includes Kokkos execution commands for GPU/multi-threaded runs

Simulation Parameters

Usage

The repository includes LAMMPS input scripts and Python analysis scripts. Run the LAMMPS scripts to generate trajectory data, then use the Python scripts to visualize the results.

Results

This workflow is documented in detail in companion blog posts:

• LAMMPS Tutorial: Copper and Platinum Adatom Diffusion - Complete setup walkthrough with line-by-line script explanation and comparison of how heavier atoms behave differently on surfaces

I developed an automated GROMACS pipeline to generate molecular dynamics (MD) datasets for machine learning applications. The workflow automates the simulation of capped dipeptides across nine distinct residue types, creating a diverse training set suitable for Neural Network Potentials (NNPs). The pipeline is built off Luca Tubiana’s GROMACS tutorial (University of Trento); the Python analysis layer and the curated dipeptide dataset are my own.

Features

Automated Simulation Pipeline

• End-to-End Scripting: Bash-automated workflow handling topology generation (pdb2gmx), solvation, ionization, and equilibration
• Langevin Dynamics: Implemented Stochastic Dynamics (SD) integration to ensure proper canonical (NVT) ensemble sampling
• High-Resolution Output: Configured to capture 0.1 ps (100 fs) resolution trajectories, critical for capturing fast bond vibrations
• Force Extraction: Optimized output to .trr format preserving uncompressed atomic forces, a key requirement for force-matching in ML potentials

; md_langevin.mdp
integrator  = sd        ; Stochastic dynamics for proper sampling
dt          = 0.001     ; 1 fs timestep
nstxout     = 100       ; Output every 100 steps = 0.1 ps resolution
tc-grps     = Protein Non-Protein
tau_t       = 0.1  0.1  ; Friction constant (ps)

Chemical Diversity Suite

Designed to stress-test ML models against varied kinematic constraints:

Usage

The pipeline is executed via bash scripts, requiring GROMACS to be installed.

Results

• Data Volume vs. Fidelity: Balanced high-frequency force outputs (every 100 steps) against storage constraints by automating post-processing extraction of forces into lightweight .xvg formats
• Force Field Consistency: Standardized the Amber03 force field and TIP3P water model across all residues to ensure consistent potential energy surfaces for downstream model training

Note: This pipeline uses Amber03 for consistency across residue types. For production ML potentials, consider swapping to Charmm36m or similar modern force fields.

Retrospective

• Demonstrative, not production-scale: the 1 ns trajectories exercise the pipeline and capture fast bond vibrations, but proper conformational sampling needs 100 ns to 1 µs runs. This is a working reference, not a finished dataset.
• Dated force field: Amber03 / TIP3P keeps the potential energy surface consistent across residues, but it is not state-of-the-art for ML-potential training; CHARMM36m or Amber ff19SB would be the upgrade path.
• Paused, not abandoned: a candidate to revive and extend (more residues, longer trajectories, Ramachandran analysis) for future force-matching work.

Related Work

• Mini-Protein Dynamics - Detailed blog post on the simulation methodology

A computational social science project that constructed a dataset of 47,000+ US congressional bills by extracting legislative text and metadata from the 115th-117th Congresses. The project creates a “legislative graph” (linking sponsors, committees, and bill text) and establishes TF-IDF baseline models for policy area classification across 33 (highly imbalanced) policy classes, now hosted on Hugging Face to support reproducible political science research.

Features

Intelligent Data Acquisition

Standard APIs impose strict rate limits. I built a Selenium-based extraction engine to handle Congress.gov’s complex DOM structures.

• Optimization: Targeted aggregate endpoints (e.g., /all-info) to pull each bill’s text and metadata in fewer requests.
• Resilience: Implemented a local caching layer to store raw HTML, separating the fetch step from the parse step. This made the parse step re-runnable without re-fetching, and minimized server load during iterative development.
• Graph construction: Beyond simple text, the script extracts relational data including co-sponsorship networks, committee assignments, and related bill lineage.

Natural Language Processing

• Corpus construction: Cleaned and normalized legislative text, removing procedural artifacts (e.g., “A BILL TO…”) to isolate semantic policy content.
• Feature engineering: Utilized TF-IDF vectorization with N-gram analysis to capture legislative jargon.
• Modeling: Benchmarked Naive Bayes, Logistic Regression, and gradient-boosted trees (XGBoost), reaching ~0.86 weighted F1 on bill summaries and up to ~0.89 on full text (cross-validated). Weighted F1, not raw accuracy, is the honest metric here: the 33 policy classes are severely imbalanced (Health has 5,911 bills; Social Sciences and History has 15).

Usage

The dataset is available on Hugging Face and can be loaded directly via the datasets library. The scraper can be run locally to fetch new bills.

Results

• The “partisan vocabulary”: Feature importance analysis revealed distinct linguistic markers separating Democratic and Republican legislation, identifiable even without metadata.
• Temporal drift: Policy priorities and terminology showed measurable shifts across congressional sessions (115th vs 117th).
• Classification success: Simple linear models (Logistic Regression and Naive Bayes) proved effective at distinguishing policy domains, outperforming gradient-boosted trees on these sparse TF-IDF features and suggesting legislative language is highly structured.

Impact & Deliverables

• Hugging Face dataset: Released a machine-readable, ML-ready dataset of modern bills (115th-117th Congresses) on Hugging Face for reproducible research.
• Open source tooling: Published the scraper and parsing logic to allow others to extend the dataset to future congresses.
• Academic benchmark: Establishing a clear baseline for “Government NLP” tasks, aiding in the automated transparency and monitoring of new legislation.

Related Work

• 117th Congress Data Exploration
• Congressional Bill Policy Area Classification

Overview

Standard Reinforcement Learning agents can behave unpredictably in unseen states. This approach forces the agent’s weights to satisfy Integral Quadratic Constraints (IQC) via a projection step. Effectively, it solves a convex optimization problem (Semidefinite Program) inside the gradient descent loop to ensure the controller never violates Lyapunov stability criteria.

The method bridges classic Robust Control Theory (1990s) with Deep Reinforcement Learning (2020s), providing mathematical certificates of safety for neural network controllers.

Features

• Hybrid Optimization: Interleaved standard Gradient Descent (PyTorch) with Convex Optimization (cvxpy + MOSEK) to project weights onto the “safe” manifold after each training step.
• Complex Constraints: Implemented the “Tilde” parametrization from the original paper to convexify the non-convex stability conditions of the RNN dynamics, transforming an intractable problem into a solvable Linear Matrix Inequality (LMI).
• Safety-Critical Domains: Applied the controller across six control systems (cartpole, inverted pendulum, nonlinear pendulum, pendubot, power grid, and vehicle dynamics), including unstable plants where “crashing” during training is unacceptable.

Usage

The repository includes training scripts for the inverted pendulum and power grid environments, demonstrating the stability guarantees in practice.

Results

This project was a deep dive into the tension between Safety and Speed.

• The Bottleneck: Solving an SDP at every few steps of training is computationally expensive (interior-point SDP solvers scale steeply, roughly $O(n^6)$ in the matrix dimension). While it provided mathematical certificates of safety, it highlighted why these methods haven’t yet overtaken standard PPO/SAC in production: the “safety tax” on training time is steep.
• The Lesson: It taught me that “theoretical guarantees” often come with “engineering fine print.” If I were to redo this today, I would look into differentiable convex optimization layers (like cvxpylayers) to make the projection end-to-end differentiable.
• The “Rough Edges”: The codebase has artifacts of its research origins (e.g., the reqs.txt dependency dump). Reading a dense control theory paper (Gu et al., 2021) and implementing the math correctly was the primary focus.

Citation

Credit to the original authors:

@misc{gu2021recurrentneuralnetworkcontrollers,
      title={Recurrent Neural Network Controllers Synthesis with Stability Guarantees for Partially Observed Systems},
      author={Fangda Gu and He Yin and Laurent El Ghaoui and Murat Arcak and Peter Seiler and Ming Jin},
      year={2021},
      eprint={2109.03861},
      archivePrefix={arXiv},
      primaryClass={eess.SY},
      url={https://arxiv.org/abs/2109.03861},
}

Related Work

• Deconstructing Recurrence and Attention Gating: research on recurrent network architectures, providing context for why stability guarantees on RNNs matter

Undergraduate thesis exploring representation learning for social media text and developing tools for cross-platform conversational analysis. Built PyConversations, a Python module for analyzing social media conversations, and found that domain-specific approaches often outperform large pre-trained models.

Features

PyConversations Module

• Graph-based modeling: Models conversations as Directed Acyclic Graphs (DAGs) to quantify topological structure (depth, width, density)
• Unified interface: Polymorphic design normalizing heterogeneous data from Twitter, Reddit, 4chan, and Facebook into a single analysis schema
• Linguistic dynamics: Implements information-theoretic feature extraction, including harmonic mixing laws and entropy measures
• Stream processing: Memory-efficient generators to ingest and traverse multi-gigabyte JSON dumps (e.g., 135M+ Reddit posts) without loading the full corpus into RAM

Research Contributions

• Representation learning: Investigated domain-specific vs. general-purpose Transformers (BERT vs. specialized variants) on social media text
• Topological analysis: Demonstrated that conversational structure (context) is as critical as content for classification tasks
• Cross-platform study: Comparative analysis of communication dynamics across moderated (Reddit/Twitter) and unmoderated (4chan) spaces

Usage

The PyConversations module can be imported into Python scripts to parse and analyze social media datasets.

Results

• Model performance: Smaller, domain-specific approaches frequently outperformed standard pre-trained models
• Context importance: Conversational context and dialogue structure proved crucial for understanding social media interactions
• Domain adaptation: Social media text benefits from specialized handling over generic approaches
• Cross-platform challenges: Different platforms require adapted approaches despite seeming similarities

Team & Recognition

• Hunter Heidenreich - Lead Researcher and Developer
• Jake Williams - Faculty Advisor
• First Place - Research Undergraduate Senior Thesis at Drexel University

Impact

This library served as the engineering backbone for my thesis, Look, Don’t Tweet, enabling the processing of 308 million posts to evaluate Transformer performance on toxic data.

The findings about model performance suggested that specialized domains require tailored model architectures, a perspective that has become more relevant as the field continues to evolve.

Overview

Standard Cartesian Genetic Programming (CGP) relies heavily on mutation. The upstream library hybridizes CGP with NEAT (NeuroEvolution of Augmenting Topologies) concepts to protect topological innovation through speciation.

My goal in forking it was to evolve graph-based programs that could learn Atari control policies using gradient-free optimization.

Features

The upstream framework provides the CGP machinery this project builds on:

• Graph-based Crossover: Crossover operators such as subgraph_crossover and aligned_node_crossover that handle the destructive nature of mating graph structures.
• Speciation: A NEAT-inspired compatibility-distance metric (cgpneat.jl) to maintain population diversity and prevent premature convergence.
• Active Gene Tracking: Differentiates between “active” nodes (those contributing to output) and “junk DNA,” focusing mutation on phenotypic changes.

My own contribution was the Atari reinforcement-learning layer on top of this: experiment variants (action_atari.jl, original_atari.jl, manual_atari.jl, play_atari.jl, param_sweep.jl), custom fitness and scoring functions, early-stopping and completion-percentage logging, multithreading and pmap multiprocessing attempts (reverted to single-thread), and config tuning to match a reference paper’s hyperparameters.

Usage

The library provides a Julia API for defining CGP graphs, configuring evolutionary parameters, and running the evolutionary loop against custom environments.

Results

Looking back, this codebase captures a transitional moment where I was moving from scripting to library design.

• The Ambition: Getting CGP graphs to learn Atari policies under the mixed-type regime (RGB-array inputs, scalar action outputs) was an ambitious undertaking for my software engineering skills at the time.
• The “Legacy” Code: The project relies on the now-deprecated Julia v0.6 and uses eval(parse(...)) patterns for configuration (a significant performance anti-pattern in modern Julia).
• The Lesson: It taught me the difficulty of designing genetic operators that respect topological constraints, a lesson that informs my current understanding of optimization in structured spaces.

Overview

I sought to replicate the logic of FFTW’s genfft: a metaprogram that generates straight-line, highly optimized C code. The goal was to understand how abstract algebra (group theory) could be translated into efficient machine code through symbolic manipulation.

Features

This was my first deep dive into functional metaprogramming and compiler theory:

• Symbolic AST: Modeled mathematical operations as a Directed Acyclic Graph (DAG) in Haskell (data Node), separating the definition of the math from its execution.
• Algebraic Simplification: Implemented a symbolic optimization pass that pruned operations at compile-time (e.g., eliminating multiplications by $1$, $0$, or $-1$) before code generation.
• Monadic State Management: Used Haskell’s State Monad to manage the graph construction and memoization, ensuring common subexpressions (like reusable cosine factors) were calculated only once.
• Code Generation: The system outputted unrolled, straight-line C code (e.g., fftw4.c), mimicking the “codelets” used by the actual FFTW library.

Usage

The compiler is run via the command line, taking the desired FFT size as input and outputting the optimized C code.

Results

Looking back, this project represents a pivotal moment where I moved from “writing programs” to “writing tools that write programs.”

• The “Magic”: It demystified high-performance computing. I learned that speed often comes from unrolling recursion and managing register pressure at compile time alongside writing fast loops.
• The “Rough Edges”: The scheduler (coloring nodes Red/Blue for register allocation) was a heuristic approximation of the optimal Aho-Johnson-Ullman algorithm.
• Legacy: The core lesson that domain-specific compilers can outperform hand-tuned generic code remains relevant to my current work in optimizing scientific computing kernels.

Overview

Manually creating a university schedule involves solving a Constraint Satisfaction Problem (CSP) with multiple variables:

• Hard Constraints: No time overlaps between classes.
• Soft Constraints: Preferences for “no 8 AMs,” specific lunch breaks, or maximizing free days.

The naive approach (manually checking every possible combination) becomes intractable as the number of courses and sections grows.

Features

I built a script that:

1. Scraped Data: Parsed the Drexel WebTMS (Term Master Schedule) using lxml to build a localized dataset of course availability.
2. Solved for X: Implemented a recursive backtracking algorithm to generate every valid schedule permutation that satisfied user-defined constraints.

The Algorithm

The core of this project is a recursive_generator function that implements a valid CSP solver using backtracking. It performs a recursive depth-first search that:

1. Takes a set of variables (courses).
2. Checks constraints (time overlaps, lunch hours, max classes per day).
3. Backtracks when a branch fails.

It is the same backtracking pattern used in everything from Sudoku solvers to compiler register allocation.

Usage/Gameplay

The tool is run via the command line, taking a list of desired courses and outputting valid schedule combinations.

Results

This tool saved me (and several friends) hours of planning time each quarter. While the scraping logic was fragile (dependent on 2017 HTML structures), the core logic (a depth-first search through the state space of possible schedules) remains a fundamental algorithmic pattern.

Built in under 24 hours at the Drexel 2017 Music Hackathon, this project attempts to answer a question: What does order sound like?

The system uses a webcam to scan a Rubik’s cube face and algorithmically generates audio based on the color configuration. A scrambled cube generates dissonant, complex waveforms; a solved cube resolves into a pure, harmonious chord.

Features

This freshman-year project was built on first principles:

• Manual Waveform Synthesis: The audio engine generates raw 8-bit PCM audio byte-by-byte using sine functions (math.sin), played at a 16 kHz sample rate.
• Algorithmic Harmony: Colors are mapped to musical intervals. The “center” color establishes the root note (Tonic), while the surrounding “cubies” determine the chord structure and melody using equal temperament frequency calculations ($f = f_0 \cdot 2^{n/12}$).

Usage/Gameplay

The application runs via a Python script, requiring a webcam to scan the Rubik’s cube.

Results

Looking back at this code 8 years later, it serves as a “time capsule” of my early engineering mindset.

• The “Hack”: The computer vision relied on hardcoded pixel coordinates and raw OS shell calls, classic “glue code” behavior typical of hackathons.
• The Lesson: While brittle, the project successfully demonstrated how to bridge the gap between physical entropy and digital signal processing using fundamental programming concepts.

Related Content

• Video Demonstration

In 2014, as a junior in high school, I had a dream: to create a fighting game where the elements of the periodic table came to life to duke it out. Elemental Brawl was born.

The vision was ambitious for a 16-year-old: 37 playable characters (each a different element), 25 stages, 30 music tracks, 40 items, 100+ achievements, and 4-player LAN support. I assembled a team of talented artists and a composer, launched a Kickstarter campaign, and built a playable demo.

Features

Each element had its own personality and fighting style based on its chemical properties:

Oxygen was a gaseous fighter, utilizing small bubbles that formed into legs for amazing speed and agility. A fun-loving character but a bit of a hot head. Get it too hyped up and it would burst into flames, scorching all its foes!

Carbon was a nonmetallic brawler with a burning passion for the art of fighting. Carbon hit hard, jumped high, and launched small fireballs at enemies. When charged with enough energy, it would pressurize itself into solid diamond and launch into the sky with atomic force.

We even had concept art for more complex characters like Iron:

Usage/Gameplay

The game was a 2D fighting game with a focus on elemental interactions and combos.

Results

We launched our Kickstarter campaign on October 24, 2014, seeking $19,000 to fund the full development.

The campaign raised $1,910 from 31 backers; people who believed in a high schooler’s dream. While we didn’t reach our funding goal, the experience was invaluable.

The Team

I was fortunate to work with talented people:

• Noah Evans (Concept Artist/GUI Artist): A visual arts major at School of the Arts in South Carolina
• Molly Heady-Carroll (Character Animator): An Irish artist earning her MA in Game Art from HKU in the Netherlands
• Sean Pack (Composer): A versatile composer for film, TV, video games, and theater
• Bryan Moore (Stage Artist): A SCAD graduate specializing in backgrounds and environments

Retrospective (2025)

Looking back over a decade later, the project was a massive success in terms of learning. We accomplished several major milestones:

• Built a playable demo from scratch
• Coordinated a remote team across multiple countries
• Created original music, art, and animations
• Ran a real crowdfunding campaign
• Learned what it takes to turn an idea into something tangible

The project taught me about project management, creative collaboration, and the gap between vision and execution. These lessons carried forward into every project since.