Using SMILE Wrappers > Diagnosis

With diagnostic attributes—such as node roles and, optionally, observation costs—defined, a diagnostic session can be initiated to generate a ranked list of candidate observations. The diagnostic session is represented by a DiagNetwork object. Its constructor requires a reference to the Network object where the diagnostic information is defined.

The DiagNetwork instance provides an API for pursuing faults, instantiating observations, and retrieving observation statistics. During a diagnostic session, all interactions with the diagnostic model should be performed through the DiagNetwork instance.

Python

diagnet = pysmile.DiagNetwork(net)

Java

DiagNetwork diagNet = new DiagNetwork(net);

diagNet <- DiagNetwork(net)

The diagnostic session automatically instantiates mandatory observations during initialization. To obtain a ranking of uninstantiated observations, their diagnostic value must be calculated. This value is dynamic, depending on the observations already instantiated and the fault or faults selected as the focus of reasoning, referred to as pursued faults. By default, the pursued fault is the most likely fault.

From the diagnostic session perspective, a fault is represented as a node/state pair, since a single fault node may have multiple faulty states. Node/state pairs are referenced by their indices; fault node handles should not be used directly when specifying the pursued fault. To convert a node handle/state pair to a fault index, use DiagNetwork.get_fault_index. To change the pursued fault, use DiagNetwork.set_pursued_fault, or DiagNetwork.set_pursued_faults when pursuing multiple faults simultaneously.

During the diagnostic session, observation nodes can be set to evidence using DiagNetwork.instantiate_observation. The Network.setEvidence method should not be called directly during a session, as it can render the internal session state inconsistent. Instantiated observations can be reset to unobserved using DiagNetwork.release_observation, which internally calls Network.clearEvidence.

After selecting the pursued faults and instantiating known observations, the application can call DiagNetwork.update to obtain a DiagResults object, which contains two arrays:

•DiagResults.faults contains an entry for each fault node in the network. Each entry includes the probability of the fault state in its probability member. The array is sorted in descending order of fault probability.

•DiagResults.observations contains an entry for each uninstantiated observation node in the network. Each entry includes the diagnostic measure in its measure member, and the info_gain member contains the effective measure combined with the observation cost. If no cost is defined, info_gain is equal to measure. The array is sorted in descending order of info_gain.

A typical diagnostic program is interactive, beginning with a single pursued fault and no instantiated observations other than those with default values. The user may change the pursued faults and instantiate observations based on the diagnostic values displayed in the interface.

The following methods of the DiagNetwork class provide programmatic access to the diagnostic session, allowing pursued faults to be set, observations to be instantiated, and diagnostic results to be retrieved.

Python

update() -> DiagResults

restart() -> None

set_pursued_fault(faultIndex: int) -> None

set_pursued_faults(faultIndices: List[int]) -> None

get_pursued_fault() -> int

get_pursued_faults() -> List[int]

get_fault_count() -> int

get_unperformed_test_count() -> int

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

release_observation(node: int | str) -> None

get_unperformed_observations() -> List[int]

get_unperformed_observation_ids() -> List[str]

mandatories_instantiated() -> bool

find_most_likely_fault() -> int

get_fault_index(node: int | str, outcome: int | str) -> int

get_fault_node(faultIndex: int) -> int

get_fault_node_id(faultIndex: int) -> str

get_fault_outcome(faultIndex: int) -> int

get_fault_outcome_id(faultIndex: int) -> str

Java

DiagResults update();

void restart();

void setPursuedFault(int faultIndex);

void setPursuedFaults(int[] faultIndices);

int getPursuedFault();

int[] getPursuedFaults();

int getFaultCount();

int getUnperformedTestCount();

void instantiateObservation(int nodeHandle, int outcomeIndex);

void instantiateObservation(int nodeHandle, String outcomeId);

void instantiateObservation(String nodeId, String outcomeId);

void instantiateObservation(String nodeId, int outcomeIndex);

void releaseObservation(int nodeHandle);

void releaseObservation(String nodeId);

int[] getUnperformedObservations();

String[] getUnperformedObservationIds();

boolean mandatoriesInstantiated();

int findMostLikelyFault();

int getFaultIndex(int nodeHandle, int outcomeIndex);

int getFaultIndex(int nodeHandle, String outcomeId);

int getFaultIndex(String nodeId, String outcomeId);

int getFaultIndex(String nodeId, int outcomeIndex);

int getFaultNode(int faultIndex);

String getFaultNodeId(int faultIndex);

int getFaultOutcome(int faultIndex);

String getFaultOutcomeId(int faultIndex);

DiagResults Update();

void Restart();

void SetPursuedFault(int faultIndex);

void SetPursuedFaults(int[] faultIndices);

int GetPursuedFault();

int[] GetPursuedFaults();

int GetFaultCount();

int GetUnperformedTestCount();

void InstantiateObservation(int nodeHandle, int outcomeIndex);

void InstantiateObservation(int nodeHandle, string outcomeId);

void InstantiateObservation(string nodeId, int outcomeIndex);

void InstantiateObservation(string nodeId, string outcomeId);

void ReleaseObservation(int nodeHandle);

void ReleaseObservation(string nodeId);

int[] GetUnperformedObservations();

string[] GetUnperformedObservationIds();

bool MandatoriesInstantiated();

int FindMostLikelyFault();

int GetFaultIndex(int nodeHandle, int outcomeIndex);

int GetFaultIndex(int nodeHandle, string outcomeId);

int GetFaultIndex(string nodeId, string outcomeId);

int GetFaultIndex(string nodeId, int outcomeIndex);

int GetFaultNode(int faultIndex);

string GetFaultNodeId(int faultIndex);

int GetFaultOutcome(int faultIndex);

string GetFaultOutcomeId(int faultIndex);

diagResults <- update()

restart()

pursuedFault <- get_pursued_fault()

pursuedFaults <- get_pursued_faults()

set_pursued_fault(faultIndex)

set_pursued_faults(faultIndices)

faultCount <- get_fault_count()

unperformedTestCount <- get_unperformed_test_count()

instantiate_observation(nodeIdOrHandle, outcomeIndexOrId)

release_observation(nodeIdOrHandle)

unperformedObservations <- get_unperformed_observations()

unperformedObservationIds <- get_unperformed_observation_ids()

mandatoriesInstantiated <- mandatories_instantiated()

mostLikelyFault <- find_most_likely_fault()

faultIndex <- get_fault_index(nodeIdOrHandle, outcomeIndexOrId)

faultNode <- get_fault_node(faultIndex)

faultNodeId <- get_fault_node_id(faultIndex)

faultOutcome <- get_fault_outcome(faultIndex)

faultOutcomeId <- get_fault_outcome_id(faultIndex)

Diagnostic session

Diagnostic session