Pith. sign in

REVIEW 3 major objections 3 minor 4 references

KAGE-Bench shows that visual generalization in RL is strongly axis-dependent, with background and photometric shifts collapsing success while agent-appearance shifts remain mild.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

arxiv 2601.14232 v2 pith:DJ4JCGTU submitted 2026-01-20 cs.LG cs.AIcs.CV

KAGE-Bench: Fast Known-Axis Visual Generalization Evaluation for Reinforcement Learning

classification cs.LG cs.AIcs.CV
keywords visual generalizationreinforcement learningdistribution shiftbenchmarkPOMDPinduced policyknown-axis evaluationpixel-based RL
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

KAGE-Bench tries to establish that visual generalization failure in pixel-based RL can be decomposed into known visual axes, and that these axes matter very unequally. The paper builds a 2D platformer, KAGE-Env, where latent dynamics and rewards are fixed and only the renderer changes, so any train-eval gap is attributable to the visual axis being varied. Running a standard PPO-CNN baseline across 34 paired train-evaluation configurations, it finds that background and photometric shifts collapse success rates (53% and 87% success-rate gaps), while agent-appearance shifts are comparatively mild (21% gap). It also proves a formal reduction: a visual shift is exactly an induced policy shift in a shared latent MDP, which justifies evaluating with trajectory-level metrics like distance and success instead of return alone.

Core claim

The paper's central claim is that visual generalization in reinforcement learning should be studied as a known-axis, controlled variation of the observation kernel, and that doing so reveals strong axis-dependence: some visual changes (backgrounds, filters, lighting) cause catastrophic failure of task completion even when forward motion is preserved, while others (agent sprites) are comparatively benign. The formal anchor is Theorem 4.2: for any reactive pixel policy, executing it in a visual POMDP induces the same state-action law as executing the marginalized state policy in the latent MDP; hence the visual train-eval gap is exactly the performance difference between two induced state poli

What carries the argument

The central object is the induced state policy πξ(a|s) = ∫ π(a|o) Oξ(do|s), which marginalizes the renderer's observation distribution over the policy's action distribution. Theorem 4.2 shows that this single construction carries the whole argument: the state-action process under (Mξ, π) equals in law the process under (M, πξ), so return and any trajectory functional are preserved. This reduces visual generalization to policy shift in a fixed latent MDP and justifies the benchmark's axis-isolated pairing protocol.

Load-bearing premise

The 34 train-eval pairs were deliberately chosen from a pilot sweep to 'exhibit a range of generalization behavior,' so the reported axis ordering depends on which pairs were selected; a different set of pairs along the same axes might yield a different ranking.

What would settle it

Train a PPO-CNN on a random sample of many configurations per axis (rather than the curated 34 pairs) and check whether the success-rate ranking by axis (filters worst, agent mild) changes or reverses; if it changes, the axis-dependence claim is an artifact of pair selection.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

Share X LinkedIn Reddit HN

If this is right

  • Because transition dynamics and rewards are fixed across configurations, any gap in KAGE-Bench is attributable to the changed visual axis; no confound from altered task structure remains.
  • Filters and effects show large success-rate gaps (87% and 80%) while distance gaps remain moderate, so return alone can hide catastrophic completion failures; joint reporting of distance, progress, and success is necessary.
  • Training with more visual diversity along an axis reduces the gap (e.g., 3-image backgrounds generalize better than black backgrounds), suggesting that diversity within an axis is a mitigating factor.
  • The induced-policy equivalence means visual generalization can be analyzed as a policy-shift problem in a fixed MDP, enabling standard RL tools to be applied to perception failures.
  • The environment's throughput (up to 33M steps/s on one GPU) makes large-scale axis-wise sweeps practical, supporting reproducible hyperparameter and method comparisons.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The 34 pairs are curated from a pilot sweep of the same PPO-CNN baseline, so the axis ordering (filters worst, agent mild) is partly a function of pair selection; a random sample of pairs per axis could change the ranking.
  • The reduction theorem suggests a diagnostic test: if a policy is augmented with an explicit one-hot visual-axis indicator, its induced state policy should become independent of the axis; measuring the gap after such augmentation could directly test whether representations are axis-invariant.
  • The same factorization could be applied to 3D or manipulation environments, but 'known-axis' isolation is harder to guarantee when rendering pipelines involve lighting, materials, and geometry simultaneously.
  • The preserved-motion-but-collapsed-completion pattern implies that reward shaping that gives small forward-progress bonuses can mask perception failures; in deployment, separate success metrics may be more reliable signals.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 3 minor

