DIAGNOSIS IN AUTOMOTIVE APPLICATIONS

Abstract

A system and method for constructing a diagnosis function for mapping a symptom of a fault in an electromechanical system onto the fault by simulating the electromechanical system in at least a fault mode and a node fault mode, and learning a classifier function from the collected simulation results for mapping the system of the fault onto the fault.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

Exemplary embodiments of the present invention are explained in more detail below with reference to the accompanying drawings, in which:

FIG. 1 illustrates an embodiment of the present invention in a vehicle environment;

FIG. 2 illustrates a taxonomy of fault locations;

FIG. 3 illustrates a simplified ECU structure from a software point-of-view;

FIG. 4 illustrates an overview of a model according to the present invention;

FIG. 5 illustrates a signal flow in the present invention;

FIG. 6 illustrates the interplay between a motor, motor control, and connecting subsystems between user input, motor, and motor control;

FIG. 7 illustrates results of a simulation of a faultless behavior model according to a model of the present invention;

FIG. 8 illustrates results of a simulation of a fault behavior model corresponding to the faultless behavior model illustrated in FIG. 7; and

FIG. 9 illustrates a flowchart of an embodiment of the present invention.

DETAILED DESCRIPTION

The present invention introduces a new technology to the diagnosis of automotive systems as both a formal framework and a concrete implementation, comprising an experimental setup, simulation tasks, and classification results.

The present invention is directed to intricate diagnosis situations in modern cars. The invention employs a mixture of model-based and associative diagnosis and an associated model compilation. In the present invention, a simulation database is built from module simulations of the system in various fault modes over a typical input range. From the simulation database, a simplified rule-based behavior model can be constructed where long cause-effect chains are replaced with much simpler associations. The behavior model is also optimized for a heuristic classification of the faults. The present invention applies the novel model behavior to the complex discrete event/continuous system models of modern cars.

Model compilation is a diagnosis approach that combines the model-based paradigm and the associative (heuristic) paradigm within the following four steps:

1. Simulation. A database, C, is compiled by simulating the interesting system in various fault modes and over its typical input range.

2. Symptom Computation. By comparing the faultless simulation to simulation runs in fault modes a symptom database C_Δ is built up.

3. Generalization. Using cluster analysis or vector quantization, the numerical values in C_Δ are abstracted towards intervals.

4. Learning. Data mining and machine learning is applied to learn a mapping from symptoms onto the set of fault modes; the resulting classifier can be considered as a “diagnosis compiled model.”

Since this process can be completely automated, the approach has the potential to combine the advantages of the model-based philosophy, such as behavior fidelity and generality, with the efficiency and robustness of a heuristic diagnosis system.

One advantage of the present invention is that the substantial number of existing libraries of behavior models, along with the expertise to handle them, can be reused in the simulation step. Additionally, the behavior models are analyzed in their intended inference direction, i.e., neither a special diagnosis model needs to be developed nor an inverse simulation problem needs to be solved.

Further, the classifier learned in the generalization and learning steps integrates seamlessly with existing diagnosis approaches in the automotive domain, such as fault trees. Another advantage provided by the present invention is that the compiled diagnosis model has a very small computational footprint. In contrast, traditional diagnosis approaches require the execution and analysis of a behavior model at runtime.

As illustrated in FIG. 1, a car 1 is complex system that consists of several connected (sub)systems, such as motor, drive train, motor control, etc. For simulation purposes we consider each interesting subsystem being adequately represented as a behavior model M. Depending on the associated subsystem and the simulation purpose, M may be input-free or input-depending; or memoryless or dynamic. The most important distinction relates to the time base of dynamic models, that being continuous time, discrete time, or discrete event.

Definition 1 (Behavior Model): A behavior model M is a tuple (F_U, F_Z, F_Y, V, Δ, Λ). F_U∩F_Z=, whose elements are defined as follows.

