CN112148260A

CN112148260A - Decision engine implementation method, device, equipment and storage medium

Info

Publication number: CN112148260A
Application number: CN202011021805.6A
Authority: CN
Inventors: 张杰龙; 王宇光; 吕军; 邹明明
Original assignee: JD Digital Technology Holdings Co Ltd
Current assignee: JD Digital Technology Holdings Co Ltd
Priority date: 2020-09-25
Filing date: 2020-09-25
Publication date: 2020-12-29

Abstract

The embodiment of the invention provides a decision engine implementation method, a decision engine implementation device, a decision engine implementation equipment and a storage medium, wherein the method comprises the steps of providing a plurality of functional components and decision flow components for a user, responding to instantiation operation of the functional components by the user, and creating a first instance of the functional components; creating a second instance of the decision flow component in response to a user instantiation operation on the decision flow component; responding to the arrangement operation of a user on the first instance and the second instance, generating a strategy file and a corresponding decision service, and displaying an interface of the decision service; abstracting a plurality of functional components and decision flow components to realize different business decision logics; the complete service decision logic is realized through the arrangement of the decision flow; the method has the advantages that the modularization mode is adopted, the strong expandability of the system and the flexibility of logic implementation are guaranteed, a user can arrange the component examples to implement the service decision logic by instantiating the existing components, the operation is simple, and the generation efficiency of the decision logic is improved.

Description

Decision engine implementation method, device, equipment and storage medium

Technical Field

The embodiment of the invention relates to the technical field of computers, in particular to a decision engine implementation method, a decision engine implementation device, decision engine implementation equipment and a storage medium.

Background

Most of traditional decision engine systems are built based on rule engines (such as drools) and are mainly applied to policy implementation in the financial field and the like.

In the process of implementing the invention, the inventor finds that at least the following problems exist in the existing decision engine system: the use of rule engine drive has poor expandability; when the method is used, a large amount of codes need to be written, a strategy person without a programming base cannot use the codes, more, research and development personnel use the codes, and the use is complex, so that the generation efficiency of decision logic is low.

Disclosure of Invention

The embodiment of the invention provides a decision engine implementation method, a decision engine implementation device, decision engine implementation equipment and a storage medium, which are used for solving the problem that the existing decision engine system is low in decision logic generation efficiency due to the fact that the existing decision engine system is driven by a rule engine, poor in expandability and complex to use.

In one aspect, an embodiment of the present invention provides a method for implementing a decision engine, including:

responding to instantiation operation of a user on any functional component, and creating a first instance of the functional component, wherein the functional component is used for realizing corresponding business logic; creating a second instance of the decision flow component in response to an instantiation operation of any decision flow component by the user, the decision flow component for implementing corresponding decision logic; generating a policy file in response to the user's choreography operation on the first instance and the second instance; and generating a decision service corresponding to the strategy file, and displaying an interface of the decision service.

In another aspect, an embodiment of the present invention provides a decision engine implementation apparatus, including: the system comprises a policy designer, a first service logic module and a second service logic module, wherein the policy designer is used for responding to instantiation operation of a user on any functional component and creating a first instance of the functional component, and the functional component is used for realizing the corresponding service logic; creating a second instance of the decision flow component in response to an instantiation operation of any decision flow component by the user, the decision flow component for implementing corresponding decision logic; generating a policy file in response to the user's choreography operation on the first instance and the second instance;

and the strategy execution engine is used for generating the decision service corresponding to the strategy file and displaying an interface of the decision service.

In another aspect, an embodiment of the present invention provides a decision engine implementation device, including: a processor, a memory, and a computer program stored on the memory and executable on the processor; wherein the processor implements the method described above when running the computer program.

In another aspect, an embodiment of the present invention provides a computer-readable storage medium, in which a computer program is stored, and the computer program, when executed by a processor, implements the method described above.

According to the decision engine implementation method, the decision engine implementation device, the decision engine implementation equipment and the storage medium, a plurality of functional components and decision flow components are provided for a user, and a first instance of the functional component is created in response to instantiation operation of the user on any functional component; creating a second instance of any decision flow component in response to an instantiation operation of the decision flow component by the user; generating a policy file in response to the user's choreography operation on the first instance and the second instance; generating a decision service corresponding to the strategy file, and displaying an interface of the decision service; a plurality of functional components and decision flow components are abstracted to realize different business decision logics; the complete service decision logic is realized through the arrangement of the decision flow; by adopting a componentization mode, the strong expandability of the system and the flexibility of logic implementation are ensured, a user can realize service decision logic by instantiating and arranging existing components, the use is very simple, and the generation efficiency of the decision logic can be improved.

Drawings

FIG. 1 is a diagram illustrating the overall functional architecture of a decision engine system according to an embodiment of the present invention;

FIG. 2 is a flowchart of a decision engine implementation method according to an embodiment of the present invention;

FIG. 3 is a flowchart of a decision engine implementation method according to a second embodiment of the present invention;

FIG. 4 is a diagram illustrating relationships among persons, roles, and groups according to an embodiment of the present invention;

FIG. 5 is a diagram illustrating a rights management page for an item provided by an embodiment of the invention;

FIG. 6 is a diagram illustrating a rights management page for a component provided by an embodiment of the invention;

