Scene-oriented intelligent decision-making method and device, equipment and storage medium

Abstract

The invention discloses a scene-oriented intelligent decision-making method and device, equipment and a storage medium. Comprising the steps of loading a corresponding pre-arranged plan for instantiation based on input target business scene information, and creating an initial unified context corresponding to a pre-arranged plan instance; the scheduler determines a ready node queue in a plan instance based on a plan map and the initial unified context; based on the ready node queue execution process plan, writing back an execution result, a verification result and a monitoring result in an execution period into a unified context; and carrying out local re-evaluation on affected edges and nodes in the plan graph based on the updated unified context, determining a subsequent ready node queue, and executing the subsequent ready node queue until the nodes in the plan instance are executed completely. The invention provides an intelligent decision-making platform of'light application + shared center ', which is a universal intelligent decision-making system supporting dynamic arrangement, real-time response and continuous verification, so that the business process has the capabilities of sensing environment change and dynamically and autonomously optimizing.

Description

Technical Field

[0001] This application relates to the field of information processing and business decision-making technology, and more specifically, to a scenario-oriented intelligent decision-making method, apparatus, device, and storage medium. Background Technology

[0002] In critical business scenarios such as emergency response, operational scheduling, and traffic management, a series of steps are typically required, including data collection, model prediction, rule determination, instruction issuance, and effect monitoring. Currently, enterprises generally adopt a BPM (Business Process Management)-based approach, combined with independently deployed rule engines, model services, and form systems to support these business processes.

[0003] The existing technical architecture is built on individual business applications, each with its own fixed business processes, data models, decision-making rules, and user interfaces. Different application systems exchange data only through application programming interfaces (APIs), leading to problems such as fragmented architecture, tight system coupling, scattered judgment criteria, insufficient scenario collaboration, and disconnect between verification and processes. As the intelligence level of software systems increases and business complexity grows, the existing technical architecture can hardly support the demands of agile collaboration, intelligent decision-making, and continuous evolution in the context of digitalization. There is an urgent need for an innovative architecture to achieve centralized governance of common capabilities and unified intelligent orchestration and execution of scenario-based processes. Summary of the Invention

[0004] This application provides a scenario-oriented intelligent decision-making method, apparatus, device, and storage medium to at least solve the technical problems in related technologies that make it difficult to achieve scenario-oriented intelligent decision-making with business collaboration, centralized process governance, and dynamic real-time response.

[0005] According to one aspect of the embodiments of this application, a scenario-oriented intelligent decision-making method is provided, comprising: Based on the input target business scenario information, load the corresponding contingency plan diagram for instantiation and create the initial unified context corresponding to the contingency plan instance. The scheduler determines the queue of ready nodes in the plan instance based on the plan graph and the initial unified context; Based on the pre-defined execution process plan of the ready node queue, the execution results, verification results, and monitoring results during the execution period are written back to the unified context. Based on the updated unified context, the affected edges and nodes in the contingency plan graph are locally re-evaluated, the subsequent ready node queue is determined and executed, until all nodes in the contingency plan instance have been executed.

[0006] According to another aspect of the embodiments of this application, a scenario-oriented intelligent decision-making device is also provided, comprising: The contingency plan instantiation module is used to load the corresponding contingency plan diagram for instantiation based on the input target business scenario information, and create the initial unified context corresponding to the contingency plan instance. The execution module is used by the scheduler to determine the queue of ready nodes in the plan instance based on the plan graph and the initial unified context. The result write-back module is used to write back the execution results, verification results, and monitoring results during the execution process to a unified context based on the ready node queue. The dynamic correction module is used to perform local re-evaluation of the affected edges and nodes in the contingency plan graph based on the updated unified context, determine the subsequent ready node queue and execute it, until the nodes in the contingency plan instance have been executed.

[0007] According to another aspect of the embodiments of this application, an electronic device is also provided, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to execute the above-described scenario-oriented intelligent decision-making method through the computer program.

[0008] According to another aspect of the embodiments of this application, a computer-readable storage medium is also provided, wherein a computer program is stored in the computer-readable storage medium, and the computer program is configured to execute the above-described scenario-oriented intelligent decision-making method at runtime.

[0009] The technical solutions provided in this application embodiment may include the following beneficial effects: This application provides a scenario-oriented intelligent decision-making method. Through the dynamic instantiation of a pre-plan diagram and the construction of a unified context, rapid response to business scenarios is achieved. During execution, the results, verification metrics, and monitoring data produced by all nodes are written back to the unified context. Affected nodes are re-evaluated based on the updated context, and the queue of subsequent nodes to be executed is dynamically modified in real time. The local re-evaluation mechanism ensures that the process can dynamically adjust its path according to the latest business status. Based on the process pre-plan diagram, scenario-oriented autonomous optimization and intelligent evolution of the process are realized. The unified context solves the data traceability problem, deeply integrating monitoring, verification, and other aspects with the business process, enabling the process to react according to the real-time status of the system, improving the reliability of decisions. It is a general intelligent decision-making system framework that supports dynamic orchestration, real-time response, and continuous verification. Attached Figure Description

[0010] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 This is a flowchart of a scenario-oriented intelligent decision-making method according to an embodiment of this application; Figure 2 This is a schematic diagram of the architecture of an intelligent decision-making system in existing technology; Figure 3 This is a schematic diagram of an intelligent decision-making system architecture according to an embodiment of this application; Figure 4 This is a schematic diagram of a scenario-oriented intelligent decision-making device according to an embodiment of this application; Figure 5 This is a schematic diagram of the structure of an optional electronic device according to an embodiment of this application. Detailed Implementation

