Overview

Built a two-node home server cluster from repurposed gaming laptops, running Proxmox VE for bare-metal hypervisor management and hardware resource isolation.

Deployed a Kubernetes cluster across both nodes, orchestrating Dockerised workloads including local LLM inference, media and file serving, and self-hosted productivity services.

Hands-on experience with on-premise LLM inference on constrained hardware — directly relevant to sovereign AI deployment patterns.

Overview

neural_blueprint is an open-source Python framework that enables modular and reproducible deep learning model design. It uses a blueprint-driven approach to assemble architectures from reusable building blocks, simplifying experimentation and reducing low-level implementation overhead.

Core Features

- Modular building blocks (core and composite components) for fast model assembly,

- Tabular-first projection system that integrates tabular data across architectures,

- Config-driven training pipeline with typed dataset outputs,

- Multiple loss functions supported, including VAE, reconstruction, and classification losses,

- Implemented architectures: MLP, AE, VAE, Transformer.

Current Focus

The project is currently optimized for tabular data and representation learning, providing a strong foundation for building and testing diverse neural architectures.

Future Directions

- Expand modality support to text, images, and audio

- Implement custom self-attention and cross-attention mechanisms

- Add data augmentation and balancing utilities

- Grow the architecture library with more advanced model types

Fluence is a full-stack, multi-user language learning platform designed to organize vocabulary, grammar, characters, words, passages, and exercises across structured lessons.

Key features: multi-user system with per-user preferences and AI API configuration; 10+ exercise types including speaking, conversation, and quizz; AI-assisted example sentences, word definitions, and TTS audio via user-configured OpenAI-compatible endpoints; speech evaluation using Whisper STT with embedding-based scoring; LLM-generated tutor feedback with few-shot prompts; global CJK-aware search; study tracking with daily stats, commitment log, and practice heatmap; sources and tags for metadata on any learning element; automatic CJK enrichment (pinyin, romanization, stroke count, gloss translation); action-based backup system; Kubernetes deployment with PVC persistence.

Backend: Flask, SQLAlchemy with Alembic migrations, PostgreSQL/SQLite, APScheduler. Frontend: Next.js 15, React 19, TypeScript, Tailwind CSS 4. Infrastructure: Docker, Kubernetes (k3s). AI/ML: OpenAI-compatible API integration, Whisper, spaCy, Sentence Transformers, language-tool-python.

Text2SpeechMultiLingualApp is a short project exploring multilingual speech synthesis using Coqui's xTTS v2 model. It generates speech in languages like French, Chinese, and Japanese using voice samples from friends and online sources. I learned to install Python with Homebrew, manage PATH variables on macOS, and use tools like ffmpeg and yt-dlp for audio processing.

Overview

This high-stakes 9-day challenge from McGill and Waterloo universities tested my ability to predict how drugs affect cell RNA. We were evaluated on prediction accuracy using Mean Rowwise Root Mean Squared Error (MRRMSE).

Preprocessing

I tackled the challenge of limited data (just 500 samples) by implementing smart dimensionality reduction. After normalizing gene perturbations to a 0-1 scale, I used Truncated SVD to compress 18,211 dimensions down to just 5 key features. To overcome the complete lack of overlap between training and test molecules, I generated molecular isomers using RDkit, forcing the model to understand fundamental chemical structures rather than memorizing specific molecules.

Model Architecture

My winning solution featured a custom transformer architecture with four powerful components: 1. **Smart Molecule Understanding (Embeddings)**: - Used pre-trained ChemBERTa embeddings to grasp complex molecular structures - Combined with cell type information for context-aware predictions 2. **Pattern Recognition Layer (1D CNN)**: - 1D CNN with optimized kernel size captures local molecular patterns - Applied strong regularization (80% dropout) to prevent overfitting 3. **Chemical Relationship Modeling (Encoder)**: - 8-head transformer attention mechanism identifies critical interactions - Robust regularization ensures generalization to unseen molecules 4. **Precision Prediction System (Normalized Regression Head)**: - Carefully designed output layers with normalization for stability - Sigmoid activation captures the non-linear nature of biological responses This balanced architecture combined deep chemical understanding with powerful regularization techniques—essential for excellent performance with limited training data.

Results

My custom transformer achieved remarkable success: - **1st place 🏆** in the competition - **0.5685 validation MRRMSE** (at epoch 13) This achievement is particularly impressive considering: - Nearly zero overlap between training and test molecules - Extremely limited training data (500 samples) The results demonstrate the model's exceptional ability to understand fundamental chemical-biological interactions rather than simply memorizing patterns from training data.

Overview

As digital interactions become more integrated into daily life, there is a growing need for AI assistants that can engage in **meaningful, long-term conversations while managing personal information securely**. Users want a system that not only remembers **key details** about their private lives—such as **people**, **events**, and **preferences**—but also **retrieves related images** to enhance interactions. However, ensuring data persistence, accessibility, and security remains a challenge. A robust memory system **must prevent data loss**, allow seamless external database access, and maintain user trust through reliable and structured information storage.