FIG. 7 is a diagram illustrating an interface for project management provided by an embodiment of the present invention;

FIG. 8 is a schematic diagram of a log management interface according to an embodiment of the present invention;

FIG. 9 is a schematic diagram of a generic setup interface provided in an embodiment of the invention;

FIG. 10 is a schematic diagram of an interface for message announcements provided by an embodiment of the present invention;

FIG. 11 is a diagram illustrating a management interface for global variables according to an embodiment of the present invention;

FIG. 12 is a diagram illustrating a management interface for local variables provided by an embodiment of the present invention;

FIG. 13 is a diagram illustrating an orchestration interface for decision flow according to an embodiment of the invention;

FIG. 14 is a schematic diagram of an interface for segment subdivision provided by an embodiment of the present invention;

FIG. 15 is a schematic diagram of an interface for subdividing according to an embodiment of the present invention;

FIG. 16 is a schematic diagram of a decision tree provided in accordance with an embodiment of the present invention;

FIG. 17 is a schematic view of a champion challenger's interface provided by an embodiment of the invention;

FIG. 18 is a schematic view of an interface for a scorecard provided by an embodiment of the present invention;

FIG. 19 is a schematic view of an interface of a model actuator provided in accordance with an embodiment of the present invention;

FIG. 20 is a schematic diagram of a rule definition interface provided by an embodiment of the invention;

FIG. 21 is a schematic diagram of an interface for a rule set provided by an embodiment of the present invention;

FIG. 22 is a schematic diagram of a sequencer provided in accordance with an embodiment of the present invention;

FIG. 23 is a schematic diagram of an interface for code scripts provided in an embodiment of the present invention;

FIG. 24 is a schematic diagram of an interface for a decision table provided by an embodiment of the present invention;

FIG. 25 is a schematic diagram of an interface for external calls provided by an embodiment of the present invention;

FIG. 26 is a diagram illustrating an interface of a custom function provided by an embodiment of the invention;

FIG. 27 is a schematic diagram of an interface for viewing details provided by an embodiment of the invention;

FIG. 28 is a schematic illustration of a viewing history provided by an embodiment of the invention;

FIG. 29 is a schematic diagram of an interface for unit testing provided by an embodiment of the present invention;

FIG. 30 is a diagram illustrating an overall technical architecture of a method for implementing a decision engine according to an embodiment of the present invention;

fig. 31 is a schematic structural diagram of a decision engine implementation apparatus according to a third embodiment of the present invention;

fig. 32 is a schematic structural diagram of a decision engine implementation device according to a fifth embodiment of the present invention.

Detailed Description

Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present invention. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the invention, as detailed in the appended claims.

First, terms related to embodiments of the present invention are explained:

a scoring card: the method is a mature prediction method, is widely used in the fields of credit risk assessment and financial risk control, and adopts the principle that a logistic regression model is used for carrying out a generalized linear model of binary variables after a model variable WOE (Weight of Evidence) coding mode is discretized.

Furthermore, the terms "first", "second", etc. are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or implicitly indicating the number of technical features indicated. In the description of the following examples, "plurality" means two or more unless specifically limited otherwise.

The embodiment of the invention specifically realizes a service user-oriented componentized decision engine system, and the overall functional architecture of the decision engine system is shown in figure 1 and mainly comprises a policy designer and a policy execution engine. The strategy designer provides a plurality of functional components with general functions and a component library comprising a plurality of decision flow components for a user through a visual interface, the user can create examples of each functional component and decision flow component through the visual interface, and corresponding business decision logic is realized through each example to obtain a corresponding decision file; the strategy execution engine executes the decision file by analyzing the decision file to generate a corresponding decision service, realizes the deployment of the decision service, provides a decision service interface for a user, and the user can call the decision service through the decision service interface.

The core idea of the strategy designer is to realize service logic through componentization, then realize the overall complex service decision logic through flexible arrangement of decision flow, and simultaneously improve the high multiplexing of the component logic. The strategy designer provides a general function and a component library, the general function provides a plurality of functional components, and the general function at least comprises the following components: personnel management, role management, group management, authority management, version management, general setting, message announcement, operation log management, personal information management and test management. The component library provides decision flow components, including at least: decision flow, global variable, local variable, segmentation subdivision, matrix subdivision, subdivision or not, decision tree, champion challenger, score card, model executor, sequence executor, rule set, index table, decision table, numerical value setter, decision setter, sequence setter, external call, code script and self-defined function. Additionally, the created component instance may include various debugging functions such as printing, importing, exporting, unit testing, batch testing, reference locating, updating versions, and the like. The model executor may be compatible with various machine learning models, such as logistic regression model, decision tree model, neural network model, AI learning model, etc. Therefore, the strategy designer greatly improves the user interaction experience and the deployment efficiency compared with the traditional decision engine, can support the service user to conveniently and rapidly deploy own strategy, complete the service logic test, and simultaneously support the service user to deploy by one key.

The strategy execution engine mainly comprises deployment management (supporting hot deployment), a decision flow executor, a component executor, a script executor, log management, exception handling and the like, can adopt a latest distributed architecture, has infinite expansion capability on the performance of the strategy execution engine, can greatly improve the performance of the strategy execution engine, and can meet the requirements of financial scenes such as customer marketing, application credit, application anti-fraud, transaction anti-fraud, post-loan management and the like on the strategy engine.

