Robust-R1: Degradation-Aware Reasoning for Robust Visual Understanding – A Deep Dive into the AAAI 2026 Oral Presentation

In the field of computer vision, robustness has long been a core concern for researchers and developers alike. In real-world applications, images and videos are frequently affected by various degradation factors—such as blur, noise, lighting variations, and compression artifacts—all of which can significantly impair a model’s ability to understand visual content. Today, we’re exploring Robust-R1, a groundbreaking solution designed to address this critical challenge. As an oral presentation highlight at AAAI 2026, Robust-R1 centers on “degradation-aware reasoning,” offering a fresh perspective on achieving robust visual understanding.

For many professionals working in computer vision, understanding a model’s theory is just the starting point. Being able to hands-on operate and intuitively experience its performance is far more valuable. In this article, we’ll focus on Robust-R1’s GUI Demo—covering how to run it locally, how to access it via the online platform, and answering common questions you might encounter along the way. Whether you’re a developer, researcher, student, or tech enthusiast, this guide will help you unlock the full potential of Robust-R1’s interactive demo.

What Is Robust-R1’s GUI Demo?

At its core, the GUI Demo (Graphical User Interface Demo) is an interactive visual tool that allows you to experience Robust-R1’s robust visual understanding capabilities without needing to dive into complex underlying code or algorithms. It’s designed to be intuitive: you can upload degraded images, observe the model’s reasoning process, and compare outputs across different inputs—all through a user-friendly interface.

Who is this demo for? Let’s break it down:

• Developers: Use the demo as a debugging and validation tool to test how Robust-R1 performs on real-world images before integrating it into larger projects.
• Researchers: Visualize the model’s core strengths and weaknesses, helping to identify areas for further optimization or experimentation.
• Students & Enthusiasts: A low-barrier entry point to explore cutting-edge computer vision technology, without the need for advanced technical expertise.
• Practitioners: Evaluate whether Robust-R1 aligns with specific use cases—such as surveillance, autonomous driving, or medical imaging—where image degradation is a common challenge.

The demo’s strength lies in its accessibility: it bridges the gap between theoretical research and practical application, making state-of-the-art robust visual understanding accessible to a broader audience.

How to Run Robust-R1’s GUI Demo Locally?

Running the GUI Demo on your local machine is straightforward—you only need two key steps: set an environment variable for the model path, and execute the corresponding Python script. Below, we’ll walk through each step in detail, with clear instructions for different operating systems (Windows, macOS, and Linux).

Prerequisites Before You Start

Before diving into the setup, ensure your system meets these basic requirements:

• Python Environment: Robust-R1’s demo is built with Python, so you’ll need Python 3.7 or higher installed. You can download the latest version from the official Python website.
• Model Files: You’ll need access to Robust-R1’s pre-trained model weights. These can be downloaded from the project’s Hugging Face repository: Robust-R1 Models. Choose either the SFT (Supervised Fine-Tuned) or RL (Reinforcement Learning) version based on your needs.
• Dependencies: The demo relies on specific Python libraries (e.g., PyTorch, Gradio, Transformers). We’ll cover how to install these later in the process.

Step 1: Set the Environment Variable for the Model Path

An environment variable is a system-level parameter that tells programs where to find critical files—in this case, Robust-R1’s model weights. Here’s how to set it up on different operating systems:

For macOS or Linux Users:

1. Locate Your Model Path: First, determine where you’ve saved the Robust-R1 model files. For example, if you downloaded the model to your Documents folder, the path might look like: /Users/YourUsername/Documents/Robust-R1-Models/Robust-R1-SFT.
2. Open Terminal: Launch the Terminal app (you can find it via Spotlight search or in the Applications > Utilities folder).
3. Set the Environment Variable: Type the following command, replacing your_model_name_or_path with your actual model path or model name:

   export MODEL_PATH="your_model_name_or_path"
   

   Example:

   export MODEL_PATH="/Users/YourUsername/Documents/Robust-R1-Models/Robust-R1-SFT"
   

   Press Enter to execute the command. The environment variable is now set (note: this setting is temporary—if you close the Terminal, you’ll need to re-run the command).

For Windows Users:

1. Locate Your Model Path: Find the folder where you saved the Robust-R1 model. For example: C:\Users\YourUsername\Documents\Robust-R1-Models\Robust-R1-RL.
2. Open Command Prompt: Press Win + R, type cmd, and press Enter to open the Command Prompt.
3. Set the Environment Variable: Use the set command (instead of export, which is for Unix-based systems) to define the model path:

   set MODEL_PATH="your_model_name_or_path"
   

   Example:

   set MODEL_PATH="C:\Users\YourUsername\Documents\Robust-R1-Models\Robust-R1-RL"
   

   Press Enter. The environment variable is now active for this Command Prompt session.

