HoloBoxing: A Simple Recipe for Humanoid Boxing with 7 Minutes of Single-GPU Training

AI summary

Overview

Research area: Robot learning / reinforcement learning for physically simulated humanoid control, specifically competitive humanoid boxing built on top of a pretrained whole-body motion controller.

Technical level: Intermediate. The paper is readable without deep mathematics, but it assumes familiarity with reinforcement learning (PPO), motion imitation, latent action representations, and sim-to-sim policy evaluation.

Scope: The paper describes and evaluates a short task-adaptation recipe that adds boxing behavior to a frozen whole-body humanoid controller, accounting for 7.0 minutes of additional single-GPU training and measuring the resulting behavior in a six-policy simulated league.

What This Paper Is About

A humanoid can already throw a punch using a pretrained motion controller, but that controller does not decide when, where, or against whom to punch. HoloBoxing asks how little additional training is needed to turn such a controller into an interactive boxer. The authors propose a deliberately simple recipe: keep the whole-body controller frozen, let a small upper-level planner pick compact movement requests, give that planner an initial behavior through imitation of measured robot states, and then refine it with reinforcement learning against a standing opponent.

Key Contributions

1. A three-part separation of concerns for boxing. Motor execution (a frozen HoloMotion v2 controller on a Unitree G1), target structure (a learned 32-dimensional latent decoder), and task decisions (a compact planner with hidden widths 256 and 128) are kept in separate components so that task learning never relearns joint-level control.

2. A compact latent target interface. The planner outputs a 32-dimensional action that a frozen decoder expands into 225 coordinates — five body points (pelvis, both wrists, both ankles) at five future times (20–100 ms), with 3 position and 6 orientation features each. This replaces direct prediction of 225 coordinates.

3. Measured-state imitation as initialization. The frozen controller tracks reference motions while the authors record the robot's actual observations paired with future-target labels, then supervise the planner on those pairs through the frozen decoder. This supplies behavior before reward-driven exploration.

4. A timed, component-controlled evaluation. The paper reports a 7.0-minute accounted training cost, a 21.4-minute long version, two matched-budget component removals (no imitation, no latent decoder), an observation study with eight conditions, representation diagnostics, and a 150-bout six-policy league using Elo.

Main Findings

• The headline seven minutes is an accounted total, not a single fresh run. Table 1 sums to 422.2 seconds (7.0 minutes) from a reused target-prior fitting run of 47.2 seconds (epoch 148 selected) plus a complete new single-RTX-4090 process of 375.0 seconds. The breakdown is 6.7 s imitation initialization (20 epochs), 84.9 s standing warmup (32 updates), 275.3 s interaction learning (128 updates), and 8.1 s setup/saving/exit. Representation fitting plus imitation account for only 53.9 s; standing and interaction account for 360.2 s.

• The excluded scope is explicit. The total excludes controller pretraining, downloading, retargeting, observation collection, evaluation, hyperparameter search, and the original training of the fixed standing opponent.

• The 7-minute version ranks second of six; the long version ranks first. In the ten-round, 150-bout league, the long version reaches Elo 1669 with a 41–3–6 record and 327:64 contacts, while the 7-minute version reaches Elo 1541 with 26–17–7 and 76:196 contacts. RoboStriker scores 1524 (28–22–0, 337:29), GGSD run2 1476 (20–25–5, 69:155), the no-decoder removal 1428 (4–22–24, 3:165), and the no-imitation removal 1362 (4–34–12, 0:203).

• The 7-minute version beats GGSD but loses the contact battle to RoboStriker. Against GGSD it wins 7–3–0 with contacts 21:16 and falls 0:5; against RoboStriker it wins 4–6–0 with contacts 4:85 and falls 2:6. The authors note this contact deficit limits claims about offensive strength.

• Wins do not always mean landed punches. Four of the primary version's wins contain no scored hand contact, which is why the paper reports contacts and falls alongside match outcomes.

• Both component removals are clearly worse at the same budget. With identical 128 final-stage updates and 491,520 learner transitions, the full 7-minute recipe ranks above both removals, and against the removed-component family it goes 13–0–7 with contacts 30:0 and no falls.

