CN111767032A

CN111767032A - Method and device for processing expert rules of industrial equipment faults

Info

Publication number: CN111767032A
Application number: CN202010907678.3A
Authority: CN
Inventors: 徐地; 田春华; 李闯; 刘家杨; 杨宁
Original assignee: Beijing Innovation Center For Industrial Big Data Co ltd
Current assignee: Beijing Innovation Center For Industrial Big Data Co ltd
Priority date: 2020-09-02
Filing date: 2020-09-02
Publication date: 2020-10-13
Anticipated expiration: 2040-09-02
Also published as: CN111767032B

Abstract

The embodiment of the invention provides a method and a device for processing expert rules of industrial equipment faults, wherein the method comprises the following steps: determining an expert rule description document describing the fault of the industrial equipment; performing model conversion according to the expert rule description document to determine a conversion model of an expert rule; and obtaining a model packet of an expert rule according to the conversion model. The technical scheme of the invention can realize formalization and programming of expert rule description of industrial equipment faults and improve the conversion efficiency of the expert rule.

Description

Method and device for processing expert rules of industrial equipment faults

Technical Field

The invention relates to the technical field of industrial equipment information processing, in particular to a method and a device for processing an expert rule of industrial equipment faults.

Background

In the data processing of an industrial plant, expert experience or expert rules are illustrated as follows:

the following symptoms occur simultaneously when the rotor thermally bends: the vibration pass frequency value is large, the pass frequency difference value is large at the same rotating speed when starting and stopping, and the work frequency difference value is large at the same rotating speed when starting and stopping;

the following signs occur simultaneously when mechanical or electrical deviations of the journal occur: the vibration pass frequency value is large, the pass frequency value is large at low rotating speed, the power frequency value is large at low rotating speed, the pass frequency value is smaller at high and low speeds, and the power frequency value is smaller at high and low speeds;

the following signs are simultaneously shown when the dynamic balance is poor: when the rotating speed is stable, the power frequency phase is stable, the pass frequency value is greater than 35% to 55% of the alarm value, the power frequency value is greater than 75% to 85% of the pass frequency value, the power frequency value increases along with the rise of the rotating band, the power frequency value decreases along with the fall of the rotating speed, and the pass frequency value suddenly increases.

The industrial equipment owners accumulate a great deal of fault diagnosis experience through long-term operation and maintenance, but most of the fault diagnosis experience can be described qualitatively, but the experience is converted into a quantitative and executable model, a great deal of work is needed, and a front-line expert is difficult to complete.

The conversion of expert experiences requires the natural and deep collaboration of the expert, the data analyst and the code engineer, but the difference in the background skills of three parties causes inefficient communication and understanding, resulting in inefficient conversion.

Disclosure of Invention

The technical problem to be solved by the invention is to provide a processing and device for the expert rules of the industrial equipment faults, so that formalization and programming of description of the expert rules of the industrial equipment faults are realized, the transfer of human experience is not relied on, and the conversion efficiency of the expert rules is improved.

In order to solve the technical problems, the technical scheme of the invention is as follows:

a method for processing expert rules of industrial equipment faults comprises the following steps:

determining an expert rule description document describing the fault of the industrial equipment;

performing model conversion according to the expert rule description document to determine a conversion model of an expert rule;

and obtaining a model packet of an expert rule according to the conversion model.

Optionally, determining an expert rule description document describing the fault of the industrial equipment includes:

and determining an expert rule description document for describing the industrial equipment fault according to the industrial equipment fault description grammar definition specification.

Optionally, the syntax specification for describing the fault of the industrial equipment includes: the method comprises the steps of obtaining a fault name, a scene name, at least one symptom appearing in a scene and at least one variable corresponding to each symptom.

Optionally, performing model conversion according to the expert rule description document to determine a conversion model of the expert rule, including:

performing syntactic analysis on at least one symptom appearing in each fault name, scene and at least one variable corresponding to each symptom in the expert rule description document to determine a syntactic tree;

and determining a conversion model according to the corresponding relation of the variables and the symptoms and the corresponding relation of the symptoms and the scenes according to the syntax tree.

Optionally, obtaining a model package of an expert rule according to the conversion model includes:

generating a code skeleton of faults, scenes, signs and variables according to the conversion model and a preset programming language;

according to the code framework, development is realized, and a code file is generated;

and obtaining a model package of the expert rule according to the code file and the model description information.

Optionally, after generating the code skeleton of the fault, the scene, the symptom, and the variable, the method further includes:

and storing code skeletons of the same scene, symptom and/or variable under different faults in a database.

Optionally, the method for processing the expert rule of the industrial equipment fault further includes:

and when a code file is generated, searching the database, and if a code skeleton of a scene, a symptom and/or a variable corresponding to the target fault exists, directly calling the code skeleton of the scene, the symptom and/or the variable corresponding to the target fault in the database.

Optionally, the method for processing the expert rule of the industrial equipment fault further includes: and optimizing the code skeleton in the database according to the calling times.

The embodiment of the invention also provides a processing device for the expert rules of the industrial equipment faults, which comprises:

the first determination module is used for determining an expert rule description document for describing the fault of the industrial equipment;

the second determination module is used for performing model conversion according to the expert rule description document and determining a conversion model of the expert rule;

and the obtaining module is used for obtaining the model packet of the expert rule according to the conversion model.

Embodiments of the present invention also provide a computer-readable storage medium comprising instructions which, when executed on a computer, cause the computer to perform the method as described above.

The scheme of the invention at least comprises the following beneficial effects:

according to the scheme of the invention, the method for processing the expert rule of the industrial equipment fault comprises the following steps: determining an expert rule description document describing the fault of the industrial equipment; performing model conversion according to the expert rule description document to determine a conversion model of an expert rule; and obtaining a model packet of an expert rule according to the conversion model. Therefore, the programming of the description of the expert rules of the industrial equipment faults is realized, the transfer of human experience is not relied on, and the conversion efficiency of the expert rules is improved.

Drawings

FIG. 1 is a flow chart illustrating a method for processing expert rules for industrial equipment failure according to an embodiment of the present invention;

FIG. 2 is a block diagram of a process flow of expert rules for industrial equipment failure in accordance with an embodiment of the present invention;

FIG. 3 is a diagram illustrating a syntax tree structure of an expert rules description document in an embodiment of the present invention;

FIG. 4 is a schematic diagram of a transformation model for a fault with poor dynamic balance in an embodiment of the present invention;

FIG. 5 is a diagram of a model package of expert rules in an embodiment of the present invention;

FIG. 6 is a diagram of a definition library of code skeletons for scenarios, symptoms and/or variables in an embodiment of the invention;

fig. 7 is a block diagram of a processing device for expert rules of industrial equipment failure in an embodiment of the present invention.

Detailed Description

Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

As shown in fig. 1, an embodiment of the present invention provides a method for processing expert rules of industrial equipment failure, including:

step 11, determining an expert rule description document for describing the fault of the industrial equipment;

step 12, performing model conversion according to the expert rule description document, and determining a conversion model of the expert rule;

and step 13, obtaining a model package of an expert rule according to the conversion model.

The embodiment of the invention can realize the programming of the description of the expert rule of the industrial equipment fault, does not depend on the transmission of human experience, and improves the conversion efficiency of the expert rule.

As shown in fig. 2, in the fault definition phase, the expert rules of the faults of the industrial equipment are described according to the fault description syntax definition to form an expert rule description document;

specifically, step 12 may include: and determining an expert rule description document for describing the industrial equipment fault according to the industrial equipment fault description grammar definition specification.

Optionally, the syntax specification for describing the fault of the industrial equipment includes: the method comprises the following steps of (1) obtaining a fault name, a scene name, signs appearing in a scene and at least one variable corresponding to each sign;

if the above grammar specification is implemented in a Python-like language or a Yaml data format, the fault name, the scene name, and the description of the symptom appearing in the scene are respectively located in different lines, and the next line is indented into a space of a preset number of characters relative to the beginning of the previous line.

The specific syntax is described as follows:

E->faults

faults->faults fault | fault

fault->and (4) failure:label scenarios

scenarios->scenarios scenario | scenario

scenario->indentscene:label symptoms

