About the project

A detection service that pulls several RTSP camera feeds at once, runs inference on each stream independently, and overlays the results in the browser.

The problem

Raw detections across a wall of cameras are unreadable. An operator watching seven feeds does not need every frame scored, they need to know the moment something crosses a line that matters to them.

How it works

Each camera is decoded on its own worker so that a slow or stalling feed cannot block the others, and each is given its own region of interest. When a tracked object crosses that region the service emits an event carrying a track id and a confidence score, so the alert panel reads as "truck confirmed, track 10209, conf 0.71" instead of a scrolling wall of frames. The API is FastAPI, the whole thing is containerised, and it is deployed on Azure.

The result

Turned seven simultaneous camera feeds into a single reviewable alert stream, by isolating decode and inference per camera and reducing the operator surface from continuous video to discrete region-crossing events.

About the project

A trading system that forecasts short-horizon price movement and scores market sentiment from news, built as a layered service rather than a notebook.

The problem

A forecast on its own is not a system. Getting a model to be useful meant solving the unglamorous half: pulling live market and news data on a schedule, storing it, keeping several models fed, and surfacing the output somewhere a person can watch.

How it works

The code is layered as apis, adapters, services and engine. Providers for OKX and CoinGecko supply OHLCV candles, and NewsAPI, GNews and Google News supply articles, each behind its own adapter so a provider can be swapped without touching the services. An Engine holds named pipelines and runs them on an APScheduler interval across a thread pool and a process pool, carrying a shared context between stages. Three models sit behind that: a TS-Mixer network over the latest candles for price forecasting, an NLP tokenise/infer/post-process pipeline that writes sentiment records, and a reinforcement learning agent with its own training and prediction entry points. Everything persists to Firestore, and a socket server pushes updates to a live charting front end.

The result

Built a continuously running forecasting service rather than a one-off model, by wiring three separate models, five external data providers and a scheduled multi-process engine behind one persistence and streaming layer.

About the project

An applicant tracking prototype that compares a resume against any job description and reports how well they match.

The problem

Resume parsing normally breaks on layout. Two-column CVs, tables and embedded graphics defeat text extraction, and the structure a recruiter cares about is exactly what gets lost.

How it works

Rather than extracting text, each PDF page is converted to an image through pdf2image and passed to Gemini as vision input, so the model reads the document the way a person looks at it and layout stops being a failure mode. The same interface then returns a percentage match against the pasted job description, lists the keywords the resume is missing, and drafts a three paragraph cover letter. The whole tool is a single Streamlit app.

The result

Removed layout-sensitive text extraction from resume screening entirely, by treating each page as an image for a vision model and returning a match score, a gap list and a cover letter draft from one interface.

About the project

An action classifier that reads sequences of 2D human pose keypoints and predicts what the person is doing, across six classes: jumping, jumping jacks, boxing, waving with two hands, waving with one hand, and clapping.

How it works

Training runs over the RNN-HAR-2D-Pose database, where each sample is a window of body keypoints rather than raw pixels. Working from keypoints instead of images keeps the model small and makes it far less sensitive to lighting, clothing and background than a video classifier would be. An LSTM consumes the sequence so the prediction depends on how the pose changes over time, not on a single frame, which is the part that distinguishes waving from clapping. Inference is exposed as a Flask server that accepts base64-encoded frames, with a matching client, so the model can be called from a separate device.

What I took from it

Choosing the right representation does more than choosing the right architecture. Reducing a frame to keypoints before the model sees it removed most of the nuisance variation for free, and made a small recurrent network enough for the task.

About the project

Production CCTV work built at EKbana Solutions: object tracking together with face recognition, running on a Raspberry Pi with no GPU available.

The problem

Recognition is far slower than detection. Run both in one process and every recognition pass starts dropping detection frames, so the system misses the events it exists to catch. The hardware budget also ruled out a GPU.

How it works

