A simulation agent construction method and device based on a six-element hierarchical architecture and a medium

Abstract

The application discloses a simulation intelligent agent construction method and device based on a six-element hierarchical architecture and a medium, relates to the field of computer simulation, and comprises the following steps: dividing modeling data of a simulation intelligent agent into six elements including attributes, capabilities, rules, processes, activities and state machines; configuring parameter configuration data (attributes, capabilities and rules) in the form of a visual configuration interface and a parameter configuration file into a quick layer; configuring program logic data (processes, activities and state machines) in the form of executable program codes and configuration files into a mechanism layer; reserving a standardized parameter interface in the mechanism layer; injecting the parameter configuration data in the quick layer into the mechanism layer through the standardized parameter interface, driving the activities in the mechanism layer to perform performance calculation and the state machines to perform state conversion, and completing instantiation and simulation deduction of the simulation intelligent agent. The application can improve the operation stability of a simulation system, the verifiability of simulation results and the reuse efficiency of a model in different scenarios.

Description

Technical Field

[0001] This application relates to the field of computer simulation, and in particular to a method, device and medium for constructing a simulated intelligent agent based on a six-element hierarchical architecture. Background Technology

[0002] With the integration of computer simulation technology and artificial intelligence technology, agent-based modeling and simulation methods have been widely applied in fields such as military simulation, combat simulation, and equipment support simulation. Simulated intelligent agents use computer programs to simulate the behavior and interactions of real-world entities, constructing a computable, predictable, and evaluable digital simulation environment, providing computer-aided support for combat plan verification, equipment effectiveness evaluation, and command decision-making training.

[0003] The construction technology of simulated intelligent agents has evolved from hard-coding to parameterization: In the early days, the behavioral logic of the agent was entirely fixed in the program code. When the simulation scenario changed, the source code needed to be modified and recompiled and deployed, resulting in long system iteration cycles and high maintenance costs. As the complexity of combat scenarios increases, simulated intelligent agents need to simultaneously meet the dual requirements of rigorous behavioral logic and flexible scenario configuration.

[0004] The core technological bottleneck in the construction of intelligent agents in current computer simulation systems lies in the inability to simultaneously achieve the stability of the underlying behavioral logic and the flexibility of the upper-level scene parameters. In traditional single-layer architectures, parameters and logic are implemented in the same code layer, and parameter modifications can easily lead to accidental tampering with the program control flow, resulting in abnormal behavior; behavioral mechanisms exist implicitly in the flat code, making it impossible to explicitly map them to business procedures, resulting in insufficient verifiability of simulation results; and the reuse of similar intelligent agents across scenarios requires repeated code development, leading to high system redundancy and low deployment efficiency. Summary of the Invention

[0005] The purpose of this application is to provide a method, device and medium for constructing a simulation intelligent agent based on a six-element hierarchical architecture, which can ensure the rigor of simulation behavior logic while enabling flexible configuration of scene parameters, improving the operational stability of the simulation system, the verifiability of simulation results and the reusability of the model in different scenarios.

[0006] To achieve the above objectives, this application provides the following solution: Firstly, this application provides a method for constructing a simulated intelligent agent based on a six-element hierarchical architecture, including: The modeling data of the simulated intelligent agent is divided into six elements: attributes, capabilities, rules, processes, activities, and state machines. The attributes, capabilities, and rules are parameter configuration data; the processes, activities, and state machines are program logic data. The parameter configuration data is configured as a quick layer in the form of a visual configuration interface and a parameter configuration file; The program logic data is configured as a mechanism layer in the form of executable program code and configuration files; A standardized parameter interface is reserved in the mechanism layer; the standardized parameter interface includes an attribute parameter interface, a capability parameter interface, and a rule parameter interface. Through the standardized parameter interface, the parameter configuration data in the fast layer is injected into the mechanism layer, driving the activity execution performance calculation and state machine state transition in the mechanism layer, thus completing the instantiation and simulation deduction of the simulated intelligent agent.

[0007] Secondly, this application provides a computer device, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the above-described method for constructing a simulated intelligent agent based on a six-element hierarchical architecture.

[0008] Thirdly, this application provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the above-described method for constructing a simulated intelligent agent based on a six-element hierarchical architecture.

