Assignment4/eval_policy.py

import sys
import os
import subprocess
import multiprocessing as mp
import queue
import time

sys.path.append("./")
sys.path.append(f"./policy")
sys.path.append("./description/utils")
from envs import CONFIGS_PATH
from envs.utils.create_actor import UnStableError

import numpy as np
from pathlib import Path
from collections import deque
import traceback

import yaml
from datetime import datetime
import importlib
import argparse
import pdb
import ast

from generate_episode_instructions import *

current_file_path = os.path.abspath(__file__)
parent_directory = os.path.dirname(current_file_path)
DEMO_PREFLIGHT_TIMEOUT = 300


def class_decorator(task_name):
    envs_module = importlib.import_module(f"envs.{task_name}")
    try:
        env_class = getattr(envs_module, task_name)
        env_instance = env_class()
    except:
        raise SystemExit("No Task")
    return env_instance


def eval_function_decorator(policy_name, model_name):
    try:
        policy_model = importlib.import_module(policy_name)
        return getattr(policy_model, model_name)
    except ImportError as e:
        raise e


def run_demo_preflight_once(task_name: str, args: dict, now_id: int, now_seed: int) -> tuple[str, dict | str]:
    task_env = None
    try:
        task_env = class_decorator(task_name)
        task_env.setup_demo(now_ep_num=now_id, seed=now_seed, is_test=True, **args)
        episode_info = task_env.play_once()
        return (
            "ok",
            {
                "episode_info": {"info": episode_info["info"]},
                "success": bool(task_env.plan_success and task_env.check_success()),
            },
        )
    except UnStableError as e:
        return "unstable", str(e)
    except Exception:
        return "error", traceback.format_exc()
    finally:
        if task_env is not None:
            try:
                task_env.close_env()
            except Exception:
                pass


def demo_preflight_worker(task_name: str, request_queue, result_queue) -> None:
    while True:
        request = request_queue.get()
        if request is None:
            break
        request_id, args, now_id, now_seed = request
        status, payload = run_demo_preflight_once(task_name, args, now_id, now_seed)
        result_queue.put((request_id, status, payload))


class DemoPreflightRunner:

    def __init__(self, task_name: str, timeout: int = DEMO_PREFLIGHT_TIMEOUT) -> None:
        self.task_name = task_name
        self.timeout = timeout
        self.ctx = mp.get_context("spawn")
        self.request_id = 0
        self.process = None
        self.request_queue = None
        self.result_queue = None
        self.start()

    def start(self) -> None:
        self.request_queue = self.ctx.Queue()
        self.result_queue = self.ctx.Queue()
        self.process = self.ctx.Process(
            target=demo_preflight_worker,
            args=(self.task_name, self.request_queue, self.result_queue),
        )
        self.process.daemon = True
        self.process.start()

    def close(self, force: bool = False) -> None:
        if self.process is None:
            return
        if self.process.is_alive() and not force:
            try:
                self.request_queue.put(None)
            except Exception:
                pass
            self.process.join(5)
        if self.process.is_alive():
            self.process.terminate()
            self.process.join(5)
        if self.process.is_alive():
            self.process.kill()
            self.process.join()

    def restart(self, force: bool = False) -> None:
        self.close(force=force)
        self.start()

    def run(self, args: dict, now_id: int, now_seed: int) -> tuple[str, dict | str | None]:
        if self.process is None or not self.process.is_alive():
            self.restart()

        self.request_id += 1
        request_id = self.request_id
        self.request_queue.put((request_id, args, now_id, now_seed))

        deadline = time.time() + self.timeout
        while True:
            try:
                result_id, status, payload = self.result_queue.get_nowait()
                if result_id == request_id:
                    return status, payload
            except queue.Empty:
                if not self.process.is_alive():
                    exitcode = self.process.exitcode
                    self.restart()
                    return "error", f"preflight worker exited with code {exitcode}"
                if time.time() >= deadline:
                    self.restart(force=True)
                    return "timeout", None
                time.sleep(0.2)

def get_camera_config(camera_type):
    camera_config_path = os.path.join(parent_directory, "../task_config/_camera_config.yml")

    assert os.path.isfile(camera_config_path), "task config file is missing"

    with open(camera_config_path, "r", encoding="utf-8") as f:
        args = yaml.load(f.read(), Loader=yaml.FullLoader)

    assert camera_type in args, f"camera {camera_type} is not defined"
    return args[camera_type]


