LiveNet: Robust, Minimally Invasive Multi-Robot Control for Safe and Live Navigation in Constrained Environments

In plain words

Two robots that meet in a narrow doorway or at a crossing can block each other. If both stop and wait, nobody moves. If both push on, they can collide. People avoid this by slowing down a little so the other person can pass, without changing where they walk. This paper asks how a robot can do the same.

The authors train a small neural network to drive each robot. The network learns from examples made by a slower, hand-tuned planner. On top of the network sits a safety layer. The layer checks two things: the robot must keep clear of others, and it must not get stuck in a standoff. When it has to give way, it changes only its speed, not its path. The robots do not talk to each other.

In simulation, the authors report that the robots pass doorways and crossings without collisions or deadlocks. The controller also runs much faster than the optimisation-based methods built for this setting. The results come from simulation with two robots, and they have not been tested on real hardware.

TL;DR

• A fully decentralised neural controller for two robots that must pass through a doorway or an intersection without colliding or deadlocking §1, §5.1.
• A network outputs a reference control and two sets of learned penalties; a QP layer then enforces one collision CBF per other robot and one liveness CBF on speed only §4.
• Trained by supervised learning on controls of a receding-horizon MPC that uses the same barrier functions §5.1.
• Author-reported, in simulation: 0 collisions and 0 deadlocks in 50 runs per scenario, and 10 to 20 times lower compute time per step than the specially designed optimisation baseline §1, tab. 2.
• Two-agent scenarios only, simulation only, and the code is not hardened for deployment §6.

Problem

Robots in cramped spaces need three things at once: safety (no collisions), liveness (keep making progress, no deadlock) and minimal invasiveness (change the planned path as little as possible). Decentralised methods that handle liveness often perturb paths heavily, and methods that are safe alone are too conservative §1.

The paper states the task as a partially observable stochastic game. A social mini-game (SMG) is one where two agents' desired space-time trajectories intersect, which causes either a collision or a deadlock §3. The goal is to perturb the desired trajectories so that no collision occurs, keeping the spatial path fixed and changing the velocity profile. The paper ranks minimal invasiveness by first minimising the summed spatial deviation ε(1) and then the summed change of velocity ε(2) §3. Kinodynamic limits u_min ≤ u ≤ u_max apply §3.

Method

Network and what it outputs §4. Each robot runs its own copy of one network F. The input is the robot's own state and its observation of others, z = (x, o). The network has three heads: a reference control u_ref, penalties p^o for the collision CBF, and penalties p^l for the liveness CBF. The control is u = (ω, a), with ω the turn rate and a the linear acceleration §4.1. The heads feed a QP layer that enforces the CBF inequalities §4 fig. 3. Training is by mean-squared error against the optimal control from the dataset §4, §5.1.

Collision CBF (degree 2 in the control) §4.1. Let b = (x^i − x^j)² + (y^i − y^j)² − R², with R = r^i + r^j. Each other robot, and each static obstacle, gets one row. For a static obstacle, its velocity and heading are zero §4.1. The second-order barrier inequality is

-L_g L_f b(z)\,u \le L_f^2 b(z) + (p^o_1 + p^o_2)\,L_f b(z) + p^o_1 p^o_2\, b(z) §4.1

with the Lie derivatives

L_f b = 2\Delta x\,(v^i\cos\theta^i - v^j\cos\theta^j) + 2\Delta y\,(v^i\sin\theta^i - v^j\sin\theta^j) §4.1

L_f^2 b = 2\big(v_i^2 + v_j^2 - 2 v_i v_j \cos(\theta^i + \theta^j)\big) §4.1, see Pitfalls

L_g L_f b = \big[-2\Delta x\, v^i\sin\theta^i + 2\Delta y\, v^i\cos\theta^i,\;\; 2\Delta x\cos\theta^i + 2\Delta y\sin\theta^i\big] §4.1

The derivative of p^o_1 is set to zero §4.1.

Liveness CBF (minimal invasive, speed only) §4.2. This row is added only when the two heading rays cross. The rays cross when two signed ray tests are both positive §4.2. The steps are:

1. Take each robot's critical point: the boundary point of its own footprint that faces the other robot. Project both critical points forward along their current heading §4.2.
2. Find where the two projected paths meet. Let d^i and d^j be the distances from each critical point to that meeting point §4.2.
3. Compute times t = d / v. If t^i < t^j, the ego robot passes first (δ = 1). Otherwise it yields (δ = −1) §4.2.
4. Enforce b = δ(t^j − t^i) ≥ 0 with a first-order CBF. Because the spatial path is fixed, only the speed derivative enters §4.2.

The paper's form of the constraint is