The decision engine implementation method provided by the embodiment of the invention has the characteristics of service orientation, flexible configuration, one-key deployment, strict logic and the like, supports hot deployment, high performance, high concurrency and the like, and is far superior to the traditional decision engine and rule engine.

The following describes the technical solutions of the present invention and how to solve the above technical problems with specific embodiments. The following several specific embodiments may be combined with each other, and details of the same or similar concepts or processes may not be repeated in some embodiments. Embodiments of the present invention will be described below with reference to the accompanying drawings.

Fig. 2 is a flowchart of a decision engine implementation method according to an embodiment of the present invention. The embodiment of the invention provides a decision engine implementation method aiming at the problems of low decision logic generation efficiency caused by poor expandability and complex use of a rule engine drive in the conventional decision engine system.

The method in this embodiment is applied to a decision engine implementation device, which may be embodied as a server or a server cluster (hereinafter, referred to as "decision engine system device") with certain computing power, such as a desktop computer, a tablet computer, a notebook computer, or the like, or may be a chip in an electronic device, and the like, and this embodiment is not limited in detail here.

As shown in fig. 2, the method comprises the following specific steps:

step S101, responding to instantiation operation of any functional component by a user, and creating a first instance of the functional component, wherein the functional component is used for realizing corresponding business logic.

In this embodiment, a plurality of functional components and decision flow components may be provided through a visualization interface.

Wherein, the functional component is used for realizing corresponding business logic, and at least comprises: personnel management, role management, group management, authority management, version management, general setting, message announcement, operation log management, personal information management and test management.

Decision flow component the decision flow component is used to implement corresponding decision logic, comprising at least: decision flow, global variable, local variable, segmentation subdivision, matrix subdivision, subdivision or not, decision tree, champion challenger, score card, model executor, sequence executor, rule set, index table, decision table, numerical value setter, decision setter, sequence setter, external call, code script and self-defined function.

In addition, the functions and the use rules of all the components can be displayed through a visual interface, so that a user can view and select a plurality of functional components and decision flow components to realize the business decision logic of the user.

In this embodiment, when a user needs to use a functional component, an instantiation operation of the functional component may be performed through the visual interface. The decision engine system device creates a first instance of any functional component in response to a user instantiation operation of the functional component.

Wherein the first instance may represent an instance of any one of the functional components to distinguish it from the second instance of the decision flow component.

A user may select and create a first instance of a plurality of functional components.

Step S102, responding to instantiation operation of any decision flow component by a user, and creating a second instance of the decision flow component, wherein the decision flow component is used for realizing corresponding decision logic.

In this embodiment, when a user needs to use a decision flow component, an instantiation operation of the decision flow component can be performed through the visual interface. The decision engine system device creates a second instance of any of the decision flow components in response to a user instantiation operation of the decision flow component.

Wherein the second instance may represent an instance of any one of the decision flow components to distinguish it from the first instance of the functional component.

The user may select and create a second instance of the plurality of decision flow components.

And step S103, generating a policy file in response to the arrangement operation of the first instance and the second instance by the user.

In this embodiment, a user may perform an arranging operation on the created first instance and second instance to generate a desired service decision logic and generate a corresponding policy file.

The decision engine system device generates a policy file in response to a user's orchestration operation of the first instance and the second instance. The policy file is used to implement a corresponding business decision logic.

For example, the user may perform an operation of arranging the created first instance and second instance, and may perform an operation of dragging the first instance and second instance to the work space and arranging the dependency relationship between the first instance and second instance.

And step S104, generating a decision service corresponding to the strategy file, and displaying an interface of the decision service.

After the policy file is obtained, the decision engine system device may parse the policy file, execute the policy file, generate a corresponding decision service, and display a decision service interface to the user in an assigned manner. The decision service interface is an interface for calling a decision service.

For example, the decision service interface may be displayed to the user through a visual interface, or pushed to the user or a designated person through a designated manner.

The designated mode and designated personnel may be set and adjusted by a user through a visual interface, which is not specifically limited in this embodiment.

The embodiment of the invention provides a plurality of functional components and decision flow components for a user, responds to the instantiation operation of the user on any functional component, and creates a first instance of the functional component; creating a second instance of any decision flow component in response to a user instantiation operation on the decision flow component; generating a policy file in response to the arrangement operation of the first instance and the second instance by the user; generating a decision service corresponding to the strategy file, and displaying an interface of the decision service; a plurality of functional components and decision flow components are abstracted to realize different business decision logics; the complete service decision logic is realized through the arrangement of the decision flow; by adopting a componentization mode, the strong expandability of the system and the flexibility of logic implementation are ensured, a user can realize service decision logic by instantiating and arranging existing components, the use is very simple, and the generation efficiency of the decision logic can be improved.

Fig. 3 is a flowchart of a decision engine implementation method according to a second embodiment of the present invention. On the basis of the first embodiment, in this embodiment, in response to a deployment instruction for the decision service, the decision service is automatically deployed according to a deployment manner specified by a user, where the deployment manner includes: one-touch deployment, offline deployment, timed deployment. And executing the decision service in response to the call instruction of the decision service interface. As shown in fig. 3, the method comprises the following specific steps:

step S201, providing a plurality of functional components and decision flow components through a visual interface, where the functional components are used to implement corresponding business logic, and the decision flow components are used to implement corresponding decision logic.

In the embodiment, in order to enable business personnel to conveniently and flexibly realize and verify the complex policy logic, the complex policy logic is split into a plurality of policy nodes and abstracted into each functional component; and the complex service decision logic is realized by arranging the instance content of each functional component, and the decision flow component is abstracted according to the arrangement of the functional component instance.

The functional components include at least: personnel management, role management, group management, authority management, version management, general setting, message announcement, operation log management, personal information management and test management.

The personnel management is mainly used for realizing addition, deletion, modification and checking of personnel and the corresponding relation between the personnel and roles and groups. Many-to-many relationships exist between people and roles and groups.

The role management is mainly used for realizing the addition, deletion, modification and viewing of roles and the corresponding relation between the roles and the personnel and the groups, and the many-to-many relation exists between the roles and the personnel and the groups.

The group management is mainly used for realizing the addition, deletion, modification and viewing of the group and the corresponding relation between the group and the personnel and the roles, and the many-to-many relation exists between the group and the personnel and the roles. For example, the relationship of people, roles, groups may be as shown in FIG. 4.

The authority management is mainly used for establishing mapping relations among the roles, the projects, the subdirectories and the components, having the authorities of creating, deleting, modifying, checking, importing and exporting different projects and subdirectories, and having the authorities of correspondingly creating, deleting, modifying, checking, importing and exporting corresponding components. For example, a rights management page for an item may be as shown in FIG. 5 and a rights management page for a component may be as shown in FIG. 6.

The project management can control the addition, deletion, modification and viewing of the project through the authority, and can maintain the basic information of the project and the like. The project structure is clear and easy to understand, the project content can be quickly positioned, and the hierarchical management of the project catalog is supported. For example, an interface for project management may be as shown in FIG. 7.

The log management supports the viewing of all operation record logs, the logs can be classified and hierarchically managed according to different operation contents, and the log screening query is supported. The category and level of the operation recorded by the log can be set according to the actual application scenario. In addition, policy sensitive information is masked in the log. The policy sensitive information may include information related to a specific rule in the decision logic to improve security of the decision engine, and in addition, the policy sensitive information may also include other information, which may be set according to an actual application scenario, and this embodiment is not specifically limited herein. For example, the log management interface may be as shown in fig. 8, record a topic type, a topic name, an operation type, operation content, an operator, operation time, and the like in the log, and support filtering queries by items, time, or operators. In addition, the log may further include contents of other fields, and the filtering query may be performed through other conditions, which is not specifically limited herein.

The general setting may support setting general parameters, such as a user name length, a password strength, a password validity period, a password retry number, a password count, and the like, and the embodiment is not limited herein. Optionally, if the repeated login times of the user exceed a preset threshold, locking the user; and/or locking the user if the password retries more times. For example, the general setting interface may set the reserved password count, and set the login retry limit (number of login retries), as shown in fig. 9; one-touch restore default settings are also supported.

The message announcement is mainly used for broadcasting messages for all users in the system, so that all users receive corresponding message contents. For example, as shown in fig. 10, the content of the message announcement includes an announcement title, a publisher, and an announcement time, and the published and unpublished message announcements can be displayed in a differentiated manner.

In this embodiment, the decision flow component at least includes: decision flow, global variable, local variable, segmentation subdivision, matrix subdivision, subdivision or not, decision tree, champion challenger, score card, model executor, sequence executor, rule set, index table, decision table, numerical value setter, decision setter, sequence setter, external call, code script and self-defined function.

Wherein the decision flow component comprises at least the following decision variable components: global variables, local variables. In order to enable business personnel to get rid of the trouble of data source problems, all decision variables are divided into global variables and local variables, and the global variables and the local variables are distinguished according to the scope of the decision variables. The global variable supports flexibly configured variables required by decision making, can support character type, numerical type, date type variables and other types, can support array variables, and supports flexible management, grouping management and Chinese definition of the variables. Setting global variables and local variables through different scopes of the variables, wherein the local variables mainly act in the subdirectories. For example, as shown in fig. 11, the management interface of global variables supports the export of all global variables or selected global variables, as shown in fig. 12, the management interface of local variables supports the export of all local variables or selected local variables.

The decision flow can arrange all component contents to complete the definition of final service decision logic, wherein the definition comprises an execution node, a branch node and a sub-flow node, other decision flows are quoted in the decision flow to form a sub-flow, the quoted subsection subdivision, the matrix subdivision, whether subdivision exists, a decision tree and a champion challenger form the branch node, and the rest components can become the execution nodes. All components and component instances can be dragged to the work space for layout. For example, as shown in fig. 13, the orchestration interface of the decision stream may support operations of decision stream export, printing, unit testing, batch testing, deployment, version updating, and the like, and the decision stream with clear and concise content may be generated by a drag operation in the orchestration interface of the decision stream.

In this embodiment, the decision flow component at least includes the following conditional branch components: segmentation subdivision, matrix subdivision, whether subdivision is available, decision tree, champion challenger.