[0009] According to the specific embodiments provided in this application, this application has the following technical effects: (1) In this application, attributes, capabilities, and rules are configured as parameter configuration data in the fast layer, and processes, activities, and state machines are configured as program logic data in the mechanism layer. The two layers interact only through standardized parameter interfaces, thereby achieving physical isolation between parameter data and program control flow. Parameter modification only affects variables in the fast layer and does not intrude into the mechanism layer control flow code, thus ensuring the stability of simulation operation from the program architecture level. (2) This application configures the program logic data as a mechanism layer in the form of three standardized elements: process, activity, and state machine. This makes the behavioral logic of the simulated intelligent agent no longer exist implicitly in fragmented code, but forms a complete explicit mechanism chain of "task → process → activity → state machine". It can be accurately mapped with business procedures. Every behavioral decision in the simulation has a clear mechanism basis that can be traced, which improves the credibility and traceability of the simulation results. (3) This application adopts an architecture design that uses a mechanism layer to carry fixed program logic, a fast layer to carry flexible parameter configuration, and two layers to dynamically combine through standardized interfaces. This allows the same set of mechanism layer program logic to be used with multiple sets of fast layer parameter templates to generate intelligent agent instances for different scenarios, realizing a reuse mode of "one set of logic framework and multiple sets of parameter configurations". This eliminates the need for repeated code development, reduces code redundancy, shortens the scenario adaptation cycle, and improves the efficiency of system iteration and deployment. Attached Figure Description

[0010] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0011] Figure 1 A flowchart illustrating a method for constructing a simulated intelligent agent based on a six-element hierarchical architecture, provided in an embodiment of this application; Figure 2 A schematic diagram of the architecture design for a simulated intelligent agent. Detailed Implementation

[0012] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0013] To make the above-mentioned objectives, features and advantages of this application more apparent and understandable, the application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0014] In one exemplary embodiment, such as Figure 1 As shown, a method for constructing a simulated intelligent agent based on a six-element hierarchical architecture is provided. This method is executed by a computer device, specifically by a computer device such as a terminal or a server alone, or by both a terminal and a server. In this embodiment, the method is described using a server as an example, and includes the following steps S1 to S5.

[0015] S1: The modeling data of the simulated intelligent agent is divided into six elements; the six elements include attributes, capabilities, rules, processes, activities, and state machines; the attributes, capabilities, and rules are parameter configuration data; the processes, activities, and state machines are program logic data.

[0016] S2: Configure the parameter configuration data as a quick layer in the form of a visual configuration interface and a parameter configuration file.

[0017] S3: Configure the program logic data as a mechanism layer in the form of executable program code and configuration files.

[0018] S4: A standardized parameter interface is reserved in the mechanism layer; the standardized parameter interface includes an attribute parameter interface, a capability parameter interface, and a rule parameter interface.

[0019] S5: Through the standardized parameter interface, the parameter configuration data in the fast layer is injected into the mechanism layer, driving the activity execution performance calculation and state machine state transition in the mechanism layer, thus completing the instantiation and simulation deduction of the simulated intelligent agent.

[0020] By implementing steps S1 to S5 above, attributes, capabilities, and rules are configured as a rapid layer, processes, activities, and state mechanisms are constructed as a mechanistic layer, and data interaction between the two layers is achieved through a standardized parameter interface, forming a structure as follows: Figure 2 The simulated intelligent agent design architecture is shown. In this application, parameter modifications only apply to the fast layer and do not intrude into the program control flow of the mechanism layer. This ensures the rigor of the simulation behavior logic while enabling flexible configuration of scene parameters, thereby improving the operational stability of the simulation system, the verifiability of simulation results, and the model's reusability efficiency in different scenarios.

[0021] Furthermore, the computer program definition of the six elements in step S1 is as follows: (1) Attributes.

[0022] The attributes are stored in the simulation system memory as key-value pair data structures and are divided into inherent static attributes and dynamic state attributes.

[0023] Attributes are characteristic parameter variables of the simulated intelligent agent, stored in the simulation system memory as key-value pair data structures, and are divided into inherent static attributes and dynamic state attributes; they provide the basic data source for capability calculation and rule judgment; changes to attribute values ​​are only written through the quick layer configuration interface and do not directly modify the mechanism layer code.

