import numpy as np import time import torch from MyDecisionTransformer import MyDecisionTransformer from citylearn.citylearn import CityLearnEnv """ This file is used to evaluate a decision transformer loaded form https://huggingface.co/TobiTob/model_name """ class Constants: """Environment Constants""" episodes = 1 # amount of environment resets state_dim = 28 # size of state space action_dim = 1 # size of action space schema_path = './data/citylearn_challenge_2022_phase_1/schema.json' """Model Constants""" load_model = "TobiTob/decision_transformer_2" force_download = False device = "cpu" TARGET_RETURN = -2500 # vllt Vector aus 5 Werten # mean and std computed from training dataset these are available in the model card for each model. state_mean = np.array( [6.525973284621532, 3.9928073981048064, 12.498801233017467, 16.836990550577212, 16.837287388159297, 16.83684213167729, 16.837161803003287, 73.00388172165772, 73.00331088023746, 73.00445256307798, 73.00331088023746, 208.30597100125584, 208.30597100125584, 208.20287704075807, 208.30597100125584, 201.25448110514898, 201.25448110514898, 201.16189062678387, 201.25448110514898, 0.15652765849893777, 1.0663012570140091, 0.6994348432433195, 0.5023924181838172, 0.49339119658209996, 0.2731373418679261, 0.2731373418679261, 0.2731373418679261, 0.2731373418679261]) state_std = np.array( [3.448045414453991, 2.0032677368929734, 6.921673394725967, 3.564552828057008, 3.5647828974724476, 3.5643565817901974, 3.564711987899257, 16.480221141108398, 16.480030755727572, 16.480238315742053, 16.480030755727565, 292.79094956097464, 292.79094956097464, 292.70528837855596, 292.79094956097543, 296.18549714910006, 296.18549714910023, 296.1216266457902, 296.18549714910006, 0.035369600587780235, 0.8889958578862672, 1.0171468928300462, 0.40202104980478576, 2.6674362928093682, 0.11780233435944305, 0.11780233435944333, 0.11780233435944351, 0.11780233435944402]) def preprocess_states(state_list_of_lists, amount_buildings): for bi in range(amount_buildings): for si in range(Constants.state_dim): state_list_of_lists[bi][si] = (state_list_of_lists[bi][si] - Constants.state_mean[si]) / Constants.state_std[si] return state_list_of_lists def evaluate(): print("========================= Start Evaluation ========================") print("==> Model:", Constants.load_model) print() env = CityLearnEnv(schema=Constants.schema_path) agent = MyDecisionTransformer(load_from=Constants.load_model, force_download=Constants.force_download, device=Constants.device) context_length = agent.model.config.max_length amount_buildings = len(env.buildings) scale = 1000.0 # normalization for rewards/returns target_return = Constants.TARGET_RETURN / scale print("Target Return:", Constants.TARGET_RETURN) print("Context Length:", context_length) # Initialize Tensors episode_return = np.zeros(amount_buildings) state_list_of_lists = env.reset() state_list_of_lists = preprocess_states(state_list_of_lists, amount_buildings) state_list_of_tensors = [] target_return_list_of_tensors = [] action_list_of_tensors = [] reward_list_of_tensors = [] for bi in range(amount_buildings): state_bi = torch.from_numpy(np.array(state_list_of_lists[bi])).reshape(1, Constants.state_dim).to( device=Constants.device, dtype=torch.float32) target_return_bi = torch.tensor(target_return, device=Constants.device, dtype=torch.float32).reshape(1, 1) action_bi = torch.zeros((0, Constants.action_dim), device=Constants.device, dtype=torch.float32) reward_bi = torch.zeros(0, device=Constants.device, dtype=torch.float32) state_list_of_tensors.append(state_bi) target_return_list_of_tensors.append(target_return_bi) action_list_of_tensors.append(action_bi) reward_list_of_tensors.append(reward_bi) timesteps = torch.tensor(0, device=Constants.device, dtype=torch.long).reshape(1, 1) # print(state_list_of_tensors) Liste mit 5 Tensoren, jeder Tensor enthält einen State s der Länge 28 # print(action_list_of_tensors) Liste mit 5 leeren Tensoren mit size (0,1) # print(reward_list_of_tensors) Liste mit 5 leeren Tensoren ohne size # print(target_return_list_of_tensors) Liste mit 5 leeren Tensoren, jeder Tensor enthält den target_return / scale # print(timesteps) enthält einen Tensor mit 0: tensor([[0]]) episodes_completed = 0 num_steps = 0 t = 0 agent_time_elapsed = 0 episode_metrics = [] while True: next_actions = [] for bi in range(amount_buildings): action_list_of_tensors[bi] = torch.cat( [action_list_of_tensors[bi], torch.zeros((1, Constants.action_dim), device=Constants.device)], dim=0) reward_list_of_tensors[bi] = torch.cat( [reward_list_of_tensors[bi], torch.zeros(1, device=Constants.device)]) # get actions for all buildings step_start = time.perf_counter() action_bi = agent.get_action( state_list_of_tensors[bi], action_list_of_tensors[bi], reward_list_of_tensors[bi], target_return_list_of_tensors[bi], timesteps, ) agent_time_elapsed += time.perf_counter() - step_start action_list_of_tensors[bi][-1] = action_bi action_bi = action_bi.detach().cpu().numpy() next_actions.append(action_bi) # Interaction with the environment state_list_of_lists, reward_list_of_lists, done, _ = env.step(next_actions) state_list_of_lists = preprocess_states(state_list_of_lists, amount_buildings) 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}", ) print("Episode Return:", episode_return) # new Initialization and env Reset t = 0 episode_return = np.zeros(amount_buildings) state_list_of_lists = env.reset() state_list_of_lists = preprocess_states(state_list_of_lists, amount_buildings) state_list_of_tensors = [] target_return_list_of_tensors = [] action_list_of_tensors = [] reward_list_of_tensors = [] for bi in range(amount_buildings): state_bi = torch.from_numpy(np.array(state_list_of_lists[bi])).reshape(1, Constants.state_dim).to( device=Constants.device, dtype=torch.float32) target_return_bi = torch.tensor(target_return, device=Constants.device, dtype=torch.float32).reshape(1, 1) action_bi = torch.zeros((0, Constants.action_dim), device=Constants.device, dtype=torch.float32) reward_bi = torch.zeros(0, device=Constants.device, dtype=torch.float32) state_list_of_tensors.append(state_bi) target_return_list_of_tensors.append(target_return_bi) action_list_of_tensors.append(action_bi) reward_list_of_tensors.append(reward_bi) timesteps = torch.tensor(0, device=Constants.device, dtype=torch.long).reshape(1, 1) else: # Process data for next step for bi in range(amount_buildings): cur_state = torch.from_numpy(np.array(state_list_of_lists[bi])).to(device=Constants.device).reshape(1, Constants.state_dim) state_list_of_tensors[bi] = torch.cat([state_list_of_tensors[bi], cur_state], dim=0) reward_list_of_tensors[bi][-1] = reward_list_of_lists[bi] pred_return = target_return_list_of_tensors[bi][0, -1] - (reward_list_of_lists[bi] / scale) target_return_list_of_tensors[bi] = torch.cat( [target_return_list_of_tensors[bi], pred_return.reshape(1, 1)], dim=1) episode_return[bi] += reward_list_of_lists[bi] timesteps = torch.cat([timesteps, torch.ones((1, 1), device=Constants.device, dtype=torch.long) * (t + 1)], dim=1) if timesteps.size(dim=1) > context_length: # Store only the last values according to context_length timesteps = timesteps[:, -context_length:] for bi in range(amount_buildings): state_list_of_tensors[bi] = state_list_of_tensors[bi][-context_length:] action_list_of_tensors[bi] = action_list_of_tensors[bi][-context_length:] reward_list_of_tensors[bi] = reward_list_of_tensors[bi][-context_length:] target_return_list_of_tensors[bi] = target_return_list_of_tensors[bi][:, -context_length:] num_steps += 1 t += 1 if num_steps % 100 == 0: print(f"Num Steps: {num_steps}, Num episodes: {episodes_completed}") if episodes_completed >= Constants.episodes: break print("========================= Evaluation Done ========================") print("Total number of steps:", num_steps) if len(episode_metrics) > 0: price_cost = np.mean([e['price_cost'] for e in episode_metrics]) emission_cost = np.mean([e['emmision_cost'] for e in episode_metrics]) grid_cost = np.mean([e['grid_cost'] for e in episode_metrics]) print("Average Price Cost:", price_cost) print("Average Emission Cost:", emission_cost) print("Average Grid Cost:", grid_cost) print("==>", (price_cost+emission_cost+grid_cost)/3) print(f"Total time taken by agent: {agent_time_elapsed}s") if __name__ == '__main__': evaluate()