Engineering Internship in QA team, Merck Healthcare, 6 months (ongoing)

Keywords: LLM/VLM, AI Architecture, Document Understanding, Quality Assurance, Task Assistance, Data Pipeline

Architecting AI for QA: Task Assistance Pipelines and Digital Upskilling at Merck

During my final-year engineering internship at Merck Biotech Development Center, I am spearheading the design and implementation of AI-driven task assistance tools for Quality Assurance. The core mission is to architect systems that significantly accelerates processes for the team.

Contributions:

• System Architecture: Designing end-to-end data pipelines for secure ingestion, processing, and storage of highly unstructured QA documentation.
• Document Understanding Pipeline: Architecting parsing and extraction pipelines to process complex regulatory documents and surface critical data.
• Workflow Optimization (Task Assistance): Developed intelligent discrepancy detection systems designed to guide human attention and assist operators.
• Digital Transformation & Training: Will give training programs to upskill teams on emerging digital tools to improve their daily operational workflows.

Results:

• (To be updated upon completion of the internship)

Engineering Assistant Internship, CEA-List, 6 months

Keywords: CNN, GAN, U-Net, MLFlow, AI Training, ASAM standards

Developing AI-Driven Scenario Generation for Autonomous Vehicles

In this internship at CEA-List, I developed and validated systems for autonomous vehicles by creating an automated scenario generation pipeline. My work focused on addressing the limitations of traditional, manual methods by leveraging advanced AI techniques to create a wide range of realistic and complex driving scenarios.

Contributions:

• Massive Dataset Analysis: I processed and analyzed massive real-world driving datasets to inform the development of robust scenario generation models.
• AI-Based Scenario Generation: I designed and implemented innovative algorithms using PyTorch to generate diverse and realistic driving scenarios. This included leveraging Generative Adversarial Networks (GANs) and U-Net architectures to capture complex real-world variability. This involved using high-performance compute platforms for training models.
• Simulation Integration & Validation: I integrated the developed methods into simulation environments (CARLA), enabling the testing of autonomous vehicle systems under virtual conditions.
• Collaborative Development: I collaborated with a team to evaluate the results and refine the scenario generation methods.

Results:

• An end-to-end pipeline, from road layout input (OpenDRIVE) to scenarios (OpenSCENARIO).
• Compatibility with ASAM standards

[PrePrint, WIP] Detection and Classification of Red Blood Cells under flow

Keywords: CNN, YOLO, ResNet, Data augmentation, normalization, high performance computing, dataset, domain gap, biology.

Active project. Manuscript available in preprint. Currently reformatting for journal submission.

Source code and further details available on GitHub.

Detection and Classification of Red Blood Cells under flow

This semester project aimed to solve the domain gap problems in AI applied to biology for red blood cells detection and classification. The specificity is the target domain: red blood cells under flow, an under-studied field, lacking data and AI models. Yet, analyzing the shapes of RBC under flow helps understand and detect diseases. Project conducted at Biomechanics and Bioengineering Laboratory (UMR 7338).

Introduction

This study conducted a comprehensive investigation into the detection and classification of red blood cell morphologies, in particular of “slipper” and “parachute” shapes under flow conditions, exploiting the YOLOv11 framework. A significant part of this work focused on addressing the challenge of data sparsity and bias between datasets through the strategic construction of different datasets.

To counter the prevailing problem of data sparsity and improve the generalisation of the model, the study ventures into the generation of multiple-cell datasets through a cut-and-paste augmentation technique.

Contributions

• Construction of a general data set to extend training domain. This involved working with other univerisities, studying data augmentation and normalization techniques, and developping labelling algorithms.
• Training a YOLO model on this new data set using a superchip.
• Analysis: in depth analysis of the model's behaviors on different data. How does it react to data out of training domain, to new backgrounds, to different color ranges?

Results

• A new data set has emerged of this work, gathering data from multiple sources and acquisition techniques.
• YOLOv11 has been evaluated and interesting behaviors emerges from this architecture.