Summary. The paper introduces KAGE-Env, a JAX-native 2D platformer with 93 controllable rendering parameters, and KAGE-Bench, a benchmark of 34 train/evaluation configuration pairs grouped into six visual axes (agent appearance, background, distractors, effects, filters, layout). The central formal claim (Theorem 4.2, Appendix A) is that, because transitions P and rewards r are held fixed across visual configurations ξ, any change in expected return or trajectory-level metrics under a visual shift is exactly the difference between the induced state policies πξ and πξ′ in the same latent MDP. Using a PPO-CNN baseline, the authors report a strong axis-dependent ordering of success-rate gaps (filters 86.8%, effects 80.5%, layout 62.8%, background 53.3%, distractors 30.9%, agent 21.1%) and argue that several photometric/lighting shifts preserve forward motion while breaking task completion. The environment reaches up to 33M steps/second on a single GPU, and code is provided.

Significance. If the empirical claims withstand scrutiny, KAGE-Bench would be a useful diagnostic tool for visual generalization in RL: the environment is fast, fully vectorized, and open-source, and the explicit factorization of rendering axes with fixed latent dynamics/rewards is a principled design. The formal reduction in Theorem 4.2 is correct under the stated measurability assumptions; it is, however, an elementary marginalization identity rather than a substantive empirical result. The paper's main contribution is therefore the benchmark infrastructure and the empirical axis-difficulty ranking. That ranking is currently the weakest part of the paper: the pairs were curated from a pilot sweep of the same PPO-CNN baseline, and perturbation magnitudes are not matched across axes, so the observed ordering is partly an artifact of configuration selection rather than a robust property of visual axes. With a revised, pre-registered or magnitude-matched construction, this could become a valuable community benchmark.

major comments (3)
  1. [Section 6, Benchmark construction] The 34 train/evaluation pairs are curated from a pilot sweep using the same PPO-CNN baseline 'to exhibit a range of generalization behavior, including both severe and mild gaps.' This makes the axis-level ranking in Table 1 a property of the selected pairs, not an independent discovery about the visual axes. For example, the agent-appearance pairs are predominantly mild (teal→pink, circle→line, skelet→clown), while the filters pairs include brightness=1, contrast=128, hue_shift=180, and saturation=0. The central claim that 'agent-appearance shifts are comparatively benign' is therefore not established by the data. To support the cross-axis comparison, the authors must either sample pairs per axis without using the baseline's eval performance as a selection criterion, or explicitly reframe the results as characteristics of a curated suite rather than of axes per se. This issue is load-bea
  2. [Table 2 and Section 7] There is no common metric for 'amount of visual change' across axes. The Filters suite uses extreme parameter values (e.g., hue_shift=180, contrast=128, saturation=0) and Effects uses point_light_count=4, while Agent pairs use small local color/shape changes. The differing gaps could reflect perturbation magnitude rather than axis identity. A concrete test would be to add multiple intensity levels per axis (as done in Figure 6 for backgrounds and distractors) and compare axes at matched pixel-space or perceptual distances; without this, the cross-axis ordering (Table 1) is confounded. The paper should either provide such matched comparisons or restrict its conclusions to within-axis dose-response effects.
  3. [Section 6, Evaluation protocol; Tables 1 and 3] The maximum-over-training statistic for all metrics is nonstandard and can overstate achievable performance: taking the maximum over checkpoints separately for train and eval means the reported gap is between two upper envelopes, not between final or fixed-checkpoint policies. The paper should justify this choice with a sensitivity analysis (e.g., comparing final-checkpoint, best-on-train, and best-on-eval results). Additionally, Table 1 reports 'mean±SEM' across configurations, but the Layout axis has N=1, so its SEM is 0.0 and masks the substantial seed variance visible in Table 3 (Layout SR 0.86±0.10). The generalization-gap columns in Tables 1 and 2 have no error bars, making cross-axis comparisons underpowered; per-configuration bootstrap or per-seed gap distributions should be reported.