Step 2: Install Required Dependencies

Before running the demo, you need to install the Python libraries that power it. The Robust-R1 project typically includes a requirements.txt file (a common way to list dependencies in Python projects) in the demo folder. Here’s how to install them:

1. Navigate to the Demo Folder: Use the cd (change directory) command in Terminal or Command Prompt to move to the folder containing the app.py script (the main file for the GUI Demo). For example:

   • macOS/Linux:

     cd /Users/YourUsername/Documents/Robust-R1/demo
     

   • Windows:

     cd C:\Users\YourUsername\Documents\Robust-R1\demo
     

2. Install Dependencies: If there’s a requirements.txt file in the folder, run this command to install all required libraries:

   pip install -r requirements.txt
   

   If no requirements.txt file exists (or if you encounter errors), install the core dependencies manually:

   pip install torch gradio transformers pillow numpy
   

   Wait for the installation to complete—this may take a few minutes depending on your internet speed.

Step 3: Launch the GUI Demo

With the environment variable set and dependencies installed, you’re ready to start the demo:

1. Run the app.py Script: In Terminal or Command Prompt (still in the demo folder), type the following command and press Enter:

   python app.py
   

   • Note: If you have multiple Python versions installed (e.g., Python 2 and Python 3), use python3 instead of python to ensure you’re using Python 3.x.

2. Wait for the Demo to Load: The script will load the model and start a local web server. This process can take 30 seconds to a few minutes, depending on your computer’s hardware (faster GPUs will speed up model loading).

3. Confirm the Demo Is Running: Once the server is active, you’ll see a message in Terminal/Command Prompt like this:

   Running on http://localhost:7860
   

   This means the demo is successfully launched and accessible via your web browser.

Step 4: Access the Local Demo Interface

1. Open Your Web Browser: Launch any modern browser (Chrome, Firefox, Edge, Safari—all work well).
2. Enter the Local URL: Type http://localhost:7860 into the address bar and press Enter.
3. Explore the Demo: You’ll be taken to Robust-R1’s GUI Demo interface, which is designed to be intuitive and user-friendly. Key features include:

   • Image Upload: A button to upload your own images (supports JPG, PNG, and other common formats).
   • Parameter Controls: Sliders or dropdowns to adjust settings (e.g., degradation intensity, reasoning depth—depending on the demo’s configuration).
   • Result Display: A section showing the model’s output, including the original image, degraded image (if applicable), and Robust-R1’s reasoning process and final prediction.

Spend some time experimenting with different images—try uploading photos with blur, noise, or poor lighting to see how Robust-R1’s degradation-aware reasoning handles them.

Don’t Want to Deploy Locally? Try Robust-R1’s Online Demo

If you don’t have access to a powerful computer, or if you want to skip the local setup process, you can experience Robust-R1’s GUI Demo directly via an online platform. The project’s developers have hosted a fully functional version on Hugging Face Spaces, a popular platform for sharing machine learning demos.

How to Access the Online Demo:

1. Visit the Hugging Face Spaces Page: Open your browser and go to: Robust-R1 Online Demo.
2. Start Using the Demo: The online interface is identical to the local version—no login or installation required. You can:

   • Upload images from your computer.
   • Adjust parameters as needed.
   • View the model’s outputs in real time.

Benefits of the Online Demo:

• No Setup Required: Skip installing Python, dependencies, or model files—just click and play.
• Cross-Device Compatibility: Use it on any device with a browser (laptops, tablets, even smartphones).
• Free to Use: The demo is hosted publicly, so you can test it as many times as you want.

Limitations to Note:

• Network Dependence: The demo’s speed depends on your internet connection—uploading large images or processing complex inputs may take longer.
• Privacy Considerations: Avoid uploading sensitive or proprietary images, as they are processed on Hugging Face’s servers (not your local machine).

Below is a snapshot of Robust-R1’s Demo interface, so you know what to expect when you launch it (local or online):

Frequently Asked Questions (FAQ) About Robust-R1’s Demo

We’ve compiled answers to the most common questions users have about Robust-R1’s GUI Demo. If you run into issues or have doubts, this section should help.

1. When I run python app.py, I get a “ModuleNotFoundError” – what should I do?

This error means your Python environment is missing one or more required libraries. Here’s how to fix it:

• First, check if the demo folder has a requirements.txt file. If yes, re-run pip install -r requirements.txt to ensure all dependencies are installed.
• If no requirements.txt exists, install the core libraries manually with:

  pip install torch gradio transformers pillow numpy requests
  

• If the error persists, check the specific missing module (the error message will tell you which one) and install it individually. For example, if “gradio” is missing: pip install gradio.

2. I launched the local demo, but http://localhost:7860 won’t load in my browser – why?

There are a few common reasons for this:

• The Server Isn’t Fully Loaded: Wait 1-2 minutes and try again—model loading can take time on slower computers.
• Port 7860 Is Occupied: Another program (e.g., another demo or web server) is using port 7860. To fix this:

  • Close any other applications that might be using the port.
  • Or, modify the app.py script to use a different port (e.g., 7861). Search for port=7860 in the script, change it to port=7861, and re-run python app.py. Then access http://localhost:7861.
• Firewall or Antivirus Blocking Access: Temporarily disable your firewall or antivirus software (ensure you trust the demo) and try again. If it works, add an exception for the demo in your security settings.

3. What’s the difference between the local demo and the online demo?

Feature	Local Demo	Online Demo
Setup Required	Yes (Python, dependencies, model files)	No (just a browser)
Speed	Faster (depends on local hardware)	Slower (depends on internet and server load)
Privacy	More private (images processed locally)	Less private (images uploaded to servers)
Customization	Full access to adjust code/parameters	Limited to preconfigured controls
Offline Use	Yes (once set up)	No (requires internet)

Both demos offer the same core functionality—choose based on your needs (privacy, speed, convenience).

4. Can I use my own images to test Robust-R1?

Absolutely! Both the local and online demos support uploading custom images. Here’s what to keep in mind:

• Supported Formats: JPG, PNG, and TIFF are recommended (most image formats work, but these are the most reliable).
• Image Size: For best results, use images under 10MB—larger files may take longer to process (especially in the online demo).
• Degradation Types: Test images with common real-world issues: blur, noise, low light, compression artifacts, occlusion, or color distortion. This will help you see how Robust-R1’s degradation-aware reasoning performs in practical scenarios.

5. What visual tasks does the demo support?

The demo focuses on Robust-R1’s core strength: robust visual understanding under degradation. Supported tasks include:

• Image Classification: Identifying the main subject or category of an image (e.g., “cars,” “animals,” “buildings”).
• Visual Question Answering (VQA): Answering questions about the content of an image (e.g., “How many people are in the photo?” or “What color is the car?”).
• Image Captioning: Generating a descriptive text for an image (e.g., “A group of hikers walking through a foggy forest”).
• Degradation Analysis: Showing the model’s reasoning process—including identifying degradation types (e.g., “motion blur”) and intensities (e.g., “medium blur”).

The exact tasks may vary slightly between the SFT and RL model versions—check the demo’s interface for specific options.

6. I set the MODEL_PATH correctly, but the demo says “Model not found” – what’s wrong?

Double-check these things:

• Path Spelling: Ensure the path you entered in the environment variable is correct (no typos, missing folders, or extra spaces).
• Model File Completeness: Verify that the model folder contains all required files (e.g., config.json, pytorch_model.bin, tokenizer.json). If you downloaded the model from Hugging Face, re-download it to ensure no files are corrupted or missing.
• Quotation Marks: Make sure the path is enclosed in quotation marks (e.g., export MODEL_PATH="/Users/YourUsername/Models/Robust-R1"—not export MODEL_PATH=/Users/YourUsername/Models/Robust-R1). Quotation marks are especially important if your path contains spaces (e.g., /Users/YourUsername/Documents/Robust R1 Models).

7. Can I run the demo on a computer without a GPU?

Yes, but with caveats:

• Robust-R1’s model (based on Qwen2.5-VL-3B) can run on CPUs, but loading and processing times will be significantly slower (5-10x slower than on a GPU).
• For a smoother experience, we recommend using a computer with an NVIDIA GPU (CUDA-enabled) and installing PyTorch with CUDA support. This will drastically speed up model loading and inference.

If you only have a CPU, be patient—model loading may take 5-10 minutes, and processing each image may take 1-2 minutes.

Why Should You Experience Robust-R1’s Demo?

You might be wondering: “I already know what Robust-R1 does—why bother testing the demo?” The answer lies in the power of hands-on experience. Here are four compelling reasons to try it:

1. See Degradation-Aware Reasoning in Action

