EVALUACIÓN DEL FIN

Sherlock frames diagnosis as a best-first generate and test search where candidates are generated, tested for consistency, and conflicts are extracted from the candidate if it is inconsistent. These conflicts are used to generate a new candidate. This process is necessary since the behavioral modes explodes the space of possible diagnoses, making them exponential in the number of components. It is infeasible to enumerate and test these diagnoses for consistency since the test for consistency is an exponential computation.

Instead, Sherlock uses the probabilities on component modes to focus the diagnosis to test likely candidates for consistency before testing less likely candidates. The probability of a candidate, defined in Equation 2-1, is given by the product of the probabilities of the component mode assignments in that candidate. The probability of a candidate is updated using the probability, P(O). The update equation is given as follows:

( )

( )

( )

( )

( )

| ^{im i}

im j

i im ij

x C

i

j im ij

j x C

P O p x v

P C O

P O p x v

∈

∈

• =

= • =

∏

∑ ∏

The numerator represents the probability that a candidate predicts all current observations, and the denominator is a normalization factor. P(O) represents the probability that a candidate correctly predicts an observation.

If a candidate predicts all observations correctly, then P(O) = 1. If a candidate does not predict, or refutes, the observations, then P(O) = 0.

Finally, if a candidate neither predicts or refutes an observation, then any

value in the domain of the observation is equally likely, so P(O) = 1/n, where n is the number of possible values for the observation. As an example, a candidate that contains the unknown mode of a component makes no predictions on the observation variable q, so in that case P(O) = 1/nq, assuming the candidate correctly predicts the remaining observations.

To demonstrate the best-first candidate generation of Sherlock, consider the NEAR Power storage system used in GDE, modified now to have behavior modes.

Switch

OK: Out(S) = In(S) p = 0.99 Stuck-High: Out(S) > In(S p = 0.001 Stuck-Low: Out(S) < In(S) p = 0.008 Unknown: [ ] p = 0.001

Charger-1

OK: Out(Ch-1) = [In(Ch-1)]² p = 0.99 Stuck-High: Out(Ch-1) >

[In(Ch-1)]2 p = 0.008 Stuck-Low: Out(Ch-1) <

[In(Ch-1)]2 p = 0..001 Unknown: [ ] p = 0.001

Adder

OK: Out(AG) = In₁(AG) + In₂(AG) p = 0.99 Stuck-High: Out(AG) >

In₁(AG) + In₂(AG) p = 0.008 Stuck-Low: Out(AG) <

In₁(AG) + In₂(AG) p = 0.001 Unknown: [ ] p = 0.001

Battery

OK: Out(B) = In(B) / 100 p = 0.99 Stuck-High: Out(B) >

In(B) / 100 p = 0.008 Stuck-Low: Out(B) <

In(B) / 100 p = 0.001 Unknown: [ ] p = 0.001

A

X Y

B C

Z

D

Charger-2

OK: Out(Ch-2) = [In(Ch-2)]² p = 0.99 Stuck-High: Out(Ch-2) >

[In(Ch-2)]2 p = 0.008 Stuck-Low: Out(Ch-2) <

[In(Ch-2)]2 p = 0.001 Unknown: [ ] p = 0.001

Figure 2-4 - NEAR Power Storage System modified to have Behavioral Modes

The modes of the components give additional fault modes, and still maintain the operational mode described in GDE, and the unknown mode that does not have any model constraints. The probability for each component mode is shown to the right of its constraint. The fault modes for the switch are stuck-high, and stuck-low capturing that the output sent to the chargers is either higher or lower than expected. The chargers are

modeled with a stuck-high and a stuck-low fault mode that captures when the output is higher or lower than the expected squaring, respectively. The adder and battery have similar modes stuck-high and stuck-low that constrain the output to be greater or lower than expected.

Sherlock generates conflicts for a given set of observations and a candidate in the same way GDE performed conflict recognition, except that Sherlock does not determine all conflicts for a given set of observations, but only those relevant to the particular candidate. As more observation information is incorporated, more conflicts are generated enabling Sherlock to focus the diagnosis more.

Sherlock is able to determine instantaneous diagnoses given the current observations for A, B, C and D, and the system model. Sherlock first chooses a candidate, and in the absence of conflicts, chooses the most likely mode assignment for each component. Suppose that A = 5, B = 9, C = 9 and D = 0.18. Sherlock determines that the most likely candidate is:

{switch = ok, charger-1 = ok, charger-2 = ok, adder = ok, battery = ok}

with p = 0.95.

Sherlock then tests if this candidate is consistent with the system mode constraints and the observations. The consistency check identifies a discrepancy in the values of X and Y. The mode switch = ok predicts that X = 5 and Y = 5. However, the modes charger-1 = ok and charger-2 = ok results in X = 3 and Y = 3, respectively. The resultant conflicts are:

¬[(switch = ok), (charger-1 = ok)]

¬[(switch = ok), (charger-2 = ok)]

Sherlock uses these conflicts and the probabilities of component modes to focus on likely diagnoses. The conflict identifies infeasible sets of

assignments. To resolve the conflicts, Sherlock chooses other component modes not mentioned in the conflict. For instance the modes that would resolve the first conflict include: switch = stuck-high, switch = stuck-low, switch = unknown, charger-1 = stuck-high, charger-1 = stuck-low, charger-1 = unknown. Sherlock chooses the minimal set of most likely component modes that resolves all conflicts, or kernel diagnoses. Sherlock only generates the most likely kernel diagnosis, and then extends this to a candidate to be tested. In the case of these conflicts, the most likely kernel diagnosis is:

(switch = stuck-low, p = 0.008) This results in the candidate:

{ switch = stuck-low, charger-1 = ok, charger-2 = ok, adder = ok, battery = ok }

with p = 0.00768.

Although this probability is low, it has not been normalized by the sum of all the probabilities of the diagnoses. Sherlock then tests this candidate for consistency. In performing this, Sherlock identifies that the component mode switch = stuck-low predicts X < 5 and Y < 5. Using the component modes charger-1 = ok and charger-2 = ok results in X = 3 and Y = 3. The consistency test does not identify any more conflicts, so this is then labeled as a diagnosis of the system.

The key feature to note is the speed with which Sherlock found the most likely diagnosis of the system. The benefits of using a conflict-directed search and guiding the choice of candidates by probability focus the search for the most likely diagnosis. A detailed, updated presentation of a Sherlock-like algorithm is presented in [Williams, 2002], with the original algorithm given in [deKleer, 1989].