gym-examples 2.0.80__py3-none-any.whl → 2.0.82__py3-none-any.whl

gym_examples/__init__.py

@@ -6,4 +6,4 @@ register(
      max_episode_steps=50,
 )
 
-__version__ = "2.0.80"
+__version__ = "2.0.82"

gym_examples/envs/wsn_env.py

@@ -10,11 +10,9 @@ import torch.nn as nn
 import torch.nn.functional as F
 
 # Define the network parameters for the final reward function
-input_dim = 5  # number of individual rewards
+input_dim = 4  # number of individual rewards
 output_dim = 1  # final reward
 
-
-stats_file_path_base = 'C:\\Users\\djime\\Documents\\PHD\\THESIS\\CODES\\RL_Routing\\Results_EPyMARL\\stats_over_time'
 Eelec = 50e-9  # energy consumption per bit in joules
 Eamp = 100e-12  # energy consumption per bit per square meter in joules
 info_amount = 3072  # data size in bits
@@ -47,7 +45,7 @@ net = net.double()  # Convert the weights to Double
 
 
 class WSNRoutingEnv(gym.Env):
-    def __init__(self, n_sensors = 20, coverage_radius=50):
+    def __init__(self, n_sensors = 20, coverage_radius=(upper_bound - lower_bound)/2):
 
         super(WSNRoutingEnv, self).__init__()
 
@@ -57,7 +55,7 @@ class WSNRoutingEnv(gym.Env):
         self.episode_count = 0
         self.scale_displacement = 0.01 * (upper_bound - lower_bound) # scale of the random displacement of the sensors
         self.epsilon = 1e-10 # small value to avoid division by zero
-        self.rewards_individual = [0] * self.n_sensors
+        # self.rewards_individual = [0] * self.n_sensors
         # Initialize the position of the sensors randomly
         self.sensor_positions = np.random.rand(self.n_sensors, 2) * (upper_bound - lower_bound) + lower_bound
         self.distance_to_base = np.linalg.norm(self.sensor_positions - base_station_position, axis=1)
@@ -75,21 +73,20 @@ class WSNRoutingEnv(gym.Env):
     def reset(self):
         # print individual rewards
         
-        if self.rewards_individual != []:
-            print("\n=================================================")
-            print(f"Episode: {self.episode_count}")
-            print(f"Rewards: {self.rewards_individual}")
-            print("=================================================\n")
+        # if self.rewards_individual != []:
+        #     print("\n=================================================")
+        #     print(f"Episode: {self.episode_count}")
+        #     print(f"Rewards: {self.rewards_individual}")
+        #     print("=================================================\n")
         # Initialize remaining energy of each sensor to initial_energy joule
         self.remaining_energy = np.ones(self.n_sensors) * initial_energy
-        self.consumption_energy = np.zeros(self.n_sensors)
         self.number_of_packets = np.ones(self.n_sensors, dtype=int) * initial_number_of_packets # number of packets to transmit
         self.episode_count += 1
         return self._get_obs()
 
     def step(self, actions):
         rewards = [0] * self.n_sensors
-        self.rewards_individual = [0] * self.n_sensors
+        # self.rewards_individual = [0] * self.n_sensors
         dones = [False] * self.n_sensors
         for i, action in enumerate(actions):
             
@@ -106,15 +103,25 @@ class WSNRoutingEnv(gym.Env):
                 continue  # Skip if sensor tries to transmit data to itself
 
             if action == self.n_sensors:
-                # Calculate the energy consumption and remaining for transmitting data to the base station
+                if self.distance_to_base[i] > self.coverage_radius:
+                    continue  # Skip if the distance to the base station is greater than the coverage radius
+
+                # Calculate the energy consumption for transmitting data to the base station
                 transmission_energy = self.transmission_energy(self.number_of_packets[i], self.distance_to_base[i])
+                if self.remaining_energy[i] < transmission_energy:
+                    continue  # Skip if the sensor does not have enough energy to transmit data to the base station
                 self.update_sensor_energies(i, transmission_energy)
                 rewards[i] = self.compute_individual_rewards(i, action)
                 dones[i] = True       
             else:
                 distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
+                if distance > self.coverage_radius:
+                    continue  # Skip if the distance to the next hop is greater than the coverage radius
+
                 transmission_energy = self.transmission_energy(self.number_of_packets[i], distance)
                 reception_energy = self.reception_energy(self.number_of_packets[i])
+                if self.remaining_energy[i] < transmission_energy or self.remaining_energy[action] < reception_energy:
+                    continue
                 self.update_sensor_energies(i, transmission_energy)  
                 self.update_sensor_energies(action, reception_energy) 
                 # Compute individual rewards
@@ -125,7 +132,7 @@ class WSNRoutingEnv(gym.Env):
             # Calculate final reward
             # rewards_individual = torch.tensor(rewards[i], dtype=torch.double)                
             # final_reward = net(rewards_individual)
