Add knapsack agent for TimeFreqResourceAllocation Env

wireless/agents/noma_ul_time_freq_resource_allocation_v0/noma_ul_proportional_fair.py

@@ -50,7 +50,7 @@ def _calculate_wsr(self, perm_idx, rx_pwr_mw, w):
         return wsr
 
     def act(self, state, reward, done):
-        o, cqi, b, buffer_size_per_ue = ProportionalFairAgent.parse_state(state, self.K, self.L)
+        o, cqi, b, buffer_size_per_ue, throughput = ProportionalFairAgent.parse_state(state, self.K, self.L)
 
         p = state[-1]
 

wireless/agents/time_freq_resource_allocation_v0/proportional_fair.py

@@ -67,3 +67,46 @@ def _calculate_priorities(self, cqi, o, b, buffer_size_per_ue):
             se[cqi == i] = self.CQI2SE[i]
         priorities = (1 + o) / b * buffer_size_per_ue * se
         return priorities
+
+
+class Knapsackagent(ProportionalFairAgent):
+    def __init__(self, action_space, n_ues, buffer_max_size):
+        super().__init__(action_space, n_ues, buffer_max_size)
+        self.r = None
+        self.window = 25 * 10
+
+    def _calculate_priorities(self, cqi, o, b, buffer_size_per_ue, throughput):
+        # Normalized values
+        k_cqi = (cqi / 15)
+        k_buffer = (buffer_size_per_ue / (throughput + 1))
+        k_age = (o / b)
+        k_fairness = (1 / (1 + self.n))
+        # tanh as ranking function for values
+        priorities = 1 * np.tanh(k_cqi) + 1 * np.tanh(k_buffer) + 1 * np.tanh(k_age) + 1 * np.tanh(k_fairness)
+        return priorities
+
+    def act(self, state, reward, done):
+        # reset the self.r
+        if self.t % self.window == 0:
+            self.r = np.zeros(shape=(self.K,), dtype=np.float32)
+
+        o, cqi, b, buffer_size_per_ue = self.parse_state(state, self.K, self.L)
+
+        priorities = self._calculate_priorities(cqi, o, b, buffer_size_per_ue, self.r)
+
+        self.buffer_size_moving_average(state)
+
+        action = np.argmax(priorities)
+        self.n[action] += 1
+
+        self.t += 1
+        return action
+
+    def buffer_size_moving_average(self, state):
+        s = np.reshape(state[self.K:self.K * (1 + self.L)],
+                       (self.K, self.L))  # Sizes in bits of packets in UEs' buffers
+        buffer_size_per_ue = np.sum(s, axis=1)
+        # Moving Average of buffer sizes
+        if self.t % 25 == 0 and self.t != 0:
+            self.r = (1 - 0.1) * self.r + buffer_size_per_ue * 0.1
+

wireless/envs/time_freq_resource_allocation_v0.py

@@ -270,3 +270,5 @@ def _generate_traffic(self):
 
     def _update_state(self):
         self.state = np.concatenate((self.cqi, self.s.flatten(), self.e.flatten(), self.qi.flatten(), [self.p]))
+
+

wireless/scripts/launch_agent.py

@@ -50,8 +50,8 @@ def main(_run):
                            eirp_dbm=_run.config['env']['eirp_dbm'], f_carrier_mhz=_run.config['env']['f_carrier_mhz'],
                            max_pkt_size_bits=_run.config['env']['max_pkt_size_bits'],
                            it=_run.config['env']['non_gbr_traffic_mean_interarrival_time_ttis'])  # Init environment
-            env.seed(seed=_run.config['seed'] + ep) 
-    
+            env.seed(seed=_run.config['seed'] + ep)
+
             # Init agent
             if ac["agent"]["agent_type"] == "random":
                 agent = RandomAgent(env.action_space)
@@ -64,6 +64,8 @@ def main(_run):
                 agent = ProportionalFairAgent(env.action_space, env.K, env.L)
             elif ac["agent"]["agent_type"] == "proportional fair channel aware":
                 agent = ProportionalFairChannelAwareAgent(env.action_space, env.K, env.L)
+            elif ac["agent"]["agent_type"] == "knapsack":
+                agent = Knapsackagent(env.action_space, env.K, env.L)
             else:
                 raise NotImplemented