TMAGFitBern Class Reference

#include <mag.h>

Collaboration diagram for TMAGFitBern:

Public Member Functions
	TMAGFitBern ()
	TMAGFitBern (const PNGraph &G, const int &NAttrs)
	TMAGFitBern (const PNGraph &G, const TStr &InitFNm)
void	Clr ()
void	SaveTxt (const TStr &FNm)
const int	GetNodes () const
const int	GetAttrs () const
const TMAGParam< TMAGNodeBern > &	GetParams () const
const TMAGNodeBern &	GetNodeAttr () const
const TFltV &	GetMuV () const
void	SetMuV (const TFltV &MuV)
void	GetMtxV (TMAGAffMtxV &MtxV) const
void	SetMtxV (const TMAGAffMtxV &MtxV)
PNGraph	GetGraph ()
void	SetGraph (const PNGraph &GraphPt)
void	SetDebug (const bool _Debug)
void	SetAlgConf (const bool EStep=true, const bool MStep=true)
void	Init (const TFltV &MuV, const TMAGAffMtxV &AffMtxV)
void	RandomInit (const TFltV &MuV, const TMAGAffMtxV &AffMtxV, const int &Seed)
const TFltVV &	GetPhiVV () const
void	SetPhiVV (const TIntVV &AttrVV, const int KnownIds=0)
void	SetPhiVV (const TFltVV &AttrVV, const int KnownIds=0)
const double	GetInCoeff (const int &i, const int &j, const int &l, const int &A, const TMAGAffMtx &Theta) const
const double	GetAvgInCoeff (const int &i, const int &AId, const int &A, const TMAGAffMtx &Theta) const
const double	GetOutCoeff (const int &i, const int &j, const int &l, const int &A, const TMAGAffMtx &Theta) const
const double	GetAvgOutCoeff (const int &i, const int &AId, const int &A, const TMAGAffMtx &Theta) const
const double	GetProbPhi (const int &NId1, const int &NId2, const int &AId, const int &Attr1, const int &Attr2) const
const double	GetProbMu (const int &NId1, const int &NId2, const int &AId, const int &Attr1, const int &Attr2, const bool Left=false, const bool Right=false) const
const double	GetThetaLL (const int &NId1, const int &NId2, const int &AId) const
const double	GetAvgThetaLL (const int &NId1, const int &NId2, const int &AId, const bool Left=false, const bool Right=false) const
const double	GetSqThetaLL (const int &NId1, const int &NId2, const int &AId) const
const double	GetAvgSqThetaLL (const int &NId1, const int &NId2, const int &AId, const bool Left=false, const bool Right=false) const
const double	GetProdLinWeight (const int &NId1, const int &NId2) const
const double	GetAvgProdLinWeight (const int &NId1, const int &NId2, const bool Left=false, const bool Right=false) const
const double	GetProdSqWeight (const int &NId1, const int &NId2) const
const double	GetAvgProdSqWeight (const int &NId1, const int &NId2, const bool Left=false, const bool Right=false) const
const double	GetEstNoEdgeLL (const int &NId, const int &AId) const
const double	GradPhiMI (const double &x, const int &NId, const int &AId, const double &Lambda, const double &DeltaQ, const TFltVV &CntVV)
const double	ObjPhiMI (const double &x, const int &NId, const int &AId, const double &Lambda, const double &Q0, const double &Q1, const TFltVV &CntVV)
const double	UpdatePhiMI (const double &Lambda, const int &NId, const int &AId, double &Phi)
const double	UpdateApxPhiMI (const double &Lambda, const int &NId, const int &AId, double &Phi, TFltVV &ProdVV)
const double	UpdatePhi (const int &NId, const int &AId, double &Phi)
const double	UpdateMu (const int &AId)
const void	PrepareUpdateAffMtx (TFltVV &ProdVV, TFltVV &SqVV)
const void	PrepareUpdateApxAffMtx (TFltVV &ProdVV, TFltVV &SqVV)
const double	UpdateAffMtx (const int &AId, const double &LrnRate, const double &MaxGrad, const double &Lambda, TFltVV &ProdVV, TFltVV &SqVV, TMAGAffMtx &NewMtx)
const double	UpdateAffMtxV (const int &GradIter, const double &LrnRate, const double &MaxGrad, const double &Lambda, const int &NReal=0)
const void	GradAffMtx (const int &AId, const TFltVV &ProdVV, const TFltVV &SqVV, const TMAGAffMtx &CurMtx, TFltV &GradV)
const void	GradApxAffMtx (const int &AId, const TFltVV &ProdVV, const TFltVV &SqVV, const TMAGAffMtx &CurMtx, TFltV &GradV)
double	DoEStepOneIter (const TFltV &TrueMuV, TFltVV &NewPhi, const double &Lambda)
double	DoEStepApxOneIter (const TFltV &TrueMuV, TFltVV &NewPhi, const double &Lambda)
double	DoEStep (const TFltV &TrueMuV, const int &NIter, double &LL, const double &Lambda)
void	DoMStep (const int &GradIter, const double &LrnRate, const double &MaxGrad, const double &Lambda, const int &NReal=0)
void	DoEMAlg (const int &NStep, const int &NEstep, const int &NMstep, const double &LrnRate, const double &MaxGrad, const double &Lambda, const double &ReInit, const int &NReal=0)
void	CountAttr (TFltV &EstMuV) const
void	SortAttrOrdering (const TFltV &TrueMuV, TIntV &IndexV) const
const double	ComputeJointOneLL (const TIntVV &AttrVV) const
const double	ComputeJointLL (int NSample) const
const double	ComputeJointAdjLL (const TIntVV &AttrVV) const
const double	ComputeApxLL () const
const double	ComputeApxAdjLL () const
void	MakeCCDF (const TFltPrV &RawV, TFltPrV &CcdfV)
void	PlotProperties (const TStr &FNm)
void	NormalizeAffMtxV (TMAGAffMtxV &MtxV, const bool UseMu=false)
void	UnNormalizeAffMtxV (TMAGAffMtxV &MtxV, const bool UseMu=false)

Static Public Member Functions
static const double	ComputeMI (const TIntVV &AttrV, const int AId1, const int AId2)
static const double	ComputeMI (const TFltVV &AttrV, const int AId1, const int AId2)
static const double	ComputeMI (const TIntVV &AttrV)
static const double	ComputeMI (const TFltVV &AttrV)

Private Member Functions
const bool	NextPermutation (TIntV &IndexV) const

Private Attributes
TFltVV	PhiVV
TBoolVV	KnownVV
PNGraph	Graph
TMAGParam< TMAGNodeBern >	Param
bool	ESpeedUp
bool	MSpeedUp
bool	Debug
TFltV	AvgPhiV
TFltVV	AvgPhiPairVV
TFlt	NormConst
TVec< TFltV >	MuHisV
TVec< TMAGAffMtxV >	MtxHisV
TFltV	LLHisV

Detailed Description

Definition at line 341 of file mag.h.

Constructor & Destructor Documentation

TMAGFitBern::TMAGFitBern ( )

inline

Definition at line 357 of file mag.h.

: PhiVV(), KnownVV(), Graph(), Param(), ESpeedUp(true), MSpeedUp(true), Debug(false), AvgPhiV(), AvgPhiPairVV(), NormConst(1.0)  { }

TMAGFitBern::TMAGFitBern ( const PNGraph &  G, const int &  NAttrs  )

inline

Definition at line 358 of file mag.h.

: PhiVV(G->GetNodes(), NAttrs), KnownVV(G->GetNodes(), NAttrs), Graph(G), Param(G->GetNodes(), NAttrs), ESpeedUp(true), MSpeedUp(true), Debug(false), AvgPhiV(NAttrs), AvgPhiPairVV(NAttrs, NAttrs), NormConst(1.0) { }

TMAGFitBern::TMAGFitBern ( const PNGraph &  G, const TStr &  InitFNm  )

inline

Definition at line 360 of file mag.h.

References AvgPhiPairVV, AvgPhiV, TVec< TVal, TSizeTy >::Gen(), TVVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TNGraph::GetNodes(), KnownVV, Param, PhiVV, and SetGraph().

                                                           : Param(G->GetNodes(), InitFNm), ESpeedUp(true), MSpeedUp(true), Debug(false), NormConst(1.0) {
                const int NNodes = G->GetNodes();
                const int NAttrs = Param.GetAttrs();

                printf("NAttrs = %d\n", NAttrs);
                SetGraph(G);
                PhiVV.Gen(NNodes, NAttrs);
                KnownVV.Gen(NNodes, NAttrs);
                AvgPhiV.Gen(NAttrs);
                AvgPhiPairVV.Gen(NAttrs, NAttrs);
        }

Here is the call graph for this function:

Member Function Documentation

void TMAGFitBern::Clr ( )

inline

Definition at line 372 of file mag.h.

References TVVec< TVal, TSizeTy >::Clr(), KnownVV, and PhiVV.

{  PhiVV.Clr();  KnownVV.Clr();  }

Here is the call graph for this function:

const double TMAGFitBern::ComputeApxAdjLL

(

)

const

Definition at line 2046 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGAffMtx::GetLLMtx(), TMAGParam< TNodeAttr >::GetMtx(), TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), GetProbPhi(), GetProdLinWeight(), Graph, TNGraph::IsEdge(), Param, PhiVV, and TVec< TVal, TSizeTy >::PutAll().

                                                {
        double LL = 0.0;
  // double LLSelf = 0.0;
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TMAGNodeBern NodeAttr = Param.GetNodeAttr();
        TFltV MuV = NodeAttr.GetMuV();
        MuV.PutAll(0.0);
        TMAGAffMtxV LLMtxV(NAttrs);
        double TotalEdge = 0.0;
        for(int l = 0; l < NAttrs; l++) {
                TMAGAffMtx Theta = Param.GetMtx(l);
                Theta.GetLLMtx(LLMtxV[l]);
        }

        for(int i = 0; i < NNodes; i++) {
                for(int j = 0; j < NNodes; j++) {
                        if(i == j) {  continue;  }

                        if(Graph->IsEdge(i, j)) {
                                for(int l = 0; l < NAttrs; l++) {
                                        LL += GetProbPhi(i, j, l, 0, 0) * LLMtxV[l].At(0, 0);
                                        LL += GetProbPhi(i, j, l, 0, 1) * LLMtxV[l].At(0, 1);
                                        LL += GetProbPhi(i, j, l, 1, 0) * LLMtxV[l].At(1, 0);
                                        LL += GetProbPhi(i, j, l, 1, 1) * LLMtxV[l].At(1, 1);
                                }
                        } else {
                                LL += log(1-exp(GetProdLinWeight(i, j)));
                        }

                        double TempLL = 1.0;
                        for(int l = 0; l < NAttrs; l++) {
                                int Ai = (double(PhiVV(i, l)) > 0.5) ? 0 : 1;
                                int Aj = (double(PhiVV(j, l)) > 0.5) ? 0 : 1;
                                TempLL *= Param.GetMtx(l).At(Ai, Aj);
                        }
                        if(TMAGNodeBern::Rnd.GetUniDev() < TempLL) {
                                TotalEdge += 1.0;
                        }
                }
        }

        return LL;
}

Here is the call graph for this function:

const double TMAGFitBern::ComputeApxLL

(

)

const

Definition at line 2005 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetAttrs(), TMAGAffMtx::GetLLMtx(), TMAGParam< TNodeAttr >::GetMtx(), TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), GetProbPhi(), GetProdLinWeight(), Graph, TNGraph::IsEdge(), NormConst, Param, and PhiVV.

Referenced by DoEMAlg().

                                             {
        double LL = 0.0;
  // double LLSelf = 0.0;
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TMAGNodeBern NodeAttr = Param.GetNodeAttr();
        TFltV MuV = NodeAttr.GetMuV();
        TMAGAffMtxV LLMtxV(NAttrs);

        for(int l = 0; l < NAttrs; l++) {
                for(int i = 0; i < NNodes; i++) {
                        LL += PhiVV(i, l) * log(MuV[l]);
                        LL += (1.0 - PhiVV(i, l)) * log(1.0 - MuV[l]);
                        LL -= PhiVV(i, l) * log(PhiVV(i, l));
                        LL -= (1.0 - PhiVV(i, l)) * log(1.0 - PhiVV(i, l));
                }
                TMAGAffMtx Theta = Param.GetMtx(l);
                Theta.GetLLMtx(LLMtxV[l]);
        }

        for(int i = 0; i < NNodes; i++) {
                for(int j = 0; j < NNodes; j++) {
                        if(i == j) {  continue;  }

                        if(Graph->IsEdge(i, j)) {
                                for(int l = 0; l < NAttrs; l++) {
                                        LL += GetProbPhi(i, j, l, 0, 0) * LLMtxV[l].At(0, 0);
                                        LL += GetProbPhi(i, j, l, 0, 1) * LLMtxV[l].At(0, 1);
                                        LL += GetProbPhi(i, j, l, 1, 0) * LLMtxV[l].At(1, 0);
                                        LL += GetProbPhi(i, j, l, 1, 1) * LLMtxV[l].At(1, 1);
                                }
                                LL += log(NormConst);
                        } else {
                                LL += log(1-exp(GetProdLinWeight(i, j)));
                        }
                }
        }

        return LL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::ComputeJointAdjLL

(

const TIntVV &

AttrVV

)

const

Definition at line 1942 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetMtxV(), TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), Graph, TNGraph::IsEdge(), TVec< TVal, TSizeTy >::Len(), and Param.

                                                                      {
        double LL = 0.0;
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TMAGAffMtxV MtxV(NAttrs);       Param.GetMtxV(MtxV);
        const TMAGNodeBern NodeAttr = Param.GetNodeAttr();
        const TFltV MuV = NodeAttr.GetMuV();

        for(int l = 0; l < NAttrs; l++) {
                for(int i = 0; i < MtxV[l].Len(); i++) {
                        MtxV[l].At(i) = log(MtxV[l].At(i));
                }
        }

        for(int i = 0; i < NNodes; i++) {
                for(int j = 0; j < NNodes; j++) {
                        if(i == j) {  continue;  }

                        double ProbLL = 0.0;
                        for(int l = 0; l < NAttrs; l++) {
                                ProbLL += MtxV[l].At(AttrVV.At(i, l), AttrVV.At(j, l));
                        }

                        if(Graph->IsEdge(i, j)) {
                                LL += ProbLL;
                        } else {
                                LL += log(1-exp(ProbLL));
                        }
                }
        }

        return LL;
}

