void TSirModel::GetParam(TFltV& ParamV) const { ParamV.Clr(false); ParamV.Add(N0); ParamV.Add(I0); ParamV.Add(Beta); ParamV.Add(Gamma); ParamV.Add(T0); }
void TEpidemModel::RungeKutta(const TFltV& y, const TFltV& dydx, double x, double h, TFltV& SirOutV) { const int n = y.Len(); IAssert(y.Len() == n && dydx.Len() == n); TFltV dym(n), dyt(n), yt(n); int i; double hh=h*0.5; double h6=h/6.0; double xh=x+hh; for (i=0; i < n; i++) { yt[i]=y[i]+hh*dydx[i]; } GetDerivs(xh, yt, dyt); for (i=0; i<n; i++) { yt[i]=y[i]+hh*dyt[i]; } GetDerivs(xh,yt,dym); for (i=0; i<n; i++) { yt[i]=y[i]+h*dym[i]; dym[i] += dyt[i]; } GetDerivs(x+h,yt,dyt); SirOutV.Clr(false); for (i=0; i<n; i++) { SirOutV.Add(y[i]+h6 * (dydx[i]+dyt[i]+2.0*dym[i])); } }
int main() { TLSHash LSH(7, 7, DIM, TLSHash::EUCLIDEAN); LSH.Init(); TRnd Gen; Gen.Randomize(); TVec<TFltV> DataV; for (int i=0; i<1000000; i++) { TFltV Datum; for (int j=0; j<3; j++) { Datum.Add(Gen.GetUniDev()*2100); } DataV.Add(Datum); } LSH.AddV(DataV); TVec<TPair<TFltV, TFltV> > NeighborsV = LSH.GetAllCandidatePairs(); printf("Number of Candidates: %d\n", NeighborsV.Len()); NeighborsV = LSH.GetAllNearPairs(); printf("Number of Close Pairs: %d\n", NeighborsV.Len()); for (int i=0; i<NeighborsV.Len(); i++) { outputPoint(NeighborsV[i].GetVal1()); printf(" "); outputPoint(NeighborsV[i].GetVal2()); printf("\n"); } return 0; }
void TNetInfBs::SaveObjInfo(const TStr& OutFNm) { TGnuPlot GnuPlot(OutFNm); TFltV Objective; for (THash<TIntPr, TEdgeInfo>::TIter EI = EdgeInfoH.BegI(); EI < EdgeInfoH.EndI(); EI++) { if (Objective.Len()==0) { Objective.Add(EI.GetDat().MarginalGain); } else { Objective.Add(Objective[Objective.Len()-1]+EI.GetDat().MarginalGain); } } GnuPlot.AddPlot(Objective, gpwLinesPoints); GnuPlot.SavePng(); }
void TNNet::GetResults(TFltV& ResultV) const{ ResultV.Clr(true, -1); for(int NeuronN = 0; NeuronN < LayerV.Last().GetNeuronN() - 1; ++NeuronN){ ResultV.Add(LayerV.Last().GetOutVal(NeuronN)); } }
void TJsonVal::GetArrNumV(TFltV& FltV) const { EAssert(IsArr()); for (int FltN = 0; FltN < GetArrVals(); FltN++) { PJsonVal ArrVal = GetArrVal(FltN); EAssert(ArrVal->IsNum()); FltV.Add(ArrVal->GetNum()); } }
void TBowLinAlg::GetDual(const PBowDocWgtBs& X, const TFltV& x, TFltV& y, const int& _Docs) { const int Docs = (_Docs == -1) ? X->GetDocs() : _Docs; y.Gen(Docs, 0); // prepare space for (int DId = 0; DId < Docs; DId++) { y.Add(TBowLinAlg::DotProduct(x, X->GetSpV(DId))); } }
void TNEANet::FltAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TFltV& Values) const { Values = TVec<TFlt>(); while (!EdgeHI.IsEnd()) { if (EdgeHI.GetDat().Val1 == FltType && !EdgeAttrIsFltDeleted(EId, EdgeHI)) { TFlt val = (this->VecOfFltVecsE.GetVal(EdgeHI.GetDat().Val2).GetVal(EId)); Values.Add(val); } EdgeHI++; } }
void TNEANet::FltAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TFltV& Values) const { Values = TVec<TFlt>(); while (!NodeHI.IsEnd()) { if (NodeHI.GetDat().Val1 == FltType && !NodeAttrIsFltDeleted(NId, NodeHI)) { TFlt val = (this->VecOfFltVecsN.GetVal(NodeHI.GetDat().Val2).GetVal(NId)); Values.Add(val); } NodeHI++; } }
void TGUtil::MakeExpBins(const TFltV& YValV, TFltV& ExpYValV, const double& BinFactor) { ExpYValV.Clr(true); int prevI=0; for (int i = 0; i < YValV.Len(); ) { ExpYValV.Add(YValV[i]); i = int(i*BinFactor); if (i==prevI) { i++; } prevI = i; } }
void TSirSR2Model::GetParam(TFltV& ParamV) const { ParamV.Clr(false); ParamV.Add(N0M); ParamV.Add(I0M); ParamV.Add(N0B); ParamV.Add(I0B); ParamV.Add(T0); ParamV.Add(BetaM); ParamV.Add(GammaM); ParamV.Add(BetaB); ParamV.Add(GammaB); ParamV.Add(BetaMB); ParamV.Add(BetaBM); ParamV.Add(DeltaM); ParamV.Add(DeltaB); }
void TEpidemModel::LoadTxt(const TStr& InFNm, const int& ColId, TFltV& ValV) { ValV.Clr(); if (! TFile::Exists(InFNm)) { printf("*** %s not found!\n", InFNm.CStr()); return; } TSsParser Ss(InFNm, ssfTabSep); while (Ss.Next()) { ValV.Add(Ss.GetFlt(ColId)); } }
PUNGraph TAGM::GenAGM(TVec<TIntV>& CmtyVV, const double& DensityCoef, const double& ScaleCoef, TRnd& Rnd) { TFltV CProbV; double Prob; for (int i = 0; i < CmtyVV.Len(); i++) { Prob = ScaleCoef*pow( double( CmtyVV[i].Len()), - DensityCoef); if (Prob > 1.0) { Prob = 1; } CProbV.Add(Prob); } return TAGM::GenAGM(CmtyVV, CProbV, Rnd); }
void TWgtNet::PermOutEdgeWgt() { TFltV WgtV; for (TNodeI NI = BegNI(); NI < EndNI(); NI++) { WgtV.Clr(false); for (int e = 0; e < NI.GetOutDeg(); e++) { WgtV.Add(NI.GetOutEDat(e)); } WgtV.Shuffle(TInt::Rnd); for (int e = 0; e < NI.GetOutDeg(); e++) { NI.GetOutEDat(e) = WgtV[e]; } } }
TBowMatrix::TBowMatrix(PBowDocBs BowDocBs, PBowDocWgtBs BowDocWgtBs, const TStr& CatNm, const TIntV& DIdV, TFltV& ClsV): TMatrix() { RowN = BowDocBs->GetWords(); ClsV.Gen(DIdV.Len(), 0); ColSpVV.Gen(DIdV.Len(), 0); IAssert(BowDocBs->IsCatNm(CatNm)); int CatId = BowDocBs->GetCId(CatNm); for (int i = 0; i < DIdV.Len(); i++) { ColSpVV.Add(BowDocWgtBs->GetSpV(DIdV[i])); ClsV.Add(BowDocBs->IsCatInDoc(DIdV[i], CatId) ? 0.99 : -0.99); } }
void TGnuPlot::MakeExpBins(const TFltKdV& XYValV, TFltKdV& ExpXYValV, const double& BinFactor, const double& MinYVal) { if (XYValV.Empty()) { ExpXYValV.Clr(false); return; } IAssert(! XYValV.Empty()); IAssert(XYValV.IsSorted()); const TFlt MxX = XYValV.Last().Key; // find buckets TFltV BucketEndV; BucketEndV.Add(1); double PrevBPos = 1, BPos = 1; while (BPos <= MxX) { PrevBPos = (uint) floor(BPos); BPos *= BinFactor; if (floor(BPos) == PrevBPos) { BPos = PrevBPos + 1; } BucketEndV.Add(floor(BPos)); } //printf("buckets:\n"); for (int i = 0; i < BucketEndV.Len(); i++) { printf("\t%g\n", BucketEndV[i]);} ExpXYValV.Gen(BucketEndV.Len(), 0); int CurB = 0; double AvgPos=0, Cnt=0, AvgVal=0; for (int v = 0; v < XYValV.Len(); v++) { if (XYValV[v].Key() == 0.0) { continue; } AvgPos += XYValV[v].Key ;//* XYValV[v].Dat; // x AvgVal += XYValV[v].Dat; // y Cnt++; if (v+1 == XYValV.Len() || XYValV[v+1].Key > BucketEndV[CurB]) { if (Cnt != 0) { //AvgPos /= AvgVal; //AvgVal /= (BucketEndV[CurB]-BucketEndV[CurB-1]); AvgPos /= (double) Cnt; AvgVal /= (double) Cnt; if (AvgVal < MinYVal) { AvgVal = MinYVal; } ExpXYValV.Add(TFltKd(AvgPos, AvgVal)); //printf("b: %6.2f\t%6.2f\n", AvgPos, AvgVal); AvgPos = 0; AvgVal = 0; Cnt = 0; } CurB++; } } }
void TWgtNet::PermEdgeWgt() { TFltV WgtV; for (TNodeI NI = BegNI(); NI < EndNI(); NI++) { for (int e = 0; e < NI.GetOutDeg(); e++) { WgtV.Add(NI.GetOutEDat(e)); } } WgtV.Shuffle(TInt::Rnd); int w = 0; for (TNodeI NI = BegNI(); NI < EndNI(); NI++) { for (int e = 0; e < NI.GetOutDeg(); e++) { NI.GetOutEDat(e) = WgtV[w++]; } } }
double TNetInfBs::GetBound(const TIntPr& Edge, double& CurProb) { double Bound = 0; TFltV Bounds; // bound could be computed faster (using lazy evaluation, as in the optimization procedure) for (int e=0; e < EdgeGainV.Len(); e++) { const TIntPr& EE = EdgeGainV[e].Val2; if (EE != Edge && !Graph->IsEdge(EE.Val1, EE.Val2)) { const double EProb = GetAllCascProb(EE.Val1, EE.Val2); if (EProb > CurProb) Bounds.Add(EProb - CurProb); } } Bounds.Sort(false); for (int i=0; i<Graph->GetEdges() && i<Bounds.Len(); i++) Bound += Bounds[i]; return Bound; }
// Computes GINI coefficient of egonet as a subset of the parent graph (edges into and out of the egonet ARE considered) double TSnap::GetGiniCoefficient(const TIntFltH DegH, const TIntV NIdV) { typename TIntV::TIter VI; typename TFltV::TIter DI; TFltV DegV; const int n = NIdV.Len(); // DegV.Gen(n); // NOTE: don't use Gen() and Sort() on the same object (!) for (VI = NIdV.BegI(); VI < NIdV.EndI(); VI++) { DegV.Add(DegH.GetDat(VI->Val)); // might need to change this (in / out / undirected) } DegV.Sort(); int i = 0; double numerator = 0.0, denominator = 0.0; for (DI = DegV.BegI(); DI < DegV.EndI(); DI++, i++) { numerator += (i + 1)*DegV[i]; denominator += DegV[i]; } return(double(2*numerator) / double(n*denominator) - double(n + 1) / double(n)); }
TFltV TEnv::GetIfArgPrefixFltV(const TStr& PrefixStr, TFltV& DfValV, const TStr& DNm) const { // convert default-integer-values to // default-string-values TStrV DfValStrV; for (int ValN = 0; ValN < DfValV.Len(); ValN++) DfValStrV.Add(TFlt::GetStr(DfValV[ValN])); // get string-values TStrV ValStrV = GetIfArgPrefixStrV(PrefixStr, DfValStrV, DNm); // convert string-values to integer-values TFltV ValV; double Val; for (int ValN = 0; ValN < ValStrV.Len(); ValN++) { if (ValStrV[ValN].IsFlt(Val)) ValV.Add(Val); } // return value-vector return ValV; }
void TGnuPlot::Test() { TFltV DeltaY; TFltPrV ValV1, ValV2, ValV3; for (int i = 1; i < 30; i++) { ValV1.Add(TFltPr(i, pow(double(i), 1.2))); DeltaY.Add(5*TInt::Rnd.GetUniDev()); ValV2.Add(TFltPr(i, 5*i-1)); } for (int i = -10; i < 20; i++) { ValV3.Add(TFltPr(i, 2*i + 2 + TInt::Rnd.GetUniDev())); } TGnuPlot GnuPlot("testDat", "TestPlot", true); GnuPlot.SetXYLabel("X", "Y"); const int id2 = GnuPlot.AddPlot(ValV2, gpwPoints, "y=5*x-1"); const int id3 = GnuPlot.AddPlot(ValV3, gpwPoints, "y=2*x+2"); GnuPlot.AddErrBar(ValV1, DeltaY, "y=x^2", "Error bar"); GnuPlot.AddLinFit(id2, gpwLines); GnuPlot.AddLinFit(id3, gpwLines); GnuPlot.Plot(); GnuPlot.SavePng("testPlot.png"); }
PUNGraph TAGM::GenAGM(TVec<TIntV>& CmtyVV, const double& DensityCoef, const double& ScaleCoef, TRnd& Rnd){ TFltV CProbV; double Prob; for(int i=0;i<CmtyVV.Len();i++) { Prob = ScaleCoef*pow(double(CmtyVV[i].Len()),-DensityCoef); if(Prob>1){Prob = 1;} CProbV.Add(Prob); } PUNGraph G = TUNGraph::New(); printf("AGM begins\n"); for(int i=0;i<CmtyVV.Len();i++) { TIntV& CmtyV = CmtyVV[i]; for(int u=0;u<CmtyV.Len();u++) { G->AddNode(CmtyV[u]); } Prob = CProbV[i]; printf("\r%d(%d)/%d",i,CmtyVV[i].Len(),CmtyVV.Len()); RndConnectInsideCommunity(G,CmtyV,Prob,Rnd); } printf("AGM completed (%d nodes %d edges)\n",G->GetNodes(),G->GetEdges()); return G; }
void TAGMFit::GetCmtyVV(TVec<TIntV>& CmtyVV, TFltV& QV, const double QMax) { CmtyVV.Gen(CIDNSetV.Len(), 0); QV.Gen(CIDNSetV.Len(), 0); TIntFltH CIDLambdaH(CIDNSetV.Len()); for (int c = 0; c < CIDNSetV.Len(); c++) { CIDLambdaH.AddDat(c, LambdaV[c]); } CIDLambdaH.SortByDat(false); for (int c = 0; c < CIDNSetV.Len(); c++) { int CID = CIDLambdaH.GetKey(c); IAssert(LambdaV[CID] >= MinLambda); double Q = exp( - (double) LambdaV[CID]); if (Q > QMax) { continue; } TIntV CmtyV; CIDNSetV[CID].GetKeyV(CmtyV); if (CmtyV.Len() == 0) { continue; } if (CID == BaseCID) { //if the community is the base community(epsilon community), discard IAssert(CmtyV.Len() == G->GetNodes()); } else { CmtyVV.Add(CmtyV); QV.Add(Q); } } }
int main(int argc, char* argv[]) { setbuf(stdout, NULL); // disables the buffer so that print statements are not buffered and display immediately (?) Env = TEnv(argc, argv, TNotify::StdNotify); Env.PrepArgs(TStr::Fmt("Vespignani backbone method. build: %s, %s. Time: %s", __TIME__, __DATE__, TExeTm::GetCurTm())); TExeTm ExeTm; Try const TStr InFNm = Env.GetIfArgPrefixStr("-i:", "", "input network"); const TStr OutFNm = Env.GetIfArgPrefixStr("-o:", "", "output prefix (alpha value and filename extensions added)"); double alpha = Env.GetIfArgPrefixFlt("-a:", 0.01, "alpha significance level threshold"); const TStr AlphaVFNm = Env.GetIfArgPrefixStr("--alphav:", "", "vector of alpha significance level threshold (overrides -a)"); const bool verbose = Env.GetIfArgPrefixBool("--verbose:", true, "verbose output for each step of the Vespignani method"); const bool bootstrap = Env.GetIfArgPrefixBool("--bootstrap:", false, "bootstrap Vespignani method to retain --ratio of total weight W"); const double ratio = Env.GetIfArgPrefixFlt("--ratio:", 0.50, "bootstrap target ratio of total weight W"); const double lowerBound = Env.GetIfArgPrefixFlt("--lowerbound:", 0.0, "lower bound for alpha (binary search)"); const double upperBound = Env.GetIfArgPrefixFlt("--upperbound:", 1.0, "upper bound for alpha (binary search)"); const double tol = Env.GetIfArgPrefixFlt("--tolerance:", 5.0e-3, "tolerance for alpha (binary search)"); const double spread = Env.GetIfArgPrefixFlt("--spread:", 2.0, "spread for bootstrapped alpha benchmark (binary search)"); // Load graph and create directed and undirected graphs (pointer to the same memory) printf("\nLoading %s...", InFNm.CStr()); const PFltWNGraph WGraph = TSnap::LoadFltWEdgeList<TWNGraph>(InFNm); printf(" DONE (time elapsed: %s (%s))\n", ExeTm.GetTmStr(), TSecTm::GetCurTm().GetTmStr().CStr()); TSnap::printFltWGraphSummary(WGraph, true, "\nWGraph\n------"); // Variables PFltWNGraph WGraphCopy; TFltV AlphaV; TFltV::TIter VI; if (!AlphaVFNm.Empty()) { AlphaV = TSnap::LoadTxtFltV(AlphaVFNm); } else { if (bootstrap) { printf("\n"); alpha = TSnap::FindVespignaniThreshold<TFlt, TWNGraph>(WGraph, ratio, tol, lowerBound, upperBound); AlphaV.Add(alpha / spread); AlphaV.Add(alpha); AlphaV.Add(alpha * spread); } else { AlphaV.Add(alpha); } } // VESPIGNANI METHOD Progress progress(ExeTm, AlphaV.Len(), 5, "Computing Vespignani method", !verbose); progress.start(); if (verbose) { printf("\n"); } int i = 0; for (VI = AlphaV.BegI(); VI < AlphaV.EndI(); VI++) { const double& alpha = VI->Val; // Compute method and save filtered printf("Computing Vespignani method (alpha: %e)\n\n", alpha); WGraphCopy = TSnap::FilterEdgesVespignani<TFlt, TWNGraph>(WGraph, alpha); TSnap::RemoveIsolated(WGraphCopy); TSnap::SaveFltWEdgeList(WGraphCopy, TStr::Fmt("%s-%9e.snap", OutFNm.CStr(), alpha), TStr::Fmt("Vespignani backbone with alpha: %e", alpha)); // Save bootstrapped if (bootstrap && i == 1) { TSnap::SaveFltWEdgeList(WGraphCopy, TStr::Fmt("%s-bootstrapped.snap", OutFNm.CStr()), TStr::Fmt("Vespignani backbone with alpha: %e", alpha)); } // Verbose summary if (verbose) { TSnap::printFltWGraphSummary(WGraphCopy, true, TStr::Fmt("WGraphCopy (alpha: %e)\n------", alpha)); printf("\n"); } i++; progress++; } Catch printf("\nrun time: %s (%s)\n", ExeTm.GetTmStr(), TSecTm::GetCurTm().GetTmStr().CStr()); return 0; }
void TPropHazards::GetWgtV(TFltV& _WgtV) const { for (int i = 1; i < WgtV.Len(); i++) { _WgtV.Add(WgtV[i]); } }
/// estimate number of communities using AGM int TAGMUtil::FindComsByAGM(const PUNGraph& Graph, const int InitComs, const int MaxIter, const int RndSeed, const double RegGap, const double PNoCom, const TStr PltFPrx) { TRnd Rnd(RndSeed); int LambdaIter = 100; if (Graph->GetNodes() < 200) { LambdaIter = 1; } if (Graph->GetNodes() < 200 && Graph->GetEdges() > 2000) { LambdaIter = 100; } //Find coms with large C TAGMFit AGMFitM(Graph, InitComs, RndSeed); if (PNoCom > 0.0) { AGMFitM.SetPNoCom(PNoCom); } AGMFitM.RunMCMC(MaxIter, LambdaIter, ""); int TE = Graph->GetEdges(); TFltV RegV; RegV.Add(0.3 * TE); for (int r = 0; r < 25; r++) { RegV.Add(RegV.Last() * RegGap); } TFltPrV RegComsV, RegLV, RegBICV; TFltV LV, BICV; //record likelihood and number of communities with nonzero P_c for (int r = 0; r < RegV.Len(); r++) { double RegCoef = RegV[r]; AGMFitM.SetRegCoef(RegCoef); AGMFitM.MLEGradAscentGivenCAG(0.01, 1000); AGMFitM.SetRegCoef(0.0); TVec<TIntV> EstCmtyVV; AGMFitM.GetCmtyVV(EstCmtyVV, 0.99); int NumLowQ = EstCmtyVV.Len(); RegComsV.Add(TFltPr(RegCoef, (double) NumLowQ)); if (EstCmtyVV.Len() > 0) { TAGMFit AFTemp(Graph, EstCmtyVV, Rnd); AFTemp.MLEGradAscentGivenCAG(0.001, 1000); double CurL = AFTemp.Likelihood(); LV.Add(CurL); BICV.Add(-2.0 * CurL + (double) EstCmtyVV.Len() * log((double) Graph->GetNodes() * (Graph->GetNodes() - 1) / 2.0)); } else { break; } } // if likelihood does not exist or does not change at all, report the smallest number of communities or 2 if (LV.Len() == 0) { return 2; } else if (LV[0] == LV.Last()) { return (int) TMath::Mx<TFlt>(2.0, RegComsV[LV.Len() - 1].Val2); } //normalize likelihood and BIC to 0~100 int MaxL = 100; { TFltV& ValueV = LV; TFltPrV& RegValueV = RegLV; double MinValue = TFlt::Mx, MaxValue = TFlt::Mn; for (int l = 0; l < ValueV.Len(); l++) { if (ValueV[l] < MinValue) { MinValue = ValueV[l]; } if (ValueV[l] > MaxValue) { MaxValue = ValueV[l]; } } while (ValueV.Len() < RegV.Len()) { ValueV.Add(MinValue); } double RangeVal = MaxValue - MinValue; for (int l = 0; l < ValueV.Len(); l++) { RegValueV.Add(TFltPr(RegV[l], double(MaxL) * (ValueV[l] - MinValue) / RangeVal)); } } { TFltV& ValueV = BICV; TFltPrV& RegValueV = RegBICV; double MinValue = TFlt::Mx, MaxValue = TFlt::Mn; for (int l = 0; l < ValueV.Len(); l++) { if (ValueV[l] < MinValue) { MinValue = ValueV[l]; } if (ValueV[l] > MaxValue) { MaxValue = ValueV[l]; } } while (ValueV.Len() < RegV.Len()) { ValueV.Add(MaxValue); } double RangeVal = MaxValue - MinValue; for (int l = 0; l < ValueV.Len(); l++) { RegValueV.Add(TFltPr(RegV[l], double(MaxL) * (ValueV[l] - MinValue) / RangeVal)); } } //fit logistic regression to normalized likelihood. TVec<TFltV> XV(RegLV.Len()); TFltV YV (RegLV.Len()); for (int l = 0; l < RegLV.Len(); l++) { XV[l] = TFltV::GetV(log(RegLV[l].Val1)); YV[l] = RegLV[l].Val2 / (double) MaxL; } TFltPrV LRVScaled, LRV; TLogRegFit LRFit; PLogRegPredict LRMd = LRFit.CalcLogRegNewton(XV, YV, PltFPrx); for (int l = 0; l < RegLV.Len(); l++) { LRV.Add(TFltPr(RegV[l], LRMd->GetCfy(XV[l]))); LRVScaled.Add(TFltPr(RegV[l], double(MaxL) * LRV.Last().Val2)); } //estimate # communities from fitted logistic regression int NumComs = 0, IdxRegDrop = 0; double LRThres = 1.1, RegDrop; // 1 / (1 + exp(1.1)) = 0.25 double LeftReg = 0.0, RightReg = 0.0; TFltV Theta; LRMd->GetTheta(Theta); RegDrop = (- Theta[1] - LRThres) / Theta[0]; if (RegDrop <= XV[0][0]) { NumComs = (int) RegComsV[0].Val2; } else if (RegDrop >= XV.Last()[0]) { NumComs = (int) RegComsV.Last().Val2; } else { //interpolate for RegDrop for (int i = 0; i < XV.Len(); i++) { if (XV[i][0] > RegDrop) { IdxRegDrop = i; break; } } if (IdxRegDrop == 0) { printf("Error!! RegDrop:%f, Theta[0]:%f, Theta[1]:%f\n", RegDrop, Theta[0].Val, Theta[1].Val); for (int l = 0; l < RegLV.Len(); l++) { printf("X[%d]:%f, Y[%d]:%f\n", l, XV[l][0].Val, l, YV[l].Val); } } IAssert(IdxRegDrop > 0); LeftReg = RegDrop - XV[IdxRegDrop - 1][0]; RightReg = XV[IdxRegDrop][0] - RegDrop; NumComs = (int) TMath::Round( (RightReg * RegComsV[IdxRegDrop - 1].Val2 + LeftReg * RegComsV[IdxRegDrop].Val2) / (LeftReg + RightReg)); } //printf("Interpolation coeff: %f, %f, index at drop:%d (%f), Left-Right Vals: %f, %f\n", LeftReg, RightReg, IdxRegDrop, RegDrop, RegComsV[IdxRegDrop - 1].Val2, RegComsV[IdxRegDrop].Val2); printf("Num Coms:%d\n", NumComs); if (NumComs < 2) { NumComs = 2; } if (PltFPrx.Len() > 0) { TStr PlotTitle = TStr::Fmt("N:%d, E:%d ", Graph->GetNodes(), TE); TGnuPlot GPC(PltFPrx + ".l"); GPC.AddPlot(RegComsV, gpwLinesPoints, "C"); GPC.AddPlot(RegLV, gpwLinesPoints, "likelihood"); GPC.AddPlot(RegBICV, gpwLinesPoints, "BIC"); GPC.AddPlot(LRVScaled, gpwLinesPoints, "Sigmoid (scaled)"); GPC.SetScale(gpsLog10X); GPC.SetTitle(PlotTitle); GPC.SavePng(PltFPrx + ".l.png"); } return NumComs; }
void TNetInfBs::GreedyOpt(const int& MxEdges) { double CurProb = GetAllCascProb(-1, -1); double LastGain = TFlt::Mx; int attempts = 0; bool msort = false; for (int k = 0; k < MxEdges && EdgeGainV.Len() > 0; k++) { double prev = CurProb; const TIntPr BestE = GetBestEdge(CurProb, LastGain, msort, attempts); if (BestE == TIntPr(-1, -1)) // if we cannot add more edges, we stop break; if (CompareGroundTruth) { double precision = 0, recall = 0; if (PrecisionRecall.Len() > 1) { precision = PrecisionRecall[PrecisionRecall.Len()-1].Val2.Val; recall = PrecisionRecall[PrecisionRecall.Len()-1].Val1.Val; } if (GroundTruth->IsEdge(BestE.Val1, BestE.Val2)) { recall++; } else { precision++; } PrecisionRecall.Add(TPair<TFlt, TFlt>(recall, precision)); } Graph->AddEdge(BestE.Val1, BestE.Val2); // add edge to network double Bound = 0; if (BoundOn) Bound = GetBound(BestE, prev); // localized update! TIntV &CascsEdge = CascPerEdge.GetDat(BestE); // only check cascades that contain the edge for (int c = 0; c < CascsEdge.Len(); c++) { CascV[CascsEdge[c]].UpdateProb(BestE.Val1, BestE.Val2, true); // update probabilities } // some extra info for the added edge TInt Vol; TFlt AverageTimeDiff; TFltV TimeDiffs; Vol = 0; AverageTimeDiff = 0; for (int i=0; i< CascV.Len(); i++) { if (CascV[i].IsNode(BestE.Val2) && CascV[i].GetParent(BestE.Val2) == BestE.Val1) { Vol += 1; TimeDiffs.Add(CascV[i].GetTm(BestE.Val2)-CascV[i].GetTm(BestE.Val1)); AverageTimeDiff += TimeDiffs[TimeDiffs.Len()-1]; } } AverageTimeDiff /= Vol; if (TimeDiffs.Len() > 0) TimeDiffs.Sort(); else TimeDiffs.Add(0); // compute bound only if explicitly required EdgeInfoH.AddDat(BestE) = TEdgeInfo(Vol, LastGain, Bound, TimeDiffs[(int)(TimeDiffs.Len()/2)], AverageTimeDiff); } if (CompareGroundTruth) { for (int i=0; i<PrecisionRecall.Len(); i++) { PrecisionRecall[i].Val2 = 1.0 - PrecisionRecall[i].Val2/(PrecisionRecall[i].Val2+PrecisionRecall[i].Val1); PrecisionRecall[i].Val1 /= (double)GroundTruth->GetEdges(); } } }
void GetMtxFromSepLine(const TStr& line, const TStr& separator, TFltV& matrix){ TStrV strVals; line.SplitOnAllAnyCh(separator, strVals); for (int i = 0; i < strVals.Len(); i++) matrix.Add(strVals[i].GetFlt()); }