def simulate_affiliation_dpe():
nrange = [400] #50*2**np.arange(3)
drange = np.arange(1,5)
embed = [Embed.dot_product_embed,
Embed.dot_product_embed_unscaled,
Embed.normalized_laplacian_embed,
Embed.normalized_laplacian_embed_scaled]
k = 2
p = .15
q = .1
for n in nrange:
G = rg.affiliation_model(n, k, p, q)
for d in drange:
print n*k,d,
for e in embed:
Embed.cluster_vertices_kmeans(G, e, d, k, 'kmeans')
print num_diffs_w_perms_graph(G, 'block', 'kmeans'),
print
plot.matshow(nx.adj_matrix(G))
plot.show()
def embedding_vs_dimension_performance():
n = 50
drange = np.arange(1,5)
embed = [Embed.dot_product_embed,
Embed.dot_product_embed_unscaled,
Embed.normalized_laplacian_embed,
Embed.normalized_laplacian_embed_scaled]
nmc = 10
k = 2
p = .5
q = .1
all_params = list(IterGrid({'d':drange, 'embed':embed}))
[param.update({'num_diff':np.zeros(nmc),'rand_idx':np.zeros(nmc)}) for param in all_params]
for mc in np.arange(nmc):
print mc
G = rg.affiliation_model(n, k, p, q)
truth = nx.get_node_attributes(G, 'block').values()
for param in all_params:
pred = Embed.cluster_vertices_kmeans(G, param['embed'], param['d'], 2)
param['num_diff'][mc] = num_diff_w_perms(truth, pred)
param['rand_idx'][mc] = metrics.adjusted_rand_score(truth, pred)
return all_params
def plotEmbedComparison(G, e1, e2):
e1.embed(G)
e2.embed(G)
x1 = e1.get_scaled(2)
x2 = e2.get_scaled(2)
x2p = Embed.procrustes(x1, x2)
#block = nx.get_node_attributes(G, 'block').values()
#plot.subplot(121);
plot.scatter(x1[:,0],x1[:,1],c='r')
#plot.subplot(122);
plot.scatter(x2p[:,0],x2p[:,1],c='b')
def get_results(rgg, eA, dRange):
G = rgg.generate_graph()
A = Embed.adjacency_matrix(G)
n = G.number_of_nodes()
m = max(int(np.sqrt(n)), 50)
rhoBS = np.array([get_subgraph_density(A, random_integers(0, n - 1, m)) for _ in xrange(1000)])
rhoHat = np.sort(0.5 - np.abs(0.5 - rhoBS))[950]
sval = eA.embed(G).sval
mcr = [mclust(rggk.label, eA.get_scaled(d)) for d in dRange]
return (sval, mcr, rhoHat)
def get_rdpg_sim_res(rdpg, embed, k):
rdpg.generate_adjacency()
Xhat = Embed.procrustes(rdpg.X, embed.embed(rdpg.Adj).get_scaled())
#Y = rdpg.block_assignment
knn = KNeighborsClassifier(k)
loo = cross_validation.LeaveOneOut(rdpg.n_nodes)
X = rdpg.X
Y = (X[:,0]>X[:,1]).astype(float)
Xhat = Embed.procrustes(X,embed.embed(rdpg.Adj).get_scaled(),scale=False, center=False)
result = np.zeros(1, dtype=[('X',np.float32),('Xhat',np.float32),
('gstarX',np.float32),('gstarXhat',np.float32),('sqerr',np.float32),('n',np.int)])
result['X'] = 1-np.mean(cross_validation.cross_val_score(knn, X,Y, cv=loo))
result['Xhat'] = 1-np.mean(cross_validation.cross_val_score(knn, Xhat,Y, cv=loo))
result['gstarX'] = 1-np.mean(np.equal(X[:,0]>X[:,1],Y))
result['gstarXhat'] = 1-np.mean(np.equal(Xhat[:,0]>Xhat[:,1],Y))
result['sqerr'] = np.linalg.norm(X-Xhat,'fro')
result['n'] = rdpg.n_nodes
return result
def Initialize(self):
# Load commands
import AppCommand
import ToolCommand
import Embed
Embed.ExternalApps()
AppCommand.createCommands(self.appName)
ToolCommand.createCommands(self.appName)
# List of commands for this workbench
self.list = ['ExternalAppsOpen' + self.appName + 'Command'] \
+ ['ExternalAppsTool' + self.appName + toolName + 'Command'
for toolName in ExternalAppsList.apps[self.appName].Tools]
# Create menus and toolbars
self.appendMenu("ExternalApplications", self.list)
self.appendToolbar("ExternalApplications", self.list)
def embed_graph(ccfn, fgfn, embedfn, dim=10):
"""
ccfn - connected components file with numpy arrray
fgfn - mat file with the fibergraph
embedfn - full file name of output file to be saved
dim - desired dimension for the embedding
"""
vcc = lcc.ConnectedComponent(fn=ccfn)
# Load the fibergraph
# Now get the subgraph for the lcc, binarize and symmetrize
G = vcc.induced_subgraph(loadmat(fgfn)['fibergraph'])
G.data = np.ones_like(G.data) # Binarize
G = G + G.T # Symmetrize
e = Embed.Embed(dim, matrix=Embed.self_matrix)
if not os.path.exists(os.path.dirname(embedfn)):
print "Creating svd directory: %s" % os.path.dirname(embedfn)
os.makedirs(os.path.dirname(embedfn))
np.save(embedfn, e.embed(G).get_scaled())
def Activated(self):
p = Embed.ExternalAppInstance(self.appName)
p.waitForWindow()
