Datasets:

THURCSCT
/

SafeLIBERO

@@ -1,40 +0,0 @@
-"""A script to check if any demonstration dataset does not have the exact number of demonstration trajectories"""
-from pathlib import Path
-import h5py
-import numpy as np
-from libero.libero import get_libero_path
-error_datasets = []
-for demo_file_name in Path(get_libero_path("datasets")).rglob("*hdf5"):
-    demo_file = h5py.File(demo_file_name)
-    count = 0
-    for key in demo_file["data"].keys():
-        if "demo" in key:
-            count += 1
-    if count == 50:
-        traj_lengths = []
-        action_min = np.inf
-        action_max = -np.inf
-        for demo_name in demo_file["data"].keys():
-            traj_lengths.append(demo_file["data/{}/actions".format(demo_name)].shape[0])
-        traj_lengths = np.array(traj_lengths)
-        print(f"[info] dataset {demo_file_name} is in tact, test passed \u2714")
-        print(np.mean(traj_lengths), " +- ", np.std(traj_lengths))
-        if demo_file["data"].attrs["tag"] == "libero-v1":
-            print("Version correct")
-        print("=========================================")
-    else:
-        print("[error] !!!")
-        error_datasets.append(demo_file_name)
-if len(error_datasets) > 0:
-    print("[error] The following datasets are corrupted:")
-    for dataset in error_datasets:
-        print(dataset)

scripts/collect_demonstration.py DELETED Viewed

