I am a PhD candidate in Computer Science at Johns Hopkins University, advised by Randal Burns, Joshua Vogelstein and Alan Yuille. I work on scalable and high-performance Machine Learning: CPU/GPU profiling, CUDA, tree ensembles, graph learning and scientific data systems. 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
- Sep 2026 — Teaching Assistant for EN.601.612 Big Data Systems at Johns Hopkins (Spark, Kafka, Hadoop, NoSQL).
- Aug 2026 — Developing the first multi-node distributed training method for sparse oblique forests with the YDF team; none exists today, which keeps the model out of large-scale AutoML pipelines.
- Jul 2026 — Two new YDF pull requests in review: #403, 3× faster sparse oblique training on high-dimensional data by caching projection evaluation, and #409, up to 75% faster candidate attribute sampling via Fisher–Yates.
- May 2026 — PR #354 merged into YDF: Highway VQSort for histogram binning, a 10–15% end-to-end speedup. #356 (15% Random Forest, 30% sparse oblique speedup from restructured split search) in review.
- 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 9 upstream pull requests (3 landed: 2 merged on GitHub and 1 imported internally; 4 in review) rather than a private fork. Two novel methods contribute 1.7–2.5× of the 6×: 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. The rest comes from systems work, most recently #403 (3× faster on high-dimensional data by caching projection evaluation) and #409 (up to 75% faster attribute sampling), both in review. I am now building the first multi-node distributed trainer for sparse oblique forests 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, a 2.5× speedup on low-resolution inputs. 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, 2023 and 2024 — Teaching Assistant (Course Assistant title in 2023–24),
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
Albanian Machine Learning Workshop (AMLW) 2023, an EEML satellite workshop organised with Google DeepMind researchers — University of New York Tirana, 20 October 2023. Invited speaker alongside Razvan Pascanu, Viorica Patraucean and Caglar Gulcehre.Articles
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