def metaprocess(meta):
"""
Add to meta (a dict) `labels` correspond to current model and
`colors` correspond to these labels, for drawing predictions.
"""
def _to_color(indx, base):
""" return (b, r, g) tuple"""
base2 = base * base
b = indx / base2
r = (indx % base2) / base
g = (indx % base2) % base
return (b * 127, r * 127, g * 127)
labels(meta)
assert len(meta['labels']) == meta['classes'], (
'labels.txt and {} indicate' + ' '
'inconsistent class numbers').format(meta['model'])
colors = list()
base = int(np.ceil(pow(meta['classes'], 1. / 3)))
for x in range(len(meta['labels'])):
colors += [_to_color(x, base)]
meta['colors'] = colors
return meta
def constructor(self, meta, FLAGS):
def _to_color(indx, base):
""" return (b, r, g) tuple"""
base2 = base * base
b = 2 - indx / base2
r = 2 - (indx % base2) / base
g = 2 - (indx % base2) % base
return (b * 127, r * 127, g * 127)
if 'labels' not in meta:
misc.labels(meta, FLAGS) #We're not loading from a .pb so we do need to load the labels
assert len(meta['labels']) == meta['classes'], (
'labels.txt and {} indicate' + ' '
'inconsistent class numbers'
).format(meta['model'])
# assign a color for each label
colors = list()
base = int(np.ceil(pow(meta['classes'], 1./3)))
for x in range(len(meta['labels'])):
colors += [_to_color(x, base)]
meta['colors'] = colors
self.fetch = list()
self.meta, self.FLAGS = meta, FLAGS
# over-ride the threshold in meta if FLAGS has it.
if FLAGS.threshold > 0.0:
self.meta['thresh'] = FLAGS.threshold
def disk_compare(N=100,dim=2): ###
print('\n***mds.disk_compare()***')
X = misc.disk(N,2); labels = misc.labels(X)
plt.figure()
plt.scatter(X[:,0],X[:,1],c=labels)
plt.title('original data')
plt.draw()
plt.pause(0.1)
D = distances.compute(X)
mds = MDS(D,dim=dim,verbose=1,title='disk experiments',labels=labels)
mds.initialize()
mds.figureX(title='initial embedding')
title = 'full gradient & agd'
mds.optimize(algorithm='agd',verbose=2,label=title)
mds.figureX(title=title)
mds.figureH(title=title)
mds.forget()
title = 'approx gradient & gd'
mds.approximate(algorithm='gd',verbose=2,label=title)
mds.figureX(title=title)
mds.figureH(title=title)
mds.forget()
title = 'combine'
mds.approximate(algorithm='gd',verbose=2,label=title)
mds.optimize(verbose=2,label=title,max_iters=10)
mds.figureX(title=title)
mds.figureH(title=title)
plt.show()
def disk(N=128, weights=None, **kwargs):
#basic disk example
#N is number of points
#weights: use None or 'reciprocal' or array, etc
print('\n***disk example***\n')
X = misc.disk(N, 2)
colors = misc.labels(X)
distances = scipy.spatial.distance.pdist(X)
title = 'basic disk example'
mds = MDS(distances,
weights=weights,
dim=2,
verbose=2,
title=title,
sample_colors=colors)
fig, ax = plt.subplots(1, 3, figsize=(9, 3))
fig.suptitle('MDS - disk data')
fig.subplots_adjust(top=0.80)
mds.plot_embedding(title='initial embedding', ax=ax[0])
mds.gd(min_cost=1e-6, **kwargs)
mds.plot_computations(ax=ax[1])
mds.plot_embedding(title='final embedding', ax=ax[2])
plt.draw()
plt.pause(1.0)
def example_approx(N=30, dim=2, batch_number=5):
print('\n***mds.example_disk_batch()***\n')
Y = misc.disk(N, dim)
labels = misc.labels(Y)
plt.figure()
plt.scatter(Y[:, 0], Y[:, 1], c=labels)
plt.title('Original data')
plt.draw()
plt.pause(0.1)
D = distances.compute(Y)
title = 'basic disk example using approximate gradient'
mds = MDS(D, dim=dim, verbose=1, title=title, labels=labels)
mds.initialize()
mds.approximate(verbose=2,
max_iters=200,
lr=0.1,
batch_number=batch_number,
algorithm='gd')
mds.figureX(title='Final embedding')
mds.figureH()
plt.show()
def constructor(self, meta, FLAGS):
def _to_color(indx, base):
""" return (b, r, g) tuple"""
base2 = base * base
b = 2 - indx / base2
r = 2 - (indx % base2) / base
g = 2 - (indx % base2) % base
return (b * 127, r * 127, g * 127)
misc.labels(meta)
assert len(meta['labels']) == meta['classes'], (
'labels.txt and {} indicate' + ' '
'inconsistent class numbers').format(meta['model'])
colors = list()
base = int(np.ceil(pow(meta['classes'], 1. / 3)))
for x in range(len(meta['labels'])):
colors += [_to_color(x, base)]
meta['colors'] = colors
self.meta, self.FLAGS = meta, FLAGS
def example_tsne(**kwargs):
X_true = np.load('examples/123/true2.npy') #[0:500]
colors = misc.labels(X_true)
from scipy import spatial
D = spatial.distance_matrix(X_true, X_true)
vis = TSNE(D, verbose=2, perplexity=50, sample_colors=colors)
vis.initialize(X0=X_true)
vis.plot_embedding()
vis.gd(plot=True, **kwargs)
vis.plot_embedding()
plt.show()
def test_gd_lr(N=100, dim=2):
print('\n***mds.gd_lr()***')
Y = misc.disk(N, dim)
colors = misc.labels(Y)
D = multigraph.from_coordinates(Y, colors=colors)
title = 'recovering random coordinates for different learning rates'
mds = MDS(D, dim=dim, verbose=1, title=title)
mds.initialize()
for lr in [100, 10, 1, .1]:
mds.gd(lr=lr)
mds.figure(title=f'lr = {lr}')
mds.forget()
plt.show()
def example_disk(N=100):
X = misc.disk(N,dim=3); labels=misc.labels(X)
persp = perspective.Persp()
persp.fix_Q(number=3,special='standard')
Y = persp.compute_Y(X)
D = distances.compute(Y)
mv = Multiview(D,persp=persp,verbose=1,labels=labels)
mv.setup_visualization(visualization='mds')
mv.initialize_X(verbose=1)
mv.optimize_X(batch_size=10,max_iters=50,verbose=1)
mv.figureX(save='hola')
mv.figureY()
mv.figureH()
plt.show()
def example_disk(N=100):
X = misc.disk(N, dim=3)
labels = misc.labels(X)
persp = perspective.Persp()
persp.fix_Q(number=3, special='standard')
D = multigraph.from_perspectives(X, persp)
mv = MPSE(D, persp=persp, verbose=1)
mv.setup_visualization(visualization='mds')
mv.initialize_X(verbose=1)
mv.optimize_X(batch_size=10, max_iters=50, verbose=1)
mv.figureX(save='hola')
mv.figureY()
mv.figureH()
mv.figureHY()
plt.show()
def example_disk_all(N=100):
X = misc.disk(N, dim=3)
labels = misc.labels(X)
persp = perspective.Persp()
persp.fix_Q(number=3, special='standard')
D = multigraph.from_perspectives(X, persp)
mv = MPSE(D, persp=persp, verbose=1)
mv.setup_visualization(visualization='mds')
mv.initialize_Q()
mv.initialize_X()
mv.optimize_all(agd=True)
mv.figureX(plot=True)
mv.figureY(plot=True)
mv.figureH()
plt.show()
def example_disk_all(N=100):
X = misc.disk(N,dim=3); labels=misc.labels(X)
persp = perspective.Persp()
Q_true = persp.generate_Q(number=3,special='standard')
Y_true = persp.compute_Y(X,Q=Q_true)
D = distances.compute(Y_true)
mv = Multiview(D,persp=persp,verbose=1,labels=labels)
mv.setup_visualization(visualization='mds')
mv.initialize_Q()
mv.initialize_X()
mv.optimize_all(agd=True,batch_size=10)
mv.figureX(plot=True)
mv.figureY(plot=True)
mv.figureH()
plt.show()
def example_fewer_edges(N=100, dim=2):
print('\n***mds.example_fewer_edges()***\n')
print(
'Here we explore the MDS embedding for a full graph as far way edges' +
'are removed')
title = 'MDS embedding for multiple proportion of edges'
X = misc.disk(N, dim)
colors = misc.labels(X)
D = multigraph.from_coordinates(X, colors=colors)
X0 = misc.disk(N, dim) * .5
for prop in [.99, .8, .6, .4, .2]:
DD = multigraph.remove_edges(D, proportion=prop)
mds = MDS(DD, dim=dim, verbose=1, title=title)
mds.initialize(X0=X0)
mds.stochastic(verbose=1, max_iters=300, approx=.99, lr=.5)
mds.adaptive(verbose=1, min_step=1e-6, max_iters=300)
mds.figure(title=f'proportion = {prop:0.1f}')
plt.show()
def example_stochastic(N=100, dim=2):
print('\n***mds.example_stochastic()***\n')
Y = misc.disk(N, dim)
colors = misc.labels(Y)
D = multigraph.from_coordinates(Y, colors=colors)
title = 'recovering random coordinates from full dissimilarity matrix ' +\
'using SGD, same learning rate, and different approx'
mds = MDS(D, dim=dim, verbose=1, title=title)
mds.initialize()
for approx in [1., .8, .6, .4, .2, .1]:
mds.stochastic(verbose=1,
lr=10.0,
min_step=1e-6,
approx=approx,
title=f'SGD using {approx} of edges')
mds.figure(title=f'approx = {approx}, time = {mds.H["time"]:0.2f}')
mds.forget()
plt.show()
def example_disk(N=100,dim=2,**kwargs):
print('\n***mds.example_disk()***')
Y = misc.disk(N,dim); labels = misc.labels(Y)
plt.figure()
plt.scatter(Y[:,0],Y[:,1],c=labels)
plt.title('original data')
plt.draw()
plt.pause(0.1)
D = distances.compute(Y)
title = 'basic disk example'
mds = MDS(D,dim=dim,verbose=1,title=title,labels=labels)
mds.initialize()
mds.figureX(title='initial embedding')
mds.optimize(**kwargs)
mds.figureX(title='final embedding',labels=labels,edges=.2)
mds.figure(title='final embedding',labels=labels)
plt.show()
def example_weights(N=100, dim=2):
print('\n***mds.example_weights()***\n')
print('Here we explore the MDS embedding for a full graph for different' +
'weights')
title = 'MDS embedding for multiple weights'
X = misc.disk(N, dim)
colors = misc.labels(X)
X0 = misc.disk(N, dim)
D = multigraph.from_coordinates(X, colors=colors)
mds = MDS(D, dim=dim, verbose=1, title=title)
mds.initialize(X0=X0)
mds.stochastic(verbose=1, max_iters=50, approx=.6, lr=50)
mds.adaptive(verbose=1, min_step=1e-6, max_iters=300)
mds.figure(title=f'absolute weights')
multigraph.set_weights(D, scaling=.5)
mds = MDS(D, dim=dim, verbose=1, title=title)
mds.initialize(X0=X0)
mds.stochastic(verbose=1, max_iters=50, approx=.6, lr=50)
mds.adaptive(verbose=1, min_step=1e-6, max_iters=300)
mds.figure(title=f'1/sqrt(Dij) weights')
multigraph.set_weights(D, scaling=1)
mds = MDS(D, dim=dim, verbose=1, title=title)
mds.initialize(X0=X0)
mds.stochastic(verbose=1, max_iters=50, approx=.6, lr=50)
mds.adaptive(verbose=1, min_step=1e-6, max_iters=300)
mds.figure(title=f'1/Dij weights')
multigraph.set_weights(D, scaling=2)
mds = MDS(D, dim=dim, verbose=1, title=title)
mds.initialize(X0=X0)
mds.stochastic(verbose=1, max_iters=50, approx=.6, lr=50)
mds.adaptive(verbose=1, min_step=1e-6, max_iters=300)
mds.figure(title=f'relative weights')
plt.show()
def graph_from_coordinates(X,
norm=2,
edges=None,
weights=None,
colors=None,
**kwargs):
"""\
Returns dictionary with dissimilarity measures from coordinates.
Parameters :
X : (N,dimX) array_like
Array containing coordinates of N points of dimension dimX.
norm : number (>=1) or function
If isinstance(norm,Number), this is the Minkowski p-norm with p=norm.
If callable(norm), then use this as a norm.
edges : None or float or array_like
If edges is None: all edges are included.
If isinstance(edges,Number): only edges with distance<edges are included.
if isinstance(edges,array_like): this is the list of edges.
weights : None or number or function or array_like
If weights is None, w_ij = 1
If weights is a number, w_ij = 1/Dij**int
If callable(weights), w_ij = weights(D_ij)
If array_like, w_ij = weights[i,j]
"""
N = len(X)
if isinstance(norm, numbers.Number):
p = norm
assert p >= 1
norm = lambda x: np.sum(x**p)**(1.0 / p)
else:
assert callable(norm)
if edges is None or isinstance(edges, numbers.Number):
NN = int(N * (N - 1) / 2)
e = np.empty((NN, 2), dtype=int)
d = np.empty(NN)
if edges is None:
it = 0
for i in range(N):
for j in range(i + 1, N):
e[it] = [i, j]
d[it] = norm(X[i] - X[j])
it += 1
else:
it = 0
for i in range(N):
for j in range(N):
Dij = norm(X[i] - X[j])
if Dij <= edges:
e[it] = [i, j]
d[it] = norm(X[i] - X[j])
it += 1
NN = it
e = e[0:NN]
d = d[0:NN]
else:
NN = len(edges)
e = np.array(e, dtype=int)
d = np.empty(NN)
for i in range(NN):
d[i] = norm(X[e[i, 0]] - X[e[i, 1]])
if weights is None:
w = np.ones(NN)
elif weights == 'relative':
w = d**(-2)
elif callable(weights):
w = np.empty(NN)
for i in range(NN):
w[i] = weights(d[i])
else:
w = weights
if colors is not None:
if isinstance(colors, int):
colors = misc.labels(Y, axis=colors)
DD = {
'node_number': N,
'node_labelss': range(N),
'edge_number': len(e),
'edges': e,
'distances': d,
'weights': w,
'colors': colors
}
return DD