@@ -1,356 +0,0 @@
-import argparse
-import cv2
-import datetime
-import h5py
-import init_path
-import json
-import numpy as np
-import os
-import robosuite as suite
-import time
-from glob import glob
-from robosuite import load_controller_config
-from robosuite.wrappers import DataCollectionWrapper, VisualizationWrapper
-from robosuite.utils.input_utils import input2action
-import libero.libero.envs.bddl_utils as BDDLUtils
-from libero.libero.envs import *
-def collect_human_trajectory(
-    env, device, arm, env_configuration, problem_info, remove_directory=[]
-):
-    """
-    Use the device (keyboard or SpaceNav 3D mouse) to collect a demonstration.
-    The rollout trajectory is saved to files in npz format.
-    Modify the DataCollectionWrapper wrapper to add new fields or change data formats.
-    Args:
-        env (MujocoEnv): environment to control
-        device (Device): to receive controls from the device
-        arms (str): which arm to control (eg bimanual) 'right' or 'left'
-        env_configuration (str): specified environment configuration
-    """
-    reset_success = False
-    while not reset_success:
-        try:
-            env.reset()
-            reset_success = True
-        except:
-            continue
-    # ID = 2 always corresponds to agentview
-    env.render()
-    task_completion_hold_count = (
-        -1
-    )  # counter to collect 10 timesteps after reaching goal
-    device.start_control()
-    # Loop until we get a reset from the input or the task completes
-    saving = True
-    count = 0
-    while True:
-        count += 1
-        # Set active robot
-        active_robot = (
-            env.robots[0]
-            if env_configuration == "bimanual"
-            else env.robots[arm == "left"]
-        )
-        # Get the newest action
-        action, grasp = input2action(
-            device=device,
-            robot=active_robot,
-            active_arm=arm,
-            env_configuration=env_configuration,
-        )
-        # If action is none, then this a reset so we should break
-        if action is None:
-            print("Break")
-            saving = False
-            break
-        # Run environment step
-        env.step(action)
-        env.render()
-        # Also break if we complete the task
-        if task_completion_hold_count == 0:
-            break
-        # state machine to check for having a success for 10 consecutive timesteps
-        if env._check_success():
-            if task_completion_hold_count > 0:
-                task_completion_hold_count -= 1  # latched state, decrement count
-            else:
-                task_completion_hold_count = 10  # reset count on first success timestep
-        else:
-            task_completion_hold_count = -1  # null the counter if there's no success
-    print(count)
-    # cleanup for end of data collection episodes
-    if not saving:
-        remove_directory.append(env.ep_directory.split("/")[-1])
-    env.close()
-    return saving
-def gather_demonstrations_as_hdf5(
-    directory, out_dir, env_info, args, remove_directory=[]
-):
-    """
-    Gathers the demonstrations saved in @directory into a
-    single hdf5 file.
-    The strucure of the hdf5 file is as follows.
-    data (group)
-        date (attribute) - date of collection
-        time (attribute) - time of collection
-        repository_version (attribute) - repository version used during collection
-        env (attribute) - environment name on which demos were collected
-        demo1 (group) - every demonstration has a group
-            model_file (attribute) - model xml string for demonstration
-            states (dataset) - flattened mujoco states
-            actions (dataset) - actions applied during demonstration
-        demo2 (group)
-        ...
-    Args:
-        directory (str): Path to the directory containing raw demonstrations.
-        out_dir (str): Path to where to store the hdf5 file.
-        env_info (str): JSON-encoded string containing environment information,
-            including controller and robot info
-    """
-    hdf5_path = os.path.join(out_dir, "demo.hdf5")
-    f = h5py.File(hdf5_path, "w")
-    # store some metadata in the attributes of one group
-    grp = f.create_group("data")
-    num_eps = 0
-    env_name = None  # will get populated at some point
-    for ep_directory in os.listdir(directory):
-        # print(ep_directory)
-        if ep_directory in remove_directory:
-            # print("Skipping")
-            continue
-        state_paths = os.path.join(directory, ep_directory, "state_*.npz")
-        states = []
-        actions = []
-        for state_file in sorted(glob(state_paths)):
-            dic = np.load(state_file, allow_pickle=True)
-            env_name = str(dic["env"])
-            states.extend(dic["states"])
-            for ai in dic["action_infos"]:
-                actions.append(ai["actions"])
-        if len(states) == 0:
-            continue
-        # Delete the first actions and the last state. This is because when the DataCollector wrapper
-        # recorded the states and actions, the states were recorded AFTER playing that action.
-        del states[-1]
-        assert len(states) == len(actions)
-        num_eps += 1
-        ep_data_grp = grp.create_group("demo_{}".format(num_eps))
-        # store model xml as an attribute
-        xml_path = os.path.join(directory, ep_directory, "model.xml")
-        with open(xml_path, "r") as f:
-            xml_str = f.read()
-        ep_data_grp.attrs["model_file"] = xml_str
-        # write datasets for states and actions
-        ep_data_grp.create_dataset("states", data=np.array(states))
-        ep_data_grp.create_dataset("actions", data=np.array(actions))
-    # write dataset attributes (metadata)
-    now = datetime.datetime.now()
-    grp.attrs["date"] = "{}-{}-{}".format(now.month, now.day, now.year)
-    grp.attrs["time"] = "{}:{}:{}".format(now.hour, now.minute, now.second)
-    grp.attrs["repository_version"] = suite.__version__
-    grp.attrs["env"] = env_name
-    grp.attrs["env_info"] = env_info
-    grp.attrs["problem_info"] = json.dumps(problem_info)
-    grp.attrs["bddl_file_name"] = args.bddl_file
-    grp.attrs["bddl_file_content"] = str(open(args.bddl_file, "r", encoding="utf-8"))
-    f.close()
-if __name__ == "__main__":
-    # Arguments
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--directory",
-        type=str,
-        default="demonstration_data",
-    )
-    parser.add_argument(
-        "--robots",
-        nargs="+",
-        type=str,
-        default="Panda",
-        help="Which robot(s) to use in the env",
-    )
-    parser.add_argument(
-        "--config",
-        type=str,
-        default="single-arm-opposed",
-        help="Specified environment configuration if necessary",
-    )
-    parser.add_argument(
-        "--arm",
-        type=str,
-        default="right",
-        help="Which arm to control (eg bimanual) 'right' or 'left'",
-    )
-    parser.add_argument(
-        "--camera",
-        type=str,
-        default="agentview",
-        help="Which camera to use for collecting demos",
-    )
-    parser.add_argument(
-        "--controller",
-        type=str,
-        default="OSC_POSE",
-        help="Choice of controller. Can be 'IK_POSE' or 'OSC_POSE'",
-    )
-    parser.add_argument("--device", type=str, default="spacemouse")
-    parser.add_argument(
-        "--pos-sensitivity",
-        type=float,
-        default=1.5,
-        help="How much to scale position user inputs",
-    )
-    parser.add_argument(
-        "--rot-sensitivity",
-        type=float,
-        default=1.0,
-        help="How much to scale rotation user inputs",
-    )
-    parser.add_argument(
-        "--num-demonstration",
-        type=int,
-        default=50,
-        help="How much to scale rotation user inputs",
-    )
-    parser.add_argument("--bddl-file", type=str)
-    parser.add_argument("--vendor-id", type=int, default=9583)
-    parser.add_argument("--product-id", type=int, default=50734)
-    args = parser.parse_args()
-    # Get controller config
-    controller_config = load_controller_config(default_controller=args.controller)
-    # Create argument configuration
-    config = {
-        "robots": args.robots,
-        "controller_configs": controller_config,
-    }
-    assert os.path.exists(args.bddl_file)
-    problem_info = BDDLUtils.get_problem_info(args.bddl_file)
-    # Check if we're using a multi-armed environment and use env_configuration argument if so
-    # Create environment
-    problem_name = problem_info["problem_name"]
-    domain_name = problem_info["domain_name"]
-    language_instruction = problem_info["language_instruction"]
-    if "TwoArm" in problem_name:
-        config["env_configuration"] = args.config
-    print(language_instruction)
-    env = TASK_MAPPING[problem_name](
-        bddl_file_name=args.bddl_file,
-        **config,
-        has_renderer=True,
-        has_offscreen_renderer=False,
-        render_camera=args.camera,
-        ignore_done=True,
-        use_camera_obs=False,
-        reward_shaping=True,
-        control_freq=20,
-    )
-    # Wrap this with visualization wrapper
-    env = VisualizationWrapper(env)
-    # Grab reference to controller config and convert it to json-encoded string
-    env_info = json.dumps(config)
-    # wrap the environment with data collection wrapper
-    tmp_directory = "demonstration_data/tmp/{}_ln_{}/{}".format(
-        problem_name,
-        language_instruction.replace(" ", "_").strip('""'),
-        str(time.time()).replace(".", "_"),
-    )
-    env = DataCollectionWrapper(env, tmp_directory)
-    # initialize device
-    if args.device == "keyboard":
-        from robosuite.devices import Keyboard
-        device = Keyboard(
-            pos_sensitivity=args.pos_sensitivity, rot_sensitivity=args.rot_sensitivity
-        )
-        env.viewer.add_keypress_callback("any", device.on_press)
-        env.viewer.add_keyup_callback("any", device.on_release)
-        env.viewer.add_keyrepeat_callback("any", device.on_press)
-    elif args.device == "spacemouse":
-        from robosuite.devices import SpaceMouse
-        device = SpaceMouse(
-            args.vendor_id,
-            args.product_id,
-            pos_sensitivity=args.pos_sensitivity,
-            rot_sensitivity=args.rot_sensitivity,
-        )
-    else:
-        raise Exception(
-            "Invalid device choice: choose either 'keyboard' or 'spacemouse'."
-        )
-    # make a new timestamped directory
-    t1, t2 = str(time.time()).split(".")
-    new_dir = os.path.join(
-        args.directory,
-        f"{domain_name}_ln_{problem_name}_{t1}_{t2}_"
-        + language_instruction.replace(" ", "_").strip('""'),
-    )
-    os.makedirs(new_dir)
-    # collect demonstrations
-    remove_directory = []
-    i = 0
-    while i < args.num_demonstration:
-        print(i)
-        saving = collect_human_trajectory(
-            env, device, args.arm, args.config, problem_info, remove_directory
-        )
-        if saving:
-            print(remove_directory)
-            gather_demonstrations_as_hdf5(
-                tmp_directory, new_dir, env_info, args, remove_directory
-            )
-            i += 1