[0011] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.

[0012] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0013] like Figure 2 As shown, the existing intelligent decision-making system architecture uses a single application as the construction unit. This model has the following problems: 1) Fragmented / tightly coupled architecture: Each application system has built-in data, rules, models and processes. The systems only exchange data through interfaces. Cross-systems are either isolated and difficult to coordinate, or they are hard-coupled point-to-point. Changes are costly and the effects are difficult to control.

[0014] 2) Dispersed judgment criteria: Data fields, units, thresholds and versions are scattered across multiple systems, making it difficult to standardize them uniformly, and limiting consistent judgment and reuse across nodes.

[0015] 3) Insufficient scenario collaboration: When facing cross-application issues, there is a lack of unified orchestration and control based on "scenarios". It often relies on manual integration or temporary integration, which makes it difficult to reuse and evolve stably. Moreover, when users switch between multiple systems to process the same event, context loss and duplicate operations are likely to occur, resulting in low execution efficiency.

[0016] 4) Validation is disconnected from the process: Simulation, supplementary certification and optimization are mostly peripheral tools, which are difficult to verify during business execution and difficult to feed back the validation data to the main process for judgment.

[0017] Based on this, embodiments of this application provide a scenario-oriented intelligent decision-making method, such as... Figure 3 As shown, it includes an application scenario layer and a shared intelligent decision-making center.

[0018] Application Scenario Layer: Handles scenario information interaction and context, command sending and receiving, without fixing rules / models / processes. Shared Intelligent Decision-Making Center: Supports the execution and orchestration of scenario-oriented process-based contingency plans; centrally manages unified rule sets, unified model sets, unified datasets, and unified contexts; provides unified verification services (simulation / supplementary verification / manual confirmation / optimization) and feeds back results. This application models the process-based contingency plan as a directed graph, which is instantiated and advanced by the scheduler based on the unified context at runtime. Furthermore, this directed graph is reactive: when the unified context changes during runtime (from feedback information such as forms, sensors, model recalculation, and monitoring alarms), the scheduler performs a local re-evaluation of the affected edges, nodes, and protection conditions, dynamically changing the path, switching candidate versions, entering verification, or triggering compensation; irreversible facts that have already been executed are not rolled back, only subsequent paths are adjusted. This transforms real-time environmental changes into controllable process autonomy. This solution achieves: Scene-level collaboration and unified experience: Set up scene orchestration tools, and use them to draw, edit or dynamically adjust the pre-plan diagrams of the target scene according to preset rules. Through the "pre-plan execution and scene orchestration unit", the central hub promotes the unified progress within a scene link, keeping the entry point lightweight and single, eliminating the need for users to switch between multiple systems.

[0019] Consistent Judgment Standards: Using a "unified dataset + unified context" to ensure consistent input and output standards for rules / models, guaranteeing consistent conclusions across systems.

[0020] Verification integrated into the main business chain: Simulation / re-certification / manual confirmation are incorporated into the main process, automatically triggered at key nodes and fed back to indicators for further judgment.

[0021] Advantages of system-level software architecture: centralized governance and reuse of capabilities, full-link traceability and auditing based on a unified context, reduced scope of transformation and improved delivery efficiency.

[0022] The following is a detailed description of the scenario-oriented intelligent decision-making method according to embodiments of this application, with reference to the accompanying drawings. Figure 1 As shown, the method mainly includes the following steps: Based on the input target business scenario information, S101 loads the corresponding contingency plan diagram for instantiation and creates the initial unified context corresponding to the contingency plan instance.

[0023] In one implementation, the system receives request information for the target business scenario and original context information input by the user.

[0024] The intelligent decision-making center receives submissions from the application layer scenario entry point. .in, This refers to the business intent and scenario determined by user input or automatic system judgment, which guides the central system in selecting contingency plans. Based on the target scenario information input by the user, the corresponding process-oriented contingency plan is determined. Context increment, or raw context information, is used to bring in known information from the scene as initial material for subsequent arrangement.

[0025] Furthermore, relevant sensors or external data sources are scheduled as needed to complete the original context information, and data normalization processing is performed based on a preset unified data dictionary.

[0026] Specifically, the intelligent decision-making center first schedules relevant sensors or external data sources as needed. Complete the content and record it as .like If the minimum required set for the scenario or contingency plan is not met, then generate and distribute the necessary data. Supplementary sampling will be conducted.

[0027] Furthermore, based on the unified data dictionary right Perform caliber alignment and verification to generate an initial context slice, denoted as: ; The process refers to the unified data dictionary. Defined field names and scope, Externally submitted data Standardization to conform A ready-to-use initial context slice for caliber constraints This process includes, but is not limited to: information extraction and field validation / filtering, unit alignment and necessary conversion, value range and type checking, and security and desensitization processing.

[0028] This application provides a unified data dictionary. The specification defines the name, unit, value range, version, and other information for each field.

[0029] ; in, It is a unique identifier for the field name; The basic data types of the fields are defined (string / number / boolean / date / ...). The standard unit of measurement for the field is defined; The value range, enumeration set, and interval of the field are defined; It is a description of the field; s is the version of the field.

[0030] Furthermore, based on the standardized unified context information, an initial unified context corresponding to the contingency plan instance is created. The unified context is used to record the entire execution chain data of the contingency plan instance.

[0031] Based on normalized processing Build the initial unified context .

[0032]

