def get_avg_module_values_for_each_generation_of_an_experiment(
self,
a_path,
start_gen=0,
end_gen=None,
louvain=False,
no_self_edge=False,
avg_gen=True):
sub_directories = get_immediate_subdirectories(a_path)
rtn_modularity_list = []
for a_directory in sub_directories:
phenotypes = self.get_grn_phenotypes(a_directory)
if len(phenotypes) > 0:
if end_gen is None:
end_gen = len(phenotypes)
for a_gen in range(start_gen, end_gen):
target_phenotype = phenotypes[a_gen]
if no_self_edge:
side_grn_size = int(math.sqrt(len(target_phenotype)))
for i in range(side_grn_size):
target_phenotype[i * side_grn_size + i] = 0
a_grn = self.generate_directed_grn(target_phenotype)
if len(rtn_modularity_list) <= a_gen:
rtn_modularity_list.append(
[self.get_modularity_value(a_grn, louvain)])
else:
rtn_modularity_list[a_gen].append(
self.get_modularity_value(a_grn, louvain))
if avg_gen:
for i in range(len(rtn_modularity_list)):
rtn_modularity_list[i] = sum(rtn_modularity_list[i]) / len(
rtn_modularity_list[i])
return rtn_modularity_list
def get_mod_of_each_generation_in_a_whole_exp_with_stdev(self, exp_path, column, sample_size=100):
trial_dirs = fp.get_immediate_subdirectories(exp_path)
all_trails = []
# grn_plotter = GRNPlotter()
# all_trial_fits = []
# edge_nums_1 = grn_plotter.get_exp_fittest_grn_edge_num(exp_path, index=index)
# edge_nums_2 = grn_plotter.get_exp_fittest_grn_edge_num(self.path_2, index=index)
# for a_gen in (0, 2000):
# a_trial_mod = csv_reader.get_entry_values_of_an_experiment(exp_path, column, a_gen)
#
# all_trial_fits.append()
#
# return np.mean(np.array(all_trial_fits), axis=1), np.std(np.array(all_trial_fits), axis=1)
for a_trail_dir in trial_dirs:
grn_plotter = GRNPlotter()
phenotypes = grn_plotter.get_grn_phenotypes(a_trail_dir)
a_dir_list = self.get_column_values_of_an_trial(a_trail_dir, column)
if a_dir_list is not None and phenotypes:
trial_edges = list([io_tools.count_number_of_edges(a_phe) for a_phe in phenotypes])
normed_qs = mod_tools.normalize_mod_q(a_dir_list, trial_edges)
all_trails.append(np.array(normed_qs))
if len(all_trails) > sample_size:
break
return np.mean(np.array(all_trails), axis=0), np.std(np.array(all_trails), axis=0)
def get_properties_of_each_generation_in_a_whole_experiment(self, exp_path, column, sample_size=100):
trial_dirs = fp.get_immediate_subdirectories(exp_path)
all_trails = []
for a_trail_dir in trial_dirs:
a_dir_list = self.get_column_values_of_an_trial(a_trail_dir, column)
if a_dir_list is not None:
all_trails.append(np.array(a_dir_list))
if len(all_trails) > sample_size:
break
return np.mean(np.array(all_trails), axis=0)
def get_average_std_dev_edge_number_of_the_whole_experiment(
self, working_path):
avg_edge_numbers = []
directories = get_immediate_subdirectories(working_path)
for a_directory in directories:
try:
avg_edge_numbers.append(
self.get_average_edge_number_std_dev_of_the_whole_trial(
a_directory))
except RuntimeError:
pass
return avg_edge_numbers
def get_average_edge_number_of_the_whole_experiment(self, working_path):
avg_edge_numbers = []
directories = get_immediate_subdirectories(working_path)
for a_directory in directories:
try:
a_new_number = self.get_average_edge_number_of_the_whole_trial(
a_directory)
if a_new_number is not None:
avg_edge_numbers.append(a_new_number)
except RuntimeError or TypeError:
pass
return avg_edge_numbers
def get_edge_num_of_each_generation_in_a_whole_exp_with_stdev(self, exp_path, sample_size=100):
trial_dirs = fp.get_immediate_subdirectories(exp_path)
all_trails = []
for a_trail_dir in trial_dirs:
grn_plotter = GRNPlotter()
phenotypes = grn_plotter.get_grn_phenotypes(a_trail_dir)
if phenotypes:
trial_edges = list([io_tools.count_number_of_edges(a_phe) for a_phe in phenotypes])
if len(trial_edges) == 2001:
all_trails.append(np.array(trial_edges))
if len(all_trails) > sample_size:
break
return np.mean(np.array(all_trails), axis=0), np.std(np.array(all_trails), axis=0)
def get_fittest_mod_of_a_exp_with_stdev(self, exp_path, index=-1, sample_size=100):
trial_dirs = fp.get_immediate_subdirectories(exp_path)
all_trails = []
for a_trail_dir in trial_dirs:
grn_plotter = GRNPlotter()
phenotypes = grn_plotter.get_grn_phenotypes(a_trail_dir)
a_dir_list = self.get_column_values_of_an_trial(a_trail_dir, 'FittestModularity')
if a_dir_list is not None and phenotypes:
trial_edges = list([io_tools.count_number_of_edges(a_phe) for a_phe in phenotypes])
normed_qs = mod_tools.normalize_mod_q(a_dir_list, trial_edges)
all_trails.append(np.array(normed_qs))
if len(all_trails) > sample_size:
break
return np.array(all_trails)[:, index], np.std(np.array(all_trails)[:, index])
def get_exp_fittest_grn_edge_num(self,
root_path,
index=-1,
sample_size=100):
trial_dirs = fp.get_immediate_subdirectories(root_path)
final_phes = []
for a_trail_dir in trial_dirs:
phenotypes = self.get_grn_phenotypes(a_trail_dir)
if phenotypes:
phenotypes = phenotypes[index]
final_phes.append(phenotypes)
if len(final_phes) >= sample_size:
break
return list(
[io_tools.count_number_of_edges(a_phe) for a_phe in final_phes])
def get_pop_phe_lists_of_an_experiment(self,
root_path,
sample_size,
starting_gen=0,
ending_gen=None,
the_interval=1):
pop_phe_lists_list = []
for a_trial_dir in fp.get_immediate_subdirectories(
root_path, no_limitation=5)[:sample_size]:
print(a_trial_dir)
pop_phe_lists_list.append(
self.get_pop_phe_lists_of_a_trial(a_trial_dir,
starting_gen,
ending_gen,
the_interval=the_interval))
return pop_phe_lists_list
def get_avg_edge_num_in_each_generation_of_an_exp(self,
exp_path,
with_stdev=False,
dir_num=-1):
trial_dirs = fp.get_immediate_subdirectories(exp_path)
exp_edge_nums = []
for a_trial_dir in trial_dirs[:dir_num]:
a_dir_gen_edge_nums = self.get_average_edge_number_in_each_generation(
a_trial_dir)
exp_edge_nums.append(np.array(a_dir_gen_edge_nums))
exp_edge_nums = np.array(exp_edge_nums)
avg_exp_edge_nums = np.median(exp_edge_nums, axis=0)
if not with_stdev:
return avg_exp_edge_nums
else:
std_exp_edge_nums = np.std(exp_edge_nums, axis=0)
return avg_exp_edge_nums, std_exp_edge_nums
def get_module_values_of_an_experiment(self,
a_path,
generation=-1,
draw_modularity=False,
draw_grn=False,
draw_gen_avg_modularity=False,
louvain=False,
no_self_edge=False):
sub_directories = get_immediate_subdirectories(a_path)
all_modularities = []
final_module_value_list = []
for a_directory in sub_directories:
phenotypes = self.get_grn_phenotypes(a_directory)
if len(phenotypes) > 0:
target_phenotype = phenotypes[generation]
if no_self_edge:
side_grn_size = int(math.sqrt(len(target_phenotype)))
for i in range(side_grn_size):
target_phenotype[i * side_grn_size + i] = 0
a_grn = self.generate_directed_grn(target_phenotype)
final_module_value_list.append(
self.get_modularity_value(a_grn, louvain))
if draw_modularity:
modularity_values = self.get_grn_modularity_values(
a_directory, louvain)
all_modularities.append(modularity_values)
save_a_list_graph(modularity_values, 'Modularity',
a_directory, 'modularity.png')
sum_of_modularity = map(sum, zip(*all_modularities))
avg_of_modularity = [
x / len(all_modularities) for x in sum_of_modularity
]
if draw_gen_avg_modularity:
save_a_list_graph(avg_of_modularity,
'Average Modularity', a_path,
'average_modularity.png')
if draw_grn:
self.draw_a_grn(a_grn,
is_to_save=True,
save_path=a_directory,
file_name='graph.png',
with_labels=True)
return final_module_value_list
from ClimbingAnalyzer import ClimbingAnalyzer
from file_processor import get_immediate_subdirectories
main_path = '/Users/qin/Software-Engineering/Chin-GA-Project/generated-outputs/old-data-by-20-01-18/' \
'soto-with-perturbation-recording/'
paths = get_immediate_subdirectories(main_path)
for a_path in paths[:1]:
climbing_analyzer = ClimbingAnalyzer()
climbing_analyzer.plot_blocks(climbing_analyzer.generate_blocks(a_path),
True, a_path, 'cheating_paths.png')
def __init__(self, path=None, neighbor_size=100):
self.path = path
self.grn_plotter = GRNPlotter()
self.directories = get_immediate_subdirectories(self.path)
self.grn_edge_mutator = GRNEdgeMutator()
self.neighbor_size = neighbor_size
from file_processor import count_number_of_edges
from ModularityDominanceAnalyzer import ModularityDominanceAnalyzer
from file_processor import get_immediate_subdirectories
from GRNPlotter import GRNPlotter
working_path = '/Users/qin/Software-Engineering/Chin-GA-Project/thesis-data/' \
'combined-chin-crossover'
omega = ModularityDominanceAnalyzer()
beta = GRNPlotter()
most_modular_edge_numbers = []
least_modular_edge_numbers = []
for a_directory in get_immediate_subdirectories(working_path):
phes = beta.get_grn_phenotypes(a_directory)
print len(phes)
most_modular_tuple = omega.get_the_most_modular_individual_in_the_fittest_networks(
a_directory, 501)
least_modular_tuple = omega.get_the_least_modular_individual_in_the_fittest_networks(
a_directory, 501)
most_modular_edge_numbers.append(
count_number_of_edges(phes[most_modular_tuple[0]]))
least_modular_edge_numbers.append(
count_number_of_edges(phes[least_modular_tuple[0]]))
print most_modular_edge_numbers
print least_modular_edge_numbers