Robust-R1’s core innovation is its ability to explicitly model visual degradations through structured reasoning chains—unlike traditional models that rely on implicit adaptation. The demo lets you witness this process firsthand:

• Upload a blurry image, and the model will first identify the degradation type (“motion blur”) and intensity (“high”), then analyze how it impacts semantic understanding, and finally generate a robust output.
• Compare this to a standard model (e.g., Qwen2.5-VL-3B without Robust-R1’s enhancements) to see the difference in accuracy and reliability.

This visual proof helps you grasp why degradation-aware reasoning is a game-changer for real-world applications.

2. Validate Its Relevance to Your Work

Whether you’re working on surveillance systems, autonomous vehicles, medical imaging, or e-commerce product recognition, image degradation is a common challenge. The demo lets you test Robust-R1 on images that mirror your use case:

• A surveillance engineer can upload foggy or low-light footage to see if Robust-R1 can still detect objects.
• A medical researcher can test blurry X-rays to evaluate the model’s ability to retain diagnostic information.
• An e-commerce developer can upload compressed product photos to ensure the model still classifies items correctly.

By testing real-world scenarios, you can quickly determine if Robust-R1 is a good fit for your project.

3. Lower the Barrier to Learning Cutting-Edge Tech

You don’t need a PhD in computer vision to understand Robust-R1’s value. The demo’s intuitive interface translates complex algorithms into tangible results. For students or early-career professionals, this is an excellent way to:

• Learn how robustness is achieved in modern multimodal models.
• Gain practical experience with state-of-the-art AI tools.
• Spark ideas for your own research or projects.

Even if you’re not a technical expert, the demo helps you appreciate the progress being made in solving real-world AI challenges.

4. Provide Feedback to the Developers

The Robust-R1 project is open-source, and the developers welcome feedback from users. By testing the demo, you can:

• Report bugs or usability issues (via the project’s GitHub or Hugging Face page).
• Suggest feature improvements (e.g., supporting additional tasks or degradation types).
• Share use cases where the model excels or struggles—this helps the team refine future versions.

Your input can contribute to making Robust-R1 even more useful for the broader community.

Key Background: Why Robust-R1 Matters

To fully appreciate the demo, it’s helpful to understand the problem Robust-R1 is solving. Traditional multimodal large language models (MLLMs) like Qwen2.5-VL or InternVL perform well on clean, high-quality images—but their performance drops sharply when faced with real-world degradations. This is because:

• They lack explicit mechanisms to diagnose how degradation impacts semantic information (limited interpretability).
• They optimize the visual encoder and language model in isolation, ignoring how degradation propagates between the two components (isolated optimization).

Robust-R1 addresses these limitations by introducing a structured degradation-aware reasoning process:

1. Perceive Degradation Parameters: Identify the type (e.g., blur, noise) and intensity (e.g., low, medium, high) of visual degradation.
2. Analyze Semantic Impact: Determine how the degradation affects the model’s ability to understand key visual features.
3. Reconstruct Pristine Reasoning: Generate a reasoning chain that compensates for the degradation, mimicking how the model would perform on a clean image.
4. Produce a Robust Output: Deliver an accurate prediction or answer, even with degraded input.

The demo lets you see this entire process unfold—turning abstract algorithms into concrete results.

Conclusion: Try Robust-R1’s Demo Today

Robust-R1 represents a significant step forward in robust visual understanding, and its GUI Demo is the perfect way to explore its capabilities. Whether you choose to run it locally for speed and privacy, or use the online version for convenience, you’ll gain valuable insights into how degradation-aware reasoning can solve real-world computer vision challenges.

Here’s a quick recap of how to get started:

• Online Demo: Visit https://huggingface.co/spaces/Jiaqi-hkust/Robust-R1 and start uploading images immediately.
• Local Demo:

  1. Download the model from Hugging Face.
  2. Set the MODEL_PATH environment variable.
  3. Install dependencies.
  4. Run python app.py and access http://localhost:7860.

Whether you’re a developer looking to integrate robust vision into your project, a researcher exploring new approaches to AI robustness, or a student curious about cutting-edge technology, Robust-R1’s demo offers something for everyone. It’s a testament to the power of combining theoretical innovation with practical accessibility—and it’s just the beginning of what’s possible with degradation-aware reasoning.

So go ahead—upload an image, tweak the parameters, and see for yourself how Robust-R1 is redefining what’s possible in robust visual understanding. If you have questions or feedback, don’t hesitate to reach out to the project team via their GitHub or Hugging Face repositories. Happy testing!