Libs/Optimize/GradientDescentOptimizer.h

Namespaces

Name
shapeworks User usage reporting (telemetry)

Classes

	Name
class	shapeworks::GradientDescentOptimizer Optimizes particle system positions using gradient descent.

Source code

#pragma once

#include <functional>
#include <vector>

#include "EarlyStoppingConfig.h"
#include "Libs/Optimize/Domain/ImageDomainWithGradients.h"
#include "Libs/Optimize/Function/EarlyStop/EarlyStopping.h"
#include "Libs/Optimize/Function/VectorFunction.h"
#include "ParticleSystem.h"

namespace shapeworks {

class GradientDescentOptimizer {
 public:
  static constexpr unsigned int Dimension = 3;

  using VectorType = VectorFunction::VectorType;

  using PointType = ParticleSystem::PointType;

  void start_optimization() { start_adaptive_gauss_seidel_optimization(); }
  void start_adaptive_gauss_seidel_optimization();
  void set_early_stopping_config(const EarlyStoppingConfig& config);
  void initialize_early_stopping_score_function(const ParticleSystem* p);

  void augmented_lagrangian_constraints(VectorType& gradient, const PointType& pt, const size_t& dom,
                                        const double& maximum_update_allowed, size_t index);

  void stop_optimization() { stop_optimization_ = true; }

  void abort_processing() {
    stop_optimization_ = true;
    abort_processing_ = true;
  }

  unsigned int get_number_of_iterations() const { return number_of_iterations_; }

  void set_number_of_iterations(unsigned int val) { number_of_iterations_ = val; }

  void set_verbosity(unsigned int val) { verbosity_ = val; }

  unsigned int get_verbosity() const { return verbosity_; }

  double get_time_step() const { return time_step_; }

  void set_time_step(double val) { time_step_ = val; }

  unsigned int get_maximum_number_of_iterations() const { return max_iterations_; }

  void set_maximum_number_of_iterations(unsigned int val) { max_iterations_ = val; }

  double get_tolerance() const { return tolerance_; }

  void set_tolerance(double val) { tolerance_ = val; }

  ParticleSystem* get_particle_system() { return particle_system_.GetPointer(); }

  const ParticleSystem* get_particle_system() const { return particle_system_.GetPointer(); }

  void set_particle_system(ParticleSystem* val) { particle_system_ = val; }

  std::shared_ptr<VectorFunction> get_gradient_function() { return gradient_function_; }

  std::shared_ptr<const VectorFunction> get_gradient_function() const { return gradient_function_; }

  void set_gradient_function(std::shared_ptr<VectorFunction> val) { gradient_function_ = val; }

  void set_initialization_mode(bool b) { initialization_mode_ = b; }

  void set_check_iterations(size_t si) { check_iterations_ = si; }

  void set_initialization_start_scaling_factor(double si) { init_start_scaling_factor_ = si; }

  void set_iteration_callback(std::function<void()> callback) { iteration_callback_ = callback; }

  std::function<void()> get_iteration_callback() const { return iteration_callback_; }

  GradientDescentOptimizer();

  ~GradientDescentOptimizer() = default;

 private:
  GradientDescentOptimizer(const GradientDescentOptimizer&) = delete;

  GradientDescentOptimizer& operator=(const GradientDescentOptimizer&) = delete;

  void reset_time_step_vectors();

  ParticleSystem::Pointer particle_system_;
  std::shared_ptr<VectorFunction> gradient_function_;
  bool stop_optimization_ = false;
  bool abort_processing_ = false;
  unsigned int number_of_iterations_ = 0;
  unsigned int max_iterations_ = 0;
  double tolerance_ = 0.0;
  double time_step_ = 1.0;
  std::vector<std::vector<double>> time_steps_;
  unsigned int verbosity_ = 0;
  EarlyStopping early_stopping_;
  bool early_stopping_enabled_ = false;
  bool early_stopping_score_ready_ = false;

  // Adaptive Initialization variables
  bool initialization_mode_ = false;
  size_t check_iterations_ = 50;
  double init_start_scaling_factor_ = 0.0;

  // Iteration callback
  std::function<void()> iteration_callback_;
};

}  // namespace shapeworks

---

Updated on 2025-12-17 at 23:05:26 +0000