# robust measurement by schneider et.al. from robust_graph import s, R # log level: what kind of information are to be printed # other options: VERBOSE, DEBUG, INFO, WARNING, ERROR # e.g. WARNING: print warning and error information from robust_graph import LOG_LEVEL_QUIET as LOG_LEVEL # 4 optimizers based on 4 different algorithms from robust_graph import Schneider, WuHolme, Sun, IchinoseSatotani # measures certain index through optimization process from robust_graph import TimeTracker # function to load united states airline network # and make powerlaw-degree-distribution network from robust_graph import load_us, scale_free_network # initialize graph object and algorithm object G1 = scale_free_network() R1 = R(G1, n=10) # calculate 10 times to get more accurate result # use of optimizer print('----- optimizer test -----') print('original R =', R1) for opt_cls in [Schneider, WuHolme, IchinoseSatotani]: # still there are more options # see robust_graph/optimize document optimizer = opt_cls(G1, log_level=LOG_LEVEL, max_trials=10) G2 = optimizer.optimize(steps=100) R2 = R(G2, n=10) print('optimized by', opt_cls.__name__, 'R =', R2) # use of tracker print('----- time tracker test -----')
'Schneider' : (Schneider, LOG_LEVEL, True, dict(max_trials=100), 100), 'Holme' : (WuHolme, LOG_LEVEL, True, dict(), 1), 'Ichinose' : (IchinoseSatotani, LOG_LEVEL, False, dict(greedy=True), 100) } result_s = dict(zip(optimizers.keys(), [[0]*n_nodes]*len(optimizers))) for _ in range(n_graphs): # build graph and optimize with each algorithm G = scale_free_network(n_nodes) for name, params in optimizers.items(): opt_cls, log_level, force_update, config, steps = params optimizer = opt_cls(G, log_level, force_update, **config) optimized = optimizer.optimize(steps) # the following three lines do: # s[name] += s(optimized) * n_attacks result_s[name] = map(sum, zip(result_s[name], map(lambda e: e*n_attacks, s(optimized, n=n_attacks)))) # convert result_s sum of s(q) -> average of s(q) for k, v in result_s.items(): result_s[k] = map(lambda s: s / (n_graphs*n_attacks), v)