|| || || || || ||

---

BayesFusion.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_BayesFusion_h
#define Impala_Core_Table_BayesFusion_h

#include "Core/Table/Bayes.h"

namespace Impala
{
namespace Core
{
namespace Table
{


class BayesFusion : public Bayes
{
public:

    BayesFusion(String annoSetName, String genreSet, String conceptSet, String quid, 
                String setName, String genrePath, String conceptPath, 
                int nStart,int nEnd, bool bWriteTable): 
         Bayes(annoSetName, setName, genreSet, conceptSet, quid, nStart, nEnd)
    {

        mSetName = setName;

        mGenrePath = genrePath;
        mConceptPath = conceptPath;
        
        // Note: mVidSet/mImgSet has been initialized in Bayes class
        if (mIsImageSet)
        {
            mGenreSimSet = Core::Table::SimilarityTableSet::MakeFromFile(genrePath, mImgSet->GetDatabase());
            mConceptSimSet = Core::Table::SimilarityTableSet::MakeFromFile(conceptPath, mImgSet->GetDatabase());
        }
        else
        {
            mKeyframes = new Core::VideoSet::Keyframes(mVidSet, "keyframes"); 
            mGenreSimSet = Core::Table::SimilarityTableSet::MakeFromFile(genrePath, mVidSet->GetDatabase());
            mConceptSimSet = Core::Table::SimilarityTableSet::MakeFromFile(conceptPath, mVidSet->GetDatabase());
        }
        mQuidTable = mGenreSimSet->GetQuidTable();
        mTableSize = mQuidTable->Size();

        Core::Table::QuidTable* conceptQuidTable = mConceptSimSet->GetQuidTable();
        int conceptTableSize = conceptQuidTable->Size();

        //_ASSERT(mTableSize == conceptTableSize);
        if (mTableSize != conceptTableSize)
        {
            printf("ERROR: Quid Table is NOT the same for concept and genre.\n");
            return;
        }


        if ((mEnd == -1) || (mEnd > mQuidTable->Size()))
            mEnd = mQuidTable->Size();

        mWriteTable = bWriteTable;

        genreSimTable = NULL;
        conceptSimTable = NULL;

    }

    virtual ~BayesFusion()
    {
        if (NULL != genreSimTable)
            delete []genreSimTable;
        if (NULL != conceptSimTable)
            delete []conceptSimTable;

        delete mGenreSimSet;
        delete mConceptSimSet;

        delete mKeyframes;
    }

    void
    DoFusion(double alpha, bool bUseAnnoMatrix = true)
    {
        if (Initialization())
        {
            mbDumpTable = false;
            if (mbDumpTable)
            {
                DumpGenreSimilarityTableSet();
                DumpConceptSimilarityTableSet();   
            }
      
            ExecuteBayesFusion(alpha, bUseAnnoMatrix);
        }
        else
        {
            std::cout << "There are errors for initialization()." << std::endl;
        }

        int x=0;
    }

    bool
    Initialization()
    {
        //(LoadNumFromAnnotation())
        //AllocateMatrix(mProb_c_g, mConceptNum, mGenreNum);

        bool success = LoadMatrix(true);
        if (success)
        {
            for (int j=0; j<mGenreNum; j++)
                genreSimTable = new SimilarityTableSet::SimTableType*[mGenreNum];

            for (int k=0; k<mConceptNum; k++)
                conceptSimTable = new SimilarityTableSet::SimTableType*[mConceptNum];

            return true;

        } else {
            return false;
        }        
    }

    void
    DumpGenreSimilarityTableSet()
    { 
        std::cout << "SimilarityTableSet " << mGenreSimSet->GetDescription() << std::endl << std::endl;

        //for (int j=0 ; j<mGenreSimSet->NrTables() ; j++)
        //_ASSERT(mGenreNum == mGenreSimSet->NrTables());
        for (int j=0 ; j<mGenreNum ; j++)
        {
            //SimilarityTableSet::SimTableType* genreSimTable = mGenreSimSet->GetSimTable(j);
            genreSimTable[j] = mGenreSimSet->GetSimTable(j);

            std::cout << "table " << j << ", name = " << mGenreSimSet->GetName(j)
                      << std::endl;
            if (genreSimTable[j]->Size() != mQuidTable->Size())
            {
                //ILOG_ERROR("DumpRanking: simtable size doesn't match");
                printf("DumpRanking: simtable size doesn't match\n");
                continue;
            }
            String genre = mGenreSimSet->GetName(j);
            for (int i=mStart ; i<mEnd ; i++)
            {
                Quid quid = mQuidTable->Get1(i);
                //std::cout << i << ", ";
                std::cout << genre << ", ";

                if (!mIsImageSet)
                {
                    int keyId = mKeyframes->GetFrameId(quid);
                    if (keyId != -1)
                        std::cout << FileNameBase(mKeyframes->GetName(keyId)) << ", ";
                    else
                        std::cout << mVidSet->QuidToString(quid, true) << ", ";
                }
                std::cout << genreSimTable[j]->Get1(i) << std::endl;
            }
            std::cout << std::endl;
        }
        
    }