symptoms->symptoms symptom | symptom

symptom->indent indentwhen in usesymptom_body|indent indentAnd issymptom_body

symptom_body->{ w | w is a short sentence containing 0 or more variable }

indent->\t

label->Non-air English identifier

variable->“label”

For example: an example of an expert rule that can be implemented is:

and (4) failure: poor dynamic balance

(indent 1) scenario: possible scenarios 1

(setback 1) + (setback 2) "Power frequency phase" is stable when "rotational speed" is stable

And the ' pass frequency value ' is more than 35 to 55 percent of the ' alarm value

And the power frequency value is more than 75 to 80 percent of the pass frequency value

And the power frequency value increases along with the increase of the rotating speed

And the power frequency value becomes smaller along with the reduction of the rotating speed

And the 'pass frequency value' suddenly increases

(indent 1) scenario: possible scenario 2

(setback 1) + (setback 2) when … …

And (4) failure: cooling pump breaking pump

(indent 1) scenario: possible scenarios 1

(setback 1) + (setback 2) when "load tonnage" is normal

And the 'motor rotating speed' is normal

And "pump outlet pressure measurement point is normal"

And the pump outlet pressure is suddenly and greatly reduced

And "oil flow Point" is Normal

And the 'oil flow' is suddenly reduced by a large margin

In this example, the faults include: poor dynamic balance or pump failure of the cooling pump; in the failure of poor dynamic balance, a possible scenario 1 and a possible scenario 2 are included; in scenario 1, symptoms are included: when the 'rotating speed' is stable, the 'power frequency phase' is stable, the 'pass frequency value' is greater than 35% to 55% of the 'alarm value', the 'power frequency value' is greater than 75% to 80% of the 'pass frequency value', the 'power frequency value' is increased along with the increase of the 'rotating speed', the 'power frequency value' is decreased along with the decrease of the 'rotating speed', the 'pass frequency value' is suddenly increased and the like; the variables included in the symptom are: rotation speed, power frequency phase, pass frequency value, alarm value and power frequency value;

likewise, in the failure of the cooling pump to shut down, a possible scenario 1 is included, and in scenario 1, the symptoms are included: the 'loading tonnage' is normal, the 'motor rotating speed' is normal, the 'pump outlet pressure measuring point is normal', the 'pump outlet pressure' is suddenly and greatly reduced, the 'oil flow measuring point' is normal, and the 'oil flow' is suddenly and greatly reduced; the variables included in the symptom are: load tonnage, motor speed, oil flow point, oil flow.

In the above description of faults, one "fault" may have multiple "scenarios" (paths) occurring; an occurrence "scene" contains a plurality of "symptoms" appearing simultaneously (the symptoms are guided by the keywords "when" or "and"); the symptom contains two pieces of information: variables and calculation methods; variables are marked by double quotes.

Thus, the domain expert does not need to have a priori which variables are available in the system, and in the subsequent model conversion stage, the engineer will associate the variable names identified in the grammar analysis with the data available to the system.

One symptom is described as a calculation method. Similar to the variables, the domain expert does not need to know which symptom calculation methods (operators) exist in the system in advance, and in the subsequent model conversion stage, the calculation methods are realized on the identified framework; study and judgment =f(symptom) is an implicit operator, and does not need explicit description; indentation makes sense like Python language or Yaml data format.

In an alternative embodiment of the present invention, step 12 may include:

step 121, performing syntax analysis on the expert rule description document, each fault name, each scene, at least one symptom appearing in the scene and at least one variable corresponding to each symptom, and determining a syntax tree;

and step 122, determining a conversion model according to the corresponding relation of the variables and the symptoms and the corresponding relation of the symptoms and the scenes according to the syntax tree.

As shown in fig. 2 and fig. 3, in the compiling stage, a syntax tree can be formed through the above-mentioned preprocessing and syntax analysis of the expert rule description document;

in an example that can be realized, for scenario 1 of a failure with poor dynamic balance, the syntax tree is as shown in fig. 3, the failure "with poor dynamic balance" is used as a parent node, the child nodes thereof are possible scenario 1 nodes, and the child nodes of the possible scenario 1 nodes include: symptom 1 node: { v1} is stable { v2} is stable; symptom 2 node: { v3} is greater than 35% to 55% of { v4 }; symptom 3 nodes: { v5} is greater than 75% to 80% of { v6}, symptom 4 nodes, and so on;