scripts/config_copy.py DELETED Viewed

@@ -1,20 +0,0 @@
-import os
-import shutil
-from libero.libero import get_libero_path
-def main():
-    target_path = os.path.abspath(os.path.join("./", "configs"))
-    print(f"Copying configs to {target_path}")
-    if os.path.exists(target_path):
-        response = input("The target directory already exists. Overwrite it? (y/n) ")
-        if response.lower() != "y":
-            return
-        shutil.rmtree(target_path)
-    shutil.copytree(
-        os.path.join(get_libero_path("benchmark_root"), "../configs"), target_path
-    )
-if __name__ == "__main__":
-    main()

scripts/create_dataset.py DELETED Viewed

@@ -1,282 +0,0 @@
-import argparse
-import os
-from pathlib import Path
-import h5py
-import numpy as np
-import json
-import robosuite
-import robosuite.utils.transform_utils as T
-import robosuite.macros as macros
-import init_path
-import libero.libero.utils.utils as libero_utils
-import cv2
-from PIL import Image
-from robosuite.utils import camera_utils
-from libero.libero.envs import *
-from libero.libero import get_libero_path
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--demo-file", default="demo.hdf5")
-    parser.add_argument(
-        "--use-actions",
-        action="store_true",
-    )
-    parser.add_argument("--use-camera-obs", action="store_true")
-    parser.add_argument(
-        "--dataset-path",
-        type=str,
-        default="datasets/",
-    )
-    parser.add_argument(
-        "--dataset-name",
-        type=str,
-        default="training_set",
-    )
-    parser.add_argument("--no-proprio", action="store_true")
-    parser.add_argument(
-        "--use-depth",
-        action="store_true",
-    )
-    args = parser.parse_args()
-    hdf5_path = args.demo_file
-    f = h5py.File(hdf5_path, "r")
-    env_name = f["data"].attrs["env"]
-    env_args = f["data"].attrs["env_info"]
-    env_kwargs = json.loads(f["data"].attrs["env_info"])
-    problem_info = json.loads(f["data"].attrs["problem_info"])
-    problem_info["domain_name"]
-    problem_name = problem_info["problem_name"]
-    language_instruction = problem_info["language_instruction"]
-    # list of all demonstrations episodes
-    demos = list(f["data"].keys())
-    bddl_file_name = f["data"].attrs["bddl_file_name"]
-    bddl_file_dir = os.path.dirname(bddl_file_name)
-    replace_bddl_prefix = "/".join(bddl_file_dir.split("bddl_files/")[:-1] + "bddl_files")
-    hdf5_path = os.path.join(get_libero_path("datasets"), bddl_file_dir.split("bddl_files/")[-1].replace(".bddl", "_demo.hdf5"))
-    output_parent_dir = Path(hdf5_path).parent
-    output_parent_dir.mkdir(parents=True, exist_ok=True)
-    h5py_f = h5py.File(hdf5_path, "w")
-    grp = h5py_f.create_group("data")
-    grp.attrs["env_name"] = env_name
-    grp.attrs["problem_info"] = f["data"].attrs["problem_info"]
-    grp.attrs["macros_image_convention"] = macros.IMAGE_CONVENTION
-    libero_utils.update_env_kwargs(
-        env_kwargs,
-        bddl_file_name=bddl_file_name,
-        has_renderer=not args.use_camera_obs,
-        has_offscreen_renderer=args.use_camera_obs,
-        ignore_done=True,
-        use_camera_obs=args.use_camera_obs,
-        camera_depths=args.use_depth,
-        camera_names=[
-            "robot0_eye_in_hand",
-            "agentview",
-        ],
-        reward_shaping=True,
-        control_freq=20,
-        camera_heights=128,
-        camera_widths=128,
-        camera_segmentations=None,
-    )
-    grp.attrs["bddl_file_name"] = bddl_file_name
-    grp.attrs["bddl_file_content"] = open(bddl_file_name, "r").read()
-    print(grp.attrs["bddl_file_content"])
-    env = TASK_MAPPING[problem_name](
-        **env_kwargs,
-    )
-    env_args = {
-        "type": 1,
-        "env_name": env_name,
-        "problem_name": problem_name,
-        "bddl_file": f["data"].attrs["bddl_file_name"],
-        "env_kwargs": env_kwargs,
-    }
-    grp.attrs["env_args"] = json.dumps(env_args)
-    print(grp.attrs["env_args"])
-    total_len = 0
-    demos = demos
-    cap_index = 5
-    for (i, ep) in enumerate(demos):
-        print("Playing back random episode... (press ESC to quit)")
-        # # select an episode randomly
-        # read the model xml, using the metadata stored in the attribute for this episode
-        model_xml = f["data/{}".format(ep)].attrs["model_file"]
-        reset_success = False
-        while not reset_success:
-            try:
-                env.reset()
-                reset_success = True
-            except:
-                continue
-        model_xml = libero_utils.postprocess_model_xml(model_xml, {})
-        if not args.use_camera_obs:
-            env.viewer.set_camera(0)
-        # load the flattened mujoco states
-        states = f["data/{}/states".format(ep)][()]
-        actions = np.array(f["data/{}/actions".format(ep)][()])
-        num_actions = actions.shape[0]
-        init_idx = 0
-        env.reset_from_xml_string(model_xml)
-        env.sim.reset()
-        env.sim.set_state_from_flattened(states[init_idx])
-        env.sim.forward()
-        model_xml = env.sim.model.get_xml()
-        ee_states = []
-        gripper_states = []
-        joint_states = []
-        robot_states = []
-        agentview_images = []
-        eye_in_hand_images = []
-        agentview_depths = []
-        eye_in_hand_depths = []
-        agentview_seg = {0: [], 1: [], 2: [], 3: [], 4: []}
-        rewards = []
-        dones = []
-        valid_index = []
-        for j, action in enumerate(actions):
-            obs, reward, done, info = env.step(action)
-            if j < num_actions - 1:
-                # ensure that the actions deterministically lead to the same recorded states
-                state_playback = env.sim.get_state().flatten()
-                # assert(np.all(np.equal(states[j + 1], state_playback)))
-                err = np.linalg.norm(states[j + 1] - state_playback)
-                if err > 0.01:
-                    print(
-                        f"[warning] playback diverged by {err:.2f} for ep {ep} at step {j}"
-                    )
-            # Skip recording because the force sensor is not stable in
-            # the beginning
-            if j < cap_index:
-                continue
-            valid_index.append(j)
-            if not args.no_proprio:
-                if "robot0_gripper_qpos" in obs:
-                    gripper_states.append(obs["robot0_gripper_qpos"])
-                joint_states.append(obs["robot0_joint_pos"])
-                ee_states.append(
-                    np.hstack(
-                        (
-                            obs["robot0_eef_pos"],
-                            T.quat2axisangle(obs["robot0_eef_quat"]),
-                        )
-                    )
-                )
-            robot_states.append(env.get_robot_state_vector(obs))
-            if args.use_camera_obs:
-                if args.use_depth:
-                    agentview_depths.append(obs["agentview_depth"])
-                    eye_in_hand_depths.append(obs["robot0_eye_in_hand_depth"])
-                agentview_images.append(obs["agentview_image"])
-                eye_in_hand_images.append(obs["robot0_eye_in_hand_image"])
-            else:
-                env.render()
-        # end of one trajectory
-        states = states[valid_index]
-        actions = actions[valid_index]
-        dones = np.zeros(len(actions)).astype(np.uint8)
-        dones[-1] = 1
-        rewards = np.zeros(len(actions)).astype(np.uint8)
-        rewards[-1] = 1
-        print(len(actions), len(agentview_images))
-        assert len(actions) == len(agentview_images)
-        print(len(actions))
-        ep_data_grp = grp.create_group(f"demo_{i}")
-        obs_grp = ep_data_grp.create_group("obs")
-        if not args.no_proprio:
-            obs_grp.create_dataset(
-                "gripper_states", data=np.stack(gripper_states, axis=0)
-            )
-            obs_grp.create_dataset("joint_states", data=np.stack(joint_states, axis=0))
-            obs_grp.create_dataset("ee_states", data=np.stack(ee_states, axis=0))
-            obs_grp.create_dataset("ee_pos", data=np.stack(ee_states, axis=0)[:, :3])
-            obs_grp.create_dataset("ee_ori", data=np.stack(ee_states, axis=0)[:, 3:])
-        obs_grp.create_dataset("agentview_rgb", data=np.stack(agentview_images, axis=0))
-        obs_grp.create_dataset(
-            "eye_in_hand_rgb", data=np.stack(eye_in_hand_images, axis=0)
-        )
-        if args.use_depth:
-            obs_grp.create_dataset(
-                "agentview_depth", data=np.stack(agentview_depths, axis=0)
-            )
-            obs_grp.create_dataset(
-                "eye_in_hand_depth", data=np.stack(eye_in_hand_depths, axis=0)
-            )
-        ep_data_grp.create_dataset("actions", data=actions)
-        ep_data_grp.create_dataset("states", data=states)
-        ep_data_grp.create_dataset("robot_states", data=np.stack(robot_states, axis=0))
-        ep_data_grp.create_dataset("rewards", data=rewards)
-        ep_data_grp.create_dataset("dones", data=dones)
-        ep_data_grp.attrs["num_samples"] = len(agentview_images)
-        ep_data_grp.attrs["model_file"] = model_xml
-        ep_data_grp.attrs["init_state"] = states[init_idx]
-        total_len += len(agentview_images)
-    grp.attrs["num_demos"] = len(demos)
-    grp.attrs["total"] = total_len
-    env.close()
-    h5py_f.close()
-    f.close()
-    print("The created dataset is saved in the following path: ")
-    print(hdf5_path)
-if __name__ == "__main__":
-    main()

