Node evidence

<< Click to Display Table of Contents >>

Navigation:  Using SMILE Wrappers > Networks, nodes and arcs > Nodes >

Node evidence

The output from inference algorithms depends on node definitions and the evidence set on nodes. For discrete nodes, evidence is specified by outcome index or identifier; for continuous nodes, it is a numeric value, with related methods including “cont” in their names (e.g., Network.get_cont_evidence). In dynamic Bayesian networks (DBNs), evidence is set for specific time slices, with corresponding methods including “temporal” (e.g., Network.get_temporal_evidence).

Nodes can also have propagated evidence, implied by other evidence in the network, and virtual evidence, a probability distribution over discrete node outcomes.

Evidence is transient: it is not stored when the network is saved or serialized, and must be reapplied when a network is reloaded. For users who need to store multiple evidence sets persistently, SMILE provides a case manager functionality that allows different evidence cases to be saved directly in the network object and serialized along with it.

The methods related to evidence include:

Python

is_evidence(node: int | str) -> bool

is_propagated_evidence(node: int | str) -> bool

is_real_evidence(node: int | str) -> bool

is_virtual_evidence(node: int | str) -> bool

is_temporal_evidence(node: int | str) -> bool

has_temporal_evidence(node: int | str) -> bool

clear_evidence(node: int | str) -> None

clear_temporal_evidence(node: int | str, time_slice: int) -> None

get_evidence(node: int | str) -> int

get_evidence_id(node: int | str) -> str

get_cont_evidence(node: int | str) -> float

get_virtual_evidence(node: int | str) -> List[float]

get_temporal_evidence(node: int | str, time_slice: int) -> int

get_temporal_evidence_id(node: int | str, time_slice: int) -> str

get_temporal_virtual_evidence(node: int | str, time_slice: int) -> List[float]

set_evidence(node: int | str, outcome: int | str) -> None

set_cont_evidence(node: int | str, value: float) -> None

set_virtual_evidence(node: int | str, distribution: List[float]) -> None

set_temporal_evidence(node: int | str, time_slice: int, outcome: int | str) -> None

set_temporal_virtual_evidence(node: int | str, time_slice: int, distribution: List[float]) -> None

Java

boolean isEvidence(int nodeHandle);

boolean isEvidence(String nodeId);

boolean isPropagatedEvidence(int nodeHandle);

boolean isPropagatedEvidence(String nodeId);

boolean isRealEvidence(int nodeHandle);

boolean isRealEvidence(String nodeId);

boolean isVirtualEvidence(int nodeHandle);

boolean isVirtualEvidence(String nodeId);

boolean isTemporalEvidence(int nodeHandle);

boolean isTemporalEvidence(String nodeId);

boolean hasTemporalEvidence(int nodeHandle);

boolean hasTemporalEvidence(String nodeId);

void clearEvidence(int nodeHandle);

void clearEvidence(String nodeId);

int getEvidence(int nodeHandle);

String getEvidenceId(String nodeId);

void setEvidence(int nodeHandle, int outcomeIndex);

void setEvidence(String nodeId, String outcomeId);

double getContEvidence(int nodeHandle);

double getContEvidence(String nodeId);

void setContEvidence(int nodeHandle, double value);

void setContEvidence(String nodeId, double value);

double[] getVirtualEvidence(int nodeHandle);

double[] getVirtualEvidence(String nodeId);

void setVirtualEvidence(int nodeHandle, double[] distribution);

void setVirtualEvidence(String nodeId, double[] distribution);

void clearTemporalEvidence(int nodeHandle, int timeSlice);

void clearTemporalEvidence(String nodeId, int timeSlice);

int getTemporalEvidence(int nodeHandle, int timeSlice);

String getTemporalEvidenceId(String nodeId, int timeSlice);

double[] getTemporalVirtualEvidence(int nodeHandle, int timeSlice);

void setTemporalEvidence(int nodeHandle, int timeSlice, int outcomeIndex);

void setTemporalEvidence(String nodeId, int timeSlice, String outcomeId);

void setTemporalVirtualEvidence(int nodeHandle, int timeSlice, double[] distribution);

void setTemporalVirtualEvidence(String nodeId, int timeSlice, double[] distribution);

C#

