PLSA.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2003 University of Massachusetts.  All Rights Reserved.
 *
 * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
 * is subject to the terms of the software license set forth in the LICENSE
 * file included with this software, and also available at
 * http://www.lemurproject.org/license.html
 *
 *==========================================================================
 */
/*
  Probabilistic Latent Semantic Analysis 
  Java Reference implementation from Andrew Schein and Alexandrin Popescul
  Author: dmf 2/2003
*/

#ifndef _PLSA_HPP
#define _PLSA_HPP
#include "common_headers.hpp"
#include <cmath>
#include <set>
#include "Index.hpp"
#include "FreqVector.hpp"
namespace lemur 
{
  namespace cluster 
  {
    
    //forward declaration.
    class PLSA;

    // Needed to declare member function parameter (not sure why...).
    typedef double (PLSA::*jointfuncType)(int, int);


    // Need both transient and permanent versions (store model components).
    class PLSA  {
    public:
      // need to pass in many parameters. Use sensible defaults...
      // document arguments.
      PLSA(const lemur::api::Index &dbIndex, int numCats, 
           lemur::utility::HashFreqVector **train, 
           lemur::utility::HashFreqVector **validate, int numIter, 
           int numRestarts, double betastart, 
           double betastop, double anneal, double betaMod);

      PLSA(const lemur::api::Index &dbIndex, int testPercentage, int numCats, int numIter, 
           int numRestarts, double betastart, 
           double betastop, double anneal, double betaMod);
      PLSA(const lemur::api::Index &dbIndex);
      virtual ~PLSA();
    
      void iterateWithRestarts();

      double *get_p_z() const   {return p_z_best;}
      double **get_p_w_z() const {return p_w_z_best;}
      double **get_p_d_z() const {return p_d_z_best;}
      double getProb(int d, int w) const ;
      // get the matrix sizes
      int numWords() const {return sizeW;}
      int numDocs() const {return sizeD;}
      int numCats() const {return sizeZ;}
      bool readArrays();

    private:
      // attributes
      const lemur::api::Index &ind;
      int sizeZ;
      int sizeD;
      int sizeW;

      lemur::utility::HashFreqVector **data; // passed in
      lemur::utility::HashFreqVector **testData; // passed in
      set<int, less<int> > *invIndex; // constructed
  
      double startBeta, beta, betaMin;
      double betaModifier;
      double annealcue;
      int R;
      int numberOfIterations;
      int numberOfRestarts;
      double bestTestLL;
      double bestA;
      bool bestOnly;
      bool ownMem;
      double *p_z_current;
      double **p_w_z_current;
      double **p_d_z_current;

      double *p_z_prev;
      double **p_w_z_prev;
      double **p_d_z_prev;

      double *p_z_best;
      double **p_w_z_best;
      double **p_d_z_best;

      // methods
      void setPrevToCurrent();
      void setCurrentToBest();
      void setBestToCurrent();
      void setBestToPrev();
      void setPrevToBest();

      double getAverageLikelihood();
      double getAverageLikelihoodPrev();

      double jointEstimate (int indexD, int indexW);
      double jointEstimateCurrent (int indexD, int indexW);
      double jointEstimateBest (int indexD, int indexW);
      double jointEstimateBeta (int indexD, int indexW);
  
      void iterate();
      void initializeParameters();

      double doLogLikelihood(jointfuncType, lemur::utility::HashFreqVector **&myData);
      double logLikelihood();
      double validateDataLogLikelihood();
      double validateCurrentLogLikelihood();
      double bestDataLogLikelihood();
      double interleavedIterationEM();
      void selectTestTrain(int testPercent);
      void init();
      void initR();
      enum pType {P_Z = 0, P_W_Z = 1, P_D_Z = 2};
      void writeArrays();  
      bool readArray(ifstream& infile, enum pType which);
      void writeArray(ofstream& ofile, enum pType which);
    };
  }
}

#endif /* _PLSA_HPP */

---