Detection with YOLOv5 and recognition with FaceNet were split into separate Docker services so the two scale independently and detection holds its frame rate regardless of what recognition is doing. Both models had to be sized to fit a Raspberry Pi rather than a workstation.

The result

Kept a real-time detection frame rate on CPU-only edge hardware, by separating detection and recognition into independent services so the slower stage could never stall the faster one.

About the project

A signal processing exercise: implement the Fast Fourier Transform and its inverse from first principles, then prove it by recording real audio, transforming it, and reconstructing it.

How it works

It starts with a naive DFT built as a matrix of complex exponentials applied to the signal, which is correct but quadratic. The FFT then splits the input into even and odd samples, recurses on each half, and recombines them with twiddle factors, falling back to the naive DFT at the base case. That is Cooley-Tukey, written out rather than called from a library. The inverse follows the same recursive shape. The script records five seconds of mono audio at 16 kHz, pads the length up to the next power of two so the radix-2 split stays valid, keeps only the unique bins from DC to Nyquist, then rebuilds the full spectrum by mirroring the positive bins in reverse as complex conjugates, handling even and odd lengths separately, and inverse transforms back to a WAV file.

What I took from it

The Hermitian symmetry of a real signal stops being a formula and becomes something you can hear. Getting the mirroring wrong by a single bin produces audible artefacts in the reconstruction, which makes it a very direct way to check whether you actually understood the maths.

About the project

An implementation of the transformer architecture written from the paper rather than imported, building each component in turn.

How it works

It is composed bottom up: a self-attention module first, then a transformer block wrapping attention with the feed-forward layer, residual connections and normalisation, then an encoder stacking those blocks, then a decoder block adding masked attention over the target sequence and cross-attention over the encoder output, and finally the full encoder-decoder model.

What I took from it

Writing masked attention by hand is what makes the decoder click. Once you have had to build the mask that stops a position attending to its own future, the difference between the encoder and decoder stacks stops being a diagram and becomes an obvious consequence.

About the project

A set of three generative adversarial models, each a step further from the original formulation.

How it works

The base GAN establishes the adversarial loop: a generator producing samples from noise against a discriminator learning to separate real from generated. SRGAN keeps that loop but changes the objective to super-resolution, so the generator upsamples a low-resolution input and the loss combines adversarial and content terms. pix2pix moves to paired image-to-image translation with a conditional generator and a patch-based discriminator that judges local regions rather than the whole image.

What I took from it

The adversarial loop is the easy part to write and the hard part to keep stable. Seeing the same training dynamics under three different objectives made it much clearer which failures come from the architecture and which come from the loss.

About the project

U-Net implemented from the paper for image segmentation, with a trained checkpoint and an evaluation script so results can be reproduced rather than described.

How it works

The contracting path repeatedly convolves and downsamples to build up semantic context while losing spatial precision. The expanding path upsamples back to full resolution, and at each level takes a skip connection from the matching contracting stage, which restores the fine boundary detail the downsampling threw away. The result is a per-pixel mask at the input resolution.

What I took from it

The skip connections are the whole idea, not a detail. Removing them leaves a network that can tell you what is in the image but not where its edges are.

About the project

An object detector written from the original YOLO paper, with training, evaluation and a real-time inference path.

How it works

Detection is framed as a single regression over a grid: the image is divided into cells, and each cell predicts bounding boxes with confidence scores and class probabilities in one forward pass, rather than proposing regions and classifying them separately. The repository carries the model, the loss, the training loop, dataset handling and utilities as separate modules, and inference runs either over a webcam stream or a still image, with normalisation applied automatically and boxes drawn on the output.

What I took from it

The loss function is where YOLO actually lives. Writing it out, with the separate terms for coordinates, object confidence, no-object confidence and class, explains the design choices far better than the architecture diagram does.

About the project

A recurrent neural network implemented in NumPy alone, with no PyTorch or TensorFlow anywhere in the code.

How it works

