import sys import os import time import json import asyncio import pickle import click import numpy as np import torch import dill import hydra import omegaconf import traceback from omegaconf import open_dict from unified_video_action.policy.base_image_policy import BaseImagePolicy from unified_video_action.workspace.base_workspace import BaseWorkspace from unified_video_action.common.pytorch_util import dict_apply from umi.real_world.real_inference_util import get_real_obs_resolution import torch.nn.functional as F import websockets language_latents = pickle.load(open("prepared_data/language_latents.pkl", "rb")) def echo_exception(): exc_type, exc_value, exc_traceback = sys.exc_info() tb_lines = traceback.format_exception(exc_type, exc_value, exc_traceback) return "".join(tb_lines) def smooth_action(act_out, window_size=3, pad_size=1): kernel = torch.ones(1, 1, window_size) / window_size kernel = kernel.to(act_out.device) act_out_padded = F.pad(act_out, (0, 0, pad_size, pad_size), mode="replicate") batch_size, timesteps, action_dim = act_out_padded.shape act_out_padded = act_out_padded.permute(0, 2, 1) act_out_padded = act_out_padded.reshape(-1, 1, timesteps) smoothed_act_out = F.conv1d(act_out_padded, kernel, padding=0) smoothed_act_out = smoothed_act_out.reshape(batch_size, action_dim, timesteps - 2 * pad_size) smoothed_act_out = smoothed_act_out.permute(0, 2, 1) return smoothed_act_out class PolicyInferenceNode: def __init__(self, ckpt_path: str, ip: str, port: int, device: str, output_dir: str): self.ckpt_path = ckpt_path if not self.ckpt_path.endswith(".ckpt"): self.ckpt_path = os.path.join(self.ckpt_path, "checkpoints", "latest.ckpt") payload = torch.load(open(self.ckpt_path, "rb"), map_location="cpu", pickle_module=dill) self.cfg = payload["cfg"] with open_dict(self.cfg): if "autoregressive_model_params" in self.cfg.model.policy: self.cfg.model.policy.autoregressive_model_params.num_sampling_steps = "100" print("-----------------------------------------------") print( "num_sampling_steps", self.cfg.model.policy.autoregressive_model_params.num_sampling_steps, ) print("-----------------------------------------------") cfg_path = self.ckpt_path.replace(".ckpt", ".yaml") with open(cfg_path, "w") as f: f.write(omegaconf.OmegaConf.to_yaml(self.cfg)) print(f"Exported config to {cfg_path}") print( f"Loading configure: {self.cfg.task.name}, workspace: {self.cfg.model._target_}, policy: {self.cfg.model.policy._target_}" ) self.obs_res = get_real_obs_resolution(self.cfg.task.shape_meta) cls = hydra.utils.get_class(self.cfg.model._target_) self.workspace = cls(self.cfg, output_dir=output_dir) self.workspace: BaseWorkspace self.workspace.load_payload(payload, exclude_keys=None, include_keys=None) self.policy: BaseImagePolicy = self.workspace.model if self.cfg.training.use_ema: self.policy = self.workspace.ema_model print("Using EMA model") self.device = torch.device(device) self.policy.eval().to(self.device) self.policy.reset() self.ip = ip self.port = port def _prepare_language_goal(self, task_name: str): if self.cfg.task.dataset.language_emb_model is None: return None key = None if task_name is None: return None for candidate in ["cup", "towel", "mouse"]: if candidate in task_name: key = candidate break if key is None: return None language_goal = language_latents.get(key) if language_goal is None: return None language_goal = torch.tensor(language_goal).to(self.device).unsqueeze(0) return language_goal def predict_action(self, obs_dict_np: dict, past_action_list=None): if past_action_list is None: past_action_list = [] task_name = obs_dict_np.pop("task_name", None) language_goal = self._prepare_language_goal(task_name) with torch.no_grad(): obs_dict = dict_apply( obs_dict_np, lambda x: torch.from_numpy(x).unsqueeze(0).to(self.device) ) if self.cfg.name == "uva": result = self.policy.predict_action(obs_dict=obs_dict, language_goal=language_goal) past_action_list.append(np.array(result["action"][0].cpu())) if len(past_action_list) > 2: past_action_list.pop(0) action = smooth_action(result["action_pred"].detach().to("cpu")).numpy()[0] else: result = self.policy.predict_action(obs_dict, language_goal=language_goal) action = result["action_pred"][0].detach().to("cpu").numpy() del result del obs_dict return action, past_action_list async def _handle_connection(self, websocket): past_action_list = [] async for message in websocket: try: request = json.loads(message) payload = request.get("body", request.get("data", request)) if isinstance(payload, str): payload = json.loads(payload) if not isinstance(payload, dict): raise ValueError("Parsed payload is not a dict") start_time = time.monotonic() action, past_action_list = self.predict_action(payload, past_action_list) elapsed = time.monotonic() - start_time response = { "status": "ok", "action": action.tolist(), "inference_time": elapsed, } except Exception: err_str = echo_exception() response = {"status": "error", "error": err_str} await websocket.send(json.dumps(response)) async def run_node(self): print(f"PolicyInferenceNode WebSocket listening on {self.ip}:{self.port}") async with websockets.serve(self._handle_connection, self.ip, self.port): await asyncio.Future() # run forever @click.command() @click.option("--input", "-i", required=True, help="Path to checkpoint") @click.option("--ip", default="0.0.0.0") @click.option("--port", default=8766, help="Port to listen on") @click.option("--device", default="cuda", help="Device to run on") @click.option("--output_dir", required=True) def main(input, ip, port, device, output_dir): node = PolicyInferenceNode(input, ip, port, device, output_dir) asyncio.run(node.run_node()) if __name__ == "__main__": main()