Paper · 2024-11-20 · cs.RO

Hierarchical Diffusion Policy: manipulation trajectory generation via contact guidance

Dexin Wang, Chunsheng Liu, Faliang Chang, Yichen Xu

Hierarchical Diffusion Policy (HDP) splits imitation learning into two diffusion models. A Guider predicts the next object contact; an Actor generates a 16-step action sequence toward it, trained with behaviour cloning plus a Q-learning term. Author-reported: 20.8% average success gain over Diffusion Policy across six tasks.

Diffusion models Imitation learning Offline reinforcement learning Hierarchical reinforcement learningrobot-manipulationdiffusionimitation-learningrobotics

arXiv PDF Code Markdown18 min read

AI-compiled by claude-haiku-5-5 on 2026-10-25, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

A robot can learn a task by copying recorded demonstrations. Diffusion Policy is a recent way to do this: it generates the whole motion in one go, starting from noise and refining it. It works well when a task involves one contact, but the authors found it weaker when a task involves many contacts, such as pushing an object and then grabbing it.

HDP splits the job in two, like a planner and a driver. A "Guider" looks at the scene and predicts where the fingers should touch the object next. An "Actor" then plans the motion that leads to that touch point. Both parts are generative models of the same kind. The Actor is also nudged by a learned value estimate that favours motions which reach the target.

Because the target is an explicit point, a person can type in a different target while the robot is running. The robot then steers toward it. The authors use this to fix a failed attempt mid-task, and they say the robot can get out of a stuck motion this way.

TL;DR

HDP is an imitation-learning policy with two conditional diffusion models. The Guider predicts the next object contact (two finger positions plus contact flags). The Actor denoises a 16-step action sequence given that contact and the observation, and it also gets a Q-learning gradient from a critic §3.2 tab. 8. The authors report a 20.8% average success gain over Diffusion Policy across six tasks §6. Simulation numbers use a reduced Diffusion Policy baseline they reproduced. The official repository has no license file, and several paper equations differ from the released code.

Problem

Diffusion Policy models the whole action sequence end to end. The authors argue that it performs worse on contact-rich tasks than on single-contact tasks, and that it does not model the robot-object interaction explicitly §1.

Behaviour cloning on its own cannot exceed the demonstrator, and it struggles with multimodal action distributions §1 §2.2. Learning a value function over the whole task has low sample efficiency, so the authors split the task into short subtasks, each ending at an object contact §3.2.

Demonstrations also contain misoperations: accidental touches that do not move the object, and overshoot-then-correct motions. Using the immediate next contact as the target would reproduce these §4.1.

The method assumes a single robot and a single object §6. It needs object point clouds, transformed into the world frame from the object pose for rigid objects, or taken from stereo cameras or keypoints for deformable ones §4.2.

Method

Equation numbers are counted from the LaTeX source in order of appearance. The compiled PDF was not checked, so cross-check numbers against the PDF before quoting them.

HDP is a conditional denoising diffusion model for each level §3.1 §3.2. At time $t$ the Guider reads the last $T_o$ observations $O_t$ and predicts a contact $C_t$ . The Actor reads $O_t$ and $C_t$ and predicts $T_p$ actions, of which $T_a$ are executed open-loop before replanning fig. 2 tab. 8.

Diffusion background. The forward process adds Gaussian noise over $K$ steps §3.1 eq. 1. The noisy sample is $x^k$ , computed in one step from $x^0$ eq. 2. The reverse step is a Gaussian centred on the noise prediction $\epsilon_\theta$ eq. 3. The clean sample can be read off directly from $x^k$ and the noise eq. 4. Training regresses the noise with mean-squared error. The noise scale used in the reverse step is written as $(1-\alpha^k)\mathbf{I}$ eq. 3.

$x^k = \sqrt{\bar{\alpha}^k}\, x^0 + \sqrt{1-\bar{\alpha}^k}\, z^k \qquad \text{[eq. 2]}$
Guider. The contact target $C_t$ is the expected contact at time $t$ . It is the position of each finger in the object frame plus a flag for whether the finger is touching. Non-contacting fingers have target 0 §3.2 app. Hyperparameters. The Guider is a conditional diffusion model on $O_t$ eq. 5. Its training loss is the mean-squared error between the true and predicted noise eq. 6. The Guider's MLP widths are not stated in the paper text; the Move-T config uses 1024-512-256-128 with ReLU hdp_moveT.yaml.

