Learns a k-TBN (structure and/or parameters) from trajectory CSVs. More...

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

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

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

Public Member Functions
Constructors / Destructors
	KTBNLearner (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size k, const std::unordered_set< std::string > &atemporalVars, const std::vector< std::string > &missingSymbols={"?"}, bool induceTypes=true, bool ignoreMissingSymbols=false)
	Structure-learning constructor — variable roles supplied explicitly.
	KTBNLearner (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size k, const std::vector< std::string > &missingSymbols={"?"}, bool induceTypes=true, bool ignoreMissingSymbols=false)
	Structure-learning constructor — atemporal variables inferred from the CSVs.
	KTBNLearner (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, Size k, const BayesNet< GUM_SCALAR > &bn, const std::unordered_set< std::string > &atemporalVars={}, const std::vector< std::string > &missingSymbols={"?"}, bool ignoreMissingSymbols=false)
	Variable-schema constructor — types and domains supplied via a BN.
	~KTBNLearner ()
	destructor
Main learning methods
KTBN< GUM_SCALAR >	learnKTBN () override
	Full learning (structure + CPTs). Mirrors BNLearner::learnBN().
KTBN< GUM_SCALAR >	learnParameters (const KTBN< GUM_SCALAR > &structure, bool takeIntoAccountScore=true)
	CPTs only, using the arc structure of `structure`. `structure` must have the same base variables (names and domains) as those used to construct this learner; mismatches throw at learn time.
Score selection (applied to all internal learners)
KTBNLearner< GUM_SCALAR > &	useScoreAIC () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
KTBNLearner< GUM_SCALAR > &	useScoreBD () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
KTBNLearner< GUM_SCALAR > &	useScoreBDeu () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
KTBNLearner< GUM_SCALAR > &	useScoreBIC () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
KTBNLearner< GUM_SCALAR > &	useScoreLog2Likelihood () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
KTBNLearner< GUM_SCALAR > &	useScoreMDL () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
void	useScorefNML () override
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
std::string	checkScorePriorCompatibility () const
	Returns a warning string if the current score and prior are incompatible, empty string otherwise.
Algorithm selection (applied to all internal learners)
KTBNLearner< GUM_SCALAR > &	useGreedyHillClimbing () override
KTBNLearner< GUM_SCALAR > &	useExtendedGreedyHillClimbing () override
KTBNLearner< GUM_SCALAR > &	useLocalSearchWithTabuList (Size tabu_size=100, Size nb_decrease=2) override
KTBNLearner< GUM_SCALAR > &	useMIIC () override
MIIC correction (applied to all internal learners)
KTBNLearner< GUM_SCALAR > &	useNMLCorrection () override
	Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.
KTBNLearner< GUM_SCALAR > &	useMDLCorrection () override
	Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.
KTBNLearner< GUM_SCALAR > &	useNoCorrection () override
	Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.
std::vector< std::pair< std::string, std::string > >	latentVariables () const
	Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.
Prior selection (applied to all internal learners)
KTBNLearner< GUM_SCALAR > &	useSmoothingPrior (double weight=1.0) override
Structural constraints (base names, translated to the relevant internal learner(s))
KTBNLearner< GUM_SCALAR > &	addForbiddenArc (std::string_view tailNode, std::string_view headNode) override
	Forbid `tailNode` from ever parenting `headNode` (engine names, e.g. "X[1]", "C").
KTBNLearner< GUM_SCALAR > &	addForbiddenArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Forbid one (base, slice) -> (base, slice) arc (KTBN::ATEMPORAL for static). A backward arc (`tailSlice` > `headSlice`) is accepted but has no effect: such an arc is already impossible, so forbidding it is a harmless no-op.
KTBNLearner< GUM_SCALAR > &	eraseForbiddenArc (std::string_view tailNode, std::string_view headNode) override
	Undo a previous addForbiddenArc (engine names, e.g. "X[1]", "C").
KTBNLearner< GUM_SCALAR > &	eraseForbiddenArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Undo a previous addForbiddenArc for a specific (base, slice) pair.
KTBNLearner< GUM_SCALAR > &	addMandatoryArc (std::string_view tailNode, std::string_view headNode) override
	Force `tailNode` to be a parent of `headNode` (engine names, e.g. "X[1]", "C").
KTBNLearner< GUM_SCALAR > &	addMandatoryArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Force one arc, lag stated explicitly via slices (KTBN::ATEMPORAL for static).
KTBNLearner< GUM_SCALAR > &	eraseMandatoryArc (std::string_view tailNode, std::string_view headNode) override
	Undo a previous addMandatoryArc (engine names, e.g. "X[1]", "C").