[0033] In this application embodiment, the unified context It records the entire execution process of the contingency plan instance, serving as the sole factual carrier for subsequent end-to-end judgments and traceability. All judgments, calculations, and verifications are read-only / write-only, ensuring consistent standards and end-to-end traceability.

[0034] Unified Context The definition is as follows:

[0035] in, It is the unique identifier of the current contingency plan instance; Refers to the current business scenario number; Input mapping refers to the mapping (field name) between the original input fields and their values ​​(key-value pairs) submitted from external systems or forms. (Value / Unit / Time / Source). Derivative mapping refers to the mapping (field name) of derived fields and values ​​(key-value pairs) calculated by nodes such as rules, calculations, and validations during the process of workflow execution. (Value / Unit / Time / Source). This is a set of constraints / flags used to express whether a certain condition is met. This is a snapshot of the rule / model / form / plan version actually used at key nodes in this example (name). Version number). It records the event sequence, including time, version, input / output summary, etc. Record instance status, such as init / running / waiting / halted / Done.

[0036] In this embodiment of the application, a consistency constraint rule is defined to achieve uniformity in the judgment criteria. The consistency constraint means that for any key-value pair mapped from the input or derived data... ,satisfy:

[0037] Consistency constraints ensure that, during the process, regardless of the fields written... still A dictionary must be used. The standard unit is specified, and the value falls within the legal value range, thereby achieving "comparability and reusability" across systems and nodes.

[0038] By standardizing the definition of all fields through a unified data dictionary, constraining their names, units, value ranges, and versions, a foundation for consistent judgment is established. Furthermore, relying on a unified context as the sole fact carrier at runtime, it centrally carries information such as input data, derived indicators, constraint flags, and version snapshots. This ensures that throughout the entire execution process of a business instance, each node performs judgments and calculations based on the same set of standardized, traceable data. This completely eliminates data ambiguity and comparison barriers across systems and nodes, achieving high credibility and global reproducibility of business decisions under consistent standards.

[0039] Furthermore, based on the input target business scenario information, the corresponding contingency plan diagram is loaded and instantiated.

[0040] Specifically, based on the target business scenario information, the corresponding contingency plan diagram is loaded from the contingency plan library; a running instance is created based on the contingency plan diagram, and candidate artifacts are added for each pluggable node in the contingency plan diagram; corresponding security protection conditions are added for each preset key node in the contingency plan diagram; the node roles in the contingency plan diagram are bound to the corresponding users, and global constraints and version snapshot information are written into the unified context.

[0041] In one implementation, upon receiving a business scenario request, the system first determines the scenario identifier. Match the corresponding contingency plan diagram from the contingency plan database. The template is used to create independent process execution instances, while the instance state is initialized to... .

[0042] The following key operations are performed during instantiation: For all nodes in the schematic diagram that depend on external artifacts, their location identifiers are used. (Note: In this embodiment,) The node is not bound to a specific event, but rather to a location. To decouple business logic from code implementation (detailed below), the specific artifact identifier and version are calculated from the candidate set by combining real-time health, business tag matching degree, and priority strategy. And complete the binding, thereby decoupling the business logic from the specific implementation.

[0043] Furthermore, the predefined key node protection conditions in the template will be... Instantiate to the current instance and configure confidence thresholds, constraint sets, and other release rules for the core decision points.

[0044] Furthermore, the roles defined in the process nodes are bound to specific executing users or organizations, and the global business constraints of the contingency plan are written into the unified context of the instance. This ensures that permissions and rules take effect during this execution.

[0045] Finally, the complete configuration information, such as the version of the pre-plan diagram, the version of the rules and models selected for each node, and the version of the form, is recorded in the instance's version snapshot set to form an immutable version fingerprint, providing a reliable basis for full-process auditing and backtracking.

[0046] Through the standardized instantiation process described above, each process instance is ensured to have an independent, well-configured, and fully traceable runtime environment. The instantiation process is a configuration process from "abstract" to "concrete." Through a series of operations such as materialization, assembly, binding, and recording, it transforms a static, reusable template into a concrete, implementable process instance.

[0047] in, A complete process-oriented "plan diagram" is defined, which serves to be instantiated and executed by the scheduler at runtime.

[0048]

[0049] in, It is the set of nodes in a graph, containing the complete set of nodes for all process steps. In this application, it is defined as follows: There are 6 types of nodes, as shown in the table below:

[0050] in, To unify the data dictionary The set of all field names in the document, and their corresponding values ​​must conform to the following rules. Defined unit and range constraints.

[0051] The set of field names required for the task node to run; these fields are either already present in the unified context when the node starts. If there are values, either they need to be collected / completed first. Furthermore, in... During instantiation and execution, the scheduler checks upon arrival at the node. If the form contains values ​​for these fields, and if they are missing, the user will typically be redirected to a form node. Go to collect additional data, or call the output of the upstream calculation / rule node, and then come back to execute it.

[0052] This defines a set of field names that need to be refreshed after a node finishes execution. After the node finishes execution, the values ​​of these fields will be written back to the derived area of ​​the context. This indicates that the task has no structured output.

[0053] This is the set of field names that the compute node needs to read. These fields must already exist in the unified context before execution. (Or complete the form / upstream steps first).

[0054] This is the set of field names that the compute node will write back, which is then written to the context after execution. The derived area.

[0055] The confidence level is calculated; a higher value indicates a more reliable result (the source can be model probability, rating mapping, or in-service evaluation).

