Home Projects Academic

Academic Projects
@ Warwick

thesis and coursework projects during my
undergraduate studies at Warwick
[contact me for code or reports where not provided]

Multi-Agent Car Parking Thesis

Multi-Agent Car Parking (Thesis)

Undergraduate thesis applying reinforcement learning to simulate and control groups of autonomous vehicles using PPO and Unity ML-Agents.
  • Implemented variants of Q-Learning and modifications to PPO using Tensorflow/Python.
  • Designed a flexible environment modelled as an MDP with independent agents and dynamic goals. Implemented in Unity using C#.
  • Achieved over 98% parking success with 7 cars using PPO, outperforming single-agent baselines.
  • Explored collaborative and competitive behaviours with variable communication and density.
  • Revealed novel group dynamics such as 'leaky' collaboration and competition-induced cooperation.
  • Scaled training on the university's HPC using Slurm.
  • Awarded 85% for the thesis (top 2% / 250 in cohort).

    • Python   C#   Unity   Slurm
    Compiler Design Project

    MiniC Compiler

    Compiler Design coursework implementing a compiler frontend for a simple C-like language using modern C++17 and LLVM.
  • Developed lexical analysis and parsing with Flex and Bison.
  • Generated LLVM IR through syntax tree traversal.
  • Implemented semantic analysis and robust error reporting.
  • Awarded first-class honours for the project.

    • C++
    Card image cap

    Physics Simulation Optimisation

    Advanced Computer Architecture coursework, involving the optimisation of a two-dimensional computational fluid dynamics simulator.
  • Implemented low-level optimisation techniques on the C code, making it run in 1/10th of the original time (~80s to ~7s).
  • Utilised parallelisation by applying multi-threading using OpenMP, and vectorisation using SSE Intrinsics. Made the code parralilsable by removing inter-loop dependencies.
  • Applied general optimisation techniques such as loop unrolling, loop fusion & fission, precomputing static conditionals, and removing unexecuted code.

    • C
    Machine Learning Project - Iris Clustering

    Gaussian Mixture Model Clustering with EM Algorithm

    Machine Learning coursework on implementing clustering on the Iris dataset using Gaussian Mixture Models and the EM algorithm, improving accuracy over K-Means.
  • Achieved 98% max cluster assignment accuracy after 19 EM iterations.
  • Used PCA for dimensionality reduction and data visualisation.
  • Developed and analysed E-step, M-step, and label assignment for EM clustering.

    • Python

    Packet Sniffer

    Operating Systems coursework, involving the implementation of packet sniffer to detect SYN Flood, ARP Poisoning and URL Blacklist attacks.
  • Low-level C implementation of IP and TCP packet header parsing.
  • Multi-threaded implementation to handle high load of incoming packets.
  • Utilised a work queue and mutex locks for the multi-threading to handle high loads and prevent race conditions.

    • C
    Card image cap

    Timetable Scheduler

    Artificial Intelligence coursework involving the implementation of a class timetable scheduler in Python.
  • Abstracted the problem into a game of "Tetris".
  • Modelled the task of scheduling the timetable around the various time and cost constraints as a Constraint Satisfaction Problem (CSP), and implemented CSP solving algorithms to find the optimal assignment.
  • Found the optimal assignment by implementing Informed Search algorithms.

    • Python
    Mobile Robotics Project

    TurtleBot Planning, Localisation and Control

    Mobile Robotics coursework involving motion planning, control, sensing, and localisation using ROS and Turtlebot3 in the Gazebo simulator.
  • Implemented in Python using ROS.
  • Developed square path navigation using velocity control and PD controllers.
  • Implemented closed and open-loop obstacle avoidance with laser scan data.
  • Applied particle-filter-based localisation with covariance analysis at waypoints.
  • Designed wall-following and dynamic adaptation behaviours.

    • Python   ROS
    Card image cap

    Pong

    C Programming coursework, involving implementing the classic "Pong" game on the screen of an oscilloscope via an ARM controller.
  • Primitive game logic, such as game loops and rendering.
  • Implementation involved creating an API between the oscilloscope screen and the C code, which provided a set of primitive operations such as drawing rectangles and other shapes, which were later combined to form the whole game.

    • C
    Card image cap

    Derivative Trade Manager

    Software Engineering group project sponsored by Deutsche Bank, involving the design and implementation of a full-stack application to manage derivative trades.
  • Went through the full process of Software Engineering in a group of 6 (requirements gathering -> design -> implementation).
  • Backend implemented in Java with an SQL database, frontend built with React (JavaScript), communicating via a REST API.
  • Automatically learns, detects and corrects input errors using AI via a Naive Bayes model.
  • Scalable implementation via pagination and query indexing.

    • Java   JavaScript   SQL
    Card image cap

    Witter

    Java Programming coursework, involving implementing the backend data store for a "Witter" application (akin to Twitter).
  • Raw implementation of hash tables, search trees and other data structures.
  • Complexity optimisation and balancing between time and space complexities, for scalability.

    • Java
    Card image cap

    Scratch Clone

    Haskell Programming coursework, involving implementing an interpreter to compute the resulting memory state, from an input program in Scratch block format and the initial memory state.
  • Implementation utilised a Monad Transformer and other high-level abstractions.
  • Obtained full marks for the implementation, and awarded two Purple λ awards for achieving marks among the year's highest for Functional Programming.

    • Haskell

    PLM Parser and Evaluator

    Formal Languages coursework, involving the implementation of a parser and evaluator for a made-up programming language (Programming Language of the Moment).
  • Translated the rules of the language into a Formal Grammar (including functions, parameters, variables, basic mathematical operators and positive integers).
  • Implemented a parser for input programs in the language using JavaCC.
  • Implemented an evaluator for input programs in the language using Java.
  • Obtained full marks for my implementation.

    • Java

    Propositional Logic Prover

    Logic coursework, involving the implementation of a logical evaluator to determine whether an input logical theorem is a tautology.
  • Implemented the resolution algorithm for propositional logic formulas to determine if a given formula is a tautology in a divide-and-conquer fashion.
  • Used Prolog for the implementation, making it entirely functional.

    • Prolog