-\delta\,\frac{a^i d^i}{(v^i)^2} \le p^l_\delta\left(\frac{d^j}{v^j} - \frac{d^i}{v^i}\right) §4.2, see Pitfalls

The paper's Theorem 1 says these constraints guarantee liveness. The proof follows BarrierNet's theorem, under the condition that the penalty functions have the required relative degree in their inputs §4.2, thm. 1.

Minimal-change QP §4. The QP is an OptNet-style layer with identity Q, linear term from u_ref, and the stacked CBF rows G u ≤ h as constraints. The paper writes the objective as maximising (u − u_ref)² §4; the code's objective is discussed in Paper vs code.

Training §5.1. Expert labels come from an MPC controller tuned per perturbed scenario and built with the same barrier functions. The authors perturb start state, goal state and gap size to build a dataset §5.1. The network is then trained with supervised learning on these labels.

# LiveNet control step for one robot  [§4]
# Input:  feats (8 + 4 per other obstacle), ego speed v, heading theta
# Output: u = (omega, a)  [code: model.py#L64-L85]

def livenet_step(feats, ego, others):
    # Standardise with the stored input mean and std  [code: model.py#L69]
    x = (feats - input_mean) / input_std
    # Shared trunk, one 256-unit ReLU layer  [§5.1]
    hidden = relu(fc1(x))                            # (256,)
    # Reference control  [§4]  [code: model.py#L70-L73]
    u_ref = fc31(relu(fc21(hidden)))                 # (2,)
    # Penalties kept in (0, 4) per CBF  [code: model.py#L79, L85]
    p_obs = 4 * sigmoid(fc_obs2(relu(fc_obs1(hidden))))
    p_live = 4 * sigmoid(fc34(relu(fc24(hidden))))   # (slower, faster)
    G_rows, h_rows = [], []
    # Collision CBF row for each other robot or obstacle  [§4.1]
    for other in others:
        G_row, h_row = obstacle_row(ego, other, p_obs)
        G_rows.append(G_row)
        h_rows.append(h_row)
    # Liveness CBF row for each crossing path  [§4.2]
    for other in others:
        row = liveness_row(ego, other, p_live)
        if row is not None:
            G_rows.append(row[0])
            h_rows.append(row[1])
    # Minimal-change QP  [§4]  [code: model.py#L100, L268]
    return qp_solve(G_rows, h_rows, u_ref)

# Collision CBF row, second order in the control  [§4.1]
# Static obstacle: v_j = 0 and theta_j = 0  [code: model.py#L157-L181]

def obstacle_row(ego, other, p):
    # Relative position, barrier b = |d|^2 - R^2  [§4.1]
    dx, dy = ego.x - other.x, ego.y - other.y
    R = ego.radius + other.radius        # + safety distance, not stated
    barrier = dx**2 + dy**2 - R**2
    # First Lie derivative along the drift  [§4.1]
    barrier_dot = (
        2 * dx * (ego.v * cos(ego.th) - other.v * cos(other.th))
        + 2 * dy * (ego.v * sin(ego.th) - other.v * sin(other.th))
    )
    # Second Lie derivative, drift part  [§4.1, see Pitfalls]
    lf2 = 2 * (ego.v**2 + other.v**2
               - 2 * ego.v * other.v * cos(ego.th + other.th))
    # Coefficients of (omega, a) in L_g L_f b  [§4.1]
    coef_omega = -2 * dx * ego.v * sin(ego.th) + 2 * dy * ego.v * cos(ego.th)
    coef_accel = 2 * dx * cos(ego.th) + 2 * dy * sin(ego.th)
    # -(coef . u) <= lf2 + (p1 + p2) * barrier_dot + p1 * p2 * barrier
    G_row = [-coef_omega, -coef_accel]
    h_row = lf2 + (p[0] + p[1]) * barrier_dot + p[0] * p[1] * barrier
    return G_row, h_row

# Liveness CBF row, changes speed only  [§4.2]
# Returns None when the heading rays do not cross  [code: model.py#L199-L216]

def liveness_row(ego, other, p):
    # Both ray tests must be positive for a crossing  [§4.2]
    if not rays_cross(ego, other):
        return None
    # Critical points on each footprint, facing the other robot  [§4.2]
    unit = normalise(other.xy - ego.xy)
    crit_ego = ego.xy + ego.radius * unit
    crit_other = other.xy - other.radius * unit
    # Meeting point of the two projected heading rays  [§4.2]
    meet = ray_intersection(crit_ego, ego.th, crit_other, other.th)
    d_ego = norm(crit_ego - meet)
    d_other = norm(crit_other - meet)
    # Time for each critical point to reach the meeting point  [§4.2]
    t_ego = d_ego / ego.v
    t_other = d_other / other.v
    # Ego yields: it arrives later, so its barrier is t_ego - t_other
    if t_ego >= t_other:
        barrier = t_ego - t_other
        return [0, d_ego / ego.v**2], p[0] * barrier    # p[0]: slower
    # Ego goes first: barrier t_other - t_ego  [§4.2]
    barrier = t_other - t_ego
    return [0, -d_ego / ego.v**2], p[1] * barrier       # p[1]: faster

