Skip to content

ForagerRL_step15

Killian edited this page May 4, 2026 · 1 revision

15. Testing & Tutorial Summary

By Killian Trouillet


Step 15: Testing & Tutorial Summary

Testing the Trained Multi-Agent Policy

After training, we load the shared PPO model and run both foragers in the GAMA GUI.

Starting GAMA GUI

Open GAMA normally. The GUI server runs on port 1000 by default.

Loading the Shared Model

from train_forager_petz import PPOAgent

agent = PPOAgent(state_dim=15, action_dim=2)
agent.load("saved_models/ppo_forager.pth")

One model, shared by both foragers — just like training.

Running a Cooperative Episode

obs, _ = env.reset()
done = False
while not done:
    actions = {}
    for agent_id in env.agents:
        action, _, _ = agent.select_action(
            np.array(obs[agent_id], dtype=np.float32),
            test=True   # ← deterministic: use mean action
        )
        actions[agent_id] = action

    obs, rewards, terminations, truncations, _ = env.step(actions)
    done = not env.agents or all(terminations.values()) or all(truncations.values())
    time.sleep(0.1)

What You Should See

In the GAMA GUI:

  • Blue forager_0 navigates with its LIDAR cone around the left obstacles.
  • Teal forager_1 follows a slightly different path due to its starting position.
  • The first to arrive at the green food turns orange and freezes.
  • When both are orange, the episode ends: cooperative success.

Running the Test Script

cd models/petz
python test_forager_petz.py

Expected Console Output

=======================================================
  Smart Forager — MARL Test (gama-pettingzoo GUI)
=======================================================
Model loaded (shared by both foragers)

Running 1 cooperative test episodes...

  Episode 1/1: ✓ COOPERATIVE SUCCESS! | Steps: 61
    forager_0: reward = 89.4
    forager_1: reward = 87.1

=======================================================
  Test Results Summary
=======================================================
  Episodes    : 1
  Success Rate: 100%
  Avg Steps   : 61
  forager_0 avg reward: 89.4
  forager_1 avg reward: 87.1
=======================================================

Full Tutorial Summary

Part 1 – Internal RL (GAML only)

Step Concept introduced
1 Grid world with grid species
2 Forager agent with random movement
3 Reward function and episodes
4 Q-Table as map<string, float>
5 Q-Learning / Bellman equation
6 Charts, heatmap, test mode

Part 2 – Deep RL with Gymnasium

Step Concept introduced
7 Continuous world, architecture overview
8 GymAgent bridge species
9 LIDAR ray-cast sensors, movement, reward shaping
10 Headless training with custom PyTorch PPO
11 GUI testing, deterministic evaluation

Part 3 – Multi-Agent RL with PettingZoo

Step Concept introduced
12 PettingZoo Parallel API, PetzAgent bridge, cooperative rewards
13 Multi-agent GAML model, as_map, team obs, episode-end signal
14 Parameter-Shared PPO, batch inference, GamaParallelEnv directly
15 GUI testing, series recap

Key Concepts Across All 3 Parts

Concept Part 1 Part 2 Part 3
World 10×10 grid 100×100 continuous Same
Agents 1 1 2
Actions 4 discrete 2D continuous [dx, dy] Same
Sensors Grid position 8 LIDAR rays 8 LIDAR + teammate pos
Algorithm Q-Learning PPO Parameter-Shared PPO
Bridge None GymAgent PetzAgent
Library None gama-gymnasium gama-pettingzoo
RL Framework None PyTorch (custom PPO) Same
Task Solo food Solo food Cooperative food

Key GAML Concepts Introduced in Part 3

PetzAgent, agents, possible_agents, observations, rewards, terminations, truncations, actions, update_data, as_map, all_match, contains_key, episode-end via agents <- []

Key Python Concepts Introduced in Part 3

GamaParallelEnv, env.agents, env.observation_space(agent_id), env.action_space(agent_id), env.reset()dict, env.step(actions_dict)dict, parameter sharing, batch inference, select_actions_batch(), per-agent RolloutBuffer


Key Files

File Description
models/petz/forager_petz.gaml GAMA model with PetzAgent bridge
models/petz/train_forager_petz.py MARL training script (headless)
models/petz/test_forager_petz.py Testing script (GUI visualization)
  1. What's new (Changelog)
  2. Migration Guide (2025-06 → 2026-06)
  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Getting Started
    2. Headless Legacy
    3. Headless Batch
  6. Preferences
  7. Troubleshooting
  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Classes and Objects
    1. Class Definition and Instantiation
    2. Attributes and Actions
    3. Inheritance
    4. Virtual Classes
    5. Advanced Features
  7. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  8. Optimizing Models
    1. Runtime Concepts
    2. Analyzing code performance
    3. Optimizing Models
  9. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations
  1. Manipulate OSM Data
  2. Cleaning OSM Data
  3. Diffusion
  4. Using Database
  5. Using Dataframes
  6. Using FIPA ACL
  7. Using BDI with BEN
  8. Using Driving Skill
  9. Manipulate dates
  10. Manipulate lights
  11. Using comodel
  12. Save and restore Simulations
  13. Using network
  14. Writing Unit Tests
  15. Ensure model's reproducibility
  16. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA
  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Stats Extension
  8. Sound Extension
  9. BDI Extension
  10. FIPA Skill
  11. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators (Definition)
    6. Operators [A-A]
    7. Operators [B-C]
    8. Operators [D-H]
    9. Operators [I-M]
    10. Operators [N-R]
    11. Operators [S-Z]
  12. Exhaustive list of GAMA Keywords
  1. Installing the development version
    1. Install GAMA source code with Eclipse plugin
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Creating a release of GAMA
  6. Documentation generation

  1. Predator Prey
  2. Road Traffic
  3. Incremental Model
  4. Luneray's flu
  5. BDI Agents
  6. Forager RL
  7. SIR Analysis
  8. 3D Model

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Resources

  1. Videos
  2. Conferences
  3. Pedagogical materials

Clone this wiki locally