• • F_U, F_Z, and F_Y are sets of input variables, constraint variables, and output variables.
  • For each variable vεF_U, F_Z, F_Y there is an arbitrary, possibly infinite set U_v, Z_v, and Y_v respectively, called the domain of v.
  • For each vεF_U there is an additional domain, U_v^T, of partially defined functions in the parameter time, U_v^T:={u|u: T→U_v, tu(t)}. Depending on the model's time base, which may be continuous time, discrete time, or discrete even, T may be an interval from R⁺, an interval from N, or a linearly ordered finite set.

V comprises the domains of all variables. As a matter of convenience, the Cartesian products of the domains of the variables in F_U, F_Z, F_Y are designated with U, U^T, Z, and Y. E.g., Y:=Y_v1×Y_v2× . . . ×Y_v|YY|, v_iεF_Y.

Δ is a function, it is called the global state prescription function. Δ declares a set of state variables, F_x⊂F_z, and a state space, X, which is the projection of Z with respect to F_X. Given a state vector xεX, a vector of input functions u(t)εU^T, and some point in time tεT, Δ determines a constraint vector zεZ including a new state, say, Δ: X×U^t×T→Z.

Λ is a function, it is called the output function. The output function might be a function of constraint variables and input or only a function of constraint variables. Given a constraint vector zεZ and an input vector uεU, A determines an output vector yεY, say, Λ:Z×U→Y or Λ:Z→Y.

A model of even a small part of a car is likely to combine behavior models of different types, say, different time bases; such a model is called “hybrid.”

Let M={M₁, . . . , M_k} be a possibly hybrid car model, then M_i and M_j are coupled if they share output variables and input variables, i.e., if F_Yi∩F_Uj≠, with F_YiεM_i, F_UjεM_j, i≠j. For example, M_i may be a continuous time model of the motor, and M_j may be a discrete time model of the motor control. In the car such a coupling is realized by a sensor whose signal is passed to an ECU where, in the software abstraction layer, the physical quantity is represented as an input variable of the motor control software.

The preceding definition can be regarded as a correct behavior model specification of a system. For the diagnosis approach of the present invention, we also need models of fault behavior in the sense of the GDE+, as described in Peter Struβ, ‘Model-Based Diagnosis—Progress and Problems’, in Proceedings of the International GI-Convention, volume 3, pp. 320-331, (October 1989); Peter Struβand Oskar Dressler, ‘“Physical Negation”—Integrating Fault Models into the General Diagnostic Engine’, in Proceedings of the Fifteenth International Joint Conference on Artificial Intelligence (IJCAI 89), volume 2, pp. 1318-1323, (1989); and Johan deKleer and Brian C. Williams, ‘Diagnosis with Behavioral Models’, in Proceedings of the Eleventh International Joint Conference on Artificial Intelligence (IJCAI 89), pp. 1324-1330, Detroit, Mich., (1989). Each of these references is hereby incorporated by reference as if set forth in its entirety.

A fault behavior model is an extension of the above definition: There is an additional set of state variables, F_D, along with respective domains D, and a state prescription function Δ′. F_D defines fault states of the components, such as those discussed previously or illustrated in FIG. 2. Thus, the domain of Δ′ is D×X×U^T×T.

Let σ(M,u(t)) and σ(M_i′, u(t)) designate simulation results of the faultless model M and some fault model M′_i for a given vector of input functions u(t). By applying a model- and quantity-specific “difference” operator, ⊖, between the simulated O.K.-values and the related fault values a database C_Δ with symptom vectors can be compiled:

σ(M,u(t))⊖σ(M_i′,u(t))=C_Δ, i=1, . . . , k  (1)

In a second step, based on filtering, machine learning, and data mining methods, a classifier can be constructed that maps from symptoms onto faults:

C_Δ→F_D  (2)

An alternative to the previous steps is the direct application of a learning approach to the simulation results:

C→F_Dwith  (3)