scripts/create_libero_task_example.py DELETED Viewed

@@ -1,107 +0,0 @@
-"""This is a standalone file for create a task in libero."""
-import numpy as np
-from libero.libero.utils.bddl_generation_utils import (
-    get_xy_region_kwargs_list_from_regions_info,
-)
-from libero.libero.utils.mu_utils import register_mu, InitialSceneTemplates
-from libero.libero.utils.task_generation_utils import (
-    register_task_info,
-    get_task_info,
-    generate_bddl_from_task_info,
-)
-@register_mu(scene_type="kitchen")
-class KitchenScene1(InitialSceneTemplates):
-    def __init__(self):
-        fixture_num_info = {
-            "kitchen_table": 1,
-            "wooden_cabinet": 1,
-        }
-        object_num_info = {
-            "akita_black_bowl": 1,
-            "plate": 1,
-        }
-        super().__init__(
-            workspace_name="kitchen_table",
-            fixture_num_info=fixture_num_info,
-            object_num_info=object_num_info,
-        )
-    def define_regions(self):
-        self.regions.update(
-            self.get_region_dict(
-                region_centroid_xy=[0.0, -0.30],
-                region_name="wooden_cabinet_init_region",
-                target_name=self.workspace_name,
-                region_half_len=0.01,
-                yaw_rotation=(np.pi, np.pi),
-            )
-        )
-        self.regions.update(
-            self.get_region_dict(
-                region_centroid_xy=[0.0, 0.0],
-                region_name="akita_black_bowl_init_region",
-                target_name=self.workspace_name,
-                region_half_len=0.025,
-            )
-        )
-        self.regions.update(
-            self.get_region_dict(
-                region_centroid_xy=[0.0, 0.25],
-                region_name="plate_init_region",
-                target_name=self.workspace_name,
-                region_half_len=0.025,
-            )
-        )
-        self.xy_region_kwargs_list = get_xy_region_kwargs_list_from_regions_info(
-            self.regions
-        )
-    @property
-    def init_states(self):
-        states = [
-            ("On", "akita_black_bowl_1", "kitchen_table_akita_black_bowl_init_region"),
-            ("On", "plate_1", "kitchen_table_plate_init_region"),
-            ("On", "wooden_cabinet_1", "kitchen_table_wooden_cabinet_init_region"),
-        ]
-        return states
-def main():
-    # kitchen_scene_1
-    scene_name = "kitchen_scene1"
-    language = "Your Language 1"
-    register_task_info(
-        language,
-        scene_name=scene_name,
-        objects_of_interest=["wooden_cabinet_1", "akita_black_bowl_1"],
-        goal_states=[
-            ("Open", "wooden_cabinet_1_top_region"),
-            ("In", "akita_black_bowl_1", "wooden_cabinet_1_top_region"),
-        ],
-    )
-    scene_name = "kitchen_scene1"
-    language = "Your Language 2"
-    register_task_info(
-        language,
-        scene_name=scene_name,
-        objects_of_interest=["wooden_cabinet_1", "akita_black_bowl_1"],
-        goal_states=[
-            ("Open", "wooden_cabinet_1_top_region"),
-            ("In", "akita_black_bowl_1", "wooden_cabinet_1_bottom_region"),
-        ],
-    )
-    bddl_file_names, failures = generate_bddl_from_task_info()
-    print(bddl_file_names)
-if __name__ == "__main__":
-    main()

