register_minari_dataset.py

import os
import json
import numpy as np
import gymnasium as gym
from gymnasium.spaces import Box
import minari
from minari.data_collector import EpisodeBuffer
from minari import create_dataset_from_buffers
from gymnasium.envs.registration import EnvSpec
from numpy import dtype
from fcev import FCEVEnv, load_drive_cycle

def reward_function(stage_cost, state, beta=0.01, c=10):
    """Custom reward function based on stage cost and system state.

    Args:
        stage_cost (float): Original stage cost.
        state (np.ndarray): Observation state.
        beta (float): Slope parameter for logistic transformation.
        c (float): Cost offset threshold.

    Returns:
        float: Transformed reward value.
    """
    if stage_cost == 0 and state[0] == 0:
        return 0.0
    return 1 / (1 + np.exp(beta * (stage_cost - c)))


def load_matlab_json_data(json_path):
    with open(json_path, 'r') as f:
        data = json.load(f)

    episodes = dict()

    for t in data:
        eid = t.get("episode_id", 0)
        if eid not in episodes:
            episodes[eid] = {
                "observations": [],
                "actions": [],
                "rewards": [],
                "next_observations": [],
                "terminations": [],
            }
        episodes[eid]["observations"].append(t["observation"])
        episodes[eid]["actions"].append(t["action"])
        episodes[eid]["rewards"].append(reward_function(stage_cost=t["reward"],state=t["observation"]))
        episodes[eid]["next_observations"].append(t["next_observation"])
        episodes[eid]["terminations"].append(t["termination"])

    for epi in episodes.keys():
        episodes[epi]["observations"] = np.array(episodes[epi]["observations"], dtype=np.float32)
        episodes[epi]["actions"] = np.array(episodes[epi]["actions"], dtype=np.float32)
        episodes[epi]["rewards"] = np.array(episodes[epi]["rewards"], dtype=np.float32)
        if np.isnan(episodes[epi]["rewards"]).any():
            print("Detected NaN, in episode", eid)
            episodes[epi]["rewards"] = np.nan_to_num(episodes[epi]["rewards"], nan=0)
        episodes[epi]["next_observations"] = np.array(episodes[epi]["next_observations"], dtype=np.float32)
        episodes[epi]["terminations"] = np.array(episodes[epi]["terminations"], dtype=np.bool)

    return episodes


def register_minari_dataset(folder_path, dataset_id):
    dataset_json_path = os.path.join(folder_path, 'data', 'dataset.json')
    info_json_path = os.path.join(folder_path, 'dataset_info.json')

    # load data from json
    episodes = load_matlab_json_data(dataset_json_path)

    with open(info_json_path, 'r') as f:
        info = json.load(f)

    # example_ep = episodes[1]
    # obs_dim = example_ep["observations"].shape[1]
    # act_dim = example_ep["actions"].shape[1]
    #
    # observation_space = Box(-np.inf, np.inf, shape=(obs_dim,), dtype=np.float32)
    # action_space = Box(0.0, 1.0, shape=(act_dim,), dtype=np.float32)
    #
    # class DummyEnv(gym.Env):
    #     def __init__(self):
    #         self.observation_space = observation_space
    #         self.action_space = action_space
    #         self.spec = EnvSpec(id="FCEV-SimulatedEnv-v0")
    #
    # env = DummyEnv()
    env = FCEVEnv(load_drive_cycle("CLTC-P-PartI.csv"))

    buffers = []

    xid = 0

    for eid, ep in episodes.items():
        obs = ep["observations"]
        next_obs = ep["next_observations"]
        actions = ep["actions"]
        rewards = ep["rewards"]
        rewards = np.clip(rewards, -1e6, 1e6)
        terminations =ep["terminations"]
        truncations = np.zeros_like(terminations, dtype=bool)

        full_obs = np.vstack([obs, next_obs[-1:]])  # 末尾补 observation

        buffer = EpisodeBuffer(
            id=xid,
            observations=full_obs,
            actions=actions,
            rewards=rewards,
            terminations=terminations,
            truncations=truncations,
        )
        buffers.append(buffer)
        xid += 1

    dataset = create_dataset_from_buffers(
        dataset_id=dataset_id,
        env=env,
        buffer=buffers,
        algorithm_name=info.get("strategy_type", "unknown"),
        author=info.get("author", "matlab-export"),
    )

    print(f"✅ Minari dataset formed：{dataset_id}")
    return dataset


if __name__ == "__main__":
    base_dir = "minari_export"
    strategies = ["mpc", "rule"]

    for strat in strategies:
        folder = os.path.join(base_dir, f"minari_{strat}")
        dataset_id = f"fcev-{strat}-v1"
        try:
            minari.delete_dataset(dataset_id)
        except:
            pass
        register_minari_dataset(folder, dataset_id)