Segmentation subdivision is the simplest conditional branch, which is a different definition of different content partitions from a single variable. For example, the marital status may be divided into singles, married, dissimilarity, other, etc., and the age may be divided into children, teenagers, middle-aged, elderly, other, etc. As shown in fig. 14, the interface of the segment subdivision supports selection of variables that need segment subdivision, setting of specific subdivision modes of the variables, and supports operations of derivation, unit testing, batch testing, saving, version updating, and the like of the segment subdivision of the variables.

Whether the subdivision is one of the conditional branches is judged based on business logic, and the result is true or false according to whether the judgment condition is satisfied. For example, as shown in fig. 15, the interface for subdivision or non-subdivision may edit the subdivision modes of the variables, and support operations such as export, unit test, batch test, save, and update of the variables or non-subdivision.

The decision tree is one of conditional branches, can conveniently quote other component contents, supports flexible definition of node contents, is clear and concise in hierarchical mechanism and node contents, is convenient to operate, and supports an interaction mode of dragging and pulling. The interface of the decision tree supports operations such as export, unit test, batch test, saving, version updating and the like. An example of a decision tree is provided as shown in fig. 16.

The champion challenger is one of conditional branches and supports different strategies of quantitative random grouping, namely, the grouping condition is controlled by a built-in random number; different strategies of interface variable quantitative random grouping are supported, namely grouping conditions are controlled through input parameters; and the system supports the full-flow distribution strategy, namely, two sets of strategies are completely executed, and one set of strategy is used as the standard, and the other set of strategy is used for recording and referring. As shown in fig. 17, the champion challenger's interface may set the corresponding scale and support export, unit test, batch test, save, update version, etc. operations.

The scoring card is one of execution nodes, supports flexible definition of a scoring variable, a scoring score and an expected score, supports definition of segmentation dimension and code of the scoring variable and defines a scoring level; and support the multi-dimensional processing of the scoring variable, namely the scoring variable can be a single variable or a plurality of variables. For example, the interface of the score card may be as shown in fig. 18, may set score segments, scores, expected scores, reason codes (identification codes corresponding to reason information), score grades, ranges (segment dimensions), and the like, and support operations of exporting, unit testing, batch testing, saving, updating versions, and the like.

In this embodiment, the decision flow component includes a model executor that, in response to an instantiation operation of the model executor by a user, creates a second instance for implementing the machine learning model according to the machine learning model specified by the user.

Specifically, according to a machine learning Model specified by a user, a PMML (Predictive Model Markup Language) file of the machine learning Model is parsed, and a second instance for implementing the machine learning Model is generated. In this way, the machine learning model can be fused to the decision engine to be realized through the model executor, and the PMML file directly imported into the machine learning model is supported. The model executor may be compatible with various machine learning models, such as logistic regression model, decision tree model, neural network model, AI learning model, etc.

The model executor is one of execution nodes and supports PMML files supporting models of import decision trees, logistic regression, linear regression, random forests, neural networks, gbdt, xgboost and the like. The PMML file with a plurality of versions (such as 4.0, 4.1, 4.2 and 4.3) is supported to be imported. In the interface of the model executor, a model file (PMML file) can be uploaded, the analysis of the access of the PMML file is supported, and the relational mapping can be carried out on the access of the PMML file and the variables defined above. For example, the interface of the model executor may support export, unit test, batch test, save, update version, etc. operations as shown in FIG. 19.

The rule definition is the finest granularity of a rule layer, supports self-defined rule codes (such as 20 bits), rule contents, rule logic, rule modes and the like, and supports rule grouping management; the support rule logic may use custom functions, built-in functions, etc. For example, the rule definition interface may support export, save, update version, etc. operations, as shown in FIG. 20.

The rule set is one of execution nodes, supports flexible combination rules to form the rule set, adjusts the content priority order of the rule set, and defines the output content triggered irregularly; and supports the interactive form of dragging and pulling, and can set triggering weight, etc. For example, the interface for the rule set may support export, unit testing, batch testing, save, update version, etc. operations as shown in FIG. 21.

The sequence setter is one of execution nodes, can refer to other condition component examples to form a condition tree, supports assignment operation of multiple columns of variables, and can assign a value of one variable to another variable to realize data transmission and the like. For example, the sequencer may support export, unit testing, batch testing, save, update version, etc. operations as shown in FIG. 22.

The code script is one of execution nodes, supports flexible definition of script content, and supports drag operation or guided operation of variables, functions, operational characters and the like; common functions such as reference character class, data class, statistic class, date class and conversion class are supported, and nested use is allowed; supporting common logic processing modes such as condition judgment, circulation and the like; common functions such as built-in character type, data type, statistic type, date type and conversion type are supported; and supporting the extensibility of built-in functions and the like. For example, the interface for the code script may support export, unit testing, batch testing, save, update version, etc. operations as shown in FIG. 23.

The decision table is one of execution nodes, supports flexible definition of the structure of the decision table, including field content, condition content and the like, supports the finding of the corresponding relation between conditions and results, and is very flexible and convenient. For example, the interface of the decision table may support export, unit test, batch test, save, update version, etc. operations as shown in FIG. 24.

The external call is one of execution nodes, supports a certain node in the decision flow to initiate and call an external program, realizes data and collection or execution of external sub-strategies, and the like, and simultaneously supports definition of access parameters and relational mapping with variables inside the engine. For example, the interface for external calls may support export, unit testing, batch testing, save, update version, etc. operations, as shown in FIG. 25.