[0056] Points to a certain verification template ( It declares what inputs and output metrics this type of validation requires, and its formal definition is as follows: ; in, This refers to the set of fields that need to be read from the unified context for this verification. To ensure validation is successful, validation metrics such as upper bound of the prediction interval, queue length estimation, and missing value score are written back to the unified context. (Optional):

[0057] Runtime constraints, (as defined below) is a current context A Boolean predicate that can be evaluated triggers a verification node when it is satisfied. Its formal definition is:

[0058] Point to a form This is used to precisely define which fields need to be collected for this node, which are required, what the type / unit / value range is, and how to validate and display them.

[0059]

[0060] in, The set of fields that the form needs to collect is defined, and each field needs to come from a unified data dictionary. Ensure that the units and value ranges are consistent. A set of validation rules (required / type / range / unit consistency, etc.) is defined; RenderHints defines optional rendering hints (control type, placeholder, grouping, description, etc.); and ReleaseState defines an optional release state, facilitating "trial → official → rollback". In short, The rules / model input dependencies can be dynamically updated and released in a controlled manner to ensure that the input and the decision criteria are linked and consistent.

[0061] for node, The set of indicators to be monitored; For time windows; For alarm determination rules, there are nodes. Definition:

[0062] It is a set of directed edges in a graph, each edge carrying a condition. ,have: ; in, For a set of predicates that can be evaluated based on context, As the unique start / end node of the contingency plan diagram, there are , and Furthermore, in directed graphs... middle, In-degree is 0. The out-degree is 0.

[0063] In one alternative implementation, the nodes of the schematic diagram are not bound to a specific implementation, but rather to a location ( ). Defined The mapping table (dictionary) for all sites is as follows: ; in, It is a unique identifier for the site, corresponding to a specific "pluggable implementation" location in the flowchart. It is the set of candidate sites that can be selected. It is a globally unique identifier for a workpiece, which includes rules, models, strategies, etc. invoked externally. It is the version number of the workpiece; A health / availability score for the artifact is defined for rolling back and blocking unhealthy versions; The tags or constraints used by the artifact are defined, such as scope of application, release stage, resources and dependencies, priority, etc.

[0064] exist In the node definition, nodes that require external artifacts (compute nodes, rule nodes, etc.) need to explicitly include fields. When the above nodes are reached, the scheduler will... get And select one from them based on runtime policies (health, tag / scenario matching, release stage, priority, etc.). The workpiece is invoked and executed.

[0065] Should The plug-and-play mechanism decouples node function definitions from their specific implementation versions, giving the system a high degree of manageability and flexibility. Specifically, it supports version canary releases and rapid rollback in case of failures based on health and tag policies; it can select the appropriate version by tenant, region, and scenario to meet the adaptation needs of multiple scenarios; it ensures version stickiness during the runtime of a single instance, ensuring consistency of long-link decisions, and supports performance evaluation through A / B testing or background parallel running; all version switching and path adjustments are performed while retaining the executed actions and are fully recorded in the audit log, ultimately enabling business capabilities to continuously and agilely evolve under the premise of security, controllability, and observability.

[0066] The S102 scheduler determines the queue of ready nodes in the plan instance based on the plan diagram and the initial unified context.

[0067] After creating the running instance, path advancement is performed. This application embodiment provides an event-driven worklist as a scheduler. Ready nodes in the plan instance can be determined; a ready node refers to a node awaiting execution.

[0068] The scheduler advances in two ways. One is the conventional approach, which advances nodes in the PlanGraph instance that meet the conditions in a hierarchical manner, which can be seen as a breadth-first approach to advancing the currently reachable subgraph. The other approach is when a unified context increment arrives, the system only performs a local re-evaluation on the hit edges and nodes, adds or removes nodes from the ready queue accordingly, and continues advancing, thus achieving reactive operation in response to environmental changes.

[0069] Specifically, after a node finishes execution, the conventional advancement method includes: after the current node finishes execution, the scheduler will traverse each of its outgoing edges, obtain its preset judgment conditions, calculate the judgment conditions based on the unified context, and if the conditions are met, add the node pointed to by this edge to the ready node queue.

[0070] Alternatively, when the current node is a rule node, the scheduler first checks whether its output contains a branch selection identifier. If a branch selection identifier exists, it searches for edges in the outgoing edges whose condition fields match the branch selection identifier, and adds the node pointed to by the matching edge to the ready node queue. If the rule node returns a branch result, it prioritizes matching the corresponding branch; otherwise, it proceeds according to the edge conditions.

[0071] S103 executes the process plan based on the ready node queue and writes the execution results, verification results, and monitoring results during the execution period back into the unified context.

[0072] During the process of advancing based on the ready node queue, the current node is executed. This stage involves the unified data dictionary. and unified context The following completes the closed loop of execution → write-back → route selection → guardian judgment.

[0073] When the current node is a compute node, the corresponding candidate artifact is invoked to perform the computation, obtaining the computation result and confidence level. This is based on the compute node's... The scheduler from Selected workpiece Execution. Based on. The scheduler invokes an external implementation of the rule or model and outputs the calculation results. ,in As a result, This represents the confidence level used in this calculation. Write later Record information such as the confidence level and version used in this execution for record keeping and auditing purposes.

[0074] Understandably, when the current node is a form node, human-computer interaction is performed based on the form node to obtain the interactive form; when the current node is a task node, business actions are performed based on the task node to obtain the business execution result; when the current node is a rule node, logical rules are executed based on the rule node and branch selection is output to obtain the rule judgment result.

[0075] Finally, the calculation results, confidence scores, forms, business execution results, rule determination results, and other information after node execution are written back to the unified context.

[0076] In one embodiment of this application, target business scenario information can be received through the application layer, which can be a front-end web page, a mobile APP, etc. In the application layer used to receive scenario requirement information and interactions, a large model can be accessed. The large model parses the obtained target scenario input information and outputs content in a preset format. For example, when a certain form node corresponds to a task in the target business scenario, dialogue, voice, and forms can all serve as input and output carriers for the large model.

[0077] In one embodiment of this application, the large model can be an LLM. On the one hand, the large model can interface with the application layer, the unified context and task instructions, without having to intervene in the internal rules and processes of each system. On the other hand, the large model can also interface with an intelligent decision-making center for dynamically orchestrating process plans, managing unified rule sets, unified model sets, unified datasets, unified contexts, etc. The large model maps the task execution results and task execution node sequences of the application scenario layer to the process plan and executes them in a controlled manner, thus giving full play to generative capabilities while maintaining consistency and controllable risks.

[0078] In one implementation, execution is performed based on a ready node queue to obtain execution results; a node-preset monitor is used to monitor the execution results; when the execution results are within a preset abnormal range, an early warning is triggered; local re-evaluation is performed on the edges and nodes affected by the early warning; and the subsequent ready node queue is determined and executed based on the evaluation results.

[0079] In this embodiment, a monitor is set up at each node. The monitor's operation mechanism includes four core steps: First, the indicators are configured, specifying the set of KPIs that the monitoring node needs to monitor, the statistical time window, and the alarm strategy. Then, real-time aggregation calculations are performed based on the data within the window to determine whether an early warning is triggered, and anomaly or recovery events and status flags are generated according to the alarm strategy.

[0080] The monitoring results are then persisted to a unified context constraint set in the form of constraint identifiers, and detailed alarm events are recorded for auditing. Finally, dynamic switching of process paths is triggered by changes in constraint status. When an alarm event occurs, the verification in-loop or rollback strategy is automatically activated, forming a closed-loop control from indicator monitoring to process self-optimization, enabling the system to have autonomous decision-making and fault tolerance capabilities based on runtime status.

[0081] This also includes making a release decision when the current node is a preset critical node. A critical node refers to a core link in the business process that undertakes high-risk decisions or triggers irreversible operations, such as final credit approval in the financial sector or the issuance of automatic shutdown commands in industrial scenarios. The necessity of making a release decision for such nodes lies in the fact that the completion of the preceding processes alone is insufficient to guarantee the reliability of the decision; the overall confidence level of the decision-making chain must be quantitatively assessed and compared with preset safeguard conditions (such as minimum confidence thresholds and necessary constraint states). Only decisions that meet the reliability requirements are allowed to proceed to the execution stage; otherwise, they will automatically enter the verification or manual confirmation process. This mechanism effectively prevents business risks that may arise from forcibly pushing through automated decisions when data uncertainty is high or the evidence chain is weak, achieving a balance between process efficiency and operational security.

[0082] Specifically, the confidence scores of nodes involved in the decision-making process on the preceding links of the current node are aggregated to obtain the total confidence score of the key node.

[0083] Defined The set of protection conditions for key nodes is as follows:

[0084] in, Refers to the minimum confidence threshold, This refers to the set of essential constraints (such as complete data, no alarms, etc.). Refers to the lower limit of KPI (which can be a single value or a vector / rule).

[0085] In this application, critical nodes refer to nodes that make high-cost or high-risk decisions. To improve the reliability of the release decision, this invention assesses the confidence level of the steps involved in the decision-making process in the preceding links. Aggregation is used as a measure of control over key nodes.

[0086] Set key nodes The set of confidence scores for preceding nodes in the decision-making chain is Then The aggregate is the total power, which can be calculated using the following three methods:

[0087] When the overall confidence level is greater than or equal to the confidence threshold, all necessary constraints are met, and monitoring indicators meet the standards, the key node is considered passed, and the subsequent path is executed; With nodes Preset protection conditions A comparison may be made if and only if: and All conditions are met and If the decision is made in a timely manner, the path will be allowed to proceed to the next step; otherwise, the process will proceed to the verification, rollback, or manual confirmation stage to improve the reliability of the decision.

[0088] When the total confidence level is less than the confidence threshold, the set of necessary constraints is not met, or the monitoring indicators trigger an early warning, the verification service is invoked to perform verification, the verification result is obtained, and the verification result is written back to the unified context.

[0089] In one implementation, supported by a unified data dictionary and a unified context, it is triggered in a standardized manner in three scenarios: when the overall confidence level of the decision-making chain of a key node is lower than a preset security threshold, when the business constraint flag in the unified context is determined to be unmet, or when the system explicitly detects data loss, timeout, alarm, or even manual intervention request.

[0090] This design ensures that whenever the system detects a risk to the reliability of a decision or a deviation from business rules, it automatically initiates the verification process. By writing back the results of simulation, supplementary verification, etc., and triggering a re-judgment, a self-correcting closed loop of "risk detection - verification initiation - result feedback - decision re-judgment" is constructed.

[0091] Specifically, the verification and re-evaluation process includes: the verification stage performs standardized operations based on a predefined verification template. These operations cover various modes such as data supplementation, result simulation, information supplementation via dynamic forms, data consistency verification, and optimization solutions. After execution, a structured result containing standardized output and confidence levels is generated. This result, after standardization using a data dictionary, is written back to the derived data area within a unified context, and execution metadata is recorded, thereby achieving end-to-end audit traceability.

[0092] After the write-back is completed, the system immediately re-evaluates the judgment conditions of the affected path and the key node protection rules based on the new context state, dynamically updates the ready queue and continues to advance the process, thus forming a closed-loop self-correction mechanism of "verification execution - result write-back - intelligent re-judgment" to ensure that the business process can maintain the accuracy of decision-making and the rationality of evolution in an uncertain environment.

[0093] Understandably, after the verification conclusion is generated, the system executes a differentiated path strategy based on the judgment result: if the verification passes, it returns to the main path and continues execution. If it fails, a gradual rollback mechanism is initiated according to the priority of the contingency plan, successively adopting a backup path with a conservative threshold or alternative solution, switching to a more stable version of the specific implementation at subsequent nodes, or transferring the case to manual decision-making for confirmation. The entire process strictly follows the "rollback forward" principle, maintaining the invariance of completed business actions and only dynamically adjusting unexecuted paths.

[0094] S104 performs local re-evaluation of the affected edges and nodes in the contingency plan graph based on the updated unified context, determines the subsequent ready node queue and executes it until all nodes in the contingency plan instance have been executed.

[0095] In one implementation, the affected edges and nodes in the contingency plan graph are locally re-evaluated based on the updated unified context, and the subsequent ready node queue is dynamically modified.

[0096] Based on the context listening mechanism, a unified context increment is obtained, and the affected edges and nodes in the contingency plan graph are determined based on the unified context increment. For the affected edges, the judgment conditions of the edges are re-evaluated based on the unified context increment, and the set of nodes in the subsequent ready node queue is dynamically adjusted according to the changes in the condition values.

[0097] This application uses a context listener to monitor changes in the unified context in real time and generates accurate incremental data. The scheduler implements a targeted recalculation strategy based on this incremental data: it re-evaluates the conditions of directed edges affected by data changes; when a condition value changes from false to true, the corresponding successor node is automatically activated and added to the ready queue; when a condition value changes from true to false and the target node has not yet been executed, it is removed from the ready queue. This differential state synchronization mechanism effectively avoids the overhead of full graph traversal, enabling incremental advancement and dynamic path adjustment of the business process.

[0098] For reentrant nodes, execution is re-executed and the output is updated based on a unified context increment. For computation nodes, rule nodes, and verification nodes with reentrancy, the system will automatically trigger the node to re-execute based on the latest context state when its dependent input parameters change. This process strictly follows the idempotency principle, ensuring that repeated execution does not cause side effects, and that the new output generated by each execution will safely overwrite the previous result.

[0099] For critical nodes, the pass / fail status is reassessed based on unified context increments. (This applies to critical nodes.) The system will recalculate the overall confidence level of the decision-making link composed of all its preceding nodes in real time, and compare and verify the aggregated result with the node's preset protection conditions. If the conditions are met, the process continues along the main path. When the confidence level does not meet the standard, it will automatically switch to backup handling channels such as verification and review, policy rollback, or manual confirmation.

[0100] Based on the reactive operation mechanism of this application, the affected nodes are re-evaluated based on the updated context, and the queue of subsequent nodes to be executed is dynamically modified in real time. The local re-evaluation mechanism ensures that the process can dynamically adjust the path according to the latest business status, realizing the autonomous optimization and intelligent evolution of the process.

[0101] In one implementation, the pre-plan diagram is dynamically arranged according to preset rules using a scene orchestration tool. The pre-plan diagram can be dynamically edited. Based on an updated unified context, the affected edges and nodes in the pre-plan diagram are locally re-evaluated to determine the subsequent ready node queue. The implementation also includes: if the current pre-plan diagram cannot cover the subsequent ready node sequence, then the scene orchestration tool is used to dynamically orchestrate the pre-plan diagram. The scene orchestration tool provided in this application embodiment can dynamically modify the subsequent direction of the pre-plan diagram, enabling the front-end visualization interface to accurately reflect the latest state and subsequent evolution direction of the process, allowing users to intuitively perceive the system's decision-making logic and the next action.

[0102] It also includes auditing based on unified context information. The system constructs a complete audit traceability system through the dual constraints of a unified data dictionary and context: all node execution, rule judgment, alarm events, and version switching operations are structured and recorded in the context, forming an immutable chain of execution evidence; simultaneously, the instance status is dynamically updated according to the node's progress, switching between running, waiting, interrupted, and completed states, and automatically saving the process snapshot after the final state is achieved. This mechanism ensures that key judgment criteria, decision path versions, and data transformation processes throughout the entire business lifecycle can be accurately traced back, meeting compliance audit requirements and providing complete data support for process optimization and review, ultimately achieving transparency and measurability in the operational process.

[0103] The intelligent decision-making system constructed in this application has achieved significant beneficial effects, specifically reflected in the following four aspects: Scenario-level unified collaboration and continuous experience: By centrally orchestrating and advancing processes based on "business scenarios," and by pre-building process-oriented plans corresponding to target scenarios, the fragmented collaboration model of multiple systems has been completely transformed. Front-end applications only need to provide lightweight interaction entry points, and users do not need to frequently switch between multiple independent systems when handling single business events, thus achieving a seamless and continuous experience with clear processing paths and unified operational context.

[0104] Unified judgment and closed-loop verification enhance decision robustness: A unified data dictionary standardizes data across the entire process, ensuring consistency between rule and model inputs and outputs. Innovatively, verification steps (simulation, supplementary verification, and manual confirmation) are embedded into the main workflow as standardized nodes. These steps are automatically triggered at key decision points based on confidence levels, and the verification results are fed back to the context for further judgment, forming a closed loop of "decision-verification-re-decision," significantly improving the reliability of automated decision-making in complex scenarios.

[0105] Centralized capability governance and agile business evolution: Core capabilities such as rules, models, contingency plans, and verification templates are centrally governed and reused on a platform. It supports canary releases, rolling upgrades, and smooth rollbacks of capabilities, and is compatible with the migration of running instances. When front-end business requirements change, only the central processes and rules need to be adjusted, with minimal invasiveness to existing systems, enabling rapid business iteration and low-cost delivery.

[0106] End-to-end evidence retention and compliance support: The system automatically accumulates complete audit information for each node, including the version of the rules / models used, input / output snapshots, verification conclusions, etc., forming a consistent and tamper-proof chain of evidence across systems. This not only meets stringent compliance and audit requirements but also provides a high-quality data foundation for business review and knowledge accumulation.

[0107] According to another aspect of the embodiments of this application, a scenario-oriented intelligent decision-making apparatus for implementing the above-described scenario-oriented intelligent decision-making method is also provided. For example... Figure 4 As shown, the device includes: The contingency plan instantiation module 401 is used to load the corresponding contingency plan diagram for instantiation based on the input target business scenario information and create the initial unified context corresponding to the contingency plan instance. Execution module 402 is used by the scheduler to determine the queue of ready nodes in the plan instance based on the plan diagram and the initial unified context; The result write-back module 403 is used to write back the execution results, verification results, and monitoring results during the execution process to a unified context based on the ready node queue. The dynamic correction module 404 is used to perform local re-evaluation of the affected edges and nodes in the contingency plan graph based on the updated unified context, determine the subsequent ready node queue and execute it, until the nodes in the contingency plan instance have been executed.

[0108] It should be noted that the scenario-oriented intelligent decision-making device provided in the above embodiments is only illustrated by the division of the above functional modules when executing the scenario-oriented intelligent decision-making method. In practical applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above. In addition, the scenario-oriented intelligent decision-making device and the scenario-oriented intelligent decision-making method embodiments provided in the above embodiments belong to the same concept, and the implementation process is detailed in the method embodiments, which will not be repeated here.

[0109] According to another aspect of the embodiments of this application, an electronic device corresponding to the scenario-oriented intelligent decision-making method provided in the foregoing embodiments is also provided, so as to execute the scenario-oriented intelligent decision-making method described above.

[0110] Please refer to Figure 5 This illustrates a schematic diagram of an electronic device provided by some embodiments of this application. For example... Figure 5 As shown, the electronic device includes: a processor 500, a memory 501, a bus 502, and a communication interface 503. The processor 500, the communication interface 503, and the memory 501 are connected via the bus 502. The memory 501 stores a computer program that can run on the processor 500. When the processor 500 runs the computer program, it executes the scenario-oriented intelligent decision-making method provided in any of the foregoing embodiments of this application.

[0111] The memory 501 may include high-speed random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Communication between this system network element and at least one other network element is achieved through at least one communication interface 503 (which can be wired or wireless), such as the Internet, wide area network, local area network, or metropolitan area network.

[0112] Bus 502 can be an ISA bus, PCI bus, or EISA bus, etc. Buses can be divided into address buses, data buses, control buses, etc. Memory 501 is used to store programs. After receiving execution instructions, processor 500 executes the programs. The scenario-oriented intelligent decision-making method disclosed in any of the aforementioned embodiments of this application can be applied to processor 500, or implemented by processor 500.

[0113] The processor 500 may be an integrated circuit chip with signal processing capabilities. In implementation, each step of the above method can be completed by the integrated logic circuitry in the hardware of the processor 500 or by instructions in software form. The processor 500 may be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc.; it may also be a digital signal processor (DSP), an application-specific integrated circuit (ASIC), an off-the-shelf programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this application. The general-purpose processor may be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this application can be directly embodied in the execution of a hardware decoding processor, or executed by a combination of hardware and software modules in the decoding processor. The software modules may reside in random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, or other mature storage media in the art. The storage medium is located in memory 501. The processor 500 reads the information in memory 501 and, in conjunction with its hardware, completes the steps of the above method.

[0114] The electronic device provided in this application embodiment and the scenario-oriented intelligent decision-making method provided in this application embodiment are based on the same inventive concept and have the same beneficial effects as the methods they adopt, operate or implement.

[0115] According to another aspect of the embodiments of this application, a computer-readable storage medium corresponding to the scenario-oriented intelligent decision-making method provided in the foregoing embodiments is also provided, wherein a computer program (i.e., a program product) is stored thereon, and when the computer program is run by a processor, it executes the scenario-oriented intelligent decision-making method provided in any of the foregoing embodiments.

[0116] It should be noted that examples of computer-readable storage media may also include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other optical and magnetic storage media, which will not be elaborated here.

[0117] The computer-readable storage medium provided in the above embodiments of this application and the scenario-oriented intelligent decision-making method provided in the embodiments of this application are based on the same inventive concept and have the same beneficial effects as the methods adopted, run or implemented by the applications stored therein.

[0118] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0119] The above embodiments merely illustrate several implementation methods of the present invention, and their descriptions are relatively specific and detailed, but they should not be construed as limiting the scope of the present invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention. Therefore, the protection scope of this patent should be determined by the appended claims.

