/usr/include/kido/optimizer/GradientDescentSolver.hpp is in libkido-dev 0.1.0+dfsg-2build9.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 | /*
* Copyright (c) 2015, Georgia Tech Research Corporation
* All rights reserved.
*
* Author(s): Michael X. Grey <mxgrey@gatech.edu>
*
* Georgia Tech Graphics Lab and Humanoid Robotics Lab
*
* Directed by Prof. C. Karen Liu and Prof. Mike Stilman
* <karenliu@cc.gatech.edu> <mstilman@cc.gatech.edu>
*
* This file is provided under the following "BSD-style" License:
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef KIDO_OPTIMIZER_GRADIENTDESCENTSOLVER_HPP_
#define KIDO_OPTIMIZER_GRADIENTDESCENTSOLVER_HPP_
#include <random>
#include "kido/optimizer/Solver.hpp"
namespace kido {
namespace optimizer {
/// DefaultSolver is a Solver extension which is native to KIDO (rather than
/// relying on third-party libraries). It uses randomized gradient descent and
/// softened constraints (i.e. constraint functions are added into the
/// objective function and assigned weights) to solve nonlinear problems. Note
/// that this is not a good option for Problems with difficult constraint
/// functions that need to be solved exactly.
class GradientDescentSolver : public Solver
{
public:
static const std::string Type;
struct UniqueProperties
{
/// Value of the fixed step size
double mStepSize;
/// Number of attempts to make before quitting. Each attempt will start from
/// the next seed provided by the problem. Once there are no more seeds,
/// random starting configurations will be used.
///
/// Set this to 0 to keep trying until a solution is found (the program will
/// need to be interrupted in order to stop if no solution is being found).
size_t mMaxAttempts;
/// The number of steps between random perturbations being applied to the
/// configuration. Set this to 0 to never apply randomized perturbations.
size_t mPerturbationStep;
/// The random perturbation works as follows: A random point in the domain
/// of the Problem is selected, and then a random step size between 0 and
/// mMaxPerturbationFactor is selected. The configuration will take a step
/// of that random step size towards the random point.
///
/// A maximum value of 1.0 is recommended for mMaxPerturbationFactor. A
/// smaller value will result in smaller randomized perturbations. A value
/// significantly larger than 1.0 could bias the configuration towards the
/// boundary of the Problem domain.
double mMaxPerturbationFactor;
/// The largest permittable change in value when randomizing a configuration
double mMaxRandomizationStep;
/// This is the weight that will be applied to any constraints that do not
/// have a corresponding weight specified by mEqConstraintWeights or by
/// mIneqConstraintWeights
double mDefaultConstraintWeight;
/// Vector of weights that should be applied to the equality constraints.
/// If there are fewer components in this vector than there are equality
/// constraints in the Problem, then the remaining equality constraints will
/// be assigned a weight of mDefaultConstraintWeight.
Eigen::VectorXd mEqConstraintWeights;
/// Vector of weights that should be applied to the inequality constraints.
/// If there are fewer components in this vector than there are inequality
/// constraints in the Problem, then the remaining inequality constraints
/// will be assigned a weight of mDefaultConstraintWeight.
Eigen::VectorXd mIneqConstraintWeights;
UniqueProperties(
double _stepMultiplier = 0.1,
size_t _maxAttempts = 1,
size_t _perturbationStep = 0,
double _maxPerturbationFactor = 1.0,
double _maxRandomizationStep = 1e10,
double _defaultConstraintWeight = 1.0,
Eigen::VectorXd _eqConstraintWeights = Eigen::VectorXd(),
Eigen::VectorXd _ineqConstraintWeights = Eigen::VectorXd() );
};
struct Properties : Solver::Properties, UniqueProperties
{
Properties(
const Solver::Properties& _solverProperties = Solver::Properties(),
const UniqueProperties& _descentProperties = UniqueProperties() );
};
/// Default constructor
explicit GradientDescentSolver(const Properties& _properties = Properties());
/// Alternative constructor
explicit GradientDescentSolver(std::shared_ptr<Problem> _problem);
/// Destructor
virtual ~GradientDescentSolver();
// Documentation inherited
virtual bool solve() override;
/// Get the last configuration that was used by the Solver
Eigen::VectorXd getLastConfiguration() const;
// Documentation inherited
virtual std::string getType() const override;
// Documentation inherited
virtual std::shared_ptr<Solver> clone() const override;
/// Set the Properties of this GradientDescentSolver
void setProperties(const Properties& _properties);
/// Set the Properties of this GradientDescentSolver
void setProperties(const UniqueProperties& _properties);
/// Get the Properties of this GradientDescentSolver
Properties getGradientDescentProperties() const;
/// Copy the Properties of another GradientDescentSolver
void copy(const GradientDescentSolver& _other);
/// Copy the Properties of another GradientDescentSolver
GradientDescentSolver& operator=(const GradientDescentSolver& _other);
/// Set the multiplier for the step size
void setStepSize(double _newMultiplier);
/// Get the multiplier for the step size
double getStepSize() const;
/// Set the maximum number of solving attempts before quitting. Each attempt
/// will use getNumMaxIterations() steps. When a new attempt is started, it
/// will use the next seed in the list of seeds. If we've reached the end of
/// the list of seeds, the attempt will start from a randomized configuration.
void setMaxAttempts(size_t _maxAttempts);
/// Get the maximum number of solving attempts.
size_t getMaxAttempts() const;
/// Set the number of steps that will be taken before applying a randomized
/// perturbation.
void setPerturbationStep(size_t _step);
/// Get UniqueProperties::mPerturbationStep
size_t getPerturbationStep() const;
/// Set UniqueProperties::mPerturbationFactor
void setMaxPerturbationFactor(double _factor);
/// Get UniqueProperties::mPerturbationFactor
double getMaxPerturbationFactor() const;
/// Set UniqueProperties::mDefaultConstraintWeight
void setDefaultConstraintWeight(double _newDefault);
/// Get UniqueProperties::mDefaultConstraintWeight
double getDefaultConstraintWeight() const;
/// Set UniqueProperties::mEqConstraintWeights
Eigen::VectorXd& getEqConstraintWeights();
/// Get UniqueProperties::mEqConstraintWeights
const Eigen::VectorXd& getEqConstraintWeights() const;
/// Set UniqueProperties::mIneqConstraintWeights
Eigen::VectorXd& getIneqConstraintWeights();
/// Get UniqueProperties::mIneqConstraintWeights
const Eigen::VectorXd& getIneqConstraintWeights() const;
/// Randomize the configuration based on this Solver's settings
void randomizeConfiguration(Eigen::VectorXd& _x);
/// Clamp the configuration to the limits of the Problem
void clampToBoundary(Eigen::VectorXd& _x);
/// Get the number of iterations used in the last attempt to solve the problem
size_t getLastNumIterations() const;
protected:
/// GradientDescentSolver properties
UniqueProperties mGradientP;
/// The last number of iterations performed by this Solver
size_t mLastNumIterations;
/// Randomization device
std::random_device mRD;
/// Mersenne twister method
std::mt19937 mMT;
/// Distribution
std::uniform_real_distribution<double> mDistribution;
/// Cache to track the costs of equality constraints
Eigen::VectorXd mEqConstraintCostCache;
/// Cache to track the costs of inequality constraints
Eigen::VectorXd mIneqConstraintCostCache;
/// The last config reached by this Solver
Eigen::VectorXd mLastConfig;
};
} // namespace optimizer
} // namespace kido
#endif // KIDO_OPTIMIZER_GRADIENTDESCENTSOLVER_HPP_
|