{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 在你的数据集上训练 Action-Chunking-Transformer (ACT)\n",
    "在你的自定义数据集上训练 ACT 模型。本示例中 chunk_size 设为 10。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ACT 算法背景与上下文（给初学者）\n",
    "\n",
    "ACT（Action Chunking Transformer）是一个从视觉+状态直接预测一段动作序列的模仿学习策略。\n",
    "\n",
    "这个 notebook 的核心目标：\n",
    "1. 从数据集读取观测（图像、状态）与动作标签。\n",
    "2. 训练 ACTPolicy 学会在每个时刻预测 `chunk_size` 长度的动作片段。\n",
    "3. 在推理时滚动执行预测动作，并与真实动作对比误差。\n",
    "\n",
    "为什么要 Action Chunking：\n",
    "- 单步动作回归容易抖动且短视。\n",
    "- 一次预测多步动作可以提升时间一致性与执行稳定性。\n",
    "- 在固定采样频率（例如 20Hz）下，多步预测更接近短期规划。\n",
    "\n",
    "你当前任务中的数据模态：\n",
    "- 输入：`observation.image`（相机图像）+ `observation.state`（状态）。\n",
    "- 输出：`action`（7 维，6 关节 + 1 夹爪）。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Env Info] 运行环境已就绪，当前工作目录: C:\\Users\\kewei\\lerobot-mujoco-tutorial\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "from lerobot.common.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata\n",
    "from lerobot.common.datasets.utils import dataset_to_policy_features\n",
    "from lerobot.common.policies.act.configuration_act import ACTConfig\n",
    "from lerobot.common.policies.act.modeling_act import ACTPolicy\n",
    "from lerobot.configs.types import FeatureType\n",
    "from lerobot.common.datasets.factory import resolve_delta_timestamps\n",
    "import torchvision\n",
    "import env_config\n",
    "import os\n",
    "os.environ[\"HF_DATASETS_CACHE\"] = \"./.hf_cache_py310\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\")\n",
    "\n",
    "# Number of offline training steps (we'll only do offline training for this example.)\n",
    "# Adjust as you prefer. 5000 steps are needed to get something worth evaluating.\n",
    "training_steps = 5000\n",
    "log_freq = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 策略配置与初始化\n",
    "\n",
    "chunk_size = 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Device 'None' is not available. Switching to 'cuda'.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "ACTPolicy(\n",
       "  (normalize_inputs): Normalize(\n",
       "    (buffer_observation_image): ParameterDict(\n",
       "        (mean): Parameter containing: [torch.cuda.FloatTensor of size 3x1x1 (cuda:0)]\n",
       "        (std): Parameter containing: [torch.cuda.FloatTensor of size 3x1x1 (cuda:0)]\n",
       "    )\n",
       "    (buffer_observation_state): ParameterDict(\n",
       "        (mean): Parameter containing: [torch.cuda.FloatTensor of size 6 (cuda:0)]\n",
       "        (std): Parameter containing: [torch.cuda.FloatTensor of size 6 (cuda:0)]\n",
       "    )\n",
       "  )\n",
       "  (normalize_targets): Normalize(\n",
       "    (buffer_action): ParameterDict(\n",
       "        (mean): Parameter containing: [torch.cuda.FloatTensor of size 7 (cuda:0)]\n",
       "        (std): Parameter containing: [torch.cuda.FloatTensor of size 7 (cuda:0)]\n",
       "    )\n",
       "  )\n",
       "  (unnormalize_outputs): Unnormalize(\n",
       "    (buffer_action): ParameterDict(\n",
       "        (mean): Parameter containing: [torch.cuda.FloatTensor of size 7 (cuda:0)]\n",
       "        (std): Parameter containing: [torch.cuda.FloatTensor of size 7 (cuda:0)]\n",
       "    )\n",
       "  )\n",
       "  (model): ACT(\n",
       "    (vae_encoder): ACTEncoder(\n",
       "      (layers): ModuleList(\n",
       "        (0-3): 4 x ACTEncoderLayer(\n",
       "          (self_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
       "          )\n",
       "          (linear1): Linear(in_features=512, out_features=3200, bias=True)\n",
       "          (dropout): Dropout(p=0.1, inplace=False)\n",
       "          (linear2): Linear(in_features=3200, out_features=512, bias=True)\n",
       "          (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (dropout1): Dropout(p=0.1, inplace=False)\n",
       "          (dropout2): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "      )\n",
       "      (norm): Identity()\n",
       "    )\n",
       "    (vae_encoder_cls_embed): Embedding(1, 512)\n",
       "    (vae_encoder_robot_state_input_proj): Linear(in_features=6, out_features=512, bias=True)\n",
       "    (vae_encoder_action_input_proj): Linear(in_features=7, out_features=512, bias=True)\n",
       "    (vae_encoder_latent_output_proj): Linear(in_features=512, out_features=64, bias=True)\n",
       "    (backbone): IntermediateLayerGetter(\n",
       "      (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "      (bn1): FrozenBatchNorm2d(64, eps=1e-05)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "      (layer1): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(64, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(64, eps=1e-05)\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(64, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(64, eps=1e-05)\n",
       "        )\n",
       "      )\n",
       "      (layer2): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(128, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(128, eps=1e-05)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): FrozenBatchNorm2d(128, eps=1e-05)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(128, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(128, eps=1e-05)\n",
       "        )\n",
       "      )\n",
       "      (layer3): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(256, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(256, eps=1e-05)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): FrozenBatchNorm2d(256, eps=1e-05)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(256, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(256, eps=1e-05)\n",
       "        )\n",
       "      )\n",
       "      (layer4): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(512, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(512, eps=1e-05)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): FrozenBatchNorm2d(512, eps=1e-05)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): FrozenBatchNorm2d(512, eps=1e-05)\n",
       "          (relu): ReLU(inplace=True)\n",
       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): FrozenBatchNorm2d(512, eps=1e-05)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (encoder): ACTEncoder(\n",
       "      (layers): ModuleList(\n",
       "        (0-3): 4 x ACTEncoderLayer(\n",
       "          (self_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
       "          )\n",
       "          (linear1): Linear(in_features=512, out_features=3200, bias=True)\n",
       "          (dropout): Dropout(p=0.1, inplace=False)\n",
       "          (linear2): Linear(in_features=3200, out_features=512, bias=True)\n",
       "          (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (dropout1): Dropout(p=0.1, inplace=False)\n",
       "          (dropout2): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "      )\n",
       "      (norm): Identity()\n",
       "    )\n",
       "    (decoder): ACTDecoder(\n",
       "      (layers): ModuleList(\n",
       "        (0): ACTDecoderLayer(\n",
       "          (self_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
       "          )\n",
       "          (multihead_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
       "          )\n",
       "          (linear1): Linear(in_features=512, out_features=3200, bias=True)\n",
       "          (dropout): Dropout(p=0.1, inplace=False)\n",
       "          (linear2): Linear(in_features=3200, out_features=512, bias=True)\n",
       "          (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "          (dropout1): Dropout(p=0.1, inplace=False)\n",
       "          (dropout2): Dropout(p=0.1, inplace=False)\n",
       "          (dropout3): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "      )\n",
       "      (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "    )\n",
       "    (encoder_robot_state_input_proj): Linear(in_features=6, out_features=512, bias=True)\n",
       "    (encoder_latent_input_proj): Linear(in_features=32, out_features=512, bias=True)\n",
       "    (encoder_img_feat_input_proj): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "    (encoder_1d_feature_pos_embed): Embedding(2, 512)\n",
       "    (encoder_cam_feat_pos_embed): ACTSinusoidalPositionEmbedding2d()\n",
       "    (decoder_pos_embed): Embedding(10, 512)\n",
       "    (action_head): Linear(in_features=512, out_features=7, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# When starting from scratch (i.e. not from a pretrained policy), we need to specify 2 things before\n",
    "# creating the policy:\n",
    "#   - input/output shapes: to properly size the policy\n",
    "#   - dataset stats: for normalization and denormalization of input/outputs\n",
    "dataset_metadata = LeRobotDatasetMetadata(\"datawhale_eai_pnp\", root='./demo_data')\n",
    "features = dataset_to_policy_features(dataset_metadata.features)\n",
    "output_features = {key: ft for key, ft in features.items() if ft.type is FeatureType.ACTION}\n",
    "input_features = {key: ft for key, ft in features.items() if key not in output_features}\n",
    "input_features.pop(\"observation.wrist_image\")\n",
    "# Policies are initialized with a configuration class, in this case `DiffusionConfig`. For this example,\n",
    "# we'll just use the defaults and so no arguments other than input/output features need to be passed.\n",
    "cfg = ACTConfig(input_features=input_features, output_features=output_features, chunk_size= 10, n_action_steps=10)\n",
    "# This allows us to construct the data with action chunking\n",
    "delta_timestamps = resolve_delta_timestamps(cfg, dataset_metadata)\n",
    "# We can now instantiate our policy with this config and the dataset stats.\n",
    "policy = ACTPolicy(cfg, dataset_stats=dataset_metadata.stats)\n",
    "policy.train()\n",
    "policy.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ACT 模型结构导图（Mermaid）\n",
    "\n",
    "```mermaid\n",
    "flowchart TD\n",
    "    A[\"Batch 输入\\nobservation.image: (B, C, H, W)\\nobservation.state: (B, S)\\naction 标签: (B, T, A)\"] --> B1[\"Normalize Inputs\\nimage/state 按统计量归一化\"]\n",
    "    B1 --> C1[\"视觉 Backbone (ResNet)\\n提取图像特征\"]\n",
    "    B1 --> C2[\"状态投影\\nLinear(S->D)\"]\n",
    "    C1 --> D1[\"Transformer Encoder\\n融合视觉 token + 状态 token + 潜变量 token\"]\n",
    "    C2 --> D1\n",
    "    D1 --> E1[\"Transformer Decoder\\n按 chunk_size 生成动作序列\"]\n",
    "    E1 --> F1[\"Action Head\\nLinear(D->A)\"]\n",
    "    F1 --> G1[\"Predicted Actions\\n(B, T, A)\"]\n",
    "    G1 --> H1[\"Unnormalize Outputs\\n恢复动作物理尺度\"]\n",
    "    H1 --> I1[\"损失计算（训练）\\n与 GT action 对齐\"]\n",
    "```\n",
    "\n",
    "符号说明：\n",
    "- `B`: batch size\n",
    "- `T`: chunk_size（一次预测的动作步数）\n",
    "- `A`: action 维度（本项目是 7）\n",
    "- `D`: hidden dim（你的模型里是 512）\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据集\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision import transforms\n",
    "\n",
    "class AddGaussianNoise(object):\n",
    "    \"\"\"\n",
    "    Adds Gaussian noise to a tensor.\n",
    "    \"\"\"\n",
    "    def __init__(self, mean=0., std=0.01):\n",
    "        self.mean = mean\n",
    "        self.std = std\n",
    "\n",
    "    def __call__(self, tensor):\n",
    "        # Adds noise: tensor remains a tensor.\n",
    "        noise = torch.randn(tensor.size()) * self.std + self.mean\n",
    "        return tensor + noise\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}(mean={self.mean}, std={self.std})\"\n",
    "\n",
    "# Create a transformation pipeline that converts a PIL image to a tensor, then adds noise.\n",
    "class Clamp01(object):\n",
    "    def __call__(self, tensor):\n",
    "        return tensor.clamp(0, 1)\n",
    "\n",
    "\n",
    "transform = transforms.Compose([\n",
    "    AddGaussianNoise(mean=0., std=0.02),\n",
    "    Clamp01(),\n",
    "])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove-Item -Recurse -Force \"$env:USERPROFILE\\.cache\\huggingface\\datasets\\parquet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "patched hf_transform_to_torch\n"
     ]
    }
   ],
   "source": [
    "# Patch lerobot image transform for parquet rows that decode images as dict{'bytes','path'}\n",
    "import io\n",
    "import torch\n",
    "import torchvision.transforms as T\n",
    "from PIL import Image\n",
    "\n",
    "import lerobot.common.datasets.utils as ds_utils\n",
    "import lerobot.common.datasets.lerobot_dataset as ds_mod\n",
    "\n",
    "def hf_transform_to_torch_patched(items_dict):\n",
    "    to_tensor = T.ToTensor()\n",
    "    for key in items_dict:\n",
    "        first_item = items_dict[key][0]\n",
    "\n",
    "        # Case 1: normal PIL images\n",
    "        if isinstance(first_item, Image.Image):\n",
    "            items_dict[key] = [to_tensor(img) for img in items_dict[key]]\n",
    "\n",
    "        # Case 2: dict image payload from parquet: {'bytes': ..., 'path': ...}\n",
    "        elif isinstance(first_item, dict) and (\"bytes\" in first_item or \"path\" in first_item):\n",
    "            out = []\n",
    "            for x in items_dict[key]:\n",
    "                if isinstance(x, dict) and x.get(\"bytes\") is not None:\n",
    "                    img = Image.open(io.BytesIO(x[\"bytes\"])).convert(\"RGB\")\n",
    "                    out.append(to_tensor(img))\n",
    "                else:\n",
    "                    # fallback: keep as is\n",
    "                    out.append(x)\n",
    "            items_dict[key] = out\n",
    "\n",
    "        elif first_item is None:\n",
    "            pass\n",
    "        else:\n",
    "            items_dict[key] = [x if isinstance(x, str) else torch.tensor(x) for x in items_dict[key]]\n",
    "    return items_dict\n",
    "\n",
    "# patch both references used by lerobot\n",
    "ds_utils.hf_transform_to_torch = hf_transform_to_torch_patched\n",
    "ds_mod.hf_transform_to_torch = hf_transform_to_torch_patched\n",
    "\n",
    "print(\"patched hf_transform_to_torch\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:'torchcodec' is not available in your platform, falling back to 'pyav' as a default decoder\n"
     ]
    }
   ],
   "source": [
    "# We can then instantiate the dataset with these delta_timestamps configuration.\n",
    "dataset = LeRobotDataset(\"datawhale_eai_pnp\", delta_timestamps=delta_timestamps, root='./demo_data', image_transforms=transform)\n",
    "\n",
    "# Then we create our optimizer and dataloader for offline training.\n",
    "import os\n",
    "num_workers = 0 if os.name == \"nt\" else 4\n",
    "optimizer = torch.optim.Adam(policy.parameters(), lr=1e-4)\n",
    "dataloader = torch.utils.data.DataLoader(\n",
    "    dataset,\n",
    "    num_workers=num_workers,\n",
    "    batch_size=64,\n",
    "    shuffle=True,\n",
    "    pin_memory=device.type != \"cpu\",\n",
    "    drop_last=True,\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 输入输出与 Shape 说明\n",
    "\n",
    "从你打印的 `ACTPolicy` 结构可见：\n",
    "- `normalize_inputs`：对图像与状态做标准化。\n",
    "- `normalize_targets`：训练时对动作标签标准化。\n",
    "- `unnormalize_outputs`：推理时把预测动作还原到原尺度。\n",
    "- `model.backbone`：图像编码（ResNet）。\n",
    "- `model.encoder / model.decoder`：Transformer 主干。\n",
    "- `model.action_head`：输出动作维度。\n",
    "\n",
    "本 notebook 里每个 batch 的主要键：\n",
    "- `observation.image`\n",
    "- `observation.state`\n",
    "- `action`\n",
    "\n",
    "下面两个代码单元会：\n",
    "1. 打印一个 batch 的每个字段 shape。\n",
    "2. 对关键模块挂 forward hook，打印中间张量 shape。\n",
    "\n",
    "这样你能清楚看到每个 batch 如何流经模型并产生 loss。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parquet files: 1\n",
      "patched: demo_data\\data\\chunk-000\\episode_000000.parquet\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "# from pathlib import Path\n",
    "# import pyarrow.parquet as pq\n",
    "\n",
    "# root = Path(\"./demo_data/data\")\n",
    "# files = sorted(root.rglob(\"*.parquet\"))\n",
    "# print(\"parquet files:\", len(files))\n",
    "\n",
    "# for f in files:\n",
    "#     table = pq.read_table(f)\n",
    "#     md = dict(table.schema.metadata or {})\n",
    "#     if b\"huggingface\" in md:\n",
    "#         del md[b\"huggingface\"]\n",
    "#         table = table.replace_schema_metadata(md if md else None)\n",
    "#         pq.write_table(table, f)\n",
    "#         print(\"patched:\", f)\n",
    "\n",
    "# print(\"done\")\n",
    "# 上面主要是将py311保存的数据改为py310版本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Dataset / Policy Feature Summary =====\n",
      "Input features:\n",
      "  - observation.image: type=VISUAL, shape=(3, 256, 256)\n",
      "  - observation.state: type=STATE, shape=(6,)\n",
      "Output features:\n",
      "  - action: type=ACTION, shape=(7,)\n",
      "===== One Batch Tensor Shapes =====\n",
      "observation.image              shape=(64, 3, 256, 256) dtype=torch.float32\n",
      "observation.wrist_image        shape=(64, 3, 256, 256) dtype=torch.float32\n",
      "observation.state              shape=(64, 6) dtype=torch.float32\n",
      "action                         shape=(64, 10, 7) dtype=torch.float32\n",
      "obj_init                       shape=(64, 6) dtype=torch.float32\n",
      "timestamp                      shape=(64,) dtype=torch.float32\n",
      "frame_index                    shape=(64,) dtype=torch.int64\n",
      "episode_index                  shape=(64,) dtype=torch.int64\n",
      "index                          shape=(64,) dtype=torch.int64\n",
      "task_index                     shape=(64,) dtype=torch.int64\n",
      "action_is_pad                  shape=(64, 10) dtype=torch.bool\n",
      "task                           type=<class 'list'>, len=4\n"
     ]
    }
   ],
   "source": [
    "# ===== Shape 1=====\n",
    "print('===== Dataset / Policy Feature Summary =====')\n",
    "print('Input features:')\n",
    "for k, ft in input_features.items():\n",
    "    print(f'  - {k}: type={ft.type}, shape={ft.shape}')\n",
    "\n",
    "print('Output features:')\n",
    "for k, ft in output_features.items():\n",
    "    print(f'  - {k}: type={ft.type}, shape={ft.shape}')\n",
    "\n",
    "sample_batch = next(iter(dataloader))\n",
    "print('===== One Batch Tensor Shapes =====')\n",
    "for k, v in sample_batch.items():\n",
    "    if isinstance(v, torch.Tensor):\n",
    "        print(f'{k:30s} shape={tuple(v.shape)} dtype={v.dtype}')\n",
    "    else:\n",
    "        print(f'{k:30s} type={type(v)}, len={len(k)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Forward Hook Shape Trace =====\n",
      "[normalize_inputs]\n",
      "  in : [{'observation.image': (64, 3, 256, 256), 'observation.wrist_image': (64, 3, 256, 256), 'observation.state': (64, 6), 'action': (64, 10, 7), 'obj_init': (64, 6), 'timestamp': (64,), 'frame_index': (64,), 'episode_index': (64,), 'index': (64,), 'task_index': (64,), 'action_is_pad': (64, 10), 'task': ['str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str']}]\n",
      "  out: {'observation.image': (64, 3, 256, 256), 'observation.wrist_image': (64, 3, 256, 256), 'observation.state': (64, 6), 'action': (64, 10, 7), 'obj_init': (64, 6), 'timestamp': (64,), 'frame_index': (64,), 'episode_index': (64,), 'index': (64,), 'task_index': (64,), 'action_is_pad': (64, 10), 'task': ['str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str']}\n",
      "[backbone]\n",
      "  in : [(64, 3, 256, 256)]\n",
      "  out: {'feature_map': (64, 512, 8, 8)}\n",
      "[encoder]\n",
      "  in : [(66, 64, 512)]\n",
      "  out: (66, 64, 512)\n",
      "[decoder]\n",
      "  in : [(10, 64, 512), (66, 64, 512)]\n",
      "  out: (10, 64, 512)\n",
      "[action_head]\n",
      "  in : [(64, 10, 512)]\n",
      "  out: (64, 10, 7)\n",
      "loss = 64.4516372680664\n",
      "out_dict keys = ['l1_loss', 'kld_loss']\n"
     ]
    }
   ],
   "source": [
    "# ===== Shape 2 forward shape =====\n",
    "from collections import OrderedDict\n",
    "\n",
    "\n",
    "def shape_repr(x):\n",
    "    if isinstance(x, torch.Tensor):\n",
    "        return tuple(x.shape)\n",
    "    if isinstance(x, dict):\n",
    "        return {k: shape_repr(v) for k, v in x.items()}\n",
    "    if isinstance(x, (list, tuple)):\n",
    "        return [shape_repr(v) for v in x]\n",
    "    return type(x).__name__\n",
    "\n",
    "\n",
    "hook_records = OrderedDict()\n",
    "\n",
    "\n",
    "def make_hook(name):\n",
    "    def _hook(module, inputs, outputs):\n",
    "        hook_records[name] = {\n",
    "            'in': shape_repr(inputs),\n",
    "            'out': shape_repr(outputs),\n",
    "        }\n",
    "    return _hook\n",
    "\n",
    "\n",
    "\n",
    "named_modules = OrderedDict([\n",
    "    ('normalize_inputs', policy.normalize_inputs),\n",
    "    ('backbone', policy.model.backbone),\n",
    "    ('encoder', policy.model.encoder),\n",
    "    ('decoder', policy.model.decoder),\n",
    "    ('action_head', policy.model.action_head),\n",
    "])\n",
    "\n",
    "handles = [m.register_forward_hook(make_hook(n)) for n, m in named_modules.items()]\n",
    "\n",
    "inp_batch = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in sample_batch.items()}\n",
    "with torch.no_grad():\n",
    "    loss, out_dict = policy.forward(inp_batch)\n",
    "\n",
    "for h in handles:\n",
    "    h.remove()\n",
    "\n",
    "print('===== Forward Hook Shape Trace =====')\n",
    "for name, rec in hook_records.items():\n",
    "    print(f'[{name}]')\n",
    "    print('  in :', rec['in'])\n",
    "    print('  out:', rec['out'])\n",
    "\n",
    "print('loss =', float(loss.item()))\n",
    "print('out_dict keys =', list(out_dict.keys()) if isinstance(out_dict, dict) else type(out_dict))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 每个 Batch 是如何迭代并更新参数的\n",
    "\n",
    "训练循环逻辑可概括为：\n",
    "1. 从 `dataloader` 取出一个 batch。\n",
    "2. 搬到 GPU：`inp_batch = {k: v.to(device) ...}`。\n",
    "3. `loss, _ = policy.forward(inp_batch)`。\n",
    "4. `loss.backward()` 反向传播。\n",
    "5. `optimizer.step()` 更新参数。\n",
    "6. `optimizer.zero_grad()` 清梯度。\n",
    "\n",
    "可以理解为：\n",
    "- 数据流：`batch -> model -> loss`\n",
    "- 梯度流：`loss -> model parameters`\n",
    "\n",
    "建议同时观察：\n",
    "- loss 曲线\n",
    "- 学习率\n",
    "- 梯度范数\n",
    "- 推理误差（mean action error）\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) 输入输出如何组成\n",
    "\n",
    "当前配置里：\n",
    "\n",
    "- 输入特征（给策略用）  \n",
    "  - `observation.image`: `(B, 3, 256, 256)`  \n",
    "  - `observation.state`: `(B, 6)`\n",
    "\n",
    "- 输出特征（监督目标）  \n",
    "  - `action`: `(B, 10, 7)`\n",
    "\n",
    "这里 `B=64`，`10` 是 `chunk_size`，`7` 是动作维度（6关节 + 1夹爪）。\n",
    "\n",
    "所以每个样本不是“一个动作”，而是“**当前观测 -> 未来10步动作序列**”。\n",
    "\n",
    "---\n",
    "\n",
    "## 2) 每个 batch 是几张图？\n",
    "\n",
    "从 batch 字段看有两路图像：\n",
    "\n",
    "- `observation.image`: `(64, 3, 256, 256)`\n",
    "- `observation.wrist_image`: `(64, 3, 256, 256)`\n",
    "\n",
    "这表示 dataloader 每个 batch 里加载了 `64 x 2 = 128` 张图（两路相机）。\n",
    "\n",
    "但 ACT 配置里输入特征只包含 `observation.image`（之前 `pop(\"observation.wrist_image\")` 了），所以**模型主干实际只吃主视角这一路**。  \n",
    "这也和 hook 一致：`backbone` 输入是 `(64, 3, 256, 256)`。\n",
    "\n",
    "---\n",
    "\n",
    "## 3) 为什么 encoder 是 `(66, 64, 512)`？\n",
    "\n",
    "这个很关键：\n",
    "\n",
    "- `backbone` 输出 `feature_map`: `(64, 512, 8, 8)`\n",
    "- 8x8 会展开成 64 个视觉 token\n",
    "- 再加上额外 2 个 1D token（通常是机器人状态 token + latent token）\n",
    "\n",
    "所以 token 总长度是 `64 + 2 = 66`，即：\n",
    "- encoder 输入：`(66, B, 512) = (66, 64, 512)`\n",
    "\n",
    "decoder 输入 `(10, 64, 512)` 则对应 10 个动作查询位（chunk 长度）。\n",
    "\n",
    "---\n",
    "\n",
    "## 4) 这个 ACT 是 VA 模型，不是 VLA 模型吗？\n",
    "\n",
    "对：**这里的 ACT 是基于 CVAE/Transformer 的视觉-运动策略，不是 VLA。**\n",
    "\n",
    "- 它有 VAE encoder + latent（日志里 `kld_loss` 也证明了有 KL 正则）\n",
    "- 输入没有语言 token（当前任务是视觉+状态）\n",
    "- 所以这不是“Vision-Language-Action”范式\n",
    "\n",
    "---\n",
    "\n",
    "## 5) `task` 为什么显示长度是 4？\n",
    "\n",
    "按这批数据的其余 tensor 都是 batch=64，正常 `task` 也应是长度 64 的字符串列表。  \n",
    "hook 里也确实显示是 64 个 `str`。\n",
    "\n",
    "那行 `len=4` 大概率是打印逻辑统计的不是“batch长度”，而是比如：\n",
    "- 唯一 task 数量（`len(set(task))`），或\n",
    "- 被截断后的前几项长度。\n",
    "\n",
    "建议直接用这段确认：\n",
    "\n",
    "```python\n",
    "tasks = sample_batch[\"task\"]\n",
    "print(type(tasks), len(tasks))          # 应该是 list, 64\n",
    "print(tasks[:5])\n",
    "print(\"unique =\", len(set(tasks)))\n",
    "print(\"unique_tasks =\", sorted(set(tasks)))\n",
    "```\n",
    "\n",
    "如果 `len(tasks)` 真是 4，那说明该 batch 的 `task` 结构被额外包装了（定位具体哪一层改了它，大概率是经过词向量化之后的）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> 64\n",
      "['Put mug cup on the plate', 'Put mug cup on the plate', 'Put mug cup on the plate', 'Put mug cup on the plate', 'Put mug cup on the plate']\n",
      "unique = 1\n",
      "unique_tasks = ['Put mug cup on the plate']\n"
     ]
    }
   ],
   "source": [
    "tasks = sample_batch[\"task\"]\n",
    "print(type(tasks), len(tasks))          # 应该是 list, 64\n",
    "print(tasks[:5])\n",
    "print(\"unique =\", len(set(tasks)))\n",
    "print(\"unique_tasks =\", sorted(set(tasks)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "训练好的 checkpoint 将保存到 `./ckpt/act_y` 目录。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7614d9891155432782bf600e1d3697fe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ACT Training:   0%|                                                                           | 0/5000 [00:00<…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练完成\n",
      "已记录 step 数: 5000\n"
     ]
    }
   ],
   "source": [
    "from tqdm.notebook import tqdm\n",
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "# ========== 配置 ==========\n",
    "eval_freq = 200          # 每多少 step 做一次评估\n",
    "max_eval_batches = 2     # 每次评估最多用多少个 batch（越小越快）\n",
    "# 假设你已经有: policy, optimizer, dataloader, training_steps, device\n",
    "# 可选：如果有单独验证集，设成你的 eval_dataloader；否则会退回用 train dataloader\n",
    "eval_dataloader = None\n",
    "\n",
    "# ========== 日志缓存 ==========\n",
    "train_loss_history = []   # 每个 step 的训练 loss\n",
    "eval_mae_history = []     # 对齐 step，未评估位置为 nan\n",
    "step_history = []\n",
    "\n",
    "def compute_mean_action_error(policy, loader, device, max_batches=2):\n",
    "    policy.eval()\n",
    "    maes = []\n",
    "    with torch.no_grad():\n",
    "        for i, batch in enumerate(loader):\n",
    "            if i >= max_batches:\n",
    "                break\n",
    "            inp = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in batch.items()}\n",
    "\n",
    "            # 预测动作\n",
    "            pred = policy.select_action(inp)\n",
    "            target = inp[\"action\"]\n",
    "\n",
    "            # 维度对齐：pred[B,7] vs target[B,10,7] 时取第一个chunk\n",
    "            if pred.ndim == 2 and target.ndim == 3:\n",
    "                target = target[:, 0, :]\n",
    "            elif pred.ndim == 3 and target.ndim == 3:\n",
    "                pass\n",
    "            else:\n",
    "                continue\n",
    "\n",
    "            mae = torch.mean(torch.abs(pred - target)).item()\n",
    "            maes.append(mae)\n",
    "\n",
    "    policy.train()\n",
    "    if len(maes) == 0:\n",
    "        return float(\"nan\")\n",
    "    return float(np.mean(maes))\n",
    "\n",
    "# ========== 训练循环 ==========\n",
    "step = 0\n",
    "done = False\n",
    "last_eval_mae = float(\"nan\")\n",
    "\n",
    "pbar = tqdm(total=training_steps, desc=\"ACT Training\", leave=True, dynamic_ncols=True)\n",
    "\n",
    "policy.train()\n",
    "while not done:\n",
    "    for batch in dataloader:\n",
    "        inp_batch = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in batch.items()}\n",
    "\n",
    "        optimizer.zero_grad(set_to_none=True)\n",
    "        loss, _ = policy.forward(inp_batch)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss = float(loss.item())\n",
    "\n",
    "        # 按频率评估 MAE\n",
    "        if step % eval_freq == 0:\n",
    "            loader_for_eval = eval_dataloader if eval_dataloader is not None else dataloader\n",
    "            last_eval_mae = compute_mean_action_error(\n",
    "                policy, loader_for_eval, device, max_batches=max_eval_batches\n",
    "            )\n",
    "\n",
    "        # 单行刷新\n",
    "        pbar.set_postfix_str(\n",
    "            f\"train_loss={train_loss:.4f} | eval_mae={last_eval_mae:.4f}\"\n",
    "        )\n",
    "        pbar.update(1)\n",
    "\n",
    "        # 记录历史\n",
    "        step_history.append(step)\n",
    "        train_loss_history.append(train_loss)\n",
    "        eval_mae_history.append(last_eval_mae)\n",
    "\n",
    "        step += 1\n",
    "        if step >= training_steps:\n",
    "            done = True\n",
    "            break\n",
    "\n",
    "pbar.close()\n",
    "\n",
    "print(\"训练完成\")\n",
    "print(f\"已记录 step 数: {len(step_history)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3060Ti占用3708MB显存，训练4小时"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from tqdm import tqdm  # 记得先导入\n",
    "\n",
    "# # Run training loop.\n",
    "# step = 0\n",
    "# done = False\n",
    "\n",
    "# # 1. 初始化进度条，设置总步数\n",
    "# pbar = tqdm(total=training_steps, desc=\"ACT Training\")\n",
    "\n",
    "# while not done:\n",
    "#     for batch in dataloader:\n",
    "#         inp_batch = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in batch.items()}\n",
    "#         loss, _ = policy.forward(inp_batch)\n",
    "#         loss.backward()\n",
    "#         optimizer.step()\n",
    "#         optimizer.zero_grad()\n",
    "        \n",
    "#         # 2. 更新进度条状态\n",
    "#         # 我们可以把 print 替换为 set_postfix，这样 Loss 会实时显示在进度条右侧\n",
    "#         if step % log_freq == 0:\n",
    "#             pbar.set_postfix(loss=f\"{loss.item():.3f}\")\n",
    "        \n",
    "#         # 3. 步进进度条\n",
    "#         pbar.update(1)\n",
    "        \n",
    "#         step += 1\n",
    "#         if step >= training_steps:\n",
    "#             done = True\n",
    "#             break\n",
    "\n",
    "# # 4. 训练结束关闭进度条\n",
    "# pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "基础版简单训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0 loss: 60.068\n",
      "step: 100 loss: 2.277\n",
      "step: 200 loss: 1.658\n",
      "step: 300 loss: 1.212\n",
      "step: 400 loss: 0.913\n",
      "step: 500 loss: 0.683\n",
      "step: 600 loss: 0.512\n",
      "step: 700 loss: 0.375\n",
      "step: 800 loss: 0.324\n",
      "step: 900 loss: 0.281\n",
      "step: 1000 loss: 0.245\n",
      "step: 1100 loss: 0.216\n",
      "step: 1200 loss: 0.189\n",
      "step: 1300 loss: 0.161\n",
      "step: 1400 loss: 0.159\n",
      "step: 1500 loss: 0.145\n",
      "step: 1600 loss: 0.136\n",
      "step: 1700 loss: 0.131\n",
      "step: 1800 loss: 0.116\n",
      "step: 1900 loss: 0.110\n",
      "step: 2000 loss: 0.100\n",
      "step: 2100 loss: 0.093\n",
      "step: 2200 loss: 0.091\n",
      "step: 2300 loss: 0.086\n",
      "step: 2400 loss: 0.082\n",
      "step: 2500 loss: 0.084\n",
      "step: 2600 loss: 0.079\n",
      "step: 2700 loss: 0.070\n",
      "step: 2800 loss: 0.066\n",
      "step: 2900 loss: 0.063\n"
     ]
    }
   ],
   "source": [
    "# # Run training loop.\n",
    "# step = 0\n",
    "# done = False\n",
    "# while not done:\n",
    "#     for batch in dataloader:\n",
    "#         inp_batch = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in batch.items()}\n",
    "#         loss, _ = policy.forward(inp_batch)\n",
    "#         loss.backward()\n",
    "#         optimizer.step()\n",
    "#         optimizer.zero_grad()\n",
    "\n",
    "#         if step % log_freq == 0:\n",
    "#             print(f\"step: {step} loss: {loss.item():.3f}\")\n",
    "#         step += 1\n",
    "#         if step >= training_steps:\n",
    "#             done = True\n",
    "#             break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 训练历史：step_history, train_loss_history, eval_mae_history\n",
    "steps = np.array(step_history)\n",
    "train_loss = np.array(train_loss_history, dtype=np.float32)\n",
    "eval_mae = np.array(eval_mae_history, dtype=np.float32)\n",
    "\n",
    "# 平滑一下训练loss（可选）\n",
    "def moving_avg(x, w=50):\n",
    "    if len(x) < w:\n",
    "        return x\n",
    "    return np.convolve(x, np.ones(w)/w, mode=\"valid\")\n",
    "\n",
    "train_loss_smooth = moving_avg(train_loss, w=50)\n",
    "steps_smooth = steps[len(steps) - len(train_loss_smooth):]\n",
    "\n",
    "fig, axs = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n",
    "\n",
    "axs[0].plot(steps, train_loss, alpha=0.25, label=\"train_loss(raw)\")\n",
    "axs[0].plot(steps_smooth, train_loss_smooth, label=\"train_loss(smooth, w=50)\")\n",
    "axs[0].set_ylabel(\"Loss\")\n",
    "axs[0].legend()\n",
    "axs[0].grid(True, alpha=0.3)\n",
    "\n",
    "valid = np.isfinite(eval_mae)\n",
    "axs[1].plot(steps[valid], eval_mae[valid], \"o-\", markersize=3, label=\"eval_mae\")\n",
    "axs[1].set_xlabel(\"Step\")\n",
    "axs[1].set_ylabel(\"MAE\")\n",
    "axs[1].legend()\n",
    "axs[1].grid(True, alpha=0.3)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`MAE` 是 **Mean Absolute Error（平均绝对误差）**，这里是动作误差：\n",
    "\n",
    "$$\n",
    "\\text{MAE} = \\frac{1}{N}\\sum |a_{\\text{pred}} - a_{\\text{gt}}|\n",
    "$$\n",
    "\n",
    "在你的 ACT 里，通常是对 `action`（7 维关节/夹爪）按 batch、按维度取绝对值再平均。  \n",
    "数值越小越好，`0` 表示和示教动作完全一致。\n",
    "\n",
    "你图里“规律波动”主要有这几个原因（都正常）：\n",
    "\n",
    "1. `eval_freq` 稀疏评估  \n",
    "你每隔固定 step 才算一次 MAE，所以曲线天然是“台阶状”。\n",
    "\n",
    "2. `max_eval_batches=2` 太小  \n",
    "每次只看 2 个 batch，统计方差很大，容易一会高一会低，出现周期性抖动。\n",
    "\n",
    "3. 评估集不固定（若复用 train dataloader 或 shuffle）  \n",
    "每次评估样本不同，MAE 会跟着样本难度跳。\n",
    "\n",
    "4. ACT 是 chunk 预测  \n",
    "你可能只拿 `target[:,0,:]` 对比，某些时刻刚好更容易/更难，也会形成规律起伏。\n",
    "\n",
    "你现在这张图的解读：  \n",
    "- train loss 持续下降，训练在收敛。  \n",
    "- MAE 在约 `0.15~0.32` 区间震荡，整体略下降但噪声较大。  \n",
    "- 这更像“评估采样太少导致的测量噪声”，不是训练坏掉。\n",
    "\n",
    "想让 MAE 更平滑可信，改三点就行：  \n",
    "1. `max_eval_batches` 提到 `10` 或 `20`。  \n",
    "2. 用固定 `eval_dataloader(shuffle=False)`。  \n",
    "3. 固定评估 episode 子集（每次都同一批数据）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不过还是应该看整体MAE，这样更准确。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the policy to disk.\n",
    "policy.save_pretrained('./ckpt/act_y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 推理测试\n",
    "\n",
    "在数据集上评估策略时，可以计算预测动作与数据集真值动作之间的误差。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class EpisodeSampler(torch.utils.data.Sampler):\n",
    "    def __init__(self, dataset: LeRobotDataset, episode_index: int):\n",
    "        from_idx = dataset.episode_data_index[\"from\"][episode_index].item()\n",
    "        to_idx = dataset.episode_data_index[\"to\"][episode_index].item()\n",
    "        self.frame_ids = range(from_idx, to_idx)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self.frame_ids)\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return len(self.frame_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean action error: 0.004\n"
     ]
    }
   ],
   "source": [
    "policy.eval()\n",
    "actions = []\n",
    "gt_actions = []\n",
    "images = []\n",
    "episode_index = 0\n",
    "episode_sampler = EpisodeSampler(dataset, episode_index)\n",
    "test_dataloader = torch.utils.data.DataLoader(\n",
    "    dataset,\n",
    "    num_workers=num_workers,\n",
    "    batch_size=1,\n",
    "    shuffle=False,\n",
    "    pin_memory=device.type != \"cpu\",\n",
    "    sampler=episode_sampler,\n",
    ")\n",
    "policy.reset()\n",
    "for batch in test_dataloader:\n",
    "    inp_batch = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in batch.items()}\n",
    "    action = policy.select_action(inp_batch)\n",
    "    actions.append(action)\n",
    "    gt_actions.append(inp_batch[\"action\"][:,0,:])\n",
    "    images.append(inp_batch[\"observation.image\"])\n",
    "actions = torch.cat(actions, dim=0)\n",
    "gt_actions = torch.cat(gt_actions, dim=0)\n",
    "print(f\"Mean action error: {torch.mean(torch.abs(actions - gt_actions)).item():.3f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "plot actions and gt_actions\n",
    "'''\n",
    "import matplotlib.pyplot as plt\n",
    "action_dim = 7\n",
    "\n",
    "fig, axs = plt.subplots(action_dim, 1, figsize=(10, 10))\n",
    "\n",
    "for i in range(action_dim):\n",
    "    axs[i].plot(actions[:, i].cpu().detach().numpy(), label=\"pred\")\n",
    "    axs[i].plot(gt_actions[:, i].cpu().detach().numpy(), label=\"gt\")\n",
    "    axs[i].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果是把“多个动作/多个 episode”做成分层统计，不要只看单条曲线。\n",
    "\n",
    "推荐 3 个层级：\n",
    "\n",
    "per-dim MAE（每个动作维度一个 MAE）\n",
    "per-episode MAE（每条轨迹一个 MAE）\n",
    "overall MAE（全部轨迹汇总，外加标准差）\n",
    "再补两个更稳的指标：\n",
    "\n",
    "RMSE（更惩罚大误差）\n",
    "成功率（例如末端误差 < 阈值 的 episode 占比）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "结论（单任务下）：\n",
    "- `1条轨迹`：能过拟合演示，但泛化差，稍微偏离就失败。  \n",
    "- `多条轨迹`：对初始状态、抓取姿态、时序扰动更鲁棒，ACT 学到的是任务分布，不是单一路径。\n",
    "\n",
    "一般规律：\n",
    "- 同任务、数据质量一致时，轨迹数增加通常先显著提升，再边际递减。  \n",
    "- 低质量/冲突示教太多会拉低效果，所以“数量 + 一致性”都重要。\n",
    "\n",
    "实操建议：\n",
    "1. 至少先做 `20-50` 条高质量轨迹（比 1 条稳定很多）。  \n",
    "2. 覆盖不同初始位置、轻微视角变化、速度变化。  \n",
    "3. 保证成功率高，失败轨迹要么单独标注，要么先不混。  \n",
    "4. 固定评估集，比较 `MAE + 成功率`，不要只看 train loss。  \n",
    "\n",
    "所以你的场景里，多轨迹训练 ACT 基本不会比单条更差，前提是数据标注和操作一致性过关。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved mp4: C:\\Users\\kewei\\Documents\\2025\\04资料整理\\03具身教程编写\\ai-hardware-robotics\\12-待定开源教程\\lerobot-mujoco-tutorial\\eval_videos\\episode0_eval.mp4\n",
      "saved gif: C:\\Users\\kewei\\Documents\\2025\\04资料整理\\03具身教程编写\\ai-hardware-robotics\\12-待定开源教程\\lerobot-mujoco-tutorial\\eval_videos\\episode0_eval.gif\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import imageio.v2 as imageio\n",
    "from pathlib import Path\n",
    "\n",
    "# images: 你前面eval循环里 append 的列表，每个元素通常是 [1,3,H,W]\n",
    "# 先拼成 [T,3,H,W]\n",
    "img_t = torch.cat(images, dim=0).detach().cpu()  # float tensor, usually [0,1]\n",
    "\n",
    "# 转成 uint8 [T,H,W,3]\n",
    "frames = []\n",
    "for i in range(img_t.shape[0]):\n",
    "    x = img_t[i].clamp(0, 1).permute(1, 2, 0).numpy()\n",
    "    x = (x * 255).astype(np.uint8)\n",
    "    frames.append(x)\n",
    "\n",
    "out_dir = Path(\"./eval_videos\")\n",
    "out_dir.mkdir(parents=True, exist_ok=True)\n",
    "mp4_path = out_dir / \"episode0_eval.mp4\"\n",
    "gif_path = out_dir / \"episode0_eval.gif\"\n",
    "\n",
    "fps = 20\n",
    "imageio.mimsave(mp4_path, frames, fps=fps, quality=8)\n",
    "imageio.mimsave(gif_path, frames, fps=10)\n",
    "\n",
    "print(f\"saved mp4: {mp4_path.resolve()}\")\n",
    "print(f\"saved gif: {gif_path.resolve()}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved: C:\\Users\\kewei\\Documents\\2025\\04资料整理\\03具身教程编写\\ai-hardware-robotics\\12-待定开源教程\\lerobot-mujoco-tutorial\\logs_txt\\train_loss.txt\n",
      "saved: C:\\Users\\kewei\\Documents\\2025\\04资料整理\\03具身教程编写\\ai-hardware-robotics\\12-待定开源教程\\lerobot-mujoco-tutorial\\logs_txt\\eval_mae.txt\n",
      "saved: C:\\Users\\kewei\\Documents\\2025\\04资料整理\\03具身教程编写\\ai-hardware-robotics\\12-待定开源教程\\lerobot-mujoco-tutorial\\logs_txt\\train_loss_mae.txt\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "import numpy as np\n",
    "\n",
    "# 你之前训练循环里的列表\n",
    "# step_history, train_loss_history, eval_mae_history\n",
    "\n",
    "out_dir = Path(\"./logs_txt\")\n",
    "out_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "steps = np.asarray(step_history, dtype=np.int64)\n",
    "loss = np.asarray(train_loss_history, dtype=np.float32)\n",
    "mae = np.asarray(eval_mae_history, dtype=np.float32)\n",
    "\n",
    "# 1) 各自单独保存\n",
    "np.savetxt(out_dir / \"train_loss.txt\", loss, fmt=\"%.8f\")\n",
    "np.savetxt(out_dir / \"eval_mae.txt\", mae, fmt=\"%.8f\")\n",
    "\n",
    "# 2) 合并保存（推荐，便于后续画图）\n",
    "# 列: step,train_loss,eval_mae\n",
    "merged = np.column_stack([steps, loss, mae])\n",
    "np.savetxt(\n",
    "    out_dir / \"train_loss_mae.txt\",\n",
    "    merged,\n",
    "    fmt=[\"%d\", \"%.8f\", \"%.8f\"],\n",
    "    delimiter=\",\",\n",
    "    header=\"step,train_loss,eval_mae\",\n",
    "    comments=\"\"\n",
    ")\n",
    "\n",
    "print(\"saved:\", (out_dir / \"train_loss.txt\").resolve())\n",
    "print(\"saved:\", (out_dir / \"eval_mae.txt\").resolve())\n",
    "print(\"saved:\", (out_dir / \"train_loss_mae.txt\").resolve())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🤖 机器人 ACT 的核心奥秘：为什么它这么强？\n",
    "\n",
    "传统的机器人控制往往是“看一眼，动一下”，这种方式容易导致动作迟钝、磕磕绊绊。ACT 换了个思路，它像是一个**钢琴家**：不是思考下一个音符弹什么，而是脑子里已经有了一小段旋律。\n",
    "\n",
    "### 1. 动作分块 (Action Chunking)：拒绝“帕金森”\n",
    "\n",
    "代码中的 `chunk_size=10` 就是核心。ACT 不仅仅预测当前的动作，它会一次性预测未来 $k$ 个步长（比如 10 步或 100 步）的一整串动作。\n",
    "\n",
    "- **好处：** 动作之间有连贯性，减少了因为网络计算延迟导致的“手抖”现象。\n",
    "\n",
    "### 2. CVAE：应对“选择困难症”\n",
    "\n",
    "人类教机器人做动作时，同样一个任务（比如抓瓶子），每次的手势可能略有不同。普通的模型会把这些不同的教法“平均化”，导致机器人最后做出了一个四不像的动作。\n",
    "\n",
    "ACT 引入了 **CVAE (条件变分自编码器)**。它会学习专家演示中的潜在风格（Latent Style）。\n",
    "\n",
    "- **原理：** 训练时，它把动作序列压缩成一个隐含空间；推理时，它从这个空间采样，确保输出的动作既符合当前画面，又是逻辑自洽的“一整套方案”。\n",
    "\n",
    "### 3. 时间集成 (Temporal Ensembling)：给动作加“磨皮滤镜”\n",
    "\n",
    "代码里虽然没直接写出，但 ACT 在执行时有个绝活：它每步都会预测后面 10 步，这意味着对于第 $t$ 时刻，其实有多个重叠的预测方案。ACT 会把这些方案进行**加权平均**。\n",
    "\n",
    "- **效果：** 极大地增加了动作的平滑度，让机械臂动起来像人手一样柔顺。\n",
    "\n",
    "------\n",
    "\n",
    "## 🔍 代码细节拆解\n",
    "\n",
    "结合你提供的 `LeRobot` 代码片段，我们来看看这些关键参数在干什么：\n",
    "\n",
    "| **参数**            | **俗称**       | **实际作用**                                                 |\n",
    "| ------------------- | -------------- | ------------------------------------------------------------ |\n",
    "| `chunk_size=10`     | **连招长度**   | 预测未来 10 个动作帧。值越大，动作越连贯，但对长时建模要求越高。 |\n",
    "| `n_action_steps=10` | **执行步数**   | 模型预测了 10 步，实际执行几步？通常与 chunk_size 保持一致。 |\n",
    "| `dataset_stats`     | **归一化字典** | 机器人的关节角度坐标系各异，必须根据数据集的均值/方差进行标准化，否则模型会“跑飞”。 |\n",
    "| `input_features`    | **感知全家桶** | 包含相机图像、机械臂当前关节位置（Qpos）。注意代码里剔除了手腕相机，只留了主视角。 |\n",
    "\n",
    "------\n",
    "\n",
    "## 🌟 为什么它在 `LeRobot` 里这么火？\n",
    "\n",
    "`LeRobot` 是 Hugging Face 推出的机器人开源库，而 ACT 正是其中的明星策略。它的应用场景非常生动：\n",
    "\n",
    "- **精细操作：** 拉拉链、系鞋带、翻转煎蛋卷。\n",
    "- **抗干扰：** 即使你轻轻推一下机械臂，因为它预测的是一串连续动作，它能展现出更强的鲁棒性。\n",
    "\n",
    "> **💡 举个例子：**\n",
    ">\n",
    "> 如果用旧方法教机器人折衣服，它可能在手碰到衣服的一瞬间停顿一下，思考“接下来怎么捏”；\n",
    ">\n",
    "> 用了 **ACT**，它在手伸向衣服的过程中，脑子里已经规划好了“捏住-提起-折叠”的整套弧线。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🛠️ 如何调整 `chunk_size` 优化抓取？\n",
    "\n",
    "在 ACT 模型中，`chunk_size` 决定了机器人一次性规划多远的未来。调整它时，你可以参考以下这个“平衡木”准则：\n",
    "\n",
    "### 1. 较小的 `chunk_size` (例如 1-10)\n",
    "\n",
    "- **表现：** 机器人变得非常“敏感”和“多疑”。它会高频地重新观察世界并修正动作。\n",
    "- **优点：** 能够快速响应环境变化（比如你突然把杯子挪位了）。\n",
    "- **缺点：** 容易出现**抖动**（类似帕金森症状），因为 Transformer 在每一帧预测的动作可能不完全连续。\n",
    "- **适用场景：** 需要高频闭环反馈、精细避障或目标会移动的任务。\n",
    "\n",
    "### 2. 较大的 `chunk_size` (例如 30-100)\n",
    "\n",
    "- **表现：** 机器人动起来像在跳芭蕾，动作极其丝滑连贯。\n",
    "- **优点：** 动作非常自然，克服了单帧预测的不稳定性，能完成复杂的长程任务（如打个死结）。\n",
    "- **缺点：** 产生**“盲目性”**。如果机器人正在执行这 100 步连招，即使环境变了，它也要把这套招式耍完才会看下一眼。\n",
    "- **适用场景：** 环境相对静止、需要动作极度平滑的精细操作（如翻开书页）。\n",
    "\n",
    "> **💡 调参秘籍：** > 大多数抓取任务的“甜点区”在 **20 到 60** 之间。如果你的机器人看起来动作迟钝、跟不上物体移动，减小它；如果它动作频繁颤抖，加大它。\n",
    "\n",
    "------\n",
    "\n",
    "## 📥 ACT 模型的输入与输出是什么？\n",
    "\n",
    "ACT 本质上是一个“多模态到序列”的翻译官。\n",
    "\n",
    "### 1. 输入 (Inputs)：它“看”到了什么？\n",
    "\n",
    "ACT 的输入通常包含两部分信息，这模拟了人类的**视觉**和**肌肉感知**：\n",
    "\n",
    "- **视觉观察 (Visual Observations)：**\n",
    "  - **主视角图像 (Top/Front Camera)：** 提供全局信息（物体在哪里，障碍物在哪里）。\n",
    "  - **手腕相机图像 (Wrist Camera)：** 提供局部细节（夹爪离物体还有几毫米）。*（注意：你提供的代码中 `pop` 掉了这个，说明该实验只用了主视角）*\n",
    "- **本体感受 (Proprioception / State)：**\n",
    "  - **当前关节角度 ($q_{pos}$)：** 机器人得知道自己现在的“手脚”在哪儿，才能规划下一步去哪儿。通常是一个 6 或 7 维的向量。\n",
    "\n",
    "### 2. 输出 (Outputs)：它“打算”做什么？\n",
    "\n",
    "ACT 的输出不再是一个简单的“下一刻坐标”，而是一个**动作矩阵**：\n",
    "\n",
    "- **动作序列 (Action Chunk)：**\n",
    "  - 形状通常为 `(chunk_size, action_dim)`。\n",
    "  - 它包含从当前时刻 $t$ 到 $t + \\text{chunk\\_size}$ 的所有预想动作（如各关节的目标角度）。\n",
    "- **样式向量 (Style Variable/Latent $z$)：**\n",
    "  - 在训练阶段，CVAE 会输出一个关于动作风格的分布，帮助模型在面对“多种可能的正确解”时保持逻辑自洽。\n",
    "\n",
    "------\n",
    "\n",
    "## 🔄 流程拆解：从输入到动作\n",
    "\n",
    "1. **感知：** 拍下照片，读取当前关节角度。\n",
    "2. **联想：** 将图像和角度喂给 Transformer 编码器。\n",
    "3. **决策：** Transformer 解码器一次性“喷出”接下来 $N$ 步（`chunk_size`）的全部动作。\n",
    "4. **执行：** 机器人按照这 $N$ 步走下去。\n",
    "5. **集成：** 在走的过程中（比如走到第 2 步时），模型其实又在计算下一组 $N$ 步了。ACT 会把**新预测的动作**和**正在执行的旧动作**按时间权重“揉合”在一起，实现无缝衔接。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py310",
   "language": "python",
   "name": "py310"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}