Data processing method and device based on multilayer context awareness, computer equipment, readable storage medium and program product

Abstract

The invention relates to a data processing method and device based on multilayer context awareness, computer equipment, a computer readable storage medium and a computer program product, relates to the field of data processing, and can improve the accuracy of data processing. The method comprises the steps of obtaining unstructured original data through an expansion interface unit of a data processing system, and packaging the original data into an instance layer data object based on attribute parameters of the original data; attribute parameters contained in the instance layer data objects are associated and matched with scene attributes preset in template layer data objects, and the template layer data objects associated with the instance layer data objects are determined; determining a target business logic rule according to the template layer data object and an abstraction layer data object inherited by the template layer data object; and generating a module calling instruction for controlling the expansion interface unit to call the external module according to the target business logic rule and the attribute parameter.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to a multi-layer context-aware data processing method, apparatus, computer equipment, computer-readable storage medium, and computer program product. Background Technology

[0002] With the development of artificial intelligence technology, intelligent data processing systems are widely used in scenarios that transform unstructured data into business instructions. Existing technologies typically employ a data encapsulation and static rule matching model, which involves converting the collected raw data into a standard format and then processing it directly based on preset rigid rules (such as numerical threshold judgment or keyword matching).

[0003] However, this processing model struggles to effectively represent and reason about context-dependent, ambiguous abstract concepts, making it impossible for existing systems to dynamically adjust evaluation criteria based on context. This results in low cognitive accuracy for intelligent systems when facing complex semantic environments or non-standardized interaction scenarios. Summary of the Invention

[0004] Therefore, it is necessary to provide a multi-layer context-aware data processing method, apparatus, computer device, computer-readable storage medium, and computer program product to address the aforementioned technical problems.

[0005] Firstly, this application provides a multi-layer context-aware data processing method applied to a data processing system. The database of the data processing system stores abstract layer data objects, template layer data objects, and instance layer data objects. The abstract layer data objects indicate preset logical rules commonly satisfied by multiple template layer data objects. The template layer data objects indicate preset scenario rules satisfied by the instance layer data objects in different scenarios. The method includes: The data processing system obtains unstructured raw data through its extended interface unit, and encapsulates the raw data into an instance-layer data object based on the attribute parameters of the raw data. The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. Based on the template layer data object and the abstract layer data object inherited by the template layer data object, determine the target business logic rules; Based on the target business logic rules and the attribute parameters, a module call instruction is generated to control the extended interface unit to call external modules.

[0006] In one embodiment, the step of associating and matching the attribute parameters contained in the instance layer data object with scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object includes: The attribute parameters contained in the instance layer data object are associated and matched with the scene attributes preset in the template layer data object to determine the matching degree of each scene attribute. Based on the matching degree, the template layer data object associated with the instance layer data object is determined.

[0007] In one embodiment, determining the target business logic rule based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Obtain a first template layer data object whose matching degree is greater than the first preset threshold, and determine a first scene rule based on the first template layer data object; Obtain the first logical rule of the first abstract layer data object associated with the first template layer data object; If multiple first template layer data objects point to the same first abstract layer data object, then the scene mapping rule is determined based on the first template layer data object; The target business logic rule is determined based on the first scenario rule, the first logic rule, and the scenario mapping rule.

[0008] In one embodiment, determining the target business logic rule based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Obtain a second template layer data object whose matching degree is less than or equal to the first preset threshold, and determine the second scene rule based on the second template layer data object; Based on the second scenario rule and the attribute parameters, the degree of association between the target processing objects indicated by the attribute parameters is determined; the degree of association is used to indicate the closeness of commonalities and the balance of data interaction between the target processing objects. Based on the degree of association, a third scenario rule is determined, as well as a second logical rule associated with the template layer data object corresponding to the third scenario rule; The target business logic rule is determined based on the second logic rule and the third scenario rule.

[0009] In one embodiment, the attribute parameters include key parameters and modifier parameters; the attribute parameters based on the original data encapsulate the original data into the instance-level data object, including: If the modification parameter and the key parameter have independent physical semantics, then the modification parameter and the key parameter are each independently encapsulated as a first target processing object; If the modification parameter is used to evaluate the status of the key parameter, then the modification parameter and the key parameter are established as subordinate to each other and identified as the second target processing object; The instance layer data object is generated based on the first target processing object or the second target processing object.

[0010] In one embodiment, before determining the template layer data object associated with the instance layer data object by associating and matching the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object, the method further includes: When the instance layer data object includes the first target processing object, a first processing mode is determined based on the interaction between the modification parameters and the key parameters in the first target processing object; the first processing mode is used to call the logical rules and / or the scenario rules to perform data derivation. When the instance layer data object includes the second target processing object, the degree of influence of the modification parameter on the key parameter is determined based on the modification parameter corresponding to the second target processing object; Based on the degree of influence of the modified parameters on the key parameters, a second processing mode for the instance layer data is determined; the second processing mode is used to update the state attributes of the key parameters so as to perform association matching based on the updated state attributes.

[0011] In one embodiment, determining the target business logic rule based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Based on the first processing mode and / or the second processing mode of the instance layer data object corresponding to the template layer data object, the scene weight corresponding to the template layer data object and the logical weight corresponding to the associated abstract layer data object are determined; wherein the logical weight includes utility weight and intensity weight. The evaluation angle is determined based on the scenario weights and the logical weights. The target business logic rules are determined based on the template layer data object, the abstract layer data object, and the evaluation angle.

[0012] In one embodiment, the method further includes: During the generation of the module call instruction, the operation tracing unit of the data processing system records the association and matching records between the instance layer data object and the template layer data object. Record the inheritance tracing path of the template layer data object to the abstract layer data object; And, record the rule identifier and decision logic of the determined target business logic rule; The associated matching records, inheritance tracing paths, rule identifiers, and decision logic are saved to the database.

[0013] In one embodiment, determining the target business logic rule based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Obtain the preset logical constraints in the abstract layer data object; Based on the instance layer data object, determine the data processing scope corresponding to the target business logic rule; Under the premise of satisfying the logical constraints and data processing scope, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object.

[0014] In one embodiment, after determining the template layer data object associated with the instance layer data object based on the matching degree, the method further includes: If the matching degree is less than the second preset threshold, the instance layer data object is marked by the operation tracing unit of the data processing system to obtain the marked instance layer data object; the second preset threshold is less than the first preset threshold. The operation tracing unit obtains the operation result corresponding to the marked instance layer data object. If the number of markings meets the preset conditions, the template layer data object is updated based on the marked instance layer data object and the operation result to obtain the updated template layer data object.

[0015] Secondly, this application also provides a multi-layer context-aware data processing apparatus for a data processing system. The database of the data processing system stores abstract layer data objects, template layer data objects, and instance layer data objects. The abstract layer data objects indicate preset logical rules commonly satisfied by multiple template layer data objects. The template layer data objects indicate preset scenario rules satisfied by the instance layer data objects in different scenarios, including: The instance layer data object determination module is used to obtain unstructured raw data through the extended interface unit of the data processing system, and encapsulate the raw data into the instance layer data object based on the attribute parameters of the raw data. The template layer data object acquisition module is used to match the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. The target business logic rule determination module is used to determine the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object; The module call instruction module is used to generate module call instructions for controlling the extended interface unit to call external modules based on the target business logic rules and the attribute parameters.

[0016] Thirdly, this application also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to perform the following steps: The data processing system obtains unstructured raw data through its extended interface unit, and encapsulates the raw data into an instance-layer data object based on the attribute parameters of the raw data. The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. Based on the template layer data object and the abstract layer data object inherited by the template layer data object, determine the target business logic rules; Based on the target business logic rules and the attribute parameters, a module call instruction is generated to control the extended interface unit to call external modules.

[0017] Fourthly, this application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, performs the following steps: The data processing system obtains unstructured raw data through its extended interface unit, and encapsulates the raw data into an instance-layer data object based on the attribute parameters of the raw data. The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. Based on the template layer data object and the abstract layer data object inherited by the template layer data object, determine the target business logic rules; Based on the target business logic rules and the attribute parameters, a module call instruction is generated to control the extended interface unit to call external modules.

[0018] Fifthly, this application also provides a computer program product, including a computer program that, when executed by a processor, performs the following steps: The data processing system obtains unstructured raw data through its extended interface unit, and encapsulates the raw data into an instance-layer data object based on the attribute parameters of the raw data. The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. Based on the template layer data object and the abstract layer data object inherited by the template layer data object, determine the target business logic rules; Based on the target business logic rules and the attribute parameters, a module call instruction is generated to control the extended interface unit to call external modules.

[0019] The aforementioned multi-layer context-aware data processing method, apparatus, computer equipment, computer-readable storage medium, and computer program product acquire unstructured raw data through the extended interface unit of the data processing system. Based on the attribute parameters of the raw data, the raw data is encapsulated into instance-layer data objects. The attribute parameters contained in the instance-layer data objects are matched with the scene attributes preset in the template-layer data objects to determine the template-layer data objects associated with the instance-layer data objects. Based on the template-layer data objects and the abstract-layer data objects inherited by the template-layer data objects, the target business logic rules are determined. Based on the target business logic rules and attribute parameters, module call instructions for controlling the extended interface unit to call external modules are generated. In this application, unstructured raw data is encapsulated into standardized instance-level data objects by extending interface units, achieving structural decoupling between the underlying heterogeneous data sources and the upper-level cognitive logic. Furthermore, by associating instance-level data objects with template-level data objects based on scenario attributes and tracing their inherited abstract-level data objects to jointly generate business logic rules, dynamic integration of scenario-based polymorphic rules (specific context) and underlying general logical contracts (abstract essence) is achieved. This achieves the technical effect of endowing intelligent systems with both flexibility and rigor in complex semantic environments, enabling them to accurately parse ambiguous concepts based on context and generate compliant control instructions. This effectively solves the problem of cognitive rigidity in traditional rule engines when processing abstract concepts and improves the accuracy of data processing. Attached Figure Description

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

