def _increment_shape_model(self, shapes, scale_index, forgetting_factor=1.0): aligned_shapes = align_shapes(shapes) dense_shapes = densify_shapes(aligned_shapes, self.reference_frame, self.transform) # Increment shape model self.shape_models[scale_index].increment( dense_shapes, forgetting_factor=forgetting_factor, max_n_components=self.max_shape_components[scale_index] )
def _increment_shape_model(self, shapes, shape_model, forgetting_factor=1.0): # Compute aligned shapes aligned_shapes = align_shapes(shapes) # Increment shape model shape_model.increment(aligned_shapes, forgetting_factor=forgetting_factor)
def _increment_shape_model(self, shapes, shape_model, forgetting_factor=1.0): aligned_shapes = align_shapes(shapes) dense_shapes = densify_shapes(aligned_shapes, self.reference_frame, self.transform) # Increment shape model shape_model.increment(dense_shapes, forgetting_factor=forgetting_factor)
def _increment_shape_model(self, shapes, scale_index, forgetting_factor=1.0): aligned_shapes = align_shapes(shapes) dense_shapes = densify_shapes(aligned_shapes, self.reference_frame, self.transform) # Increment shape model self.shape_models[scale_index].increment( dense_shapes, forgetting_factor=forgetting_factor, max_n_components=self.max_shape_components[scale_index])
def _build_shape_model(self, shapes, scale_index): mean_aligned_shape = mean_pointcloud(align_shapes(shapes)) self.n_landmarks = mean_aligned_shape.n_points self.reference_frame = build_reference_frame(mean_aligned_shape) dense_shapes = densify_shapes(shapes, self.reference_frame, self.transform) # build dense shape model shape_model = build_shape_model(dense_shapes) return shape_model
def __init__(self, data, **kwargs): from menpofit.transform import DifferentiableAlignmentSimilarity aligned_shapes = align_shapes(data) self.mean = mean_pointcloud(aligned_shapes) # Default target is the mean self._target = self.mean self.transform = DifferentiableAlignmentSimilarity( self.target, self.target)
def _build_shape_model(self, shapes, scale_index): mean_aligned_shape = mean_pointcloud(align_shapes(shapes)) self.n_landmarks = mean_aligned_shape.n_points self.reference_frame = build_reference_frame(mean_aligned_shape) dense_shapes = densify_shapes(shapes, self.reference_frame, self.transform) # Build dense shape model max_sc = self.max_shape_components[scale_index] return self._shape_model_cls[scale_index](dense_shapes, max_n_components=max_sc)
def __init__(self, data, **kwargs): from menpofit.transform import DifferentiableAlignmentSimilarity aligned_shapes = align_shapes(data) self.mean = mean_pointcloud(aligned_shapes) # Default target is the mean self._target = self.mean self.transform = DifferentiableAlignmentSimilarity(self.target, self.target)
def increment(self, shapes, n_shapes=None, forgetting_factor=1.0, max_n_components=None, verbose=False): old_target = self.target aligned_shapes = align_shapes(shapes) self.model.increment(aligned_shapes, n_samples=n_shapes, forgetting_factor=forgetting_factor, verbose=verbose) if max_n_components is not None: self.model.trim_components(max_n_components) # Reset the target given the new model self.set_target(old_target)
def _build_shape_model(self, shapes, scale_index): mean_aligned_shape = mean_pointcloud(align_shapes(shapes)) self.n_landmarks = mean_aligned_shape.n_points self.reference_frame = build_patch_reference_frame( mean_aligned_shape, patch_shape=self.patch_shape[scale_index]) dense_shapes = densify_shapes(shapes, self.reference_frame, self.transform) # Build dense shape model max_sc = self.max_shape_components[scale_index] return self._shape_model_cls[scale_index](dense_shapes, max_n_components=max_sc)
def __init__(self, data, max_n_components=None): if isinstance(data, PCAModel): shape_model = data else: aligned_shapes = align_shapes(data) shape_model = PCAModel(aligned_shapes) if max_n_components is not None: shape_model.trim_components(max_n_components) super(PDM, self).__init__(shape_model) # Default target is the mean self._target = self.model.mean()
def increment(self, shapes, n_shapes=None, forgetting_factor=1.0, max_n_components=None, verbose=False): r""" Update the eigenvectors, eigenvalues and mean vector of this model by performing incremental PCA on the given samples. Parameters ---------- shapes : `list` of `menpo.shape.PointCloud` List of new shapes to update the model from. n_shapes : `int` or ``None``, optional If `int`, then `shapes` must be an iterator that yields `n_shapes`. If ``None``, then `shapes` has to be a list (so we know how large the data matrix needs to be). forgetting_factor : ``[0.0, 1.0]`` `float`, optional Forgetting factor that weights the relative contribution of new samples vs old samples. If 1.0, all samples are weighted equally and, hence, the results is the exact same as performing batch PCA on the concatenated list of old and new simples. If <1.0, more emphasis is put on the new samples. See [1] for details. max_n_components : `int` or ``None``, optional The maximum number of components that the model will keep. If ``None``, then all the components will be kept. verbose : `bool`, optional If ``True``, then information about the progress will be printed. References ---------- .. [1] D. Ross, J. Lim, R.S. Lin, M.H. Yang. "Incremental Learning for Robust Visual Tracking". International Journal on Computer Vision, 2007. """ old_target = self.target aligned_shapes = align_shapes(shapes) self.model.increment(aligned_shapes, n_samples=n_shapes, forgetting_factor=forgetting_factor, verbose=verbose) if max_n_components is not None: self.model.trim_components(max_n_components) # Re-orthonormalize self._construct_similarity_model() # Reset the target given the new models self.set_target(old_target)
def _train_batch(self, image_batch, increment=False, group=None, verbose=False): # Rescale to existing reference shape image_batch = rescale_images_to_reference_shape(image_batch, group, self.reference_shape, verbose=verbose) # If the deformation graph was not provided (None given), then compute # the MST if None in self.deformation_graph: graph_shapes = [i.landmarks[group].lms for i in image_batch] deformation_mst = _compute_minimum_spanning_tree(graph_shapes, root_vertex=0, prefix='- ', verbose=verbose) self.deformation_graph = [ deformation_mst if g is None else g for g in self.deformation_graph ] # Build models at each scale if verbose: print_dynamic('- Building models\n') feature_images = [] # for each scale (low --> high) for j in range(self.n_scales): if verbose: if len(self.scales) > 1: scale_prefix = ' - Scale {}: '.format(j) else: scale_prefix = ' - ' else: scale_prefix = None # Handle holistic features if j == 0 and self.holistic_features[j] == no_op: # Saves a lot of memory feature_images = image_batch elif (j == 0 or self.holistic_features[j] is not self.holistic_features[j - 1]): # Compute features only if this is the first pass through # the loop or the features at this scale are different from # the features at the previous scale feature_images = compute_features(image_batch, self.holistic_features[j], prefix=scale_prefix, verbose=verbose) # handle scales if self.scales[j] != 1: # Scale feature images only if scale is different than 1 scaled_images = scale_images(feature_images, self.scales[j], prefix=scale_prefix, verbose=verbose) else: scaled_images = feature_images # Extract potentially rescaled shapes scale_shapes = [i.landmarks[group].lms for i in scaled_images] # Apply procrustes to align the shapes aligned_shapes = align_shapes(scale_shapes) # Build the shape model using the aligned shapes if verbose: print_dynamic('{}Building shape model'.format(scale_prefix)) if not increment: self.shape_models.append( self._build_shape_model(aligned_shapes, self.shape_graph[j], self.max_shape_components[j], verbose=verbose)) else: self.shape_models[j].increment(aligned_shapes, verbose=verbose) # Build the deformation model if verbose: print_dynamic( '{}Building deformation model'.format(scale_prefix)) if self.use_procrustes: deformation_shapes = aligned_shapes else: deformation_shapes = scale_shapes if not increment: self.deformation_models.append( self._build_deformation_model(deformation_shapes, self.deformation_graph[j], verbose=verbose)) else: self.deformation_models[j].increment(deformation_shapes, verbose=verbose) # Obtain warped images warped_images = self._warp_images(scaled_images, scale_shapes, j, scale_prefix, verbose) # Build the appearance model if verbose: print_dynamic( '{}Building appearance model'.format(scale_prefix)) if not increment: self.appearance_models.append( self._build_appearance_model( warped_images, self.appearance_graph[j], self.n_appearance_components[j], verbose=verbose)) else: self._increment_appearance_model(warped_images, self.appearance_graph[j], self.appearance_models[j], verbose=verbose) if verbose: print_dynamic('{}Done\n'.format(scale_prefix))
def _train_batch(self, image_batch, increment=False, group=None, verbose=False): # Rescale to existing reference shape image_batch = rescale_images_to_reference_shape( image_batch, group, self.reference_shape, verbose=verbose) # If the deformation graph was not provided (None given), then compute # the MST if None in self.deformation_graph: graph_shapes = [i.landmarks[group] for i in image_batch] deformation_mst = _compute_minimum_spanning_tree( graph_shapes, root_vertex=0, prefix='- ', verbose=verbose) self.deformation_graph = [deformation_mst if g is None else g for g in self.deformation_graph] # Build models at each scale if verbose: print_dynamic('- Building models\n') feature_images = [] # for each scale (low --> high) for j in range(self.n_scales): if verbose: if len(self.scales) > 1: scale_prefix = ' - Scale {}: '.format(j) else: scale_prefix = ' - ' else: scale_prefix = None # Handle holistic features if j == 0 and self.holistic_features[j] == no_op: # Saves a lot of memory feature_images = image_batch elif (j == 0 or self.holistic_features[j] is not self.holistic_features[j - 1]): # Compute features only if this is the first pass through # the loop or the features at this scale are different from # the features at the previous scale feature_images = compute_features(image_batch, self.holistic_features[j], prefix=scale_prefix, verbose=verbose) # handle scales if self.scales[j] != 1: # Scale feature images only if scale is different than 1 scaled_images = scale_images(feature_images, self.scales[j], prefix=scale_prefix, verbose=verbose) else: scaled_images = feature_images # Extract potentially rescaled shapes scale_shapes = [i.landmarks[group] for i in scaled_images] # Apply procrustes to align the shapes aligned_shapes = align_shapes(scale_shapes) # Build the shape model using the aligned shapes if verbose: print_dynamic('{}Building shape model'.format(scale_prefix)) if not increment: self.shape_models.append(self._build_shape_model( aligned_shapes, self.shape_graph[j], self.max_shape_components[j], verbose=verbose)) else: self.shape_models[j].increment(aligned_shapes, verbose=verbose) # Build the deformation model if verbose: print_dynamic('{}Building deformation model'.format( scale_prefix)) if self.use_procrustes: deformation_shapes = aligned_shapes else: deformation_shapes = scale_shapes if not increment: self.deformation_models.append(self._build_deformation_model( deformation_shapes, self.deformation_graph[j], verbose=verbose)) else: self.deformation_models[j].increment(deformation_shapes, verbose=verbose) # Obtain warped images warped_images = self._warp_images(scaled_images, scale_shapes, j, scale_prefix, verbose) # Build the appearance model if verbose: print_dynamic('{}Building appearance model'.format( scale_prefix)) if not increment: self.appearance_models.append(self._build_appearance_model( warped_images, self.appearance_graph[j], self.n_appearance_components[j], verbose=verbose)) else: self._increment_appearance_model( warped_images, self.appearance_graph[j], self.appearance_models[j], verbose=verbose) if verbose: print_dynamic('{}Done\n'.format(scale_prefix))