In this below code i am randomly generating the targets for testing and training process…
- User
In this below code i am randomly generating the targets for testing and training process in the function 'generate_random_targets' and saving and loading all the necessary data's relating to the testing and training target data and number of target data's with in the training and testing loop. now i need to modify the code as, instead of generating random targets with in the ranges, i need to choose the targets from the .xlsx file (path: 'D:\OPAMP CIRCUITS\RLGNN_LTSpice\Dataset_Predict.xlsx'), where the excel file having four columns with header 'gain', 'bandwidth', 'unitygainfrequency', 'phasemargin', excluding the first row (header), the excel data has 355 rows, each row are the corresponding values of the target data which required for the below training and testing process. so i need you to read all the row data and shuffle it in row wise and select 300 row datas as training target data and 35 row data as testing target data, these training and testing data are need to be keep saved and loaded in the training and testing loop, it datas are need to be fetch from save state while it is in loading, only at the first time it is need to be setch from excel file and seperate it s test and training data (the consistancy should be maintained) no duplicate must be present between testing and trainning data, it should not be fetch from excel on every time loading. while selecting training datas and testing datas (the selection of data is row 'x' column1, row 'x' column2, row 'x' column3, row 'x' column4, 'x' is the row number the column data must be choosen from the same row for the corresponding target data.
Define Circuit Environment
class CircuitEnvironment: PERFORMANCE_METRICS_TARGET_LOW = np.array([45, 10e3, 5e6, 60]) PERFORMANCE_METRICS_TARGET_HIGH = np.array([55, 30e3, 10e6, 75])
def __init__(self, bounds_low, bounds_high): # Initialization code: setup bounds @staticmethod def generate_random_targets(num_targets, seed): np.random.seed(seed) gain_targets = np.random.choice(np.arange(45, 56), num_targets) bw_targets = np.random.choice(np.arange(10e3, 30.1e3, 1e3), num_targets) ugf_targets = np.random.choice(np.arange(5e6, 10.1e6, 1e6), num_targets) pm_targets = np.random.choice(np.arange(60, 76), num_targets) random_targets = np.vstack((gain_targets, bw_targets, ugf_targets, pm_targets)).T return random_targetssave and load training process
def save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets, filepath='training_state_TrainTest7.pt'): state = { 'episode': episode, 'actor_state_dict': agent.actor.state_dict(), 'critic_state_dict': agent.critic.state_dict(), 'optimizer_actor_state_dict': agent.optimizer_actor.state_dict(), 'optimizer_critic_state_dict': agent.optimizer_critic.state_dict(), 'rewards_log': rewards_log, 'losses_log': losses_log, 'metrics_log': metrics_log, 'train_targets': train_targets, 'test_targets': test_targets } torch.save(state, filepath)
def load_training_state(filepath='training_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None
Training Function
def train(env, agent, num_episodes, max_timesteps): num_targets = 100 train_targets = CircuitEnvironment.generate_random_targets(num_targets=num_targets, seed=0) test_targets = CircuitEnvironment.generate_random_targets(num_targets=20, seed=1)
# Initialize the episode to start from and log lists start_episode = 0 rewards_log = [] losses_log = [] metrics_log = [] episode_lengths = [] # Attempt to load the saved state saved_state = load_training_state() if saved_state: start_episode = saved_state['episode'] + 1 # Start from the next episode agent.actor.load_state_dict(saved_state['actor_state_dict']) agent.critic.load_state_dict(saved_state['critic_state_dict']) agent.optimizer_actor.load_state_dict(saved_state['optimizer_actor_state_dict']) agent.optimizer_critic.load_state_dict(saved_state['optimizer_critic_state_dict']) rewards_log = saved_state['rewards_log'] losses_log = saved_state['losses_log'] metrics_log = saved_state['metrics_log'] train_targets = saved_state['train_targets'] test_targets = saved_state['test_targets'] print(f"Resuming from episode {start_episode}") for episode in range(start_episode, num_episodes): if episode >= num_targets: break # Exit the loop if exhausted the number of targets target = train_targets[episode % len(train_targets)] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) # Initialize storage for episode data episode_rewards = [] states = [] actions = [] log_probs = [] values = [] masks = [] perf_metrics_log = [] for t in range(max_timesteps): action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) next_state = (next_node_features_tensor, next_edge_index) save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets) agent.save_checkpoint('final')save and load testing process
def save_test_state(test_targets, rewards_log, metrics_log, current_target_index, filepath='test_state_TrainTest7.pt'): state = { 'test_targets': test_targets, 'rewards_log': rewards_log, 'metrics_log': metrics_log, 'current_target_index': current_target_index } torch.save(state, filepath)
def load_test_state(filepath='test_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None
Test Function
def test(env, agent, num_targets, max_timesteps_per_target=300, test_targets=None): rewards_log = [] metrics_log = []
# Load test state if exists saved_test_state = load_test_state() if saved_test_state: test_targets = saved_test_state['test_targets'] rewards_log = saved_test_state['rewards_log'] metrics_log = saved_test_state['metrics_log'] start_target_index = saved_test_state['current_target_index'] + 1 print(f"Resuming from target index {start_target_index}") else: start_target_index = 0 if not test_targets: saved_state = load_training_state() if saved_state and 'test_targets' in saved_state: test_targets = saved_state['test_targets'] else: test_targets = CircuitEnvironment.generate_random_targets(num_targets=num_targets, seed=1) for i in range(start_target_index, num_targets): target = test_targets[i] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) episode_rewards = [] states = [] actions = [] values = [] masks = [] perf_metrics_log = [] done = False t = 0 while not done and t < max_timesteps_per_target: action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) state = (next_node_features_tensor, next_edge_index) # Save the test state after each target save_test_state(test_targets, rewards_log, metrics_log, i, filepath='test_state_TrainTest7.pt')if name == "main": # Initialize environment parameters # Define the values for bounds, and target metrics
env = CircuitEnvironment(bounds_low, bounds_high) agent = PPOAgent(state_dim, action_space, lr_actor, lr_critic, gamma, gae_lambda, epsilon, policy_clip, epochs, entropy_coef) num_episodes = 1000 max_timesteps = 300 train(env, agent, num_episodes, max_timesteps) trained_state = load_training_state() if trained_state: agent.actor.load_state_dict(trained_state['actor_state_dict']) agent.critic.load_state_dict(trained_state['critic_state_dict']) num_test_targets = 20 test(env, agent, num_test_targets, max_timesteps_per_target=300) - Assistant
To modify the provided code so that it reads target values from the specified Excel file, shuffles them, splits them into training and testing datasets, and ensures consistent fetching from a saved state, follow these steps:
-
Install necessary libraries for Excel handling: Ensure that you have
pandasandopenpyxlinstalled. If not, install them using:pip install pandas openpyxl -
Modify the
generate_random_targetsmethod: Replace it with a method to read the Excel file, shuffle the rows, and split them into training and testing datasets. -
Adjust the
trainandtestfunctions: Load the targets from the saved states, if available.
Below is the modified code:
import numpy as np import pandas as pd import torch import os class CircuitEnvironment: PERFORMANCE_METRICS_TARGET_LOW = np.array([45, 10e3, 5e6, 60]) PERFORMANCE_METRICS_TARGET_HIGH = np.array([55, 30e3, 10e6, 75]) def __init__(self, bounds_low, bounds_high): # Initialization code: setup bounds pass # Replace with actual initialization @staticmethod def load_and_prepare_targets(filepath, seed=0): df = pd.read_excel(filepath) np.random.seed(seed) data = df.to_numpy() np.random.shuffle(data) train_targets = data[:300] test_targets = data[300:] return train_targets, test_targets # Save and load training process def save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets, filepath='training_state_TrainTest7.pt'): state = { 'episode': episode, 'actor_state_dict': agent.actor.state_dict(), 'critic_state_dict': agent.critic.state_dict(), 'optimizer_actor_state_dict': agent.optimizer_actor.state_dict(), 'optimizer_critic_state_dict': agent.optimizer_critic.state_dict(), 'rewards_log': rewards_log, 'losses_log': losses_log, 'metrics_log': metrics_log, 'train_targets': train_targets, 'test_targets': test_targets } torch.save(state, filepath) def load_training_state(filepath='training_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None # Training Function def train(env, agent, num_episodes, max_timesteps, target_filepath): saved_state = load_training_state() if saved_state: train_targets = saved_state['train_targets'] test_targets = saved_state['test_targets'] start_episode = saved_state['episode'] + 1 else: train_targets, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) start_episode = 0 rewards_log = [] losses_log = [] metrics_log = [] for episode in range(start_episode, num_episodes): if episode >= len(train_targets): break # Exit the loop if exhausted the number of targets target = train_targets[episode % len(train_targets)] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) # Initialize storage for episode data episode_rewards = [] states = [] actions = [] log_probs = [] values = [] masks = [] perf_metrics_log = [] for t in range(max_timesteps): action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) next_state = (next_node_features_tensor, next_edge_index) save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets) agent.save_checkpoint('final') # Save and load testing process def save_test_state(test_targets, rewards_log, metrics_log, current_target_index, filepath='test_state_TrainTest7.pt'): state = { 'test_targets': test_targets, 'rewards_log': rewards_log, 'metrics_log': metrics_log, 'current_target_index': current_target_index } torch.save(state, filepath) def load_test_state(filepath='test_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None # Test Function def test(env, agent, num_targets, max_timesteps_per_target=300, target_filepath=None): rewards_log = [] metrics_log = [] saved_test_state = load_test_state() if saved_test_state: test_targets = saved_test_state['test_targets'] rewards_log = saved_test_state['rewards_log'] metrics_log = saved_test_state['metrics_log'] start_target_index = saved_test_state['current_target_index'] + 1 else: start_target_index = 0 if target_filepath: _, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) else: saved_state = load_training_state() if saved_state and 'test_targets' in saved_state: test_targets = saved_state['test_targets'] else: raise ValueError("Target filepath must be provided on first run") for i in range(start_target_index, num_targets): target = test_targets[i] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) episode_rewards = [] states = [] actions = [] values = [] masks = [] perf_metrics_log = [] done = False t = 0 while not done and t < max_timesteps_per_target: action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) state = (next_node_features_tensor, next_edge_index) save_test_state(test_targets, rewards_log, metrics_log, i, filepath='test_state_TrainTest7.pt') if __name__ == "__main__": # Initialize environment parameters # Define the values for bounds, and target metrics bounds_low = ... bounds_high = ... state_dim = ... action_space = ... lr_actor = ... lr_critic = ... gamma = ... gae_lambda = ... epsilon = ... policy_clip = ... epochs = ... entropy_coef = ... env = CircuitEnvironment(bounds_low, bounds_high) agent = PPOAgent(state_dim, action_space, lr_actor, lr_critic, gamma, gae_lambda, epsilon, policy_clip, epochs, entropy_coef) num_episodes = 1000 max_timesteps = 300 target_filepath = 'D:\\OPAMP CIRCUITS\\RLGNN_LTSpice\\Dataset_Predict.xlsx' train(env, agent, num_episodes, max_timesteps, target_filepath) trained_state = load_training_state() if trained_state: agent.actor.load_state_dict(trained_state['actor_state_dict']) agent.critic.load_state_dict(trained_state['critic_state_dict']) num_test_targets = 20 test(env, agent, num_test_targets, max_timesteps_per_target=300, target_filepath=target_filepath)Explanation:
-
Loading and Preparing Targets: The static method
load_and_prepare_targetsreads the target data from the Excel file located attarget_filepath, shuffles it, and splits it into training and testing datasets. -
Training and Testing Function Modifications:
- During training, targets are loaded from a saved state if available, ensuring consistency. If no saved state is found, it reads the targets from the Excel file.
- During testing, the targets are loaded in the same manner, ensuring consistency between training and testing data.
-
Maintaining State Consistency: Save and load methods for training and testing states are included, which store and fetch the targets along with other relevant data, ensuring consistent training and testing across multiple runs.
By following the above modifications, you can ensure that your training and testing procedures work with real target data from the provided Excel file while maintaining persistency across sessions.
-
- User
is the command 'np.random.shuffle(data)', will shuffle the data between the rows combined with all column datas or rows of each column seperately, because the each row is belongs to specific metrics of circuit design the row data need to be shuffle with all four column data together example r1c1, r1c2, r1c3, r1c4 be shuffle with r2c1, r2c2, r2c3, r2c4 not to shuffle like r1c1, r2c2, r1c3, r2c4
- Assistant
Yes, the command
np.random.shuffle(data)will shuffle the rows while keeping the relationship between the columns intact. This means that the entire row will be shuffled as a single unit, so each set of metrics will stay together.Here's an example to clarify:
import numpy as np # Create a sample 2D array data = np.array([ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16] ]) # Shuffle the data np.random.shuffle(data) print(data)After shuffling, you might see something like this (the entire rows are moved):
[[ 9 10 11 12] [ 1 2 3 4] [13 14 15 16] [ 5 6 7 8]]This indicates that the rows have been shuffled, but each row's columns have stayed together.
Here’s the context of your code with the shuffle command ensuring rows are shuffled correctly:
import numpy as np import pandas as pd import torch import os class CircuitEnvironment: PERFORMANCE_METRICS_TARGET_LOW = np.array([45, 10e3, 5e6, 60]) PERFORMANCE_METRICS_TARGET_HIGH = np.array([55, 30e3, 10e6, 75]) def __init__(self, bounds_low, bounds_high): # Initialization code: setup bounds pass # Replace with actual initialization @staticmethod def load_and_prepare_targets(filepath, seed=0): df = pd.read_excel(filepath) np.random.seed(seed) data = df.to_numpy() np.random.shuffle(data) # This shuffles entire rows while keeping columns together train_targets = data[:300] test_targets = data[300:] return train_targets, test_targets # Save and load training process def save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets, filepath='training_state_TrainTest7.pt'): state = { 'episode': episode, 'actor_state_dict': agent.actor.state_dict(), 'critic_state_dict': agent.critic.state_dict(), 'optimizer_actor_state_dict': agent.optimizer_actor.state_dict(), 'optimizer_critic_state_dict': agent.optimizer_critic.state_dict(), 'rewards_log': rewards_log, 'losses_log': losses_log, 'metrics_log': metrics_log, 'train_targets': train_targets, 'test_targets': test_targets } torch.save(state, filepath) def load_training_state(filepath='training_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None # Training Function def train(env, agent, num_episodes, max_timesteps, target_filepath): saved_state = load_training_state() if saved_state: train_targets = saved_state['train_targets'] test_targets = saved_state['test_targets'] start_episode = saved_state['episode'] + 1 else: train_targets, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) start_episode = 0 rewards_log = [] losses_log = [] metrics_log = [] for episode in range(start_episode, num_episodes): if episode >= len(train_targets): break # Exit the loop if exhausted the number of targets target = train_targets[episode % len(train_targets)] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) # Initialize storage for episode data episode_rewards = [] states = [] actions = [] log_probs = [] values = [] masks = [] perf_metrics_log = [] for t in range(max_timesteps): action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) next_state = (next_node_features_tensor, next_edge_index) save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets) agent.save_checkpoint('final') # Save and load testing process def save_test_state(test_targets, rewards_log, metrics_log, current_target_index, filepath='test_state_TrainTest7.pt'): state = { 'test_targets': test_targets, 'rewards_log': rewards_log, 'metrics_log': metrics_log, 'current_target_index': current_target_index } torch.save(state, filepath) def load_test_state(filepath='test_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None # Test Function def test(env, agent, num_targets, max_timesteps_per_target=300, target_filepath=None): rewards_log = [] metrics_log = [] saved_test_state = load_test_state() if saved_test_state: test_targets = saved_test_state['test_targets'] rewards_log = saved_test_state['rewards_log'] metrics_log = saved_test_state['metrics_log'] start_target_index = saved_test_state['current_target_index'] + 1 else: start_target_index = 0 if target_filepath: _, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) else: saved_state = load_training_state() if saved_state and 'test_targets' in saved_state: test_targets = saved_state['test_targets'] else: raise ValueError("Target filepath must be provided on first run") for i in range(start_target_index, num_targets): target = test_targets[i] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) episode_rewards = [] states = [] actions = [] values = [] masks = [] perf_metrics_log = [] done = False t = 0 while not done and t < max_timesteps_per_target: action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) state = (next_node_features_tensor, next_edge_index) save_test_state(test_targets, rewards_log, metrics_log, i, filepath='test_state_TrainTest7.pt') if __name__ == "__main__": # Initialize environment parameters # Define the values for bounds, and target metrics bounds_low = ... bounds_high = ... state_dim = ... action_space = ... lr_actor = ... lr_critic = ... gamma = ... gae_lambda = ... epsilon = ... policy_clip = ... epochs = ... entropy_coef = ... env = CircuitEnvironment(bounds_low, bounds_high) agent = PPOAgent(state_dim, action_space, lr_actor, lr_critic, gamma, gae_lambda, epsilon, policy_clip, epochs, entropy_coef) num_episodes = 1000 max_timesteps = 300 target_filepath = 'D:\\OPAMP CIRCUITS\\RLGNN_LTSpice\\Dataset_Predict.xlsx' train(env, agent, num_episodes, max_timesteps, target_filepath) trained_state = load_training_state() if trained_state: agent.actor.load_state_dict(trained_state['actor_state_dict']) agent.critic.load_state_dict(trained_state['critic_state_dict']) num_test_targets = 20 test(env, agent, num_test_targets, max_timesteps_per_target=300, target_filepath=target_filepath)This ensures the rows are shuffled intact, keeping each row's columns together.
- User
at the begining of the loop in training we execute the command 'train_targets, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath)', and saving the train and test target datas(please ensure it is properly saving all the datas), then again we are executing the same command at the begining of the test function. will it make inconsistancy?
- Assistant
Indeed, executing
CircuitEnvironment.load_and_prepare_targets(target_filepath)repeatedly could introduce inconsistency, as each execution will result in a new shuffle, which could lead to different training and testing sets each time. Instead, you should ensure that the targets are only loaded and shuffled once and subsequently saved to maintain consistency.Adjustments:
- Load and prepare targets only once if there's no saved state.
- When saved state is available, use the saved targets.
- Ensure targets are consistently saved and loaded throughout the training and testing process.
Code Adjustments:
Here's how you can modify the
trainandtestfunctions accordingly:- Modify
load_training_stateandsave_training_statefunctions to ensure loading and saving of all necessary data: - Ensure that targets aren't reloaded and reshuffled during testing, but rather load from the saved state:
import numpy as np import pandas as pd import torch import os class CircuitEnvironment: PERFORMANCE_METRICS_TARGET_LOW = np.array([45, 10e3, 5e6, 60]) PERFORMANCE_METRICS_TARGET_HIGH = np.array([55, 30e3, 10e6, 75]) def __init__(self, bounds_low, bounds_high): # Initialization code: setup bounds pass # Replace with actual initialization @staticmethod def load_and_prepare_targets(filepath, seed=0): df = pd.read_excel(filepath) np.random.seed(seed) data = df.to_numpy() np.random.shuffle(data) # This shuffles entire rows while keeping columns together train_targets = data[:300] test_targets = data[300:] return train_targets, test_targets def save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets, filepath='training_state_TrainTest7.pt'): state = { 'episode': episode, 'actor_state_dict': agent.actor.state_dict(), 'critic_state_dict': agent.critic.state_dict(), 'optimizer_actor_state_dict': agent.optimizer_actor.state_dict(), 'optimizer_critic_state_dict': agent.optimizer_critic.state_dict(), 'rewards_log': rewards_log, 'losses_log': losses_log, 'metrics_log': metrics_log, 'train_targets': train_targets, 'test_targets': test_targets } torch.save(state, filepath) def load_training_state(filepath='training_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None def train(env, agent, num_episodes, max_timesteps, target_filepath): saved_state = load_training_state() if saved_state: train_targets = saved_state['train_targets'] test_targets = saved_state['test_targets'] start_episode = saved_state['episode'] + 1 else: train_targets, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) start_episode = 0 rewards_log = [] losses_log = [] metrics_log = [] for episode in range(start_episode, num_episodes): if episode >= len(train_targets): break # Exit the loop if exhausted the number of targets target = train_targets[episode % len(train_targets)] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) # Initialize storage for episode data episode_rewards = [] states = [] actions = [] log_probs = [] values = [] masks = [] perf_metrics_log = [] for t in range(max_timesteps): action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) next_state = (next_node_features_tensor, next_edge_index) save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets) agent.save_checkpoint('final') def save_test_state(test_targets, rewards_log, metrics_log, current_target_index, filepath='test_state_TrainTest7.pt'): state = { 'test_targets': test_targets, 'rewards_log': rewards_log, 'metrics_log': metrics_log, 'current_target_index': current_target_index } torch.save(state, filepath) def load_test_state(filepath='test_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None def test(env, agent, num_targets, max_timesteps_per_target=300, target_filepath=None): rewards_log = [] metrics_log = [] saved_test_state = load_test_state() if saved_test_state: test_targets = saved_test_state['test_targets'] rewards_log = saved_test_state['rewards_log'] metrics_log = saved_test_state['metrics_log'] start_target_index = saved_test_state['current_target_index'] + 1 else: start_target_index = 0 saved_state = load_training_state() if saved_state and 'test_targets' in saved_state: test_targets = saved_state['test_targets'] else: if target_filepath: _, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) else: raise ValueError("Target filepath must be provided on first run") for i in range(start_target_index, num_targets): target = test_targets[i] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) episode_rewards = [] states = [] actions = [] values = [] masks = [] perf_metrics_log = [] done = False t = 0 while not done and t < max_timesteps_per_target: action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) state = (next_node_features_tensor, next_edge_index) save_test_state(test_targets, rewards_log, metrics_log, i, filepath='test_state_TrainTest7.pt') if __name__ == "__main__": # Initialize environment parameters # Define the values for bounds, and target metrics bounds_low = ... bounds_high = ... state_dim = ... action_space = ... lr_actor = ... lr_critic = ... gamma = ... gae_lambda = ... epsilon = ... policy_clip = ... epochs = ... entropy_coef = ... env = CircuitEnvironment(bounds_low, bounds_high) agent = PPOAgent(state_dim, action_space, lr_actor, lr_critic, gamma, gae_lambda, epsilon, policy_clip, epochs, entropy_coef) num_episodes = 1000 max_timesteps = 300 target_filepath = 'D:\\OPAMP CIRCUITS\\RLGNN_LTSpice\\Dataset_Predict.xlsx' train(env, agent, num_episodes, max_timesteps, target_filepath) trained_state = load_training_state() if trained_state: agent.actor.load_state_dict(trained_state['actor_state_dict']) agent.critic.load_state_dict(trained_state['critic_state_dict']) num_test_targets = 20 test(env, agent, num_test_targets, max_timesteps_per_target=300, target_filepath=target_filepath)Explanation:
-
Initialization:
- The
trainfunction first attempts to load the saved state. If found, it uses the savedtrain_targetsandtest_targets. - If no saved state exists, it prepares the targets by reading from the Excel file once and then saves them.
- The
-
Save and Load:
- The
save_training_statefunction now ensures that bothtrain_targetsandtest_targetsare saved. - The
load_training_statefunction retrieves the complete training state, including the targets.
- The
-
Testing Consistency:
- The
testfunction now first tries to load a saved testing state. - If there's no saved testing state but a training state exists, it uses the
test_targetsfrom the training state. - This ensures that the test targets are the same as those used during training, maintaining consistency.
- The
This approach ensures that targets are only shuffled and split once, avoiding inconsistencies between different runs or stages of your training and testing processes.
- User
the fetch target values for training and testing from the file path must be round off to discrete values, the value of rows column1 is to be 'int(round(value of column1))', the value of rows column2 is to be 'int(round(value of column2 / 1e3) * 1e3)', the value of rows column3 is to be 'int(round(value of column3 / 1e6) * 1e6)', the value of rows column4 is to be 'int(round(value of column4))'
@staticmethod def load_and_prepare_targets(filepath, seed=0): df = pd.read_excel(filepath) np.random.seed(seed) data = df.to_numpy() np.random.shuffle(data) train_targets = data[:300] test_targets = data[300:] return train_targets, test_targets - Assistant
To ensure the fetched target values are rounded off to the specified discrete values, you can modify the
load_and_prepare_targetsmethod as follows:- Read the data from the Excel file.
- Round the values according to the specified rules:
- Column 1: Round to the nearest integer.
- Column 2: Round to the nearest thousand.
- Column 3: Round to the nearest million.
- Column 4: Round to the nearest integer.
- Shuffle the data and split into training and testing datasets.
Here is the updated code:
import numpy as np import pandas as pd import torch import os class CircuitEnvironment: PERFORMANCE_METRICS_TARGET_LOW = np.array([45, 10e3, 5e6, 60]) PERFORMANCE_METRICS_TARGET_HIGH = np.array([55, 30e3, 10e6, 75]) def __init__(self, bounds_low, bounds_high): # Initialization code: setup bounds pass # Replace with actual initialization @staticmethod def load_and_prepare_targets(filepath, seed=0): df = pd.read_excel(filepath) np.random.seed(seed) data = df.to_numpy() # Apply rounding rules data[:, 0] = np.round(data[:, 0]).astype(int) # Column 1 data[:, 1] = (np.round(data[:, 1] / 1e3) * 1e3).astype(int) # Column 2 data[:, 2] = (np.round(data[:, 2] / 1e6) * 1e6).astype(int) # Column 3 data[:, 3] = np.round(data[:, 3]).astype(int) # Column 4 np.random.shuffle(data) # Shuffle entire rows while keeping columns together train_targets = data[:300] test_targets = data[300:] return train_targets, test_targets def save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets, filepath='training_state_TrainTest7.pt'): state = { 'episode': episode, 'actor_state_dict': agent.actor.state_dict(), 'critic_state_dict': agent.critic.state_dict(), 'optimizer_actor_state_dict': agent.optimizer_actor.state_dict(), 'optimizer_critic_state_dict': agent.optimizer_critic.state_dict(), 'rewards_log': rewards_log, 'losses_log': losses_log, 'metrics_log': metrics_log, 'train_targets': train_targets, 'test_targets': test_targets } torch.save(state, filepath) def load_training_state(filepath='training_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None def train(env, agent, num_episodes, max_timesteps, target_filepath): saved_state = load_training_state() if saved_state: train_targets = saved_state['train_targets'] test_targets = saved_state['test_targets'] start_episode = saved_state['episode'] + 1 else: train_targets, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) start_episode = 0 rewards_log = [] losses_log = [] metrics_log = [] for episode in range(start_episode, num_episodes): if episode >= len(train_targets): break # Exit the loop if exhausted the number of targets target = train_targets[episode % len(train_targets)] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) # Initialize storage for episode data episode_rewards = [] states = [] actions = [] log_probs = [] values = [] masks = [] perf_metrics_log = [] for t in range(max_timesteps): action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) next_state = (next_node_features_tensor, next_edge_index) save_training_state(agent, episode, rewards_log, losses_log, metrics_log, train_targets, test_targets) agent.save_checkpoint('final') def save_test_state(test_targets, rewards_log, metrics_log, current_target_index, filepath='test_state_TrainTest7.pt'): state = { 'test_targets': test_targets, 'rewards_log': rewards_log, 'metrics_log': metrics_log, 'current_target_index': current_target_index } torch.save(state, filepath) def load_test_state(filepath='test_state_TrainTest7.pt'): if os.path.isfile(filepath): state = torch.load(filepath) return state else: return None def test(env, agent, num_targets, max_timesteps_per_target=300, target_filepath=None): rewards_log = [] metrics_log = [] saved_test_state = load_test_state() if saved_test_state: test_targets = saved_test_state['test_targets'] rewards_log = saved_test_state['rewards_log'] metrics_log = saved_test_state['metrics_log'] start_target_index = saved_test_state['current_target_index'] + 1 else: start_target_index = 0 saved_state = load_training_state() if saved_state and 'test_targets' in saved_state: test_targets = saved_state['test_targets'] else: if target_filepath: _, test_targets = CircuitEnvironment.load_and_prepare_targets(target_filepath) else: raise ValueError("Target filepath must be provided on first run") for i in range(start_target_index, num_targets): target = test_targets[i] node_features_tensor, edge_index, performance_metrics = env.reset(target) state = (node_features_tensor, edge_index) episode_rewards = [] states = [] actions = [] values = [] masks = [] perf_metrics_log = [] done = False t = 0 while not done and t < max_timesteps_per_target: action, log_prob, perf_metrics = agent.select_action(state, performance_metrics) next_node_features_tensor, next_edge_index, reward, done, previous_metrics = env.step(action, perf_metrics, target) state = (next_node_features_tensor, next_edge_index) save_test_state(test_targets, rewards_log, metrics_log, i, filepath='test_state_TrainTest7.pt') if __name__ == "__main__": # Initialize environment parameters # Define the values for bounds, and target metrics bounds_low = ... bounds_high = ... state_dim = ... action_space = ... lr_actor = ... lr_critic = ... gamma = ... gae_lambda = ... epsilon = ... policy_clip = ... epochs = ... entropy_coef = ... env = CircuitEnvironment(bounds_low, bounds_high) agent = PPOAgent(state_dim, action_space, lr_actor, lr_critic, gamma, gae_lambda, epsilon, policy_clip, epochs, entropy_coef) num_episodes = 1000 max_timesteps = 300 target_filepath = 'D:\\OPAMP CIRCUITS\\RLGNN_LTSpice\\Dataset_Predict.xlsx' train(env, agent, num_episodes, max_timesteps, target_filepath) trained_state = load_training_state() if trained_state: agent.actor.load_state_dict(trained_state['actor_state_dict']) agent.critic.load_state_dict(trained_state['critic_state_dict']) num_test_targets = 20 test(env, agent, num_test_targets, max_timesteps_per_target=300, target_filepath=target_filepath)Explanation:
-
Rounding Data:
data[:, 0] = np.round(data[:, 0]).astype(int): Rounds column 1 to the nearest integer.data[:, 1] = (np.round(data[:, 1] / 1e3) * 1e3).astype(int): Rounds column 2 to the nearest thousand.data[:, 2] = (np.round(data[:, 2] / 1e6) * 1e6).astype(int): Rounds column 3 to the nearest million.data[:, 3] = np.round(data[:, 3]).astype(int): Rounds column 4 to the nearest integer.
-
Shuffle Entire Rows: The
np.random.shuffle(data)shuffles the rows, keeping all columns in each row together. -
Consistency:
- The
trainfunction first attempts to load the saved state, and if not found, it initializes and shuffles the targets. - The
testfunction uses the saved test targets from the training process to maintain consistency. - Both functions save and load their states properly to ensure persistent data across sessions.
- The
This approach ensures that the rounding is performed as required and the targets are handled consistently throughout training and testing, maintaining the integrity of the data.