Upload generate_sequences.py

generate_sequences.py

@@ -0,0 +1,201 @@
+import os
+import numpy as np
+import pickle
+import time
+from agents.orderenforcingwrapper import OrderEnforcingAgent
+from citylearn.citylearn import CityLearnEnv
+
+"""
+This file is used to generate offline data for a decision transformer.
+Data is saved as pickle file.
+Data structure:
+list(
+    dict(
+        "observations": nparray(nparray(np.float32)),
+        "next_observations": nparray(nparray(np.float32)),
+        "actions": nparray(nparray(np.float32)),
+        "rewards": nparray(np.oat32),
+        "terminals": nparray(np.bool_)
+        )
+    )
+"""
+
+
+class Constants:
+    file_to_save = "non.pkl"
+    sequence_length = 720
+    episodes = 1
+    state_dim = 28  # size of state space
+    action_dim = 1  # size of action space
+    schema_path = './data/citylearn_challenge_2022_phase_1/schema.json'
+
+
+def action_space_to_dict(aspace):
+    """ Only for box space """
+    return {"high": aspace.high,
+            "low": aspace.low,
+            "shape": aspace.shape,
+            "dtype": str(aspace.dtype)
+            }
+
+
+def env_reset(env):
+    observations = env.reset()
+    action_space = env.action_space
+    observation_space = env.observation_space
+    building_info = env.get_building_information()
+    building_info = list(building_info.values())
+    action_space_dicts = [action_space_to_dict(asp) for asp in action_space]
+    observation_space_dicts = [action_space_to_dict(osp) for osp in observation_space]
+    obs_dict = {"action_space": action_space_dicts,
+                "observation_space": observation_space_dicts,
+                "building_info": building_info,
+                "observation": observations}
+    return obs_dict
+
+
+def generate_data():
+    print("========================= Start Data Collection ========================")
+
+    env = CityLearnEnv(schema=Constants.schema_path)
+    agent = OrderEnforcingAgent()
+
+    dataset = []
+    observation_data = []
+    next_observation_data = []
+    action_data = []
+    reward_data = []
+    done_data = []
+
+    obs_dict = env_reset(env)
+    observations = obs_dict["observation"]
+
+    agent_time_elapsed = 0
+
+    step_start = time.perf_counter()
+    actions = agent.register_reset(obs_dict)
+    agent_time_elapsed += time.perf_counter() - step_start
+
+    episodes_completed = 0
+    sequences_completed = 0
+    current_step_total = 0
+    current_step_in_sequence = 0
+    interrupted = False
+    episode_metrics = []
+
+    try:
+        while True:
+            current_step_in_sequence += 1
+            current_step_total += 1
+            next_observations, reward, done, info = env.step(actions)
+            # ACTION [-1,1] attempts to decrease or increase the electricity stored in the battery by an amount
+            # equivalent to action times its maximum capacity
+            # Save environment interactions:
+            observation_data.append(observations)
+            next_observation_data.append(next_observations)
+            action_data.append(actions)
+            reward_data.append(reward)
+            done_data.append(False)  # always False
+
+            observations = next_observations  # observations of next time step
+
+            if current_step_in_sequence >= Constants.sequence_length:  # Sequence completed
+                current_step_in_sequence = 0
+                sequences_completed += 1
+
+                for bi in range(len(env.buildings)):
+                    obs_building_i = np.zeros((Constants.sequence_length, Constants.state_dim), dtype=np.float32)
+                    n_obs_building_i = np.zeros((Constants.sequence_length, Constants.state_dim), dtype=np.float32)
+                    acts_building_i = np.zeros((Constants.sequence_length, Constants.action_dim), dtype=np.float32)
+                    rwds_building_i = np.zeros(Constants.sequence_length, dtype=np.float32)
+                    dones_building_i = np.zeros(Constants.sequence_length, dtype=np.bool_)
+                    for ti in range(Constants.sequence_length):
+                        obs_building_i[ti] = np.array(observation_data[ti][bi])
+                        n_obs_building_i[ti] = np.array(next_observation_data[ti][bi])
+                        acts_building_i[ti] = np.array(action_data[ti][bi])
+                        rwds_building_i[ti] = reward_data[ti][bi]
+                        dones_building_i[ti] = done_data[ti]
+
+                    dict_building_i = {
+                        "observations": obs_building_i,
+                        "next_observations": n_obs_building_i,
+                        "actions": acts_building_i,
+                        "rewards": rwds_building_i,
+                        "terminals": dones_building_i
+                    }
+                    dataset.append(dict_building_i)
+
+                observation_data = []
+                next_observation_data = []
+                action_data = []
+                reward_data = []
+                done_data = []
+                print("Sequence completed:", sequences_completed)
+
+            if done:
+                episodes_completed += 1
+
+                metrics_t = env.evaluate()
+                metrics = {"price_cost": metrics_t[0], "emmision_cost": metrics_t[1], "grid_cost": metrics_t[2]}
+                if np.any(np.isnan(metrics_t)):
+                    raise ValueError("Episode metrics are nan, please contant organizers")
+                episode_metrics.append(metrics)
+                print(f"Episode complete: {episodes_completed} | Latest episode metrics: {metrics}", )
+
+                obs_dict = env_reset(env)
+                observations = obs_dict["observation"]
+
+                step_start = time.perf_counter()
+                actions = agent.register_reset(obs_dict)
+                agent_time_elapsed += time.perf_counter() - step_start
+            else:
+                step_start = time.perf_counter()
+                actions = agent.compute_action(next_observations)
+                agent_time_elapsed += time.perf_counter() - step_start
+
+            if current_step_total % 1000 == 0:
+                print(f"Num Steps: {current_step_total}, Num episodes: {episodes_completed}")
+
+            if episodes_completed >= Constants.episodes:
+                break
+    except KeyboardInterrupt:
+        print("========================= Stopping Generation ==========================")
+        interrupted = True
+
+    if not interrupted:
+        print("========================= Generation Completed =========================")
+
+    if len(episode_metrics) > 0:
+        print("Agent Performance:")
+        print("Average Price Cost:", np.mean([e['price_cost'] for e in episode_metrics]))
+        print("Average Emission Cost:", np.mean([e['emmision_cost'] for e in episode_metrics]))
+        print("Average Grid Cost:", np.mean([e['grid_cost'] for e in episode_metrics]))
+    print(f"Total time taken by agent: {agent_time_elapsed}s")
+
+    print("========================= Writing Data File ============================")
+
+    length = 0
+    for data in dataset:
+        if len(data["observations"]) > length:
+            length = len(data["observations"])
+
+    print("Amount Of Sequences: ", len(dataset))
+    print("Longest Sequence: ", length)
+    total_values = (2 * Constants.state_dim + Constants.action_dim + 2) * length * len(dataset)
+    print("Total values to store: ", total_values)
+
+    # create or overwrite pickle file
+    with open(Constants.file_to_save, "wb") as f:
+        pickle.dump(dataset, f)
+
+    print("========================= Writing Completed ============================")
+    file_size = os.stat(Constants.file_to_save).st_size
+    if file_size > 1e+6:
+        string_byte = "(" + str(round(file_size / 1e+6)) + " MB)"
+    else:
+        string_byte = "(" + str(round(file_size / 1e+3)) + " kB)"
+    print("==> Data saved in", Constants.file_to_save, string_byte)
+
+
+if __name__ == '__main__':
+    generate_data()