The recurrent cell carries a hidden state forward across timesteps, and training unrolls the sequence and propagates gradients backwards through every step, accumulating them into the shared weights. With no autograd available, each gradient is derived and written out by hand.

What I took from it

Backpropagation through time is where vanishing gradients stop being a phrase you repeat. Watching the gradient shrink as it travels back through the unrolled steps is the clearest possible argument for why gating was invented.

About the project

A small deep learning framework written in NumPy from the ground up, then used to train a fully connected network on handwritten digits: 60,000 MNIST images for training and 10,000 for testing.

How it works

Everything a framework would normally hand you is written out here. A common layer interface gives every component a forward and a backward method, so the training loop can walk an arbitrary list of layers in either direction. A dense layer folds the bias into the weight matrix, initialises from a scaled normal, and applies its own gradient step. Sigmoid, ReLU, tanh and softmax each carry their own derivative, and mean squared error, binary cross-entropy and categorical cross-entropy are each paired with the gradient the backward pass needs. Training runs in mini-batches over the flattened 784-pixel inputs, and the network is evaluated with a confusion matrix and a per-class report rather than accuracy alone, so it is visible which digits get confused for which.

The result

The network trained for the writeup runs 784 inputs through two hidden layers to ten outputs, on sigmoid activations with mean squared error, and reaches 90.6% on the training set and 85.98% on the held-out test set after 100 epochs.

What I took from it

This was the first network I wrote, and building the pieces separately is what made them stick: once every layer is just a forward and a backward, backpropagation stops being an algorithm you memorise and becomes bookkeeping. The confusion matrix taught me the other half, because the mistakes cluster in ways that point straight at what the model has failed to represent.

About the project

A collection of computer vision and machine learning algorithms implemented from their definitions rather than called from a library, each building and running on its own.

How it works

Each algorithm is a self-contained CMake project with its own sources, headers and sample images. The set covers edge detection and a separate full Canny pipeline, feature detectors and matching, gradient thresholding, line detection, affine transformation, image rotation and flipping, video reading, and QR handling; alongside the machine learning side with principal component analysis, k-means clustering, logistic regression, activation functions and a neural network.

What I took from it

Implementing Canny end to end, rather than calling it, is what made the parameters stop being magic numbers. Once you have written the non-maximum suppression and the hysteresis yourself, you know exactly what the two thresholds are doing and why the result changes the way it does.

About the project

Implementations of VGG16 and ResNet, the two architectures that frame how convolutional depth was approached before and after residual connections.

How it works

VGG16 takes the direct route: a deep uniform stack of small convolutions with pooling between blocks, which is simple to reason about and expensive to train. ResNet adds the identity shortcut so each block learns a residual against its input rather than a full transformation, which is what makes very deep stacks trainable at all. Building both makes the contrast concrete rather than theoretical.

What I took from it

Depth is not free, and the residual connection is the reason it became affordable. Training both makes it obvious that the shortcut is a gradient path first and an architectural idea second.

About the project

Forecasting how chronic disease prevalence moves over time across US states, using CDC chronic disease indicator records.

How it works

Prevalence per state is treated as a time series and an LSTM is trained to project it forward, with the records grouped and cleaned per state and indicator before training so each series is consistent.

What I took from it

Public health data is mostly a data engineering problem before it is a modelling one. Most of the effort went into reconciling how indicators are reported across states and years, not into the network.

About the project

A hardware project, built with friends, that locates an animal by GPS and reports its temperature and heart rate. The first hardware system I worked on.

How it works

The collar is built around an AVR microcontroller programmed in C, reading a GPS module for position alongside temperature and heart-rate sensors, driving a local LCD for on-device readout, and transmitting readings over custom hardware to a receiving device that forwards them to a server for storage and display.

What I took from it

On a microcontroller you feel every byte and every cycle, and there is no library to hide behind. That constraint carried directly into the later edge vision work, where the question was again what fits rather than what is most accurate.