KTBNLearner< GUM_SCALAR > &	eraseMandatoryArc (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Undo a previous addMandatoryArc.
KTBNLearner< GUM_SCALAR > &	addForbiddenIntraSliceArc (std::string_view tailBase, std::string_view headBase) override
	Forbid `tailBase` -> `headBase` at every intra-slice position (i.e. tailBase[t] -> headBase[t] for all t in [0, k-1]).
KTBNLearner< GUM_SCALAR > &	eraseForbiddenIntraSliceArc (std::string_view tailBase, std::string_view headBase) override
	Undo a previous addForbiddenIntraSliceArc.
KTBNLearner< GUM_SCALAR > &	addForbiddenArcAllSlices (std::string_view tailBase, std::string_view headBase) override
	Forbid `tailBase` -> `headBase` at every causally-possible slice pair (every lag, not just matching slices): tailBase can never be an ancestor of headBase in the learned k-TBN. A temporal->atemporal pair is a no-op (already structurally impossible).
KTBNLearner< GUM_SCALAR > &	eraseForbiddenArcAllSlices (std::string_view tailBase, std::string_view headBase) override
	Undo a previous addForbiddenArcAllSlices.
KTBNLearner< GUM_SCALAR > &	addNoParentNode (std::string_view base, int slice) override
	Declare a single (base, slice) node as a root (no parents).
KTBNLearner< GUM_SCALAR > &	addNoParentNode (std::string_view name) override
	Declare a single node (bracket notation, e.g. "X[2]" or "C") as a root.
KTBNLearner< GUM_SCALAR > &	eraseNoParentNode (std::string_view base, int slice) override
	Undo a previous addNoParentNode for a single (base, slice) node.
KTBNLearner< GUM_SCALAR > &	eraseNoParentNode (std::string_view name) override
	Undo addNoParentNode for a node given by bracket notation.
KTBNLearner< GUM_SCALAR > &	addNoChildrenNode (std::string_view base, int slice) override
	Declare a single (base, slice) node as a leaf (no children).
KTBNLearner< GUM_SCALAR > &	addNoChildrenNode (std::string_view name) override
	Declare a single node (bracket notation, e.g. "X[2]" or "C") as a leaf.
KTBNLearner< GUM_SCALAR > &	eraseNoChildrenNode (std::string_view base, int slice) override
	Undo a previous addNoChildrenNode for a single (base, slice) node.
KTBNLearner< GUM_SCALAR > &	eraseNoChildrenNode (std::string_view name) override
	Undo addNoChildrenNode for a node given by bracket notation.
KTBNLearner< GUM_SCALAR > &	addPossibleEdge (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Add a candidate edge for MIIC (only edges explicitly listed are explored).
KTBNLearner< GUM_SCALAR > &	addPossibleEdge (std::string_view tail, std::string_view head) override
	Add a candidate edge for MIIC using engine names (e.g. "X[1]", "C").
KTBNLearner< GUM_SCALAR > &	erasePossibleEdge (std::string_view tailBase, int tailSlice, std::string_view headBase, int headSlice) override
	Undo a previous addPossibleEdge.
KTBNLearner< GUM_SCALAR > &	erasePossibleEdge (std::string_view tail, std::string_view head) override
	Undo a previous addPossibleEdge using engine names (e.g. "X[1]", "C").
KTBNLearner< GUM_SCALAR > &	allowArcAdditions (bool allow=true) override
	Allow or forbid arc additions during structure search.
KTBNLearner< GUM_SCALAR > &	allowArcDeletions (bool allow=true) override
	Allow or forbid arc deletions during structure search.
KTBNLearner< GUM_SCALAR > &	allowArcReversals (bool allow=true) override
	Allow or forbid arc reversals during structure search.
KTBNLearner< GUM_SCALAR > &	setMaxIndegree (Size max_indegree) override
	Cap the number of parents of any single node.
Diagnostics
Size	k () const
	Order \(k\) of the k-TBN being learned.
Size	nbCols () const
	Number of columns in each CSV, i.e. of base variables (temporal + atemporal).
std::vector< Size >	nbRows () const
	Number of time steps in each trajectory CSV (one entry per sample, in load order). This is the raw trajectory length; the transition table's sliding-window row count for trajectory `i` is `nbRows()`[i] - k + 1.
bool	isConstraintBased () const
	True if the current structure-learning algorithm is constraint-based (e.g. MIIC).
bool	isScoreBased () const
	True if the current structure-learning algorithm is score-based (e.g. BIC, AIC).
std::string	toString () const
	Human-readable summary of the learner's current configuration.
std::vector< std::tuple< std::string, std::string, std::string > >	state () const
	Settings as a vector of (key, value, comment) tuples (mirrors BNLearner::state()).
void	copyState (const KTBNLearner< GUM_SCALAR > &learner)
	Copy all score/algorithm/prior/constraint settings from another KTBNLearner (does not copy the database).
Database accessors
Size	nbSamples () const
	Number of trajectory CSV files loaded (the constructor's `nbSamples`).
bool	hasMissingValues () const
	True if any internal database contains missing values.
Size	nbDroppedRows () const
	Number of rows dropped from the internal databases because they carried a missing symbol.
bool	isIgnoringMissingSymbols () const
	Whether build() drops the rows carrying a missing symbol.
std::vector< std::string >	names () const
	Base names (no slice suffix), one entry per base variable (temporal or atemporal), in the original CSV header order.
std::vector< std::size_t >	domainSizes () const
	Domain sizes of the base variables, in the same column order as names().
Size	domainSize (std::string_view base) const
	Domain size of the base variable `base` (e.g. "X", "C"). Engine names (e.g. "X[1]") are also accepted.

Private Member Functions
template<class F>
void	_forEachLearner_ (F &&f)
	Apply `f` to each present internal learner (the atemporal one only when it exists). Factors out the fan-out shared by every score / algorithm / prior / correction / graph-change setter.
template<class F>
void	_forOwningLearner_ (std::string_view tail, std::string_view head, F &&f)
	Apply `f` to the ONE internal learner that can learn the arc `tail` -> `head`, chosen by its head: a slice-(k-1) head belongs to the transition learner, an atemporal->atemporal arc to the atemporal learner, any other head (a past temporal slice) to the initial learner. The three cases are exclusive because build() forces every other node root in the learners that do not own it, so no arc is ever learnable in two of them.
template<class F>
void	_forEachAllSlicesPair_ (std::string_view tailBase, std::string_view headBase, F &&f) const
	Apply `f(tailSlice, headSlice)` to every causally-possible slice pair of an all-slices constraint between `tailBase` and `headBase`. Four shapes: atemporal->atemporal is one pair; an atemporal tail reaches every slice of the head; a temporal tail into an atemporal head is structurally impossible and yields none; two temporal bases give every pair with tailSlice <= headSlice, i.e. every lag.
void	_build_ (std::string_view dirPath, std::string_view csvBaseName, Size nbSamples, const std::vector< std::string > &missingSymbols)
	reads every trajectory, builds the three DatabaseTables (sliding window, initial-slice flattening, atemporal columns), constructs the BNLearners from them and applies the automatic temporal constraints (slice order, root past slices, temporal->atemporal forbids). Relies solely on prior_ktbn (already fully populated by the time it runs): the column order is read from the first trajectory's header and the atemporal columns are derived from prior_ktbn.atemporalVarNames(). Shared by both constructors.
const std::unordered_set< std::string > &	_atemporalVarNames_ () const override
	atemporal base names for IKTBNLearner's shared encode/_determineNode_; read straight from the prior k-TBN (the single source of truth).
bool	_isKnownBase_ (std::string_view base) const override
	whether `base` is one of this learner's variables; read straight from the prior k-TBN, like atemporalVarNames() above.
KTBN< GUM_SCALAR >	_assemble_ (const BayesNet< GUM_SCALAR > &transitionBN, const BayesNet< GUM_SCALAR > &initialBN, const BayesNet< GUM_SCALAR > &atemporalBN) const
	glues the three parameter-learned BNs into a single k-TBN
	KTBNLearner (const KTBNLearner< GUM_SCALAR > &)=delete
	KTBNLearner (KTBNLearner< GUM_SCALAR > &&)=delete
KTBNLearner< GUM_SCALAR > &	operator= (const KTBNLearner< GUM_SCALAR > &)=delete
KTBNLearner< GUM_SCALAR > &	operator= (KTBNLearner< 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 k, const std::vector< std::string > &missingSymbols)
	checks `k` >= 2, then delegates the actual scan to the shared IKTBNLearner::scanConstantColumns() (also used by KTBNAdaptiveLearner, hence not duplicated here). The check happens first and here, not inside the shared scan: called once, in the member-initialiser list of the atemporal-inferring constructor, before prior_ktbn exists — before that constructor's body runs the equivalent check in buildPriorFromCSV — so without it here too, a bad `k` would only be caught after a wasted scan of every trajectory.
static KTBN< GUM_SCALAR >	_buildPriorFromCSV_ (std::string_view dirPath, std::string_view csvBaseName, Size k, const std::unordered_set< std::string > &atemporalVars, const std::vector< std::string > &missingSymbols, bool induceTypes)
	called in the member-initialiser list of the k-CSV constructor: opens the first trajectory CSV, uses a temporary BNLearner to type the base variables (induceTypes promotes numeric columns to range/integer), builds and returns a KTBN with the right temporal/atemporal classification. Must be static because it is called before the object exists.
static KTBN< GUM_SCALAR >	_buildPriorFromBN_ (Size k, const BayesNet< GUM_SCALAR > &bn, const std::unordered_set< std::string > &atemporalVars)
	called in the member-initialiser list of the BN constructor: builds and returns a KTBN whose variables are copied from `bn` (one node per base variable, right types/domains) and classified as temporal/atemporal according to `atemporalVars`. Must be static because it is called before the object exists.

Private Attributes
std::unique_ptr< BNLearner< GUM_SCALAR > >	_transitionLearner_
	learns the transition kernel (arcs arriving at slice k-1)
std::unique_ptr< BNLearner< GUM_SCALAR > >	_initialLearner_
	learns the initial slices 0..k-2
std::unique_ptr< BNLearner< GUM_SCALAR > >	_atemporalLearner_
	learns the atemporal variables (arcs atemporal -> atemporal)
bool	_ignoreMissingSymbols_ {false}
	prior k-TBN: the single source of truth for k, variable domains, temporal/atemporal classification and engine names. Everything else (base lists, column names) is derived from it on demand. Analogous to the prior BayesNet stored in BNLearner when a reference BN is given. whether build() drops incomplete rows rather than refusing the data
KTBN< GUM_SCALAR >	_prior_ktbn_
Size	_nbDroppedRows_ {0}
	number of time steps (rows) in each trajectory CSV, in load order. rows build() dropped because they carried a missing symbol
std::vector< Size >	_nbTimeSlices_
	Captured once by build() and exposed by nbRows(). This is the raw trajectory length, not the sliding-window row count of the transition table (which is nbTimeSlices[i] - k + 1 summed over trajectories).
Size	_nbTemporalPossibleEdges_ = 0
	counts of currently-active possible edges, split by kind: edges with at least one temporal endpoint, and edges between two atemporal variables. Maintained by add/erasePossibleEdge(). When a whitelist is active (temporal count > 0) but no atemporal->atemporal edge is whitelisted, the atemporal learner would otherwise stay unrestricted; learnKTBN() then suppresses it so the whitelist is honoured (no atemporal arc is produced).
Size	_nbAtemporalPossibleEdges_ = 0

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::KTBNLearner< GUM_SCALAR >

Learns a k-TBN (structure and/or parameters) from trajectory CSVs.

See also: gum::learning::BNLearner, the static Bayesian-network counterpart whose API this class mirrors. KTBNLearner delegates score / algorithm / prior / constraint settings to three internal BNLearner instances (one per table).

Implements gum::learning::IKTBNLearner, the configuration interface shared with gum::learning::KTBNAdaptiveLearner (which learns k as well): here the setters apply each setting to the internal learners immediately, since k is fixed at construction.

Definition at line 115 of file KTBNLearner.h.

Constructor & Destructor Documentation

◆ KTBNLearner() [1/5]

template<GUM_Numeric GUM_SCALAR>

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

Structure-learning constructor — variable roles supplied explicitly.

Use this constructor when you want to learn the k-TBN structure from the data. The order \(k\) and the atemporal variable list must be given because they cannot be reliably inferred from the CSVs alone. Variable domains (modality counts) are read from the CSV data.

Internally calls _buildPriorFromCSV_() then _build_().

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.
k	Order of the k-TBN. Must be \(\geq 2\).
atemporalVars	Base names of the atemporal (static) variables. All other variables found in the CSV header are treated as temporal. 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 gum::learning::BNLearner.
ignoreMissingSymbols	When true, a row carrying a missing symbol is dropped rather than handed to the internal learners, which cannot cope with one (see nbDroppedRows() and its warning on the distortion this introduces). When false (the default), such data is refused outright.

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 131 of file KTBNLearner_tpl.h.

                                                                    :
      _ignoreMissingSymbols_(ignoreMissingSymbols), _prior_ktbn_(_buildPriorFromCSV_(dirPath,
                                                                                     csvBaseName,
                                                                                     k,
                                                                                     atemporalVars,
                                                                                     missingSymbols,
                                                                                     induceTypes)) {
    // k >= 2 is already enforced by _buildPriorFromCSV_ during member initialisation
    if (nbSamples == 0) GUM_ERROR(InvalidArgument, "KTBNLearner needs at least one sample")
    GUM_CONSTRUCTOR(KTBNLearner)
    try {
      _build_(dirPath, csvBaseName, nbSamples, missingSymbols);
    } catch (const gum::UnknownLabelInDatabase&) {
      // Domains are inferred from trajectory 1 alone, so a variable whose full
      // domain is absent there fails once a later trajectory shows a new label.
      // Atemporal variables are the usual culprits: constant within a trajectory,
      // they reveal only one value per file. Re-throw with a KTBN-specific hint.
      GUM_DESTRUCTOR(KTBNLearner)
      GUM_ERROR(UnknownLabelInDatabase,
                "KTBNLearner CSV constructor: an unknown label was encountered while "
                "reading the trajectory CSVs. The variable domains are inferred from "
                "the first CSV alone, so any variable whose modalities are not all "
                "present in trajectory 1 will trigger this error (atemporal variables "
                "are especially prone: each trajectory holds a single constant value "
                "for them, so at most one label appears in trajectory 1). "
                "Use the BN-schema constructor "
                "KTBNLearner(dir, base, n, k, bn, atemporals) to supply the full "
                "variable domains explicitly.")
    } catch (...) {
      GUM_DESTRUCTOR(KTBNLearner)
      throw;
    }
  }

References KTBNLearner(), _build_(), _buildPriorFromCSV_(), _ignoreMissingSymbols_, _prior_ktbn_, GUM_ERROR, k(), and nbSamples().

Referenced by KTBNLearner(), KTBNLearner(), KTBNLearner(), KTBNLearner(), KTBNLearner(), ~KTBNLearner(), addForbiddenArc(), addForbiddenArc(), addMandatoryArc(), addMandatoryArc(), addNoChildrenNode(), addNoChildrenNode(), addNoParentNode(), addNoParentNode(), addPossibleEdge(), addPossibleEdge(), allowArcAdditions(), allowArcDeletions(), allowArcReversals(), copyState(), eraseForbiddenArc(), eraseMandatoryArc(), eraseNoChildrenNode(), eraseNoChildrenNode(), eraseNoParentNode(), eraseNoParentNode(), erasePossibleEdge(), erasePossibleEdge(), operator=(), operator=(), setMaxIndegree(), useExtendedGreedyHillClimbing(), useGreedyHillClimbing(), useMDLCorrection(), useMIIC(), useNMLCorrection(), useNoCorrection(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScoreLog2Likelihood(), useScoreMDL(), and useSmoothingPrior().

Here is the call graph for this function:

◆ KTBNLearner() [2/5]

template<GUM_Numeric GUM_SCALAR>

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

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

Same as the explicit-atemporalVars constructor, except the temporal/atemporal classification is inferred instead of supplied: a base variable is classified atemporal iff its value never changes across the rows of any single trajectory. It may still differ between trajectories — this matches the model's actual semantics (constant through time, not constant across samples) rather than requiring one global value, e.g. a per-individual static covariate such as an age or a site identifier. A column with too few non-missing values to ever witness a change is optimistically classified atemporal.

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

Warning: Variable domains are still discovered from trajectory 1 alone (see the explicit-atemporalVars constructor). An inferred atemporal variable is, by construction, one whose value may vary between trajectories — exactly the case most likely to reveal only one of several modalities in trajectory 1 and later throw UnknownLabelInDatabase. Use the BN-schema constructor if the full domain cannot be guaranteed present in the first trajectory.

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.
k	Order of the k-TBN. 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.
ignoreMissingSymbols	When true, a row carrying a missing symbol is dropped rather than handed to the internal learners, which cannot cope with one (see nbDroppedRows() and its warning on the distortion this introduces). When false (the default), such data is refused outright.

Definition at line 173 of file KTBNLearner_tpl.h.

                                                                                                 :
      // _inferAtemporalVars_ checks k>=2 itself, before opening anything (see
      // its declaration) — this initialiser-list call runs before the
      // delegated-to constructor's own body, so that check cannot be left to
      // _buildPriorFromCSV_ the way the explicit constructor leaves it.
      // Delegates to the explicit-atemporalVars constructor for the rest
      // (including the UnknownLabelInDatabase hint); _inferAtemporalVars_
      // needs nbSamples, unlike _buildPriorFromCSV_, since one trajectory
      // alone cannot show that a value stays constant.
      KTBNLearner(dirPath,
                  csvBaseName,
                  nbSamples,
                  k,
                  _inferAtemporalVars_(dirPath, csvBaseName, nbSamples, k, missingSymbols),
                  missingSymbols,
                  induceTypes,
                  ignoreMissingSymbols) {}

References KTBNLearner(), _inferAtemporalVars_(), k(), and nbSamples().

Here is the call graph for this function:

◆ KTBNLearner() [3/5]

template<GUM_Numeric GUM_SCALAR>

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

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

Use this constructor when the variable types and domains are already known (e.g. from a reference BN). The BN must contain exactly one node per base variable (temporal or atemporal), with the correct DiscreteVariable type and domain. Arcs in bn are ignored.

Internally calls _buildPriorFromBN_() then _build_().

Parameters

dirPath	Directory holding the trajectory CSV files.
csvBaseName	Stem of each file name.
nbSamples	Number of CSV files to read.
k	Order of the k-TBN. Must be \(\geq 2\).
bn	A BayesNet with one node per base variable providing variable types and domains. Atemporal variables are identified by `atemporalVars`.
atemporalVars	Base names of the atemporal (static) variables present in `bn`.
missingSymbols	Symbols in the CSVs to interpret as missing values.
ignoreMissingSymbols	When true, a row carrying a missing symbol is dropped rather than handed to the internal learners, which cannot cope with one (see nbDroppedRows() and its warning on the distortion this introduces). When false (the default), such data is refused outright.

Definition at line 198 of file KTBNLearner_tpl.h.

                                                                    :
      _ignoreMissingSymbols_(ignoreMissingSymbols),
      _prior_ktbn_(_buildPriorFromBN_(k, bn, atemporalVars)) {
    // k >= 2 is already enforced by _buildPriorFromBN_ during member initialisation
    if (nbSamples == 0) GUM_ERROR(InvalidArgument, "KTBNLearner needs at least one sample")
    GUM_CONSTRUCTOR(KTBNLearner)
    try {
      _build_(dirPath, csvBaseName, nbSamples, missingSymbols);
    } catch (...) {
      GUM_DESTRUCTOR(KTBNLearner)
      throw;
    }
  }

References KTBNLearner(), _build_(), _buildPriorFromBN_(), _ignoreMissingSymbols_, _prior_ktbn_, GUM_ERROR, k(), and nbSamples().

Here is the call graph for this function:

◆ ~KTBNLearner()

template<GUM_Numeric GUM_SCALAR>

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

destructor

Definition at line 220 of file KTBNLearner_tpl.h.

                                          {
    GUM_DESTRUCTOR(KTBNLearner)
  }

References KTBNLearner().

Here is the call graph for this function:

◆ KTBNLearner() [4/5]

template<GUM_Numeric GUM_SCALAR>

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

privatedelete

References KTBNLearner().

Here is the call graph for this function:

◆ KTBNLearner() [5/5]

template<GUM_Numeric GUM_SCALAR>

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

privatedelete

References KTBNLearner().

Here is the call graph for this function:

Member Function Documentation

◆ _assemble_()

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::learning::KTBNLearner< GUM_SCALAR >::_assemble_	(	const BayesNet< GUM_SCALAR > &	transitionBN,
		const BayesNet< GUM_SCALAR > &	initialBN,
		const BayesNet< GUM_SCALAR > &	atemporalBN ) const

private

glues the three parameter-learned BNs into a single k-TBN

Definition at line 1311 of file KTBNLearner_tpl.h.

                                                                                             {
    const int k = (int)_prior_ktbn_.k();
 
    // 1. Base: initialBN provides slices 0..k-2 (temporal structure + CPTs, and
    //    atemporal→temporal arcs). Atemporal variables enter only as forced roots;
    //    steps 4 and 6 overwrite their mutual structure and CPTs from atemporalBN
    //    (transitionBN repeats each atemporal value k-fold — not independent samples).
    BayesNet< GUM_SCALAR > bn(initialBN);
 
    // 2. Add the slice k-1 variables from transitionBN (absent from initialBN).
    for (const auto& base: _prior_ktbn_.temporalVarNames()) {
      const std::string name    = _encode_(base, k - 1);
      const NodeId      transId = transitionBN.idFromName(name);
      bn.add(transitionBN.variable(transId));
    }
 
    // 3. Add the arcs arriving at slice k-1 from transitionBN
    for (const auto& base: _prior_ktbn_.temporalVarNames()) {
      const std::string headName  = _encode_(base, k - 1);
      const NodeId      transHead = transitionBN.idFromName(headName);
      for (const NodeId transParent: transitionBN.parents(transHead)) {
        const std::string& parentName = transitionBN.variable(transParent).name();
        bn.addArc(parentName, headName);
      }
    }
 
    // 4. Add the atemporal -> atemporal arcs from atemporalBN. Skipped when
    //    atemporalBN is an empty placeholder: either <= 1 atemporal variable (no
    //    learner is built, see _build_()) or the learner was suppressed by a
    //    temporal-only possible-edge whitelist (see learnKTBN()). Either way the
    //    atemporal variables already sit in bn as roots, via initialBN.
    if (atemporalBN.size() != 0) {
      for (const auto& atemBase: _prior_ktbn_.atemporalVarNames()) {
        const NodeId atemTail = atemporalBN.idFromName(atemBase);
        for (const NodeId atemChild: atemporalBN.children(atemTail)) {
          const std::string& childName = atemporalBN.variable(atemChild).name();
          bn.addArc(atemBase, childName);
        }
      }
    }
 
    // 5. Fill the slice k-1 CPTs from transitionBN
    for (const auto& base: _prior_ktbn_.temporalVarNames()) {
      const std::string name    = _encode_(base, k - 1);
      const NodeId      bnId    = bn.idFromName(name);
      const NodeId      transId = transitionBN.idFromName(name);
      bn.cpt(bnId).fillWith(transitionBN.cpt(transId));
    }
 
    // 6. Fill the atemporal CPTs from atemporalBN (same guard as step 4); when
    //    skipped, the atemporal variables keep their initialBN marginal.
    if (atemporalBN.size() != 0) {
      for (const auto& atemBase: _prior_ktbn_.atemporalVarNames()) {
        const NodeId bnId   = bn.idFromName(atemBase);
        const NodeId atemId = atemporalBN.idFromName(atemBase);
        bn.cpt(bnId).fillWith(atemporalBN.cpt(atemId));
      }
    }
 
    // 7. Convert the assembled flat BN into a KTBN: fromBN infers k from the
    //    highest bracket index and validates temporal causality.
    return KTBN< GUM_SCALAR >::fromBN(bn);
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _prior_ktbn_, gum::KTBN< GUM_SCALAR >::fromBN(), and k().

Referenced by learnKTBN(), and learnParameters().

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::KTBNLearner< GUM_SCALAR >::_atemporalVarNames_ ( ) const

overrideprivatevirtual

atemporal base names for IKTBNLearner's shared encode/_determineNode_; read straight from the prior k-TBN (the single source of truth).

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

Definition at line 1298 of file KTBNLearner_tpl.h.

                                                                                            {
    return _prior_ktbn_.atemporalVarNames();
  }

References _prior_ktbn_.

◆ _build_()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::KTBNLearner< GUM_SCALAR >::_build_	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		const std::vector< std::string > &	missingSymbols )

private

reads every trajectory, builds the three DatabaseTables (sliding window, initial-slice flattening, atemporal columns), constructs the BNLearners from them and applies the automatic temporal constraints (slice order, root past slices, temporal->atemporal forbids). Relies solely on prior_ktbn (already fully populated by the time it runs): the column order is read from the first trajectory's header and the atemporal columns are derived from prior_ktbn.atemporalVarNames(). Shared by both constructors.

Definition at line 994 of file KTBNLearner_tpl.h.

                                                                                        {
    Size k           = _prior_ktbn_.k();
    Size nbTempVars  = _prior_ktbn_.temporalVarNames().size();
    Size nbAtempVars = _prior_ktbn_.atemporalVarNames().size();
 
    // tables are default-constructed here; translators are inserted per-column
    // in the i==0 block once the header (column order) is known
    DatabaseTable transitionTable(missingSymbols);
    DatabaseTable initTable(missingSymbols);
    DatabaseTable atemporalTable(missingSymbols);
 
    // Complete-case selection, at row granularity.
    //
    // aGrUM's structure learning refuses a database holding any missing value
    // outright (IBNLearner::learnDag_), so an incomplete row cannot simply be
    // handed over: learnKTBN() would throw on any trajectory with a gap. A row
    // that carries one is therefore dropped here, and everything downstream sees
    // a database with no missing value at all.
    //
    // This mirrors what the cross-k score already does per instance
    // (KTBNAdaptiveLearner::_forEachScoredNode_ skips any instance whose family
    // is not fully observed), so the two layers agree on which data counts.
    //
    // The unit differs per table: a transition row is a whole width-k window, so
    // one gap costs up to k windows; an initial or atemporal row is the whole
    // trajectory's contribution to that table.
    const std::unordered_set< std::string > missingSet(missingSymbols.begin(),
                                                       missingSymbols.end());
    const auto insertIfComplete = [&](DatabaseTable& table, const std::vector< std::string >& r) {
      if (_ignoreMissingSymbols_) {
        for (const auto& cell: r)
          if (missingSet.contains(cell)) {
            ++_nbDroppedRows_;
            return;
          }
      }
      table.insertRow(r);
    };
 
    const std::filesystem::path dir{dirPath};
    const std::string           stem{csvBaseName};
 
    const std::size_t transRowSize = nbAtempVars + nbTempVars * k;
    const std::size_t initRowSize  = nbAtempVars + nbTempVars * (k - 1);
    const std::size_t atempRowSize = nbAtempVars;
 
    std::vector< std::string > header;         // column order, captured from trajectory 1
    std::unordered_set< Size > atemVarsCols;   // atemporal column indices
 
    // reused across trajectories (capacity is kept between iterations)
    std::vector< std::vector< std::string > > buffer;
    std::vector< std::string >                row;
    row.reserve(transRowSize);
    _nbTimeSlices_.reserve(nbSamples);   // one raw length per trajectory (see nbRows())
 
    for (Size i = 0; i < nbSamples; ++i) {
      // open the i-th trajectory (each file is opened exactly once)
      const std::filesystem::path file = dir / (stem + std::to_string(i + 1) + ".csv");
      std::ifstream               is(file, std::ifstream::in);
      if (!is.is_open()) GUM_ERROR(gum::IOError, "Cannot open " << file.string());
 
      CSVParser parser(is, file.string());
      parser.next();
 
      if (i == 0) {
        // first file only: capture the column order, derive the atemporal columns
        // from _prior_ktbn_, build the bracket-encoded names and finish setting up the
        // tables (must happen before any insertRow)
        const auto& rawHeader = parser.current();
        header.assign(rawHeader.begin(), rawHeader.end());
        for (std::size_t c = 0; c < header.size(); ++c)
          if (_prior_ktbn_.atemporalVarNames().contains(header[c])) atemVarsCols.insert(c);
 
        // every schema variable must appear in the data, else _assemble_ (used
        // by both learnKTBN and learnParameters) would later fail with an
        // opaque NotFound when resolving bracket names
        {
          const std::unordered_set< std::string > headerSet(header.begin(), header.end());
          auto                                    requirePresent = [&](const std::string& base) {
            if (!headerSet.contains(base))
              GUM_ERROR(MissingVariableInDatabase,
                        "schema variable '" << base << "' is absent from '" << file.string() << "'")
          };
          for (const auto& base: _prior_ktbn_.temporalVarNames())
            requirePresent(base);
          for (const auto& base: _prior_ktbn_.atemporalVarNames())
            requirePresent(base);
 
          // conversely, every CSV column must be a known schema variable, else the
          // translator-insertion loop below would fail with an opaque NotFound
          // when resolving it against _prior_ktbn_
          for (const std::string& col: header)
            if (!_prior_ktbn_.exists(col))
              GUM_ERROR(MissingVariableInDatabase,
                        "CSV column '" << col << "' in '" << file.string()
                                       << "' is not declared as a variable of this KTBNLearner")
        }
 
        // insert one translator per column into each table; every schema variable
        // has a concrete domain (user-supplied, or discovered by _buildPriorFromCSV_), so
        // insertTranslator picks the matching translator type from the variable.
        std::vector< std::string > varNamesTran;
        std::vector< std::string > varNamesInit;
        std::vector< std::string > varNamesAtemp;
        {
          auto insertTrans
              = [&](DatabaseTable& table, const std::string& base, int slice, std::size_t col) {
                  table.insertTranslator(_prior_ktbn_.variable(base, slice), col, missingSymbols);
                };
 
          // translators and their engine names are built in lockstep, column by
          // column, so a translator's table position and its name can never drift
          // apart (unlike keeping two separately-indexed passes in sync by hand).
          varNamesTran.reserve(transRowSize);
          varNamesInit.reserve(initRowSize);
          varNamesAtemp.reserve(atempRowSize);
 
          std::size_t tcol = 0, icol = 0, acol = 0;
          for (std::size_t c = 0; c < header.size(); ++c) {
            const int slice = atemVarsCols.contains(c) ? KTBN< GUM_SCALAR >::ATEMPORAL : 0;
            insertTrans(transitionTable, header[c], slice, tcol++);
            varNamesTran.push_back(_encode_(header[c], slice));
            insertTrans(initTable, header[c], slice, icol++);
            varNamesInit.push_back(_encode_(header[c], slice));
            if (atemVarsCols.contains(c)) {
              insertTrans(atemporalTable, header[c], KTBN< GUM_SCALAR >::ATEMPORAL, acol++);
              varNamesAtemp.push_back(header[c]);
            }
          }
          for (Size slice = 1; slice < k - 1; ++slice)
            for (std::size_t c = 0; c < header.size(); ++c)
              if (!atemVarsCols.contains(c)) {
                insertTrans(initTable, header[c], (int)slice, icol++);
                varNamesInit.push_back(_encode_(header[c], (int)slice));
              }
          for (Size slice = 1; slice < k; ++slice)
            for (std::size_t c = 0; c < header.size(); ++c)
              if (!atemVarsCols.contains(c)) {
                insertTrans(transitionTable, header[c], (int)slice, tcol++);
                varNamesTran.push_back(_encode_(header[c], (int)slice));
              }
        }
 
        transitionTable.setVariableNames(varNamesTran, false);
        initTable.setVariableNames(varNamesInit, false);
        atemporalTable.setVariableNames(varNamesAtemp, false);
      } else {
        // later files: validate the header against trajectory 1's without copying it
        const auto& raw  = parser.current();
        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");
      }
 
      buffer.clear();
      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());
        buffer.push_back({tokens.begin(), tokens.end()});
      }
 
      if (buffer.size() < k)
        GUM_ERROR(OperationNotAllowed,
                  "Trajectory " << (i + 1) << " has " << buffer.size()
                                << " time steps but at least k=" << k << " are required");
 
      // record this trajectory's raw length (number of time steps), exposed by nbRows()
      _nbTimeSlices_.push_back(buffer.size());
 
      // An atemporal column is constant down the trajectory, so any row carries
      // its value -- but row 0's may be the missing one, and reading row 0 blindly
      // would then drop every row this trajectory feeds. Resolve each once, from
      // its first non-missing occurrence. Same rule the score walk applies.
      std::unordered_map< Size, std::string > atempValue;
      for (const Size col: atemVarsCols)
        for (const auto& r: buffer)
          if (!missingSet.contains(r[col])) {
            atempValue[col] = r[col];
            break;
          }
 
      // value of column col at time tt: the resolved constant for an atemporal
      // column, the row's own cell for a temporal one. A column missing all the
      // way down has no resolved value, so row 0's marker stands and the row is
      // dropped like any other incomplete one.
      const auto cellAt = [&](std::size_t tt, Size col) -> const std::string& {
        if (!atemVarsCols.contains(col)) return buffer[tt][col];
        const auto it = atempValue.find(col);
        return (it == atempValue.end()) ? buffer[0][col] : it->second;
      };
 
      // transition table: sliding windows of width k
      for (std::size_t t = 0; t + k <= buffer.size(); ++t) {
        row.clear();
        // slice 0 carries the atemporal columns; later slices skip them so atemporal
        // variables aren't repeated k-1 times in each row
        for (Size col = 0; col < buffer[0].size(); ++col) {
          row.push_back(cellAt(t, col));
        }
        for (Size slice = 1; slice < k; ++slice) {
          for (Size col = 0; col < buffer[0].size(); ++col) {
            if (!atemVarsCols.contains(col)) { row.push_back(buffer[t + slice][col]); }
          }
        }
        insertIfComplete(transitionTable, row);
      }
 
      // initial table: first k-1 slices, one row per trajectory
      row.clear();
      for (Size col = 0; col < buffer[0].size(); ++col) {
        row.push_back(cellAt(0, col));
      }
      for (Size slice = 1; slice < k - 1; ++slice) {
        for (Size col = 0; col < buffer[0].size(); ++col) {
          if (!atemVarsCols.contains(col)) { row.push_back(buffer[slice][col]); }
        }
      }
      insertIfComplete(initTable, row);
 
      // atemporal table: one row per trajectory, atemporal columns only. Their
      // value is constant across the trajectory, so any time step works — take 0.
      // Skipped when fewer than 2 atemporal variables exist: a single atemporal
      // variable has no possible atemporal->atemporal arcs, so no learner is built.
      if (nbAtempVars > 1) {
        row.clear();
        for (Size col = 0; col < buffer[0].size(); ++col)
          if (atemVarsCols.contains(col)) row.push_back(cellAt(0, col));
        insertIfComplete(atemporalTable, row);
      }
    }
 
    // Dropping incomplete rows can empty a table outright -- every transition
    // window straddling a gap, or every trajectory's initial block incomplete.
    // The internal learner would then fail obscurely on an empty database, so
    // say what actually happened.
    if (_ignoreMissingSymbols_ && (transitionTable.nbRows() == 0 || initTable.nbRows() == 0))
      GUM_ERROR(OperationNotAllowed,
                "every row was dropped as incomplete ("
                    << _nbDroppedRows_
                    << " in total): no fully observed transition window (or initial block) is left "
                       "to learn from. The trajectories are too sparsely observed for k="
                    << k << ".")
 
    // Variables are already typed upstream (template / first-trajectory learner),
    // so no induceTypes pass is needed here — just canonicalize the value codes.
    transitionTable.reorder();
    initTable.reorder();
 
    _transitionLearner_ = std::make_unique< BNLearner< GUM_SCALAR > >(transitionTable);
    _initialLearner_    = std::make_unique< BNLearner< GUM_SCALAR > >(initTable);
 
    if (nbAtempVars > 1) {
      atemporalTable.reorder();
      _atemporalLearner_ = std::make_unique< BNLearner< GUM_SCALAR > >(atemporalTable);
    }
 
 
    // Impose k-TBN temporal constraints on structure learning:
    //  - transition learner: past slices (0..k-2) are forced roots so only the
    //    present slice (k-1) receives new arcs.
    //  - atemporal variables are forced roots in transition/initial learners so
    //    their mutual structure is learned exclusively by the atemporal learner.
    //    No-parent in both learners covers every algorithm and also bans
    //    temporal→atemporal arcs.
    //  - initial learner: backward temporal arcs among past slices forbidden
    //    explicitly (honoured by MIIC and score-based algorithms alike).
    // These constraints shape structure search in learnKTBN(); they are inert
    // for learnParameters.
    const int   ki            = (int)k;
    const auto& temporalVars  = _prior_ktbn_.temporalVarNames();
    const auto& atemporalVars = _prior_ktbn_.atemporalVarNames();
 
    for (const auto& base: temporalVars)
      for (int slice = 0; slice < ki - 1; ++slice)
        _transitionLearner_->addNoParentNode(_encode_(base, slice));
 
    for (const auto& atemBase: atemporalVars) {
      _transitionLearner_->addNoParentNode(atemBase);
      _initialLearner_->addNoParentNode(atemBase);
    }
 
    if (k > 2) {
      // backward-in-time arcs among the past slices 0..k-2 are forbidden
      // explicitly: this is the only form MIIC honours (it ignores slice order),
      // and score-based algorithms respect it too, so it fully covers the
      // constraint. A setSliceOrder() mirror was dropped here as redundant.
      for (const auto& tailBase: temporalVars)
        for (const auto& headBase: temporalVars)
          for (int tailSlice = 1; tailSlice < ki - 1; ++tailSlice)
            for (int headSlice = 0; headSlice < tailSlice; ++headSlice)
              _initialLearner_->addForbiddenArc(_encode_(tailBase, tailSlice),
                                                _encode_(headBase, headSlice));
    }
  }

References _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _ignoreMissingSymbols_, _initialLearner_, _nbDroppedRows_, _nbTimeSlices_, _prior_ktbn_, _transitionLearner_, gum::KTBN< GUM_SCALAR >::ATEMPORAL, gum::learning::CSVParser::current(), GUM_ERROR, gum::learning::DatabaseTable::insertRow(), gum::learning::DatabaseTable::insertTranslator(), k(), gum::learning::CSVParser::nbLine(), gum::learning::IDatabaseTable< T_DATA >::nbRows(), nbSamples(), gum::learning::CSVParser::next(), gum::learning::DatabaseTable::reorder(), and gum::learning::DatabaseTable::setVariableNames().

Referenced by KTBNLearner(), and KTBNLearner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _buildPriorFromBN_()

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::learning::KTBNLearner< GUM_SCALAR >::_buildPriorFromBN_	(	Size	k,
		const BayesNet< GUM_SCALAR > &	bn,
		const std::unordered_set< std::string > &	atemporalVars )

staticprivate

called in the member-initialiser list of the BN constructor: builds and returns a KTBN whose variables are copied from bn (one node per base variable, right types/domains) and classified as temporal/atemporal according to atemporalVars. Must be static because it is called before the object exists.

Definition at line 974 of file KTBNLearner_tpl.h.

                                                          {
    IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(k, "k");
 
    KTBN< GUM_SCALAR > prior(k);
    // bn.nodes() iterates in hash order (unspecified). This is harmless because
    // KTBN looks up variables by name, not by insertion index.
    for (const NodeId node: bn.nodes()) {
      const DiscreteVariable& var = bn.variable(node);
      prior.add(var, !atemporalVars.contains(var.name()));
    }
    for (const std::string& aname: atemporalVars)
      if (!prior.exists(aname))
        GUM_ERROR(InvalidArgument, "atemporal variable '" << aname << "' not found in the BN")
    return prior;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(), GUM_ERROR, k(), and gum::Variable::name().

Referenced by KTBNLearner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _buildPriorFromCSV_()

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::learning::KTBNLearner< GUM_SCALAR >::_buildPriorFromCSV_	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	k,
		const std::unordered_set< std::string > &	atemporalVars,
		const std::vector< std::string > &	missingSymbols,
		bool	induceTypes )

staticprivate

called in the member-initialiser list of the k-CSV constructor: opens the first trajectory CSV, uses a temporary BNLearner to type the base variables (induceTypes promotes numeric columns to range/integer), builds and returns a KTBN with the right temporal/atemporal classification. Must be static because it is called before the object exists.

Definition at line 933 of file KTBNLearner_tpl.h.

                                                            {
    IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(k, "k");
 
    namespace fs = std::filesystem;
    const std::string firstCSV
        = (fs::path{dirPath} / (std::string{csvBaseName} + "1.csv")).string();
    // _build_() also reads trajectory 1 (its i=0 pass). The double-read is
    // unavoidable: this function runs in the member-initialiser list, before
    // the object (and hence _build_()) exists, and _build_() must read every
    // trajectory.
 
    // BNLearner construction runs induceTypes on the CSV and populates all
    // column translators with properly-typed DiscreteVariables.
    const BNLearner< GUM_SCALAR > tmpLearner(firstCSV, missingSymbols, induceTypes);
 
    // Pull typed variables from the translator set. translatorSafe(i) bounds-checks,
    // guarding against any names()/translator-set mismatch.
    const DBTranslatorSet&            translators = tmpLearner.database().translatorSet();
    const std::vector< std::string >& names       = tmpLearner.names();
 
    KTBN< GUM_SCALAR > prior(k);
    for (std::size_t i = 0; i < names.size(); ++i) {
      prior.add(static_cast< const DiscreteVariable& >(*translators.translatorSafe(i).variable()),
                !atemporalVars.contains(names[i]));
    }
 
    // Every declared atemporal name must appear in the CSV header.
    for (const std::string& aname: atemporalVars)
      if (!prior.exists(aname))
        GUM_ERROR(InvalidArgument,
                  "atemporal variable '" << aname << "' not found in the CSV header")
    return prior;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(), GUM_ERROR, k(), names(), gum::learning::DBTranslatorSet::translatorSafe(), and gum::learning::DBTranslator::variable().

Referenced by KTBNLearner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _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:

◆ _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:

◆ _forEachAllSlicesPair_()

template<GUM_Numeric GUM_SCALAR>

template<class F>

void gum::learning::KTBNLearner< GUM_SCALAR >::_forEachAllSlicesPair_	(	std::string_view	tailBase,
		std::string_view	headBase,
		F &&	f ) const

private

Apply f(tailSlice, headSlice) to every causally-possible slice pair of an all-slices constraint between tailBase and headBase. Four shapes: atemporal->atemporal is one pair; an atemporal tail reaches every slice of the head; a temporal tail into an atemporal head is structurally impossible and yields none; two temporal bases give every pair with tailSlice <= headSlice, i.e. every lag.

Validates that both bases exist – which the two callers used not to do, letting an unknown name reach a BNLearner as an opaque MissingVariableInDatabase – but deliberately NOT that they are temporal: an atemporal tail is one of the four shapes above.

Definition at line 95 of file KTBNLearner_tpl.h.

                                                                                   {
    if (!_isKnownBase_(tailBase))
      GUM_ERROR(InvalidArgument,
                "unknown base variable '" << tailBase
                                          << "': it is not one of this learner's variables")
    if (!_isKnownBase_(headBase))
      GUM_ERROR(InvalidArgument,
                "unknown base variable '" << headBase
                                          << "': it is not one of this learner's variables")
 
    constexpr int AT        = KTBN< GUM_SCALAR >::ATEMPORAL;
    const int     k         = static_cast< int >(_prior_ktbn_.k());
    const bool    tailAtemp = _prior_ktbn_.atemporalVarNames().contains(std::string{tailBase});
    const bool    headAtemp = _prior_ktbn_.atemporalVarNames().contains(std::string{headBase});
 
    if (tailAtemp && headAtemp) {
      f(AT, AT);
    } else if (tailAtemp) {
      for (int hs = 0; hs < k; ++hs)
        f(AT, hs);
    } else if (headAtemp) {
      // temporal tail -> atemporal head is already structurally impossible
    } else {
      for (int ts = 0; ts < k; ++ts)
        for (int hs = ts; hs < k; ++hs)
          f(ts, hs);
    }
  }

References _isKnownBase_(), _prior_ktbn_, gum::KTBN< GUM_SCALAR >::ATEMPORAL, GUM_ERROR, and k().

Referenced by addForbiddenArcAllSlices(), and eraseForbiddenArcAllSlices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _forEachLearner_()

template<GUM_Numeric GUM_SCALAR>

template<class F>

void gum::learning::KTBNLearner< GUM_SCALAR >::_forEachLearner_ ( F && f )

private

Apply f to each present internal learner (the atemporal one only when it exists). Factors out the fan-out shared by every score / algorithm / prior / correction / graph-change setter.

Definition at line 67 of file KTBNLearner_tpl.h.

                                                        {
    f(*_transitionLearner_);
    f(*_initialLearner_);
    if (_atemporalLearner_) f(*_atemporalLearner_);
  }

References _atemporalLearner_, _initialLearner_, and _transitionLearner_.

Referenced by allowArcAdditions(), allowArcDeletions(), allowArcReversals(), setMaxIndegree(), useExtendedGreedyHillClimbing(), useGreedyHillClimbing(), useLocalSearchWithTabuList(), useMDLCorrection(), useMIIC(), useNMLCorrection(), useNoCorrection(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScorefNML(), useScoreLog2Likelihood(), useScoreMDL(), and useSmoothingPrior().

Here is the caller graph for this function:

◆ _forOwningLearner_()

template<GUM_Numeric GUM_SCALAR>

template<class F>

void gum::learning::KTBNLearner< GUM_SCALAR >::_forOwningLearner_	(	std::string_view	tail,
		std::string_view	head,
		F &&	f )

private

Apply f to the ONE internal learner that can learn the arc tail -> head, chosen by its head: a slice-(k-1) head belongs to the transition learner, an atemporal->atemporal arc to the atemporal learner, any other head (a past temporal slice) to the initial learner. The three cases are exclusive because build() forces every other node root in the learners that do not own it, so no arc is ever learnable in two of them.

The bothAtemp guard matters: without it an "X[0] -> C" arc would be routed to the atemporal learner, whose table has no X[0] column, and surface as MissingVariableInDatabase. It falls to the initial learner instead, where both endpoints exist and the arc is a harmless no-op.

Callers keep their own checkArcTemporallyFeasible call, which is deliberately asymmetric – forbidding an impossible arc is harmless while UN-forbidding it lifts an invariant, and forcing one must be refused while erasing a never-forced one is harmless – so it cannot be folded in here without flattening that asymmetry.

Definition at line 75 of file KTBNLearner_tpl.h.

                                                                         {
    const int  last      = static_cast< int >(_prior_ktbn_.k()) - 1;
    const int  tailSlice = _determineNode_(std::string{tail}).second;
    const int  headSlice = _determineNode_(std::string{head}).second;
    const bool bothAtemp = (tailSlice == KTBN< GUM_SCALAR >::ATEMPORAL
                            && headSlice == KTBN< GUM_SCALAR >::ATEMPORAL);
    if (headSlice == last) f(*_transitionLearner_);
    else if (bothAtemp && _atemporalLearner_) f(*_atemporalLearner_);
    else if (tailSlice != last) f(*_initialLearner_);
    // else: the head is at a past slice but the tail sits on the kernel one,
    // i.e. a backward arc. No table can hold it -- the initial one has no
    // slice k-1 column -- and the k-TBN forbids it anyway, so there is
    // nothing to constrain. Silently nothing, as the old broadcast did
    // through its "tailSlice != last && headSlice != last" guard.
  }

References _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Referenced by addForbiddenArc(), addMandatoryArc(), eraseForbiddenArc(), and eraseMandatoryArc().

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::KTBNLearner< GUM_SCALAR >::_inferAtemporalVars_	(	std::string_view	dirPath,
		std::string_view	csvBaseName,
		Size	nbSamples,
		Size	k,
		const std::vector< std::string > &	missingSymbols )

staticprivate

checks k >= 2, then delegates the actual scan to the shared IKTBNLearner::scanConstantColumns() (also used by KTBNAdaptiveLearner, hence not duplicated here). The check happens first and here, not inside the shared scan: called once, in the member-initialiser list of the atemporal-inferring constructor, before prior_ktbn exists — before that constructor's body runs the equivalent check in buildPriorFromCSV — so without it here too, a bad k would only be caught after a wasted scan of every trajectory.

Definition at line 919 of file KTBNLearner_tpl.h.

                                                    {
    IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(k, "k");
    return IKTBNLearner< GUM_SCALAR >::_scanConstantColumns_(dirPath,
                                                             csvBaseName,
                                                             nbSamples,
                                                             missingSymbols);
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkMinimalOrder_(), gum::learning::IKTBNLearner< GUM_SCALAR >::_scanConstantColumns_(), k(), and nbSamples().

Referenced by KTBNLearner().

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::KTBNLearner< GUM_SCALAR >::_isKnownBase_ ( std::string_view base ) const

overrideprivatevirtual

whether base is one of this learner's variables; read straight from the prior k-TBN, like atemporalVarNames() above.

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

Definition at line 1303 of file KTBNLearner_tpl.h.

                                                                         {
    const std::string b{base};
    return _prior_ktbn_.temporalVarNames().contains(b)
        || _prior_ktbn_.atemporalVarNames().contains(b);
  }

References _prior_ktbn_.

Referenced by _forEachAllSlicesPair_().

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:

◆ addForbiddenArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Forbid one (base, slice) -> (base, slice) arc (KTBN::ATEMPORAL for static). A backward arc (tailSlice > headSlice) is accepted but has no effect: such an arc is already impossible, so forbidding it is a harmless no-op.

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

Definition at line 465 of file KTBNLearner_tpl.h.

                                                                                       {
    // wrapper: encode (base, slice) -> engine name and delegate to the string overload
    return addForbiddenArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

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

Here is the call graph for this function:

◆ addForbiddenArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Forbid tailNode from ever parenting headNode (engine names, e.g. "X[1]", "C").

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

Definition at line 456 of file KTBNLearner_tpl.h.

                                                                                                 {
    _forOwningLearner_(tailNode, headNode, [&](BNLearner< GUM_SCALAR >& l) {
      l.addForbiddenArc(tailNode, headNode);
    });
    return *this;
  }

References KTBNLearner(), and _forOwningLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_(), addForbiddenArc(), addForbiddenArcAllSlices(), and addForbiddenIntraSliceArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenArcAllSlices()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Forbid tailBase -> headBase at every causally-possible slice pair (every lag, not just matching slices): tailBase can never be an ancestor of headBase in the learned k-TBN. A temporal->atemporal pair is a no-op (already structurally impossible).

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

Definition at line 567 of file KTBNLearner_tpl.h.

                                                                                   {
    _forEachAllSlicesPair_(tailBase, headBase, [&](int ts, int hs) {
      addForbiddenArc(tailBase, ts, headBase, hs);
    });
    return *this;
  }

References _forEachAllSlicesPair_(), and addForbiddenArc().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenIntraSliceArc()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Forbid tailBase -> headBase at every intra-slice position (i.e. tailBase[t] -> headBase[t] for all t in [0, k-1]).

Exceptions

InvalidArgument if either endpoint is unknown or atemporal (an atemporal variable has no intra-slice position).

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

Definition at line 541 of file KTBNLearner_tpl.h.

                                                                                    {
    // validate both endpoints BEFORE touching any learner, so a rejected call
    // leaves no partially-applied constraint behind
    _checkBaseIsTemporal_(tailBase, "an intra-slice constraint");
    _checkBaseIsTemporal_(headBase, "an intra-slice constraint");
    const int k = static_cast< int >(_prior_ktbn_.k());
    for (int t = 0; t < k; ++t)
      addForbiddenArc(tailBase, t, headBase, t);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkBaseIsTemporal_(), _prior_ktbn_, addForbiddenArc(), and k().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addMandatoryArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Force one arc, lag stated explicitly via slices (KTBN::ATEMPORAL for static).

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

Definition at line 511 of file KTBNLearner_tpl.h.

                                                                                       {
    // wrapper: encode (base, slice) -> engine name and delegate to the string overload
    return addMandatoryArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

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

Here is the call graph for this function:

◆ addMandatoryArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Force tailNode to be a parent of headNode (engine names, e.g. "X[1]", "C").

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

Definition at line 495 of file KTBNLearner_tpl.h.

                                                                                                 {
    // Unlike forbidding, a mandatory arc must be feasible: reject up front the arcs
    // the k-TBN can never contain (shared with eraseForbiddenArc) rather than
    // letting them crash later in the wrong learner. Kept here, not in
    // _forOwningLearner_: the check is deliberately asymmetric across the four
    // setters (see its declaration).
    _checkArcTemporallyFeasible_(tailNode, headNode, "force the mandatory arc");
 
    _forOwningLearner_(tailNode, headNode, [&](BNLearner< GUM_SCALAR >& l) {
      l.addMandatoryArc(tailNode, headNode);
    });
    return *this;
  }

References KTBNLearner(), gum::learning::IKTBNLearner< GUM_SCALAR >::_checkArcTemporallyFeasible_(), and _forOwningLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_(), and addMandatoryArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addNoChildrenNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Declare a single (base, slice) node as a leaf (no children).

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

Definition at line 627 of file KTBNLearner_tpl.h.

                                                                                                  {
    return addNoChildrenNode(_encode_(base, slice));
  }

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

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_(), and 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>

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

overridevirtual

Declare a single node (bracket notation, e.g. "X[2]" or "C") as a leaf.

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

Definition at line 633 of file KTBNLearner_tpl.h.

                                                                                             {
    const int  slice   = _determineNode_(std::string{name}).second;
    const bool isAtemp = (slice == KTBN< GUM_SCALAR >::ATEMPORAL);
    _transitionLearner_->addNoChildrenNode(name);
    if (slice < (int)_prior_ktbn_.k() - 1) _initialLearner_->addNoChildrenNode(name);
    if (isAtemp && _atemporalLearner_) _atemporalLearner_->addNoChildrenNode(name);
    return *this;
  }

References KTBNLearner(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ addNoParentNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Declare a single (base, slice) node as a root (no parents).

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

Definition at line 586 of file KTBNLearner_tpl.h.

                                                                                                {
    return addNoParentNode(_encode_(base, slice));
  }

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

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_(), and 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>

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

overridevirtual

Declare a single node (bracket notation, e.g. "X[2]" or "C") as a root.

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

Definition at line 592 of file KTBNLearner_tpl.h.

                                                                                           {
    const int  slice   = _determineNode_(std::string{name}).second;
    const bool isAtemp = (slice == KTBN< GUM_SCALAR >::ATEMPORAL);
    if (isAtemp && _atemporalLearner_) {
      // Atemporals are already forced roots in transition/initial learners by _build_.
      // The user constraint is only meaningful in the atemporal learner.
      _atemporalLearner_->addNoParentNode(name);
    } else if (!isAtemp) {
      _transitionLearner_->addNoParentNode(name);
      if (slice < (int)_prior_ktbn_.k() - 1) _initialLearner_->addNoParentNode(name);
    }
    return *this;
  }

References KTBNLearner(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ addPossibleEdge() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Add a candidate edge for MIIC using engine names (e.g. "X[1]", "C").

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

Definition at line 677 of file KTBNLearner_tpl.h.

                                                                                             {
    const int last      = (int)_prior_ktbn_.k() - 1;
    const int tailSlice = _determineNode_(std::string{tail}).second;
    const int headSlice = _determineNode_(std::string{head}).second;
 
    // Atemporal names exist as forced roots in every table, so whitelisting them
    // here too keeps the whole-model promise ("only listed edges are explored")
    // even when the edge can fire in just one learner: the no-parent constraint
    // on atemporal heads still vetoes it there (constraints compound, never
    // override), so this can only shrink the candidate set, never widen it.
    _transitionLearner_->addPossibleEdge(tail, head);
    // forward to the initial learner only when both endpoints exist there, i.e. both
    // are at a past slice (< k-1); atemporals (slice -1) satisfy this automatically.
    if (tailSlice < last && headSlice < last) _initialLearner_->addPossibleEdge(tail, head);
 
    if (tailSlice == KTBN< GUM_SCALAR >::ATEMPORAL && headSlice == KTBN< GUM_SCALAR >::ATEMPORAL) {
      ++_nbAtemporalPossibleEdges_;
      if (_atemporalLearner_) _atemporalLearner_->addPossibleEdge(tail, head);
    } else {
      ++_nbTemporalPossibleEdges_;
    }
    return *this;
  }

References KTBNLearner(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _nbAtemporalPossibleEdges_, _nbTemporalPossibleEdges_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ addPossibleEdge() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Add a candidate edge for MIIC (only edges explicitly listed are explored).

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

Definition at line 659 of file KTBNLearner_tpl.h.

                                                                                       {
    // encode (base, slice) -> engine name and delegate to the string overload, which
    // owns the full routing (atemporal->atemporal to the atemporal learner, slice-k-1 guard)
    return addPossibleEdge(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

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

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_(), and addPossibleEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allowArcAdditions()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Allow or forbid arc additions during structure search.

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

Definition at line 722 of file KTBNLearner_tpl.h.

                                                                                    {
    _forEachLearner_([&](BNLearner< GUM_SCALAR >& l) { l.allowArcAdditions(allow); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allowArcDeletions()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Allow or forbid arc deletions during structure search.

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

Definition at line 728 of file KTBNLearner_tpl.h.

                                                                                    {
    _forEachLearner_([&](BNLearner< GUM_SCALAR >& l) { l.allowArcDeletions(allow); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allowArcReversals()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Allow or forbid arc reversals during structure search.

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

Definition at line 734 of file KTBNLearner_tpl.h.

                                                                                    {
    _forEachLearner_([&](BNLearner< GUM_SCALAR >& l) { l.allowArcReversals(allow); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkScorePriorCompatibility()

template<GUM_Numeric GUM_SCALAR>

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

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

Definition at line 356 of file KTBNLearner_tpl.h.

                                                                          {
    // Every score/prior setter is applied uniformly to all internal learners, so
    // their configurations are identical: a single check on the transition learner
    // is representative of the whole KTBNLearner.
    return _transitionLearner_->checkScorePriorCompatibility();
  }

References _transitionLearner_.

◆ copyState()

template<GUM_Numeric GUM_SCALAR>

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

Copy all score/algorithm/prior/constraint settings from another KTBNLearner (does not copy the database).

Definition at line 834 of file KTBNLearner_tpl.h.

                                                                                    {
    // As in BNLearner::copyState, only score/algorithm/prior/constraint settings
    // are copied, never the database. Both sides must be structurally compatible
    // (same k, same temporal/atemporal partition) for the name-based constraints
    // to mean the same thing. The atemporal learner is copied only when both
    // sides have one (absent when there are <= 1 atemporal vars).
    _transitionLearner_->copyState(*learner._transitionLearner_);
    _initialLearner_->copyState(*learner._initialLearner_);
    if (_atemporalLearner_ && learner._atemporalLearner_)
      _atemporalLearner_->copyState(*learner._atemporalLearner_);
 
    // KTBNLearner-only state (BNLearner::copyState can't carry it): learnKTBN reads
    // these to suppress the atemporal learner under a temporal-only whitelist
    _nbTemporalPossibleEdges_  = learner._nbTemporalPossibleEdges_;
    _nbAtemporalPossibleEdges_ = learner._nbAtemporalPossibleEdges_;
  }

References KTBNLearner(), _atemporalLearner_, _initialLearner_, _nbAtemporalPossibleEdges_, _nbTemporalPossibleEdges_, and _transitionLearner_.

Here is the call graph for this function:

◆ domainSize()

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::domainSize ( std::string_view base ) const

Domain size of the base variable base (e.g. "X", "C"). Engine names (e.g. "X[1]") are also accepted.

Note: KTBNLearner is deliberately name-only: it exposes no NodeId-based accessor (no domainSize(NodeId), idFromName or nameFromId). The three internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous — always address variables by name here.

Definition at line 902 of file KTBNLearner_tpl.h.

                                                                      {
    // Resolve the base name to an engine name in the transition table: a temporal
    // variable is addressed at slice 0, everything else keeps its bare name (which
    // also lets a raw engine name pass through). An unknown name reaches
    // domainSize() unchanged and throws MissingVariableInDatabase.
    const std::string b{base};
    const int         slice
        = _prior_ktbn_.temporalVarNames().contains(b) ? 0 : KTBN< GUM_SCALAR >::ATEMPORAL;
    return _transitionLearner_->domainSize(_encode_(b, slice));
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ domainSizes()

template<GUM_Numeric GUM_SCALAR>

std::vector< Size > gum::learning::KTBNLearner< GUM_SCALAR >::domainSizes ( ) const

Domain sizes of the base variables, in the same column order as names().

Definition at line 894 of file KTBNLearner_tpl.h.

                                                                 {
    // Mirror names(): the first nbCols() columns are the base variables (a temporal
    // variable's domain size is the same across all its slices), so keep only those.
    const auto& all = _transitionLearner_->domainSizes();
    return std::vector< Size >(all.begin(), all.begin() + nbCols());
  }

References _transitionLearner_, and nbCols().

Here is the call graph for this function:

◆ eraseForbiddenArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addForbiddenArc for a specific (base, slice) pair.

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

Definition at line 487 of file KTBNLearner_tpl.h.

                                                                                         {
    return eraseForbiddenArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

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

Here is the call graph for this function:

◆ eraseForbiddenArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addForbiddenArc (engine names, e.g. "X[1]", "C").

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

Definition at line 475 of file KTBNLearner_tpl.h.

                                                                            {
    // refuse to lift an invariant the k-TBN definition enforces (shared with addMandatoryArc)
    _checkArcTemporallyFeasible_(tailNode, headNode, "un-forbid the arc");
 
    _forOwningLearner_(tailNode, headNode, [&](BNLearner< GUM_SCALAR >& l) {
      l.eraseForbiddenArc(tailNode, headNode);
    });
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkArcTemporallyFeasible_(), and _forOwningLearner_().

Referenced by eraseForbiddenArc(), eraseForbiddenArcAllSlices(), and eraseForbiddenIntraSliceArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseForbiddenArcAllSlices()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addForbiddenArcAllSlices.

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

Definition at line 577 of file KTBNLearner_tpl.h.

                                                                                     {
    _forEachAllSlicesPair_(tailBase, headBase, [&](int ts, int hs) {
      eraseForbiddenArc(tailBase, ts, headBase, hs);
    });
    return *this;
  }

References _forEachAllSlicesPair_(), and eraseForbiddenArc().

Here is the call graph for this function:

◆ eraseForbiddenIntraSliceArc()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addForbiddenIntraSliceArc.

Exceptions

InvalidArgument under the same conditions as addForbiddenIntraSliceArc.

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

Definition at line 555 of file KTBNLearner_tpl.h.

                                                                                      {
    _checkBaseIsTemporal_(tailBase, "an intra-slice constraint");
    _checkBaseIsTemporal_(headBase, "an intra-slice constraint");
    const int k = static_cast< int >(_prior_ktbn_.k());
    for (int t = 0; t < k; ++t)
      eraseForbiddenArc(tailBase, t, headBase, t);
    return *this;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_checkBaseIsTemporal_(), _prior_ktbn_, eraseForbiddenArc(), and k().

Here is the call graph for this function:

◆ eraseMandatoryArc() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addMandatoryArc.

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

Definition at line 532 of file KTBNLearner_tpl.h.

                                                                                         {
    return eraseMandatoryArc(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

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

Here is the call graph for this function:

◆ eraseMandatoryArc() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addMandatoryArc (engine names, e.g. "X[1]", "C").

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

Definition at line 521 of file KTBNLearner_tpl.h.

                                                                            {
    // no feasibility check: a backward-in-time arc can never have been added, so
    // erasing it is harmless -- it resolves to a no-op on the owning learner.
    _forOwningLearner_(tailNode, headNode, [&](BNLearner< GUM_SCALAR >& l) {
      l.eraseMandatoryArc(tailNode, headNode);
    });
    return *this;
  }

References _forOwningLearner_().

Referenced by eraseMandatoryArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseNoChildrenNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addNoChildrenNode for a single (base, slice) node.

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

Definition at line 643 of file KTBNLearner_tpl.h.

                                                                                       {
    return eraseNoChildrenNode(_encode_(base, slice));
  }

References KTBNLearner(), gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), 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>

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

overridevirtual

Undo addNoChildrenNode for a node given by bracket notation.

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

Definition at line 649 of file KTBNLearner_tpl.h.

                                                                                               {
    const int  slice   = _determineNode_(std::string{name}).second;
    const bool isAtemp = (slice == KTBN< GUM_SCALAR >::ATEMPORAL);
    _transitionLearner_->eraseNoChildrenNode(name);
    if (slice < (int)_prior_ktbn_.k() - 1) _initialLearner_->eraseNoChildrenNode(name);
    if (isAtemp && _atemporalLearner_) _atemporalLearner_->eraseNoChildrenNode(name);
    return *this;
  }

References KTBNLearner(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ eraseNoParentNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addNoParentNode for a single (base, slice) node.

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

Definition at line 607 of file KTBNLearner_tpl.h.

                                                                                                  {
    return eraseNoParentNode(_encode_(base, slice));
  }

References KTBNLearner(), gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), 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>

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

overridevirtual

Undo addNoParentNode for a node given by bracket notation.

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

Definition at line 613 of file KTBNLearner_tpl.h.

                                                                                             {
    const int  slice   = _determineNode_(std::string{name}).second;
    const int  last    = (int)_prior_ktbn_.k() - 1;
    const bool isAtemp = (slice == KTBN< GUM_SCALAR >::ATEMPORAL);
    if (isAtemp && _atemporalLearner_) _atemporalLearner_->eraseNoParentNode(name);
    else if (slice == last) _transitionLearner_->eraseNoParentNode(name);
    else if (!isAtemp)
      // Past slices keep their transition-learner root constraint (confines learning
      // to the kernel); only lift the constraint in the initial learner.
      _initialLearner_->eraseNoParentNode(name);
    return *this;
  }

References KTBNLearner(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ erasePossibleEdge() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addPossibleEdge using engine names (e.g. "X[1]", "C").

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

Definition at line 703 of file KTBNLearner_tpl.h.

                                                                                               {
    const int last      = (int)_prior_ktbn_.k() - 1;
    const int tailSlice = _determineNode_(std::string{tail}).second;
    const int headSlice = _determineNode_(std::string{head}).second;
 
    _transitionLearner_->erasePossibleEdge(tail, head);
    if (tailSlice < last && headSlice < last) _initialLearner_->erasePossibleEdge(tail, head);
 
    if (tailSlice == KTBN< GUM_SCALAR >::ATEMPORAL && headSlice == KTBN< GUM_SCALAR >::ATEMPORAL) {
      if (_nbAtemporalPossibleEdges_ > 0) --_nbAtemporalPossibleEdges_;
      if (_atemporalLearner_) _atemporalLearner_->erasePossibleEdge(tail, head);
    } else {
      if (_nbTemporalPossibleEdges_ > 0) --_nbTemporalPossibleEdges_;
    }
    return *this;
  }

References KTBNLearner(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _initialLearner_, _nbAtemporalPossibleEdges_, _nbTemporalPossibleEdges_, _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

Here is the call graph for this function:

◆ erasePossibleEdge() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Undo a previous addPossibleEdge.

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

Definition at line 669 of file KTBNLearner_tpl.h.

                                                                                         {
    return erasePossibleEdge(_encode_(tailBase, tailSlice), _encode_(headBase, headSlice));
  }

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

Referenced by erasePossibleEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasMissingValues()

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNLearner< GUM_SCALAR >::hasMissingValues ( ) const

True if any internal database contains missing values.

Warning: Always false since build() performs complete-case selection: a row carrying a missing symbol is never inserted, so the databases hold no gap by construction. To learn whether the CSVs actually had any, read nbDroppedRows() instead.

Definition at line 873 of file KTBNLearner_tpl.h.

                                                         {
    return _transitionLearner_->hasMissingValues() || _initialLearner_->hasMissingValues()
        || (_atemporalLearner_ && _atemporalLearner_->hasMissingValues());
  }

References _atemporalLearner_, _initialLearner_, and _transitionLearner_.

◆ isConstraintBased()

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNLearner< GUM_SCALAR >::isConstraintBased ( ) const

True if the current structure-learning algorithm is constraint-based (e.g. MIIC).

Definition at line 768 of file KTBNLearner_tpl.h.

                                                          {
    return _transitionLearner_->isConstraintBased();
  }

References _transitionLearner_.

◆ isIgnoringMissingSymbols()

template<GUM_Numeric GUM_SCALAR>

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

Whether build() drops the rows carrying a missing symbol.

See also: nbDroppedRows() for how much was dropped, and for the warning on the likelihood distortion this causes.

Definition at line 863 of file KTBNLearner_tpl.h.

                                                                        {
    return _ignoreMissingSymbols_;
  }

References _ignoreMissingSymbols_.

◆ isScoreBased()

template<GUM_Numeric GUM_SCALAR>

bool gum::learning::KTBNLearner< GUM_SCALAR >::isScoreBased ( ) const

True if the current structure-learning algorithm is score-based (e.g. BIC, AIC).

Definition at line 773 of file KTBNLearner_tpl.h.

                                                     {
    return _transitionLearner_->isScoreBased();
  }

References _transitionLearner_.

◆ k()

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::k ( ) const

Order \(k\) of the k-TBN being learned.

Definition at line 750 of file KTBNLearner_tpl.h.

                                          {
    return _prior_ktbn_.k();
  }

References _prior_ktbn_.

Referenced by KTBNLearner(), KTBNLearner(), KTBNLearner(), _assemble_(), _build_(), _buildPriorFromBN_(), _buildPriorFromCSV_(), _forEachAllSlicesPair_(), _inferAtemporalVars_(), addForbiddenIntraSliceArc(), eraseForbiddenIntraSliceArc(), learnParameters(), and toString().

Here is the caller graph for this function:

◆ latentVariables()

template<GUM_Numeric GUM_SCALAR>

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

Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.

Definition at line 417 of file KTBNLearner_tpl.h.

                                                       {
    // Each learner reports latent arcs in its own NodeId space, so translate each
    // Arc to an (engine-name, engine-name) pair before merging. A pair among
    // slices 0..k-2 can be flagged by both the transition and the initial learner,
    // so deduplicate on a tab-joined key (engine names never contain a tab).
    // Propagates BNLearner's OperationNotAllowed if MIIC is not selected.
    std::vector< std::pair< std::string, std::string > > result;
    std::unordered_set< std::string >                    seen;
 
    auto collect = [&](const std::unique_ptr< BNLearner< GUM_SCALAR > >& learner) {
      if (!learner) return;
      for (const auto& arc: learner->latentVariables()) {
        std::string tail = learner->nameFromId(arc.tail());
        std::string head = learner->nameFromId(arc.head());
        if (seen.insert(tail + '\t' + head).second)
          result.emplace_back(std::move(tail), std::move(head));
      }
    };
    collect(_transitionLearner_);
    collect(_initialLearner_);
    collect(_atemporalLearner_);
    return result;
  }

References _atemporalLearner_, _initialLearner_, and _transitionLearner_.

◆ learnKTBN()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Full learning (structure + CPTs). Mirrors BNLearner::learnBN().

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

Definition at line 229 of file KTBNLearner_tpl.h.

                                                          {
    // Honour the possible-edge whitelist for atemporal->atemporal arcs: when a
    // whitelist is active (>=1 possible edge with a temporal endpoint) but no
    // atemporal->atemporal edge was whitelisted, the atemporal learner has an
    // empty (hence unrestricted) list. Skip it entirely so no atemporal arc is
    // produced; _assemble_ then leaves the atemporal variables as roots.
    const bool suppressAtemporal
        = (_nbTemporalPossibleEdges_ > 0) && (_nbAtemporalPossibleEdges_ == 0);
    BayesNet< GUM_SCALAR > transitionBN = _transitionLearner_->learnBN();
    BayesNet< GUM_SCALAR > initialBN    = _initialLearner_->learnBN();
    BayesNet< GUM_SCALAR > atemporalBN  = (_atemporalLearner_ && !suppressAtemporal)
                                            ? _atemporalLearner_->learnBN()
                                            : BayesNet< GUM_SCALAR >{};
    return _assemble_(transitionBN, initialBN, atemporalBN);
  }

References _assemble_(), _atemporalLearner_, _initialLearner_, _nbAtemporalPossibleEdges_, _nbTemporalPossibleEdges_, and _transitionLearner_.

Here is the call graph for this function:

◆ learnParameters()

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::learning::KTBNLearner< GUM_SCALAR >::learnParameters	(	const KTBN< GUM_SCALAR > &	structure,
		bool	takeIntoAccountScore = true )

CPTs only, using the arc structure of structure. structure must have the same base variables (names and domains) as those used to construct this learner; mismatches throw at learn time.

Definition at line 246 of file KTBNLearner_tpl.h.

                                                                                           {
    if (structure.k() != _prior_ktbn_.k())
      GUM_ERROR(InvalidArgument,
                "learnParameters: structure has k="
                    << structure.k() << " but this learner was built with k=" << _prior_ktbn_.k())
    const int k = (int)_prior_ktbn_.k();
 
    // Build one DAG per internal table, in that table's own NodeId space, by
    // routing each of structure's (base, slice) arcs to the table that owns its
    // head: slice k-1 goes to the transition table, atemporal heads go to the
    // atemporal table (guaranteed atemporal-tailed too — a temporal variable can
    // never be a parent of an atemporal one), everything else (slices 0..k-2,
    // whether the tail is temporal or atemporal) goes to the initial table.
    DAG transitionDAG;
    DAG initialDAG;
    DAG atemporalDAG;
 
    const std::size_t nbTransNodes = _transitionLearner_->database().nbVariables();
    for (std::size_t id = 0; id < nbTransNodes; ++id)
      transitionDAG.addNodeWithId(NodeId(id));
 
    const std::size_t nbInitNodes = _initialLearner_->database().nbVariables();
    for (std::size_t id = 0; id < nbInitNodes; ++id)
      initialDAG.addNodeWithId(NodeId(id));
 
    if (_atemporalLearner_) {
      const std::size_t nbAtemNodes = _atemporalLearner_->database().nbVariables();
      for (std::size_t id = 0; id < nbAtemNodes; ++id)
        atemporalDAG.addNodeWithId(NodeId(id));
    }
 
    for (const auto& [tail, head]: structure.arcs()) {
      const auto& [tailBase, tailSlice] = tail;
      const auto& [headBase, headSlice] = head;
      const std::string tailName        = _encode_(tailBase, tailSlice);
      const std::string headName        = _encode_(headBase, headSlice);
 
      if (headSlice == k - 1) {
        transitionDAG.addArc(_transitionLearner_->idFromName(tailName),
                             _transitionLearner_->idFromName(headName));
      } else if (headSlice == KTBN< GUM_SCALAR >::ATEMPORAL) {
        if (_atemporalLearner_)
          atemporalDAG.addArc(_atemporalLearner_->idFromName(tailName),
                              _atemporalLearner_->idFromName(headName));
      } else {
        initialDAG.addArc(_initialLearner_->idFromName(tailName),
                          _initialLearner_->idFromName(headName));
      }
    }
 
    BayesNet< GUM_SCALAR > transitionBN
        = _transitionLearner_->learnParameters(transitionDAG, takeIntoAccountScore);
    BayesNet< GUM_SCALAR > initialBN
        = _initialLearner_->learnParameters(initialDAG, takeIntoAccountScore);
    BayesNet< GUM_SCALAR > atemporalBN
        = _atemporalLearner_
            ? _atemporalLearner_->learnParameters(atemporalDAG, takeIntoAccountScore)
            : BayesNet< GUM_SCALAR >{};
 
    return _assemble_(transitionBN, initialBN, atemporalBN);
  }

References _assemble_(), _atemporalLearner_, gum::learning::IKTBNLearner< GUM_SCALAR >::_encode_(), _initialLearner_, _prior_ktbn_, _transitionLearner_, gum::DAG::addArc(), gum::NodeGraphPart::addNodeWithId(), gum::KTBN< GUM_SCALAR >::ATEMPORAL, GUM_ERROR, and k().

Here is the call graph for this function:

◆ names()

template<GUM_Numeric GUM_SCALAR>

std::vector< std::string > gum::learning::KTBNLearner< GUM_SCALAR >::names ( ) const

Base names (no slice suffix), one entry per base variable (temporal or atemporal), in the original CSV header order.

Definition at line 879 of file KTBNLearner_tpl.h.

                                                                {
    // The first nbCols() columns of the transition table are the base variables
    // (slice-0 temporals then atemporals); the remaining columns are just later
    // slices of those same temporals. So strip the slice suffix off the first
    // nbCols() engine names to get each base variable exactly once.
    const auto&                engine = _transitionLearner_->names();
    const Size                 n      = nbCols();
    std::vector< std::string > result;
    result.reserve(n);
    for (Size i = 0; i < n; ++i)
      result.push_back(_determineNode_(engine[i]).first);
    return result;
  }

References gum::learning::IKTBNLearner< GUM_SCALAR >::_determineNode_(), _transitionLearner_, and nbCols().

Referenced by _buildPriorFromCSV_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nbCols()

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::nbCols ( ) const

Number of columns in each CSV, i.e. of base variables (temporal + atemporal).

Definition at line 755 of file KTBNLearner_tpl.h.

                                               {
    return _prior_ktbn_.nbTemporalVars() + _prior_ktbn_.nbAtemporalVars();
  }

References _prior_ktbn_.

Referenced by domainSizes(), names(), and toString().

Here is the caller graph for this function:

◆ nbDroppedRows()

template<GUM_Numeric GUM_SCALAR>

INLINE Size gum::learning::KTBNLearner< GUM_SCALAR >::nbDroppedRows ( ) const

Number of rows dropped from the internal databases because they carried a missing symbol.

aGrUM's structure learning refuses a database holding any missing value (gum::learning::IBNLearner::learnDag_), so build() performs complete-case selection: a row is inserted only if every cell it needs is observed. This mirrors the cross-k score, which likewise skips any instance whose family is incomplete, so both layers agree on which data counts. hasMissingValues() is consequently always false.

The unit differs per table: a transition row is a whole width-k window, so one gap costs up to \(k\) of them; an initial or atemporal row is a whole trajectory's contribution.

Warning: Complete-case selection distorts any likelihood computed on the result, and it does so unevenly across \(k\).

A row is dropped as soon as one cell of the window it feeds is missing, so a single gap costs up to \(k\) transition rows. A larger \(k\) spans more rows per window and therefore loses proportionally more of them.

That matters because \(\log_2 L\) is a sum of per-instance terms, every one of which is \(\leq 0\). Scoring fewer instances removes negative terms, so it raises the total — a model does not fit better, it is simply charged for less. Two consequences:

a \(\log_2 L\) obtained with dropping is not comparable to one obtained on complete data, nor to one obtained at a different missing-value rate;
comparing orders this way (gum::learning::KTBNAdaptiveLearner) skews towards larger \(k\), since the larger candidate both drops more instances and gains more from having dropped them. The BIC penalty does not offset it: \(\log_2 N\) is taken once from the raw trajectory length and held fixed across candidates, so the penalty describes a sample size the likelihood no longer uses.

The effect grows with the missing-value rate. Read bestK() and scorePerCandidateK() with that in mind, and prefer complete trajectories whenever the order itself is the question being asked.

Note: Independently of the above, complete-case selection is only unbiased when values are missing completely at random (MCAR). If missingness depends on the data, the retained rows are a biased sample and the learned CPTs inherit that bias.

Definition at line 868 of file KTBNLearner_tpl.h.

                                                             {
    return _nbDroppedRows_;
  }

References _nbDroppedRows_.

◆ nbRows()

template<GUM_Numeric GUM_SCALAR>

std::vector< Size > gum::learning::KTBNLearner< GUM_SCALAR >::nbRows ( ) const

Number of time steps in each trajectory CSV (one entry per sample, in load order). This is the raw trajectory length; the transition table's sliding-window row count for trajectory i is nbRows()[i] - k + 1.

Definition at line 760 of file KTBNLearner_tpl.h.

                                                            {
    // Raw trajectory lengths captured by _build_(), one entry per sample. Unlike
    // BNLearner::nbRows() (a single flat-table row count), a trajectory learner
    // has one length per sequence, so the per-sample vector is the natural analog.
    return _nbTimeSlices_;
  }

References _nbTimeSlices_.

◆ nbSamples()

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::nbSamples ( ) const

Number of trajectory CSV files loaded (the constructor's nbSamples).

Definition at line 856 of file KTBNLearner_tpl.h.

                                                  {
    // the initial table holds exactly one row per trajectory, so its row count
    // is the number of trajectory files given to the constructor.
    return _initialLearner_->nbRows();
  }

References _initialLearner_.

Referenced by KTBNLearner(), KTBNLearner(), KTBNLearner(), _build_(), and _inferAtemporalVars_().

Here is the caller graph for this function:

◆ operator=() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

privatedelete

References KTBNLearner().

Here is the call graph for this function:

◆ operator=() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

privatedelete

References KTBNLearner().

Here is the call graph for this function:

◆ setMaxIndegree()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Cap the number of parents of any single node.

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

Definition at line 740 of file KTBNLearner_tpl.h.

                                                                                        {
    _forEachLearner_([&](BNLearner< GUM_SCALAR >& l) { l.setMaxIndegree(max_indegree); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConstraints_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ state()

template<GUM_Numeric GUM_SCALAR>

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

Settings as a vector of (key, value, comment) tuples (mirrors BNLearner::state()).

Definition at line 803 of file KTBNLearner_tpl.h.

                                             {
    // settings are applied identically to every internal learner, so the
    // transition learner's state represents the whole KTBNLearner.
    auto result = _transitionLearner_->state();
 
    // The transition learner lists every slice of every temporal variable
    // (e.g. "W[0][2], W[1][2], W[2][2], W[3][2]"). Replace that row with one
    // entry per base variable (e.g. "W[2]") built directly from the KTBN's own
    // variable sets — no string parsing, robust to any base name.
    for (auto& [key, val, comment]: result) {
      if (key != "Variables") continue;
      // Build base -> domainSize from the prior KTBN (slice 0 for temporal, AT for atemporal).
      std::string collapsed;
      bool        first = true;
      auto        emit  = [&](const std::string& base, int slice) {
        const auto& var = _prior_ktbn_.variable(base, slice);
        if (!first) collapsed += ", ";
        collapsed += base + "[" + std::to_string(var.domainSize()) + "]";
        first = false;
      };
      for (const auto& base: _prior_ktbn_.temporalVarNames())
        emit(base, 0);
      for (const auto& base: _prior_ktbn_.atemporalVarNames())
        emit(base, KTBN< GUM_SCALAR >::ATEMPORAL);
      val = collapsed;
      break;
    }
    return result;
  }

References _prior_ktbn_, _transitionLearner_, and gum::KTBN< GUM_SCALAR >::ATEMPORAL.

◆ toString()

template<GUM_Numeric GUM_SCALAR>

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

Human-readable summary of the learner's current configuration.

Definition at line 778 of file KTBNLearner_tpl.h.

                                                      {
    // Emit a k-TBN-specific header, then delegate score/algo/prior/constraint
    // details to each internal learner's toString().
    std::stringstream s;
    s << "k                 : " << k() << '\n';
    s << "Variables         : " << nbCols() << " (" << _prior_ktbn_.nbTemporalVars()
      << " temporal, " << _prior_ktbn_.nbAtemporalVars() << " atemporal)" << '\n';
    s << "Transition rows   : " << _transitionLearner_->nbRows() << '\n';
    s << "Initial rows      : " << _initialLearner_->nbRows() << '\n';
    s << '\n';
    s << "=== Transition learner (arcs into slice " << (k() - 1) << ") ===" << '\n';
    s << _transitionLearner_->toString();
    s << '\n';
    s << "=== Initial learner (slices 0.." << (k() - 2) << ") ===" << '\n';
    s << _initialLearner_->toString();
    if (_atemporalLearner_) {
      s << '\n';
      s << "=== Atemporal learner (atemporal->atemporal arcs) ===" << '\n';
      s << _atemporalLearner_->toString();
    }
    return s.str();
  }

References _atemporalLearner_, _initialLearner_, _prior_ktbn_, _transitionLearner_, k(), and nbCols().

Here is the call graph for this function:

◆ useExtendedGreedyHillClimbing()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

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

Definition at line 374 of file KTBNLearner_tpl.h.

                                                                                      {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useExtendedGreedyHillClimbing(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useGreedyHillClimbing()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

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

Definition at line 368 of file KTBNLearner_tpl.h.

                                                                              {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useGreedyHillClimbing(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useLocalSearchWithTabuList()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

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

Definition at line 381 of file KTBNLearner_tpl.h.

                                                                                            {
    _forEachLearner_(
        [&](BNLearner< GUM_SCALAR >& l) { l.useLocalSearchWithTabuList(tabu_size, nb_decrease); });
    return *this;
  }

References _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useMDLCorrection()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.

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

Definition at line 404 of file KTBNLearner_tpl.h.

                                                                         {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useMDLCorrection(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Here is the call graph for this function:

◆ useMIIC()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

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

Definition at line 388 of file KTBNLearner_tpl.h.

                                                                {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useMIIC(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Here is the call graph for this function:

◆ useNMLCorrection()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.

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

Definition at line 398 of file KTBNLearner_tpl.h.

                                                                         {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useNMLCorrection(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useNoCorrection()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Engine-name pairs (tail, head) of arcs flagged as hiding a latent variable by MIIC (merged from all internal learners). Returned as names rather than Arc/NodeId pairs because the internal learners live in independent NodeId spaces, so a bare NodeId would be ambiguous.

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

Definition at line 410 of file KTBNLearner_tpl.h.

                                                                        {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useNoCorrection(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useScoreAIC()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 315 of file KTBNLearner_tpl.h.

                                                                    {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScoreAIC(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useScoreBD()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 321 of file KTBNLearner_tpl.h.

                                                                   {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScoreBD(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useScoreBDeu()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 327 of file KTBNLearner_tpl.h.

                                                                     {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScoreBDeu(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Here is the call graph for this function:

◆ useScoreBIC()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 333 of file KTBNLearner_tpl.h.

                                                                    {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScoreBIC(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useScorefNML()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 351 of file KTBNLearner_tpl.h.

                                               {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScorefNML(); });
  }

References _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useScoreLog2Likelihood()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 339 of file KTBNLearner_tpl.h.

                                                                               {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScoreLog2Likelihood(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useScoreMDL()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns a warning string if the current score and prior are incompatible, empty string otherwise.

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

Definition at line 345 of file KTBNLearner_tpl.h.

                                                                    {
    _forEachLearner_([](BNLearner< GUM_SCALAR >& l) { l.useScoreMDL(); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useSmoothingPrior()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

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

Definition at line 446 of file KTBNLearner_tpl.h.

                                                                                       {
    _forEachLearner_([&](BNLearner< GUM_SCALAR >& l) { l.useSmoothingPrior(weight); });
    return *this;
  }

References KTBNLearner(), and _forEachLearner_().

Referenced by gum::learning::KTBNAdaptiveLearner< GUM_SCALAR >::_applyConfig_().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _atemporalLearner_

template<GUM_Numeric GUM_SCALAR>

std::unique_ptr< BNLearner< GUM_SCALAR > > gum::learning::KTBNLearner< GUM_SCALAR >::_atemporalLearner_

private

learns the atemporal variables (arcs atemporal -> atemporal)

Definition at line 580 of file KTBNLearner.h.

Referenced by _build_(), _forEachLearner_(), _forOwningLearner_(), addNoChildrenNode(), addNoParentNode(), addPossibleEdge(), copyState(), eraseNoChildrenNode(), eraseNoParentNode(), erasePossibleEdge(), hasMissingValues(), latentVariables(), learnKTBN(), learnParameters(), and toString().

◆ _ignoreMissingSymbols_

template<GUM_Numeric GUM_SCALAR>

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

private

prior k-TBN: the single source of truth for k, variable domains, temporal/atemporal classification and engine names. Everything else (base lists, column names) is derived from it on demand. Analogous to the prior BayesNet stored in BNLearner when a reference BN is given. whether build() drops incomplete rows rather than refusing the data

Definition at line 587 of file KTBNLearner.h.

Referenced by KTBNLearner(), KTBNLearner(), _build_(), and isIgnoringMissingSymbols().

◆ _initialLearner_

template<GUM_Numeric GUM_SCALAR>

std::unique_ptr< BNLearner< GUM_SCALAR > > gum::learning::KTBNLearner< GUM_SCALAR >::_initialLearner_

private

learns the initial slices 0..k-2

Definition at line 577 of file KTBNLearner.h.

Referenced by _build_(), _forEachLearner_(), _forOwningLearner_(), addNoChildrenNode(), addNoParentNode(), addPossibleEdge(), copyState(), eraseNoChildrenNode(), eraseNoParentNode(), erasePossibleEdge(), hasMissingValues(), latentVariables(), learnKTBN(), learnParameters(), nbSamples(), and toString().

◆ _nbAtemporalPossibleEdges_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::_nbAtemporalPossibleEdges_ = 0

private

Definition at line 607 of file KTBNLearner.h.

Referenced by addPossibleEdge(), copyState(), erasePossibleEdge(), and learnKTBN().

◆ _nbDroppedRows_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::_nbDroppedRows_ {0}

private

number of time steps (rows) in each trajectory CSV, in load order. rows build() dropped because they carried a missing symbol

Definition at line 593 of file KTBNLearner.h.

Referenced by _build_(), and nbDroppedRows().

◆ _nbTemporalPossibleEdges_

template<GUM_Numeric GUM_SCALAR>

Size gum::learning::KTBNLearner< GUM_SCALAR >::_nbTemporalPossibleEdges_ = 0

private

counts of currently-active possible edges, split by kind: edges with at least one temporal endpoint, and edges between two atemporal variables. Maintained by add/erasePossibleEdge(). When a whitelist is active (temporal count > 0) but no atemporal->atemporal edge is whitelisted, the atemporal learner would otherwise stay unrestricted; learnKTBN() then suppresses it so the whitelist is honoured (no atemporal arc is produced).

Definition at line 606 of file KTBNLearner.h.

Referenced by addPossibleEdge(), copyState(), erasePossibleEdge(), and learnKTBN().

◆ _nbTimeSlices_

template<GUM_Numeric GUM_SCALAR>

std::vector< Size > gum::learning::KTBNLearner< GUM_SCALAR >::_nbTimeSlices_

private

Captured once by build() and exposed by nbRows(). This is the raw trajectory length, not the sliding-window row count of the transition table (which is nbTimeSlices[i] - k + 1 summed over trajectories).

Definition at line 598 of file KTBNLearner.h.

Referenced by _build_(), and nbRows().

◆ _prior_ktbn_

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::learning::KTBNLearner< GUM_SCALAR >::_prior_ktbn_

private

Definition at line 589 of file KTBNLearner.h.

Referenced by KTBNLearner(), KTBNLearner(), _assemble_(), _atemporalVarNames_(), _build_(), _forEachAllSlicesPair_(), _forOwningLearner_(), _isKnownBase_(), addForbiddenIntraSliceArc(), addNoChildrenNode(), addNoParentNode(), addPossibleEdge(), domainSize(), eraseForbiddenIntraSliceArc(), eraseNoChildrenNode(), eraseNoParentNode(), erasePossibleEdge(), k(), learnParameters(), nbCols(), state(), and toString().

◆ _transitionLearner_

template<GUM_Numeric GUM_SCALAR>

std::unique_ptr< BNLearner< GUM_SCALAR > > gum::learning::KTBNLearner< GUM_SCALAR >::_transitionLearner_

private

learns the transition kernel (arcs arriving at slice k-1)

Definition at line 574 of file KTBNLearner.h.

Referenced by _build_(), _forEachLearner_(), _forOwningLearner_(), addNoChildrenNode(), addNoParentNode(), addPossibleEdge(), checkScorePriorCompatibility(), copyState(), domainSize(), domainSizes(), eraseNoChildrenNode(), eraseNoParentNode(), erasePossibleEdge(), hasMissingValues(), isConstraintBased(), isScoreBased(), latentVariables(), learnKTBN(), learnParameters(), names(), state(), and toString().

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

agrum/KTBN/learning/KTBNLearner.h
agrum/KTBN/learning/KTBNLearner_tpl.h

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

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

Detailed Description

Constructor & Destructor Documentation

◆ KTBNLearner() [1/5]

◆ KTBNLearner() [2/5]

◆ KTBNLearner() [3/5]

◆ ~KTBNLearner()

◆ KTBNLearner() [4/5]

◆ KTBNLearner() [5/5]

Member Function Documentation

◆ _assemble_()

◆ _atemporalVarNames_()

◆ _build_()

◆ _buildPriorFromBN_()

◆ _buildPriorFromCSV_()

◆ _checkArcTemporallyFeasible_()

◆ _checkBaseIsTemporal_()

◆ _checkMinimalOrder_()

◆ _determineNode_()

◆ _encode_()

◆ _forEachAllSlicesPair_()

◆ _forEachLearner_()

◆ _forOwningLearner_()

◆ _inferAtemporalVars_()

◆ _isKnownBase_()

◆ _scanConstantColumns_()

◆ addForbiddenArc() [1/2]

◆ addForbiddenArc() [2/2]

◆ addForbiddenArcAllSlices()

◆ addForbiddenIntraSliceArc()

◆ addMandatoryArc() [1/2]

◆ addMandatoryArc() [2/2]

◆ addNoChildrenNode() [1/2]

◆ addNoChildrenNode() [2/2]

◆ addNoParentNode() [1/2]

◆ addNoParentNode() [2/2]

◆ addPossibleEdge() [1/2]

◆ addPossibleEdge() [2/2]

◆ allowArcAdditions()

◆ allowArcDeletions()

◆ allowArcReversals()

◆ checkScorePriorCompatibility()

◆ copyState()

◆ domainSize()

◆ domainSizes()

◆ eraseForbiddenArc() [1/2]

◆ eraseForbiddenArc() [2/2]

◆ eraseForbiddenArcAllSlices()

◆ eraseForbiddenIntraSliceArc()

◆ eraseMandatoryArc() [1/2]

◆ eraseMandatoryArc() [2/2]

◆ eraseNoChildrenNode() [1/2]

◆ eraseNoChildrenNode() [2/2]

◆ eraseNoParentNode() [1/2]

◆ eraseNoParentNode() [2/2]

◆ erasePossibleEdge() [1/2]

◆ erasePossibleEdge() [2/2]

◆ hasMissingValues()

◆ isConstraintBased()

◆ isIgnoringMissingSymbols()

◆ isScoreBased()

◆ k()

◆ latentVariables()

◆ learnKTBN()

◆ learnParameters()

◆ names()

◆ nbCols()

◆ nbDroppedRows()

◆ nbRows()

◆ nbSamples()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ setMaxIndegree()

◆ state()

◆ toString()

◆ useExtendedGreedyHillClimbing()