-            self.rewards_individual[i] = rewards[i]
+            # self.rewards_individual[i] = rewards[i]
             final_reward = np.sum(rewards[i]) 
             rewards[i] = final_reward
 
@@ -133,7 +140,7 @@ class WSNRoutingEnv(gym.Env):
         # rewards = [0.5 * r + 0.5 * (self.network_reward_consumption_energy() + self.network_reward_dispersion_remaining_energy()) for r in rewards]
         
         # Only proceed if network consumption energy is not zero to avoid unnecessary list comprehension
-        self.rewards_individual = [r for r in self.rewards_individual if ((r != 0) and (r[len(r) -1] < 1))]
+        # self.rewards_individual = [r for r in self.rewards_individual if ((r != 0) and (r[len(r) -1] < 1))]
 
         # self.rewards_individual = [{"ind": r, "net_consumption_energy": self.network_reward_consumption_energy(), "net_dispersion_energy": self.network_reward_dispersion_remaining_energy()} for r in self.rewards_individual if ((r != 0) and (self.network_reward_consumption_energy() != 0))]
         for i in range(self.n_sensors):
@@ -149,15 +156,15 @@ class WSNRoutingEnv(gym.Env):
 
     def _get_obs(self):
         return [{'remaining_energy': np.array([e]), 
+                 'consumption_energy': np.array([initial_energy - e]),
                  'sensor_positions': p,
-                 'consumption_energy': np.array([c]),
-                 'number_of_packets': np.array([d])} for e, p, c, d in zip(self.remaining_energy, self.sensor_positions, self.consumption_energy, self.number_of_packets)]
+                 '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),
-            'sensor_positions': Box(low=lower_bound, high=upper_bound, shape=(2,), dtype=np.float64),
             'consumption_energy': Box(low=0, high=initial_energy, shape=(1,), dtype=np.float64),
+            'sensor_positions': Box(low=lower_bound, high=upper_bound, shape=(2,), dtype=np.float64),
             'number_of_packets': Box(low=0, high=self.n_sensors * initial_number_of_packets + 1, shape=(1,), dtype=int)
         })
 
@@ -168,7 +175,6 @@ class WSNRoutingEnv(gym.Env):
         return [list(range(self.n_sensors + 1)) for _ in range(self.n_sensors)]
     
     def update_sensor_energies(self, i, delta_energy):
-        self.consumption_energy[i] += delta_energy
         self.remaining_energy[i] -= delta_energy
 
     def transmission_energy(self, number_of_packets, distance):
@@ -208,7 +214,7 @@ class WSNRoutingEnv(gym.Env):
         Compute the reward based on the distance to the next hop
         '''
         if action == self.n_sensors:
-            distance = np.linalg.norm(self.sensor_positions[i] - base_station_position)
+            distance = np.linalg.norm(self.sensor_positions[i] - self.distance_to_base[i])
         else:
             distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
         # Normalize the distance to the next hop
@@ -228,37 +234,35 @@ class WSNRoutingEnv(gym.Env):
             transmission_energy = self.transmission_energy(self.number_of_packets[i], distance)
             reception_energy = self.reception_energy(self.number_of_packets[i])
             total_energy = transmission_energy + reception_energy
-            # total_energy = transmission_energy
-
+        
         # Normalize the total energy consumption
         max_transmission_energy = self.transmission_energy(self.n_sensors * initial_number_of_packets, self.coverage_radius)
         max_reception_energy = self.reception_energy(self.n_sensors * initial_number_of_packets)
         max_total_energy = max_transmission_energy + max_reception_energy
-        # max_total_energy = max_transmission_energy
         normalized_total_energy = total_energy / max_total_energy
 
         return np.clip(1 - normalized_total_energy, 0, 1)
     
-    def compute_reward_dispersion_remaining_energy(self,i):
-        '''
-        Compute the reward based on the difference between the remaining energy of the sensor i and the mean remaining energy of all sensors
-        '''
-        difference = np.abs(self.remaining_energy[i] - np.mean(self.remaining_energy))
-        # Normalize the difference
-        normalized_difference = difference / initial_energy
-
-        return np.clip(1 - normalized_difference, 0, 1)
-
-    # def compute_reward_dispersion_remaining_energy(self):
+    # def compute_reward_dispersion_remaining_energy(self,i):
     #     '''
-    #     Compute the reward based on the standard deviation of the remaining energy
+    #     Compute the reward based on the difference between the remaining energy of the sensor i and the mean remaining energy of all sensors
     #     '''
-    #     dispersion_remaining_energy = np.std(self.remaining_energy)
-    #     # Normalize the standard deviation of the remaining energy
-    #     max_dispersion_remaining_energy = initial_energy / 2 # maximum standard deviation of the remaining energy if n_sensors is even
-    #     normalized_dispersion_remaining_energy = dispersion_remaining_energy / max_dispersion_remaining_energy
+    #     difference = np.abs(self.remaining_energy[i] - np.mean(self.remaining_energy))
+    #     # Normalize the difference
+    #     normalized_difference = difference / initial_energy
 
