STK_IMixtureBridge.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.org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::Clustering
 * created on: 15 nov. 2013
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_IMIXTUREBRIDGE_H
#define STK_IMIXTUREBRIDGE_H
 
#include "STK_IMixture.h"
 
#include <DManager/include/STK_DataBridge.h>
 
namespace STK
{
 
template<class Derived>
class IMixtureBridge: public IMixture, public IRecursiveTemplate<Derived>
{
  public:
    typedef typename hidden::MixtureBridgeTraits<Derived>::Mixture Mixture;
    typedef typename hidden::MixtureBridgeTraits<Derived>::Data Data;
    typedef typename hidden::MixtureBridgeTraits<Derived>::Type Type;
    typedef typename hidden::MixtureBridgeTraits<Derived>::Parameters Parameters;
    typedef typename hidden::MixtureBridgeTraits<Derived>::MissingIndexes MissingIndexes;
    typedef typename hidden::MixtureBridgeTraits<Derived>::MissingValues MissingValues;
    typedef typename MissingIndexes::const_iterator ConstIterator;
 
    enum
    {
      // class of mixture
      idMixtureClass_ = hidden::MixtureBridgeTraits<Derived>::idMixtureClass_
    };
 
 
  protected:
    IMixtureBridge( Data* p_data, String const& idData, int nbCluster);
    IMixtureBridge( IMixtureBridge const& bridge);
    IMixtureBridge( Mixture const& mixture, String const& idData, int nbCluster);
    virtual ~IMixtureBridge() {}
 
  public:
    // getters
    inline Mixture const& mixture() const { return mixture_;}
    inline MissingIndexes const& v_missing() const { return v_missing_;}
    inline Data* const p_dataij() const { return p_dataij_;}
    inline int nbMissing() const { return v_missing_.size();}
    void getMissingValues( MissingValues& data) const;
 
    // getter and setter of the parameters
    inline void getParameters( Parameters& param) const { param = mixture_.param_;}
    inline void setParameters( Parameters const& param) { mixture_.param_ = param;}
 
    // getter and setter of the parameters using an array
    template<class Array>
    inline void getParameters(Array& param) const { mixture_.getParameters(param);}
    template<class Array>
    inline void setParameters(ExprBase<Array> const& param)
    { mixture_.param_.setParameters(param.asDerived());}
 
    // start default implementation of virtual method inherited from IMixture
    inline virtual void initializeStep()
    {
      if (!p_composer())
        STKRUNTIME_ERROR_NO_ARG(IMixtureBridge::initializeStep,composer is not set);
      if (!mixture_.initializeStep()) throw Clust::initializeStepFail_;
    }
    inline virtual Real lnComponentProbability(int i, int k)
    { return mixture_.lnComponentProbability(i, k);}
    inline virtual void paramUpdateStep()
    { if (!mixture_.run( p_tik(), p_tk())) throw Clust::mStepFail_;}
    inline virtual void randomInit() { mixture_.randomInit( p_tik(), p_tk());};
    inline virtual int nbFreeParameter() const { return mixture_.computeNbFreeParameters();}
    virtual int nbMissingValues() const { return v_missing_.size();}
    inline virtual void storeIntermediateResults(int iteration)
    { mixture_.param_.updateStatistics();}
    inline virtual void releaseIntermediateResults()
    { mixture_.param_.releaseStatistics();}
    inline virtual void setParametersStep()
    { mixture_.param_.setStatistics();}
    inline virtual void finalizeStep() { mixture_.finalizeStep();}
    inline virtual void imputationStep();
    inline virtual void samplingStep();
    inline virtual void writeParameters(ostream& os) const
    { mixture_.writeParameters(p_tik(), os);}
 
  protected:
   virtual std::vector< std::pair<int,int> >::size_type findMissing();
 
    virtual void removeMissing();
 
