Lunar Lander is a game in which the player controls a spaceship and attempts to land it safely on the surface of the Moon. The game was developped in Python using Pygame for the Gymnasium API.

As someone who has only studied model based reinforcement learning (RL) in class, I wanted to experiment more with deep reinforcement learning and push my understanding of the field.

The actor-critic method is a popular approach in RL that combines the benefits of both value-based and policy-based methods. It involves two separate neural networks, with one (the actor) responsible for selecting actions, and the other (the critic) estimating the value of those actions.

I encountered a number of challenges along the way, including hyperparameter tuning and debugging issues, but with persistence and perseverance, I was able to successfully train and evaluate the algorithm. Through this project, I gained a deeper understanding of deep reinforcement learning.

The goal of this project was to classify images using a weakly supervised dataset. The dataset consisted of 18 classes, with only 20 images labeled per class, and 2000 labeled images in total (100 images per class for testing).

To tackle this challenge, we experimented with two different approaches: simCLR and SGAN.

The first approach, simCLR, is a semi-supervised method for learning representations from a large number of unlabeled images. The model consists of a series of transformations that convert the inputs into a continuous learning space, followed by a classifier that predicts the labels of the transformed inputs.

The second approach, SGAN, is a semi-supervised GAN network that uses a generator to produce random images and a discriminator to classify them based on known labels. The goal is to produce images that are both realistic and informative for the classification task.

The goal of this project was to reconstruct a 3D model from a set of images. We had to implement a levelset method to reconstruct the 3D model from a set of images.

The levelset is a function that represents the surface of the object. The levelset function is initialized with a sphere and is then evolved to fit the object.

During this project, we only had the time to implement a 2D proof of concept. The results were promising, but the 3D implementation was too slow to be usable.

This project provided a valuable opportunity to explore the field of 3D reconstruction and gain a deeper understanding of these concepts. A strong state of the art analysis was required to understand the levelset method and its implementation in an inverse problem.

The objective of this project was to develop a deep learning-based classification method for recognizing cars in the mobile game Rocket League Sideswipe, regardless of the accessories equipped.

To acquire the approximately 400,000 images in the dataset, a script was written to automate the customization of the car models and take screenshots on an Android phone. It took approximately 18 hours to compile the dataset.

To prevent overfitting, augmentation was performed using the albumentations library (only for the training data).

A simple convolutional neural network (CNN) was created for the project. Due to the network's nature, it did not require a pre-trained model.

This project involved creating a 3D rendering engine using C++ and OpenGL. The engine supports basic shapes, transformations, and lighting.

The renderer is capable of rendering a scene with multiple objects, each with their own transformations and materials. It is redering shapes using the Phong reflection model for each mesh face.

It has been made using z-buffering for hidden surface removal and supports basic lighting. There are a lot of improvements that could be made to the renderer, including adding transparency or implementing a more advanced lighting model.

This project involved creating a camera travelling. The trajectory was computed using b-splines to ensure the trajectory was both smooth and controllable.

To achieve this, we utilized the Spigot API to develop a Minecraft plugin that provided a 3D environment with interactive controls.

This project required a strong understanding of geometric modeling, programming, and software development to successfully create an immersive experience for users. Overall, this project provided a valuable opportunity to explore the intersection of technology, 3D modeling, and game development.

The goal of this project was to segment images using two methods. The first method was k-means, which is an unsupervised clustering algorithm that partitions the data into k clusters. The second method was mean shift, which is a non-parametric clustering algorithm that assigns each data point to the nearest cluster centroid.

Image segmentation is a fundamental problem in computer vision that involves partitioning an image into multiple segments. This project provided a valuable opportunity to explore this field and gain a deeper understanding of image processing.

This project involved implementing a compression algorithm for 3D meshes. The goal was to reduce the size of the mesh data to be sent over the network, while maintaining a reasonable level of quality.

We had to implement a compression algorithm that could be used to compress a 3D mesh before sending it over the network. The algorithm had to be able to decompress the mesh step by step, so that the user could see the mesh being reconstructed in real time.

The algorithm we implemented was based on the paper MAPS. This paper describes a method for compressing 3D meshes using a combination of ordered vertex decimation based on vertex saliency and retriangulation. As we had to deeply understand the paper to implement the algorithm, we learned a lot about 3D mesh compression and metrics.

This project involved implementing a compiler for a simple programming language. The compiler had to be able to translate the source code into an intermediate representation, which could be, at the end, translated into machine code by the assembler.

The compiler was implemented in OcamL, a functional programming language. The compiler translated the source code in RAT (a simple programming language) into an assembler-like language, named TAM. The compiler was able to verify the syntax of the source code and generate an error message if the code was invalid. Then it translated the source code into TAM code.

This project was a great opportunity to learn about compilers and the various techniques used to translate source code into machine code. We learned about the different stages of compilation, such as lexical analysis, syntax analysis, semantic analysis, and code generation. We also learned about the various data structures used to represent the source code, such as abstract syntax trees and symbol tables.

This project involved implementing a system for animating a 3D avatar using a webcam. The goal was to allow the user to control the avatar's movements by moving their head.

We had to implement a system that could track the user's head movements and use them to animate the avatar. The system had to be able to track the user's head movements in real time, and the avatar's movements had to be smooth and natural. To achieve this, we used MediaPipe to obtain the user's head pose.

Then, we used the head pose to animate the avatar. We used homography to map the avatar's head to the user's head each frame. We also used a simple linear interpolation to smooth the avatar's movements.

This project was inspired by the popular The Million Dollar Homepage. Our website allowed users to purchase pixels on a virtual canvas, with each pixel representing a small piece of digital real estate. Users could buy pixels in any color they wanted, and we provided tools for them to create their own custom designs.

The web project we developed was a fun and exciting endeavor that combined various technologies to create a functional and engaging website. We used JBoss as the backend, a powerful and reliable Java library that provided excellent support for our web application. On the frontend, we opted for a more hands-on approach, creating custom HTML, CSS, and JavaScript code from scratch.

To manage our data, we implemented a MariaDB database server, which allowed us to store and retrieve data efficiently. The server was optimized for performance and could handle a high volume of queries without any issues. To handle the connections between the frontend and the backend, we used servlets, which provided an efficient and reliable communication protocol.

This project involved implementing a client-server tuple space in Java, where clients could perform various operations such as `read`, `write`, `take`, as well as `try` variants. It was also possible to use an event register to trigger a callback when a specific tuple was added to the space.

The primary challenge of this project was to handle concurrency to ensure that multiple clients could access and modify the shared space simultaneously without conflicts or errors.

Additionally, we had to provide proof of the package's functionality through the use of unit tests and code coverage analysis tools such as Jacoco. Overall, this project required strong programming skills, an understanding of distributed data systems, and the ability to develop effective testing strategies to ensure the package's reliability and functionality.