minor comments (3)
  1. [Table 2 and Appendix D] Typographical inconsistencies: 'vinegrette' should be 'vignette' (Filters row 8), 'fallof' should be 'falloff' (Effects row 2). Also, the paper says '34 train-evaluation configuration pairs'; the count is correct, but the Layout suite contains only one pair, which should be explicitly flagged when discussing axis-level summaries.
  2. [Section 4 and Appendix A] The proof of Theorem 4.2 is correct but somewhat repetitive (steps 1d and 1e repeat the same argument). Consider condensing. Also, the statement in Section 4 that 'any performance difference can be attributed to changes in the observation process' is a direct consequence of fixing P and r; it would be clearer to state this as a design guarantee rather than a discovery.
  3. [Figure 6] The x-axis label 'Step 1e7' is ambiguous; the total training budget is 2.5e7 steps, and the figure appears to show 1.0e7 on the axis. Please make the axis units explicit.

Circularity Check

1 steps flagged

Axis-difficulty ranking is partially constructed by the benchmark's own pair-selection procedure.

specific steps
  1. fitted input called prediction [Section 6, Benchmark construction; Section 7, Results; Table 1]
    "We first conduct a pilot sweep over KAGE-Env’s rendering parameters using a standard PPO-CNN... Based on these results, we curate 34 train–evaluation configuration pairs that exhibit a range of generalization behavior, including both severe and mild gaps."

    The headline empirical finding—'Generalization is strongly axis-dependent' with the ranking filters (86.8%) > effects (80.5%) > layout (62.8%) > background (53.3%) > distractors (30.9%) > agent (21.1%)—is computed on pairs that were explicitly curated from a pilot sweep of the same PPO-CNN baseline to exhibit a range of gaps. The observed range and axis ordering are therefore partly inputs to the benchmark construction rather than independent outputs. Moreover, the selected perturbations are not magnitude-matched across axes (e.g., filters use hue_shift=180, saturation=0, contrast=128, while agent pairs use mild color/sprite changes), so the axis ranking conflates axis identity with perturbation intensity. The conclusion that agent-appearance shifts are 'comparatively benign' is thus force

full rationale

The formal core of the paper—Theorem 4.2 and its appendix proof—is a self-contained marginalization identity: for a fixed reactive pixel policy, the visual POMDP and the induced state policy generate the same latent state–action law. This is not circular; it is a mathematical equivalence proven from the stated definitions, and it does not rely on self-citation or on any fitted value. The throughput results are also independent external measurements. The circularity concern is limited to the empirical axis-difficulty claims. Section 6 states that the 34 train–eval pairs were curated 'based on' a pilot sweep using the same PPO-CNN baseline 'to exhibit a range of generalization behavior.' The paper then presents the resulting spread of gaps as evidence of strong axis-dependence and ranks the axes. Because the benchmark was deliberately constructed to include both severe and mild gaps, the existence of a wide range of gaps is guaranteed by selection rather than discovered. The specific ranking is further confounded by unmatched perturbation magnitudes across axes. This makes the empirical diagnostic partially circular, but the formal reduction and the environment infrastructure remain independent contributions, so the overall circularity score is moderate.

Axiom & Free-Parameter Ledger

4 free parameters · 4 axioms · 0 invented entities

The central derivation is a standard probability identity; the load-bearing assumptions are the invariance of dynamics/rewards across visual configs and the reactive-policy restriction. The benchmark's empirical conclusions rest on hand-chosen reward/horizon/success-threshold parameters and on the specific intensities selected for the 34 pairs.

