Information

Introducing iFeed. The fully autonomous pet caretaker that my team and I spent 3 weeks building. This is not just your typical food dispenser, we ensured that it contains all the features needed to monitor, communicate, and feed your pet while you are away from home. These features include:

• Ability to login to your personal profile and create a feeding timetable (amount of food and date/time).
• Send recorded messages to your pet while away from home (built-in speaker).
• Private livestream monitoring of pet's activity, streamed to your private YouTube channel (built-in camera)
• Choice to dispense a chosen amount directly using the built-in keypad.

In addition to this, our vision-based machine learning model can discern between the different types and breeds of pets, then use this to automatically upload snapshots of their activities to their separate profiles.

Our design is unique and was 3D printed. The website was built using VueJS for the frontend and Fast-API for the backend. The computer vision model was built using the PyTorch library and it takes the video data directly from the Youtube livestream. I was in charge of programming the Raspberry Pi, communication between device and website using MQTT, creating and hosting the server on AWS EC2, setting up the livestream from the Pi Cam, testing and programming the sensors, and building the circuitry.

Information

This was a massive project that was completed in a group of 6. We completed the following goals:

• Fully operational Mars Rover with 3-mode functionality (Remote Control, Autopilot and Shortest Path to Coordinate).
• Online Web-App (JavaScript + REACT + MQTT + AWS hosting) that allows full control of rover's operation modes with a virtual map that updates during the rover's missions. Data stored in a MongoDB database.
• Terasic camera module with programmed Computer Vision to detect aliens and buildings on Mars.
• Radar module to detect underground infrastructure. Gyroscope, optic sensor and ultrasonic sensors for positioning and obstacle avoidance.
• Autonomous driving and shortest distance algorithm.
• Solar energy farm to recharge the rover when low on battery.

I developed the self-driving algorithm, built the communication system between the rover and webserver (MQTT), built a back-end for the web app, and managed rover data using MongoDB.

I learned to work in a diverse team where members had different skills, and we incorporated each into the design of our rover. The toughest part was fixing the final self-driving algorithm. This was very difficult to perfect for real-world conditions.

Information

Issie is a digital circuit and CPU simulation software with a large codebase that has been in continuous development, run by Dr Thomas Clarke of Imperial College London's EEE Department. This project involved improving and implementing new features to the current version of Issie. The codebase was mainly built using F#, a functional programming language. This was our first functional programming project, hence my team and I had to learn this new paradigm and code to the high standard required as this is a product that is currently used within our University with multiple collaborators expanding on it all the time.

My first task was building a feature that allowed the option for users to switch between the new IEEE square gates and the old curved logic gates. First I manually created the SVGs for the gates but later built functions that automatically generate SVGs based on parameters. I then proposed unique features that I created such as the ability to scale all logic gates, and automatic rendering of component titles that don't overlap with the components around it.

I added advanced features later on that required extensive knowledge of this large codebase, which I gained from the previous tasks. This included adding n-input gates (not supported beforehand) and rendering them in both old and new IEEE styles. These tasks required me to collaborate directly with my Professor in real-time and it improved my use of git version control.

My rendering work was the best from my cohort according to feedback from Dr Clarke, and it was one of the few to be chosen for integration with the next version of Issie!

Information

My team and I built a Pictionary-inspired motion-controlled multiplayer drawing game, using an Intel DE10-Lite FPGA board. We used the FPGA's accelerometer + mathematical modelling (Euler angles) to map the drawing motion onto a 2D grid. Then I created a GUI for the game using the Pygame library. Finally we created a server that clients connect to using TCP Sockets and hosted it globally on AWS.

I took a lead role in this project and was in charge of building the GUI and managing TCP communication between the server and clients.

Information

Project 1: Discerning Location from Wifi Signal Strength Using Decision Trees

In a group of 4, we built a decision tree model using entropy calculations, on a large dataset of Wi-Fi signal strength values corresponding to specific locations on a map. The objective was to determine the receiver's location based on the Wi-Fi signal strengths surrounding them. We improved the tree using recursive pruning which simplified it significantly and made it less error-prone when dealing with noisy data.

Project 2: Building a Neural Network model to Predict Property Values

In the same groups, we created an artificial neural network using the PyTorch library to model the average house prices in different locations within California. I was in charge of building and training the main pytorch regressor model. We then built an automated hyperparamter tuning algorithm to modify parameters (learning rate, number of neurons, epochs ...) to improve the architecture while through numerous training cycles.

Information

I built a convolutional neural network using the U-NET Architecture and trained a model to segment tumour regions from a database of x-ray images from brain tumour patients. The model was fed with a large set of diverse images, each annotated for the tumor areas, making it capable of accurately distinguishing between normal brain tissue and the regions inflicted with tumour. The training was successful and the my model achieved a final loss of 0.005318, which is very accurate as it was able to discern between images that humans would find difficulty in.

Information

One of the most challenging projects I've been a part of. Working as a pair with my peer, we were able to build a fully functional C compiler that could convert high-level code into MIPS Assembly. For this project we had to learn lexing, parsing, scripting (bash), building abstract syntax trees and combining all of these using high-level C++ OOP and Polymorphism.

Information

I Built a robot that could draw any bitmap image onto a piece paper. I used my own mechanical design (for the pen) and spare computer parts, such as stepper motors from DVD drives for the XY motion, and servo motors for the Z motion of the pen. Using an Arduino micro-controller to control the components via C++ code, I created a robot that could sketch any uploaded image onto a piece of paper.

Information

This was my first programming project. I built an online shooter game using Python's game and network libraries. This was a real-time game and required extensive research and optimisation using TCP sockets on a client-server network. I then hosted my server globally on an AWS EC2 server and built a system where players could broadcast their own local servers or connect to one global server and play against each other.