C=(σ(M,u(t))∪σ(M_i′,u(t)), i=1, . . . , k

Note that this alternative burdens the learning approach with the task of both discovering and implicitly computing the ⊖-operation, and hence it is less powerful. On the other hand, it enables one to directly apply the learned diagnosis associations at runtime without the need of simulating M and applying the ⊖-operator.

Case Study

To obtain first experimental results, a case study has been made by the inventors:

In this case study, faulty sensor readings within an engine ECU are diagnosed.

To simulate the behavior of the engine and its ECU, advanced models are needed that are able to represent the correct physical behavior of an engine. Furthermore, since the engine and its ECU 2 do not operate autonomous in a car 1 but interact with other components and ECUs 2, additional models such as drivetrain models are needed. Here, the “Gasoline Engine Simulation Package” of dSPACE's Automotive Simulation Models (ASM) has been used, which is implemented in Matlab/Simulink. The model is a complete model of a six-cylinder 2.9 L gasoline engine and comprises also models for the engine 3, ECU 2, drivetrain 4, vehicle dynamics 5, and environment 6. In the vehicle dynamics model there are external forces on the vehicle taken into account, such as air resistance and braking. In the environment model road conditions and the drivers interactions are considered.

An overview of the model components: ECU 2, the engine 3, the drivetrain 4, the vehicle dynamics 5, and the environment 6 can be seen in FIG. 4.

The model compilation approach is described using the example of a faulty accelerator pedal position reading. In the engine model exists an accelerator pedal sensor that relays the signal to the ECU. In the ECU the data is used to set actuators such as the throttle position in the motor. This signal flow can be seen in FIG. 5. The starting point of the signal flow is the user input for the accelerator pedal.

Model Description

To simplify matters, the models for drivetrain 4, vehicle dynamics 5, and environment 6 are not shown since are not necessary for describing the different faults. The present description focuses on the engine model, denoted as M₁, and the model for the engine ECU, denoted as M₂. A third model M₃ comprises the sensor and actuator software and hardware. In this model faults may be generated.

FIG. 6 illustrates the interplay of three models: M₁ (motor), M₂ (motor control), and M₃ (connecting subsystems between user input, motor, and motor control). In the faultless behavior situation M₃ functions as a short-circuit, directly connecting both the user input with M₂ and M₁ with M₂; in a fault situation the model M₃ acts as a fault model and inserts particular signal disturbances.

As long as no faults exist, M₃ does nothing but relaying signals between M₂ and M₁. But if faults should be simulated, M₃ is used to manipulate (i) the sensor data so that the motor control receives disturbed values or (ii) the actuator data so that the motor receives disturbed values. Using this, we can simulate both the faultless behavior and the fault behavior. That is why in this case a fault behavior model M′ is not used. Additionally, further implementations failures could also be generated in the other parts of M₃, e.g., in the drivers or in the API.

In the following definition 1 is used to describe the example formally:

$F_{Y_{M_1}}$

• • comprises values such as mean effective engine torque.

$F_{U_{M_1}}$

• • consists of variables such as crank angle per cylinder and throttle angle. Note that

$F_{U_{M_1}}=F_{Y_{M_2}}.$

• • Examples for input variables of

$F_{U_{M_2}}$

• • are accelerator pedal position, ignition signal, and engine speed.

$F_{U_{M_3}}\mathrm{and}F_{Y_{M_3}}$

• • do not comprise any variable that are not used in M₁ and M₂. Thus,

$F_{U_{M_3}}=F_{U_{M_2}}\bigcup F_{U_{M_1}}=F_{Y_{M_3}}.$

• • This is because M₃ is only used to manipulate input and output variables of the engine control.

$F_{X_{M_2}}$

• • might comprise, for example, the throttle position.

$F_{X_{M_1}}$

• • consists of such variables as the manifold temperature, the air flow through the throttle, and several others.
  • In M₃ the state variables

$F_{X_{M_3}}$

• • are constants which control the fault types.

Δ_M1 and Δ_M2 are one or more differential equations describing the real behavior of the corresponding components to compute the constraint variables and the output variables. If no faults are simulated, M₃ comprises no differential equations, so Δ_M3 is, in that case, an identity function and just passes the input values. In the case of a fault, Δ_M3 manipulates one or more input values by multiplying a given value with the input value or by adding an offset to the input value. For example, a random value might be added to the accelerator pedal signal to simulate white noise.

In this case Λ only maps the values from Z to Y. So Λ_M1, Λ_M2, and Λ_M3 are the identity function.

Considered Fault Types

For this first case study, some basic faults occurring in sensors and actuators were implemented. This is a realistic fault type in modern cars. In this case study, four different fault types were modeled:

1. The signal is reduced to 90% of its correct value.

2. The signal value used for the simulation is 110% of the correct value.

3. Noise is added to the signal.

4. The signal is dropped out.

Simulation of the Overall Model

The overall model comprises the models described above and the models for the drivetrain 4, the vehicle dynamics 5, and the environment 6. The main input variables of this model are driver actions as observed by the respective sensors. Here, the driver is a subsystem of the environment model. So the set of input variables comprises among other things the positions of the brake pedal, the clutch pedal, the accelerator pedal, and the engaged gear.

For simulation purposes j different vectors of input function u₁(t), . . . , u_j(t)εU^T were defined. These vectors are called scenarios and represent specific driving behavior for a defined time period. Thus, the model may be executed in different driving situations.

Since it is rather unrealistic that all faults exist during the whole scenarios, faults are inserted into the model at several random points in time. Each simulation run is characterized by the scenario, by the fault type (including the no-fault scenario), by the faulty component—e.g., the actuator for the throttle—and by the point in time the failure occurs.

Then several scenarios were simulated using the different fault types of the accelerator pedal position sensor. For every simulation run the values of all relevant signals, i.e., signals that may have been influenced by the faulty accelerator pedal sensor, were logged and written to a simulation database, C. As an alternative, all accessible data could be logged. Additionally, the information about the fault type is stored at the database C. For simulations of faults, the fault type and the time when the fault occurred were also stored in the database C.

In FIGS. 7 and 8, an extract of the simulation results of a faultless and of a faulty behavior, respectively, are shown. FIG. 7 illustrates the results of the simulation of a faultless behavior model. u₁(t), y₁(t), and y₂(t) designate the accelerator pedal position, the throttle position, and the number of revolutions, respectively. FIG. 8 illustrates the results of the simulation of a fault behavior model that corresponds to the faultless behavior model in FIG. 7. The introduced and simulated fault puts noise on the pedal position signal. The comparison of both figures reveals that the fault of the accelerator pedal sensor influences other values such as the throttle position value and the number of revolutions.

Learning the Diagnosis Function

After simulating the system in different scenarios with different faults (again, including the no-fault case), a machine learning approach has been applied to the simulation results as presented in Equation 3. Generally, the algorithm shall use the data of the no-fault simulation and the data of one fault simulation run (e.g., the noisy signal) to detect patterns in the data. Based on this detection, the algorithm develops a classification function which decides whether the accelerator pedal sensor was noisy or not. Ideally, this classifier can also be applied to new measured data of a real vehicle, which means that the classifier has to generalize the data. Thus, it is a goal of the present invention to find a machine learning approach that will learn the classification function as best as possible.

In the field of machine learning, several algorithms exist. Two different learning algorithms are applied here:

• • Linear Regression. This common method uses a least square estimation to get parameters a₁, . . . , a_nεR for the diagnosis function template

$d_i=a_1·v_1+\dots +a_n·v_n\mathrm{with}$ $d_i=\begin{array}{cc}0& \mathrm{if}\mathrm{failure}i\mathrm{occurs}\\ 1& \mathrm{else}\end{array}$

• • v₁, . . . , v_n are the variables measured during the simulation. For details, please refer to T. Wonnacot and R. Wonnacot, Regression: A second course in statistics, John Wiley & Sons, New York, Chichester/Brisbane/Toronto, 1981; R. H. Myers. Classical and Modern Regression with Applications. Duxbury Press, Boston, 1986; S. Weisberg. Applied Linear Regression. John Wiley & Sons, New York, 1985; K. Backhaus, B. Erichson, W. Plinke, and R. Weber. Multivariate Analysemethoden. Springer, 1996; and Hartung, J: Statistic. Oldenbourg, 1999, each of which is hereby incorporated by reference as if set forth in its entirety.
  • Decision Trees. A decision tree uses a series of binary decisions to reach a classification. Learning such a tree is done by binary recursive partitioning of the input space using a given optimization criterion. Details about decision trees can be found in L., Breiman, J. H. Friedman, R. A. Olshen, and C. J. Stone, Classification and Regression Trees, Wadsworth, 1984; and Ripley, B. D.: Pattern Recognition and Neural Networks. Cambridge University Press, 1996, each of which is hereby incorporated by reference as if set forth in its entirety.

For the case study of the present invention, the R programming environment has been used.

The problem with the above procedure is that a diagnosis function learned for a special fault type may not know how to deal with data measured in a situation where another fault type has occurred. To differentiate between the different fault types, in a second step, the data for learning a diagnosis function of a specific fault type was extended by the data of the other three corresponding fault types. This new data was classified as non-failure scenarios. The disadvantage of this procedure is that the number of failure cases is no longer equivalent to the number of non-failure cases, thus making an assessment of the learning result rather difficult.

FIG. 9 illustrates an exemplary flowchart according to the present invention. A generator X1 provides test vectors X3 for different test scenarios to a simulation X5. The text vectors X3 are provided with faults. In addition to test vectors X3, behavior models X4, which are executable, are provided to the simulation X5. The behavior models X4 include fault behavior models provided by a model of controller and plant X2. The simulation results X6, which include faults and symptoms, are stored during a simulation X5 run.

By applying methods of machine learning X7 to the simulation results X6, a classifier function X8 is learned. The classifier function X8 may be a decision tree, neural network, Bayesian network, etc. The classifier function X8 offers a classification X9 and in the course of this a mapping of the symptom of a fault onto the fault.

State vectors X10 may be provided in order to differentiate between faults in different states of the mechatronic system. Ideally, the state vectors X10 are in the same format as the test vectors X3. The resulting diagnosis X11 reflects the detected fault as well as the state of the mechatronic system during occurrence of the fault.

Experimental Results

Though only simple standard algorithms for learning the diagnosis function were used and furthermore no preprocessing steps were implemented, the results show that quite good solutions could be achieved. Tables 1 and 2 show the error rates of the learned diagnosis functions for the four fault types “−10% offset”, “+10% offset”, “noisy signal”, and “dropped out signal”. The results are presented for both applied learning algorithms. Five runs were done for each of the failure types respectively. The average of the five runs is presented in the tables.

The error rate is the percentage of cases diagnosed incorrectly by the algorithm. In the first line, the error rates are shown that were achieved by runs with the same data that was used to learn the diagnosis function. The error rates in the second line were achieved with input data the algorithm did not learn to use the diagnosis function.

TABLE 1
Error rates of the linear regression for the four fault types.
				dropped out
	−10% offset	+10% offset	noisy signal	signal
	15.04%	16.13%	3.84%	0.04%
	14.85%	16.53%	3.55%	0.11%

TABLE 2
Error rates of the decision tree for the four fault types.
				dropped out
	−10% offset	+10% offset	noisy signal	signal
	0.88%	0.32%	0.33%	0.10%
	1.13%	0.46%	0.31%	0.17%

The results show that the decision tree algorithm performs much better than the linear regression. Only when the signal is dropped out, the linear regression is able to perform a little better than the decision tree. Furthermore, in each table, there is nearly no difference between the results in the first line and the results in the second line.

If the diagnosis functions is also used to differentiate between different failures types, the result were not as good as before. But nevertheless the results still show that it is possible to achieve satisfying results.

The present invention introduces the model compilation paradigm for the diagnosis of complex technical systems. Model compilation is fairly involved and combines modern simulation technology with methods from data mining and learning theory. The models M of interesting systems are simulated with respect to expected inputs along with possible faults, and a compiled diagnosis model is distilled from the huge set of generated data. At heart, the compiled model is a classifier, which is not only able to detect the simulated faults, but which will also generalize with respect to unseen situations.

Model compilation becomes particularly attractive due to the fact that the original simulation models M from the application domain can be utilized. In fact, within the presented case study from the automotive domain, M comprises a vehicle's plant and controller models; it is hybrid and contains more than 100 states. The outlined diagnosis situations address realistic signal faults that occur between the environment and the vehicle electronics. Two learning approaches, linear regression and decision trees were applied, leading to an acceptable (85%) and an excellent (99%) fault detection rate.

In addition, the present invention can be applied to more complex and different fault scenarios, which also consider software faults within ECUs. The application of stronger data filtering techniques during the data mining step, such as vector quantization and cluster analysis can also assist in creating a more accurate model. Further, more refined methods to differentiate between a large number of faults are desirable. Note that the choice and the adaptation of the machine learning algorithms are a key for the success of the model compilation paradigm, and, association rules or Bayesian networks have the potential to outperform decision trees on large data sets.

While the invention has been particularly shown and described with reference to preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention.

Claims

1. A method for constructing a diagnosis function for mapping a symptom of a fault in an electromechanical system onto the fault, the method comprising the steps of: simulating the electromechanical system in at least a fault-mode and a non-fault-mode; andlearning a classifier function from collected simulation results for mapping the symptom of the fault onto the fault.

2. The method according to claim 1, wherein the simulating step comprises simulating the electromechanical system for given vectors of input functions, and further comprising the step of determining symptom vectors by compiling the results of fault- and non-fault-simulations and comparing related results.

3. The method according to claim 1, wherein the learning step includes at least one of filtering, machine learning, data mining, and pattern recognition.

4. The method according to claim 1, further comprising the step of: prior to the learning step, generalizing the symptom.

5. The method according to claim 1, wherein the electromechanical system is a mechatronic system, and the method further comprises the steps of: detecting the symptom of the fault in the mechatronic system; andmapping the detected symptom onto the fault using the learned classifier function.

6. The method according to claim 5, wherein the detecting step comprises detecting the system by comparing an expected behavior with an observed behavior of the mechatronic system.

7. An apparatus for detecting a fault in a mechatronic system, the apparatus comprising at least one electronic control unit operable to run a learned classifier function, to detect a symptom of a fault, and to map the system onto the fault using the classifier function.

8. The apparatus according to claim 7, further comprising: at least one sensor operable to provide a sensor reading,wherein the electronic control unit is operable to detect the symptom by comparing an expected behavior with an observed behavior of the system using the sensor reading.

9. The method according to claim 1 wherein the fault causes the symptom.

10. The method according to claim 1, wherein the learning step is performed using linear regression.

11. The method according to claim 1, wherein the learning step is performed using decision trees.

12. The method according to claim 1, wherein the electromechanical system includes a vehicle.

13. The method according to claim 2, further comprising the step of: generalizing the compiled symptom vectors prior to the learning step.

14. The method according to claim 13, wherein the generalizing step comprises abstracting the compiled symptom vectors into intervals.

15. The method according to claim 6, wherein the detecting step comprises using a sensor reading.

16. The apparatus according to claim 7, wherein the mechatronic system includes a vehicle.

17. A method for constructing a diagnosis function for mapping a symptom of a fault in an electromechanical system onto the fault causing the symptom, the method comprising the steps of: simulating the electromechanical system in a fault-mode;generating a first set of simulation results;storing the first set of simulation results in a database;simulating the electromechanical system in a non-fault mode;generating a second set of simulation results;storing the second set of simulation results in the database;comparing the first and second sets of simulation results to detect patterns in the results;developing a classification function which determines a cause of the fault;applying the classification function to map the determined fault onto the fault causing the symptom.

18. The method according to claim 17, further comprising the steps of: simulating the electromechanical system for a set of vectors of an input function; anddetermining a set of symptom vectors by compiling the results of the fault-mode and non-fault mode simulations and comparing related results.

19. The method according to claim 17, further comprising the step of: developing the classification function by learning, using at least one of filtering, machine learning, data mining, and pattern recognition.

20. The method according to claim 17, wherein the electromechanical system includes a vehicle.

21. The method according to claim 17, further comprising the step of: detecting symptoms by comparing an expected behavior with an observed behavior of the electromechanical system.