gym-examples 3.0.248__py3-none-any.whl → 3.0.250__py3-none-any.whl

gym_examples/__init__.py

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

gym_examples/envs/wsn_env.py

@@ -48,7 +48,7 @@ net = net.double()  # Convert the weights to Double
 
 class WSNRoutingEnv(gym.Env):
 
-    print_stats = False  # Global flag to control printing of statistics
+    PRINT_STATS = "False"  # Global flag to control printing of statistics
 
     def __init__(self, n_sensors = 20, coverage_radius=(upper_bound - lower_bound)/4, num_timesteps = None, version = None):
 
@@ -128,20 +128,16 @@ class WSNRoutingEnv(gym.Env):
 
         return self._get_obs()
 
+
     def step(self, actions):
         self.steps += 1 
-        rewards = [-max_reward] * self.n_sensors
-        # rewards = [0] * self.n_sensors
-        dones = [False] * self.n_sensors
+        # 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):
-        for i, action in [actions]:
-            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
-
+        for i, action in [actions]: # This loop is for the PPO algorithm: actions is a numpy array of shape (1, 2)
             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
             
@@ -167,10 +163,10 @@ class WSNRoutingEnv(gym.Env):
                 self.total_latency += self.packet_latency[i] + latency_per_hop
                 self.packet_latency[i] = 0
 
-                # 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       
+                # rewards[i] = np.ones(input_dim) * max_reward # Reward for transmitting data to the base station
+                reward = max_reward
+                # dones[i] = True
+                # done = True       
             else:
                 distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
                 if distance > self.coverage_radius:
@@ -195,18 +191,20 @@ 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)  
+                # rewards[i] = self.compute_individual_rewards(i, action)  
+                reward = 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])
-            # 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
+            # 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
 
         # Integrate the mobility of the sensors
         # self.integrate_mobility() 
@@ -218,41 +216,45 @@ 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
-        # 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
+        # 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))
         
-        if os.getenv('PRINT_STATS') == 'True': # We are trying to extract only the statistics for the PPO algorithm
-            self.number_of_steps += 1
-            self.episode_return += rewards
-            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, {}
+        # if os.getenv('PRINT_STATS') == 'True': # We are trying to extract only the statistics for the PPO algorithm
+        #     self.number_of_steps += 1
+
+            
+
+        #     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]), 

{gym_examples-3.0.248.dist-info → gym_examples-3.0.250.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-examples
-Version: 3.0.248
+Version: 3.0.250
 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.250.dist-info/RECORD

@@ -0,0 +1,7 @@
+gym_examples/__init__.py,sha256=SCP88qKNLXNrQnomR5aDwTUKRGcubrWoYrMLMh_Jv_E,166
+gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
+gym_examples/envs/wsn_env.py,sha256=YWHO8EnD2HiG-72eWOtOtvEuR4x1tiUEQGjfUGCnN1g,26424
+gym_examples-3.0.250.dist-info/METADATA,sha256=iNb1JdpzCy-fSeT2rhapPJK-McEwXRcoGqY7cJIdHSo,412
+gym_examples-3.0.250.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+gym_examples-3.0.250.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
+gym_examples-3.0.250.dist-info/RECORD,,

gym_examples-3.0.248.dist-info/RECORD

@@ -1,7 +0,0 @@
-gym_examples/__init__.py,sha256=BjAXRifSQtOSJYJbOPIngjGcITUUcHk6qRjyJl_zT5A,166
-gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
-gym_examples/envs/wsn_env.py,sha256=qNvcWbmU5fv6t-CRHNWzWfPU_Z3qp_Qu9m6IPe-EuGg,26505
-gym_examples-3.0.248.dist-info/METADATA,sha256=sq4qBRNZXMFG1ohtgJM-Xrs8znvFxDEoEKniZ85JQZs,412
-gym_examples-3.0.248.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-gym_examples-3.0.248.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
-gym_examples-3.0.248.dist-info/RECORD,,