def get_embodiment_config(robot_file):
    robot_config_file = os.path.join(robot_file, "config.yml")
    with open(robot_config_file, "r", encoding="utf-8") as f:
        embodiment_args = yaml.load(f.read(), Loader=yaml.FullLoader)
    return embodiment_args


def parse_bool(value):
    if isinstance(value, bool):
        return value
    if isinstance(value, (int, float)):
        return bool(value)
    if isinstance(value, str):
        value = value.strip().lower()
        if value in ("1", "true", "yes", "on"):
            return True
        if value in ("0", "false", "no", "off"):
            return False
    raise ValueError(f"cannot parse boolean value: {value!r}")


def keep_task_static_cameras(embodiment_config, task_args):
    config = dict(embodiment_config)
    static_cameras = config.get("static_camera_list", [])
    allowed_names = set()
    if task_args.get("camera", {}).get("collect_head_camera", True):
        allowed_names.add("head_camera")
    config["static_camera_list"] = [
        dict(camera) for camera in static_cameras if camera.get("name") in allowed_names
    ]
    return config


def main(usr_args):
    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    task_name = usr_args["task_name"]
    task_config = usr_args["task_config"]
    ckpt_setting = usr_args["ckpt_setting"]
    # checkpoint_num = usr_args['checkpoint_num']
    policy_name = usr_args["policy_name"]
    instruction_type = usr_args["instruction_type"]
    save_dir = None
    video_save_dir = None
    video_size = None

    get_model = eval_function_decorator(policy_name, "get_model")

    with open(f"./task_config/{task_config}.yml", "r", encoding="utf-8") as f:
        args = yaml.load(f.read(), Loader=yaml.FullLoader)

    if "eval_video_log" in usr_args:
        args["eval_video_log"] = parse_bool(usr_args["eval_video_log"])
    if "eval_step_lim" in usr_args:
        args["eval_step_lim"] = int(usr_args["eval_step_lim"])
    if "force_arm_tag" in usr_args:
        args["force_arm_tag"] = usr_args["force_arm_tag"]
    if "force_block_arm_tag" in usr_args:
        args["force_block_arm_tag"] = usr_args["force_block_arm_tag"]

    args['task_name'] = task_name
    args["task_config"] = task_config
    args["ckpt_setting"] = ckpt_setting

    embodiment_type = args.get("embodiment")
    embodiment_config_path = os.path.join(CONFIGS_PATH, "_embodiment_config.yml")

    with open(embodiment_config_path, "r", encoding="utf-8") as f:
        _embodiment_types = yaml.load(f.read(), Loader=yaml.FullLoader)

    def get_embodiment_file(embodiment_type):
        robot_file = _embodiment_types[embodiment_type]["file_path"]
        if robot_file is None:
            raise "No embodiment files"
        return robot_file

    with open(CONFIGS_PATH + "_camera_config.yml", "r", encoding="utf-8") as f:
        _camera_config = yaml.load(f.read(), Loader=yaml.FullLoader)

    head_camera_type = args["camera"]["head_camera_type"]
    args["head_camera_h"] = _camera_config[head_camera_type]["h"]
    args["head_camera_w"] = _camera_config[head_camera_type]["w"]

    if len(embodiment_type) == 1:
        args["left_robot_file"] = get_embodiment_file(embodiment_type[0])
        args["right_robot_file"] = get_embodiment_file(embodiment_type[0])
        args["dual_arm_embodied"] = True
    elif len(embodiment_type) == 3:
        args["left_robot_file"] = get_embodiment_file(embodiment_type[0])
        args["right_robot_file"] = get_embodiment_file(embodiment_type[1])
        args["embodiment_dis"] = embodiment_type[2]
        args["dual_arm_embodied"] = False
    else:
        raise "embodiment items should be 1 or 3"

    args["left_embodiment_config"] = keep_task_static_cameras(get_embodiment_config(args["left_robot_file"]), args)
    args["right_embodiment_config"] = keep_task_static_cameras(get_embodiment_config(args["right_robot_file"]), args)

    if len(embodiment_type) == 1:
        embodiment_name = str(embodiment_type[0])
    else:
        embodiment_name = str(embodiment_type[0]) + "+" + str(embodiment_type[1])

    save_dir = Path(f"eval_result/{task_name}/{policy_name}/{task_config}/{ckpt_setting}/{current_time}")
    save_dir.mkdir(parents=True, exist_ok=True)

    if args["eval_video_log"]:
        video_save_dir = save_dir
        camera_config = get_camera_config(args["camera"]["head_camera_type"])
        video_size = str(camera_config["w"]) + "x" + str(camera_config["h"])
        video_save_dir.mkdir(parents=True, exist_ok=True)
        args["eval_video_save_dir"] = video_save_dir

    # output camera config
    print("============= Config =============\n")
    print("\033[95mMessy Table:\033[0m " + str(args["domain_randomization"]["cluttered_table"]))
    print("\033[95mRandom Background:\033[0m " + str(args["domain_randomization"]["random_background"]))
    if args["domain_randomization"]["random_background"]:
        print(" - Clean Background Rate: " + str(args["domain_randomization"]["clean_background_rate"]))
    print("\033[95mRandom Light:\033[0m " + str(args["domain_randomization"]["random_light"]))
    if args["domain_randomization"]["random_light"]:
        print(" - Crazy Random Light Rate: " + str(args["domain_randomization"]["crazy_random_light_rate"]))
    print("\033[95mRandom Table Height:\033[0m " + str(args["domain_randomization"]["random_table_height"]))
    print("\033[95mRandom Head Camera Distance:\033[0m " + str(args["domain_randomization"]["random_head_camera_dis"]))

    print("\033[94mHead Camera Config:\033[0m " + str(args["camera"]["head_camera_type"]) + f", " +
          str(args["camera"]["collect_head_camera"]))
    print("\033[94mWrist Camera Config:\033[0m " + str(args["camera"]["wrist_camera_type"]) + f", " +
          str(args["camera"]["collect_wrist_camera"]))
    print("\033[94mEmbodiment Config:\033[0m " + embodiment_name)
    print("\n==================================")

    TASK_ENV = class_decorator(args["task_name"])
    args["policy_name"] = policy_name
    usr_args["left_arm_dim"] = len(args["left_embodiment_config"]["arm_joints_name"][0])
    usr_args["right_arm_dim"] = len(args["right_embodiment_config"]["arm_joints_name"][1])

    seed = usr_args["seed"]

    st_seed = int(usr_args.get("fixed_eval_seed", 100000 * (1 + seed)))
    suc_nums = []
    test_num = int(usr_args.get("eval_test_num", 100))
    topk = 1

    model = get_model(usr_args)
    st_seed, suc_num = eval_policy(task_name,
                                   TASK_ENV,
                                   args,
                                   model,
                                   st_seed,
                                   test_num=test_num,
                                   video_size=video_size,
                                   instruction_type=instruction_type)
    suc_nums.append(suc_num)

    topk_success_rate = sorted(suc_nums, reverse=True)[:topk]

    file_path = os.path.join(save_dir, f"_result.txt")
    with open(file_path, "w") as file:
        file.write(f"Timestamp: {current_time}\n\n")
        file.write(f"Instruction Type: {instruction_type}\n\n")
        # file.write(str(task_reward) + '\n')
        file.write("\n".join(map(str, np.array(suc_nums) / test_num)))

    print(f"Data has been saved to {file_path}")
    # return task_reward


