gym-examples 3.0.263__py3-none-any.whl → 3.0.264__py3-none-any.whl

gym_examples/__init__.py

@@ -5,4 +5,4 @@ register(
      entry_point="gym_examples.envs:WSNRoutingEnv",
 )
 
-__version__ = "3.0.263"
+__version__ = "3.0.264"

gym_examples/envs/wsn_env.py

@@ -81,9 +81,9 @@ class WSNRoutingEnv(gym.Env):
         )
 
         # self.action_space = Tuple(tuple([Discrete(self.n_sensors + 1)] * self.n_agents))
-        # self.action_space = MultiDiscrete([self.n_sensors + 1] * self.n_agents)
+        self.action_space = MultiDiscrete([self.n_sensors + 1] * self.n_agents)
         # self.action_space = MultiDiscrete([self.n_agents, self.n_sensors + 1]) 
-        self.action_space = Discrete(self.n_agents * (self.n_sensors + 1))
+        # self.action_space = Discrete(self.n_agents * (self.n_sensors + 1))
 
         self.reset()        
 
@@ -131,16 +131,18 @@ class WSNRoutingEnv(gym.Env):
 
 
     def step(self, actions):
+        actions = [actions[i] for i in range(self.n_agents)] # We want to go back from the MultiDiscrete action space to a tuple of tuple of Discrete action spaces
         self.steps += 1 
-        # rewards = [-max_reward] * self.n_sensors
-        reward = -max_reward
-        # dones = [False] * self.n_sensors
-        done = False
-        # actions = [actions[i] for i in range(self.n_agents)] # We want to go back from the MultiDiscrete action space to a tuple of tuple of Discrete action spaces
-        # for i, action in enumerate(actions):
-        selected_sensor = actions // (self.n_sensors + 1)
-        target = actions % (self.n_sensors + 1)
-        for i, action in [np.array([selected_sensor, target])]: # This loop is for the PPO algorithm: actions is a numpy array of shape (1, 2)
+        rewards = [-max_reward] * self.n_sensors
+        dones = [False] * self.n_sensors
+        for i, action in enumerate(actions):
+            print(f"\nAction in WSNRoutingEnv: {action} and type: {type(action)}")
+            if action not in range(self.n_sensors + 1):
+                raise ValueError("Invalid action!")
+            
+            if i >= self.n_sensors:
+                raise ValueError("Invalid sensor index!") # the number of actions is greater than the number of sensors
+
             if self.remaining_energy[i] <= 0 or self.number_of_packets[i] <= 0:
                 continue  # Skip if sensor has no energy left or no packets to transmit
             
@@ -166,10 +168,10 @@ class WSNRoutingEnv(gym.Env):
                 self.total_latency += self.packet_latency[i] + latency_per_hop
                 self.packet_latency[i] = 0
 
-                # rewards[i] = np.ones(input_dim) * max_reward # Reward for transmitting data to the base station
-                reward = max_reward
-                # dones[i] = True
-                # done = True       
+                # rewards[i] = self.compute_individual_rewards(i, action)
+                rewards[i] = np.ones(input_dim) * max_reward # Reward for transmitting data to the base station
+                # rewards[i] = np.ones(input_dim) # Reward for transmitting data to the base station
+                dones[i] = True       
             else:
                 distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
                 if distance > self.coverage_radius:
@@ -194,20 +196,18 @@ class WSNRoutingEnv(gym.Env):
                 self.packet_latency[action] += self.packet_latency[i] + latency_per_hop
                 self.packet_latency[i] = 0
 
-                # rewards[i] = self.compute_individual_rewards(i, action)  
-                reward = self.compute_individual_rewards(i, action)
+                rewards[i] = self.compute_individual_rewards(i, action)  
 
                 # Update the number of packets
                 self.number_of_packets[action] += self.number_of_packets[i]
-
             self.number_of_packets[i] = 0 # Reset the number of packets of the sensor i
             # Calculate final reward
             # rewards[i] = self.compute_attention_rewards(rewards[i])
-            # rewards[i] = np.mean(rewards[i])
-            reward = np.mean(reward)
-        # for i in range(self.n_sensors):
-        #     if (self.remaining_energy[i] <= 0) or (self.number_of_packets[i] <= 0):
-        #         dones[i] = True
+            rewards[i] = np.mean(rewards[i])
+            # rewards[i] = self.compute_weighted_sum_rewards(rewards[i])
+        for i in range(self.n_sensors):
+            if (self.remaining_energy[i] <= 0) or (self.number_of_packets[i] <= 0):
+                dones[i] = True
 
         # Integrate the mobility of the sensors
         # self.integrate_mobility() 
@@ -219,45 +219,15 @@ class WSNRoutingEnv(gym.Env):
 
         self.get_metrics()
 