$\mathcal{L}_g = \mathrm{MSE}\big(z^k,\ \epsilon_\omega(\mathbf{C}^k_t, k, \mathbf{O}_t)\big) \qquad \text{[eq. 6]}$
Actor. The Actor is built on Diffusion Policy §3.2 §2.3. It uses object point clouds and robot proprioception as observation, and $C_t$ as an extra condition §3.2. Its behaviour-cloning loss is eq. 8. The implementation is a 1-D convolutional network fig. 2 actor_small.py.

$\mathcal{L}_a = \mathrm{MSE}\big(z^k,\ \epsilon_\theta(\mathbf{A}^k_t, k, \mathbf{O}_t, \mathbf{C}_t)\big) \qquad \text{[eq. 8]}$
Q-learning term. The Actor loss adds a Q-value term eq. 9. The coefficient $\eta$ weights it. The Q-value is evaluated on the action $\mathbf{A}^0_{t,\theta}$ that the Actor denoises. The authors keep the original MSE term "to enhance robustness and optimization efficiency" §4.4.

$\mathcal{L}_a = \mathrm{MSE}\big(z^k,\ \epsilon_\theta(\cdot)\big) - \eta\, Q_\phi\big(\mathbf{S}_t, \mathbf{C}_t, \mathbf{A}^0_{t,\theta}\big) \qquad \text{[eq. 9]}$

Denoising to $\mathbf{A}^0_{t,\theta}$ can use the full reverse chain eq. 10 or one step at step $k$ eq. 11. The paper uses the one-step form, which it calls snapshot gradient optimization §4.4. The one-step form trains about 4 times faster and uses 24% less GPU memory at 10 denoising steps (author-reported) §4.4.

$\mathbf{A}^0_{t,\theta} = \frac{1}{\sqrt{\bar{\alpha}^k}}\Big(\mathbf{A}^k_t - \sqrt{1-\bar{\alpha}^k}\, \epsilon_\theta(\mathbf{A}^k_t, k, \mathbf{O}_t, \mathbf{C}_t)\Big) \qquad \text{[eq. 11]}$
Critic. The Critic is an MLP $Q_\phi(\mathbf{O}, \mathbf{C}, \mathbf{A})$ §3.2 fig. 2. Its reward is $R$ if the robot reaches the contact within the first $T_r$ steps of the predicted trajectory, and 0 otherwise §3.2. $R$ is 10 in every task tab. 8. The target uses the next tuple from the demonstration, not the Actor's prediction. The paper states this change explicitly eq. 13 §3.2. The discount $\gamma$ is 0.95 tab. 9.

$\mathcal{L}_c = \mathrm{MSE}\big(r + \gamma\, Q_{\phi'}(\mathbf{O}_{t+T_r}, \mathbf{C}'_{t+T_r}, \mathbf{A}_{t+T_r}),\ Q_\phi(\mathbf{O}_t, \mathbf{C}_t, \mathbf{A}_t)\big) \qquad \text{[eq. 13]}$

Here $\mathbf{C}'_{t+T_r}$ is the contact at $t+T_r$ with the same position relative to the object §3.2.

Phased objective contacts. This procedure builds the Guider's targets from a demonstration. It splits the demo where finger contact changes, merges phases with similar object poses, and then assigns each step its target alg. 1 alg. 2 alg. 3 alg. 4 §4.1. Two object poses are similar when the position distance is below $\tau_l$ and the angle is below $\tau_r$ eq. 14.

$\rho = \begin{cases} 1, & \text{if } dl < \tau_l \text{ and } dr < \tau_r \\ 0, & \text{else} \end{cases} \qquad \text{[eq. 14]}$

Pseudocode

# Phased objective contacts  [alg. 1] [alg. 2] [alg. 3] [alg. 4]
# Input:  demo of N steps; max reward R; Q-learning steps Tr
# Output: per step: target C_t, next target C'_t, reward r_t

def phased_objective_contacts(demo, R, Tr, tau_l, tau_r, tau_f):
    # Cut the demo where finger contact changes; keep the object
    # pose at each cut as a subgoal  [alg. 2]
    contacts, poses, cut_steps = record_phases(demo)

    # Merge a phase into the previous one when the object poses are
    # similar  [alg. 3] [eq. 14]
    contacts, poses, cut_steps = merge_similar(
        contacts, poses, cut_steps, tau_l, tau_r)

    # Target is the contact at the current or next phase; reward R
    # if a finger reaches it within Tr steps  [alg. 4]
    targets, next_targets, rewards = configure(
        demo, contacts, poses, cut_steps, R, Tr, tau_f)
    return targets, next_targets, rewards

