Experimentation with different techniques for tracking optical flow in a video sequence. Optical flow is the apparent motion of objects, either due to the motion of the objects themselves or the motion of the camera.
Techiniques implemented include:

• Lucas-Kanade method for estimating optical flow by assuming that the flow is constant in a local neighborhood.
• Lucas-Kanade inverse-compositional method for estimating optical flow by assuming that the flow is constant in a local neighborhood and that the flow is smooth across the image.
• Matthews-Baker inverse-compositional method for estimating optical flow by assuming that the flow is constant in a local neighborhood and that the flow is smooth across the image.

You can view the report here.

Experimentation with different techniques for 3D reconstruction of a scene using multiple images taken at slightly different angles.
Techiniques implemented include:

• Sparse reconstruction to estimate the 3D structure of a scene from a set of 2D images.
• Epipolar geometry to identify corresponding points in different images.
• Triangulation to estimate the 3D position of a point in space given its position in multiple images.
• Bundle adjustment to refine the 3D reconstruction by minimizing the reprojection error.

You can view the report here.

Experimentation with using planar homographies to overlay images on top of other images. The goal is to create an augmented reality effect by transforming the perspective of the overlay image to match the perspective of the background image.
Techiniques implemented include:

• Image feature descriptors, such as BRIEF and ORB, for detecting and describing keypoints in images.
• RANSAC algorithm for estimating the homography between two images.
• Perspective Transform for transforming the perspective of an image to match the perspective of another image.

You can view the report here.

Experimentation with using convolutions and hough transforms to detect lines and corners in images.
Techiniques implemented include:

• Harris Corner Detection, a method for detecting corners in images by identifying regions with high variation in intensity in both the x and y directions.
• Hough Line Transform, a method for detecting lines in images by mapping points in the image space to lines in the hough space. Lines are detected by finding intersections in the hough space.
• Gaussian Smoothing, a method for reducing noise in images by applying a gaussian filter to the image.
• Sobel Operator, a method for calculating the gradient of an image by convolving the image with a pair of 3x3 kernels.

You can view the report here.

Exxperimented with using transformers to classify emotions in audio data, using Wav2Vec2 and MFCC (Mel-Frequency Cepstral Coefficients) features to train a model to classify emotions in audio data.

Collaborative project with Ivy (Aiwei) Zhang and Carlos Guerrero Alvarez.

Implemented neural networks (using PyTorch) to learn multi-class classification. Also experimented with similarities in word embeddings using cosine similarity and t-SNE.

You can view the report here.

Implemented a transformer architecture that uses attention mechanism to translate from English to Pig Latin. Also created visualizations of the attention weights, demonstrating the progress of the attention mechanism over time as it generates a more accurate alignment between the input and the eventual output sequences.

You can view the report here.

Implemented a transformer architecture that uses attention mechanism to translate from English to Pig Latin. Also created visualizations of the attention weights, demonstrating the progress of the attention mechanism over time as it generates a more accurate alignment between the input and the eventual output sequences.

You can view the report here.

Implemented text classifiers using naive bayes and n-grams, both implemented from scratch, to learn word probabilities in a corpus and classify text documents based on those probabilities.

You can view the report here.

Implemented a simple chatbot in Swahili using regular expressions to match patterns in the input text and generate appropriate responses. The chatbot is able to respond to greetings, questions, and farewells, as well as dismissing insults and handling unknown input.

You can view the report here.

Artificial Intelligence (AI) is a hot topic, especially in light of recent improvements in its capabilities. This research project studies the societal attitudes toward AI, both present and how they have evolved over the years, as a way to understand how different events have shaped the public's perception of AI. We use topic modeling, sentiment analysis, and procrustes analysis to analyze relationships across time periods and extract insight into the changing story of artificial intelligence. Here's the studied dataset and the project report.

Collaborative project with Aimen Abdulaziz and Angelic McPherson.

I wrote a high-performant web scraper in Haskell to scrape 17000+ articles from online technology websites such as DeepMind, MIT Tech Review, OpenAI, Singularity Hub, and TechCrunch

The scraper uses Arrows and other functional programming patterns to ensure concurrency and efficiency. The dataset is open-source and available on HuggingFace.

Collaborative project with Aimen Abdulaziz and Angelic McPherson.

Built a landing-page and documentation website for my Computer Science senior design challenge project.

Designed my presentation platform website for my dev work and related stuff. Built with Vue and deployed on Vercel.

It is straightforward to build a REST API in TypeScript using Express. As a proof-of-concept for an upcoming project, I tried out building a REST API in Rust using Rocket. Rust is advantageous since it offers C-like performance without the associated memory safety issues. The API has a database backend using MongoDB.

This project is part of a bigger personal project that's in the works — stay tuned!

New blog website design and, along with it, a new domain! Built with Nuxt/Vue and SCSS. Deployed on Netlify.