[0024] (2) Ability.

[0025] The capabilities are stored in the form of a structure array, with each capability corresponding to a set of metrics.

[0026] A capability is a set of quantifiable parameters of the performance of the simulated intelligent agent's operations. It is stored in the form of a structure array. Each capability corresponds to a set of metrics (such as detection range, detection accuracy, and recognition probability for reconnaissance capabilities), providing a basis for performance calculation for the execution of activities.

[0027] (3) Rules.

[0028] The rules exist in the form of variables in conditional expressions.

[0029] The rule is a variable threshold variable in the decision-making logic of the simulated intelligent agent, which exists in the form of variables in the condition expression; the rule "condition-action" logic structure is fixed in the mechanism layer, and only the threshold parameter can be adjusted through the fast layer without changing the rule's judgment logic and execution path.

[0030] (4) Process.

[0031] The process is stored in the process definition file as a node-edge directed graph data structure, supporting sequential, conditional branching, parallel branching and loop control structures. The process execution engine parses and generates execution instances to schedule activities.

[0032] The process is a task-level behavior orchestration unit, stored in a node-edge directed graph data structure. At the mechanism layer, it is stored in XML format process definition files, supporting control structures such as sequential, conditional branching, parallel branching, and iterative loops. The process execution engine parses the file and generates execution instances, scheduling activities according to the defined logic. Each process corresponds to a type of simulation task, triggered by a task dispatch mechanism.

[0033] (5) Activities.

[0034] The activities are implemented as independently encapsulated program modules. Each activity module defines a standardized input parameter interface, execution logic function, and post-result output interface. The activity modules are compiled and then embedded in the mechanism layer.

[0035] An activity is the smallest executable unit simulating the behavior of an intelligent agent. It is implemented as an independently encapsulated program module (function / class). Each activity includes a standardized parameter interface, execution logic, post-result output, and defines pre-start conditions and post-state change rules. It can be reused and called by different processes. After compilation, the activity module is fixed in the mechanism layer and only reads external data through the reserved parameter interface. The internal logic cannot be modified through the fast layer.

[0036] (6) State machine.

[0037] The state machine is implemented in the form of a state table configuration file combined with state transition logic functions, and is bound to the execution hook points of the activity module. The state machine automatically triggers state verification and transition at the preset hook points of the activity execution, and writes the state transition results into shared memory and feeds them back to the process execution engine to control the branch selection of subsequent activities.

[0038] A state machine is a logical control unit for simulating the state transitions of an intelligent agent. It is implemented in the form of a state table and state transition functions, and is bound to each activity. It defines the state set, transition events, transition conditions, and transition actions, which are automatically driven by the state machine. The transition results are fed back to the process to control the selection of subsequent activity branches.

[0039] The state machine adopts topic-based management. A simulated intelligent agent can contain state machines for multiple business topics. The state table defines all legal states and transition rules. The state machine automatically triggers state verification and transition at fixed hook points during activity execution. The transition results are written to shared memory and fed back to the process.

[0040] Furthermore, the mechanism layer and the rapid layer interact with each other through three types of standardized parameter interfaces, achieving physical isolation between logic and parameters at the program architecture level. The interaction rules are as follows: (1) The fast layer depends on the mechanism layer to run: All parameters of the fast layer are only data variables and do not have execution capabilities. They must be injected into the mechanism layer through the standardized parameter interface before they can be called by the activity and state machine to participate in behavior calculation and state judgment.

[0041] (2) The mechanism layer exists independently of the fast layer: the program code, process definition, and state machine rules of the mechanism layer do not depend on any fast layer parameters; even if all fast layer parameters are cleared, the mechanism layer can still run completely based on the default parameters, and the program control flow and state transition logic are completely unaffected, ensuring the stability and reusability of the logic framework.

[0042] Furthermore, the standardized parameter interface enables decoupled interaction. The standardized parameter interface is implemented in the form of application programming interface functions. The standardized parameter interface has built-in parameter verification logic, which includes data type verification, value range verification, and business logic constraint verification. Parameter configuration data that fails verification is intercepted and does not affect the program logic of the mechanism layer, thus preventing parameter modification from disrupting the program logic from a technical perspective.

