def main():
"""Parse arguments and perform the computation."""
# Parse arguments
parser = argparse.ArgumentParser()
parser.description = "Compute approximate betweenness centrality of all vertices in a graph using the algorihm by Brandes and Pich, and the time to compute them, and write them to file"
parser.add_argument("epsilon", type=util.valid_interval_float,
help="accuracy parameter")
parser.add_argument("delta", type=util.valid_interval_float,
help="confidence parameter")
parser.add_argument("graph", help="graph file")
parser.add_argument("output", help="output file")
parser.add_argument("-m", "--maxconn", action="store_true", default=False,
help="if the graph is not weakly connected, only save the largest connected component")
parser.add_argument("-p", "--pickle", action="store_true", default=False,
help="use pickle reader for input file")
parser.add_argument("-s", "--samplesize", type=util.positive_int,
default=0, help="use specified sample size. Overrides epsilon, delta, and diameter computation")
parser.add_argument("-t", "--timeout", type=util.positive_int, default=3600,
help="Timeout computation after specified number of seconds (default 3600 = 1h, 0 = no timeout)")
parser.add_argument("-u", "--undirected", action="store_true", default=False,
help="consider the graph as undirected ")
parser.add_argument("-v", "--verbose", action="count", default=0, help="increase verbosity (use multiple times for more verbosity)")
parser.add_argument("-w", "--write", nargs="?", default=False, const="auto",
help="write graph (and computed attributes) to file.")
args = parser.parse_args()
# Set the desired level of logging
util.set_verbosity(args.verbose)
# Read graph
if args.pickle:
G = util.read_graph(args.graph)
else:
G = converter.convert(args.graph, not args.undirected, args.maxconn)
# Compute betweenness
if args.samplesize:
(stats, betw) = betweenness_sample_size(G, args.samplesize, args.write,
args.timeout)
else:
(stats, betw) = betweenness(G, args.epsilon, args.delta, args.write,
args.timeout)
# If specified, write betweenness as vertex attributes, and time as graph
# attribute back to file
if args.write:
logging.info("Writing betweenness as vertex attributes and stats as graph attribute")
if args.write == "auto":
filename = os.path.splitext(args.graph)[0] + ("-undir" if args.undirected else "dir") + ".picklez"
G.write(filename)
else:
G.write(args.write)
# Write stats and betweenness to output
util.write_to_output(stats, betw, args.output)
def write_line_to_output(count_step, x_matrix, e_matrix, f_ouput):
write_to_output('%5d|' % count_step, f_ouput, end='')
for el in x_matrix:
write_to_output('%10.4f|' % el[0], f_ouput, end='')
if e_matrix is not None:
for el in e_matrix:
write_to_output('%10.4f|' % el[0], f_ouput, end='')
else:
for _ in range(RANK_MATRIX):
write_to_output('%10s|' % '---', f_ouput, end='')
write_to_output('\n', f_ouput)
def write_heading_to_output(f_output):
write_to_output('%5s|' % 'k', f_output, end='')
for i in range(RANK_MATRIX):
write_to_output('%10s|' % ('x' + str(i)), f_output, end='')
for i in range(RANK_MATRIX):
write_to_output('%10s|' % ('e' + str(i)), f_output, end='')
write_to_output('\n', f_output)
def write_heading_for_ouput(rank, f_output):
write_to_output('%3s|' % 'k', f_output, end='')
for i in range(rank):
x = 'x' + str(i + 1)
write_to_output('%15s|' % x, f_output, end='')
write_to_output('%15s|' % 'eigenvalue', f_output, end='')
write_to_output('%15s|' % 'Precision', f_output, end='')
def write_output(array_dict):
out_file = open(OUTPUT_FILE_NAME, 'w')
for heading in array_dict.keys():
write_to_output('%15s|' % heading, out_file, end='')
write_to_output('\n', out_file)
for i in range(RANK_LEFT_MATRIX):
for array in array_dict.values():
write_to_output('%15.10f|' % array[i], out_file, end='')
write_to_output('\n', out_file)
out_file.close()
def main():
"""Parse arguments and perform the computation."""
# Parse arguments
parser = argparse.ArgumentParser()
parser.description = "Compute approximate betweenness centrality of all vertices in a graph using the algorihm by Brandes and Pich, and the time to compute them, and write them to file"
parser.add_argument("epsilon",
type=util.valid_interval_float,
help="accuracy parameter")
parser.add_argument("delta",
type=util.valid_interval_float,
help="confidence parameter")
parser.add_argument("graph", help="graph file")
parser.add_argument("output", help="output file")
parser.add_argument(
"-m",
"--maxconn",
action="store_true",
default=False,
help=
"if the graph is not weakly connected, only save the largest connected component"
)
parser.add_argument("-p",
"--pickle",
action="store_true",
default=False,
help="use pickle reader for input file")
parser.add_argument(
"-s",
"--samplesize",
type=util.positive_int,
default=0,
help=
"use specified sample size. Overrides epsilon, delta, and diameter computation"
)
parser.add_argument(
"-t",
"--timeout",
type=util.positive_int,
default=3600,
help=
"Timeout computation after specified number of seconds (default 3600 = 1h, 0 = no timeout)"
)
parser.add_argument("-u",
"--undirected",
action="store_true",
default=False,
help="consider the graph as undirected ")
parser.add_argument(
"-v",
"--verbose",
action="count",
default=0,
help="increase verbosity (use multiple times for more verbosity)")
parser.add_argument("-w",
"--write",
nargs="?",
default=False,
const="auto",
help="write graph (and computed attributes) to file.")
args = parser.parse_args()
# Set the desired level of logging
util.set_verbosity(args.verbose)
# Read graph
if args.pickle:
G = util.read_graph(args.graph)
else:
G = converter.convert(args.graph, not args.undirected, args.maxconn)
# Compute betweenness
if args.samplesize:
(stats, betw) = betweenness_sample_size(G, args.samplesize, args.write,
args.timeout)
else:
(stats, betw) = betweenness(G, args.epsilon, args.delta, args.write,
args.timeout)
# If specified, write betweenness as vertex attributes, and time as graph
# attribute back to file
if args.write:
logging.info(
"Writing betweenness as vertex attributes and stats as graph attribute"
)
if args.write == "auto":
filename = os.path.splitext(args.graph)[0] + (
"-undir" if args.undirected else "dir") + ".picklez"
G.write(filename)
else:
G.write(args.write)
# Write stats and betweenness to output
util.write_to_output(stats, betw, args.output)
def cal_norma(matrix):
result = 0
for row in matrix:
for el in row:
result += el**2
return math.sqrt(result)
if __name__ == "__main__":
f_output = open(OUTPUT_FILE_NAME, 'w')
matrix_aplha, matrix_beta = read_input()
norma = cal_norma(matrix_aplha)
if norma < 1:
write_to_output('norma = {} < 1 \n'.format(norma), f_output)
else:
write_to_output('Norma > 1', f_output)
import sys
sys.exit(-1)
dif = PRECISION + 1
x = init_x(RANK_MATRIX)
count_step = 0
write_heading_to_output(f_output)
write_line_to_output(count_step, x, None, f_output)
while dif > PRECISION:
count_step += 1
new_x = matrix_aplha.dot(x) + matrix_beta
dif = cal_dif(new_x, x)
write_line_to_output(count_step, new_x, cal_precision_matrix(new_x, x),
def main():
"""Parse arguments, call betweenness(), write to file."""
# Parse arguments
parser = argparse.ArgumentParser()
parser.description = "Compute approximate betweenness centrality of all vertices in a graph using sampling and VC-dimension, and the time to compute them, and write them to file"
parser.add_argument("epsilon",
type=util.valid_interval_float,
help="accuracy parameter")
parser.add_argument("delta",
type=util.valid_interval_float,
help="confidence parameter")
parser.add_argument("graph", help="graph file")
parser.add_argument("output", help="output file")
group = parser.add_mutually_exclusive_group()
group.add_argument("-a",
"--approximate",
action="store_true",
default=True,
help="use approximate diameter (default)")
group.add_argument("-d",
"--diameter",
type=util.positive_int,
default=0,
help="value to use for the diameter")
group.add_argument("-e",
"--exact",
action="store_true",
default=False,
help="use exact diameter")
parser.add_argument(
"-m",
"--maxconn",
action="store_true",
default=False,
help=
"if the graph is not weakly connected, only save the largest connected component"
)
parser.add_argument("-p",
"--pickle",
action="store_true",
default=False,
help="use pickle reader for input file")
parser.add_argument(
"-s",
"--samplesize",
type=util.positive_int,
default=0,
help=
"use specified sample size. Overrides epsilon, delta, and diameter computation"
)
parser.add_argument(
"-t",
"--timeout",
type=util.positive_int,
default=3600,
help=
"Timeout computation after specified number of seconds (default 3600 = 1h, 0 = no timeout)"
)
parser.add_argument("-u",
"--undirected",
action="store_true",
default=False,
help="consider the graph as undirected ")
parser.add_argument(
"-v",
"--verbose",
action="count",
default=0,
help="increase verbosity (use multiple times for more verbosity)")
parser.add_argument("-w",
"--write",
nargs="?",
default=False,
const="auto",
help="write graph (and computed attributes) to file.")
parser.add_argument(
"-l",
"--weightFile",
default="-",
help=
"random weights within the interval 0 to 1, must have as many entries as the number of edges"
)
args = parser.parse_args()
# Set the desired level of logging
util.set_verbosity(args.verbose)
# Seed the random number generator
random.seed()
# Read graph
if args.pickle:
G = util.read_graph(args.graph)
else:
G = converter.convert(args.graph, not args.undirected, args.maxconn)
if args.exact:
args.approximate = False
# Read the weights
weights_list = []
if args.weightFile != "-":
with open(args.weightFile, 'r') as weight_file:
for line in weight_file:
weights_list.append(float(line.strip()))
# Compute betweenness
if args.samplesize:
(stats, betw) = betweenness_sample_size(G, args.samplesize, args.write)
else:
if args.diameter > 0:
(stats, betw) = betweenness(G, args.epsilon, args.delta,
weights_list, args.diameter,
args.write)
else:
(stats, betw) = betweenness(G, args.epsilon, args.delta,
weights_list, args.approximate,
args.write)
# If specified, write betweenness as vertex attributes, and time as graph
# attribute back to file
if args.write:
logging.info(
"Writing betweenness as vertex attributes and stats as graph attribute"
)
if args.write == "auto":
filename = os.path.splitext(args.graph)[0] + (
"-undir" if args.undirected else "dir") + ".picklez"
G.write(filename)
else:
G.write(args.write)
# Write stats and betweenness to output
util.write_to_output(stats, betw, args.output)
def main():
"""Parse arguments, call betweenness(), write to file."""
# Parse arguments
parser = argparse.ArgumentParser()
parser.description = "Compute approximate betweenness centrality of all vertices in a graph using sampling and VC-dimension, and the time to compute them, and write them to file"
parser.add_argument("epsilon", type=util.valid_interval_float,
help="accuracy parameter")
parser.add_argument("delta", type=util.valid_interval_float,
help="confidence parameter")
parser.add_argument("graph", help="graph file")
parser.add_argument("output", help="output file")
group = parser.add_mutually_exclusive_group()
group.add_argument("-a", "--approximate", action="store_true",
default=True, help="use approximate diameter (default)")
group.add_argument("-d", "--diameter", type=util.positive_int, default=0,
help="value to use for the diameter")
group.add_argument("-e", "--exact", action="store_true", default=False,
help="use exact diameter")
parser.add_argument("-m", "--maxconn", action="store_true", default=False,
help="if the graph is not weakly connected, only save the largest connected component")
parser.add_argument("-p", "--pickle", action="store_true", default=False,
help="use pickle reader for input file")
parser.add_argument("-s", "--samplesize", type=util.positive_int,
default=0, help="use specified sample size. Overrides epsilon, delta, and diameter computation")
parser.add_argument("-t", "--timeout", type=util.positive_int, default=3600,
help="Timeout computation after specified number of seconds (default 3600 = 1h, 0 = no timeout)")
parser.add_argument("-u", "--undirected", action="store_true", default=False,
help="consider the graph as undirected ")
parser.add_argument("-v", "--verbose", action="count", default=0,
help="increase verbosity (use multiple times for more verbosity)")
parser.add_argument("-w", "--write", nargs="?", default=False, const="auto",
help="write graph (and computed attributes) to file.")
parser.add_argument("-l", "--weightFile", default="-",
help="random weights within the interval 0 to 1, must have as many entries as the number of edges")
args = parser.parse_args()
# Set the desired level of logging
util.set_verbosity(args.verbose)
# Seed the random number generator
random.seed()
# Read graph
if args.pickle:
G = util.read_graph(args.graph)
else:
G = converter.convert(args.graph, not args.undirected, args.maxconn)
if args.exact:
args.approximate = False
# Read the weights
weights_list=[]
if args.weightFile != "-":
with open(args.weightFile,'r') as weight_file:
for line in weight_file:
weights_list.append(float(line.strip()))
# Compute betweenness
if args.samplesize:
(stats, betw) = betweenness_sample_size(G, args.samplesize, args.write)
else:
if args.diameter > 0:
(stats, betw) = betweenness(G, args.epsilon, args.delta,
weights_list, args.diameter, args.write)
else:
(stats, betw) = betweenness(G, args.epsilon, args.delta,
weights_list, args.approximate, args.write)
# If specified, write betweenness as vertex attributes, and time as graph
# attribute back to file
if args.write:
logging.info("Writing betweenness as vertex attributes and stats as graph attribute")
if args.write == "auto":
filename = os.path.splitext(args.graph)[0] + ("-undir" if args.undirected else "dir") + ".picklez"
G.write(filename)
else:
G.write(args.write)
# Write stats and betweenness to output
util.write_to_output(stats, betw, args.output)
def write_line_to_output(step_count, x, eigenvalue, precision, f_output):
write_to_output('\n', f_output)
write_to_output('%3d|' % step_count, f_output, end='')
for row in x:
write_to_output('%15.4f|' % row[0], f_output, end='')
if eigenvalue:
write_to_output('%15.4f|' % eigenvalue, f_output, end='')
else:
write_to_output('%15s|' % '---', f_output, end='')
if precision:
write_to_output('%15.4f|' % precision, f_output, end='')
else:
write_to_output('%15s|' % '---', f_output, end='')
write_to_output('\n', f_output)
def write_eigenvector(x, f_output):
l = max(x)
write_to_output('\nEigenvector: \n{}'.format(str(x / l)), f_output)
if __name__ == "__main__":
f_output = open(OUTPUT_FILE_NAME, 'w')
raw_matrix = read_raw_input(INPUT_FILE_NAME)
matrix_a = np.array(raw_matrix)
rank = len(raw_matrix)
write_heading_for_ouput(rank, f_output)
x = init_x(rank)
dif = PRECISION + 1
previous_eigenvalue = None
count_step = 0
write_line_to_output(count_step, x, None, None, f_output)
while dif > PRECISION:
count_step += 1
new_x = matrix_a.dot(x)
new_eigenvalue = sum([new_x[i][0] / x[i][0]
for i in range(rank)]) / rank
dif = cal_dif(new_eigenvalue, previous_eigenvalue)
write_line_to_output(count_step, new_x, new_eigenvalue, dif, f_output)
x = new_x
previous_eigenvalue = new_eigenvalue
if dif is None:
dif = PRECISION + 1
write_to_output('EigenValue={}'.format(new_eigenvalue), f_output)
write_eigenvector(x, f_output)
f_output.close()