Claims

1. A scenario-oriented intelligent decision-making method, characterized in that, include: Based on the input target business scenario information, load the corresponding contingency plan diagram for instantiation and create the initial unified context corresponding to the contingency plan instance. The scheduler determines the ready node queue in the plan instance based on the plan diagram and the initial unified context; Based on the pre-execution process plan of the ready node queue, the execution results, verification results, and monitoring results during the execution period are written back to the unified context; Based on the updated unified context, the affected edges and nodes in the contingency plan graph are locally re-evaluated, the subsequent ready node queue is determined and executed, until all nodes in the contingency plan instance have been executed.

2. The method according to claim 1, characterized in that, Based on the pre-defined execution flow plan for the ready node queue, the following are included: Execution is performed based on the ready node queue to obtain the execution result; The execution results are monitored using a pre-set monitor for each node; When the execution result is within a preset abnormal range, an early warning is triggered. The edges and nodes affected by the early warning are locally re-evaluated, and the subsequent ready node queue is determined and executed based on the evaluation results.

3. The method according to claim 1, characterized in that, Based on the input target business scenario information, the corresponding contingency plan diagram is loaded and instantiated, including: Based on the target business scenario information, load the corresponding contingency plan diagram from the contingency plan library; Based on the aforementioned plan diagram, a running instance is created, and candidate workpieces are added to each pluggable node in the plan diagram; corresponding safety protection conditions are added to each preset key node in the plan diagram. The node roles in the proposed plan diagram are bound to the corresponding users, and global constraints and version snapshot information are written into the unified context.