[0043] Furthermore, the parameter configuration data injection methods include initialization injection and dynamic injection. The initialization injection method involves loading parameter configuration files in batches before the simulation agent starts. The dynamic injection method involves updating individual parameter configuration data while the simulation is paused. The dynamically injected updated parameter configuration data only applies to subsequent unexecuted activities; the results of executed activities and the current state of the simulation agent remain unchanged.

[0044] Furthermore, step S2 specifically includes: S21: Receive attribute parameter data input by the user through the attribute configuration interface, perform legality verification on the attribute parameter data, and store it in the attribute parameter dataset after the verification is successful.

[0045] S22: Receive the measurement indicators of each capability input by the user through the capability configuration interface, perform legality verification on the measurement indicators, and store them into the capability parameter dataset after the verification is passed.

[0046] S23: Receive rule threshold parameter data input by the user through the rule configuration interface, perform legality verification on the rule threshold parameter data, and store it in the rule parameter dataset after the verification is successful.

[0047] S24: Establish a mapping relationship between the activity parameters and the measurement indicators, and store the mapping relationship data in the associated configuration table.

[0048] S25: Package the attribute parameter dataset, the capability parameter dataset, the rule parameter dataset, and the associated configuration table into a parameter configuration file in JSON format.

[0049] Furthermore, step S3 specifically includes: S31: Receive the arrangement operation data from the user in the process editing interface, and generate a process definition file based on the arrangement operation data; S32: Bind a corresponding activity module to each process node in the process definition file, and configure the type data, pre-start condition data, execution logic entry data and post-result output rule data of the activity module; S33: Bind a corresponding state machine to each activity module, define state set data, transition event data, transition condition data and transition action data, and generate a state table configuration file; S34: Scan the variable data in the activity module and the state machine, identify and mark configurable parameters, and generate corresponding standardized parameter interfaces and parameter verification logic based on the configurable parameters.

[0050] Furthermore, a parameter mapping association mechanism is established between the fast layer and the mechanism layer; the parameter mapping association mechanism is a mapping relationship between activity parameters and metrics, where activity parameter = metric × transformation coefficient.

[0051] The simulation intelligent agent construction method based on a six-element hierarchical architecture provided in this embodiment is executed by the computer system in three stages: Phase 1: Mechanism layer construction phase.

[0052] (1) Create an intelligent agent model framework.

[0053] The computer system receives the model name, type, and description information input by the user, creates model metadata records in the system database, initializes the configuration containers for the mechanism layer and the rapid layer, and provides a basic framework for subsequent element definition.

[0054] (2) Define the process structure.

[0055] The computer system receives drag-and-drop arrangement operations from the user in the workflow editing interface and automatically generates standardized workflow definition files: 1) Establish a process list, with each process bound to a corresponding simulation task subject; 2) Arrange activity nodes and logical nodes in the flowchart canvas, and set the execution order and branch conditions between nodes; 3) Automatically verify the integrity of the process logic (no infinite loops, no isolated nodes), and generate an XML format process definition file after the verification is successful.

[0056] (3) Define the activity module.

[0057] The computer system binds a corresponding activity module to each process node, configures the activity type (mobility, reconnaissance, shooting, communication, etc.), pre-start conditions, execution logic entry point, and post-output rules, and completes the association between activities and processes.

[0058] (4) Bind state machine logic.

[0059] The computer system binds a state machine corresponding to a topic to each active node: 1) Define the state machine topic, create a state table, and enter all valid states and their descriptions; 2) Configure the transition events, transition conditions, and transition actions for each state; 3) After the state machine is configured, a state table configuration file is generated and bound to the hook points of the activity execution to ensure that the state check is automatically triggered when the activity is executed.

[0060] (5) Mark configurable parameters and generate interfaces.

[0061] The computer system scans variables in the activity module and state machine logic, identifies and marks configurable parameters, and automatically generates corresponding standardized parameter interfaces and parameter validation logic. 1) Set the data type, value range, and default value for each configurable parameter; 2) Generate corresponding attribute / ability / rule interface functions and establish a mapping relationship between parameters and interfaces; 3) Built-in parameter validation logic ensures that all injected parameters are within the legal range.

[0062] Phase Two: Rapid Layer Configuration Phase.

[0063] (1) Configure attribute parameters.

