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

---

BayesCondProb.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_BayesCondProb_h
#define Impala_Core_Table_BayesCondProb_h

#include "Core/Table/Bayes.h"

namespace Impala
{
namespace Core
{
namespace Table
{


class BayesCondProb : public Bayes
{
public:

    BayesCondProb(String annoSetName, String genreSet, String conceptSet, String quid, 
                                               bool dumpTable,int nStart,int nEnd): 
        Bayes(annoSetName, "",genreSet, conceptSet, quid, nStart, nEnd)
    {
        mbDumpTable = dumpTable;

        conceptPrior = new double[mConceptNum];
        genrePrior = new double[mGenreNum];

        // mProb_c_g[][] has been initialized in Bayes class
        //AllocateMatrix(mProb_c_g, mConceptNum, mGenreNum);

        // for CalcGenreConditionalPriorProbability()
        AllocateMatrix(mProb_g_c, mGenreNum, mConceptNum);
        ResetMatrix(mProb_g_c, mGenreNum, mConceptNum);

    }

    virtual ~BayesCondProb()
    {
        delete []conceptPrior;
        delete []genrePrior;

        ReleaseMatrix(mProb_g_c, mGenreNum);

    }

    void
    CalcConceptPriorProbability()
    {   
        if (mAnnoTableSize == 0)
        {
            std::cout << "The table size is zero: NOT acceptable" <<std::endl;
            for (int k=0 ; k< mConceptNum ; k++)
                conceptPrior[k] = 0;
            return;
        }
        std::cout<< std::endl <<"Concept Prior Probability:" <<std::endl <<std::endl;

        // loop for all concepts c_{k}
        for (int k=0 ; k< mConceptNum ; k++)
        {
            //int tabSize = tabConcept[k]->Capacity();
            int posNum = tabConcept[k]->GetNrPositive();
            String strConcept = tabConcept[k]->GetLabel();

            conceptPrior[k] = posNum*1.0/mAnnoTableSize;
            std::cout << conceptPrior[k] << " Pos=" << posNum << " [c" << k << " " << strConcept << "]" << std::endl;
            
        }
        std::cout << std::endl;
    }

    void
    CalcGenrePriorProbability()
    {
        if (mAnnoTableSize == 0)
        {
            std::cout << "The table size is zero: NOT acceptable" <<std::endl;
            for (int j=0 ; j < mGenreNum ; j++)
                genrePrior[j] = 0;
            return;
        }
        std::cout<<std::endl<<"Genre Prior Probability:" <<std::endl <<std::endl;

        // loop for all video genres
        for (int j=0 ; j < mGenreNum ; j++)
        {
            //int tabSize = tabGenre[j]->Capacity();
            int posNum = tabGenre[j]->GetNrPositive();
            String strGenre = tabGenre[j]->GetLabel();

            genrePrior[j] = posNum*1.0/mAnnoTableSize;
            std::cout << genrePrior[j] << " Pos=" << posNum << " [g" << j << " " << strGenre << "]"<< std::endl;

        }
    }

    void
    CalcGenreConditionalPriorProbability()
    {
        //mProb_g_c = new double* [mGenreNum];
        //for (int j=0; j<mGenreNum; j++) mProb_g_c[j] = new double [mConceptNum];

        for (int j=0; j<mGenreNum; j++)
            memset(mProb_g_c[j],0,sizeof(double)*mConceptNum);
        
        for (int j=0; j<mGenreNum; j++)
        {      
            for (int k=0; k<mConceptNum; k++)
            {         
                int countConcept = 0;
                int countGenre = 0;

                // loop for all the keyframes
                for (int idx=0; idx<mAnnoTableSize; idx++)
                {
                    if (tabConcept[k]->IsPositive(idx))
                    {
                        countConcept ++;
                        if (tabGenre[j]->IsPositive(idx))
                        {
                            countGenre++;
                        }
                    }               
                }

                // compute the conditional probability based on counting.
                if (0 == countConcept)
                    mProb_g_c[j][k] = 0;
                else
                    mProb_g_c[j][k] = countGenre*1.0/countConcept;
            }
        }
        DumpMatrix("mProb_g_c[j][k]", mProb_g_c, mGenreNum, mConceptNum);
    }