Noise augmentation for the critic. Demonstrated actions are often suboptimal, so the Critic would score poor trajectories similarly §4.3. The authors add noise to the action $\mathbf{A}_t$ in two levels, chosen with equal probability eq. 15. Minor noise keeps the reward; major noise sets the reward to 0 eq. 16. The target Q-value of major-noise samples is set to 0 eq. 17. $\mu_1 = 0.1$ and $\mu_2 = 1$ §4.3 tab. 9. The minor noise is limited to half the size of a finger §4.3.

$\tilde{\mathbf{A}}_t = P\big(\mathbf{A}_t + \max(\tau_{n1}, \min(\tau_{n2}, \mathcal{N}(0, \mu_1 \mathbf{I})))\big) + (1-P)\big(\mathbf{A}_t + \mathcal{N}(0, \mu_2 \mathbf{I})\big) \qquad \text{[eq. 15]}$
Pseudocode
```
# Noise augmentation for critic samples  [eq. 15] [eq. 16] [eq. 17]
# mu1 = 0.1 and mu2 = 1 as in the paper; tau_n bounds minor noise

def augment(action, reward, tau_n):
    # Minor noise, clipped to tau_n: the reward is kept  [eq. 15]
    if random() < 0.5:
        noise = clip(normal(0, mu1), -tau_n, tau_n)
        return action + noise, reward
    # Major noise: the reward is set to 0  [eq. 16]
    noise = normal(0, mu2)
    return action + noise, 0.0
```
3D encoder. A PointNet encoder is modified in two ways. It drops the input and feature transforms, so the network is sensitive to pose. It drops all normalisation, so it is sensitive to size §4.2. In the Move-T config the encoder is a max-pooled stack of 1x1 convolutions with no normalisation pointcloud_encoder.py. Push-T instead concatenates 9 keypoints with proprioception and skips the encoder §6.2.
Training order. The three networks are trained in sequence, then used together at inference §3.2 train_workspace_real.py. Guider: sample tuples, then train on eq. 2 and eq. 6. Critic: train on eq. 13. Actor: train on eq. 2, eq. 9, eq. 10 and eq. 11 §3.2. Exponential moving averages of the Actor and Guider weights are used at inference. The target critic is a moving average of the critic weights with rate $\sigma = 0.005$ , and two target critics are kept and the minimum is used app. Hyperparameters.

Inference. At each control step the Guider samples a target from the observation. The Actor then samples $T_p$ actions given the observation and the target. The first $T_a$ actions after the observation horizon are executed open-loop fig. 2 hiera_diffusion_policy.py.

Pseudocode

# Inference at every control step  [§3.2] [fig. 2] [tab. 8]

def hdp_act(observations):
    # Guider: denoise the contact target from the observation  [eq. 5]
    contact = guider_denoise(observations)

    # Actor: denoise Tp action steps given observation and contact
    action_seq = actor_denoise(observations, contact)  # (Tp, A)

    # Execute Ta steps starting after the observation horizon, then
    # replan  [fig. 2]
    start = To - 1
    return action_seq[start : start + Ta]

Simulation evaluation. Four simulated families are used: Robomimic Can and Square (proficient and mixed-human demos), Tilt, and Push-T §6.1 tab. 4. Real-robot tasks are Move-T and cloth unfolding §7.

Hyperparameters

Tables 8 and 9 in the paper are reproduced below. Values with a source from the code are noted.

Task	Ctrl	$T_o$	$T_p$	$T_a$	$T_r$	$\tau_l$	$\tau_r$ (deg)	$\tau_f$	SEef	$R$	DimOC	RepPred	DimPred
Can	Pose	2	16	8	8	0.02 m	10	0.004 m	0.016 m	10	8	Pos+6DRot+Close	10
Square	Pose	2	16	8	8	0.02 m	10	0.004 m	0.016 m	10	8	Pos+6DRot+Close	10
Tilt	Pose	2	4	2	2	0.02 m	10	0.004 m	0.016 m	10	8	Pos+AA+Close	7
Push-T	Pos	2	16	8	8	3 (units not stated)	1	7.5	30	10	3	Pos	2
Move-T	Pose	2	16	8	8	0.002 m	1	0.0075 m	0.03 m	10	8	Pos+6DRot+Close	10
Cloth Unfold	Pose	2	16	8	8	-	-	-	-	10	8	Pos+6DRot+Close	10