# Minimal-change QP  [§4]  [code: model.py#L100, L266-L268]
# Objective as the code writes it: 0.5 |u|^2 + u_ref . u
# Constraints: G u <= h, one row per CBF

def qp_solve(G_rows, h_rows, u_ref):
    # Identity Q, linear term u_ref  [code: model.py#L100]
    return argmin_u(0.5 * dot(u, u) + dot(u_ref, u),
                    subject_to=(stack(G_rows) @ u <= stack(h_rows)))

# Supervised training  [§5.1]  [code: train.py#L66-L116]
# Labels: controls of an MPC that uses the same barrier functions  [§5.1]

def train(dataset):
    # 30 epochs  [§5.1]
    for epoch in range(30):
        # Batch size and optimiser: see Hyperparameters and Paper vs code
        for batch in shuffled(dataset):
            # Loss: mean squared error against the expert control  [§5.1]
            loss = mse(livenet(batch.features), batch.expert_control)
            update(parameters, learning_rate=1e-3)  # Adam in code

Hyperparameters

Values in the code differ from the paper in a few places; these are listed under Paper vs code. The table gives the paper's value and the code's value where they differ.

Results

Author-reported, in simulation, with two robots. Setup: 50 runs per scenario for each method, cycle-time and makespan as reported in the paper tab. 2. The robustness test is on 28 perturbed doorway scenarios §5.2.

Source: tab. 2. Cycle time is labelled "s" in the paper; see Pitfalls.

Other reported results §5.2:

• MPC-CBF avoided collisions but deadlocked in every run; MACBF, PIC and BarrierNet collided in every run §5.2 tab. 2.
• In the robustness suite of 28 perturbed doorway scenarios, LiveNet solved 25 without deadlock or collision and SMG-CBF solved 16 §5.2.
• Trajectories of all six methods are in fig. 4. The CBF values and path deviation of LiveNet are in fig. 5. Velocity profiles against SMG-CBF are in fig. 6.

Paper vs code

The official repository is srikarg89/LiveNet at the commit above. Its README names the three authors as developers README.md. The code follows the paper's structure but differs in several places.

1. QP objective sign. The paper writes the layer as maximising (u − u_ref)² §4. The code passes +u_ref as the linear term of a minimisation, so the unconstrained optimum is u = −u_ref model.py. Training is end-to-end, so the network learns the reference with this sign. An implementation that follows the paper literally gets a flipped reference.
2. Control order. The paper uses u = (ω, a) §4.1. The coefficients in the code and the simulator's clamps use the same order model.py. The class comment says "[linear vel, angular vel]" model.py, and the README lists "linear acceleration, angular velocity" README.md. Both are wrong about the order used in the code.
3. Liveness critical-point direction. The paper uses p̂ = (p^j − p^i)/|p^j − p^i| §4.2. The code builds the unit vector from swapped components, (Δy, Δx) model.py. The helper in util.py uses the correct direction, but only on the optional input path util.py. The shipped liveness weights use the model.py path, since add_liveness_filter is true in the shipped definitions.
4. Liveness gradient factor. The paper's L_g b carries a^i d^i / (v^i)², where a^i is a cross-product term defined in §4.2 §4.2. The code uses d / v² only model.py. The paper uses the symbol a^i for acceleration as well.
5. Network width. The paper's reference head has width 64 and comes off the 256-unit layer through a separate branch §5.1. The code puts the reference head behind an extra hidden layer of width nHidden21 model.py. Config sets 128 config.py; the shipped doorway weights use 64 livenet_doorway_definition.json; the shipped intersection and doorway-suite weights use 128 livenet_intersection_definition.json.
6. Batch size. The paper states 64 §5.1; the training config uses 32 config.py.
7. Input count. Config trains with n_opponents = 6 config.py. The shipped doorway weights use n_opponents = 12, which fixes the input size at 4 + 4 × 12 = 52 livenet_doorway_definition.json model_utils.py.
8. Inputs. The paper's network input is the state and an observation §4. The code uses goal-relative inputs, with the ego position replaced by the vector to the goal, when x_is_d_goal is true util.py config.py.
9. Simulation time. The paper states 18 s §5.1; config uses 20 s config.py.
10. Optimiser and checkpoint. The paper states gradient descent with learning rate 1e-3 §5.1. The code uses Adam train.py. The code keeps the epoch with the lowest test loss, on a 75/25 split with seed 42 train.py.
11. Infeasible QP at run time. The paper does not say what happens. The code returns −u_ref when the solver raises model.py. For liveness, a missing crossing or zero speed adds a loose row a ≤ 100 × accel_limit = 10 model.py.
12. Control limits. The paper includes u_min ≤ u ≤ u_max in its problem §3. The QP in the code has no box constraints model.py. The simulator clamps ω, a and v after the controller runs environment.py.
13. Velocity of other robots. The simulator estimates an opponent's speed by finite difference of positions environment.py. The paper does not say how velocities are observed.
14. Expert. The paper says the MPC cost matrices and CBF parameters were tuned per perturbation §5.1. The repository ships one set of cost matrices config.py and a dataset path datasets/doorway_scenario_suite_5/ config.py.
15. Licence file. The LICENSE is MIT, but the copyright line names "Elena Oikonomou", not an author of this paper LICENSE. The card records MIT, because the README and repository owner match the authors. Check this before quoting code.

