def weighted_average(self, realign, max_iters, tol, vis=True):
"""Performs iterative weighted average algorithm to propagate labels to unlabeled nodes.
Features: Hard label clamps, probabilistic solution.
See: Zhu and Ghahramani, 2002."""
""" The first approach to be considered in the semi-supervised learning case
is to propagate labels on the graph.
A simple algorithm of this sort has been propoosed by Zhu and Ghahramani (2002),
and starts (like all such algorithms) with a set of n nodes,
l of which are labeled, and u unlabeled.
The algorithm takes as its input the affinity matrix W (self.aff_mat).
From the affinity matrix, one may construct the diagonal degree matrix,
which is a measure of the total weight (or number of edges) which are attached to a node."""
self.DDM = go.compute_diagonal_degree_matrix(self.aff_mat, inverse=True)
""" Next, we must initialize a vector to represent the results of the label propagation algorithm.
It will contain l labels and u 0's.
This has already been done by the function initialize_labels,
and is called self.assigned_labels.
We will just check to make sure this has been accomplished."""
if isinstance(self.assigned_labels,int):
print 'Please initialize the labels by calling self.initialize_labels()'
return
""" Now, we can actually proceed to perform the iterative algorithm.
At each timestep, the labels will be updated to reflect the weighted average
of adjacent nodes. An important caveat of this algorithm,
is that the labeled nodes remain fixed, or clamped.
They should not be changed, and will need to be reset.
We accomplish the reset by recalling that self.preserved_labels
stores the indexes of those nodes whose labels were preserved,
and self.Labels contains the actual labels.
The algorithm repeates itself until either convergence or max_iters
(which will prevent excessive computation time).
We must also take care to solve the multi-label problem.
To do so, we employ a one-vs-all framework, where each label is considered independently,
and set against the rest of the labels.
More specifically, self.label_matrix is an n x C matrix, where each row represents a node
and each column represents class membership. We can go column by column and process the algorithm
iteratively. So, we'd start at the first column and see which nodes get labeled.
Then we'd move to the next column and label more nodes.
Because it is possible (likely) that some nodes will not receive any label,
and also to account for probabilistic labeling, we will assign a probability
of a node receiving a label. Then we can report these probabilities.
So, to begin, let us first construct this probabilistic label assignment:
This matrix will store a 1 for 100% probability, 0 for 0%, and fractional values for the rest.
We will rename self.label_matrix for this purpose."""
self.probabilistic_assignment = self.label_matrix
""" We will later change the -1s to 0s.
As nodes get labeled, we assign a confidence measure to the labeling and store the value
in this matrix.
Now, let us go column by column, and run the weighted averaging algorithm.
For each column, you're studying one class. Therefore, when updating self.probabilistic_assignment,
you'll be working with one column at a time too.
If a label gets node, keep the fractional value, do not simply round to 1 to assign membership."""
i = 0 # record of class number
for column in self.probabilistic_assignment.T:
t0 = time()
print 'Working on class: ', i
restore = column[self.preserved_labels==1]
Y_hat_now = csr_matrix(column).transpose()
converged = False
counter = 0
while not converged and counter < max_iters:
""" The option will exist to visualize the proceedings of the algorith.
The results of a number of the iterations will be sent to vtk files which can then be visualized.
For the visualization, we will construct two types of vtk files.
The first will be the actual (manual) labels, as found in self.Labels,
with the class of interest highlighted (=1), and the others blanked out (=-1)
The other vtk files will be the result of the algorithm.
"""
if vis:
"""First, we'll find out which class/label we're working with, by calling label_mapping.
We'll then send that class to the method highlight() which will do the actual work of
creating the vtk."""
label = self.label_mapping[i]
if not counter: # No need to do this more than once :-)
self.highlight(label)
""" Next, we'll construct vtk files, assuming that the iteration step is one we care about.
For our purposes, let's see the early iterations in high density, once low density in the middle,
and the last iteration before convergence or max_iters.
So, the numbers of interest will be when counter is between 0 and 10, and at 100.
We'll also see max_iters/2, and max_iters (or convergence).
"""
# Actually, just see if counter is a multiple of a number of interest.
# set_of_interest = np.array([0,101,202,max_iters-2,max_iters-1])
""" Let's define a file for output.
We have the nodes and meshing, and we have the labels which are found in column.todense().flatten()."""
filename = '/home/eli/Neuroscience-Research/Visualizations/Alignment/'+self.id+'_'+str(label)+'_'+str(counter)+'.vtk'
if not np.mod(counter,1000):
LABELS = np.zeros(self.num_nodes)
LABELS[:] = Y_hat_now.todense().T.flatten()
vo.write_all(filename, self.Nodes, self.Mesh, LABELS)
Y_hat_next = (self.DDM * self.aff_mat * Y_hat_now).todense() # column matrix
Y_hat_next[self.preserved_labels==1,0] = restore # reset
converged = (np.sum(np.abs(Y_hat_now.todense() - Y_hat_next)) < tol) # check convergence
# print 'Iteration number {0}, convergence = {1}'.format(str(counter),str(np.sum(np.abs(column.todense() - tmp))))
Y_hat_now = csr_matrix(Y_hat_next)
counter += 1
# Print out the number of iterations, so that we get a sense for future runs.
# It is also an indication of whether the algorithm converged.
if counter == max_iters:
print 'The algorithm did not converge.'
else:
print 'The algorithm converged in {0} iterations.'.format(str(counter))
print 'Done in {0} seconds'.format(str(time()-t0))
self.probabilistic_assignment[:,i] = Y_hat_now.todense().flatten()
print 'There were {0} nodes initially preserved in this class'.format(str(self.count_assigned_members(i)))
print 'The file actually had {0} nodes in this class'.format(str(self.count_real_members(self.label_mapping[i])))
print 'Using only those nodes which crossed the threshold, there are now: '.format(str(self.count_real_members(i)))
i += 1
""" Before reporting the probabilistic assignment, we change all -1's, which were used
to indicate non-membership in a class, into 0's, which signify 0 probability that the
node belongs to that class.
Note: because the labels were initially numbered -1 and 1, there will be 'probabilities' below 0.
So, to obtain a sort of probability distribution which preserves order, we will add 1 to each number,
and then divide by 2. Thus -1 --> 0, 1 --> 1 and everything else keeps its order."""
self.probabilistic_assignment += 1
self.probabilistic_assignment /= 2
""" self.probabilistic_assignment is now complete."""
#pylab.plot(self.probabilistic_assignment[:,3])
#pylab.show()
return self.probabilistic_assignment
def jacobi_iteration(self, alpha, max_iters, tol, eps):
"""Performs label propagation inspired from Jacobi iterative algorithm
to propagate labels to unlabeled nodes.
Features: Soft label clamps (alpha), probabilistic solution.
See: Chapelle, ch. 11 (algorithm 11.2)."""
"""The next approach to be considered in the semi-supervised learning case
is to propagate labels on the graph, using a modified version of the above algorithm.
The main differences are soft clamping, forcing the diagonals to be equal to 0,
and the introduction of an error term (eps) for numerical stability.
We start with a set of n nodes, l of which are labeled, and u unlabeled.
The algorithm takes as its input the affinity matrix W (self.aff_mat).
From the affinity matrix, we construct the diagonal degree matrix,
which is a measure of the total weight (or number of edges) which are attached to a node."""
self.DDM = go.compute_diagonal_degree_matrix(self.aff_mat, inverse=True)
"""Next, we must initialize a vector to represent the results
of the label propagation algorithm. It will contain l labels and u 0's.
This has already been done by the function initialize_labels(),
and is called self.assigned_labels.
We will just check to make sure this has been accomplished."""
if isinstance(self.assigned_labels,int):
print 'Please initialize the labels by calling self.initialize_labels()'
return
""" Now, we can actually proceed to perform the iterative algorithm.
At each timestep, the labels will be updated to reflect the weighted average
of adjacent nodes. An important caveat of this algorithm,
is that the labeled nodes do not remain fixed, or clamped.
The algorithm repeates itself until either convergence or max_iters
(which will prevent excessive computation time).
We must again take care to solve the multi-label problem.
So, to begin, let us first construct this probabilistic label assignment:
This matrix will store a 1 for 100% probability, 0 for 0%, and fractional values for the rest.
We will rename self.label_matrix for this purpose.
We will later change the -1s to 0s."""
self.probabilistic_assignment = self.label_matrix
""" Before proceeding, let us check that the parameters are valid"""
if not (alpha < 1 and alpha > 0 and eps > 0 and isinstance(max_iters, int) and max_iters > 0 and tol > 0):
print 'You have failed to properly input parameters. Alpha must be strictly between 0 and 1, eps \ \
and tol must be greater than 0 and max_iters must be an integer.'
return
""" As nodes get labeled, we assign a confidence measure to the labeling and store the value in this matrix.
Now, let us go column by column, and run the weighted averaging algorithm.
For each column, you're studying one class. Therefore, when updating self.probabilistic_assignment,
you'll be working with one column at a time too.
If a label gets node, keep the fractional value, do not simply round to 1 to assign membership."""
i = 0 # record of class number
for column in self.probabilistic_assignment.T:
self.labeled_indices = column[self.preserved_labels==1]
column = csr_matrix(column).transpose()
converged = False
counter = 0
while not converged and counter < max_iters:
tmp = self.DDM * self.aff_mat * column # column matrix
tmp = tmp.tolil() # store results of iteration
tmp[self.labeled_indices,0] = self.labeled_indices # reset
converged = (np.abs(column - tmp).sum() < tol) # check convergence
print 'convergence=', np.abs(column-tmp).sum()
column = csr_matrix(tmp)
counter += 1
# Print out the number of iterations, so that we get a sense for future runs.
# It is also an indication of whether the algorithm converged.
if counter == max_iters:
print 'The algorithm did not converge.'
else:
print 'The algorithm converged in {0} iterations.'.format(str(counter))
i += 1
""" Before reporting the probabilistic assignment, we change all -1's, which were used
to indicate non-membership in a class, into 0's, which signify 0 probability that the
node belongs to that class."""
self.probabilistic_assignment[self.probabilistic_assignment==-1] = 0
return self.probabilistic_assignment