tab. 8. Pos = position, Close = manipulator closure, 6DRot = 6-D rotation tab. 8. For Push-T the table gives no units for $\tau_l$ , $\tau_f$ and SEef tab. 8. Rotation is 6-D tab. 8 or axis-angle (AA) for Tilt tab. 8.

Network	Batch	Epochs	Steps	Lr	Weight decay	$\eta$	$\gamma$	Params (M)	Diffusion steps	$\sigma$	$\mu_1$	$\mu_2$
Actor	256	3000	-	1e-4	1e-6	1e-3	-	9.5 ± 0.2	10	0.75	-	-
Guider	256	-	3e5	1e-3	1e-6	-	-	1.2 ± 0.1	100	0.75	-	-
Critic	256	-	3e5	1e-3	1e-6	-	0.95	0.8 ± 0.4	-	0.005	0.1	1

tab. 9. $\sigma$ is the EMA coefficient for the Actor and Guider and the target-critic rate for the Critic app. Hyperparameters.

Name	Value	Where	Notes
Demonstrations, Robomimic Can	PH 200; MH 300	tab. 4	Max rollout steps 400
Demonstrations, Robomimic Square	PH 200; MH 300	tab. 4	Max rollout steps 400
Demonstrations, Tilt	200 (AP column)	tab. 4 §6.1	Table 4 lists them as automated-program demos; §6.1 says they come from the RL method MRLNM
Demonstrations, Push-T	200	tab. 4	Max rollout steps 300
Demonstrations, Move-T	192 (push 128, grasp 64)	tab. 4 tab. 5	800 max rollout steps; pushing and grasping are separate subsets
Demonstrations, Cloth	100	tab. 4	300 max rollout steps
Action control mode	pose control	app. Hyperparameters	Follows Diffusion Policy's comparison of pose and velocity control
Push-T control	2-D translation only	app. Hyperparameters	End-effector is a circle
Distance threshold $\tau_f$	one quarter of end-effector size	app. Hyperparameters	Table 8 gives the numbers
Action steps $T_r$	equal to $T_a$	app. Hyperparameters	HDP is not sensitive to $T_r$ fig. 8
Coefficient $\eta$	0.001	§4.4 tab. 9	Best for most tasks tested; too large conflicts with imitation
Target critic count	2, min taken	app. Hyperparameters
Learning-rate schedule	cosine, 500 warm-up steps	hdp_moveT.yaml	Not stated in the paper
Optimizer	AdamW, betas (0.95, 0.999), eps 1e-8	hdp_moveT.yaml	Not stated in the paper
Discount $\gamma$ in config	0.95	hdp_moveT.yaml	Code's class default is 0.99 hiera_diffusion_policy.py
Actor epochs	3000	tab. 9	Guider and Critic run 3e5 steps
Real-robot Move-T action rate	5 Hz	§7.1
Move-T action dimension	5 (text) vs 10 (Table 8)	§7.1 tab. 8	See Pitfalls

Results

Author-reported. Setup: three training seeds; each method evaluated on the average of the last 10 checkpoints (every 50 epochs) across 50 initial conditions, 150 episodes in all §6.2 tab. 1. The Diffusion Policy baseline was reduced in size and reproduced with state-based observations, because the authors found the published numbers inaccurate §6.2 tab. 2. Simulation numbers are therefore not directly comparable with the published Diffusion Policy results. Cells are max / average of the last 10 checkpoints for success rate, except Push-T, where the metric is target-area coverage §6.2 tab. 3.

Encoder ablation on Tilt and Square-ph with 50 demos tab. 1:

Encoder	Tilt (50)	Square-ph (50)	Relative inference time
No 3D encoder	0.66 / 0.49	0.78 / 0.62	1
PointNet	0.02 / 0	0.06 / 0.02	1
PointNet w/o normalisation	0.84 / 0.66	0.72 / 0.57	1
PointNet++	0 / 0	0 / 0	6
PointNet++ w/o normalisation	0.72 / 0.60	0.68 / 0.59	6
Paper's encoder	0.86 / 0.74	0.84 / 0.74	1

