From 8c34a2a7f2e1849cb465dcf601e266fdab04e6b8 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 13:24:32 +0000
Subject: [PATCH] Deployed 50bc3bf with MkDocs version: 1.6.1

---
 design/actor-critic/index.html | 2 +-
 search/search_index.json       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/design/actor-critic/index.html b/design/actor-critic/index.html
index 3aa718b..f1092f5 100644
--- a/design/actor-critic/index.html
+++ b/design/actor-critic/index.html
@@ -978,7 +978,7 @@ critic for all nodes at once, for the following reasons:</p>
 and computational cost. As of right now, though this might change as we make progress in our experiments, we use:</p>
 <ul>
 <li>Input Networks (Sensors &amp; Feature Extractors): These networks map the raw state inputs to internal hidden states.
-  They are configured as standard dense networks with 2 hidden layers of 64 nodes each (<code>[64, 64]</code>) and utilize <code>tanh</code>
+  They are configured as standard dense networks with 3 hidden layers of 300 nodes each (<code>[300, 300, 300]</code>) and utilize <code>tanh</code>
   activation functions.</li>
 <li>Output Networks (Motors, Actors &amp; Critics): The final output models are intentionally kept shallow. The Actor
   directly projects the hidden state to a continuous action distribution (<code>mean</code> and <code>log_std</code>) using a single dense