Problem Statement

*How can a **conversational AI assistant** effectively **store, retrieve, and manage user-specific personal information**, including images, while **ensuring data persistence, security, and seamless accessibility** across external databases?*

Contributions

This project introduces a **full-stack conversational assistant** designed to address these challenges by integrating **Gemini 1.5**, a **Neo4j knowledge graph**, and **LLM Agents** for efficient long-term memory management. The system features a **React frontend and a Flask backend**, enabling smooth and responsive user interactions. To enhance reliability, it includes an **automated Neo4j backup system**, ensuring data persistence and protection against loss. Additionally, the app supports **image retrieval**, allowing users to associate images with their stored knowledge for a richer conversational experience. **Performance is optimized with quick response times (5-8 seconds)** and a **request-locking mechanism** to prevent simultaneous conflicting queries, ensuring a seamless and efficient user experience.

This project leverages Retrieval-Augmented Generation (RAG) and Generative Agents to create a personalized family storybook enriched with both text and visuals. A Neo4j knowledge graph stores family images, memories, and comments, allowing an LLM-powered agent to generate dynamic, context-aware narratives that reflect personal histories and relationships. Additionally, a dedicated image-selection agent explores the graph to retrieve relevant photos for each generated paragraph, ensuring meaningful visual storytelling. The final output is automatically formatted and converted into a Word document, providing a beautifully structured, shareable family album that brings memories to life in a seamless, AI-assisted storytelling experience.

v0.1

Version 0.1 features a clean interface where players can search for summoners across regions, view comprehensive player statistics, analyze detailed match histories, and easily navigate between different player profiles.

Context

Large Language Models (LLMs) are increasingly being integrated into educational environments, raising questions about their effectiveness as teaching tools. While previous research has primarily focused on their ability to teach mathematics to children, less attention has been given to their role in higher education. Understanding how LLM-generated educational content compares to human-authored materials is essential for assessing their potential impact on university-level learning.

Problem

*How do LLM-generated stories compare to human-authored stories in enhancing university students' understanding of advanced mathematical concepts?*

Contribution

This study extends prior research by evaluating the effectiveness of LLM-generated stories versus human-authored stories in teaching university-level mathematics. Through an experiment involving 16 university students, participants were exposed to two different mathematical concepts (Gradient and Bayesian Probability), with story authorship blinded to eliminate bias. Preliminary results indicate a notable improvement in understanding the gradient concept among students who read LLM-generated stories. These findings highlight the potential advantages of LLMs in teaching specific mathematical topics and suggest the need for further research into their role in higher education.

Context

Domain modeling is a crucial step in software and systems design, where an abstract representation of a solution domain is created to address a problem domain. Traditionally, this process requires a domain expert and an experienced modeler, iterating over multiple feedback cycles, making it time-intensive and costly. As Large Language Models (LLMs) advance, there is growing interest in automating domain model generation, reducing reliance on human intervention while maintaining high-quality results.

Problem

*Can Large Language Models generate accurate domain models with minimal human intervention, reducing time and effort while maintaining high precision in class, attribute, and relationship extraction?*

Contribution

This project introduces a Python Automated Model Assistant that leverages OpenAI and Gemini models to generate metamodels using Few-Shot learning, Task Decomposition, and Partial Solution Models. To our knowledge, this is the first implementation incorporating Task Decomposition and the ability to refine outputs using pre-existing partial models. Experimental results demonstrate that incorporating a 40% Partial Solution Model into the prompt significantly improves performance, achieving F1 scores of 0.90 for classes, 0.82 for attributes, and 0.79 for relationships. These findings highlight the potential of LLM-assisted domain modeling to streamline the process while maintaining strong accuracy.

Context

Sign Language recognition is an important area of research aimed at facilitating communication between hearing and non-hearing individuals. With the growing availability of datasets, such as the Sign Language MNIST from Kaggle, there is an opportunity to leverage deep learning techniques for automatic recognition of sign language. While more complex models, such as Convolutional Neural Networks (CNNs), are often used for this task, simpler models can also provide meaningful insights and serve as a foundation for further exploration.

Problem

*How can a simple Neural Network, without CNNs, effectively recognize American Sign Language letters using the Sign Language MNIST dataset?*

Contribution

This project implements a basic Neural Network using TensorFlow (not Keras) to recognize the 24 American Sign Language letters from the Sign Language MNIST dataset. The model employs dense layers and was optimized using a manually decaying learning rate, mini-batch size of 512, and two hidden layers with 85 and 84 nodes. Despite the simplicity of the model, the system achieved 81% training accuracy, 65% testing accuracy, and a 0.67 cost, demonstrating solid performance for a basic architecture. Additionally, two hypertuning pipelines were created with respective graphs to improve model optimization.

Context