The custom function is a business logic function and can refer to other built-in functions while supporting definition parameters. The self-defined function can be quoted as the built-in function, and high multiplexing can be realized. For example, the interface of the custom function may support export, unit test, batch test, save, update version, etc. operations as shown in FIG. 26.

The viewing details are that the specific component instance content in the project catalog can be viewed, including the conditions of version, creator, component name and the like, and the overall condition of the whole catalog can be viewed. For example, the interface to view details may operate as shown in FIG. 27, update versions and refresh.

The history of viewing can view the historical version condition of a single component, and can view the specific version change history. For example, the viewing history may be as shown in FIG. 28.

The test includes a unit test and a batch test. Unit test, which can be executed to obtain results by inputting variable values manually; the unit test can carry out comparison test, namely, a plurality of records can be input to carry out strategy result comparison. And batch testing, wherein the batch data testing can be realized by uploading files or directly connecting the files with a database, and the test results are stored in the files or the database. For example, the interface for unit testing may be as shown in FIG. 29.

All the visual interfaces provided by the embodiment support full-screen display and full-screen cancellation operation.

In the embodiment, different components are abstracted to realize different decision logics; through decision stream arrangement, complete and complex decision logic is realized. The realization of the function and decision flow adopts the componentized design, thereby ensuring the strong expandability of the decision engine system and the flexibility of the logic realization. The conditional subdivision components, namely segmentation subdivision, whether subdivision is needed, matrix subdivision, decision trees and champion challengers, realize complex conditional content in business decision logic. Whether subdivision, rules, code scripts and custom functions pass through a custom logic domain language or not is achieved, and flexible and variable business logic processing capacity is improved. The model executor realizes that the machine learning model is realized through an engine, and ensures comprehensive decision. The logic test (including unit test and batch test) of the assembly can rapidly reproduce the execution process of the assembly by analyzing the dependent variable in the assembly, and the verification of the assembly logic is flexibly realized.

Step S202, responding to instantiation operation of a user on any functional component, and creating a first instance of the functional component.

This step is the same as the step S102, and is not described here again.

Step S203, responding to the instantiation operation of the user to any decision flow component, and creating a second instance of the decision flow component.

This step is the same as the step S103, and is not described herein again.

In this embodiment, the policy file is generated in response to the orchestration operation of the first instance and the second instance by the user, which may specifically be implemented in the following manner: generating a corresponding decision flow instance in response to the user's choreography operation on the first instance and the second instance; and responding to a decision completion instruction of the user, and generating a strategy file according to the decision flow instance.

And step S204, responding to the arrangement operation of the user on the first instance and the second instance, and generating a corresponding decision flow instance.

In this embodiment, in the component library of the decision flow component, the decision flow may arrange all component contents to complete the definition of the final service decision logic, where the definition includes an execution node, a branch node, and a sub-flow node, the decision flow refers to other decision flows to form a sub-flow, refers to a segment subdivision, a matrix subdivision, whether to subdivide, a decision tree, and a champion challenger to form a branch node, and the remaining components become execution nodes.

All components and component instances can be dragged to the work space for layout.

The user can obtain the corresponding decision flow by arranging the first instance and the second instance in the working interval. In response to a user's orchestration operation of the first instance and the second instance, the decision engine device generates a corresponding decision stream instance.

Step S205, in response to the debugging operation of the user on any component instance or decision flow instance, executing corresponding debugging processing on the component instance or decision flow instance, where the component instance is any first instance or second instance.

Wherein the debugging process comprises at least one of: printing, importing, exporting, unit testing, batch testing, quotation positioning and updating versions.

In the embodiment, in order to realize convenient and flexible deployment of verification service decision logic for a user, functions such as printing, import and export, unit testing, batch testing, reference positioning and the like are added to the functional components and the decision flow. There will be corresponding functionality in the component instances.

The user can realize the corresponding debugging function of the component instance or the programmed decision flow instance through the debugging operation of any component instance or decision flow instance.

And step S206, responding to a decision completion instruction of the user, and generating a policy file according to the decision flow instance.

After completing the orchestration of all decision logic, the user may send a decision completion instruction to the decision engine device through the visual interface. And responding to a decision completion instruction of the user, and generating a strategy file according to the decision flow instance.

In addition, after the strategy file is generated, the strategy file is encrypted and then put into a strategy execution engine.

And step S207, generating a decision service corresponding to the strategy file.

In this embodiment, the policy execution engine includes modules such as a policy loader, an executor, an execution log, context management, and exception handling. The policy enforcement engine is mainly characterized in that: based on Java, the method is easy to integrate; the platform diversity supports simultaneous use of multiple users; data management, which supports data import of different formats; the performance is outstanding, and the time of each call is in the millisecond level; the operation is safe, an audit flow is arranged in the system, and the system has tracking capability and the like.

After obtaining the policy file, a policy loader in the policy enforcement engine may decrypt and parse the policy file to generate a corresponding decision service.

And S208, responding to the deployment instruction of the decision service, and automatically deploying the decision service according to the deployment mode specified by the user.

Wherein, the deployment mode includes: one-touch deployment, offline deployment, timed deployment.

In order to realize convenient and flexible deployment decision service of users, one-touch deployment, offline deployment, timed deployment and the like are provided on a deployment mode.

