def oneD_random_comparison(N=10,average_in_degree=1): p = (float(N)* float(average_in_degree))/float(sum(range((N-1),0,-1))) oneD_box = models.box_model(1, N, p) DAG = oneD_box[0] # nx.draw_circular(DAG, with_labels=False, node_colour ='k', node_size=50, node_color = 'k', width=0.5) #nx.draw_networkx(G, pos=random, with_labels=False, node_colour ='k', node_size=50, node_color = 'k', width=0.5) # plt.show() # display figure return oneD_box
def oneD_random_comparison_by_degree(N=10,average_in_degree=1): """ This is the oneD box with probability of edge presence p, but we set average_in_degree instead of p. This calculation could be wrong, but I'm pretty confident! """ p = (float(N)* float(average_in_degree))/float(sum(range((N-1),0,-1))) oneD_box = models.box_model(1, N, p) return oneD_box
def mm_dim_with_removal(number_of_trials, number_of_probabilities_considered, N, D, filename): """ arguments: number_of_trials for each probability, output data is averaged over this. number_of_probabilities_considered = integer: number of data points N = integer: number of nodes in network D = integer: dimension of network filename = string: output file path e.g. './testing.txt' """ start_time = time.time() #start clock myfile = open(filename, 'w') p_step = 1.0/number_of_probabilities_considered #define size of step in probability (prob = prob that edge is removed given it's causally allowed) myfile.write(str(D)+"D box w/ random removal prob p, and longest path l. Number trials averaged over=" + str(number_of_trials) + " N="+ str(N) + '\n') myfile.write('p' + '\t' + 'mm(p)' +'\t' + 'std error' + '\n') #send column headings to output file #initialize lists for each output variable p_list = [] mm_average_list = [] mm_std_error_list = [] p_range = np.arange(0.0,1.0+p_step,p_step) #defines list of p values to loop over for p in p_range: #Loop over x, where x=10^p, so we get more points around prob's closer to 1 and can see phase transition-y behavior more clearly. #initialize lists for each quantity for which we require an individual value to be stored after every trial (e.g. for calculations stats) mm_list = [] for _ in range(int(number_of_trials)): model = models.box_model(D, N,1-p) #create model with prob of no edge given edge is causally allowed = p DAG_with_removal = model[0] #networkx DAG object from above model mm_dimension = mm.MM_dimension(DAG = DAG_with_removal) mm_list.append(mm_dimension) statistics = stats(mm_list) mm_average = statistics[3] #calculates average lp over all trials for the current probability statistics = stats(mm_list) mm_std_error = statistics[0] p_list.append(p) mm_average_list.append(mm_average) mm_std_error_list.append(mm_std_error) myfile.write(str(p)+ '\t' + str(mm_average) + '\t' + str(mm_std_error) + '\n') print "finished ", p , "probability" elapsed = (time.time() - start_time) #calculate time for method completion print "finished. Time elapsed = " , elapsed return [p_list, mm_average_list, mm_std_error_list]
def lp_with_removal(number_of_trials, number_of_probabilities_considered, N, D, filename): """ arguments: number_of_trials for each probability, output data is averaged over this. number_of_probabilities_considered = integer: number of data points N = integer: number of nodes in network D = integer: dimension of network filename = string: output file path e.g. './testing.txt' """ start_time = time.time() #start clock myfile = open(filename, 'w') p_step = 10.0/number_of_probabilities_considered #define size of step in probability (prob = prob that edge is removed given it's causally allowed) myfile.write(str(D)+"D box w/ random removal prob p, and longest path l. Number trials averaged over=" + str(number_of_trials) + " N="+ str(N) + '\n') myfile.write('p' + '\t' + 'l(p)' +'\t' + 'std error' + '\n') #send column headings to output file #initialize lists for each output variable p_list = [] lp_average_list = [] lp_std_error_list = [] x_range = np.arange(1.0,10.0+p_step,p_step) #defines list of x values to loop over for x in x_range: #Loop over x, where x=10^p, so we get more points around prob's closer to 1 and can see phase transition-y behavior more clearly. #initialize lists for each quantity for which we require an individual value to be stored after every trial (e.g. for calculations stats) lp_list = [] p = math.log10(x) for _ in range(int(number_of_trials)): model = models.box_model(D, N,1-p) #create model with prob of no edge given edge is causally allowed = p DAG_with_removal = model[0] #networkx DAG object from above model tr_DAG_with_removal = tr.trans_red(DAG_with_removal) #transitively reduce DAG - doesn't effect lp or MM dimension, DOES MIDPOINT SCALING extremes = model[1] #returns list of extremes from model if nx.has_path(DAG_with_removal, extremes[1], extremes[0]): longest_path_between_extremes = dl.lpd(tr_DAG_with_removal, extremes[1],extremes[0]) #calculate longest path between extremes length_of_longest_path = longest_path_between_extremes[2] #save length of longest path between extremes else: length_of_longest_path=0 #if no path between extremes, longest path = 0 is physical. lp_list.append(length_of_longest_path) statistics = stats(lp_list) lp_average = statistics[3] #calculates average lp over all trials for the current probability if p == 0.0: lp_0 = lp_average #calculate average longest path for p==0 and use as normalization constant lp_average = lp_average / lp_0 #normalize average longest paths so can compare results of different dimensions for i in range(len(lp_list)): lp_list[i] /= lp_0 #normalize longest paths (need to do this for std error calculation) statistics = stats(lp_list) lp_std_error = statistics[0] p_list.append(p) lp_average_list.append(lp_average) lp_std_error_list.append(lp_std_error) myfile.write(str(p)+ '\t' + str(lp_average) + '\t' + str(lp_std_error) + '\n') print "finished ", p , "probability" elapsed = (time.time() - start_time) #calculate time for method completion print "finished. Time elapsed = " , elapsed return [p_list, lp_average_list, lp_std_error_list]
def ms_dim_with_removal(number_of_trials, number_of_probabilities_considered, N, D, filename): """ arguments: number_of_trials for each probability, output data is averaged over this. number_of_probabilities_considered = integer: number of data points N = integer: number of nodes in network D = integer: dimension of network filename = string: output file path e.g. './testing.txt' """ start_time = time.time() #start clock myfile = open(filename, 'w') p_step = 1.0/number_of_probabilities_considered #define size of step in probability (prob = prob that edge is removed given it's causally allowed) myfile.write(str(D)+"D box w/ random removal prob p, and longest path l. Number trials averaged over=" + str(number_of_trials) + " N="+ str(N) + '\n') myfile.write('p' + '\t' + 'ms dimension (p)' +'\t' + 'std error' + '\n') #send column headings to output file #initialize lists for each output variable p_list_for_ms = [] ms_average_list = [] ms_std_error_list = [] p_range = np.arange(0.0,1.0+p_step,p_step) for p in p_range: #Loop over x, where x=10^p, so we get more points around prob's closer to 1 and can see phase transition-y behavior more clearly. #initialize lists for each quantity for which we require an individual value to be stored after every trial (e.g. for calculations stats) ms_list = [] ms_diff_sq_list = [] ms_failed_trials = 0 ms_sum = ms_average = 0.0 for _ in range(int(number_of_trials)): model = models.box_model(D, N,1-p) #create model with prob of no edge given edge is causally allowed = p DAG_with_removal = model[0] #networkx DAG object from above model tr_DAG_with_removal = tr.trans_red(DAG_with_removal) #transitively reduce DAG - doesn't effect lp or MM dimension, DOES MIDPOINT SCALING extremes = model[1] #returns list of extremes from model if nx.has_path(DAG_with_removal, extremes[1], extremes[0]): longest_path_between_extremes = dl.lpd(tr_DAG_with_removal, extremes[1],extremes[0]) #calculate longest path between extremes longest_path = longest_path_between_extremes[1] length_of_longest_path = longest_path_between_extremes[2] #save length of longest path between extremes else: length_of_longest_path=0 #if no path between extremes, longest path = 0 is physical. if length_of_longest_path > 2: ms_dimension = ms.mpsd(DAG_with_removal, longest_path)[0] #need to trans red DAG first as otherwise lp method does not return the correct longest path. James said he'd sorted this? else: ms_dimension = 0 ms_failed_trials += 1 ms_list.append(ms_dimension) if len(ms_list)<number_of_trials: ms_list.append(None) ms_sum = sum(ms_list) if (number_of_trials - ms_failed_trials - 1)>0: ms_average = ms_sum/float(number_of_trials-ms_failed_trials) else: ms_average=None ms_diff_sq_sum = 0.0 if (number_of_trials - ms_failed_trials - 1)>0: for i in range(number_of_trials - ms_failed_trials): ms_diff_sq_list.append((ms_list[i] - ms_average)**2) ms_diff_sq_sum += ms_diff_sq_list[i] ms_std_dev = math.sqrt(ms_diff_sq_sum/float(number_of_trials - ms_failed_trials -1)) ms_std_error = ms_std_dev/math.sqrt(float(number_of_trials - ms_failed_trials)) else: ms_std_error = 0 p_list_for_ms.append(p) ms_average_list.append(ms_average) ms_std_error_list.append(ms_std_error) myfile.write(str(p)+ '\t' + str(ms_average) + '\t' + str(ms_std_error) + '\n') clean = clean_for_plotting(ms_average_list,p_list_for_ms, ms_std_error_list) ms_average_list = clean[0] p_list_for_ms = clean[1] ms_std_error_list = clean[2] print "finished ", p , "probability" elapsed = (time.time() - start_time) #calculate time for method completion print "finished. Time elapsed = " , elapsed return [p_list_for_ms, ms_average_list, ms_std_error_list]
def oneD_random_probabilistic(N,p): oneD_box = models.box_model(1, N, p) return oneD_box
def oneD_random_comparison(N=10,average_in_degree=1): p = (float(N)* float(average_in_degree))/float(sum(range((N-1),0,-1))) oneD_box = models.box_model(1, N, p) return oneD_box
return[std_error, std_dev, list_sum, list_average] for D in [1,2,3,4,10]: myfile = open(str(D)+'how many longest paths?', 'w') myfile.write('N' + '\t' + 'L_scale=N^1/D'+ '\t'+ 'average lp length'+ '\t'+'std err'+ '\t'+ 'average no. lp'+ '\t'+'std err' +'\n') start_time = time.time() trials = 1000 N_list = [] for N in range(0,105,5): lp_length_list = [] j_list = [] for trial in range(trials): # model = models.COd(2, N) model = models.box_model(D, N) DAG = model[0] extremes = model[1] tr_DAG = tr.trans_red(DAG) lp = dl.lpd(tr_DAG, extremes[1], extremes[0]) length_lp = lp[2] lp_length_list.append(length_lp) j=0 paths_list = list(nx.all_simple_paths(tr_DAG, extremes[1], extremes[0], cutoff=length_lp+1)) for i in range(len(paths_list)): if len(paths_list[i])==length_lp+1: j+=1 j_list.append(j)