feat(layout): improving overall layout

app/src/content/chapters/folding/06-training.mdx

@@ -28,9 +28,11 @@ The model generates actions through **flow matching**, a generative approach tha
   Flow matching is closely related to diffusion models but uses a simpler, more direct interpolation path between noise and data. 
 </Sidenote>
 
+Before diving further into the model architecture, let's introduce a few key ingredients: [RTC](https://huggingface.co/docs/lerobot/rtc), [SARM](https://huggingface.co/docs/lerobot/sarm) and [relative actions](https://huggingface.co/docs/lerobot/action_representations).
+
 #### [Real-Time Chunking (RTC)](https://huggingface.co/docs/lerobot/rtc)
 
-RTC was crucial for real-world deployment. Instead of waiting for the predicted action chunk to finish before generating the next, RTC generates the next chunk while executing the current one. It "freezes" actions that are already committed and "inpaints" the remaining ones, producing smooth asynchronous motion. In practice, this sped up our rollouts by at least a factor of 2.
+RTC is crucial for real-world deployment. Instead of waiting for the predicted action chunk to finish before generating the next, RTC generates the next chunk while executing the current one. It "freezes" actions that are already committed and "inpaints" the remaining ones, producing smooth asynchronous motion. In practice, this sped up our rollouts by at least a factor of 2.
 
 ```mermaid
 sequenceDiagram
@@ -43,6 +45,35 @@ sequenceDiagram
     end
 ```
 