[0021] Figure 1 This is an application environment diagram of a multi-layer context-aware data processing method in one embodiment; Figure 2 This is a schematic diagram of the architecture of a data processing system in one embodiment; Figure 3 This is a flowchart illustrating a multi-layer context-aware data processing method in one embodiment; Figure 4 This is a structural block diagram of a multi-layer context-aware data processing device in one embodiment; Figure 5 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation

[0022] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0023] It should be noted that the terms "first," "second," etc., used in this application can be used to describe various objects, but these objects are not limited by these terms. These terms are only used to distinguish the first object from the second object. The terms "comprising" and "having," and any variations thereof, used in this application, are intended to cover non-exclusive inclusion. The term "multiple" used in this application refers to two or more. The term "and / or" used in this application refers to one of the embodiments, or any combination of multiple embodiments.

[0024] The multi-layer context-aware data processing method provided in this application can be applied to a data processing system. In an exemplary embodiment, the data processing system is an intelligent computing architecture that integrates symbolic logical reasoning and distributed data processing capabilities. Its underlying layer relies on a scalable computer network or cloud-native environment, and it achieves the understanding and reasoning of abstract concepts, polymorphic scenarios, and complex relationships by maintaining a hierarchical knowledge graph (i.e., a three-layer cognitive model). In one embodiment, the system is logically divided into a Content Encapsulation Unit (CTU) responsible for data standardization, a Relation Definition Unit (RDU) responsible for logical judgment, an Extension Interface Unit (EIU) responsible for external calls, a Traceability Record Unit (TRU) responsible for end-to-end recording, and a Unique Identifier Unit (UID) responsible for identity management.

[0025] For example, such as Figure 1 As shown, the data processing system may include terminal devices, a server, and external functional modules. The terminal devices communicate with the server via a network to collect raw data from the external environment (such as voice, images, text, or sensor readings) and send it to the server.

[0026] Specifically, the server, as the core processing unit, has the aforementioned five core components (CTU, RDU, EIU, TRU, UID) deployed in its internal storage and is connected to one or more databases. These databases pre-build and store abstraction layer data objects (defining atomic contracts), template layer data objects (defining scene rules), and are used for runtime dynamic storage of instance layer data objects (carrying real-time data). In one embodiment, such as... Figure 2 In the architecture of the data processing system shown, after the server receives the data uploaded by the terminal, the CTU encapsulates it into an instance, the RDU performs inference based on the templates and abstract definitions in the database, and the EIU calls external functional modules (such as third-party AI models, physical actuators or business APIs) to execute specific tasks based on the inference results.

[0027] Alternatively, the data processing system can be deployed as a cloud-edge collaborative architecture, where the terminal device acts as an edge node, carrying the initial encapsulation function of the CTU, while the server acts as the cloud brain, carrying the deep reasoning and knowledge evolution function of the RDU; or, the system can be an independent system-on-a-chip, directly embedded inside the robot or smart hardware, with all components interacting through the system bus.

[0028] In one exemplary embodiment, such as Figure 3 As shown, a multi-layer context-aware data processing method is provided, which can be applied to... Figure 1 The following steps, S302 to S308, are used as an example to illustrate the data processing system in the server. Step S302: Obtain unstructured raw data through the extended interface unit of the data processing system, and encapsulate the raw data into instance-level data objects based on the attribute parameters of the raw data.

[0029] The extended interface unit can be a communication gateway and protocol adapter component in the data processing system responsible for information interaction with the external environment. In one embodiment, it can be an API interface set or hardware I / O port that integrates multiple network protocols.

[0030] Unstructured raw data can be a collection of information with high entropy characteristics that has not been processed by a system cognitive model, such as natural language text, continuous speech waveforms, pixel-level image data, or discrete sensor readings.

[0031] Attribute parameters can be feature values ​​with clear semantic or physical meaning extracted from the original data, including but not limited to timestamps, semantic keywords, physical quantity values, etc.

[0032] Instance-level data objects are standardized data containers that are dynamically created in system memory or database to carry the aforementioned attribute parameters. They are the most basic concrete entities in the three-layer cognitive model, possess a globally unique identity identifier (UID), and serve as the direct input carrier for subsequent rule matching and logical reasoning.

[0033] For example, when an external terminal device (such as a smartphone, industrial sensor, or monitoring probe) collects environmental information or user commands, it sends a request to the data processing system via the network. The extended interface unit (EIU) of the data processing system listens for and captures the unstructured raw data carried in the request in real time. Specifically, after receiving the raw data, the EIU first calls a pre-set parsing algorithm (such as an NLP word segmenter, signal decoder, or OCR recognition module) to perform "entropy reduction" processing on the data, identifying and extracting key attribute parameters. For example, for a piece of text data, "subject," "predicate," "modifiers," and "sentiment" are extracted as attribute parameters; for a piece of sensor data, "device ID," "current reading," "unit," and "acquisition time" are extracted as attribute parameters.

[0034] Subsequently, the system's Content Encapsulation Unit (CTU) is activated. Based on a preset data structure template, it instantiates a new instance-level data object in memory and injects the extracted attribute parameters into the corresponding fields of the object in the form of key-value pairs or feature vectors. At the same time, the CTU also assigns a globally unique instance ID to the object so that the subsequent Traceability Unit (TRU) can perform end-to-end recording.

[0035] Optionally, during the encapsulation process, the system can also perform data augmentation or completion operations. As an alternative, if the original data lacks certain necessary attribute parameters (e.g., only a description of the action "smash hard" is available, but the numerical value of "force" is missing), CTU can call the default configuration or statistical mean from the historical database to generate default attribute parameters and fill them into the instance-level data object, thus ensuring data integrity. Alternatively, as another similar approach, CTU can map the original data as a whole into a high-dimensional semantic vector, storing this vector directly as an attribute parameter in the instance-level data object to support subsequent fuzzy matching based on vector similarity, without exhaustively enumerating all semantic fields. This approach represents a higher-level generalization of attribute parameters, encompassing various implementation forms such as structured field extraction and unstructured vector mapping.

[0036] Step S304: The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object.

[0037] Among them, template layer data objects can be structured data entities used to concretize the implementation of abstract concepts. They are encapsulations of concrete implementation classes of abstract interfaces or scenario-based configuration files, defining the triggering conditions (i.e., scenario attributes) and corresponding business rules under specific scenarios, reflecting the polymorphism of the same abstract concept in different contexts.

[0038] Scene attributes can be a set of conditions preset in the template layer data object to define the scope of application of the template, including but not limited to numerical thresholds, semantic tags, environmental context identifiers, or logical expressions. Association matching can be a computational process in which the system compares dynamically generated instance data with statically stored template data to find the best suitable context.

[0039] For example, after the content encapsulation unit completes the encapsulation of the instance-level data object, it passes it to the rule decision unit. The RDU initiates an association matching procedure, traversing multiple template-level data objects stored in the database. Specifically, the RDU reads the attribute parameters in the instance-level data object and compares them one by one with the preset scene attributes in each template-level data object. This comparison can be an exact match based on Boolean logic or a range match based on numerical ranges. When the attribute parameters of the instance-level data object meet the conditions defined by the scene attributes of a certain template-level data object, the RDU determines that an association has been established between the two and identifies that template-level data object as the target template associated with the current instance.

[0040] This process is similar to dynamic dispatch in object-oriented programming, which determines which specific class (template) to call based on the object's runtime type (instance attribute).

[0041] Alternatively, there are several alternative mechanisms for association matching. As one similar approach, the system can adopt a fuzzy matching mechanism based on semantic vectors, that is, calculate the cosine similarity or Euclidean distance between the attribute vector of the instance layer data object and the feature vector of the template layer data object. When the similarity exceeds a certain threshold, an association is established. This approach is suitable for processing unstructured or fuzzy natural language instructions (such as "Help me process this file"). In another embodiment, the system can introduce a context-weighted mechanism, which combines the current system time, geographical location, or user history habits (as implicit attribute parameters) to weight and score the matching results, thereby selecting the template that best fits the current context from multiple candidate templates, rather than being limited to literal matching of attribute parameters.

[0042] Step S306: Determine the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object.

[0043] The abstract layer data object can be a metadata entity used to define atomic attributes and logical contracts common across different scenarios. This definition includes, but is not limited to, the attribute fields corresponding to the template layer, the common logical rules they satisfy, and the inviolable axioms. As the cornerstone of knowledge reuse and reasoning consistency, it ensures the consistency of specific concepts in different scenarios at the underlying logic level. Inheritance refers to a logical derivation relationship established between the template layer data object and the abstract layer data object, indicating that the template layer is a concrete implementation of the abstract layer definition.

[0044] For example, after identifying the template layer data object associated with the instance layer data object, the rule decision unit (RDU) can initiate the inference process. Specifically, the RDU first parses the inherited fields in the template layer data object, using these fields to trace back through the database via indexes, locates and loads the inherited abstract layer data object. Subsequently, the RDU performs a rule fusion operation: on one hand, it reads the underlying logical rules defined in the abstract layer data object (e.g., the physical axiom "force produces acceleration" or the logical contract "all RegionMax should be exclusive"); on the other hand, it reads the scenario-based rules encapsulated in the template layer data object (e.g., "in a boxing ring, the one with the higher knockout rate wins"). The RDU jointly parses these two sets of rules to generate the target business logic rule for the current instance. For example, if the abstract layer specifies "entities cannot pass through walls," and the template layer specifies "movement actions," then the fused rule is "perform movement without passing through walls."