Optionally, the policy execution engine may be implemented by using a distributed architecture, which may reduce the impact of policy deployment on services, improve the efficiency of the policy execution engine, and ensure high performance, high concurrency, and high availability of the decision engine.

And S209, displaying a decision service interface.

After the corresponding decision service is generated, the decision service interface can be presented to the user in a specified manner. For example, the decision service interface may be displayed to the user through a visual interface, or pushed to the user or a designated person through a designated manner.

Step S210, responding to the call instruction of the decision service interface, executing the decision service.

When the decision service is called, the executor in the policy execution engine may execute the decision service according to the input parameter to obtain a decision result.

In this embodiment, in response to a call instruction to the policy service interface, the policy execution engine may perform the policy service based on memory calculation, so as to improve performance of the policy execution engine.

Illustratively, the overall technical architecture of the decision engine implementation method provided by this embodiment is shown in fig. 30, as shown in fig. 30, a policy designer may generate a policy file, and a policy execution engine generates a decision service corresponding to the policy file and provides a decision service interface to the outside. The strategy executor can be further subdivided into modules such as a decision flow executor, a component processor, a rule script language and the like. The decision flow executor is an inlet of the policy execution engine, and comprises a policy loader, a context manager, an executor and the like. The component processor comprises a processor (processing module), a rule set, a score card, a decision tree, a model executor and the like, and can perform corresponding processing. The rule script language comprises functions, custom functions, expressions, semantic analysis, grammar analysis, rule language grammar and the like, and supports the realization of various code scripts. The decision engine implementation method provided by the embodiment can implement the full life cycle management of the strategy, including strategy design, deployment, test, verification, online, simulation, optimization and the like, so that strategy iteration is more agile and efficient.

The embodiment of the invention is used for realizing different business decision logics by abstracting a plurality of functional components and decision flow components; the complete service decision logic is realized through the arrangement of the decision flow; flexible deployment of complex strategy logic can be realized through parameterization and visual flexible configuration, strong expandability of the system and flexibility in logic realization are guaranteed, a user can realize service decision logic by instantiating an existing component and arranging, the service decision logic is very simple to use, and the generation efficiency of the decision logic can be improved; the realization of the function and decision flow adopts the componentized design, thereby ensuring the strong expandability of the decision engine system and the flexibility of the logic realization. The conditional subdivision components, namely segmentation subdivision, whether subdivision is needed, matrix subdivision, decision trees and champion challengers, realize complex conditional content in business decision logic. Whether subdivision, rules, code scripts and custom functions pass through a custom logic domain language or not is achieved, and flexible and variable business logic processing capacity is improved. And the internal rich strategy components are made, the execution of the PMML model file is supported, and the comprehensive decision of the strategy and the model is realized. The logic test (including unit test and batch test) of the assembly can rapidly reproduce the execution process of the assembly by analyzing the dependent variable in the assembly, and the verification of the assembly logic is flexibly realized; the decision service is executed based on the memory calculation, so that the performance of the decision service execution can be improved.

Fig. 31 is a schematic structural diagram of a decision engine implementation apparatus according to a third embodiment of the present invention. The decision engine implementation device provided by the embodiment of the invention can execute the processing flow provided by the decision engine implementation method. As shown in fig. 31, the decision engine implementing device 30 includes: a policy designer 301 and a policy enforcement engine 302.

Specifically, the policy designer 301 is configured to provide a plurality of functional components and decision flow components through a visual interface, where the functional components are configured to implement corresponding business logic, and the decision flow components are configured to implement corresponding decision logic; in response to an instantiation operation of a user on any functional component, creating a first instance of the functional component; creating a second instance of any decision flow component in response to a user instantiation operation on the decision flow component; and generating a policy file in response to the user's choreography operation on the first instance and the second instance.

The policy execution engine 302 is configured to generate a decision service corresponding to the policy file, and display an interface of the decision service.

The apparatus provided in the embodiment of the present invention may be specifically configured to execute the method embodiment provided in the first embodiment, and specific functions are not described herein again.

On the basis of the third embodiment, in this embodiment, the policy designer is further configured to: the decision flow component includes a model executor that, in response to an instantiation operation of the model executor by a user, creates a second instance for implementing the machine learning model from the machine learning model specified by the user.

In an alternative embodiment, the policy designer is further configured to: and analyzing the PMML file of the machine learning model according to the machine learning model specified by the user, and generating a second example for realizing the machine learning model.

In an alternative embodiment, the policy enforcement engine is further configured to: and executing the decision service in response to the call instruction of the decision service interface.

In an alternative embodiment, the policy enforcement engine is further configured to: and responding to a call instruction of the decision service interface, and executing the decision service based on memory calculation.

In an alternative embodiment, the policy designer is further configured to: generating a corresponding decision flow instance in response to the user's choreography operation on the first instance and the second instance; and responding to a decision completion instruction of the user, and generating a strategy file according to the decision flow instance.

In an alternative embodiment, the policy designer is further configured to: and responding to the debugging operation of a user on any component instance or decision flow instance, and executing corresponding debugging processing on the component instance or decision flow instance, wherein the component instance is any first instance or second instance.