+#### [Stage-Aware Reward Modeling (SARM)](https://huggingface.co/docs/lerobot/sarm)
+
+SARM is a trained reward model that scores trajectories based on how well the robot is progressing toward task completion, it acts as a learned "critic" that predicts whether things are going well or badly.
+
+SARM is trained on our demonstration data to predict 0-1 task progression. The takeaway: it correctly identifies **mistakes** (drops in value) and **progress** (increases) in real time.
+
+<Wide>
+<Stack layout="3-column" gap="small">
+  <img src={sarmEp300.src} alt="SARM annotation on episode 300" style="width:100%; border-radius: 8px;" />
+  <img src={sarmEp2500.src} alt="SARM annotation on episode 2500" style="width:100%; border-radius: 8px;" />
+  <img src={sarmEp2200.src} alt="SARM annotation on episode 2200" style="width:100%; border-radius: 8px;" />
+</Stack>
+</Wide>
+
+We use SARM exclusively for **RABC** (Reward-Advantage-Based Conditioning): every episode is scored with a per-timestep quality signal, and during training, actions are weighted by their contribution to progress. High-reward actions contribute more to the loss, low-reward ones contribute less. Negative progress is clipped to 0. Unlike binary success/fail labels, SARM provides a continuous signal at every timestep.
+
+#### [Relative actions representation](https://huggingface.co/docs/lerobot/action_representations)
+
+Following [UMI](https://arxiv.org/abs/2402.10329) approach, actions are expressed as **relative trajectories**: each action in the chunk is an offset from the robot's current state at prediction time, not from the previous action. This avoids error accumulation (unlike true delta) and doesn't require a global coordinate frame (unlike absolute). 
+
+<HtmlEmbed
+  id="action-representations"
+  src="folding/action-representations.html"
+  title="Action Representations"
+  desc="Relative trajectory (blue) references all actions to the current state. Delta (yellow) chains each action to the previous one, accumulating error. Absolute (red) requires a global coordinate frame. Diagram adapted from UMI (Chi et al., 2024)."
+/>
+
+See the [LeRobot action representations docs](https://huggingface.co/docs/lerobot/action_representations) for a full guide on how to use relative actions in your own training.
+
 ### Models
 
 We initially trained multiple architectures supported in LeRobot, but we ended up focusing on two VLA architectures for our cloth folding data:

app/src/content/chapters/folding/08-ablations.mdx

@@ -30,36 +30,9 @@ We ran 11 experiments to understand what *actually* matters. **Series 1** trains
 
 </Wide>
 
-All experiments use **[RTC](https://huggingface.co/docs/lerobot/rtc)** (Real-Time Chunking) and **action interpolation** (upsampling from 30 Hz to 90 Hz). The RTC settings used across all experiments:
+All experiments use **[RTC](https://huggingface.co/docs/lerobot/rtc)** (Real-Time Chunking) with an action queue size of 30 and a maximum action horizon of 20, along with **action interpolation** (upsampling from 30 Hz to 90 Hz).
 
-```python
-policy_cfg.rtc_config = RTCConfig(
-    enabled=True,
-    execution_horizon=20,
-    max_guidance_weight=5.0,
-    prefix_attention_schedule=RTCAttentionSchedule.LINEAR,
-)
-```
-
-with an action queue size of 30 and a maximum action horizon of 20. 
-
-RTC gave us a ~2x speedup (sometimes even 2.5x) and action interpolation made the robot much quieter and smoother. Both are now available on [LeRobot main](https://github.com/huggingface/lerobot).
-
-### SARM: Our Reward Model
-
-Before diving into the experiments further, let's introduce a key ingredient: **[SARM](https://huggingface.co/docs/lerobot/sarm)** (Stage-Aware Reward Modeling). SARM is a trained reward model that scores trajectories based on how well the robot is progressing toward task completion, it acts as a learned "critic" that predicts whether things are going well or badly.
-
-SARM is trained on our demonstration data to predict 0-1 task progression. The takeaway: it correctly identifies **mistakes** (drops in value) and **progress** (increases) in real time.
-
-<Wide>
-<Stack layout="3-column" gap="small">
-  <img src={sarmEp300.src} alt="SARM annotation on episode 300" style="width:100%; border-radius: 8px;" />
-  <img src={sarmEp2500.src} alt="SARM annotation on episode 2500" style="width:100%; border-radius: 8px;" />
-  <img src={sarmEp2200.src} alt="SARM annotation on episode 2200" style="width:100%; border-radius: 8px;" />
-</Stack>
-</Wide>
-
-We use SARM exclusively for **RABC** (Reward-Advantage-Based Conditioning): every episode is scored with a per-timestep quality signal, and during training, actions are weighted by their contribution to progress. High-reward actions contribute more to the loss, low-reward ones contribute less. Negative progress is clipped to 0. Unlike binary success/fail labels, SARM provides a continuous signal at every timestep.
+RTC gave us a ~2x speedup (sometimes even 2.5x) and action interpolation made the robot much quieter and smoother. Both are now available on [LeRobot repository](https://github.com/huggingface/lerobot).
 
 ---
 
@@ -141,32 +114,6 @@ We hypothesise that the root cause is the difference in **multi-modality** betwe
 
 #### 2. Relative actions improve performance consistently
 
-We use **relative trajectory** actions as defined by [UMI](https://arxiv.org/abs/2402.10329): each action in the chunk is an offset from the robot's current state at prediction time, not from the previous action. This avoids error accumulation (unlike true delta) and doesn't require a global coordinate frame (unlike absolute). LeRobot uses absolute actions by default — switching to relative trajectory was one of our key improvements. See the [LeRobot action representations docs](https://huggingface.co/docs/lerobot/action_representations) for a full guide on how to use relative actions in your own training.
-
-<HtmlEmbed
-  id="action-representations"
-  src="folding/action-representations.html"
-  title="Action Representations"
-  desc="Relative trajectory (blue) references all actions to the current state. Delta (yellow) chains each action to the previous one, accumulating error. Absolute (red) requires a global coordinate frame. Diagram adapted from UMI (Chi et al., 2024)."
-/>
-
-To enable relative actions for π0/π0.5, first precompute the relative action statistics for your dataset, then train with the flag enabled:
-
-```bash
-# Precompute relative action stats
-lerobot-edit-dataset \
-    --repo_id your_dataset \
-    --operation.type recompute_stats \
-    --operation.relative_action true \
-    --operation.chunk_size 50
-
-# Train with relative actions
-lerobot-train \
-    --dataset.repo_id=your_dataset \
-    --policy.type=pi0 \
-    --policy.use_relative_actions=true
-```
-
 Comparing π0.5 without relative actions (1.2: 20% total SR, 40% Level 1) to π0.5 with relative actions and quantile normalization (1.3: 35% total SR, 70% Level 1), and then to the full combination in 1.7 (40% total SR, 80% Level 1), shows that training with relative actions consistently improves performance. The trend is clear and shows up in every comparison we made.
 
 With only 20 rollouts, the exact gap between experiments is hard to pin down — but the improvement is consistent across every comparison. **Caveat:** π0.5 is likely pretrained with relative actions, so 1.3 and 1.7 fine-tune in a regime consistent with pretraining, while 1.2 fine-tunes against it.

app/src/content/chapters/folding/09-learnings.mdx

@@ -22,31 +22,59 @@ If you're training a policy for a new manipulation task with LeRobot, **here's t
 2. **Collect 50–100 clean demonstrations.** Quality over volume. Consistent technique, good camera angles, deliberate motions. This is your foundation, everything else builds on it.
 3. **Train a reward model.** Use [SARM](https://huggingface.co/docs/lerobot/sarm) to score your episodes and enable RABC during training. This allows the policy to focus on the best demonstrations, which is crucial for longer tasks.
 4. **Train a baseline and watch it fail.** Film the rollouts. Understanding *how* and *where* it breaks tells you exactly what kind of data to collect next.
-5. **Use DAgger for targeted improvement.** Once you have a model that mostly works, collect correction data for its specific failure modes. LeRobot's [HIL scripts](https://github.com/huggingface/lerobot/tree/main/examples/hil) handle the full loop, the operator watches the policy run, pauses on failure, teleoperates a recovery, and hands control back:
+5. **Enable action interpolation and [RTC](https://huggingface.co/docs/lerobot/rtc).** This smooths transitions and speeds up execution. Action interpolation upsamples the policy's 30 Hz output to your robot's control frequency (e.g. 90 Hz), and RTC overlaps inference with execution. Both features are available at inference time with flags on `lerobot-eval`:
 
 ```bash
-python examples/hil/hil_data_collection.py \
+lerobot-eval \
+    --policy.path=outputs/checkpoints/last/pretrained_model \
     --robot.type=bi_openarm_follower \
-    --teleop.type=openarm_mini \
-    --policy.path=outputs/pretrain/checkpoints/last/pretrained_model \
-    --dataset.repo_id=your-username/hil-dataset \
+    --policy.device=cuda \
     --rtc.enabled=true \
-    --rtc.execution_horizon=20
+    --rtc.execution_horizon=20 \
+    --interpolation_multiplier=3
 ```
 
-6. **Enable action interpolation and RTC.** This smooths transitions and speeds up execution. Action interpolation upsamples the policy's 30 Hz output to your robot's control frequency (e.g. 90 Hz), and RTC overlaps inference with execution. Both features are flags on `lerobot-eval`:
+RTC can also be enabled at training time with the appropriate configuration:
+
+```python
+policy_cfg.rtc_config = RTCConfig(
+    enabled=True,
+    execution_horizon=20,
+    max_guidance_weight=5.0,
+    prefix_attention_schedule=RTCAttentionSchedule.LINEAR,
+)
+```
+
+6. **Find the right [action representation](https://huggingface.co/docs/lerobot/action_representations).** LeRobot uses absolute actions by default. Switching to relative trajectory was one of our key improvements, and unlocked consistency with π0.5 pretraining. To enable relative actions for π0/π0.5 using LeRobot, first precompute the relative action statistics for your dataset, then train with the flag enabled:
 
 ```bash
-lerobot-eval \
-    --policy.path=outputs/checkpoints/last/pretrained_model \
+# Precompute relative action stats
+lerobot-edit-dataset \
+    --repo_id your_dataset \
+    --operation.type recompute_stats \
+    --operation.relative_action true \
+    --operation.chunk_size 50
+
+# Train with relative actions
+lerobot-train \
+    --dataset.repo_id=your_dataset \
+    --policy.type=pi0 \
+    --policy.use_relative_actions=true
+```
+
+7. **Use DAgger for targeted improvement.** Once you have a model that mostly works, collect correction data for its specific failure modes. LeRobot's [HIL scripts](https://github.com/huggingface/lerobot/tree/main/examples/hil) handle the full loop, the operator watches the policy run, pauses on failure, teleoperates a recovery, and hands control back:
+
+```bash
+python examples/hil/hil_data_collection.py \
     --robot.type=bi_openarm_follower \
-    --policy.device=cuda \
+    --teleop.type=openarm_mini \
+    --policy.path=outputs/pretrain/checkpoints/last/pretrained_model \
+    --dataset.repo_id=your-username/hil-dataset \
     --rtc.enabled=true \
-    --rtc.execution_horizon=20 \
-    --interpolation_multiplier=3
+    --rtc.execution_horizon=20
 ```
 
-7. **Film every evaluation.** Metrics alone won't tell the full story. Video reveals subtle failure modes that success rate misses, and lets you score quality.
+8. **Film every evaluation.** Metrics alone won't tell the full story. Video reveals subtle failure modes that success rate misses, and lets you score quality.
 
 <Note variant="info">
   All the innovations from this project [SARM](https://huggingface.co/docs/lerobot/sarm), [RTC](https://huggingface.co/docs/lerobot/rtc), DAgger, [OpenArm](https://huggingface.co/docs/lerobot/openarm), and OpenArm Mini are merged into [LeRobot repository](https://github.com/huggingface/lerobot). You can use our full pipeline as a starting point and swap in your own task.