[0045] Optionally, the system can adopt a dynamic rule assembly mechanism, that is, instead of pre-storing complete rules, it stores rule fragments. RDU dynamically assembles an executable script at runtime based on the logical rules defined by the abstraction layer and the scenario rules provided by the template layer, and marks the execution order of the rule fragments. By executing the script according to which one is executed, precise business logic rule fusion is achieved.

[0046] Step S308: Generate a module call instruction for controlling the extended interface unit to call external modules based on the target business logic rules and attribute parameters.

[0047] Module invocation instructions are structured commands or signal sets used by the system to drive external functional units to perform specific operations. These include, but are not limited to, the target module's addressing information (such as URI, IP address, or device ID), opcode, and payload data. They serve as a medium for translating abstract business decisions into concrete actions, acting as a translator between the cognitive and execution layers. External modules refer to functional entities independent of the core cognitive logic of the data processing system, including but not limited to third-party AI algorithm models, cloud microservices, or physical executors.

[0048] For example, once the rule decision unit determines the target business logic rule (e.g., "Initiate powerful cooling for abnormal high temperatures"), it combines the attribute parameters in the instance layer data object (e.g., {temperature:85, device_id:"motor_01"}) to generate an executable module call instruction. Specifically, the RDU first parses the action definition in the business logic rule to determine the type of external module to be called (e.g., cooling control service). Then, the RDU fills the specific values ​​from the attribute parameters into the parameter template of the action definition, constructing an instruction package that conforms to a preset interface specification (e.g., JSON-RPC, gRPC, or RESTful API specification). For example, the generated instruction might be: {service:"CoolingSystem",action:"set_fan_speed",params:{speed:"MAX",target:"motor_01"}}. This instruction is then passed to the extended interface unit (EIU), which distributes it to the corresponding external module to drive the physical fan or trigger a remote alarm service.

[0049] Optionally, instead of generating a single atomic instruction, RDU generates a workflow description file (such as a DAG or XML script) containing multiple steps, which is then sent to EIU all at once. The EIU's internal task scheduler then calls multiple external modules sequentially to suit complex business processes.

[0050] In another embodiment, RDU can generate a generic business event instead of directly specifying a specific target module, and publish it to the system bus. Any external module that has subscribed to the event can respond to it automatically. This approach achieves more thorough decoupling and is suitable for loosely coupled distributed systems.

[0051] In one specific embodiment, the Extended Interface Unit (EIU) of the data processing system receives natural language text uploaded by the terminal: "You did a great job on this." The Content Encapsulation Unit (CTU) parses this unstructured data and extracts attribute parameters. In this example, the system identifies the key parameter as "this matter" (entity type: transaction / task, Task) and the modifier parameter as "beautiful" (feature tag: High_Quality). The CTU encapsulates these parameters into an instance-level data object (UID: Inst_Task_001), which contains attribute key-value pairs: {target_type:"Task_Execution", feature_tag:"Beautiful"}.

[0052] The Rule Decision Unit (RDU) associates and matches the attribute parameters (mainly `target_type`) of the instance-level data objects with the scene attributes of multiple template-level data objects stored in the database. At this point, the system database contains multiple templates inheriting from the same abstract layer, reflecting the polymorphism of the term "beautiful" in different scenarios: Template A (Template_Visual_Inspection, visual inspection template): The preset scene attribute is {target_type:"Image"||"Product_Surface"}. In this template, "beautiful" is defined as "no scratches, high gloss". Template B (Template_Process_Audit, process audit template): The preset scene attribute is {target_type:"Task_Execution"||"Workflow"}. In this template, "beautiful" is defined as "logical closed loop, zero redundancy, high efficiency".

[0053] During the RDU's traversal and matching, it was found that the instance's `target_type: "Task_Execution"` perfectly matched the scenario attribute of template B, but did not match template A. Therefore, the system discarded template A and determined that the template layer data object associated with this instance was template B (process audit template). The RDU resolved the inheritance relationship of template B and traced its inherited abstract layer data object `Abstract_Quality_Metric` (quality metric abstraction).

[0054] Furthermore, logical contracts are obtained from the abstraction layer. For example, input features are mapped to Quantifiable_Metric, and Result_Confirmation is triggered when the metric exceeds a threshold. Contextual rules are obtained from template B. In the "process audit" scenario, the modifier "beautiful" is mapped to the quantitative metrics Efficiency_Score=1.0 (full score) and Error_Rate=0 (zero errors).

[0055] Based on the aforementioned business rules, the RDU generates a module call instruction to control the Extended Interface Unit (EIU). The instruction content can be: `CALLProject_Management_SystemWITH {action:"mark_complete",task_id:"Inst_Task_001",quality_tag:"A_Plus",comment:"Efficient_Execution"}`. Upon receiving this instruction, the EIU calls the external project management system to update the task status to "perfectly completed," thus completing the final business response to the input "Well done!"

[0056] In this embodiment, unstructured raw data is encapsulated into standardized instance-level data objects by extending the interface unit, achieving structural decoupling between the underlying heterogeneous data source and the upper-level cognitive logic. Furthermore, by associating instance-level data objects with template-level data objects based on scene attributes and tracing their inherited abstract-level data objects to jointly generate business logic rules, dynamic integration of scenario-based polymorphic rules (specific context) and underlying general logical contracts (abstract essence) is achieved. This achieves the technical effect of endowing the intelligent system with both flexibility and rigor in complex semantic environments, enabling it to accurately parse ambiguous concepts based on context and generate compliant control instructions, effectively solving the problem of cognitive rigidity in traditional rule engines when processing abstract concepts and improving the accuracy of data processing.

[0057] In an exemplary embodiment, the attribute parameters contained in the instance layer data object are associated and matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object, including: The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the matching degree of each scene attribute; based on the matching degree, the template layer data object associated with the instance layer data object is determined.

[0058] Among them, the matching degree is a numerical indicator used to quantify the semantic fit or feature similarity between instance layer data objects and template layer data objects. It can be the cosine similarity value in high-dimensional vector space, the reciprocal of Euclidean distance, or the weighted total score calculated based on Boolean rules.

[0059] For example, when the rule decision unit receives the instance layer data object, it reads the attribute parameters of the instance layer data object (e.g., {text:"This company is simply the Tyson of the software industry", vector:[0.8,0.1,...]}) and concurrently accesses multiple candidate template layer data objects in the database (e.g., business review template, sports news template). Specifically, for each candidate template, the RDU performs the following calculation process: First, it extracts the preset scene attributes from the template (e.g., Template_Business:{vector_center:[0.75,0.2,...]}); second, it calls the built-in algorithm library to calculate the distance or similarity between the instance attributes and the scene attributes. For example, it uses the cosine similarity formula to calculate the cosine value of the angle between two semantic vectors, obtaining a floating-point number between 0 and 1; or, it uses a weighted scoring method to calculate the matching score for attributes of different dimensions such as time, location, and people, and then sums them.

[0060] Finally, RDU labels the calculated values ​​as the matching degree of the template relative to the current instance. The system sorts all candidate templates based on these matching degrees, and identifies the template with the highest matching degree that exceeds a certain basic threshold as the associated template, ensuring that the system always prioritizes the cognitive model that best explains the current data.

[0061] Optionally, one could first perform Boolean filtering using simple metadata (such as file type) to exclude templates that are obviously mismatched (with the matching degree set directly to 0), and then perform vector calculations on the remaining templates to balance performance and accuracy; or, one could introduce a negative feedback penalty mechanism, that is, if an instance contains mutually exclusive attributes that are explicitly prohibited by certain templates (such as game terms appearing in a serious business template), its matching degree would be significantly reduced, thereby more accurately determining the best template through the elimination method.

[0062] In this embodiment, by calculating the matching degree between instances and templates, logical judgments are transformed into continuous and comparable numerical evaluations, thereby achieving refinement and flexibility in cognitive decision-making. This not only enables the system to handle complex inputs, but also further improves the precision of template layer division, thus achieving the technical effect of improving decision robustness in uncertain environments.

[0063] In an exemplary embodiment, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object, including: Obtain a first template layer data object with a matching degree greater than a first preset threshold, and determine a first scenario rule based on the first template layer data object; obtain a first logical rule for the first abstract layer data object associated with the first template layer data object; if multiple first template layer data objects indicate the same first abstract layer data object, determine a scenario mapping rule based on the first template layer data object; determine a target business logic rule based on the first scenario rule, the first logical rule, and the scenario mapping rule.

[0064] The first preset threshold can be a quantitative indicator configured to initiate the direct template determination mechanism during the cognitive matching process. Its value is set to characterize the system's accurate positioning of the input instance data. When the matching degree between the instance features and the template exceeds this threshold, the system can identify and lock the specific cognitive object.

[0065] The first scenario rule can refer to an explicit business rule that is applicable to the current specific environment and is directly obtained from the first template layer data object under the condition of meeting the above threshold. Its first attribute is intended to emphasize that the rule is directly triggered based on high confidence recognition.

[0066] Scene mapping rules refer to the attribute alignment and feature transfer logic established between templates based on the interface definition of the common abstract layer data object when multiple template layer data objects are accurately located and they are detected to point to the same abstract layer data object.

[0067] The first logical rule can refer to the general logical rule defined in the first abstract layer data object that applies to all templates that inherit from that abstract layer. Its "first" attribute indicates that the rule is directly derived from the logical rule corresponding to the abstract layer data object inherited by the first template layer data object corresponding to the current instance data.

[0068] For example, the rule decision unit can calculate the matching degree between instance-level data objects and template-level data objects in the database. When the matching degree is greater than a first preset threshold, the system confirms that the key concept has been accurately located, and then obtains the corresponding first template-level data object and directly loads the preset first scenario rule therein. Next, the system performs a deep cognitive scan. If it finds that multiple first template-level data objects involved in the current instance (e.g., corresponding to the ontology and metaphor respectively) can be traced back to the same first abstract-level data object, it can determine that there is a cross-domain analogy scenario and generate scenario mapping rules based on the structural definition of the abstract object.