[0064] The computer system receives the initial values ​​of static and dynamic attributes input by the user in the attribute configuration interface, automatically calls the validation logic to verify the validity of the parameters, and stores them in the attribute parameter dataset after the validation is successful.

[0065] (2) Configuration capability parameters.

[0066] The computer system receives the measurement indicators of each capability input by the user in the capability configuration interface, automatically calculates the linkage relationship of parameters and previews the effect of performance in real time, performs legality verification, and stores the capability parameter dataset after the verification is passed.

[0067] (3) Configure rule parameters.

[0068] The computer system receives the rule threshold parameters adjusted by the user in the rule configuration interface, modifies only the variable values ​​without changing the rule logic structure, performs a validity check on the rule threshold parameter data, and stores it in the rule parameter dataset after the check passes.

[0069] (4) Establish parameter mapping association.

[0070] The computer system receives the user's association operation in the parameter association interface, establishes the mapping relationship between activity parameters and metrics, supports setting transformation coefficients to realize unit conversion (activity parameter = metric × transformation coefficient), and stores the mapping relationship in the association configuration table.

[0071] (5) Generate and save parameter templates.

[0072] The computer system packages all configured parameters and mapping relationships into a JSON-formatted parameter template file, which supports naming, version management, and batch import / export, and can be directly loaded and reused in different simulation scenarios.

[0073] Phase 3: Instantiation and Run Phase.

[0074] (1) Create a behavior execution framework.

[0075] The simulation engine loads the process definition files, activity modules, and state machine configuration files of the mechanism layer, and creates a parameterless intelligent agent behavior framework in the runtime memory, which includes complete process control logic, activity call chains, and state transition paths.

[0076] (2) Initialization parameter injection.

[0077] The simulation engine loads the parameter template file of the fast layer and injects the parameter configuration data into the behavior framework in batches through three types of standardized parameter interfaces. After the injection is completed, the simulation agent is instantiated and has complete simulation execution capabilities.

[0078] (3) Simulation operation and status linkage.

[0079] The simulation engine schedules activities according to the process defined in the mechanism layer: when an activity is executed, it reads parameters from the fast layer through a standardized parameter interface to complete the performance calculation; the state machine engine automatically triggers state transitions at the hook points of activity execution, and the transition results are fed back to the process engine to control the selection of subsequent activity branches. The entire process is executed automatically without manual intervention.

[0080] (4) Dynamic parameter hot update.

[0081] When the simulation is paused, the computer system receives the parameter values ​​modified by the user, and after the validity is verified, it is re-injected into the mechanism layer through the standardized parameter interface. The new parameters only take effect on subsequent activities, and the results and states of the already executed activities remain unchanged, ensuring the consistency and traceability of the simulation process.

[0082] The following example, "Simulation Intelligent Agent of Land Equipment Support Unit," fully illustrates the specific implementation of this solution: 1. Quick layer parameter configuration.

[0083] (1) Attributes: Entity ID=GUARANTEE-001, maximum trip=500km, number of members=8 people, initial position=(116.3,39.9).

[0084] (2) Capabilities: Emergency repair capability = (Emergency repair distance 50km, single equipment emergency repair time 30min, emergency repair success rate 95%), Resupply capability = (Resupply load 20t, resupply speed 5t / h).

[0085] (3) Rules: Damage rate ≥ 30% triggers emergency repair process, fuel balance ≤ 20% triggers refueling process.

[0086] 2. Mechanism layer logic definition.

[0087] (1) Process: Define three main processes: routine support, emergency repair, and emergency supply. Each process consists of multiple activity nodes arranged in sequence and branch structure.

[0088] (2) Activities: Includes five atomic activity modules: maneuver, fault detection, equipment repair, material supply, and status reporting. Each module is compiled and fixed, and parameter interfaces are reserved.

[0089] (3) State machine: Binds the task state theme, including five states: standby, maneuver, operation, rest and failure. Defines the state transition rules triggered by each activity, such as when performing equipment repair activities, the state changes from maneuver to operation.

