src/bayesnet.h

/*****************************************************************************
* This file is provided under the Creative Commons Attribution 3.0 license.
*
* You are free to share, copy, distribute, transmit, or adapt this work
* PROVIDED THAT you attribute the work to the authors listed below.
* For more information, please see the following web page:
* http://creativecommons.org/licenses/by/3.0/
*
* This file is a component of the Sleipnir library for functional genomics,
* authored by:
* Curtis Huttenhower (chuttenh@princeton.edu)
* Mark Schroeder
* Maria D. Chikina
* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
*
* If you use this library, the included executable tools, or any related
* code in your work, please cite the following publication:
* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
* Olga G. Troyanskaya.
* "The Sleipnir library for computational functional genomics"
*****************************************************************************/
#ifndef BAYESNET_H
#define BAYESNET_H

#include "bayesnetint.h"
#include "bayesneti.h"

namespace Sleipnir {

class IDataset;

#ifndef NO_SMILE

class CBayesNetSmile : public CBayesNetSmileImpl, public IBayesNet {
public:
    CBayesNetSmile( bool fGroup = true );

    bool Open( const std::vector<std::string>& vecstrFiles, size_t iValues );
#ifdef PNL_ENABLED
    bool Convert( CBayesNetPNL& BNPNL ) const;
#endif // PNL_ENABLED
    bool Open( const IDataset* pDataset, const std::vector<std::string>& vecstrNames,
        const std::vector<size_t>& veciDefaults );
    bool Open( const CBayesNetSmile& BNPrior, const std::vector<CBayesNetSmile*>& vecpBNs );
    bool Open( const CBayesNetMinimal& BNMinimal, const std::vector<std::string>& vecstrNames );
    float Evaluate( size_t iNode, unsigned char bValue ) const;
    unsigned char GetDefault( size_t iNode ) const;

    void SetDefault( const CBayesNetSmile& Defaults ) {

        m_pDefaults = &Defaults; }

    bool Learn( const IDataset* pDataset, size_t iIterations, bool fZero = false, bool fELR = false );
    bool Evaluate( const std::vector<unsigned char>& vecbDatum, std::vector<float>& vecdResults,
        bool fZero = false, size_t iNode = 0, bool fIgnoreMissing = false ) const;
    bool Evaluate( const CPCLPair& PCLData, CPCL& PCLResults, bool fZero = false,
        int iAlgorithm = DSL_ALG_BN_LAURITZEN ) const;
    void GetNodes( std::vector<std::string>& vecstrNodes ) const;
    void Randomize( );
    void Randomize( size_t iNode );
    void Reverse( size_t iNode );

    bool Open( const char* szFile ) {

        return ( m_fSmileNet = !m_SmileNet.ReadFile( szFile ) ); }

    bool Save( const char* szFile ) const {

        return ( m_fSmileNet ? !((CBayesNetSmile*)this)->m_SmileNet.WriteFile( szFile ) : false ); }

    bool GetCPT( size_t iNode, CDataMatrix& MatCPT ) const {

        return CBayesNetSmileImpl::GetCPT( m_SmileNet.GetNode( (int)iNode ), MatCPT ); }

    unsigned char GetValues( size_t iNode ) const {

        return m_SmileNet.GetNode( (int)iNode )->Definition( )->GetNumberOfOutcomes( ); }

    bool IsContinuous( size_t iNode ) const {
        UNUSED_PARAMETER(iNode);

        return IsContinuous( ); }

    bool IsContinuous( ) const {

        return CBayesNetSmileImpl::IsContinuous( ); }

    bool Evaluate( const IDataset* pDataset, std::vector<std::vector<float> >& vecvecdResults,
        bool fZero ) const {

        return CBayesNetSmileImpl::Evaluate( pDataset, NULL, &vecvecdResults, fZero ); }

    bool Evaluate( const IDataset* pDataset, CDat& DatResults, bool fZero ) const {

        return CBayesNetSmileImpl::Evaluate( pDataset, &DatResults, NULL, fZero ); }
};

class CBayesNetFN : CBayesNetFNImpl, public IBayesNet {
public:
    bool Open( const char* szFile );
    bool Save( const char* szFile ) const;
    bool Learn( const IDataset* pDataset, size_t iIterations, bool fZero = false, bool fELR = false );
    bool Evaluate( const std::vector<unsigned char>& vecbDatum, std::vector<float>& vecdResults,
        bool fZero = false, size_t iNode = 0, bool fIgnoreMissing = false ) const;
    void GetNodes( std::vector<std::string>& vecstrNodes ) const;
    unsigned char GetValues( size_t iNode ) const;
    bool IsContinuous( ) const;

    bool Evaluate( const IDataset* pDataset, std::vector<std::vector<float> >& vecvecdResults,
        bool fZero ) const {

        return CBayesNetFNImpl::Evaluate( pDataset, NULL, &vecvecdResults, fZero ); }

    bool Evaluate( const IDataset* pDataset, CDat& DatResults, bool fZero ) const {

        return CBayesNetFNImpl::Evaluate( pDataset, &DatResults, NULL, fZero ); }