Simulation, Robomimic Can and Square tab. 2. LSTM-GMM, IBC and BET numbers are adopted from Chi et al. (2023) rather than rerun §6.2. "Improvement" is the paper's own row, labelled "HDP Improvement", and its definition is not stated.

Task (demos)	LSTM-GMM	IBC	BET	Diffusion Policy	HDP No-OC	HDP $\eta$ =0	HDP $\eta$ =0.001	Paper's "HDP Improvement"
Can-ph (30)	-	-	-	0.88 / 0.81	0.92 / 0.86	0.90 / 0.81	0.94 / 0.86	6.2%
Can-ph (100)	-	-	-	1.00 / 0.99	1.00 / 0.99	1.00 / 1.00	1.00 / 1.00	1.0%
Can-ph (200)	1.00 / 0.91	0.00 / 0.00	1.00 / 0.89	1.00 / 0.97	1.00 / 0.97	1.00 / 0.99	1.00 / 0.99	2.1%
Can-mh (30)	-	-	-	0.82 / 0.73	0.90 / 0.79	0.82 / 0.73	0.82 / 0.74	8.2%
Can-mh (100)	-	-	-	0.96 / 0.89	0.94 / 0.87	0.94 / 0.85	0.98 / 0.89	0%
Can-mh (300)	1.00 / 0.81	0.01 / 0.01	1.00 / 0.90	1.00 / 0.95	1.00 / 0.95	1.00 / 0.94	1.00 / 0.97	2.1%
Square-ph (50)	-	-	-	0.78 / 0.62	0.84 / 0.74	0.88 / 0.72	0.74 / 0.60	19.4%
Square-ph (100)	-	-	-	0.92 / 0.83	0.96 / 0.88	0.96 / 0.86	0.94 / 0.86	6.0%
Square-ph (200)	0.95 / 0.73	0.00 / 0.00	0.76 / 0.52	0.98 / 0.89	0.98 / 0.89	0.98 / 0.91	1.00 / 0.92	3.4%
Square-mh (50)	-	-	-	0.40 / 0.28	0.62 / 0.46	0.62 / 0.44	0.56 / 0.44	64.3%
Square-mh (100)	-	-	-	0.72 / 0.61	0.84 / 0.68	0.86 / 0.71	0.82 / 0.69	16.4%
Square-mh (300)	0.86 / 0.59	0.00 / 0.00	0.68 / 0.43	0.90 / 0.76	0.92 / 0.73	0.96 / 0.77	0.94 / 0.79	3.9%

Simulation, Tilt and Push-T tab. 3.

Task (demos)	LSTM-GMM	IBC	BET	Diffusion Policy	HDP No-OC	HDP $\eta$ =0	HDP $\eta$ =0.001	Paper's "HDP Improvement"
Tilt (50)	-	-	-	0.66 / 0.49	0.86 / 0.74	0.82 / 0.71	0.90 / 0.74	51.0%
Tilt (100)	-	-	-	0.64 / 0.48	0.86 / 0.76	0.88 / 0.76	0.96 / 0.82	70.8%
Tilt (200)	-	-	-	0.76 / 0.63	0.94 / 0.76	0.96 / 0.84	0.96 / 0.88	39.7%
Push-T (50)	-	-	-	0.79 / 0.67	0.79 / 0.67	0.84 / 0.71	0.86 / 0.73	9.0%
Push-T (100)	-	-	-	0.97 / 0.87	0.97 / 0.87	0.98 / 0.86	0.94 / 0.83	0%
Push-T (200)	0.67 / 0.61	0.90 / 0.84	0.79 / 0.70	1.00 / 0.95	1.00 / 0.95	1.00 / 0.97	1.00 / 0.96	2.1%

On Push-T, the HDP No-OC row equals Diffusion Policy because no 3D encoder is used there tab. 3.

Real robot, Move-T. UR5e with a parallel gripper, 20 test runs per method and per dataset tab. 5 §7.1. Stage 2 succeeds when IoU exceeds 0.8 and the end-effector reaches the end-zone. Stage 1 succeeds when only IoU is met tab. 5.

Metric	DP Push	DP Grasp	DP Both	HDP Push	HDP Grasp	HDP Both
Success, stage 1	0.20	0.00	0.15	0.15	0.00	0.05
Success, stage 2	0.35	0.45	0.30	0.65	0.75	0.60
Average IoU, stage 2	0.96	0.94	0.96	0.94	0.95	0.93
Average IoU, final	0.57	0.54	0.52	0.78	0.72	0.63