Image classification, especially in the fashion industry, has gained significant attention for its potential applications in product recognition and recommendation systems. Leveraging datasets like Fashion MNIST provides an accessible way to explore and implement neural networks for classifying clothing images. While deep learning models such as CNNs are commonly used for such tasks, this project explores simpler, shallow neural networks to assess the performance and potential of basic architectures in achieving competitive accuracy.

Problem

*How effectively can shallow neural networks classify clothing images from the Fashion MNIST dataset, and how do different network architectures impact classification accuracy?*

Contribution

This project implements shallow neural networks in Python using NumPy to classify clothing images from the Fashion MNIST dataset. Three models were created: a single-layer neural network mimicking logistic regression for binary classification (achieving 97% accuracy for t-shirts and trousers after 2000 steps), a three-layer neural network using ReLU and Softmax activation functions (with 85% training accuracy and 83% testing accuracy after 10 epochs), and a three-layer network with the Adam optimizer (reaching 90% training accuracy and 87% testing accuracy after 10 epochs). These results highlight the impact of architecture and optimization techniques on performance.

Context

With the rise of streaming platforms, users often face difficulty in discovering new movies or series that match their interests. A movie search app can help streamline this process by offering recommendations, detailed pages for movies and series, and user reviews. Leveraging public APIs like TMDB makes it easier to provide users with accurate and up-to-date information on their favorite movies, actors, and ratings, all within a customizable interface.

Problem

*How can a movie search application, powered by the TMDB API, provide an intuitive and user-friendly experience for discovering and exploring movies, series, and their associated content?*

Contribution

This project created a local movie search app using React for the frontend and .NET for the backend. The app offers multiple features, including a main page with movie recommendations, a search page, dedicated pages for movies/series, actors, and commentaries, with all data sourced from the TMDB API. Although there are opportunities for further enhancement, such as filtering comments and expanding the movie list on the home page, the project effectively showcases an interactive and engaging movie exploration experience.

Context

Analyzing player performance is crucial for soccer coaches to develop effective training strategies and improve team performance. By leveraging data visualization, coaches can gain valuable insights into player statistics and performance trends, ultimately leading to better decision-making. The 2020 Euro Cup dataset offers rich player data, which can be analyzed to identify key metrics and patterns that influence game outcomes.

Problem

*How can data visualization techniques be applied to the 2020 Euro Cup dataset to help soccer coaches analyze and improve player performance?*

Contribution

This project developed a web application for soccer coaches, leveraging the 2020 Euro Cup dataset to visualize player performance data. The tool enables coaches to analyze key performance metrics, identify trends, and make data-driven decisions to enhance player development and team strategy. The application is designed to provide actionable insights in an interactive and user-friendly interface for SportsAI.

Under the guidance of Prof. Dr. Luis A. Leiva at the University of Luxembourg, I developed a real-time drawing application using Python and OpenCV. The application analyzed finger positions to determine drawing actions, enabling users to interact with the system and create drawings through hand gestures. This project allowed me to explore computer vision techniques and real-time processing in a dynamic application.

Under the guidance of Prof. Dr. Luis A. Leiva at the University of Luxembourg, I implemented a Convolutional Neural Network (CNN) in Python with TensorFlow to recognize diverse handwriting styles. Using a dataset from a separate project, the model was trained to replicate various handwriting styles, showcasing the power of CNNs in pattern recognition for handwritten text. This project provided valuable insights into the application of deep learning for handwriting analysis.

A figma prototype of an IOS privacy app, designed in the context of my HCI bachelor course at the University of Luxembourg.

Under the guidance of Prof. Dr. Christoph Schommer at the University of Luxembourg, I created a transformer architecture in Python using the TensorFlow library for building a chatbot. The project involved data extraction, cleaning, online article research, and defining and training a model before creating the chatbot interface. The model consisted of three parts: an encoding layer, an Attention layer, and a decoding layer. It was trained on Reddit threads containing parent commentaries in both French and English, allowing the chatbot to engage in small talk effectively.

Under the guidance of Dr. Jose Luis Sanchez Lopez at the University of Luxembourg, I trained a drone to navigate and avoid obstacles in a simulated environment (AirSim) using Python. The drone's navigation was powered by Q-learning, where I defined a Q-table and implemented rewards to enable the drone to learn and improve its navigation strategy autonomously.

Under the guidance of Dr. Gregoire Danoy at the University of Luxembourg, I created a simulated environment with quadrotors as agents using Unreal Engine 4 and Python. The project involved controlling drones to avoid obstacles and collisions, applying linear algebra concepts to ensure precise movements and enhance the drones' ability to navigate autonomously in the environment.

Under the guidance of Dr. Gregoire Danoy at the University of Luxembourg, I learned to work with the Sparki robot and programmed it using Sparkiduino. The task was to code Sparki to chase another Sparki while ensuring both robots stayed within an enclosure marked by ground markers. This project involved both robot control and spatial awareness programming.