def derive_ETB(node_info, maxBD):
num_files = len(node_info['benefits'])
num_instances = len(node_info['benefits'][-1])
num_nodes = len(node_info['benefits'][-1][0])
ETB_score = np.zeros((num_files, maxBD, maxBD))
ct, ft, dt, ft = 0, 0, 0, 0
for i in range(num_files):
solnB, solnD = [], []
for j in range(num_instances):
t0 = ptime()
for k in range(num_nodes):
if (node_info['solution'][i][j][k] == 1):
solnB.append(node_info['benefits'][i][j][k])
solnD.append(node_info['damages'][i][j][k])
t1 = ptime()
ct += t1 - t0
t0 = ptime()
soln_freq = np.bincount(np.array(solnB))
denom = sum(solnB)
t1 = ptime()
ft += t1 - t0
t0 = ptime()
for k in range(len(solnB)):
B = solnB[k]
D = solnD[k]
node_contrib = (B / soln_freq[B]) / denom
ETB_score[i][B][D] += node_contrib
t1 = ptime()
dt += t1 - t0
t0 = ptime()
for j in range(maxBD):
for k in range(maxBD):
if (ETB_score[i][j][k] != 0):
ETB_score[i][j][k] /= num_instances
t1 = ptime()
ft += t1 - t0
print("\nTime to collect solution = " + str(ct) +
"\nTime to get greq in solution = " + str(ft) +
"\nTime to get hub contrib = " + str(ct) +
"\nTime to fill ETB_score = " + str(ft))
return ETB_score
def analyze(output_dir):
dirr = output_dir + "instances/"
t0 = ptime()
node_info, iters, leaf_metric = read_in(dirr)
t1 = ptime()
print("\nRead_in took " + str(t1 - t0))
t0 = ptime()
freq, maxBD = extract_freq(node_info)
t1 = ptime()
print("\nExtract_freq took " + str(t1 - t0))
t0 = ptime()
Pr = BD_probability(maxBD)
t1 = ptime()
print("\nProbability took " + str(t1 - t0))
t0 = ptime()
BD_leaf_fitness = calc_BD_leaf_fitness(
leaf_metric, maxBD) #derive leaf metric from file name?
t1 = ptime()
print("\nCalc_leaf_fitness took " + str(t1 - t0))
t0 = ptime()
t1 = ptime()
print("\nDerive_ETB took " + str(t1 - t0))
####PLOTS####
if not os.path.exists(output_dir + "/BD_plots/"):
os.makedirs(output_dir + "/BD_plots/")
if not os.path.exists(output_dir + "/slice_plots/"):
os.makedirs(output_dir + "/slice_plots/")
t0 = ptime()
plot_dir = output_dir + "BD_plots/"
BD_plots.freq(plot_dir, freq, iters)
BD_plots.probability(plot_dir, Pr)
BD_plots.leaf_fitness(plot_dir, BD_leaf_fitness)
BD_plots.Pr_leaf_fitness(plot_dir, Pr, BD_leaf_fitness)
#BD_plots.ETB(plot_dir, ETB_score, iters)
plot_dir = output_dir + "slice_plots/"
slice_plots.leaf_fitness(plot_dir, Pr, BD_leaf_fitness, None)
#slice_plots.ETB(plot_dir, ETB_score, iters)
t1 = ptime()
print("\nPlots took " + str(t1 - t0))
#Outputs: "binaries.dat"
from amuse.lab import *
import commands
import numpy
import random
from os import system
from itertools import islice
from time import time as ptime
k=0
j=0
system("mv bns.dat bns.dat.save.$(date +%s)")
tini=ptime()
while True:
k+=1
#Constants from stellar evolution, common envelope and kick velocity
time = 1500
K1 = 1
K2 = 1
neta = 0.5
bwind = 0
hewind = 1
alpha1 = 1
lambda1 = 0.5
ceflag = 0
tflag = 1
ifflag = 0
def evolve_minion(worker_file, gen, rank, output_dir):
t_start = time.time()
with open(str(worker_file), 'rb') as file:
worker_ID, seed, worker_gens, pop_size, num_return, randSeed, curr_gen, configs = pickle.load(
file)
file.close()
survive_fraction = float(configs['worker_percent_survive']) / 100
num_survive = math.ceil(survive_fraction * pop_size)
output_dir = configs['output_directory'].replace(
"v4nu_minknap_1X_both_reverse/", '')
#output_dir += str(worker_ID)
max_gen = int(configs['max_generations'])
control = configs['control']
if (control == "None"): control = None
fitness_direction = str(configs['fitness_direction'])
node_edge_ratio = float(configs['edge_to_node_ratio'])
random.seed(randSeed)
population = gen_population_from_seed(seed, pop_size)
start_size = len(seed.net.nodes())
pressurize_time = 0
mutate_time = 0
for g in range(worker_gens):
gen_percent = float(curr_gen / max_gen)
if (g != 0):
for p in range(num_survive, pop_size):
population[p] = population[p % num_survive].copy()
#assert (population[p] != population[p%num_survive])
#assert (population[p].net != population[p % num_survive].net)
for p in range(pop_size):
t0 = ptime()
mutate.mutate(configs, population[p].net, gen_percent,
node_edge_ratio)
t1 = ptime()
mutate_time += t1 - t0
if (control == None):
pressure_results = pressurize.pressurize(
configs, population[p].net, None
) # false: don't track node fitness, None: don't write instances to file
population[p].fitness_parts[0], population[p].fitness_parts[
1], population[p].fitness_parts[2] = pressure_results[
0], pressure_results[1], pressure_results[2]
else:
util.cluster_print(
output_dir, "ERROR in minion(): unknown control config: " +
str(control))
old_popn = population
population = fitness.eval_fitness(old_popn, fitness_direction)
del old_popn
#debug(population,worker_ID, output_dir)
curr_gen += 1
write_out_worker(output_dir + "/to_master/" + str(gen) + "/" + str(rank),
population, num_return)
# some output, probably outdated
if (worker_ID == 0):
orig_dir = configs['output_directory']
end_size = len(population[0].net.nodes())
growth = end_size - start_size
output.minion_csv(orig_dir, pressurize_time, growth, end_size)
#debug(population, worker_ID, output_dir)
#if (worker_ID==0): util.cluster_print(output_dir,"Pressurizing took " + str(pressurize_time) + " secs, while mutate took " + str(mutate_time) + " secs.")
t_end = time.time()
time_elapsed = t_end - t_start
if (rank == 1 or rank == 32 or rank == 63):
util.cluster_print(
output_dir, "Worker #" + str(rank) + " finishing after " +
str(time_elapsed) + " seconds")
def analyze(output_dir):
dirr = output_dir + "instances/"
t0 = ptime()
node_info, iters, leaf_metric = read_in(dirr)
# node_info = {'id':names, 'degree':deg, 'benefit':B, 'damage':D, 'solution':soln}
# 'benefit' = [file#] [node#]
t1 = ptime()
print("\nRead_in took " + str(t1 - t0))
#TEMP FOR HUBS:
#leaf_metric = "RGAR"
t0 = ptime()
freq, maxBD = extract_freq(node_info)
t1 = ptime()
print("\nExtract_freq took " + str(t1 - t0))
t0 = ptime()
Pr = BD_probability(maxBD)
t1 = ptime()
print("\nProbability took " + str(t1 - t0))
# Pr [B] [D]
t0 = ptime()
BD_leaf_fitness = calc_BD_leaf_fitness(
leaf_metric, maxBD) #derive leaf metric from file name?
# BD_leaf_fitness [B] [D]
t1 = ptime()
print("\nCalc_leaf_fitness took " + str(t1 - t0))
t0 = ptime()
#ETB_score = derive_ETB(node_info, maxBD)
# ETB_score [file#] [B] [D]
t1 = ptime()
print("\nDerive_ETB took " + str(t1 - t0))
####PLOTS####
if not os.path.exists(output_dir + "/BD_plots/"):
os.makedirs(output_dir + "/BD_plots/")
if not os.path.exists(output_dir + "/slice_plots/"):
os.makedirs(output_dir + "/slice_plots/")
t0 = ptime()
plot_dir = output_dir + "BD_plots/"
BD_plots.freq(plot_dir, freq, iters)
BD_plots.probability(plot_dir, Pr)
BD_plots.leaf_fitness(plot_dir, BD_leaf_fitness)
BD_plots.Pr_leaf_fitness(plot_dir, Pr, BD_leaf_fitness)
#BD_plots.ETB(plot_dir, ETB_score, iters)
plot_dir = output_dir + "slice_plots/"
slice_plots.leaf_fitness(plot_dir, Pr, BD_leaf_fitness, None)
#slice_plots.ETB(plot_dir, ETB_score, iters)
t1 = ptime()
print("\nPlots took " + str(t1 - t0))