Robust Recurrent Reinforcement Learning under Evolving Hidden Disturbances with Application to Rover Wheel Slip

In plain words

A controller that cannot see everything that affects its robot has to guess the hidden part from what it has seen recently. Here the hidden part is how slippery each wheel is, and the controller only sees how far the robot's speed and turning are off target. The question is what the controller should remember: only what it saw, or also what it commanded. Commands matter because the same command can produce different results depending on the hidden slip.

The paper tests several memory layouts on a recurrent version of a standard continuous-control learner, TD3, and checks how much history is worth keeping. It also proposes a shortcut: the critic (the part that scores actions) reuses the memory state already computed by the actor (the part that picks actions), so the same history is not processed twice.

The layouts are tested on simple pendulum tasks with artificial disturbances and then on a simulated rover that loses traction on its wheels. The point is practical guidance for building agents that work when part of the world is hidden and changes over time.

TL;DR

• Recurrent TD3 agents under hidden, evolving disturbances; the paper compares what history to feed (observations, actions, window length) and how to wire the LSTM §4 §5 §6.
• Including past actions helps most when the observed response depends on earlier commands §5.3.
• One LSTM over a single, unified observation-action sequence beats two separate input branches; H-TD3 lets the critic start from the actor's LSTM state §6.2 §6.3.
• Rover result (author-reported): the 1ha1hc variant holds up best under unseen wheel-slip dynamics tab. 3. No training hyperparameter values (learning rate, discount, and similar) are given.

Problem

Partially observable control needs a memory of past inputs and outputs, since the current observation alone does not reveal the hidden state §1 §4.3. Most recurrent RL work feeds only observations, and it is not well studied which history to keep, how long it should be, or how to structure the network §1. In off-policy TD3, the actor and both critics each run the same recurrent history separately, which costs compute as the window grows. Sharing the whole recurrent encoder between actor and critic has been reported to hurt learning §1 §2.

The paper assumes the disturbance is temporally correlated or structured, so that past actions and their observed effects carry information about it §4.2 §8.1. Two kinds of disturbance are studied: ones with dynamics that can be inferred from history, and uncorrelated noise, which the paper argues requires removing the disturbance rather than modelling it §4.2 §5.2.

Method

Setting. The agent is a TD3 actor-critic with recurrent layers §3 tab. 4. Training uses fixed-length sub-trajectories of length l sampled from the replay buffer, not full episodes, to keep samples decorrelated and to save compute §5.1 §3. The paper sweeps l \in \{1, 3, 6, 10, 20\} §7.1.

Architectures compared.

1. LSTM-TD3 (baseline, from Meng et al.). Two input channels. The first takes the past window of observations and actions from memory; the second takes the current observation (and, for the critic, the current action) §3. The paper also trains a variant without past actions in the first channel; for that variant the window holds l-1 past observations §5.2.
2. LSTM-TD3_{1ha1hc} (one head actor, one head critic). The actor has one input channel. The LSTM reads one sequence of observations up to o_t and actions up to a_{t-1} §6.2. The critic reads one sequence that also includes the current action a_t §6.2 tab. 4. This variant is the most robust in the benchmarks §7.2 and in the rover test tab. 3.
3. LSTM-TD3_{1ha2hc} (one head actor, two head critic). Same actor. The critic has a second branch that embeds the current action a_t and concatenates it with the LSTM output before the last two layers §6.2 tab. 4.
4. H-TD3. The actor and the behaviour policy are the same network. When the actor runs during exploration, the LSTM hidden state h and cell state c are stored in the replay buffer with each transition §6.3. The critic is a one-step LSTM that starts from the stored states, so the critic does not reprocess the window. The paper's stated reason is that the critic would otherwise process the history again §6.3 §7.2.

Actor and critic in H-TD3. Pseudocode for the critic update, as described in §6.3. Learning rate, discount and target-update rate are not stated.

# H-TD3 critic update, reusing the actor's LSTM states  [§6.3]
# Each replay tuple also holds (h, c): the LSTM states the behaviour actor
# produced over the window that ends one step before t  [§6.3]