Here is the call graph for this function:

const double TMAGFitBern::ComputeJointLL

(

int

NSample

)

const

Definition at line 1976 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), TVVec< TVal, TSizeTy >::Clr(), ComputeJointOneLL(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetNodes(), TRnd::GetUniDev(), Param, and PhiVV.

                                                          {
        double LL = 0.0;
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();

        TRnd Rnd(2000);
        TIntVV AttrVV(NNodes, NAttrs);
        int count = 0;
        for(int s = 0; s < NSample; s++) {
                for(int i = 0; i < NNodes; i++) {
                        for(int l = 0; l < NAttrs; l++) {
                        
                                if(Rnd.GetUniDev() <= PhiVV(i, l)) {
                                        AttrVV.At(i, l) = 0;
                                } else {
                                        AttrVV.At(i, l) = 1;
                                }

                                if(PhiVV(i, l) > 0.05 && PhiVV(i, l) < 0.95) count++;
                        }
                }

                LL += ComputeJointOneLL(AttrVV);
        }
        AttrVV.Clr();

        return LL / double(NSample);
}

Here is the call graph for this function:

const double TMAGFitBern::ComputeJointOneLL

(

const TIntVV &

AttrVV

)

const

Definition at line 1900 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetMtxV(), TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), Graph, TNGraph::IsEdge(), TVec< TVal, TSizeTy >::Len(), and Param.

Referenced by ComputeJointLL().

                                                                      {
        double LL = 0.0;
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TMAGAffMtxV MtxV(NAttrs);       Param.GetMtxV(MtxV);
        const TMAGNodeBern NodeAttr = Param.GetNodeAttr();
        const TFltV MuV = NodeAttr.GetMuV();

        for(int l = 0; l < NAttrs; l++) {
                for(int i = 0; i < MtxV[l].Len(); i++) {
                        MtxV[l].At(i) = log(MtxV[l].At(i));
                }
        }

        for(int i = 0; i < NNodes; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        if(AttrVV.At(i, l) == 0) {
                                LL += log(MuV[l]);
                        } else {
                                LL += log(1.0 - MuV[l]);
                        }
                }

                for(int j = 0; j < NNodes; j++) {
                        if(i == j) {  continue;  }

                        double ProbLL = 0.0;
                        for(int l = 0; l < NAttrs; l++) {
                                ProbLL += MtxV[l].At(AttrVV.At(i, l), AttrVV.At(j, l));
                        }

                        if(Graph->IsEdge(i, j)) {
                                LL += ProbLL;
                        } else {
                                LL += log(1-exp(ProbLL));
                        }
                }
        }

        return LL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::ComputeMI ( const TIntVV &  AttrV, const int  AId1, const int  AId2  )

static

Definition at line 2091 of file mag.cpp.

References TVVec< TVal, TSizeTy >::GetXDim(), TVec< TVal, TSizeTy >::PutAll(), and TVVec< TVal, TSizeTy >::PutAll().

Referenced by ComputeMI().

                                                                                       {
        const int NNodes = AttrV.GetXDim();
        double MI = 0.0;
        double Cor = 0.0;

        TFltVV Pxy(2,2);
        TFltV Px(2), Py(2);
        Pxy.PutAll(0.0);
        Px.PutAll(0.0);
        Py.PutAll(0.0);

        for(int i = 0; i < NNodes; i++) {
                int X = AttrV(i, AId1);
                int Y = AttrV(i, AId2);
                Pxy(X, Y) = Pxy(X, Y) + 1;
                Px[X] = Px[X] + 1;
                Py[Y] = Py[Y] + 1;
                Cor += double(X * Y);
        }

        for(int x = 0; x < 2; x++) {
                for(int y = 0; y < 2; y++) {
      MI += Pxy(x, y) / double(NNodes) * (log(Pxy(x, y).Val) - log(Px[x].Val) - log(Py[y].Val) + log((double)NNodes));
                }
        }
        
        return MI;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::ComputeMI ( const TFltVV &  AttrV, const int  AId1, const int  AId2  )

static

Definition at line 2120 of file mag.cpp.

References TVVec< TVal, TSizeTy >::GetXDim(), TVec< TVal, TSizeTy >::PutAll(), and TVVec< TVal, TSizeTy >::PutAll().

                                                                                       {
        const int NNodes = AttrV.GetXDim();
        double MI = 0.0;
        double Cor = 0.0;

        TFltVV Pxy(2,2);
        TFltV Px(2), Py(2);
        Pxy.PutAll(0.0);
        Px.PutAll(0.0);
        Py.PutAll(0.0);
        
        for(int i = 0; i < NNodes; i++) {
                double X = AttrV(i, AId1);
                double Y = AttrV(i, AId2);
                Pxy(0, 0) = Pxy(0, 0) + X * Y;
                Pxy(0, 1) = Pxy(0, 1) + X * (1 - Y);
                Pxy(1, 0) = Pxy(1, 0) + (1 - X) * Y;
                Pxy(1, 1) = (i+1) - Pxy(0, 0) - Pxy(0, 1) - Pxy(1, 0);
                Px[0] = Px[0] + X;
                Py[0] = Py[0] + Y;
                Cor += double((1-X) * (1-Y));
        }
        Px[1] = NNodes - Px[0];
        Py[1] = NNodes - Py[0];
        
        for(int x = 0; x < 2; x++) {
                for(int y = 0; y < 2; y++) {
                        MI += Pxy(x, y) / double(NNodes) * (log(Pxy(x, y)) - log(Px[x]) - log(Py[y]) + log(double(NNodes)));
                }
        }
        
        return MI;
}

Here is the call graph for this function:

const double TMAGFitBern::ComputeMI ( const TIntVV &  AttrV )

static

Definition at line 2154 of file mag.cpp.

References ComputeMI(), and TVVec< TVal, TSizeTy >::GetYDim().

                                                       {
        // const int NNodes = AttrV.GetXDim();
        const int NAttrs = AttrV.GetYDim();
        double MI = 0.0;

        for(int l = 0; l < NAttrs; l++) {
                for(int k = l+1; k < NAttrs; k++) {
                        MI += ComputeMI(AttrV, l, k);
                }
        }

        return MI;
}

Here is the call graph for this function:

const double TMAGFitBern::ComputeMI ( const TFltVV &  AttrV )

static

Definition at line 2168 of file mag.cpp.

References ComputeMI(), and TVVec< TVal, TSizeTy >::GetYDim().

                                                       {
        // const int NNodes = AttrV.GetXDim();
        const int NAttrs = AttrV.GetYDim();
        double MI = 0.0;

        for(int l = 0; l < NAttrs; l++) {
                for(int k = l+1; k < NAttrs; k++) {
                        MI += ComputeMI(AttrV, l, k);
                }
        }

        return MI;
}

Here is the call graph for this function:

void TMAGFitBern::CountAttr

(

TFltV &

EstMuV

)

const

Definition at line 1814 of file mag.cpp.

References TVec< TVal, TSizeTy >::Gen(), TVVec< TVal, TSizeTy >::GetXDim(), TVVec< TVal, TSizeTy >::GetYDim(), PhiVV, and TVec< TVal, TSizeTy >::PutAll().

Referenced by SortAttrOrdering().

                                               {
        const int NNodes = PhiVV.GetXDim();
        const int NAttrs = PhiVV.GetYDim();
        EstMuV.Gen(NAttrs);
        EstMuV.PutAll(0.0);

        for(int l = 0; l < NAttrs; l++) {
                for(int i = 0; i < NNodes; i++) {
                        EstMuV[l] = EstMuV[l] + PhiVV(i, l);
                }
                EstMuV[l] = EstMuV[l] / double(NNodes);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::DoEMAlg	(	const int &	NStep,
		const int &	NEstep,
		const int &	NMstep,
		const double &	LrnRate,
		const double &	MaxGrad,
		const double &	Lambda,
		const double &	ReInit,
		const int &	NReal = 0
	)

Definition at line 1630 of file mag.cpp.

References TVec< TVal, TSizeTy >::Add(), TVVec< TVal, TSizeTy >::At(), ComputeApxLL(), Debug, DoEStep(), DoMStep(), TVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetMtxV(), TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), TRnd::GetUniDev(), KnownVV, LLHisV, MtxHisV, MuHisV, NormalizeAffMtxV(), NormConst, Param, PhiVV, TMAGParam< TNodeAttr >::SetMtxV(), and UnNormalizeAffMtxV().

                                                                                                                                                                                            {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TIntV IndexV;
        double LL;
  // double MuDist, MtxDist;

        MuHisV.Gen(NStep + 1, 0);
        MtxHisV.Gen(NStep + 1, 0);
        LLHisV.Gen(NStep + 1, 0);

        printf("--------------------------------------------\n");
        printf("Before EM Iteration\n");
        printf("--------------------------------------------\n");

        TMAGAffMtxV InitMtxV;
        TMAGNodeBern NodeAttr = Param.GetNodeAttr();
        Param.GetMtxV(InitMtxV);
        TFltV InitMuV = NodeAttr.GetMuV();
        
        for(int i = 0; i < NNodes; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        if(! KnownVV(i, l)) {
                                PhiVV.At(i, l) = TMAGNodeBern::Rnd.GetUniDev();
                        }
                }
        }
        
        if(Debug) {
                double LL = ComputeApxLL();
                MuHisV.Add(InitMuV);
                MtxHisV.Add(InitMtxV);
                LLHisV.Add(LL);
        }

        NormalizeAffMtxV(InitMtxV, true);
        Param.SetMtxV(InitMtxV);

        for(int n = 0; n < NStep; n++) {
                printf("--------------------------------------------\n");
                printf("EM Iteration : %d\n", (n+1));
                printf("--------------------------------------------\n");
                
                NodeAttr = Param.GetNodeAttr();
                for(int i = 0; i < NNodes; i++) {
                        for(int l = 0; l < NAttrs; l++) {
                                if(!KnownVV(i, l) && TMAGNodeBern::Rnd.GetUniDev() < ReInit) {
                                        PhiVV.At(i, l) = TMAGNodeBern::Rnd.GetUniDev();
                                }
                        }
                }
                DoEStep(InitMuV, NEstep, LL, Lambda);
                Param.GetMtxV(InitMtxV);
//              NormalizeAffMtxV(InitMtxV);
                Param.SetMtxV(InitMtxV);
                DoMStep(NMstep, LrnRate, MaxGrad, Lambda, NReal);

                printf("\n");

                if(Debug) {
                        double LL = ComputeApxLL();
                        MuHisV.Add(InitMuV);
                        MtxHisV.Add(InitMtxV);
                        LLHisV.Add(LL);
                        printf("    ApxLL = %.2f (Const = %f)\n", LL, double(NormConst));
                }

        }
        Param.GetMtxV(InitMtxV);
        UnNormalizeAffMtxV(InitMtxV, true);
        Param.SetMtxV(InitMtxV);
}

Here is the call graph for this function:

double TMAGFitBern::DoEStep	(	const TFltV &	TrueMuV,
		const int &	NIter,
		double &	LL,
		const double &	Lambda
	)

Definition at line 1272 of file mag.cpp.

References TVVec< TVal, TSizeTy >::Clr(), DoEStepApxOneIter(), DoEStepOneIter(), ESpeedUp, TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetNodes(), TExeTm::GetTmStr(), TVec< TVal, TSizeTy >::Last(), and Param.

Referenced by DoEMAlg().

                                                                                                    {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TFltVV NewPhiVV(NNodes, NAttrs);
        // double MI;

        TFltV Delta(NIter);

        for(int i = 0; i < NIter; i++) {
                TExeTm IterTm;
                printf("EStep iteration : %d\n", (i+1));
                if(ESpeedUp) {
                        Delta[i] = DoEStepApxOneIter(TrueMuV, NewPhiVV, Lambda);
                } else {
                        Delta[i] = DoEStepOneIter(TrueMuV, NewPhiVV, Lambda);
                }
//              PhiVV = NewPhiVV;

                printf("  (Time = %s)\n", IterTm.GetTmStr());
        }
        printf("\n");

        NewPhiVV.Clr();

        return Delta.Last();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double TMAGFitBern::DoEStepApxOneIter	(	const TFltV &	TrueMuV,
		TFltVV &	NewPhi,
		const double &	Lambda
	)

Definition at line 1134 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), AvgPhiPairVV, AvgPhiV, TVec< TVal, TSizeTy >::Gen(), TVVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), GetAvgProdLinWeight(), GetAvgProdSqWeight(), GetAvgSqThetaLL(), GetAvgThetaLL(), TMAGParam< TNodeAttr >::GetNodes(), TRnd::GetUniDevInt(), KnownVV, Param, PhiVV, TVec< TVal, TSizeTy >::PutAll(), TVVec< TVal, TSizeTy >::PutAll(), and UpdateApxPhiMI().