-        # rewards = [r.item() if isinstance(r, torch.Tensor) else r for r in rewards] # Convert the rewards to a list of floats
-        reward = reward.item() if isinstance(reward, torch.Tensor) else reward # Convert the reward to a float
-        # rewards = np.mean(rewards)  # Average the rewards of all agents
-        # dones = all(dones)  # Done if all agents are done
-        # Check if done condition is met
-        done = all(self.remaining_energy[i] <= 0 or self.number_of_packets[i] == 0 for i in range(self.n_sensors))
+        rewards = [r.item() if isinstance(r, torch.Tensor) else r for r in rewards] # Convert the rewards to a list of floats
+        # rewards = np.sum(rewards)  # Sum the rewards of all agents
+        rewards = np.mean(rewards)  # Average the rewards of all agents
+        # rewards = np.mean(self.compute_network_rewards())  # Average the rewards of all agents
+        # print(f"Step: {self.steps}, Rewards: {rewards}, Done: {dones}")
+        dones = all(dones)  # Done if all agents are done
         
-        # if os.getenv('PRINT_STATS') == 'True': # We are trying to extract only the statistics for the PPO algorithm
-        #     self.number_of_steps += 1
+        return self._get_obs(), rewards, dones, self.get_metrics()
 
-            
-
-        #     self.episode_return += reward
-        #     if self.number_of_steps >= self.num_timesteps:
-        #         self.episode_returns.append(self.episode_return)
-        #         self.episode_std_remaining_energy.append(np.std(self.remaining_energy))
-        #         self.episode_mean_remaining_energy.append(np.mean(self.remaining_energy))
-        #         self.episode_total_consumption_energy.append(np.sum(initial_energy - self.remaining_energy))
-        #         self.episode_network_throughput.append(self.network_throughput)
-        #         self.episode_packet_delivery_ratio.append(self.packet_delivery_ratio)
-        #         self.episode_network_lifetime.append(self.network_lifetime)
-        #         self.episode_average_latency.append(self.average_latency)
-
-        #         metrics = {
-        #             "returns_PPO": self.episode_returns,
-        #             "std_remaining_energy_PPO": self.episode_std_remaining_energy,
-        #             "total_consumption_energy_PPO": self.episode_total_consumption_energy,
-        #             "mean_remaining_energy_PPO": self.episode_mean_remaining_energy,
-        #             "network_throughput_PPO": self.episode_network_throughput,
-        #             "packet_delivery_ratio_PPO": self.episode_packet_delivery_ratio,
-        #             "network_lifetime_PPO": self.episode_network_lifetime,
-        #             "average_latency_PPO": self.episode_average_latency
-        #         }
-
-        #         for metric_name, metric_value in metrics.items():
-        #             np.save(f"{base_back_up_dir}{metric_name}_{self.version}.npy", np.array(metric_value))
-
-        # return self._get_obs(), rewards, dones, {}
-        return self._get_obs(), reward, done, self.get_metrics()
 
     def _get_obs(self):
         return [{'remaining_energy': np.array([e]), 
@@ -266,6 +236,7 @@ class WSNRoutingEnv(gym.Env):
                  'number_of_packets': np.array([d])
                 } for e, p, d in zip(self.remaining_energy, self.sensor_positions, self.number_of_packets)]
 
+
     def _get_observation_space(self):
         return Dict({
             'remaining_energy': Box(low=0, high=initial_energy, shape=(1,), dtype=np.float64),
@@ -274,23 +245,29 @@ class WSNRoutingEnv(gym.Env):
             'number_of_packets': Box(low=0, high=self.n_sensors * initial_number_of_packets + 1, shape=(1,), dtype=int)
         })
 
+
     def get_state(self):
         return self._get_obs()
     
+
     def get_avail_actions(self):
         return [list(range(self.n_sensors + 1)) for _ in range(self.n_sensors)]
     
+
     def update_sensor_energies(self, i, delta_energy):
         self.remaining_energy[i] -= delta_energy
 
+
     def transmission_energy(self, number_of_packets, distance):
         # energy consumption for transmitting data on a distance        
         return number_of_packets * info_amount * (Eelec + Eamp * distance**2)
     
+
     def reception_energy(self, number_of_packets):
         # energy consumption for receiving data
         return number_of_packets * info_amount * Eelec
     
+
     def compute_angle_vectors(self, i, action):
         '''
         Compute the angle in radians between the vectors formed by (i, action) and (i, base station)
@@ -304,6 +281,7 @@ class WSNRoutingEnv(gym.Env):
             
             return np.arccos(np.clip(cosine_angle, -1, 1))
 
+
     def compute_reward_angle(self, i, action):
         '''
         Compute the reward based on the angle between the vectors formed by (i, action) and (i, base station)
@@ -316,6 +294,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_angle, 0, 1)
         # return np.clip(- normalized_angle, -1, 1)
     
+
     def compute_reward_distance(self, i, action):
         '''
         Compute the reward based on the distance to the next hop
@@ -330,6 +309,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_distance_to_next_hop, 0, 1)
         # return np.clip(-normalized_distance_to_next_hop, -1, 1)
 
+
     def compute_reward_consumption_energy(self, i, action):
         '''
         Compute the reward based on the total energy consumption (transmission, reception)
