I am a PhD candidate in Machine Learning at Johns Hopkins University, advised by Randal Burns, Joshua Vogelstein and Alan Yuille. My research focus is scalable and high performance Machine Learning, Fluid Dynamics and Medical Imaging methods. I am a member of the Institute for Data Intensive Engineering and Science (IDIES), and I write about High Performance Python, scientific data management and hands-on graph data science.
News
- Feb 2026 — Vectorized Adaptive Histograms for Sparse Oblique Forests posted to arXiv, joint work with Google's Yggdrasil Decision Forests (YDF) team.
- Feb 2026 — Second pull request merged into NVIDIA PhysicsNeMo-Sym, restoring and speeding up its Johns Hopkins Turbulence Database integration.
- Jul 2025 — First contribution merged upstream into Google's YDF: O(k) binomial oblique projection sampling.
- May 2024 — Edge-Parallel Graph Encoder Embedding presented at IPDPS 2024 Workshops (GrAPL).
Selected work
Faster oblique forests in Google's YDF
Sparse oblique forests are more expressive than standard random forests, but far more expensive to train because they build deep trees and must sort or histogram linear combinations of the data at every split. I make them practical, working directly with Google's Yggdrasil Decision Forests (YDF) team in Zurich.
Cutting sparse oblique training time by ~6× on high-dimensional data — 12 hours down to 2 — contributed as 7 upstream pull requests (3 merged, 4 in review) rather than a private fork. On top of that baseline, two further methods add another 1.7–2.5× end to end: SIMD-vectorized histogram binning, where two vector compares replace a per-sample binary search, and a per-node adaptive splitter that chooses between exact and histogram splits by cardinality. I am now extending this to multi-node distributed training and SIMD-vectorized inference via QuickScorer, and I mentor two graduate students on the project.
arXiv preprint · Upstream PRs · Experimental fork
NVIDIA PhysicsNeMo & the Johns Hopkins Turbulence Database
PhysicsNeMo is NVIDIA's framework for Physics-ML surrogates of expensive dynamical systems, and it reads from the Johns Hopkins Turbulence Database (JHTDB), of which I am a funded member. I restored its broken JHTDB data path by porting it onto the current Giverny API, and removed a redundant low-resolution fetch for a 60% runtime reduction. Two pull requests merged upstream.
Edge-Parallel Graph Encoder Embedding
Graph Encoder Embedding computes node embeddings in a single linear pass over edges — an order of magnitude cheaper than spectral, node2vec or GCN methods even before parallelization — but its reference implementation was serial and interpreted. I reformulated it as a lock-free, edge-parallel program in the Ligra graph engine. On the 1.8B-edge Friendster graph this cuts embedding from ~56 minutes to 6.4 seconds on 24 cores: a 500× speedup over the original implementation and 17× over a Numba JIT baseline. Peer-reviewed and published at IPDPS 2024 Workshops (GrAPL).
IEEE Xplore · arXiv · GitHub
GPU-accelerated Orthogonal Matching Pursuit
Scikit-learn's OMP is accessible but single-threaded, which rules it out for all but the smallest sparse reconstruction problems. Using Gramian precomputation, Cholesky factorization and cuBLAS, my implementation is up to 310× faster than Scikit-learn and 26× faster than SPAMS — including up to 83× on a single core before any GPU is involved — while staying a drop-in scikit-learn-compatible estimator.
arXiv · GitHub · pip install batched-omp
Publications
- Vectorized Adaptive Histograms for Sparse Oblique Forests — arXiv
Preprint, 2026. With the Google YDF team. - Edge-Parallel Graph Encoder Embedding — IEEE Xplore · arXiv · GitHub
IEEE IPDPS 2024 Workshops (GrAPL) - A Practical GPU-Accelerated Implementation of Orthogonal Matching Pursuit — arXiv · GitHub
Preprint, 2024 - Application of Machine Learning in a Rodent Malaria Model for Rapid, Accurate, and Consistent Parasite Counts
— bioRxiv
Preprint, 2024 - Analysis of Inertial-Range Intermittency in Forward and Inverse Cascade Regions in Isotropic Turbulence —
arXiv
Preprint, 2025 - Analysis of Energy Cascade and Buoyancy Loss in a Publicly Accessible Stable Atmospheric Boundary Layer Dataset
— NASA ADS
AGU Fall Meeting 2024
Teaching
- Fall 2026 — Teaching Assistant, EN.601.612 Big Data Systems
Johns Hopkins University. Big data processing end to end: NoSQL databases, the Hadoop ecosystem, distributed processing with Apache Spark, data warehousing with Hive and streaming with Kafka, with an emphasis on the architectural design and operational challenges of big data ecosystems at scale. - Fall 2022 (Teaching Assistant), Fall 2023 and Fall 2024 (Course Assistant) —
EN.601.620 Parallel Programming & Performance Engineering
Johns Hopkins University. Writing efficient software by exploiting hardware parallelism — instruction-level parallelism, vectorization, pipelining, multicore and the memory hierarchy — mostly in C/C++, with parallel Python and CUDA for GPUs.
Earlier projects & explorations
Not everything below worked, and that is the point — these are where the profiling and systems instincts came from. The Zarr and turbulence tooling led directly to JHTDB and PhysicsNeMo; the Ligra experiments became the IPDPS paper; the graph tooling fed Graph Encoder Embedding.
- Model pruning and tensor parallelism for Evolutional Deep Neural Networks — preliminary work on GPU-porting EDNNs, a neural surrogate for PDE time evolution. The sequential dependence between time steps left too little work per kernel launch for tensor parallelism to pay off at the network sizes we needed; a useful negative result about where this class of surrogate does and does not scale.
- Deploy scientific datasets to multi-disk systems — sharding large turbulence arrays across disks to maximize parallel read throughput. Directly ancestral to my JHTDB work.
- Visualize turbulence data — tooling for direct numerical simulation data, built while learning what JHTDB users actually need.
- Zarr efficiency analysis — benchmarks on whether Zarr and its compression are the right choice for scientific arrays. The answer was "it depends, and here is the measurement", which became two of the articles below.
- Tools for working with graphs — synthetic graph generation and benchmarking harnesses, the scaffolding used to evaluate Graph Encoder Embedding.
- Leiden community detection performance analysis — profiling the Leiden algorithm's parallel scaling. The bottleneck turned out to be inherent to the refinement phase rather than the implementation, so I did not pursue a parallel rewrite.
- DALL·E image generator for Google Docs, Sheets and Slides — shipped to the Google Workspace Marketplace and used by real people; retired when the underlying API changed. The documentation is kept here.
- Alice in Wonderland chatbot — built for the University of Southern California with Mycroft speech-to-text, a custom NLP model and Google Dialogflow. The hosted endpoint has since been taken down.
- Hierarchical time series analysis — reconciled forecasts for same-category pharmaceutical demand.
- Malaria detection & segmentation — the computer vision groundwork behind the rodent malaria parasite-counting paper above.
- Hand gesture recognition — an early computer vision project.
- Octave dark theme — a small colour configuration that turned out to be my most-starred repository. A reminder that impact and effort are only loosely correlated.
Repositories I maintain
I contribute to the Johns Hopkins Turbulence Database's Python clients: giverny (current) and pyJHTDB (legacy).Talks
DeepMind's EEML Albania 2023Articles
ChatGPT can’t count, and that’s a problemHands-On Quickstart to Training Large Language Models
To Compress or Not to Compress — A Zarr Question
Plot Most Important Nodes in a Graph with NetworkX and MatPlotLib
More CPU cores is seldom better, and here’s why
The Reasons Behind Numpy’s Speed are Often Misunderstood - Part 2
Efficiently Querying Large Scientific Data Using Zarr’s partial decompress
The Reasons Behind Numpy’s Speed are Often Misunderstood - Part 1
Parallelize Graph Computations Using Ligra Framework’s EdgeMap Interface