diff --git a/search/search_index.json b/search/search_index.json
index 0f6f92a..be2b6da 100644
--- a/search/search_index.json
+++ b/search/search_index.json
@@ -1 +1 @@
-{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"],"fields":{"title":{"boost":1000.0},"text":{"boost":1.0},"tags":{"boost":1000000.0}}},"docs":[{"location":"","title":"Documentation","text":"<p>Welcome to the Brittle Star project documentation. This codebase contains the implementations and research for the scientific evaluation of controller modularity in brittle-star-like robots trained using Reinforcement Learning.</p> <p>For the core codebase, scripts, and contribution history, visit our GitHub Repository.</p>"},{"location":"#core-requirements-guides","title":"Core Requirements &amp; Guides","text":"<ul> <li>Installation Instructions: Steps to set up your development environment locally or in a devcontainer using <code>uv</code>, including GPU configuration. For High-Performance Computing (HPC) setup details, see the HPC Guide.</li> <li>How to Run Experiments: A complete guide on running training jobs, setting custom hyperparameters, and overriding config options using Hydra.</li> <li>Results &amp; Reproduction: Guide on how to access our public WandB training runs table and reproduce our training and evaluation phases (determining the best checkpoint vs. comparing architectures).</li> <li>Contribution Guidelines: Standards, rules, and best practices for developing and adding code to the repository.</li> <li>Repository Structure: Overview of the directories and files within the codebase.</li> </ul>"},{"location":"#repository-structure","title":"Repository Structure","text":"<pre><code>.\n\u251c\u2500\u2500 configs/                # Hydra configuration files (YAML)\n\u251c\u2500\u2500 docs/                   # Comprehensive documentation and API guides\n\u251c\u2500\u2500 runs/                   # Default output directory for Hydra and training artifacts\n\u251c\u2500\u2500 scripts/                # High-level entrypoints for training, simulation, and evaluation\n\u251c\u2500\u2500 src/\n\u2502   \u251c\u2500\u2500 brittle_star_project/ # Core library and environment logic\n\u2502   \u2502   \u251c\u2500\u2500 evaluation/     # Checkpoint evaluation, rollout logic, and metrics persistence\n\u2502   \u2502   \u2514\u2500\u2500 trainers/       # Training loop implementations (e.g., PPO)\n\u2502   \u2514\u2500\u2500 experiment_logger/  # Standalone logging package\n\u2514\u2500\u2500 tests/                  # Unit and integration tests\n</code></pre>"},{"location":"#design-architecture-design","title":"Design &amp; architecture (<code>/design</code>)","text":"<p>If you are interested in the \"why did you do it like this?\"</p> <ul> <li>Actor-Critic Architecture: Description of the actor-critic pipeline.</li> <li>Communication Scheme: Message propagation, Nerve-Net style.</li> <li>Modularity &amp; Topology: Macroscopic brain topology, centralized, arm-level, segment-level.</li> <li>Input &amp; Action Spaces: Description of the model's input and output.</li> <li>Reinforcement Learning Algorithm: RL techniques, i.e. PPO.</li> <li>Reward Function &amp; Observation Space: Goals, fitness tracking, and reward structures.</li> </ul>"},{"location":"#api-reference-api","title":"API reference (<code>/api</code>)","text":"<p>If you are interested in the \"how do I use it?\"</p> <ul> <li>Brittle Star Environment: MuJoCo environment interaction and configuration.</li> <li>Training Models: How to configure and run experiments.</li> <li>Tracking &amp; Monitoring: Setting up WandB and TensorBoard to monitor runs.</li> <li>Checkpoint &amp; Model Evaluation: Evaluating checkpoints and comparing fault tolerance.</li> <li>Interactive Simulation &amp; Visualization: Visualizing models in the MuJoCo viewer or rendering simulation videos.</li> <li>Analysis &amp; Plotting Tools: Comparing checkpoints and generating plots.</li> <li>Results &amp; Reproduction: Accessing WandB results and running reproduction pipelines.</li> </ul>"},{"location":"CONTRIBUTING/","title":"Contribution Guidelines","text":"<p>This document outlines the contribution protocols for the scientific software engineering project focusing on bio-inspired control architectures for brittle-star-like robots. The primary objective of this project is to produce scientific insight, rather than a commercial product.</p>"},{"location":"CONTRIBUTING/#1-scientific-context-methodology","title":"1. Scientific Context &amp; Methodology","text":"<ul> <li>Research Focus: The goal is to study how controller modularity affects learning speed, coordination, and fault tolerance in brittle-star locomotion.</li> <li>Hypothesis-Driven Design: Clear hypotheses must dictate a structured methodology and rigorous evaluation. All design decisions must be formally documented prior to implementation.</li> <li>Scaffolding Approach: Development must start with simple setups before progressively increasing the complexity of environments and morphologies.</li> <li>Evaluation of Results: Negative results possess scientific validity when thoroughly analyzed. If a controller fails to learn locomotion, providing a comprehensive analysis of the failure is considered a strong scientific contribution.</li> <li>Reproducibility: Contributors must utilize fixed library versions. Configuration systems (such as json, gin, or yaml) must be employed to ensure reproducible runs.</li> </ul>"},{"location":"CONTRIBUTING/#2-clean-code-code-quality","title":"2. Clean Code &amp; Code Quality","text":"<p>Code readability is paramount, as code is read far more frequently than it is written.</p> <ul> <li>Naming Conventions: Variables and functions must utilize consistent, intention-revealing names. A long, descriptive name is strictly preferred over a short name accompanied by a comment.</li> <li>Function Design: Functions must be modular and adhere to the single responsibility principle. Arguments must be minimized, and boolean flag arguments controlling behavior should be avoided.</li> <li>Commenting: Code must document the \"how,\" while comments are strictly reserved for documenting the \"why\". Commented-out code is prohibited and must be deleted via version control.</li> <li>YAGNI: Contributors must adhere to the \"You Aren't Gonna Need It\" (YAGNI) principle and actively avoid premature optimization.</li> <li>Notebooks: Jupyter Notebooks are strictly limited to quick prototyping, tutorials, demonstrations, or post-processing analysis. They are explicitly forbidden for general software development because they discourage modularity.</li> </ul>"},{"location":"CONTRIBUTING/#3-version-control-repository-structure","title":"3. Version Control &amp; Repository Structure","text":"<ul> <li>Git Practices: Commits must be frequent and small. Each commit should relate to exactly one piece of functionality.</li> <li>Branching Strategy: The <code>dev</code> branch serves as the integration branch for pushing and merging code. Only stable releases may be pushed to the <code>main</code> branch.</li> <li>Artifact Management: Data files, trained models, and large datasets must never be committed directly to Git. Git Large File Storage (LFS) must be used for tracking large files. All developers must have <code>git-lfs</code> installed locally (see DEVELOPMENT.md for setup).</li> <li>Repository Layout: The repository must maintain the following core directories: <code>src/</code> for algorithms, <code>env/</code> for MuJoCo wrappers, <code>config/</code> for experiment configurations, <code>experiments/</code> for scripts, <code>docs/</code> for Doxygen or ReadTheDocs documentation, and <code>tests/</code> for unit tests.</li> </ul>"},{"location":"CONTRIBUTING/#4-architecture-tooling","title":"4. Architecture &amp; Tooling","text":"<ul> <li>Algorithms &amp; Frameworks: Proximal Policy Optimization (PPO) is the recommended baseline algorithm. CleanRL should be used as a starting point and adapted for continuous action spaces. All Artificial Neural Network (ANN) controller architectures must be implemented using Flax.</li> <li>Simulation: The simulation environment utilizes a MuJoCo brittle star. XML MuJoCo structures must remain realistic and respect morphological constraints.</li> <li>Experiment Tracking: Weights &amp; Biases (wandb) must be utilized for tracking and logging all experiments.</li> <li>Code Styling: All code must conform to the chosen style guide (Google standard). This is enforced via <code>uv</code> using ruff and pre-commit hooks.</li> </ul>"},{"location":"CONTRIBUTING/#5-ai-assisted-development-code-review","title":"5. AI-Assisted Development &amp; Code Review","text":"<p>This project supports AI-assisted development to enhance productivity, but contributors must take full responsibility for all AI-generated outputs.</p> <ul> <li>Self-Review Requirement: Contributors must thoroughly self-review all AI-assisted code, documentation, and configurations before requesting peer review. This includes verifying correctness, adherence to project standards, scientific validity, and integration with existing code.</li> <li>Quality Standards: AI-generated content must meet the same rigorous standards as manually written code, including proper testing, documentation, and alignment with the scientific methodology outlined in Section 1.</li> <li>Available Skills: This project provides specific AI skills for common tasks (located in <code>.agents/skills/</code>), including linting and testing workflows. Contributors should leverage these skills to maintain consistency and quality.</li> <li>Transparency: When using AI assistance for complex algorithmic decisions or scientific design choices, contributors should document the rationale in commit messages or code comments where appropriate.</li> </ul>"},{"location":"DEVELOPMENT/","title":"Development Guide","text":"<p>This guide outlines how to set up the development environment for this project, prioritizing reproducible builds, environment parity, and cross-hardware compatibility.</p>"},{"location":"DEVELOPMENT/#reproducibility-uv","title":"Reproducibility &amp; uv","text":"<p>This project uses uv to manage dependencies and virtual environments. The <code>uv.lock</code> file is the absolute source of truth for package versions and must always be committed.</p>"},{"location":"DEVELOPMENT/#source-of-truth","title":"Source of Truth","text":"<ul> <li>Never modify <code>uv.lock</code> manually.</li> <li>To add a dependency, run <code>uv add &lt;package&gt;</code>.</li> <li>To update dependencies, run <code>uv lock --upgrade</code>.</li> <li>To sync your environment with the lockfile, run <code>uv sync --frozen</code>.</li> </ul>"},{"location":"DEVELOPMENT/#git-lfs-critical","title":"Git LFS (Critical)","text":"<p>All developers must have Git LFS installed locally. This repository tracks model weights (<code>.pt</code>, <code>.safetensors</code>, etc.), recordings (<code>.mp4</code>), and datasets using Git LFS.</p> <ul> <li>Setup: Run <code>git lfs install</code> after cloning this repository. If you are using the <code>.devcontainer</code> or <code>flake.nix</code>, LFS is typically available automatically.</li> <li>If you clone without LFS installed, run <code>git lfs pull</code> after installation to fetch the actual data files instead of the small pointer files.</li> </ul>"},{"location":"DEVELOPMENT/#devcontainer-setup-recommended","title":"Devcontainer Setup (Recommended)","text":"<p>The devcontainer provides an identical experience to local development but with all system dependencies pre-configured. It automatically detects your hardware (GPU vs CPU) and syncs the appropriate dependencies.</p>"},{"location":"DEVELOPMENT/#prerequisites","title":"Prerequisites","text":"<ul> <li>Docker Desktop or Docker Engine.</li> <li>NVIDIA Container Toolkit (for GPU support).</li> </ul>"},{"location":"DEVELOPMENT/#setup-for-vs-code","title":"Setup for VS Code","text":"<ol> <li>Install the Dev Containers extension.</li> <li>Open the project and click Reopen in Container.</li> <li>On first launch, the <code>post-create.sh</code> script will:</li> <li>Detect if an NVIDIA GPU is available via <code>nvidia-smi</code>.</li> <li>Run <code>uv sync --frozen --extra cuda</code> if a GPU is found.</li> <li>Run <code>uv sync --frozen</code> otherwise.</li> <li>The environment is stored in a named volume for <code>.venv</code> to ensure persistence and performance.</li> </ol>"},{"location":"DEVELOPMENT/#setup-for-jetbrains-ides","title":"Setup for JetBrains IDEs","text":"<ol> <li>The IDE will detect the <code>.devcontainer/devcontainer.json</code> file.</li> <li>The environment is pre-configured to point to <code>/workspaces/project/.venv</code>.</li> <li>The hardware-aware sync will run automatically during container creation.</li> </ol>"},{"location":"DEVELOPMENT/#local-development-alternative","title":"Local Development (Alternative)","text":"<p>If you prefer not to use Docker:</p> <ol> <li>Install uv.</li> <li>Run <code>uv sync --frozen</code> (CPU) or <code>uv sync --frozen --extra cuda</code> (GPU).</li> </ol>"},{"location":"DEVELOPMENT/#hardware-acceleration-jax","title":"Hardware Acceleration (JAX)","text":"<p>Verify your setup by running the JAX initialization test:</p> <pre><code>uv run pytest tests/test_jax_init.py\n</code></pre> <p>In the devcontainer, this will succeed on both CPU and GPU. A <code>GpuDevice</code> is expected if a GPU is detected and the <code>cuda</code> extra was installed.</p>"},{"location":"DEVELOPMENT/#logging-monitoring","title":"Logging &amp; Monitoring","text":"<p>This project uses a unified logging system through the <code>experiment_logger</code> package. </p> <ul> <li>Usage in Code: To use the logger in your scripts, refer to the package README for the API reference.</li> <li>WandB/TensorBoard Setup: For information on how to configure tracking for experiments, see the Tracking &amp; Monitoring API Guide.</li> </ul> <p>The logger automatically detects if it is running in an interactive terminal or a non-interactive environment (like an HPC Slurm job), adjusting progress bars and fallback modes accordingly.</p>"},{"location":"HPC/","title":"HPC Guide","text":"<p>Full documentation: https://docs.hpc.ugent.be/</p>"},{"location":"HPC/#storage-overview","title":"Storage Overview","text":"<ul> <li>Run Outputs: Written to <code>$VSC_SCRATCH</code> during the job (fast I/O) and copied to <code>$VSC_DATA</code> at the end for persistence.</li> <li>Virtual Environments: Managed on <code>$VSC_DATA</code> by mirroring configuration files. This avoids the 3GB home quota without requiring symlinks in the project root.</li> </ul>"},{"location":"HPC/#initial-environment-setup","title":"Initial Environment Setup","text":"<p>Run once after cloning the repository. This script handles all modules, mirroring, and environment synchronization.</p> <pre><code># Option A: Interactive (on a compute node)\nmodule swap cluster/donphan  # Debug cluster (CPU only)\n# OR for GPU clusters:\n# module swap cluster/joltik\n# module swap cluster/accelgor\n# module swap cluster/litleo\n\nqsub -I -l nodes=1:gpus=1  # Only for GPU clusters\ncd \"${PBS_O_WORKDIR}\"\nbash scripts/hpc/install.sh\n\n# Option B: Batch (Run in background)\n# NOTE: GPU clusters (joltik/accelgor/litleo) require -l gpus=1 at runtime\nqsub -l gpus=1 scripts/hpc/install.sh\n</code></pre>"},{"location":"HPC/#production-vs-debug-clusters","title":"Production vs. Debug Clusters","text":"<p>Our scripts are cluster-agnostic and do not have hardcoded GPU requirements. Instead, you must request GPUs at runtime using the <code>-l gpus=1</code> flag when submitting to a production GPU cluster.</p>"},{"location":"HPC/#debugging-donphan","title":"Debugging (Donphan)","text":"<p>The <code>donphan</code> cluster does not support GPUs. Simply run the scripts without extra resource flags: <pre><code>module swap cluster/donphan\nqsub scripts/hpc/train.pbs\n</code></pre></p>"},{"location":"HPC/#production-joltik-accelgor-litleo","title":"Production (Joltik, Accelgor, Litleo)","text":"<p>These clusters provide GPU acceleration and require a GPU request at runtime: <pre><code>module swap cluster/joltik  # or accelgor/litleo\nqsub -l gpus=1 scripts/hpc/train.pbs\n</code></pre></p>"},{"location":"HPC/#interactive-debugging","title":"Interactive Debugging","text":"<p>To activate your environment for interactive work, simply run the same <code>install.sh</code> script.</p> <pre><code>qsub -I -l nodes=1:ppn=4 -l walltime=1:00:00\ncd \"$PBS_O_WORKDIR\"\nbash scripts/hpc/install.sh\n</code></pre>"},{"location":"HPC/#verification-commands","title":"Verification Commands","text":"<p>After installation, run these commands to ensure your environment is set up correctly:</p> <ol> <li> <p>Verify Quota Safety:    <pre><code>ls -d venvs 2&gt;/dev/null &amp;&amp; echo \"FAIL\" || echo \"&gt;&gt;&gt; PASS: Project root is clean.\"\n</code></pre></p> </li> <li> <p>Verify Library Versions (NumPy Fix):    <pre><code>python -c \"import numpy; print(f'NumPy: {numpy.__version__}')\"\n# Expected: 2.x.x (Venv version), not 1.2x (System version)\n</code></pre></p> </li> <li> <p>Verify GPU Access:    <pre><code>python -c \"import torch, jax; print(f'GPU: {torch.cuda.is_available()}'); print(f'JAX: {jax.devices()}')\"\n</code></pre></p> </li> </ol>"},{"location":"HPC/#managing-dependencies","title":"Managing Dependencies","text":"<p><code>env/hpc/requirements.txt</code> is auto-generated from <code>pyproject.toml</code>. To regenerate:</p> <pre><code>uv run scripts/hpc/export_requirements.py\n</code></pre> <p>Modules listed in <code>env/hpc/modules.txt</code> are automatically excluded from the pip requirements to save space and use HPC-optimized binaries.</p>"},{"location":"api/analysis/","title":"Analysis &amp; Plotting Tools","text":"<p>This guide outlines the tools available for analyzing experimental data and generating poster-quality visualizations for the Brittle Star project.</p>"},{"location":"api/analysis/#shared-configuration","title":"Shared Configuration","text":"<p>All plotting scripts share a central configuration in <code>scripts/plots/plot_config.py</code>. This file defines:</p> <ul> <li>Color Palette: A color-blind friendly, high-contrast palette for different architectures.</li> <li>Typography: Consistent font sizes and styles tailored for A0 posters.</li> <li>Markers: Shared visual indicators, such as the \u2605 used for best performers.</li> </ul>"},{"location":"api/analysis/#comparison-visualization","title":"Comparison Visualization","text":"<p>The <code>scripts/plots/analyze_comparisons.py</code> script generates grouped bar charts comparing the performance of different architectures across various morphologies.</p>"},{"location":"api/analysis/#usage","title":"Usage","text":"<p>Run the script from the root of the project, providing the path to your evaluation CSV:</p> <pre><code># Basic usage (saves PNG and SVG to runs/evaluation/plots/)\nuv run python scripts/plots/analyze_comparisons.py path/to/results.csv\n\n# Advanced usage for Figma/Poster integration\nuv run python scripts/plots/analyze_comparisons.py path/to/results.csv \\\n    --output_dir docs/assets/plots/ \\\n    --font_size 30 \\\n    --fig_width 14 \\\n    --fig_height 10\n</code></pre>"},{"location":"api/analysis/#cli-arguments","title":"CLI Arguments","text":"<ul> <li><code>input_csv</code>: (Required) Path to the CSV file containing evaluation results.</li> <li><code>--output_dir</code>, <code>-o</code>: Directory where plots will be saved (default: <code>runs/evaluation/plots</code>).</li> <li><code>--show_titles</code>: Include titles in the plots. Default is False, as titles are typically added natively in design tools like Figma.</li> <li><code>--font_size</code>: Base font size in points (default: 28).</li> <li><code>--fig_width</code> / <code>--fig_height</code>: Physical dimensions of the plot in inches. Match these to your Figma layout to maintain exact font sizes.</li> </ul>"},{"location":"api/analysis/#outputs","title":"Outputs","text":"<p>The script generates four key plots, each saved as both <code>.png</code> and <code>.svg</code>:</p> <ol> <li>Forward Velocity: Grouped bar chart (cm/s).</li> <li>Accumulated Reward: Mean cumulative reward.</li> <li>Success Rate: Target acquisition percentage.</li> <li>Distance Remaining: Navigational accuracy.</li> </ol>"},{"location":"api/analysis/#convergence-analysis","title":"Convergence Analysis","text":"<p>The <code>scripts/plots/analyze_convergence.py</code> script determines the convergence point of training runs.</p>"},{"location":"api/analysis/#usage_1","title":"Usage","text":"<pre><code>uv run python scripts/plots/analyze_convergence.py --output_dir runs/convergence/\n</code></pre>"},{"location":"api/analysis/#configuration","title":"Configuration","text":"<ul> <li>File Mapping: The script uses hardcoded paths in the <code>FILE_MAPPING</code> dictionary. Update these paths to point to your specific run evaluation files.</li> <li>CLI Arguments: Supports the same <code>--show_titles</code>, <code>--font_size</code>, and <code>--fig_width/height</code> flags as the comparison script.</li> </ul>"},{"location":"api/analysis/#outputs_1","title":"Outputs","text":"<p>Generates three plots (PNG &amp; SVG):</p> <ol> <li><code>convergence_comparison</code>: Grouped horizontal bar chart.</li> <li><code>progress_reward_curves</code>: Line plots of reward over time.</li> <li><code>progress_velocity_curves</code>: Line plots of velocity over time.</li> </ol>"},{"location":"api/analysis/#poster-integration-figma","title":"Poster Integration (Figma)","text":""},{"location":"api/analysis/#svg-scaling","title":"SVG &amp; Scaling","text":"<p>We recommend using the SVG outputs for poster design in Figma:</p> <ol> <li>No Resolution Loss: SVGs are vector-based and will remain sharp at any size.</li> <li>Native Text: Text in the SVG imports as native text layers in Figma.</li> <li>Exact Font Matching: To ensure a <code>28pt</code> font in the plot matches a <code>28pt</code> font in your poster, set the <code>--fig_width</code> and <code>--fig_height</code> to match the physical dimensions of the plot box in your Figma layout.</li> <li>Editable: You can \"Ungroup\" the SVG in Figma to manually move labels, adjust colors, or tweak individual bars.</li> </ol>"},{"location":"api/analysis/#image-placeholders","title":"Image Placeholders","text":"<p>The comparison charts include light-gray square placeholders below the X-axis. These are designed as guides; in Figma, you can drop your morphology renders or illustrations directly on top of these squares.</p>"},{"location":"api/environment/","title":"Brittle star environment","text":""},{"location":"api/environment/#creation","title":"Creation","text":"<p>The environment package contains a factory class <code>BrittleStarEnvFactory</code>  that creates instances of the environment/morphologies/... It uses the configuration classes defined in <code>env_config.py</code> to create the instances.</p>"},{"location":"api/environment/#configuration","title":"Configuration","text":"<p>The data classes in <code>env_config</code> have default values as stated in the tutorials.</p> <ul> <li>MorphologyConfig: configuration for the morphology of the brittle star. Contains number of arms, number of segments per arm, and control mode.</li> <li>ArenaConfig: configuration for the arena. Sets the size of the arena, whether to  set the ground floor to sand, attach a target and sizes of the walls.</li> <li>EnvConfig: configuration for the environment. These set shared settings such as camera locations, simulation time and the task.</li> </ul>"},{"location":"api/environment/#backend-and-task-enums","title":"Backend and Task enums","text":"<p>The Backend enum specifies either an MJC or MJX backend.</p> <ul> <li>MJC: runs on CPU</li> <li>MJX: uses jax on the gpu</li> </ul> <p>The Task enum specifies which task to use. 2 items are present:</p> <ul> <li>DIRECTED_LOCOMOTION: move to a target location</li> <li>LIGHT_ESCAPE: situation where the robot must move to a darker location</li> </ul>"},{"location":"api/evaluation/","title":"Checkpoint &amp; Model Evaluation","text":"<p>This guide covers how to evaluate trained brittle star models, with a focus on measuring defect tolerance (amputations) across different controller architectures.</p>"},{"location":"api/evaluation/#checkpoint-evaluation-during-training","title":"Checkpoint Evaluation (During Training)","text":"<p>The <code>PPOTrainer</code> can automatically evaluate every saved checkpoint using the fast MJX backend. This is enabled via configuration.</p>"},{"location":"api/evaluation/#configuration","title":"Configuration","text":"<p>In your experiment config or via CLI: <pre><code>python scripts/train.py evaluation.evaluate_checkpoints=true evaluation.eval_max_steps=5000\n</code></pre></p> <p>Results are saved to <code>runs/&lt;run_dir&gt;/metrics/checkpoint_evaluation.csv</code> and synced to Weights &amp; Biases if enabled.</p>"},{"location":"api/evaluation/#cross-model-fault-tolerance-analysis","title":"Cross-Model &amp; Fault Tolerance Analysis","text":"<p>To measure how well different controllers handle damage (amputations), use <code>scripts/compare_models.py</code>. This script performs a grid search over models x morphologies.</p> <ol> <li>Create or update a YAML file in <code>configs/evaluation</code>.</li> <li>Run the benchmark:</li> </ol> <pre><code>python scripts/compare_models.py evaluation=poster\n</code></pre> <p>The script will evaluate every combination of model and morphology for the specified number of episodes.</p> <p>The results are saved to a CSV (default: <code>metrics/model_comparison.csv</code>).</p>"},{"location":"api/evaluation/#csv-schema","title":"CSV Schema","text":"Column Description <code>model_path</code> Path to the trained weights. <code>architecture</code> The <code>morph_mode</code> of the model (e.g., <code>CENTRALIZED</code>, <code>RING</code>). <code>arm_0</code> ... <code>arm_4</code> Number of segments in each arm slot (0 = amputated). <code>num_active_arms</code> Total number of arms with segments &gt; 0. <code>seed</code> The episode seed. <code>eval_return</code> Accumulated shaped reward. <code>approx_max_velocity</code> Average velocity: <code>(initial_dist - final_dist) / steps</code>. <code>reached_target</code> Whether the robot finished within the success radius."},{"location":"api/evaluation/#post-hoc-checkpoint-scanning","title":"Post-hoc Checkpoint Scanning","text":"<p>If you need to re-evaluate every saved checkpoint in a run (e.g., to generate a learning curve with different metrics):</p> <pre><code>python scripts/evaluate_checkpoints.py \\\n    simulation.model_path=runs/&lt;run_id&gt;/final_model.flax \\\n    evaluation.eval_max_steps=2000\n</code></pre> <p>This script scans the <code>checkpoints/</code> directory of the specified run and evaluates every <code>.flax</code> file it finds using the model's training morphology.</p> <p>For a step-by-step walkthrough on using these evaluation phases to reproduce our project results, see the Results &amp; Reproduction Guide.</p>"},{"location":"api/reproduction/","title":"Results &amp; Reproduction","text":"<p>This guide explains how to access our official training logs and reproduce our results.</p> <p>Our official training runs, model configurations, and metrics are publicly hosted on Weights &amp; Biases (WandB).</p>"},{"location":"api/reproduction/#weights-biases-wandb-project","title":"Weights &amp; Biases (WandB) Project","text":"<p>All experiments, final models, and training logs are tracked in our public WandB project:</p> <ul> <li>Official Runs Table: WandB final-models-v2 Table</li> </ul> <p>This page lists the verified runs with their architecture types, morphology definitions, evaluation metrics, and final model performance.</p>"},{"location":"api/reproduction/#how-to-reproduce-a-run-from-wandb","title":"How to Reproduce a Run from WandB","text":"<p>Weights &amp; Biases provides a built-in feature to extract the exact parameters and commands used for any given run:</p> <ol> <li>Open the WandB final-models-v2 Table.</li> <li>Click on the name of the run you wish to reproduce to open its detail page.</li> <li>In the top-right corner of the run header (next to the run name, not the main workspace header), click the three dots (<code>...</code>) menu.</li> <li>Select \"Reproduce run\". This will display the exact command-line arguments and configuration settings used to execute that run.</li> </ol>"},{"location":"api/reproduction/#local-hpc-reproduction-workflow","title":"Local &amp; HPC Reproduction Workflow","text":"<p>To reproduce our training and evaluation phases locally or on an HPC cluster, follow the procedures below.</p>"},{"location":"api/reproduction/#1-environment-setup","title":"1. Environment Setup","text":"<p>To ensure identical package versions (including JAX, Flax, and MuJoCo), sync your environment using the lockfile:</p> <pre><code>uv sync --frozen\n</code></pre>"},{"location":"api/reproduction/#2-training-phase","title":"2. Training Phase","text":"<p>Run the training script using the exact parameters retrieved from WandB's \"Reproduce run\" page or from a downloaded <code>_metadata.yaml</code> file:</p> <pre><code>uv run python scripts/train.py experiment=my_experiment ppo.learning_rate=0.001 experiment.seed=42\n</code></pre>"},{"location":"api/reproduction/#evaluation-phases","title":"Evaluation Phases","text":"<p>Reproducing our evaluation results is divided into two distinct phases:</p>"},{"location":"api/reproduction/#phase-1-determining-the-best-checkpoint","title":"Phase 1: Determining the Best Checkpoint","text":"<p>During training, checkpoints are saved at regular intervals. To determine which of these checkpoints performed the best:</p> <ol> <li>Evaluate Checkpoints Post-Training:    If checkpoint evaluation was not run during training, scan the completed run's checkpoints folder by pointing to the final model path:</li> </ol> <pre><code>uv run python scripts/evaluate_checkpoints.py simulation.model_path=runs/your_run_dir/final_model.flax\n</code></pre> <p>This script runs deterministic rollouts for every checkpoint in <code>runs/your_run_dir/checkpoints/</code>.</p> <ol> <li>Locate the Results:    The evaluations are saved to:</li> </ol> <pre><code>runs/your_run_dir/metrics/checkpoint_evaluation.csv\n</code></pre> <p>Analyze this CSV to find the checkpoint iteration with the highest average return or target success rate. This checkpoint will be used for cross-architecture comparisons.</p>"},{"location":"api/reproduction/#phase-2-comparing-checkpoints-between-architectures","title":"Phase 2: Comparing Checkpoints Between Architectures","text":"<p>Once the best checkpoints for each architecture are identified, they are compared under shared, standardized environments (including fault tolerance checks such as leg amputations).</p> <ol> <li>Configure the Comparison Models:    Open or create an evaluation config file (e.g., <code>configs/evaluation/poster.yaml</code>) and add the paths to the best checkpoints:</li> </ol> <pre><code># configs/evaluation/poster.yaml\nevaluation:\n  comparison_models:\n    - runs/run_arch_centralized/checkpoints/checkpoint_best.flax\n    - runs/run_arch_decentralized/checkpoints/checkpoint_best.flax\n</code></pre> <ol> <li>Execute the Comparison Script:    Run the comparison script using your config:</li> </ol> <pre><code>uv run python scripts/compare_models.py evaluation=poster\n</code></pre> <p>This script runs multiple sequential evaluation episodes (defined by <code>comparison_num_episodes</code> starting at <code>comparison_base_seed</code>) for every model across the selected morphologies.</p> <ol> <li> <p>Analyze Comparison Metrics:    The script writes a consolidated CSV file to <code>metrics/model_comparison.csv</code> containing:</p> </li> <li> <p><code>eval_return</code>: The cumulative return.</p> </li> <li><code>approx_max_velocity</code>: The distance covered per step.</li> <li><code>reached_target</code>: Navigational success rates.</li> <li><code>arm_0</code> to <code>arm_4</code>: Active segments per arm (indicating damage/amputations).</li> </ol> <p>This CSV can then be passed to the plotting scripts (e.g., <code>scripts/plots/analyze_comparisons.py</code>) to generate visualization plots. For details on configuration and outputs, see the Analysis &amp; Plotting Guide.</p>"},{"location":"api/simulation/","title":"Interactive Simulation &amp; Visualization","text":"<p>The simulation pipeline allows you to visualize trained models and observe their behavior under various conditions.</p>"},{"location":"api/simulation/#overview","title":"Overview","text":"<p>The simulation pipeline is metadata-driven. Training-specific configurations (morphology, arena, environment, etc.) are automatically loaded from the <code>_metadata.yaml</code> file associated with the model checkpoint.</p>"},{"location":"api/simulation/#basic-simulation","title":"Basic Simulation","text":"<p>To simulate a model in the MuJoCo viewer:</p> <pre><code>uv run scripts/simulate.py simulation.model_path=runs/your_run/final_model.flax\n</code></pre>"},{"location":"api/simulation/#amputation-morphology-overrides","title":"Amputation &amp; Morphology Overrides","text":"<p>You can test trained models on different morphologies (e.g., amputating legs) by providing a morphology override. The observations will be automatically padded up to the training morphology's dimensions:</p> <pre><code>uv run scripts/simulate.py \\\n    simulation.model_path=runs/your_run/final_model.flax \\\n    simulation.morphology_override=configs/morphology/3_arms.yaml\n</code></pre>"},{"location":"api/simulation/#video-recording","title":"Video Recording","text":"<p>Recording videos requires the <code>[evaluation]</code> extra:</p> <pre><code>uv run scripts/simulate.py \\\n    simulation.model_path=runs/your_run/final_model.flax \\\n    simulation.record_video=true \\\n    simulation.max_steps=1000\n</code></pre> <p>Videos and evaluation metadata are stored in timestamped folders alongside the model: <code>runs/your_run/final_model_evaluations/eval_&lt;timestamp&gt;/simulation.mp4</code></p>"},{"location":"api/simulation/#top-down-and-follow-cameras","title":"Top-Down and Follow Cameras","text":"<p>Using the following script, you can render a top-down and follow camera view for multiple models at once:</p> <p><pre><code>uv run scripts/poster_visualisations/render_poster_videos.py \\\n  runs/final-models/centralized/.../final_model.flax \\\n  runs/final-models/fully-connected/.../final_model.flax \\\n  runs/final-models/ring/.../final_model.flax \\\n  --max-steps 10000 --width 640 --height 480 --fps 60 \\\n  --output-root vids/poster/\n</code></pre> For batch evaluation, checkpoint analysis, and cross-model architecture comparisons, see the Checkpoint &amp; Model Evaluation Guide.</p>"},{"location":"api/tracking/","title":"Tracking &amp; Monitoring","text":"<p>This guide explains how to monitor your experiments using Weights &amp; Biases (WandB) and TensorBoard.</p>"},{"location":"api/tracking/#weights-biases-wandb","title":"Weights &amp; Biases (WandB)","text":"<p>WandB is used for online synchronization and visualization of training metrics.</p>"},{"location":"api/tracking/#authorization","title":"Authorization","text":"<p>Export your API key in your terminal to enable WandB synchronization:</p> <pre><code>export WANDB_API_KEY=your_copied_api_key_here\n</code></pre> <p>Alternatively, you can log in using the CLI:</p> <pre><code>uv run wandb login\n</code></pre>"},{"location":"api/tracking/#enabling-tracking","title":"Enabling Tracking","text":"<p>To enable online sync during a training run, set <code>logging.track=true</code> on the command line:</p> <pre><code>uv run python scripts/train.py logging.track=true\n</code></pre> <p>You can also configure your project and entity:</p> <pre><code>uv run python scripts/train.py \\\n    logging.track=true \\\n    logging.wandb_project_name=\"MyProject\" \\\n    logging.wandb_entity=\"my-team\"\n</code></pre> <p>These can also be set in your configuration YAML file under the <code>logging</code> key.</p>"},{"location":"api/tracking/#local-monitoring-with-tensorboard","title":"Local Monitoring with TensorBoard","text":"<p>All runs are recorded locally in the <code>runs/</code> directory (or the directory specified in <code>experiment.base_run_dir</code>). You can view scalars and other metrics with TensorBoard:</p> <pre><code>tensorboard --logdir runs/\n</code></pre> <p>Access the interface at http://localhost:6006.</p>"},{"location":"api/tracking/#cli-exploration-tool","title":"CLI Exploration Tool","text":"<p>For quick diagnostics or to export data to CSV without launching the full TensorBoard UI, you can use the <code>explore_tensorboard.py</code> script:</p> <pre><code>uv run python scripts/analysis/explore_tensorboard.py runs/your_run_name/\n</code></pre> <p>See the detailed description in <code>/scripts/analysis/README.md</code>.</p>"},{"location":"api/tracking/#developer-logging-api","title":"Developer Logging API","text":"<p>For details on the developer API of our internal logging library (how backend routing, checkpoint synchronization, and singleton initialization works), see the Experiment Logger API Guide.</p>"},{"location":"api/training/","title":"Training Models","text":"<p>This guide covers how to configure and run training experiments for the Brittle Star project using Hydra-based configurations.</p>"},{"location":"api/training/#configuration","title":"Configuration","text":"<p>The project uses a modular configuration system powered by Hydra. Instead of passing many command-line flags, you select and override configuration groups.</p> <p>For a detailed guide on the structure, validation, and usage of our Hydra configuration files, see the Brittle Star Configuration System Guide.</p>"},{"location":"api/training/#creating-a-custom-experiment","title":"Creating a Custom Experiment","text":"<ol> <li> <p>Create a new experiment file:    Create a file at <code>configs/experiment/my_experiment.yaml</code>. You can copy an existing one as a template:    <pre><code>cp configs/experiment/base.yaml configs/experiment/my_experiment.yaml\n</code></pre></p> </li> <li> <p>Edit <code>configs/experiment/my_experiment.yaml</code> to set your experiment parameters:</p> </li> </ol> <pre><code># @package _global_\nexperiment:\n  exp_name: \"my_custom_run\"\n  seed: 42\n</code></pre>"},{"location":"api/training/#training-execution","title":"Training Execution","text":"<p>To start a training run with the default settings defined in <code>configs/main_config.yaml</code>:</p> <pre><code>uv run python scripts/train.py\n</code></pre>"},{"location":"api/training/#using-a-custom-experiment-configuration","title":"Using a Custom Experiment Configuration","text":"<p>To run with your custom experiment file:</p> <pre><code>uv run python scripts/train.py experiment=my_experiment\n</code></pre> <pre><code>uv run python scripts/train.py ppo.learning_rate=0.001 ppo.num_envs=32 logging.track=true\n</code></pre>"},{"location":"api/training/#evaluation-during-training","title":"Evaluation During Training","text":"<p>By default, the trainer saves checkpoints but does not evaluate them. To enable automatic headless evaluation of every saved checkpoint, set <code>evaluation.evaluate_checkpoints=true</code>:</p> <pre><code>uv run python scripts/train.py evaluation.evaluate_checkpoints=true\n</code></pre>"},{"location":"api/training/#reproducing-experiments","title":"Reproducing Experiments","text":"<p>For detailed steps on how to reproduce training runs, locate run configuration metadata, or reproduce our experiments using Weights &amp; Biases (WandB), see the Results &amp; Reproduction Guide.</p> <p>For more details on evaluation metrics and comparison tools, see Checkpoint &amp; Model Evaluation.</p> <p>For more details on tracking your experiments, see Tracking &amp; Monitoring.</p>"},{"location":"configs/","title":"Brittle Star Configuration System","text":"<p>This project uses Hydra for a modular, hierarchical, and strictly-typed configuration system.</p>"},{"location":"configs/#core-concepts","title":"Core Concepts","text":"<ol> <li>Composition over Inheritance: Instead of one giant config file, the configuration is composed of small, domain-specific modules (PPO settings, architecture, morphology, etc.).</li> <li>Strict Typing: Every configuration is validated against a Python dataclass schema (<code>ConfigStore</code>). Misspelled keys throw a <code>ConfigAttributeError</code> immediately.</li> <li>CLI Swapping: You can swap entire modules or override individual values from the command line without touching code.</li> </ol>"},{"location":"configs/#directory-structure","title":"Directory Structure","text":"<ul> <li><code>main_config.yaml</code>: The root entry point defining the default composition.</li> <li><code>experiment/</code>: High-level experiment settings (seed, device).</li> <li><code>logging/</code>: WandB and checkpointing configuration.</li> <li><code>ppo/</code>: PPO training hyperparameters.</li> <li><code>architecture/</code>: Polymorphic network architectures (centralized vs. decentralized).</li> <li><code>morphology/</code>: Physical robot definitions (number of segments, amputations).</li> <li><code>arena/</code>: Environment physics and visual settings.</li> <li><code>environment/</code>: Task-specific settings (Directed Locomotion, Light Escape).</li> </ul>"},{"location":"configs/#common-commands","title":"Common Commands","text":""},{"location":"configs/#local-debugging","title":"Local Debugging","text":"<p>Run a quick test with minimal iterations: <pre><code>python scripts/train.py experiment=dev_test ppo=fast\n</code></pre></p>"},{"location":"configs/#swapping-architectures-or-morphologies","title":"Swapping Architectures or Morphologies","text":"<p>Test a decentralized controller on a 3-arm robot: <pre><code>python scripts/train.py architecture=decentralized morphology=3_arms\n</code></pre></p>"},{"location":"configs/#hpc-production","title":"HPC Production","text":"<p>Run stable PPO with WandB enabled (HPC submission scripts handle the <code>hydra.run.dir</code> redirection): <pre><code>python scripts/train.py ppo=stable logging=wandb_enabled\n</code></pre></p>"},{"location":"configs/#dry-run-validation","title":"Dry-Run Validation","text":"<p>Check if your configuration is valid without starting the simulation: <pre><code>python scripts/train.py --cfg job\n</code></pre></p>"},{"location":"configs/#developer-notes","title":"Developer Notes","text":"<ul> <li>Adding a new group: Create a subdirectory in <code>configs/</code> and register the new dataclass in <code>src/brittle_star_project/configs/register_configs.py</code>.</li> <li>Typo Catching: If you see a <code>ConfigAttributeError</code>, check for typos in your YAML keys or CLI overrides.</li> <li>Output Redirection: We use <code>experiment.base_run_dir</code> to configure where logs and models are stored (defaults to <code>runs/</code>).</li> <li>To change it locally: <code>python scripts/train.py experiment.base_run_dir=/path/to/custom/dir</code></li> <li>On HPC, ensure this points to a fast scratch storage.</li> </ul>"},{"location":"design/actor-critic/","title":"Actor-Critic Architecture","text":"<p>To process observations into actions, our controllers utilize an Actor-Critic architecture. Because we use Proximal Policy Optimization (PPO), the pipeline fundamentally requires separate networks for the policy (Actor) and the value estimation (Critic).</p> <p>Centralized Architecture (Baseline)</p> <p>This pipeline treats the agent as a single entity and uses standard Proximal Policy Optimization (PPO).</p> <ul> <li>Centralized Actor: Composed of two chained MLPs (Sensor \\(\\rightarrow\\) Motor) passing a hidden state between them. The   centralized sensor receives the concatenated global state vector of all limbs at once and processes it into a hidden   state. The centralized motor receives this hidden state and outputs the joint offsets for all actuators   simultaneously. This is mathematically equivalent to using one large MLP with hidden layers, but splitting makes the   implementation easier by allowing us to reuse the same components for the decentralized modules.</li> <li>Centralized Critic: Composed of two sequential MLPs (Feature Extractor \\(\\rightarrow\\) Critic). Because PPO evaluates   the state-value function, this network only receives the concatenated global state vector (no actions). It outputs a   single scalar estimating the expected future reward for the entire agent.</li> </ul> <p>Our policy and value networks use separate input networks/feature extractors as advised by the SEL3 course assistants and the blog. For continuous actions this should allow better learning at a small cost.</p> <pre><code>graph TD\n    Obs([Global Observation])\n\n    Sens[Sensor]\n    Act[Motor]\n    OutAct([Action Distribution&lt;br/&gt;mean, log_std])\n\n    Feat[Feature extractor]\n    Crit[Critic]\n    OutCrit([Value Estimate&lt;br/&gt;scalar])\n\n    Obs --&gt; Sens\n    Obs --&gt; Feat\n\n    Sens --&gt;|\"Hidden state\"| Act\n    Feat --&gt;|\"Hidden state\"| Crit\n\n    Act --&gt; OutAct\n    Crit --&gt; OutCrit</code></pre> <p>Decentralized Architecture</p> <p>This pipeline utilizes the \"Centralized Training with Decentralized Execution\" principle, specifically the NerveNet-MLP variant.</p> <ul> <li>Decentralized Actor, split into three distinct models:</li> <li>Sensor: A local model at each node. It receives its local state plus the goal vector directly, processing them into     an initial hidden state.</li> <li>Propagator: Nodes synchronously compute and exchange messages with connected neighbors for \\(N\\) steps to update     their hidden states. See communication.md for details.</li> <li>Motor: A local model uses its final updated hidden state to output the joint offset strictly for its own actuator.</li> <li>Centralized Critic: Composed of two sequential MLPs (Feature Extractor \\(\\rightarrow\\) Critic). During training, it   acts globally by taking the concatenated state vectors from all sensors to output a single, global state-value scalar   evaluating the entire agent's pose.</li> </ul> <p>To keep the implementation simple, we should use one critic per node in our architecture, but only a single, global critic for all nodes at once, for the following reasons:</p> <ol> <li>Credit Assignment Problem (Ha, 2017): The MuJoCo simulator provides an overall reward based on the brittle star   movement progression, e.g. total distance travelled. Using an isolated critic for each node in the network would not   allow to determine which local action contributed to the global success. A global critic solves this by evaluating   the combined state of the agent at once.</li> <li>Implementation simplicity: Building a second decentralized message-passing graph for the critic (NerveNet-2) would   require more coding. Using a standard MLP that concatenates all raw input vectors is much easier to program while   mathematically equivalent.</li> </ol> <pre><code>graph TD\n    Obs([Local Observation])\n\n    Sens[Sensor]\n    Prop[Propagator]\n    Feat[Feature extractor]\n\n    Mot[Motor]\n    Crit[Critic]\n\n    OutMot([Action Distribution&lt;br/&gt;mean, log_std])\n    OutCrit([Value Estimate&lt;br/&gt;scalar])\n\n    Obs --&gt; Sens\n    Sens --&gt;|\"Hidden state\"| Prop\n    Obs --&gt; Feat\n\n    Prop --&gt;|\"Hidden state\"| Mot\n\n\n    Feat --&gt;|\"Hidden state\"| Crit\n\n    Mot --&gt; OutMot\n    Crit --&gt; OutCrit\n\n    Prop -.-&gt;|\"message passing\"|Prop</code></pre>"},{"location":"design/actor-critic/#implementation-details-network-depth","title":"Implementation Details (Network Depth)","text":"<p>Inspired by: PPO Implementation Details</p> <p>The MLPs used in both pipelines are defined with specific hidden layer configurations to balance learning capability and computational cost. As of right now, though this might change as we make progress in our experiments, we use:</p> <ul> <li>Input Networks (Sensors &amp; Feature Extractors): These networks map the raw state inputs to internal hidden states.   They are configured as standard dense networks with 2 hidden layers of 64 nodes each (<code>[64, 64]</code>) and utilize <code>tanh</code>   activation functions.</li> <li>Output Networks (Motors, Actors &amp; Critics): The final output models are intentionally kept shallow. The Actor   directly projects the hidden state to a continuous action distribution (<code>mean</code> and <code>log_std</code>) using a single dense   output layer (zero hidden layers) initialized orthogonally. The Critic functions similarly, mapping the hidden   representation to a single scalar value.</li> </ul> <p>Note: For the continuous action distributions outputted by the Motor, we explicitly use <code>mean</code> and <code>log_std</code> as advised by previous research to maintain learning stability.</p> <p>References</p> <ul> <li>Ha, D. (2017, October 29). A Visual Guide to Evolution Strategies. \u5927\u30c8\u30ed \u30fb Machine Learning. https://blog.otoro.net/2017/10/29/visual-evolution-strategies/</li> <li>Schulman, John, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. \u2018Proximal Policy Optimization Algorithms\u2019. arXiv:1707.06347. Preprint, arXiv, 28 August 2017. https://doi.org/10.48550/arXiv.1707.06347.</li> <li>Wang, Tingwu, Renjie Liao, Jimmy Ba, and S. Fidler. \u2018NerveNet: Learning Structured Policy with Graph Neural Networks\u2019. Conference paper presented at International Conference on Learning Representations. 15 February 2018. https://www.semanticscholar.org/paper/NerveNet:-Learning-Structured-Policy-with-Graph-Wang-Liao/249408527106d7595d45dd761dd53c83e5a02613.</li> </ul>"},{"location":"design/communication/","title":"Communication scheme (Message Passing)","text":"<p>Remember our research question:</p> <p>\"What is the impact of different levels of controller modularity on learning speed, coordination, and fault tolerance (e.g. amputations) in brittle-star-like robots trained with Reinforcement Learning?\"</p> <p>To test decentralized modularity (such as arm-level or segment-level controllers), the various modules must be able to communicate with each other to achieve coordinated locomotion. This is accomplished through message passing in a Graph Neural Network (GNN)-like architecture. Two prominent communication styles from the literature are N-step NerveNet (Wang et al., 2018) and bottom-up top-down Shared Modular Policies (Huang et al., 2020).</p> <p>We have chosen to apply one uniform communication style across all modular architectures, specifically opting for N-step NerveNet.</p>"},{"location":"design/communication/#rationale","title":"Rationale","text":"<p>Initially, our idea was to equip arm-level controllers with NerveNet message passing and segment-level controllers with SMP. However, we evaluated that this introduces a threat to the validity of our research question. If we observe differences in performance, it would be impossible to determine whether the variance is caused by the level of modularity, or by the difference in the message passing scheme. To purely compare modularity, the communication scheme style must remain constant.</p> <p>Second, we decided that NerveNet is a better fit for our research. The morphology of our brittle star contains cycles at the decentralized level (e.g., a ring of segments or arms around the body). NerveNet has proven to be robust for arbitrary structures, including graphs with cycles. SMP inherently expects a tree structure for its bottom-up and top-down pass. Applying SMP to a ring structure requires a workaround to break that cycle.</p>"},{"location":"design/communication/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Choosing NerveNet introduces a scalability issue as the morphology grows. In NerveNet, a message advances only one segment or node per propagation step. When dealing with long arms (e.g., &gt; 5 segments), this requires a large number of propagation steps to transmit information from one tip of an arm to another.</p> <p>If we were to use SMP instead - which is possible - the inner states of nodes are shared across the entire graph in just two passes. For very large or long morphologies, this would be much more scalable.</p> <p>By rejecting SMP, we accept that our model might learn slower or require more computational power for highly segmented, extended morphologies.</p> <p>References</p> <ul> <li>Wang, Tingwu, Renjie Liao, Jimmy Ba, and S. Fidler. \u2018NerveNet: Learning Structured Policy with Graph Neural Networks\u2019. Conference paper presented at International Conference on Learning Representations. 15 February 2018. https://www.semanticscholar.org/paper/NerveNet:-Learning-Structured-Policy-with-Graph-Wang-Liao/249408527106d7595d45dd761dd53c83e5a02613.</li> <li>Huang, Wenlong, Igor Mordatch, and Deepak Pathak. \u2018One Policy to Control Them All: Shared Modular Policies for Agent-Agnostic Control\u2019. arXiv:2007.04976. Preprint, arXiv, 9 July 2020. https://doi.org/10.48550/arXiv.2007.04976.</li> </ul>"},{"location":"design/controllers/","title":"Levels of modularity and topology","text":"<p>The brittle star can be controlled at different levels. A monolithic controller processes all inputs and outputs at once, whereas modular controllers divide the brains across the body, inspired by the biology of brittle stars.</p> <p>We define four architectures to compare:</p> <ol> <li>Centralized, monolithic: A single Multi Layer Perceptron per robot that receives all observations and outputs    all actions.</li> <li>Fully connected arm-level: Each arm contains an MLP that processes the inputs for that arm, an MLP that processes    the communicated inner-states, and an MLP that outputs the actions for that arm. One policy for these MLPs is shared    across the arms. The controllers in each arm are connected to each other and form a fully connected graph. There is    no central disk, but the controllers are fully connected.</li> <li>Ring arm-level: Identical setup to the fully connected arm-level, but the controllers are connected in a ring    structure. This setup is considered less centralized than the fully connected graph.</li> <li>Segment-level: Each segment contains the three MLPs discussed above. The base segments, attached to the body,    form a ring structure, with the remaining segments attached as extended \"strings\". Segments can only communicate with    segments that are physically connected to it.</li> </ol>"},{"location":"design/controllers/#rationale","title":"Rationale","text":"<p>To fairly compare decentralized modularity against centralized control, the decentralized models should not be allowed to contain a central organ acting as a bottleneck or coordinator. By removing the central disk in the decentralized models and replacing it with a ring topology, we closely approximate the biological reality of the brittle star and test a decentralized morphology.</p> <p>The fully connected graph functions as an intermediate step in between a fully centralized and a decentralized ring. We use it to test whether our models scale to more complex structures.</p>"},{"location":"design/input_action_spaces/","title":"Input (state) and output (action) spaces","text":"<p>To effectively learn locomotion and navigation, the agent requires a well-defined observation space (inputs) and action space (outputs). The control models map these observations directly to physical movements.</p> <p>Inputs (state space)</p> <p>The observation space provides the agent with its current physical state and its navigational objective. With a decentralized control architecture in mind, we divide these inputs into global and local states.</p> <p>Global inputs, always broadcasted to all nodes:</p> <ul> <li>Vertical orientation/tilt: A single, simplified metric representing the tilt/vertical alignment of the agent's   central body/disk, a.k.a. the deviation from the global Z-axis. Its value is derived from the environment's raw disk   rotation 3D vector \\([roll, pitch, yaw]\\):   $$   tilt = sqrt(roll^2 + pitch^2)   $$</li> <li>Goal vector: A 2D unit vector representing the egocentric direction to the target. A value of \\([1.0, 0.0]\\)   indicates that the target is directly in front of the agent (angle 0).</li> </ul> <p>Local inputs, routed directly to specific nodes:</p> <ul> <li>Joint positions: The current angles of all joints within the morphology.</li> <li>Joint velocities: The current angular velocities of the joints.</li> <li>Joint actuator forces: The physical forces currently exerted at each specific joint.</li> <li>Segment contact: These values indicate whether each physical segment of the agent is currently touching the ground.</li> </ul> <p>Outputs (action space)</p> <p>The action space defines how the agent interacts with the environment.</p> <ul> <li>Joint offsets: absolute target positions (offsets) for the joints, i.e. the exact angle the joint should move to.</li> </ul>"},{"location":"design/input_action_spaces/#normalization-and-scaling","title":"Normalization and Scaling","text":"<p>Both the input (observation) and output (action) spaces are rescaled to the range \\([-1, 1]\\). </p> <p>For the input space, all raw physical values (angles, velocities, forces, distances) are normalized based on their defined physical bounds. If a value exceeds these bounds during simulation, it is clipped to the \\([-1, 1]\\) range.</p> <p>For the output space, the neural network's tanh-activated outputs (which naturally fall in \\([-1, 1]\\)) are linearly mapped to the physical joint limits defined in the robot's morphology.</p>"},{"location":"design/input_action_spaces/#rationale","title":"Rationale","text":"<p>When designing the state space, we must ask: Could a human operator perform this task given only these inputs?</p> <ul> <li>Inclusion of Joint Velocities: Because our control models do not inherently possess memory of previous timesteps,   providing only the joint position is insufficient to determine the direction a limb is currently moving. By   explicitly including joint velocities, the agent can immediately infer momentum and movement direction without   needing to memorize past states.</li> <li>Absolute Joint Offsets: The physical Brittle Star robot relies on servo motors (if we were to build this simulated   robot), which are inherently position-controlled devices. (Continuous rotation servos exist, but they are less   commonly used for joints.) If our network outputted continuous torques (forces), a significant portion of the   reinforcement learning process would be wasted on learning low-level PID control dynamics (i.e., how much force to   apply to hold a position). Abstracting this away forces the learning algorithm to focus entirely on higher-level gait   generation and locomotion.</li> <li>Simplified vertical orientation: We drop the full 3D spatial rotation and angular velocity arrays in favor of a   single vertical orientation metric (tilt). For a brittle star moving accross a flat plane, this metric is sufficient   for the agent to sense if it is losing balance or flipping over.</li> <li>Force representation: We strictly retain the joint actuator forces and drop the more generic actuator force. Forces   that are explicitly tied to individual joints are significantly easier to route into decentralized, local limb nodes,   which is necessary for our message-passing architecture.</li> <li>Goal Vector (Distance + Angle): Providing only the scalar \"distance to the goal\" as an input is akin to blindfolding   the robot and asking it to find a target by playing \"hot or cold.\" By providing a full vector, the agent knows   exactly where the target is relative to its current orientation, allowing for directed and efficient locomotion.</li> </ul> <p>The goal representation is explicitly divided into a directional vector and a scalar distance. Keeping the direction   as a normalized unit vector bounds the values to the \\([-1, 1]\\) range, which stabilizes neural network training.   Providing only a scalar \"distance to the goal\" would force the agent to learning localized searching behaviors (e.g.   random walks or spiraling) to deduce the direction, drastically increasing the difficulty of the learning task.</p> <p>NOTE: We later dropped the \"distance to vector\", switching to only a direction as the input. Our reasoning is   the agent should always move towards the goal (it should not learn to stop at the goal), which allows for this   simplification that decreases the model input size.</p> <p>The environment provides a raw <code>unit_xy_direction_to_target</code> (global), which we transform into a calculated   <code>robot_direction_to_target</code> (egocentric) before passing it to the MLPs. This vector consists of the X and Y   direction, where a value of \\([1.0, 0.0]\\) (mapping to an angle of \\(0\\)) means the robot is facing directly towards the   target. - Contact sensors: Segment contact detects external ground interaction and is biologically vital for timing gait   transitions. - Zero-Centered Rescaling (\\([-1, 1]\\)): Using a zero-centered range is standard best practice for continuous control   tasks. It provides several mathematical and physical advantages:   - Improved Gradient Flow: Neural networks optimize faster when inputs are zero-centered. If all inputs were positive     (e.g., \\([0, 1]\\)), the gradients during backpropagation would be forced to the same sign, causing inefficient     \"zig-zag\" weight updates.   - Meaningful Neutral State: In robotics, \\(0.0\\) naturally represents a resting state (zero velocity, centered     position, no force). In a \\([-1, 1]\\) system, this physical rest maps to a neutral \\(0.0\\) signal in the network.     This also correctly communicaties a \"neutral/dead\" signal for amputated limbs that are padded with \\(0.0\\) values.</p> <p>Specifically, we do not include some available inputs:</p> <ul> <li>Global position: Absolute spatial coordinates can cause the agent to overfit to a specific coordinate frame or map,   rather than learning general, adaptable locomotion strategies.</li> </ul>"},{"location":"design/input_action_spaces/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Alternative state and action formulations include:</p> <ul> <li>Torque-based continuous control: In many continuous control tasks (like standard MuJoCo benchmarks), actions   represent continuous torques applied to joints. While this provides more granular, low-level physical control, it   heavily complicates training and does not align well with the physical reality of servo-driven hardware.</li> <li>Recurrent Neural Networks (RNNs) / Frame Stacking: Instead of explicitly passing velocities in the state space, the   network could infer momentum by observing a history of past states. Using RNNs or frame stacking allows the agent to   build an internal memory of movement. However, this significantly increases architectural complexity and training   time compared to explicitly providing the velocity data.</li> <li>Scalar Goal Distance: Giving the agent only the scalar distance to the target would force it to learn a localized   searching behavior (e.g., spiraling or random walks) to determine the correct direction. While biologically plausible   for simpler organisms following chemical gradients, it drastically increases the difficulty of the learning task.</li> <li>\\([0, 1]\\) Rescaling: While some domains (like computer vision) use \\([0, 1]\\) scaling, it is generally avoided in   robotics. Scaling to \\([0, 1]\\) would mean that a resting joint (velocity = 0) maps to an input of \\(0.5\\). This   constant positive bias forces the network to waste capacity learning to ignore or subtract this baseline signal just   to stand still. Furthermore, it breaks the \"dead signal\" interpretation of zero-padding used for amputations.</li> </ul>"},{"location":"design/input_action_spaces/#mujoco","title":"MuJoCo","text":"<p>This is what the filtered input vectors look like in MuJoCo, with \\(J\\) joints and \\(S\\) segments:</p> <ul> <li><code>joint_position</code>: shape=(J,), dtype=float64</li> <li><code>joint_velocity</code>: shape=(J,), dtype=float64</li> <li><code>joint_actuator_force</code>: shape=(J,), dtype=float64</li> <li><code>segment_contact</code>: shape=(S,), dtype=float64</li> <li><code>robot_direction_to_target</code>: shape=(2,), dtype=float64, egocentric</li> <li><code>disk_z_tilt</code>: shape=(1,), dtype=float64, derived from <code>disk_rotation</code></li> </ul> <p>This brings the entire input space down to \\(3J + S + 4\\) float64's, compared to \\(4J + S + 15\\) float64's for the unfiltered inputs.</p> <p>For reference, these are all the inputs that are available in the MuJoCo environment:</p> <pre><code>obs keys: ['joint_position', 'joint_velocity', 'joint_actuator_force', 'actuator_force', 'disk_position', 'disk_rotation', 'disk_linear_velocity', 'disk_angular_velocity', 'tendon_position', 'tendon_velocity', 'segment_contact', 'unit_xy_direction_to_target', 'xy_distance_to_target']\n\nraw observations dict:\n{'joint_position': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'joint_velocity': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'joint_actuator_force': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'actuator_force': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'disk_position': array([0.  , 0.  , 0.11]),\n 'disk_rotation': (0.0, -0.0, 0.0),\n 'disk_linear_velocity': array([0., 0., 0.]),\n 'disk_angular_velocity': array([0., 0., 0.]),\n 'tendon_position': array([], dtype=float64),\n 'tendon_velocity': array([], dtype=float64),\n 'segment_contact': array([0., 0., 0., 0., 0., 0.]),\n 'unit_xy_direction_to_target': array([-0.95333378, -0.30191837]),\n 'xy_distance_to_target': array([3.])}\n\n(shapes)\njoint_position: shape=(12,), dtype=float64, size=12\njoint_velocity: shape=(12,), dtype=float64, size=12\njoint_actuator_force: shape=(12,), dtype=float64, size=12\nactuator_force: shape=(12,), dtype=float64, size=12\ndisk_position: shape=(3,), dtype=float64, size=3\ndisk_rotation: shape=(3,), dtype=float64, size=3\ndisk_linear_velocity: shape=(3,), dtype=float64, size=3\ndisk_angular_velocity: shape=(3,), dtype=float64, size=3\ntendon_position: shape=(0,), dtype=float64, size=0\ntendon_velocity: shape=(0,), dtype=float64, size=0\nsegment_contact: shape=(6,), dtype=float64, size=6\nxy_distance_to_target: shape=(1,), dtype=float64, size=1\n</code></pre>"},{"location":"design/learning_algorithm/","title":"Reinforcement Learning Algorithm","text":"<p>To control the continuous action space (the joints of the robot) based on sensor data, we require a reliable Reinforcement Learning (RL) algorithm or optimization strategy.</p> <p>We have chosen Proximal Policy Optimization (PPO) (Schulman et al., 2017).</p>"},{"location":"design/learning_algorithm/#rationale","title":"Rationale","text":"<p>PPO is an on-policy algorithm known for its stability and robustness (safe training without excessive variance). More importantly, it requires relatively little hyperparameter tuning compared to other algorithms. Since NerveNet was successfully trained using PPO (Wang et al., 2018), selecting PPO significantly reduces the risk of convergence failures.</p>"},{"location":"design/learning_algorithm/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Alternative learning algorithms include:</p> <ul> <li>Twin Delayed DDPG (Fujimoto et al., 2018): TD3 is a strong off-policy alternative used in the SMP paper (Huang et   al., 2020). It is highly sample-efficient and reportedly excels at zero-shot adaptations. However, this approach would   be more complex and error-prone than with PPO.</li> <li>Evolution strategies (ES): Evolution strategies are useful for optimizing Central Pattern Generators (CPGs), e.g.   CMA-ES, OpenAI-ES. While this method is easier to distribute and parallelize, ES typically scales worse with   exceptionally large observation spaces compared to gradient-based RL methods like PPO.</li> </ul> <p>References</p> <ul> <li>Fujimoto, Scott, Herke Hoof, and David Meger. \u2018Addressing Function Approximation Error in Actor-Critic Methods\u2019. Proceedings of the 35th International Conference on Machine Learning, 3 July 2018, 1587-96. https://proceedings.mlr.press/v80/fujimoto18a.html.</li> <li>Huang, Wenlong, Igor Mordatch, and Deepak Pathak. \u2018One Policy to Control Them All: Shared Modular Policies for Agent-Agnostic Control\u2019. arXiv:2007.04976. Preprint, arXiv, 9 July 2020. https://doi.org/10.48550/arXiv.2007.04976.</li> <li>Schulman, John, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. \u2018Proximal Policy Optimization Algorithms\u2019. arXiv:1707.06347. Preprint, arXiv, 28 August 2017. https://doi.org/10.48550/arXiv.1707.06347.</li> </ul>"},{"location":"design/reward_function/","title":"Reward function and observation space","text":"<p>The robot needs to know whether its movements contribute to the ultimate goal of locomotion towards a target. Sensor inputs must be distributed fairly to guarantee an objective comparison between different architectures.</p> <ul> <li>The distance from the robot to the target and/or the light intensity are treated as global inputs.</li> <li>Positions and joints, which are normalized to floating-point values between 0 and 1, are considered local inputs.</li> <li>The reward function is centered around minimizing the distance to the goal or maximizing the movement towards the goal   within a finite number of timesteps \\(T\\).</li> <li>To motivate efficient movement, the amount of timesteps taken to reach the goal will be used as penalty.</li> <li>An extra penalty based on movement relative to the current step and the previous is used to penalize a movement away from the target.</li> </ul>"},{"location":"design/reward_function/#from-reward-to-ppo","title":"From reward to PPO","text":"<p>The resulting reward is passed to our PPO library. Our critic network (value function) predicts how good our eventual reward will be for the current state, this value is combined with the reward from the reward function to get advantages. These advantages are then used to calculate the losses to update both our critic and actor pipeline.</p>"},{"location":"design/reward_function/#rationale","title":"Rationale","text":"<p>Using a light source (or a gradient) is biologically plausible for many simple organisms. By normalizing all signals between 0 and 1, PPO training is highly stabilized. The timesteps must be finite to reset the environment in a timely manner if the policy gets stuck in a local minimum.</p>"},{"location":"design/reward_function/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Providing global information to all individual decentralized segments can be considered biologically cheating or practically infeasible once the robot would be physically built. Some sensory input cannot be put in each joint, for example.</p> <p>The alternative is to provide the global input to the outermost segments of the arms, or a specific set of segments assigned with this functionality. The network would then have to learn to propagate this signal throughout the body via message passing. While biologically more accurate, this drastically complicates the learning process. We have written this down as potential future research.</p>"},{"location":"scripts/analysis/","title":"Experiment Analysis Tools","text":"<p>This directory contains scripts for post-processing and analyzing experiment results, including TensorBoard logs and saved model weights.</p>"},{"location":"scripts/analysis/#scripts","title":"Scripts","text":""},{"location":"scripts/analysis/#1-explore_tensorboardpy","title":"1. <code>explore_tensorboard.py</code>","text":"<p>A CLI tool to summarize TensorBoard <code>tfevents</code> files without a GUI.</p> <p>Key Features: - Displays last values, min, max, and step counts for all scalar metrics. - Calculates total run duration and estimated completion percentage. - Exports granular scalar data to CSV for analysis in Excel/Pandas.</p> <p>Usage: <pre><code># General usage\npython explore_tensorboard.py &lt;run_directory&gt;\n\n# Exporting data\npython explore_tensorboard.py &lt;run_directory&gt; --csv data.csv\n</code></pre></p> <p>Requirements: - <code>pandas</code> - <code>tensorboard</code> - <code>tensorflow-cpu</code> (or <code>tensorflow</code>)</p>"},{"location":"src/experiment_logger/","title":"Experiment Logger","text":"<p>A standardized, unified interface for logging experiments across multiple backends (WandB, TensorBoard, and Local Disk).</p> <p>This library is designed to be a standalone package that decouples the logging logic from the core training routines in the <code>brittle_star_project</code>.</p>"},{"location":"src/experiment_logger/#quick-start","title":"Quick Start","text":"<p>The recommended way to use the logger is through the <code>get_logger()</code> singleton:</p> <pre><code>from experiment_logger import UnifiedLogger, get_logger\n\n# Initialize at the start of your script (e.g., in train.py)\nlogger = UnifiedLogger(\n    run_name=\"my_experiment_run\",\n    config={\"learning_rate\": 3e-4},\n    project_name=\"MyProject\",\n    base_dir=\"runs\",\n    use_wandb=True\n)\n\n# In other files, retrieve the initialized singleton:\n# logger = get_logger()\n\n# Log metrics (Scalar values, numpy scalars, or JAX types)\nlogger.log({\"loss\": 0.5, \"accuracy\": 0.98}, step=100)\n\n# Standard logging (Mirrored to disk and stdout)\nlogger.info(\"Training started\")\nlogger.warning(\"Learning rate is very high\")\n\n# Save checkpoints (Automatically synced to WandB as artifacts)\nlogger.save_checkpoint(params, step=5000)\n</code></pre>"},{"location":"src/experiment_logger/#logger-classes","title":"Logger Classes","text":""},{"location":"src/experiment_logger/#unifiedlogger","title":"<code>UnifiedLogger</code>","text":"<p>The full suite for production training. It manages: - WandB: Syncs metrics and uploads model checkpoints as artifacts. - TensorBoard: Writes events for local visualization. - Local Disk: Stores metrics in <code>metrics.yaml</code> and textual logs in <code>run.log</code>.</p>"},{"location":"src/experiment_logger/#simplelogger","title":"<code>SimpleLogger</code>","text":"<p>A zero-dependency fallback that uses standard Python <code>print()</code> statements. Use this for standalone testing or minimal environments where you don't need persistent monitoring.</p> <pre><code>from experiment_logger import SimpleLogger\nlogger = SimpleLogger(run_name=\"test_run\")\n</code></pre>"},{"location":"src/experiment_logger/#api-features","title":"API Features","text":""},{"location":"src/experiment_logger/#loggerprogress_bariterable-kwargs","title":"<code>logger.progress_bar(iterable, **kwargs)</code>","text":"<p>A smart wrapper around <code>tqdm</code> that automatically detects its environment.  - Interactive Terminal: Displays a normal progress bar. - Non-Interactive (HPC): Automatically disables the bar to prevent log file bloat in <code>slurm.out</code>.</p>"},{"location":"src/experiment_logger/#loggerlog_non_interactivemsg-str","title":"<code>logger.log_non_interactive(msg: str)</code>","text":"<p>Prints a message only when running in non-interactive environments. Useful for high-level progress tracking (e.g., \"Epoch 5 Complete\") without interactive noise.</p>"},{"location":"src/experiment_logger/#loggersave_checkpointparams-step-prefixcheckpoint","title":"<code>logger.save_checkpoint(params, step, prefix=\"checkpoint\")</code>","text":"<p>Saves model parameters using Flax serialization. - Local Location: <code>runs/&lt;run_name&gt;/checkpoints/</code> - WandB Logic: Automatically uploads the <code>.flax</code> file as a model artifact for lineage tracking.</p>"}]}
\ No newline at end of file
+{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"],"fields":{"title":{"boost":1000.0},"text":{"boost":1.0},"tags":{"boost":1000000.0}}},"docs":[{"location":"","title":"Documentation","text":"<p>Welcome to the Brittle Star project documentation. This codebase contains the implementations and research for the scientific evaluation of controller modularity in brittle-star-like robots trained using Reinforcement Learning.</p> <p>For the core codebase, scripts, and contribution history, visit our GitHub Repository.</p>"},{"location":"#core-requirements-guides","title":"Core Requirements &amp; Guides","text":"<ul> <li>Installation Instructions: Steps to set up your development environment locally or in a devcontainer using <code>uv</code>, including GPU configuration. For High-Performance Computing (HPC) setup details, see the HPC Guide.</li> <li>How to Run Experiments: A complete guide on running training jobs, setting custom hyperparameters, and overriding config options using Hydra.</li> <li>Results &amp; Reproduction: Guide on how to access our public WandB training runs table and reproduce our training and evaluation phases (determining the best checkpoint vs. comparing architectures).</li> <li>Contribution Guidelines: Standards, rules, and best practices for developing and adding code to the repository.</li> <li>Repository Structure: Overview of the directories and files within the codebase.</li> </ul>"},{"location":"#repository-structure","title":"Repository Structure","text":"<pre><code>.\n\u251c\u2500\u2500 configs/                # Hydra configuration files (YAML)\n\u251c\u2500\u2500 docs/                   # Comprehensive documentation and API guides\n\u251c\u2500\u2500 runs/                   # Default output directory for Hydra and training artifacts\n\u251c\u2500\u2500 scripts/                # High-level entrypoints for training, simulation, and evaluation\n\u251c\u2500\u2500 src/\n\u2502   \u251c\u2500\u2500 brittle_star_project/ # Core library and environment logic\n\u2502   \u2502   \u251c\u2500\u2500 evaluation/     # Checkpoint evaluation, rollout logic, and metrics persistence\n\u2502   \u2502   \u2514\u2500\u2500 trainers/       # Training loop implementations (e.g., PPO)\n\u2502   \u2514\u2500\u2500 experiment_logger/  # Standalone logging package\n\u2514\u2500\u2500 tests/                  # Unit and integration tests\n</code></pre>"},{"location":"#design-architecture-design","title":"Design &amp; architecture (<code>/design</code>)","text":"<p>If you are interested in the \"why did you do it like this?\"</p> <ul> <li>Actor-Critic Architecture: Description of the actor-critic pipeline.</li> <li>Communication Scheme: Message propagation, Nerve-Net style.</li> <li>Modularity &amp; Topology: Macroscopic brain topology, centralized, arm-level, segment-level.</li> <li>Input &amp; Action Spaces: Description of the model's input and output.</li> <li>Reinforcement Learning Algorithm: RL techniques, i.e. PPO.</li> <li>Reward Function &amp; Observation Space: Goals, fitness tracking, and reward structures.</li> </ul>"},{"location":"#api-reference-api","title":"API reference (<code>/api</code>)","text":"<p>If you are interested in the \"how do I use it?\"</p> <ul> <li>Brittle Star Environment: MuJoCo environment interaction and configuration.</li> <li>Training Models: How to configure and run experiments.</li> <li>Tracking &amp; Monitoring: Setting up WandB and TensorBoard to monitor runs.</li> <li>Checkpoint &amp; Model Evaluation: Evaluating checkpoints and comparing fault tolerance.</li> <li>Interactive Simulation &amp; Visualization: Visualizing models in the MuJoCo viewer or rendering simulation videos.</li> <li>Analysis &amp; Plotting Tools: Comparing checkpoints and generating plots.</li> <li>Results &amp; Reproduction: Accessing WandB results and running reproduction pipelines.</li> </ul>"},{"location":"CONTRIBUTING/","title":"Contribution Guidelines","text":"<p>This document outlines the contribution protocols for the scientific software engineering project focusing on bio-inspired control architectures for brittle-star-like robots. The primary objective of this project is to produce scientific insight, rather than a commercial product.</p>"},{"location":"CONTRIBUTING/#1-scientific-context-methodology","title":"1. Scientific Context &amp; Methodology","text":"<ul> <li>Research Focus: The goal is to study how controller modularity affects learning speed, coordination, and fault tolerance in brittle-star locomotion.</li> <li>Hypothesis-Driven Design: Clear hypotheses must dictate a structured methodology and rigorous evaluation. All design decisions must be formally documented prior to implementation.</li> <li>Scaffolding Approach: Development must start with simple setups before progressively increasing the complexity of environments and morphologies.</li> <li>Evaluation of Results: Negative results possess scientific validity when thoroughly analyzed. If a controller fails to learn locomotion, providing a comprehensive analysis of the failure is considered a strong scientific contribution.</li> <li>Reproducibility: Contributors must utilize fixed library versions. Configuration systems (such as json, gin, or yaml) must be employed to ensure reproducible runs.</li> </ul>"},{"location":"CONTRIBUTING/#2-clean-code-code-quality","title":"2. Clean Code &amp; Code Quality","text":"<p>Code readability is paramount, as code is read far more frequently than it is written.</p> <ul> <li>Naming Conventions: Variables and functions must utilize consistent, intention-revealing names. A long, descriptive name is strictly preferred over a short name accompanied by a comment.</li> <li>Function Design: Functions must be modular and adhere to the single responsibility principle. Arguments must be minimized, and boolean flag arguments controlling behavior should be avoided.</li> <li>Commenting: Code must document the \"how,\" while comments are strictly reserved for documenting the \"why\". Commented-out code is prohibited and must be deleted via version control.</li> <li>YAGNI: Contributors must adhere to the \"You Aren't Gonna Need It\" (YAGNI) principle and actively avoid premature optimization.</li> <li>Notebooks: Jupyter Notebooks are strictly limited to quick prototyping, tutorials, demonstrations, or post-processing analysis. They are explicitly forbidden for general software development because they discourage modularity.</li> </ul>"},{"location":"CONTRIBUTING/#3-version-control-repository-structure","title":"3. Version Control &amp; Repository Structure","text":"<ul> <li>Git Practices: Commits must be frequent and small. Each commit should relate to exactly one piece of functionality.</li> <li>Branching Strategy: The <code>dev</code> branch serves as the integration branch for pushing and merging code. Only stable releases may be pushed to the <code>main</code> branch.</li> <li>Artifact Management: Data files, trained models, and large datasets must never be committed directly to Git. Git Large File Storage (LFS) must be used for tracking large files. All developers must have <code>git-lfs</code> installed locally (see DEVELOPMENT.md for setup).</li> <li>Repository Layout: The repository must maintain the following core directories: <code>src/</code> for algorithms, <code>env/</code> for MuJoCo wrappers, <code>config/</code> for experiment configurations, <code>experiments/</code> for scripts, <code>docs/</code> for Doxygen or ReadTheDocs documentation, and <code>tests/</code> for unit tests.</li> </ul>"},{"location":"CONTRIBUTING/#4-architecture-tooling","title":"4. Architecture &amp; Tooling","text":"<ul> <li>Algorithms &amp; Frameworks: Proximal Policy Optimization (PPO) is the recommended baseline algorithm. CleanRL should be used as a starting point and adapted for continuous action spaces. All Artificial Neural Network (ANN) controller architectures must be implemented using Flax.</li> <li>Simulation: The simulation environment utilizes a MuJoCo brittle star. XML MuJoCo structures must remain realistic and respect morphological constraints.</li> <li>Experiment Tracking: Weights &amp; Biases (wandb) must be utilized for tracking and logging all experiments.</li> <li>Code Styling: All code must conform to the chosen style guide (Google standard). This is enforced via <code>uv</code> using ruff and pre-commit hooks.</li> </ul>"},{"location":"CONTRIBUTING/#5-ai-assisted-development-code-review","title":"5. AI-Assisted Development &amp; Code Review","text":"<p>This project supports AI-assisted development to enhance productivity, but contributors must take full responsibility for all AI-generated outputs.</p> <ul> <li>Self-Review Requirement: Contributors must thoroughly self-review all AI-assisted code, documentation, and configurations before requesting peer review. This includes verifying correctness, adherence to project standards, scientific validity, and integration with existing code.</li> <li>Quality Standards: AI-generated content must meet the same rigorous standards as manually written code, including proper testing, documentation, and alignment with the scientific methodology outlined in Section 1.</li> <li>Available Skills: This project provides specific AI skills for common tasks (located in <code>.agents/skills/</code>), including linting and testing workflows. Contributors should leverage these skills to maintain consistency and quality.</li> <li>Transparency: When using AI assistance for complex algorithmic decisions or scientific design choices, contributors should document the rationale in commit messages or code comments where appropriate.</li> </ul>"},{"location":"DEVELOPMENT/","title":"Development Guide","text":"<p>This guide outlines how to set up the development environment for this project, prioritizing reproducible builds, environment parity, and cross-hardware compatibility.</p>"},{"location":"DEVELOPMENT/#reproducibility-uv","title":"Reproducibility &amp; uv","text":"<p>This project uses uv to manage dependencies and virtual environments. The <code>uv.lock</code> file is the absolute source of truth for package versions and must always be committed.</p>"},{"location":"DEVELOPMENT/#source-of-truth","title":"Source of Truth","text":"<ul> <li>Never modify <code>uv.lock</code> manually.</li> <li>To add a dependency, run <code>uv add &lt;package&gt;</code>.</li> <li>To update dependencies, run <code>uv lock --upgrade</code>.</li> <li>To sync your environment with the lockfile, run <code>uv sync --frozen</code>.</li> </ul>"},{"location":"DEVELOPMENT/#git-lfs-critical","title":"Git LFS (Critical)","text":"<p>All developers must have Git LFS installed locally. This repository tracks model weights (<code>.pt</code>, <code>.safetensors</code>, etc.), recordings (<code>.mp4</code>), and datasets using Git LFS.</p> <ul> <li>Setup: Run <code>git lfs install</code> after cloning this repository. If you are using the <code>.devcontainer</code> or <code>flake.nix</code>, LFS is typically available automatically.</li> <li>If you clone without LFS installed, run <code>git lfs pull</code> after installation to fetch the actual data files instead of the small pointer files.</li> </ul>"},{"location":"DEVELOPMENT/#devcontainer-setup-recommended","title":"Devcontainer Setup (Recommended)","text":"<p>The devcontainer provides an identical experience to local development but with all system dependencies pre-configured. It automatically detects your hardware (GPU vs CPU) and syncs the appropriate dependencies.</p>"},{"location":"DEVELOPMENT/#prerequisites","title":"Prerequisites","text":"<ul> <li>Docker Desktop or Docker Engine.</li> <li>NVIDIA Container Toolkit (for GPU support).</li> </ul>"},{"location":"DEVELOPMENT/#setup-for-vs-code","title":"Setup for VS Code","text":"<ol> <li>Install the Dev Containers extension.</li> <li>Open the project and click Reopen in Container.</li> <li>On first launch, the <code>post-create.sh</code> script will:</li> <li>Detect if an NVIDIA GPU is available via <code>nvidia-smi</code>.</li> <li>Run <code>uv sync --frozen --extra cuda</code> if a GPU is found.</li> <li>Run <code>uv sync --frozen</code> otherwise.</li> <li>The environment is stored in a named volume for <code>.venv</code> to ensure persistence and performance.</li> </ol>"},{"location":"DEVELOPMENT/#setup-for-jetbrains-ides","title":"Setup for JetBrains IDEs","text":"<ol> <li>The IDE will detect the <code>.devcontainer/devcontainer.json</code> file.</li> <li>The environment is pre-configured to point to <code>/workspaces/project/.venv</code>.</li> <li>The hardware-aware sync will run automatically during container creation.</li> </ol>"},{"location":"DEVELOPMENT/#local-development-alternative","title":"Local Development (Alternative)","text":"<p>If you prefer not to use Docker:</p> <ol> <li>Install uv.</li> <li>Run <code>uv sync --frozen</code> (CPU) or <code>uv sync --frozen --extra cuda</code> (GPU).</li> </ol>"},{"location":"DEVELOPMENT/#hardware-acceleration-jax","title":"Hardware Acceleration (JAX)","text":"<p>Verify your setup by running the JAX initialization test:</p> <pre><code>uv run pytest tests/test_jax_init.py\n</code></pre> <p>In the devcontainer, this will succeed on both CPU and GPU. A <code>GpuDevice</code> is expected if a GPU is detected and the <code>cuda</code> extra was installed.</p>"},{"location":"DEVELOPMENT/#logging-monitoring","title":"Logging &amp; Monitoring","text":"<p>This project uses a unified logging system through the <code>experiment_logger</code> package. </p> <ul> <li>Usage in Code: To use the logger in your scripts, refer to the package README for the API reference.</li> <li>WandB/TensorBoard Setup: For information on how to configure tracking for experiments, see the Tracking &amp; Monitoring API Guide.</li> </ul> <p>The logger automatically detects if it is running in an interactive terminal or a non-interactive environment (like an HPC Slurm job), adjusting progress bars and fallback modes accordingly.</p>"},{"location":"HPC/","title":"HPC Guide","text":"<p>Full documentation: https://docs.hpc.ugent.be/</p>"},{"location":"HPC/#storage-overview","title":"Storage Overview","text":"<ul> <li>Run Outputs: Written to <code>$VSC_SCRATCH</code> during the job (fast I/O) and copied to <code>$VSC_DATA</code> at the end for persistence.</li> <li>Virtual Environments: Managed on <code>$VSC_DATA</code> by mirroring configuration files. This avoids the 3GB home quota without requiring symlinks in the project root.</li> </ul>"},{"location":"HPC/#initial-environment-setup","title":"Initial Environment Setup","text":"<p>Run once after cloning the repository. This script handles all modules, mirroring, and environment synchronization.</p> <pre><code># Option A: Interactive (on a compute node)\nmodule swap cluster/donphan  # Debug cluster (CPU only)\n# OR for GPU clusters:\n# module swap cluster/joltik\n# module swap cluster/accelgor\n# module swap cluster/litleo\n\nqsub -I -l nodes=1:gpus=1  # Only for GPU clusters\ncd \"${PBS_O_WORKDIR}\"\nbash scripts/hpc/install.sh\n\n# Option B: Batch (Run in background)\n# NOTE: GPU clusters (joltik/accelgor/litleo) require -l gpus=1 at runtime\nqsub -l gpus=1 scripts/hpc/install.sh\n</code></pre>"},{"location":"HPC/#production-vs-debug-clusters","title":"Production vs. Debug Clusters","text":"<p>Our scripts are cluster-agnostic and do not have hardcoded GPU requirements. Instead, you must request GPUs at runtime using the <code>-l gpus=1</code> flag when submitting to a production GPU cluster.</p>"},{"location":"HPC/#debugging-donphan","title":"Debugging (Donphan)","text":"<p>The <code>donphan</code> cluster does not support GPUs. Simply run the scripts without extra resource flags: <pre><code>module swap cluster/donphan\nqsub scripts/hpc/train.pbs\n</code></pre></p>"},{"location":"HPC/#production-joltik-accelgor-litleo","title":"Production (Joltik, Accelgor, Litleo)","text":"<p>These clusters provide GPU acceleration and require a GPU request at runtime: <pre><code>module swap cluster/joltik  # or accelgor/litleo\nqsub -l gpus=1 scripts/hpc/train.pbs\n</code></pre></p>"},{"location":"HPC/#interactive-debugging","title":"Interactive Debugging","text":"<p>To activate your environment for interactive work, simply run the same <code>install.sh</code> script.</p> <pre><code>qsub -I -l nodes=1:ppn=4 -l walltime=1:00:00\ncd \"$PBS_O_WORKDIR\"\nbash scripts/hpc/install.sh\n</code></pre>"},{"location":"HPC/#verification-commands","title":"Verification Commands","text":"<p>After installation, run these commands to ensure your environment is set up correctly:</p> <ol> <li> <p>Verify Quota Safety:    <pre><code>ls -d venvs 2&gt;/dev/null &amp;&amp; echo \"FAIL\" || echo \"&gt;&gt;&gt; PASS: Project root is clean.\"\n</code></pre></p> </li> <li> <p>Verify Library Versions (NumPy Fix):    <pre><code>python -c \"import numpy; print(f'NumPy: {numpy.__version__}')\"\n# Expected: 2.x.x (Venv version), not 1.2x (System version)\n</code></pre></p> </li> <li> <p>Verify GPU Access:    <pre><code>python -c \"import torch, jax; print(f'GPU: {torch.cuda.is_available()}'); print(f'JAX: {jax.devices()}')\"\n</code></pre></p> </li> </ol>"},{"location":"HPC/#managing-dependencies","title":"Managing Dependencies","text":"<p><code>env/hpc/requirements.txt</code> is auto-generated from <code>pyproject.toml</code>. To regenerate:</p> <pre><code>uv run scripts/hpc/export_requirements.py\n</code></pre> <p>Modules listed in <code>env/hpc/modules.txt</code> are automatically excluded from the pip requirements to save space and use HPC-optimized binaries.</p>"},{"location":"api/analysis/","title":"Analysis &amp; Plotting Tools","text":"<p>This guide outlines the tools available for analyzing experimental data and generating poster-quality visualizations for the Brittle Star project.</p>"},{"location":"api/analysis/#shared-configuration","title":"Shared Configuration","text":"<p>All plotting scripts share a central configuration in <code>scripts/plots/plot_config.py</code>. This file defines:</p> <ul> <li>Color Palette: A color-blind friendly, high-contrast palette for different architectures.</li> <li>Typography: Consistent font sizes and styles tailored for A0 posters.</li> <li>Markers: Shared visual indicators, such as the \u2605 used for best performers.</li> </ul>"},{"location":"api/analysis/#comparison-visualization","title":"Comparison Visualization","text":"<p>The <code>scripts/plots/analyze_comparisons.py</code> script generates grouped bar charts comparing the performance of different architectures across various morphologies.</p>"},{"location":"api/analysis/#usage","title":"Usage","text":"<p>Run the script from the root of the project, providing the path to your evaluation CSV:</p> <pre><code># Basic usage (saves PNG and SVG to runs/evaluation/plots/)\nuv run python scripts/plots/analyze_comparisons.py path/to/results.csv\n\n# Advanced usage for Figma/Poster integration\nuv run python scripts/plots/analyze_comparisons.py path/to/results.csv \\\n    --output_dir docs/assets/plots/ \\\n    --font_size 30 \\\n    --fig_width 14 \\\n    --fig_height 10\n</code></pre>"},{"location":"api/analysis/#cli-arguments","title":"CLI Arguments","text":"<ul> <li><code>input_csv</code>: (Required) Path to the CSV file containing evaluation results.</li> <li><code>--output_dir</code>, <code>-o</code>: Directory where plots will be saved (default: <code>runs/evaluation/plots</code>).</li> <li><code>--show_titles</code>: Include titles in the plots. Default is False, as titles are typically added natively in design tools like Figma.</li> <li><code>--font_size</code>: Base font size in points (default: 28).</li> <li><code>--fig_width</code> / <code>--fig_height</code>: Physical dimensions of the plot in inches. Match these to your Figma layout to maintain exact font sizes.</li> </ul>"},{"location":"api/analysis/#outputs","title":"Outputs","text":"<p>The script generates four key plots, each saved as both <code>.png</code> and <code>.svg</code>:</p> <ol> <li>Forward Velocity: Grouped bar chart (cm/s).</li> <li>Accumulated Reward: Mean cumulative reward.</li> <li>Success Rate: Target acquisition percentage.</li> <li>Distance Remaining: Navigational accuracy.</li> </ol>"},{"location":"api/analysis/#convergence-analysis","title":"Convergence Analysis","text":"<p>The <code>scripts/plots/analyze_convergence.py</code> script determines the convergence point of training runs.</p>"},{"location":"api/analysis/#usage_1","title":"Usage","text":"<pre><code>uv run python scripts/plots/analyze_convergence.py --output_dir runs/convergence/\n</code></pre>"},{"location":"api/analysis/#configuration","title":"Configuration","text":"<ul> <li>File Mapping: The script uses hardcoded paths in the <code>FILE_MAPPING</code> dictionary. Update these paths to point to your specific run evaluation files.</li> <li>CLI Arguments: Supports the same <code>--show_titles</code>, <code>--font_size</code>, and <code>--fig_width/height</code> flags as the comparison script.</li> </ul>"},{"location":"api/analysis/#outputs_1","title":"Outputs","text":"<p>Generates three plots (PNG &amp; SVG):</p> <ol> <li><code>convergence_comparison</code>: Grouped horizontal bar chart.</li> <li><code>progress_reward_curves</code>: Line plots of reward over time.</li> <li><code>progress_velocity_curves</code>: Line plots of velocity over time.</li> </ol>"},{"location":"api/analysis/#poster-integration-figma","title":"Poster Integration (Figma)","text":""},{"location":"api/analysis/#svg-scaling","title":"SVG &amp; Scaling","text":"<p>We recommend using the SVG outputs for poster design in Figma:</p> <ol> <li>No Resolution Loss: SVGs are vector-based and will remain sharp at any size.</li> <li>Native Text: Text in the SVG imports as native text layers in Figma.</li> <li>Exact Font Matching: To ensure a <code>28pt</code> font in the plot matches a <code>28pt</code> font in your poster, set the <code>--fig_width</code> and <code>--fig_height</code> to match the physical dimensions of the plot box in your Figma layout.</li> <li>Editable: You can \"Ungroup\" the SVG in Figma to manually move labels, adjust colors, or tweak individual bars.</li> </ol>"},{"location":"api/analysis/#image-placeholders","title":"Image Placeholders","text":"<p>The comparison charts include light-gray square placeholders below the X-axis. These are designed as guides; in Figma, you can drop your morphology renders or illustrations directly on top of these squares.</p>"},{"location":"api/environment/","title":"Brittle star environment","text":""},{"location":"api/environment/#creation","title":"Creation","text":"<p>The environment package contains a factory class <code>BrittleStarEnvFactory</code>  that creates instances of the environment/morphologies/... It uses the configuration classes defined in <code>env_config.py</code> to create the instances.</p>"},{"location":"api/environment/#configuration","title":"Configuration","text":"<p>The data classes in <code>env_config</code> have default values as stated in the tutorials.</p> <ul> <li>MorphologyConfig: configuration for the morphology of the brittle star. Contains number of arms, number of segments per arm, and control mode.</li> <li>ArenaConfig: configuration for the arena. Sets the size of the arena, whether to  set the ground floor to sand, attach a target and sizes of the walls.</li> <li>EnvConfig: configuration for the environment. These set shared settings such as camera locations, simulation time and the task.</li> </ul>"},{"location":"api/environment/#backend-and-task-enums","title":"Backend and Task enums","text":"<p>The Backend enum specifies either an MJC or MJX backend.</p> <ul> <li>MJC: runs on CPU</li> <li>MJX: uses jax on the gpu</li> </ul> <p>The Task enum specifies which task to use. 2 items are present:</p> <ul> <li>DIRECTED_LOCOMOTION: move to a target location</li> <li>LIGHT_ESCAPE: situation where the robot must move to a darker location</li> </ul>"},{"location":"api/evaluation/","title":"Checkpoint &amp; Model Evaluation","text":"<p>This guide covers how to evaluate trained brittle star models, with a focus on measuring defect tolerance (amputations) across different controller architectures.</p>"},{"location":"api/evaluation/#checkpoint-evaluation-during-training","title":"Checkpoint Evaluation (During Training)","text":"<p>The <code>PPOTrainer</code> can automatically evaluate every saved checkpoint using the fast MJX backend. This is enabled via configuration.</p>"},{"location":"api/evaluation/#configuration","title":"Configuration","text":"<p>In your experiment config or via CLI: <pre><code>python scripts/train.py evaluation.evaluate_checkpoints=true evaluation.eval_max_steps=5000\n</code></pre></p> <p>Results are saved to <code>runs/&lt;run_dir&gt;/metrics/checkpoint_evaluation.csv</code> and synced to Weights &amp; Biases if enabled.</p>"},{"location":"api/evaluation/#cross-model-fault-tolerance-analysis","title":"Cross-Model &amp; Fault Tolerance Analysis","text":"<p>To measure how well different controllers handle damage (amputations), use <code>scripts/compare_models.py</code>. This script performs a grid search over models x morphologies.</p> <ol> <li>Create or update a YAML file in <code>configs/evaluation</code>.</li> <li>Run the benchmark:</li> </ol> <pre><code>python scripts/compare_models.py evaluation=poster\n</code></pre> <p>The script will evaluate every combination of model and morphology for the specified number of episodes.</p> <p>The results are saved to a CSV (default: <code>metrics/model_comparison.csv</code>).</p>"},{"location":"api/evaluation/#csv-schema","title":"CSV Schema","text":"Column Description <code>model_path</code> Path to the trained weights. <code>architecture</code> The <code>morph_mode</code> of the model (e.g., <code>CENTRALIZED</code>, <code>RING</code>). <code>arm_0</code> ... <code>arm_4</code> Number of segments in each arm slot (0 = amputated). <code>num_active_arms</code> Total number of arms with segments &gt; 0. <code>seed</code> The episode seed. <code>eval_return</code> Accumulated shaped reward. <code>approx_max_velocity</code> Average velocity: <code>(initial_dist - final_dist) / steps</code>. <code>reached_target</code> Whether the robot finished within the success radius."},{"location":"api/evaluation/#post-hoc-checkpoint-scanning","title":"Post-hoc Checkpoint Scanning","text":"<p>If you need to re-evaluate every saved checkpoint in a run (e.g., to generate a learning curve with different metrics):</p> <pre><code>python scripts/evaluate_checkpoints.py \\\n    simulation.model_path=runs/&lt;run_id&gt;/final_model.flax \\\n    evaluation.eval_max_steps=2000\n</code></pre> <p>This script scans the <code>checkpoints/</code> directory of the specified run and evaluates every <code>.flax</code> file it finds using the model's training morphology.</p> <p>For a step-by-step walkthrough on using these evaluation phases to reproduce our project results, see the Results &amp; Reproduction Guide.</p>"},{"location":"api/reproduction/","title":"Results &amp; Reproduction","text":"<p>This guide explains how to access our official training logs and reproduce our results.</p> <p>Our official training runs, model configurations, and metrics are publicly hosted on Weights &amp; Biases (WandB).</p>"},{"location":"api/reproduction/#weights-biases-wandb-project","title":"Weights &amp; Biases (WandB) Project","text":"<p>All experiments, final models, and training logs are tracked in our public WandB project:</p> <ul> <li>Official Runs Table: WandB final-models-v2 Table</li> </ul> <p>This page lists the verified runs with their architecture types, morphology definitions, evaluation metrics, and final model performance.</p>"},{"location":"api/reproduction/#how-to-reproduce-a-run-from-wandb","title":"How to Reproduce a Run from WandB","text":"<p>Weights &amp; Biases provides a built-in feature to extract the exact parameters and commands used for any given run:</p> <ol> <li>Open the WandB final-models-v2 Table.</li> <li>Click on the name of the run you wish to reproduce to open its detail page.</li> <li>In the top-right corner of the run header (next to the run name, not the main workspace header), click the three dots (<code>...</code>) menu.</li> <li>Select \"Reproduce run\". This will display the exact command-line arguments and configuration settings used to execute that run.</li> </ol>"},{"location":"api/reproduction/#local-hpc-reproduction-workflow","title":"Local &amp; HPC Reproduction Workflow","text":"<p>To reproduce our training and evaluation phases locally or on an HPC cluster, follow the procedures below.</p>"},{"location":"api/reproduction/#1-environment-setup","title":"1. Environment Setup","text":"<p>To ensure identical package versions (including JAX, Flax, and MuJoCo), sync your environment using the lockfile:</p> <pre><code>uv sync --frozen\n</code></pre>"},{"location":"api/reproduction/#2-training-phase","title":"2. Training Phase","text":"<p>Run the training script using the exact parameters retrieved from WandB's \"Reproduce run\" page or from a downloaded <code>_metadata.yaml</code> file:</p> <pre><code>uv run python scripts/train.py experiment=my_experiment ppo.learning_rate=0.001 experiment.seed=42\n</code></pre>"},{"location":"api/reproduction/#evaluation-phases","title":"Evaluation Phases","text":"<p>Reproducing our evaluation results is divided into two distinct phases:</p>"},{"location":"api/reproduction/#phase-1-determining-the-best-checkpoint","title":"Phase 1: Determining the Best Checkpoint","text":"<p>During training, checkpoints are saved at regular intervals. To determine which of these checkpoints performed the best:</p> <ol> <li>Evaluate Checkpoints Post-Training:    If checkpoint evaluation was not run during training, scan the completed run's checkpoints folder by pointing to the final model path:</li> </ol> <pre><code>uv run python scripts/evaluate_checkpoints.py simulation.model_path=runs/your_run_dir/final_model.flax\n</code></pre> <p>This script runs deterministic rollouts for every checkpoint in <code>runs/your_run_dir/checkpoints/</code>.</p> <ol> <li>Locate the Results:    The evaluations are saved to:</li> </ol> <pre><code>runs/your_run_dir/metrics/checkpoint_evaluation.csv\n</code></pre> <p>Analyze this CSV to find the checkpoint iteration with the highest average return or target success rate. This checkpoint will be used for cross-architecture comparisons.</p>"},{"location":"api/reproduction/#phase-2-comparing-checkpoints-between-architectures","title":"Phase 2: Comparing Checkpoints Between Architectures","text":"<p>Once the best checkpoints for each architecture are identified, they are compared under shared, standardized environments (including fault tolerance checks such as leg amputations).</p> <ol> <li>Configure the Comparison Models:    Open or create an evaluation config file (e.g., <code>configs/evaluation/poster.yaml</code>) and add the paths to the best checkpoints:</li> </ol> <pre><code># configs/evaluation/poster.yaml\nevaluation:\n  comparison_models:\n    - runs/run_arch_centralized/checkpoints/checkpoint_best.flax\n    - runs/run_arch_decentralized/checkpoints/checkpoint_best.flax\n</code></pre> <ol> <li>Execute the Comparison Script:    Run the comparison script using your config:</li> </ol> <pre><code>uv run python scripts/compare_models.py evaluation=poster\n</code></pre> <p>This script runs multiple sequential evaluation episodes (defined by <code>comparison_num_episodes</code> starting at <code>comparison_base_seed</code>) for every model across the selected morphologies.</p> <ol> <li> <p>Analyze Comparison Metrics:    The script writes a consolidated CSV file to <code>metrics/model_comparison.csv</code> containing:</p> </li> <li> <p><code>eval_return</code>: The cumulative return.</p> </li> <li><code>approx_max_velocity</code>: The distance covered per step.</li> <li><code>reached_target</code>: Navigational success rates.</li> <li><code>arm_0</code> to <code>arm_4</code>: Active segments per arm (indicating damage/amputations).</li> </ol> <p>This CSV can then be passed to the plotting scripts (e.g., <code>scripts/plots/analyze_comparisons.py</code>) to generate visualization plots. For details on configuration and outputs, see the Analysis &amp; Plotting Guide.</p>"},{"location":"api/simulation/","title":"Interactive Simulation &amp; Visualization","text":"<p>The simulation pipeline allows you to visualize trained models and observe their behavior under various conditions.</p>"},{"location":"api/simulation/#overview","title":"Overview","text":"<p>The simulation pipeline is metadata-driven. Training-specific configurations (morphology, arena, environment, etc.) are automatically loaded from the <code>_metadata.yaml</code> file associated with the model checkpoint.</p>"},{"location":"api/simulation/#basic-simulation","title":"Basic Simulation","text":"<p>To simulate a model in the MuJoCo viewer:</p> <pre><code>uv run scripts/simulate.py simulation.model_path=runs/your_run/final_model.flax\n</code></pre>"},{"location":"api/simulation/#amputation-morphology-overrides","title":"Amputation &amp; Morphology Overrides","text":"<p>You can test trained models on different morphologies (e.g., amputating legs) by providing a morphology override. The observations will be automatically padded up to the training morphology's dimensions:</p> <pre><code>uv run scripts/simulate.py \\\n    simulation.model_path=runs/your_run/final_model.flax \\\n    simulation.morphology_override=configs/morphology/3_arms.yaml\n</code></pre>"},{"location":"api/simulation/#video-recording","title":"Video Recording","text":"<p>Recording videos requires the <code>[evaluation]</code> extra:</p> <pre><code>uv run scripts/simulate.py \\\n    simulation.model_path=runs/your_run/final_model.flax \\\n    simulation.record_video=true \\\n    simulation.max_steps=1000\n</code></pre> <p>Videos and evaluation metadata are stored in timestamped folders alongside the model: <code>runs/your_run/final_model_evaluations/eval_&lt;timestamp&gt;/simulation.mp4</code></p>"},{"location":"api/simulation/#top-down-and-follow-cameras","title":"Top-Down and Follow Cameras","text":"<p>Using the following script, you can render a top-down and follow camera view for multiple models at once:</p> <p><pre><code>uv run scripts/poster_visualisations/render_poster_videos.py \\\n  runs/final-models/centralized/.../final_model.flax \\\n  runs/final-models/fully-connected/.../final_model.flax \\\n  runs/final-models/ring/.../final_model.flax \\\n  --max-steps 10000 --width 640 --height 480 --fps 60 \\\n  --output-root vids/poster/\n</code></pre> For batch evaluation, checkpoint analysis, and cross-model architecture comparisons, see the Checkpoint &amp; Model Evaluation Guide.</p>"},{"location":"api/tracking/","title":"Tracking &amp; Monitoring","text":"<p>This guide explains how to monitor your experiments using Weights &amp; Biases (WandB) and TensorBoard.</p>"},{"location":"api/tracking/#weights-biases-wandb","title":"Weights &amp; Biases (WandB)","text":"<p>WandB is used for online synchronization and visualization of training metrics.</p>"},{"location":"api/tracking/#authorization","title":"Authorization","text":"<p>Export your API key in your terminal to enable WandB synchronization:</p> <pre><code>export WANDB_API_KEY=your_copied_api_key_here\n</code></pre> <p>Alternatively, you can log in using the CLI:</p> <pre><code>uv run wandb login\n</code></pre>"},{"location":"api/tracking/#enabling-tracking","title":"Enabling Tracking","text":"<p>To enable online sync during a training run, set <code>logging.track=true</code> on the command line:</p> <pre><code>uv run python scripts/train.py logging.track=true\n</code></pre> <p>You can also configure your project and entity:</p> <pre><code>uv run python scripts/train.py \\\n    logging.track=true \\\n    logging.wandb_project_name=\"MyProject\" \\\n    logging.wandb_entity=\"my-team\"\n</code></pre> <p>These can also be set in your configuration YAML file under the <code>logging</code> key.</p>"},{"location":"api/tracking/#local-monitoring-with-tensorboard","title":"Local Monitoring with TensorBoard","text":"<p>All runs are recorded locally in the <code>runs/</code> directory (or the directory specified in <code>experiment.base_run_dir</code>). You can view scalars and other metrics with TensorBoard:</p> <pre><code>tensorboard --logdir runs/\n</code></pre> <p>Access the interface at http://localhost:6006.</p>"},{"location":"api/tracking/#cli-exploration-tool","title":"CLI Exploration Tool","text":"<p>For quick diagnostics or to export data to CSV without launching the full TensorBoard UI, you can use the <code>explore_tensorboard.py</code> script:</p> <pre><code>uv run python scripts/analysis/explore_tensorboard.py runs/your_run_name/\n</code></pre> <p>See the detailed description in <code>/scripts/analysis/README.md</code>.</p>"},{"location":"api/tracking/#developer-logging-api","title":"Developer Logging API","text":"<p>For details on the developer API of our internal logging library (how backend routing, checkpoint synchronization, and singleton initialization works), see the Experiment Logger API Guide.</p>"},{"location":"api/training/","title":"Training Models","text":"<p>This guide covers how to configure and run training experiments for the Brittle Star project using Hydra-based configurations.</p>"},{"location":"api/training/#configuration","title":"Configuration","text":"<p>The project uses a modular configuration system powered by Hydra. Instead of passing many command-line flags, you select and override configuration groups.</p> <p>For a detailed guide on the structure, validation, and usage of our Hydra configuration files, see the Brittle Star Configuration System Guide.</p>"},{"location":"api/training/#creating-a-custom-experiment","title":"Creating a Custom Experiment","text":"<ol> <li> <p>Create a new experiment file:    Create a file at <code>configs/experiment/my_experiment.yaml</code>. You can copy an existing one as a template:    <pre><code>cp configs/experiment/base.yaml configs/experiment/my_experiment.yaml\n</code></pre></p> </li> <li> <p>Edit <code>configs/experiment/my_experiment.yaml</code> to set your experiment parameters:</p> </li> </ol> <pre><code># @package _global_\nexperiment:\n  exp_name: \"my_custom_run\"\n  seed: 42\n</code></pre>"},{"location":"api/training/#training-execution","title":"Training Execution","text":"<p>To start a training run with the default settings defined in <code>configs/main_config.yaml</code>:</p> <pre><code>uv run python scripts/train.py\n</code></pre>"},{"location":"api/training/#using-a-custom-experiment-configuration","title":"Using a Custom Experiment Configuration","text":"<p>To run with your custom experiment file:</p> <pre><code>uv run python scripts/train.py experiment=my_experiment\n</code></pre> <pre><code>uv run python scripts/train.py ppo.learning_rate=0.001 ppo.num_envs=32 logging.track=true\n</code></pre>"},{"location":"api/training/#evaluation-during-training","title":"Evaluation During Training","text":"<p>By default, the trainer saves checkpoints but does not evaluate them. To enable automatic headless evaluation of every saved checkpoint, set <code>evaluation.evaluate_checkpoints=true</code>:</p> <pre><code>uv run python scripts/train.py evaluation.evaluate_checkpoints=true\n</code></pre>"},{"location":"api/training/#reproducing-experiments","title":"Reproducing Experiments","text":"<p>For detailed steps on how to reproduce training runs, locate run configuration metadata, or reproduce our experiments using Weights &amp; Biases (WandB), see the Results &amp; Reproduction Guide.</p> <p>For more details on evaluation metrics and comparison tools, see Checkpoint &amp; Model Evaluation.</p> <p>For more details on tracking your experiments, see Tracking &amp; Monitoring.</p>"},{"location":"configs/","title":"Brittle Star Configuration System","text":"<p>This project uses Hydra for a modular, hierarchical, and strictly-typed configuration system.</p>"},{"location":"configs/#core-concepts","title":"Core Concepts","text":"<ol> <li>Composition over Inheritance: Instead of one giant config file, the configuration is composed of small, domain-specific modules (PPO settings, architecture, morphology, etc.).</li> <li>Strict Typing: Every configuration is validated against a Python dataclass schema (<code>ConfigStore</code>). Misspelled keys throw a <code>ConfigAttributeError</code> immediately.</li> <li>CLI Swapping: You can swap entire modules or override individual values from the command line without touching code.</li> </ol>"},{"location":"configs/#directory-structure","title":"Directory Structure","text":"<ul> <li><code>main_config.yaml</code>: The root entry point defining the default composition.</li> <li><code>experiment/</code>: High-level experiment settings (seed, device).</li> <li><code>logging/</code>: WandB and checkpointing configuration.</li> <li><code>ppo/</code>: PPO training hyperparameters.</li> <li><code>architecture/</code>: Polymorphic network architectures (centralized vs. decentralized).</li> <li><code>morphology/</code>: Physical robot definitions (number of segments, amputations).</li> <li><code>arena/</code>: Environment physics and visual settings.</li> <li><code>environment/</code>: Task-specific settings (Directed Locomotion, Light Escape).</li> </ul>"},{"location":"configs/#common-commands","title":"Common Commands","text":""},{"location":"configs/#local-debugging","title":"Local Debugging","text":"<p>Run a quick test with minimal iterations: <pre><code>python scripts/train.py experiment=dev_test ppo=fast\n</code></pre></p>"},{"location":"configs/#swapping-architectures-or-morphologies","title":"Swapping Architectures or Morphologies","text":"<p>Test a decentralized controller on a 3-arm robot: <pre><code>python scripts/train.py architecture=decentralized morphology=3_arms\n</code></pre></p>"},{"location":"configs/#hpc-production","title":"HPC Production","text":"<p>Run stable PPO with WandB enabled (HPC submission scripts handle the <code>hydra.run.dir</code> redirection): <pre><code>python scripts/train.py ppo=stable logging=wandb_enabled\n</code></pre></p>"},{"location":"configs/#dry-run-validation","title":"Dry-Run Validation","text":"<p>Check if your configuration is valid without starting the simulation: <pre><code>python scripts/train.py --cfg job\n</code></pre></p>"},{"location":"configs/#developer-notes","title":"Developer Notes","text":"<ul> <li>Adding a new group: Create a subdirectory in <code>configs/</code> and register the new dataclass in <code>src/brittle_star_project/configs/register_configs.py</code>.</li> <li>Typo Catching: If you see a <code>ConfigAttributeError</code>, check for typos in your YAML keys or CLI overrides.</li> <li>Output Redirection: We use <code>experiment.base_run_dir</code> to configure where logs and models are stored (defaults to <code>runs/</code>).</li> <li>To change it locally: <code>python scripts/train.py experiment.base_run_dir=/path/to/custom/dir</code></li> <li>On HPC, ensure this points to a fast scratch storage.</li> </ul>"},{"location":"design/actor-critic/","title":"Actor-Critic Architecture","text":"<p>To process observations into actions, our controllers utilize an Actor-Critic architecture. Because we use Proximal Policy Optimization (PPO), the pipeline fundamentally requires separate networks for the policy (Actor) and the value estimation (Critic).</p> <p>Centralized Architecture (Baseline)</p> <p>This pipeline treats the agent as a single entity and uses standard Proximal Policy Optimization (PPO).</p> <ul> <li>Centralized Actor: Composed of two chained MLPs (Sensor \\(\\rightarrow\\) Motor) passing a hidden state between them. The   centralized sensor receives the concatenated global state vector of all limbs at once and processes it into a hidden   state. The centralized motor receives this hidden state and outputs the joint offsets for all actuators   simultaneously. This is mathematically equivalent to using one large MLP with hidden layers, but splitting makes the   implementation easier by allowing us to reuse the same components for the decentralized modules.</li> <li>Centralized Critic: Composed of two sequential MLPs (Feature Extractor \\(\\rightarrow\\) Critic). Because PPO evaluates   the state-value function, this network only receives the concatenated global state vector (no actions). It outputs a   single scalar estimating the expected future reward for the entire agent.</li> </ul> <p>Our policy and value networks use separate input networks/feature extractors as advised by the SEL3 course assistants and the blog. For continuous actions this should allow better learning at a small cost.</p> <pre><code>graph TD\n    Obs([Global Observation])\n\n    Sens[Sensor]\n    Act[Motor]\n    OutAct([Action Distribution&lt;br/&gt;mean, log_std])\n\n    Feat[Feature extractor]\n    Crit[Critic]\n    OutCrit([Value Estimate&lt;br/&gt;scalar])\n\n    Obs --&gt; Sens\n    Obs --&gt; Feat\n\n    Sens --&gt;|\"Hidden state\"| Act\n    Feat --&gt;|\"Hidden state\"| Crit\n\n    Act --&gt; OutAct\n    Crit --&gt; OutCrit</code></pre> <p>Decentralized Architecture</p> <p>This pipeline utilizes the \"Centralized Training with Decentralized Execution\" principle, specifically the NerveNet-MLP variant.</p> <ul> <li>Decentralized Actor, split into three distinct models:</li> <li>Sensor: A local model at each node. It receives its local state plus the goal vector directly, processing them into     an initial hidden state.</li> <li>Propagator: Nodes synchronously compute and exchange messages with connected neighbors for \\(N\\) steps to update     their hidden states. See communication.md for details.</li> <li>Motor: A local model uses its final updated hidden state to output the joint offset strictly for its own actuator.</li> <li>Centralized Critic: Composed of two sequential MLPs (Feature Extractor \\(\\rightarrow\\) Critic). During training, it   acts globally by taking the concatenated state vectors from all sensors to output a single, global state-value scalar   evaluating the entire agent's pose.</li> </ul> <p>To keep the implementation simple, we should use one critic per node in our architecture, but only a single, global critic for all nodes at once, for the following reasons:</p> <ol> <li>Credit Assignment Problem (Ha, 2017): The MuJoCo simulator provides an overall reward based on the brittle star   movement progression, e.g. total distance travelled. Using an isolated critic for each node in the network would not   allow to determine which local action contributed to the global success. A global critic solves this by evaluating   the combined state of the agent at once.</li> <li>Implementation simplicity: Building a second decentralized message-passing graph for the critic (NerveNet-2) would   require more coding. Using a standard MLP that concatenates all raw input vectors is much easier to program while   mathematically equivalent.</li> </ol> <pre><code>graph TD\n    Obs([Local Observation])\n\n    Sens[Sensor]\n    Prop[Propagator]\n    Feat[Feature extractor]\n\n    Mot[Motor]\n    Crit[Critic]\n\n    OutMot([Action Distribution&lt;br/&gt;mean, log_std])\n    OutCrit([Value Estimate&lt;br/&gt;scalar])\n\n    Obs --&gt; Sens\n    Sens --&gt;|\"Hidden state\"| Prop\n    Obs --&gt; Feat\n\n    Prop --&gt;|\"Hidden state\"| Mot\n\n\n    Feat --&gt;|\"Hidden state\"| Crit\n\n    Mot --&gt; OutMot\n    Crit --&gt; OutCrit\n\n    Prop -.-&gt;|\"message passing\"|Prop</code></pre>"},{"location":"design/actor-critic/#implementation-details-network-depth","title":"Implementation Details (Network Depth)","text":"<p>Inspired by: PPO Implementation Details</p> <p>The MLPs used in both pipelines are defined with specific hidden layer configurations to balance learning capability and computational cost. As of right now, though this might change as we make progress in our experiments, we use:</p> <ul> <li>Input Networks (Sensors &amp; Feature Extractors): These networks map the raw state inputs to internal hidden states.   They are configured as standard dense networks with 3 hidden layers of 300 nodes each (<code>[300, 300, 300]</code>) and utilize <code>tanh</code>   activation functions.</li> <li>Output Networks (Motors, Actors &amp; Critics): The final output models are intentionally kept shallow. The Actor   directly projects the hidden state to a continuous action distribution (<code>mean</code> and <code>log_std</code>) using a single dense   output layer (zero hidden layers) initialized orthogonally. The Critic functions similarly, mapping the hidden   representation to a single scalar value.</li> </ul> <p>Note: For the continuous action distributions outputted by the Motor, we explicitly use <code>mean</code> and <code>log_std</code> as advised by previous research to maintain learning stability.</p> <p>References</p> <ul> <li>Ha, D. (2017, October 29). A Visual Guide to Evolution Strategies. \u5927\u30c8\u30ed \u30fb Machine Learning. https://blog.otoro.net/2017/10/29/visual-evolution-strategies/</li> <li>Schulman, John, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. \u2018Proximal Policy Optimization Algorithms\u2019. arXiv:1707.06347. Preprint, arXiv, 28 August 2017. https://doi.org/10.48550/arXiv.1707.06347.</li> <li>Wang, Tingwu, Renjie Liao, Jimmy Ba, and S. Fidler. \u2018NerveNet: Learning Structured Policy with Graph Neural Networks\u2019. Conference paper presented at International Conference on Learning Representations. 15 February 2018. https://www.semanticscholar.org/paper/NerveNet:-Learning-Structured-Policy-with-Graph-Wang-Liao/249408527106d7595d45dd761dd53c83e5a02613.</li> </ul>"},{"location":"design/communication/","title":"Communication scheme (Message Passing)","text":"<p>Remember our research question:</p> <p>\"What is the impact of different levels of controller modularity on learning speed, coordination, and fault tolerance (e.g. amputations) in brittle-star-like robots trained with Reinforcement Learning?\"</p> <p>To test decentralized modularity (such as arm-level or segment-level controllers), the various modules must be able to communicate with each other to achieve coordinated locomotion. This is accomplished through message passing in a Graph Neural Network (GNN)-like architecture. Two prominent communication styles from the literature are N-step NerveNet (Wang et al., 2018) and bottom-up top-down Shared Modular Policies (Huang et al., 2020).</p> <p>We have chosen to apply one uniform communication style across all modular architectures, specifically opting for N-step NerveNet.</p>"},{"location":"design/communication/#rationale","title":"Rationale","text":"<p>Initially, our idea was to equip arm-level controllers with NerveNet message passing and segment-level controllers with SMP. However, we evaluated that this introduces a threat to the validity of our research question. If we observe differences in performance, it would be impossible to determine whether the variance is caused by the level of modularity, or by the difference in the message passing scheme. To purely compare modularity, the communication scheme style must remain constant.</p> <p>Second, we decided that NerveNet is a better fit for our research. The morphology of our brittle star contains cycles at the decentralized level (e.g., a ring of segments or arms around the body). NerveNet has proven to be robust for arbitrary structures, including graphs with cycles. SMP inherently expects a tree structure for its bottom-up and top-down pass. Applying SMP to a ring structure requires a workaround to break that cycle.</p>"},{"location":"design/communication/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Choosing NerveNet introduces a scalability issue as the morphology grows. In NerveNet, a message advances only one segment or node per propagation step. When dealing with long arms (e.g., &gt; 5 segments), this requires a large number of propagation steps to transmit information from one tip of an arm to another.</p> <p>If we were to use SMP instead - which is possible - the inner states of nodes are shared across the entire graph in just two passes. For very large or long morphologies, this would be much more scalable.</p> <p>By rejecting SMP, we accept that our model might learn slower or require more computational power for highly segmented, extended morphologies.</p> <p>References</p> <ul> <li>Wang, Tingwu, Renjie Liao, Jimmy Ba, and S. Fidler. \u2018NerveNet: Learning Structured Policy with Graph Neural Networks\u2019. Conference paper presented at International Conference on Learning Representations. 15 February 2018. https://www.semanticscholar.org/paper/NerveNet:-Learning-Structured-Policy-with-Graph-Wang-Liao/249408527106d7595d45dd761dd53c83e5a02613.</li> <li>Huang, Wenlong, Igor Mordatch, and Deepak Pathak. \u2018One Policy to Control Them All: Shared Modular Policies for Agent-Agnostic Control\u2019. arXiv:2007.04976. Preprint, arXiv, 9 July 2020. https://doi.org/10.48550/arXiv.2007.04976.</li> </ul>"},{"location":"design/controllers/","title":"Levels of modularity and topology","text":"<p>The brittle star can be controlled at different levels. A monolithic controller processes all inputs and outputs at once, whereas modular controllers divide the brains across the body, inspired by the biology of brittle stars.</p> <p>We define four architectures to compare:</p> <ol> <li>Centralized, monolithic: A single Multi Layer Perceptron per robot that receives all observations and outputs    all actions.</li> <li>Fully connected arm-level: Each arm contains an MLP that processes the inputs for that arm, an MLP that processes    the communicated inner-states, and an MLP that outputs the actions for that arm. One policy for these MLPs is shared    across the arms. The controllers in each arm are connected to each other and form a fully connected graph. There is    no central disk, but the controllers are fully connected.</li> <li>Ring arm-level: Identical setup to the fully connected arm-level, but the controllers are connected in a ring    structure. This setup is considered less centralized than the fully connected graph.</li> <li>Segment-level: Each segment contains the three MLPs discussed above. The base segments, attached to the body,    form a ring structure, with the remaining segments attached as extended \"strings\". Segments can only communicate with    segments that are physically connected to it.</li> </ol>"},{"location":"design/controllers/#rationale","title":"Rationale","text":"<p>To fairly compare decentralized modularity against centralized control, the decentralized models should not be allowed to contain a central organ acting as a bottleneck or coordinator. By removing the central disk in the decentralized models and replacing it with a ring topology, we closely approximate the biological reality of the brittle star and test a decentralized morphology.</p> <p>The fully connected graph functions as an intermediate step in between a fully centralized and a decentralized ring. We use it to test whether our models scale to more complex structures.</p>"},{"location":"design/input_action_spaces/","title":"Input (state) and output (action) spaces","text":"<p>To effectively learn locomotion and navigation, the agent requires a well-defined observation space (inputs) and action space (outputs). The control models map these observations directly to physical movements.</p> <p>Inputs (state space)</p> <p>The observation space provides the agent with its current physical state and its navigational objective. With a decentralized control architecture in mind, we divide these inputs into global and local states.</p> <p>Global inputs, always broadcasted to all nodes:</p> <ul> <li>Vertical orientation/tilt: A single, simplified metric representing the tilt/vertical alignment of the agent's   central body/disk, a.k.a. the deviation from the global Z-axis. Its value is derived from the environment's raw disk   rotation 3D vector \\([roll, pitch, yaw]\\):   $$   tilt = sqrt(roll^2 + pitch^2)   $$</li> <li>Goal vector: A 2D unit vector representing the egocentric direction to the target. A value of \\([1.0, 0.0]\\)   indicates that the target is directly in front of the agent (angle 0).</li> </ul> <p>Local inputs, routed directly to specific nodes:</p> <ul> <li>Joint positions: The current angles of all joints within the morphology.</li> <li>Joint velocities: The current angular velocities of the joints.</li> <li>Joint actuator forces: The physical forces currently exerted at each specific joint.</li> <li>Segment contact: These values indicate whether each physical segment of the agent is currently touching the ground.</li> </ul> <p>Outputs (action space)</p> <p>The action space defines how the agent interacts with the environment.</p> <ul> <li>Joint offsets: absolute target positions (offsets) for the joints, i.e. the exact angle the joint should move to.</li> </ul>"},{"location":"design/input_action_spaces/#normalization-and-scaling","title":"Normalization and Scaling","text":"<p>Both the input (observation) and output (action) spaces are rescaled to the range \\([-1, 1]\\). </p> <p>For the input space, all raw physical values (angles, velocities, forces, distances) are normalized based on their defined physical bounds. If a value exceeds these bounds during simulation, it is clipped to the \\([-1, 1]\\) range.</p> <p>For the output space, the neural network's tanh-activated outputs (which naturally fall in \\([-1, 1]\\)) are linearly mapped to the physical joint limits defined in the robot's morphology.</p>"},{"location":"design/input_action_spaces/#rationale","title":"Rationale","text":"<p>When designing the state space, we must ask: Could a human operator perform this task given only these inputs?</p> <ul> <li>Inclusion of Joint Velocities: Because our control models do not inherently possess memory of previous timesteps,   providing only the joint position is insufficient to determine the direction a limb is currently moving. By   explicitly including joint velocities, the agent can immediately infer momentum and movement direction without   needing to memorize past states.</li> <li>Absolute Joint Offsets: The physical Brittle Star robot relies on servo motors (if we were to build this simulated   robot), which are inherently position-controlled devices. (Continuous rotation servos exist, but they are less   commonly used for joints.) If our network outputted continuous torques (forces), a significant portion of the   reinforcement learning process would be wasted on learning low-level PID control dynamics (i.e., how much force to   apply to hold a position). Abstracting this away forces the learning algorithm to focus entirely on higher-level gait   generation and locomotion.</li> <li>Simplified vertical orientation: We drop the full 3D spatial rotation and angular velocity arrays in favor of a   single vertical orientation metric (tilt). For a brittle star moving accross a flat plane, this metric is sufficient   for the agent to sense if it is losing balance or flipping over.</li> <li>Force representation: We strictly retain the joint actuator forces and drop the more generic actuator force. Forces   that are explicitly tied to individual joints are significantly easier to route into decentralized, local limb nodes,   which is necessary for our message-passing architecture.</li> <li>Goal Vector (Distance + Angle): Providing only the scalar \"distance to the goal\" as an input is akin to blindfolding   the robot and asking it to find a target by playing \"hot or cold.\" By providing a full vector, the agent knows   exactly where the target is relative to its current orientation, allowing for directed and efficient locomotion.</li> </ul> <p>The goal representation is explicitly divided into a directional vector and a scalar distance. Keeping the direction   as a normalized unit vector bounds the values to the \\([-1, 1]\\) range, which stabilizes neural network training.   Providing only a scalar \"distance to the goal\" would force the agent to learning localized searching behaviors (e.g.   random walks or spiraling) to deduce the direction, drastically increasing the difficulty of the learning task.</p> <p>NOTE: We later dropped the \"distance to vector\", switching to only a direction as the input. Our reasoning is   the agent should always move towards the goal (it should not learn to stop at the goal), which allows for this   simplification that decreases the model input size.</p> <p>The environment provides a raw <code>unit_xy_direction_to_target</code> (global), which we transform into a calculated   <code>robot_direction_to_target</code> (egocentric) before passing it to the MLPs. This vector consists of the X and Y   direction, where a value of \\([1.0, 0.0]\\) (mapping to an angle of \\(0\\)) means the robot is facing directly towards the   target. - Contact sensors: Segment contact detects external ground interaction and is biologically vital for timing gait   transitions. - Zero-Centered Rescaling (\\([-1, 1]\\)): Using a zero-centered range is standard best practice for continuous control   tasks. It provides several mathematical and physical advantages:   - Improved Gradient Flow: Neural networks optimize faster when inputs are zero-centered. If all inputs were positive     (e.g., \\([0, 1]\\)), the gradients during backpropagation would be forced to the same sign, causing inefficient     \"zig-zag\" weight updates.   - Meaningful Neutral State: In robotics, \\(0.0\\) naturally represents a resting state (zero velocity, centered     position, no force). In a \\([-1, 1]\\) system, this physical rest maps to a neutral \\(0.0\\) signal in the network.     This also correctly communicaties a \"neutral/dead\" signal for amputated limbs that are padded with \\(0.0\\) values.</p> <p>Specifically, we do not include some available inputs:</p> <ul> <li>Global position: Absolute spatial coordinates can cause the agent to overfit to a specific coordinate frame or map,   rather than learning general, adaptable locomotion strategies.</li> </ul>"},{"location":"design/input_action_spaces/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Alternative state and action formulations include:</p> <ul> <li>Torque-based continuous control: In many continuous control tasks (like standard MuJoCo benchmarks), actions   represent continuous torques applied to joints. While this provides more granular, low-level physical control, it   heavily complicates training and does not align well with the physical reality of servo-driven hardware.</li> <li>Recurrent Neural Networks (RNNs) / Frame Stacking: Instead of explicitly passing velocities in the state space, the   network could infer momentum by observing a history of past states. Using RNNs or frame stacking allows the agent to   build an internal memory of movement. However, this significantly increases architectural complexity and training   time compared to explicitly providing the velocity data.</li> <li>Scalar Goal Distance: Giving the agent only the scalar distance to the target would force it to learn a localized   searching behavior (e.g., spiraling or random walks) to determine the correct direction. While biologically plausible   for simpler organisms following chemical gradients, it drastically increases the difficulty of the learning task.</li> <li>\\([0, 1]\\) Rescaling: While some domains (like computer vision) use \\([0, 1]\\) scaling, it is generally avoided in   robotics. Scaling to \\([0, 1]\\) would mean that a resting joint (velocity = 0) maps to an input of \\(0.5\\). This   constant positive bias forces the network to waste capacity learning to ignore or subtract this baseline signal just   to stand still. Furthermore, it breaks the \"dead signal\" interpretation of zero-padding used for amputations.</li> </ul>"},{"location":"design/input_action_spaces/#mujoco","title":"MuJoCo","text":"<p>This is what the filtered input vectors look like in MuJoCo, with \\(J\\) joints and \\(S\\) segments:</p> <ul> <li><code>joint_position</code>: shape=(J,), dtype=float64</li> <li><code>joint_velocity</code>: shape=(J,), dtype=float64</li> <li><code>joint_actuator_force</code>: shape=(J,), dtype=float64</li> <li><code>segment_contact</code>: shape=(S,), dtype=float64</li> <li><code>robot_direction_to_target</code>: shape=(2,), dtype=float64, egocentric</li> <li><code>disk_z_tilt</code>: shape=(1,), dtype=float64, derived from <code>disk_rotation</code></li> </ul> <p>This brings the entire input space down to \\(3J + S + 4\\) float64's, compared to \\(4J + S + 15\\) float64's for the unfiltered inputs.</p> <p>For reference, these are all the inputs that are available in the MuJoCo environment:</p> <pre><code>obs keys: ['joint_position', 'joint_velocity', 'joint_actuator_force', 'actuator_force', 'disk_position', 'disk_rotation', 'disk_linear_velocity', 'disk_angular_velocity', 'tendon_position', 'tendon_velocity', 'segment_contact', 'unit_xy_direction_to_target', 'xy_distance_to_target']\n\nraw observations dict:\n{'joint_position': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'joint_velocity': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'joint_actuator_force': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'actuator_force': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n 'disk_position': array([0.  , 0.  , 0.11]),\n 'disk_rotation': (0.0, -0.0, 0.0),\n 'disk_linear_velocity': array([0., 0., 0.]),\n 'disk_angular_velocity': array([0., 0., 0.]),\n 'tendon_position': array([], dtype=float64),\n 'tendon_velocity': array([], dtype=float64),\n 'segment_contact': array([0., 0., 0., 0., 0., 0.]),\n 'unit_xy_direction_to_target': array([-0.95333378, -0.30191837]),\n 'xy_distance_to_target': array([3.])}\n\n(shapes)\njoint_position: shape=(12,), dtype=float64, size=12\njoint_velocity: shape=(12,), dtype=float64, size=12\njoint_actuator_force: shape=(12,), dtype=float64, size=12\nactuator_force: shape=(12,), dtype=float64, size=12\ndisk_position: shape=(3,), dtype=float64, size=3\ndisk_rotation: shape=(3,), dtype=float64, size=3\ndisk_linear_velocity: shape=(3,), dtype=float64, size=3\ndisk_angular_velocity: shape=(3,), dtype=float64, size=3\ntendon_position: shape=(0,), dtype=float64, size=0\ntendon_velocity: shape=(0,), dtype=float64, size=0\nsegment_contact: shape=(6,), dtype=float64, size=6\nxy_distance_to_target: shape=(1,), dtype=float64, size=1\n</code></pre>"},{"location":"design/learning_algorithm/","title":"Reinforcement Learning Algorithm","text":"<p>To control the continuous action space (the joints of the robot) based on sensor data, we require a reliable Reinforcement Learning (RL) algorithm or optimization strategy.</p> <p>We have chosen Proximal Policy Optimization (PPO) (Schulman et al., 2017).</p>"},{"location":"design/learning_algorithm/#rationale","title":"Rationale","text":"<p>PPO is an on-policy algorithm known for its stability and robustness (safe training without excessive variance). More importantly, it requires relatively little hyperparameter tuning compared to other algorithms. Since NerveNet was successfully trained using PPO (Wang et al., 2018), selecting PPO significantly reduces the risk of convergence failures.</p>"},{"location":"design/learning_algorithm/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Alternative learning algorithms include:</p> <ul> <li>Twin Delayed DDPG (Fujimoto et al., 2018): TD3 is a strong off-policy alternative used in the SMP paper (Huang et   al., 2020). It is highly sample-efficient and reportedly excels at zero-shot adaptations. However, this approach would   be more complex and error-prone than with PPO.</li> <li>Evolution strategies (ES): Evolution strategies are useful for optimizing Central Pattern Generators (CPGs), e.g.   CMA-ES, OpenAI-ES. While this method is easier to distribute and parallelize, ES typically scales worse with   exceptionally large observation spaces compared to gradient-based RL methods like PPO.</li> </ul> <p>References</p> <ul> <li>Fujimoto, Scott, Herke Hoof, and David Meger. \u2018Addressing Function Approximation Error in Actor-Critic Methods\u2019. Proceedings of the 35th International Conference on Machine Learning, 3 July 2018, 1587-96. https://proceedings.mlr.press/v80/fujimoto18a.html.</li> <li>Huang, Wenlong, Igor Mordatch, and Deepak Pathak. \u2018One Policy to Control Them All: Shared Modular Policies for Agent-Agnostic Control\u2019. arXiv:2007.04976. Preprint, arXiv, 9 July 2020. https://doi.org/10.48550/arXiv.2007.04976.</li> <li>Schulman, John, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. \u2018Proximal Policy Optimization Algorithms\u2019. arXiv:1707.06347. Preprint, arXiv, 28 August 2017. https://doi.org/10.48550/arXiv.1707.06347.</li> </ul>"},{"location":"design/reward_function/","title":"Reward function and observation space","text":"<p>The robot needs to know whether its movements contribute to the ultimate goal of locomotion towards a target. Sensor inputs must be distributed fairly to guarantee an objective comparison between different architectures.</p> <ul> <li>The distance from the robot to the target and/or the light intensity are treated as global inputs.</li> <li>Positions and joints, which are normalized to floating-point values between 0 and 1, are considered local inputs.</li> <li>The reward function is centered around minimizing the distance to the goal or maximizing the movement towards the goal   within a finite number of timesteps \\(T\\).</li> <li>To motivate efficient movement, the amount of timesteps taken to reach the goal will be used as penalty.</li> <li>An extra penalty based on movement relative to the current step and the previous is used to penalize a movement away from the target.</li> </ul>"},{"location":"design/reward_function/#from-reward-to-ppo","title":"From reward to PPO","text":"<p>The resulting reward is passed to our PPO library. Our critic network (value function) predicts how good our eventual reward will be for the current state, this value is combined with the reward from the reward function to get advantages. These advantages are then used to calculate the losses to update both our critic and actor pipeline.</p>"},{"location":"design/reward_function/#rationale","title":"Rationale","text":"<p>Using a light source (or a gradient) is biologically plausible for many simple organisms. By normalizing all signals between 0 and 1, PPO training is highly stabilized. The timesteps must be finite to reset the environment in a timely manner if the policy gets stuck in a local minimum.</p>"},{"location":"design/reward_function/#limitations-and-alternatives","title":"Limitations and alternatives","text":"<p>Providing global information to all individual decentralized segments can be considered biologically cheating or practically infeasible once the robot would be physically built. Some sensory input cannot be put in each joint, for example.</p> <p>The alternative is to provide the global input to the outermost segments of the arms, or a specific set of segments assigned with this functionality. The network would then have to learn to propagate this signal throughout the body via message passing. While biologically more accurate, this drastically complicates the learning process. We have written this down as potential future research.</p>"},{"location":"scripts/analysis/","title":"Experiment Analysis Tools","text":"<p>This directory contains scripts for post-processing and analyzing experiment results, including TensorBoard logs and saved model weights.</p>"},{"location":"scripts/analysis/#scripts","title":"Scripts","text":""},{"location":"scripts/analysis/#1-explore_tensorboardpy","title":"1. <code>explore_tensorboard.py</code>","text":"<p>A CLI tool to summarize TensorBoard <code>tfevents</code> files without a GUI.</p> <p>Key Features: - Displays last values, min, max, and step counts for all scalar metrics. - Calculates total run duration and estimated completion percentage. - Exports granular scalar data to CSV for analysis in Excel/Pandas.</p> <p>Usage: <pre><code># General usage\npython explore_tensorboard.py &lt;run_directory&gt;\n\n# Exporting data\npython explore_tensorboard.py &lt;run_directory&gt; --csv data.csv\n</code></pre></p> <p>Requirements: - <code>pandas</code> - <code>tensorboard</code> - <code>tensorflow-cpu</code> (or <code>tensorflow</code>)</p>"},{"location":"src/experiment_logger/","title":"Experiment Logger","text":"<p>A standardized, unified interface for logging experiments across multiple backends (WandB, TensorBoard, and Local Disk).</p> <p>This library is designed to be a standalone package that decouples the logging logic from the core training routines in the <code>brittle_star_project</code>.</p>"},{"location":"src/experiment_logger/#quick-start","title":"Quick Start","text":"<p>The recommended way to use the logger is through the <code>get_logger()</code> singleton:</p> <pre><code>from experiment_logger import UnifiedLogger, get_logger\n\n# Initialize at the start of your script (e.g., in train.py)\nlogger = UnifiedLogger(\n    run_name=\"my_experiment_run\",\n    config={\"learning_rate\": 3e-4},\n    project_name=\"MyProject\",\n    base_dir=\"runs\",\n    use_wandb=True\n)\n\n# In other files, retrieve the initialized singleton:\n# logger = get_logger()\n\n# Log metrics (Scalar values, numpy scalars, or JAX types)\nlogger.log({\"loss\": 0.5, \"accuracy\": 0.98}, step=100)\n\n# Standard logging (Mirrored to disk and stdout)\nlogger.info(\"Training started\")\nlogger.warning(\"Learning rate is very high\")\n\n# Save checkpoints (Automatically synced to WandB as artifacts)\nlogger.save_checkpoint(params, step=5000)\n</code></pre>"},{"location":"src/experiment_logger/#logger-classes","title":"Logger Classes","text":""},{"location":"src/experiment_logger/#unifiedlogger","title":"<code>UnifiedLogger</code>","text":"<p>The full suite for production training. It manages: - WandB: Syncs metrics and uploads model checkpoints as artifacts. - TensorBoard: Writes events for local visualization. - Local Disk: Stores metrics in <code>metrics.yaml</code> and textual logs in <code>run.log</code>.</p>"},{"location":"src/experiment_logger/#simplelogger","title":"<code>SimpleLogger</code>","text":"<p>A zero-dependency fallback that uses standard Python <code>print()</code> statements. Use this for standalone testing or minimal environments where you don't need persistent monitoring.</p> <pre><code>from experiment_logger import SimpleLogger\nlogger = SimpleLogger(run_name=\"test_run\")\n</code></pre>"},{"location":"src/experiment_logger/#api-features","title":"API Features","text":""},{"location":"src/experiment_logger/#loggerprogress_bariterable-kwargs","title":"<code>logger.progress_bar(iterable, **kwargs)</code>","text":"<p>A smart wrapper around <code>tqdm</code> that automatically detects its environment.  - Interactive Terminal: Displays a normal progress bar. - Non-Interactive (HPC): Automatically disables the bar to prevent log file bloat in <code>slurm.out</code>.</p>"},{"location":"src/experiment_logger/#loggerlog_non_interactivemsg-str","title":"<code>logger.log_non_interactive(msg: str)</code>","text":"<p>Prints a message only when running in non-interactive environments. Useful for high-level progress tracking (e.g., \"Epoch 5 Complete\") without interactive noise.</p>"},{"location":"src/experiment_logger/#loggersave_checkpointparams-step-prefixcheckpoint","title":"<code>logger.save_checkpoint(params, step, prefix=\"checkpoint\")</code>","text":"<p>Saves model parameters using Flax serialization. - Local Location: <code>runs/&lt;run_name&gt;/checkpoints/</code> - WandB Logic: Automatically uploads the <code>.flax</code> file as a model artifact for lineage tracking.</p>"}]}
\ No newline at end of file