I contributed to a research project using Clang and the LLVM compiler. We altered generated code blocks from the Clang front-end to imprint a unique watermark on compiled software. I wrote the optimization passes that alter the IR code blocks to apply the watermark. Clang and LLVM are both open-source with active communities. After completing this project, I made some modest contributions to Clang's formatter application.
Paper

Simulates a generic blockchain network where each node is its own flask server. The nodes communicate with each other through HTTP to send 'mined' blocks, propagate results, and verify each other. The simulation focuses on how byzantine failures impact network performance. This is when the node starts sending incorrect information (sometimes maliciously) but it is not apparent that the node is acting incorrectly. This is based on the byzantine general problem which is a commonly discussed issue in distributed voting systems.
Paper

We measured how offloading parallelizable tasks to the GPU can improve performance. Using the GPU requires some overhead as there is a cost to sending the data and instructions to the GPU. Additionally, there is a cost to read the results back from the GPU. APIs for running code on the GPU such as OpenCL and Cuda give the developer the freedom to specify how the GPU runs: number of work groups, number of cores in each workgroup, etc. This project looked at what the 'tipping point' is for when the overhead cost outweighs the benefit for offloading computation to the GPU. We also looked at parallelization on the CPU using OpenMP although this is not included in the paper.
Paper

Neural radiance fields, NeRFs, combine the techniques of volumetric rendering with deep learning. These networks are trained on a static set of images of a scene at different angles and then train a convolutional network to generate new novel views of that scene. This allows for interesting applications such as generating 3D assets from a few static images. This paper builds a NeRF from scratch based on the original 2020 paper.
Paper

There are a lot of algorithms for identifying a star based on a limited view of its surrounding stars. These algorithms have a practical application for navigation especially for satellites determining their attitude. I implemented a novel algorithm from a 2017 paper that decomposes the surrounding stars into a hash table of values. The algorithm assigns each star a value based on its distance from the target star and assigns it to a hash table based on its angle relative to the target star. The algorithm then uses Spearman correlation to compare our result against values in a database to determine a match. The project uses python with openCV to generate and parse star images. The sky2000 star catalog was used for the database comparison. Paper

I compared several different neural network architectures and how they perform when classifying human activities (running, sitting, walking, etc). The datasets consist of sensor readouts from accelerometers, gyroscopes, and magnetometers. I looked at convolutional and recurrent networks. Convolutional networks are good at understanding spatial relationships in a single time-step. This is why they are so popular in image classification. Recurrent networks are useful for learning temporal relationships. For example, in a video clip the convolutional layers would learn to identify objects in each frame while the recurrent layers would learn the relationship between consecutive frames.

Several different recurrent network types were tested: RNN, LSTM, GRU, and BiLSTM. I found that using a convolutional network which feeds into a self-regulating recurrent network is the most performant and can achieve over 98 percent accuracy against validation data.
Paper