[0069] Specifically, the input raw data contains two concepts: Tyson and King. The system first accurately locates the "boxer template (corresponding to Tyson)" and the "monarch template (corresponding to King)" based on high matching, and obtains their respective first-scene rules (e.g., "boxers pursue KOs," "monarchs possess territory"). Subsequently, the system traces back and discovers that both templates inherit from the same abstract layer data object: "Region Max (largest region)." Based on this shared cognitive foundation, the system generates scene mapping rules, mapping the attributes of the "Region Max" dimension in the "monarch template" (e.g., "absolute dominance") to the corresponding dimensions in the "boxer template" (e.g., "dominance in the arena"). Finally, the system combines the first logical rules of the abstract layer, jointly solving the first-scene rules, the first logical rules, and the scene mapping rules to determine the target business logic rule: Tyson possesses an exclusive, dominant position in the boxing world, similar to a king in a nation. This processing method is not a simple semantic concatenation, but rather a machine replication of the complex cognitive process by which humans, through the abstract commonality of the largest, map political power across domains to competitive strength.

[0070] In this embodiment, by accurately locating specific concepts and using common abstract data objects as logical bridges, the semantic barriers between different cognitive scenarios are broken down, achieving the effect of giving the system analogical thinking that allows it to grasp the common abstract essence behind specific appearances (Region Max), just like humans. Thus, when faced with metaphors, metonymy, or cross-domain concepts, it can perform accurate and logical deep reasoning.

[0071] In an exemplary embodiment, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object, including: Obtain a second template layer data object with a matching degree less than or equal to a first preset threshold, and determine a second scenario rule based on the second template layer data object; determine the degree of association between target processing objects indicated by the attribute parameters based on the second scenario rule and attribute parameters; the degree of association is used to indicate the degree of commonality and data interaction balance between target processing objects; determine a third scenario rule based on the degree of association, and a second logical rule associated with the template layer data object corresponding to the third scenario rule; determine the target business logic rule based on the second logical rule and the third scenario rule.

[0072] Among them, the second template layer data object can refer to the category template with generalized attributes obtained by the system when a specific template layer object cannot be accurately located, and its corresponding second scenario rules can cover the basic behavioral norms of the category object; The degree of association is used to quantify the interaction properties of multiple objects in the absence of clear scene labels. It is composed of the degree of commonality of overlapping static attributes and the balance of data interaction that indicates the symmetry of dynamic value flow.

[0073] The third scenario rule can be a group collaboration strategy dynamically determined by the system based on the derived relationship definition, in order to match more accurate template layer data objects; the second logical rule is a general rule defined in the abstract layer that is specifically used to constrain the interaction relationship of multiple subjects. The second attribute here indicates that it is a logic activated based on the relationship derivation path, in order to distinguish it from the first logical rule based on direct inheritance of individuals.

[0074] For example, when dealing with complex interaction scenarios, the rule decision unit first attempts to match instance-level data objects with templates. If the matching degree is less than or equal to a first preset threshold, the system determines that it is currently in a fuzzy cognitive scenario and cannot directly call the experience template of a specific individual. At this time, the system then obtains generalized second template-level data objects and initiates in-depth analysis of the degree of correlation between multiple objects.

[0075] Specifically, taking a friendship relationship as an example, suppose the input raw data describes the behavior of "Zhang San" and "Li Si" exchanging fishing gear on the riverbank. However, the system database does not contain template layer data objects for these two specific target processing objects (i.e., the matching degree is low, and their social status or specific identity cannot be identified). It can only identify them as generalized general users (second template layer data objects). At this time, the system cannot directly apply the processing rules for specific acquaintances (i.e., the logical rules of Region Max). Instead, it derives the relationship by analyzing the interaction behavior between the two target processing objects.

[0076] The system calculations revealed a high degree of commonality between the two entities in the spatial coordinates of "riverside" and the interest tag of "fishing." Furthermore, during dynamic interactions, Zhang San sharing bait and Li Si sharing fishing techniques demonstrated a high degree of data interaction equilibrium (i.e., reciprocity in value exchange). Based on this high correlation, the system deduced a "friends" or "reciprocal partners" relationship between them. Accordingly, the system determined third-scenario rules (such as allowing resource sharing and lowering security levels) and, combined with the second logical rule regarding partnerships in the abstract layer (such as reciprocity improving system stability), ultimately determined the target business logic rule: this constitutes a trustworthy collaborative state, allowing for deep resource access between the two. This approach simulates the cognitive logic humans use when facing unfamiliar groups, judging their closeness by observing "whether they have commonalities" and "whether they reciprocate favors."

[0077] In addition, in another specific embodiment, taking the "symbiotic relationship" in nature as an example, it is assumed that the input raw data describes the interaction between "crocodile" and "toothpick bird", but the system database does not include the specific template layer data object "toothpick bird" (i.e. the matching degree is low and it cannot be identified as a specific organism), and can only identify it as a generalized small bird (second template layer data object).

[0078] At this point, the system cannot directly apply the "toothpick bird template," but instead derives rules by analyzing the interaction between the two. The system calculations reveal a high degree of commonality and close proximity between the two in the "riverbank" space. Simultaneously, in dynamic interactions, a high degree of data interaction equilibrium (i.e., reciprocity in value exchange) is formed between the crocodile opening its mouth (providing food / risk exposure) and the bird cleaning its teeth (obtaining food / providing cleaning). Based on this high degree of correlation, the system reverse-engineers a "mutually beneficial symbiotic" relationship definition between the two. Accordingly, the system determines the third scenario rules (such as suppressing predatory impulses and maintaining static cooperation), and combines this with the second logical rule regarding cooperative relationships in the abstract layer to ultimately determine the target business logic rule: determining that this is a safe cooperative state, rather than a predatory risk. This approach simulates the cognitive logic of judging the development of a situation by observing "what they are doing" and "how they interact" when facing unfamiliar things.

[0079] In this embodiment, business logic is defined by quantitatively analyzing the actual application of the target processing object. This achieves the effect of giving the system a social intuition similar to that of humans, enabling it to make reasonable decisions based on the underlying logic of commonality and mutual benefit when dealing with complex scenarios such as interaction with unknown entities, cold start user analysis, or multi-agent collaboration. This significantly improves the system's adaptability and robustness in non-standard or open environments.

[0080] In an exemplary embodiment, the attribute parameters include key parameters and modifier parameters; based on the attribute parameters of the original data, the original data is encapsulated into an instance-level data object, including: If the modifier and the key parameter have independent physical semantics, then the modifier and the key parameter are each encapsulated as a first target processing object. If the modifier is used to evaluate the state of the key parameter, then the modifier and the key parameter are associated and determined as a second target processing object. Based on the first target processing object or the second target processing object, an instance layer data object is generated.

[0081] In this context, independent physical semantics can refer to entities or variables in the modifying parameters that are considered to have independent existence value. These correspond to interaction quantities in physics (such as force, velocity, and energy), and do not exist in the data topology dependent on the key parameters. Instead, they exist as independent nodes that can have computational relationships with the key parameters.

[0082] The first target processing object can be an independent data instance that is encapsulated and upgraded from the modifier parameter itself to be at the same level as the key parameter after recognizing this independent physical semantics, and then used as an independent computing unit.

[0083] State evaluation refers to the identification of modifying parameters as observations or descriptions of certain intrinsic attributes (such as aesthetic value, emotional tendency, health status) of key parameters. Cognitively, it can be compared to state collapse in quantum measurement. That is, the role of modifiers is to determine or update a certain attribute value of key parameters, rather than to introduce new physical entities.

[0084] The second target processing object can be a composite object formed after the modification parameters are internalized into subordinate tags or extended attributes of key parameters in the state evaluation mode, where the modification components are subordinate or dependent in this structure.

[0085] For example, when parsing unstructured raw data, the Content Encapsulation Unit (CTU) determines how to construct the internal topology of instance-level data objects. If the system determines that the modifier parameter describes an objective, measurable physical process, it executes an independent encapsulation strategy; if it determines that the modifier parameter describes a subjective or observation-based state characterization, it executes a subordinate association strategy.

[0086] Specifically, taking the comparison between physical interaction and aesthetic perception as an example, suppose the system receives two instructions: "Smash the wood hard" and "Beautiful wood." When processing "Smash the wood hard," the system recognizes that "hard" is not an inherent attribute of "wood," but rather an external energy input with independent physical meaning. Therefore, the system treats "force" and "wood" as two equal interactive subjects, encapsulating them independently as the first target processing object (i.e., an independent force instance and an independent wood instance). This structure preserves the ability of force to participate as an independent variable in the derivation of subsequent business logic rules.

[0087] In another embodiment, when processing "beautiful wood," the system recognizes that "beautiful" is a subjective observation of the wood's appearance. In this case, the system no longer creates independent "beautiful instances," but instead directly attaches "beautiful" as a state parameter to the wood's attribute list, establishing a subordinate association, thereby generating a second target object with a high aesthetic rating. This processing method simulates the essential distinction in human cognition: physical quantities are objective entities, while evaluation is a subjective label.

[0088] In this embodiment, the system implements an encapsulation mechanism that structurally decouples "objective physical semantics" and "subjective evaluation semantics" at the data source, thereby providing a differentiated data foundation for subsequent cognitive reasoning. This ensures the logical clarity and physical authenticity of the cognitive architecture when processing complex mixed semantics at the underlying data structure level.

[0089] In an exemplary embodiment, before associating and matching the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object, the method further includes: When the instance-level data object includes a first target processing object, a first processing mode is determined based on the interaction between the modifier parameters and key parameters in the first target processing object. The first processing mode is used to invoke logical rules and / or scenario rules to perform data derivation. When the instance-level data object includes a second target processing object, the degree of influence of the modifier parameters on the key parameters is determined based on the modifier parameters corresponding to the second target processing object. Based on the degree of influence of the modifier parameters on the key parameters, a second processing mode for the instance-level data is determined. The second processing mode is used to update the state attributes of the key parameters so as to perform association matching based on the updated state attributes.