Referenced by DoEStep().

                                                                                                  {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        double MaxDelta = 0, L1 = 0;
        double Val;
        TFltIntIntTrV NewVal;
        int RndCount = 0;
        // double OldMI = 0.0, NewMI = 0.0;
        TFltV MuV(NAttrs);      MuV.PutAll(0.0);
        TFltVV ProdVV(NNodes, 4);       ProdVV.PutAll(0.0);
        TIntV NIndV(NNodes), AIndV(NAttrs);

        //      Update Phi
        /*
        for(int i = 0; i < NNodes; i++) {  NIndV[i] = i;  }
        for(int l = 0; l < NAttrs; l++) {  AIndV[l] = l;  }
        if(Randomized) {
                NIndV.Shuffle(TMAGNodeBern::Rnd);
                AIndV.Shuffle(TMAGNodeBern::Rnd);
        }
        */

        AvgPhiV.Gen(NAttrs);    AvgPhiV.PutAll(0.0);
        AvgPhiPairVV.Gen(NAttrs, 4*NAttrs);             AvgPhiPairVV.PutAll(0.0);
        for(int i = 0; i < NNodes; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        for(int p = l+1; p < NAttrs; p++) {
                                int index = 4 * p;
                                AvgPhiPairVV(l, index) += PhiVV(i, l) * PhiVV(i, p);
                                AvgPhiPairVV(l, index+1) += PhiVV(i, l) * (1.0-PhiVV(i, p));
                                AvgPhiPairVV(l, index+2) += (1.0-PhiVV(i, l)) * PhiVV(i, p);
                                AvgPhiPairVV(l, index+3) += (1.0-PhiVV(i, l)) * (1.0-PhiVV(i, p));
                        }
                        AvgPhiV[l] += PhiVV(i, l);
                }
        }
        for(int i = 0; i < NNodes; i++) {
                ProdVV(i, 0) = GetAvgProdLinWeight(i, i, true, false);
                ProdVV(i, 1) = GetAvgProdLinWeight(i, i, false, true);
                ProdVV(i, 2) = GetAvgProdSqWeight(i, i, true, false);
                ProdVV(i, 3) = GetAvgProdSqWeight(i, i, false, true);
        }

        const int Iter = 3;

        NewVal.Gen(NAttrs * Iter);
        for(int i = 0; i < NNodes * Iter; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        const int NId = TMAGNodeBern::Rnd.GetUniDevInt(NNodes);
                        const int AId = TMAGNodeBern::Rnd.GetUniDevInt(NAttrs);
                        double Delta = 0.0;
                        if(KnownVV(NId, AId)) {
                                Val = PhiVV.At(NId, AId);
                        } else {
                                Delta = UpdateApxPhiMI(Lambda, NId, AId, Val, ProdVV);
                        }

//                      PhiVV.At(NId, AId) = Val;
                        NewVal[l] = TFltIntIntTr(Val, NId, AId);
                        
//                      MuV[AId] = MuV[AId] + Val;
                        if(fabs(Delta) > MaxDelta) {
                                MaxDelta = fabs(Delta);
                        }
                        if(Val > 0.3 && Val < 0.7) {    RndCount++;     }
                }

                for(int l = 0; l < NAttrs; l++) {
                        const int NId = NewVal[l].Val2;
                        const int AId = NewVal[l].Val3;

                        ProdVV(NId, 0) -= GetAvgThetaLL(NId, NId, AId, true, false);
                        ProdVV(NId, 1) -= GetAvgThetaLL(NId, NId, AId, false, true);
                        ProdVV(NId, 2) -= GetAvgSqThetaLL(NId, NId, AId, true, false);
                        ProdVV(NId, 3) -= GetAvgSqThetaLL(NId, NId, AId, false, true);
                        for(int p = 0; p < NAttrs; p++) {
                                if(p > AId) {
                                        int index = 4 * p;
                                        AvgPhiPairVV(AId, index) -= PhiVV(NId, AId) * PhiVV(NId, p);
                                        AvgPhiPairVV(AId, index+1) -= PhiVV(NId, AId) * (1.0-PhiVV(NId, p));
                                        AvgPhiPairVV(AId, index+2) -= (1.0-PhiVV(NId, AId)) * PhiVV(NId, p);
                                        AvgPhiPairVV(AId, index+3) -= (1.0-PhiVV(NId, AId)) * (1.0-PhiVV(NId, p));
                                } else if (p < AId) {
                                        int index = 4 * AId;
                                        AvgPhiPairVV(p, index) -= PhiVV(NId, p) * PhiVV(NId, AId);
                                        AvgPhiPairVV(p, index+1) -= PhiVV(NId, p) * (1.0-PhiVV(NId, AId));
                                        AvgPhiPairVV(p, index+2) -= (1.0-PhiVV(NId, p)) * PhiVV(NId, AId);
                                        AvgPhiPairVV(p, index+3) -= (1.0-PhiVV(NId, p)) * (1.0-PhiVV(NId, AId));
                                }
                        }
                        AvgPhiV[AId] -= PhiVV(NId, AId);

                        PhiVV.At(NId, AId) = NewVal[l].Val1;
                        
                        ProdVV(NId, 0) += GetAvgThetaLL(NId, NId, AId, true, false);
                        ProdVV(NId, 1) += GetAvgThetaLL(NId, NId, AId, false, true);
                        ProdVV(NId, 2) += GetAvgSqThetaLL(NId, NId, AId, true, false);
                        ProdVV(NId, 3) += GetAvgSqThetaLL(NId, NId, AId, false, true);
                        for(int p = 0; p < NAttrs; p++) {
                                if(p > AId) {
                                        int index = 4 * p;
                                        AvgPhiPairVV(AId, index) += PhiVV(NId, AId) * PhiVV(NId, p);
                                        AvgPhiPairVV(AId, index+1) += PhiVV(NId, AId) * (1.0-PhiVV(NId, p));
                                        AvgPhiPairVV(AId, index+2) += (1.0-PhiVV(NId, AId)) * PhiVV(NId, p);
                                        AvgPhiPairVV(AId, index+3) += (1.0-PhiVV(NId, AId)) * (1.0-PhiVV(NId, p));
                                } else if (p < AId) {
                                        int index = 4 * AId;
                                        AvgPhiPairVV(p, index) += PhiVV(NId, p) * PhiVV(NId, AId);
                                        AvgPhiPairVV(p, index+1) += PhiVV(NId, p) * (1.0-PhiVV(NId, AId));
                                        AvgPhiPairVV(p, index+2) += (1.0-PhiVV(NId, p)) * PhiVV(NId, AId);
                                        AvgPhiPairVV(p, index+3) += (1.0-PhiVV(NId, p)) * (1.0-PhiVV(NId, AId));
                                }
                        }
                        AvgPhiV[AId] += PhiVV(NId, AId);
                }
        }

        for(int l = 0; l < NAttrs; l++) {
                MuV[l] = AvgPhiV[l] / double(NNodes);
        }

        TFltV SortMuV = MuV;
        double Avg = 0.0;
//      SortMuV.Sort(false);
        for(int l = 0; l < NAttrs; l++) {
                printf("  F[%d] = %.3f", l, double(MuV[l]));
                Avg += SortMuV[l];
//              L1 += fabs(TrueMuV[l] - SortMuV[l]);
        }
        printf("\n");
        printf("  Rnd = %d(%.3f)", RndCount, double(RndCount) / double(NNodes * NAttrs));
        printf("  Avg = %.3f\n", Avg / double(NAttrs));
//      printf("  Linf = %f\n", MaxDelta);
//      L1 /= double(NAttrs);

        return L1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double TMAGFitBern::DoEStepOneIter	(	const TFltV &	TrueMuV,
		TFltVV &	NewPhi,
		const double &	Lambda
	)

Definition at line 1056 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), TVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetNodes(), TRnd::GetUniDevInt(), KnownVV, Param, PhiVV, TVec< TVal, TSizeTy >::PutAll(), TVec< TVal, TSizeTy >::Sort(), and UpdatePhiMI().

Referenced by DoEStep().

                                                                                               {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        double MaxDelta = 0, L1 = 0;
        double Val;
        TFltIntIntTrV NewVal;
        int RndCount = 0;
        // double OldMI = 0.0, NewMI = 0.0;
        TFltV MuV(NAttrs);      MuV.PutAll(0.0);
        TIntV NIndV(NNodes), AIndV(NAttrs);

        //      Update Phi
        /*
        for(int i = 0; i < NNodes; i++) {  NIndV[i] = i;  }
        for(int l = 0; l < NAttrs; l++) {  AIndV[l] = l;  }
        if(Randomized) {
                NIndV.Shuffle(TMAGNodeBern::Rnd);
                AIndV.Shuffle(TMAGNodeBern::Rnd);
        }
        */

        NewVal.Gen(NAttrs * 2);
        for(int i = 0; i < NNodes; i++) {
//              const int NId = NIndV[i]%NNodes;
                for(int l = 0; l < NAttrs * 2; l++) {
                        const int NId = TMAGNodeBern::Rnd.GetUniDevInt(NNodes);
                        const int AId = TMAGNodeBern::Rnd.GetUniDevInt(NAttrs);
//                      const int AId = AIndV[l]%NAttrs;
//                      double Delta = UpdatePhi(NId, AId, Val);
                        double Delta = 0.0;
                        if(KnownVV(NId, AId)) {
                                Val = PhiVV.At(NId, AId);
                        } else {
                                Delta = UpdatePhiMI(Lambda, NId, AId, Val);
                        }

//                      PhiVV.At(NId, AId) = Val;
                        NewVal[l] = TFltIntIntTr(Val, NId, AId);
                        
//                      MuV[AId] = MuV[AId] + Val;
                        if(fabs(Delta) > MaxDelta) {
                                MaxDelta = fabs(Delta);
                        }
                        if(Val > 0.3 && Val < 0.7) {    RndCount++;     }
                }

                for(int l = 0; l < NAttrs * 2; l++) {
                        const int NId = NewVal[l].Val2;
                        const int AId = NewVal[l].Val3;
                        PhiVV.At(NId, AId) = NewVal[l].Val1;
                }
        }
        for(int i = 0; i < NNodes; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        MuV[l] = MuV[l] + PhiVV.At(i, l);
                }
        }
        for(int l = 0; l < NAttrs; l++) {
                MuV[l] = MuV[l] / double(NNodes);
        }

        TFltV SortMuV = MuV;
        double Avg = 0.0;
        SortMuV.Sort(false);
        for(int l = 0; l < NAttrs; l++) {
                printf("  F[%d] = %.3f", l, double(MuV[l]));
                Avg += SortMuV[l];
                L1 += fabs(TrueMuV[l] - SortMuV[l]);
        }
        printf("\n");
        printf("  Rnd = %d(%.3f)", RndCount, double(RndCount) / double(NNodes * NAttrs));
        printf("  Avg = %.3f\n", Avg / double(NAttrs));
        L1 /= double(NAttrs);

        return L1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::DoMStep	(	const int &	GradIter,
		const double &	LrnRate,
		const double &	MaxGrad,
		const double &	Lambda,
		const int &	NReal = 0
	)

Definition at line 1608 of file mag.cpp.

References AvgPhiV, TVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TExeTm::GetTmStr(), Param, TVec< TVal, TSizeTy >::PutAll(), UpdateAffMtxV(), and UpdateMu().