Design inspired by the ideals of minimalism.

New website design and, along with it, a new domain! Built with Nuxt/Vue and SCSS. Deployed on Netlify.

Design inspired by the ideals of minimalism.

New website design for the Dartmouth Robotics Club. Built with Next/React and SCSS. Deployed on Vercel.

Networking and job applications management platform for college students.

Built with React, TypeScript, and built with Vite.

Collaborative project with Bansharee Ireen, Yizhen Zhen, Cindy Li Wang, and Johan Cruz Hernandez.

A minimal Youtube player that lets you watch videos without distractions.
Built with React, TypeScript, Sass, and the Youtube Data API.

Post-it-note style platform for organizing your thoughts and ideas.

Built with React, JavaScript, and Sass.

An API endpoint that supports the standard game of Kahoots.

Built with TypeScript, Express and Node Data stored on MongoDB.

Interactive notepad for organizing your thoughts.

Built with React, JavaScript, and Sass.

An API endpoint that supports the standard game of Kahoots.

Built with TypeScript, Express and Node. Data stored on MongoDB.

BuzzFeed-style quiz for movie recs!

Built with vanilla HTML, CSS, and JavaScript, with a lot of jQuery sprinkled in.

Apple-inspired timer that shows quotes from Foundation, my favorite TV show.

Built with vanilla HTML, CSS, and TypeScript.

A minimal blog demo using Jekyll.

Built with Jekyll, Ruby, and Sass.

The first iteration of my personal blog/portfolio. Built with Nuxt/Vue and SCSS. Deployed on Netlify.

For fun, I implemented the Generative Pre-trained Transformer (GPT) architecture in PyTorch. GPT is a language model that uses a transformer architecture to generate text. I trained the model on the tiny Shakespeare dataset and used it to generate text in the style of Shakespeare.

Transformers are a type of neural network architecture that employes techniques such as:

• Self-attention, which allows the model to learn the relationships between different parts of the input data.
• Positional encoding, which allows the model to learn the relative positions of the input data.
• Multi-head attention, which allows the model to learn different relationships between different parts of the input data.
• Residual connections, which allows the model to learn the difference between the input data and the output data.

Experimentation with various adversarial training techniques for neural networks. Adversarial training is useful to improve the robustness of neural networks to adversarial attacks — which often happen as noise in the input data. Techniques explored include:

• Data augmentation, which helps the model have more data to learn from. New samples are generated by randomly cropping and/or flipping some images. We also add pertubations, to a random subset of images, which helps the model learn to be robust to noise.
• Dropout, which entails randomly blocking a subset of the neurons in the network from transmitting information during training. This helps huge models avoid overfitting, thus generalize better.
• Ensemble learning, which entails training multiple models on the same dataset and then averaging their predictions. This helps the model generalize better by mitigating the effects of a single model overfitting.

Experimentation with how variations in specific hyperparameters affect the performance of neural networks. Hyperparameters are parameters that are not learned by the model, but are instead set by the user. Usually, such hyperparameters control the learning process of the model.

As part of a publication exploring the emergence of and the state of the art in machine learning, I implemented neural networks to demonstrate how predictions work in the context of simple classification and regression problems.

To keep my coding skills sharp, I solve a few Leetcode challenges every week. I also make a point to write up the solutions and explanations so a future, forgetful me can review them.

Efficient implementations of various data structures in C.

• A bag stores unique items without duplication.
• A set stores unique key-value pairs without duplication.
• A hashtable mimics the set, but uses hashing with chaining for improved efficiency.

The infamous Kevin Bacon game; given any two actors, find the shortest social connection path between them. We use breadth-first search the strategy to find the shortest path in the graph of connections.

Program to efficiently detect collisions between blobs in 2D space by using quad-trees to partition the space into smaller regions and index which blobs are in which region.

Interactive program that allows the user to draw on a canvas using their webcam. The program detects the color of the paintbrush and draws the path of the brush on the canvas.

An interactive program that renders locations on a campus map and highlights the shortest path between any two points the user clicks on. We use breadth-first search to find the shortest path.

A blog server built with a Python frontend and a MongoDB backend. It supports registered users posting updates and comments, querying for posts and comments, and deleting posts and comments.

Collaborative project with Ke Lou.

A relational database with a Python frontend and a MySQL backend, including various triggers and SQL automations.

Collaborative project with Ke Lou.

A fully functional 16-bit CPU implemented in Logisim. All CPU components including the ALU, registers, control unit, program counter, RAM, micro-sequencer, finite-state machine, and IO are implemented from basic gates.

A multiplayer command-line game of nuggets. Players join over web sockets. The maze is gradually revealed to each player as they view different sectors of it. The game ends when all the nuggets are collected, and the player with the most nuggets wins.

Collaborative project with Alphonso Bradham and Zimehr Abbasi.