[0090] 3. Complete execution process When the simulation starts, the parameter template is injected into the mechanism layer, and the simulation agent is initially in standby mode. After receiving the support task, the routine support process is triggered, the maneuver activity is executed, the maneuver capability parameters are read to calculate the travel time, and the state is changed to maneuver. After arriving at the task point, the fault detection activity is executed, the detection capability parameters are read to calculate the detection results. If the damage rate is detected to be ≥30%, the branch jump to the emergency repair process is triggered, the equipment repair activity is executed, and the state is changed to operation. After the activity is completed, the state is changed to rest, and the process ends.

[0091] When the simulation is paused, the repair success rate parameter can be modified to 90%. After verification, it is injected into the system, and subsequent repair activities are executed according to the new parameter. The completed detection and maneuver results are not affected.

[0092] The beneficial effects of the technical solution in this application are as follows: (1) Implement physical isolation between parameters and logic at the architecture level to improve system stability.

[0093] Through a layered design of the mechanism layer and the fast layer, parameter modifications only affect the data variables in the fast layer and do not intrude into the program control flow of the mechanism layer. Combined with a parameter validity verification mechanism, this fundamentally avoids abnormal program behavior caused by parameter adjustments. Testing has shown that the simulation behavior anomaly rate caused by parameter modifications is reduced by more than 90%, non-developers can independently complete the safety configuration, and the system's operational stability is significantly improved.

[0094] (2) Construct explicit behavioral mechanism chains to improve the credibility and verifiability of simulation.

[0095] Through the standardized orchestration of "task → process → activity → state machine" at the mechanism layer, a complete and traceable behavioral mechanism chain is formed, which can be correlated layer by layer with operational doctrine and business procedures. All behavioral decisions during the simulation process have clear mechanistic basis, supporting expert review and result debriefing, and significantly improving the interpretability and credibility of the simulation results.

[0096] (3) Achieve decoupling and reuse of logic and parameters, reduce system redundancy and improve deployment efficiency.

[0097] Once the mechanism layer program logic is developed once, intelligent agent instances for different scenarios can be quickly generated using multiple sets of rapid layer parameter templates, eliminating the need for repetitive code development. Scenario adaptation time is reduced from the traditional 4 hours to 20 minutes, code redundancy is reduced by more than 70%, and the iterative deployment efficiency of the simulation system is significantly improved.

[0098] (4) Supports dynamic hot updating of parameters, improving the flexibility of simulation and deduction.

[0099] Through a paused-state parameter dynamic injection mechanism, parameter adjustments can be completed and state consistency ensured without stopping the simulation engine or recompiling the program. It supports complex simulation scenarios such as impromptu scenario changes and parameter sensitivity analysis, providing more flexible technical means for simulation analysis.

[0100] (5) Unify modeling standards to improve model interoperability and maintainability.

[0101] The standardized definition and interface specifications of the six elements provide a unified standard for the development of simulation models by different teams, solve the problems of incompatibility and difficulty in reusing model formats from different vendors, and facilitate the accumulation, sharing and version management of model assets.

[0102] In an exemplary embodiment, a computer device is provided, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the steps in the above-described method embodiments. The computer device can be a server or a terminal. The computer device includes a processor, a memory, an input / output interface (I / O), and a communication interface. The processor, memory, and I / O interface are connected via a system bus, and the communication interface is connected to the system bus via the I / O interface. The processor of the computer device provides computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The database of the computer device stores data to be processed. The I / O interface of the computer device is used for exchanging information between the processor and external devices. The communication interface of the computer device is used for communicating with an external terminal via a network connection. When the computer program is executed by the processor, it implements the steps in the above-described method embodiments.

[0103] In one exemplary embodiment, a computer-readable storage medium is provided storing a computer program that, when executed by a processor, implements the steps in the above-described method embodiments.

[0104] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of the relevant data must comply with relevant regulations.

[0105] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments described above. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM).

[0106] The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0107] 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.

[0108] This document uses specific examples to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only for the purpose of helping to understand the methods and core ideas of this application. Furthermore, those skilled in the art will recognize that, based on the ideas of this application, there will be changes in the specific implementation methods and application scope. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A method for constructing a simulated intelligent agent based on a six-element hierarchical architecture, executed by a computer system, characterized in that, include: The modeling data of the simulated intelligent agent is divided into six elements: attributes, capabilities, rules, processes, activities, and state machines. The attributes, capabilities, and rules are parameter configuration data; the process, activity, and state machine are program logic data. The parameter configuration data is configured as a quick layer in the form of a visual configuration interface and a parameter configuration file; The program logic data is configured as a mechanism layer in the form of executable program code and configuration files; A standardized parameter interface is reserved in the mechanism layer; the standardized parameter interface includes an attribute parameter interface, a capability parameter interface, and a rule parameter interface. Through the standardized parameter interface, the parameter configuration data in the fast layer is injected into the mechanism layer, driving the activity execution performance calculation and state machine state transition in the mechanism layer, thus completing the instantiation and simulation deduction of the simulated intelligent agent.