    void
    CalcConceptConditionalPriorProbability()
    {
        //double** mProb_c_g = new double* [mConceptNum];
        //for (int k=0; k<mConceptNum; k++) mProb_c_g[k] = new double [mGenreNum];

        for (int k=0; k<mConceptNum; k++)
            memset(mProb_c_g[k],0,sizeof(double)*mGenreNum);

        for (int k=0; k<mConceptNum; k++)
        {
            for (int j=0; j< mGenreNum; j++)
            {     
                int countGenre = 0;
                int countConcept = 0;
                
                // loop for all the keyframes
                for (int idx=0; idx<mAnnoTableSize; idx++)
                {
                    if (tabGenre[j]->IsPositive(idx))
                    {
                        countGenre ++;
                        if (tabConcept[k]->IsPositive(idx))
                        {
                            countConcept++;
                        }
                    }               
                }

                // compute the conditional probability based on counting.
                if (0 == countGenre)
                    mProb_c_g[k][j] = 0;
                else
                    mProb_c_g[k][j] = countConcept*1.0/countGenre;
            }
        }
        DumpMatrix("mProb_c_g[k][j] - counting", mProb_c_g, mConceptNum, mGenreNum);
    }

    void
    CalcConceptConditionalPriorProbabilityBayesRule()
    {
        //double** mProb_c_g = new double* [mConceptNum];
        //for (int k=0; k<mConceptNum; k++) mProb_c_g[k] = new double [mGenreNum];

        for (int k=0; k<mConceptNum; k++)
            memset(mProb_c_g[k],0,sizeof(double)*mGenreNum);

        for (int k=0; k<mConceptNum; k++)
        {
            for (int j=0; j< mGenreNum; j++)
            {     
                // compute the conditional probability based on Bayes theorem
                if (genrePrior[j] < 1e-10)
                    mProb_c_g[k][j] = 0;
                else
                    mProb_c_g[k][j] = mProb_g_c[j][k] * conceptPrior[k] / genrePrior[j];
            }
        }
        DumpMatrix("mProb_c_g[k][j] - Bayes", mProb_c_g, mConceptNum, mGenreNum);

        DumpMatrixProb_c_gAsList();
    }

    void
    CalcConceptPosteriorProbability()
    {
    }

    void
    CalcBayes()
    {
        //InitializeTables();
        //VerifyAndSetTableSize();
     
        // step 1 - compute concept prior probability: P(c_{k})
        CalcConceptPriorProbability();

        // step 2 - compute genre prior probability: P(g_{j})
        CalcGenrePriorProbability();
        
        // step 3 - compute conditional probability 
        //             P( g_{j} | c_{k} ) = mProb_g_c [j][k]
        CalcGenreConditionalPriorProbability();        

        // step 4 - compute conditional probability 
        //             P( c_{k} | g_{j} ) = mProb_c_g [k][j]
        CalcConceptConditionalPriorProbability();
        
        // step 5 - re-compute conditional probability 
        //             P( c_{k} | g_{j} ) = mProb_c_g [k][j]
        // based on Bayes theorem, as follows:
        //
        //                     P(c_{k}|g_{j})*P(c_{k})    mProb_g_c[j][k] * conceptPrior[k]
        // mProb_c_g[k][j] = -------------------------- = ----------------------------------
        //                            P(g_{j})                     genrePrior[j]
        CalcConceptConditionalPriorProbabilityBayesRule();

    }

