I build and ship production machine learning: model training, evaluation, and the systems that serve it.
I build applied machine learning end to end: training and evaluating models, then shipping them behind production APIs and infrastructure. My work spans document AI and information extraction, reinforcement learning for 3D bin-packing, parameter-efficient fine-tuning research, and real-time anomaly detection, alongside the systems, security tooling, and full-stack products I've shipped.
I care about shipping under production constraints: evaluation gates before a model promotes, integrity verification, and honest reporting of what's ● measured versus what's ○ still in progress. Every project claim below is marked accordingly.
Looking for
Machine learning engineering roles: applied ML, model training and evaluation, and ML systems/platform work. Contract or full-time, remote (US).
Work
16 exhibits
Exhibit 01ML & Applied AI
Packomation · Spatial Capture & Learned 3D Bin Packing
An iOS app that scans a room or shipment and generates an optimized 3D load plan, for both personal moves and freight/container loading. A local Expo native module bridges RoomPlan LiDAR scans and ARKit tap-to-measure for item dimensioning, with camera intake (react-native-vision-camera) and a non-LiDAR fallback chain (marker-assisted estimate, then model prior). Planning ships classical 2D/3D heuristics in TypeScript (BL/BAF/BSSF/BLSF plus an NFDH shelf packer) alongside a learned packer: a height-map actor-critic (Zhao et al., AAAI 2021) trained from scratch by PPO self-play on synthetic instances (no labels), extended with a lookahead policy that chooses which of the next k buffered items to place, and where to put it, in one forward pass (k = 1 reduces exactly to the online env, parity-verified). Packing constraints (stacking limits, orientation locks, unload-order/LIFO) enter as declarative per-step feasibility masks randomized during training, so a single policy transfers across constraint sets; inference wraps the policy in sampled rollouts with value-guided beam search, served via a FastAPI /plan endpoint with a TypeScript client and an ONNX export path for on-device inference. Freight mode adds pallet-first planning, container presets, load sequencing, a deterministic scorecard with a profile-aware re-ranker, and carrier handoff docs.
●Measured:Under realistic constraints the lookahead policy's strict win rate over the best-of-4 heuristic rises from 0.10 to 0.69 as constraints tighten, staying 90–95% proven-optimal against a CP-SAT lower bound while the heuristic's optimality gap grows ~9×; the learned edge grows with constraint complexity
●Measured:Process-parallel env stepping (shared-memory workers): 555 → 4,051 env-steps/s (7.3×) and ~3.7× end-to-end PPO, turning a ~3-hour training run into under an hour on one GPU
●Measured:Eval-gated promotion: a checkpoint ships only if it beats the heuristic baseline; promoted checkpoint and training configs are committed. Jest suite covers planning, dimension estimation, sensor matching, persistence, exporters, and integration
○In progress:Completability research: the boundary of mask-sufficiency is dead-end-free vs dead-end-prone, not static vs order-dependent; a fixed-capacity cut-subset feasibility benchmark is underway
Fig. 01 · Learned packer fitting a 2-bedroom load (18 items, 7 fragile) into a 14-ft truck under automatic stacking constraints
Does the Basis Matter? Permutation Controls for Wavelet PEFT
Python · PyTorch · PEFT / LoRA · Wavelets · Computer Vision · Medical Imaging · SAM · Permutation Tests
This project began as WaRA, a PyTorch PEFT library for LoRA-style fine-tuning in the wavelet domain (a separate low-rank adapter per DWT subband, recombined via inverse DWT at zero inference cost), and grew into a diagnostic study of whether frequency-domain PEFT methods exploit any real structure in their basis. The instrument is a matched basis-permutation control. Permutations are orthogonal and energy-preserving: they leave the LoRA baseline exactly invariant (singular values are preserved) while destroying the adjacency a separable 2D DWT relies on, so comparing the real metric to its permutation null separates real structure from basis artifact. On SAM ViT-B fine-tuned for CT segmentation (MSD-Spleen, full fine-tuning to val DSC 0.929, one 12 GB GPU), the two spaces split cleanly. In weight space, a genuine update is statistically indistinguishable from its permutation null (mean z ≈ 0), and a per-subband wavelet split needs ~85% more parameters than plain LoRA to match approximation quality, because the update is globally low-rank, exactly the regime where the SVD is optimal. In activation space, the patch-token grid beats its spatial-permutation null in every block (mean z ≈ +19). The wavelet basis helps only where adjacency is real, which explains why published wavelet PEFT operates on activations rather than weights.
●Measured:Weight space is a basis artifact: a full fine-tuning update is indistinguishable from its permutation null (mean z ≈ 0), and the wavelet split needs ~85% more parameters than plain LoRA
●Measured:Activation space is real: the patch-token grid beats its spatial-permutation null in 100% of blocks (mean z ≈ +19)
●Measured:The WaRA library remains the instrument: weight-space and activation-space (WaRA-Seg for SAM) variants with a parameter-matched LoRA baseline; 75-test pytest suite passes
○In progress:Paper v2 ('Does the Basis Matter?') extends the control to FourierFT, WaveFT, VeRA, and RandLoRA across parameter budgets to test a capacity-threshold law
A statistical library (certify) and paper for certifying whether a compressed model is ε-equivalent to its source, with guarantees that hold at any stopping time. The certifier is an anytime-valid ε-equivalence test (betting confidence sequence plus a GROW-boundary e-process) whose wrong-verdict probability stays ≤ α no matter when you stop. Matching sample-complexity bounds accompany it, E[τ] = (1+o(1))·log(1/α)/KL(D‖ε) with rate ratio ≈ 1.2 at α = 0.05, and the oracle second-order term is resolved exactly. It ships two specializations: a worst-slice test certifying that every subgroup stays within ε, made multiplicity-free by a product e-process (no Bonferroni log G penalty), and a compression-frontier mode that certifies which of K candidate compressions are ε-equivalent and returns the cheapest, sharing each source pass so the expensive source cost is max_k rather than Σ_k. An audit applies it to eight architecture families under bitsandbytes plus released GPTQ/AWQ checkpoints: 4-bit certifies NOT_EQUIVALENT for every family, 8-bit is architecture-dependent, and query cost tracks the theory. The paper is explicit that the statistical pieces specialize known results; the contribution is assembling them into the first rigorous, deployable, anytime-valid certifier for compression, run end to end on a single 12 GB GPU.
●Measured:Provenance recorded for every number in the paper
●Measured:Audit across 8 architecture families: 4-bit certifies NOT_EQUIVALENT for every family, 8-bit is architecture-dependent; query cost tracks the theory
○In progress:Consolidating for submission; open theory: the exact plug-in second-order adaptivity constant
A single-binary Go service that streams host telemetry at 1 Hz over WebSocket and flags anomalies with an online isolation forest and conformal-prediction alerting. It collects CPU/memory/disk/network/process metrics via gopsutil, scores each snapshot with a sliding-window online isolation forest (Liu et al., 2008), and fires alerts at a target false-positive rate using conformal p-values (no per-metric threshold tuning). Each alert ships linear-SHAP feature attributions and a rule-based label across six anomaly types (resource exhaustion, data exfiltration, port scan, process anomaly, ransomware-style disk writes, and C2 beaconing, with network-aware features like send/recv asymmetry and send-periodicity). Persists to embedded BoltDB with switchable live/historical views and a go:embed single-binary build.
●Measured:Conformal p-value alerting at a target false-positive rate, with no per-metric threshold tuning
●Measured:29-feature engineering with linear-SHAP attributions on every alert; 1,905 lines of tests pass
○In progress:Separate Python pipeline (IsolationForest / LSTM-autoencoder / XGBoost → ONNX) exists for offline evaluation but is not yet wired into the live binary
Fig. 04 · Crypto-miner CPU spike flagged critical (score 0.912) with per-feature attributions
A full-stack EdTech platform for a spiritual-education client, live in production at learnwithspirit.com, where learners buy and watch structured courses and instructors run their own teaching workspace. Next.js 15 + TypeScript on Prisma/PostgreSQL: Clerk auth with learner/instructor/admin roles, Stripe Checkout for single courses and discounted bundles, Mux video with signed RS256 playback and self-serve instructor upload, and Resend transactional email. Lessons span video, audio, Markdown articles, and private reflection journals, with resume positions, practice-streak stats, and auto-issued shareable certificates; learners get one-click data export and account deletion, and money and content mutations land in an audit log.
●Measured:Deployed to production on Railway behind Cloudflare at learnwithspirit.com, with 13 Prisma migrations applied on deploy and CI on GitHub Actions
●Measured:70 Vitest tests across 9 files pass, covering the money path end to end: checkout (course and bundle variants), signature-verified webhook fulfillment with idempotent redelivery, refund revocation, entitlements, and the admin authorization matrix
●Measured:Signature-verified Stripe webhook grants entitlements idempotently inside a DB transaction; bundle purchases allocate the discounted total pro-rata across member courses; refunds revoke access and email the buyer
○In progress:Soft launch: the production catalog is still seed content — real course videos, business registration, and the switch to live-mode Stripe sit with the client
An end-to-end forensic image-analysis service that flags splicing, copy-move, AI inpainting, and GAN-generated images and produces court-ready PDF reports with chain-of-custody metadata. I built the full inference pipeline: handcrafted forensic features (ELA, wavelet noise variance, CFA artifact maps, DCT block similarity) computed in parallel, then a pluggable weighted ensemble over five PyTorch detector heads (a 9-layer FCN, fine-tuned MantraNet, a Siamese ResNet-50 with contrastive loss, a CLIP ViT-B/32 inpainting head, and a dual-head CLIP ViT-L/14 GAN head). Ensemble weights are tunable via an L-BFGS-B routine that maximizes pixel-level F1 on a validation set. Wrapped in a FastAPI + Celery + Redis service with RS256 JWT auth, SHA-256 chain-of-custody, a JPEG re-compression resilience check, PDF/JSON reporting, a React canvas-overlay UI, Kubernetes manifests, Prometheus metrics, and CI enforcing 85% line coverage.
A theory-plus-audit research project (speccomp) on what makes a neural network layer compressible, and whether the field's training-free sensitivity heuristics actually measure it. The central audit finding is that popular training-free scores (Hessian trace as in HAWQ, heavy-tailed exponent α) predict weight-space compressibility but not output-space damage; used for mixed-precision bit allocation, they perform worse than random. A cheap one-backward empirical-Fisher gradient predictor does better. It beat HAWQ's double-backward Hessian score on 100% of cells in the multi-architecture RTN sweep, and ties it (WikiText-2 perplexity 60.5 vs 60.1) at a fraction of the cost under GPTQ, a real quantizer implemented from scratch with cached bit-independent inverse-Hessians. A Gauss–Newton analysis explains the gap, and its falsifiable probe-noise-vs-data-alignment prediction held up in testing. The headline claim survived a pre-registered confirmatory test, locked before the data was collected, on 7 held-out models across 5 architectures. All numbers reproduce from the experiments directory; everything runs on a single 12 GB GPU.
Python · PyTorch · Random Matrix Theory · Model Compression · Quantization · GPTQ · Statistics
●Measured:Pre-registered confirmatory test (locked before data) passed on 7 held-out models across 5 architectures
●Measured:One-backward gradient allocator matched HAWQ under GPTQ + WikiText-2 (perplexity 60.5 vs 60.1) and beat it on 100% of multi-arch RTN cells; data-free scores allocate worse than random; 37/37 tests pass
○In progress:Workshop paper drafted ('What Do Training-Free Compressibility Metrics Actually Predict?'); multi-model GPTQ sweep next; targeting NeurIPS 2027
08SketchyLow-Rank Curvature Corrections to Muon, Tested HonestlyML & Applied AI+−
Low-Rank Curvature Corrections to Muon, Tested Honestly
An optimization-theory project asking two questions: is Muon's gradient orthogonalization genuinely optimal, or an artifact of its isotropic-curvature model? And is a randomized Nyström low-rank-plus-scaled-identity preconditioner (SketchySGD-style) the cheapest provable correction, i.e. steepest descent under a data-adaptive norm with O(p·r) memory? I built sketchy, a PyTorch library with stabilized-Nyström sketching, Hessian-vector-product and Gauss–Newton oracles (including multiclass), SketchySGD/SketchySVRG, and Muon, plus six experiment suites with figures (CIFAR-10 on a single RTX 3060) and five theory notes. The empirical answer is a negative with a mechanism: the rank-r curvature correction substantially redirects the Muon step (~0.84 direction change) without improving optimization, and the concentration experiment shows the redundancy is structural rather than a concentration artifact. After a novelty audit found the 2025–26 optimizer/curvature space saturated (five candidate re-pivots each killed by a pre-check), the project is shipping that negative result, with its mechanism, as a 10-page arXiv paper rather than chasing a saturated niche.
●Measured:The rank-r correction redirects the Muon step (~0.84) without helping; the redundancy is structural, refuting the concentration-predicts-the-gap framing
09MacforensicForensic Imaging Tool for macOSSystems & Security+−
Forensic Imaging Tool for macOS
A macOS command-line tool for forensically sound disk acquisition, built for investigators who need a verifiable raw image with a defensible chain of custody. It enumerates and risk-flags source devices via diskutil, streams a block device to a .dd image, and records a JSON case manifest plus an append-only acquisition event log, with a PyInstaller DMG build for field-portable distribution.
Python · Systems · Forensics · Security
●Measured:Verify-after-write: SHA-256 computed during acquisition, then the written image is re-hashed to confirm it matches
●Measured:Three policy modes (forensic-safe / lab / emergency-live) guard live acquisition of the currently booted disk; a map-apfs subtool documents containers, physical stores, and volumes
●Measured:Optional detached Ed25519 signatures and RFC3161 timestamping of the hash sidecar
●Measured:pytest suite covers the imager, verifier, and APFS topology mapping
Fig. 09 · Device survey with per-disk risk flags, then APFS container mapping; read-only, no root
An Autopsy file-ingest module that implements the methods from my ITIS 5250 computer-forensics paper ('Evaluating Entropy-Based Encryption Detection Methods', UNC Charlotte, Dec 2023). Autopsy's built-in detector flags a file as encrypted when its Shannon entropy exceeds 6.0 bits/byte, a rule that produces false positives on structured-but-dense formats like PDFs and archives. This module instead computes four entropy measures per file from a byte histogram (Shannon, collision at Rényi α=2, Rényi α=3, and min-entropy) and raises Autopsy's native TSK_ENCRYPTION_SUSPECTED artifact with all four values recorded in the comment. It defaults to min-entropy, the paper's lowest-false-positive measure: structured files always have a dominant byte, encrypted data has none. Analysts can switch measures, tune the threshold and α, or flag when any measure trips. The code is Jython- and CPython-safe, and ships with unit tests, a standalone CLI scanner, and a regenerable labeled corpus that reproduces the paper's result.
●Measured:Reproduces the paper's headline on the bundled corpus: Shannon (Autopsy's default) wrongly flags a real PDF at 7.90 bits/byte; min-entropy clears it (4.82) while still catching random bytes (7.87)
●Measured:Drop-in python_modules folder with a settings UI (measure, threshold, α); unit tests and the CLI scanner run without Autopsy
Two live e-commerce sites, a mobile plant shop (The New Leaf) and a vintage clothing store (Locket Vintage), each with a self-serve storefront and an owner admin dashboard. Built on a reusable Express + SQLite (node:sqlite) API and React/Vite storefront pattern, with self-serve Stripe Checkout, signature-verified Stripe webhooks driving order and inventory state, and JWT-secured admin portals for inventory, orders, schedule, expenses, bookings, and reporting. Hardened with express-rate-limit, Helmet, a strict CORS allowlist, and request sanitization; Locket onboards real inventory via a CSV import pipeline. Deployed on Vercel (storefronts) + Railway (APIs).
A personal climbing-progress tracker that turns a messy session spreadsheet into an interactive analytics dashboard for spotting training trends. Full-stack TypeScript: an Express + SQLite (node:sqlite) backend seeds from an Excel/CSV log via an ExcelJS pipeline (with Excel date-serial handling), then computes analytics server-side: a cumulative timeline with 7-day rolling average, grade distribution, per-grade flash rate and average attempts, attempt histogram, sends-by-wall, style mix, and weekday training volume. A React + Recharts frontend renders these with date/wall/grade/style filters and token auth. Deployed frontend on Vercel, backend on Railway.
A local-first web app I built to run homemade Taskmaster game nights: one operator drives the show, and a second screen displays it to the room. TypeScript end to end: a Fastify API over Node's built-in SQLite (node:sqlite, WAL mode) with routes for episodes, contestants, tasks, scoring, results, presenter state, and history, where every score change is written to a score_events table (old/new points, actor, timestamp) for a full audit trail with rollback. A React + React Router front end pairs a control surface with a dedicated /presenter window that stays in sync by polling shared state through TanStack Query; Zustand (persisted) handles local UI flow. Includes a media picker (video/image/gallery via multipart) plus JSON export/import of the whole show database.
14MultiModelRTCP2P Video Chat with In-Browser ML DetectionSide Projects+−
P2P Video Chat with In-Browser ML Detection
A peer-to-peer WebRTC video chat where TensorFlow.js models run in the browser to detect faces, hands, and objects, overlaying live annotations on each stream. A Vite client establishes RTCPeerConnection sessions over Google STUN with Firebase Firestore for room signaling (offer/answer + ICE), so media never leaves the peer-to-peer path. Four TensorFlow.js models (coco-ssd, facemesh, handpose, body-pix) run client-side and render predictions as positioned DOM overlays (boxes, face mesh, gesture labels). No video pixels are modified, and there is no server-side CV. Built as a 4-person UNC Charlotte ITCS 6166 course project (2023), where I was the repo integrator and authored the final IEEE report; per-member feature ownership isn't separable from the source.
A desktop GUI for grabbing YouTube videos and playlists without touching the terminal. A C++17 app with a wxWidgets window that takes a pasted URL and an output folder, then shells out to yt-dlp (with ffmpeg for format support) and streams its log output live in-app. Intentionally wraps the yt-dlp CLI rather than re-implementing YouTube extraction, with an optional full-playlist mode for playlist links.
A native macOS app for people who want a fast, clean local preview of Markdown files without opening a browser or editor. A SwiftUI shell renders Markdown to HTML in a WebKit view via the Ink parser, with Cmd+O file-open and drag-and-drop intake, a GitHub-like reading style, and shell scripts that build a .app bundle and package it as DMG/PKG.
Swift · SwiftUI · macOS · WebKit · Desktop
●Measured:Downloadable DMG build, ad-hoc signed for local use and not notarized
Built a content-based course recommender for an EdTech platform serving 10,000+ learners: scraping and cataloging the course library, then ranking related courses with TF-IDF and Word2Vec embeddings over cosine similarity to power learning-pathway suggestions
Jan 2024 – Apr 2024
Remote
Contract Software Engineer · Narrative.ai
Back-end and front-end contract work on a real-time logistics platform: ingesting carrier events, tracking shipment state, and surfacing live status in a production operations dashboard.
Built back-end services for real-time shipment tracking, including status ingestion, state management, and carrier data integration
Maintained production databases, owning schema design and query optimization for high-volume logistics data
Built front-end components for the operations dashboard that surface live shipment status
May 2022 – Aug 2023
Charlotte, NC
Graduate Research Assistant · University of North Carolina at Charlotte
Research on second-order optimization and continual reinforcement learning. I built reproducible experiment frameworks and migrated legacy MATLAB pipelines to Python.
Built a research framework to evaluate second-order optimization algorithms
Implemented and experimentally tested replay buffer designs for continual reinforcement learning
Converted several legacy MATLAB codebases to Python so other researchers could maintain and extend them
ML engineering for cybersecurity products including network log analysis, vulnerability visualization, and feature work on a unified security posture dashboard.
Scripted network log analysis tools to provide feedback for reinforcement learning agents
Performed data analysis and visualization to identify and mitigate security vulnerabilities
Added features to a web application that gives clients a unified view of their security posture
Aug 2021 – May 2022
Saint George, UT
Undergraduate Research Assistant · Utah Tech University
Contributed to university-wide scheduling systems and led security research on ML-assisted side-channel analysis.
Contributed to implementation of university-wide course scheduling and classroom placement system
Led a data-analysis project to find optimal course-enrollment sequences for students
Led security projects applying machine learning to side-channel attacks
Education
9 graduate courses
2022 – 2023
M.S. Computer Science · University of North Carolina at Charlotte
4.0 GPA · Phi Kappa Phi Honor Society
Graduate Certificate in Applied Artificial Intelligence
Graduate coursework in machine learning, digital forensics, databases, and algorithms
Graduate research assistant in optimization and reinforcement learning