-    #     return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
+    #     return np.clip(1 - normalized_difference, 0, 1)
+
+    def compute_reward_dispersion_remaining_energy(self):
+        '''
+        Compute the reward based on the standard deviation of the remaining energy
+        '''
+        dispersion_remaining_energy = np.std(self.remaining_energy)
+        # Normalize the standard deviation of the remaining energy
+        max_dispersion_remaining_energy = initial_energy / 2 # maximum standard deviation of the remaining energy if n_sensors is even
+        normalized_dispersion_remaining_energy = dispersion_remaining_energy / max_dispersion_remaining_energy
+
+        return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
     
     def compute_reward_number_of_packets(self, action):
         '''
@@ -286,27 +290,27 @@ class WSNRoutingEnv(gym.Env):
         # return [reward_angle, reward_distance, reward_consumption_energy, reward_number_of_packets]
         return [reward_angle, reward_distance, reward_dispersion_remaining_energy, reward_number_of_packets]
 
-    def network_reward_dispersion_remaining_energy(self):
-        '''
-        Compute the reward based on the standard deviation of the remaining energy at the network level
-        '''
-        dispersion_remaining_energy = np.std(self.remaining_energy)
-        # Normalize the standard deviation of the remaining energy
-        max_dispersion_remaining_energy = initial_energy / 2 # maximum standard deviation of the remaining energy if n_sensors is even
-        normalized_dispersion_remaining_energy = dispersion_remaining_energy / max_dispersion_remaining_energy
+    # def network_reward_dispersion_remaining_energy(self):
+    #     '''
+    #     Compute the reward based on the standard deviation of the remaining energy at the network level
+    #     '''
+    #     dispersion_remaining_energy = np.std(self.remaining_energy)
+    #     # Normalize the standard deviation of the remaining energy
+    #     max_dispersion_remaining_energy = initial_energy / 2 # maximum standard deviation of the remaining energy if n_sensors is even
+    #     normalized_dispersion_remaining_energy = dispersion_remaining_energy / max_dispersion_remaining_energy
 
-        return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
+    #     return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
     
-    def network_reward_consumption_energy(self):
-        '''
-        Compute the reward based on the total energy consumption (transmission, reception) at the network level
-        '''
-        total_energy = np.sum(self.consumption_energy)
-        # Normalize the total energy consumption
-        max_total_energy = self.n_sensors * initial_energy
-        normalized_total_energy = total_energy / max_total_energy
+    # def network_reward_consumption_energy(self):
+    #     '''
+    #     Compute the reward based on the total energy consumption (transmission, reception) at the network level
+    #     '''
+    #     total_energy = self.n_sensors * initial_energy - np.sum(self.remaining_energy)
+    #     # Normalize the total energy consumption
+    #     max_total_energy = self.n_sensors * initial_energy
+    #     normalized_total_energy = total_energy / max_total_energy
 
-        return np.clip(1 - normalized_total_energy, 0, 1)
+    #     return np.clip(1 - normalized_total_energy, 0, 1)
 
     def integrate_mobility(self):
         '''

{gym_examples-2.0.80.dist-info → gym_examples-2.0.82.dist-info}/METADATA

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

@@ -0,0 +1,7 @@
+gym_examples/__init__.py,sha256=0a6V_iaBbwkYsQh-6xcZfi7W2c80bYCfqPCbB9J335k,193
+gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
+gym_examples/envs/wsn_env.py,sha256=smTNOcnzz5rgGkvpdgZycyVbeAJA3DpXVA1BJoRsQ4s,17142
+gym_examples-2.0.82.dist-info/METADATA,sha256=OfTN21UuVUewI4w-o8_84TLg4LJW3r4c7fNFsZ8obBY,411
+gym_examples-2.0.82.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+gym_examples-2.0.82.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
+gym_examples-2.0.82.dist-info/RECORD,,

gym_examples-2.0.80.dist-info/RECORD

@@ -1,7 +0,0 @@
-gym_examples/__init__.py,sha256=1BNt94Y-ZBFKM09grE3oS4yWNI7qkuapGX3c7aVQxyk,193
-gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
-gym_examples/envs/wsn_env.py,sha256=SyD3DwXcsuSpLHxZhaVFnL3oe4KbdvQvP-bm8qIquhs,16706
-gym_examples-2.0.80.dist-info/METADATA,sha256=rRA4HZBKdJwffh-LYmwbiRulGQ-Q_8K2Lophc-KjWrE,411
-gym_examples-2.0.80.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-gym_examples-2.0.80.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
-gym_examples-2.0.80.dist-info/RECORD,,