    void
    DumpConceptSimilarityTableSet()
    {
        std::cout << "SimilarityTableSet " << mConceptSimSet->GetDescription() << std::endl << std::endl;

        //for (int k=0 ; k<mConceptSimSet->NrTables() ; k++)
        //_ASSERT(mConceptNum == mConceptSimSet->NrTables());
        for (int k=0 ; k<mConceptNum ; k++)
        {
            //SimilarityTableSet::SimTableType* conceptSimTable = mConceptSimSet->GetSimTable(k);
            conceptSimTable[k] = mConceptSimSet->GetSimTable(k);

            std::cout << "table " << k << ", name = " << mConceptSimSet->GetName(k)
                      << std::endl;
            if (conceptSimTable[k]->Size() != mQuidTable->Size())
            {
                //ILOG_ERROR("DumpRanking: simtable size doesn't match");
                printf("DumpRanking: simtable size doesn't match\n");
                continue;
            }
            String concept = mConceptSimSet->GetName(k);
            for (int i=mStart ; i<mEnd ; i++)
            {
                Quid quid = mQuidTable->Get1(i);
                //std::cout << i << ", ";
                std::cout << concept << ", ";

                if (!mIsImageSet)
                {
                    int keyId = mKeyframes->GetFrameId(quid);
                    if (keyId != -1)
                        std::cout << FileNameBase(mKeyframes->GetName(keyId)) << ", ";
                    else
                        std::cout << mVidSet->QuidToString(quid, true) << ", ";
                }
                std::cout << conceptSimTable[k]->Get1(i) << std::endl;
            }
            std::cout << std::endl;
        }
    }

