code/eval_real_ws.py

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()