    // for annotations of the joint models:
    // positive: both are positive
    // negative: either are negative, rest of the positive pairs
    void
    SaveAnnoTableJointGenreAndConcept(int nLeastPositiveSamples=0, bool bWriteTable=false)
    {
        std::cout << std::endl;
        std::cout << "Saving Annotation Tables for joint probability: "<< std::endl;
        std::cout << "------------------------------------------------"<< std::endl;

        if (nLeastPositiveSamples<0)
            nLeastPositiveSamples = 100;

        int nAddTable = 0;
        int nSkipTable = 0;

        for (int j=0; j<mGenreNum; j++)
        {      
            for (int k=0; k<mConceptNum; k++)
            {
                //AnnotationTable* annoTab = annoTabSet->GetTable(j);
                Core::Table::AnnotationTable* annoTab = new Core::Table::AnnotationTable;

                int countJointPos = 0;

                // loop for all the keyframes
                for (int idx=0; idx<mAnnoTableSize; idx++)
                {
                    Quid q= tabGenre[j]->Get1(idx);
                    //std::cout << "Quid: " << QuidObj(q).ToString()  << std::endl;

                    if (tabGenre[j]->IsPositive(idx) && tabConcept[k]->IsPositive(idx))
                    {
                        // both genre and concept are positive
                        countJointPos ++;
                        annoTab->AddPositive(q);
                    }
                    else if (tabGenre[j]->IsSkip(idx) || tabConcept[k]->IsSkip(idx))
                    {
                        // either genre is skipped, or concept is skipped
                        annoTab->AddSkip(q);
                    }
                    else
                    {
                        // either genre is negative, or concept is negtive
                        annoTab->AddNegative(q);
                    }
                }

                String strGenreName = tabGenre[j]->GetLabel();
                String strConceptName = tabConcept[k]->GetLabel();
                String strTabName = strGenreName + "-" + strConceptName + ".tab";

                if (countJointPos)
                {
                    if (countJointPos >= nLeastPositiveSamples)
                    {
                        std::cout << strTabName << std::endl;
                        annoTab->DumpSummary();
                    }
                    else
                    {
                        std::cout << strTabName << std::endl;
                        std::cout << "[0-" << nLeastPositiveSamples-1 << "]: ";
                        annoTab->DumpSummary();

                        nSkipTable++;
                    }
                                           
                }

                //std::string fName = mAnnoVidSet->GetFilePathAnnotation("Frame/concepts_joint.txt/",false,false);
                //if (fName == "") std::cout << "Path does not exist: " << fName << std::endl;
 
                String OutPath;
                String OutConceptSet1 = "concepts_joint_set3.txt";
                //String OutConceptSet1 = "concepts_joint_setx.txt";
                            
                if (bWriteTable && (countJointPos >= nLeastPositiveSamples) )
                {
                    if (mIsImageSet)
                    {
                        OutPath = "Annotations/Image/"+OutConceptSet1+"/" + strTabName;
                        Core::Table::Write(annoTab, OutPath, mAnnoImgSet->GetDatabase(), true);
                    }
                    else
                    {
                        OutPath = "Annotations/Frame/"+OutConceptSet1+"/" + strTabName;
                        Core::Table::Write(annoTab, OutPath, mAnnoVidSet->GetDatabase(), true);
                    }
                    

                    nAddTable ++;
                }

                delete annoTab;
            }
        }

        std::cout << "Done. [ " << nAddTable << " (out of " << mGenreNum << "*" << mConceptNum << ")"; 
        std::cout << " *.tab files have been saved! ] " << std::endl;
        std::cout << "Skipped: " << nSkipTable << std::endl;

        int x=0;

    }


