In the following code I need some adjustments in the code,
class CircuitEnvironment:
    def __init__(self, server_address, username, password, bounds_low, bounds_high, target_metrics):
        # Initialization.....     

    def step(self, raw_actions, previous_metrics):
        print("raw actions", raw_actions)
        # Scale raw actions to obtain meaningful adjustments
        W_deltas, L_deltas, Io_delta, Cp_delta, Vc_delta = self.scale_action(raw_actions)
        # Apply adjustments to update parameters
        self.W_current[0] = np.clip(self.W_current[0] + W_deltas[0], W_min, W_max)
        self.W_current[1] = np.clip(self.W_current[1] + W_deltas[1], W_min, W_max)
        self.W_current[2] = np.clip(self.W_current[2] + W_deltas[2], W_min, W_max)
        self.W_current[3] = np.clip(self.W_current[3] + W_deltas[3], W_min, W_max)
        self.W_current[4] = np.clip(self.W_current[4] + W_deltas[4], W_min, W_max)
        
        self.L_current[0] = np.clip(self.L_current[0] + L_deltas[0], L_min, L_max)
        self.L_current[1] = np.clip(self.L_current[1] + L_deltas[1], L_min, L_max)
        self.L_current[2] = np.clip(self.L_current[2] + L_deltas[2], L_min, L_max)
        self.L_current[3] = np.clip(self.L_current[3] + L_deltas[3], L_min, L_max)
        self.L_current[4] = np.clip(self.L_current[4] + L_deltas[4], L_min, L_max)

        self.Io_current = np.clip(self.Io_current + Io_delta, Io_min, Io_max)
        self.Cp_current = np.clip(self.Cp_current + Cp_delta, Cp_min, Cp_max)
        self.Vc_current = np.clip(self.Vc_current + Vc_delta, Vc_min, Vc_max)
        # Form new parameters
        new_parameters = np.concatenate((self.W_current, self.L_current, [self.Io_current, self.Cp_current, self.Vc_current]))
        # Run simulation with new parameters
        transistor_regions, saturation_condition, performance_metrics = self.simulator.run_simulation(new_parameters)
        # state, reward, done.................
        return state, reward, done, previous_metrics

    def scale_action(self, raw_actions):
        # Ensure raw_actions is a 1D array
        raw_actions = np.squeeze(raw_actions)
        # Scale raw actions to obtain meaningful adjustments
        deltas = np.multiply(raw_actions, [W_max - W_min, L_max - L_min] * 5 + [Io_max - Io_min, Cp_max - Cp_min, Vc_max - Vc_min])
        W_deltas = deltas[5:10]
        L_deltas = deltas[:5]
        Io_deltas = deltas[10]
        Cp_deltas = deltas[11]
        Vc_deltas = deltas[12]
        # Clip adjustments to ensure they stay within bounds
        W_deltas = np.clip(W_deltas, W_min - self.W_current, W_max - self.W_current)
        L_deltas = np.clip(L_deltas, L_min - self.L_current, L_max - self.L_current)
        Io_deltas = np.clip(Io_deltas, Io_min - self.Io_current, Io_max - self.Io_current)
        Cp_deltas = np.clip(Cp_deltas, Cp_min - self.Cp_current, Cp_max - self.Cp_current)
        Vc_deltas = np.clip(Vc_deltas, Vc_min - self.Vc_current, Vc_max - self.Vc_current)
        return W_deltas, L_deltas, Io_deltas, Cp_deltas, Vc_deltas

# Constants
W_min = 0.5e-6
W_max = 50e-6
L_min = 0.18e-6
L_max = 0.2e-6
Io_min = 15e-6
Io_max = 30e-6
Cp_min = 0.1e-12
Cp_max = 10e-12
Vc_min = 0.8
Vc_max = 1.4

# Define the values for server_address, username, password, bounds, and target metrics
bounds_low = np.array([0.18e-6, 0.18e-6, 0.18e-6, 0.18e-6, 0.18e-6, 0.5e-6, 0.5e-6, 0.5e-6, 0.5e-6, 0.5e-6, 15e-6, 0.1e-12, 0.8])
bounds_high = np.array([0.2e-6, 0.2e-6, 0.2e-6, 0.2e-6, 0.2e-6, 50e-6, 50e-6, 50e-6, 50e-6, 50e-6, 30e-6, 10e-12, 1.4])

# Create the environment
env = CircuitEnvironment(server_address, username, password, bounds_low, bounds_high, target_metrics)

# Set the Hyperparameters
num_episodes = 1000 # Number of episodes to train for
max_timesteps = 200 # Maximum number of timesteps per episode

# Training Loop
for episode in range(num_episodes):
    # Define the Training Loop 
    state, performance_metrics = env.reset()
    # Run one episode
    for t in range(max_timesteps):
        action, log_prob, value, perf_metrics = select_action(state, env.actor, env.critic, bounds_low, bounds_high, performance_metrics)
        
        # Clip the action to ensure it's within the action space bounds
        action = np.clip(action, bounds_low, bounds_high)
        
        next_state, reward, done, previous_metrics = env.step(action, perf_metrics) # Take action in environment

env.disconnect_from_simulator()