🤖 AI

Navigating Simply, Aligning Deeply: Winning Solutions for Mouse vs. AI 2025

Team HCMUS_TheFangs achieved winning results in both tracks of the NeurIPS 2025 Mouse vs. AI competition by demonstrating that lightweight, simple architectures excel at visual robustness while deeper, high-capacity models are superior for neural alignment, revealing that optimal performance depends on matching architectural complexity to specific task goals rather than maximizing model size.

Original authors: Phu-Hoa Pham, Chi-Nguyen Tran, Dao Sy Duy Minh, Nguyen Lam Phu Quy, Huynh Trung Kiet

Published 2026-02-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Phu-Hoa Pham, Chi-Nguyen Tran, Dao Sy Duy Minh, Nguyen Lam Phu Quy, Huynh Trung Kiet

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a competition where artificial intelligence agents race against real mice to find a hidden ball in a 3D maze. But there's a twist: the competition has two different judges with very different goals.

The Contest: "Mouse vs. AI"
Think of this like a driving test.

Track 1 (The "Tough Weather" Test): The first judge wants to see if the AI can drive the maze even when the weather changes. What if it suddenly gets foggy? What if the lights flicker or the sun sets? The goal here is robustness—can the AI keep working when things get messy?
Track 2 (The "Brain Scan" Test): The second judge doesn't care if the AI wins the race. Instead, they want to know: Does the AI's brain work like a mouse's brain? They have recordings of 19,000 real mouse neurons firing while the mice run the maze. The goal here is alignment—does the AI's internal processing look like biology?

The Big Surprise: Simple vs. Complex
The team from University of Science, VNU-HCM (Team HCMUS_TheFangs) entered the competition with a surprising discovery: One size does not fit all.

1. For the "Tough Weather" Test (Track 1): Keep it Simple

The team tried building a super-complex AI brain with many layers (like a deep neural network). It was like giving the AI a giant, complicated encyclopedia to memorize.

What happened: The complex AI memorized the training maze perfectly but froze when the fog rolled in. It was too specific.
The Winning Solution: They switched to a tiny, two-layer brain (a "SimpleCNN"). Think of this like a street-smart local who knows the general rules of the road but doesn't overthink every detail.
The Secret Sauce: They added two simple tools:
1. Normalization: This is like putting on sunglasses. It helps the AI ignore sudden changes in brightness or color, focusing only on the shape of the path.
2. Gating (GLU): This acts like a bouncer at a club. It lets useful information in but blocks out "noise" or confusing visual static.
The Result: This simple, "street-smart" AI won with a score of 95.4%. It proved that for surviving weird weather, you don't need a supercomputer; you need a simple, adaptable system.

2. For the "Brain Scan" Test (Track 2): Go Deep

When the goal changed to mimicking a mouse's brain, the strategy flipped. The tiny AI wasn't good enough.

The Problem: A mouse's brain is a massive, complex hierarchy. It processes simple edges, then shapes, then objects, all at once. A tiny AI just couldn't capture that depth.
The Winning Solution: They built a deep, 16-layer ResNet. Think of this as a massive library with 17.8 million books (parameters). It has enough "brain power" to understand the complex, layered way a mouse sees the world.
The Result: This deep, complex model won the top spot for neural alignment. It showed that to mimic biology, you actually do need a big, complex brain.

The "Sweet Spot" Discovery

The team also noticed something weird about training time. You might think, "If I train the AI longer, it gets better."

The Reality: It's not a straight line. They tested models trained for different amounts of time (from 60,000 steps to over 1 million).
The Finding: The best models were often found around 200,000 steps. If they trained too long (like 1 million steps), the models actually got worse.
The Analogy: It's like studying for a test. If you study a little, you know nothing. If you study just the right amount, you ace it. But if you study for days straight without stopping, you get burnt out, forget the basics, and start making silly mistakes. The "perfect" model was the one that stopped training right before it started to overthink things.

What Failed?

The team tried many fancy ideas that didn't work:

InceptionNet: A very complex architecture that simply refused to learn anything.
Data Augmentation: They tried artificially making the training images look weird (rain, night, etc.) to teach the AI. Surprisingly, this made the AI worse. It was like trying to teach someone to drive by showing them photos of cars on fire; it confused the AI rather than helping it.
LSTMs (Memory): They tried giving the AI a "memory" to remember past frames. This destroyed the AI's ability to see the 2D picture clearly, making it clumsy.

The Takeaway

The paper concludes with a clear lesson:

If you want an AI that is tough and reliable in changing environments, keep it simple. Don't over-engineer it.
If you want an AI that mimics biology, you need complexity and depth to match the richness of a living brain.

The team didn't just find a winner; they showed that the "best" AI design depends entirely on what you are trying to achieve. Sometimes, less is more; sometimes, you need the whole library.

Technical Summary: Navigating Simply, Aligning Deeply

Problem Statement

The paper addresses the "robustness gap" in artificial agents, where deep reinforcement learning (RL) systems often fail when encountering visual perturbations outside their training distribution, unlike biological systems (specifically mice) which maintain stable navigation under varying conditions. The authors participated in the NeurIPS 2025 Mouse vs. AI: Robust Visual Foraging Competition, which evaluates agents on two distinct, complementary tracks:

Track 1 (Visual Robustness): Measures generalization to held-out visual perturbations (e.g., fog, lighting changes) using a weighted average of the Average Success Rate (ASR) and Modified Success Rate (MSR).
Track 2 (Neural Alignment): Evaluates how well an agent's internal visual representations predict neural activity recorded from over 19,000 neurons in the mouse visual cortex during the same task, using linear readout $R^2$ metrics.

The core challenge lies in the tension between these objectives: behavioral robustness often favors abstraction from low-level statistics, while neural alignment may require preserving detailed stimulus structure.

Methodology

The authors, Team HCMUS_TheFangs, abandoned the conventional wisdom that complex visual tasks require correspondingly complex architectures. Instead, they pursued a dual-strategy approach, developing distinct architectures optimized for each track's specific requirements.

Track 1: Lightweight Architecture for Robustness

For visual robustness, the team developed a SimpleCNN architecture prioritizing simplicity to prevent overfitting.

Architecture: A two-layer convolutional backbone with aggressive spatial downsampling (8×8 kernel, stride 4; followed by 4×4 kernel, stride 2).
Enhancements:
- Gated Linear Units (GLU): A module using Swish activation for feature transformation and sigmoid for gating, enabling selective information flow to suppress noise-sensitive components.
- Observation Normalization: Running statistics (exponential moving average) applied to inputs to ensure invariance to global illumination changes.
Training: A two-phase strategy where the backbone is trained first, followed by the addition of the GLU module.

Track 2: Deep Architecture for Neural Alignment

For neural alignment, the team employed a Deep ResNet-like architecture designed to capture hierarchical representations mirroring biological visual cortex.

Architecture: 16 convolutional layers organized into residual blocks with progressive channel expansion (64 → 128 → 256 → 512).
Mechanism: Incorporates GLU-based gating for adaptive feature routing. The model contains 17.8 million parameters, significantly larger than the Track 1 model (1.4M).
Training: Extensive experimentation with training durations ranging from 60K to 1.14M steps, saving checkpoints every 20K steps to analyze the relationship between training time and performance.

Failed Approaches

The paper systematically documents several approaches that underperformed:

InceptionNet: Failed to converge entirely.
Deep ResNet (24 layers): Achieved high training performance but suffered a 35% drop in performance under perturbations due to severe overfitting.
LSTM Integration: Caused training instability and performance collapse, likely due to the destruction of 2D spatial structure.
Naive Data Augmentation: Surprisingly decreased performance (from 87.7% to 59.8%) by introducing distribution mismatches.

Key Results

Track 1: Visual Robustness

The lightweight SimpleCNN with GLU and normalization achieved a 95.4% final score, securing the top position.

Ablation: Observation normalization provided the largest gain (+3.8%), followed by GLU (+0.2%).
Comparison: The 24-layer ResNet baseline scored only 65.98%, highlighting that increased depth harms generalization in this context. The SimpleCNN maintained a minimal gap between ASR (96.80%) and MSR (94.00%), whereas the deep ResNet had a 30-point gap.

Track 2: Neural Alignment

The deep ResNet architecture achieved top-1 performance (Score: 0.1517) on neural alignment metrics.

Capacity: The 17.8M parameter model significantly outperformed the lightweight SimpleCNN (Rank 13, Score 0.1451), demonstrating that capturing biological representations requires substantial model capacity.
Non-Monotonic Training: A critical finding was the non-monotonic relationship between training duration and performance. The optimal checkpoint emerged around 200K steps (Rank 2), performing nearly as well as the model trained for 1.14M steps (Rank 1). Models trained for intermediate durations (e.g., 520K steps) performed worse than those trained for very short durations (80K steps), suggesting that extended training can lead to overfitting or catastrophic forgetting even in neural alignment tasks.

Key Contributions

Architectural Simplicity for Robustness: Demonstrated that a lightweight two-layer CNN with targeted enhancements (GLU, normalization) significantly outperforms complex deep networks for visual robustness, challenging assumptions about model requirements for visuomotor tasks.
Capacity for Neural Alignment: Showed that while simpler models excel at behavioral robustness, deeper architectures with increased capacity are necessary to achieve superior neural alignment, reflecting the hierarchical complexity of biological visual processing.
Documentation of Failure: Provided a comprehensive analysis of failed approaches (InceptionNet, deep ResNet, LSTM, naive augmentation), offering practical guidance on avoiding common pitfalls in robust visual RL.
Training Dynamics Analysis: Revealed a non-monotonic relationship between training duration and performance, identifying that optimal checkpoints often emerge well before convergence (around 200K steps).

Significance and Claims

The paper claims to offer practical guidance for developing robust, biologically-inspired visual agents by challenging conventional assumptions about model complexity. The authors argue that behavioral competence does not necessarily imply biological plausibility; the architectures optimal for surviving visual perturbations differ fundamentally from those required to mimic neural activity.

By demonstrating that "simpler is better" for robustness while "deeper is better" for alignment, the work suggests that the objectives of robustness and biological plausibility may be in tension, requiring distinct architectural choices. The findings emphasize the importance of task-appropriate inductive biases and the value of systematic checkpoint analysis over training to convergence.