@@ -352,6 +332,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_total_energy, 0, 1)
         # return np.clip(- normalized_total_energy, -1, 1)
 
+
     def compute_reward_dispersion_remaining_energy(self):
         '''
         Compute the reward based on the standard deviation of the remaining energy
@@ -364,6 +345,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
         # return np.clip(- normalized_dispersion_remaining_energy, -1, 1)
 
+
     def compute_reward_number_of_packets(self, action):
         '''
         Compute the reward based on the number of packets of the receiver
@@ -377,6 +359,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_number_of_packets, 0, 1)
         # return np.clip(- normalized_number_of_packets, -1, 1)
 
+
     def compute_individual_rewards(self, i, action):
         '''
         Compute the individual rewards
@@ -416,6 +399,7 @@ class WSNRoutingEnv(gym.Env):
 
         return np.concatenate((rewards_energy, rewards_performance))
 
+
     def network_reward_dispersion_remaining_energy(self):
         '''
         Compute the reward based on the standard deviation of the remaining energy at the network level
@@ -428,6 +412,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
         # return np.clip(- normalized_dispersion_remaining_energy, -1, 1)
     
+
     def network_reward_consumption_energy(self):
         '''
         Compute the reward based on the total energy consumption (transmission, reception) at the network level
@@ -440,6 +425,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_total_energy, 0, 1)
         # return np.clip(- normalized_total_energy, -1, 1)
     
+
     def compute_reward_packet_delivery_ratio(self):
         '''
         Compute the reward based on the packet delivery ratio
@@ -447,6 +433,7 @@ class WSNRoutingEnv(gym.Env):
         packet_delivery_ratio = self.packets_delivered / (self.total_packets_sent_by_sensors + self.epsilon) if self.total_packets_sent_by_sensors > 0 else 0
         return np.clip(packet_delivery_ratio, 0, 1)
     
+
     def compute_reward_latency(self):
         '''
         Compute the reward based on the average latency
@@ -458,6 +445,7 @@ class WSNRoutingEnv(gym.Env):
         return np.clip(1 - normalized_latency, 0, 1)
         # return np.clip(- normalized_latency, -1, 1)
 
+
     def compute_reward_network_throughput(self):
         '''
         Compute the reward based on the network throughput
@@ -467,6 +455,7 @@ class WSNRoutingEnv(gym.Env):
         normalized_throughput = network_throughput / (maximum_throughput + self.epsilon)
         return np.clip(normalized_throughput, 0, 1)
     
+
     def compute_attention_rewards(self, rewards):
         '''
         Compute the attention-based rewards
@@ -475,6 +464,7 @@ class WSNRoutingEnv(gym.Env):
         final_reward = net(rewards)
         return final_reward 
 
+
     def integrate_mobility(self):
         '''
         Integrate the mobility of the sensors after each step
@@ -487,6 +477,7 @@ class WSNRoutingEnv(gym.Env):
             if not(np.all(self.sensor_positions[i] >= lower_bound) and np.all(self.sensor_positions[i] <= upper_bound)):
                 self.sensor_positions[i] -= displacement[i]
     
+
     def get_metrics(self):
         # Calculate network throughput
         self.network_throughput = self.packets_delivered / (self.steps + self.epsilon) if self.steps > 0 else 0

{gym_examples-3.0.263.dist-info → gym_examples-3.0.264.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-examples
-Version: 3.0.263
+Version: 3.0.264
 Summary: A custom environment for multi-agent reinforcement learning focused on WSN routing.
 Home-page: https://github.com/gedji/CODES.git
 Author: Georges Djimefo

gym_examples-3.0.264.dist-info/RECORD

@@ -0,0 +1,7 @@
+gym_examples/__init__.py,sha256=OE2WBgKyEbqBOaXf4v4N5a0qFaCkN5iUcgmZIdLghqk,166
+gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
+gym_examples/envs/wsn_env.py,sha256=t0uJq77RsuDKn_VRKh8dY9khp4DE1etoHzaUd582OSw,24905
+gym_examples-3.0.264.dist-info/METADATA,sha256=4l07YRLJpfbh8kvvuZIlaOTAls-N81hZPxxvNNAu8bM,412
+gym_examples-3.0.264.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+gym_examples-3.0.264.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
+gym_examples-3.0.264.dist-info/RECORD,,

gym_examples-3.0.263.dist-info/RECORD

@@ -1,7 +0,0 @@
-gym_examples/__init__.py,sha256=V-lDBqJirIbwK5vx8WNT5JyIwiwk22PGBiYSvm6JPo8,166
-gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
-gym_examples/envs/wsn_env.py,sha256=Ee3PTxhwKw2igwK5z465IdgK3mP0ParioXCni6BqXiE,26695
-gym_examples-3.0.263.dist-info/METADATA,sha256=rpRe1k5FCesyS6hKApj_Z-_sQAjJ01WM90Mzk_a5XPs,412
-gym_examples-3.0.263.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-gym_examples-3.0.263.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
-gym_examples-3.0.263.dist-info/RECORD,,