def __init__(self, images, group=None, bounding_box_group_glob=None, verbose=False, reference_shape=None, diagonal=None, scales=(0.5, 1.0), n_perturbations=30, n_dlib_perturbations=1, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, n_iterations=10, feature_padding=0, n_pixel_pairs=400, distance_prior_weighting=0.1, regularisation_weight=0.1, n_split_tests=20, n_trees=500, n_tree_levels=5): checks.check_diagonal(diagonal) self.diagonal = diagonal self.scales = checks.check_scales(scales) self.holistic_features = checks.check_features(no_op, self.n_scales) self.reference_shape = reference_shape self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, self.n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box self._setup_dlib_options(feature_padding, n_pixel_pairs, distance_prior_weighting, regularisation_weight, n_split_tests, n_trees, n_dlib_perturbations, n_tree_levels) self._setup_algorithms() # Train DLIB over multiple scales self._train(images, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose)
def __init__(self, images, group=None, bounding_box_group_glob=None, reference_shape=None, sd_algorithm_cls=Newton, holistic_features=no_op, patch_features=no_op, patch_shape=(17, 17), diagonal=None, scales=(0.5, 1.0), n_iterations=6, n_perturbations=30, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, batch_size=None, verbose=False): # check parameters checks.check_diagonal(diagonal) scales = checks.check_scales(scales) n_scales = len(scales) patch_features = checks.check_features(patch_features, n_scales) holistic_features = checks.check_features(holistic_features, n_scales) patch_shape = checks.check_patch_shape(patch_shape, n_scales) # set parameters self.algorithms = [] self.reference_shape = reference_shape self._sd_algorithm_cls = sd_algorithm_cls self.holistic_features = holistic_features self.patch_features = patch_features self.patch_shape = patch_shape self.diagonal = diagonal self.scales = scales self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box # set up algorithms self._setup_algorithms() # Now, train the model! self._train(images,increment=False, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose, batch_size=batch_size)
def _fit(self, images, initial_shape, gt_shapes=None, max_iters=20, **kwargs): # Perform check max_iters = checks.check_max_iters(max_iters, self.n_scales) # Set initial and ground truth shapes shape = initial_shape gt_shape = None # Initialize list of algorithm results algorithm_results = [] for i in range(self.n_scales): # Handle ground truth shape if gt_shapes is not None: gt_shape = gt_shapes[i] # Run algorithm algorithm_result = self.algorithms[i].run(images[i], shape, gt_shape=gt_shape, max_iters=max_iters[i], **kwargs) # Add algorithm result to the list algorithm_results.append(algorithm_result) # Prepare this scale's final shape for the next scale shape = algorithm_result.final_shape if self.scales[i] != self.scales[-1]: shape = Scale(self.scales[i + 1] / self.scales[i], n_dims=shape.n_dims).apply(shape) # Return list of algorithm results return algorithm_results
def _fit(self, images, initial_shape, gt_shapes=None, max_iters=20, **kwargs): r""" Fits the fitter to the multilevel pyramidal images. Parameters ----------- images: :class:`menpo.image.masked.MaskedImage` list The images to be fitted. initial_shape: :class:`menpo.shape.PointCloud` The initial shape from which the fitting will start. gt_shapes: :class:`menpo.shape.PointCloud` list, optional The original ground truth shapes associated to the multilevel images. max_iters: int or list, optional The maximum number of iterations. If int, then this will be the overall maximum number of iterations for all the pyramidal levels. If list, then a maximum number of iterations is specified for each pyramidal level. Returns ------- algorithm_results: :class:`FittingResult` list The fitting object containing the state of the whole fitting procedure. """ # Perform check max_iters = checks.check_max_iters(max_iters, self.n_scales) # Set initial and ground truth shapes shape = initial_shape gt_shape = None # Initialize list of algorithm results algorithm_results = [] for i in range(self.n_scales): # Handle ground truth shape if gt_shapes is not None: gt_shape = gt_shapes[i] # Run algorithm algorithm_result = self.algorithms[i].run(images[i], shape, gt_shape=gt_shape, max_iters=max_iters[i], **kwargs) # Add algorithm result to the list algorithm_results.append(algorithm_result) # Prepare this scale's final shape for the next scale shape = algorithm_result.final_shape if self.scales[i] != self.scales[-1]: shape = Scale(self.scales[i + 1] / self.scales[i], n_dims=shape.n_dims).apply(shape) # Return list of algorithm results return algorithm_results
def __init__(self, images, group=None, bounding_box_group_glob=None, reference_shape=None, diagonal=None, scales=(0.5, 1.0), n_perturbations=30, n_dlib_perturbations=1, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, n_iterations=10, feature_padding=0, n_pixel_pairs=400, distance_prior_weighting=0.1, regularisation_weight=0.1, n_split_tests=20, n_trees=500, n_tree_levels=5, verbose=False): checks.check_diagonal(diagonal) scales = checks.check_scales(scales) n_scales = len(scales) # Dummy option that is required by _prepare_image of MultiFitter. holistic_features = checks.check_callable(no_op, n_scales) # Call superclass super(DlibERT, self).__init__(scales=scales, reference_shape=reference_shape, holistic_features=holistic_features, algorithms=[]) # Set parameters self.diagonal = diagonal self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box # DLib options self._setup_dlib_options(feature_padding, n_pixel_pairs, distance_prior_weighting, regularisation_weight, n_split_tests, n_trees, n_dlib_perturbations, n_tree_levels) # Set-up algorithms for j in range(self.n_scales): self.algorithms.append( DlibAlgorithm(self._dlib_options_templates[j], n_iterations=self.n_iterations[j])) # Train DLIB over multiple scales self._train(images, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose)
def __init__( self, images, group=None, bounding_box_group_glob=None, reference_shape=None, sd_algorithm_cls=None, holistic_features=no_op, patch_features=no_op, patch_shape=(17, 17), diagonal=None, scales=(0.5, 1.0), n_iterations=3, n_perturbations=30, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, batch_size=None, verbose=False, ): if batch_size is not None: raise NotImplementedError("Training an SDM with a batch size " "(incrementally) is not implemented yet.") # check parameters checks.check_diagonal(diagonal) scales = checks.check_scales(scales) n_scales = len(scales) patch_features = checks.check_callable(patch_features, n_scales) sd_algorithm_cls = checks.check_callable(sd_algorithm_cls, n_scales) holistic_features = checks.check_callable(holistic_features, n_scales) patch_shape = checks.check_patch_shape(patch_shape, n_scales) # set parameters self.algorithms = [] self.reference_shape = reference_shape self._sd_algorithm_cls = sd_algorithm_cls self.holistic_features = holistic_features self.patch_features = patch_features self.patch_shape = patch_shape self.diagonal = diagonal self.scales = scales self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box # set up algorithms self._setup_algorithms() # Now, train the model! self._train( images, increment=False, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose, batch_size=batch_size, )
def __init__(self, images, group=None, bounding_box_group_glob=None, reference_shape=None, sd_algorithm_cls=None, holistic_features=no_op, patch_features=no_op, patch_shape=(17, 17), diagonal=None, scales=(0.5, 1.0), n_iterations=3, n_perturbations=30, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, batch_size=None, verbose=False): if batch_size is not None: raise NotImplementedError( 'Training an SDM with a batch size ' '(incrementally) is not implemented yet.') # check parameters checks.check_diagonal(diagonal) scales = checks.check_scales(scales) n_scales = len(scales) patch_features = checks.check_callable(patch_features, n_scales) sd_algorithm_cls = checks.check_callable(sd_algorithm_cls, n_scales) holistic_features = checks.check_callable(holistic_features, n_scales) patch_shape = checks.check_patch_shape(patch_shape, n_scales) # set parameters self.algorithms = [] self.reference_shape = reference_shape self._sd_algorithm_cls = sd_algorithm_cls self.holistic_features = holistic_features self.patch_features = patch_features self.patch_shape = patch_shape self.diagonal = diagonal self.scales = scales self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box # set up algorithms self._setup_algorithms() # Now, train the model! self._train(images, increment=False, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose, batch_size=batch_size)
def __init__(self, images, group=None, bounding_box_group_glob=None, verbose=False, reference_shape=None, diagonal=None, scales=(0.5, 1.0), n_perturbations=30, n_dlib_perturbations=1, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, n_iterations=10, feature_padding=0, n_pixel_pairs=400, distance_prior_weighting=0.1, regularisation_weight=0.1, n_split_tests=20, n_trees=500, n_tree_levels=5): checks.check_diagonal(diagonal) self.diagonal = diagonal self.scales = checks.check_scales(scales) self.holistic_features = checks.check_callable(no_op, self.n_scales) self.reference_shape = reference_shape self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, self.n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box self._setup_dlib_options(feature_padding, n_pixel_pairs, distance_prior_weighting, regularisation_weight, n_split_tests, n_trees, n_dlib_perturbations, n_tree_levels) self._setup_algorithms() # Train DLIB over multiple scales self._train(images, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose)
def __init__(self, images, group=None, bounding_box_group_glob=None, reference_shape=None, diagonal=None, scales=(0.5, 1.0), n_perturbations=30, n_dlib_perturbations=1, perturb_from_gt_bounding_box=noisy_shape_from_bounding_box, n_iterations=10, feature_padding=0, n_pixel_pairs=400, distance_prior_weighting=0.1, regularisation_weight=0.1, n_split_tests=20, n_trees=500, n_tree_levels=5, verbose=False): checks.check_diagonal(diagonal) scales = checks.check_scales(scales) n_scales = len(scales) # Dummy option that is required by _prepare_image of MultiFitter. holistic_features = checks.check_callable(no_op, n_scales) # Call superclass super(DlibERT, self).__init__( scales=scales, reference_shape=reference_shape, holistic_features=holistic_features, algorithms=[]) # Set parameters self.diagonal = diagonal self.n_perturbations = n_perturbations self.n_iterations = checks.check_max_iters(n_iterations, n_scales) self._perturb_from_gt_bounding_box = perturb_from_gt_bounding_box # DLib options self._setup_dlib_options(feature_padding, n_pixel_pairs, distance_prior_weighting, regularisation_weight, n_split_tests, n_trees, n_dlib_perturbations, n_tree_levels) # Set-up algorithms for j in range(self.n_scales): self.algorithms.append(DlibAlgorithm( self._dlib_options_templates[j], n_iterations=self.n_iterations[j])) # Train DLIB over multiple scales self._train(images, group=group, bounding_box_group_glob=bounding_box_group_glob, verbose=verbose)
def _fit(self, images, initial_shape, affine_transforms, scale_transforms, gt_shapes=None, max_iters=20, return_costs=False, **kwargs): r""" Function the applies the multi-scale fitting procedure on an image, given the initial shape. Parameters ---------- images : `list` of `menpo.image.Image` The list of images per scale. initial_shape : `menpo.shape.PointCloud` The initial shape estimate from which the fitting procedure will start. affine_transforms : `list` of `menpo.transform.Affine` The list of affine transforms per scale that are the inverses of the transformations introduced by the rescale wrt the reference shape as well as the feature extraction. scale_transforms : `list` of `menpo.shape.Scale` The list of inverse scaling transforms per scale. gt_shapes : `list` of `menpo.shape.PointCloud` The list of ground truth shapes per scale. max_iters : `int` or `list` of `int`, optional The maximum number of iterations. If `int`, then it specifies the maximum number of iterations over all scales. If `list` of `int`, then specifies the maximum number of iterations per scale. return_costs : `bool`, optional If ``True``, then the cost function values will be computed during the fitting procedure. Then these cost values will be assigned to the returned `fitting_result`. *Note that the costs computation increases the computational cost of the fitting. The additional computation cost depends on the fitting method. Only use this option for research purposes.* kwargs : `dict`, optional Additional keyword arguments that can be passed to specific implementations. Returns ------- algorithm_results : `list` of :map:`NonParametricIterativeResult` or subclass The list of fitting result per scale. """ # Check max iters max_iters = checks.check_max_iters(max_iters, self.n_scales) # Set initial and ground truth shapes shape = initial_shape gt_shape = None # Initialize list of algorithm results algorithm_results = [] for i in range(self.n_scales): # Handle ground truth shape if gt_shapes is not None: gt_shape = gt_shapes[i] # Run algorithm algorithm_result = self.algorithms[i].run( images[i], shape, gt_shape=gt_shape, max_iters=max_iters[i], return_costs=return_costs, **kwargs) # Add algorithm result to the list algorithm_results.append(algorithm_result) # Prepare this scale's final shape for the next scale if i < self.n_scales - 1: # This should not be done for the last scale. shape = algorithm_result.final_shape if self.holistic_features[i + 1] != self.holistic_features[i]: # If the features function of the current scale is different # than the one of the next scale, this means that the affine # transform is different as well. Thus we need to do the # following composition: # # S_{i+1} \circ A_{i+1} \circ inv(A_i) \circ inv(S_i) # # where: # S_i : scaling transform of current scale # S_{i+1} : scaling transform of next scale # A_i : affine transform of current scale # A_{i+1} : affine transform of next scale t1 = scale_transforms[i].compose_after( affine_transforms[i]) t2 = affine_transforms[i + 1].pseudoinverse().compose_after(t1) transform = scale_transforms[ i + 1].pseudoinverse().compose_after(t2) shape = transform.apply(shape) elif (self.holistic_features[i + 1] == self.holistic_features[i] and self.scales[i] != self.scales[i + 1]): # If the features function of the current scale is the same # as the one of the next scale, this means that the affine # transform is the same as well, and thus can be omitted. # Given that the scale factors are different, we need to do # the # following composition: # # S_{i+1} \circ inv(S_i) # # where: # S_i : scaling transform of current scale # S_{i+1} : scaling transform of next scale transform = scale_transforms[ i + 1].pseudoinverse().compose_after( scale_transforms[i]) shape = transform.apply(shape) # Return list of algorithm results return algorithm_results
def _fit(self, images, initial_shape, affine_transforms, scale_transforms, gt_shapes=None, max_iters=20, return_costs=False, **kwargs): r""" Function the applies the multi-scale fitting procedure on an image, given the initial shape. Parameters ---------- images : `list` of `menpo.image.Image` The list of images per scale. initial_shape : `menpo.shape.PointCloud` The initial shape estimate from which the fitting procedure will start. affine_transforms : `list` of `menpo.transform.Affine` The list of affine transforms per scale that are the inverses of the transformations introduced by the rescale wrt the reference shape as well as the feature extraction. scale_transforms : `list` of `menpo.shape.Scale` The list of inverse scaling transforms per scale. gt_shapes : `list` of `menpo.shape.PointCloud` The list of ground truth shapes per scale. max_iters : `int` or `list` of `int`, optional The maximum number of iterations. If `int`, then it specifies the maximum number of iterations over all scales. If `list` of `int`, then specifies the maximum number of iterations per scale. return_costs : `bool`, optional If ``True``, then the cost function values will be computed during the fitting procedure. Then these cost values will be assigned to the returned `fitting_result`. *Note that the costs computation increases the computational cost of the fitting. The additional computation cost depends on the fitting method. Only use this option for research purposes.* kwargs : `dict`, optional Additional keyword arguments that can be passed to specific implementations. Returns ------- algorithm_results : `list` of :map:`NonParametricIterativeResult` or subclass The list of fitting result per scale. """ # Check max iters max_iters = checks.check_max_iters(max_iters, self.n_scales) # Set initial and ground truth shapes shape = initial_shape gt_shape = None # Initialize list of algorithm results algorithm_results = [] for i in range(self.n_scales): # Handle ground truth shape if gt_shapes is not None: gt_shape = gt_shapes[i] # Run algorithm algorithm_result = self.algorithms[i].run(images[i], shape, gt_shape=gt_shape, max_iters=max_iters[i], return_costs=return_costs, **kwargs) # Add algorithm result to the list algorithm_results.append(algorithm_result) # Prepare this scale's final shape for the next scale if i < self.n_scales - 1: # This should not be done for the last scale. shape = algorithm_result.final_shape if self.holistic_features[i + 1] != self.holistic_features[i]: # If the features function of the current scale is different # than the one of the next scale, this means that the affine # transform is different as well. Thus we need to do the # following composition: # # S_{i+1} \circ A_{i+1} \circ inv(A_i) \circ inv(S_i) # # where: # S_i : scaling transform of current scale # S_{i+1} : scaling transform of next scale # A_i : affine transform of current scale # A_{i+1} : affine transform of next scale t1 = scale_transforms[i].compose_after(affine_transforms[i]) t2 = affine_transforms[i + 1].pseudoinverse().compose_after(t1) transform = scale_transforms[i + 1].pseudoinverse().compose_after(t2) shape = transform.apply(shape) elif (self.holistic_features[i + 1] == self.holistic_features[i] and self.scales[i] != self.scales[i + 1]): # If the features function of the current scale is the same # as the one of the next scale, this means that the affine # transform is the same as well, and thus can be omitted. # Given that the scale factors are different, we need to do # the # following composition: # # S_{i+1} \circ inv(S_i) # # where: # S_i : scaling transform of current scale # S_{i+1} : scaling transform of next scale transform = scale_transforms[i + 1].pseudoinverse().compose_after(scale_transforms[i]) shape = transform.apply(shape) # Return list of algorithm results return algorithm_results