    // for annotations of the casecade models: Genre-specific concept models
    // positive: both are positive
    // negative: negative concept, only within the positive genres.
    void
    SaveAnnoTableSubsetConceptInGenre(bool bDumpTestSet,int nLeastPositiveSamples=0, bool bWriteTable=false)
    {
        std::cout << std::endl;
        std::cout << "Saving Annotation Tables subset concept-in-genre.tab: "<< std::endl;
        std::cout << "------------------------------------------------------"<< std::endl;

        if (bDumpTestSet)
        {
            nLeastPositiveSamples = 0;
        }
        else
        {
            if (nLeastPositiveSamples<0)
                nLeastPositiveSamples = 100;
        }

        int nAddTable = 0;
        int nSkipTable = 0;

        for (int j=0; j<mGenreNum; j++)
        {      
            for (int k=0; k<mConceptNum; k++)
            {
                //AnnotationTable* annoTab = annoTabSet->GetTable(j);
                Core::Table::AnnotationTable* annoTab = new Core::Table::AnnotationTable;

                int countConceptPositiveInGenre = 0;

                // loop for all the keyframes
                for (int idx=0; idx<mAnnoTableSize; idx++)
                {
                    Quid q= tabGenre[j]->Get1(idx);
                    //std::cout << "Quid: " << QuidObj(q).ToString()  << std::endl;

                    if (bDumpTestSet)
                    {
                        // processing test set (no subset selection)
                        // actually the same as SaveAnnoTableJointGenreAndConcept()
                        if (tabGenre[j]->IsPositive(idx) && tabConcept[k]->IsPositive(idx))
                        {
                            // both genre and concept are positive
                            countConceptPositiveInGenre ++;
                            annoTab->AddPositive(q);
                        }
                        else if (tabGenre[j]->IsSkip(idx) || tabConcept[k]->IsSkip(idx))
                        {
                            // either genre is skipped, or concept is skipped
                            annoTab->AddSkip(q);
                        }
                        else
                        {
                            // either genre is negative, or concept is negtive
                            annoTab->AddNegative(q);
                        }

                     }
                    else
                    {
                        // processing training set, 
                        // Note: only processing a subset, within a specific genre type
                        if (tabGenre[j]->IsPositive(idx))
                        {
                            //only output the positives samples within a gerne
                            if (tabConcept[k]->IsPositive(idx))
                            {
                                countConceptPositiveInGenre ++;
                                annoTab->AddPositive(q);
                            }
                            else
                            {
                                // genre is positive, but concept is negtive
                                annoTab->AddNegative(q);
                            }
                        }
                        else
                        {
                            //Either negative samples or skipped samples for a genre will be ignored
                        }
                    }
                       
                }

                String strGenreName = tabGenre[j]->GetLabel();
                String strConceptName = tabConcept[k]->GetLabel();
                String strTabName = strGenreName + "-" + strConceptName + ".tab";

                if (countConceptPositiveInGenre)
                {
                    if (countConceptPositiveInGenre >= nLeastPositiveSamples)
                    {
                        std::cout << strTabName << std::endl;
                        annoTab->DumpSummary();
                    }
                    else
                    {
                        std::cout << strTabName << std::endl;
                        std::cout << "[0-" << nLeastPositiveSamples-1 <<"]: ";
                        annoTab->DumpSummary();

                        nSkipTable++;
                    }
                        
                    
                }

                //std::string fName = mAnnoVidSet->GetFilePathAnnotation("Frame/concepts_joint.txt/",false,false);
                //if (fName == "") std::cout << "Path does not exist: " << fName << std::endl;
 
                String OutPath;
                String OutConceptSet2 = "concepts_subset_in_genres.txt";
                            
                if (bWriteTable && (countConceptPositiveInGenre >= nLeastPositiveSamples) )
                {
                    if (mIsImageSet)
                    {
                        OutPath = "Annotations/Image/"+OutConceptSet2+"/" + strTabName;
                        Core::Table::Write(annoTab, OutPath, mAnnoImgSet->GetDatabase(), true); 
                    }
                    else
                    {
                        OutPath = "Annotations/Frame/"+OutConceptSet2+"/" + strTabName;
                        Core::Table::Write(annoTab, OutPath, mAnnoVidSet->GetDatabase(), true); 
                    }
                    

                    nAddTable ++;
                }

                delete annoTab;
            }
        }

        std::cout << "Done. [ " << nAddTable << " (out of " << mGenreNum << "*" << mConceptNum << ")"; 
        std::cout << " *.tab files have been saved! ] " << std::endl;
        std::cout << "Skipped: " << nSkipTable << std::endl;

        int x=0;

    }



protected:

    double* conceptPrior;
    double* genrePrior;

    double** mProb_g_c;

};


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

#endif

---