Arthur Desbiaux

Un Shoot 'em up rétro inspiré de l'univers de Touhou, entièrement développé en Rust avec le moteur de jeu ECS (Entity Component System) Bevy. Un projet passion né de la volonté de maîtriser la gestion de la mémoire, la performance brute et l'architecture de systèmes complexes.

De la première ligne de code au dernier pixel, j'ai conçu l'intégralité du projet seul. Cela inclut le développement technique, mais aussi la création complète des assets visuels (sprites/animations) et de l'univers sonore (musiques).

• • Architecture ECS Pure : Utilisation intensive du paradigme Entity-Component-System de Bevy pour gérer efficacement des centaines d'entités simultanées (projectiles, ennemis, particules) sans baisse de framerate.
• • Gestion des Collisions & Danmaku : Implémentation d'un système de patterns de balles (bullet hell) fluide, nécessitant des calculs de trajectoires géométriques précis et des calculs de collisions optimisés.
• • Pipeline CI/CD automatisé : Mise en place de GitHub Actions pour compiler automatiquement le jeu en mode release (.exe), empaqueter les assets, et générer proprement des versions exécutables zippées sans terminal de debug.

Pour une expérience sans ralentissements, privilégiez la version .exe pour Windows .

fn move_player(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    time: Res<Time>,
    mut query: Query<(&mut Transform, &Player)>,
) {
    if let Ok((mut transform, player)) = query.get_single_mut() {
        let mut direction = Vec3::ZERO;

        if keyboard_input.pressed(KeyCode::ArrowUp)    { direction.y += 1.0; }
        if keyboard_input.pressed(KeyCode::ArrowDown)  { direction.y -= 1.0; }
        if keyboard_input.pressed(KeyCode::ArrowLeft)  { direction.x -= 1.0; }
        if keyboard_input.pressed(KeyCode::ArrowRight) { direction.x += 1.0; }

        if direction != Vec3::ZERO {
            transform.translation += direction.normalize() * player.speed * time.delta_seconds();
        }
    }
}

Un projet de Data Mining exploratoire mené sur les données mondiales d'homicides intentionnels (UNODC, 2000-2021). L'objectif n'était pas une seule analyse mais une comparaison méthodique de plusieurs approches de clustering et de modélisation pour répondre à une question simple : existe-t-il des tendances de criminalité partagées entre pays voisins ou dans le temps ?

Résultat de la régionalisation : un Agglomerative Clustering contraint par la proximité géographique des pays (7 clusters), qui fait ressortir des zones cohérentes comme l'Europe, Moyen-Orient ou les Caraïbes.

Le dataset brut (fichier Excel à en-têtes multi-niveaux) a d'abord été nettoyé et restructuré en Python, avant d'être attaqué sous quatre angles complémentaires : clustering classique, régionalisation géographique contrainte, clustering de séries temporelles, et théorie des graphes.

• •
  Clustering & Régionalisation (Scikit-learn) : Premier passage en K-Means sur l'ensemble des variables encodées, rapidement écarté car trop bruité. Pivot vers une Agglomerative Clustering contrainte par une matrice de connectivité spatiale (k plus proches voisins géographiques), permettant de faire émerger des régions cohérentes (Europe, Moyen-Orient, zone Caraïbes) à partir des seuls taux d'homicides.
• • Clustering de séries temporelles (DTW) : Utilisation de TimeSeriesKMeans avec une distance Dynamic Time Warping pour regrouper les pays selon la forme de l'évolution de leur taux d'homicides plutôt que son niveau absolu, révélant des dynamiques régionales distinctes en Afrique et en Europe.
• • Analyse de périodicité (ACF) : Calcul de l'autocorrélation par pays pour tester l'existence d'un cycle annuel de criminalité, et comparaison par DTW de pays géographiquement proches (Amérique latine, Europe de l'Ouest) pour vérifier la présence de tendances communes.
• •
  Théorie des graphes (NetworkX) : Construction d'un graphe de corrélation (Pearson) entre pays sur leurs taux d'homicides, puis calcul des centralités (closeness, degree, betweenness) pour identifier les pays "représentatifs" ou les ponts structurels entre profils de criminalité.

  

  Chaque nœud est un pays, chaque arête relie deux pays dont les taux d'homicides sont fortement corrélés (Pearson > 0.7) sur 2000-2021. Le cœur du graphe regroupe la majorité des pays sans distinction de continent.

