SparseDictionary.h

// Sparse Dictionary class interface
// Written by Sergey G. Kosov in 2016 for Project X (based on Xingdi (Eric) Yuan implementation)
#pragma once

#include "types.h"

namespace DirectGraphicalModels { namespace fex
{
    const float SC_LRATE_W = 5e-2f;     
    const float SC_LRATE_D = 1e-2f;     

    const float SC_LAMBDA  = 5e-5f;     
    const float SC_EPSILON = 1e-5f;     
    const float SC_GAMMA   = 1e-2f;     


    // ================================ Sparse Dictionary Class ==============================
    class CSparseDictionary
    {
    public:
        CSparseDictionary(void) : m_D(Mat()) { }
        virtual ~CSparseDictionary(void) {}

        DllExport void train(const Mat &X, word nWords, dword batch = 2000, unsigned int nIt = 1000, float lRate = SC_LRATE_D, const std::string &fileName = std::string());
        DllExport void save(const std::string &fileName) const;
        DllExport void load(const std::string &fileName);
        DllExport bool empty(void) const { return m_D.empty(); }
        DllExport Mat getDictionary(void) const { return m_D; }
        DllExport static Mat getDictionary(const std::string &fileName)
        {
            CSparseDictionary me;
            me.load(fileName);
            return me.getDictionary();
        }
        DllExport int getBlockSize(void) const { return empty() ? 0 : static_cast<int>(sqrt(m_D.cols)); }
        DllExport word getNumWords(void) const { return empty() ? 0 : static_cast<word>(m_D.rows); }

#ifdef DEBUG_MODE   // --- Debugging ---

        DllExport Mat TEST_decode(const Mat &X, cv::Size imgSize) const;
#endif              // --- --------- ---

        DllExport static Mat img2data(const Mat &img, int blockSize, float varianceThreshold = 0.0f);
        DllExport static Mat data2img(const Mat &X, cv::Size imgSize);


    protected:
        DllExport static void calculate_W(const Mat &X, const Mat& D, Mat &W, float lambda, float epsilon, unsigned int nIt = 800, float lRate = SC_LRATE_W);
        DllExport static void calculate_D(const Mat &X, Mat &D, const Mat &W, float gamma, unsigned int nIt = 800, float lRate = SC_LRATE_D);


    private:
        Mat     m_D;                    


    protected:
        enum grad_type { GRAD_D, GRAD_W };
        static Mat calculateGradient(grad_type gType, const Mat &X, const Mat &D, const Mat &W, float lambda, float epsilon, float gamma);
        static float calculateCost(const Mat &X, const Mat &D, const Mat &W, float lambda, float epsilon, float gamma);
    };

} }