tab. 5. The paper reports an average success-rate improvement of 84.1% for Move-T §7.1 and 26.7% for cloth §7.2.

Prompt guidance, Move-T, policies trained on the push dataset, 7 scenarios tab. 6 §7.1:

Metric	Diffusion Policy	HDP	HDP with prompts
Success, stage 2	0.29	0.29	0.71
Average IoU	0.43	0.63	0.74

The paper states a 145% increase in success rate from prompts §7.1. Prompts are placed with a visual interface; no more than 3 per scenario §7.1 app. Prompt Specifying Method.

Cloth unfolding, 50 trials per method tab. 7 §7.2:

Method	Planning failure	Lift both layers	Other corners folded	Success
Diffusion Policy	6	14	0	0.60
HDP	6	2	4	0.76

Paper vs code

Code is the repository the paper links, at commit f5d63571a87ace19ddde1dc21f1624011c493ba5. It is under the first author's GitHub account (dexin-wang). A search of the whole tree found no LICENSE file, so the code is cited by path and line only, with no quotes. The authors' README says real-robot data and code are "being collated" README.md. The Move-T config points at a real-robot data file that is not in the repository hdp_moveT.yaml.

Q-learning term. Paper Eq. 9 is $\mathrm{MSE} - \eta Q$ . The code picks one of the two critics at random each step and divides the Q term by the detached mean absolute value of the other critic's Q hiera_diffusion_policy.py. This normalisation is not in the paper.
Critic noise augmentation. The paper applies minor or major noise to every sample with equal probability eq. 15 eq. 16. The code leaves half the samples unchanged, gives a quarter minor noise, and a quarter major noise hiera_diffusion_policy.py. Minor noise is applied to all steps except the last hiera_diffusion_policy.py.
Minor-noise clip. The paper gives no number, only "half the size of a finger" §4.3. The code clips to $\text{fin\_rad}/2$ times the action scale hiera_diffusion_policy.py. The Move-T config does not set fin_rad, so it uses the policy default of 0.008 hiera_diffusion_policy.py. The Move-T subgoal stage uses fin_rad=0.015 real_moveT_pcd_replay_dataset.py. The same parameter name therefore carries two values within the Move-T setup.
Terminal flag. The code sets done when the reward equals the literal 10 hiera_diffusion_policy.py hiera_diffusion_policy.py. Paper Eq. 13 has no terminal term.
Two critics. The paper's Eq. 13 has one Q-function. The code sums the MSE of two critics hiera_diffusion_policy.py and uses the minimum of two target critics for the Bellman target hiera_diffusion_policy.py.
One-step denoising. The single-step path calls noise_scheduler_actor.step_batch hiera_diffusion_policy.py. The method is not defined in the repository. The environment pins diffusers==0.11.1 conda_environment.yaml. I did not check whether that version provides step_batch.
Noise variance and clipping. The paper writes the reverse-step variance as $(1-\alpha^k)\mathbf{I}$ eq. 3. The configs use variance_type: fixed_small and clip_sample: true for both schedulers hdp_moveT.yaml. The paper's equations include no clipping.
EMA. The Move-T config caps the EMA decay at 0.9999 and sets the power to 0.75 hdp_moveT.yaml. The decay is clipped to that cap in get_decay ema_model_hdp.py. The cap is not in the paper. The target critic uses a fixed rate of 0.005 hiera_diffusion_policy.py, matching $\sigma = 0.005$ tab. 9.
Contact definition. The paper does not give a contact threshold. The code calls a finger "in contact" when its distance to the object cloud is below fin_rad + 0.01 robot.py robot.py. The last $T_r$ steps are forced to contact robot.py.
Move-T point clouds. Contact detection uses a 2100-point T-block cloud real_moveT_pcd_replay_dataset.py real_moveT_pcd_replay_dataset.py. The policy observation uses 700 points real_moveT_pcd_replay_dataset.py real_moveT_pcd_replay_dataset.py. Table 4 lists 700 object points for Move-T tab. 4.
Move-T action dimension. The text lists 5 action dimensions §7.1 and Table 8 gives 10 predicted dimensions with 6-D rotation tab. 8. The config uses action_dim: 10 with rotation_6d hdp_moveT.yaml real_moveT_pcd_replay_dataset.py. The code follows Table 8.
Tilt. is_tilt: true divides the policy's fin_rad by 0.01 hiera_diffusion_policy.py hdp_tilt.yaml. The paper does not mention this.
Discount. The Move-T config sets $\gamma = 0.95$ hdp_moveT.yaml. The class default is 0.99 hiera_diffusion_policy.py. Table 9 gives 0.95 tab. 9.
Mode in config. The Move-T config defaults to mode: grasp hdp_moveT.yaml. The paper's combined experiment uses all 192 demos tab. 5.
Guider output. Predicted flags are rounded with torch.round, and each finger position is multiplied by its flag hiera_diffusion_policy.py. The paper states only that non-contacting targets are 0 app. Hyperparameters.