Un projet de Machine Learning orienté production, pensé au-delà du simple notebook : versioning des données, pipeline reproductible, contrôle qualité des métriques et exposition du modèle via une API conteneurisée, à la manière d'un système prêt pour un environnement réel.

Conçu pour démontrer une chaîne MLOps complète, le projet enchaîne prétraitement, entraînement, évaluation et validation automatique des performances avant tout déploiement, avec une intégration continue qui bloque le merge en cas de régression.

• •
  Versioning des données (DVC) : Mise en place de DVC pour tracer les jeux de données bruts et prétraités, et pour définir une pipeline déclarative (dvc.yaml) reliant prétraitement, entraînement et évaluation en étapes reproductibles.

  La pipeline agrège deux sources :

  • — données clients (profil, features numériques)
  • — historique de paiement (retards, soldes, plafonds)
• • Prétraitement & Feature Engineering : Nettoyage des valeurs manquantes, décomposition des dates en variables exploitables, puis agrégation de l'historique de paiement par client (retards maximums, somme des impayés, soldes moyens) avant fusion avec les données clients.
• • Entraînement & Quality Gate : Pipeline scikit-learn (StandardScaler + régression logistique) entraînée avec split stratifié train/test, puis évaluation automatique (accuracy, recall, precision, F1) comparée à la version précédente via dvc metrics diff — le pipeline échoue si les performances régressent.
• • API & Déploiement (FastAPI + Docker) : Modèle exposé via un endpoint POST /predict validé par schéma Pydantic, conteneurisé avec Docker, et intégré à deux workflows GitHub Actions (validation sur Pull Request, tests & lint sur main).

Une application interactive de Computer Vision & Deep Learning capable d'analyser les expressions faciales en temps réel pour y substituer des éléments graphiques dynamiques. Ce projet met en œuvre des techniques avancées de détection, d'alignement de formes géométriques et de classification d'images par réseaux de neurones.

Conçu pour optimiser le compromis entre précision du modèle et latence d'affichage, le projet intègre une pipeline de traitement d'images asynchrone permettant un rendu fluide (30+ FPS) indispensable à une expérience utilisateur de type filtre vidéo ou réalité augmentée.

• •
  Reconnaissance d'Expressions (CNN) : Entraînement d'un réseau de neurones convolutif optimisé pour la reconnaissance d'émotions faciales (FER), capable d'inférer instantanément l'état émotionnel à partir d'une région d'intérêt (ROI) isolée.

  Ce dataset contient :

  • — 35 887 images
  • — réparties en 7 émotions
• • Tracking Géométrique Spatial : Utilisation des repères faciaux (facial landmarks) pour calculer dynamiquement l'orientation, l'échelle et la distorsion de la zone du visage, garantissant un ancrage parfait des assets superposés.
• • Optimisation du Flux Vidéo (OpenCV) : Mise en place d'une gestion efficace des buffers d'images avec OpenCV pour garantir une latence d'inférence minimale et un traitement fluide image par image.

Un système expert d'exploration cinématographique basé sur l'Intelligence Artificielle Générative, exploitant une architecture moderne de type RAG (Retrieval-Augmented Generation) pour offrir une expérience de recherche sémantique fluide et naturelle.

En combinant la puissance de compréhension des grands modèles de langage (LLMs) et la précision mathématique d'une base de données vectorielle, l'application est capable de décoder l'humeur et le contexte d'une requête utilisateur complexe afin de proposer des recommandations ciblées sans aucune hallucination.