Pitfalls

• QP sign. Implement the code's objective, 0.5 |u|² + u_refᵀu, or the trained weights will not behave the same. The paper's (u − u_ref)² form gives the reference with the opposite sign §4 model.py.
• Second Lie derivative. The paper and the code both use cos(θ^i + θ^j) in L_f² b §4.1 model.py. Derivation by the card author: with the drift f only (ω = a = 0), L_f² b = 2 |v^i e^i − v^j e^j|², where e = (cos θ, sin θ). That gives cos(θ^i − θ^j), not the plus sign. The paper's source keeps a commented-out line with a plus sign on cos(θ^i − θ^j), marked "Incorrect". The authors did not settle this here. Check numerically before implementing.
• Liveness constraint. The paper's form has a^i d^i / v² on the left, and the code has d / v² §4.2 model.py. Which is right depends on the definition of a^i, which the paper overloads with acceleration. Verify the geometry before implementing.
• Liveness direction bug. The code's critical points lie off the line between the robots because of the swapped components model.py. Implement the paper's direction, not the code's.
• Penalties. The code bounds each penalty to (0, 4) through 4·sigmoid model.py. The paper says nothing about bounds. Set ṗ to zero as the paper does §4.1.
• Guarantee scope. The liveness claim is a theorem about the CBF constraints under the stated conditions §4.2, thm. 1. The conclusion says the guarantee needs enough training data for the penalties to be learned §6. The code's fallback at run time breaks the guarantee when the QP cannot be solved model.py.
• Input layout. The obstacle inputs are the nearest obstacles, truncated to n_opponents − 1 util.py. No padding appears in the code, so the input length changes whenever fewer obstacles are present. Use a fixed slot count with padding.
• Other robots' velocity. The code's opponent velocity is a finite difference of positions in simulation environment.py. A real robot must estimate it, and the paper gives no method.
• Scale. The paper says "multiple robots" in the scenario text §5.1, but the conclusion says only two-agent scenarios were tested §6.
• Advertised ratios. The abstract's "4–5 times more invasive" holds for the doorway only (SMG-CBF ΔV 0.009 against LiveNet 0.002). In the intersection, the two are 0.012 and 0.011 tab. 2. The makespans in the doorway are tied at 13.8 s tab. 2.
• Cycle-time units. The table labels cycle time in seconds tab. 2, but the code's summary converts seconds to milliseconds summarize_experiments.py. The values are almost certainly milliseconds.
• Error bars. The paper does not say what ± means. The code's compute-time summary uses the standard error of the mean, std / √n summarize_experiments.py.
• Symmetry. The paper says a single network breaks symmetry through its input bias, and that SMG-CBF needs a predefined winner §5.2. This is not tested beyond the paper's suite.
• Hardware. Simulation only, with a 0.3 m/s speed cap and 0.1 m/s² acceleration cap §5.1 §6. The paper defers real deployment.

Lineage

• Builds on BarrierNet, a differentiable CBF layer with a theorem on its guarantees §4.2. Cited in the paper as barriernet2021 (Xiao et al., IEEE Transactions on Robotics) [refs.bib].
• Builds on OptNet, the differentiable QP layer, cited as amos2017optnet (Amos and Kolter, ICML) §4 [refs.bib].
• Compared against: MPC-CBF (zeng2021safety), SMG-CBF (chandra2024deadlock), MACBF (macbf2021), PIC (liu2020pic), BarrierNet (barriernet2021) §5.2.
• Expert data comes from an MPC built on zeng2021safety §5.1.