Initial commit

Author: Alvis Logins

DegreeSolver.py

@@ -0,0 +1,17 @@
+import networkx as nx
+import time
+from Solver import *
+
+class DegreeSolver(Solver):
+
+    def run(self):
+        t1 = time.time()
+        degrees = [(node, self.G.degree([node])[node]) for node in self.G.nodes() if node not in self.seeds]
+        blocked = []
+        degrees.sort(key=lambda t: t[1])
+        for i in range(self.k):
+            blocked.append(degrees.pop()[0])
+        t2 = time.time()
+
+        self.log['Total time'] = (t2-t1)
+        self.log['Blocked nodes'] = [int(node) for node in blocked]

DomSolver.py

@@ -0,0 +1,111 @@
+'''
+The class implements DAVA - the seed-aware immunization algorithm based on dominator trees.
+'''
+
+import networkx as nx
+import time
+from collections import defaultdict
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import Solver as slv
+from functools import reduce
+import math
+import numpy as np
+
+class DomSolver(slv.Solver):
+
+    def clear(self):
+        for e in self.G.edges(data=True):
+            if e[2]['weight'] == 1:
+                e[2]['weight'] = 0.99999  # No p=1 allowed due to probability calculation along shortest path
+        self.create_superseed_and_update_weights()
+
+    def create_superseed_and_update_weights(self):
+        self.superseed_index = len(self.G)
+        while self.superseed_index in self.G:
+            self.superseed_index += 1
+        neighbors = defaultdict(lambda: [])
+        for seed in self.seeds:
+            for n in self.G.neighbors(seed):
+                neighbors[n].append(self.G[seed][n]['weight'])
+        new_edges = [(self.superseed_index, n, DomSolver.get_total_weight(neighbors[n])) for n in neighbors]
+        self.G.add_weighted_edges_from(new_edges)
+        self.G = self.G.subgraph((set(self.G.nodes()) - set(self.seeds)) | set([self.superseed_index])).copy()
+        for edge in self.G.edges():
+            self.G[edge[0]][edge[1]]['weight'] = -math.log(self.G[edge[0]][edge[1]]['weight'])
+
+    @staticmethod
+    def get_total_weight(list_of_probabilities):
+        return 1. - reduce(lambda x, y: x*y, [(1.-p) for p in list_of_probabilities])
+
+    def run(self):
+        t1 = time.time()
+        blocked = []
+        extra_time = 0
+
+        if not self.params.get("fast", False):
+            for iteration in range(self.k):
+                self.build_domtree()
+                if iteration == 0:
+                    extra_time += self.save_tree_stats_return_time("first it")
+                if iteration == self.k - 1:
+                    extra_time += self.save_tree_stats_return_time("last it")
+                blocked += self.get_best_nodes(1)
+                self.G.remove_node(blocked[-1])
+        else:
+            self.build_domtree()
+            extra_time += self.save_tree_stats_return_time("first it")
+            blocked = self.get_best_nodes(self.k)
+        t2 = time.time()
+        self.log['Total time'] = t2 - t1 - extra_time
+        self.log['Blocked nodes'] = blocked
+
+    def save_tree_stats_return_time(self, prefix):
+        t1 = time.time()
+        g = self.domtree
+        sp = nx.single_source_shortest_path_length(g,self.superseed_index)
+        self.log['tree depth ' + prefix] = max([sp[n] for n in sp])
+        self.log['first level node fraction ' + prefix] = g.degree(self.superseed_index)/len(self.G)
+        first_level_degrees = [g.out_degree(n) for n in g.neighbors(self.superseed_index)]
+        self.log['second level node fraction ' + prefix] = sum(first_level_degrees)/len(self.G)
+        self.log['second level avg degree ' + prefix] = 0 if len(first_level_degrees) == 0 else np.mean(first_level_degrees)
+        t2 = time.time()
+        return t2 - t1
+
+    def build_domtree(self):
+        tree_dict = nx.algorithms.dominance.immediate_dominators(self.G, self.superseed_index)
+        self.domtree = nx.DiGraph()
+        self.domtree.add_node(self.superseed_index)
+        self.domtree.add_edges_from([(edge[1],edge[0]) for edge in tree_dict.items() if edge[0] != edge[1]])
+        probabilities_from_root = nx.single_source_dijkstra_path_length(self.G, self.superseed_index)
+
+        #probability (v,u) = p(u)/p(v) from root
+        for edge in self.domtree.edges():
+            if edge[0] == self.superseed_index:
+                probability = math.exp(-probabilities_from_root[edge[1]])
+            else:
+                probability = math.exp(-probabilities_from_root[edge[1]]+probabilities_from_root[edge[0]])
+            self.domtree[edge[0]][edge[1]]['weight'] = probability
+
+    def traverseTreeRec(self, node):
+        benefit = 1
+        for n in self.domtree.neighbors(node):
+            benefit += self.traverseTreeRec(n)*self.domtree[node][n]['weight']
+        return benefit
+
+    def get_rank(self):
+        rank = []
+        if self.k > self.domtree.degree(self.superseed_index):
+            self.log['error'] = "Problem is trivial"
+            if self.domtree.degree(self.superseed_index) == 0:
+                return [(0,np.random.choice([n for n in self.G.nodes() if n != self.superseed_index and n not in self.seeds], replace=False))]
+            return [(0, next(self.domtree.neighbors(self.superseed_index)))]
+        for n in self.domtree.neighbors(self.superseed_index):
+            benefit = self.traverseTreeRec(n)*self.domtree[self.superseed_index][n]['weight']
+            rank.append((benefit, n))
+        return rank
+
+    def get_best_nodes(self, number_of_nodes):
+        rank = self.get_rank()
+        return [int(a[1]) for a in sorted(rank)[-number_of_nodes:]]