• • Recherche Sémantique (Vector DB) : Modélisation d'un dataset de films sous forme de vecteurs d'embeddings denses. Utilisation de calculs de similarité cosinus pour extraire instantanément les films sémantiquement les plus proches de l'intention de l'utilisateur.
• • Architecture RAG & Orchestration : Mise en place d'une pipeline d'orchestration via LangChain permettant de lier la base de données au modèle de langage en injectant dynamiquement le contexte pertinent dans le prompt.
• • Prompt Engineering & Grounding : Conception de fenêtres de contextes et de règles de filtrage strictes pour aligner les réponses du LLM, évitant les dérives comportementales et garantissant une argumentation rigoureuse basée uniquement sur les données réelles.

L'utilisateur peut fournir ses informations letterbox pour avoir de meilleurs recommandation.

Une application de Traitement d'Image mettant en œuvre l'algorithme de region growing pour segmenter une image en zones homogènes en couleur, à partir de graines placées aléatoirement puis étendues itérativement à leurs pixels voisins. Le projet implémente l'ensemble du pipeline en C++ natif au-dessus d'OpenCV, sans dépendance à une bibliothèque de segmentation existante.

Conçu pour traiter aussi bien des images fixes que des flux vidéo complets, le projet repose sur une parallélisation à plusieurs niveaux (croissance simultanée des régions, fusion concurrente des voisinages, pipeline de frames borné) afin de limiter le temps de traitement malgré le coût algorithmique de la segmentation pixel par pixel.

• •
  Génération de Graines (RegionFactory) : Découpage de l'image en une grille de zones candidates et sélection aléatoire d'un sous-ensemble de zones pour y placer les graines initiales, garantissant une répartition spatiale homogène des régions de départ.

  Le pipeline distingue trois phases successives :

  • — Croissance parallèle des régions (GrowthChamber)
  • — Fusion des régions voisines par similarité de couleur (RegionMerger)
• • Croissance Multi-thread (GrowthChamber) : Propagation simultanée de chaque région à ses 8-voisins via des tâches asynchrones, avec validation de couleur par seuil de tolérance et application synchronisée des pixels colorisés à chaque itération.
• • Pipeline Vidéo Asynchrone (VideoRegionGrowing) : Traitement frame par frame d'un flux vidéo complet, avec un pool de tâches borné par condition variable garantissant un nombre maximal de frames en cours de calcul tout en préservant l'ordre d'écriture dans la vidéo de sortie.

Une application web géolocalisée multijoueur où deux camps, les pirates et les villageois, s'affrontent en temps réel autour du campus de l'Université Lyon 1. Le projet met en œuvre une architecture distribuée en microservices, une logique de jeu basée sur la proximité GPS réelle des joueurs, et une expérience type PWA avec notifications natives.

Dans le village de Zeelandia Rainbow Rock, les villageois doivent retrouver des potions magiques avant que les pirates ne s'en emparent. Chaque potion accorde une invulnérabilité temporaire (TTL) permettant d'éliminer un pirate ou de convertir un villageois adverse. Le terrain de jeu est délimité dynamiquement par une zone géographique (ZRR) affichée en surimpression sur une carte satellite Mapbox.

• •
  Géolocalisation & Carte temps réel (Leaflet) : Suivi GPS natif des joueurs avec calcul de cap (relèvement et direction cardinale), affichage de marqueurs dynamiques par rôle et par état (vivant, sous potion, mort), et calcul de distance réelle entre joueurs via la formule de Haversine.

  Mécaniques de capture, déclenchées uniquement à proximité réelle (≤ 500m) :

  • — Un villageois sous potion élimine un pirate
  • — Un pirate sous potion convertit un villageois
• • Authentification & Gestion des rôles (Spring Boot) : Microservice utilisateurs dédié exposant une API REST documentée en OpenAPI, avec authentification par token, CRUD complet et trois rôles : Pirate, Villageois et Administrateur.
• • Expérience PWA immersive : Notifications push natives lors d'un changement de camp ou d'une élimination, retours haptiques (vibration) sur les actions de jeu, et adaptation automatique du thème clair/sombre via le capteur de luminosité ambiante du terminal.
• • Architecture en microservices : Séparation claire entre le client (Vue 3 + Pinia + Vite), l'API de jeu (Node.js / Express), le service utilisateurs (Spring Boot) et l'interface d'administration, déployés via une pipeline CI/CD GitLab.