A hyper-efficient search engine that crawls webpages (whose domain can be restricted to a given subset) and indexes them, then handles user queries on the contents of the collection of pages, with results ranked by frequency. It also supports query modifiers such as AND, OR, and NOT.

Three different command-line utilities written in C:

• chill calculates the chill factor of a given temperature and wind speed.
• words efficiently prints out the words in a file.
• histo prints a histogram for a stream of numbers.

Hacking our way out of various scenarios with bash scripting.

Includes processing streams of data using sed, matching string patters in files using grep, extracting bits of data from files using head / tail / cut / sort / uniq, and more.

A collaborative editor on shared canvas. Multiple users can connect, and each sees changes in real-time as they are made. We use mutexes and locks to enable concurrent access whilst avoiding data races and deadlock pitfalls such as mutual exclusion, hold-and-wait, circular wait, and no preemption.

Using ridge regression and lasso regression models to find an optimal learning strategy for a given set of data.

Using regression models to classify provided data. The models are not pre-trained, se we use gradient descent to find the optimal parameters for the model.

Using a position-based system with constraints (instead of the more common mass-spring model) to simulate bodies. The method, as described in this paper, offers several advantages over the mass-spring model including being more generalizable to other scenarios and requiring less computation to simulate a body.

We use rotational dynamics to simulate a rigid-body helicopter, using rotor blades to generate lift and thrust. We use the Euler method to numerically integrate the equations of motion.

Using Physics-based simulation to simulate a fluid-flow system. We use the SPH method to simulate the Navier Stokes equations for smoke. We also apply the Vorticity confinement method to simulate the vorticity of the fluid. To reduce the computational space,we use a grid to store the fluid particles.

Using Physics-based simulation to simulate fluid and particle systems.
We use the SPH method to simulate the Navier Stokes equations for fluids.
For particles, we use positional indexing to efficiently detect collisions and propagate forces between particles.

Using Physics-based simulation to animate a hair strand using connection and bending constraints. The simulation is implemented in C++ using the OpenGL framework.

A Physics-accurate simulation of mass bodies (stars, planets, etc.) in a 2D space. The program uses the PyQt5 library to display graphics and allows the user to arbitrarily add more bodies to the simulation by clicking, adding bigger bodies by holding for longer, etc.

An interactive GUI game of pong that uses the PyQt5 library to display graphics and handles user inputs, detects collisions (for the game), and tracks scores as well as the high score in the current streak of games.

Wordle and Grep replicas implemented in Haskell, a pure functional programming language.

Wordle is a program picks a random five-letter word out of a corpus then lets the user guess the word, providing feedback at every iteration. The game is won when the full word is guessed, usually in at most 5 tries although my version allows playing in infinite mode. The original game was created by Josh Wardle.

Grep is a program that matches a string prompt to a text-stream, e.g. from files. Basically, it's Google search for your local file contents.

A common problem in robotics is localizing a robot in a novel environment given sensor readings. This project uses hidden markov models and the forward-backward algorithm and the viterbi algorithm to decipher where a robot's situation probabilities in a maze, given a sequence of sensor readings from the robot. Emissions due to sensor inaccuracies are also factored in.

Boolean satisfiability is NP-complete, meaning any algorithm that solves it takes exponential time — in fact, any polynomial solution would prove P=NP.

Still, there are several algorithms that attempt to cut down the search space in order to find a solution in a reasonable amount of time. In this project, we implement two such algorithms, GSAT and WalkSAT, and use them to solve sudoku puzzles modelled as first-order logic clauses.

Using backtracking and forward-checking to solve constraint satisfaction problems such as map coloring and circuit placement. We use heuristics such as least-constraining value, most-constraining variable and minimum remaining values to intelligently narrow the search space.

Using informed search techniques such as A* search and Greedy search and heuristics such as manhattan distance and euclidean distance to navigate a robot through a maze with obstacles to a goal location.

A chess bot that uses various strategies including minimax, alpha-beta pruning, iterative deepening, transposition tables, move ordering, null-move pruning, aspiration windows, and quiescence search to maximize outcome against an opponent in chess.

Using uninformed search algorithms such as breadth-first search and depth-first search to search the solution space for elementary problems such as the 🐔 and 🐶 problem (we wish to get x chicken and y foxes across a crossway with limited carriage capacity without leaving any chicken unattended with the foxes).

A bot that uses hidden markov models to tag parts of speech in a sentence. We use the viterbi algorithm to generate a sequence of tags for the sentence keeping in mind the tag probabilities for each word and the transition probabilities between tags.

A program that encodes text using a lossless compression algorithm. A frequency tree is built from the text. Thereafter, binary codes are assigned to each character having the most frequent characters get shortest codes.

An interactive program that processes provided raw data about world city populations and other important metrics and renders the cities on a map highlighting standout locations or other interesting data-points.