The performance of YOLOv11 is evaluated both on the Saarland University dataset, where the focus is on accurate cell type classification, and on the Naples University dataset, which is primarily aimed at differentiation between cells and background. On the Saarland University dataset, the model shows excellent performance for the distinct class “parachute”, consistently achieving high recall. When compared to the Naples dataset, characterised by significant colour shifts in the image, the YOLO model shows significant difficulties. It consistently produces high false negative rates, failing to detect a large percentage of real cells and showing high false-positive rates due to misinterpretation of the background.

Overall, these results demonstrate that YOLOv11, despite its strong performance within training-data-like environments, exhibits significant limitations in its generalization capabilities when confronted with substantial discrepancies in visual characteristics. This underscores the inherent challenge in constructing a single, comprehensive data set capable of encompassing the vast array of diverse scenarios encountered in the microscopy domain.

Acknowledgement

The authors would like to thank Prof. Giovanna Tomaiuolo and Prof. Stefano Guido of the Università degli Studi di Napoli Federico II; Prof. Christian Wagner, Prof. Lars Kästner, and Dr. Mohammed Nouaman of the Universität des Saarlandes; and Prof. Ye Ai of the Singapore University of Technology and Design for kindly sharing their datasets and granting permission for their use.

Professors C. Wagner and Y. Ai notably granted us access to the data of the following publications:

• A. Kihm, L. Kaestner, C. Wagner, and S. Quint, Classification of red blood cell shapes in flow using outlier tolerant machine learning, PLoS Computational Biology, vol. 14, no. 6, p. e1006278, 2018. doi:10.1371/journal.pcbi.1006278.

• M. Liang, J. Zhong, C. S. Shannon, R. Agrawal, and Y. Ai, Intelligent image-based deformability assessment of red blood cells via dynamic shape classification, Sensors and Actuators B: Chemical, vol. 401, p. 135056, 2024. doi:10.1016/j.snb.2023.135056

The authors also wish to thank Dr. Imad Rida, Ms. Alaa Bou Orm, and Prof. Amine Nait-Ali for their valuable support and for providing the opportunity to present this work at BioSMART—the 6th International Conference on Bioengineering for Smart Technologies.

Citation