4. The method according to claim 1, characterized in that, Create the initial unified context corresponding to the contingency plan instance, including: Receive user input of request information for the target business scenario and original context information; The system will schedule relevant sensors or external data sources as needed to complete the original context information and perform data normalization processing based on a preset unified data dictionary. Based on the standardized unified context information, an initial unified context corresponding to the contingency plan instance is created. The unified context is used to record the entire execution chain data of the contingency plan instance.

5. The method according to claim 1, characterized in that, Based on the contingency plan diagram and the initial unified context, the scheduler determines the ready node queue in the contingency plan instance, including: After the current node finishes execution, the scheduler will traverse each of its outgoing edges, obtain its preset judgment conditions, calculate the judgment conditions based on the unified context, and if the conditions are met, add the node pointed to by this edge to the ready node queue.

6. The method according to claim 1, characterized in that, Based on the pre-defined execution process plan for the ready node queue, the execution results, verification results, and monitoring results during execution are written back to the unified context, including: When the current node is a computation node, the corresponding candidate artifact of the node is invoked to perform the computation, and the computation result and confidence score are obtained. When the current node is a form node, human-computer interaction is performed based on the form node to obtain an interactive form; When the current node is a task node, business actions are executed based on the task node to obtain business execution results; When the current node is a rule node, the logical rules are executed based on the rule node and the branch selection is output to obtain the rule determination result; The calculation results, confidence scores, forms, business execution results, and rule determination results after the node execution are written back to the unified context.

