Learns a k-TBN (order k + structure + parameters) from trajectory CSVs. More...

#include <agrum/KTBN/learning/KTBNAdaptiveLearner.h>

Inheritance diagram for gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >:

Collaboration diagram for gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >:

Public Member Functions
Constructors / Destructors
	KTBNAdaptiveLearner (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size kMax, const std::unordered_set< std::string > &atemporalVars, const std::vector< std::string > &missingSymbols={"?"}, bool induceTypes=true)
	Constructor — the candidate orders are kMin..kMax.
	KTBNAdaptiveLearner (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size kMax, const std::vector< std::string > &missingSymbols={"?"}, bool induceTypes=true)
	Structure-learning constructor — atemporal variables inferred from the CSVs.
	KTBNAdaptiveLearner (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size kMax, const BayesNet< GUM_SCALAR > &bn, const std::unordered_set< std::string > &atemporalVars={}, const std::vector< std::string > &missingSymbols={"?"})
	Variable-schema constructor — types and domains supplied via a BN.
	~KTBNAdaptiveLearner ()
	Constructor — the candidate orders are kMin..kMax.
Main learning methods
KTBN< GUM_SCALAR >	learnKTBN () override
	Learns the best k in [kMin, kMax] together with the structure and the CPTs: one KTBNLearner is built and run per candidate k, the recorded configuration is replayed on each, and the k-TBN with the best model-selection score is returned. kMin starts at 2 and is raised by the structural-constraint setters (see class doc).
Size	bestK () const
	Order k selected by the last learnKTBN() call.
const std::vector< std::pair< Size, double > > &	scorePerCandidateK () const
	Per-candidate cross-k scores from the last learnKTBN() call, as (k, score) pairs for k = kMin..kMax in ascending k order — the values the order selection compared to choose bestK() (higher is better; the argmax is bestK()). Under the default useOrderScoreBIC() each score is $\log_2 L - \tfrac{1}{2}\,d\,\log_2 N$ of the k-TBN learned for that k.
const std::vector< std::pair< std::string, std::string > > &	latentVariables () const
	Engine-name (tail, head) pairs of arcs the selected model's MIIC run flagged as hiding a latent variable. Empty when the recorded algorithm is not MIIC (only MIIC produces latent-variable annotations) or when none were found.
Missing values
KTBNAdaptiveLearner< GUM_SCALAR > &	ignoreMissingSymbols (bool ignore=true)
	Learn and score on the fully observed data only, dropping every row and every scoring instance that carries a missing symbol.
bool	isIgnoringMissingSymbols () const
	Whether incomplete rows and instances are dropped. False by default.
Diagnostics
Size	kMax () const
	Largest order explored (the kMax argument of the constructor).
std::string	checkScorePriorCompatibility () const
	Warning string if the recorded score and prior are incompatible, empty otherwise. Data-free: it evaluates the recorded (score, prior) pair exactly as KTBNLearner/BNLearner would, so an incompatible combination can be caught before learnKTBN() reads any trajectory.
std::string	toString () const
	Human-readable summary of the recorded configuration (candidate order range, algorithm / score / correction / prior, structural constraints) plus the selected k once learnKTBN() has run.
std::vector< std::tuple< std::string, std::string, std::string > >	state () const
	The recorded configuration as (key, value, comment) tuples (mirrors KTBNLearner::state()); toString() is a formatted view of it.
Score selection (recorded, replayed on each candidate k)
KTBNAdaptiveLearner< GUM_SCALAR > &	useScoreAIC () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useScoreBD () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useScoreBDeu () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useScoreBIC () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useScoreLog2Likelihood () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useScoreMDL () override
void	useScorefNML () override
Algorithm selection (recorded, replayed on each candidate k)
KTBNAdaptiveLearner< GUM_SCALAR > &	useGreedyHillClimbing () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useExtendedGreedyHillClimbing () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useLocalSearchWithTabuList (Size tabu_size=100, Size nb_decrease=2) override
KTBNAdaptiveLearner< GUM_SCALAR > &	useMIIC () override
MIIC correction (recorded, replayed on each candidate k)
KTBNAdaptiveLearner< GUM_SCALAR > &	useNMLCorrection () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useMDLCorrection () override
KTBNAdaptiveLearner< GUM_SCALAR > &	useNoCorrection () override
Prior selection (recorded, replayed on each candidate k)
KTBNAdaptiveLearner< GUM_SCALAR > &	useSmoothingPrior (double weight=1.0) override
Structural constraints (recorded, replayed on each candidate k)
KTBNAdaptiveLearner< GUM_SCALAR > &	addForbiddenArc (std::string_view tailNode, std::string_view headNode) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addForbiddenArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseForbiddenArc (std::string_view tailNode, std::string_view headNode) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseForbiddenArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addMandatoryArc (std::string_view tailNode, std::string_view headNode) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addMandatoryArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseMandatoryArc (std::string_view tailNode, std::string_view headNode) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseMandatoryArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addForbiddenKernelArc (std::string_view tailBase, int lag, std::string_view headBase)
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseForbiddenKernelArc (std::string_view tailBase, int lag, std::string_view headBase)
	Undo a previous addForbiddenKernelArc (same (tailBase, lag, headBase) triple).
KTBNAdaptiveLearner< GUM_SCALAR > &	addMandatoryKernelArc (std::string_view tailBase, int lag, std::string_view headBase)
	Force an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel. See addForbiddenKernelArc for the (base, slice) vs. kernel-relative distinction; the validity constraints (`lag` range, temporal bases, kMin effect) are the same. Always temporally feasible by construction (lag >= 0 guarantees headSlice = k-1 >= k-1-lag = tailSlice), so unlike the plain addMandatoryArc there is no separate feasibility check to run.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseMandatoryKernelArc (std::string_view tailBase, int lag, std::string_view headBase)
	Undo a previous addMandatoryKernelArc (same (tailBase, lag, headBase) triple).
