STK_IMixtureStatModel.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA
 
    Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::Clustering
 * created on: 16 oct. 2012
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 * Originally created by Parmeet Bhatia <b..._DOT_p..._AT_gmail_Dot_com>
 **/
 
#ifndef STK_IMIXTURESTATMODEL_H
#define STK_IMIXTURESTATMODEL_H
 
#include <StatModels/include/STK_IStatModelBase.h>
 
#include "STK_Clust_Util.h"
#include "STK_IMixtureManager.h"
#include <STatistiK/include/STK_Stat_Functors.h>
 
 
namespace STK
{
 
class IMixtureStatModel: public IStatModelBase
{
  protected:
    IMixtureStatModel( int nbSample, int nbCluster);
    IMixtureStatModel( IMixtureStatModel const& model);
 
  public:
    typedef std::vector<IMixture*>::const_iterator ConstMixtIterator;
    typedef std::vector<IMixture*>::iterator MixtIterator;
 
    virtual ~IMixtureStatModel();
 
    inline int nbCluster() const { return nbCluster_;}
    inline CPointX const& pk() const { return pk_;};
    inline CArrayXX const& tik() const { return tik_;};
    inline CPointX const& tk() const { return tk_;};
    inline CVectorXi const& zi() const { return zi_;};
    inline std::vector<IMixture*> const& v_mixtures() const { return v_mixtures_;}
 
    Real computeLnLikelihood(int i) const;
    Real computeLikelihood(int i) const;
    Real computeLnLikelihood() const;
    Real computeICL() const;
 
     IMixture* getMixture( String const& idData) const;
     void registerMixture(IMixture* p_mixture);
     void releaseMixture(String const& idData);
     int computeNbFreeParameters() const;
     int computeNbMissingValues() const;
 
    // pure virtual
    virtual IMixtureStatModel* create() const = 0;
    virtual IMixtureStatModel* clone() const = 0;
    virtual void randomInit() = 0;
    virtual Real lnComponentProbability(int i, int k) const = 0;
 
    // virtual with default implementation
    virtual void initializeStep();
 
    inline virtual void imputationStep() {}
    inline virtual void samplingStep() {}
    inline virtual void setParametersStep() {}
    inline virtual void storeIntermediateResults(int iteration) {}
    inline virtual void releaseIntermediateResults() {}
    inline virtual void finalizeStep() { setLnLikelihood(computeLnLikelihood());}
    virtual void writeParameters(ostream& os) const {};
 
    // initialization of the arrays pk_, tik_, tk_ and zi_
    template<class Array>
    void setMixtureParameters( Array const& tik);
    template<class Array, class RowVector>
    void setMixtureParameters( Array const& tik, RowVector const& pk);
    template<class RowVector>
    void setProportions( RowVector const& pk);
 
    // allow to update specific mixture parameters values
    template<class Manager, class Parameters>
    void setParameters(IMixtureManager<Manager> const& manager, String const& idData, Parameters const& param);
 
    // utilities methods
    template<class Manager>
    void createMixture(IMixtureManager<Manager>& manager);
    template<class Manager>
    IMixture* createMixture(IMixtureManager<Manager>& manager, String const& idData);
    template<class Manager>
    void removeMixture(IMixtureManager<Manager>& manager, String const& idData);
 
    template<class Manager, class Parameters>
    void getParameters(IMixtureManager<Manager> const& manager, String const& idData, Parameters& param) const;
 
    template<class Manager, class MissingValues>
    void getMissingValues(IMixtureManager<Manager> const& manager, String const& idData, MissingValues& missing) const;
 
  protected:
    inline void setNbCluster( int nbCluster) { nbCluster_ = nbCluster;}
 
    int nbCluster_;
    CPointX pk_;
    CArrayXX tik_;
    CPointX tk_;
    CVectorXi zi_;
 