free parameters (4)
  • reward coefficients α1..α4 (forward_reward_scale=0.2, jump_penalty=10, timestep_penalty=0.1, idle_penalty=5) = 0.2, 10.0, 0.1, 5.0
    Hand-chosen in Code 3; shape the reward so return can mask completion failures, which the paper exploits for its claim that return alone is insufficient.
  • success threshold D (dist_to_success) = 490.0
    Defines binary success; with D=490, several shifts show large SR gaps while distance gaps are small. A smaller threshold would shrink SR gaps.
  • episode length T = 500
    Horizon in Code 3; interaction with D determines whether agents can complete episode under shift.
  • visual shift intensities for eval pairs (e.g., brightness=1, contrast=128, hue_shift=180, pixelate=3) = various
    Hand-picked from pilot sweep; these extreme values drive the observed collapses in Filters/Effects suites.
axioms (4)
  • standard math Tower property and measurability of kernels (Weiss et al., standard probability)
    Used in Appendix A.4 to prove Theorem 4.2.
  • domain assumption P and r are invariant across visual configurations ξ
    Enforced by KAGE-Env construction and the pairing protocol; if violated, attribution of gaps to visual axis fails (Section 3, 4).
  • domain assumption Policies are reactive (memoryless): π(a|o), no recurrent state
    Theorem 4.2 requires marginalizing observations at a single timestep; recurrent policies or frame-stacking could change the induced process logic.
  • domain assumption Each visual axis is independently controllable in the renderer
    The entire known-axis protocol rests on the ability to intervene on one axis at a time while holding ξrest fixed (Section 4, Eq. 9).

reviewed 2026-08-03 · how reviews work

0 comments
Cite this review

Pith. "Pith review of KAGE-Bench: Fast Known-Axis Visual Generalization Evaluation for Reinforcement Learning." pith.science (2026). https://pith.science/paper/DJ4JCGTU

@misc{pith2026260114232,
  author       = {Pith},
  title        = {Pith review of: KAGE-Bench: Fast Known-Axis Visual Generalization Evaluation for Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DJ4JCGTU}},
  note         = {Machine review of arXiv:2601.14232}
}
Share X LinkedIn Reddit HN
read the original abstract

Pixel-based reinforcement learning agents often fail under purely visual distribution shift even when latent dynamics and rewards are unchanged, but existing benchmarks entangle multiple sources of shift and hinder systematic analysis. We introduce KAGE-Env, a JAX-native 2D platformer that factorizes the observation process into independently controllable visual axes while keeping the underlying control problem fixed. By construction, varying a visual axis affects performance only through the induced state-conditional action distribution of a pixel policy, providing a clean abstraction for visual generalization. Building on this environment, we define KAGE-Bench, a benchmark of six known-axis suites comprising 34 train-evaluation configuration pairs that isolate individual visual shifts. Using a standard PPO-CNN baseline, we observe strong axis-dependent failures, with background and photometric shifts often collapsing success, while agent-appearance shifts are comparatively benign. Several shifts preserve forward motion while breaking task completion, showing that return alone can obscure generalization failures. Finally, the fully vectorized JAX implementation enables up to 33M environment steps per second on a single GPU, enabling fast and reproducible sweeps over visual factors. Code: https://avanturist322.github.io/KAGEBench/.

Figures

Figures reproduced from arXiv: 2601.14232 by Aleksandr I. Panov, Alexey K. Kovalev, Daniil Zelezetsky, Egor Cherepanov.