scripts/create_template.py DELETED Viewed

@@ -1,96 +0,0 @@
-"""
-This is a script for creating various files frrom templates. This is to ease the process for users who want to extend LIBERO, creating new tasks. You would still need to make necessary changes based on the template to serve your own need, but the hope is that we save you much time by providing the necessar templates.
-"""
-import os
-import xml.etree.ElementTree as ET
-from libero.libero import get_libero_path
-from libero.libero.envs.textures import get_texture_file_list
-def create_problem_class_from_file(class_name):
-    template_source_file = os.path.join(
-        get_libero_path("benchmark_root"), "../../templates/problem_class_template.py"
-    )
-    with open(template_source_file, "r") as f:
-        lines = f.readlines()
-    new_lines = []
-    for line in lines:
-        if "YOUR_CLASS_NAME" in line:
-            line = line.replace("YOUR_CLASS_NAME", class_name)
-        new_lines.append(line)
-    with open(f"{class_name.lower()}.py", "w") as f:
-        f.writelines(new_lines)
-    print(f"Creating class {class_name} at the file: {class_name.lower()}.py")
-def create_scene_xml_file(scene_name):
-    """This is just an example for you to jump start. For more advanced editing, you will need to figure out yourself. You can take a look at all the available xml files for reference."""
-    template_source_file = os.path.join(
-        get_libero_path("benchmark_root"), "../../templates/scene_template.xml"
-    )
-    parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True))
-    tree = ET.parse(template_source_file, parser)
-    root = tree.getroot()
-    basic_elements = [
-        ("Floor", "texplane"),
-        ("Table", "tex-table"),
-        ("Table legs", "tex-table-legs"),
-        ("Walls", "tex-wall"),
-    ]
-    for (element_name, texture_name) in basic_elements:
-        element = root.findall('.//texture[@name="{}"]'.format(texture_name))[0]
-        type = None
-        if "floor" in element_name.lower():
-            type = "floor"
-        elif "table" in element_name.lower():
-            type = "table"
-        elif "wall" in element_name.lower():
-            type = "wall"
-        # If you want to change the path of the texture file, you can pass in texture_path variable to change it.
-        texture_list = get_texture_file_list(type=type, texture_path="../")
-        for i, (texture_name, texture_file_path) in enumerate(texture_list):
-            print(f"[{i}]: {texture_name}")
-        choice = int(input(f"Please select which texture to use for {element_name}: "))
-        element.set("file", texture_list[choice][1])
-    tree.write(f"{scene_name}.xml", encoding="utf-8")
-    print(f"Creating scene {scene_name} at the file: {scene_name}.xml")
-    print(
-        "\n [Notice] The texture fiile paths are specified in the relative path format assuming your scene xml will be placed in the path libero/libero/assets/scenes/. "
-    )
-    return
-def main():
-    # use keyboard to select which file to create
-    choices = [
-        "problem_class",
-        "scene",
-        "object",
-        "arena",
-    ]
-    for i, choice in enumerate(choices):
-        print(f"[{i}]: {choice}")
-    choice = int(input("Please select which file to create: "))
-    if choices[choice] == "problem_class":
-        # Ask user to specify the class name
-        class_name = input("Please specify the class name: ")
-        assert " " not in class_name, "space is not allowed in the naming"
-        parts = class_name.split("_")
-        class_name = "_".join([part.lower().capitalize() for part in parts])
-        create_problem_class_from_file(class_name)
-    elif choices[choice] == "scene":
-        # Ask user to specify the scene name
-        scene_name = input("Please specify the scene name: ")
-        scene_name = scene_name.lower()
-        assert " " not in scene_name, "space is not allowed in the naming"
-        create_scene_xml_file(scene_name)
-if __name__ == "__main__":
-    main()