    std::vector<IMixture*> v_mixtures_;
};
 
 
/* Utility method allowing to create all the mixtures handled by a mixture manager.
 *  @param manager the manager with the responsibility of the creation.
 **/
template<class DataHandler>
void IMixtureStatModel::createMixture(IMixtureManager<DataHandler>& manager)
{
  typedef typename DataHandlerBase<DataHandler>::InfoMap InfoMap;
  typedef typename InfoMap::const_iterator const_iterator;
  for ( const_iterator it=manager.p_handler()->info().begin(); it!=manager.p_handler()->info().end(); ++it)
  {
    IMixture* p_mixture = manager.createMixture(it->first, nbCluster());
#ifdef STK_MIXTURE_DEBUG
  if (!p_mixture)
  { stk_cout << _T("In IMixtureStatModel::createMixture(manager) failed.\n");}
#endif
    if (p_mixture) registerMixture(p_mixture);
  }
}
 
/* Utility method allowing to create a mixture with a given data set
 *  and register it. The Mixture Manager will find the associated model
 *  to use with this data set.
 *  @param manager the manager with the responsibility of the creation.
 *  @param idData the id name of the data to modelize.
 **/
template<class Manager>
IMixture* IMixtureStatModel::createMixture(IMixtureManager<Manager>& manager, String const& idData)
{
  IMixture* p_mixture = manager.createMixture( idData, nbCluster());
#ifdef STK_MIXTURE_DEBUG
  if (!p_mixture)
  { stk_cout << _T("In IMixtureStatModel::createMixture(manager,")<< idData << _T(") failed.\n");}
#endif
  if (p_mixture) registerMixture(p_mixture);
  return p_mixture;
}
 
/* Utility method allowing to release completely a mixture with its data set.
 *  The MixtureManager will find and release the associated data set.
 *  @param manager the manager with the responsibility of the release.
 *  @param idData the id name of the data to modelize.
 **/
template<class Manager>
void IMixtureStatModel::removeMixture(IMixtureManager<Manager>& manager, String const& idData)
{
  IMixture* p_mixture = getMixture(idData);
#ifdef STK_MIXTURE_DEBUG
  if (!p_mixture)
  { stk_cout << _T("In IMixtureStatModel::removeMixture(manager,")<< idData << _T(") failed.\n");}
#endif
  if (p_mixture)
  {
    releaseMixture(idData);
    manager.releaseDataBridge( idData);
  }
}
 
/* Utility method allowing to set the parameters to a specific mixture.
 *  @param manager the manager with the responsibility of the parameters
 *  @param idData Id of the data we want to set the parameters
 *  @param param structure which contains the parameters
 **/
template<class Manager, class Parameters>
void IMixtureStatModel::setParameters(IMixtureManager<Manager> const& manager, String const& idData, Parameters const& param)
{ IMixture* p_mixture= getMixture(idData);
  if (p_mixture) manager.setParameters(p_mixture, param);
}
/* set the mixture parameters using the posterior probabilities.
 **/
template<class Array>
void IMixtureStatModel::setMixtureParameters(Array const& tik)
{
  tik_ = tik;
  tk_ = Stat::sumByCol(tik_);
  pk_ = tk_ / nbSample();
  for (int i = tik_.beginCols(); i< tik_.endCols(); ++i)
  {
    int k;
    tik_.row(i).maxElt(k);
    zi_[i] = k;
  }
}
 
/* set the mixture parameters using the posterior probabilities.
 **/
template<class Array, class RowVector>
void IMixtureStatModel::setMixtureParameters(Array const& tik, RowVector const& pk)
{
#ifdef STK_MIXTURE_DEBUG
  if (pk_.size() != tik_.sizeCols())
  { STKRUNTIME_ERROR_2ARG(IMixtureLearner::setMixtureParameters,pk_.size(),tik_.sizeCols(),Numbers of class in tik and pk differ);}
#endif
  tik_ = tik;
  pk_  = pk;
  tk_  = Stat::sumByCol(tik_);
  for (int i = tik_.beginCols(); i< tik_.endCols(); ++i)
  {
    int k;
    tik_.row(i).maxElt(k);
    zi_[i] = k;
  }
}
 
/* set proportions */
template<class RowVector>
void IMixtureStatModel::setProportions( RowVector const& pk)
{
#ifdef STK_MIXTURE_DEBUG
  if (pk_.size() != nbCluster())
  { STKRUNTIME_ERROR_2ARG(IMixtureLearner::setProportions,pk_.size(),nbCluster(),Numbers of class in pk differs);}
#endif
  pk_  = pk;
}
 
/* Utility method allowing to get the parameters of a specific mixture.
 *  @param manager the manager with the responsibility of the parameters
 *  @param idData the Id of the data we want the parameters
 *  @param param the structure which will receive the parameters
 **/
template<class Manager, class Parameters>
void IMixtureStatModel::getParameters(IMixtureManager<Manager> const& manager, String const& idData, Parameters& param) const
{  IMixture* p_mixture= getMixture(idData);
   if (p_mixture) manager.getParameters(p_mixture, param);
}
/* Utility method allowing to get the missing values of a specific mixture.
 *  @param manager the manager with the responsibility of the parameters
 *  @param idData the Id of the data we want the parameters
 *  @param missing the structure which will receive the missing values
 **/
template<class Manager, class MissingValues>
void IMixtureStatModel::getMissingValues(IMixtureManager<Manager> const& manager, String const& idData, MissingValues& missing) const
{
  IMixture* p_mixture= getMixture(idData);
  if (p_mixture) manager.getMissingValues(p_mixture, missing);
}
 
 
 
} // namespace STK
 
#endif /* STK_IMIXTURESTATMODEL_H */