7. The method according to claim 1 or 6, characterized in that, Based on the pre-defined execution process plan for the ready node queue, the execution results, verification results, and monitoring results during execution are written back to the unified context, including: When the current node is a preset key node, the confidence of the nodes involved in the decision on the preceding links of the current node is aggregated to obtain the total confidence of the key node; When the total confidence level is greater than or equal to the confidence threshold, all necessary constraints are met, and the monitoring indicators meet the standards, the key node is determined to have passed, and the subsequent path is executed. When the total confidence level is less than the confidence threshold, the essential constraint set is not met, or the monitoring indicator triggers an early warning, the verification service is invoked to perform verification, the verification result is obtained, and the verification result is written back to the unified context.

8. The method according to claim 1, characterized in that, Based on the updated unified context, the affected edges and nodes in the contingency plan graph are locally re-evaluated to determine the subsequent ready node queue and execute it, including: Based on the context listening mechanism, a unified context increment is obtained, and the affected edges and nodes in the contingency plan graph are determined based on the unified context increment. For the affected edges, the judgment conditions of the edges are re-evaluated based on the unified context increment, and the set of nodes in the subsequent ready node queue is dynamically adjusted according to the change of the condition value. For reentrant nodes, the execution is re-executed and the output is updated based on the unified context increment; For critical nodes, the pass / fail status of the critical node is reassessed based on the unified context increment.