bool IsEvidence(int nodeHandle);

bool IsEvidence(string nodeId);

bool IsPropagatedEvidence(int nodeHandle);

bool IsPropagatedEvidence(string nodeId);

bool IsRealEvidence(int nodeHandle);

bool IsRealEvidence(string nodeId);

bool IsVirtualEvidence(int nodeHandle);

bool IsVirtualEvidence(string nodeId);

bool IsTemporalEvidence(int nodeHandle);

bool IsTemporalEvidence(string nodeId);

bool HasTemporalEvidence(int nodeHandle);

bool HasTemporalEvidence(string nodeId);

void ClearEvidence(int nodeHandle);

void ClearEvidence(string nodeId);

void ClearTemporalEvidence(int nodeHandle, int timeSlice);

void ClearTemporalEvidence(string nodeId, int timeSlice);

int GetEvidence(int nodeHandle);

int GetEvidence(string nodeId);

string GetEvidenceId(int nodeHandle);

string GetEvidenceId(string nodeId);

double GetContEvidence(int nodeHandle);

double GetContEvidence(string nodeId);

double[] GetVirtualEvidence(int nodeHandle);

double[] GetVirtualEvidence(string nodeId);

int GetTemporalEvidence(int nodeHandle, int timeSlice);

int GetTemporalEvidence(string nodeId, int timeSlice);

string GetTemporalEvidenceId(int nodeHandle, int timeSlice);

string GetTemporalEvidenceId(string nodeId, int timeSlice);

double[] GetTemporalVirtualEvidence(int nodeHandle, int timeSlice);

double[] GetTemporalVirtualEvidence(string nodeId, int timeSlice);

void SetEvidence(int nodeHandle, int outcome);

void SetEvidence(string nodeId, int outcome);

void SetEvidence(int nodeHandle, string outcomeId);

void SetEvidence(string nodeId, string outcomeId);

void SetContEvidence(int nodeHandle, double value);

void SetContEvidence(string nodeId, double value);

void SetVirtualEvidence(int nodeHandle, double[] distribution);

void SetVirtualEvidence(string nodeId, double[] distribution);

void SetTemporalEvidence(int nodeHandle, int timeSlice, int outcome);

void SetTemporalEvidence(string nodeId, int timeSlice, int outcome);

void SetTemporalEvidence(int nodeHandle, int timeSlice, string outcomeId);

void SetTemporalEvidence(string nodeId, int timeSlice, string outcomeId);

void SetTemporalVirtualEvidence(int nodeHandle, int timeSlice, double[] distribution);

void SetTemporalVirtualEvidence(string nodeId, int timeSlice, double[] distribution);

R

evidenceStatus <- isEvidence(nodeIdOrHandle)

propagatedEvidenceStatus <- isPropagatedEvidence(nodeIdOrHandle)

realEvidenceStatus <- isRealEvidence(nodeIdOrHandle)

virtualEvidenceStatus <- isVirtualEvidence(nodeIdOrHandle)

temporalEvidenceStatus <- isTemporalEvidence(nodeIdOrHandle)

hasTemporal <- hasTemporalEvidence(nodeIdOrHandle)

clearEvidence(nodeIdOrHandle)

clearTemporalEvidence(nodeIdOrHandle, timeSlice)

evidenceValue <- getEvidence(nodeIdOrHandle)

evidenceId <- getEvidenceId(nodeIdOrHandle)

contEvidenceValue <- getContEvidence(nodeIdOrHandle)

virtualEvidenceValues <- getVirtualEvidence(nodeIdOrHandle)

temporalEvidenceValues <- getTemporalEvidence(nodeIdOrHandle, timeSlice)

temporalEvidenceIds <- getTemporalEvidenceId(nodeIdOrHandle, timeSlice)

temporalVirtualValues <- getTemporalVirtualEvidence(nodeIdOrHandle, timeSlice)

setEvidence(nodeIdOrHandle, outcomeOrId)

setContEvidence(nodeIdOrHandle, value)

setVirtualEvidence(nodeIdOrHandle, distribution)

setTemporalEvidence(nodeIdOrHandle, timeSlice, outcomeOrId)

setTemporalVirtualEvidence(nodeIdOrHandle, timeSlice, distribution)