def critic_update(batch):
    # Critic input is only the current pair (a_t, o_t); the LSTM starts
    # from the stored states, so the window is not reprocessed  [§6.3]
    q_values = [
        critic_k(batch.obs, batch.act, batch.h_prev, batch.c_prev)
        for critic_k in critics   # two critics, as in TD3  [§6.3]
    ]
    # Target uses the next pair (a'_{t+1}, o_{t+1}) and the states stored
    # for the window that ends at t  [§6.3]
    next_q = [
        target_k(batch.obs_next, batch.act_next, batch.h_cur, batch.c_cur)
        for target_k in target_critics
    ]
    # Clipped double-Q target; gamma and terminal handling not stated  [§6.3]
    target = batch.reward + gamma * min(next_q)
    loss = sum((q - target) ** 2 for q in q_values)
    return loss

Rover environment. The rover is a differential-drive vehicle with wheelbase b = 0.5 m §8.2. Each wheel has a hidden slip \lambda_i \in [0, 0.5] that scales its nominal speed §8.2. The action is a body velocity command, the observation is the tracking error, and the reward is the negative squared tracking error §8.3. The slip is not observed §8.3.

# Rover step: slip attenuates each wheel's nominal speed  [§8.2] [§8.3]
# Action: v_cmd (m/s), w_cmd (rad/s). Slip: lam_left, lam_right in [0, 0.5]
# Targets: v_target = 0.5 m/s, w_target = 0 rad/s  [§8.3]

def rover_step(v_cmd, w_cmd, lam_left, lam_right):
    # Nominal wheel speeds from the commanded body motion  [§8.3]
    v_nom_left = v_cmd - (WHEELBASE / 2) * w_cmd   # WHEELBASE = 0.5 m
    v_nom_right = v_cmd + (WHEELBASE / 2) * w_cmd
    # Each wheel is attenuated by its own hidden slip  [§8.2]
    v_left = (1 - lam_left) * v_nom_left
    v_right = (1 - lam_right) * v_nom_right
    # Body velocities from the realised wheel speeds  [§8.2]
    v = (v_left + v_right) / 2
    w = (v_right - v_left) / WHEELBASE
    # Observation is the tracking error, not the raw speed  [§8.3]
    obs = [v - 0.5, w - 0.0]
    # Reward is the negative squared tracking error  [§8.3]
    reward = -(obs[0] ** 2 + obs[1] ** 2)
    return obs, reward

Rover slip models. The nominal slip is a clipped AR(1) process per wheel, with \rho = 0.95, \sigma = 0.05 and initial slip uniform on [0, 0.5] §8.4.1. The abstract training disturbance replaces it with a clipped sinusoid per wheel, with amplitude, period and phase drawn at the start of each episode and offset \lambda_0 = 0.12 §8.4.1. The parameter ranges are in the Hyperparameters table.

# Nominal slip: clipped AR(1) per wheel  [§8.4.1]
# rho = 0.95, sigma = 0.05, lam_max = 0.5, lam_0 ~ Unif(0, 0.5)

def next_slip(lam, rng):
    # Previous slip carries over with factor rho; noise is zero-mean  [§8.4.1]
    noise = rng.normal(0.0, 0.05)
    # Clip keeps slip in the physical range [0, lam_max]  [§8.4.1]
    return min(max(0.95 * lam + noise, 0.0), 0.5)

Hyperparameters

Benchmark values come from the text and the appendix. The paper does not give a table of training hyperparameters. The rover section says it uses "the same training protocol and hyperparameters as in the benchmark experiments" §8.4.2, and those are not stated either.

Results

Author-reported. The benchmark results are learning curves that are normalised in an unstated way; the paper gives no numeric benchmark table §5.3 §7.2 fig. 3–fig. 8 fig. 11 fig. 12. Qualitative findings: all LSTM variants beat feed-forward TD3 on the pendulum conditions; the noise condition is hardest for TD3 and for H-TD3 §7.2. Iteration time is shorter for H-TD3, which does not reprocess the window in the critic fig. 13 §7.2. The paper states the code is not optimised, so timing comparisons are weak evidence §7.2.

Rover results, from tab. 3: mean ± SD over five seed-level average returns, each averaged over 20 evaluation episodes. Setup: policies trained under the physically motivated AR(1) slip §8.4.1, or under the abstract sinusoidal disturbance §8.4.1, or with no disturbance; the three robustness columns evaluate the abstract-trained policies under modified slip §8.4.2. Bold marks the highest value in each column, as in the paper.