Generator.py

@@ -0,0 +1,138 @@
+import networkx as nx
+from networkx.algorithms import approximation
+import random
+import sys
+import time
+import os
+import argparse
+import numpy as np
+import scipy.io
+import logging
+from scipy.sparse import csr_matrix
+sys.path.append(os.path.join(os.environ['PHD_ROOT'], 'imin', 'src'))
+sys.path.append(os.path.join(os.environ['PHD_ROOT'], 'imin', 'scripts'))
+import helpers
+from FileManager import *
+
+class Generator:
+    def __init__(self, params):
+        self.params = params
+        self.generators = {
+            'powerlaw_cluster': lambda: nx.powerlaw_cluster_graph(params["n"], params["m"], params["p"]),
+            'stanford': lambda: self.get_stanford_graph(),
+            'gnutella': lambda: self.get_gnutella_graph(),
+            'grid': lambda: nx.convert_node_labels_to_integers(nx.grid_2d_graph(params['n'], params['n'])),
+            'path': lambda: nx.path_graph(params["n"]),
+            'binomial': lambda: nx.fast_gnp_random_graph(params['n'], params['p']),
+            'watts_strogatz': lambda: nx.watts_strogatz_graph(params['n'], params['k'], params['p']),
+            'karate': lambda: nx.karate_club_graph(),
+            'vk': lambda: self.get_vk_graph(),
+            'gaussian_random_partition': lambda: nx.gaussian_random_partition_graph(params['n'], params['s'], params['v'], params['p_in'], params['p_out'])
+        }
+
+    def gen_graph_id(self):
+        return str(helpers.get_static_hash(str(int(time.time())) + str(random.randint(10000, 99999)) + "_".join([str(self.params[p]) for p in self.params])))
+
+    def generate(self, number_of_graphs=1):
+        for i in range(number_of_graphs):
+            G = self.generators[self.params["graph_type"]]()
+            if self.params["graph_type"] != 'vk':
+                if self.params["graph_type"] not in ["gnutella", "stanford"]:
+                    G = self.add_random_directions(G, self.params["both_directions"])
+                else:
+                    if self.params["both_directions"]:
+                        raise Exception("Not implemeted")
+                G = self.assign_weights(G, self.params["weight_scale"], self.params["random_weight"])
+            G.graph['graph_id'] = self.gen_graph_id()
+            G.graph.update(self.params)
+            yield G
+
+    @staticmethod # used in tests
+    def assign_weights(G, weight_scale, random_weight):
+        if random_weight:
+            for e in G.edges():
+                a = np.random.random()*weight_scale
+                G[e[0]][e[1]]['weight'] = np.random.random()*weight_scale
+        else:
+            for e in G.edges():
+                G[e[0]][e[1]]['weight'] = weight_scale
+        return G
+
+    @staticmethod
+    def add_random_directions(G, both=False):
+        assert(not nx.is_directed(G))
+        dG = nx.DiGraph()
+        for e in G.edges():
+            if both:
+                dG.add_edge(e[0],e[1])
+                dG.add_edge(e[1],e[0])
+                for key in G[e[0]][e[1]]:
+                    dG[e[0]][e[1]][key] = G[e[0]][e[1]][key]
+                    dG[e[1]][e[0]][key] = G[e[0]][e[1]][key]
+            else:
+                if np.random.random() < 0.5:
+                    dG.add_edge(e[0],e[1])
+                    for key in G[e[0]][e[1]]:
+                        dG[e[0]][e[1]][key] = G[e[0]][e[1]][key]
+                else:
+                    dG.add_edge(e[1],e[0])
+                    for key in G[e[1]][e[0]]:
+                        dG[e[1]][e[0]][key] = G[e[0]][e[1]][key]
+        return dG
+
+    def get_stanford_graph(self):
+        mat = scipy.io.loadmat(os.path.join(os.environ['ALLDATA_PATH'], 'imin', 'wb-cs-stanford.mat'))
+        sparse = mat['Problem'][0][0][2]
+        m = csr_matrix(sparse)
+        g = nx.DiGraph()
+        G = nx.from_numpy_matrix(m.toarray(), create_using=g)
+        return G
+        # g = G
+        # g = G.to_undirected() -- mistake
+        # nodeset = []
+        # for g1 in nx.connected_components(g):
+        #     if len(g1) > 1000:
+        #         nodeset = g1
+        #         break
+        # return G.subgraph(nodeset).copy()
+
+    def get_gnutella_graph(self):
+        edges = []
+        with open(os.path.join(os.environ['ALLDATA_PATH'], 'imin', 'p2p-Gnutella31.txt')) as f:
+            nodes, edge_count = f.readline().split()
+            nodes = int(nodes)
+            edge_count = int(edge_count)
+            for line in f:
+                edges.append((int(line.split()[0]), int(line.split()[1])))
+        assert(len(edges) == edge_count)
+        G = nx.DiGraph()
+        G.add_nodes_from(range(nodes))
+        G.add_edges_from(edges)
+        return G
+
+    def get_vk_graph(self):
+        G = nx.read_gpickle(os.path.join(os.environ['ALLDATA_PATH'], 'imin', 'vk_graph_cleaned.pkl'))
+        return G
+
+    @staticmethod
+    def analyze_graph(G):
+        G.graph['directed'] = nx.is_directed(G)
+        G_und = G.to_undirected()
+        # if G.graph['directed']:
+        #     G.graph['weakly_connected_components'] = nx.number_weakly_connected_components(G)
+        #     G.graph['largest_weak_component'] = max(nx.weakly_connected_components(G), key=len)
+        #     G.graph['strongly_connected_components'] = nx.number_strongly_connected_components(G)
+        # else:
+        G.graph['connected_components'] = nx.number_connected_components(G_und)
+        G.graph['largest_component'] = len(max(nx.connected_components(G_und), key=len))
+
+        logging.info("Graph ID {}: components analyzed.".format(G.graph['graph_id']))
+        G.graph['average_clustering'] = approximation.average_clustering(G_und)
+        logging.info("Graph ID {}: clustering analyzed.".format(G.graph['graph_id']))
+        degrees = [d for n, d in G.degree()]
+        G.graph['min_degree'] = min(degrees),max(degrees),np.mean(degrees),np.median(degrees)
+        G.graph['max_degree'] = max(degrees)
+        G.graph['avg_degree'] = np.mean(degrees)
+        G.graph['std_degree'] = np.std(degrees)
+        G.graph['median_degree'] = np.median(degrees)
+        logging.info("Graph ID {}: degrees analyzed.".format(G.graph['graph_id']))