def highlight(self, class_label): """ This method highlights a set of nodes which belong to the specified class. To accomplish this, we find all the nodes which have that label - this can be found in self.Labels - and then we create a new array where those indices are labeled 1 and all others are labeled -1. """ indices = np.asarray(map(int,self.Labels==class_label)) * 2 - 1 """ That's it. Now we just write the file.""" filename = '/home/eli/Neuroscience-Research/Visualizations/Alignment/highlighted_'+self.id+'_'+str(class_label)+'.vtk' vo.write_all(filename, self.Nodes, self.Mesh, indices)
def find_label_boundary(self, draw=True): """ This method finds those nodes which comprise the label boundary. I will define a label boundary as the set of all nodes whose neighbors are not all from the same class. Thus, any node which is connected to two (or more) nodes from different classes will be a boundary node, and will help constitute the label boundary. """ """ To do so, we simply go triangle by triangle and see if they are all from the same class. If yes, do nothing. If no, then add the nodes from the majority class (it'll be 2 to 1) to the label boundary. First, let us define an empty array to store the label boundaries. It will have zeros and ones. We can then define a new array to store all and only those nodes which are part of the label boundary. """ self.label_boundary = np.zeros(self.num_nodes) """ Now, let us go triangle by triangle. Set the node's index in label_boundary to 1 if and only if it is satisfies the definition. """ for triangle in self.Mesh: v0, v1, v2 = triangle[0], triangle[1], triangle[2] # If they are not all the same... same_labels = [self.Labels[v1]==self.Labels[v2], self.Labels[v0]==self.Labels[v2], self.Labels[v0]==self.Labels[v1]] # Did it this way for option to modify it later. Perhaps reconsider 'not all' statement. if not all(same_labels): # Then label those nodes as part of the boundary. self.label_boundary[triangle] = 1 # We can now output a file to show the boundary. if draw: filename = '/home/eli/Neuroscience-Research/Realign/label_boundary_'+self.id+'.vtk' vo.write_all(filename,self.Nodes,self.Mesh,self.label_boundary) # Reformat label_boundary to include only the indices of those nodes in the boundary. self.label_boundary = np.nonzero(self.label_boundary==1)[0] return self.label_boundary
def create_vtk(self, fname, label = 'Labels', header='Shape Analysis by PyShape'): """Create vtk file from imported data.""" if not(self.has_nodes and self.has_mesh): print 'You have yet to enter the nodes and meshing!' return if not self.has_labels: self.Labels = None self.vtk = vo.write_all(fname, self.Nodes, self.Mesh, self.Labels, label_type=label, msg=header) print 'vtk file was successfully created at: ', self.vtk.name self.has_vtk = 1 return self.vtk.name
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