[0090] The first processing mode can refer to the system targeting entity objects with independent physical semantics, based on the causal law or axiomatic system in scene rules and logical rules, and deep computation path, aiming to verify whether the interaction between entities conforms to the logical rules by calling the preset calculation function, thereby deriving the evolution results that have not yet appeared. The interaction relationship can be a logical link in which the independently encapsulated first target processing object acts as an active operator to influence key parameters in the first processing mode.

[0091] The second processing mode can be a weight- or strength-based direct update path performed on subordinate objects that only have state evaluation semantics. It aims to directly change the current state attributes of key parameters according to the semantic strength of the modifiers. The state attribute update can be an incremental modification or reset of certain dimension values ​​(such as health and intimacy) of instance layer data objects without involving complex physical calculations.

[0092] For example, after receiving the instance-level data object constructed by the content encapsulation unit, the rule decision unit is configured to scan its internal data topology. Regarding this data topology, if the RDU detects that the instance contains an independently encapsulated first target processing object, the system can determine that the current task involves interaction between objective entities, thereby activating the first processing mode. In this mode, the system loads a pre-defined calculation function (such as axioms of physics and mechanics, code compilation dependency rules) from the abstraction layer, substitutes the first target processing object as an input variable into the function, and performs evolutionary derivation of key parameters.

[0093] If the RDU detects that an instance contains a second target processing object with a subordinate relationship, the system can determine that the current task involves subjective qualitative analysis or observation of the current situation, and then activate the second processing mode. In this mode, the system calculates the degree of influence of the modification parameters on the key parameters (such as calculating the intensity coefficient based on the sentiment dictionary or evaluation system) and directly generates a state change instruction to modify the attribute value of the key parameters in the system snapshot.

[0094] Specifically, suppose the system receives the instruction "smash the wood forcefully," where "force" has been encapsulated as an independent first target processing object (force instance). In the first processing mode, the system invokes Newton's axioms of mechanics as logical rules to establish an interaction relationship between the numerical value of the force instance and the physical properties of the wood instance (such as yield strength). The stress distribution is calculated through formula derivation, and the derivation result of wood fracture is generated accordingly. This is a rigorous simulation based on objective laws.

[0095] In another embodiment, if the system processes the description "redundant code," where "redundancy" has been encapsulated as a subordinate evaluation of the code entity (the second target processing object), the system in the second processing mode does not need to deduce the physical trajectory of "redundancy." Instead, it calculates the degree of negative impact of the "redundancy" evaluation on the code health index (e.g., deducting 10 points) and directly updates the technical debt status attribute of the code instance. This is an instantaneous state transition based on value judgment. The instance-level data object (code instance) after this state update will continue to be used in the derivation of business logic rules.

[0096] In this embodiment, rigorous causal deduction is performed for objective logical entities (first mode), while efficient state updates are performed for subjective evaluation attributes (second mode). This achieves the technical effect of balancing logical consistency, physical reality, emotional resonance, and value judgment. This allows the architecture to generate code or simulate physics as rigorously as an engineer, and to handle emotions and evaluations as sensitively as a human, thereby fundamentally improving the system's parsing accuracy and processing efficiency for complex mixed semantics.

[0097] In an exemplary embodiment, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object, including: Based on the first processing mode and / or the second processing mode of the instance layer data object corresponding to the template layer data object, determine the scenario weight corresponding to the template layer data object and the logical weight corresponding to the associated abstract layer data object; wherein the logical weight includes utility weight and intensity weight; based on the scenario weight and logical weight, determine the evaluation angle; and determine the target business logic rules according to the template layer data object, the abstract layer data object and the evaluation angle.

[0098] The scenario weight can be a pre-defined quantitative indicator in the template layer data object that reflects the priority of rules in a specific context. In a specific embodiment, the scenario weight can be an environment variable constant referenced in the template layer data object that is fixed in the macro definition library during the system initialization phase.

[0099] Logical weights can be quantitative indicators defined in abstract layer data objects that reflect the importance of underlying contracts or axioms. They are composed of utility weights that characterize the practical value of rules and strength weights that characterize the binding force of rules. In a specific embodiment, logical weights can be composed of preset macro instructions, including utility weight macros that characterize semantic polarity and strength weight macros that characterize the degree of modification.

[0100] The evaluation perspective can be the decision-making stance or value orientation (such as safety priority, efficiency priority, or emotion priority) calculated based on the above weight combination to guide the generation of final business rules, similar to the internal weighing process of humans when making decisions.

[0101] For example, the data processing system pre-builds a global enhanced semantic macro definition system. When the rule decision unit determines the processing mode (such as the second processing mode) for the instance layer data object, in the general operation logic, the system does not temporarily calculate the weight based on the current environment, but executes the following standardized macro instruction call process.