@article {Amrani2025.09.18.677048,
    author = {Amrani, A. and Caridi, I. and Kaoui, B.},
    title = {Deep Learning Detection and Classification of Red Blood Cells: Towards a Universal Dataset},
    elocation-id = {2025.09.18.677048},
    year = {2025},
    doi = {10.1101/2025.09.18.677048},
    publisher = {Cold Spring Harbor Laboratory},
    URL = {https://www.biorxiv.org/content/early/2025/09/20/2025.09.18.677048},
    eprint = {https://www.biorxiv.org/content/early/2025/09/20/2025.09.18.677048.full.pdf},
    journal = {bioRxiv}
}

[Project, WIP] AI Grand Challenge 2026 — The Thinking Layer

Keywords: FastAPI, Multi-Agent, RAG, Supabase, Qdrant, Arq, Redis, System Resilience, Sovereign AI

Overview

Developed for the AI Grand Challenge 2026 by the UTC EduTech team, this project introduces The Thinking Layer — a fundamentally different approach to educational AI. Instead of acting as a frictionless answer-engine, the system serves as a "Cognitive Mirror" that treats the student as a thinker to be provoked, rather than a vessel to be filled. Demo application here.

Scientific Foundations

The system is built on established pedagogical frameworks:

• Desirable Difficulties (Bjork & Bjork): Recognizing that learning is most effective when it requires cognitive effort.

• Productive Failure (Kapur): Encouraging students to struggle with problems before receiving direct instruction to deepen structural understanding.

• Socratic Tutoring: Using fine-tuned smaller models to guide students through reasoning rather than delivering facts.

The Core Idea: The Thinking Layer

Most students use AI as a shortcut. Our system acts as a processing stage between the student and the LLM, calibrating the AI's posture based on the student's actual learning state.

1. The Dynamic State Classifier: Detects engagement levels in real-time (EXPLORING, SHORTCUTTING, STUCK, or BREAKTHROUGH).
2. Pedagogical Steering: If a student tries to "shortcut" the thinking process, the system redirects them; if they are genuinely stuck, it provides scaffolding.
3. Cognitive Mirroring: Maintains a structured, legible, and editable Metacognitive Profile for each student to target their Zone of Proximal Development.

Technical Architecture & Engineering

The backend is designed for pedagogical precision with multi-agent orchestration.

Engineering for Resilience

• Multi-Provider Fallback: We implemented a custom FallbackOpenAIClient that manages a priority-based chain of LLM providers. It handles automatic retries and transparent mid-stream fallback for failed function calls, ensuring availability. Sovereignty will later require national-scaled infrastructure as ILaaS.
• Asynchronous Processing Pipeline: To maintain API responsiveness, expensive operations like document summarization, memory compression, and learner profile updates are offloaded to a task queue (Arq + Redis).
• Agentic RAG Strategy: Retrieval is not limited to a single course context. The system performs multi-course searches across both institutional materials and personal student libraries using MatchAny filtering, providing a unified knowledge base for the agent.
• Tools: Both supervisor agent and subagents have tool calling to generate learning plan, access user profile and access PDF content.

Misc.: we first used openai-agents SDK (and wrapped it in a FallbackOpenAIClient), but we are now moving to pydantic-ai SDK.

Multi-Agent Orchestration

The system employs a modular agent framework:

• Supervisor Agent: Orchestrates the dialogue, dynamically composing system prompts from five distinct layers (Context, Document Summaries, Base Socratic Instructions, Pedagogical State, and Verbosity Style).
• Specialized Sub-Agents: Dedicated agents handle RAG retrieval, profile editing, exercise generation, and per-step pedagogical feedback, allowing for independent testing and prompt optimization of each component.

The Stack

Metacognitive Student Profiles

The system maintains a profile_json that adapts the AI's behavior to each student's reasoning style and progress:

{
"reasoning_style": "unknown",       // inductive/deductive/mixed/unknown
"preferred_format": "step_by_step", // mcq/step_by_step/open_ended/examples_first
"bloom_level": 2,                   // Bloom's taxonomy (1-6), used if unknown topic
"topic_levels": [                   // Per-topic granularity
    { "topic": "string", "bloom_level": 1 }
],
"recent_wins": [],                  // Specific successful reasoning traces
"recurring_misconceptions": [],     // Identified misconceptions
"stuck_topics": [],                 // Currently struggling topics
"mastered_topics": [],              // Progressed topics
"last_session_note": ""             // AI-generated session summary
}

Status

• [x] Initial Submission & Concept (March 2026)
• [x] Core Backend Implementation (FastAPI, Arq Workers)
• [x] Multi-Agent Layering & Supervisor System
• [x] Multi-Course RAG & Personal Libraries
• [x] Fallback Resilience & Sovereign Deployment
• [X] Frontend Implementation (React + Shadcn/UI)
• [X] Final POC Integration & Institutional Testing
• [X] Submission of Final Proposal (11 May 2026)

Team

• Alexandre AMRANI
• Emma CHOUKROUN
• Gautier MIRALLES

[Project] Explainable Drug-Target Affinity Prediction

Keywords: Graph Neural Networks, Explainable AI, Drug Discovery, Protein-Drug Interaction, Grad-AAM, UMAP, t-SNE, Captum, Bioinformatics.

Problem Statement

Deep learning models excel at predicting drug-target affinity but operate as "black boxes," creating a serious obstacle when computational predictions need to guide real experimental work. Without understanding why a model predicts high affinity, computational chemists and biologists cannot trust or validate its recommendations.

Semester project extending MGraphDTA model (Yang et al., 2021) capabilities with enhanced explainability and latent space analysis.

Availability

• GitHub: 4l3x4ndre/Drug-Target-Affinity-XAI
• Demo: Hugging Face Spaces
• Full manuscript and implementation details available in repository

Approach

Applied a multi-modal Explainable AI framework to the MGraphDTA model on the KIBA benchmark dataset, combining:

• Graph Neural Networks (GNN) for molecular structure representation with DenseNet-inspired architecture (27 layers)
• Multi-scale CNNs for protein sequence analysis
• GNNExplainer to identify critical molecular substructures through mutual information maximization: $$\max_{M,F} \text{MI}(Y, G_S) = H(Y) - H(Y|G_S)$$
• Integrated Gradients for atom-residue interaction matrices: $$\text{IG}_i(x) = (x_i - x'_i) \times \int_0^1 \frac{\partial F(x' + \alpha(x - x'))}{\partial x_i} d\alpha$$
• SHAP & LIME for feature importance attribution at atomic and residue levels
• Latent space perturbation analysis to uncover context-dependent prediction strategies

Findings

• Model learns chemically relevant pharmacophores rather than superficial patterns
• Applies context-dependent reasoning through distinct "rule families" for different protein clusters
• Successfully generates testable hypotheses about specific atom-residue binding mechanisms
• Reveals model bias towards ligand features (expected given dataset composition)

Technologies

• PyTorch for deep learning
• PyTorch Geometric for graph neural networks
• SHAP, LIME for model-agnostic explanations
• GNNExplainer for graph-native interpretability
• Streamlit for interactive web dashboard
• RDKit for molecular structure processing

Results

• MSE: 0.1265 | CI: 0.9032 | R²: 0.8098 on KIBA dataset
• High-fidelity reproduction of state-of-the-art MGraphDTA architecture
• Interactive tool for real-time exploration of model predictions and explanations

Based on MGraphDTA: deep multiscale graph neural network for explainable drug–target binding affinity prediction (Yang et al., 2021)

[Project] Disentangling Visual, Semantic, and Factual Deception: A Multi-Branch Approach to Misinformation Detection

Keywords: Misinformation Detection, Multi-Modal Deep Learning, Graph Neural Networks, Knowledge Graphs, Deepfake Detection, CLIP, Vision Transformers, DBpedia.

Technologies: PyTorch, PyTorch Geometric, CLIP, spaCy, Transformers, DBpedia, Graph Neural Networks

Overview

A deep learning framework for detecting misinformation in social media posts by analyzing visual authenticity, semantic consistency, and factual veracity simultaneously. This system addresses the growing challenge of "out-of-context" misinformation where authentic images are paired with false or misleading textual narratives.

Problem Statement

Traditional misinformation detection systems focus on single-modality violations (either fake images OR false text), failing to address real-world scenarios where:

• Authentic images are paired with fabricated claims (cross-modal mismatch)
• Deepfake images support true statements (visual manipulation)
• True images accompany factually incorrect context (textual falsity)

The system must disentangle these three distinct types of deception while avoiding "search pollution" where web-based verification retrieves the very misinformation being investigated.

Repository

GitHub: multi-branch-approach-to-misinformation-detection, manuscript

Includes:

• Complete source code and training scripts
• Interactive Streamlit demo application
• Pre-trained model checkpoint (HuggingFace)
• Processed knowledge graphs for MMFakeBench-Val dataset

Technical Approach

Architecture

The model employs a three-branch neural network with specialized modules:

1. Deepfake Detection Branch: Vision Transformer (ViT) fine-tuned for visual manipulation detection (92.9M parameters)
2. Text-Image Consistency Branch: CLIP ViT-L/14 for semantic alignment (428M parameters)
3. Encyclopedic Knowledge Branch: Graph Neural Network reasoning over DBpedia-derived Knowledge Graphs

Technologies

• Graph Neural Networks (GNN): Graph Attention Networks (GAT) with 2-layer encoding for knowledge graph reasoning
• Knowledge Graphs: DBpedia SPARQL endpoint with semantic expansion and filtering (top-25 neighbors by cosine similarity)
• Transformers: CLIP (Contrastive Language-Image Pre-training), SigLIP vision encoders
• NLP: spaCy dependency parsing, Sentence Transformers (all-MiniLM-L6-v2) for node embeddings
• Graph Metrics: PageRank, Edge Betweenness Centrality, Jaccard similarity for structural features

Results

Evaluated on MMFakeBench and COSMOS datasets:

Innovations

• DBpedia-based Evidence Graphs: Avoids web search pollution by constructing knowledge graphs from curated encyclopedic sources
• Multi-Task Decomposition: Provides explainable outputs for each deception type (visual, semantic, factual)
• Enhanced Graph Construction: Improved predicate filtering and semantic expansion over baseline EGMMG architecture

Claim verification branch based on EGMMG pipeline: Duwal, S., Shopnil, M. N. S., Tyagi, A., & Proma, A. M. (2025). Evidence-Grounded Multimodal Misinformation Detection with Attention-Based GNNs. arXiv. https://doi.org/10.48550/arXiv.2505.18221

[Project] High-Resolution Urban Climate Forecasting with Metadata-Augmented U-Net

Keywords: Multi-modal Deep Learning CNN, RNN/LSTM, Sentinel-2, Google Earth Engine, Urban Planning, Satellite Imagery.

Technologies: PyTorch • Google Earth Engine • Streamlit • LSTM • U-Net • Remote Sensing

Project Overview

A data-driven deep learning framework for predicting the microclimatic impact of urban land-use changes. The system forecasts high-resolution Land Surface Temperature (LST, 30m) and Normalized Difference Vegetation Index (NDVI, 10m) maps based on proposed urban modifications, enabling city planners to quantitatively assess green infrastructure interventions before implementation.

Problem Statement

Urban Heat Island (UHI) effects pose significant environmental challenges as cities expand. Traditional physics-based simulations (CFD, WRF, ENVI-met) are computationally prohibitive for rapid scenario testing. This project addresses the need for fast, scalable tools that can answer "what-if" questions: How will surface temperature change if we convert this parking lot into a park?

Availability

• Code: GitHub Repository
• Interactive Demo: Hugging Face Space
• License: MIT (code), CC BY 4.0 (CRU climate data)
• Full manuscript and implementation details available in repository

Technical Approach

Architecture

Multi-Modal U-Net with contextual embeddings:

Technologies

• Satellite Data Fusion: Sentinel-2 (10m RGB/NDVI), Landsat 8 (30m LST), Dynamic World (10m LULC)
• Google Earth Engine
• PyTorch: Custom U-Net variants (standard, U-Net++)
• Temporal Modeling: LSTM for 69-year climate anomaly series (CRU TS dataset)

Findings

Contrary to expectations, static metadata outperformed historical time-series:

Geographic coordinates serve as effective proxies for climatic zoning, enabling generalization to unseen cities (MAE 4.024°C on unknown locations with long time gaps).

Dataset

• 137,147 samples across 211 global cities (pop. ≥50k)
• Temporal range: 2017–2025
• Filtering criteria: NDVI Δ≥0.1, LST Δ≥0.1°C, or LULC change ≥10%
• Geographical + temporal train/val/test splits

Demo

Utilizing Google Earth Engine API and Copernicus Climate Data Store for comprehensive environmental modeling. City metadata data set is the World Cities Database from simplemaps.

[Project] Distributed Data Sharing System (applied to Temperature)

Keywords: Go, distributed system, frontend.

This project implements a fully decentralized distributed system where multiple types of nodes collaborate to collect, verify, and use data across different sites. Written in Go for the group project of the course Distributed systems at UTC.

Project available on GitHub.

Presentation

The system models a real-world scenario where devices collect sensor data, verify its accuracy, and produce predictions, while ensuring correct coordination and consistency across geographically separate nodes.

For educational purpose, it is applied to temperature data: sensors get temperature, and users predict the next day weather based on the 15 days past data. All system's nodes will work on their own copy of this dataset (the 15 past data, 15 past days as working with temperature).

The core idea is that sensors might give erroneous data, perturbating the users. Thus, verifier systems are integrated to update, slowly, each data point one after the other. The goal is to observe the impact of verifier parameters on user behaviors.

Each node maintains a local replica of the shared dataset (past 15 days of temperature readings) and participates in maintaining consistency between replicas using locks and logical clocks.

Key Features 💡

• Decentralized Architecture:
  No centralized database. All nodes maintain and update their own local replica.

• Replica Consistency:
  Nodes coordinate using a distributed queue with logical clocks to serialize all updates.

• Shared Data Management:
  Nodes work on a sliding window of the latest 15 days of temperature readings.

• P2P Communication:
  Direct messaging between nodes for update propagation and coordination.

• Flexible Role Execution:
  A single program can run in different node modes (sensor, verifier, or user) based on configuration at launch.

Scenario Example 🎉

1. Sensor generates a new reading (e.g., 25°C).
2. It broadcasts the reading to all nodes, including verifiers and users, which will store it in their local data stores.
3. Verifiers receive the reading and ask for a lock to verify the data. They send a request to all other verifiers.
4. Once all verifiers grant access, the requesting verifier processes the data (e.g., checks for anomalies) and updates the local data store.
5. It then releases the lock and sends the verified data to all nodes, including users.
6. Users receive the verified data and update their local data stores.
7. Users read all local data to predict the temperature, without needing to lock.

Each user has a web view:

• Buttons (1) and (2) are used to refresh the data displayed (which is otherwise done every five seconds) and to take a snapshot, respectively.
• The main view (3) shows the last fifteen predictions made by the user for each sensor, differentiated by color.
• Below, the view (4) allows to quickly obtain the number of verified values out of the total number of values in the database.
• Then, the view (5) lists, for each sensor, the temperatures in the database with the data identifier, the temperature value, and the name of the verifying node that verified it. Verified data is highlighted in green. There are a maximum of 15 values for each sensor (the 15 days of the use case).
• Finally, the button (6) allows you to disconnect the user node.

System topology

Bidirectionnal links between network layers. Each of which communicates with the control layer, which in turns communicates with the application layer.

[Project] LLM Knowledge Graph Converter

Keywords: Python, Streamlit, Ollama, LLMs, NetworkX, Plotly, Natural Language Processing, Graph Theory

Presentation

I developed an simple document processing tool that transforms unstructured text into interactive knowledge graphs using Large Language Models. This project combines natural language processing with graph theory to extract meaningful relationships from documents, making complex information more accessible and visually comprehensible. The application features a user-friendly Streamlit interface and supports both English and French document processing.

💭 This project is an exploration of LLM technology, focused on a discovery and learning process rather than production readiness. More advanced pipelines, pretrained models, and dedicated NER libraries like spaCy should be used in a production environment. The current code is a demonstration of my discovery of this technology.

Key Features

Pipeline:

• Custom LLM model creation using Ollama with specialized relation extraction prompts
• Document fragmentation based on markdown structure for improved precision
• Automated entity and relationship extraction from unstructured text

Interactive Visualization System: - Dynamic knowledge graphs rendered with Plotly and NetworkX - Smart node positioning using planar or Kamada-Kawai layouts - Interactive features: zoom, pan, save as PNG, and real-time exploration - Source/destination labeling system for relationship clarity

Intelligent Processing Optimization: - Document chunking strategy to maintain model precision on large texts - Caching system to avoid reprocessing previously analyzed files - Adaptive processing that creates separate graphs for document sections - Integrated chat interface for direct LLM interaction

Production-Ready Architecture:

• Streamlit web interface for seamless user experience
• Local LLM deployment ensuring data privacy
• Modular design with custom Ollama model files
• Robust file handling for text and markdown formats

Results & Impact

Technical Achievements:

• Successfully engineered a text-to-visualization pipeline that converts raw text into structured knowledge representations
• Custom model fine-tuning and strategic document segmentation
• Intuitive interface

Performance Optimization:

• Document fragmentation
• Caching mechanism

User Experience Innovation:

• Interactive graph visualization enables intuitive knowledge exploration beyond traditional text analysis
• Flexible input formats (text/markdown) accommodate diverse document types

Practical Applications:

• Research document analysis and literature review acceleration
• Legal document relationship mapping
• Educational content structuring and comprehension aid
• Business process documentation and knowledge management

[Project] TikTok Trends Analysis Project

Keywords: R, RSelenium, Docker, Web Scraping, Statistical Analysis, Data Visualization

Presentation

This project explores the viral mechanics behind TikTok's trending content system. Initially focused on audio trends, I pivoted to investigate what drives the algorithm's selection of trending videos versus regular "For You" page content. Working with a team of three, I developed a comprehensive data scraping and analysis pipeline to decode TikTok's virality patterns.

The code and report are available on GitHub (french).

My contributions: web crawler and data visualization.

Key Features

Web Scraping Infrastructure:

• Built automated data collection using R, RSelenium, and Docker
• Implemented error handling for TikTok's dynamic web structure
• Collected engagement metrics, hashtags, user profiles, and dated comment data

Multi-dimensional Analysis Framework:

• Analyzed 14 trending topics with 6 videos each
• Tracked engagement evolution over time through comment timestamps
• Built user interest profiling by analyzing public "liked videos"
• Created comparative analysis between trending and For You page content

Data Visualization & Insights:

• Generated word clouds for hashtag analysis
• Developed temporal engagement charts showing video lifecycle patterns
• Created correlation plots revealing virality indicators

Results & Key Findings

Virality Drivers Identified:

• Share rate emerges as the primary trending factor - videos with higher share-to-like ratios are more likely to trend
• Trending content shows linear correlation across all engagement metrics, unlike chaotic For You page patterns
• Temporal intensity matters more than total volume - sudden engagement spikes drive algorithmic promotion

Audience Dynamics Revealed:

• Trending videos reach diverse audiences beyond their natural communities
• News/event-based trends show sharp engagement drops after initial spike
• Community-driven trends (like sports personalities) maintain sustained engagement through dedicated fanbase

Algorithm Behavior Patterns:

• TikTok pushes trending content to users regardless of their typical interests
• Bookmark rates are actually lower for trending content (users save personalized For You content more)
• The platform prioritizes rapid diffusion over long-term engagement for trend selection

Example plot: number of comments over time on a video showing pandas 🐼

Technical Impact

This project is the first step to reverse-engineer TikTok's recommendation algorithm through empirical analysis, providing data-driven insights into social media virality mechanisms. The methodology could be adapted for analyzing other platforms' trending systems.

[Study] Information visualization in Virtual Reality

Keywords: Python, Numpy, data interpretation, data processing.

As part of an experimental study for the University of Technology of Compiègne with the Costech laboratory and ENSADLab, we conducted a virtual reality experiment with a dozen participants.

The results are analyzed in the report on GitHub (french).

Study conducted in connection with TamedCloud project (descriptive pdf).

Objectives and Experiment

To date, most data has been presented to users in a two-dimensional space: smartphones, computers, and tablets are simply planes on which images are displayed. However, more and more solutions are making the three-dimensional world transposable to the digital realm, thanks in particular to virtual reality headsets. It is therefore interesting to observe how users evolve within these immersive environments: while they are used to evolving digitally on a flat plane, how do they react to digital three-dimensionality ? Do they revert to their real-world reflexes? This study will examine data visualization through the following question: how does three-dimensional space affect users' perception of image visualization through image search tasks?

To test these hypotheses, software was developed. Participants were tested on this software and answered a subjective questionnaire. The goal is to use virtual reality to perform visual image searches. To do this, the virtual reality condition (three dimensions) will be compared to the two-dimensional condition, known as “classic” because it corresponds to classic image search on a computer. The objective for participants is to validate (by clicking on a button) as many images as possible corresponding to the target category (such as ‘motorcycles’ or “ducklings”).

Participants were able to move around, zoom in on images, and validate them (2D and 3D conditions). They had five minutes to complete the task. Each participant went through three configurations:

• 3D with cylindrical display
• 3D with spherical display (image cloud)
• 2D with page display

image from EnsadLab

Data analysis

All available data (position, rotation, acceleration, validated images, action, etc.) were recorded every 10 milliseconds.

The purpose of the data analysis is to determine which configuration performs best for image search. The graphs were created using matplotlib.

Firstly, the number of validated images is one of the most relevant indicators.

When comparing other factors, it is clear that searching for 2D images is the most effective in the short term: boredom and lack of action will reduce the effectiveness of the search over a longer period of time.

Other data were analyzed, such as

• position (3D then 2D): 3D position 2D position:

• rotations and their frequencies, the number of images in the field of view:

See report on GitHub for results.

Archive: Gallery of computer projects in school years (Raspberry, Arduino, Games)

Link to my old website