• The long version dominates the short one head-to-head. The 21.4-minute version wins eight of ten bouts against the 7-minute version (2–8–0 from the short version's perspective, contacts 21:95). It was trained with separate RTX 5090 runs (47 s prior fitting, 19 s imitation, 247 s standing, 969 s interaction) and 256 final updates, so the comparison is not matched-hardware.

• Current state plus opponent input is the best observation choice for imitation. Across eight conditions with three seeds and the same frozen decoder, the lowest mean validation loss is 0.44447 (std 0.00128) for current state with opponent input, 16.9% below ten-frame history with opponent input (0.53513, std 0.00617). The paper stresses this supports the imitation input choice but does not independently show faster reinforcement learning.

• Low reconstruction error alone is not sufficient. The selected reconstruction and uncompressed targets each complete 80 of 81 validation windows, failing the same source window. A later candidate lowers validation loss from 0.045326 to 0.044545 but adds a tracking failure and misses 16 fixed comparison frames, so it is rejected. Failure is defined as pelvis or torso height below 0.30 m.

• Reconstruction quality varies sharply by source. Held-out normalized error is 0.01985 on RoboStriker validation (1.595 cm, 3.441°) and 0.06342 on InterHuman validation (2.902 cm, 5.890°), but 0.78406 on the InterHuman test split (6.752 cm, 19.055°), where one seated-retreat clip contributes 97.7% of that source's test loss.

• Measured-frame targets are harder than reference-frame targets. On the 6448-sample measured validation population with all representation weights frozen, paired source-frame references give 2.90 cm and 5.88°, while measured-frame labels give 6.30 cm and 10.36°.

• Decoder capacity has a sweet spot. The 512/256 encoder gives the lowest normalized error (0.046047 ± 0.000709, 2.474 cm, 4.839°), better than 256/128 (0.052182 ± 0.001057) and 512/256/128 (0.055442 ± 0.002174).

• The comparison to prior systems is qualitative, not a controlled speedup factor. SLMP reports approximately 8 hours for two-agent combat on a server with two RTX 4090 GPUs; RoboStriker reports no wall-clock task-stage time in the checked sources; GGSD reports 70,000 joint skill-learning and self-play updates with no wall-clock duration. The authors explicitly decline a "fastest method" claim.

• Inference is fast in a narrow benchmark. A fixed-pose RTX 4090 microbenchmark of the long version averages 3.182 ms over 100 measured iterations after ten warmups, with a 99th percentile of 3.373 ms, excluding physics and output sanitation.

Methodology in Plain English

The authors start from an assumption: the robot already knows how to move. A pretrained HoloMotion v2 controller on a Unitree G1 handles joint-level execution and stays frozen for the entire study. The only thing that needs to be learned is the decision layer that tells the controller what to do next.

First, they compress movement requests. Instead of asking the planner to name 225 future position and orientation coordinates directly, they train an encoder and decoder pair so that a 32-dimensional vector can be expanded back into those 225 coordinates, covering five body points at five future times between 20 and 100 ms. The decoder is kept; the encoder is only used for fitting and diagnostics. This shrinks the planner's action space by roughly a factor of seven.

Second, they give the planner a starting behavior. The frozen controller is made to track reference motions (drawn from paired InterHuman data and released RoboStriker trajectories), and while it does so the authors record what the actual robot observed — not what the reference said it should have observed — paired with the future targets. The planner is trained by supervised learning on those pairs, with gradients flowing through the frozen decoder. Because the labels are expressed in the measured robot's own pelvis frame, the planner learns to answer the question the controller will actually ask during play.

Third, they refine the planner with reinforcement learning using PPO: 32 standing-warmup updates against a passive opponent, then 128 interaction updates against a fixed external standing actor. The reward mixes task shaping (approach, facing, contact, balance) at weight 0.8 with an adversarial motion style term at weight 0.2. A separate referee, not the reward, decides match outcomes.

For evaluation, they run a fixed ten-round league in which all six participants fight every other participant ten times with randomized sides and recorded seeds, for 150 bouts total. Every policy starts at Elo 1500 with K = 16. A valid hand contact to the head or torso crossing a 5 N·s impulse threshold within 20 ms scores a point and triggers a 200 ms cooldown for that hand; a continuous three-second fall below 0.30 m confirms a knockout worth 1000 points; otherwise a 60-second timeout decides on score. They also run component ablations at matched 128-update budgets and an eight-condition observation study with three seeds each.

Why This Matters

Impact on research. The paper makes a case for measuring task adaptation separately from motor-controller development, and it is unusually explicit about what its seven-minute number does and does not contain. It also documents a recurring methodological trap in this literature: reported training times across systems are rarely comparable because inherited controllers, hardware, and inherited priors differ. Reporting contacts and falls alongside Elo is a second, quieter contribution — it exposes that terminal wins can come from an opponent's unforced fall rather than a landed punch.

Real-world applications:

• Competitive robot sports and entertainment. Humanoid boxing and similar adversarial formats need policies that approach, face, strike, and stay upright — exactly the behavior mix this recipe produces.
• Rapid task adaptation on deployed humanoids. Reusing a frozen controller and training only a small upper policy is a practical pattern for adding new skills to a robot already in the field without re-deriving whole-body control.
• Upper-body manipulation and reaching. The 225-coordinate target interface covers wrists and ankles at multiple future times, which generalizes conceptually to reaching or hand-off tasks above an existing locomotion stack.
• Benchmarking infrastructure for policy leagues. The fixed ten-round, Elo-rated, referee-scored protocol with replayed states and recorded seeds is a reusable template for comparing policies fairly within a frozen participant pool.

Industry relevance. The recipe's premise — a frozen general-purpose controller plus a small, cheaply trained task head — is attractive for commercial humanoid platforms, since it means task-specific behavior can be added with one consumer GPU and without touching the expensive pretrained motor stack. The paper's careful accounting boundary (and its explicit statement that controller pretraining is excluded) is exactly the kind of reporting industrial consumers need to evaluate whether such a claim transfers to their own setup.

Future Directions

• Isolate component effects on learning speed. The authors state directly that the current experiments do not isolate each component's contribution to convergence time. Independent seeds and matched timing studies are needed, especially since the direct-target control changes action dimension and exploration geometry at the same time as it removes the decoder.

• Test real-robot transfer. All experiments are simulation-only; real-robot boxing and transfer remain untested. The 3.182 ms inference benchmark is a fixed-pose microbenchmark that the authors say does not establish full-match or hard real-time latency.

• Broaden motion and reset coverage. The seated-retreat InterHuman test clip that accounts for 97.7% of its source's test loss shows the representation's coverage limits beyond upright behavior. The authors also call for broader motion and reset coverage and for testing alternative lower controllers.

• Make the league a controlled comparison. The six-policy league is not observation-controlled: participants retain different state encodings, history, and auxiliary inputs, and external policies receive no destination fine-tuning. The authors note the results describe these checkpoint systems rather than establish method superiority.

Target Audience

Researchers and engineers working on humanoid whole-body control, reinforcement learning for physically simulated characters, and adversarial robot sports will get the most from this paper. It suits readers who already understand PPO and motion-imitation pipelines and want a concrete, honestly scoped data point on how cheap task adaptation can be when motor control is treated as a given. Practitioners deciding whether to build on a frozen controller versus train end-to-end will find the timing breakdown and the component ablations the most useful parts; readers looking for a controlled speedup comparison against other methods will not find one here, and the authors say so.

Authors’ abstract

HoloBoxing presents a simple recipe for learning humanoid boxing by building on a pretrained whole-body controller. The recipe separates reusable motor skills from task decisions: a compact planner requests future body-point targets, while the frozen controller handles joint-level execution. A learned decoder maps 32-dimensional actions to structured target windows, and measured-state imitation initializes the planner before reinforcement learning. Task learning then refines interaction behavior while reusing the decoder and controller, avoiding the need to relearn whole-body control. This combination keeps task optimization focused on a compact upper policy and supplies an initial behavior before reward-driven exploration. Starting from that available controller, the recipe accounts for about seven minutes of additional training, including reused representation fitting and a single-GPU task run. This excludes controller pretraining, data preparation, evaluation, and search. Simulated boxing experiments and component controls evaluate the resulting behavior and the roles of imitation initialization and the target representation.