Referenced by DoEMAlg().

                                                                                                                                   {
        // const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        double MuDelta = 0.0, AffMtxDelta = 0.0;

        TExeTm ExeTm;
        
        printf("\n");
        AvgPhiV.Gen(NAttrs);    AvgPhiV.PutAll(0.0);
        for(int l = 0; l < NAttrs; l++) {
//              printf("    [Attr = %d]\n", l);
                MuDelta += UpdateMu(l);
        }
        printf("\n");

        printf("  == Update Theta\n");
        AffMtxDelta += UpdateAffMtxV(GradIter, LrnRate, MaxGrad, Lambda, NReal);
        printf("\n");
        printf("Elpased time = %s\n", ExeTm.GetTmStr());
        printf("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

const int TMAGFitBern::GetAttrs ( ) const

inline

Definition at line 376 of file mag.h.

References TMAGParam< TNodeAttr >::GetAttrs(), and Param.

{ return Param.GetAttrs(); }

Here is the call graph for this function:

const double TMAGFitBern::GetAvgInCoeff	(	const int &	i,
		const int &	AId,
		const int &	A,
		const TMAGAffMtx &	Theta
	)		const

Definition at line 558 of file mag.cpp.

References TMAGAffMtx::At(), AvgPhiV, TMAGParam< TNodeAttr >::GetNodes(), and Param.

Referenced by UpdateApxPhiMI().

                                                                                                                 {
        const int NNodes = Param.GetNodes();
        const double Mu_l = AvgPhiV[AId] / double(NNodes);
        return (Mu_l * Theta.At(0, A) + (1.0 - Mu_l) * Theta.At(1, A));
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetAvgOutCoeff	(	const int &	i,
		const int &	AId,
		const int &	A,
		const TMAGAffMtx &	Theta
	)		const

Definition at line 564 of file mag.cpp.

References TMAGAffMtx::At(), AvgPhiV, TMAGParam< TNodeAttr >::GetNodes(), and Param.

Referenced by UpdateApxPhiMI().

                                                                                                                  {
        const int NNodes = Param.GetNodes();
        const double Mu_l = AvgPhiV[AId] / double(NNodes);
        return (Mu_l * Theta.At(A, 0) + (1.0 - Mu_l) * Theta.At(A, 1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetAvgProdLinWeight	(	const int &	NId1,
		const int &	NId2,
		const bool	Left = false,
		const bool	Right = false
	)		const

Definition at line 642 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetAttrs(), GetAvgThetaLL(), NormConst, and Param.

Referenced by DoEStepApxOneIter(), and PrepareUpdateApxAffMtx().

                                                                                                                       {
        const int NAttrs = Param.GetAttrs();
        double LL = 0.0;

        for(int l = 0; l < NAttrs; l++) {
                LL += GetAvgThetaLL(NId1, NId2, l, Left, Right);
        }
//      return LL;
        return LL + log(NormConst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetAvgProdSqWeight	(	const int &	NId1,
		const int &	NId2,
		const bool	Left = false,
		const bool	Right = false
	)		const

Definition at line 664 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetAttrs(), GetAvgSqThetaLL(), NormConst, and Param.

Referenced by DoEStepApxOneIter(), and PrepareUpdateApxAffMtx().

                                                                                                                      {
        const int NAttrs = Param.GetAttrs();
        double LL = 0.0;

        for(int l = 0; l < NAttrs; l++) {
                LL += GetAvgSqThetaLL(NId1, NId2, l, Left, Right);
        }
//      return LL;
        return LL + 2 * log(NormConst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetAvgSqThetaLL	(	const int &	NId1,
		const int &	NId2,
		const int &	AId,
		const bool	Left = false,
		const bool	Right = false
	)		const

Definition at line 620 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetMtx(), GetProbMu(), and Param.

Referenced by DoEStepApxOneIter(), GetAvgProdSqWeight(), GradApxAffMtx(), and UpdateApxPhiMI().

                                                                                                                                   {
        double LL = 0.0;
        const TMAGAffMtx& Mtx = Param.GetMtx(AId);
        for(int A1 = 0; A1 < 2; A1++) {
                for(int A2 = 0; A2 < 2; A2++) {
                        LL += GetProbMu(NId1, NId2, AId, A1, A2, Left, Right) * Mtx.At(A1, A2) * Mtx.At(A1, A2);
                }
        }
        return log(LL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetAvgThetaLL	(	const int &	NId1,
		const int &	NId2,
		const int &	AId,
		const bool	Left = false,
		const bool	Right = false
	)		const

Definition at line 598 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetMtx(), GetProbMu(), and Param.

Referenced by DoEStepApxOneIter(), GetAvgProdLinWeight(), GradApxAffMtx(), and UpdateApxPhiMI().

                                                                                                                                 {
        double LL = 0.0;
        const TMAGAffMtx& Mtx = Param.GetMtx(AId);
        for(int A1 = 0; A1 < 2; A1++) {
                for(int A2 = 0; A2 < 2; A2++) {
                        LL += GetProbMu(NId1, NId2, AId, A1, A2, Left, Right) * Mtx.At(A1, A2);
                }
        }
        return log(LL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetEstNoEdgeLL	(	const int &	NId,
		const int &	AId
	)		const

Definition at line 746 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetNodeAttr(), and Param.

                                                                             {
        // const int NNodes = Param.GetNodes();
        // const int NAttrs = Param.GetAttrs();
        
        TMAGNodeBern DistParam = Param.GetNodeAttr();
        double LL = 0.0;

        return LL;
}

Here is the call graph for this function:

PNGraph TMAGFitBern::GetGraph ( )

inline

Definition at line 383 of file mag.h.

References Graph.

{  return Graph;  }

const double TMAGFitBern::GetInCoeff	(	const int &	i,
		const int &	j,
		const int &	l,
		const int &	A,
		const TMAGAffMtx &	Theta
	)		const

Definition at line 550 of file mag.cpp.

References TMAGAffMtx::At(), TVVec< TVal, TSizeTy >::At(), and PhiVV.

Referenced by UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

                                                                                                                          {
        return (PhiVV.At(i, l) * Theta.At(0, A) + (1.0 - PhiVV.At(i, l)) * Theta.At(1, A));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::GetMtxV ( TMAGAffMtxV &  MtxV ) const

inline

Definition at line 381 of file mag.h.

References TMAGParam< TNodeAttr >::GetMtxV(), and Param.

{  Param.GetMtxV(MtxV);  }

Here is the call graph for this function:

const TFltV& TMAGFitBern::GetMuV ( ) const

inline

Definition at line 379 of file mag.h.

References TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), and Param.

Referenced by NormalizeAffMtxV(), SaveTxt(), and UnNormalizeAffMtxV().

{  const TMAGNodeBern& Dist = Param.GetNodeAttr();  return Dist.GetMuV();  }

Here is the call graph for this function:

Here is the caller graph for this function:

const TMAGNodeBern& TMAGFitBern::GetNodeAttr ( ) const

inline

Definition at line 378 of file mag.h.

References TMAGParam< TNodeAttr >::GetNodeAttr(), and Param.

{  return Param.GetNodeAttr();  }

Here is the call graph for this function:

const int TMAGFitBern::GetNodes ( ) const

inline

Definition at line 375 of file mag.h.

References TMAGParam< TNodeAttr >::GetNodes(), and Param.

{ return Param.GetNodes(); }

Here is the call graph for this function:

const double TMAGFitBern::GetOutCoeff	(	const int &	i,
		const int &	j,
		const int &	l,
		const int &	A,
		const TMAGAffMtx &	Theta
	)		const

Definition at line 554 of file mag.cpp.

References TMAGAffMtx::At(), TVVec< TVal, TSizeTy >::At(), and PhiVV.

Referenced by UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

                                                                                                                           {
        return (PhiVV.At(j, l) * Theta.At(A, 0) + (1.0 - PhiVV.At(j, l)) * Theta.At(A, 1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

const TMAGParam<TMAGNodeBern>& TMAGFitBern::GetParams ( ) const

inline

Definition at line 377 of file mag.h.

References Param.

{ return Param; }

const TFltVV& TMAGFitBern::GetPhiVV ( ) const

inline

Definition at line 392 of file mag.h.

References PhiVV.

{ return PhiVV; }

const double TMAGFitBern::GetProbMu	(	const int &	NId1,
		const int &	NId2,
		const int &	AId,
		const int &	Attr1,
		const int &	Attr2,
		const bool	Left = false,
		const bool	Right = false
	)		const

Definition at line 576 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), AvgPhiV, TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), Param, and PhiVV.

Referenced by GetAvgSqThetaLL(), GetAvgThetaLL(), and GradApxAffMtx().

                                                                                                                                                                 {
        TMAGNodeBern DistParam = Param.GetNodeAttr();
//      double Mu = DistParam.GetMu(AId);
        double Mu = AvgPhiV[AId] / double(Param.GetNodes());
        double Prob1 = (Left) ? double(PhiVV.At(NId1, AId)) : double(Mu);
        double Prob2 = (Right)? double(PhiVV.At(NId2, AId)) : double(Mu);
        Prob1 = (Attr1 == 0) ? Prob1 : 1.0 - Prob1;
        Prob2 = (Attr2 == 0) ? Prob2 : 1.0 - Prob2;
        return (Prob1 * Prob2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetProbPhi	(	const int &	NId1,
		const int &	NId2,
		const int &	AId,
		const int &	Attr1,
		const int &	Attr2
	)		const

Definition at line 570 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), and PhiVV.

Referenced by ComputeApxAdjLL(), ComputeApxLL(), GetSqThetaLL(), GetThetaLL(), GradAffMtx(), and GradApxAffMtx().

                                                                                                                               {
        double Prob1 = (Attr1 == 0) ? double(PhiVV.At(NId1, AId)) : (1.0 - PhiVV.At(NId1, AId));
        double Prob2 = (Attr2 == 0) ? double(PhiVV.At(NId2, AId)) : (1.0 - PhiVV.At(NId2, AId));
        return (Prob1 * Prob2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetProdLinWeight	(	const int &	NId1,
		const int &	NId2
	)		const

Definition at line 631 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetAttrs(), GetThetaLL(), NormConst, and Param.

Referenced by ComputeApxAdjLL(), ComputeApxLL(), GradApxAffMtx(), PrepareUpdateAffMtx(), UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

                                                                                 {
        const int NAttrs = Param.GetAttrs();
        double LL = 0.0;

        for(int l = 0; l < NAttrs; l++) {
                LL += GetThetaLL(NId1, NId2, l);
        }
//      return LL;
        return LL + log(NormConst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetProdSqWeight	(	const int &	NId1,
		const int &	NId2
	)		const

Definition at line 653 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetAttrs(), GetSqThetaLL(), NormConst, and Param.

Referenced by GradApxAffMtx(), PrepareUpdateAffMtx(), UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

                                                                                {
        const int NAttrs = Param.GetAttrs();
        double LL = 0.0;

        for(int l = 0; l < NAttrs; l++) {
                LL += GetSqThetaLL(NId1, NId2, l);
        }
//      return LL;
        return LL + 2 * log(NormConst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetSqThetaLL	(	const int &	NId1,
		const int &	NId2,
		const int &	AId
	)		const

Definition at line 609 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetMtx(), GetProbPhi(), and Param.

Referenced by GetProdSqWeight(), GradAffMtx(), GradApxAffMtx(), UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

                                                                                             {
        double LL = 0.0;
        const TMAGAffMtx& Mtx = Param.GetMtx(AId);
        for(int A1 = 0; A1 < 2; A1++) {
                for(int A2 = 0; A2 < 2; A2++) {
                        LL += GetProbPhi(NId1, NId2, AId, A1, A2) * Mtx.At(A1, A2) * Mtx.At(A1, A2);
                }
        }
        return log(LL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GetThetaLL	(	const int &	NId1,
		const int &	NId2,
		const int &	AId
	)		const

Definition at line 587 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetMtx(), GetProbPhi(), and Param.

Referenced by GetProdLinWeight(), GradAffMtx(), GradApxAffMtx(), UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

                                                                                           {
        double LL = 0.0;
        const TMAGAffMtx& Mtx = Param.GetMtx(AId);
        for(int A1 = 0; A1 < 2; A1++) {
                for(int A2 = 0; A2 < 2; A2++) {
                        LL += GetProbPhi(NId1, NId2, AId, A1, A2) * Mtx.At(A1, A2);
                }
        }
        return log(LL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const void TMAGFitBern::GradAffMtx	(	const int &	AId,
		const TFltVV &	ProdVV,
		const TFltVV &	SqVV,
		const TMAGAffMtx &	CurMtx,
		TFltV &	GradV
	)

Definition at line 1320 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetNodes(), GetProbPhi(), GetSqThetaLL(), GetThetaLL(), Graph, TNGraph::IsEdge(), Param, and TVec< TVal, TSizeTy >::PutAll().

Referenced by UpdateAffMtx().

                                                                                                                                   {
        const int NNodes = Param.GetNodes();
        // const int NAttrs = Param.GetAttrs();
        GradV.PutAll(0.0);
        
        for(int i = 0; i < NNodes; i++) {
                for(int j = 0; j < NNodes; j++) {
                        double Prod = ProdVV(i, j) - GetThetaLL(i, j, AId);
                        double Sq = SqVV(i, j) - GetSqThetaLL(i, j, AId);

                        for(int p = 0; p < 4; p++) {
                                int Ai = p / 2;
                                int Aj = p % 2;
                                double Prob = GetProbPhi(i, j, AId, Ai, Aj);
                                if(Graph->IsEdge(i, j)) {
                                        GradV[p] += Prob / CurMtx.At(p);
                                } else {
                                        GradV[p] -= Prob * exp(Prod);
                                        GradV[p] -= Prob * exp(Sq) * CurMtx.At(p);
                                }
                        }
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const void TMAGFitBern::GradApxAffMtx	(	const int &	AId,
		const TFltVV &	ProdVV,
		const TFltVV &	SqVV,
		const TMAGAffMtx &	CurMtx,
		TFltV &	GradV
	)

Definition at line 1346 of file mag.cpp.

References TVec< TVal, TSizeTy >::Add(), TMAGAffMtx::At(), TNGraph::BegEI(), TNGraph::EndEI(), TVec< TVal, TSizeTy >::Gen(), GetAvgSqThetaLL(), GetAvgThetaLL(), TMAGParam< TNodeAttr >::GetNodes(), GetProbMu(), GetProbPhi(), GetProdLinWeight(), GetProdSqWeight(), GetSqThetaLL(), GetThetaLL(), Graph, LogSumExp(), Param, and TVec< TVal, TSizeTy >::PutAll().

Referenced by UpdateAffMtx().

                                                                                                                                      {
        const int NNodes = Param.GetNodes();
        // const int NAttrs = Param.GetAttrs();
        // const int NSq = NNodes * (NNodes - 1);
        GradV.PutAll(0.0);

        TFltV LogSumV;
        for(int p = 0; p < 4; p++) {
                int Ai = p / 2;
                int Aj = p % 2;
                LogSumV.Gen(NNodes * 4, 0);

                for(int i = 0; i < NNodes; i++) {
                        const double LProd = ProdVV(i, 0) - GetAvgThetaLL(i, i, AId, true, false);
                        const double LSq = SqVV(i, 0) - GetAvgSqThetaLL(i, i, AId, true, false);
                        const double RProd = ProdVV(i, 1) - GetAvgThetaLL(i, i, AId, false, true);
                        const double RSq = SqVV(i, 1) - GetAvgSqThetaLL(i, i, AId, false, true);

                        LogSumV.Add(LProd + log(GetProbMu(i, i, AId, Ai, Aj, true, false)));
                        LogSumV.Add(LSq + log(GetProbMu(i, i, AId, Ai, Aj, true, false)) + log(CurMtx.At(p)));
                        LogSumV.Add(RProd + log(GetProbMu(i, i, AId, Ai, Aj, false, true)));
                        LogSumV.Add(RSq + log(GetProbMu(i, i, AId, Ai, Aj, false, true)) + log(CurMtx.At(p)));
                }
                double LogSum = LogSumExp(LogSumV);
                GradV[p] -= (NNodes - 1) * 0.5 * exp(LogSum);
        }
        
        for(TNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
                const int NId1 = EI.GetSrcNId();
                const int NId2 = EI.GetDstNId();
                const double ProdOne = GetProdLinWeight(NId1, NId2) - GetThetaLL(NId1, NId2, AId);
                const double SqOne = GetProdSqWeight(NId1, NId2) - GetSqThetaLL(NId1, NId2, AId);

                for(int p = 0; p < 4; p++) {
                        int Ai = p / 2;
                        int Aj = p % 2;
                        double Prob = GetProbPhi(NId1, NId2, AId, Ai, Aj);
                        GradV[p] += Prob / CurMtx.At(p);
                        GradV[p] += Prob * exp(ProdOne);
                        GradV[p] += Prob * exp(SqOne) * CurMtx.At(p);
                }
        }

#if 0
        const double Prod = ProdVV(0, 0) - GetAvgThetaLL(0, 0, AId, false, false);
        const double Sq = SqVV(0, 0) - GetAvgSqThetaLL(0, 0, AId, false, false);
        for(int p = 0; p < 4; p++) {
                int Ai = p / 2;
                int Aj = p % 2;
                GradV[p] -= NSq * exp(Prod) * GetProbMu(0, 0, AId, Ai, Aj, false, false);
                GradV[p] -= NSq * exp(Sq) * GetProbMu(0, 0, AId, Ai, Aj, false, false) * CurMtx.At(p);
        }

        for(TNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
                const int NId1 = EI.GetSrcNId();
                const int NId2 = EI.GetDstNId();
                const double ProdOne = GetProdLinWeight(NId1, NId2) - GetThetaLL(NId1, NId2, AId);
                const double SqOne = GetProdSqWeight(NId1, NId2) - GetSqThetaLL(NId1, NId2, AId);

                for(int p = 0; p < 4; p++) {
                        int Ai = p / 2;
                        int Aj = p % 2;
                        double Prob = GetProbPhi(NId1, NId2, AId, Ai, Aj);
//                      GradV[p] += Prob / CurMtx.At(p);
//                      GradV[p] += Prob * exp(ProdOne);
//                      GradV[p] += Prob * exp(SqOne) * CurMtx.At(p);
                }
        }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::GradPhiMI	(	const double &	x,
		const int &	NId,
		const int &	AId,
		const double &	Lambda,
		const double &	DeltaQ,
		const TFltVV &	CntVV
	)

Definition at line 703 of file mag.cpp.

References TVVec< TVal, TSizeTy >::GetYDim(), and PhiVV.

Referenced by UpdateApxPhiMI(), and UpdatePhiMI().

                                                                                                                                                    {
        const int NAttrs = CntVV.GetYDim();
        double Grad = DeltaQ - log(x) + log(1.0-x);

        for(int l = 0; l < NAttrs; l++) {
                if(l == AId) {  continue;  }
                const double C0 = PhiVV(NId, l);
                const double C1 = 1.0 - C0;
                Grad -= Lambda * C0 * log(CntVV(0, l) + C0 * x);
                Grad -= Lambda * C1 * log(CntVV(1, l) + C1 * x);
                Grad += Lambda * C0 * log(CntVV(2, l) + C0 * (1-x));
                Grad += Lambda * C1 * log(CntVV(3, l) + C1 * (1-x));
                Grad -= Lambda * log(CntVV(0, l) + CntVV(1, l) + x);
                Grad += Lambda * log(CntVV(2, l) + CntVV(3, l) + (1-x));
        }

        return Grad;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::Init	(	const TFltV &	MuV,
		const TMAGAffMtxV &	AffMtxV
	)

Definition at line 452 of file mag.cpp.

References TVVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetNodes(), KnownVV, Param, PhiVV, TVVec< TVal, TSizeTy >::PutAll(), TMAGParam< TNodeAttr >::SetMtxV(), and TMAGParam< TNodeAttr >::SetNodeAttr().

                                                                   {
        TMAGNodeBern DistParam(MuV);
        Param.SetNodeAttr(DistParam);
        Param.SetMtxV(AffMtxV);

        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();

        PhiVV.Gen(NNodes, NAttrs);
        KnownVV.Gen(NNodes, NAttrs);
        KnownVV.PutAll(false);
}

Here is the call graph for this function:

void TMAGFitBern::MakeCCDF	(	const TFltPrV &	RawV,
		TFltPrV &	CcdfV
	)

Definition at line 1703 of file mag.cpp.

References TVec< TVal, TSizeTy >::Add(), TVec< TVal, TSizeTy >::Gen(), IAssert, and TVec< TVal, TSizeTy >::Len().

Referenced by PlotProperties().

                                                              {
        double Total = 0.0;
        CcdfV.Gen(RawV.Len(), 0);

        for(int i = 0; i < RawV.Len(); i++) {
                if(RawV[i].Val2 <= 0) {  continue;  }
                Total += RawV[i].Val2;
                CcdfV.Add(RawV[i]);
                IAssert(RawV[i].Val2 > 0);
        }
        for(int i = 1; i < CcdfV.Len(); i++) {
                CcdfV[i].Val2 += CcdfV[i-1].Val2;
        }

        for(int i = CcdfV.Len() - 1; i > 0; i--) {
                CcdfV[i].Val2 = (Total - CcdfV[i-1].Val2) ;
                if(CcdfV[i].Val2 <= 0) {  printf("CCDF = %f\n", double(CcdfV[i].Val2));}
                IAssert(CcdfV[i].Val2 > 0);
        }
        CcdfV[0].Val2 = Total;
//      CcdfV[0].Val2 = 1.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const bool TMAGFitBern::NextPermutation ( TIntV &  IndexV ) const

private

Definition at line 1867 of file mag.cpp.

References TVec< TVal, TSizeTy >::GetSubValV(), TVec< TVal, TSizeTy >::Len(), and TVec< TVal, TSizeTy >::Sort().

                                                           {
        const int NAttrs = IndexV.Len();
        int Pos = NAttrs - 1;
        while(Pos > 0) {
                if(IndexV[Pos-1] < IndexV[Pos]) {
                        break;
                }
                Pos--;
        }
        if(Pos == 0) {
                return false;
        }

        int Val = NAttrs, NewPos = -1;
        for(int i = Pos; i < NAttrs; i++) {
                if(IndexV[i] > IndexV[Pos - 1] && IndexV[i] < Val) {
                        NewPos = i;
                        Val = IndexV[i];
                }
        }
        IndexV[NewPos] = IndexV[Pos - 1];
        IndexV[Pos - 1] = Val;

        TIntV SubIndexV;
    IndexV.GetSubValV(Pos, NAttrs - 1, SubIndexV);
        SubIndexV.Sort(true);
        for(int i = Pos; i < NAttrs; i++) {
                IndexV[i] = SubIndexV[i - Pos];
        }

        return true;
}

Here is the call graph for this function:

void TMAGFitBern::NormalizeAffMtxV	(	TMAGAffMtxV &	MtxV,
		const bool	UseMu = false
	)

Definition at line 1454 of file mag.cpp.

References AvgPhiV, TNGraph::GetEdges(), GetMuV(), TMAGParam< TNodeAttr >::GetNodes(), Graph, TVec< TVal, TSizeTy >::Len(), NormConst, and Param.

Referenced by DoEMAlg(), UnNormalizeAffMtxV(), and UpdateAffMtxV().

                                                                      {
        const int NNodes = Param.GetNodes();
        const int NAttrs = MtxV.Len();
        TFltV MuV = GetMuV();
        double Product = 1.0, ExpEdge = NNodes * (NNodes - 1);
        
        TFltV SumV(NAttrs), EdgeSumV(NAttrs);
        SumV.PutAll(0.0);       EdgeSumV.PutAll(0.0);
        for(int l = 0; l < NAttrs; l++) {
                double Mu = (UseMu) ? double(MuV[l]) : (AvgPhiV[l] / double(NNodes));
                EdgeSumV[l] += Mu * Mu * MtxV[l].At(0, 0);
                EdgeSumV[l] += Mu * (1.0-Mu) * MtxV[l].At(0, 1);
                EdgeSumV[l] += Mu * (1.0-Mu) * MtxV[l].At(1, 0);
                EdgeSumV[l] += (1.0-Mu) * (1.0-Mu) * MtxV[l].At(1, 1);
                SumV[l] = SumV[l] + MtxV[l].At(0, 0);
                SumV[l] = SumV[l] + MtxV[l].At(0, 1);
                SumV[l] = SumV[l] + MtxV[l].At(1, 0);
                SumV[l] = SumV[l] + MtxV[l].At(1, 1);
                Product *= SumV[l];
                ExpEdge *= EdgeSumV[l];
        }
        ExpEdge = Graph->GetEdges() / ExpEdge;
        NormConst *= Product;
//      NormConst = ExpEdge;
        Product = 1.0;
//      Product = pow(Product * ExpEdge, 1.0 / double(NAttrs));
        
        for(int l = 0; l < NAttrs; l++) {
                for(int p = 0; p < 4; p++) {
                        MtxV[l].At(p) = MtxV[l].At(p) * Product / SumV[l];
//                      MtxV[l].At(p) = MtxV[l].At(p) * Product / MtxV[l].At(0, 0);
//                      MtxV[l].At(p) = MtxV[l].At(p) * Product;
//                      if(MtxV[l].At(p) > 0.9999) {  MtxV[l].At(p) = 0.9999;  }
//                      if(MtxV[l].At(p) < 0.0001) {  MtxV[l].At(p) = 0.0001;  }
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::ObjPhiMI	(	const double &	x,
		const int &	NId,
		const int &	AId,
		const double &	Lambda,
		const double &	Q0,
		const double &	Q1,
		const TFltVV &	CntVV
	)

Definition at line 722 of file mag.cpp.

References TVVec< TVal, TSizeTy >::GetYDim(), and PhiVV.

Referenced by UpdateApxPhiMI(), and UpdatePhiMI().

                                                                                                                                                                 {
        const int NAttrs = CntVV.GetYDim();
        double Val = x*(Q0 - log(x)) + (1-x)*(Q1 - log(1.0-x));

        for(int l = 0; l < NAttrs; l++) {
                if(l == AId) {  continue;  }
                const double C0 = PhiVV(NId, l);
                const double C1 = 1.0 - C0;
                Val -= Lambda * (CntVV(0, l) + C0 * x) * log(CntVV(0, l) + C0 * x);
                Val -= Lambda * (CntVV(1, l) + C1 * x) * log(CntVV(1, l) + C1 * x);
                Val -= Lambda * (CntVV(2, l) + C0 * (1-x)) * log(CntVV(2, l) + C0 * (1-x));
                Val -= Lambda * (CntVV(3, l) + C1 * (1-x)) * log(CntVV(3, l) + C1 * (1-x));
                Val += Lambda * (CntVV(0, l) + CntVV(1, l) + x) * log(CntVV(0, l) + CntVV(1, l) + x);
                Val += Lambda * (CntVV(2, l) + CntVV(3, l) + 1 - x) * log(CntVV(2, l) + CntVV(3, l) + (1-x));

                if(!(CntVV(0, l) > 0))  printf("CntVV(0, %d) = %.2f\n", l, double(CntVV(0, l)));
                if(!(CntVV(1, l) > 0))  printf("CntVV(1, %d) = %.2f\n", l, double(CntVV(1, l)));
                if(!(CntVV(2, l) > 0))  printf("CntVV(2, %d) = %.2f\n", l, double(CntVV(2, l)));
                if(!(CntVV(3, l) > 0))  printf("CntVV(3, %d) = %.2f\n", l, double(CntVV(3, l)));
        }

        return Val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::PlotProperties

(

const TStr &

FNm

)

Definition at line 1727 of file mag.cpp.

References TGStatVec::Add(), TGnuPlot::AddCmd(), TGnuPlot::AddPlot(), TGStatVec::At(), TSnap::DelZeroDegNodes(), TMAGParam< TNodeAttr >::GenMAG(), TMAGParam< TNodeAttr >::GetAttrs(), TNGraph::GetEdges(), TMAGParam< TNodeAttr >::GetMtxV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), gpsLog10XY, gpwLines, Graph, gsdClustCf, gsdHops, gsdInDeg, gsdOutDeg, gsdSngVal, gsdSngVec, gsdTriadPart, gsdWcc, TGStatVec::Len(), MakeCCDF(), Param, PhiVV, TGnuPlot::SaveEps(), TMAGParam< TNodeAttr >::SetMtxV(), TMAGParam< TNodeAttr >::SetNodeAttr(), TGnuPlot::SetScale(), TGnuPlot::SetXYLabel(), TGnuPlot::ShowGrid(), and tmuNodes.

                                                {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        TMAGParam<TMAGNodeBern> MAGGen(NNodes, NAttrs);
        TMAGNodeBern MAGNode = Param.GetNodeAttr();
        MAGGen.SetNodeAttr(MAGNode);
        TMAGAffMtxV MtxV;       Param.GetMtxV(MtxV);
        MAGGen.SetMtxV(MtxV);
        
        PNGraph TrG = new TNGraph;
        *TrG = *Graph;

        TIntVV AttrVV(NNodes, NAttrs);
        for(int i = 0; i < NNodes; i++) {
                for(int j = 0; j < NAttrs; j++) {
                        if(PhiVV(i, j) > TMAGNodeBern::Rnd.GetUniDev()) AttrVV(i, j) = 0;
                        else AttrVV(i, j) = 1;
                }
        }
        PNGraph MAG = MAGGen.GenMAG(AttrVV, true, 10000);
//      PNGraph MAG = MAGGen.GenAttrMAG(AttrVV, true, 10000);
        printf("%d edges created for MAG...\n", MAG->GetEdges());
        
        TSnap::DelZeroDegNodes(TrG);
        TSnap::DelZeroDegNodes(MAG);

        TGStatVec GS(tmuNodes, TFSet() | gsdInDeg | gsdOutDeg | gsdWcc | gsdHops | gsdClustCf | gsdSngVec | gsdSngVal | gsdTriadPart);
        
    TGnuPlot InDegP(FNm + "-InDeg"), OutDegP(FNm + "-OutDeg"), SvalP(FNm + "-Sval"), SvecP(FNm + "-Svec"), WccP(FNm + "-Wcc"), HopP(FNm + "-Hop"), TriadP(FNm + "-Triad"), CcfP(FNm + "-Ccf");;

    InDegP.SetXYLabel("Degree", "# of nodes");
    OutDegP.SetXYLabel("Degree", "# of nodes");
    SvalP.SetXYLabel("Rank", "Singular value");
    SvecP.SetXYLabel("Rank", "Primary SngVec component");
    WccP.SetXYLabel("Size of component", "# of components");
    CcfP.SetXYLabel("Degree", "Clustering coefficient");
    HopP.SetXYLabel("Hops", "# of node pairs");
    TriadP.SetXYLabel("# of triads", "# of participating nodes");

    InDegP.SetScale(gpsLog10XY);    InDegP.AddCmd("set key top right");
    OutDegP.SetScale(gpsLog10XY);   OutDegP.AddCmd("set key top right");
    SvalP.SetScale(gpsLog10XY);     SvalP.AddCmd("set key top right");
    SvecP.SetScale(gpsLog10XY);     SvecP.AddCmd("set key top right");
    CcfP.SetScale(gpsLog10XY);      CcfP.AddCmd("set key top right");
    HopP.SetScale(gpsLog10XY);      HopP.AddCmd("set key top right");
    TriadP.SetScale(gpsLog10XY);    TriadP.AddCmd("set key top right");
        InDegP.ShowGrid(false);
        OutDegP.ShowGrid(false);
        SvalP.ShowGrid(false);
        SvecP.ShowGrid(false);
        CcfP.ShowGrid(false);
        HopP.ShowGrid(false);
        TriadP.ShowGrid(false);
        
        const TStr Style[2] = {"lt 1 lw 3 lc rgb 'black'", "lt 2 lw 3 lc rgb 'red'"};
        const TStr Name[2] = {"Real", "MAG"};
        GS.Add(Graph, TSecTm(1), "Real Graph");
        GS.Add(MAG, TSecTm(2), "MAG");

        TFltPrV InDegV, OutDegV, SvalV, SvecV, HopV, WccV, CcfV, TriadV;
        for(int i = 0; i < GS.Len(); i++) {
                MakeCCDF(GS.At(i)->GetDistr(gsdInDeg), InDegV);
                MakeCCDF(GS.At(i)->GetDistr(gsdOutDeg), OutDegV);
                SvalV = GS.At(i)->GetDistr(gsdSngVal);
                SvecV = GS.At(i)->GetDistr(gsdSngVec);
                MakeCCDF(GS.At(i)->GetDistr(gsdClustCf), CcfV);
                HopV = GS.At(i)->GetDistr(gsdHops);
                MakeCCDF(GS.At(i)->GetDistr(gsdTriadPart), TriadV);

                InDegP.AddPlot(InDegV, gpwLines, Name[i], Style[i]);
                OutDegP.AddPlot(OutDegV, gpwLines, Name[i], Style[i]);
                SvalP.AddPlot(SvalV, gpwLines, Name[i], Style[i]);
                SvecP.AddPlot(SvecV, gpwLines, Name[i], Style[i]);
                CcfP.AddPlot(CcfV, gpwLines, Name[i], Style[i]);
                HopP.AddPlot(HopV, gpwLines, Name[i], Style[i]);
                TriadP.AddPlot(TriadV, gpwLines, Name[i], Style[i]);
        }

        InDegP.SaveEps(30);
        OutDegP.SaveEps(30);
        SvalP.SaveEps(30);
        SvecP.SaveEps(30);
        CcfP.SaveEps(30);
        HopP.SaveEps(30);
        TriadP.SaveEps(30);
}

Here is the call graph for this function:

const void TMAGFitBern::PrepareUpdateAffMtx	(	TFltVV &	ProdVV,
		TFltVV &	SqVV
	)

Definition at line 1532 of file mag.cpp.

References TVVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetNodes(), GetProdLinWeight(), GetProdSqWeight(), and Param.

Referenced by UpdateAffMtxV().

                                                                        {
        const int NNodes = Param.GetNodes();
        ProdVV.Gen(NNodes, NNodes);
        SqVV.Gen(NNodes, NNodes);

        for(int i = 0; i < NNodes; i++) {
                for(int j = 0; j < NNodes; j++) {
                        ProdVV(i, j) = GetProdLinWeight(i, j);
                        SqVV(i, j) = GetProdSqWeight(i, j);
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const void TMAGFitBern::PrepareUpdateApxAffMtx	(	TFltVV &	ProdVV,
		TFltVV &	SqVV
	)

Definition at line 1545 of file mag.cpp.

References TVVec< TVal, TSizeTy >::Gen(), GetAvgProdLinWeight(), GetAvgProdSqWeight(), TMAGParam< TNodeAttr >::GetNodes(), and Param.

Referenced by UpdateAffMtxV().

                                                                           {
        const int NNodes = Param.GetNodes();
        ProdVV.Gen(NNodes, 2);
        SqVV.Gen(NNodes, 2);

        for(int i = 0; i < NNodes; i++) {
                ProdVV(i, 0) = GetAvgProdLinWeight(i, i, true, false);
                ProdVV(i, 1) = GetAvgProdLinWeight(i, i, false, true);
                SqVV(i, 0) = GetAvgProdSqWeight(i, i, true, false);
                SqVV(i, 1) = GetAvgProdSqWeight(i, i, false, true);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::RandomInit	(	const TFltV &	MuV,
		const TMAGAffMtxV &	AffMtxV,
		const int &	Seed
	)

Definition at line 510 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), TVVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetNodes(), TRnd::GetUniDev(), KnownVV, Param, PhiVV, TVec< TVal, TSizeTy >::PutAll(), TVVec< TVal, TSizeTy >::PutAll(), TRnd::PutSeed(), TMAGNodeBern::Rnd, TMAGParam< TNodeAttr >::SetMtxV(), and TMAGParam< TNodeAttr >::SetNodeAttr().

                                                                                          {
        TRnd& Rnd = TMAGNodeBern::Rnd;
        Rnd.PutSeed(Seed);

        TFltV InitMuV = MuV;    InitMuV.PutAll(0.5);
        TMAGNodeBern DistParam(InitMuV);
        Param.SetMtxV(AffMtxV);
        
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        
        PhiVV.Gen(NNodes, NAttrs);
        KnownVV.Gen(NNodes, NAttrs);
        KnownVV.PutAll(false);

        for(int i = 0; i < NNodes; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        PhiVV.At(i, l) = Rnd.GetUniDev();
//                      PhiVV.At(i, l) = 0.5;
                }
        }
        
        TMAGAffMtxV RndMtxV = AffMtxV;
        for(int l = 0; l < NAttrs; l++) {
                for(int p = 0; p < 4; p++) {
                        RndMtxV[l].At(p) = TMAGNodeBern::Rnd.GetUniDev();
                        if(RndMtxV[l].At(p) < 0.1) {  RndMtxV[l].At(p) = 0.1;  }
                        if(RndMtxV[l].At(p) > 0.9) {  RndMtxV[l].At(p) = 0.9;  }
                }
                RndMtxV[l].At(0, 1) = RndMtxV[l].At(1, 0);
        }
        
        printf("\n");
        for(int l = 0; l < NAttrs; l++) {
                printf("AffMtx = %s\n", RndMtxV[l].GetMtxStr().GetCStr());
        }
        Param.SetMtxV(RndMtxV);
        Param.SetNodeAttr(DistParam);
}

Here is the call graph for this function:

void TMAGFitBern::SaveTxt

(

const TStr &

FNm

)

Definition at line 423 of file mag.cpp.

References TMAGParam< TNodeAttr >::GetAttrs(), TStr::GetCStr(), TMAGParam< TNodeAttr >::GetMtxV(), GetMuV(), TMAGParam< TNodeAttr >::GetNodes(), Param, and PhiVV.

                                         {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        const TFltV MuV = GetMuV();
        TMAGAffMtxV MtxV;
        Param.GetMtxV(MtxV);

        FILE *fp = fopen(FNm.GetCStr(), "w");
        for(int l = 0; l < NAttrs; l++) {
                fprintf(fp, "%.4f\t", double(MuV[l]));
                for(int row = 0; row < 2; row++) {
                        for(int col = 0; col < 2; col++) {
                                fprintf(fp, " %.4f", double(MtxV[l].At(row, col)));
                        }
                        fprintf(fp, (row == 0) ? ";" : "\n");
                }
        }
        fclose(fp);

        fp = fopen((FNm + "f").CStr(), "w");
        for(int i = 0; i < NNodes; i++) {
                for(int l = 0; l < NAttrs; l++) {
                        fprintf(fp, "%f ", double(PhiVV(i, l)));
                }
                fprintf(fp, "\n");
        }
        fclose(fp);
}

Here is the call graph for this function:

void TMAGFitBern::SetAlgConf ( const bool  EStep = true, const bool  MStep = true  )

inline

Definition at line 387 of file mag.h.

References ESpeedUp, and MSpeedUp.

{  ESpeedUp = EStep;  MSpeedUp = MStep;  }

void TMAGFitBern::SetDebug ( const bool  _Debug )

inline

Definition at line 386 of file mag.h.

References Debug.

{  Debug = _Debug;  }

void TMAGFitBern::SetGraph

(

const PNGraph &

GraphPt

)

Definition at line 385 of file mag.cpp.

References TNGraph::GetNIdV(), TNGraph::GetNodes(), TSnap::GetSubGraph(), Graph, IAssert, and TNGraph::IsNode().

Referenced by TMAGFitBern().

                                                 {
        Graph = GraphPt;
        bool NodesOk = true;
        // check that nodes IDs are {0,1,..,Nodes-1}
        for (int nid = 0; nid < Graph->GetNodes(); nid++) {
        if (! Graph->IsNode(nid)) { NodesOk=false; break; } }
        if (! NodesOk) {
        TIntV NIdV;  GraphPt->GetNIdV(NIdV);
        Graph = TSnap::GetSubGraph(GraphPt, NIdV, true);
        for (int nid = 0; nid < Graph->GetNodes(); nid++) {
          IAssert(Graph->IsNode(nid)); }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TMAGFitBern::SetMtxV ( const TMAGAffMtxV &  MtxV )

inline

Definition at line 382 of file mag.h.

References Param, and TMAGParam< TNodeAttr >::SetMtxV().

{  Param.SetMtxV(MtxV);  }

Here is the call graph for this function:

void TMAGFitBern::SetMuV ( const TFltV &  MuV )

inline

Definition at line 380 of file mag.h.

References TMAGParam< TNodeAttr >::GetNodeAttr(), Param, TMAGNodeBern::SetMuV(), and TMAGParam< TNodeAttr >::SetNodeAttr().

{  TMAGNodeBern Dist = Param.GetNodeAttr();  Dist.SetMuV(MuV);  Param.SetNodeAttr(Dist);  }

Here is the call graph for this function:

void TMAGFitBern::SetPhiVV	(	const TIntVV &	AttrVV,
		const int	KnownIds = 0
	)

Definition at line 399 of file mag.cpp.

References TVVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetNodes(), KnownVV, Param, PhiVV, and TVVec< TVal, TSizeTy >::PutY().

                                                                   {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();

        PhiVV.Gen(NNodes, NAttrs);
        KnownVV.Gen(NNodes, NAttrs);
        
        for(int l = 0; l < NAttrs; l++) {
                for(int i = 0; i < NNodes; i++) {
                        if(int(AttrVV(i, l)) == 0) {
                                PhiVV(i, l) = 0.9999;
                        } else {
                                PhiVV(i, l) = 0.0001;
                        }
                }

                if(l < KnownIds) {
                        KnownVV.PutY(l, true);
                } else {
                        KnownVV.PutY(l, false);
                }
        }
}

Here is the call graph for this function:

void TMAGFitBern::SetPhiVV ( const TFltVV &  AttrVV, const int  KnownIds = 0  )

inline

Definition at line 394 of file mag.h.

References TVVec< TVal, TSizeTy >::Gen(), TVVec< TVal, TSizeTy >::GetXDim(), TVVec< TVal, TSizeTy >::GetYDim(), KnownVV, PhiVV, TVVec< TVal, TSizeTy >::PutAll(), and TVVec< TVal, TSizeTy >::PutY().

{  PhiVV = AttrVV;  KnownVV.Gen(PhiVV.GetXDim(), PhiVV.GetYDim());  KnownVV.PutAll(false);  for(int i = 0; i < KnownIds; i++) {  KnownVV.PutY(i, true); } }

Here is the call graph for this function:

void TMAGFitBern::SortAttrOrdering	(	const TFltV &	TrueMuV,
		TIntV &	IndexV
	)		const

Definition at line 1828 of file mag.cpp.

References CountAttr(), TVec< TVal, TSizeTy >::Gen(), TVec< TVal, TSizeTy >::Len(), and TVec< TVal, TSizeTy >::Swap().

                                                                            {
        const int NAttrs = TrueMuV.Len();
        // const int NNodes = PhiVV.GetXDim();
        TFltV EstMuV, SortedTrueMuV, SortedEstMuV, TrueIdxV, EstIdxV;
        IndexV.Gen(NAttrs);
        TrueIdxV.Gen(NAttrs);
        EstIdxV.Gen(NAttrs);

        for(int l = 0; l < NAttrs; l++) {
                TrueIdxV[l] = l;
                EstIdxV[l] = l;
        }
        
        CountAttr(EstMuV);
        SortedTrueMuV = TrueMuV;
        SortedEstMuV = EstMuV;
        for(int i = 0; i < NAttrs; i++) {
                if(SortedTrueMuV[i] > 0.5) {  SortedTrueMuV[i] = 1.0 - SortedTrueMuV[i];  }
                if(SortedEstMuV[i] > 0.5) {  SortedEstMuV[i] = 1.0 - SortedEstMuV[i];  }
        }

        for(int i = 0; i < NAttrs; i++) {
                for(int j = i+1; j < NAttrs; j++) {
                        if(SortedTrueMuV[i] < SortedTrueMuV[j]) {
                                SortedTrueMuV.Swap(i, j);
                                TrueIdxV.Swap(i, j);
                        }
                        if(SortedEstMuV[i] < SortedEstMuV[j]) {
                                EstIdxV.Swap((int)SortedEstMuV[i], (int)SortedEstMuV[j]);
                                SortedEstMuV.Swap(i, j);
                        }
                }
        }

        for(int l = 0; l < NAttrs; l++) {
                IndexV[l] = (int)TrueIdxV[(int)EstIdxV[l]];
        }
}

Here is the call graph for this function:

void TMAGFitBern::UnNormalizeAffMtxV	(	TMAGAffMtxV &	MtxV,
		const bool	UseMu = false
	)

Definition at line 1492 of file mag.cpp.

References TNGraph::GetEdges(), GetMuV(), TMAGParam< TNodeAttr >::GetNodes(), Graph, TVec< TVal, TSizeTy >::Len(), NormalizeAffMtxV(), NormConst, Param, and TVec< TVal, TSizeTy >::Sort().

Referenced by DoEMAlg().

                                                                        {
        const int NNodes = Param.GetNodes();
        const int NAttrs = MtxV.Len();
        TFltIntPrV MaxEntV(NAttrs);
        TFltV MuV = GetMuV();
        NormalizeAffMtxV(MtxV, UseMu);
        
        double ExpEdge = NNodes * (NNodes - 1);
        for(int l = 0; l < NAttrs; l++) {
                double Mu = MuV[l];
                double EdgeSum = Mu * Mu * MtxV[l].At(0, 0);
                EdgeSum += Mu * (1.0-Mu) * MtxV[l].At(0, 1);
                EdgeSum += Mu * (1.0-Mu) * MtxV[l].At(1, 0);
                EdgeSum += (1.0-Mu) * (1.0-Mu) * MtxV[l].At(1, 1);
                ExpEdge *= EdgeSum;
        }
        NormConst = double(Graph->GetEdges()) / ExpEdge;
//      NormConst *= ExpEdge;
        
        for(int l = 0; l < NAttrs; l++) {
                MaxEntV[l] = TFltIntPr(-1, l);
                for(int p = 0; p < 4; p++) {
                        if(MaxEntV[l].Val1 < MtxV[l].At(p)) {  MaxEntV[l].Val1 = MtxV[l].At(p);  }
                }
        }
        MaxEntV.Sort(false);

        for(int l = 0; l < NAttrs; l++) {
                int CurId = MaxEntV[l].Val2;
                double Factor = pow(NormConst, 1.0 / double(NAttrs - l));
                double MaxFactor = 0.9999 / MaxEntV[l].Val1;
                Factor = (Factor > MaxFactor) ? MaxFactor : Factor;
                NormConst = NormConst / Factor;

                for(int p = 0; p < 4; p++) {
                        MtxV[CurId].At(p) = MtxV[CurId].At(p) * Factor;
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::UpdateAffMtx	(	const int &	AId,
		const double &	LrnRate,
		const double &	MaxGrad,
		const double &	Lambda,
		TFltVV &	ProdVV,
		TFltVV &	SqVV,
		TMAGAffMtx &	NewMtx
	)

Definition at line 1418 of file mag.cpp.

References TMAGAffMtx::At(), TMAGParam< TNodeAttr >::GetMtx(), TMAGAffMtx::GetMtxStr(), GradAffMtx(), GradApxAffMtx(), MSpeedUp, and Param.

Referenced by UpdateAffMtxV().

                                                                                                                                                                           {
        double Delta = 0.0;
        // const int NNodes = Param.GetNodes();
        // const int NAttrs = Param.GetAttrs();
        TMAGAffMtx AffMtx = Param.GetMtx(AId);

        TFltV GradV(4);
        TFltV HessV(4);
        if(MSpeedUp) {
                GradApxAffMtx(AId, ProdVV, SqVV, NewMtx, GradV);
        } else {
                GradAffMtx(AId, ProdVV, SqVV, NewMtx, GradV);
        }

        double Ratio = 1.0;
        for(int p = 0; p < 4; p++) {
                if(fabs(Ratio * LrnRate * GradV[p]) > MaxGrad) {
                        Ratio = MaxGrad / fabs(LrnRate * GradV[p]);
                }
        }

        for(int p = 0; p < 4; p++) {
                GradV[p] *= (Ratio * LrnRate);
                NewMtx.At(p) = AffMtx.At(p) + GradV[p];
//              if(NewMtx.At(p) > 0.9999) {  NewMtx.At(p) = 0.9999;  }
                if(NewMtx.At(p) < 0.0001) {  NewMtx.At(p) = 0.0001;  }
        }

        printf("      [Attr = %d]\n", AId);
    printf("        %s  + [%f, %f; %f %f]  ----->  %s\n", (AffMtx.GetMtxStr()).GetCStr(), double(GradV[0]), double(GradV[1]), double(GradV[2]), double(GradV[3]), (NewMtx.GetMtxStr()).GetCStr());
        
//      Param.SetMtx(AId, NewMtx);
        return Delta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::UpdateAffMtxV	(	const int &	GradIter,
		const double &	LrnRate,
		const double &	MaxGrad,
		const double &	Lambda,
		const int &	NReal = 0
	)

Definition at line 1558 of file mag.cpp.

References TVVec< TVal, TSizeTy >::Clr(), TMAGParam< TNodeAttr >::GetAttrs(), TMAGParam< TNodeAttr >::GetMtxV(), TMAGNodeBern::GetMuV(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), MSpeedUp, NormalizeAffMtxV(), Param, PrepareUpdateAffMtx(), PrepareUpdateApxAffMtx(), TMAGParam< TNodeAttr >::SetMtxV(), and UpdateAffMtx().

Referenced by DoMStep().

                                                                                                                                                 {
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        const TMAGNodeBern DistParam = Param.GetNodeAttr();
        const TFltV MuV = DistParam.GetMuV();
        double Delta = 0.0;
        double DecLrnRate = LrnRate, DecMaxGrad = MaxGrad;
        
        TFltVV ProdVV(NNodes, NNodes), SqVV(NNodes, NNodes);
        TMAGAffMtxV NewMtxV, OldMtxV;
        Param.GetMtxV(OldMtxV);
        Param.GetMtxV(NewMtxV);

        for(int g = 0; g < GradIter; g++) {
                if(MSpeedUp) {
                        PrepareUpdateApxAffMtx(ProdVV, SqVV);
                } else {
                        PrepareUpdateAffMtx(ProdVV, SqVV);
                }

                printf("    [Grad step = %d]\n", (g+1));
//              for(int l = 0; l < NAttrs; l++) {
                for(int l = NReal; l < NAttrs; l++) {
                        UpdateAffMtx(l, DecLrnRate, DecMaxGrad, Lambda, ProdVV, SqVV, NewMtxV[l]);
                        Param.SetMtxV(NewMtxV);
                }
                DecLrnRate *= 0.97;
                DecMaxGrad *= 0.97;

                printf("\n");
                NormalizeAffMtxV(NewMtxV, true);
                Param.SetMtxV(NewMtxV);
        }
        NormalizeAffMtxV(NewMtxV, true);
        
        printf( "\nFinal\n");
        for(int l = 0; l < NAttrs; l++) {
                printf("    [");
                for(int p = 0; p < 4; p++) {
//                      NewMtxV[l].At(p) = NewMtxV[l].At(p) * Product / SumV[l];
                        Delta += fabs(OldMtxV[l].At(p) - NewMtxV[l].At(p));
                        printf(" %.4f ", double(NewMtxV[l].At(p)));
                }
                printf("]\n");
        }
        Param.SetMtxV(NewMtxV);
        ProdVV.Clr();           SqVV.Clr();
        return Delta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::UpdateApxPhiMI	(	const double &	Lambda,
		const int &	NId,
		const int &	AId,
		double &	Phi,
		TFltVV &	ProdVV
	)

Definition at line 930 of file mag.cpp.

References TVec< TVal, TSizeTy >::Add(), TMAGAffMtx::At(), TVVec< TVal, TSizeTy >::At(), AvgPhiPairVV, TVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), GetAvgInCoeff(), GetAvgOutCoeff(), GetAvgSqThetaLL(), GetAvgThetaLL(), GetInCoeff(), TNGraph::TNodeI::GetInDeg(), TNGraph::TNodeI::GetInNId(), TMAGAffMtx::GetLLMtx(), TMAGParam< TNodeAttr >::GetMtx(), TMAGNodeBern::GetMu(), TNGraph::GetNI(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), GetOutCoeff(), TNGraph::TNodeI::GetOutDeg(), TNGraph::TNodeI::GetOutNId(), GetProdLinWeight(), GetProdSqWeight(), TVVec< TVal, TSizeTy >::GetRow(), GetSqThetaLL(), GetThetaLL(), GradPhiMI(), Graph, IAssert, TMAGAffMtx::Len(), TVec< TVal, TSizeTy >::Len(), LogSumExp(), MaxExp, ObjPhiMI(), Param, PhiVV, and TVVec< TVal, TSizeTy >::PutAll().

Referenced by DoEStepApxOneIter().

                                                                                                                          {
        TMAGAffMtx LLTheta, Theta = Param.GetMtx(AId); 
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        Theta.GetLLMtx(LLTheta);
        TMAGNodeBern DistParam = Param.GetNodeAttr();
        const double Mu = DistParam.GetMu(AId);

        TMAGAffMtx SqTheta(Theta);
        for(int i = 0; i < Theta.Len(); i++) {
                SqTheta.At(i) = SqTheta.At(i) * SqTheta.At(i);
        }

        TFltV ProdV;    ProdVV.GetRow(NId, ProdV);
        ProdV[0] -= GetAvgThetaLL(NId, NId, AId, true, false);
        ProdV[1] -= GetAvgThetaLL(NId, NId, AId, false, true);
        ProdV[2] -= log(2.0) + GetAvgSqThetaLL(NId, NId, AId, true, false);
        ProdV[3] -= log(2.0) + GetAvgSqThetaLL(NId, NId, AId, false, true);

        //      Using log-sum-exp trick
        double EdgeQ[2], MaxExp[2];
        TFltV NonEdgeLLV[2];
        TFltVV CntVV(4, NAttrs);                CntVV.PutAll(0.0);
        for(int i = 0; i < 2; i++) {
                EdgeQ[i] = 0.0;
                MaxExp[i] = -DBL_MAX;
                NonEdgeLLV[i].Gen(4 * NNodes, 0);
        }

        for(int F = 0; F < 2; F++) {
                NonEdgeLLV[F].Add(ProdV[0] + log(GetAvgOutCoeff(NId, AId, F, Theta)));
                NonEdgeLLV[F].Add(ProdV[1] + log(GetAvgInCoeff(NId, AId, F, Theta)));
                NonEdgeLLV[F].Add(ProdV[2] + log(GetAvgOutCoeff(NId, AId, F, SqTheta)));
                NonEdgeLLV[F].Add(ProdV[3] + log(GetAvgInCoeff(NId, AId, F, SqTheta)));
        }
        EdgeQ[0] = -(NNodes - 1) * exp(LogSumExp(NonEdgeLLV[0]));
        EdgeQ[1] = -(NNodes - 1) * exp(LogSumExp(NonEdgeLLV[1]));

        
        for(int l = 0; l < NAttrs; l++) {
                if(l == AId) {  continue;  }
                int BgId = (AId > l) ? AId : l;
                int SmId = (AId + l) - BgId;
                int SmL = (l < AId) ? 1 : 0;
                BgId *= 4;
                CntVV(0, l) = AvgPhiPairVV(SmId, BgId) - PhiVV(NId, AId) * PhiVV(NId, l);
                CntVV(1+SmL, l) = AvgPhiPairVV(SmId, BgId+1+SmL) - PhiVV(NId, AId) * (1.0-PhiVV(NId, l));
                CntVV(2-SmL, l) = AvgPhiPairVV(SmId, BgId+2-SmL) - (1.0-PhiVV(NId, AId)) * PhiVV(NId, l);
                CntVV(3, l) = AvgPhiPairVV(SmId, BgId+3) - (1.0-PhiVV(NId, AId)) * (1.0-PhiVV(NId, l));
        }

        TNGraph::TNodeI NI = Graph->GetNI(NId);
        for(int d = 0; d < NI.GetOutDeg(); d++) {
                int Out = NI.GetOutNId(d);
                if(NId == Out) {  continue;  }
                double LinW = GetProdLinWeight(NId, Out) - GetThetaLL(NId, Out, AId);
                double SqW = GetProdSqWeight(NId, Out) - GetSqThetaLL(NId, Out, AId);

                for(int F = 0; F < 2; F++) {
                        EdgeQ[F] += GetOutCoeff(NId, Out, AId, F, LLTheta);
                        EdgeQ[F] += exp(LinW + log(GetOutCoeff(NId, Out, AId, F, Theta)));
                        EdgeQ[F] += 0.5 * exp(SqW + log(GetOutCoeff(NId, Out, AId, F, SqTheta)));
                }
        }
        for(int d = 0; d < NI.GetInDeg(); d++) {
                int In = NI.GetInNId(d);
                if(NId == In) {  continue;  }
                double LinW = GetProdLinWeight(In, NId) - GetThetaLL(In, NId, AId);
                double SqW = GetProdSqWeight(In, NId) - GetSqThetaLL(In, NId, AId);

                for(int F = 0; F < 2; F++) {
                        EdgeQ[F] += GetInCoeff(In, NId, AId, F, LLTheta);
                        EdgeQ[F] += exp(LinW + log(GetInCoeff(In, NId, AId, F, Theta)));
                        EdgeQ[F] += 0.5 * exp(SqW + log(GetInCoeff(In, NId, AId, F, SqTheta)));
                }
        }

        EdgeQ[0] += log(Mu);
        EdgeQ[1] += log(1.0 - Mu);
        double DeltaQ = EdgeQ[0] - EdgeQ[1];
//      printf("(%d, %d) :: Q[0] = %f, Q[1] = %f\n", NId, AId, EdgeQ[0], EdgeQ[1]);

//      double x[] = {0.1, 0.3, 0.5, 0.7, 0.9};
        double x[] = {PhiVV(NId, AId)};
        TFltV ObjValV;  ObjValV.Gen(60, 0);
//      for(int n = 0; n < 5; n++) {
        for(int n = 0; n < 1; n++) {
//              double LrnRate = 0.0002;
                double LrnRate = 0.001;
                for(int step = 0; step < 50; step++) {
//              for(int step = 0; step < 10; step++) {
                        double Grad = GradPhiMI(x[n], NId, AId, Lambda, DeltaQ, CntVV);
                        if(Grad > 0.0) {  x[n] += LrnRate;  }
                        else {  x[n] -= LrnRate;  }
                        if(x[n] > 0.9999) {  x[n] = 0.9999;  }
                        if(x[n] < 0.0001) {  x[n] = 0.0001;  }
                        if(x[n] == 0.9999 || x[n] == 0.0001) {
                                break;
                        }
                        LrnRate *= 0.995;
                }
                ObjValV.Add(x[n]);
//              ObjValV.Add(PhiVV(NId, AId));
        }

        double MaxVal = -DBL_MAX;
        int MaxX = -1;
//      for(int n = 0; n < 5; n++) {
        for(int n = 0; n < ObjValV.Len(); n++) {
                double Val = ObjPhiMI(ObjValV[n], NId, AId, Lambda, EdgeQ[0], EdgeQ[1], CntVV);
                if(Val > MaxVal) {
                        MaxVal = Val;
                        MaxX = n;
                } else if(MaxX < 0) {
                        printf("(%d, %d) : %f  Q[0] = %f  Q[1] = %f  Val = %f\n", NId, AId, double(x[n]), double(EdgeQ[0]), double(EdgeQ[1]), Val);
                }
        }
        IAssert(MaxX >= 0);

        Phi = ObjValV[MaxX];

        return Phi - PhiVV.At(NId, AId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::UpdateMu

(

const int &

AId

)

Definition at line 1299 of file mag.cpp.

References TVVec< TVal, TSizeTy >::At(), AvgPhiV, TMAGNodeBern::GetMu(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), Param, PhiVV, TMAGNodeBern::SetMu(), and TMAGParam< TNodeAttr >::SetNodeAttr().

Referenced by DoMStep().

                                                 {
        const int NNodes = Param.GetNodes();
        TMAGNodeBern DistParam = Param.GetNodeAttr();
        const double OldMu = DistParam.GetMu(AId);
        double NewMu = 0.0;

        for(int i = 0; i < NNodes; i++) {
                NewMu += PhiVV.At(i, AId);
        }
        AvgPhiV[AId] = NewMu;
        NewMu /= double(NNodes);

        printf("      [Posterior Mu] = %.4f\n", NewMu);

        double Delta = fabs(NewMu - OldMu);
        DistParam.SetMu(AId, NewMu);
        Param.SetNodeAttr(DistParam);

        return Delta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const double TMAGFitBern::UpdatePhi	(	const int &	NId,
		const int &	AId,
		double &	Phi
	)

Definition at line 756 of file mag.cpp.

References TVec< TVal, TSizeTy >::Add(), TMAGAffMtx::At(), TVVec< TVal, TSizeTy >::At(), TVec< TVal, TSizeTy >::Gen(), GetInCoeff(), TMAGAffMtx::GetLLMtx(), TMAGParam< TNodeAttr >::GetMtx(), TMAGNodeBern::GetMu(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), GetOutCoeff(), GetProdLinWeight(), GetProdSqWeight(), GetSqThetaLL(), GetThetaLL(), Graph, TNGraph::IsEdge(), TMAGAffMtx::Len(), LogSumExp(), MaxExp, Param, and PhiVV.

                                                                               {
        TMAGAffMtx LLTheta, Theta = Param.GetMtx(AId); 
        TMAGAffMtx SqTheta(Theta);
        const int NNodes = Param.GetNodes();
        // const int NAttrs = Param.GetAttrs();
        Theta.GetLLMtx(LLTheta);
        TMAGNodeBern DistParam = Param.GetNodeAttr();
        const double Mu = DistParam.GetMu(AId);

        for(int i = 0; i < Theta.Len(); i++) {
                SqTheta.At(i) = SqTheta.At(i) * SqTheta.At(i);
        }

        //      Using log-sum-exp trick
        double EdgeQ[2], NonEdgeQ[2], MaxExp[2];
        TFltV NonEdgeLLV[2];
        for(int i = 0; i < 2; i++) {
                EdgeQ[i] = 0.0;
                NonEdgeQ[i] = 0.0;
                MaxExp[i] = -DBL_MAX;
                NonEdgeLLV[i].Gen(4 * NNodes, 0);
        }
        
        for(int j = 0; j < NNodes; j++) {
                if(j == NId) {  continue;       }

                if(Graph->IsEdge(NId, j)) {
                        EdgeQ[0] += GetOutCoeff(NId, j, AId, 0, LLTheta);
                        EdgeQ[1] += GetOutCoeff(NId, j, AId, 1, LLTheta);
                } else {
                        double LinW = GetProdLinWeight(NId, j) - GetThetaLL(NId, j, AId);
                        double SqW = GetProdSqWeight(NId, j) - GetSqThetaLL(NId, j, AId);

                        for(int i = 0; i < 2; i++) {
                                NonEdgeLLV[i].Add(LinW + log(GetOutCoeff(NId, j, AId, i, Theta)));
                                NonEdgeLLV[i].Add(SqW + log(GetOutCoeff(NId, j, AId, i, SqTheta)) + log(0.5));
                        }
                }

                if(Graph->IsEdge(j, NId)) {
                        EdgeQ[0] += GetInCoeff(j, NId, AId, 0, LLTheta);
                        EdgeQ[1] += GetInCoeff(j, NId, AId, 1, LLTheta);
                } else {
                        double LinW = GetProdLinWeight(j, NId) - GetThetaLL(j, NId, AId);
                        double SqW = GetProdSqWeight(j, NId) - GetSqThetaLL(j, NId, AId);

                        for(int i = 0; i < 2; i++) {
                                NonEdgeLLV[i].Add(LinW + log(GetInCoeff(j, NId, AId, i, Theta)));
                                NonEdgeLLV[i].Add(SqW + log(GetInCoeff(j, NId, AId, i, SqTheta)) + log(0.5));
                        }
                }
        }

        NonEdgeQ[0] = LogSumExp(NonEdgeLLV[0]);
        NonEdgeQ[1] = LogSumExp(NonEdgeLLV[1]);
        
        double Q[2];
        Q[0] = log(Mu) + EdgeQ[0] - exp(NonEdgeQ[0]);
        Q[1] = log(1.0 - Mu) + EdgeQ[1] - exp(NonEdgeQ[1]);
//      double Q = Q1 - Q0;
//      printf("  [Phi_{%d}{%d}]  :: Q0 = %f, Q1 = %f\n", NId, AId, Q0, Q1);

//      Phi = 1.0 / (1.0 + exp(Q));
        Phi = Q[0] - LogSumExp(Q, 2);
        Phi = exp(Phi);

        return Phi - PhiVV.At(NId, AId);
}

Here is the call graph for this function:

const double TMAGFitBern::UpdatePhiMI	(	const double &	Lambda,
		const int &	NId,
		const int &	AId,
		double &	Phi
	)

Definition at line 826 of file mag.cpp.

References TVec< TVal, TSizeTy >::Add(), TMAGAffMtx::At(), TVVec< TVal, TSizeTy >::At(), TVec< TVal, TSizeTy >::Gen(), TMAGParam< TNodeAttr >::GetAttrs(), GetInCoeff(), TMAGAffMtx::GetLLMtx(), TMAGParam< TNodeAttr >::GetMtx(), TMAGNodeBern::GetMu(), TMAGParam< TNodeAttr >::GetNodeAttr(), TMAGParam< TNodeAttr >::GetNodes(), GetOutCoeff(), GetProdLinWeight(), GetProdSqWeight(), GetSqThetaLL(), GetThetaLL(), GradPhiMI(), Graph, IAssert, TNGraph::IsEdge(), TMAGAffMtx::Len(), LogSumExp(), MaxExp, ObjPhiMI(), Param, PhiVV, and TVVec< TVal, TSizeTy >::PutAll().

Referenced by DoEStepOneIter().

                                                                                                       {
        TMAGAffMtx LLTheta, Theta = Param.GetMtx(AId); 
        TMAGAffMtx SqTheta(Theta);
        const int NNodes = Param.GetNodes();
        const int NAttrs = Param.GetAttrs();
        Theta.GetLLMtx(LLTheta);
        TMAGNodeBern DistParam = Param.GetNodeAttr();
        const double Mu = DistParam.GetMu(AId);

        for(int i = 0; i < Theta.Len(); i++) {
                SqTheta.At(i) = SqTheta.At(i) * SqTheta.At(i);
        }

        //      Using log-sum-exp trick
        double EdgeQ[2], NonEdgeQ[2], MaxExp[2];
        TFltV NonEdgeLLV[2];
        TFltVV CntVV(4, NAttrs);                CntVV.PutAll(0.0);
        for(int i = 0; i < 2; i++) {
                EdgeQ[i] = 0.0;
                NonEdgeQ[i] = 0.0;
                MaxExp[i] = -DBL_MAX;
                NonEdgeLLV[i].Gen(4 * NNodes, 0);
        }
        
        for(int j = 0; j < NNodes; j++) {
                if(j == NId) {  continue;       }

                for(int l = 0; l < NAttrs; l++) {
                        if(l == AId) {  continue;  }
                        CntVV(0, l) = CntVV(0, l) + PhiVV(j, AId) * PhiVV(j, l);
                        CntVV(1, l) = CntVV(1, l) + PhiVV(j, AId) * (1.0-PhiVV(j, l));
                        CntVV(2, l) = CntVV(2, l) + (1.0-PhiVV(j, AId)) * PhiVV(j, l);
                        CntVV(3, l) = CntVV(3, l) + (1.0-PhiVV(j, AId)) * (1.0-PhiVV(j, l));
                }

                if(Graph->IsEdge(NId, j)) {
                        EdgeQ[0] += GetOutCoeff(NId, j, AId, 0, LLTheta);
                        EdgeQ[1] += GetOutCoeff(NId, j, AId, 1, LLTheta);
                } else {
                        double LinW = GetProdLinWeight(NId, j) - GetThetaLL(NId, j, AId);
                        double SqW = GetProdSqWeight(NId, j) - GetSqThetaLL(NId, j, AId);

                        for(int i = 0; i < 2; i++) {
                                NonEdgeLLV[i].Add(LinW + log(GetOutCoeff(NId, j, AId, i, Theta)));
                                NonEdgeLLV[i].Add(SqW + log(GetOutCoeff(NId, j, AId, i, SqTheta)) + log(0.5));
                        }
                }

                if(Graph->IsEdge(j, NId)) {
                        EdgeQ[0] += GetInCoeff(j, NId, AId, 0, LLTheta);
                        EdgeQ[1] += GetInCoeff(j, NId, AId, 1, LLTheta);
                } else {
                        double LinW = GetProdLinWeight(j, NId) - GetThetaLL(j, NId, AId);
                        double SqW = GetProdSqWeight(j, NId) - GetSqThetaLL(j, NId, AId);

                        for(int i = 0; i < 2; i++) {
                                NonEdgeLLV[i].Add(LinW + log(GetInCoeff(j, NId, AId, i, Theta)));
                                NonEdgeLLV[i].Add(SqW + log(GetInCoeff(j, NId, AId, i, SqTheta)) + log(0.5));
                        }
                }
        }
        
        NonEdgeQ[0] = LogSumExp(NonEdgeLLV[0]);
        NonEdgeQ[1] = LogSumExp(NonEdgeLLV[1]);
        
        double Q[2];
        Q[0] = log(Mu) + EdgeQ[0] - exp(NonEdgeQ[0]);
        Q[1] = log(1.0 - Mu) + EdgeQ[1] - exp(NonEdgeQ[1]);
        double DeltaQ = Q[0] - Q[1];

//      double x[] = {0.1, 0.3, 0.5, 0.7, 0.9};
        double x[] = {PhiVV(NId, AId)};
//      for(int n = 0; n < 5; n++) {
        for(int n = 0; n < 1; n++) {
//              double LrnRate = 0.0002;
                double LrnRate = 0.001;
                for(int step = 0; step < 200; step++) {
                        double Grad = GradPhiMI(x[n], NId, AId, Lambda, DeltaQ, CntVV);
                        if(Grad > 0.0) {  x[n] += LrnRate;  }
                        else {  x[n] -= LrnRate;  }
                        if(x[n] > 0.9999) {  x[n] = 0.9999;  }
                        if(x[n] < 0.0001) {  x[n] = 0.0001;  }
                        LrnRate *= 0.995;
                }
        }

        double MaxVal = -DBL_MAX;
        int MaxX = -1;
//      for(int n = 0; n < 5; n++) {
        for(int n = 0; n < 1; n++) {
                double Val = ObjPhiMI(x[n], NId, AId, Lambda, Q[0], Q[1], CntVV);
                if(Val > MaxVal) {
                        MaxVal = Val;
                        MaxX = n;
                }
        }
        IAssert(MaxX >= 0);

        Phi = x[MaxX];

        return Phi - PhiVV.At(NId, AId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

TFltVV TMAGFitBern::AvgPhiPairVV

private

Definition at line 349 of file mag.h.

Referenced by DoEStepApxOneIter(), TMAGFitBern(), and UpdateApxPhiMI().

TFltV TMAGFitBern::AvgPhiV

private

Definition at line 348 of file mag.h.

Referenced by DoEStepApxOneIter(), DoMStep(), GetAvgInCoeff(), GetAvgOutCoeff(), GetProbMu(), NormalizeAffMtxV(), TMAGFitBern(), and UpdateMu().

bool TMAGFitBern::Debug

private

Definition at line 347 of file mag.h.

Referenced by DoEMAlg(), and SetDebug().

bool TMAGFitBern::ESpeedUp

private

Definition at line 347 of file mag.h.

Referenced by DoEStep(), and SetAlgConf().

PNGraph TMAGFitBern::Graph

private

Definition at line 345 of file mag.h.

Referenced by ComputeApxAdjLL(), ComputeApxLL(), ComputeJointAdjLL(), ComputeJointOneLL(), GetGraph(), GradAffMtx(), GradApxAffMtx(), NormalizeAffMtxV(), PlotProperties(), SetGraph(), UnNormalizeAffMtxV(), UpdateApxPhiMI(), UpdatePhi(), and UpdatePhiMI().

TBoolVV TMAGFitBern::KnownVV

private

Definition at line 344 of file mag.h.

Referenced by Clr(), DoEMAlg(), DoEStepApxOneIter(), DoEStepOneIter(), Init(), RandomInit(), SetPhiVV(), and TMAGFitBern().

TFltV TMAGFitBern::LLHisV

private

Definition at line 354 of file mag.h.

Referenced by DoEMAlg().

bool TMAGFitBern::MSpeedUp

private

Definition at line 347 of file mag.h.

Referenced by SetAlgConf(), UpdateAffMtx(), and UpdateAffMtxV().

TVec<TMAGAffMtxV> TMAGFitBern::MtxHisV

private

Definition at line 353 of file mag.h.

Referenced by DoEMAlg().

TVec<TFltV> TMAGFitBern::MuHisV

private

Definition at line 352 of file mag.h.

Referenced by DoEMAlg().

TFlt TMAGFitBern::NormConst

private

Definition at line 350 of file mag.h.

Referenced by ComputeApxLL(), DoEMAlg(), GetAvgProdLinWeight(), GetAvgProdSqWeight(), GetProdLinWeight(), GetProdSqWeight(), NormalizeAffMtxV(), and UnNormalizeAffMtxV().

TMAGParam<TMAGNodeBern> TMAGFitBern::Param

private

Definition at line 346 of file mag.h.

Referenced by ComputeApxAdjLL(), ComputeApxLL(), ComputeJointAdjLL(), ComputeJointLL(), ComputeJointOneLL(), DoEMAlg(), DoEStep(), DoEStepApxOneIter(), DoEStepOneIter(), DoMStep(), GetAttrs(), GetAvgInCoeff(), GetAvgOutCoeff(), GetAvgProdLinWeight(), GetAvgProdSqWeight(), GetAvgSqThetaLL(), GetAvgThetaLL(), GetEstNoEdgeLL(), GetMtxV(), GetMuV(), GetNodeAttr(), GetNodes(), GetParams(), GetProbMu(), GetProdLinWeight(), GetProdSqWeight(), GetSqThetaLL(), GetThetaLL(), GradAffMtx(), GradApxAffMtx(), Init(), NormalizeAffMtxV(), PlotProperties(), PrepareUpdateAffMtx(), PrepareUpdateApxAffMtx(), RandomInit(), SaveTxt(), SetMtxV(), SetMuV(), SetPhiVV(), TMAGFitBern(), UnNormalizeAffMtxV(), UpdateAffMtx(), UpdateAffMtxV(), UpdateApxPhiMI(), UpdateMu(), UpdatePhi(), and UpdatePhiMI().

TFltVV TMAGFitBern::PhiVV

private

Definition at line 343 of file mag.h.

Referenced by Clr(), ComputeApxAdjLL(), ComputeApxLL(), ComputeJointLL(), CountAttr(), DoEMAlg(), DoEStepApxOneIter(), DoEStepOneIter(), GetInCoeff(), GetOutCoeff(), GetPhiVV(), GetProbMu(), GetProbPhi(), GradPhiMI(), Init(), ObjPhiMI(), PlotProperties(), RandomInit(), SaveTxt(), SetPhiVV(), TMAGFitBern(), UpdateApxPhiMI(), UpdateMu(), UpdatePhi(), and UpdatePhiMI().

---

The documentation for this class was generated from the following files:

• snap-adv/mag.h
• snap-adv/mag.cpp