In an alternative embodiment, the debugging process includes at least one of: printing, importing, exporting, unit testing, batch testing, quotation positioning and updating versions.

In an alternative embodiment, the policy enforcement engine is further configured to: responding to a deployment instruction of the decision service, and automatically deploying the decision service according to a deployment mode specified by a user, wherein the deployment mode comprises the following steps: one-touch deployment, offline deployment, timed deployment.

In an alternative embodiment, the decision flow component includes the following conditional branch components: segmentation subdivision, matrix subdivision, whether subdivision is available, decision tree, champion challenger.

In an alternative embodiment, the decision flow component includes the following decision variable components: global variables, local variables.

The apparatus provided in the embodiment of the present invention may be specifically configured to execute the method embodiment provided in the second embodiment, and specific functions are not described herein again.

Fig. 32 is a schematic structural diagram of a decision engine implementation device according to a fifth embodiment of the present invention. As shown in fig. 32, the apparatus 100 includes: a processor 1001, a memory 1002, and computer programs stored on the memory 1002 and executable on the processor 1001. When the processor 1001 runs the computer program, the decision engine implementation method provided by any one of the above method embodiments is implemented.

In addition, an embodiment of the present invention further provides a computer-readable storage medium, where a computer program is stored in the computer-readable storage medium, and when the computer program is executed by a processor, the computer program implements the decision engine implementation method provided in any of the above method embodiments.

It is obvious to those skilled in the art that, for convenience and simplicity of description, the foregoing division of the functional modules is merely used as an example, and in practical applications, the above function distribution may be performed by different functional modules according to needs, that is, the internal structure of the device is divided into different functional modules to perform all or part of the above described functions. For the specific working process of the device described above, reference may be made to the corresponding process in the foregoing method embodiment, which is not described herein again.

Other embodiments of the invention will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This invention is intended to cover any variations, uses, or adaptations of the invention following, in general, the principles of the invention and including such departures from the present disclosure as come within known or customary practice within the art to which the invention pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the invention being indicated by the following claims.

It will be understood that the invention is not limited to the precise arrangements described above and shown in the drawings and that various modifications and changes may be made without departing from the scope thereof. The scope of the invention is limited only by the appended claims.

Claims

1. A method for implementing a decision engine, comprising:

responding to instantiation operation of a user on any functional component, and creating a first instance of the functional component, wherein the functional component is used for realizing corresponding business logic;

creating a second instance of the decision flow component in response to an instantiation operation of any decision flow component by the user, the decision flow component for implementing corresponding decision logic;

generating a policy file in response to the user's choreography operation on the first instance and the second instance;

and generating a decision service corresponding to the strategy file, and displaying an interface of the decision service.

2. The method of claim 1, wherein creating the second instance of the decision flow component in response to the user's instantiation operation of any decision flow component comprises:

the decision flow component comprises a model executor, and in response to the instantiation operation of the model executor by the user, a second instance for implementing the machine learning model is created according to the machine learning model specified by the user.

3. The method of claim 2, wherein creating a second instance for implementing the machine learning model from the user-specified machine learning model comprises:

and analyzing the PMML file of the machine learning model according to the machine learning model specified by the user, and generating a second example for realizing the machine learning model.

4. The method of claim 1, further comprising:

and responding to a calling instruction of the interface, and executing the decision service.

5. The method of claim 4, wherein the executing the decision service in response to the call instruction to the interface comprises:

and responding to a call instruction of the interface, and executing the decision service based on memory calculation.

6. The method of claim 1, wherein generating a policy file in response to the user's orchestration operations on the first and second instances comprises:

generating a corresponding decision flow instance in response to the user's choreography operation on the first instance and the second instance;

and responding to the decision completion instruction of the user, and generating a policy file according to the decision flow instance.

7. The method of claim 6, further comprising:

and responding to the debugging operation of the user on any component instance or decision flow instance, and executing corresponding debugging processing on the component instance or decision flow instance, wherein the component instance is any first instance or second instance.

8. The method of claim 7, wherein the debugging process comprises at least one of: printing, importing, exporting, unit testing, batch testing, quotation positioning and updating versions.

9. The method of claim 1, further comprising:

responding to a deployment instruction of the decision service, and automatically deploying the decision service according to a deployment mode specified by the user, wherein the deployment mode comprises the following steps: one-touch deployment, offline deployment, timed deployment.

10. The method according to any of claims 1-9, wherein the decision flow component comprises the following conditional branch components:

segmentation subdivision, matrix subdivision, whether subdivision is available, decision tree, champion challenger.

11. The method of any of claims 1-9, wherein the decision flow component comprises the following decision variable components:

global variables, local variables.

12. A decision engine implementation apparatus, comprising:

the system comprises a policy designer, a first service logic module and a second service logic module, wherein the policy designer is used for responding to instantiation operation of a user on any functional component and creating a first instance of the functional component, and the functional component is used for realizing the corresponding service logic; creating a second instance of the decision flow component in response to an instantiation operation of any decision flow component by the user, the decision flow component for implementing corresponding decision logic; generating a policy file in response to the user's choreography operation on the first instance and the second instance;

13. A decision engine implementing device, comprising:

a processor, a memory, and a computer program stored on the memory and executable on the processor;

wherein the processor, when executing the computer program, implements the method of any of claims 1 to 11.

14. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 11.