ArtificialLandscapes.hpp

Go to the documentation of this file.

#ifndef ARTIFICIALLANDSCAPES_HPP_
#define ARTIFICIALLANDSCAPES_HPP_

#include <types/MatrixTypes.hpp>

namespace mic {
namespace neural_nets {
namespace optimization {
namespace artificial_landscapes {

template <typename eT=float>
class DifferentiableFunction {
public:
    DifferentiableFunction (size_t dims_) : dims(dims_) {
        assert (dims > 0);
    }

    virtual ~DifferentiableFunction () { }

    // Abstract method responsible for calculation of the function value.
    virtual eT calculateValue(mic::types::MatrixPtr<eT> x_) = 0;

    // Abstract method responsible for calculation of the a gradient in a given point.
    virtual mic::types::MatrixPtr<eT> calculateGradient(mic::types::MatrixPtr<eT> x_) = 0;

    mic::types::MatrixPtr<eT> minArguments () { return min_arguments; }

    eT minValue() { return min_value; }

protected:
    size_t dims;

    mic::types::MatrixPtr<eT> min_arguments;

    eT min_value;
};



template <typename eT=float>
class SphereFunction : public DifferentiableFunction<eT> {
public:

    SphereFunction(size_t dims_) : DifferentiableFunction<eT>(dims_) {
        // Set minimum.
        this->min_arguments = MAKE_MATRIX_PTR(eT, this->dims, 1);
        this->min_arguments->zeros();
        this->min_value = 0;
    }

    eT calculateValue(mic::types::MatrixPtr<eT> x_) {
        assert((size_t)x_->size() == this->dims);
        // Calculate sum of x^2.
        eT val = 0;
        for (size_t i=0; i<this->dims; i++)
            val += (*x_)[i] * (*x_)[i];
        return val;
    }

    mic::types::MatrixPtr<eT> calculateGradient(mic::types::MatrixPtr<eT> x_) {
        assert((size_t)x_->size() == this->dims);

        // Calculate gradients.
        mic::types::MatrixPtr<eT> dx = MAKE_MATRIX_PTR(eT, this->dims, 1);
        for (size_t i=0; i<this->dims; i++)
            (*dx)[i] = 2 * (*x_)[i];

        return dx;
    }
};


template <typename eT=float>
class Beale2DFunction  : public DifferentiableFunction<eT> {
public:

    Beale2DFunction() : DifferentiableFunction<eT>(2) {
        // Set minimum.
        this->min_arguments = MAKE_MATRIX_PTR(eT, this->dims, 1);
        (*this->min_arguments)[0] = 3;
        (*this->min_arguments)[1] = 0.5;
        this->min_value = 0.0;
    }

    eT calculateValue(mic::types::MatrixPtr<eT> x_) {
        assert((size_t)x_->size() == this->dims);

        // Calculate value.
        eT x = (*x_)[0];
        eT y = (*x_)[1];

        eT a = (1.5 - x + x*y);
        eT b = (2.25 - x + x * y * y);
        eT c = (2.625 - x  + x * y * y * y);
        return a*a + b*b + c*c;
    }

    mic::types::MatrixPtr<eT> calculateGradient(mic::types::MatrixPtr<eT> x_) {
        assert((size_t)x_->size() == this->dims);

        mic::types::MatrixPtr<double> dx = MAKE_MATRIX_PTR(eT, this->dims, 1);

        // Calculate gradients.
        eT x = (*x_)[0];
        eT y = (*x_)[1];

        eT ax = 2*(1.5 - x + x*y) * (-1 + y);
        eT bx = 2*(2.25 - x + x * y * y) * ( - 1 + y * y);
        eT cx = 2*(2.625 - x  + x * y * y * y) * ( - 1 + y * y * y);

        eT ay = 2*(1.5 - x + x*y) * (x);
        eT by = 2*(2.25 - x + x * y * y) * (2*x*y);
        eT cy = 2*(2.625 - x  + x * y * y * y) * (3*x*y*y);

        (*dx)[0] = ax + bx +cx;
        (*dx)[1] = ay + by +cy;

        return dx;
    }
};




template <typename eT=float>
class Rosenbrock2DFunction  : public DifferentiableFunction<eT> {
public:

    Rosenbrock2DFunction(eT a_ = 1, eT b_ = 100) : DifferentiableFunction<eT>(2), a(a_), b(b_) {
        // Set minimum.
        this->min_arguments = MAKE_MATRIX_PTR(eT, this->dims, 1);
        (*this->min_arguments)[0] = a;
        (*this->min_arguments)[1] = a*a;
        this->min_value = 0.0;
    }

    eT calculateValue(mic::types::MatrixPtr<eT> x_) {
        assert((size_t)x_->size() == this->dims);

        // Calculate value.
        eT x = (*x_)[0];
        eT y = (*x_)[1];

        eT p1 = (a - x) * (a - x);
        eT p2 = b * (y - x * x) * (y - x * x);
//      std::cout << "p1 = " << p1 << " p2 = " << p2 << std::endl;
        return p1 + p2;
    }

    mic::types::MatrixPtr<eT> calculateGradient(mic::types::MatrixPtr<eT> x_) {
        assert((size_t)x_->size() == this->dims);

        mic::types::MatrixPtr<eT> dx = MAKE_MATRIX_PTR(eT, this->dims, 1);

        // Calculate gradients.
        eT x = (*x_)[0];
        eT y = (*x_)[1];

        eT p1x = -2 * (a - x);
        eT p2x = 2 * b * (y - x * x) * (-2 * x) ;
//      std::cout << "p1x = " << p1x << " p2x = " << p2x << std::endl;

        eT p1y = 0;
        eT p2y = 2 * b * (y - x * x) ;
//      std::cout << "p1y = " << p1y << " p2y = " << p2y << std::endl;

        (*dx)[0] = p1x + p2x;
        (*dx)[1] = p1y + p2y;

        return dx;
    }

private:
    eT a, b;
};


} //: artificial_landscapes
} //: optimization
} //: neural_nets
} //: mic


#endif /* ARTIFICIALLANDSCAPES_HPP_ */