def eval_policy(task_name,
                TASK_ENV,
                args,
                model,
                st_seed,
                test_num=100,
                video_size=None,
                instruction_type=None):
    print(f"\033[34mTask Name: {args['task_name']}\033[0m")
    print(f"\033[34mPolicy Name: {args['policy_name']}\033[0m")

    TASK_ENV.suc = 0
    TASK_ENV.test_num = 0

    now_id = 0
    succ_seed = 0
    suc_test_seed_list = []

    policy_name = args["policy_name"]
    eval_func = eval_function_decorator(policy_name, "eval")
    reset_func = eval_function_decorator(policy_name, "reset_model")

    now_seed = st_seed
    task_total_reward = 0
    clear_cache_freq = args["clear_cache_freq"]

    args["eval_mode"] = True

    preflight_runner = DemoPreflightRunner(task_name)
    try:
        while succ_seed < test_num:
            render_freq = args["render_freq"]
            args["render_freq"] = 0

            preflight_status, preflight_payload = preflight_runner.run(args, now_id, now_seed)
            if preflight_status == "timeout":
                print(f"demo preflight timeout after {DEMO_PREFLIGHT_TIMEOUT}s, skip seed {now_seed}")
                now_seed += 1
                args["render_freq"] = render_freq
                continue
            if preflight_status == "unstable":
                now_seed += 1
                args["render_freq"] = render_freq
                continue
            if preflight_status == "error":
                print(" -------------")
                print("Error: ", preflight_payload)
                print(" -------------")
                now_seed += 1
                args["render_freq"] = render_freq
                print("error occurs !")
                continue

            episode_info = preflight_payload["episode_info"]

            if preflight_payload["success"]:
                succ_seed += 1
                suc_test_seed_list.append(now_seed)
            else:
                now_seed += 1
                args["render_freq"] = render_freq
                continue

            args["render_freq"] = render_freq

            TASK_ENV.setup_demo(now_ep_num=now_id, seed=now_seed, is_test=True, **args)
            episode_info_list = [episode_info["info"]]
            results = generate_episode_descriptions(args["task_name"], episode_info_list, test_num)
            instruction_choices = results[0].get(instruction_type, []) if results else []
            instruction = np.random.choice(instruction_choices) if instruction_choices else ""
            TASK_ENV.set_instruction(instruction=instruction)  # set language instruction

            if TASK_ENV.eval_video_path is not None:
                ffmpeg = subprocess.Popen(
                    [
                        "ffmpeg",
                        "-y",
                        "-loglevel",
                        "error",
                        "-f",
                        "rawvideo",
                        "-pixel_format",
                        "rgb24",
                        "-video_size",
                        video_size,
                        "-framerate",
                        "10",
                        "-i",
                        "-",
                        "-pix_fmt",
                        "yuv420p",
                        "-vcodec",
                        "libx264",
                        "-crf",
                        "23",
                        f"{TASK_ENV.eval_video_path}/episode{TASK_ENV.test_num}.mp4",
                    ],
                    stdin=subprocess.PIPE,
                )
                TASK_ENV._set_eval_video_ffmpeg(ffmpeg)

            succ = False
            reset_func(model)
            while TASK_ENV.take_action_cnt < TASK_ENV.step_lim:
                observation = TASK_ENV.get_obs()
                eval_func(TASK_ENV, model, observation)
                if TASK_ENV.eval_success:
                    succ = True
                    break
            # task_total_reward += TASK_ENV.episode_score
            if TASK_ENV.eval_video_path is not None:
                TASK_ENV._del_eval_video_ffmpeg()

            if succ:
                TASK_ENV.suc += 1
                print("\033[92mSuccess!\033[0m")
            else:
                print("\033[91mFail!\033[0m")

            now_id += 1
            TASK_ENV.close_env(clear_cache=((succ_seed + 1) % clear_cache_freq == 0))

            if TASK_ENV.render_freq:
                TASK_ENV.viewer.close()

            TASK_ENV.test_num += 1

            print(
                f"\033[93m{task_name}\033[0m | \033[94m{args['policy_name']}\033[0m | \033[92m{args['task_config']}\033[0m | \033[91m{args['ckpt_setting']}\033[0m\n"
                f"Success rate: \033[96m{TASK_ENV.suc}/{TASK_ENV.test_num}\033[0m => \033[95m{round(TASK_ENV.suc/TASK_ENV.test_num*100, 1)}%\033[0m, current seed: \033[90m{now_seed}\033[0m\n"
            )
            # TASK_ENV._take_picture()
            now_seed += 1
    finally:
        preflight_runner.close()

    return now_seed, TASK_ENV.suc


def parse_args_and_config():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=str, required=True)
    parser.add_argument("--overrides", nargs=argparse.REMAINDER)
    args = parser.parse_args()

    with open(args.config, "r", encoding="utf-8") as f:
        config = yaml.safe_load(f)

    # Parse overrides
    def parse_override_pairs(pairs):
        if len(pairs) % 2 != 0:
            raise ValueError(f"overrides must be key/value pairs, got odd argument count: {pairs}")
        override_dict = {}
        for i in range(0, len(pairs), 2):
            key = pairs[i].lstrip("--")
            value = pairs[i + 1]
            try:
                value = ast.literal_eval(value)
            except (ValueError, SyntaxError):
                pass
            override_dict[key] = value
        return override_dict

    if args.overrides:
        overrides = parse_override_pairs(args.overrides)
        config.update(overrides)

    return config


if __name__ == "__main__":
    from test_render import Sapien_TEST
    Sapien_TEST()

    usr_args = parse_args_and_config()

    main(usr_args)