Projects

Neural Networks from Scratch – MLP, K-Means & Model Selection

CS-233 · EPFL · Semester 4 · 2026

Built with Python · NumPy · Matplotlib

This project focuses on implementing and evaluating neural-network and clustering methods from scratch for both classification and regression tasks. Using the Gaming and Mental Health dataset, the goal was to predict addiction level and addiction score from behavioral and mental-health related features.

We worked within a provided machine learning framework and implemented a complete Multi-Layer Perceptron (MLP) with manual forward propagation, backpropagation, mini-batch gradient descent, regularization, and early stopping. We also implemented K-Means clustering and adapted it for classification by assigning labels to clusters through majority voting.

My contributions

• MLP from scratch: implemented fully connected layers, forward pass, backpropagation, and weight/bias updates using NumPy.
• Classification loss: implemented Softmax output with Cross-Entropy loss for multi-class classification.
• Regression model: used an Identity output activation with MSE loss to predict continuous addiction scores.
• Regularization & early stopping: added L2 regularization, validation-loss monitoring, and restoration of the best model weights.
• K-Means: implemented vectorized distance computation, cluster updates, empty-cluster handling, and label assignment by majority vote.
• Model selection: designed validation-based grid search over architecture, learning rate, batch size, regularization, and number of clusters.
• Evaluation pipeline: compared models using accuracy, macro F1-score, MSE, confusion matrices, loss curves, and runtime measurements.

Key results (on provided dataset)

• The best MLP classifier achieved about 87.0% test accuracy and 0.811 macro F1-score.
• The MLP regression model achieved a test MSE of about 0.999.
• K-Means provided a useful unsupervised baseline but performed worse for classification, especially on minority classes.

The results showed that the MLP significantly outperformed K-Means on classification, mainly because it directly used labels during training. The use of Cross-Entropy improved macro F1-score by helping the model handle the rare High addiction class more effectively. For regression, the MLP generalized well and achieved performance close to simpler linear models, suggesting that the target score is largely explained by structured relationships in the features.

This project strengthened my understanding of how neural networks work internally, especially how activation functions, losses, gradients, regularization, and early stopping interact during training. It also gave me practical experience building a rigorous model-selection pipeline and interpreting results beyond accuracy alone.

Machine Learning Pipeline – Classification, Regression & Performance Analysis

CS-233 · EPFL · Semester 4 · 2026

Built with Python · NumPy · Matplotlib

This project focuses on implementing and comparing several classical machine learning methods for both classification and regression tasks, using a dataset provided as part of an EPFL coursework project. The goal was to understand the full machine learning workflow, including preprocessing, validation strategies, hyperparameter tuning, and model evaluation.

We worked within a provided framework and implemented key components of Logistic Regression, Linear Regression, and K-Nearest Neighbors (KNN), extending the base structure with additional features such as validation pipelines, regularization, and performance analysis.

My contributions

• Logistic Regression: implemented multi-class softmax classifier trained with gradient descent.
• Linear Regression: implemented closed-form solution with L2 regularization
• KNN: implemented classification and regression using Euclidean distance
• Model selection: designed validation-based grid search for hyperparameters (learning rate, iterations, regularization, K).
• Evaluation pipeline: used accuracy, macro F1-score, and MSE to compare models.
• Analysis tools: added confusion matrix, runtime measurements, and a --plot option for visualization.

Key results (on provided dataset)

• Logistic Regression achieved about 88.5% test accuracy on the classification task.
• Linear Regression achieved the best regression performance with a test MSE of about 0.994.
• KNN provided a useful baseline but showed slower prediction and weaker generalization.

These results are specific to the dataset provided for the project and illustrate how different models behave in practice. Logistic Regression performed best for classification, suggesting that linear decision boundaries capture a substantial part of the structure of the data, while Linear Regression was most effective for regression.

This project strengthened my understanding of how to implement, tune, and evaluate machine learning models in a rigorous way, and how to compare different approaches in terms of both predictive performance and computational efficiency.

EPFL Events – Real-Time Event Web App

CS-214 · EPFL · Semester 3 · 2025

Built with Scala 3 · CS-214 WebApp framework · Scala.js UI · JSON wire protocol

EPFL Events is a multi-user web application that lets authenticated users create, browse and manage events in real time. Users can open event pages, reserve seats (with capacity enforcement), cancel participation, and organizers can edit or delete their events while tracking the participant list.

The project was developed as a team of three for the CS-214 Software Construction unguided lab. My main role focused on the application logic and state machine design, ensuring that navigation, validation rules and concurrency-safe updates behave correctly for multiple users.

My role (Application Logic)

• State machine backend: implemented transitions for navigation (Home, Create, Manage, Detail, Edit) and per-user page state.
• Validation & invariants: enforced non-empty fields, numeric constraints, and a strict date format (DD.MM.YYYY HHhMM) with future-only dates.
• Booking rules: prevented overbooking, handled seat reservation and cancellation, and kept views consistent after actions.
• Event lifecycle: enabled organizers to edit/delete events safely (creator-only access) and view participant lists.
• Cleanup: added automatic pruning of past events based on stored event dates.

Key features