Batch size, epochs, steps, learning rates and weight decay in the Move-T config match Table 9 hdp_moveT.yaml hdp_moveT.yaml hdp_moveT.yaml tab. 9. I did not check the other task configs.

Pitfalls

Headline numbers. The abstract's 20.8% is not derived in the text. I recomputed it from the tables: it equals the unweighted mean of the 18 simulation "HDP Improvement" entries (tabs. 2 and 3, 17.0%) plus the two real-robot task improvements (84.1% and 26.7%). Check this before quoting the headline as a per-task average.
Move-T success figure. The text's 84.1% average success improvement §7.1 does not follow from Table 5 with a simple mean of the stage-2 success rates. Those give 0.667 for HDP and 0.367 for DP, a 81.8% gain tab. 5. The paper does not say how 84.1% is computed.
Baseline. The Diffusion Policy baseline is smaller and reproduced §6.2 tab. 2. Its numbers differ from the published Diffusion Policy results, so the comparison is within the paper only.
Ablation signal. The HDP-vs-DP gain on Can-mh (100) and Push-T (100) is 0% tab. 2 tab. 3. No variance is reported, so small gaps cannot be judged.
Phased contacts. The paper says phased contacts improve success and stability on three tasks §5.3 fig. 7. This is not evidence for every task.
Push-T units. Table 8 gives $\tau_l = 3$ , $\tau_f = 7.5$ and SEef = 30 with no units tab. 8. Do not carry these numbers across environments without the unit definitions from the code.
Eta sensitivity. Eta = 0.001 is best for most tasks tested, and larger values conflict with imitation §4.4. The per-task choice is not reported as a sweep.
Snapshot gradient cost claim. The 4x speed-up and 24% memory saving are reported at 10 denoising steps only §4.4. Not verified beyond the paper.
Prompts. For Move-T, prompts set x and y from the mouse click and z to a constant: the mean z of the collected demonstrations app. Prompt Specifying Method. Prompts that are out of the demonstration distribution can conflict with the task §5.2 §8.
Real-robot reproducibility. The Move-T and cloth real-robot code and data are not in the repository, and the README says they are being collated README.md. The point cloud for Move-T is built by ICP alignment of a pre-built T-block model §7.1. That pipeline is not in the repository.
Cost per control step. Each control step runs 100 Guider denoising steps and 10 Actor denoising steps tab. 9 before any execution. The authors do not report wall-clock latency for the full pipeline.
Equation numbering. Equation numbers were counted from the LaTeX source. Verify against the compiled PDF.

Lineage

Builds on: Diffusion Policy (Chi et al., 2023): the Actor's architecture, receding-horizon control and state-based comparison protocol §2.3 §3.2. Q-learning for diffusion policies (Wang et al., 2022): the value-based fine-tuning idea §2.2 §4.4. The authors' earlier contact-subgoal work MRLNM (Wang et al., 2024): the source of the Tilt demonstrations and the threshold setting §2.1 §6.1 app. Hyperparameters.
Compared against: Diffusion Policy, LSTM-GMM, IBC and BET in simulation §6.2 tab. 2 tab. 3.
Related concurrent work: Ma et al., a hierarchical diffusion policy that predicts an end pose first §2.3.
Superseded by: not stated in the paper or the repository.

Source and license

Adapted from “Hierarchical Diffusion Policy: manipulation trajectory generation via contact guidance” by Dexin Wang, Chunsheng Liu, Faliang Chang, Yichen Xu (arXiv:2411.12982), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/dexin-wang/Hierarchical_Diffusion_Policy at commit f5d63571a87a (not stated (no LICENSE file in repository)). Any quoted code is shown under that license.