    Mixture mixture_;
    MissingIndexes v_missing_;
    Data* p_dataij_;
};
 
/* default constructor.
 *  @param p_data pointer on the DataBridge that will be used by the bridge.
 *  @param idData id name of the mixture model
 *  @param nbCluster number of cluster
 **/
template< class Derived>
IMixtureBridge<Derived>::IMixtureBridge( Data* p_dataij, String const& idData, int nbCluster)
                                       : IMixture(idData)
                                       , mixture_(nbCluster)
                                       , v_missing_()
                                       , p_dataij_(p_dataij)
{// find coordinates of the missing values
  findMissing();
}
/* copy constructor */
template< class Derived>
IMixtureBridge<Derived>::IMixtureBridge( IMixtureBridge const& bridge)
                                       : IMixture(bridge)
                                       , mixture_(bridge.mixture_)
                                       , v_missing_(bridge.v_missing_)
                                       , p_dataij_(bridge.p_dataij_)
{}
// implementation
template< class Derived>
void IMixtureBridge<Derived>::imputationStep()
{
  for(ConstIterator it = v_missing().begin(); it!= v_missing().end(); ++it)
  { p_dataij_->elt(it->first, it->second) = mixture_.impute(it->first, it->second, p_tik()->row(it->first) );}
}
// implementation
template< class Derived>
void IMixtureBridge<Derived>::samplingStep()
{
  for(ConstIterator it = v_missing().begin(); it!= v_missing().end(); ++it)
  { p_dataij_->elt(it->first, it->second) = mixture_.sample(it->first, it->second, p_tik()->row(it->first));}
}
 
// implementation
/* protected constructor to use in order to create a bridge.
 *  @param mixture the mixture to copy
 *  @param idData id name of the mixture
 *  @param nbCluster number of cluster
 **/
template< class Derived>
IMixtureBridge<Derived>::IMixtureBridge( Mixture const& mixture, String const& idData, int nbCluster)
                                       : IMixture(idData)
                                       , mixture_(mixture)
                                       , v_missing_()
                                       , p_dataij_(0)
{}
 
template< class Derived>
std::vector< std::pair<int,int> >::size_type IMixtureBridge<Derived>::findMissing()
{
#ifdef STK_MIXTURE_VERBOSE
  stk_cout << _T("Entering IMixtureBridge<Derived>::findMissing()\n");
#endif
  if (p_dataij_)
  {
    for (int j=p_dataij_->beginCols(); j< p_dataij_->endCols(); ++j)
    {
      for (int i=p_dataij_->beginRows(); i< p_dataij_->endRows(); ++i)
      {
        if (Arithmetic<Type>::isNA(p_dataij_->elt(i,j)))
        {
          v_missing_.push_back(std::pair<int,int>(i,j));
        }
      }
    }
  }
 return v_missing_.size();
#ifdef STK_MIXTURE_VERBOSE
  stk_cout << _T("IMixtureBridge<Derived>::findMissing() terminated, nbMiss= ") << v_missing_.size() << _T("\n");
#endif
}
 
 
/* This function will be used for imputation of the missing data
 *  at the initialization (initializationStep). By default missing values
 *  in a column will be replaced by the mean or map (maximum a
 *  posteriori) value of the column.
 **/
template< class Derived>
void IMixtureBridge<Derived>::removeMissing()
{
  if (p_dataij_)
  {
    Type value = Type();
    int j, old_j = Arithmetic<int>::NA();
    for(ConstIterator it = v_missing().begin(); it!= v_missing().end(); ++it)
    {
      j = it->second; // get column
      if (j != old_j)
      {
        old_j = j;
        value =  this->asDerived().safeValue(j);
      }
      p_dataij_->elt(it->first, j) = value;
    }
  }
}
 
/* get the (imputed) missing values of a data set.
 *  @note In C++11, it will be possible to use a tuple rather that this pair of pair...
 *  @param data the array to return with the missing values
 **/
template< class Derived>
void IMixtureBridge<Derived>::getMissingValues( MissingValues& data) const
{
  data.resize(v_missing_.size());
  for(size_t i = 0; i< v_missing_.size(); ++i)
  {
    data[i].first  = v_missing_[i];
    data[i].second =  p_dataij_->elt(v_missing_[i].first, v_missing_[i].second);
  }
}
 
} // namespace STK
 
#endif /* IMIXTUREBRIDGE_H */