• Home page showing events created by all users, updated live.
• Event detail page with description, images, location (physical/virtual), price and remaining seats.
• Organizer tools: edit, delete, and see who registered.
• Participant actions: reserve a seat, cancel participation.
• Robust JSON wiring between frontend and backend to avoid “unknown error” states.

Image

Multicycle RISC-V CPU – Computer Architecture

CS-200 · EPFL · Semester 3 · 2025

Built with Verilog

Designed and implemented a complete 32-bit multicycle RISC-V CPU in Verilog (RTL), including the datapath, control unit, and a working memory/peripheral interface. The final system runs real RISC-V assembly programs end-to-end and supports realistic interactions through memory-mapped I/O.

As a demonstration of correctness and integration, the CPU is able to run a full Conway’s Game of Life program (presented as a separate project on this website), where the simulation logic executes on the CPU and the state is displayed through the board’s I/O.

What the CPU supports

• Core execution: instruction fetch/decode/execute with a multicycle controller (FSM).
• 32-bit ALU: arithmetic, logic, comparisons, and shifts following RISC-V semantics.
• Datapath integration: PC, register file, immediates, control signals, and write-back.
• External memory + memory-mapped peripherals: buttons/LEDs/displays accessed via addresses.
• Interrupt handling: CSR-based interrupt flow with proper return (mret) and context restore.
• Verification: simulation with Verilator, waveform debugging with GTKWave, and targeted test programs.

Game of Life – RISC-V Assembly Implementation

CS-200 · EPFL · Semester 3 · 2025

Built with RISC-V Assembly

This project implements a complete version of Conway’s Game of Life entirely in RISC-V assembly, running on the Gecko5 simulator board. The game evolves cell states on a 10×12 LED grid according to the classic rules (underpopulation, overpopulation, reproduction, stasis).

The implementation handles LED rendering, random seed generation, masks (walls), user inputs through hardware buttons, speed control, step counting on a 7-segment display, and a full state machine (INIT → RAND → RUN).

• Full LED drawing pipeline (clear, pixel-set, draw GSA).
• Two-buffer GSA system with automatic swapping.
• Random and predefined seeds with wall masks.
• Hardware button controls: pause, speed, randomize, reset, next seed.
• 7-segment step counter and adjustable run length.

Images

ReCHor – Swiss Public Transport Route Planner

CS-108 · EPFL · Semester 2 · 2025

Built with Java

ReCHor is an offline public transport timetable search engine for Switzerland, similar in spirit to cff.ch or search.ch. Given a departure stop, destination, date and time, it computes Pareto-optimal journeys that balance departure time, arrival time and number of transfers.

The project is structured in weekly milestones and focuses on algorithmic design, data structures and code quality. It loads the official Swiss public transport schedule locally, computes optimal routes, and can export trips to iCalendar or visualize them on a map.

• Implements multi-criteria route search (Pareto-optimal journeys).
• Offline timetable data; no internet connection required at query time.
• Exports results to iCalendar and supports map visualization (via uMap / OpenStreetMap).

Images

Online BlackJack – Full-Stack Web App

CS50x Final Project · Harvard · 2025

Built with Python · Flask · JavaScript · HTML/CSS

Online BlackJack is a full-stack web application that lets a single player practice Blackjack against a dealer with a clean, modern UI and persistent statistics. It is built with Flask (Python), SQLite via SQLAlchemy and a front-end in HTML/CSS/JavaScript, using Chart.js to visualize net wins over time.

The app implements realistic Blackjack rules (dealer stands on 17, 3:2 blackjack payout, double after split, single split max) and separates concerns between server, client and database. A basic-strategy Bot Advice helper suggests optimal actions, and a simple leaderboard tracks performance.

• Flask back-end with JSON APIs for game actions and statistics.
• Persistent user accounts and round history using SQLite/SQLAlchemy.
• Interactive UI with animations and a running P/L chart via Chart.js.

ICoop – Cooperative 2D Puzzle-Adventure Game

CS-107 · EPFL · Semester 1 · 2024

Built with Java

ICoop is a cooperative 2D grid-based game built on top of a custom Java game engine. Two elemental characters must collaborate to traverse areas, activate doors, trigger explosives, solve puzzles, and defeat enemies. The project focuses on object-oriented design, interactions between actors, signals (logic), and extensible gameplay mechanics across multiple stages.

Over the different steps, we implemented doors, explosives, pressure plates, elemental walls (fire/water), health bars, dialogues, collectables (orbs, hearts), enemies, and final arena challenges, all driven by clean abstractions and interaction handlers.

Images

BlackJack – Terminal Game with ASCII Graphics

CS50’s Introduction to Programming with Python Final Project · Harvard · 2025

Built with Python (ANSI/terminal rendering)

This project is a terminal-based implementation of the classic card game Blackjack, with stylized ASCII graphics and a casino-style feel. It runs entirely in the terminal, using ANSI escape codes to clear the screen, control the cursor and add colored output.

The game manages a bankroll, betting, dealer logic and hand evaluation with support for Aces counting as 1 or 11, Blackjack detection and clear separation between player and dealer phases. A dedicated test_project.py suite built with pytest ensures correctness of the core logic (deck handling, hand values, Blackjack detection).

• Multi-deck shoe, realistic dealer behavior and bankroll management.
• ASCII card rendering with colored suits and a hidden dealer card.
• Unit tests for core mechanics using pytest.