Rover slip distributions fig. 15 have mean slip 0.117 for the nominal model, 0.190 for high variance, 0.082 for fast slip and 0.174 for slow slip.

Paper vs code

No official code.

The paper gives no code, data or project link. The arXiv abstract page lists no code link for this version. Searches of GitHub for "H-TD3", "1ha1hc", "LSTM-TD3", the author name "saki omi" and the title keywords found no repository owned by the authors. The only LSTM-TD3 repository found is a third-party implementation of the baseline method, which is not used here.

Pitfalls

• No training hyperparameters. The learning rate, optimizer, discount, target-update rate, batch size, replay size, exploration noise, policy delay and number of training steps are not stated anywhere in the paper or its appendix. The rover section points back to the benchmark settings, which are also not stated §8.4.2. Any value you use is your own choice; do not copy TD3 or LSTM-TD3 defaults without saying so.
• Window length for the baseline. The "w/o action" variant is described as using l-1 past observations, while the "w/ action" variant uses l §5.2. Whether the baseline's window is l or l-1 is ambiguous.
• Index typo in the unified sequence. The critic input I^{C'} is written as starting at o_{t-1} but with the actions starting at a_{t-l} §6.2. The actor input in the same section starts observations at o_{t-l} §6.2. Use the window (o_{t-l..t}, a_{t-l-1..t-1}) for the actor, which matches the formula in the text, and check the critic indices in tab. 4.
• No current action in the actor. The actor sequence ends at a_{t-1}, so the current action must not be fed to the actor. The critic does include a_t §6.2.
• H-TD3 states are stored, not recomputed. The stored (h, c) come from the behaviour actor at collection time §6.3. The paper does not say how stale they become as the actor changes. Treat this as a risk and test it; it is not analysed in the paper.
• H-TD3 drops actions. The critic omits a_{t-1} and the target omits a_t §6.3. The paper reports that this hurts the noise condition most §7.2, so the omission may be the cause of that drop.
• Hidden-state initialisation. How the LSTM is initialised at the start of each window, and whether state is reset between episodes, is not stated. The paper says the LSTM is initialised from stored states in H-TD3 §6.3 but gives no rule for the other variants.
• Noise level. The benchmark noise is given as a range in the scenario table tab. 2, as a fixed 0.5 in training §7.1, and as 1.0 in the generalisation tests §7.2. Whether it is drawn per episode or fixed is not stated.
• "1,000 trials". The generalisation evaluation is reported after "1,000 trials" §7.2. The paper does not say whether that means episodes or training iterations.
• Normalised curves. The benchmark figures are normalised, and the normalisation is not defined §5.3 §7.2. Do not compare absolute values across figures.
• Rover observation and action units. The observation is the tracking error, not raw speed §8.3. The action bounds, observation scaling and the sequence length l used for the rover are not stated.
• Exp2 parameters. The abstract sinusoid is said to match the AR(1) slip distribution, but the matching procedure is not described §8.4.1.
• Small sample. Every "±" comes from five seeds §8.4.2. Many gaps between rows in tab. 3 are about the same size as the reported SDs, so rank orders there are fragile.
• Compute claims. The timing advantage of H-TD3 is qualitative; no numbers are given in the text §7.2 fig. 13.
• Hidden scenario and parameter counts. Table 5 assumes obs dim 3 tab. 5; the hidden scenario uses obs dim 2 §5.2. Recount parameters for that case.

Lineage

• Builds on: Meng et al., "Memory-based deep reinforcement learning for POMDPs" (IROS 2021), which introduced the two-channel LSTM-TD3 baseline §3 §5.2. The paper compares against the version with and without past actions.
• Builds on: TD3, "Addressing function approximation error in actor-critic methods" (ICML 2018), as the base algorithm §1 §6.3.
• Related: Ni et al., arXiv:2110.05038, on recurrent model-free RL as a strong baseline for POMDPs; cited for the cost of sharing the recurrent encoder §1 §2.
• Related: Heess et al., arXiv:1512.04455, on recurrent actor-critic with whole-trajectory updates §2 §5.1.
• Compared against: feed-forward TD3, and the LSTM-TD3 variants listed above tab. 3 §7.2.