    void
    ExecuteBayesFusion(double alpha, bool bUseAnnoMatrix = true)
    {
        if (!bUseAnnoMatrix)
        {
            // load Prob_c_g[][] from ground truth of test set
            LoadMatrix(false);
        }

        // load genre similarity tables
        for (int j=0 ; j<mGenreNum ; j++)
            genreSimTable[j] = mGenreSimSet->GetSimTable(j);

        //for (int k=0 ; k<mConceptSimSet->NrTables() ; k++)
        //_ASSERT(mConceptNum == mConceptSimSet->NrTables());
        for (int k=0 ; k<mConceptNum ; k++)
        {
            //SimilarityTableSet::SimTableType* conceptSimTable = mConceptSimSet->GetSimTable(k);
            conceptSimTable[k] = mConceptSimSet->GetSimTable(k);

            std::cout << "table " << k << ", name = " << mConceptSimSet->GetName(k)
                      << std::endl;
            if (conceptSimTable[k]->Size() != mQuidTable->Size())
            {
                //ILOG_ERROR("DumpRanking: simtable size doesn't match");
                printf("DumpRanking: simtable size doesn't match\n");
                continue;
            }

            int nForwardCount = 0;
            int nBackwardCount = 0;
            double diffForward = 0;
            double diffBackward = 0;

            int nPosOutRangeCount=0;
            int nNegOutRangeCount=0;

            String concept = mConceptSimSet->GetName(k);
            //for (int i=mStart ; i<mEnd ; i++)
            for (int i=0 ; i<mTableSize ; i++)
            {
                Quid quid = mQuidTable->Get1(i);
                //std::cout << concept << ", ";
                /*if (!mIsImageSet)
                {
                    int keyId = mKeyframes->GetFrameId(quid);
                    if (keyId != -1)
                        std::cout << FileNameBase(mKeyframes->GetName(keyId)) << ", ";
                    else
                        std::cout << mVidSet->QuidToString(quid, true) << ", ";
                }*/
                std::cout << conceptSimTable[k]->Get1(i) << std::endl;

                // update the concept scores
                Real64 conceptOldScore = conceptSimTable[k]->Get1(i);

                Real64 sum = 0;
                for (int j=0; j<mGenreNum; j++)
                {
                    Real64 genreScore = genreSimTable[j]->Get1(i);

                    sum += mProb_c_g[k][j] * genreScore;

                    //std::cout << mProb_c_g[k][j] << "*" <<genreScore<< "+" << std:endl;
                }
                //std::cout << std::endl;

                //Real64 conceptNewScore = sum/mGenreNum;
                //Real64 conceptNewScore = sum;
                //double alpha = 0.95;
                Real64 conceptNewScore = conceptOldScore * alpha + (1-alpha)* sum;
                conceptSimTable[k]->Set1(i,conceptNewScore); // set the new concept score

                // check positive samples
                Real64 diff;
                if (tabConcept[k]->IsPositive(i))
                {
                    diff = conceptNewScore - conceptOldScore;
                    if (diff > 0)
                    {
                        diffForward += diff;
                        nForwardCount ++;
                    } 
                    else 
                    {
                        diffBackward += diff;
                        nBackwardCount ++;
                    }

                    if (conceptNewScore > 1 && mVerbose)
                    {
                        //std::cout << "[+ out of range] New Score: " << conceptNewScore << std::endl;
                        nPosOutRangeCount ++;
                    }
                }
                else
                {
                    if (conceptNewScore > 1 && mVerbose)
                    {
                        //std::cout << "[- out of range] New Score: " << conceptNewScore << std::endl;
                        nNegOutRangeCount ++;
                    }
                }
            }
            //std::cout << std::endl;

            if (mVerbose)
            {
                std::cout << "+ [pos moving] ";
                std::cout << "Forward " << nForwardCount << ": " <<  diffForward << ", ";
                std::cout << "Backward " << nBackwardCount << ": " <<  diffBackward << std::endl;

                std::cout << "+ [out of range]: " << nPosOutRangeCount << " in total" << std::endl;
                std::cout << "- [out of range]: " << nNegOutRangeCount << " in total" << std::endl;
            }              
        }

        mConceptSimSet->ComputeRanks(true);
          
        if (mWriteTable)
        {
            //mImgSet->GetFilePathSimilarityIndex(conceptSet, model,feature, "names.txt",false, false);
            //mVidSet->GetFilePathSimilarityIndex(conceptSet, model,feature, "names.txt",false, false);
            //Impala::CString outpath = ".\\SimilarityIndex\\concepts.txt\\chi2\\both2-3sift-p112213\\";
            String OutPath = mConceptPath;
            OutPath.resize(OutPath.size() - 9); // remove "names.txt"

            if (mIsImageSet)
                mConceptSimSet->Save(OutPath, mImgSet->GetDatabase(),true);
            else
                mConceptSimSet->Save(OutPath, mVidSet->GetDatabase(),true);
            std::cout << "Saving files: " << OutPath << std::endl;
        }

    }

    /*bool
    LoadNumFromAnnotation()
    {
        bool flag = LoadConceptGenreNumFromAnnotation(mMatrixFile, mConceptNum, mGenreNum);

        if (flag)
        {
            _ASSERT(mGenreNum>0 && mConceptNum>0);
            return true;
        } else
            return false;
    }*/

    bool
    LoadConceptGenreNumFromAnnotation(String name, int& nRow, int& nCol)
    {
        std::string fName;
        
        if (mIsImageSet)
            fName = mAnnoImgSet->GetFilePathAnnotation(name,false,false);
        else
            fName = mAnnoVidSet->GetFilePathAnnotation(name,false,false);
        FILE* fp = fopen(fName.c_str(),"rb");

        if (NULL == fp)
        {
            std::cout << "File does NOT exist: " << name << "" << std::endl;
            return false;
        }

        fread(&nRow, sizeof(int), 1, fp);  //mConceptNum
        fread(&nCol, sizeof(int), 1, fp);  //mGenreNum

        fclose(fp);

        return true;

    }


protected:

    SimilarityTableSet* mGenreSimSet;
    SimilarityTableSet* mConceptSimSet;

    SimilarityTableSet::SimTableType** genreSimTable;
    SimilarityTableSet::SimTableType** conceptSimTable;

    Core::Table::QuidTable* mQuidTable;  // only for similiarty table set

    String mConceptPath;
    String mGenrePath;

    Core::VideoSet::Keyframes* mKeyframes;

    bool mWriteTable;

};

} // namespace Table
} // namespace Core
} // namespace Impala

#endif

---