    bool IsContinuous( size_t iNode ) const {

        return m_apNodes[ iNode ]->IsContinuous( ); }

    void Randomize( ) {
        size_t  i;

        for( i = 0; i < m_iNodes; ++i )
            Randomize( i ); }

    void Randomize( size_t iNode ) {

        m_apNodes[ iNode ]->Randomize( ); }

    void Reverse( size_t iNode ) {

        m_apNodes[ iNode ]->Reverse( ); }

    bool GetCPT( size_t iNode, CDataMatrix& MatCPT ) const {

        return CBayesNetSmileImpl::GetCPT( m_SmileNet.GetNode( (int)iNode ), MatCPT ); }

    bool Evaluate( const CPCLPair& PCLData, CPCL& PCLResults, bool fZero, int iAlgorithm ) const {
        UNUSED_PARAMETER(PCLData);
        UNUSED_PARAMETER(PCLResults);
        UNUSED_PARAMETER(fZero);
        UNUSED_PARAMETER(iAlgorithm);

        return false; }
};

#endif // NO_SMILE

#ifdef PNL_ENABLED

class CBayesNetPNL : public CBayesNetPNLImpl, public IBayesNet {
public:
    CBayesNetPNL( bool fGroup = true );

    bool Open( const char* szFile );
    bool Save( const char* szFile ) const;
    bool Learn( const IDataset* pDataset, size_t iIterations, bool fZero = false, bool fELR = false );

    void GetNodes( std::vector<std::string>& vecstrNodes ) const {
        UNUSED_PARAMETER(vecstrNodes); }

    bool IsContinuous( size_t iNode ) const {
        UNUSED_PARAMETER(iNode);

        return IsContinuous( ); }

    bool IsContinuous( ) const {

        return CBayesNetPNLImpl::IsContinuous( ); }

    bool Evaluate( const IDataset* pDataset, std::vector<std::vector<float> >& vecvecdResults,
        bool fZero ) const {

        return CBayesNetPNLImpl::Evaluate( pDataset, NULL, &vecvecdResults, fZero ); }

    bool Evaluate( const IDataset* pDataset, CDat& DatResults, bool fZero ) const {

        return CBayesNetPNLImpl::Evaluate( pDataset, &DatResults, NULL, fZero ); }

    void Randomize( ) { }

    void Randomize( size_t iNode ) {
        UNUSED_PARAMETER(iNode); }

    void Reverse( size_t iNode ) {
        UNUSED_PARAMETER(iNode); }

    virtual bool Evaluate( const std::vector<unsigned char>& vecbDatum, std::vector<float>& vecdResults,
        bool fZero = false, size_t iNode = 0, bool fIgnoreMissing = false ) const {

        return false; }

    unsigned char GetValues( size_t iNode ) const {
        UNUSED_PARAMETER(iNode);

        return 0; }

    bool GetCPT( size_t iNode, CDataMatrix& MatCPT ) const {
        UNUSED_PARAMETER(iNode);
        UNUSED_PARAMETER(MatCPT);

        return false; }

    bool Evaluate( const CPCLPair& PCLData, CPCL& PCLResults, bool fZero, int iAlgorithm ) const {
        UNUSED_PARAMETER(PCLData);
        UNUSED_PARAMETER(PCLResults);
        UNUSED_PARAMETER(fZero);
        UNUSED_PARAMETER(iAlgorithm);

        return false; }
};

#endif // PNL_ENABLED

class CBayesNetMinimal : public CBayesNetMinimalImpl {
public:
#ifndef NO_SMILE
    bool Open( const CBayesNetSmile& BNSmile );
#endif // NO_SMILE
    bool Open( std::istream& istm );
    bool OpenCounts( const char* szFileCounts, const std::map<std::string, size_t>& mapstriNodes,
        const std::vector<unsigned char>& vecbDefaults, const std::vector<float>& vecdAlphas,
        float dPseudocounts = HUGE_VAL, const CBayesNetMinimal* pBNDefault = NULL );
    void Save( std::ostream& ostm ) const;
    float Evaluate( const std::vector<unsigned char>& vecbDatum, size_t iOffset = 0 ) const;
    bool Evaluate( const std::vector<unsigned char>& vecbData, float* adResults, size_t iGenes,
        size_t iStart = 0 ) const;
    float Regularize( std::vector<float>& vecdAlphas ) const;

    const CDataMatrix& GetCPT( size_t iNode ) const {

        return ( iNode ? m_vecNodes[ iNode - 1 ].m_MatCPT : m_MatRoot ); }

    size_t GetNodes( ) const {

        return ( m_vecNodes.size( ) + 1 ); }

    void SetID( const std::string& strID ) {

        m_strID = strID; }

    const std::string& GetID( ) const {

        return m_strID; }

    const unsigned char GetDefault( size_t iNode ) const {

        return ( iNode ? m_vecNodes[ iNode - 1 ].m_bDefault : 0xFF ); }
};

}

#endif // BAYESNET_H