2. The method for constructing a simulated intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, The attributes are stored in the simulation system memory in a key-value pair data structure and are divided into inherent static attributes and dynamic state attributes. The capabilities are stored in the form of a structure array, with each capability corresponding to a set of metrics. The rules exist in the form of variables in conditional expressions.

3. The method for constructing a simulation intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, The process is stored in the process definition file as a node-edge directed graph data structure, supporting sequential, conditional branching, parallel branching and loop control structures. The process execution engine parses and generates execution instances to schedule activities. The activities are implemented as independently encapsulated program modules. Each activity module defines a standardized input parameter interface, execution logic function, and post-result output interface. The activity modules are compiled and then embedded in the mechanism layer. The state machine is implemented in the form of a state table configuration file combined with state transition logic functions, and is bound to the execution hook point of the activity module; The state machine automatically triggers state verification and transition at preset hook points during activity execution, and writes the state transition results into shared memory to feed back to the process execution engine to control the branch selection of subsequent activities.

4. The method for constructing a simulation intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, The standardized parameter interface is implemented in the form of an application programming interface function; the standardized parameter interface has built-in parameter validation logic, which includes data type validation, value range validation and business logic constraint validation. Parameter configuration data that fails the validation is intercepted and does not affect the program logic of the mechanism layer.

5. The method for constructing a simulated intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, The parameter configuration data is injected using two methods: initialization injection and dynamic injection. The initialization injection method involves loading parameter configuration files in batches before the simulation agent starts. The dynamic injection method involves updating individual parameter configuration data while the simulation is paused. The dynamically injected updated parameter configuration data only applies to subsequent unexecuted activities, while the results of executed activities and the current state of the simulation agent remain unchanged.

6. The method for constructing a simulation intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, A parameter mapping association mechanism is also established between the fast layer and the mechanism layer; the parameter mapping association mechanism is the mapping relationship between activity parameters and metrics, where activity parameter = metric × transformation coefficient.

7. The method for constructing a simulation intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, The configuration process for the fast layer includes: The system receives attribute parameter data input by the user through the attribute configuration interface, performs a validity check on the attribute parameter data, and stores it in the attribute parameter dataset after the check passes. The system receives the measurement metrics of each capability input by the user through the capability configuration interface, performs a validity check on the measurement metrics, and stores them into the capability parameter dataset after the check passes. The rule configuration interface receives rule threshold parameter data input by the user, performs a validity check on the rule threshold parameter data, and stores it in the rule parameter dataset after the check passes. Establish a mapping relationship between activity parameters and the metrics, and store the mapping relationship data in the associated configuration table; The attribute parameter dataset, the capability parameter dataset, the rule parameter dataset, and the associated configuration table are packaged into a parameter configuration file in JSON format.

8. The method for constructing a simulation intelligent agent based on a six-element hierarchical architecture according to claim 1, characterized in that, The configuration process of the mechanism layer includes: Receive arrangement operation data from the user in the process editing interface, and generate a process definition file based on the arrangement operation data; Bind a corresponding activity module to each process node in the process definition file, and configure the type data, pre-start condition data, execution logic entry data and post-result output rule data of the activity module; Bind a corresponding state machine to each activity module, define state set data, transition event data, transition condition data and transition action data, and generate a state table configuration file; Scan the variable data in the activity module and the state machine, identify and mark configurable parameters, and generate corresponding standardized parameter interfaces and parameter verification logic based on the configurable parameters.

9. A computer device, comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that the processor executes the computer program to implement the simulation intelligent agent construction method based on a six-element hierarchical architecture as described in any one of claims 1-8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the simulation intelligent agent construction method based on the six-element hierarchical architecture as described in any one of claims 1-8.

Images