wherein, the variable v1 is the rotating speed, v2 is the power frequency phase, v3 is the pass frequency value, v4 is the alarm value, v5 is the power frequency value, v6 is the pass frequency value.

And determining a conversion model according to the corresponding relation of the variables and the symptoms in the syntax tree and the corresponding relation of the symptoms and the scenes. The conversion model is the corresponding relation of variables, symptoms and the corresponding relation of the symptoms and scenes in one fault description. The transformation model for a fault such as a poor dynamic balance is shown in fig. 4.

In an alternative embodiment of the present invention, step 13 may include:

step 131, generating a code skeleton of faults, scenes, symptoms and variables according to the conversion model and a preset programming language;

step 132, developing and realizing according to the code framework to generate a code file;

step 133, obtaining a model package of the expert rules according to the code file and the model description information.

The generation of the code skeleton in this embodiment is interface definition, and further, the development implementation requires a developer to implement specific logic, that is, to generate a code file, according to the code skeleton. After the specific logic is implemented, whether the compiling is performed or not is determined according to a specific implementation language, for example, when the compiling is implemented by using the python language, the compiling is not required, and the source file is directly packaged in the model package. In this embodiment, a set of code skeletons is automatically generated through parsing the obtained elements, and taking Python language as an example, the above example generates the following code skeletons:

category-variable acquisition (5)

Code framework 1:

@ Variable ("speed")

defget _ variable _ speed (filter):

return NotImplementError()

code framework 2:

@ Variable ("Power frequency phase")

defget _ variable _ power frequency phase (filter):

return NotImplementError()

code framework 3:

@ Variable ("pass-frequency value")

defget _ variable _ passband value (filter):

return NotImplementError()

code framework 4:

@ Variable ("alarm value")

defget _ variable _ alarm value (filter):

return NotImplementError()

code framework 5:

@ Variable ("Power frequency")

defget _ variable _ power frequency value (filter):

return NotImplementError()

the category: symptom logic (6 pieces)

Code framework 6:

@ Symptom ("{ v1} is stable, { v2} is stable")

def x _ when stable _ y _ stable (v1, v2):

return NotImplementError()

and a code framework 7:

@ Symptom ("{ v1} is greater than 35% to 55% of { v2 })

35pct to 55pct (x, y) with def x _ greater than _ y:

return NotImplementError()

the code framework 8:

@ Symptom ("{ v1} is greater than 75% to 85% of { v2 })

75pct to 85pct (x, y) with def x _ greater than _ y:

return NotImplementError()

code skeleton 9:

@ Symptom ("{ v1} becomes larger as { v2} rises")

def x _ becomes larger as _ y _ goes up (x, y):

return NotImplementError()

code framework 10:

@ Symptom ("{ v1} decreases as { v2} decreases")

def x _ decreases as _ y _ decreases (x, y):

return NotImplementError()

code skeleton 11:

@ Symptom ("{ v1} suddenly increased")

def x _ sudden increase (x):

return NotImplementError()

the category: judging logic (1 piece)

Code skeleton 12:

@ Diagnostic ("{ poor dynamic balance } { possible scenario 1 }")

def dynamic imbalance _ possible scenario 1(s1, s2, s3, s4, s5, s6):

return NotImplementError()。

as shown in fig. 5, the model package of the expert rules is a schematic diagram, and the model package includes implementation code files of the variables, the symptoms, and the study (i.e. the scenes), which are implemented by a code skeleton according to the certain language, and at the same time, the model package also includes model metadata names, versions, computation topologies, and computation parameters (such as time windows); finally, the code files in the model package can be output to the corresponding machine execution framework through the corresponding adapter to be operated. The machine execution framework can be Flink, Spark, Hadoop MR and the like, and finally the programmed transmission of expert experience (namely expert rules) is realized, the transmission is not dependent on manual work, and the conversion efficiency of the expert rules is improved.

In an optional embodiment of the present invention, in the step 131, after generating the code skeleton of the fault, the scene, the symptom, and the variable, the step may further include:

step 1311, storing the code skeletons of the same scene, symptom and/or variable in a database under different faults.

As shown in fig. 6, the code skeletons corresponding to the same scene under different faults may be stored in a study definition library; or storing the code frameworks corresponding to the same sign in a sign definition library under different faults; or storing the code frameworks corresponding to the same variables in a variable definition library under different faults; of course, the code skeletons of the above scenarios, symptoms and/or variables may also be stored in the same database.

The code frameworks of the scenes, the symptoms and/or the variables are stored in the database, so that the full hero frameworks are reused under different faults and are not repeatedly generated, and the generation efficiency of the code frameworks can be improved.

In an optional embodiment of the present invention, the method for processing the expert rule of the industrial equipment fault may further include:

step 134, when the code file is generated, searching the database, and if a code skeleton of a scene, a symptom and/or a variable corresponding to the target fault exists, directly calling the code skeleton of the scene, the symptom and/or the variable corresponding to the target fault in the database.

As shown in fig. 6, when a code skeleton is called from the database, for example:

and (4) failure: cooling pump breaking pump

Scene: possible scenarios 1

When the 'loading tonnage' is normal

And the 'motor rotating speed' is normal

And the pump outlet pressure measuring point is normal

And the pump outlet pressure is suddenly and greatly reduced

And "oil flow Point" is Normal

And the 'oil flow' is suddenly reduced by a large margin

Calling a code skeleton corresponding to a certain sign, and directly calling the code skeleton according to a sign calculation method, for example, a normal load tonnage and a normal motor speed, wherein the two signs are matched with @ Symptom ("{ v1} normal), if the two signs are matched with each other, the code skeleton is called directly: @ Symptom ("{ v1} normal"), and implementing code according to the code skeleton. Thereby improving the efficiency of code implementation.

and 135, optimizing the code skeleton in the database according to the calling times.

In an achievable optimization mode, for example, according to the number of calls, a code skeleton of which the number of calls is greater than a first preset value in a first preset time period is marked by a preset mark, and during calling, the code skeleton with the preset mark is preferentially inquired and matched, so that the inquiry efficiency can be greatly improved; furthermore, the code skeleton with the calling times smaller than the second preset value in the second preset time period can be deleted, so that the size of the database is favorably reduced, the query efficiency can be improved during global query, and the second preset time period can be a longer time period, such as one month or several months.

In the above embodiments of the present invention, the fault descriptions and the like are only examples, and the fault descriptions in the industrial data are not limited to those listed in the above examples, and may also include other expert rules, which are not described one by one. The above embodiments of the present invention provide a structured fault description method close to natural language for domain experts to describe fault diagnosis experience; extracting fault elements using syntactic analysis: faults, scenes, symptoms, variables and research and judgment; generating a realization code skeleton by using semantic analysis for engineering realization of data and code engineers; the variable, the symptom and the research and judgment definition library are accumulated and realized, the realization multiplexing degree is increased, and the expert experience conversion speed is accelerated; and encapsulating the model by using the model package, wherein the model package comprises general DAG (connected graph) computing topology information to realize the universality of model deployment.

As shown in fig. 7, the embodiment of the present invention further provides an expert rule processing apparatus 70 for an industrial equipment fault, including:

Optionally, the first determining module is specifically configured to: and determining an expert rule description document for describing the industrial equipment fault according to the industrial equipment fault description grammar definition specification.

Optionally, the second determining module is specifically configured to: performing syntactic analysis on at least one symptom appearing in each fault name, scene and at least one variable corresponding to each symptom in the expert rule description document to determine a syntactic tree; and determining a conversion model according to the corresponding relation of the variables and the symptoms and the corresponding relation of the symptoms and the scenes according to the syntax tree.

Optionally, the obtaining module is specifically configured to: generating a code skeleton of faults, scenes, signs and variables according to the conversion model and a preset programming language; according to the code framework, development is realized, and a code file is generated; and obtaining a model package of the expert rule according to the code file and the model description information.

Optionally, the apparatus further comprises: and the storage module is used for storing the code frameworks of the same scene, symptom and/or variable under different faults in a database.

Optionally, the apparatus further comprises: and the multiplexing module is used for searching the database when generating the code file, and directly calling the code skeleton of the scene, the symptom and/or the variable corresponding to the target fault in the database if the code skeleton of the scene, the symptom and/or the variable corresponding to the target fault exists.

Optionally, the apparatus further comprises: and the optimization module is used for optimizing the code skeleton in the database according to the calling times.

It should be noted that the apparatus is an apparatus corresponding to the above method, and all the implementations in the above method embodiment are applicable to the embodiment of the apparatus, and the same technical effects can be achieved.

Embodiments of the present invention also provide a computer-readable storage medium comprising instructions which, when executed on a computer, cause the computer to perform the method as described above. All the implementation manners in the method embodiment are applicable to the embodiment of the device, and the same technical effect can be achieved.

Those of ordinary skill in the art will appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.

It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

In the embodiments provided in the present invention, it should be understood that the disclosed apparatus and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit.

The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: various media capable of storing program codes, such as a U disk, a removable hard disk, a ROM, a RAM, a magnetic disk, or an optical disk.

Furthermore, it is to be noted that in the device and method of the invention, it is obvious that the individual components or steps can be decomposed and/or recombined. These decompositions and/or recombinations are to be regarded as equivalents of the present invention. Also, the steps of performing the series of processes described above may naturally be performed chronologically in the order described, but need not necessarily be performed chronologically, and some steps may be performed in parallel or independently of each other. It will be understood by those skilled in the art that all or any of the steps or elements of the method and apparatus of the present invention may be implemented in any computing device (including processors, storage media, etc.) or network of computing devices, in hardware, firmware, software, or any combination thereof, which can be implemented by those skilled in the art using their basic programming skills after reading the description of the present invention.

Thus, the objects of the invention may also be achieved by running a program or a set of programs on any computing device. The computing device may be a general purpose device as is well known. The object of the invention is thus also achieved solely by providing a program product comprising program code for implementing the method or device. That is, such a program product also constitutes the present invention, and a storage medium storing such a program product also constitutes the present invention. It is to be understood that the storage medium may be any known storage medium or any storage medium developed in the future. It is further noted that in the apparatus and method of the present invention, it is apparent that each component or step can be decomposed and/or recombined. These decompositions and/or recombinations are to be regarded as equivalents of the present invention. Also, the steps of executing the series of processes described above may naturally be executed chronologically in the order described, but need not necessarily be executed chronologically. Some steps may be performed in parallel or independently of each other.

While the foregoing is directed to the preferred embodiment of the present invention, it will be understood by those skilled in the art that various changes and modifications may be made without departing from the spirit and scope of the invention as defined in the appended claims.

Claims

1. A method for processing expert rules of industrial equipment faults is characterized by comprising the following steps:

2. The method for processing the expert rule of the industrial equipment fault according to claim 1, wherein determining the expert rule description document describing the industrial equipment fault comprises:

3. The method for processing expert rules for industrial equipment failure of claim 2 wherein the industrial equipment failure description grammar specification comprises: the method comprises the steps of obtaining a fault name, a scene name, at least one symptom appearing in a scene and at least one variable corresponding to each symptom.

4. The method for processing the expert rule of the industrial equipment fault according to claim 3, wherein performing model conversion according to the expert rule description document to determine a conversion model of the expert rule comprises:

5. The method for processing the expert rules of the industrial equipment fault according to claim 4, wherein obtaining the model package of the expert rules according to the conversion model comprises:

6. The method for processing the expert rules of the industrial equipment failure according to claim 5, wherein after generating the code skeleton of the failure, the scenario, the symptom and the variable, the method further comprises:

7. The method for processing expert rules for industrial equipment failure according to claim 6, further comprising:

8. The method for processing expert rules for industrial equipment failure according to claim 7, further comprising:

and optimizing the code skeleton in the database according to the calling times.

9. An apparatus for processing expert rules for industrial equipment failure, comprising:

10. A computer-readable storage medium comprising instructions which, when executed on a computer, cause the computer to perform the method of any of claims 1 to 8.