scripts/get_affordance_info.py DELETED Viewed

@@ -1,9 +0,0 @@
-# This is an example script to get all the affordance information specified in xml files.
-import init_path
-from libero.libero.envs.objects import OBJECTS_DICT
-from libero.libero.utils.object_utils import get_affordance_regions
-affordances = get_affordance_regions(OBJECTS_DICT)
-print(affordances)

scripts/get_dataset_info.py DELETED Viewed

@@ -1,156 +0,0 @@
-"""
-Helper script to report dataset information. By default, will print trajectory length statistics,
-the maximum and minimum action element in the dataset, filter keys present, environment
-metadata, and the structure of the first demonstration. If --verbose is passed, it will
-report the exact demo keys under each filter key, and the structure of all demonstrations
-(not just the first one).
-Args:
-    dataset (str): path to hdf5 dataset
-    filter_key (str): if provided, report statistics on the subset of trajectories
-        in the file that correspond to this filter key
-    verbose (bool): if flag is provided, print more details, like the structure of all
-        demonstrations (not just the first one)
-Example usage:
-    # run script on example hdf5 packaged with repository
-    python get_dataset_info.py --dataset ../../tests/assets/test.hdf5
-    # run script only on validation data
-    python get_dataset_info.py --dataset ../../tests/assets/test.hdf5 --filter_key valid
-"""
-import h5py
-import json
-import argparse
-import numpy as np
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        help="path to hdf5 dataset",
-    )
-    parser.add_argument(
-        "--filter_key",
-        type=str,
-        default=None,
-        help="(optional) if provided, report statistics on the subset of trajectories \
-            in the file that correspond to this filter key",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="verbose output",
-    )
-    args = parser.parse_args()
-    # extract demonstration list from file
-    filter_key = args.filter_key
-    all_filter_keys = None
-    f = h5py.File(args.dataset, "r")
-    if filter_key is not None:
-        # use the demonstrations from the filter key instead
-        print("NOTE: using filter key {}".format(filter_key))
-        demos = sorted(
-            [elem.decode("utf-8") for elem in np.array(f["mask/{}".format(filter_key)])]
-        )
-    else:
-        # use all demonstrations
-        demos = sorted(list(f["data"].keys()))
-        # extract filter key information
-        if "mask" in f:
-            all_filter_keys = {}
-            for fk in f["mask"]:
-                fk_demos = sorted(
-                    [elem.decode("utf-8") for elem in np.array(f["mask/{}".format(fk)])]
-                )
-                all_filter_keys[fk] = fk_demos
-    # put demonstration list in increasing episode order
-    inds = np.argsort([int(elem[5:]) for elem in demos])
-    demos = [demos[i] for i in inds]
-    # extract length of each trajectory in the file
-    traj_lengths = []
-    action_min = np.inf
-    action_max = -np.inf
-    for ep in demos:
-        traj_lengths.append(f["data/{}/actions".format(ep)].shape[0])
-        action_min = min(action_min, np.min(f["data/{}/actions".format(ep)][()]))
-        action_max = max(action_max, np.max(f["data/{}/actions".format(ep)][()]))
-    traj_lengths = np.array(traj_lengths)
-    problem_info = json.loads(f["data"].attrs["problem_info"])
-    language_instruction = "".join(problem_info["language_instruction"])
-    # report statistics on the data
-    print("")
-    print("total transitions: {}".format(np.sum(traj_lengths)))
-    print("total trajectories: {}".format(traj_lengths.shape[0]))
-    print("traj length mean: {}".format(np.mean(traj_lengths)))
-    print("traj length std: {}".format(np.std(traj_lengths)))
-    print("traj length min: {}".format(np.min(traj_lengths)))
-    print("traj length max: {}".format(np.max(traj_lengths)))
-    print("action min: {}".format(action_min))
-    print("action max: {}".format(action_max))
-    print("language instruction: {}".format(language_instruction.strip('"')))
-    print("")
-    print("==== Filter Keys ====")
-    if all_filter_keys is not None:
-        for fk in all_filter_keys:
-            print("filter key {} with {} demos".format(fk, len(all_filter_keys[fk])))
-    else:
-        print("no filter keys")
-    print("")
-    if args.verbose:
-        if all_filter_keys is not None:
-            print("==== Filter Key Contents ====")
-            for fk in all_filter_keys:
-                print(
-                    "filter_key {} with {} demos: {}".format(
-                        fk, len(all_filter_keys[fk]), all_filter_keys[fk]
-                    )
-                )
-        print("")
-    env_meta = json.loads(f["data"].attrs["env_args"])
-    print("==== Env Meta ====")
-    print(json.dumps(env_meta, indent=4))
-    print("")
-    print("==== Dataset Structure ====")
-    for ep in demos:
-        print(
-            "episode {} with {} transitions".format(
-                ep, f["data/{}".format(ep)].attrs["num_samples"]
-            )
-        )
-        for k in f["data/{}".format(ep)]:
-            if k in ["obs", "next_obs"]:
-                print("    key: {}".format(k))
-                for obs_k in f["data/{}/{}".format(ep, k)]:
-                    shape = f["data/{}/{}/{}".format(ep, k, obs_k)].shape
-                    print(
-                        "        observation key {} with shape {}".format(obs_k, shape)
-                    )
-            elif isinstance(f["data/{}/{}".format(ep, k)], h5py.Dataset):
-                key_shape = f["data/{}/{}".format(ep, k)].shape
-                print("    key: {} with shape {}".format(k, key_shape))
-        if not args.verbose:
-            break
-    f.close()
-    # maybe display error message
-    print("")
-    if (action_min < -1.0) or (action_max > 1.0):
-        raise Exception(
-            "Dataset should have actions in [-1., 1.] but got bounds [{}, {}]".format(
-                action_min, action_max
-            )
-        )

