---

OkapiRetMethod.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2001 Carnegie Mellon University.  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
 *
 *==========================================================================
*/


#ifndef _OKAPIRETMETHOD_HPP
#define _OKAPIRETMETHOD_HPP

#include "TextQueryRep.hpp"
#include "ScoreFunction.hpp"
#include "TextQueryRetMethod.hpp"
#include <cmath>


namespace OkapiParameter {
  struct TFParam {
    double k1;
    double b;
    double k3;
  }; 

  static double defaultK1 = 1.2;
  static double defaultB = 0.75;
  static double defaultK3 = 7;
  
  struct FeedbackParam {
    double expQTF; // expanded query term TF
    int howManyTerms;
  };

  static double defaultExpQTF = 0.5;
  static int defaultHowManyTerms = 50;
};


class OkapiQueryTerm : public QueryTerm {
public:
  OkapiQueryTerm(TERMID_T termID, double count, int pEstCount, double paramK3) : QueryTerm(termID, count), pEst(pEstCount), k3(paramK3) {
  }
  virtual int pEstCount() const { return pEst;}

  virtual double weight() const { 
    return ((k3+1)*w/(k3+w));
  } 
private:
  int pEst;
  double k3;
};


class OkapiScoreFunc : public ScoreFunction {
public:
  OkapiScoreFunc(const Index &dbIndex): ind(dbIndex) {}
  virtual double matchedTermWeight(const QueryTerm *qTerm, const TextQueryRep *qRep, const DocInfo *info, const DocumentRep *dRep) const;
protected:
  const Index &ind;
};


class OkapiQueryRep : public ArrayQueryRep {
public:
  // initial query constructor, no feedback docs assumed
  OkapiQueryRep(const TermQuery &qry, const Index &dbIndex, double paramK3);

  virtual ~OkapiQueryRep() { delete [] pEst; }
  int pNormCount() const { return pNorm;}
  void setPNormCount(int count) { pNorm = count;}
  void incPEst(int wdIndex, int val) { pEst[wdIndex]+=val;}
protected:
  virtual QueryTerm *makeQueryTerm(TERMID_T wdIndex, double wdCount) const{
    return (new OkapiQueryTerm(wdIndex, wdCount, pEst[wdIndex], k3));
  }
  double k3;
  int pNorm;
  int *pEst;
};


class OkapiDocRep : public DocumentRep {
public:
  OkapiDocRep(DOCID_T docID, const Index &dbIndex, OkapiParameter::TFParam &param) : DocumentRep(docID, dbIndex.docLength(docID)), ind(dbIndex),
  prm(param) {
  }
  virtual ~OkapiDocRep() { }
  virtual double termWeight(TERMID_T termID, const DocInfo *info) const;
  double BM25TF(double rawTF, double docLength) const;
  virtual double scoreConstant() const { return 0;}
protected:
  const Index &ind;
  OkapiParameter::TFParam &prm;
};


class OkapiRetMethod : public TextQueryRetMethod  {
public:


  OkapiRetMethod(const Index &dbIndex, ScoreAccumulator &accumulator);

  virtual ~OkapiRetMethod() { delete scFunc;}

  virtual TextQueryRep *computeTextQueryRep(const TermQuery &qry) {
    return (new OkapiQueryRep(qry, ind, tfParam.k3));
  }

  virtual DocumentRep *computeDocRep(DOCID_T docID) {
    return (new OkapiDocRep(docID, ind, tfParam));
  }

  virtual ScoreFunction *scoreFunc();

  virtual void updateTextQuery(TextQueryRep &origRep, const DocIDSet &relDocs);

  void setTFParam(OkapiParameter::TFParam &tfWeightParam);

  void setFeedbackParam(OkapiParameter::FeedbackParam &feedbackParam);

  static double RSJWeight(double r, double R, 

                          double n, double N) {
    return (log ((r+0.5)*(N-n-R+r+0.5)/((R-r+0.5)*(n-r+0.5))));
  }

protected:
  OkapiScoreFunc *scFunc;

  OkapiParameter::TFParam tfParam;
  OkapiParameter::FeedbackParam fbParam;


};


inline void OkapiRetMethod::setTFParam(OkapiParameter::TFParam &tfWeightParam)
{
  tfParam = tfWeightParam;
}

inline void OkapiRetMethod::setFeedbackParam(OkapiParameter::FeedbackParam &feedbackParam)
{
  fbParam = feedbackParam;
}

inline double OkapiDocRep::BM25TF(double rawTF, double docLength) const 
{
  return ((prm.k1+1)*rawTF/(rawTF +  prm.k1*(1-prm.b + prm.b*docLength/ind.docLengthAvg())));
}


inline double OkapiDocRep::termWeight(TERMID_T termID, const DocInfo *info) const
{
  return BM25TF(info->termCount(), ind.docLength(info->docID()));
} 




inline ScoreFunction *OkapiRetMethod::scoreFunc()
{
  return scFunc;
}

#endif /* _OKAPIRETMETHOD_HPP */

---