Figure 1
Figure 1. Figure 1: Representative observations from KAGE-Env illus￾trating controlled, known-axis visual variation. Each panel differs along one or more explicitly configurable axes, including background imagery and color, agent appearance and animation, moving distractors, photometric filters, and dynamic lighting ef￾fects, while task semantics and underlying dynamics are held fixed. purely visual distribution shifts, even … view at source ↗
Figure 3
Figure 3. Figure 3: Environment stepping throughput vs. parallelism. Environment stepping throughput (steps per second, higher is bet￾ter) as a function of the number of parallel environments nenvs for KAGE-Env across heterogeneous hardware backends. GPU re￾sults are shown for NVIDIA H100 (80 GB), A100 (80 GB), V100 (32 GB), and T4 (15 GB, Google Colab1 ), with CPU-only results on an Apple M3 Pro laptop. (a) Easy configuratio… view at source ↗
Figure 4
Figure 4. Figure 4: Examples of visual generalization gaps. Success rate for three train–evaluation pairs showing (left) negligible, (middle) moderate, and (right) severe generalization gaps. nation is that standard architectures and objectives exploit spurious visual correlations, such as background textures or color statistics, rather than learning task-relevant invari￾ances (Cobbe et al., 2020; Hansen & Wang, 2021; Stone e… view at source ↗
Figure 5
Figure 5. Figure 5: Induced state policy. The renderer Oξ(· | s) maps a latent state to an observation distribution, and the pixel policy π(· | o) maps observations to actions. Their composition defines πξ(· | s) by marginalizing o. Equivalently, for all s ∈ S the paired renderers satisfy Oξ train (· | s) = O(· | s; ξ train axis , ξrest) and Oξ eval (· | s) = O(· | s; ξ eval axis , ξrest), so the only change in the observatio… view at source ↗
Figure 6
Figure 6. Figure 6: Visual generalization gaps in single-axis shifts. Each panel shows training success rate (blue) and evaluation on pro￾gressively harder visual variants (colored curves). (Left) Back￾grounds: trained on black background, evaluated with cumulative color additions (black → black+white → black+white+red → etc.). (Right) Distractors: trained without distractors, evaluated with increasing numbers of same-as-agen… view at source ↗
Figure 7
Figure 7. Figure 7: Visual generalization gaps in single-axis shifts across all metrics. Each row shows a different metric (Distance, Progress, Return, Success Rate), and each column shows a different axis (Backgrounds, Distractors, Radial light effect). Training performance is shown in blue, evaluation on progressively harder visual variants in colored curves. Backgrounds: trained on black background, evaluated with cumulati… view at source ↗
Figure 8
Figure 8. Figure 8: Agent appearance training metrics for Configs 1–5: covering passed distance, progress, success rate, and episodic return; curves are mean±sem across 10 independent runs. 20 [PITH_FULL_IMAGE:figures/full_fig_p020_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Background-only training metrics for Configs 1–6: showing passed distance, progress, success-once, and episodic return curves that represent mean±sem across 10 independent runs. 21 [PITH_FULL_IMAGE:figures/full_fig_p021_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Background-only training metrics for Configs 7–10: showing passed distance, progress, success-once, and episodic return curves that represent mean±sem across 10 independent runs. 0.0 0.5 1.0 1.5 2.0 2.5 Step 1e7 0 100 200 300 400 500 Passed Distance Train Eval 0.0 0.5 1.0 1.5 2.0 2.5 Step 1e7 0.0 0.2 0.4 0.6 0.8 1.0 Progress Train Eval 0.0 0.5 1.0 1.5 2.0 2.5 Step 1e7 0.0 0.2 0.4 0.6 0.8 1.0 Success Rate … view at source ↗
Figure 11
Figure 11. Figure 11: Layout training metrics for Config 1: plotting passed distance, progress, success rate, and episodic return; traces are mean±sem across 10 independent runs. 22 [PITH_FULL_IMAGE:figures/full_fig_p022_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Distractors training metrics for Configs 1–6: with passed distance, progress, success-once, and episodic return curves; each trace is mean±sem across 10 independent runs. 23 [PITH_FULL_IMAGE:figures/full_fig_p023_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: Effects training metrics for Configs 1–3: showing passed distance, progress, success rate, and episodic return; curves depict mean±sem across 10 independent runs. 0.0 0.5 1.0 1.5 2.0 2.5 Step 1e7 0 100 200 300 400 500 Passed Distance Train Eval 0.0 0.5 1.0 1.5 2.0 2.5 Step 1e7 0.0 0.2 0.4 0.6 0.8 1.0 Progress Train Eval 0.0 0.5 1.0 1.5 2.0 2.5 Step 1e7 0.0 0.2 0.4 0.6 0.8 1.0 Success Rate Train Eval 0.0 0… view at source ↗
Figure 14
Figure 14. Figure 14: Filters training metrics for Configs 1–3: displaying passed distance, progress, success-once, and episodic return; curves show mean±sem across 10 independent runs. 24 [PITH_FULL_IMAGE:figures/full_fig_p024_14.png] view at source ↗
Figure 15
Figure 15. Figure 15: Filters training metrics for Configs 4–9: displaying passed distance, progress, success-once, and episodic return; curves show mean±sem across 10 independent runs. 25 [PITH_FULL_IMAGE:figures/full_fig_p025_15.png] view at source ↗
Figure 16
Figure 16. Figure 16: Global Screen Settings. Representative renders under different screen configurations. YAML parameter: H: 128, W: 128. (a) black (b) cyan (c) lime (d) magenta (e) purple (f) noise [PITH_FULL_IMAGE:figures/full_fig_p026_16.png] view at source ↗
Figure 17
Figure 17. Figure 17: Background Color Modes. Representative renders under different background color configurations. YAML parameter(s): background.mode (color/noise) and background.color names controlling the palette for the color mode. (a) Image 1 (b) Image 2 (c) Image 3 (d) Image 4 (e) Image 5 (f) Image 6 (g) Image 7 (h) Image 8 (i) Image 9 (j) Image 10 (k) Image 11 (l) Image 12 [PITH_FULL_IMAGE:figures/full_fig_p026_17.png] view at source ↗
Figure 18
Figure 18. Figure 18: Background Image Modes. Representative renders under different background image configurations. YAML parameter(s): background.mode: "image", background.image paths. (a) Sprite 1 (b) Sprite 2 (c) Sprite 3 (d) Sprite 4 (e) Sprite 5 (f) Sprite 6 [PITH_FULL_IMAGE:figures/full_fig_p026_18.png] view at source ↗
Figure 19
Figure 19. Figure 19: Agent Sprites. Representative renders showing different agent sprite configurations. YAML parameter(s): character.use sprites: true, character.sprite paths. 26 [PITH_FULL_IMAGE:figures/full_fig_p026_19.png] view at source ↗
Figure 20
Figure 20. Figure 20: Agent Shapes. Representative renders showing different agent shape configurations. YAML parameter(s): character.use shape: true, character.shape types. (a) Coral (b) Green (c) Magenta (d) Navy (e) Red (f) Teal [PITH_FULL_IMAGE:figures/full_fig_p027_20.png] view at source ↗
Figure 21
Figure 21. Figure 21: Agent Colors. Representative renders showing different agent color configurations. YAML parameter(s): character.use shape: true, character.shape colors. (a) NPC Configuration 1 (b) NPC Configuration 2 [PITH_FULL_IMAGE:figures/full_fig_p027_21.png] view at source ↗
Figure 22
Figure 22. Figure 22: NPCs. Representative renders showing different NPC configurations. YAML parameter(s): npc.enabled: true, npc.sprite dir, npc.min npc count, npc.max npc count. (a) Sprite 1 (b) Sprite 2 (c) Sprite 3 (d) Sprite 4 (e) Sprite 5 (f) Sprite 6 [PITH_FULL_IMAGE:figures/full_fig_p027_22.png] view at source ↗
Figure 23
Figure 23. Figure 23: Sticky NPCs. Representative renders showing different sticky NPCs configurations. YAML parameter(s): npc.sticky enabled: true, npc.min sticky count, npc.max sticky count, npc.sticky sprite dirs. (a) Sprite 1 (b) Sprite 2 (c) Sprite 3 (d) Sprite 4 (e) Sprite 5 (f) Sprite 6 [PITH_FULL_IMAGE:figures/full_fig_p027_23.png] view at source ↗
Figure 24
Figure 24. Figure 24: Shape Distractors. Representative renders showing different shape distractors configurations. YAML parameter(s): distractors.enabled: true, distractors.count, distractors.shape types, distractors.shape colors. 27 [PITH_FULL_IMAGE:figures/full_fig_p027_24.png] view at source ↗
Figure 25
Figure 25. Figure 25: Brightness Levels. Representative renders showing different brightness configurations. YAML parameter(s): filters.brightness varied from -1 to 1, with other filters.* held at their base values. (a) 0.1 (b) 0.5 (c) 1 (d) 2 (e) 4 (f) 128 [PITH_FULL_IMAGE:figures/full_fig_p028_25.png] view at source ↗
Figure 26
Figure 26. Figure 26: Contrast Levels. Representative renders showing different contrast configurations. YAML parameter(s): filters.contrast varies from 0.1 to 128 while other filters stay at defaults. (a) 0.5 (b) 0.75 (c) 1 (d) 1.5 (e) 2 [PITH_FULL_IMAGE:figures/full_fig_p028_26.png] view at source ↗
Figure 27
Figure 27. Figure 27: Gamma Levels. Representative renders showing different gamma configurations. YAML parameter(s): filters.gamma is swept from 0.5 to 2.0 (others default). (a) 0 (b) 0.5 (c) 1 (d) 1.5 (e) 2 [PITH_FULL_IMAGE:figures/full_fig_p028_27.png] view at source ↗
Figure 28
Figure 28. Figure 28: Saturation Levels. Representative renders showing different saturation configurations. YAML parameter(s): filters.saturation ranges from 0 to 2 with other filters unchanged. (a) -180 (b) -135 (c) -90 (d) -45 (e) 0 (f) 45 (g) 90 (h) 135 (i) 180 [PITH_FULL_IMAGE:figures/full_fig_p028_28.png] view at source ↗
Figure 29
Figure 29. Figure 29: Hue Shift Levels. Representative renders showing different hue shift configurations. YAML parameter(s): filters.hue shift sweeps through [-180, 180]. 28 [PITH_FULL_IMAGE:figures/full_fig_p028_29.png] view at source ↗
Figure 30
Figure 30. Figure 30: Color Temperature Levels. Representative renders showing different color temperature configurations. YAML parameter(s): filters.color temp is varied between -1 and 1. (a) 0 (b) 1 (c) 5 (d) 10 (e) 100 [PITH_FULL_IMAGE:figures/full_fig_p029_30.png] view at source ↗
Figure 31
Figure 31. Figure 31: Color Jitter Standard Deviation Levels. Representative renders showing different color jitter configurations. This is a stochastic effect, and the jittering changes for each timestep. YAML parameter(s): filters.color jitter std. (a) 0 (b) 1 (c) 10 (d) 50 (e) 100 (f) 200 [PITH_FULL_IMAGE:figures/full_fig_p029_31.png] view at source ↗
Figure 32
Figure 32. Figure 32: Gaussian Noise Standard Deviation Levels. Representative renders showing different gaussian noise configurations. This is a stochastic effect, and the noise changes for each timestep. YAML parameter(s): filters.gaussian noise std ranges from 0 to 200, with other filter noise terms disabled. (a) 1 (b) 2 (c) 3 (d) 4 (e) 5 (f) 6 [PITH_FULL_IMAGE:figures/full_fig_p029_32.png] view at source ↗
Figure 33
Figure 33. Figure 33: Pixelate Factor Levels. Representative renders showing different pixelate factor configurations. YAML parameter(s): filters.pixelate factor steps from 1 to 6 while other filters stay default. (a) 0 (b) 0.5 (c) 1 (d) 2 (e) 5 (f) 10 [PITH_FULL_IMAGE:figures/full_fig_p029_33.png] view at source ↗
Figure 34
Figure 34. Figure 34: Vignette Strength Levels. Representative renders showing different vignette strength configurations. YAML parameter(s): filters.vignette strength is increased from 0 to 10 (others default). 29 [PITH_FULL_IMAGE:figures/full_fig_p029_34.png] view at source ↗
Figure 35
Figure 35. Figure 35: Radial Light Strength Levels. Representative renders showing different radial light strength configurations. YAML parameter(s): filters.radial light strength spans 0 to 2. (a) none (b) vintage (c) retro (d) cyberpunk (e) horror (f) noir [PITH_FULL_IMAGE:figures/full_fig_p030_35.png] view at source ↗
Figure 36
Figure 36. Figure 36: Pop Filter List Presets. Representative renders showing different pop filter preset configurations. YAML parameter(s): filters.pop filter list. (a) 0.1 (b) 0.5 (c) 1 (d) 2 (e) 5 [PITH_FULL_IMAGE:figures/full_fig_p030_36.png] view at source ↗
Figure 37
Figure 37. Figure 37: Point Light Intensity Levels. Representative renders showing different point light intensity configurations. YAML parameter(s): effects.point light enabled: true, effects.point light intensity varies from 0.1 to 5. (a) 0.01 (b) 0.1 (c) 0.2 (d) 0.5 (e) 1 [PITH_FULL_IMAGE:figures/full_fig_p030_37.png] view at source ↗
Figure 38
Figure 38. Figure 38: Point Light Radius Levels. Representative renders showing different point light radius configurations. YAML parameter(s): effects.point light radius sweeps from 0.01 to 1 (others fixed). 30 [PITH_FULL_IMAGE:figures/full_fig_p030_38.png] view at source ↗
Figure 39
Figure 39. Figure 39: Point Light Falloff Levels. Representative renders showing different point light falloff configurations. YAML parameter(s): effects.point light falloff varies between 1 and 4. (a) 1 (b) 2 (c) 3 (d) 4 (e) 5 [PITH_FULL_IMAGE:figures/full_fig_p031_39.png] view at source ↗
Figure 40
Figure 40. Figure 40: Point Light Count Levels. Representative renders showing different point light count configurations. YAML parameter(s): effects.point light count increases from 1 to 5. (a) gold (b) warm white (c) red (d) green (e) blue (f) fire [PITH_FULL_IMAGE:figures/full_fig_p031_40.png] view at source ↗
Figure 41
Figure 41. Figure 41: Point Light Color Names. Representative renders showing different point light color configurations. YAML parameter(s): effects.point light color names lists the named lights (gold, warm white, red, green, blue, fire). (a) cyan (b) yellow (c) red (d) green (e) pink (f) lime [PITH_FULL_IMAGE:figures/full_fig_p031_41.png] view at source ↗
Figure 42
Figure 42. Figure 42: Layout Colors. Representative renders showing different layout color configurations. YAML parameter(s): layout.layout colors selects the per-level palette. 31 [PITH_FULL_IMAGE:figures/full_fig_p031_42.png] view at source ↗
Figure 43
Figure 43. Figure 43: Background palette used in KAGE-Bench experiments (128 unique scenes). Images are 128×128 pixels and located in src/kage bench/assets/backgrounds. 32 [PITH_FULL_IMAGE:figures/full_fig_p032_43.png] view at source ↗
Figure 44
Figure 44. Figure 44: Representative idle states for each of the 27 animated agent sprites used in KAGE-Env. By default, sprite bounding box is 24×16 pixels. Sprites are located in src/kage bench/assets/sprites. 33 [PITH_FULL_IMAGE:figures/full_fig_p033_44.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

4 extracted references · 1 linked inside Pith

  1. [1]

    (Conditional action law.) For every timet≥0and every measurable action setB∈ A, PMξ,π(at ∈B|s t) =π ξ(B|s t)a.s.(12) That is, after conditioning on the latent state, the intermediate observation variable can be integrated out and the resulting action distribution is exactlyπ ξ(· |st)

  2. [2]

    (Equality in law of state–action processes.) The state–action process (st, at)t≥0 induced by executing π in Mξ has the same law as the state–action process induced by executingπ ξ in the latent MDPM

  3. [3]

    averaging over renderings

    (Return equivalence.) Consequently, the expected discounted return is preserved: J(π;M ξ) =J(π ξ;M), J(π;M ξ) :=E Mξ,π h ∞X t=0 γtr(st, at) i .(13) A.4. Proof of Theorem A.4 Step 0 (Generative dynamics in Mξ).By definition of the POMDP Mξ (Definition A.3) and the reactive policy π, the interaction at timetis:    ot ∼O ξ(· |st) at ∼π(· |ot) st+1 ∼P(· ...

  4. [1289]

    Cobbe, K., Hesse, C., Hilton, J., and Schulman, J

    PMLR, 2019. Cobbe, K., Hesse, C., Hilton, J., and Schulman, J. Lever- aging procedural generation to benchmark reinforcement learning. InInternational conference on machine learn- ing, pp. 2048–2056. PMLR, 2020. Cobbe, K. W., Hilton, J., Klimov, O., and Schulman, J. Phasic policy gradient. InInternational Conference on Machine Learning, pp. 2020–2027. PML...

This paper was first reviewed by deepseek-v4-flash on August 3, 2026.