KTBNAdaptiveLearner< GUM_SCALAR > &	addForbiddenIntraSliceArc (std::string_view tailBase, std::string_view headBase) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseForbiddenIntraSliceArc (std::string_view tailBase, std::string_view headBase) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addForbiddenArcAllSlices (std::string_view tailBase, std::string_view headBase) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseForbiddenArcAllSlices (std::string_view tailBase, std::string_view headBase) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addNoParentNode (std::string_view base, int slice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addNoParentNode (std::string_view name) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseNoParentNode (std::string_view base, int slice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseNoParentNode (std::string_view name) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addNoChildrenNode (std::string_view base, int slice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addNoChildrenNode (std::string_view name) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseNoChildrenNode (std::string_view base, int slice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	eraseNoChildrenNode (std::string_view name) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addPossibleEdge (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	addPossibleEdge (std::string_view tail, std::string_view head) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	erasePossibleEdge (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	erasePossibleEdge (std::string_view tail, std::string_view head) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	allowArcAdditions (bool allow=true) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	allowArcDeletions (bool allow=true) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	allowArcReversals (bool allow=true) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.
KTBNAdaptiveLearner< GUM_SCALAR > &	setMaxIndegree (Size max_indegree) override
	Forbid an arc from `tailBase`, `lag` slices before the kernel, to `headBase` in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from `lag` relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. `lag` must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Private Member Functions
const std::unordered_set< std::string > &	_atemporalVarNames_ () const override
	atemporal base names for IKTBNLearner's shared encode/_determineNode_; the set recorded at construction.
bool	_isKnownBase_ (std::string_view base) const override
	whether `base` is one of this learner's variables; the base names read at construction, from the CSV header or the schema BN.
void	_verifyBase_ (std::string_view base, int slice) const
	Throw InvalidArgument unless `base` is a known base variable and `slice` is valid for it: `base` must be in baseNames; an atemporal `base` requires `slice` == KTBN::ATEMPORAL, a temporal one requires `slice` in [0, kMax). Used by the constraint setters to reject unknown names / out-of-range slices eagerly.
void	_verifyKernelArc_ (std::string_view tailBase, std::string_view headBase, int lag) const
	Throw InvalidArgument unless `tailBase` and `headBase` are known, temporal base variables (a kernel-relative arc has no meaning for an atemporal one: it has no kernel-slice instance) and `lag` is in [0, kMax) — so some candidate k in [2,kMax] can place tailBase at slice k-1-lag >= 0 and headBase at the kernel slice k-1. Used by the four kernel-arc setters (add/eraseForbiddenKernelArc, add/eraseMandatoryKernelArc) to reject bad calls eagerly.
void	_raiseKMinForSlice_ (int slice)
	Raise kMin, if needed, so that kMin > `slice:` a smaller candidate would silently drop a constraint naming that slice (the "slice < k" rule applyConstraints's fits() filter uses). O(1), since adding a constraint can only push kMin up. No-op for KTBN::ATEMPORAL.
void	_recomputeKMin_ ()
	Recompute kMin from scratch: max(2, 1 + the largest concrete slice named by any recorded forbidden/mandatory arc, possible edge, or no-parent/no-children node (the kinds fits() can drop). Intra-slice / all-slices constraints carry no slice and are excluded. Unlike raiseKMinForSlice, an erase can lower kMin with no O(1) way to tell, so every erase* setter runs this full rescan instead.
void	_applyConfig_ (KTBNLearner< GUM_SCALAR > &learner) const
	Apply the recorded score / algorithm / correction / prior onto a freshly-built `learner`. Only knobs that differ from their default are touched, and only those the chosen algorithm actually consumes (a score-based algo takes a score; MIIC takes a correction) — so an unconfigured learner is left at its defaults and no irrelevant setting can trip checkScorePriorCompatibility().
void	_applyConstraints_ (KTBNLearner< GUM_SCALAR > &learner, Size k) const
	Replay the recorded structural constraints onto `learner` (built for order `k`). Engine-name constraints whose slice does not fit `k` (slice >= k) are skipped for this candidate; the base-only intra-slice / all-slices constraints are handed to `learner`, which expands them for its own k. The allow-* flags and max-indegree are applied when non-default.
template<typename PerInstance, typename PerNodeFinal>
void	_forEachScoredNode_ (const KTBN< GUM_SCALAR > &net, PerInstance perInstance, PerNodeFinal perNodeFinal) const
	Stream every scored template-node instance of `net` over the recorded trajectories, driving both the likelihood and the fNML penalty off one data walk, so the width-k window logic lives in one place.
double	_log2Likelihood_ (const KTBN< GUM_SCALAR > &net) const
	Factorized log2-likelihood of `net` over the recorded trajectories, comparable across candidate k (the raw score types are not: their flattened tables differ from one k to another). The data is complete, so this is a closed-form sum of CPT lookups — no inference. A thin reduction over forEachScoredNode that sums `log2` of the CPT entry over every visited node instance.
double	_countParameters_ (const KTBN< GUM_SCALAR > &net) const
	Number of free parameters of `net's` template: summed over every template node (all initial slices, the kernel slice and the atemporal nodes), $(\|X\|-1)\prod_{P\in pa(X)}\|P\|$. This is the model-complexity term of the cross-k BIC and AIC scores used by learnKTBN(): it grows with $k$ (a higher order adds initial-slice CPTs and can widen the kernel), which is what offsets the monotonic likelihood gain and prevents always picking the largest $k$.
double	_fNMLScore_ (const KTBN< GUM_SCALAR > &net) const
	fNML order score of `net` over the recorded trajectories: $\log_2 L - \sum_i \sum_j \log_2 C^{r_i}_{N_{ij}}$, with $r_i$ the node's domain size and $N_{ij}$ the count for parent configuration $j$. Unlike BIC/AIC the penalty is data-dependent, so the regret needs the same per-instance walk as the likelihood — both are accumulated in one forEachScoredNode pass. Mirrors aGrUM's ScorefNML.
double	_orderSelectionScore_ (const KTBN< GUM_SCALAR > &net, double logN) const
	The cross-k order-selection score of `net` under the recorded orderScore criterion, given `logN` = log2 of the sample size. The single dispatch point learnKTBN() uses to compare candidates; add a branch here for each new OrderScoreType.
	KTBNAdaptiveLearner (const KTBNAdaptiveLearner< GUM_SCALAR > &)=delete
	KTBNAdaptiveLearner (KTBNAdaptiveLearner< GUM_SCALAR > &&)=delete
KTBNAdaptiveLearner< GUM_SCALAR > &	operator= (const KTBNAdaptiveLearner< GUM_SCALAR > &)=delete
KTBNAdaptiveLearner< GUM_SCALAR > &	operator= (KTBNAdaptiveLearner< GUM_SCALAR > &&)=delete

Static Private Member Functions
static std::unordered_set< std::string >	_inferAtemporalVars_ (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size kMax, const std::vector< std::string > &missingSymbols)
	checks `kMax` >= 2 and `nbSamples` >= 1, then delegates to the shared IKTBNLearner::scanConstantColumns(). Called from the atemporal-inferring constructor's member-initialiser list, before this object exists, so the checks live here rather than in the body — otherwise a bad argument would only surface after a wasted scan.

Private Attributes
std::string	_dirPath_
	directory holding the trajectory CSV files
std::string	_csvBaseName_
	stem of each trajectory file name
Size	_nbSamples_
	number of CSV files to read
Size	_kMax_
	largest order to explore (candidates are kMin..kMax)
Size	_kMin_ {2}
	smallest order worth exploring (candidates are kMin..kMax). Starts at 2 and is recomputed by recomputeKMin() from the recorded slice-bearing constraints every time one is added or erased; never set directly. See recomputeKMin() for why it must be a recompute rather than an incremental raise/lower.
std::unordered_set< std::string >	_atemporalVars_
	base names of the atemporal (static) variables
std::unordered_set< std::string >	_baseNames_
	all base variable names (temporal + atemporal), read from the first trajectory CSV header at construction. Authoritative universe used by the constraint setters to reject names that do not exist.
std::vector< std::string >	_missingSymbols_
	symbols in the CSVs to interpret as missing values
bool	_ignoreMissingSymbols_ {false}
	whether incomplete rows/instances are dropped (see ignoreMissingSymbols())
bool	_induceTypes_
	whether numeric columns are retyped (see KTBNLearner); unused (and forced false) when a schema BN is supplied
std::unique_ptr< BayesNet< GUM_SCALAR > >	_prior_bn_
	optional variable-schema BN (set by the BN constructor): when present, each per-k KTBNLearner is built from it so the variable domains are fixed explicitly instead of inferred from trajectory 1. Null in CSV mode.
IBNLearner::ScoreType	_score_ {IBNLearner::ScoreType::BDeu}
	recorded per-k structure score (the inner score, replayed on each candidate)
OrderScoreType	_orderScore_ {OrderScoreType::BIC}
	recorded cross-k order-selection criterion (the outer score used by learnKTBN() to pick the best k; independent of score)
IBNLearner::AlgoType	_algo_ {IBNLearner::AlgoType::MIIC}
	recorded structure-learning algorithm
Size	_tabuSize_ {100}
	tabu-list parameters (meaningful when algo is LOCAL_SEARCH_WITH_TABU_LIST)
Size	_nbDecrease_ {2}
CorrectedMutualInformation::KModeTypes	_correction_
	recorded MIIC correction
IBNLearner::BNLearnerPriorType	_prior_ {IBNLearner::BNLearnerPriorType::NO_prior}
	recorded prior and its weight
double	_priorWeight_ {1.0}
bool	_allowAdditions_ {true}
	recorded graph-change permissions / indegree cap
bool	_allowDeletions_ {true}
bool	_allowReversals_ {true}
Size	_maxIndegree_ {std::numeric_limits< Size >::max()}
std::set< std::pair< std::string, std::string > >	_forbiddenArcs_
	forbidden arcs, as (tail, head) engine-name pairs
std::set< std::pair< std::string, std::string > >	_mandatoryArcs_
	mandatory arcs, as (tail, head) engine-name pairs
std::set< std::pair< std::string, std::string > >	_possibleEdges_
	MIIC candidate edges, as (tail, head) engine-name pairs.
std::set< std::pair< std::string, std::string > >	_forbiddenIntraSliceArcs_
	forbidden intra-slice arcs, as (tailBase, headBase) pairs
std::set< std::pair< std::string, std::string > >	_forbiddenArcsAllSlices_
	forbidden all-slices arcs, as (tailBase, headBase) pairs
std::set< std::tuple< std::string, std::string, int > >	_forbiddenKernelArcs_
	forbidden kernel-relative arcs, as (tailBase, headBase, lag) triples: tailBase at slice k-1-lag -> headBase at the kernel slice k-1. Kept separate from forbiddenArcs (which stores resolved engine names) since the slice here is only known once a candidate k is fixed.
std::set< std::tuple< std::string, std::string, int > >	_mandatoryKernelArcs_
	mandatory kernel-relative arcs, same shape as forbiddenKernelArcs
std::set< std::string >	_noParentNodes_
	root nodes (no parents), as engine names
std::set< std::string >	_noChildrenNodes_
	leaf nodes (no children), as engine names
Size	_bestK_ {0}
	k selected by the last learnKTBN() call, or 0 as a sentinel while no learning has happened yet. 0 can never be a valid order (candidates are 2..kMax), so bestK() reads it to decide whether learnKTBN() has run.
std::vector< std::pair< std::string, std::string > >	_bestLatentVariables_
	latent-variable arcs (engine-name pairs) reported by the winning candidate's MIIC run, captured by learnKTBN(); empty when the selected algorithm is not MIIC. Exposed by latentVariables().
std::vector< std::pair< Size, double > >	_scorePerCandidateK_
	per-candidate (k, order-score) pairs from the last learnKTBN() run, in ascending k. One entry appended per candidate; read by scorePerCandidateK(). Cleared at the start of each learnKTBN() (empty while bestK == 0).
VariableLog2ParamComplexity	_ctable_
	cache of log2 of the multinomial parametric complexity C^r_n, used by the fNML order penalty. Mutable because log2Cnr() memoizes; the const order-score helpers may therefore call it. Only touched under fNML.

Order selection (cross-k model selection)
enum class	OrderScoreType { BIC , AIC , fNML }
	The criterion learnKTBN() uses to pick the best $k$ among the candidates — the outer score, distinct from the per-k structure score set by useScoreX(). Only criteria that are comparable across $k$ belong here (raw score types are not). Extended as more are added. More...
log_2	C {r_i}_{N_{ij}}@f$
	Select k by fNML (factorized Normalized Maximum Likelihood): keep the k whose learned model maximises .
KTBNAdaptiveLearner< GUM_SCALAR > &	useOrderScoreBIC ()
	Select k by BIC (the default): keep the k whose learned model maximises $\log_2 L - \tfrac{1}{2}\,d\,\log_2 N$.
KTBNAdaptiveLearner< GUM_SCALAR > &	useOrderScoreAIC ()
	Select k by AIC: keep the k whose learned model maximises $\log_2 L - d$ (a lighter, sample-size-independent complexity penalty than BIC).
log_2 where the penalty replaces BIC s KTBNAdaptiveLearner< GUM_SCALAR > &	useOrderScorefNML ()
	$\tfrac{1}{2}\,d\,\log_2 N$ by a sum of per-node, per-parent-configuration multinomial parametric complexities (regret) – data-dependent, unlike BIC/AIC, matching aGrUM's ScorefNML.

Name encoding: (base, slice) <-> engine name
std::string	_encode_ (std::string_view base, int slice) const
	(base, slice) -> engine name ("A[1]" / atemporal engine name). Pure function, shared by every learner.
std::pair< std::string, int >	_determineNode_ (const std::string &name) const
	engine name -> (base, slice); atemporal names map to KTBN::ATEMPORAL. Shared by every learner; only the atemporal test varies (via atemporalVarNames()).
void	_checkArcTemporallyFeasible_ (std::string_view tail, std::string_view head, std::string_view action) const
	Reject an arc the k-TBN definition can never contain, so eraseForbiddenArc and addMandatoryArc both fail early (before any internal learner is touched) with a uniform message. `action` is the verb phrase completing "cannot <action> <tail> -> <head>: ..." (e.g. "force the mandatory arc", "un-forbid the arc"). Two arcs are refused: a temporal -> atemporal arc (a time-varying variable can never parent a static one) and a backward-in-time arc (head strictly before tail).
void	_checkBaseIsTemporal_ (std::string_view base, std::string_view context) const
	Throw InvalidArgument unless `base` is a known temporal base. `context` completes "cannot appear in <context>" (e.g. "an intra-slice constraint", "a kernel-relative arc"): every caller rejects an atemporal base for the same underlying reason – it has no per-slice instance – so they share the sentence and vary the setting.
static void	_checkMinimalOrder_ (Size order, std::string_view label)
	Throw InvalidArgument unless `order` is at least 2, `label` naming the offending parameter ("k" for the fixed-k learner, "kMax" for the adaptive one).
static std::unordered_set< std::string >	_scanConstantColumns_ (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, const std::vector< std::string > &missingSymbols)
	Scans every trajectory and returns the base names classified atemporal: those whose value never changes across the rows of a single trajectory (checked independently per trajectory, so the value may still differ between trajectories). Shared by every atemporal-inferring CSV constructor (KTBNLearner, KTBNAdaptiveLearner): identical scanning logic regardless of which subclass calls it, so duplicating it per subclass would only invite the two copies to drift. Callers are responsible for validating their own arguments (e.g. k/kMax >= 2) before calling this — it does no such check itself, only opens files, so a bad argument would otherwise only be caught after a wasted scan.

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >

Learns a k-TBN (order k + structure + parameters) from trajectory CSVs.

See also: gum::learning::IKTBNLearner for the configuration interface, gum::learning::KTBNLearner for the fixed-k learner this class builds and drives once per candidate k.

Definition at line 104 of file KTBNAdaptiveLearner.h.

Member Enumeration Documentation

◆ OrderScoreType

template<GUM_Numeric GUM_SCALAR>

enum class gum::learning::KTBNAdaptiveLearner::OrderScoreType

strong

The criterion learnKTBN() uses to pick the best $k$ among the candidates — the outer score, distinct from the per-k structure score set by useScoreX(). Only criteria that are comparable across $k$ belong here (raw score types are not). Extended as more are added.

Enumerator
BIC
AIC
fNML

Definition at line 266 of file KTBNAdaptiveLearner.h.

266{ BIC, AIC, fNML };

Constructor & Destructor Documentation

◆ KTBNAdaptiveLearner() [1/5]

template<GUM_Numeric GUM_SCALAR>

gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		Size	kMax,
		const std::unordered_set< std::string > &	atemporalVars,
		const std::vector< std::string > &	missingSymbols = {"?"},
		bool	induceTypes = true )

Constructor — the candidate orders are kMin..kMax.

Mirrors the CSV constructor of gum::learning::KTBNLearner, except that no single order k is given: the learner explores every $k \in [k_{min}, kMax]$ at learn time. $k_{min}$ starts at 2 (k = 1 is a static BN; use BNLearner) and is raised by the structural-constraint setters — see the class doc.

Parameters

dirPath	Directory holding the trajectory CSV files.
csvBaseName	Stem of each file name (1-based index and .csv appended, e.g. `"traj"` -> `"traj1.csv"`, `"traj2.csv"`, ...).
nbSamples	Number of CSV files to read.
kMax	Largest order to explore. Must be $\geq 2$.
atemporalVars	Base names of the atemporal (static) variables. Pass an empty set for "every variable is temporal"; it has no default, since omitting it selects the inferring overload below.
missingSymbols	Symbols in the CSVs to interpret as missing values.
induceTypes	When true (default), columns whose values are all numeric are retyped (integer/range/continuous) instead of being treated as plain labels — same semantics as KTBNLearner.

Warning: A braced literal is ambiguous between this overload and the inferring one, since it could equally initialize either's fifth parameter. Name the type — std::unordered_set<std::string>{"C","D"} — or pass a named variable.

Definition at line 78 of file KTBNAdaptiveLearner_tpl.h.

                                                            :
      _dirPath_(dirPath), _csvBaseName_(csvBaseName), _nbSamples_(nbSamples), _kMax_(kMax),
      _atemporalVars_(atemporalVars), _missingSymbols_(missingSymbols), _induceTypes_(induceTypes) {
    // cheap argument checks first, so bad calls fail before touching the disk
    IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(kMax, "kMax");
    if (nbSamples < 1) GUM_ERROR(InvalidArgument, "KTBNAdaptiveLearner requires nbSamples >= 1")
 
    // Load the base-variable names (the CSV columns) so the constraint setters can
    // reject unknown names eagerly. Only the header row is needed, so we parse a
    // single line instead of loading and typing the whole file. The column order
    // matches what every per-k KTBNLearner reads from the same header at
    // learnKTBN() time.
    namespace fs            = std::filesystem;
    const fs::path firstCSV = fs::path{dirPath} / (std::string{csvBaseName} + "1.csv");
    std::ifstream  is(firstCSV, std::ifstream::in);
    if (!is.is_open()) GUM_ERROR(IOError, "Cannot open " << firstCSV.string())
 
    CSVParser parser(is, firstCSV.string());
    if (!parser.next())
      GUM_ERROR(IOError, "Empty trajectory file (no header row): " << firstCSV.string())
    const std::vector< std::string >& header = parser.current();
    _baseNames_.insert(header.begin(), header.end());
 
    // every declared atemporal variable must actually be one of those columns
    for (const std::string& aname: _atemporalVars_)
      if (!_baseNames_.contains(aname))
        GUM_ERROR(InvalidArgument,
                  "atemporal variable '" << aname << "' not found in the CSV header")
 
    GUM_CONSTRUCTOR(KTBNAdaptiveLearner)
  }

References KTBNAdaptiveLearner(), _atemporalVars_, _baseNames_, gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(), _csvBaseName_, _dirPath_, _induceTypes_, _kMax_, _missingSymbols_, _nbSamples_, gum::learning::CSVParser::current(), GUM_ERROR, kMax(), and gum::learning::CSVParser::next().

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), ~KTBNAdaptiveLearner(), operator=(), operator=(), useGreedyHillClimbing(), useMDLCorrection(), useMIIC(), useNMLCorrection(), useNoCorrection(), useOrderScoreAIC(), useOrderScoreBIC(), useOrderScorefNML(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScoreLog2Likelihood(), and useScoreMDL().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ KTBNAdaptiveLearner() [2/5]

template<GUM_Numeric GUM_SCALAR>

gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		Size	kMax,
		const std::vector< std::string > &	missingSymbols = {"?"},
		bool	induceTypes = true )

Structure-learning constructor — atemporal variables inferred from the CSVs.

Same as the explicit-atemporalVars constructor, except a base variable is classified atemporal iff its value never changes within a single trajectory (it may still differ between trajectories, e.g. a per-individual covariate such as age). A column with too few non-missing values to ever witness a change is classified atemporal optimistically.

This is a heuristic: a genuinely temporal variable that happens to hold one value throughout every sampled trajectory (short horizon, near-deterministic process) will be misclassified. Prefer the explicit-atemporalVars constructor when the classification is already known.

Warning: Domains are still discovered from trajectory 1 alone. An inferred atemporal variable, by construction, may vary between trajectories — exactly the case most likely to reveal only one of several modalities in trajectory 1 and later throw UnknownLabelInDatabase at learnKTBN() time. Use the BN-schema constructor if the full domain isn't guaranteed present in trajectory 1.; Unlike every other constructor, this one is not fully lazy: it keeps opening trajectories until every column has been falsified as a constancy candidate, so a missing/malformed file is usually (not always — an early-falsifying column set can stop the scan first) caught here rather than at learnKTBN().

Parameters

dirPath	Directory holding the trajectory CSV files.
csvBaseName	Stem of each file name (1-based index and .csv appended, e.g. `"traj"` -> `"traj1.csv"`, `"traj2.csv"`, ...).
nbSamples	Number of CSV files to read.
kMax	Largest order to explore. Must be $\geq 2$.
missingSymbols	Symbols in the CSVs to interpret as missing values.
induceTypes	When true (default), columns whose values are all numeric are retyped (integer/range/continuous) instead of being treated as plain labels.

Definition at line 118 of file KTBNAdaptiveLearner_tpl.h.

                                                     :
      // _inferAtemporalVars_ checks kMax>=2 and nbSamples>=1 itself, before
      // opening anything (see its declaration) — this initialiser-list call
      // runs before the delegated-to constructor's own body, so those checks
      // cannot be left to that body the way the explicit constructor does.
      // Delegates to the explicit-atemporalVars constructor for the rest
      // (header read); _inferAtemporalVars_ needs nbSamples, unlike the
      // header-only read above, since one trajectory alone cannot show that a
      // value stays constant.
      KTBNAdaptiveLearner(
          dirPath,
          csvBaseName,
          nbSamples,
          kMax,
          _inferAtemporalVars_(dirPath, csvBaseName, nbSamples, kMax, missingSymbols),
          missingSymbols,
          induceTypes) {}

References KTBNAdaptiveLearner(), _inferAtemporalVars_(), and kMax().

Here is the call graph for this function:

◆ KTBNAdaptiveLearner() [3/5]

template<GUM_Numeric GUM_SCALAR>

gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		Size	kMax,
		const BayesNet< GUM_SCALAR > &	bn,
		const std::unordered_set< std::string > &	atemporalVars = {},
		const std::vector< std::string > &	missingSymbols = {"?"} )

Variable-schema constructor — types and domains supplied via a BN.

The adaptive counterpart of gum::learning::KTBNLearner's BN constructor. Use it when a variable's full domain is not guaranteed to appear in the first trajectory — most notably atemporal variables, which are constant within a trajectory and so only ever reveal one value per file, and the CSV constructor would then infer an incomplete domain and later throw gum::UnknownLabelInDatabase. Each per-k KTBNLearner is built from bn so every variable's type and domain is fixed up front; induceTypes and the trajectory-1 domain inference are bypassed entirely.

Parameters

dirPath	Directory holding the trajectory CSV files.
csvBaseName	Stem of each file name (index and .csv appended).
nbSamples	Number of CSV files to read.
kMax	Largest order to explore. Must be $\geq 2$.
bn	A BayesNet with one node per base variable providing the variable types and domains. Arcs in `bn` are ignored.
atemporalVars	Base names of the atemporal (static) variables present in `bn`.
missingSymbols	Symbols in the CSVs to interpret as missing values.

Definition at line 158 of file KTBNAdaptiveLearner_tpl.h.

                                                           :
      _dirPath_(dirPath), _csvBaseName_(csvBaseName), _nbSamples_(nbSamples), _kMax_(kMax),
      _atemporalVars_(atemporalVars), _missingSymbols_(missingSymbols), _induceTypes_(false),
      _prior_bn_(std::make_unique< BayesNet< GUM_SCALAR > >(bn)) {
    IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(kMax, "kMax");
    if (nbSamples < 1) GUM_ERROR(InvalidArgument, "KTBNAdaptiveLearner requires nbSamples >= 1")
 
    // the schema BN is the authoritative variable universe here (not the CSV
    // header): take the base names from it, so the constraint setters validate
    // against the same variables every per-k KTBNLearner will use. The CSV is
    // read only later, at learnKTBN() time.
    for (const NodeId node: bn.nodes())
      _baseNames_.insert(bn.variable(node).name());
 
    // every declared atemporal variable must be a node of the schema BN
    for (const std::string& aname: _atemporalVars_)
      if (!_baseNames_.contains(aname))
        GUM_ERROR(InvalidArgument,
                  "atemporal variable '" << aname << "' not found in the schema BN")
 
    GUM_CONSTRUCTOR(KTBNAdaptiveLearner)
  }

References KTBNAdaptiveLearner(), _atemporalVars_, _baseNames_, gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(), _csvBaseName_, _dirPath_, _induceTypes_, _kMax_, _missingSymbols_, _nbSamples_, _prior_bn_, GUM_ERROR, and kMax().

Here is the call graph for this function:

◆ ~KTBNAdaptiveLearner()

template<GUM_Numeric GUM_SCALAR>

gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::~KTBNAdaptiveLearner ( )

Constructor — the candidate orders are kMin..kMax.

Mirrors the CSV constructor of gum::learning::KTBNLearner, except that no single order k is given: the learner explores every $k \in [k_{min}, kMax]$ at learn time. $k_{min}$ starts at 2 (k = 1 is a static BN; use BNLearner) and is raised by the structural-constraint setters — see the class doc.

Parameters

dirPath	Directory holding the trajectory CSV files.
csvBaseName	Stem of each file name (1-based index and .csv appended, e.g. `"traj"` -> `"traj1.csv"`, `"traj2.csv"`, ...).
nbSamples	Number of CSV files to read.
kMax	Largest order to explore. Must be $\geq 2$.
atemporalVars	Base names of the atemporal (static) variables. Pass an empty set for "every variable is temporal"; it has no default, since omitting it selects the inferring overload below.
missingSymbols	Symbols in the CSVs to interpret as missing values.
induceTypes	When true (default), columns whose values are all numeric are retyped (integer/range/continuous) instead of being treated as plain labels — same semantics as KTBNLearner.

Warning: A braced literal is ambiguous between this overload and the inferring one, since it could equally initialize either's fifth parameter. Name the type — std::unordered_set<std::string>{"C","D"} — or pass a named variable.

Definition at line 189 of file KTBNAdaptiveLearner_tpl.h.

                                                          {
    GUM_DESTRUCTOR(KTBNAdaptiveLearner)
  }

References KTBNAdaptiveLearner().

Here is the call graph for this function:

◆ KTBNAdaptiveLearner() [4/5]

template<GUM_Numeric GUM_SCALAR>

gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner ( const KTBNAdaptiveLearner< GUM_SCALAR > & )

privatedelete

References KTBNAdaptiveLearner().

Here is the call graph for this function:

◆ KTBNAdaptiveLearner() [5/5]

template<GUM_Numeric GUM_SCALAR>

gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner ( KTBNAdaptiveLearner< GUM_SCALAR > && )

privatedelete

References KTBNAdaptiveLearner().

Here is the call graph for this function:

Member Function Documentation

◆ _applyConfig_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_ ( KTBNLearner< GUM_SCALAR > & learner ) const

private

Apply the recorded score / algorithm / correction / prior onto a freshly-built learner. Only knobs that differ from their default are touched, and only those the chosen algorithm actually consumes (a score-based algo takes a score; MIIC takes a correction) — so an unconfigured learner is left at its defaults and no irrelevant setting can trip checkScorePriorCompatibility().

Definition at line 1151 of file KTBNAdaptiveLearner_tpl.h.

                                                                                                {
    // A fresh KTBNLearner already starts at the mirrored defaults (MIIC / BDeu /
    // MDL / NO_prior), so we only touch a knob when it differs from its default,
    // and only the knobs the chosen algorithm actually consumes.
    bool scoreBased = false;
    switch (_algo_) {
      case IBNLearner::AlgoType::MIIC :
        // MIIC is the default algo — nothing to set on a fresh learner. It uses a
        // correction (not a score); apply it only when it is not the default MDL.
        switch (_correction_) {
          case CorrectedMutualInformation::KModeTypes::NML : learner.useNMLCorrection(); break;
          case CorrectedMutualInformation::KModeTypes::NoCorr : learner.useNoCorrection(); break;
          case CorrectedMutualInformation::KModeTypes::MDL : break;   // default
        }
        break;
      case IBNLearner::AlgoType::GREEDY_HILL_CLIMBING :
        learner.useGreedyHillClimbing();
        scoreBased = true;
        break;
      case IBNLearner::AlgoType::EXTENDED_GREEDY_HILL_CLIMBING :
        learner.useExtendedGreedyHillClimbing();
        scoreBased = true;
        break;
      case IBNLearner::AlgoType::LOCAL_SEARCH_WITH_TABU_LIST :
        learner.useLocalSearchWithTabuList(_tabuSize_, _nbDecrease_);
        scoreBased = true;
        break;
      default : break;   // K2 / PC are never recorded by our setters
    }
 
    // score-based algos consume a score; apply it only when it is not the default BDeu
    if (scoreBased && _score_ != IBNLearner::ScoreType::BDeu) {
      switch (_score_) {
        case IBNLearner::ScoreType::AIC : learner.useScoreAIC(); break;
        case IBNLearner::ScoreType::BD : learner.useScoreBD(); break;
        case IBNLearner::ScoreType::BIC : learner.useScoreBIC(); break;
        case IBNLearner::ScoreType::LOG2LIKELIHOOD : learner.useScoreLog2Likelihood(); break;
        case IBNLearner::ScoreType::MDL : learner.useScoreMDL(); break;
        case IBNLearner::ScoreType::fNML : learner.useScorefNML(); break;
        default : break;   // BDeu (guarded out) and K2 (never recorded)
      }
    }
 
    // the prior feeds parameter estimation whatever the algorithm, so it is applied
    // independently of the score/correction split, again only when non-default
    if (_prior_ != IBNLearner::BNLearnerPriorType::NO_prior)
      learner.useSmoothingPrior(_priorWeight_);
  }

Referenced by learnKTBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _applyConstraints_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_	(	KTBNLearner< GUM_SCALAR > &	learner,
		Size	k ) const

private

Replay the recorded structural constraints onto learner (built for order k). Engine-name constraints whose slice does not fit k (slice >= k) are skipped for this candidate; the base-only intra-slice / all-slices constraints are handed to learner, which expands them for its own k. The allow-* flags and max-indegree are applied when non-default.

Definition at line 1201 of file KTBNAdaptiveLearner_tpl.h.

                                                                                                 {
    const int ik = static_cast< int >(k);
    // an engine-name endpoint fits candidate k iff its slice is < k (ATEMPORAL == -1
    // always fits); a constraint touching a slice this candidate does not have is
    // skipped for this k only.
    auto fits = [&](const std::string& node) { return _determineNode_(node).second < ik; };
 
    for (const auto& [tail, head]: _forbiddenArcs_)
      if (fits(tail) && fits(head)) learner.addForbiddenArc(tail, head);
    for (const auto& [tail, head]: _mandatoryArcs_)
      if (fits(tail) && fits(head)) learner.addMandatoryArc(tail, head);
    for (const auto& [tail, head]: _possibleEdges_)
      if (fits(tail) && fits(head)) learner.addPossibleEdge(tail, head);
    for (const auto& node: _noParentNodes_)
      if (fits(node)) learner.addNoParentNode(node);
    for (const auto& node: _noChildrenNodes_)
      if (fits(node)) learner.addNoChildrenNode(node);
 
    // kernel-relative arcs: resolve the lag against this candidate's kernel
    // slice (k-1) into an explicit (base, slice) arc. Always fits once k >=
    // _kMin_ (guaranteed by _raiseKMinForSlice_/_recomputeKMin_ above), but the
    // guard mirrors fits()'s defensive style above rather than assuming it.
    for (const auto& [tailBase, headBase, lag]: _forbiddenKernelArcs_) {
      const int tailSlice = ik - 1 - lag;
      if (tailSlice >= 0) learner.addForbiddenArc(tailBase, tailSlice, headBase, ik - 1);
    }
    for (const auto& [tailBase, headBase, lag]: _mandatoryKernelArcs_) {
      const int tailSlice = ik - 1 - lag;
      if (tailSlice >= 0) learner.addMandatoryArc(tailBase, tailSlice, headBase, ik - 1);
    }
 
    // base-only constraints: hand them to the fixed-k learner, which expands them
    // over its own slices (no manual expansion / no slice filtering needed here).
    for (const auto& [tailBase, headBase]: _forbiddenIntraSliceArcs_)
      learner.addForbiddenIntraSliceArc(tailBase, headBase);
    for (const auto& [tailBase, headBase]: _forbiddenArcsAllSlices_)
      learner.addForbiddenArcAllSlices(tailBase, headBase);
 
    // structural-search knobs, applied only when the user changed them from default
    if (!_allowAdditions_) learner.allowArcAdditions(false);
    if (!_allowDeletions_) learner.allowArcDeletions(false);
    if (!_allowReversals_) learner.allowArcReversals(false);
    if (_maxIndegree_ != std::numeric_limits< Size >::max()) learner.setMaxIndegree(_maxIndegree_);
  }

Referenced by learnKTBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _atemporalVarNames_()

template<GUM_Numeric GUM_SCALAR>

const std::unordered_set< std::string > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_atemporalVarNames_ ( ) const

overrideprivatevirtual

atemporal base names for IKTBNLearner's shared encode/_determineNode_; the set recorded at construction.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 1040 of file KTBNAdaptiveLearner_tpl.h.

                                                                   {
    return _atemporalVars_;
  }

References _atemporalVars_.

◆ _checkArcTemporallyFeasible_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::IKTBNLearner< GUM_SCALAR >::_checkArcTemporallyFeasible_	(	std::string_view	tail,
		std::string_view	head,
		std::string_view	action ) const

protectedinherited

Reject an arc the k-TBN definition can never contain, so eraseForbiddenArc and addMandatoryArc both fail early (before any internal learner is touched) with a uniform message. action is the verb phrase completing "cannot <action> <tail> -> <head>: ..." (e.g. "force the mandatory arc", "un-forbid the arc"). Two arcs are refused: a temporal -> atemporal arc (a time-varying variable can never parent a static one) and a backward-in-time arc (head strictly before tail).

Definition at line 95 of file IKTBNLearner_tpl.h.

                                                                                               {
      const int tailSlice = _determineNode_(std::string{tail}).second;
      const int headSlice = _determineNode_(std::string{head}).second;
      if (tailSlice != KTBN< GUM_SCALAR >::ATEMPORAL && headSlice == KTBN< GUM_SCALAR >::ATEMPORAL)
        GUM_ERROR(InvalidArgument,
                  "cannot " << action << " " << tail << " -> " << head
                            << ": a temporal variable can never be a parent of an atemporal one; "
                               "this constraint is part of the k-TBN definition")
      if (headSlice < tailSlice)
        GUM_ERROR(InvalidArgument,
                  "cannot " << action << " " << tail << " -> " << head
                            << ": its head is at an earlier time slice than its tail, which "
                               "violates temporal causality")
    }

References _determineNode_(), gum::KTBN< GUM_SCALAR >::ATEMPORAL, and GUM_ERROR.

Referenced by _isKnownBase_(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addMandatoryArc(), gum::learning::KTBNLearner< GUM_SCALAR >::addMandatoryArc(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenArc(), and gum::learning::KTBNLearner< GUM_SCALAR >::eraseForbiddenArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkBaseIsTemporal_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::IKTBNLearner< GUM_SCALAR >::_checkBaseIsTemporal_	(	std::string_view	base,
		std::string_view	context ) const

protectedinherited

Throw InvalidArgument unless base is a known temporal base. context completes "cannot appear in <context>" (e.g. "an intra-slice constraint", "a kernel-relative arc"): every caller rejects an atemporal base for the same underlying reason – it has no per-slice instance – so they share the sentence and vary the setting.

Definition at line 196 of file IKTBNLearner_tpl.h.

                                                                                         {
      const std::string b{base};
      if (!_isKnownBase_(b))
        GUM_ERROR(InvalidArgument,
                  "unknown base variable '" << base
                                            << "': it is not one of this learner's variables")
      if (_atemporalVarNames_().contains(b))
        GUM_ERROR(InvalidArgument,
                  "atemporal variable '" << base << "' cannot appear in " << context
                                         << ": it has no per-slice instance")
    }

References _atemporalVarNames_(), _isKnownBase_(), gum::contains(), and GUM_ERROR.

Referenced by _isKnownBase_(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_verifyKernelArc_(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addForbiddenIntraSliceArc(), gum::learning::KTBNLearner< GUM_SCALAR >::addForbiddenIntraSliceArc(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenIntraSliceArc(), and gum::learning::KTBNLearner< GUM_SCALAR >::eraseForbiddenIntraSliceArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkMinimalOrder_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_	(	Size	order,
		std::string_view	label )

staticprotectedinherited

Throw InvalidArgument unless order is at least 2, label naming the offending parameter ("k" for the fixed-k learner, "kMax" for the adaptive one).

This is a learner constraint, not a model one – gum::KTBN, gum::KTBNGenerator and gum::KTBNInference all accept k = 1 – which is why it lives here rather than on the model. Static because four of its call sites are themselves static helpers invoked from member-initialiser lists, before any object exists.

Definition at line 210 of file IKTBNLearner_tpl.h.

                                                                                         {
      if (order < 2)
        GUM_ERROR(InvalidArgument,
                  "a k-TBN learner requires "
                      << label << " >= 2: k=1 is a static Bayesian network, use BNLearner instead")
    }

References GUM_ERROR.

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::KTBNAdaptiveLearner(), gum::learning::KTBNLearner< GUM_SCALAR >::_buildPriorFromBN_(), gum::learning::KTBNLearner< GUM_SCALAR >::_buildPriorFromCSV_(), gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_inferAtemporalVars_(), gum::learning::KTBNLearner< GUM_SCALAR >::_inferAtemporalVars_(), and _isKnownBase_().

Here is the caller graph for this function:

◆ _countParameters_()

template<GUM_Numeric GUM_SCALAR>

double gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_countParameters_ ( const KTBN< GUM_SCALAR > & net ) const

private

Number of free parameters of net's template: summed over every template node (all initial slices, the kernel slice and the atemporal nodes), $(|X|-1)\prod_{P\in pa(X)}|P|$. This is the model-complexity term of the cross-k BIC and AIC scores used by learnKTBN(): it grows with $k$ (a higher order adds initial-slice CPTs and can widen the kernel), which is what offsets the monotonic likelihood gain and prevents always picking the largest $k$.

Definition at line 1470 of file KTBNAdaptiveLearner_tpl.h.

                                                                                                 {
    // Free parameters of the template: for each node, (|node| - 1) independent
    // entries per joint parent configuration. Summed over every template node
    // (initial slices, kernel slice, atemporal nodes), this is the k-TBN's total
    // parameter count — it rises with k, which is what the BIC penalty needs.
    double df = 0.0;
    for (const auto& [base, slice]: net.nodes()) {
      double cell = net.variable(base, slice).domainSize() - 1.0;
      for (const auto& [pbase, pslice]: net.parents(base, slice))
        cell *= net.variable(pbase, pslice).domainSize();
      df += cell;
    }
    return df;
  }

Referenced by _orderSelectionScore_().

Here is the caller graph for this function:

◆ _determineNode_()

template<GUM_Numeric GUM_SCALAR>

std::pair< std::string, int > gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_ ( const std::string & name ) const

protectedinherited

engine name -> (base, slice); atemporal names map to KTBN::ATEMPORAL. Shared by every learner; only the atemporal test varies (via atemporalVarNames()).

Definition at line 64 of file IKTBNLearner_tpl.h.

                                                                               {
      // check atemporal set first: a name registered as atemporal always maps
      // to ATEMPORAL, even if it syntactically looks like "base[t]"
      if (_atemporalVarNames_().contains(name)) return {name, KTBN< GUM_SCALAR >::ATEMPORAL};
 
      // syntactic parse: look for a trailing "[digits]" suffix
      const std::size_t bracketPos = name.rfind('[');
      if (bracketPos == std::string::npos) return {name, KTBN< GUM_SCALAR >::ATEMPORAL};
 
      const std::string_view bracketContent{name.c_str() + bracketPos + 1,
                                            name.size() - bracketPos - 1};
      if (bracketContent.empty() || bracketContent.back() != ']')
        return {name, KTBN< GUM_SCALAR >::ATEMPORAL};
 
      const std::string_view digits = bracketContent.substr(0, bracketContent.size() - 1);
      if (digits.empty()) return {name, KTBN< GUM_SCALAR >::ATEMPORAL};
      for (const char c: digits)
        if (std::isdigit(static_cast< unsigned char >(c)) == 0)
          return {name, KTBN< GUM_SCALAR >::ATEMPORAL};
 
      int slice{};
      try {
        slice = std::stoi(std::string{digits});
      } catch (const std::out_of_range&) {
        GUM_ERROR(InvalidArgument,
                  "Node name '" << name << "' has a slice index too large to represent as int.")
      }
      return {name.substr(0, bracketPos), slice};
    }

References _atemporalVarNames_(), gum::KTBN< GUM_SCALAR >::ATEMPORAL, gum::contains(), and GUM_ERROR.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _encode_()

template<GUM_Numeric GUM_SCALAR>

std::string gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_	(	std::string_view	base,
		int	slice ) const

protectedinherited

(base, slice) -> engine name ("A[1]" / atemporal engine name). Pure function, shared by every learner.

Definition at line 57 of file IKTBNLearner_tpl.h.

                                                                                       {
      if (slice == KTBN< GUM_SCALAR >::ATEMPORAL) return std::string{base};
      return std::string{base} + '[' + std::to_string(slice) + ']';
    }

References gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the caller graph for this function:

◆ _fNMLScore_()

template<GUM_Numeric GUM_SCALAR>

double gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_fNMLScore_ ( const KTBN< GUM_SCALAR > & net ) const

private

fNML order score of net over the recorded trajectories: $\log_2 L - \sum_i \sum_j \log_2 C^{r_i}_{N_{ij}}$, with $r_i$ the node's domain size and $N_{ij}$ the count for parent configuration $j$. Unlike BIC/AIC the penalty is data-dependent, so the regret needs the same per-instance walk as the likelihood — both are accumulated in one forEachScoredNode pass. Mirrors aGrUM's ScorefNML.

Definition at line 1444 of file KTBNAdaptiveLearner_tpl.h.

                                                                                           {
    // one data walk: per instance, accumulate log2L AND bucket the observation by
    // its parent configuration; per node, close over the buckets with the
    // multinomial parametric complexity log2Cnr, exactly the per-node regret term
    // aGrUM's ScorefNML subtracts. Fused (rather than a separate _log2Likelihood_
    // call plus a separate penalty pass) so fNML order-selection reads every
    // trajectory once per candidate k, not twice.
    double logL = 0.0, penalty = 0.0;
    _forEachScoredNode_(
        net,
        [&logL](auto& e) {
          logL += std::log2((*e.cpt)[e.inst]);
          // linear index over the parent dims (1..nbrDim-1); the node is dim 0
          Size idx = 0;
          for (Idx d = 1; d < e.cpt->nbrDim(); ++d)
            idx = idx * e.cpt->variable(d).domainSize() + e.inst.val(e.cpt->variable(d));
          e.counts[idx] += 1.0;
        },
        [this, &penalty](auto& e) {
          for (const auto& [cfg, n]: e.counts)
            penalty += _ctable_.log2Cnr(e.selfDom, n);
        });
    return logL - penalty;
  }

References _ctable_, and _forEachScoredNode_().

Referenced by _orderSelectionScore_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _forEachScoredNode_()

template<GUM_Numeric GUM_SCALAR>

template<typename PerInstance, typename PerNodeFinal>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_forEachScoredNode_	(	const KTBN< GUM_SCALAR > &	net,
		PerInstance	perInstance,
		PerNodeFinal	perNodeFinal ) const

private

Stream every scored template-node instance of net over the recorded trajectories, driving both the likelihood and the fNML penalty off one data walk, so the width-k window logic lives in one place.

Each trajectory is streamed row by row through a width-k circular buffer (absolute time t at slot t % k): every temporal node X[t] is visited against net's template CPT for slice min(t, k-1), reading each parent from row t - lag; atemporal nodes are visited once per trajectory. perInstance runs once per instance with the observed labels loaded into e.inst; perNodeFinal runs once per template node after the stream, for criteria reducing accumulated per-node state (e.g. fNML's regret).

Definition at line 1253 of file KTBNAdaptiveLearner_tpl.h.

                                                                                               {
    namespace fs = std::filesystem;
    const int k  = static_cast< int >(net.k());
 
    // Precomputed scorer for one template node, reused across every row of
    // every trajectory so the inner loop never rebuilds an Instantiation
    // (~3.7x the cost of one chgVal) or re-decodes a variable name. selfDom /
    // counts carry the accumulator a reduction criterion (fNML) closes over
    // in perNodeFinal; likelihood-style reductions ignore them.
    struct NodeEval {
      const Tensor< GUM_SCALAR >*                  cpt;
      Instantiation                                inst;      // slaved to *cpt
      std::vector< std::string >                   dimName;   // cpt.variable(d).name()
      std::vector< std::pair< std::string, int > > dimNode;   // _determineNode_(name)
      Size                                         selfDom;   // |node| (CPT dim 0 is the node)
      std::unordered_map< Size, double >           counts;    // parent-config index -> #obs
    };
 
    auto makeEval = [&](const Tensor< GUM_SCALAR >& cpt) {
      NodeEval e;
      e.cpt     = &cpt;
      e.inst    = Instantiation(cpt);
      e.selfDom = cpt.variable(0).domainSize();   // the node varies fastest (dim 0)
      e.dimName.reserve(cpt.nbrDim());
      e.dimNode.reserve(cpt.nbrDim());
      for (Idx d = 0; d < cpt.nbrDim(); ++d) {
        std::string name = cpt.variable(d).name();
        e.dimNode.push_back(_determineNode_(name));
        e.dimName.push_back(std::move(name));
      }
      return e;
    };
 
    // one evaluator per (temporal base, slice), indexed by slice in 0..k-1: the
    // node scored at absolute time t uses slice min(t, k-1) (see childSlice below)
    const auto&                            temporalBases = net.temporalVarNames();
    std::vector< std::vector< NodeEval > > temporalEvals(k);
    for (int slice = 0; slice < k; ++slice) {
      temporalEvals[slice].reserve(temporalBases.size());
      for (const auto& base: temporalBases)
        temporalEvals[slice].push_back(makeEval(net.cpt(base, slice)));
    }
 
    // one evaluator per atemporal node (scored once per trajectory)
    std::vector< NodeEval > atemporalEvals;
    atemporalEvals.reserve(net.atemporalVarNames().size());
    for (const auto& base: net.atemporalVarNames())
      atemporalEvals.push_back(makeEval(net.cpt(base, KTBN< GUM_SCALAR >::ATEMPORAL)));
 
    // one circular buffer of k rows, reused across trajectories: the row for
    // absolute time t lives at slot (t % k), so the k live rows never move —
    // reading a new row overwrites the stalest slot (which held time t-k).
    std::vector< std::vector< std::string > > window(k);
 
    // missing-value markers, as a set for O(1) tests in the inner loop
    const std::unordered_set< std::string > missing(_missingSymbols_.begin(),
                                                    _missingSymbols_.end());
 
    for (Size s = 0; s < _nbSamples_; ++s) {
      const fs::path file = fs::path{_dirPath_} / (_csvBaseName_ + std::to_string(s + 1) + ".csv");
 
      // ---- pre-pass: column index, and the atemporal values of this trajectory ----
      // An atemporal variable is constant down the file, but the row that
      // happens to carry a missing marker teaches nothing, so its value is the
      // first *informative* one rather than row 0's. The scan stops as soon as
      // every atemporal column is resolved (row 0 in the usual case), so it
      // costs one row unless the data actually has holes. It cannot be folded
      // into the main pass: a value resolved at row 12 must already be known
      // when row 0 is scored, and buffering the rows instead would defeat the
      // width-k window that bounds this function's memory.
      std::unordered_map< std::string, std::size_t > colOf;
      std::unordered_map< std::string, std::string > atempVal;
      {
        std::ifstream pis(file, std::ifstream::in);
        if (!pis.is_open()) GUM_ERROR(IOError, "Cannot open " << file.string())
        CSVParser pre(pis, file.string());
        if (!pre.next()) GUM_ERROR(IOError, "empty trajectory file '" << file.string() << "'") {
            const auto& header = pre.current();
            for (std::size_t c = 0; c < header.size(); ++c)
              colOf[header[c]] = c;
          }
        const std::size_t nbAtemp = net.atemporalVarNames().size();
        while (atempVal.size() < nbAtemp && pre.next()) {
          const auto& row = pre.current();
          for (const auto& c: net.atemporalVarNames()) {
            if (atempVal.contains(c)) continue;
            const std::string& tok = row[colOf.at(c)];
            if (!missing.contains(tok)) atempVal[c] = tok;
          }
        }
      }
 
      std::ifstream is(file, std::ifstream::in);
      if (!is.is_open()) GUM_ERROR(IOError, "Cannot open " << file.string())
      CSVParser parser(is, file.string());
      parser.next();   // skip the header, already consumed by the pre-pass
 
      // Label observed in the data for one CPT dimension (varBase, varSlice) —
      // the scored node itself or one of its parents — while scoring the node
      // whose template slice is scoredSlice at absolute time scoredTime.
      // Returns nullptr when the value is missing (or, for an atemporal
      // variable, never observed in this trajectory); the caller then drops the
      // whole instance. A pointer rather than a value: both sources are stable
      // strings, and this is the innermost loop of the order selection.
      auto labelOf = [&](const std::string& varBase,
                         int                varSlice,
                         int                scoredTime,
                         int                scoredSlice) -> const std::string* {
        // atemporal variable: constant down the trajectory, read the captured value
        if (varSlice == KTBN< GUM_SCALAR >::ATEMPORAL) {
          const auto it = atempVal.find(varBase);
          return (it == atempVal.end()) ? nullptr : &it->second;
        }
        // temporal variable: it lags (scoredSlice - varSlice) steps behind the
        // scored node, so its value was observed at that earlier absolute time
        const int varTime = scoredTime - (scoredSlice - varSlice);
        // fetch that row from the circular buffer (slot = time modulo k)
        const std::string& tok = window[varTime % k][colOf.at(varBase)];
        return missing.contains(tok) ? nullptr : &tok;
      };
 
      int t = 0;   // absolute time == data-row index
      while (parser.next()) {
        const auto& cur = parser.current();
        window[t % k].assign(cur.begin(), cur.end());
 
        // first k-1 slices use their own initial CPT; from slice k-1 on the
        // transition kernel (template slice k-1) is reused for every step
        const int childSlice = (t < k - 1) ? t : (k - 1);
        for (NodeEval& e: temporalEvals[childSlice]) {
          // an instance counts only if its WHOLE family is observed: the node
          // and every parent, each read at its own lag. One missing value drops
          // this instance alone — the other nodes of the same row are unaffected.
          bool complete = true;
          for (std::size_t d = 0; d < e.dimName.size(); ++d) {
            const auto& [vbase, vslice] = e.dimNode[d];
            const std::string* lbl      = labelOf(vbase, vslice, t, childSlice);
            if (lbl == nullptr) {
              complete = false;
              break;
            }
            e.inst.chgVal(e.dimName[d], *lbl);
          }
          if (complete) perInstance(e);
        }
        ++t;
      }
 
      // atemporal nodes: scored once per trajectory (parents are atemporal too).
      // An atemporal column left unresolved by the pre-pass drops every instance
      // that reads it, here and in the temporal loop above — for THIS trajectory
      // only, the others still scoring normally.
      if (t > 0)
        for (NodeEval& e: atemporalEvals) {
          bool complete = true;
          for (std::size_t d = 0; d < e.dimName.size(); ++d) {
            const auto it = atempVal.find(e.dimNode[d].first);
            if (it == atempVal.end()) {
              complete = false;
              break;
            }
            e.inst.chgVal(e.dimName[d], it->second);
          }
          if (complete) perInstance(e);
        }
    }
 
    // per-node closing pass over every evaluator (all slices + atemporal), for
    // criteria that reduce the accumulated per-node state after the whole walk
    for (auto& slice: temporalEvals)
      for (NodeEval& e: slice)
        perNodeFinal(e);
    for (NodeEval& e: atemporalEvals)
      perNodeFinal(e);
  }

References gum::Instantiation::Instantiation(), _csvBaseName_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _dirPath_, _missingSymbols_, _nbSamples_, gum::KTBN< GUM_SCALAR >::ATEMPORAL, gum::learning::CSVParser::current(), GUM_ERROR, and gum::learning::CSVParser::next().

Referenced by _fNMLScore_(), and _log2Likelihood_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _inferAtemporalVars_()

template<GUM_Numeric GUM_SCALAR>

std::unordered_set< std::string > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_inferAtemporalVars_	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		Size	kMax,
		const std::vector< std::string > &	missingSymbols )

staticprivate

checks kMax >= 2 and nbSamples >= 1, then delegates to the shared IKTBNLearner::scanConstantColumns(). Called from the atemporal-inferring constructor's member-initialiser list, before this object exists, so the checks live here rather than in the body — otherwise a bad argument would only surface after a wasted scan.

Definition at line 143 of file KTBNAdaptiveLearner_tpl.h.

                                                    {
    IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(kMax, "kMax");
    if (nbSamples < 1) GUM_ERROR(InvalidArgument, "KTBNAdaptiveLearner requires nbSamples >= 1")
    return IKTBNLearner< GUM_SCALAR >::_scanConstantColumns_(dirPath,
                                                             csvBaseName,
                                                             nbSamples,
                                                             missingSymbols);
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(), gum::learning::IKTBNLearner< GUM_SCALAR >::_scanConstantColumns_(), GUM_ERROR, and kMax().

Referenced by KTBNAdaptiveLearner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _isKnownBase_()

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_isKnownBase_ ( std::string_view base ) const

overrideprivatevirtual

whether base is one of this learner's variables; the base names read at construction, from the CSV header or the schema BN.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 1045 of file KTBNAdaptiveLearner_tpl.h.

                                                                                 {
    return _baseNames_.contains(std::string{base});
  }

References _baseNames_.

◆ _log2Likelihood_()

template<GUM_Numeric GUM_SCALAR>

double gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_log2Likelihood_ ( const KTBN< GUM_SCALAR > & net ) const

private

Factorized log2-likelihood of net over the recorded trajectories, comparable across candidate k (the raw score types are not: their flattened tables differ from one k to another). The data is complete, so this is a closed-form sum of CPT lookups — no inference. A thin reduction over forEachScoredNode that sums log2 of the CPT entry over every visited node instance.

Definition at line 1432 of file KTBNAdaptiveLearner_tpl.h.

                                                                                                {
    // sum log2 of the CPT entry over every visited node instance; no per-node
    // closing reduction is needed (the likelihood is fully additive per instance)
    double logL = 0.0;
    _forEachScoredNode_(
        net,
        [&logL](auto& e) { logL += std::log2((*e.cpt)[e.inst]); },
        [](auto&) {});
    return logL;
  }

References _forEachScoredNode_().

Referenced by _orderSelectionScore_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _orderSelectionScore_()

template<GUM_Numeric GUM_SCALAR>

double gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_orderSelectionScore_	(	const KTBN< GUM_SCALAR > &	net,
		double	logN ) const

private

The cross-k order-selection score of net under the recorded orderScore criterion, given logN = log2 of the sample size. The single dispatch point learnKTBN() uses to compare candidates; add a branch here for each new OrderScoreType.

Definition at line 1486 of file KTBNAdaptiveLearner_tpl.h.

                                                                                     {
    // BIC/AIC share a log2-likelihood term plus a data-free parameter-count
    // penalty, so both read the trajectories once via _log2Likelihood_. fNML
    // needs the likelihood too, but paired with a data-dependent per-node regret
    // over the very same walk, so it is fused into a single _forEachScoredNode_
    // pass (_fNMLScore_) instead of calling _log2Likelihood_ a second time.
    switch (_orderScore_) {
      case OrderScoreType::BIC :
        // reward fit, penalise complexity: log2L − ½·df·log2(N)
        return _log2Likelihood_(net) - 0.5 * _countParameters_(net) * logN;
      case OrderScoreType::AIC :
        // lighter, sample-size-independent penalty: log2L − df
        return _log2Likelihood_(net) - _countParameters_(net);
      case OrderScoreType::fNML :
        // per-node multinomial parametric complexity (regret): log2L − Σ log2Cnr
        return _fNMLScore_(net);
    }
    // every criterion returns above; unreachable while OrderScoreType is exhausted
    return _log2Likelihood_(net) - 0.5 * _countParameters_(net) * logN;
  }

References _countParameters_(), _fNMLScore_(), _log2Likelihood_(), _orderScore_, AIC, BIC, and fNML.

Referenced by learnKTBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _raiseKMinForSlice_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_raiseKMinForSlice_ ( int slice )

private

Raise kMin, if needed, so that kMin > slice: a smaller candidate would silently drop a constraint naming that slice (the "slice < k" rule applyConstraints's fits() filter uses). O(1), since adding a constraint can only push kMin up. No-op for KTBN::ATEMPORAL.

Definition at line 1106 of file KTBNAdaptiveLearner_tpl.h.

                                                                       {
    if (slice != KTBN< GUM_SCALAR >::ATEMPORAL)
      _kMin_ = std::max(_kMin_, static_cast< Size >(slice) + 1);
  }

References _kMin_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Referenced by _recomputeKMin_(), addForbiddenArc(), addForbiddenKernelArc(), addMandatoryArc(), addMandatoryKernelArc(), addNoChildrenNode(), addNoParentNode(), and addPossibleEdge().

Here is the caller graph for this function:

◆ _recomputeKMin_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_recomputeKMin_ ( )

private

Recompute kMin from scratch: max(2, 1 + the largest concrete slice named by any recorded forbidden/mandatory arc, possible edge, or no-parent/no-children node (the kinds fits() can drop). Intra-slice / all-slices constraints carry no slice and are excluded. Unlike raiseKMinForSlice, an erase can lower kMin with no O(1) way to tell, so every erase* setter runs this full rescan instead.

Definition at line 1112 of file KTBNAdaptiveLearner_tpl.h.

                                                          {
    // kMin = 1 + the largest recorded slice (fits()'s "slice < k" rule means a
    // smaller k would drop that constraint). An erase can lower kMin, unlike a
    // single _raiseKMinForSlice_ call, so this rebuilds from scratch rather
    // than adjusting in place.
    _kMin_ = 2;
    for (const auto& [tail, head]: _forbiddenArcs_) {
      _raiseKMinForSlice_(_determineNode_(tail).second);
      _raiseKMinForSlice_(_determineNode_(head).second);
    }
    for (const auto& [tail, head]: _mandatoryArcs_) {
      _raiseKMinForSlice_(_determineNode_(tail).second);
      _raiseKMinForSlice_(_determineNode_(head).second);
    }
    for (const auto& [tail, head]: _possibleEdges_) {
      _raiseKMinForSlice_(_determineNode_(tail).second);
      _raiseKMinForSlice_(_determineNode_(head).second);
    }
    for (const auto& node: _noParentNodes_)
      _raiseKMinForSlice_(_determineNode_(node).second);
    for (const auto& node: _noChildrenNodes_)
      _raiseKMinForSlice_(_determineNode_(node).second);
    // kernel-relative arcs: the lag itself is what must fit (the head's slice is
    // always the kernel k-1, which trivially fits any k), so raise on the lag
    // directly rather than decoding an engine name that doesn't exist yet.
    for (const auto& t: _forbiddenKernelArcs_)
      _raiseKMinForSlice_(std::get< 2 >(t));
    for (const auto& t: _mandatoryKernelArcs_)
      _raiseKMinForSlice_(std::get< 2 >(t));
    // _forbiddenIntraSliceArcs_ / _forbiddenArcsAllSlices_ carry no slice (they
    // are base-name pairs, expanded per-k by the fixed-k learner) and so are
    // left out: they never make a candidate drop anything, whatever k is.
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _forbiddenArcs_, _forbiddenKernelArcs_, _kMin_, _mandatoryArcs_, _mandatoryKernelArcs_, _noChildrenNodes_, _noParentNodes_, _possibleEdges_, and _raiseKMinForSlice_().

Referenced by eraseForbiddenArc(), eraseForbiddenKernelArc(), eraseMandatoryArc(), eraseMandatoryKernelArc(), eraseNoChildrenNode(), eraseNoParentNode(), and erasePossibleEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _scanConstantColumns_()

template<GUM_Numeric GUM_SCALAR>

std::unordered_set< std::string > gum::learning::IKTBNLearner< GUM_SCALAR >::_scanConstantColumns_	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		const std::vector< std::string > &	missingSymbols )

staticprotectedinherited

Scans every trajectory and returns the base names classified atemporal: those whose value never changes across the rows of a single trajectory (checked independently per trajectory, so the value may still differ between trajectories). Shared by every atemporal-inferring CSV constructor (KTBNLearner, KTBNAdaptiveLearner): identical scanning logic regardless of which subclass calls it, so duplicating it per subclass would only invite the two copies to drift. Callers are responsible for validating their own arguments (e.g. k/kMax >= 2) before calling this — it does no such check itself, only opens files, so a bad argument would otherwise only be caught after a wasted scan.

Column indices still "live" (not yet proven non-constant) are tracked as a shrinking list rather than rescanned from scratch, and scanning stops opening further trajectories once that list is empty — falsification is one-way, so nothing left to test can ever become atemporal again.

Definition at line 113 of file IKTBNLearner_tpl.h.

                                                      {
      namespace fs = std::filesystem;
      const fs::path                          dir{dirPath};
      const std::string                       stem{csvBaseName};
      const std::unordered_set< std::string > missing(missingSymbols.begin(), missingSymbols.end());
 
      std::vector< std::string > header;       // captured from trajectory 1
      std::vector< std::size_t > candidates;   // column indices not yet falsified; shrinks only
      std::vector< std::string > firstSeen;   // per column: first non-missing value THIS trajectory
      std::vector< bool >
          haveFirstSeen;   // per column: whether firstSeen[c] is set THIS trajectory
 
      for (Size i = 0; i < nbSamples; ++i) {
        // once every column has been falsified, nothing left to test can
        // ever become atemporal again, so remaining trajectories are never
        // even opened. Not part of the for-condition: `candidates` does not
        // exist yet before trajectory 1 populates it.
        if (i > 0 && candidates.empty()) break;
 
        const fs::path file = dir / (stem + std::to_string(i + 1) + ".csv");
        std::ifstream  is(file, std::ifstream::in);
        if (!is.is_open()) GUM_ERROR(IOError, "Cannot open " << file.string());
 
        CSVParser parser(is, file.string());
        parser.next();
        const auto& raw = parser.current();
 
        if (i == 0) {
          header.assign(raw.begin(), raw.end());
          candidates.resize(header.size());
          std::iota(candidates.begin(), candidates.end(), std::size_t{0});
        } else {
          bool same = (raw.size() == header.size());
          for (std::size_t c = 0; same && c < header.size(); ++c)
            same = (raw[c] == header[c]);
          if (!same)
            GUM_ERROR(InvalidArgument,
                      "Header of " << file.string() << " differs from trajectory 1");
        }
 
        haveFirstSeen.assign(header.size(), false);
        firstSeen.assign(header.size(), {});
 
        while (parser.next()) {
          const auto& tokens = parser.current();
          if (tokens.size() != header.size())
            GUM_ERROR(InvalidArgument,
                      "Trajectory " << (i + 1) << ", row " << parser.nbLine() << ": expected "
                                    << header.size() << " columns, got " << tokens.size());
          // iterate only the still-live candidates, swap-erasing any just
          // falsified so later rows (and later trajectories) never revisit it
          for (std::size_t idx = 0; idx < candidates.size();) {
            const std::size_t c = candidates[idx];
            if (missing.contains(tokens[c])) {
              ++idx;   // uninformative row for this column, still a candidate
              continue;
            }
            if (!haveFirstSeen[c]) {
              firstSeen[c]     = tokens[c];
              haveFirstSeen[c] = true;
              ++idx;
            } else if (tokens[c] != firstSeen[c]) {
              candidates[idx] = candidates.back();   // falsified: drop, O(1)
              candidates.pop_back();
            } else {
              ++idx;
            }
          }
          if (candidates.empty()) break;   // nothing left to test in this file either
        }
      }
 
      std::unordered_set< std::string > atemporalVars;
      for (const std::size_t c: candidates)
        atemporalVars.insert(header[c]);
      return atemporalVars;
    }

References gum::learning::CSVParser::current(), GUM_ERROR, gum::learning::CSVParser::nbLine(), and gum::learning::CSVParser::next().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_inferAtemporalVars_(), gum::learning::KTBNLearner< GUM_SCALAR >::_inferAtemporalVars_(), and _isKnownBase_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _verifyBase_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_verifyBase_	(	std::string_view	base,
		int	slice ) const

private

Throw InvalidArgument unless base is a known base variable and slice is valid for it: base must be in baseNames; an atemporal base requires slice == KTBN::ATEMPORAL, a temporal one requires slice in [0, kMax). Used by the constraint setters to reject unknown names / out-of-range slices eagerly.

Definition at line 1054 of file KTBNAdaptiveLearner_tpl.h.

                                                                                           {
    if (!_baseNames_.contains(std::string{base}))
      GUM_ERROR(InvalidArgument,
                "unknown base variable '" << base << "': it is not one of the data columns")
    // an atemporal variable's only valid slice is ATEMPORAL; reject eagerly
    // rather than recording e.g. "C[1]" and failing later at learnKTBN() time
    if (_atemporalVars_.contains(std::string{base})) {
      if (slice != KTBN< GUM_SCALAR >::ATEMPORAL)
        GUM_ERROR(InvalidArgument,
                  "atemporal variable '" << base << "' cannot be given a time slice (got " << slice
                                         << "): use KTBN::ATEMPORAL")
      return;
    }
    // temporal: valid slices are [0, kMax). A negative value other than
    // ATEMPORAL must be caught here -- _encode_ would turn it into "X[-5]",
    // which reads back as atemporal and slips past the slice-fit rule.
    if (slice != KTBN< GUM_SCALAR >::ATEMPORAL && slice < 0)
      GUM_ERROR(InvalidArgument,
                "negative time slice " << slice << " for '" << base
                                       << "': slices start at 0 (use KTBN::ATEMPORAL to address an "
                                          "atemporal variable)")
    if (slice >= static_cast< int >(_kMax_))
      GUM_ERROR(InvalidArgument,
                "time slice " << slice << " for '" << base
                              << "' is out of range: it must be < kMax (" << _kMax_ << ")")
  }

References _atemporalVars_, _baseNames_, _kMax_, gum::KTBN< GUM_SCALAR >::ATEMPORAL, and GUM_ERROR.

Referenced by addForbiddenArc(), addForbiddenArc(), addForbiddenArcAllSlices(), addMandatoryArc(), addMandatoryArc(), addNoChildrenNode(), addNoChildrenNode(), addNoParentNode(), addNoParentNode(), addPossibleEdge(), addPossibleEdge(), eraseForbiddenArc(), eraseForbiddenArc(), eraseForbiddenArcAllSlices(), eraseMandatoryArc(), eraseMandatoryArc(), eraseNoChildrenNode(), eraseNoChildrenNode(), eraseNoParentNode(), eraseNoParentNode(), erasePossibleEdge(), and erasePossibleEdge().

Here is the caller graph for this function:

◆ _verifyKernelArc_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_verifyKernelArc_	(	std::string_view	tailBase,
		std::string_view	headBase,
		int	lag ) const

private

Throw InvalidArgument unless tailBase and headBase are known, temporal base variables (a kernel-relative arc has no meaning for an atemporal one: it has no kernel-slice instance) and lag is in [0, kMax) — so some candidate k in [2,kMax] can place tailBase at slice k-1-lag >= 0 and headBase at the kernel slice k-1. Used by the four kernel-arc setters (add/eraseForbiddenKernelArc, add/eraseMandatoryKernelArc) to reject bad calls eagerly.

Definition at line 1082 of file KTBNAdaptiveLearner_tpl.h.

                                                                                        {
    // an atemporal variable has a single instance, not a per-slice one, so it
    // has no kernel slice to anchor a lag against: same rule as the intra-slice
    // setters, hence the same shared check
    for (const std::string_view base: {tailBase, headBase})
      _checkBaseIsTemporal_(base, "a kernel-relative arc");
    // lag < 0 would place the tail AFTER the kernel slice (the last slice by
    // definition), which can never happen
    if (lag < 0) GUM_ERROR(InvalidArgument, "negative kernel lag " << lag << ": lag must be >= 0")
    // some candidate k in [2,kMax] must be able to place the tail at slice
    // k-1-lag >= 0, i.e. lag <= k-1 <= kMax-1
    if (lag >= static_cast< int >(_kMax_))
      GUM_ERROR(InvalidArgument,
                "kernel lag " << lag << " is out of range: it must be < kMax (" << _kMax_
                              << "), so some candidate k can place the tail at slice k-1-lag >= 0")
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkBaseIsTemporal_(), _kMax_, and GUM_ERROR.

Referenced by addForbiddenKernelArc(), addMandatoryKernelArc(), eraseForbiddenKernelArc(), and eraseMandatoryKernelArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addForbiddenArc	(	std::string_view	tailBase,
		int	tailSlice,
		std::string_view	headBase,
		int	headSlice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 673 of file KTBNAdaptiveLearner_tpl.h.

                                                                                     {
    // validate before _encode_ flattens the slice (a negative one would
    // silently read back as atemporal, losing the real error)
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    return addForbiddenArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and addForbiddenArc().

Here is the call graph for this function:

◆ addForbiddenArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addForbiddenArc	(	std::string_view	tailNode,
		std::string_view	headNode )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 656 of file KTBNAdaptiveLearner_tpl.h.

                                                                                  {
    const auto [tailBase, tailSlice] = _determineNode_(std::string{tailNode});
    const auto [headBase, headSlice] = _determineNode_(std::string{headNode});
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    _forbiddenArcs_.emplace(std::string{tailNode}, std::string{headNode});
    // no _checkArcTemporallyFeasible_ call on this path (forbidding an
    // already-impossible backward arc is a harmless no-op), so head is not
    // guaranteed >= tail here: both slices must be checked.
    _raiseKMinForSlice_(tailSlice);
    _raiseKMinForSlice_(headSlice);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _forbiddenArcs_, _raiseKMinForSlice_(), and _verifyBase_().

Referenced by addForbiddenArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenArcAllSlices()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addForbiddenArcAllSlices	(	std::string_view	tailBase,
		std::string_view	headBase )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 850 of file KTBNAdaptiveLearner_tpl.h.

                                                                                           {
    _verifyBase_(tailBase, KTBN< GUM_SCALAR >::ATEMPORAL);
    _verifyBase_(headBase, KTBN< GUM_SCALAR >::ATEMPORAL);
    // record the base pair; learnKTBN() expands it over every causally-possible
    // slice pair for each candidate k (k is not fixed here)
    _forbiddenArcsAllSlices_.emplace(std::string{tailBase}, std::string{headBase});
    return *this;
  }

References _forbiddenArcsAllSlices_, _verifyBase_(), and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ addForbiddenIntraSliceArc()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addForbiddenIntraSliceArc	(	std::string_view	tailBase,
		std::string_view	headBase )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 823 of file KTBNAdaptiveLearner_tpl.h.

                                                                                            {
    // these constraints carry no single slice, so no slice range is checked;
    // an atemporal base has no intra-slice position and is rejected eagerly
    // here, where KTBNLearner would throw at its own setter (expanding to "C[t]")
    _checkBaseIsTemporal_(tailBase, "an intra-slice constraint");
    _checkBaseIsTemporal_(headBase, "an intra-slice constraint");
    // record the base pair; unlike KTBNLearner it cannot be expanded per-slice
    // now (k is not fixed) — learnKTBN() expands it for each candidate k
    _forbiddenIntraSliceArcs_.emplace(std::string{tailBase}, std::string{headBase});
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkBaseIsTemporal_(), and _forbiddenIntraSliceArcs_.

Here is the call graph for this function:

◆ addForbiddenKernelArc()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addForbiddenKernelArc	(	std::string_view	tailBase,
		int	lag,
		std::string_view	headBase )

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Definition at line 776 of file KTBNAdaptiveLearner_tpl.h.

                                                                                        {
    _verifyKernelArc_(tailBase, headBase, lag);
    _forbiddenKernelArcs_.emplace(std::string{tailBase}, std::string{headBase}, lag);
    _raiseKMinForSlice_(lag);
    return *this;
  }

References _forbiddenKernelArcs_, _raiseKMinForSlice_(), and _verifyKernelArc_().

Here is the call graph for this function:

◆ addMandatoryArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addMandatoryArc	(	std::string_view	tailBase,
		int	tailSlice,
		std::string_view	headBase,
		int	headSlice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 731 of file KTBNAdaptiveLearner_tpl.h.

                                                                                     {
    // validate before _encode_ flattens the slice (a negative one would
    // silently read back as atemporal, losing the real error)
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    return addMandatoryArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and addMandatoryArc().

Here is the call graph for this function:

◆ addMandatoryArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addMandatoryArc	(	std::string_view	tailNode,
		std::string_view	headNode )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 713 of file KTBNAdaptiveLearner_tpl.h.

                                                                                  {
    const auto [tailBase, tailSlice] = _determineNode_(std::string{tailNode});
    const auto [headBase, headSlice] = _determineNode_(std::string{headNode});
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    // a mandatory arc must be feasible: reject up front the arcs the k-TBN can
    // never contain (same check KTBNLearner::addMandatoryArc runs)
    this->_checkArcTemporallyFeasible_(tailNode, headNode, "force the mandatory arc");
    _mandatoryArcs_.emplace(std::string{tailNode}, std::string{headNode});
    // the feasibility check above just rejected headSlice < tailSlice, so
    // headSlice >= tailSlice is guaranteed here: it alone determines _kMin_.
    _raiseKMinForSlice_(headSlice);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkArcTemporallyFeasible_(), gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _mandatoryArcs_, _raiseKMinForSlice_(), and _verifyBase_().

Referenced by addMandatoryArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addMandatoryKernelArc()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addMandatoryKernelArc	(	std::string_view	tailBase,
		int	lag,
		std::string_view	headBase )

Force an arc from tailBase, lag slices before the kernel, to headBase in the kernel. See addForbiddenKernelArc for the (base, slice) vs. kernel-relative distinction; the validity constraints (lag range, temporal bases, kMin effect) are the same. Always temporally feasible by construction (lag >= 0 guarantees headSlice = k-1 >= k-1-lag = tailSlice), so unlike the plain addMandatoryArc there is no separate feasibility check to run.

Definition at line 798 of file KTBNAdaptiveLearner_tpl.h.

                                                                                        {
    _verifyKernelArc_(tailBase, headBase, lag);
    // no separate feasibility check: lag >= 0 (just verified) already guarantees
    // headSlice = k-1 >= k-1-lag = tailSlice for every candidate, so this can
    // never be a backward-in-time arc (see addMandatoryKernelArc's doc comment)
    _mandatoryKernelArcs_.emplace(std::string{tailBase}, std::string{headBase}, lag);
    _raiseKMinForSlice_(lag);
    return *this;
  }

References _mandatoryKernelArcs_, _raiseKMinForSlice_(), and _verifyKernelArc_().

Here is the call graph for this function:

◆ addNoChildrenNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addNoChildrenNode	(	std::string_view	base,
		int	slice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 908 of file KTBNAdaptiveLearner_tpl.h.

                                                                                         {
    // validate before _encode_ flattens the slice (see the arc overloads above)
    _verifyBase_(base, slice);
    return addNoChildrenNode(_encode_(base, slice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and addNoChildrenNode().

Referenced by addNoChildrenNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addNoChildrenNode() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addNoChildrenNode ( std::string_view name )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 916 of file KTBNAdaptiveLearner_tpl.h.

                                                                              {
    const auto [base, slice] = _determineNode_(std::string{name});
    _verifyBase_(base, slice);
    _noChildrenNodes_.insert(std::string{name});
    _raiseKMinForSlice_(slice);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _noChildrenNodes_, _raiseKMinForSlice_(), and _verifyBase_().

Here is the call graph for this function:

◆ addNoParentNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addNoParentNode	(	std::string_view	base,
		int	slice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 872 of file KTBNAdaptiveLearner_tpl.h.

                                                                                       {
    // validate before _encode_ flattens the slice (see the arc overloads above)
    _verifyBase_(base, slice);
    return addNoParentNode(_encode_(base, slice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and addNoParentNode().

Referenced by addNoParentNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addNoParentNode() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addNoParentNode ( std::string_view name )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 880 of file KTBNAdaptiveLearner_tpl.h.

                                                                            {
    const auto [base, slice] = _determineNode_(std::string{name});
    _verifyBase_(base, slice);
    _noParentNodes_.insert(std::string{name});
    _raiseKMinForSlice_(slice);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _noParentNodes_, _raiseKMinForSlice_(), and _verifyBase_().

Here is the call graph for this function:

◆ addPossibleEdge() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addPossibleEdge	(	std::string_view	tail,
		std::string_view	head )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 957 of file KTBNAdaptiveLearner_tpl.h.

                                                                              {
    const auto [tailBase, tailSlice] = _determineNode_(std::string{tail});
    const auto [headBase, headSlice] = _determineNode_(std::string{head});
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    // an edge is undirected (BNLearner stores it as a gum::Edge), so the pair is
    // normalized alphabetically: (A,B) and (B,A) are one and the same record
    std::string first{tail}, second{head};
    if (second < first) std::swap(first, second);
    _possibleEdges_.emplace(std::move(first), std::move(second));
    // an edge is undirected and unchecked, so neither slice dominates: both
    // must be checked (tailSlice/headSlice, decoded above the swap, are
    // unaffected by it).
    _raiseKMinForSlice_(tailSlice);
    _raiseKMinForSlice_(headSlice);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _possibleEdges_, _raiseKMinForSlice_(), and _verifyBase_().

Here is the call graph for this function:

◆ addPossibleEdge() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::addPossibleEdge	(	std::string_view	tailBase,
		int	tailSlice,
		std::string_view	headBase,
		int	headSlice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 944 of file KTBNAdaptiveLearner_tpl.h.

                                                                                     {
    // validate before _encode_ flattens the slice (a negative one would
    // silently read back as atemporal, losing the real error)
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    return addPossibleEdge(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and addPossibleEdge().

Referenced by addPossibleEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allowArcAdditions()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::allowArcAdditions ( bool allow = true )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 1008 of file KTBNAdaptiveLearner_tpl.h.

                                                                     {
    _allowAdditions_ = allow;
    return *this;
  }

References _allowAdditions_.

◆ allowArcDeletions()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::allowArcDeletions ( bool allow = true )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 1015 of file KTBNAdaptiveLearner_tpl.h.

                                                                     {
    _allowDeletions_ = allow;
    return *this;
  }

References _allowDeletions_.

◆ allowArcReversals()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::allowArcReversals ( bool allow = true )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 1022 of file KTBNAdaptiveLearner_tpl.h.

                                                                     {
    _allowReversals_ = allow;
    return *this;
  }

References _allowReversals_.

◆ bestK()

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::bestK ( ) const

Order k selected by the last learnKTBN() call.

Exceptions

OperationNotAllowed if learnKTBN() has not run yet.

Definition at line 299 of file KTBNAdaptiveLearner_tpl.h.

                                                      {
    // _bestK_ stays at its sentinel 0 (never a valid order: candidates are >= 2)
    // until learnKTBN() selects one, so 0 means no learning has run yet.
    if (_bestK_ == 0)
      GUM_ERROR(OperationNotAllowed,
                "bestK() is undefined: call learnKTBN() before querying the selected order.")
    return _bestK_;
  }

References _bestK_, and GUM_ERROR.

Referenced by learnKTBN().

Here is the caller graph for this function:

◆ checkScorePriorCompatibility()

template<GUM_Numeric GUM_SCALAR>

std::string gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::checkScorePriorCompatibility ( ) const

Warning string if the recorded score and prior are incompatible, empty otherwise. Data-free: it evaluates the recorded (score, prior) pair exactly as KTBNLearner/BNLearner would, so an incompatible combination can be caught before learnKTBN() reads any trajectory.

Definition at line 338 of file KTBNAdaptiveLearner_tpl.h.

                                                                                  {
    // MIIC is constraint-based: it consumes a correction, not a score, so no
    // score/prior clash is possible. (Mirrors IBNLearner::isConstraintBased.)
    if (_algo_ == IBNLearner::AlgoType::MIIC) return "";
 
    // map the recorded prior to the internal PriorType. The adaptive learner only
    // ever records NO_prior or SMOOTHING (its sole prior setter is useSmoothingPrior).
    const PriorType prior = (_prior_ == IBNLearner::BNLearnerPriorType::SMOOTHING)
                              ? PriorType::SmoothingPriorType
                              : PriorType::NoPriorType;
 
    // delegate to the very same per-score static checks BNLearner uses
    switch (_score_) {
      case IBNLearner::ScoreType::AIC : return ScoreAIC::isPriorCompatible(prior, _priorWeight_);
      case IBNLearner::ScoreType::BD : return ScoreBD::isPriorCompatible(prior, _priorWeight_);
      case IBNLearner::ScoreType::BDeu : return ScoreBDeu::isPriorCompatible(prior, _priorWeight_);
      case IBNLearner::ScoreType::BIC : return ScoreBIC::isPriorCompatible(prior, _priorWeight_);
      case IBNLearner::ScoreType::fNML : return ScorefNML::isPriorCompatible(prior, _priorWeight_);
      case IBNLearner::ScoreType::LOG2LIKELIHOOD :
        return ScoreLog2Likelihood::isPriorCompatible(prior, _priorWeight_);
      case IBNLearner::ScoreType::MDL : return ScoreMDL::isPriorCompatible(prior, _priorWeight_);
      default : return "";   // K2 is never recorded by this learner's setters
    }
  }

References _algo_, _prior_, _priorWeight_, _score_, gum::learning::IBNLearner::AIC, gum::learning::IBNLearner::BD, gum::learning::IBNLearner::BDeu, gum::learning::IBNLearner::BIC, gum::learning::IBNLearner::fNML, gum::learning::ScoreAIC::isPriorCompatible(), gum::learning::ScoreBD::isPriorCompatible(), gum::learning::ScoreBDeu::isPriorCompatible(), gum::learning::ScoreBIC::isPriorCompatible(), gum::learning::ScorefNML::isPriorCompatible(), gum::learning::ScoreLog2Likelihood::isPriorCompatible(), gum::learning::IBNLearner::LOG2LIKELIHOOD, gum::learning::IBNLearner::MDL, gum::learning::IBNLearner::MIIC, gum::learning::NoPriorType, gum::learning::IBNLearner::SMOOTHING, and gum::learning::SmoothingPriorType.

Referenced by state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseForbiddenArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenArc	(	std::string_view	tailBase,
		int	tailSlice,
		std::string_view	headBase,
		int	headSlice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 700 of file KTBNAdaptiveLearner_tpl.h.

                                                                                       {
    // validate before _encode_ flattens the slice (a negative one would
    // silently read back as atemporal, losing the real error)
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    return eraseForbiddenArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and eraseForbiddenArc().

Here is the call graph for this function:

◆ eraseForbiddenArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenArc	(	std::string_view	tailNode,
		std::string_view	headNode )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 686 of file KTBNAdaptiveLearner_tpl.h.

                                                                                    {
    const auto [tailBase, tailSlice] = _determineNode_(std::string{tailNode});
    const auto [headBase, headSlice] = _determineNode_(std::string{headNode});
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    this->_checkArcTemporallyFeasible_(tailNode, headNode, "un-forbid the arc");
    _forbiddenArcs_.erase({std::string{tailNode}, std::string{headNode}});
    _recomputeKMin_();
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkArcTemporallyFeasible_(), gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _forbiddenArcs_, _recomputeKMin_(), and _verifyBase_().

Referenced by eraseForbiddenArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseForbiddenArcAllSlices()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenArcAllSlices	(	std::string_view	tailBase,
		std::string_view	headBase )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 862 of file KTBNAdaptiveLearner_tpl.h.

                                                                                             {
    _verifyBase_(tailBase, KTBN< GUM_SCALAR >::ATEMPORAL);
    _verifyBase_(headBase, KTBN< GUM_SCALAR >::ATEMPORAL);
    _forbiddenArcsAllSlices_.erase({std::string{tailBase}, std::string{headBase}});
    return *this;
  }

References _forbiddenArcsAllSlices_, _verifyBase_(), and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ eraseForbiddenIntraSliceArc()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenIntraSliceArc	(	std::string_view	tailBase,
		std::string_view	headBase )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 838 of file KTBNAdaptiveLearner_tpl.h.

                                                                                              {
    // same eager rejection as addForbiddenIntraSliceArc: such a constraint can
    // never have been recorded
    _checkBaseIsTemporal_(tailBase, "an intra-slice constraint");
    _checkBaseIsTemporal_(headBase, "an intra-slice constraint");
    _forbiddenIntraSliceArcs_.erase({std::string{tailBase}, std::string{headBase}});
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkBaseIsTemporal_(), and _forbiddenIntraSliceArcs_.

Here is the call graph for this function:

◆ eraseForbiddenKernelArc()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseForbiddenKernelArc	(	std::string_view	tailBase,
		int	lag,
		std::string_view	headBase )

Undo a previous addForbiddenKernelArc (same (tailBase, lag, headBase) triple).

Definition at line 787 of file KTBNAdaptiveLearner_tpl.h.

                                                                                          {
    _verifyKernelArc_(tailBase, headBase, lag);
    _forbiddenKernelArcs_.erase({std::string{tailBase}, std::string{headBase}, lag});
    _recomputeKMin_();
    return *this;
  }

References _forbiddenKernelArcs_, _recomputeKMin_(), and _verifyKernelArc_().

Here is the call graph for this function:

◆ eraseMandatoryArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseMandatoryArc	(	std::string_view	tailBase,
		int	tailSlice,
		std::string_view	headBase,
		int	headSlice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 759 of file KTBNAdaptiveLearner_tpl.h.

                                                                                       {
    // validate before _encode_ flattens the slice (a negative one would
    // silently read back as atemporal, losing the real error)
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    return eraseMandatoryArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and eraseMandatoryArc().

Here is the call graph for this function:

◆ eraseMandatoryArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseMandatoryArc	(	std::string_view	tailNode,
		std::string_view	headNode )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 744 of file KTBNAdaptiveLearner_tpl.h.

                                                                                    {
    const auto [tailBase, tailSlice] = _determineNode_(std::string{tailNode});
    const auto [headBase, headSlice] = _determineNode_(std::string{headNode});
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    // no feasibility check: erasing a never-forced arc is a harmless no-op
    // (mirrors KTBNLearner::eraseMandatoryArc)
    _mandatoryArcs_.erase({std::string{tailNode}, std::string{headNode}});
    _recomputeKMin_();
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _mandatoryArcs_, _recomputeKMin_(), and _verifyBase_().

Referenced by eraseMandatoryArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseMandatoryKernelArc()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseMandatoryKernelArc	(	std::string_view	tailBase,
		int	lag,
		std::string_view	headBase )

Undo a previous addMandatoryKernelArc (same (tailBase, lag, headBase) triple).

Definition at line 812 of file KTBNAdaptiveLearner_tpl.h.

                                                                                          {
    _verifyKernelArc_(tailBase, headBase, lag);
    _mandatoryKernelArcs_.erase({std::string{tailBase}, std::string{headBase}, lag});
    _recomputeKMin_();
    return *this;
  }

References _mandatoryKernelArcs_, _recomputeKMin_(), and _verifyKernelArc_().

Here is the call graph for this function:

◆ eraseNoChildrenNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseNoChildrenNode	(	std::string_view	base,
		int	slice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 926 of file KTBNAdaptiveLearner_tpl.h.

                                                                                           {
    // validate before _encode_ flattens the slice (see the arc overloads above)
    _verifyBase_(base, slice);
    return eraseNoChildrenNode(_encode_(base, slice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and eraseNoChildrenNode().

Referenced by eraseNoChildrenNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseNoChildrenNode() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseNoChildrenNode ( std::string_view name )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 934 of file KTBNAdaptiveLearner_tpl.h.

                                                                                {
    const auto [base, slice] = _determineNode_(std::string{name});
    _verifyBase_(base, slice);
    _noChildrenNodes_.erase(std::string{name});
    _recomputeKMin_();
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _noChildrenNodes_, _recomputeKMin_(), and _verifyBase_().

Here is the call graph for this function:

◆ eraseNoParentNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseNoParentNode	(	std::string_view	base,
		int	slice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 890 of file KTBNAdaptiveLearner_tpl.h.

                                                                                         {
    // validate before _encode_ flattens the slice (see the arc overloads above)
    _verifyBase_(base, slice);
    return eraseNoParentNode(_encode_(base, slice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and eraseNoParentNode().

Referenced by eraseNoParentNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseNoParentNode() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::eraseNoParentNode ( std::string_view name )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 898 of file KTBNAdaptiveLearner_tpl.h.

                                                                              {
    const auto [base, slice] = _determineNode_(std::string{name});
    _verifyBase_(base, slice);
    _noParentNodes_.erase(std::string{name});
    _recomputeKMin_();
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _noParentNodes_, _recomputeKMin_(), and _verifyBase_().

Here is the call graph for this function:

◆ erasePossibleEdge() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::erasePossibleEdge	(	std::string_view	tail,
		std::string_view	head )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 991 of file KTBNAdaptiveLearner_tpl.h.

                                                                                {
    const auto [tailBase, tailSlice] = _determineNode_(std::string{tail});
    const auto [headBase, headSlice] = _determineNode_(std::string{head});
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    // same alphabetical normalization as addPossibleEdge, so erasing (B,A)
    // removes the edge recorded as (A,B)
    std::string first{tail}, second{head};
    if (second < first) std::swap(first, second);
    _possibleEdges_.erase({std::move(first), std::move(second)});
    _recomputeKMin_();
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _possibleEdges_, _recomputeKMin_(), and _verifyBase_().

Here is the call graph for this function:

◆ erasePossibleEdge() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::erasePossibleEdge	(	std::string_view	tailBase,
		int	tailSlice,
		std::string_view	headBase,
		int	headSlice )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 978 of file KTBNAdaptiveLearner_tpl.h.

                                                                                       {
    // validate before _encode_ flattens the slice (a negative one would
    // silently read back as atemporal, losing the real error)
    _verifyBase_(tailBase, tailSlice);
    _verifyBase_(headBase, headSlice);
    return erasePossibleEdge(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _verifyBase_(), and erasePossibleEdge().

Referenced by erasePossibleEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ignoreMissingSymbols()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::ignoreMissingSymbols ( bool ignore = true )

Learn and score on the fully observed data only, dropping every row and every scoring instance that carries a missing symbol.

Without this, learnKTBN() refuses trajectories containing missing values: aGrUM's structure learning cannot cope with them (gum::learning::IBNLearner::learnDag_ raises MissingValueInDatabase), so there is nothing sensible to hand it. With it, each candidate's databases are built by complete-case selection and the cross-k score skips any instance whose family is incomplete — the two agree on which data counts.

Warning: This inflates $\log_2 L$, and inflates it more for larger $k$ — so it biases the order selection this class exists to perform.

A row or instance is dropped as soon as one cell of its window is missing, so a single gap costs up to $k$ of them. A larger $k$ spans more rows per window and loses proportionally more.

$\log_2 L$ is a sum of per-instance terms, each $\leq 0$. Dropping instances removes negative terms and therefore raises the total: the candidate is not fitting better, it is being charged for less data. Since the larger $k$ drops more, it gains more — precisely the comparison bestK() rests on.

The BIC penalty does not compensate. $\log_2 N$ is computed once from the raw trajectory lengths (deliberately, so it is identical across candidates) and so describes a sample size the likelihood no longer uses; the penalty is unchanged while the likelihood is inflated.

The distortion grows with the missing-value rate. At a few percent it is usually harmless; on heavily incomplete trajectories bestK() can be pulled a full order upwards. Inspect scorePerCandidateK() rather than trusting bestK() alone, and prefer complete trajectories whenever the order itself is the question. gum::learning::KTBNLearner::nbDroppedRows() reports how much each candidate actually lost.

Definition at line 573 of file KTBNAdaptiveLearner_tpl.h.

                                                                         {
    _ignoreMissingSymbols_ = ignore;
    return *this;
  }

References _ignoreMissingSymbols_.

◆ isIgnoringMissingSymbols()

template<GUM_Numeric GUM_SCALAR>

INLINE bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::isIgnoringMissingSymbols ( ) const

Whether incomplete rows and instances are dropped. False by default.

Definition at line 579 of file KTBNAdaptiveLearner_tpl.h.

                                                                                {
    return _ignoreMissingSymbols_;
  }

References _ignoreMissingSymbols_.

◆ kMax()

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::kMax ( ) const

Largest order explored (the kMax argument of the constructor).

Definition at line 333 of file KTBNAdaptiveLearner_tpl.h.

                                                     {
    return _kMax_;
  }

References _kMax_.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), and _inferAtemporalVars_().

Here is the caller graph for this function:

◆ latentVariables()

template<GUM_Numeric GUM_SCALAR>

const std::vector< std::pair< std::string, std::string > > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::latentVariables ( ) const

Engine-name (tail, head) pairs of arcs the selected model's MIIC run flagged as hiding a latent variable. Empty when the recorded algorithm is not MIIC (only MIIC produces latent-variable annotations) or when none were found.

Exceptions

OperationNotAllowed if learnKTBN() has not run yet.

Definition at line 310 of file KTBNAdaptiveLearner_tpl.h.

                                                               {
    // gated on the same sentinel as bestK(): 0 means learnKTBN() has not run.
    if (_bestK_ == 0)
      GUM_ERROR(OperationNotAllowed, "latentVariables() is undefined: call learnKTBN() first.")
    return _bestLatentVariables_;
  }

References _bestK_, _bestLatentVariables_, and GUM_ERROR.

◆ learnKTBN()

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::learnKTBN ( )

overridevirtual

Learns the best k in [kMin, kMax] together with the structure and the CPTs: one KTBNLearner is built and run per candidate k, the recorded configuration is replayed on each, and the k-TBN with the best model-selection score is returned. kMin starts at 2 and is raised by the structural-constraint setters (see class doc).

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 198 of file KTBNAdaptiveLearner_tpl.h.

                                                                  {
    // Explore every candidate order _kMin_.._kMax_ and keep the k-TBN with the
    // best cross-k model-selection score (BIC by default; see useOrderScore*).
    // _kMin_ -- 2 unless raised by a constraint naming a concrete slice, see
    // _recomputeKMin_ -- skips candidates that would only drop that constraint.
    // Each candidate is a full fixed-k problem: a fresh KTBNLearner on the same
    // trajectories, replaying the recorded configuration and constraints (those
    // whose slices do not fit that k are dropped by _applyConstraints_).
    // Reset first: a re-entry, or a throw below, must not leave a stale selection
    // readable through bestK() / latentVariables().
    _bestK_ = 0;
    _bestLatentVariables_.clear();
    _scorePerCandidateK_.clear();
    KTBN< GUM_SCALAR > best;
    Size               bestK = 0;   // local; committed to _bestK_ only if the whole sweep succeeds
    double             bestScore = 0.0;                // unread until the first candidate sets it
    double             logN      = 0.0;                // log2 of the total number of observations
    std::vector< std::pair< Size, double > > scores;   // per-k scores, committed at the end
    std::vector< std::pair< std::string, std::string > >
        bestLatents;   // winner's latent pairs, committed at the end
 
    for (Size k = _kMin_; k <= _kMax_; ++k) {
      // build this candidate's fixed-k learner: from the schema BN when one was
      // supplied (domains fixed explicitly), else from the CSV (domains inferred).
      // KTBNLearner is non-movable, so hold it through a unique_ptr.
      std::unique_ptr< KTBNLearner< GUM_SCALAR > > learnerPtr
          = _prior_bn_ ? std::make_unique< KTBNLearner< GUM_SCALAR > >(_dirPath_,
                                                                       _csvBaseName_,
                                                                       _nbSamples_,
                                                                       k,
                                                                       *_prior_bn_,
                                                                       _atemporalVars_,
                                                                       _missingSymbols_,
                                                                       _ignoreMissingSymbols_)
                       : std::make_unique< KTBNLearner< GUM_SCALAR > >(_dirPath_,
                                                                       _csvBaseName_,
                                                                       _nbSamples_,
                                                                       k,
                                                                       _atemporalVars_,
                                                                       _missingSymbols_,
                                                                       _induceTypes_,
                                                                       _ignoreMissingSymbols_);
      KTBNLearner< GUM_SCALAR >& learner = *learnerPtr;
 
      // Refused here rather than deep inside structure learning: learnDag_ would
      // otherwise raise its own generic message only after this candidate's
      // databases had been built. Every candidate reads the same trajectories, so
      // the verdict on the first holds for all.
      if (!_ignoreMissingSymbols_ && learner.hasMissingValues())
        GUM_ERROR(MissingValueInDatabase,
                  "the trajectories contain missing values. Neither aGrUM's structure learning "
                  "nor the cross-k order score can evaluate an incomplete window. Call "
                  "ignoreMissingSymbols() to learn and score on the fully observed data only "
                  "(see its warning: dropping skews the selection towards larger k).")
 
      // sample size for the BIC penalty: the total number of time-slice rows over
      // all trajectories. Independent of k, so it is computed once on the first
      // candidate and reused — it must stay fixed for the scores to compare.
      if (logN == 0.0) {
        Size nbObs = 0;
        for (const Size len: learner.nbRows())
          nbObs += len;
        logN = std::log2(nbObs);
      }
 
      _applyConfig_(learner);
      _applyConstraints_(learner, k);
 
      KTBN< GUM_SCALAR > candidate = learner.learnKTBN();
 
      // Cross-k model selection by the recorded order score (BIC by default):
      // it must be comparable across k, unlike the per-k structure score, so it
      // is computed here on the whole learned k-TBN rather than read off the
      // internal learners. bestK == 0 means nothing is selected yet, so the
      // first candidate is always taken; a strict '>' afterwards keeps the
      // smallest k on ties (mild parsimony).
      const double score = _orderSelectionScore_(candidate, logN);
      scores.emplace_back(k, score);
      if (bestK == 0 || score > bestScore) {
        bestScore = score;
        best      = std::move(candidate);
        bestK     = k;
        // capture the winner's latent-variable annotations while its learner is
        // still alive (only MIIC produces them; other algos leave the set empty)
        bestLatents = (_algo_ == IBNLearner::AlgoType::MIIC)
                        ? learner.latentVariables()
                        : std::vector< std::pair< std::string, std::string > >{};
      }
    }
 
    // Commit only after every candidate has succeeded. An exception thrown above
    // (e.g. a trajectory too short for some candidate k) leaves the members at
    // their reset state, so bestK() / latentVariables() / scorePerCandidateK()
    // keep reporting "not learned" — the all-or-nothing guarantee promised above.
    _bestK_               = bestK;
    _scorePerCandidateK_  = std::move(scores);
    _bestLatentVariables_ = std::move(bestLatents);
    return best;
  }

References _algo_, _applyConfig_(), _applyConstraints_(), _atemporalVars_, _bestK_, _bestLatentVariables_, _csvBaseName_, _dirPath_, _ignoreMissingSymbols_, _induceTypes_, _kMax_, _kMin_, _missingSymbols_, _nbSamples_, _orderSelectionScore_(), _prior_bn_, _scorePerCandidateK_, bestK(), GUM_ERROR, and gum::learning::IBNLearner::MIIC.

Here is the call graph for this function:

◆ operator=() [1/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::operator= ( const KTBNAdaptiveLearner< GUM_SCALAR > & )

privatedelete

References KTBNAdaptiveLearner().

Here is the call graph for this function:

◆ operator=() [2/2]

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::operator= ( KTBNAdaptiveLearner< GUM_SCALAR > && )

privatedelete

References KTBNAdaptiveLearner().

Here is the call graph for this function:

◆ scorePerCandidateK()

template<GUM_Numeric GUM_SCALAR>

const std::vector< std::pair< Size, double > > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::scorePerCandidateK ( ) const

Per-candidate cross-k scores from the last learnKTBN() call, as (k, score) pairs for k = kMin..kMax in ascending k order — the values the order selection compared to choose bestK() (higher is better; the argmax is bestK()). Under the default useOrderScoreBIC() each score is $\log_2 L - \tfrac{1}{2}\,d\,\log_2 N$ of the k-TBN learned for that k.

Exceptions

OperationNotAllowed if learnKTBN() has not run yet.

Definition at line 319 of file KTBNAdaptiveLearner_tpl.h.

                                                                  {
    // same sentinel gate as bestK()/latentVariables(): 0 means learnKTBN() has not run.
    if (_bestK_ == 0)
      GUM_ERROR(
          OperationNotAllowed,
          "scorePerCandidateK() is undefined: call learnKTBN() before querying the per-k scores.")
    return _scorePerCandidateK_;
  }

References _bestK_, _scorePerCandidateK_, and GUM_ERROR.

◆ setMaxIndegree()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::setMaxIndegree ( Size max_indegree )

overridevirtual

Forbid an arc from tailBase, lag slices before the kernel, to headBase in the kernel: tailBase at slice k-1-lag -> headBase at slice k-1, for whichever k is selected. The slice is not given directly but derived from lag relative to the kernel slice k-1, which moves with the candidate — so no absolute slice could express it at record time. Adaptive-only: the fixed-k learners have no moving kernel slice to anchor it to. lag must be in [0, kMax) and both bases temporal (an atemporal variable has no kernel-slice instance). Raises kMin to at least lag+1, like a constraint naming slice lag.

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 1029 of file KTBNAdaptiveLearner_tpl.h.

                                                                         {
    _maxIndegree_ = max_indegree;
    return *this;
  }

References _maxIndegree_.

◆ state()

template<GUM_Numeric GUM_SCALAR>

std::vector< std::tuple< std::string, std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::state ( ) const

The recorded configuration as (key, value, comment) tuples (mirrors KTBNLearner::state()); toString() is a formatted view of it.

Definition at line 365 of file KTBNAdaptiveLearner_tpl.h.

                                                     {
    std::vector< std::tuple< std::string, std::string, std::string > > vals;
    const auto add = [&](std::string k, std::string v, std::string c = "") {
      vals.emplace_back(std::move(k), std::move(v), std::move(c));
    };
    // render a set of engine-name pairs as "{a->b, c->d}"
    const auto arcs = [](const std::set< std::pair< std::string, std::string > >& s) {
      std::string r     = "{";
      bool        first = true;
      for (const auto& [a, b]: s) {
        if (!first) r += ", ";
        first = false;
        r += a + "->" + b;
      }
      return r + "}";
    };
    const auto names = [](const std::set< std::string >& s) {
      std::string r     = "{";
      bool        first = true;
      for (const auto& n: s) {
        if (!first) r += ", ";
        first = false;
        r += n;
      }
      return r + "}";
    };
    // render a set of (tailBase, headBase, lag) triples as "{a->b (lag 1), ...}"
    const auto kernelArcs = [](const std::set< std::tuple< std::string, std::string, int > >& s) {
      std::string r     = "{";
      bool        first = true;
      for (const auto& [a, b, lag]: s) {
        if (!first) r += ", ";
        first = false;
        r += a + "->" + b + " (lag " + std::to_string(lag) + ")";
      }
      return r + "}";
    };
 
    add("Candidate orders", std::to_string(_kMin_) + ".." + std::to_string(_kMax_));
    add("Selected k", _bestK_ == 0 ? "not learned yet" : std::to_string(_bestK_));
    add("Base variables", std::to_string(_baseNames_.size()));
    add("Atemporal variables", names({_atemporalVars_.begin(), _atemporalVars_.end()}));
 
    switch (_algo_) {
      case IBNLearner::AlgoType::MIIC : add("Algorithm", "MIIC"); break;
      case IBNLearner::AlgoType::GREEDY_HILL_CLIMBING :
        add("Algorithm", "Greedy Hill Climbing");
        break;
      case IBNLearner::AlgoType::EXTENDED_GREEDY_HILL_CLIMBING :
        add("Algorithm", "Extended Greedy Hill Climbing");
        break;
      case IBNLearner::AlgoType::LOCAL_SEARCH_WITH_TABU_LIST :
        add("Algorithm", "Local Search with Tabu List");
        add("Tabu list size", std::to_string(_tabuSize_));
        add("Tabu nb decrease", std::to_string(_nbDecrease_));
        break;
      default : add("Algorithm", "(other)"); break;
    }
 
    if (_algo_ == IBNLearner::AlgoType::MIIC) {
      switch (_correction_) {
        case CorrectedMutualInformation::KModeTypes::MDL : add("Correction", "MDL"); break;
        case CorrectedMutualInformation::KModeTypes::NML : add("Correction", "NML"); break;
        case CorrectedMutualInformation::KModeTypes::NoCorr :
          add("Correction", "No correction");
          break;
      }
    } else {
      switch (_score_) {
        case IBNLearner::ScoreType::AIC : add("Structure score", "AIC"); break;
        case IBNLearner::ScoreType::BD : add("Structure score", "BD"); break;
        case IBNLearner::ScoreType::BDeu : add("Structure score", "BDeu"); break;
        case IBNLearner::ScoreType::BIC : add("Structure score", "BIC"); break;
        case IBNLearner::ScoreType::fNML : add("Structure score", "fNML"); break;
        case IBNLearner::ScoreType::LOG2LIKELIHOOD :
          add("Structure score", "Log2Likelihood");
          break;
        case IBNLearner::ScoreType::MDL : add("Structure score", "MDL"); break;
        default : add("Structure score", "(other)"); break;
      }
    }
 
    // the outer, cross-k criterion — distinct from the per-k structure score above
    switch (_orderScore_) {
      case OrderScoreType::BIC : add("Order selection score", "BIC"); break;
      case OrderScoreType::AIC : add("Order selection score", "AIC"); break;
      case OrderScoreType::fNML : add("Order selection score", "fNML"); break;
    }
 
    if (_prior_ == IBNLearner::BNLearnerPriorType::SMOOTHING) {
      add("Prior", "Smoothing", checkScorePriorCompatibility());
      add("Prior weight", std::to_string(_priorWeight_));
    } else {
      add("Prior", "no prior is set", checkScorePriorCompatibility());
    }
 
    if (!_forbiddenArcs_.empty()) add("Forbidden arcs", arcs(_forbiddenArcs_));
    if (!_mandatoryArcs_.empty()) add("Mandatory arcs", arcs(_mandatoryArcs_));
    if (!_forbiddenKernelArcs_.empty())
      add("Forbidden kernel arcs", kernelArcs(_forbiddenKernelArcs_));
    if (!_mandatoryKernelArcs_.empty())
      add("Mandatory kernel arcs", kernelArcs(_mandatoryKernelArcs_));
    if (!_possibleEdges_.empty()) add("Possible edges", arcs(_possibleEdges_));
    if (!_forbiddenIntraSliceArcs_.empty())
      add("Forbidden intra-slice arcs", arcs(_forbiddenIntraSliceArcs_));
    if (!_forbiddenArcsAllSlices_.empty())
      add("Forbidden all-slices arcs", arcs(_forbiddenArcsAllSlices_));
    if (!_noParentNodes_.empty()) add("No-parent nodes", names(_noParentNodes_));
    if (!_noChildrenNodes_.empty()) add("No-children nodes", names(_noChildrenNodes_));
    if (_maxIndegree_ != std::numeric_limits< Size >::max())
      add("Max in-degree", std::to_string(_maxIndegree_));
    if (!_allowAdditions_) add("Arc additions", "forbidden");
    if (!_allowDeletions_) add("Arc deletions", "forbidden");
    if (!_allowReversals_) add("Arc reversals", "forbidden");
 
    return vals;
  }

Referenced by toString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toString()

template<GUM_Numeric GUM_SCALAR>

std::string gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::toString ( ) const

Human-readable summary of the recorded configuration (candidate order range, algorithm / score / correction / prior, structural constraints) plus the selected k once learnKTBN() has run.

Definition at line 484 of file KTBNAdaptiveLearner_tpl.h.

                                                              {
    // aligned "key : value  (comment)" listing, same layout as BNLearner::toString
    const auto  st     = state();
    std::size_t maxkey = 0;
    for (const auto& t: st)
      maxkey = std::max(maxkey, std::get< 0 >(t).length());
 
    std::string s;
    for (const auto& t: st) {
      s += std::format("{:<{}} : {}", std::get< 0 >(t), maxkey, std::get< 1 >(t));
      if (!std::get< 2 >(t).empty()) s += std::format("  ({})", std::get< 2 >(t));
      s += '\n';
    }
    return s;
  }

References state().

Here is the call graph for this function:

◆ useExtendedGreedyHillClimbing()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useExtendedGreedyHillClimbing ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 595 of file KTBNAdaptiveLearner_tpl.h.

                                                                       {
    _algo_ = IBNLearner::AlgoType::EXTENDED_GREEDY_HILL_CLIMBING;
    return *this;
  }

References _algo_, and gum::learning::IBNLearner::EXTENDED_GREEDY_HILL_CLIMBING.

◆ useGreedyHillClimbing()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useGreedyHillClimbing ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 588 of file KTBNAdaptiveLearner_tpl.h.

                                                                                              {
    _algo_ = IBNLearner::AlgoType::GREEDY_HILL_CLIMBING;
    return *this;
  }

References KTBNAdaptiveLearner(), _algo_, and gum::learning::IBNLearner::GREEDY_HILL_CLIMBING.

Here is the call graph for this function:

◆ useLocalSearchWithTabuList()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useLocalSearchWithTabuList	(	Size	tabu_size = 100,
		Size	nb_decrease = 2 )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 602 of file KTBNAdaptiveLearner_tpl.h.

                                                                                      {
    _algo_       = IBNLearner::AlgoType::LOCAL_SEARCH_WITH_TABU_LIST;
    _tabuSize_   = tabu_size;
    _nbDecrease_ = nb_decrease;
    return *this;
  }

References _algo_, _nbDecrease_, _tabuSize_, and gum::learning::IBNLearner::LOCAL_SEARCH_WITH_TABU_LIST.

◆ useMDLCorrection()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useMDLCorrection ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 627 of file KTBNAdaptiveLearner_tpl.h.

                                                                                         {
    _correction_ = CorrectedMutualInformation::KModeTypes::MDL;
    return *this;
  }

References KTBNAdaptiveLearner(), _correction_, and gum::learning::CorrectedMutualInformation::MDL.

Here is the call graph for this function:

◆ useMIIC()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useMIIC ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 611 of file KTBNAdaptiveLearner_tpl.h.

                                                                                {
    _algo_ = IBNLearner::AlgoType::MIIC;
    return *this;
  }

References KTBNAdaptiveLearner(), _algo_, and gum::learning::IBNLearner::MIIC.

Here is the call graph for this function:

◆ useNMLCorrection()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useNMLCorrection ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 621 of file KTBNAdaptiveLearner_tpl.h.

                                                                                         {
    _correction_ = CorrectedMutualInformation::KModeTypes::NML;
    return *this;
  }

References KTBNAdaptiveLearner(), _correction_, and gum::learning::CorrectedMutualInformation::NML.

Here is the call graph for this function:

◆ useNoCorrection()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useNoCorrection ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 633 of file KTBNAdaptiveLearner_tpl.h.

                                                                                        {
    _correction_ = CorrectedMutualInformation::KModeTypes::NoCorr;
    return *this;
  }

References KTBNAdaptiveLearner(), _correction_, and gum::learning::CorrectedMutualInformation::NoCorr.

Here is the call graph for this function:

◆ useOrderScoreAIC()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useOrderScoreAIC ( )

Select k by AIC: keep the k whose learned model maximises $\log_2 L - d$ (a lighter, sample-size-independent complexity penalty than BIC).

Definition at line 556 of file KTBNAdaptiveLearner_tpl.h.

                                                                                         {
    _orderScore_ = OrderScoreType::AIC;
    return *this;
  }

References KTBNAdaptiveLearner(), _orderScore_, and AIC.

Here is the call graph for this function:

◆ useOrderScoreBIC()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useOrderScoreBIC ( )

Select k by BIC (the default): keep the k whose learned model maximises $\log_2 L - \tfrac{1}{2}\,d\,\log_2 N$.

Definition at line 550 of file KTBNAdaptiveLearner_tpl.h.

                                                                                         {
    _orderScore_ = OrderScoreType::BIC;
    return *this;
  }

References KTBNAdaptiveLearner(), _orderScore_, and BIC.

Here is the call graph for this function:

◆ useOrderScorefNML()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useOrderScorefNML ( )

$\tfrac{1}{2}\,d\,\log_2 N$ by a sum of per-node, per-parent-configuration multinomial parametric complexities (regret) – data-dependent, unlike BIC/AIC, matching aGrUM's ScorefNML.

Definition at line 562 of file KTBNAdaptiveLearner_tpl.h.

                                                                                          {
    _orderScore_ = OrderScoreType::fNML;
    return *this;
  }

References KTBNAdaptiveLearner(), _orderScore_, and fNML.

Here is the call graph for this function:

◆ useScoreAIC()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScoreAIC ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 505 of file KTBNAdaptiveLearner_tpl.h.

                                                                                    {
    _score_ = IBNLearner::ScoreType::AIC;
    return *this;
  }

References KTBNAdaptiveLearner(), _score_, and gum::learning::IBNLearner::AIC.

Here is the call graph for this function:

◆ useScoreBD()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScoreBD ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 511 of file KTBNAdaptiveLearner_tpl.h.

                                                                                   {
    _score_ = IBNLearner::ScoreType::BD;
    return *this;
  }

References KTBNAdaptiveLearner(), _score_, and gum::learning::IBNLearner::BD.

Here is the call graph for this function:

◆ useScoreBDeu()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScoreBDeu ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 517 of file KTBNAdaptiveLearner_tpl.h.

                                                                                     {
    _score_ = IBNLearner::ScoreType::BDeu;
    return *this;
  }

References KTBNAdaptiveLearner(), _score_, and gum::learning::IBNLearner::BDeu.

Here is the call graph for this function:

◆ useScoreBIC()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScoreBIC ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 523 of file KTBNAdaptiveLearner_tpl.h.

                                                                                    {
    _score_ = IBNLearner::ScoreType::BIC;
    return *this;
  }

References KTBNAdaptiveLearner(), _score_, and gum::learning::IBNLearner::BIC.

Here is the call graph for this function:

◆ useScorefNML()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScorefNML ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 541 of file KTBNAdaptiveLearner_tpl.h.

                                                       {
    _score_ = IBNLearner::ScoreType::fNML;
  }

References _score_, and gum::learning::IBNLearner::fNML.

◆ useScoreLog2Likelihood()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScoreLog2Likelihood ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 529 of file KTBNAdaptiveLearner_tpl.h.

                                                                                               {
    _score_ = IBNLearner::ScoreType::LOG2LIKELIHOOD;
    return *this;
  }

References KTBNAdaptiveLearner(), _score_, and gum::learning::IBNLearner::LOG2LIKELIHOOD.

Here is the call graph for this function:

◆ useScoreMDL()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useScoreMDL ( )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 535 of file KTBNAdaptiveLearner_tpl.h.

                                                                                    {
    _score_ = IBNLearner::ScoreType::MDL;
    return *this;
  }

References KTBNAdaptiveLearner(), _score_, and gum::learning::IBNLearner::MDL.

Here is the call graph for this function:

◆ useSmoothingPrior()

template<GUM_Numeric GUM_SCALAR>

KTBNAdaptiveLearner< GUM_SCALAR > & gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::useSmoothingPrior ( double weight = 1.0 )

overridevirtual

Implements gum::learning::IKTBNLearner< GUM_SCALAR >.

Definition at line 644 of file KTBNAdaptiveLearner_tpl.h.

                                                                        {
    _prior_       = IBNLearner::BNLearnerPriorType::SMOOTHING;
    _priorWeight_ = weight;
    return *this;
  }

References _prior_, _priorWeight_, and gum::learning::IBNLearner::SMOOTHING.

Member Data Documentation

◆ _algo_

template<GUM_Numeric GUM_SCALAR>

IBNLearner::AlgoType gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_algo_ {IBNLearner::AlgoType::MIIC}

private

recorded structure-learning algorithm

Definition at line 565 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), checkScorePriorCompatibility(), learnKTBN(), state(), useExtendedGreedyHillClimbing(), useGreedyHillClimbing(), useLocalSearchWithTabuList(), and useMIIC().

◆ _allowAdditions_

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_allowAdditions_ {true}

private

recorded graph-change permissions / indegree cap

Definition at line 580 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), allowArcAdditions(), and state().

◆ _allowDeletions_

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_allowDeletions_ {true}

private

Definition at line 581 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), allowArcDeletions(), and state().

◆ _allowReversals_

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_allowReversals_ {true}

private

Definition at line 582 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), allowArcReversals(), and state().

◆ _atemporalVars_

template<GUM_Numeric GUM_SCALAR>

std::unordered_set< std::string > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_atemporalVars_

private

base names of the atemporal (static) variables

Definition at line 531 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _atemporalVarNames_(), _verifyBase_(), learnKTBN(), and state().

◆ _baseNames_

template<GUM_Numeric GUM_SCALAR>

std::unordered_set< std::string > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_baseNames_

private

all base variable names (temporal + atemporal), read from the first trajectory CSV header at construction. Authoritative universe used by the constraint setters to reject names that do not exist.

Definition at line 536 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _isKnownBase_(), _verifyBase_(), and state().

◆ _bestK_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_bestK_ {0}

private

k selected by the last learnKTBN() call, or 0 as a sentinel while no learning has happened yet. 0 can never be a valid order (candidates are 2..kMax), so bestK() reads it to decide whether learnKTBN() has run.

Definition at line 624 of file KTBNAdaptiveLearner.h.

Referenced by bestK(), latentVariables(), learnKTBN(), scorePerCandidateK(), and state().

◆ _bestLatentVariables_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::pair< std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_bestLatentVariables_

private

latent-variable arcs (engine-name pairs) reported by the winning candidate's MIIC run, captured by learnKTBN(); empty when the selected algorithm is not MIIC. Exposed by latentVariables().

Definition at line 629 of file KTBNAdaptiveLearner.h.

Referenced by latentVariables(), and learnKTBN().

◆ _correction_

template<GUM_Numeric GUM_SCALAR>

CorrectedMutualInformation::KModeTypes gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_correction_

private

Initial value:

{

CorrectedMutualInformation::KModeTypes::MDL}

gum::learning::CorrectedMutualInformation::KModeTypes::MDL

@ MDL

Definition correctedMutualInformation.h:298

recorded MIIC correction

Definition at line 572 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), state(), useMDLCorrection(), useNMLCorrection(), and useNoCorrection().

◆ _csvBaseName_

template<GUM_Numeric GUM_SCALAR>

std::string gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_csvBaseName_

private

stem of each trajectory file name

Definition at line 515 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _forEachScoredNode_(), and learnKTBN().

◆ _ctable_

template<GUM_Numeric GUM_SCALAR>

VariableLog2ParamComplexity gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_ctable_

mutableprivate

cache of log2 of the multinomial parametric complexity C^r_n, used by the fNML order penalty. Mutable because log2Cnr() memoizes; the const order-score helpers may therefore call it. Only touched under fNML.

Definition at line 771 of file KTBNAdaptiveLearner.h.

Referenced by _fNMLScore_().

◆ _dirPath_

template<GUM_Numeric GUM_SCALAR>

std::string gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_dirPath_

private

directory holding the trajectory CSV files

Definition at line 512 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _forEachScoredNode_(), and learnKTBN().

◆ _forbiddenArcs_

template<GUM_Numeric GUM_SCALAR>

std::set< std::pair< std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_forbiddenArcs_

private

forbidden arcs, as (tail, head) engine-name pairs

Definition at line 592 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addForbiddenArc(), eraseForbiddenArc(), and state().

◆ _forbiddenArcsAllSlices_

template<GUM_Numeric GUM_SCALAR>

std::set< std::pair< std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_forbiddenArcsAllSlices_

private

forbidden all-slices arcs, as (tailBase, headBase) pairs

Definition at line 604 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), addForbiddenArcAllSlices(), eraseForbiddenArcAllSlices(), and state().

◆ _forbiddenIntraSliceArcs_

template<GUM_Numeric GUM_SCALAR>

std::set< std::pair< std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_forbiddenIntraSliceArcs_

private

forbidden intra-slice arcs, as (tailBase, headBase) pairs

Definition at line 601 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), addForbiddenIntraSliceArc(), eraseForbiddenIntraSliceArc(), and state().

◆ _forbiddenKernelArcs_

template<GUM_Numeric GUM_SCALAR>

std::set< std::tuple< std::string, std::string, int > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_forbiddenKernelArcs_

private

forbidden kernel-relative arcs, as (tailBase, headBase, lag) triples: tailBase at slice k-1-lag -> headBase at the kernel slice k-1. Kept separate from forbiddenArcs (which stores resolved engine names) since the slice here is only known once a candidate k is fixed.

Definition at line 610 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addForbiddenKernelArc(), eraseForbiddenKernelArc(), and state().

◆ _ignoreMissingSymbols_

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_ignoreMissingSymbols_ {false}

private

whether incomplete rows/instances are dropped (see ignoreMissingSymbols())

Definition at line 542 of file KTBNAdaptiveLearner.h.

Referenced by ignoreMissingSymbols(), isIgnoringMissingSymbols(), and learnKTBN().

◆ _induceTypes_

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_induceTypes_

private

whether numeric columns are retyped (see KTBNLearner); unused (and forced false) when a schema BN is supplied

Definition at line 546 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), and learnKTBN().

◆ _kMax_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_kMax_

private

largest order to explore (candidates are kMin..kMax)

Definition at line 521 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _verifyBase_(), _verifyKernelArc_(), kMax(), learnKTBN(), and state().

◆ _kMin_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_kMin_ {2}

private

smallest order worth exploring (candidates are kMin..kMax). Starts at 2 and is recomputed by recomputeKMin() from the recorded slice-bearing constraints every time one is added or erased; never set directly. See recomputeKMin() for why it must be a recompute rather than an incremental raise/lower.

Definition at line 528 of file KTBNAdaptiveLearner.h.

Referenced by _raiseKMinForSlice_(), _recomputeKMin_(), learnKTBN(), and state().

◆ _mandatoryArcs_

template<GUM_Numeric GUM_SCALAR>

std::set< std::pair< std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_mandatoryArcs_

private

mandatory arcs, as (tail, head) engine-name pairs

Definition at line 595 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addMandatoryArc(), eraseMandatoryArc(), and state().

◆ _mandatoryKernelArcs_

template<GUM_Numeric GUM_SCALAR>

std::set< std::tuple< std::string, std::string, int > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_mandatoryKernelArcs_

private

mandatory kernel-relative arcs, same shape as forbiddenKernelArcs

Definition at line 613 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addMandatoryKernelArc(), eraseMandatoryKernelArc(), and state().

◆ _maxIndegree_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_maxIndegree_ {std::numeric_limits< Size >::max()}

private

Definition at line 583 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), setMaxIndegree(), and state().

◆ _missingSymbols_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::string > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_missingSymbols_

private

symbols in the CSVs to interpret as missing values

Definition at line 539 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _forEachScoredNode_(), and learnKTBN().

◆ _nbDecrease_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_nbDecrease_ {2}

private

Definition at line 569 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), state(), and useLocalSearchWithTabuList().

◆ _nbSamples_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_nbSamples_

private

number of CSV files to read

Definition at line 518 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), KTBNAdaptiveLearner(), _forEachScoredNode_(), and learnKTBN().

◆ _noChildrenNodes_

template<GUM_Numeric GUM_SCALAR>

std::set< std::string > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_noChildrenNodes_

private

leaf nodes (no children), as engine names

Definition at line 619 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addNoChildrenNode(), eraseNoChildrenNode(), and state().

◆ _noParentNodes_

template<GUM_Numeric GUM_SCALAR>

std::set< std::string > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_noParentNodes_

private

root nodes (no parents), as engine names

Definition at line 616 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addNoParentNode(), eraseNoParentNode(), and state().

◆ _orderScore_

template<GUM_Numeric GUM_SCALAR>

OrderScoreType gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_orderScore_ {OrderScoreType::BIC}

private

recorded cross-k order-selection criterion (the outer score used by learnKTBN() to pick the best k; independent of score)

Definition at line 562 of file KTBNAdaptiveLearner.h.

Referenced by _orderSelectionScore_(), state(), useOrderScoreAIC(), useOrderScoreBIC(), and useOrderScorefNML().

◆ _possibleEdges_

template<GUM_Numeric GUM_SCALAR>

std::set< std::pair< std::string, std::string > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_possibleEdges_

private

MIIC candidate edges, as (tail, head) engine-name pairs.

Definition at line 598 of file KTBNAdaptiveLearner.h.

Referenced by _applyConstraints_(), _recomputeKMin_(), addPossibleEdge(), erasePossibleEdge(), and state().

◆ _prior_

template<GUM_Numeric GUM_SCALAR>

IBNLearner::BNLearnerPriorType gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_prior_ {IBNLearner::BNLearnerPriorType::NO_prior}

private

recorded prior and its weight

Definition at line 576 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), checkScorePriorCompatibility(), state(), and useSmoothingPrior().

◆ _prior_bn_

template<GUM_Numeric GUM_SCALAR>

std::unique_ptr< BayesNet< GUM_SCALAR > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_prior_bn_

private

optional variable-schema BN (set by the BN constructor): when present, each per-k KTBNLearner is built from it so the variable domains are fixed explicitly instead of inferred from trajectory 1. Null in CSV mode.

Definition at line 551 of file KTBNAdaptiveLearner.h.

Referenced by KTBNAdaptiveLearner(), and learnKTBN().

◆ _priorWeight_

template<GUM_Numeric GUM_SCALAR>

double gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_priorWeight_ {1.0}

private

Definition at line 577 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), checkScorePriorCompatibility(), state(), and useSmoothingPrior().

◆ _score_

template<GUM_Numeric GUM_SCALAR>

IBNLearner::ScoreType gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_score_ {IBNLearner::ScoreType::BDeu}

private

recorded per-k structure score (the inner score, replayed on each candidate)

Definition at line 558 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), checkScorePriorCompatibility(), state(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScorefNML(), useScoreLog2Likelihood(), and useScoreMDL().

◆ _scorePerCandidateK_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::pair< Size, double > > gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_scorePerCandidateK_

private

per-candidate (k, order-score) pairs from the last learnKTBN() run, in ascending k. One entry appended per candidate; read by scorePerCandidateK(). Cleared at the start of each learnKTBN() (empty while bestK == 0).

Definition at line 634 of file KTBNAdaptiveLearner.h.

Referenced by learnKTBN(), and scorePerCandidateK().

◆ _tabuSize_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_tabuSize_ {100}

private

tabu-list parameters (meaningful when algo is LOCAL_SEARCH_WITH_TABU_LIST)

Definition at line 568 of file KTBNAdaptiveLearner.h.

Referenced by _applyConfig_(), state(), and useLocalSearchWithTabuList().

◆ C

template<GUM_Numeric GUM_SCALAR>

log_2 gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::C {r_i}_{N_{ij}}@f$

Select k by fNML (factorized Normalized Maximum Likelihood): keep the k whose learned model maximises .

Definition at line 279 of file KTBNAdaptiveLearner.h.

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

agrum/KTBN/learning/KTBNAdaptiveLearner.h
agrum/KTBN/learning/KTBNAdaptiveLearner_tpl.h

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Order selection (cross-k model selection)

Name encoding: (base, slice) <-> engine name

Detailed Description

Member Enumeration Documentation

◆ OrderScoreType

Constructor & Destructor Documentation

◆ KTBNAdaptiveLearner() [1/5]

◆ KTBNAdaptiveLearner() [2/5]

◆ KTBNAdaptiveLearner() [3/5]

◆ ~KTBNAdaptiveLearner()

◆ KTBNAdaptiveLearner() [4/5]

◆ KTBNAdaptiveLearner() [5/5]

Member Function Documentation

◆ _applyConfig_()

◆ _applyConstraints_()

◆ _atemporalVarNames_()

◆ _checkArcTemporallyFeasible_()

◆ _checkBaseIsTemporal_()

◆ _checkMinimalOrder_()

◆ _countParameters_()

◆ _determineNode_()

◆ _encode_()

◆ _fNMLScore_()

◆ _forEachScoredNode_()

◆ _inferAtemporalVars_()

◆ _isKnownBase_()

◆ _log2Likelihood_()

◆ _orderSelectionScore_()

◆ _raiseKMinForSlice_()

◆ _recomputeKMin_()

◆ _scanConstantColumns_()

◆ _verifyBase_()

◆ _verifyKernelArc_()

◆ addForbiddenArc() [1/2]

◆ addForbiddenArc() [2/2]

◆ addForbiddenArcAllSlices()

◆ addForbiddenIntraSliceArc()

◆ addForbiddenKernelArc()

◆ addMandatoryArc() [1/2]

◆ addMandatoryArc() [2/2]

◆ addMandatoryKernelArc()

◆ addNoChildrenNode() [1/2]

◆ addNoChildrenNode() [2/2]

◆ addNoParentNode() [1/2]

◆ addNoParentNode() [2/2]

◆ addPossibleEdge() [1/2]

◆ addPossibleEdge() [2/2]

◆ allowArcAdditions()

◆ allowArcDeletions()

◆ allowArcReversals()

◆ bestK()

◆ checkScorePriorCompatibility()

◆ eraseForbiddenArc() [1/2]

◆ eraseForbiddenArc() [2/2]

◆ eraseForbiddenArcAllSlices()

◆ eraseForbiddenIntraSliceArc()

◆ eraseForbiddenKernelArc()

◆ eraseMandatoryArc() [1/2]

◆ eraseMandatoryArc() [2/2]

◆ eraseMandatoryKernelArc()

◆ eraseNoChildrenNode() [1/2]

◆ eraseNoChildrenNode() [2/2]

◆ eraseNoParentNode() [1/2]

◆ eraseNoParentNode() [2/2]

◆ erasePossibleEdge() [1/2]

◆ erasePossibleEdge() [2/2]

◆ ignoreMissingSymbols()

◆ isIgnoringMissingSymbols()

◆ kMax()

◆ latentVariables()

◆ learnKTBN()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ scorePerCandidateK()

◆ setMaxIndegree()

◆ state()