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)
