Detailed demos of my engineering, AI, IoT, robotics, and software projects.
A cutting-edge 3D demonstrator designed to bring reconfigurable manufacturing system concepts to life at the ASSAR Industrial Innovation Arena. Focused on bridging the gap between Plant Simulation models and immersive Virtual Reality environments, allowing stakeholders to virtually walk through a digitally reconfigurable factory. Industry partners: Scania, Volvo, AFRY, AC Floby, LEAX Group.
Developed a surfing simulator that integrates Virtual Reality (VR) with real-time Robotics to replicate the physical sensation of riding ocean waves. By leveraging the Unity 3D engine and Meta Quest headsets, the project creates an immersive visual environment driven by real-world data.
In collaboration with the University of Skövde, I participated in the development and evaluation of X-RAPT, a multi-user XR platform designed to bridge the gap between virtual simulation and industrial robot programming. This project leverages a 5-layer architecture integrating Unity-based Digital Twins of UR3 and ABB IRB120 robots with a Java Spring Boot and AWS backend. My role focused on investigating the technical feasibility of cross-platform VR/PC synchronization and conducting usability testing.
Developed an intelligent, connected lockout-tagout (LOTO) station designed to manage 26 electronic locks for industrial safety. The system ensures that maintenance operations are performed securely by controlling access to equipment through a centralized digital interface. Built on a Raspberry Pi 4/5 architecture and engineered for extreme resilience: in the event of a network failure, the station automatically switches to a Local Mode, utilizing a local CSV-based database and a Tkinter-based HMI to ensure safety protocols are never interrupted.
Developed as part of the Specialized Architectures module at the University of Rouen Normandy, this project focuses on the end-to-end pipeline of creating, training, and optimizing a neural network for embedded deployment. It addresses the challenge of deploying a 1024-feature classification model onto resource-constrained devices. By implementing Post-Training Quantization (PTQ) using TensorFlow Lite, the model weights and activations are compressed from 32-bit floating points to 8-bit integers.
1conv = tf.lite.TFLiteConverter.from_keras_model(model)2conv.optimizations = [tf.lite.Optimize.DEFAULT]3conv.target_spec.supported_types = [tf.int8]4tflite_model = conv.convert() # 32-bit → 8-bit
Diaposi turns any slide deck into a two-way, real-time conversation. Reactions, questions, polls and live drawing let you see exactly what your audience understands, so every presentation is audience-centric, not one-directional.
A native Android application designed to manage and visualize mobile data efficiently. Built with Jetpack Compose, it integrates local storage and remote data fetching to offer a seamless user experience.
1@Composable2fun DataScreen(vm: DataViewModel = hiltViewModel()) {3 val items by vm.items.collectAsState()4 LazyColumn { items(items) { ItemRow(it) } }5}
This project models a stochastic path-planning problem using a finite-horizon Markov Decision Process. An agent must reach a target city within a limited number of days while accounting for uncertain action outcomes. The optimal time-dependent policy is computed using backward dynamic programming.
Computer vision system that detects and tracks billiard balls in real-time match footage using a custom-trained YOLOv8 model. Trained on a hand-labeled dataset of cue, yellow, red and black (8-ball) instances, it produces per-ball trajectories, speed profiles, heatmaps, and a shot timeline, all rendered in an analytics dashboard.
Developed an autonomous AI agent trained to play Yahtzee (YAMS) optimally. The project compares multiple RL strategies, including SARSA, Q-Learning, and Perceptron-based Function Approximation, to navigate a state space of over 1,200 possibilities and maximize long-term scoring across multi-turn episodes.
1def update_q(self, s, a, r, s_next, alpha, gamma):2 best_next = np.argmax(self.q[s_next])3 td_target = r + gamma * self.q[s_next][best_next]4 td_error = td_target - self.q[s][a]5 self.q[s][a] += alpha * td_error
Implemented a diagnostic pipeline to identify Apple Black Rot using VGG-16 deep feature extraction. The project compares Fisher Discriminant Analysis against Difference-of-Means and utilizes Sensitivity Analysis to generate pixel-wise heatmaps, validating the model's focus on pathological regions.
1def sensitivity_analysis(model, image, device):2 image.requires_grad = True3 output = model(image)4 output = torch.flatten(output, 1)5 output.backward()6 gradient = image.grad.data.squeeze().pow(2).sum(0).sqrt()7 return gradient.cpu().numpy()
An in-depth exploration of Decision Tree Classifiers, evaluating their performance against Gaussian Naive Bayes and KNN. The study utilizes the Iris and Make_Moons datasets to visualize complex decision boundaries and conducts a rigorous hyper-parameter sweep to mitigate overfitting through depth and leaf-size constraints.
A comparative study of five fundamental classification algorithms: Minimum Euclidean Distance, Mahalanobis Distance, k-NN (Majority/Unanimity), and Parzen Windows. The project involves mathematical modeling of decision boundaries and performance optimization using 5-Fold Cross-Validation to determine hyper-parameters.
1# Distance relative to class covariance2def mahalanobis_distance(self, x, class_label):3 mu = self.mean_vectors[class_label]4 inv_cov = np.linalg.inv(self.covariance_matrices[class_label])5 delta = x - mu6 return np.sqrt(delta @ inv_cov @ delta.T)
A high-level decision support system developed for ASSAR Industrial Innovation Arena. This project uses Random Forest Regressors and SHAP interpretability to decode the complex relationships between 40+ industrial variables, identifying the primary drivers of Sustainability, Reconfigurability, and Footprint.
1model = RandomForestRegressor(n_estimators=400).fit(X, y)2explainer = shap.TreeExplainer(model)3shap_values = explainer.shap_values(X) # 40+ industrial vars4shap.summary_plot(shap_values, X) # top drivers