[0102] First, the system retrieves utility weight macros from the abstract layer data objects (e.g., #define POSITIVE_COMMON 1.5 for ordinary positive, #define NEGATIVE_STRONG 0.2 for strong negative) to establish the semantic baseline value. Second, the system can also retrieve intensity weight macros from the modification parameters (e.g., #define MODIFIER_SLIGHT 1.2 for slight modification, #define MODIFIER_NEG_MEDIUM 0.5 for medium negative modification) to establish the semantic intensity. Third, the system retrieves scene weight macros from the currently active template layer (e.g., #define SCENE_WORK 1.2 for high weight in work scenes, #define SCENE_EMOTION 0.8 for low weight in emotional scenes) to address the difference in importance of the same semantic in different scenarios.

[0103] Finally, the system can also selectively retrieve emotion dimension macros (such as #defineACTIVATION_HIGH 1.8 representing high activation) to support refined judgment of complex emotional states.

[0104] Subsequently, the system substitutes these constant values ​​retrieved from the macro library into a preset combinational operation function. This function encapsulates non-linear logical judgments to avoid logical paradoxes caused by simple multiplication: if the base valence is positive (e.g., >1.0), the function executes multiplication enhancement logic; if the base valence is negative (e.g., <1.0), the function executes negative decay logic. Furthermore, the system can introduce a numerical calibration mechanism, using calibration macros (e.g., #defineCALIBRATION_FACTOR 0.9) to globally fine-tune the operation results, and compare the final result with a preset threshold macro (e.g., #definePOSITIVE_THRESHOLD 1.2), thereby generating evaluation angles in a completely deterministic algebraic manner.

[0105] Specifically, taking "code review" in an intelligent code generation scenario as an example, suppose the input instruction is "extremely redundant code". The RDU identifies that it is currently in the "project acceptance" template and directly calls the preset scenario weight macro SCENE_WORK (defined as 1.2, representing a high standard), instead of SCENE_FOOD. Further, the RDU identifies the core word "redundant" and calls the utility weight macro NEGATIVE_COMMON (defined as 0.5); it identifies the modifier as "extreme" and calls the intensity weight macro MODIFIER_EXTREME (defined as 2.0). Subsequently, the system executes the combined function logic. Since 0.5 < 1.0 (negative), and the modifier is extremely strong, the function executes the negative logic: 0.5. (1.0 / 2.0) 1.2 = 0.3 (the lower the value, the more negative it is).

[0106] Based on the fact that this result is far below the threshold macro NEGATIVE_THRESHOLD (e.g., 0.8), the system will lock the evaluation perspective to the blocking governance perspective.

[0107] Conversely, if in the "Creative Exploration" template, the system calls the scene weight macro SCENE_EMOTION (with a macro value defined as 0.8), which is also "very redundant," resulting in a calculation of 0.5. 0.5 0.8 = 0.2. Although the value is lower, due to the different threshold definitions for creative scenarios, the system can classify it as "stylistic redundancy," and the evaluation perspective becomes "suggestive optimization perspective." This mechanism ensures that the system's values ​​at any given time are uniformly controlled by the underlying macro definition system and combinational logic functions, effectively solving the problem of insufficient scalability of the numerical system.

[0108] In this embodiment, by macro-defining not only the utility and modifier strength of language, but also the priority of scenarios, the system is endowed with a highly standardized, configurable, and scenario-adaptable cognitive balance. This allows developers to adjust the underlying macro-defined values ​​or combination logic to globally adjust the system's decision-making tendency in specific scenarios, ensuring the rigor of the cognitive logic and the predictability of the system's behavior.

[0109] In one exemplary embodiment, the method further includes: During the generation of module call instructions, the operation tracing unit of the data processing system records the association matching records between instance layer data objects and template layer data objects; records the inheritance tracing path of template layer data objects to abstract layer data objects; and records the rule identifier and decision logic of the determined target business logic rules. The association matching records, inheritance tracing paths, rule identifiers and decision logic are then saved to the database.

[0110] Among them, the operation traceability unit refers to a dedicated functional component in the data processing system that is responsible for recording and auditing behavior throughout the entire lifecycle. It is used for the structured storage of the cognitive reasoning chain and has the characteristics of tamper-proof and time-series alignment.

[0111] The associated matching record refers to the snapshot data when the instance layer data object and the template layer data object are compared in terms of features during the rule decision-making process, including but not limited to the matching degree value and the hit scene attribute; the inheritance tracing path refers to the complete logical chain of the system tracing back from the currently executed business logic rule to the underlying abstract contract; the decision logic can be the specific algorithm branch, weight calculation result or logical deduction process on which the final instruction is determined.

[0112] For example, in the synchronous or asynchronous process of the data processing system generating module call instructions, the system automatically activates the operation tracing unit (TRU) for bypass listening. The TRU does not simply dump the memory stack, but executes a structured cognitive reconstruction process. First, the TRU captures the decision context of the rule decision unit, extracts associated matching records, and clarifies the features on which the system locked the current template. Second, the TRU traverses the metadata of the data object, constructs an inheritance tracing path, and explicitly links the currently executed scenario rules with the underlying logical contract, forming a visualized knowledge reference graph. Finally, the TRU records the micro-details of the decision logic, including specific macro definition calculation results, the basis for selecting evaluation angles (such as "why a strict perspective was chosen"), and the finally determined rule identifier. All of the above information is packaged into an indivisible cognitive transaction, accompanied by a globally unique identifier (UID) and a nanosecond-level timestamp, and persistently saved to a graph database or time-series database.

[0113] Specifically, taking the vulnerability remediation scenario in intelligent code generation as an example, suppose the system generates a refactoring instruction to "change recursion to iteration". TRU will record the following end-to-end information: Association matching records show that the system identified a "StackOverflowError" exception instance, with the highest match being the "recursion depth overflow template"; inheritance tracing path records that this template inherits from "Abstract_Resource_Limit (resource limit axiom)," indicating that the root cause of the refactoring lies in the finiteness of physical memory, rather than arbitrary coding style preferences; decision logic records that the system calculates "current recursion depth >> security threshold," and the evaluation perspective is "stability priority," thus triggering the business rule of "downgrading to iteration." This recording allows developers to not only see that the system changed the code during review, but also to know precisely that the system made the decision based on resource axioms rather than algorithmic preferences.

[0114] In this embodiment, by structurally recording the entire process of cognitive reasoning (matching, inheritance, and decision-making), the instantaneous computational state is transformed into persistent knowledge that can be queried and verified. This endows the artificial intelligence system with the technical effects of deep interpretability and accountability traceability. It not only provides conclusive evidence for subsequent troubleshooting and compliance auditing, but also provides a high-quality feedback data source for knowledge evolution, thereby constructing a closed loop of intelligent system with self-examination and continuous evolution capabilities.

[0115] In an exemplary embodiment, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object, including: Obtain the preset logical constraints in the abstract layer data object; determine the data processing scope corresponding to the target business logic rule based on the instance layer data object; and determine the target business logic rule based on the template layer data object and the abstract layer data object inherited by the template layer data object, provided that the logical constraints and data processing scope are met.

[0116] Among them, logical constraints can be a set of inviolable constraints that exist as underlying axioms in the abstract layer data objects, which can be expressed as mathematical inequalities, logical assertions or physical law formulas; the data processing range can be the effective operation range of business logic rules in the current context, which is defined by the specific attribute parameters of the current instance layer data object, such as the extreme value range of numerical values, the effective window of time or the topological boundary of permissions.

[0117] For example, during the deep reasoning process of the rule decision unit combining the template layer and the abstraction layer, the system continuously runs a boundary review mechanism to monitor the depth and breadth of the reasoning. The system does not trace back the definition of concepts indefinitely (e.g., from friends to relationships to sociological essence), but rather detects in real time whether the current reasoning node has touched the preset logical constraints and data processing scope.

[0118] Specifically, when RDU detects a clear termination marker in the abstract layer data object, such as tracing back to basic concepts like integrity or physical laws, the system identifies it as an indivisible atomic axiom and immediately stops further philosophical inquiry or recursive reasoning about the concept, directly applying the axiom rule. Specifically, when the reasoning process involves specific attributes of the instance layer CTU, if the system detects that the attribute already has a specific quantifiable value (such as "temperature = 25℃"), the system immediately recognizes that the data has reached the numerical application level of the data, stops further questioning the nature of the attribute corresponding to the value (such as "what is temperature"), and directly performs calculations based on the value.

[0119] As an alternative implementation, when applying rules to the template layer for derivation, if the system considers that the marginal benefit of continuing the reasoning has decreased to zero (i.e., it is no longer necessary) or the required computing resources exceed the current system's load threshold (i.e., the cost is too high), the system will forcibly stop the reasoning process and output the current best approximate solution.

[0120] As an alternative implementation, the system introduces an external intervention mechanism. When a significant signal is received from an external module (such as human expert intervention or instructions from a high-priority security system) through the Extended Interface Unit (EIU), the system treats the signal as a hard terminator with the highest priority, interrupts the current internal logic deduction, and directly adopts the conclusions or instructions input by the external module.

[0121] As an optional implementation, the system can also perform consistency verification to check whether there are self-contradictory definitions of instance attributes. For example, when an instance inherits two mutually exclusive attributes in the abstraction layer (such as being both a static constant and a dynamic variable), a conflict alarm is triggered to ensure the self-consistency of cognitive reasoning.

[0122] In this embodiment, through the above steps, a hierarchical cognitive safety valve mechanism based on underlying axiomatic constraints is realized, ensuring that every instruction generated by the system is feasible at the basic physical level and has logical security and rigor at the high cognitive level.

[0123] In an exemplary embodiment, after determining the template layer data object associated with the instance layer data object based on the matching degree, the method further includes: If the matching degree is less than the second preset threshold, the instance layer data object is marked by the operation tracing unit of the data processing system to obtain the marked instance layer data object; the second preset threshold is less than the first preset threshold; the operation result corresponding to the marked instance layer data object is obtained by the operation tracing unit; if the number of markings meets the preset conditions, the template layer data object is updated according to the marked instance layer data object and the operation result to obtain the updated template layer data object.

[0124] The second preset threshold is a critical quantitative indicator used in the cognitive matching system for unknown or knowledge blind spots. Its value is set lower than the first preset threshold. When the matching degree is lower than the second preset threshold, it means that there is neither a precisely corresponding individual template in the current database nor a generalized category sufficient to support effective derivation.

[0125] The tag can be a feature attachment performed by the operation tracing unit on a free instance layer data object that meets the threshold condition (less than the second preset threshold), including but not limited to recording its differential vector, context snapshot and temporary processing strategy.

[0126] The operation result can be the actual utility feedback (such as execution success, error log, user correction behavior) generated after the instance layer data object is temporarily processed by the system (such as manual intervention, default rule fallback, or random trial and error).

[0127] The number of times a tag is marked refers to the cumulative frequency of free instances with similar but different characteristics detected by the system within a certain time window.

[0128] For example, during the entire lifecycle operation of the data processing system, the rule decision-making unit and the operation traceability unit work together to form an automated learning closed loop. When the RDU performs association matching, if the calculated matching degree between the instance layer data object and the existing template layer data object is less than a second preset threshold, the system can determine that it has encountered a cognitive anomaly or a completely new thing.

[0129] At this point, the system does not simply throw an error, but activates the TRU to mark the instance, adding it to the pending learning queue and recording its unique, unmatched attributes (i.e., differential features) in detail. Subsequently, the system may use a default strategy or request manual intervention to handle the instance, and the TRU will continuously track and capture the results of this processing.

[0130] As the system runs, when the TRU detects that the cumulative number of times instances with the same or highly similar labeling features are labeled in the queue reaches a preset statistical significance condition (such as "appearing 100 times in 24 hours"), the system can determine that this is not random noise. After the triggering condition is met, the system extracts new scene attributes based on the common features of the labeled instance layer data items, and generates new scene rules by combining the processing logic that has been verified to be effective in the operation results. Then, the template layer data object is updated, that is, a new template layer data object is instantiated in the database, and data association is performed on the new template layer data object.

[0131] Specifically, taking the intelligent code generation scenario as an example, suppose the system's knowledge base has not yet included templates related to the "Rust language". When a user first inputs a piece of Rust code for completion, RDU finds that its match with Java and Python templates is extremely low (below the second threshold). TRU then marks the code instance as "Unknown_Syntax_X" and records subsequent manual code completion by the user (the operation result is "user correction"). As more and more users submit similar Rust code and make corrections, the number of times TRU records the "Unknown_Syntax_X" mark exceeds the threshold. System analysis reveals that these instances share specific memory management syntax, so it automatically updates the template library based on these commonalities, creating a brand new "Rust programming template".

[0132] In this embodiment, through the above steps, the system can automatically expand its cognitive boundaries as the amount of processed data increases, internalizing the dynamic changes in the external world (such as new languages ​​and new norms) into the system's own cognitive capabilities, thereby constructing an intelligent ecosystem with antifragility.

[0133] In one exemplary embodiment, this application also provides a highly detailed multi-layer context-aware data processing method, which specifically includes: First, the unstructured raw data stream from external input is obtained through the extended interface unit and passed to the content encapsulation unit. The content encapsulation unit performs semantic parsing on the data, separating key parameters and modifier parameters, and performs differentiated structured encapsulation based on their logical dependencies: if a modifier parameter is detected to have physical semantics or operational independence independent of the key parameter, the system independently encapsulates it as a first target processing object at the same level as the key parameter; if a modifier parameter is detected to be used only for state evaluation or attribute description of the key parameter, the system establishes a subordinate association with the key parameter, generating a second target processing object containing evaluation labels. Thus, an instance-layer data object with a clear topological relationship is constructed in the system memory.

[0134] Subsequently, the system calculates the matching degree between the attribute parameters of the instance-level data objects and the scene attributes of each template-level data object in the database. Based on the comparison results of the matching degree values ​​and a preset threshold system, the system automatically routes the data to the following cognitive paths: Path 1 (Direct Mapping and Analogy Path): When the matching degree is greater than the first preset threshold, the system locks a specific first template layer data object. At this time, the system further traces the abstract layer data object inherited by the template. If multiple templates are detected pointing to the same abstract layer, the system activates the scene mapping mechanism, and based on the unified interface defined by the abstract layer, maps the attribute dimensions of the source template to the context of the current target template, generating cross-domain association rules.

[0135] Path Two (Relationship Derivation Path): When the matching degree is less than or equal to the first preset threshold, and the instance involves multiple target processing objects, the system switches to association analysis. By calculating the degree of commonality between objects in the feature space and the balance of data interaction in the interaction history, the system reversely derives the relationship definition between objects, and matches the applicable third scenario rule and the associated second logical rule accordingly.

[0136] Path 3 (Evolution Path): If the matching degree is less than the second preset threshold, the system marks the instance as a free instance and records its differential characteristics through the operation tracing unit. When the cumulative number of such marks meets the preset conditions, the system triggers the update process and instantiates a new template layer data object based on statistical regularity.

[0137] After establishing the basic scenario rules, the rule decision unit parses the encapsulation type of the instance-level data objects and determines the processing mode: for the independently encapsulated first target processing object, the first processing mode is activated, and the calculation function is called to analyze the interaction relationship between objects for data derivation; for the subordinate and related second target processing object, the second processing mode is activated, and the state attributes of key parameters are directly updated based on the influence degree of the modification parameters. Based on this, the system initiates a full-link macro definition invocation mechanism, retrieving preset utility weight macros and intensity weight macros from the abstraction layer, retrieving scenario weight macros from the template layer, and calculating the final evaluation angle through a preset algebraic combination function.

[0138] Next, the system obtains the pre-defined logical constraints from the abstraction layer and calculates the data range of the data objects in the instance layer. Only when the data range and logical constraints are met, the system integrates the aforementioned scenario rules, logical rules, and evaluation perspectives to determine the final target business logic rules.

[0139] Finally, the system generates standardized module call instructions based on the business rules and distributes them to external modules for execution through the extended interface unit. Throughout this process, the operation tracing unit records in real time the association and matching records between instances and templates, the inheritance tracing path of the abstract layer, and the final decision logic, and persists this structured data to the database.

[0140] In one specific embodiment, the system database pre-builds and stores complete abstract layer data objects and template layer data objects. Among them, the abstract layer includes material entity abstraction, which defines atomic property interfaces such as mass, volume, and internal energy; chemical reaction axiom abstraction, which pre-sets logical constraints and first logical rules such as mass conservation, energy conservation, and irreversible entropy increase; and bidirectional interactive contract abstraction, which defines the second logical rules for energy and matter exchange between multiple entities.

[0141] Meanwhile, the abstract layer also solidifies basic valence macros (such as #defineEXISTENCE1.0) and intensity weight macros. The template layer inherits from the above abstract layer and includes: a mineral solid template, which encapsulates the first scenario rules for rigidity, staticity, and non-flowability, as well as the corresponding scenario weight macros (such as SCENE_PHYSICS_SOLID1.0); a liquid water template, which encapsulates scenario rules for flowability and solvent properties; a thermal energy template, which encapsulates physical property rules for high internal energy and transferability; and a slurry / fluid template, which defines the mixed-state properties of reaction products. In addition, the system also presets a first preset threshold and a second preset threshold for distinguishing cognitive patterns.

[0142] Based on this premise, the system's Extended Interface Unit (EIU) acquires the unstructured raw data "hot water meets quicklime" from external input and passes it to the Content Encapsulation Unit (CTU). The CTU performs semantic parsing on the data, identifying quicklime and water as key parameters, and heat as a modifier parameter. According to the structured encapsulation logic, the system identifies "heat," and since "heat" here is not a subjective evaluation but an energy state with independent physical semantics, it is independently encapsulated as a first target processing object (thermal energy instance) at the same level as the key parameters, and establishes its interaction relationship with the water instance; at the same time, quicklime and water are also encapsulated as independent key parameter instances.

[0143] Therefore, the CTU constructs an instance-layer data object containing three independent entities and their interaction topology. Subsequently, the Rule Decision Unit (RDU) initiates association matching, calculating the matching degree between each instance and the template in the database. During this process, the quicklime instance has an extremely high matching degree with the mineral solids template (greater than the first preset threshold), so the system locks this first template-layer data object and directly loads its first scene rule. Simultaneously, for the thermal energy instance, the system confirms its conformity to the definition of a physical entity by tracing its abstract layer inheritance relationship.

[0144] While locking individual templates, the system further calculates the degree of correlation between objects due to the interaction of multiple objects (quicklime, water, and thermal energy) involved in the instance. RDU analysis revealed that quicklime and water have extremely high commonality and closeness in the chemical reaction dimension (complementary electron shells), and exhibit a dramatic data interaction balance in energy exchange (reciprocity of chemical energy to thermal energy). Based on this high degree of correlation, the system reverse-engineers the relationship definition of the two in a violently exothermic reaction, and determines the third scenario rule applicable to this reaction process (e.g., the reaction rate increases exponentially with temperature). Next, the system determines the processing mode. Since all objects are independently encapsulated first target processing objects and have clear interaction relationships, the system activates the first processing mode (data derivation type). In this mode, the full-link macro definition calling mechanism retrieves the intensity weight macros of physical axioms from the abstract layer (e.g., #defineAXIOM_FORCE1.0), retrieves the physical scenario weight macros from the template layer, and generates a rigorous physical simulation perspective evaluation angle through algebraic operations, ensuring that the derivation process strictly follows natural laws.

[0145] Subsequently, RDU substitutes the range of instance data (such as the mass of quicklime and the specific heat capacity of water) into the pre-set mass and energy conservation logic constraints of the abstract layer for verification, ensuring that the total amount of matter and energy before and after the reaction conform to the axiomatic constraints. After successful verification, the system calls the chemical reaction axiom as the calculation function to derive the evolution result of CaO + H2O + Heat -> Ca(OH)2 + More Heat. This derivation result directly triggers the dynamic association and attribute recombination process. The system removes the old association between the quicklime instance and the mineral solid template and dynamically redirects it to the slurry / fluid template. At the same time, based on the attribute interface of the abstract layer, the fluidity of the water template is combined with the alkalinity of the calcium compound to generate new properties of calcium hydroxide solution, realizing dynamic simulation where the property changes with the state, rather than simple static inheritance.

[0146] Ultimately, the system generates module call instructions containing the generation of calcium hydroxide and the release of heat. Throughout this process, the Operation Traceability Unit (TRU) records in real time the complete association matching record and inheritance traceability path from matching mineral templates, deriving mutually beneficial reaction relationships, invoking physical axioms, to finally switching associated templates, and persists this record. Furthermore, if the system detects an unknown microscopic phenomenon during the reaction process (such as abnormal color changes caused by specific impurities), and the instance matching degree corresponding to this phenomenon is lower than a second preset threshold, the system will mark and accumulate it. When the number of markings meets the condition, knowledge evolution is automatically triggered, creating a new impurity quicklime template based on the difference characteristics, thereby achieving adaptive growth of the cognitive system.

[0147] Through the above steps, this embodiment realizes the transformation of complex physical and chemical processes into dynamic associations, logical deductions, and attribute reorganization processes between data objects; this achieves the technical effect of accurately simulating the dynamic changes of the physical world in a computer system, and verifies the rigor, versatility, and feedback-based self-evolution capability of the architecture in handling the interaction of objective entities.

[0148] It should be understood that although the steps in the flowcharts of the above embodiments are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the above embodiments may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages in other steps. It is understood that the steps in different embodiments can be freely combined as needed, and all non-contradictory solutions formed by such combinations are within the scope of protection of this application.

[0149] Based on the same inventive concept, this application also provides a multi-layer context-aware data processing apparatus for implementing the multi-layer context-aware data processing method described above. The solution provided by this apparatus is similar to the implementation scheme described in the above method; therefore, the specific limitations in one or more embodiments of the multi-layer context-aware data processing apparatus provided below can be found in the limitations of the multi-layer context-aware data processing method described above, and will not be repeated here.

[0150] In one exemplary embodiment, such as Figure 4 As shown, a multi-layer context-aware data processing device is provided for a data processing system. The database of the data processing system stores abstract layer data objects, template layer data objects, and instance layer data objects. The abstract layer data objects indicate preset logical rules commonly satisfied by multiple template layer data objects. The template layer data objects indicate preset scenario rules satisfied by the instance layer data objects in different scenarios. The device includes: an instance layer data object determination module 410, a template layer data object acquisition module 420, a target business logic rule determination module 430, and a module call instruction module 440, wherein: The instance layer data object determination module 410 is used to obtain unstructured raw data through the extended interface unit of the data processing system, and encapsulate the raw data into the instance layer data object based on the attribute parameters of the raw data. The template layer data object acquisition module 420 is used to match the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. The target business logic rule determination module 430 is used to determine the target business logic rule based on the template layer data object and the abstract layer data object inherited by the template layer data object; The module call instruction module 440 is used to generate a module call instruction for controlling the extended interface unit to call external modules based on the target business logic rules and the attribute parameters.

[0151] In one embodiment, the template layer data object acquisition module 420 is further configured to associate and match the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object to determine the matching degree of each scene attribute. Based on the matching degree, the template layer data object associated with the instance layer data object is determined.

[0152] In one embodiment, the target business logic rule determination module 430 is further configured to obtain the first template layer data object whose matching degree is greater than the first preset threshold, and determine the first scenario rule based on the first template layer data object; Obtain the first logical rule of the first abstract layer data object associated with the first template layer data object; If multiple first template layer data objects point to the same first abstract layer data object, then the scene mapping rule is determined based on the first template layer data object; The target business logic rule is determined based on the first scenario rule, the first logic rule, and the scenario mapping rule.

[0153] In one embodiment, the target business logic rule determination module 430 is further configured to obtain a second template layer data object whose matching degree is less than or equal to the first preset threshold, and determine a second scenario rule based on the second template layer data object; Based on the second scenario rule and the attribute parameters, the degree of association between the target processing objects indicated by the attribute parameters is determined; the degree of association is used to indicate the closeness of commonalities and the balance of data interaction between the target processing objects. Based on the degree of association, a third scenario rule is determined, as well as a second logical rule associated with the template layer data object corresponding to the third scenario rule; The target business logic rule is determined based on the second logic rule and the third scenario rule.

[0154] In one embodiment, the attribute parameters include key parameters and modifier parameters; the instance layer data object determination module 410, based on the attribute parameters of the original data, is further configured to: If the modification parameter and the key parameter have independent physical semantics, then the modification parameter and the key parameter are each independently encapsulated as a first target processing object; If the modification parameter is used to evaluate the status of the key parameter, then the modification parameter and the key parameter are established as subordinate to each other and identified as the second target processing object; The instance layer data object is generated based on the first target processing object or the second target processing object.

[0155] In one embodiment, the target business logic rule determination module 430 is further configured to determine a first processing mode based on the interaction relationship between the modification parameters and the key parameters in the first target processing object when the instance layer data object includes the first target processing object; the first processing mode is used to call the logic rules and / or scenario rules to perform data derivation; When the instance layer data object includes the second target processing object, the degree of influence of the modification parameter on the key parameter is determined based on the modification parameter corresponding to the second target processing object; Based on the degree of influence of the modified parameters on the key parameters, a second processing mode for the instance layer data is determined; the second processing mode is used to update the state attributes of the key parameters so as to perform association matching based on the updated state attributes.

[0156] In one embodiment, the target business logic rule determination module 430 is further configured to determine the scene weight corresponding to the template layer data object and the logical weight corresponding to the associated abstract layer data object based on the first processing mode and / or the second processing mode of the instance layer data object corresponding to the template layer data object; wherein the logical weight includes utility weight and intensity weight. The evaluation angle is determined based on the scenario weights and the logical weights. The target business logic rules are determined based on the template layer data object, the abstract layer data object, and the evaluation angle.

[0157] In one embodiment, the module invocation instruction module 440 is further configured to, during the generation of the module invocation instruction, record the association matching record between the instance layer data object and the template layer data object through the operation tracing unit of the data processing system; Record the inheritance tracing path of the template layer data object to the abstract layer data object; And, record the rule identifier and decision logic of the determined target business logic rule; The associated matching records, inheritance tracing paths, rule identifiers, and decision logic are saved to the database.

[0158] In one embodiment, the target business logic rule determination module 430 is further configured to obtain preset logical constraints in the abstract layer data object; Based on the instance layer data object, determine the data processing scope corresponding to the target business logic rule; Under the premise of satisfying the logical constraints and data processing scope, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object.

[0159] In one embodiment, the module invocation instruction module 440 is further configured to mark the instance layer data object through the operation tracing unit of the data processing system if the matching degree is less than the second preset threshold, thereby obtaining the marked instance layer data object; the second preset threshold is less than the first preset threshold. The operation tracing unit obtains the operation result corresponding to the marked instance layer data object. If the number of markings meets the preset conditions, the template layer data object is updated based on the marked instance layer data object and the operation result to obtain the updated template layer data object.

[0160] Each module in the aforementioned multi-layer context-aware data processing device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device, or stored in the memory of a computer device as software, so that the processor can invoke and execute the operations corresponding to each module.

[0161] In one exemplary embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 5As shown, this computer device includes a processor, memory, input / output interfaces (I / O), and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computational and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides the environment for the operating system and computer programs stored in the non-volatile storage media. The database stores instance-level data objects, template-level data objects, and abstract-level data objects. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communicating with external terminals via a network connection. When executed by the processor, the computer program implements a multi-layer context-aware data processing method.

[0162] Those skilled in the art will understand that Figure 5 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0163] In one embodiment, a computer device is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above-described method embodiments.

[0164] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps in the above method embodiments.

[0165] In one embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps in the above method embodiments.

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

[0167] Those skilled in the art will understand that all or part of the processes in the methods of 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, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile memory 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). 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, artificial intelligence (AI) processors, etc., and are not limited to these.

[0168] 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 application.

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

Claims

1. A data processing method based on multi-layer context awareness, characterized in that, The method is applied to a data processing system, wherein the database of the data processing system stores abstract layer data objects, template layer data objects, and instance layer data objects. The abstract layer data objects indicate preset logical rules commonly satisfied by multiple template layer data objects, and the template layer data objects indicate preset scenario rules satisfied by the instance layer data objects in different scenarios. The method includes: The data processing system obtains unstructured raw data through its extended interface unit, and encapsulates the raw data into an instance-layer data object based on the attribute parameters of the raw data. The attribute parameters contained in the instance layer data object are matched with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. Based on the template layer data object and the abstract layer data object inherited by the template layer data object, determine the target business logic rules; Based on the target business logic rules and the attribute parameters, a module call instruction is generated to control the extended interface unit to call external modules.

2. The method according to claim 1, characterized in that, The step of associating and matching the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object includes: The attribute parameters contained in the instance layer data object are associated and matched with the scene attributes preset in the template layer data object to determine the matching degree of each scene attribute. Based on the matching degree, the template layer data object associated with the instance layer data object is determined.

3. The method according to claim 2, characterized in that, The step of determining the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Obtain a first template layer data object whose matching degree is greater than a first preset threshold, and determine a first scene rule based on the first template layer data object; Obtain the first logical rule of the first abstract layer data object associated with the first template layer data object; If multiple first template layer data objects point to the same first abstract layer data object, then the scene mapping rule is determined based on the first template layer data object; The target business logic rule is determined based on the first scenario rule, the first logic rule, and the scenario mapping rule.

4. The method according to claim 2, characterized in that, The step of determining the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Obtain a second template layer data object whose matching degree is less than or equal to a first preset threshold, and determine a second scene rule based on the second template layer data object; Based on the second scenario rule and the attribute parameters, the degree of association between the target processing objects indicated by the attribute parameters is determined; the degree of association is used to indicate the degree of commonality and the balance of data interaction between the target processing objects. Based on the degree of association, a third scenario rule is determined, as well as a second logical rule associated with the template layer data object corresponding to the third scenario rule; The target business logic rule is determined based on the second logic rule and the third scenario rule.

5. The method according to claim 1, characterized in that, The attribute parameters include key parameters and modifier parameters; the attribute parameters based on the original data encapsulate the original data into the instance layer data object, including: If the modification parameter and the key parameter have independent physical semantics, then the modification parameter and the key parameter are each independently encapsulated as a first target processing object; If the modification parameter is used to evaluate the status of the key parameter, then the modification parameter and the key parameter are established as subordinate to each other and identified as the second target processing object; The instance layer data object is generated based on the first target processing object or the second target processing object.

6. The method according to claim 5, characterized in that, Before determining the template layer data object associated with the instance layer data object by associating and matching the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object, the method further includes: When the instance layer data object includes the first target processing object, a first processing mode is determined based on the interaction between the modification parameters and the key parameters in the first target processing object; the first processing mode is used to call the logical rules and / or the scenario rules to perform data derivation. When the instance layer data object includes the second target processing object, the degree of influence of the modification parameter on the key parameter is determined based on the modification parameter corresponding to the second target processing object; Based on the degree of influence of the modified parameters on the key parameters, a second processing mode for the instance layer data is determined; the second processing mode is used to update the state attributes of the key parameters so as to perform association matching based on the updated state attributes.

7. The method according to claim 6, characterized in that, The step of determining the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Based on the first processing mode and / or the second processing mode of the instance layer data object corresponding to the template layer data object, the scene weight corresponding to the template layer data object and the logical weight corresponding to the associated abstract layer data object are determined; wherein the logical weight includes utility weight and intensity weight. The evaluation angle is determined based on the scenario weights and the logical weights. The target business logic rules are determined based on the template layer data object, the abstract layer data object, and the evaluation angle.

8. The method according to claim 1, characterized in that, The method further includes: During the generation of the module call instruction, the operation tracing unit of the data processing system records the association and matching records between the instance layer data object and the template layer data object. Record the inheritance tracing path of the template layer data object to the abstract layer data object; And, record the rule identifier and decision logic of the determined target business logic rule; The associated matching records, inheritance tracing paths, rule identifiers, and decision logic are saved to the database.

9. The method according to claim 1, characterized in that, The step of determining the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object includes: Obtain the preset logical constraints in the abstract layer data object; Based on the instance layer data object, determine the data processing scope corresponding to the target business logic rule; Under the premise of satisfying the logical constraints and data processing scope, the target business logic rules are determined based on the template layer data object and the abstract layer data object inherited by the template layer data object.

10. The method according to claim 2, characterized in that, After determining the template layer data object associated with the instance layer data object based on the matching degree, the method further includes: If the matching degree is less than the second preset threshold, the instance layer data object is marked by the operation tracing unit of the data processing system to obtain the marked instance layer data object; the second preset threshold is less than the first preset threshold. The operation tracing unit obtains the operation result corresponding to the marked instance layer data object. If the number of markings meets the preset conditions, the template layer data object is updated based on the marked instance layer data object and the operation result to obtain the updated template layer data object.

11. A data processing device based on multi-layer context awareness, characterized in that, For a data processing system, the database of the data processing system stores abstract layer data objects, template layer data objects, and instance layer data objects, wherein the abstract layer data objects are used to indicate preset logical rules commonly satisfied by multiple template layer data objects, and the template layer data objects are used to indicate preset scenario rules satisfied by the instance layer data objects in different scenarios. The device includes: The instance layer data object determination module is used to obtain unstructured raw data through the extended interface unit of the data processing system, and encapsulate the raw data into the instance layer data object based on the attribute parameters of the raw data. The template layer data object acquisition module is used to match the attribute parameters contained in the instance layer data object with the scene attributes preset in the template layer data object to determine the template layer data object associated with the instance layer data object. The target business logic rule determination module is used to determine the target business logic rules based on the template layer data object and the abstract layer data object inherited by the template layer data object; The module call instruction module is used to generate module call instructions for controlling the extended interface unit to call external modules based on the target business logic rules and the attribute parameters.

12. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 10.

13. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 10.

14. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 10.

Images