9. The method according to claim 1 or 8, characterized in that, The preliminary plan diagram was generated using a scene arrangement tool according to preset rules. The step of locally re-evaluating the affected edges and nodes in the contingency plan graph based on the updated unified context to determine the subsequent ready node queue also includes: If the current plan diagram cannot cover the subsequent ready node sequence, the scenario arrangement tool is used to dynamically arrange the plan diagram.

10. A scenario-oriented intelligent decision-making device, characterized in that, include: The contingency plan instantiation module is used to load the corresponding contingency plan diagram for instantiation based on the input target business scenario information, and create the initial unified context corresponding to the contingency plan instance. An execution module is used by the scheduler to determine the queue of ready nodes in the plan instance based on the plan diagram and the initial unified context; The result write-back module is used to write back the execution results, verification results, and monitoring results during the execution period to the unified context based on the execution process plan of the ready node queue. The dynamic correction module is used to perform local re-evaluation of the affected edges and nodes in the contingency plan graph based on the updated unified context, determine the subsequent ready node queue and execute it, until the nodes in the contingency plan instance have been executed.

11. An electronic device, characterized in that, It includes a processor and a memory storing program instructions, the processor being configured to execute, when executing the program instructions, perform the scenario-oriented intelligent decision-making method as described in any one of claims 1 to 9.

12. A computer-readable medium, characterized in that, It stores computer-readable instructions that are executed by a processor to implement a scenario-oriented intelligent decision-making method as described in any one of claims 1 to 9.

Images