gym-examples 2.0.81__py3-none-any.whl → 2.0.83__py3-none-any.whl

gym_examples/__init__.py

@@ -6,4 +6,4 @@ register(
      max_episode_steps=50,
 )
 
-__version__ = "2.0.81"
+__version__ = "2.0.83"

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__()
 
@@ -82,7 +80,6 @@ class WSNRoutingEnv(gym.Env):
         #     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()
@@ -109,8 +106,10 @@ class WSNRoutingEnv(gym.Env):
                 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 and remaining for transmitting data to the base station
+                # 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       
@@ -121,6 +120,8 @@ 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])
+                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
@@ -155,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)
         })
 
@@ -174,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):
@@ -214,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
@@ -234,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):
         '''
@@ -292,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.81.dist-info → gym_examples-2.0.83.dist-info}/METADATA

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

@@ -0,0 +1,7 @@
+gym_examples/__init__.py,sha256=YEKG8R03ekJWLJpmVPZiwKo5zvrqXgZbsoY-7HGY7sM,193
+gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
+gym_examples/envs/wsn_env.py,sha256=smTNOcnzz5rgGkvpdgZycyVbeAJA3DpXVA1BJoRsQ4s,17142
+gym_examples-2.0.83.dist-info/METADATA,sha256=-81toWYa0rYvAKiPCHLGlSi1otu9Pt7w8jjfOJZ4VDE,411
+gym_examples-2.0.83.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+gym_examples-2.0.83.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
+gym_examples-2.0.83.dist-info/RECORD,,

gym_examples-2.0.81.dist-info/RECORD

@@ -1,7 +0,0 @@
-gym_examples/__init__.py,sha256=bowSmkeNAOZSe_xKiNCfFdMmeF7fyV4gyu5a13H9RZE,193
-gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
-gym_examples/envs/wsn_env.py,sha256=ePw-tBdSKYUR2G1l5VD0yTMqFSIRerTxBf49kLw5DGg,17066
-gym_examples-2.0.81.dist-info/METADATA,sha256=mp1kGR4uMvgCxdrjfBjt0QPTyJqIKd8T-Fwi7YvgoZ0,411
-gym_examples-2.0.81.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-gym_examples-2.0.81.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
-gym_examples-2.0.81.dist-info/RECORD,,