def persistent(self): """ This method is used to create dionysus persistent homology implementation of given vectors :return: dionysus diagrams """ vectors = self._get_vectors() f_lower_star = dn.fill_freudenthal(vectors) p = dn.homology_persistence(f_lower_star) dgms = dn.init_diagrams(p, f_lower_star) return dgms
h1 = np.asarray(h1) h0 = h0.reshape((-1, 2)) h1 = h1.reshape((-1, 2)) return [h0, h1] PI_null_images = [] PI_one_images = [] for i in range(images.shape[0]): print(i) f_lower_star = d.fill_freudenthal(images[i, :, :, 0].astype(float)) f_upper_star = d.fill_freudenthal(images[i, :, :, 0].astype(float), reverse=True) p = d.homology_persistence(f_lower_star) dgms_temp = d.init_diagrams(p, f_lower_star) h0_temp = homology_persistent_diagrams(dgms_temp)[0] h1_temp = homology_persistent_diagrams(dgms_temp)[1] pim = PersImage(pixels=[20, 20], spread=1) PI_0_temp = pim.transform(h0_temp[1:, :]) PI_1_temp = pim.transform(h1_temp) PI_null_images.append(PI_0_temp) PI_one_images.append(PI_1_temp) PI_null_images = np.array(PI_null_images, dtype=np.float32) PI_null_images = PI_null_images.reshape((-1, 20, 20, 1)) # reshape PI_null_images = PI_null_images / (PI_null_images.max() / 255.0) # normalize PI_one_images = np.array(PI_one_images, dtype=np.float32) PI_one_images = PI_one_images.reshape((-1, 20, 20, 1)) # reshape PI_one_images = PI_one_images / (PI_one_images.max() / 255.0) # normalize
############################## #Compute Persistence Diagrams# prime = 23 maxscale = float(sys.argv[3]) #Choose the prime base for the coefficient field that we use to construct the persistence cohomology. threshold = float(sys.argv[2]) print('Base coefficient field: Z/', prime, 'Z', sep='') print('Maximal scale:', float(sys.argv[3])) print('Persistence threshold for selecting significant cocyles:', threshold, '\n') vr = dionysus.fill_rips(dataset, 2, float(sys.argv[3])) #Vietoris-Rips complex cp = dionysus.cohomology_persistence(vr, prime, True) #Create the persistent cohomology based on the chosen parameters. dgms = dionysus.init_diagrams(cp, vr) #Calculate the persistent diagram using the designated coefficient field and complex. now = datetime.datetime.now() print('End Time (VR-computation):', now.strftime("%Y-%m-%d %H:%M:%S")) ###Plot the barcode and diagrams using matplotlib incarnation within Dionysus2. This mechanism is different in Dionysus. #Plots of persistence barcodes of Vietoris-Rips complex for dimension 0 and 1. fig = plt.figure(figsize=(5, 5), dpi=100) plt.title('Persistence Barcode for dim 0') dionysus.plot.plot_bars(dgms[0], show=True) pdf.savefig(fig) fig = plt.figure(figsize=(5, 5), dpi=100) plt.title('Persistence Barcode for dim 1') dionysus.plot.plot_bars(dgms[1], show=True) pdf.savefig(fig) plt.close('all')
# vim: ft=python foldmethod=marker foldlevel=0 import dionysus as d #---# simplices = [([2], 4), ([1, 2], 5), ([0, 2], 6), ([0], 1), ([1], 2), ([0, 1], 3)] f = d.Filtration() for vertices, time in simplices: f.append(d.Simplex(vertices, time)) f.sort() for s in f: print(s) #var> f #---# #var> f m = d.homology_persistence(f) #chk> #---# dgms = d.init_diagrams(m, f) print(dgms) #var> dgms
D = 20 #Here is the data insertion part def sample_spherical(npoints, ndim=D): vec = np.random.randn(ndim, npoints) vec /= np.linalg.norm(vec, axis=0) return vec dat1 = np.array(sample_spherical(100).T) vr = dionysus.fill_rips(dat1, 2, 10) #Vietoris-Rips complex cp = dionysus.cohomology_persistence(vr, prime, True) #Create the persistent cohomology dgms = dionysus.init_diagrams( cp, vr ) #Calculate the persistent diagram using the designated coefficient field. #record for plottings.. A = np.array([0, 0, 1, 1]) for thres in [0, 0.025, 0.05, 0.1, 0.2]: #######Thresholding the features on the persistent diagrams describing persistent cohomology of VR complex(CC) dgms_tmp = denoise_dgm(dgms, thres) #thresholding CC diagrams dgms_base_0 = dionysus._dionysus.Diagram( ) #take persistent points of dim 0 dgms_base_1 = dionysus._dionysus.Diagram( ) #take persistent points of dim 1 #pybind issue, need to be correct instead of succint. for itr in range(len(dgms_tmp[0])): dgms_base_0.append(dgms_tmp[0][itr]) for itr in range(len(dgms_tmp[1])):
ax.set_xlim(dims[0][0],dims[0][1]) ax.set_ylim(dims[1][0],dims[1][1]) ax.set_zlim(dims[2][0],dims[2][1]) ax.scatter(sphere_data[:,0],sphere_data[:,1],sphere_data[:,2]) ax.set_aspect("equal") plt.show() """ computing homology """ #VR filtration TDA test_f = d.fill_rips(TDA_data, 2, 10.) p = d.homology_persistence(test_f) dgms = d.init_diagrams(p, test_f) #scatters d.plot.plot_diagram(dgms[0]) d.plot.plot_diagram(dgms[1]) plt.show() #bars d.plot.plot_bars(dgms[0]) plt.show() d.plot.plot_bars(dgms[1]) plt.show() #alpha filtration TDA
ax.scatter(xs=X[:, 0], ys=X[:, 1], zs=X[:, 2], s=10, c='b') plt.title('Scatter plot of data points') pdf.savefig(fig) # The persistent cohomology of $X$ is in the plot. As expected from the dataset, the $1$-dimensional persistent cohomology # of $X$ has one prominent topological feature. # In[5]: prime = 23 #choose the prime base for the coefficient field that we use to construct the persistence cohomology. vr = dionysus.fill_rips(X, 2, 2.) #Vietoris-Rips complex cp = dionysus.cohomology_persistence( vr, prime, True) #Create the persistent cohomology based on the chosen parameters. dgms = dionysus.init_diagrams( cp, vr ) #Calculate the persistent diagram using␣ the designated coefficient field and complex. # In[6]: with PdfPages('fig_cc-pca_dataset_ph.pdf') as pdf: fig = plt.figure(figsize=(4, 4), dpi=100) plt.xlim([0, 2]) plt.yticks([]) plt.title('Barcode(dim 1) of data points') dionysus.plot.plot_bars(dgms[1], show=True) #dionysus.plot.plot_diagram(dgms[1], show=True) #dionysus.plot.plot_diagram(dgms[0], show=True) #Plot the barcode and diagrams using matplotlib incarnation within Dionysus2. This mechanism is different in Dionysus. pdf.savefig(fig)
import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from sklearn import manifold, datasets n_points = 100 Y, color = datasets.make_circles(n_points, random_state=1, factor=0.5, noise=0) fig, ax = plt.subplots() ax.scatter(Y[:,0], Y[:,1], c=color, cmap=plt.cm.Spectral) # plt.show() import dionysus as d max_epsilon = 1 k_skeleton = 3 f = d.fill_rips(Y, k_skeleton, max_epsilon) p = d.homology_persistence(f) dgms = d.init_diagrams(p, f) fig, axes = plt.subplots(nrows=2, ncols=2) d.plot.plot_diagram(dgms[0], ax=axes[0,0], show=False) d.plot.plot_diagram(dgms[1], ax=axes[0,1], show=False) d.plot.plot_bars(dgms[0], ax=axes[1,0], show=False) d.plot.plot_bars(dgms[1], ax=axes[1,1], show=False) axes[0,0].set_title("Dimension 0") axes[0,1].set_title("Dimension 1") plt.show()
for cell in grid: weight += [max([pw[n] for n in cell])] dense += [max([pd[n] for n in cell])] fil_weight = [] for v_f, v_rho in zip(weight, dense): if v_rho <= 0.4: fil_weight += [v_f] else: fil_weight += [Mf] f = d.Filtration() for cell, level in zip(grid, fil_weight): f.append(d.Simplex(cell, level)) f.sort() res = d.homology_persistence(f) dgm = d.init_diagrams(res, f) for i, dg in enumerate(dgm): for pt in dg: if pt.death - pt.birth > 0.1: print(i, pt.birth, pt.death) for l in range(2, 3): rho_0 = mrho + l * rstep epsilon = 0.3 epsilon0 = 0.4 print("rho_0", rho_0) estep = epsilon * (1 - epsilon0) / 6 for k in range(7): print("epsilon:", epsilon) for n in range(17): a = mf * (16 - n) / 16 + Mf * n / 16
def compute_layer_mask(self, x, hiddens, subgraph_indices=[0], percentile=0): f,nm = self.compute_induced_filtration(x[0], hiddens, percentile=percentile) m = dion.homology_persistence(f) dgms = dion.init_diagrams(m,f) subgraphs = {} dion.plot.plot_diagram(dgms[0],show=False) plt.savefig('/home/tgebhart/projects/homo_explico/logdir/experiments/alexnet_vis/plt_3.png', format='png') plt.close() # compute ones tensors of same hidden dimensions muls = [torch.zeros(x.reshape((x.shape[0],-1)).shape)] for h in hiddens: print('h shape', h.reshape((h.shape[0],-1)).shape) muls.append(torch.zeros(h.reshape((h.shape[0],-1)).shape)) fac = 1.0 for i,c in enumerate(m): if len(c) == 2: if f[c[0].index][0] in subgraphs: subgraphs[f[c[0].index][0]].add_edge(f[c[0].index][0],f[c[1].index][0], weight=f[i].data) else: eaten = False for k, v in subgraphs.items(): if v.has_node(f[c[0].index][0]): v.add_edge(f[c[0].index][0], f[c[1].index][0], weight=f[i].data) eaten = True break if not eaten: g = nx.Graph() g.add_edge(f[c[0].index][0], f[c[1].index][0], weight=f[i].data) subgraphs[f[c[0].index][0]] = g # I don't think we need this composition. Disjoint subgraphs are fine. # subgraph = nx.compose_all([subgraphs[k] for k in list(subgraphs.keys())[:thru]]) ids = dict((v,k) for k,v in nm.items()) ks = list(subgraphs.keys()) print('KS: ',ks) ks_sub = [ks[s] for s in subgraph_indices] # lifetimes = np.empty(thru) # t = 0 # for pt in dgms[0]: # if pt.death < float('inf'): # lifetimes[t] = pt.birth - pt.death # t += 1 # if t >= thru: # break # max_lifetime = max(lifetimes) # min_lifetime = min(lifetimes) for k in ks_sub: for e in subgraphs[k].edges(data=True): n1 = ids[e[0]] n2 = ids[e[1]] # allow the outcoming activation from that node at that channel (idx 1) if n1[1] > 0: muls[n1[0]][n1[1],n1[2]] = fac else: muls[n1[0]][n1[2]] = fac if n2[1] > 0: muls[n2[0]][n2[1],n2[2]] = fac else: muls[n2[0]][n2[2]] = fac return muls
def GCC2(dataset,threshold,maxscale,CEthreshold=1e-5,lp=1,lq=2,Nsteps=1000,lambda_coef=0.5,PLOT=True): sys.argv = np.asarray(['GCC2_fun.GCC2','dataset',threshold,maxscale,CEthreshold,lp,lq,Nsteps,lambda_coef]) return_list = [] print('Number of arguments:', str(len(sys.argv)), 'arguments.') if len(sys.argv)!=8 and len(sys.argv)!=9: print(""" ### usage: GCC2(dataset,threshold,maxscale,CEthreshold=1e-5,lp=1,lq=2,Nsteps=1000,lambda_coef=0.5) ###[dataset] The dataset you want to analyze using circular coordinates in numpy array. The cols of the array are dimensions/variables; the rows of the array are samples. ###[threshold] The threhold on persistence which we use to select those significant cocyles from all cocycles constructed from the Vietoris-Rips complex built upon the data. If negative integer M, the 1-cocycles with the 1,2,...,M-th largest persistence will be picked. This option would override the threshold option. ###[CEthreshold] The threshold that we use to determine the constant edges. When the coordinate functions' values changed below this threshold, we consider it as a constant edge and plot it. ###[maxscal] The maximal scale at which we shall construct the Vietoris-Rips complex for circular coordinate computation. ###[lp] [lq] The generalized penalty function is in form of (1-lambda_parameter)*L^[lp]+lambda_parameter*L^[lq]. ###[Nsteps] How many iterations you want to run in the tensorflow optimizer to obtain our circular coordinates? If negative number, no optimization would be executed. ###[lambda] This is a float parameter, if supplied, then only that lambda in the genealized coordinate would be calculated. ###Functionality of this code. ####Part1: Construct the Vietoris-Rips complex built upon the data and associated persistence diagrams and barcodes. #####Scatter plot and associated persistence diagrams and barcodes, with significant topological features selected. ####Part2: Output the circular coordinates with different penalty functions. ####Part3: Output the embeddings with different penalty functions.""") return return_list print('Argument List:', str(sys.argv),'\n') filenam=sys.argv[1] print('Data file:', filenam) #From Python_code/utils.py def coboundary_1(vr, thr): D = [[],[]] data = [] indexing = {} ix = [0]*2 for s in vr: if s.dimension() != 1: continue elif s.data > thr: #break continue indexing.setdefault(s.dimension(),{}) indexing.setdefault(s.dimension()-1,{}) if not s in indexing[s.dimension()]: indexing[s.dimension()][s] = ix[s.dimension()] ix[s.dimension()] += 1 for dat, k in enumerate(s.boundary()): if not k in indexing[s.dimension()-1]: indexing[k.dimension()][k] = k[0] ix[k.dimension()] += 1 D[0].append(indexing[s.dimension()][s]) #rows D[1].append(indexing[k.dimension()][k]) #cols data.append(1. if dat % 2 == 0 else -1.) return sp.sparse.csr_matrix((data, (D[0], D[1]))), indexing def optimizer_inputs(vr, bars, cocycle, init_z, prime, thr): bdry,indexing = coboundary_1(vr,thr) n, m = bdry.shape # edges X nodes #----------------- l2_cocycle = [0]*len(init_z) #reorganize the coordinates so they fit with the coboundary indices for i, coeff in enumerate(init_z): l2_cocycle[i] = coeff l2_cocycle = np.array(l2_cocycle) #----------------- f = np.zeros((n,1)) # cocycle we need to smooth out, reorganize to fit coboundary for c2 in cocycle: if c2.element<(prime//2): f[indexing[1][vr[c2.index]]] += c2.element else: f[indexing[1][vr[c2.index]]] += c2.element-prime return l2_cocycle,f,bdry #Dionysus2 only. #This code is composed in such way that it produces the whole thing in a single pdf file. #dataset = np.loadtxt(filenam) #from matplotlib.backends.backend_pdf import PdfPages title_str='Circular Coordinates with Generalized Penalty Functions' # Create the PdfPages object to which we will save the pages: # The with statement makes sure that the PdfPages object is closed properly at the end of the block, even if an Exception occurs. os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' filenam = os.path.splitext(filenam)[0] pdfnam = filenam+'_output.pdf' print('Output file:', pdfnam,'\n') now = datetime.datetime.now() print('>>>>>>Start Time(VR computation):',now.strftime("%Y-%m-%d %H:%M:%S")) ############################## #Scatter plots for datapoints# if PLOT: fig = plt.figure(figsize=(5,5), dpi=100) plt.xlabel('X') plt.ylabel('Y') plt.gca().set_aspect('equal', 'datalim') plt.scatter(dataset.T[0,:],dataset.T[1,:],s=10, c='b') plt.axis('equal') plt.title('Scatter plot of data points') #pdf.savefig(fig) # # ############################## ############################## #Compute Persistence Diagrams# prime = 23 maxscale = float(sys.argv[3]) #Choose the prime base for the coefficient field that we use to construct the persistence cohomology. threshold = float(sys.argv[2]) print('Base coefficient field: Z/', prime ,'Z',sep='') print('Maximal scale:', float(sys.argv[3])) print('Persistence threshold for selecting significant cocyles:',threshold) vr = dionysus.fill_rips(dataset, 2, float(sys.argv[3])) #Vietoris-Rips complex cp = dionysus.cohomology_persistence(vr, prime, True) #Create the persistent cohomology based on the chosen parameters. dgms = dionysus.init_diagrams(cp, vr) #Calculate the persistent diagram using the designated coefficient field and complex. now = datetime.datetime.now() print('>>>>>>End Time (VR-computation):',now.strftime("%Y-%m-%d %H:%M:%S")) ###Plot the barcode and diagrams using matplotlib incarnation within Dionysus2. This mechanism is different in Dionysus. if PLOT: #Plots of persistence barcodes of Vietoris-Rips complex for dimension 0 and 1. fig = plt.figure(figsize=(5,5), dpi=100) plt.title('Persistence Barcode for dim 0') dionysus.plot.plot_bars(dgms[0], show=True) #pdf.savefig(fig) fig = plt.figure(figsize=(5,5), dpi=100) plt.title('Persistence Barcode for dim 1') dionysus.plot.plot_bars(dgms[1], show=True) #pdf.savefig(fig) plt.show() #Plots of persistence diagrams of Vietoris-Rips complex for dimension 0 and 1. fig = plt.figure(figsize=(5,5), dpi=100) plt.title('Persistence Diagram for dim 0') dionysus.plot.plot_diagram(dgms[0], show=True) #pdf.savefig(fig) fig = plt.figure(figsize=(5,5), dpi=100) plt.title('Persistence Diagram for dim 1') dionysus.plot.plot_diagram(dgms[1], show=True) #pdf.savefig(fig) plt.show() ######Select and highlight the features selected. bars = [bar for bar in dgms[1] ] #Choose cocycle that persist at least threshold we choose. cocycles = [cp.cocycle(bar.data) for bar in bars] #Sort the list 'cocycles' by the persistence corresponding to each bar cocycles_persistence = [bar.death-bar.birth for bar in bars] #print(cocycles_persistence) cocycles_ind = np.argsort(-np.asarray(cocycles_persistence), axis=-1, kind=None, order=None) cocycles = [cocycles[i] for i in cocycles_ind] bars = [bars[i] for i in cocycles_ind] if threshold<0: leadings = int(np.abs(threshold)) #Override threshold option threshold = 0 print('\n>>>>>>Threshold overridden, the 1-cocyles with the ',leadings,' largest persistence would be selected for computation.') cocycles = cocycles[0:leadings] bars = bars[0:leadings] else: bars = [bar for bar in dgms[1] if bar.death-bar.birth > threshold and bar.death-bar.birth < float(sys.argv[3]) ] cocycles = [cp.cocycle(bar.data) for bar in bars] print('>>>>>>Selected significant features:') for B_Lt in bars: print(B_Lt,'\tpersistence = ',B_Lt.death-B_Lt.birth) #################### #PersistenceBarcode# if PLOT: #Red highlight ***ALL*** cocyles that persist more than threshold value on barcode, when more than one cocyles have persisted over threshold values, this plots the first one. fig = plt.figure(figsize=(5,5), dpi=100) dionysus.plot.plot_bars(dgms[1], show=False) Lt1 = [[bar.birth,bar.death] for bar in bars] #Lt1 stores the bars with persistence greater than the [threshold]. Lt1_tmp = [[bar.birth,bar.death] for bar in dgms[1] ] for Lt in Lt1: loc=0 target=Lt for g in range(len(Lt1_tmp)): if Lt1_tmp[g][0] == target[0] and Lt1_tmp[g][1] == target[1]: loc=g #Searching correct term plt.plot([Lt[0],Lt[1]],[loc,loc],'r-') #print(Lt) plt.title('Selected cocycles on barcodes (red bars)') #pdf.savefig(fig) plt.show() # # #################### #################### #PersistenceDiagram# if PLOT: #Red highlight ***ALL*** cocyles that persist more than threshold value on diagram. fig = plt.figure(figsize=(5,5), dpi=100) dionysus.plot.plot_diagram(dgms[1], show=False) Lt2 = [[point.birth,point.death] for point in bars ] #Lt2 stores the (multi-)points with persistence greater than the [threshold]. for Lt in Lt2: plt.plot(Lt[0],Lt[1],'ro') plt.title('Selected cocycles on diagram (red points)') plt.figure(figsize=(5,5), dpi=100) #pdf.savefig(fig) plt.show() # # #################### # # ############################## ############################## # Visualization of GCC # overall_coords = np.zeros(dataset.shape[0], dtype = float) #from Python_code import utils toll = float(sys.argv[4])#tolerance for constant edges. print('\nConstant edges, with coordinates difference <',toll) print('Optimizer maximal iteration steps=',int(sys.argv[7])) lp=int(sys.argv[5]) lq=int(sys.argv[6]) now = datetime.datetime.now() print('>>>>>> Start Time (GCC computation):',now.strftime("%Y-%m-%d %H:%M:%S")) if len(sys.argv)>=9: lambda_list = [float(sys.argv[8])] else: lambda_list = [0,0.5,1] for lambda_parameter in lambda_list: print('>>>>>> lambda = ',lambda_parameter,'. => Analysis of Circular coordinates \n (mod {} - {}*L{} + {}*L{})'.format(prime,1-lambda_parameter,lp,lambda_parameter,lq)) embedding = [] if PLOT: fig = plt.figure(figsize=(5,5), dpi=100) plt.text(0.3,0.5,'Analysis of Circular coordinates \n (mod {} - {}*L{} + {}*L{})'.format(prime,1-lambda_parameter,lp,lambda_parameter,lq),transform=plt.gca().transAxes) #pdf.savefig(fig) plt.show() print('Penalty function =>',(1-lambda_parameter),'*L^',lp,"+",lambda_parameter,"*L^",lq,sep='') for g in range(len(cocycles)): chosen_cocycle = cocycles[g] chosen_bar = bars[g] #print(chosen_cocycle,chosen_bar) NEW_THRESHOLD = max([vr[c2.index].data for c2 in chosen_cocycle]) vr_L2 = dionysus.Filtration([s for s in vr if s.data <=NEW_THRESHOLD]) coords = dionysus.smooth(vr_L2, chosen_cocycle, prime) l2_cocycle,f,bdry = optimizer_inputs(vr, bars, chosen_cocycle, coords, prime, NEW_THRESHOLD) l2_cocycle = l2_cocycle.reshape(-1, 1) ##It does not seem to work to have double invokes here... B_mat = bdry.todense() z_init = l2_cocycle z = tf.Variable(z_init, name='z', trainable=True, dtype=tf.float64) trainable_variables = [z] def loss_function(): cost_z = (1-lambda_parameter)*tf.math.pow( tf.math.reduce_sum( tf.math.pow( tf.abs(f - tf.linalg.matmul(B_mat,z) ),lp ) ), 1/lp) + lambda_parameter*tf.math.pow( tf.math.reduce_sum( tf.math.pow( tf.math.abs(f - tf.linalg.matmul(B_mat,z) ),lq ) ), 1/lq) return cost_z #print(B_mat.shape) #l2_cocycle=np.zeros((B_mat.shape[1],1)) tf.random.set_seed(1) optimizer = tf.optimizers.Adam(learning_rate=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-7, amsgrad=False) #optimizer = tf.keras.optimizers.SGD(learning_rate=1e-4) #Not recommended if you are not using tensorflow-gpu, may result a different result sometimes. B_mat = tf.Variable(B_mat, name="B_mat", trainable=False, dtype=tf.float64) f = tf.Variable(f, name="f", trainable=False, dtype=tf.float64) if int(sys.argv[7])>0: print('Before optim cost:',loss_function().numpy()) for i in range(int(sys.argv[7])): train = optimizer.minimize(loss_function, var_list=trainable_variables) #err = np.sum(np.abs(z.numpy() - z_init)) #print('>>> step',train.numpy(),' err=',err) print('After optim cost:',loss_function().numpy(),' in ',train.numpy(),' steps') res_tf=z.numpy() else: print('Non-optimized cost:',loss_function().numpy()) res_tf=z_init #print("Absolute differentiation =>",np.sum(np.abs(res_tf-np.asarray(coords) ))) overall_coords=overall_coords+res_tf.T[0,:] color = np.mod(res_tf.T[0,:],1) #print(color) return_list.append(color) if PLOT: fig = plt.figure(figsize=(5,5), dpi=100) plt.scatter(dataset.T[0,:],dataset.T[1,:],s=10, c=color, cmap="hsv",zorder=10) plt.clim(0,1) plt.colorbar() plt.axis('equal') plt.title('Circular coordinates {}-th cocyle (mod {} - {}*L{} + {}*L{})'.format(g+1,prime,1-lambda_parameter,lp,lambda_parameter,lq)) plt.show() edges_constant = [] thr = chosen_bar.birth #####Constatn edges #Want to check constant edges in all edges that were there when the cycle was created for s in vr: if s.dimension() != 1: continue elif s.data > thr: break if abs(color[s[0]]-color[s[1]]) <= toll: edges_constant.append([dataset[s[0],:],dataset[s[1],:]]) edges_constant = np.array(edges_constant) #pdf.savefig(fig) #print('Loop End Time:',now.strftime("%Y-%m-%d %H:%M:%S")) if PLOT: fig = plt.figure(figsize=(5,5), dpi=100) if edges_constant.T!=[]: plt.plot(edges_constant.T[0,:],edges_constant.T[1,:], c='k', alpha=.5) plt.scatter(dataset.T[0,:],dataset.T[1,:],s=10, c=color, cmap="hsv",zorder=10) plt.clim(0,1) plt.colorbar() plt.axis('equal') plt.title('Circular coordinates/constant edges, \n {}-th cocyle (mod {} - {}*L{} + {}*L{})'.format(g+1,prime,1-lambda_parameter,lp,lambda_parameter,lq)) #pdf.savefig(fig) plt.show() color_filenam = filenam+'_CircularCoordinates_'+str(lambda_parameter)+'_'+str(g)+'.txt' np.savetxt(color_filenam,color) print('Penalty function =>',(1-lambda_parameter),'*L^',lp,"+",lambda_parameter,"*L^",lq,' Coordinates=>',color_filenam,sep='') if PLOT: fig = plt.figure(figsize=(5,5), dpi=100) angle = np.arctan(dataset.T[0,:]/dataset.T[1,:]) plt.scatter(angle,color,s=10, c='b',zorder=10) plt.ylim([0,1]) plt.xlim([-np.pi/2,np.pi/2]) plt.title('Correlation plot against angle, \n {}-th cocyle (mod {} - {}*L{} + {}*L{})'.format(g+1,prime,1-lambda_parameter,lp,lambda_parameter,lq)) #pdf.savefig(fig) plt.show() embedding.extend([[np.sin(a) for a in 2*np.pi*color], [np.cos(a) for a in 2*np.pi*color]]) if PLOT: fig = plt.figure(figsize=(5,5), dpi=100) dist2 = np.sqrt(np.power(dataset.T[0,:],2)+np.power(dataset.T[1,:],2)) plt.scatter(dist2,color,s=10, c='b',zorder=10) plt.ylim([0,1]) plt.xlim([0,maxscale]) plt.title('Correlation plot aginst distance, \n {}-th cocyle (mod {} - {}*L{} + {}*L{})'.format(g+1,prime,1-lambda_parameter,lp,lambda_parameter,lq)) #pdf.savefig(fig) plt.show() emb_filenam = filenam+'_Embedding_'+str(lambda_parameter)+'.txt' np.savetxt(emb_filenam, np.array(embedding)) print('Penalty function =>',(1-lambda_parameter),'*L^',lp,"+",lambda_parameter,"*L^",lq,' Embeddings=>',emb_filenam,sep='') #We plot the final circular coordinates with all co-cycles combined. overall_edges_constant = [] overall_thr = float(sys.argv[2]) #For the combined coordinates, we choose the global threshold. for s in vr: if s.dimension() != 1: continue elif s.data > overall_thr: break if abs(overall_coords[s[0]]-overall_coords[s[1]]) <= toll: overall_edges_constant.append([dataset[s[0],:],dataset[s[1],:]]) overall_edges_constant = np.array(overall_edges_constant) if PLOT: #fig = plt.figure(figsize=(5,5), dpi=100) #if overall_edges_constant.T!=[]: # plt.plot(overall_edges_constant.T[0,:],overall_edges_constant.T[1,:], c='k', alpha=.5) #plt.scatter(dataset.T[0,:],dataset.T[1,:],s=10, c=overall_coords, cmap="hsv",zorder=10) #plt.clim(0,1) #plt.colorbar() #plt.axis('equal') #plt.title('Combined circular coordinates/constant edges \n (mod {} - {}*L{} + {}*L{})'.format(prime,1-lambda_parameter,lp,lambda_parameter,lq)) #pdf.savefig(fig) #plt.show() fig = plt.figure(figsize=(5,5), dpi=100) angle = np.arctan(dataset.T[0,:]/dataset.T[1,:]) plt.scatter(angle,overall_coords,s=10, c='b',zorder=10) plt.ylim([0,1]) plt.xlim([-np.pi/2,np.pi/2]) plt.title('Correlation plot \n (mod {} - {}*L{} + {}*L{})'.format(prime,1-lambda_parameter,lp,lambda_parameter,lq)) #pdf.savefig(fig) plt.show() fig = plt.figure(figsize=(5,5), dpi=100) dist2 = np.sqrt(np.power(dataset.T[0,:],2)+np.power(dataset.T[1,:],2)) #print(color) plt.scatter(dist2,color,s=10, c='b',zorder=10) plt.ylim([0,1]) plt.xlim([0,maxscale]) plt.title('Correlation plot aginst distance, \n {}-th cocyle (mod {} - {}*L{} + {}*L{})'.format(g+1,prime,1-lambda_parameter,lp,lambda_parameter,lq)) #pdf.savefig(fig) plt.show() now = datetime.datetime.now() print('>>>>>> End Time (GCC computation):',now.strftime("%Y-%m-%d %H:%M:%S")) return return_list
def EPH_mask_demo(vertex_values, simplices): times = [] t0 = time.time() s2v_lst = [[ sorted(s), sorted([[vertex_values[v], v] for v in s], key=lambda x: x[0]) ] for s in simplices] f_ord = [dionysus.Simplex(s[0], s[1][-1][0]) for s in s2v_lst] #takes max f_ext = [dionysus.Simplex([-1] + s[0], s[1][0][0]) for s in s2v_lst] #takes min ord_dict = {tuple(s[0]): s[1][-1][1] for s in s2v_lst} ext_dict = {tuple([-1] + s[0]): s[1][0][1] for s in s2v_lst} t1 = time.time() times.append(t1 - t0) t0 = time.time() f_ord.sort(key=lambda s: (s.data, len(s))) f_ext.sort(key=lambda s: (-s.data, len(s))) t1 = time.time() times.append(t1 - t0) t0 = time.time() #computes persistence f = dionysus.Filtration([dionysus.Simplex([-1], -float('inf'))] + f_ord + f_ext) m = dionysus.homology_persistence(f) t1 = time.time() times.append(t1 - t0) t0 = time.time() dgms = [[[], []], [[], []], [[], []], [[], []]] #H0ord, H0ext, H1rel, H1ext for i in range(len(m)): dim = f[i].dimension() if m.pair(i) < i: continue # skip negative simplices to avoid double counting if m.pair( i ) != m.unpaired: #should be no unpaired apart from H0 from fictitious -1 vertex pos, neg = f[i], f[m.pair(i)] if pos.data != neg.data: #off diagonal if -1 in pos and -1 in neg: #rel1 dgms[2][0].append(ext_dict[tuple(neg)]) dgms[2][1].append(ext_dict[tuple(pos)]) elif -1 not in pos and -1 not in neg: #ord0 dgms[1][0].append(ord_dict[tuple(pos)]) dgms[1][1].append(ord_dict[tuple(neg)]) else: if dim == 0: #H0ext dgms[0][0].append(ord_dict[tuple(pos)]) dgms[0][1].append(ext_dict[tuple(neg)]) if dim == 1: #H1ext dgms[3][0].append(ext_dict[tuple(neg)]) dgms[3][1].append(ord_dict[tuple(pos)]) t1 = time.time() times.append(t1 - t0) t0 = time.time() dgms = dionysus.init_diagrams(m, f) t1 = time.time() times.append(t1 - t0) return times
def compute_dropouts(self, x, hiddens, thru=2, p=1, dropout_type='static', percentile=0, muls=None, invert=False, mat=None): if dropout_type == 'static': f = self.compute_static_filtration(x, hiddens, percentile=percentile) if dropout_type == 'induced': f = self.compute_induced_filtration(x, hiddens, percentile=percentile, mat=mat) m = dion.homology_persistence(f) dgms = dion.init_diagrams(m,f) subgraphs = {} # compute ones tensors of same hidden dimensions muls = [] if invert: for h in hiddens: muls.append(torch.zeros(h.shape)) else: for h in hiddens: muls.append(torch.ones(h.shape)) fac = 1.0 if invert else 0.0 for i,c in enumerate(m): if len(c) == 2: if f[c[0].index][0] in subgraphs: subgraphs[f[c[0].index][0]].add_edge(f[c[0].index][0],f[c[1].index][0],weight=f[i].data) else: eaten = False for k, v in subgraphs.items(): if v.has_node(f[c[0].index][0]): v.add_edge(f[c[0].index][0], f[c[1].index][0], weight=f[i].data) eaten = True break if not eaten: g = nx.Graph() g.add_edge(f[c[0].index][0], f[c[1].index][0], weight=f[i].data) subgraphs[f[c[0].index][0]] = g # I don't think we need this composition. Disjoint subgraphs are fine. # subgraph = nx.compose_all([subgraphs[k] for k in list(subgraphs.keys())[:thru]]) sub_keys = list(subgraphs.keys())[:thru] lifetimes = np.empty(thru) t = 0 for pt in dgms[0]: if pt.death < float('inf'): lifetimes[t] = pt.birth - pt.death t += 1 if t >= thru: break max_lifetime = max(lifetimes) min_lifetime = min(lifetimes) ids = self.layerwise_ids() layer_types = self.layer_types for i in range(len(sub_keys)): k = sub_keys[i] lifetime = lifetimes[i] lim = p*lifetime/max_lifetime for e in subgraphs[k].edges(data=True): r = np.random.uniform() if r < lim: for l in range(len(ids)-1): if e[0] in ids[l] and e[1] in ids[l+1]: # drop out this edge connection # if layer_types[l] == 'convolution': # num_filters = self.filters # inp_size = self.input_size # stride = self.stride # kernel_size = self.kernel_size # next_ids = list(ids[l+1]) # # muls[l] = (28-self.kernel_size+1)**2*self.filters # filt_num = math.floor((e[1]-ids[l][-1])/((inp_size-kernel_size+1)**2)) # print('filtnum', filt_num) # # filters are 0-indexed, so add 1 and 2 to get ids # start_id = (inp_size-kernel_size+stride)**2*(filt_num+1) # end_id = (inp_size-kernel_size+stride)**2*(filt_num+2) # print('s min end', start_id, end_id, e[0], e[1]) # # find which element of the kernel produced this edge # index_no = (e[1]-start_id) % (kernel_size*kernel_size) # image_no = (e[1]-start_id)//(kernel_size*kernel_size) muls[l][e[1]-ids[l+1][0]] = fac return muls