3_evaluate_franka.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/franka_deoxys/miniconda3/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "pybullet build time: Sep 21 2024 19:35:50\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "import torch\n",
    "from lerobot.common.policies.diffusion.modeling_diffusion import DiffusionPolicy\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tqdm\n",
    "\n",
    "\n",
    "import os\n",
    "from pathlib import Path\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "from deoxys import config_root\n",
    "from deoxys.franka_interface import FrankaInterface\n",
    "# from deoxys.utils import RobotStateRawObsDictGenerator, YamlConfig\n",
    "from deoxys.utils import  YamlConfig\n",
    "from deoxys.utils.config_utils import robot_config_parse_args\n",
    "from deoxys.utils.input_utils import input2action\n",
    "from deoxys.utils.io_devices import SpaceMouse\n",
    "from deoxys.utils.log_utils import get_deoxys_example_logger\n",
    "\n",
    "\n",
    "from threading import Thread\n",
    "import time\n",
    "\n",
    "from collections import OrderedDict\n",
    "\n",
    "import torch\n",
    "\n",
    "\n",
    "\n",
    "from camera_utils import MyRealSense, CVCamera\n",
    "\n",
    "np.set_printoptions(precision=3, suppress=True)\n",
    "\n",
    "logger = get_deoxys_example_logger()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading weights from local directory\n"
     ]
    }
   ],
   "source": [
    "pretrained_policy_path=Path(\"/home/franka_deoxys/data_franka/block_green_on_blue/dp_img/checkpoint_10000.pt\")\n",
    "\n",
    "policy = DiffusionPolicy.from_pretrained(pretrained_policy_path)\n",
    "policy.eval()\n",
    "policy.to(device)\n",
    "\n",
    "\n",
    "# Set up the dataset.\n",
    "delta_timestamps = {\n",
    "    # Load the previous image and state at -0.1 seconds before current frame,\n",
    "    # then load current image and state corresponding to 0.0 second.\n",
    "    \"observation.images.agentview_rgb\": [-0.1, 0.0],\n",
    "    \"observation.images.eye_in_hand_rgb\": [-0.1, 0.0],\n",
    "    \"observation.state\": [-0.1, 0.0],\n",
    "    \"observation.joint_states\": [-0.1, 0.0],\n",
    "    \"observation.gripper_states\": [-0.1, 0.0], \n",
    "    # Load the previous action (-0.1), the next action to be executed (0.0),\n",
    "    # and 14 future actions with a 0.1 seconds spacing. All these actions will be\n",
    "    # used to supervise the policy.\n",
    "    \"action\": [-0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4],\n",
    "} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_shapes = {'observation.images.agentview_rgb': (3, 128, 128), \n",
    "                'observation.images.eye_in_hand_rgb': (3, 128, 128), \n",
    "                'observation.state': (16,), \n",
    "                'observation.gripper_states': (1,),\n",
    "                'observation.joint_states': (7,)\n",
    "                }\n",
    "output_shapes = {'action': (7,)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseRawObsDictGenerator:\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.last_obs_dict = None\n",
    "\n",
    "    def get_raw_obs_dict(self, state_info):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "           state_info (dict): A dictionary of robot state + images\n",
    "        \"\"\"\n",
    "        obs_dict = {}\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def load(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "\n",
    "class RobotStateRawObsDictGenerator(BaseRawObsDictGenerator):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def load(self, obs_dict, key, value, check_valid=True):\n",
    "        \"\"\"\n",
    "        This is to check if the data is correct or not. Sometimes the data will be all zero depending on the networking conditions.\n",
    "        \"\"\"\n",
    "        if (\n",
    "            (\n",
    "                np.sum(np.abs(value)) == 0.0\n",
    "                and key in [\"ee_states\", \"joint_states\", \"gripper_states\"]\n",
    "            )\n",
    "            and check_valid\n",
    "            and self.last_obs_dict is not None\n",
    "        ):\n",
    "            value = self.last_obs_dict[key]\n",
    "        obs_dict[key] = value\n",
    "\n",
    "    def get_raw_obs_dict(self, state_info):\n",
    "        last_state = state_info[\"last_state\"]\n",
    "        last_gripper_state = state_info[\"last_gripper_state\"]\n",
    "        obs_dict = {}\n",
    "\n",
    "        ee_states = np.array(last_state.O_T_EE)\n",
    "        joint_states = np.array(last_state.q)\n",
    "        gripper_states = np.array([last_gripper_state.width])\n",
    "\n",
    "        self.load(obs_dict, \"ee_states\", ee_states)\n",
    "        self.load(obs_dict, \"joint_states\", joint_states)\n",
    "        # Gripper widh will probably become zero\n",
    "        self.load(obs_dict, \"gripper_states\", gripper_states, check_valid=False)\n",
    "\n",
    "        for state in [\"ee_states\", \"joint_states\", \"gripper_states\"]:\n",
    "            if (\n",
    "                np.sum(np.abs(obs_dict[state])) <= 1e-6\n",
    "                and self.last_obs_dict is not None\n",
    "            ):\n",
    "                print(f\"{state} missing!!!!\")\n",
    "                obs_dict[state] = self.last_obs_dict[state]\n",
    "        self.last_obs_dict = obs_dict\n",
    "        return obs_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[33m[Deoxys Examples WARNING] \u001b[0mThis is a very dummy control policy!!!!! (Ln 1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_111515/2597759035.py:1: DeprecationWarning: The 'warn' method is deprecated, use 'warning' instead\n",
      "  logger.warn(\"This is a very dummy control policy!!!!!\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening SpaceMouse device\n",
      "Manufacturer: 3Dconnexion\n",
      "Product: SpaceMouse Wireless\n",
      "\n",
      "Control                       \tCommand\n",
      "Right button                  \treset simulation\n",
      "Left button (hold)            \tclose gripper\n",
      "Move mouse laterally          \tmove arm horizontally in x-y plane\n",
      "Move mouse vertically         \tmove arm vertically\n",
      "Twist mouse about an axis     \trotate arm about a corresponding axis\n",
      "ESC                           \tquit\n",
      "\n"
     ]
    }
   ],
   "source": [
    "logger.warn(\"This is a very dummy control policy!!!!!\")\n",
    "\n",
    "args = robot_config_parse_args()\n",
    "robot_interface = FrankaInterface(os.path.join(config_root, args.interface_cfg))\n",
    "controller_cfg = YamlConfig(\n",
    "    os.path.join(config_root, args.controller_cfg)\n",
    ").as_easydict()\n",
    "controller_type = args.controller_type\n",
    "\n",
    "spacemouse = SpaceMouse(vendor_id=9583, product_id=50734)\n",
    "spacemouse.start_control()\n",
    "\n",
    "raw_obs_dict_generator = RobotStateRawObsDictGenerator()\n",
    "\n",
    "import time\n",
    "\n",
    "time.sleep(0.3)\n",
    "dummy_torch_model = torch.nn.Linear(7, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_gripper(open=True):\n",
    "    d=-1. if open else 1.0\n",
    "    action_close=np.array([ 0.,  0., -0.,  0.,  0., -0., d])\n",
    "    robot_interface.control(\n",
    "        controller_type=controller_type,\n",
    "        action=action_close,\n",
    "        controller_cfg=controller_cfg,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# logger.info(\"Resetting to the initial configuration\")\n",
    "# reset_joints_to(robot_interface, joint_sequence[0])\n",
    "# set_gripper(open=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Streaming Camera W2G: Streaming (usb-0000:00:14.0-5.1):\n",
      "\t/dev/video0\n",
      "\t/dev/video1\n",
      "\t/dev/media0\n",
      "\n",
      "USB2.0 HD UVC WebCam: USB2.0 HD (usb-0000:00:14.0-9):\n",
      "\t/dev/video8\n",
      "\t/dev/video9\n",
      "\t/dev/media3\n",
      "\n",
      "Intel(R) RealSense(TM) Depth Ca (usb-0000:3a:00.0-1):\n",
      "\t/dev/video2\n",
      "\t/dev/video3\n",
      "\t/dev/video4\n",
      "\t/dev/video5\n",
      "\t/dev/video6\n",
      "\t/dev/video7\n",
      "\t/dev/media1\n",
      "\t/dev/media2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!v4l2-ctl --list-devices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_wrist=MyRealSense()\n",
    "cam_front=CVCamera(0)\n",
    "\n",
    "tb1=Thread(target=cam_wrist.run)\n",
    "tb1.start()\n",
    "tb2=Thread(target=cam_front.run)\n",
    "tb2.start() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((120, 120, 3), (120, 120, 3))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_wrist=cam_wrist.current_frame\n",
    "img_front=cam_front.current_frame\n",
    "\n",
    "agentview_rgb=cv2.resize(img_wrist, (120, 120))  \n",
    "eye_in_hand_rgb=cv2.resize(img_front, (120, 120)) \n",
    "agentview_rgb.shape, eye_in_hand_rgb.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7aa9f0f06900>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(121)\n",
    "plt.imshow(agentview_rgb)\n",
    "plt.subplot(122)\n",
    "plt.imshow(eye_in_hand_rgb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cam_wrist.close()\n",
    "# cam_front.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_current_obs(robot_interface, cam_wrist, cam_front):\n",
    "    last_state = robot_interface._state_buffer[-1]\n",
    "    last_gripper_state = robot_interface._gripper_state_buffer[-1]\n",
    "\n",
    "    obs_dict = raw_obs_dict_generator.get_raw_obs_dict(\n",
    "    {\"last_state\": last_state, \"last_gripper_state\": last_gripper_state})\n",
    "    # obs_dict={} #rgb only \n",
    "\n",
    "    # print(obs_dict) \n",
    "\n",
    "    img_wrist=cam_wrist.current_frame\n",
    "    img_front=cam_front.current_frame\n",
    "\n",
    "    agentview_rgb=cv2.resize(img_wrist, (120, 120))  \n",
    "    eye_in_hand_rgb=cv2.resize(img_front, (120, 120)) \n",
    "\n",
    "\n",
    "    # agentview_rgb.shape, eye_in_hand_rgb.shape\n",
    "\n",
    "    obs_dict['agentview_rgb']=agentview_rgb.transpose(2, 1, 0)\n",
    "    obs_dict['eye_in_hand_rgb']=eye_in_hand_rgb.transpose(2, 1, 0)\n",
    "    return obs_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ee_states (1, 16)\n",
      "joint_states (1, 7)\n",
      "gripper_states (1, 1)\n",
      "agentview_rgb (1, 3, 120, 120)\n",
      "eye_in_hand_rgb (1, 3, 120, 120)\n"
     ]
    }
   ],
   "source": [
    "obs_dict=get_current_obs(robot_interface, cam_wrist, cam_front)\n",
    "for key in obs_dict.keys():\n",
    "    obs_dict[key]=obs_dict[key][None]\n",
    "    print(key, obs_dict[key].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def env_obs_to_input(obs): \n",
    "    input_obs = {\n",
    "        'observation.images.agentview_rgb': obs['agentview_rgb'],\n",
    "        'observation.images.eye_in_hand_rgb': obs['eye_in_hand_rgb'],\n",
    "        'observation.state': obs['ee_states'],\n",
    "        'observation.gripper_states': obs['gripper_states'],\n",
    "        'observation.joint_states': obs['joint_states'],\n",
    "    }\n",
    "    for key in input_obs.keys():\n",
    "        input_obs[key] = input_obs[key][None,:]\n",
    "    return input_obs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(obs):\n",
    "    row={k:torch.tensor(v).float() for k,v in obs.items()}\n",
    "    input_batch = {k: v.to(device) for k, v in row.items() if k in input_shapes} \n",
    "    output_dict = policy.select_action(input_batch)\n",
    "    action=output_dict.detach().cpu().numpy()\n",
    "    return action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "policy.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.199, -0.017, -0.442,  0.   ,  0.   ,  0.   , -1.   ]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs_dict=get_current_obs(robot_interface, cam_wrist, cam_front)\n",
    "obs = env_obs_to_input(obs_dict)\n",
    "ac=predict(obs)\n",
    "ac "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OSC_POSE'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "controller_type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[21], line 14\u001b[0m\n\u001b[1;32m     12\u001b[0m obs_dict\u001b[38;5;241m=\u001b[39mget_current_obs(robot_interface, cam_wrist, cam_front)\n\u001b[1;32m     13\u001b[0m obs \u001b[38;5;241m=\u001b[39m env_obs_to_input(obs_dict)\n\u001b[0;32m---> 14\u001b[0m action\u001b[38;5;241m=\u001b[39m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobs\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m     16\u001b[0m \u001b[38;5;66;03m# for key in obs_t.keys():\u001b[39;00m\n\u001b[1;32m     17\u001b[0m \u001b[38;5;66;03m#     obs_t[key]=obs_t[key][None]\u001b[39;00m\n\u001b[1;32m     18\u001b[0m \u001b[38;5;66;03m# ob2 = policy._prepare_observation(obs_t)\u001b[39;00m\n\u001b[1;32m     19\u001b[0m \u001b[38;5;66;03m# ac = policy.policy.get_action(obs_dict=ob2, goal_dict=None)\u001b[39;00m\n\u001b[1;32m     20\u001b[0m \u001b[38;5;66;03m# action=ac.detach().cpu().numpy()[0]\u001b[39;00m\n\u001b[1;32m     21\u001b[0m actions\u001b[38;5;241m.\u001b[39mappend(action)\n",
      "Cell \u001b[0;32mIn[17], line 4\u001b[0m, in \u001b[0;36mpredict\u001b[0;34m(obs)\u001b[0m\n\u001b[1;32m      2\u001b[0m row\u001b[38;5;241m=\u001b[39m{k:torch\u001b[38;5;241m.\u001b[39mtensor(v)\u001b[38;5;241m.\u001b[39mfloat() \u001b[38;5;28;01mfor\u001b[39;00m k,v \u001b[38;5;129;01min\u001b[39;00m obs\u001b[38;5;241m.\u001b[39mitems()}\n\u001b[1;32m      3\u001b[0m input_batch \u001b[38;5;241m=\u001b[39m {k: v\u001b[38;5;241m.\u001b[39mto(device) \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m row\u001b[38;5;241m.\u001b[39mitems() \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m input_shapes} \n\u001b[0;32m----> 4\u001b[0m output_dict \u001b[38;5;241m=\u001b[39m \u001b[43mpolicy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mselect_action\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_batch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      5\u001b[0m action\u001b[38;5;241m=\u001b[39moutput_dict\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy()\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m action\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/utils/_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/lerobot/lerobot/common/policies/diffusion/modeling_diffusion.py:139\u001b[0m, in \u001b[0;36mDiffusionPolicy.select_action\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m    136\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_queues[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124maction\u001b[39m\u001b[38;5;124m\"\u001b[39m]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m    137\u001b[0m     \u001b[38;5;66;03m# stack n latest observations from the queue\u001b[39;00m\n\u001b[1;32m    138\u001b[0m     batch \u001b[38;5;241m=\u001b[39m {k: torch\u001b[38;5;241m.\u001b[39mstack(\u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_queues[k]), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m batch \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_queues}\n\u001b[0;32m--> 139\u001b[0m     actions \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdiffusion\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_actions\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    141\u001b[0m     \u001b[38;5;66;03m# TODO(rcadene): make above methods return output dictionary?\u001b[39;00m\n\u001b[1;32m    142\u001b[0m     actions \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39munnormalize_outputs({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124maction\u001b[39m\u001b[38;5;124m\"\u001b[39m: actions})[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124maction\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n",
      "File \u001b[0;32m~/lerobot/lerobot/common/policies/diffusion/modeling_diffusion.py:299\u001b[0m, in \u001b[0;36mDiffusionModel.generate_actions\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m    296\u001b[0m global_cond \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_global_conditioning(batch)  \u001b[38;5;66;03m# (B, global_cond_dim)\u001b[39;00m\n\u001b[1;32m    298\u001b[0m \u001b[38;5;66;03m# run sampling\u001b[39;00m\n\u001b[0;32m--> 299\u001b[0m actions \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconditional_sample\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mglobal_cond\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mglobal_cond\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    301\u001b[0m \u001b[38;5;66;03m# Extract `n_action_steps` steps worth of actions (from the current observation).\u001b[39;00m\n\u001b[1;32m    302\u001b[0m start \u001b[38;5;241m=\u001b[39m n_obs_steps \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
      "File \u001b[0;32m~/lerobot/lerobot/common/policies/diffusion/modeling_diffusion.py:233\u001b[0m, in \u001b[0;36mDiffusionModel.conditional_sample\u001b[0;34m(self, batch_size, global_cond, generator)\u001b[0m\n\u001b[1;32m    229\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnoise_scheduler\u001b[38;5;241m.\u001b[39mset_timesteps(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_inference_steps)\n\u001b[1;32m    231\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m t \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnoise_scheduler\u001b[38;5;241m.\u001b[39mtimesteps:\n\u001b[1;32m    232\u001b[0m     \u001b[38;5;66;03m# Predict model output.\u001b[39;00m\n\u001b[0;32m--> 233\u001b[0m     model_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munet\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    234\u001b[0m \u001b[43m        \u001b[49m\u001b[43msample\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    235\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfull\u001b[49m\u001b[43m(\u001b[49m\u001b[43msample\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlong\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    236\u001b[0m \u001b[43m        \u001b[49m\u001b[43mglobal_cond\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mglobal_cond\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    237\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    238\u001b[0m     \u001b[38;5;66;03m# Compute previous image: x_t -> x_t-1\u001b[39;00m\n\u001b[1;32m    239\u001b[0m     sample \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnoise_scheduler\u001b[38;5;241m.\u001b[39mstep(model_output, t, sample, generator\u001b[38;5;241m=\u001b[39mgenerator)\u001b[38;5;241m.\u001b[39mprev_sample\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
      "File \u001b[0;32m~/lerobot/lerobot/common/policies/diffusion/modeling_diffusion.py:702\u001b[0m, in \u001b[0;36mDiffusionConditionalUnet1d.forward\u001b[0;34m(self, x, timestep, global_cond)\u001b[0m\n\u001b[1;32m    699\u001b[0m     x \u001b[38;5;241m=\u001b[39m downsample(x)\n\u001b[1;32m    701\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m mid_module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmid_modules:\n\u001b[0;32m--> 702\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[43mmid_module\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mglobal_feature\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    704\u001b[0m \u001b[38;5;66;03m# Run decoder, using the skip features from the encoder.\u001b[39;00m\n\u001b[1;32m    705\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m resnet, resnet2, upsample \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mup_modules:\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
      "File \u001b[0;32m~/lerobot/lerobot/common/policies/diffusion/modeling_diffusion.py:757\u001b[0m, in \u001b[0;36mDiffusionConditionalResidualBlock1d.forward\u001b[0;34m(self, x, cond)\u001b[0m\n\u001b[1;32m    749\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x: Tensor, cond: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m    750\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    751\u001b[0m \u001b[38;5;124;03m    Args:\u001b[39;00m\n\u001b[1;32m    752\u001b[0m \u001b[38;5;124;03m        x: (B, in_channels, T)\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    755\u001b[0m \u001b[38;5;124;03m        (B, out_channels, T)\u001b[39;00m\n\u001b[1;32m    756\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 757\u001b[0m     out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    759\u001b[0m     \u001b[38;5;66;03m# Get condition embedding. Unsqueeze for broadcasting to `out`, resulting in (B, out_channels, 1).\u001b[39;00m\n\u001b[1;32m    760\u001b[0m     cond_embed \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcond_encoder(cond)\u001b[38;5;241m.\u001b[39munsqueeze(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
      "File \u001b[0;32m~/lerobot/lerobot/common/policies/diffusion/modeling_diffusion.py:587\u001b[0m, in \u001b[0;36mDiffusionConv1dBlock.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    586\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[0;32m--> 587\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mblock\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/container.py:250\u001b[0m, in \u001b[0;36mSequential.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    248\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[1;32m    249\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 250\u001b[0m         \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    251\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/conv.py:375\u001b[0m, in \u001b[0;36mConv1d.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    374\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 375\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_conv_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniconda3/lib/python3.12/site-packages/torch/nn/modules/conv.py:370\u001b[0m, in \u001b[0;36mConv1d._conv_forward\u001b[0;34m(self, input, weight, bias)\u001b[0m\n\u001b[1;32m    358\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding_mode \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mzeros\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    359\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m F\u001b[38;5;241m.\u001b[39mconv1d(\n\u001b[1;32m    360\u001b[0m         F\u001b[38;5;241m.\u001b[39mpad(\n\u001b[1;32m    361\u001b[0m             \u001b[38;5;28minput\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reversed_padding_repeated_twice, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding_mode\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    368\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgroups,\n\u001b[1;32m    369\u001b[0m     )\n\u001b[0;32m--> 370\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv1d\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    371\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpadding\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdilation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgroups\u001b[49m\n\u001b[1;32m    372\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "actions=[]\n",
    "for _ in range(500):\n",
    "    action, grasp = input2action(\n",
    "        device=spacemouse,\n",
    "        controller_type=controller_type,\n",
    "    )\n",
    "    if action is None:\n",
    "        break\n",
    "    if len(robot_interface._state_buffer) == 0:\n",
    "        continue\n",
    "\n",
    "    obs_dict=get_current_obs(robot_interface, cam_wrist, cam_front)\n",
    "    obs = env_obs_to_input(obs_dict)\n",
    "    action=predict(obs)[0]\n",
    "\n",
    "    # for key in obs_t.keys():\n",
    "    #     obs_t[key]=obs_t[key][None]\n",
    "    # ob2 = policy._prepare_observation(obs_t)\n",
    "    # ac = policy.policy.get_action(obs_dict=ob2, goal_dict=None)\n",
    "    # action=ac.detach().cpu().numpy()[0]\n",
    "    actions.append(action)\n",
    "    \n",
    "    robot_interface.control(\n",
    "        controller_type=controller_type,\n",
    "        action=action,\n",
    "        controller_cfg=controller_cfg,\n",
    "    )\n",
    "robot_interface.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  0.,  0.,  0., -0., -1.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_wrist.close()\n",
    "cam_front.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Success "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [ 0.126 -0.02  -0.306 -0.003 -0.005 -0.005 -1.   ]\n",
    "# [ 0.126 -0.021 -0.306 -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.127 -0.02  -0.306 -0.003 -0.005 -0.005 -1.   ]\n",
    "# [ 0.136 -0.02  -0.31  -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.149 -0.019 -0.314 -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.163 -0.018 -0.319 -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.181 -0.018 -0.326 -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.2   -0.017 -0.333 -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.222 -0.016 -0.342 -0.003 -0.006 -0.005 -1.   ]\n",
    "# [ 0.241 -0.015 -0.349 -0.003 -0.006 -0.005 -1.   ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}