scripts/init_path.py DELETED Viewed

@@ -1,5 +0,0 @@
-import sys
-import os
-path = os.path.dirname(os.path.realpath(__file__))
-sys.path.insert(0, os.path.join(path, "../"))

scripts/libero_100_collect_demonstrations.py DELETED Viewed

@@ -1,372 +0,0 @@
-"""
-Modified from robosuite example scripts.
-A script to collect a batch of human demonstrations that can be used
-to generate a learning curriculum (see `demo_learning_curriculum.py`).
-The demonstrations can be played back using the `playback_demonstrations_from_pkl.py`
-script.
-"""
-import argparse
-import cv2
-import datetime
-import h5py
-import init_path
-import json
-import numpy as np
-import os
-import robosuite as suite
-import time
-from glob import glob
-from robosuite import load_controller_config
-from robosuite.wrappers import DataCollectionWrapper, VisualizationWrapper
-from robosuite.utils.input_utils import input2action
-import libero.libero.envs.bddl_utils as BDDLUtils
-from libero.libero.envs import *
-from termcolor import colored
-def collect_human_trajectory(
-    env, device, arm, env_configuration, problem_info, remove_directory=[]
-):
-    """
-    Use the device (keyboard or SpaceNav 3D mouse) to collect a demonstration.
-    The rollout trajectory is saved to files in npz format.
-    Modify the DataCollectionWrapper wrapper to add new fields or change data formats.
-    Args:
-        env (MujocoEnv): environment to control
-        device (Device): to receive controls from the device
-        arms (str): which arm to control (eg bimanual) 'right' or 'left'
-        env_configuration (str): specified environment configuration
-    """
-    reset_success = False
-    while not reset_success:
-        try:
-            env.reset()
-            reset_success = True
-        except:
-            continue
-    # ID = 2 always corresponds to agentview
-    env.render()
-    task_completion_hold_count = (
-        -1
-    )  # counter to collect 10 timesteps after reaching goal
-    device.start_control()
-    # Loop until we get a reset from the input or the task completes
-    saving = True
-    count = 0
-    while True:
-        count += 1
-        # Set active robot
-        active_robot = (
-            env.robots[0]
-            if env_configuration == "bimanual"
-            else env.robots[arm == "left"]
-        )
-        # Get the newest action
-        action, grasp = input2action(
-            device=device,
-            robot=active_robot,
-            active_arm=arm,
-            env_configuration=env_configuration,
-        )
-        # If action is none, then this a reset so we should break
-        if action is None:
-            print("Break")
-            saving = False
-            break
-        # Run environment step
-        env.step(action)
-        env.render()
-        # Also break if we complete the task
-        if task_completion_hold_count == 0:
-            break
-        # state machine to check for having a success for 10 consecutive timesteps
-        if env._check_success():
-            if task_completion_hold_count > 0:
-                task_completion_hold_count -= 1  # latched state, decrement count
-            else:
-                task_completion_hold_count = 10  # reset count on first success timestep
-        else:
-            task_completion_hold_count = -1  # null the counter if there's no success
-    print(count)
-    # cleanup for end of data collection episodes
-    if not saving:
-        remove_directory.append(env.ep_directory.split("/")[-1])
-    env.close()
-    return saving
-def gather_demonstrations_as_hdf5(
-    directory, out_dir, env_info, args, remove_directory=[]
-):
-    """
-    Gathers the demonstrations saved in @directory into a
-    single hdf5 file.
-    The strucure of the hdf5 file is as follows.
-    data (group)
-        date (attribute) - date of collection
-        time (attribute) - time of collection
-        repository_version (attribute) - repository version used during collection
-        env (attribute) - environment name on which demos were collected
-        demo1 (group) - every demonstration has a group
-            model_file (attribute) - model xml string for demonstration
-            states (dataset) - flattened mujoco states
-            actions (dataset) - actions applied during demonstration
-        demo2 (group)
-        ...
-    Args:
-        directory (str): Path to the directory containing raw demonstrations.
-        out_dir (str): Path to where to store the hdf5 file.
-        env_info (str): JSON-encoded string containing environment information,
-            including controller and robot info
-    """
-    hdf5_path = os.path.join(out_dir, "demo.hdf5")
-    f = h5py.File(hdf5_path, "w")
-    # store some metadata in the attributes of one group
-    grp = f.create_group("data")
-    num_eps = 0
-    env_name = None  # will get populated at some point
-    for ep_directory in os.listdir(directory):
-        # print(ep_directory)
-        if ep_directory in remove_directory:
-            # print("Skipping")
-            continue
-        state_paths = os.path.join(directory, ep_directory, "state_*.npz")
-        states = []
-        actions = []
-        for state_file in sorted(glob(state_paths)):
-            dic = np.load(state_file, allow_pickle=True)
-            env_name = str(dic["env"])
-            states.extend(dic["states"])
-            for ai in dic["action_infos"]:
-                actions.append(ai["actions"])
-        if len(states) == 0:
-            continue
-        # Delete the first actions and the last state. This is because when the DataCollector wrapper
-        # recorded the states and actions, the states were recorded AFTER playing that action.
-        del states[-1]
-        assert len(states) == len(actions)
-        num_eps += 1
-        ep_data_grp = grp.create_group("demo_{}".format(num_eps))
-        # store model xml as an attribute
-        xml_path = os.path.join(directory, ep_directory, "model.xml")
-        with open(xml_path, "r") as f:
-            xml_str = f.read()
-        ep_data_grp.attrs["model_file"] = xml_str
-        # write datasets for states and actions
-        ep_data_grp.create_dataset("states", data=np.array(states))
-        ep_data_grp.create_dataset("actions", data=np.array(actions))
-    # write dataset attributes (metadata)
-    now = datetime.datetime.now()
-    grp.attrs["date"] = "{}-{}-{}".format(now.month, now.day, now.year)
-    grp.attrs["time"] = "{}:{}:{}".format(now.hour, now.minute, now.second)
-    grp.attrs["repository_version"] = suite.__version__
-    grp.attrs["env"] = env_name
-    grp.attrs["env_info"] = env_info
-    grp.attrs["problem_info"] = json.dumps(problem_info)
-    grp.attrs["bddl_file_name"] = args.bddl_file
-    grp.attrs["bddl_file_content"] = str(open(args.bddl_file, "r", encoding="utf-8"))
-    f.close()
-if __name__ == "__main__":
-    # Arguments
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--directory",
-        type=str,
-        default="demonstration_data",
-    )
-    parser.add_argument(
-        "--robots",
-        nargs="+",
-        type=list,
-        default=["Panda"],
-        help="Which robot(s) to use in the env",
-    )
-    parser.add_argument(
-        "--config",
-        type=str,
-        default="single-arm-opposed",
-        help="Specified environment configuration if necessary",
-    )
-    parser.add_argument(
-        "--arm",
-        type=str,
-        default="right",
-        help="Which arm to control (eg bimanual) 'right' or 'left'",
-    )
-    parser.add_argument(
-        "--camera",
-        type=str,
-        default="agentview",
-        help="Which camera to use for collecting demos",
-    )
-    parser.add_argument(
-        "--controller",
-        type=str,
-        default="OSC_POSE",
-        help="Choice of controller. Can be 'IK_POSE' or 'OSC_POSE'",
-    )
-    parser.add_argument("--device", type=str, default="spacemouse")
-    parser.add_argument(
-        "--pos-sensitivity",
-        type=float,
-        default=1.5,
-        help="How much to scale position user inputs",
-    )
-    parser.add_argument(
-        "--rot-sensitivity",
-        type=float,
-        default=1.5,
-        help="How much to scale rotation user inputs",
-    )
-    parser.add_argument(
-        "--num-demonstration",
-        type=int,
-        default=50,
-        help="How much to scale rotation user inputs",
-    )
-    parser.add_argument("--bddl-file", type=str, default=None)
-    parser.add_argument("--task-id", type=int)
-    parser.add_argument("--vendor-id", type=int, default=9583)
-    parser.add_argument("--product-id", type=int, default=50734)
-    args = parser.parse_args()
-    # Get controller config
-    controller_config = load_controller_config(default_controller=args.controller)
-    # Create argument configuration
-    config = {
-        "robots": args.robots,
-        "controller_configs": controller_config,
-    }
-    assert os.path.exists(args.bddl_file)
-    problem_info = BDDLUtils.get_problem_info(args.bddl_file)
-    # Check if we're using a multi-armed environment and use env_configuration argument if so
-    # Create environment
-    problem_name = problem_info["problem_name"]
-    domain_name = problem_info["domain_name"]
-    language_instruction = problem_info["language_instruction"]
-    text = colored(language_instruction, "red", attrs=["bold"])
-    print("Goal of the following task: ", text)
-    instruction = colored("Hit any key to proceed to data collection ...", "green", attrs=["reverse", "blink"])
-    print(instruction)
-    input()
-    if "TwoArm" in problem_name:
-        config["env_configuration"] = args.config
-    print(language_instruction)
-    env = TASK_MAPPING[problem_name](
-        bddl_file_name=args.bddl_file,
-        **config,
-        has_renderer=True,
-        has_offscreen_renderer=False,
-        render_camera=args.camera,
-        ignore_done=True,
-        use_camera_obs=False,
-        reward_shaping=True,
-        control_freq=20,
-    )
-    # Wrap this with visualization wrapper
-    env = VisualizationWrapper(env)
-    # Grab reference to controller config and convert it to json-encoded string
-    env_info = json.dumps(config)
-    # wrap the environment with data collection wrapper
-    tmp_directory = "demonstration_data/tmp/{}_ln_{}/{}".format(
-        problem_name,
-        language_instruction.replace(" ", "_").strip('""'),
-        str(time.time()).replace(".", "_"),
-    )
-    env = DataCollectionWrapper(env, tmp_directory)
-    # initialize device
-    if args.device == "keyboard":
-        from robosuite.devices import Keyboard
-        device = Keyboard(
-            pos_sensitivity=args.pos_sensitivity, rot_sensitivity=args.rot_sensitivity
-        )
-        env.viewer.add_keypress_callback("any", device.on_press)
-        env.viewer.add_keyup_callback("any", device.on_release)
-        env.viewer.add_keyrepeat_callback("any", device.on_press)
-    elif args.device == "spacemouse":
-        from robosuite.devices import SpaceMouse
-        device = SpaceMouse(
-            args.vendor_id,
-            args.product_id,
-            pos_sensitivity=args.pos_sensitivity,
-            rot_sensitivity=args.rot_sensitivity,
-        )
-    else:
-        raise Exception(
-            "Invalid device choice: choose either 'keyboard' or 'spacemouse'."
-        )
-    # make a new timestamped directory
-    t1, t2 = str(time.time()).split(".")
-    new_dir = os.path.join(
-        args.directory,
-        f"{domain_name}_ln_{problem_name}_{t1}_{t2}_"
-        + language_instruction.replace(" ", "_").strip('""'),
-    )
-    os.makedirs(new_dir)
-    # collect demonstrations
-    remove_directory = []
-    i = 0
-    while i < args.num_demonstration:
-        print(i)
-        saving = collect_human_trajectory(
-            env, device, args.arm, args.config, problem_info, remove_directory
-        )
-        if saving:
-            print(remove_directory)
-            gather_demonstrations_as_hdf5(
-                tmp_directory, new_dir, env_info, args, remove_directory
-            )
-            i += 1