⬆️ Algorithmic Bias Model speedup

ndlib/models/opinions/AlgorithmicBiasModel.py

@@ -52,21 +52,10 @@ def __init__(self, graph, seed=None):
 
         self.name = "Agorithmic Bias"
 
-        max_edgees = (self.graph.number_of_nodes() * (self.graph.number_of_nodes()-1))/2
-
         self.node_data = {}
-        nids = np.array(list(self.status.items()))
-
-        if max_edgees == self.graph.number_of_edges():
-            self.ids = nids[:, 0]
-            self.sts = nids[:, 1]
+        self.ids = None
+        self.sts = None
 
-        else:
-            for i in self.graph.nodes:
-                i_neigh = list(self.graph.neighbors(i))
-                i_ids = nids[:, 0][i_neigh]
-                i_sts = nids[:, 1][i_neigh]
-                self.node_data[i] = (i_ids, i_sts)
 
     def set_initial_status(self, configuration=None):
         """
@@ -80,16 +69,39 @@ def set_initial_status(self, configuration=None):
             self.status[node] = np.random.random_sample()
         self.initial_status = self.status.copy()
 
+        ### Initialization numpy representation
+
+        max_edgees = (self.graph.number_of_nodes() * (self.graph.number_of_nodes() - 1)) / 2
+        nids = np.array(list(self.status.items()))
+
+        if max_edgees == self.graph.number_of_edges():
+            self.ids = nids[:, 0]
+            self.sts = nids[:, 1]
+
+        else:
+            for i in self.graph.nodes:
+                i_neigh = list(self.graph.neighbors(i))
+                i_ids = nids[:, 0][i_neigh]
+                i_sts = nids[:, 1][i_neigh]
+                self.node_data[i] = (i_ids, i_sts)
+
     # def clean_initial_status(self, valid_status=None):
     #     for n, s in future.utils.iteritems(self.status):
     #         if s > 1 or s < 0:
     #             self.status[n] = 0
 
-    # @staticmethod
-    # def prob(distance, gamma, min_dist):
-    #     if distance < min_dist:
-    #         distance = min_dist
-    #     return np.power(distance, -gamma)
+    @staticmethod
+    def prob(distance, gamma, min_dist):
+        if distance < min_dist:
+            distance = min_dist
+        return np.power(distance, -gamma)
+
+    def pb1(self, statuses, i_status):
+        dist = np.abs(statuses - i_status)
+        null = np.full(statuses.shape[0], 0.00001)
+        max_base = np.maximum(dist, null)
+        dists = max_base ** -self.params['model']['gamma']
+        return dists
 
     def iteration(self, node_status=True):
         """
@@ -103,13 +115,13 @@ def iteration(self, node_status=True):
         # - if the two agents have a distance smaller than epsilon, then they change their status to the average of
         # their previous statuses
 
-        actual_status = defaultdict(float)
+        actual_status = self.status.copy()
 
         if self.actual_iteration == 0:
             self.actual_iteration += 1
             delta, node_count, status_delta = self.status_delta(self.status)
             if node_status:
-                return {"iteration": 0, "status": self.status.copy(),
+                return {"iteration": 0, "status": actual_status,
                         "node_count": node_count.copy(), "status_delta": status_delta.copy()}
             else:
                 return {"iteration": 0, "status": {},
@@ -133,31 +145,35 @@ def iteration(self, node_status=True):
                 ids = self.node_data[n1][0]
                 sts = self.node_data[n1][1]
 
-            f = lambda x, y: np.power(np.maximum(np.abs(x-y),  np.full(x.shape[0], 0.00001)), -self.params['model']['gamma'])
-            selection_prob = f(sts, self.status[n1])
+            selection_prob = self.pb1(sts, self.status[n1])
 
             # compute probabilities to select a second node among the neighbours
             total = np.sum(selection_prob)
             selection_prob = selection_prob / total
-
             cumulative_selection_probability = np.cumsum(selection_prob)
+
             r = np.random.random_sample()
             n2 = np.argmax(cumulative_selection_probability >= r) - 1
             n2 = ids[n2]
 
             # update status of n1 and n2
             diff = np.abs(self.status[n1] - self.status[n2])
+
             if diff < self.params['model']['epsilon']:
                 avg = (self.status[n1] + self.status[n2]) / 2.0
                 actual_status[n1] = avg
                 actual_status[n2] = avg
 
-        delta, node_count, status_delta = self.status_delta(actual_status)
+        # delta, node_count, status_delta = self.status_delta(actual_status)
+        delta = actual_status
+        node_count = {}
+        status_delta = {}
+
         self.status = actual_status
         self.actual_iteration += 1
 
         if node_status:
-            return {"iteration": self.actual_iteration - 1, "status": delta.copy(),
+            return {"iteration": self.actual_iteration - 1, "status": delta,
                     "node_count": node_count.copy(), "status_delta": status_delta.copy()}
         else:
             return {"iteration": self.actual_iteration - 1, "status": {},