An interaction optimization method and system based on a big data language model

Abstract

The application provides an interactive optimization method and system based on a big data language model, which is applied to the field of interactive data processing; the application introduces a syntax structure recognition, a task structure graph construction and an interactive intention chain generation mechanism, makes up for the technical short board that the big data language model lacks structured recognition and semantic decomposition ability when processing complex requests, can recognize the syntax features in the input request on the basis of judging the model capability, constructs clear task nodes and dependent paths, then extracts a structured intention chain including elements such as actions, objects, conditions and purposes, and generates a matched execution structure, finally constructs parallel and nested intention request structures by means of the data dependence between the interactive intention trigger words and the semantic instructions, ensures that the language model can stably process multi-stage and logically complex natural language requests, and improves the overall interactive quality and execution effect.

Description

Technical Field

[0001] This invention relates to the field of interactive data processing, and in particular to an interactive optimization method and system based on a big data language model. Background Technology

[0002] Currently, interactive systems based on big data language models are widely used in fields such as intelligent assistants, chatbots, and question-answering systems. The core capabilities of these systems are natural language understanding and natural language generation. Through pre-training on large-scale corpora, they are capable of semantic parsing, intent recognition, and text generation of user language commands.

[0003] However, when dealing with complex task instructions, the language model may only complete part of the complex task requests input by the user (such as multi-step execution, condition judgment, data query, etc.), lacking the ability to plan and decompose tasks, which affects the end-to-end interaction effect. Summary of the Invention

[0004] This invention aims to address the problem that big data language models lack structured task recognition and semantic decomposition mechanisms, making it difficult to accurately classify multiple intentions in instructions. It provides an interaction optimization method and system based on big data language models.

[0005] The present invention employs the following technical means to solve the technical problem:

[0006] This invention provides an interaction optimization method based on a big data language model, comprising:

[0007] Based on a pre-trained language model, obtain the user's complex request input to the language model;

[0008] Determine whether the language model can fully execute the instruction requirements corresponding to the composite request;

[0009] If not, the corresponding syntactic structure features are identified from the composite request. Based on the syntactic structure features, a preset task structure diagram is constructed. Based on the task structure diagram, the structure of the composite request is extracted to generate the user's interaction intent chain. The task structure diagram specifically includes task nodes and dependencies, and the structure extraction specifically includes actions, objects, conditions, and purposes.

[0010] Determine whether the interaction intent chain matches the composite request;

[0011] If a match is found, the interaction intent trigger word is extracted from the interaction intent chain. Based on the interaction intent trigger word, the corresponding semantic instruction is executed through the language model to obtain the data dependency between the semantic instructions. According to the data dependency, the user's intent request structure is generated. The interaction intent trigger word specifically includes interaction verbs and conjunctions. The semantic instruction specifically includes agent, patient, manner, time, and scope. The intent request structure specifically includes parallel intent structures and nested intent structures.

[0012] Furthermore, after the step of constructing a preset task structure graph based on the grammatical structure features, the method further includes:

[0013] Based on the intent units corresponding to the task structure graph, dependency edge information between the intent units is established, wherein the dependency edge information specifically includes sequential dependency edges and conditional dependency edges.

[0014] Determine whether the dependency edge information matches a preset task scheduling queue;

[0015] If not, the verb object in the intent unit is identified, and the verb object is used as the prerequisite task dependency for each node. The triggering conditions of the prerequisite task dependency are dynamically adjusted according to the execution scenario of the task structure graph. Specifically, the execution scenario includes concurrent scenarios and asynchronous scenarios.

[0016] Furthermore, the step of extracting the structure of the composite request based on the task structure diagram to generate the user's interaction intent chain further includes:

[0017] Based on the core intent features of each task node, the logical connection relationship of the task structure graph is obtained. Specifically, the core intent features include operation intent, behavior object, condition features and output expectation, and the logical connection relationship includes sequential execution, conditional execution, loop execution and concurrent execution.

[0018] Determine whether the logical connection relationships refer to the same object to be executed;

[0019] If so, the intent flow path of the task structure graph is collected, and the upstream data input of the task node is detected based on the intent flow path. Based on the upstream data input, the intent of the task structure graph is merged to construct the user's intent chain context. The intent flow path specifically includes semantic reference path, exception rollback path and state flow path.

[0020] Furthermore, the step of obtaining the data dependencies between the semantic instructions and generating the user's intent request structure based on the data dependencies further includes:

[0021] Based on the dependency edge type of the data dependency, a data identifier for the intent request structure is generated, wherein the dependency edge type specifically includes result inheritance, condition binding, aggregation preconditioning, and context reference;

[0022] Determine whether the data identifier can break the preset circular dependency;

[0023] If possible, a preset buffer intent node is inserted. Based on the buffer intent node, the scheduling resources required by the data identifier are configured. Through the scheduling resources, dependency isolation processing is performed in the pre-received interaction instructions. Specifically, the scheduling resources include execution conditions, data input sources, and data output destinations. The interaction instructions specifically include concurrent instructions and asynchronous instructions.

[0024] Furthermore, the step of determining whether the language model can fully execute the instruction requirement corresponding to the composite request also includes:

[0025] Obtain the execution exception information of the composite request, wherein the execution exception information specifically includes the need for tool assistance, the model's inability to understand, insufficient logical judgment, dependence on external context, and information to be supplemented by the user;

[0026] Determine whether the execution exception information detects a preset non-executable item;

[0027] If so, based on the non-executable item, a preset reconstruction content is marked in the composite request, and according to the reconstruction content, the user is restricted from using a preset clarification interaction mode with the language model.

[0028] Furthermore, the step of determining whether the interaction intent chain matches the composite request further includes:

[0029] Based on the interaction intent chain, the composite request is semantically segmented according to a preset method, and the corresponding number of semantic segments is collected. Specifically, the semantic segmentation includes task action, data object, condition constraint and expected result.

[0030] Determine whether the number of semantic fragments matches the number of nodes in the interaction intent chain;

[0031] If not, then based on the number of semantic fragments, the corresponding abnormal node is mapped in the interaction intent chain, and based on the abnormal node, the corresponding matching gap is translated from the composite request.

[0032] Furthermore, the step of obtaining the user's complex request to the language model based on the pre-trained language model further includes:

[0033] Based on the user's input carrier to the language model, the input type of the composite request is obtained, wherein the input type specifically includes single-turn natural language text input, multi-turn dialogue aggregation input, and structured template triggered input;

[0034] Determine whether the input type belongs to a pre-recorded continuation request;

[0035] If so, the structured representation information in the composite request is identified, and the execution instructions corresponding to the composite request are dynamically constructed based on the structured representation information. Specifically, the structured representation information includes action semantics, target semantics, limiting conditions, and sequence relationships.

[0036] This invention also provides an interaction optimization system based on a big data language model, comprising:

[0037] The acquisition module is used to acquire the user's complex request to the language model based on the pre-trained language model;

[0038] The judgment module is used to determine whether the language model can completely execute the instruction requirements corresponding to the composite request;

[0039] An execution module is used to identify the corresponding syntactic structure features from the composite request if not otherwise, construct a preset task structure graph based on the syntactic structure features, extract the structure of the composite request based on the task structure graph, and generate the user's interaction intent chain. The task structure graph specifically includes task nodes and dependencies, and the structure extraction specifically includes actions, objects, conditions, and purposes.

[0040] The second judgment module is used to determine whether the interaction intent chain matches the composite request;

[0041] The second execution module is used to extract the interaction intent trigger word from the interaction intent chain if a match is found, execute the corresponding semantic instruction through the language model based on the interaction intent trigger word, obtain the data dependency between the semantic instructions, and generate the user's intent request structure according to the data dependency. The interaction intent trigger word specifically includes interaction verbs and conjunctions, the semantic instruction specifically includes agent, patient, manner, time and scope, and the intent request structure specifically includes parallel intent structure and nested intent structure.

[0042] Furthermore, it also includes:

[0043] A module is established to establish dependency edge information between intent units based on the intent units corresponding to the task structure graph, wherein the dependency edge information specifically includes sequential dependency edges and conditional dependency edges.

[0044] The third judgment module is used to determine whether the dependency edge information matches the preset task scheduling queue;

[0045] The third execution module is used to identify the verb object in the intent unit if no, and use the verb object as the prerequisite task dependency of each node. According to the execution scenario of the task structure graph, the triggering conditions of the prerequisite task dependency are dynamically adjusted. The execution scenario specifically includes concurrent scenario and asynchronous scenario.

[0046] Furthermore, the execution module also includes:

[0047] The acquisition unit is used to acquire the logical connection relationship of the task structure graph based on the core intent features of each task node. Specifically, the core intent features include operation intent, behavior object, condition features and output expectation, and the logical connection relationship includes sequential execution, conditional execution, loop execution and concurrent execution.

[0048] A judgment unit is used to determine whether the logical connection relationship refers to the same object to be executed;

[0049] An execution unit is configured to, if so, collect the intent flow path of the task structure graph, detect the upstream data input of the task node based on the intent flow path, merge the intents of the task structure graph based on the upstream data input, and construct the user's intent chain context. The intent flow path specifically includes a semantic reference path, an exception rollback path, and a state flow path.

[0050] This invention provides an interaction optimization method and system based on big data language models, which has the following beneficial effects:

[0051] This invention addresses the technical shortcomings of big data language models in handling complex requests by introducing mechanisms for grammatical structure recognition, task structure graph construction, and interactive intent chain generation. It overcomes the lack of structured recognition and semantic decomposition capabilities in these models. Based on an assessment of the model's capabilities, it can identify grammatical features in input requests, construct clear task nodes and dependency paths, extract structured intent chains including actions, objects, conditions, and purposes, and generate matching execution structures. Finally, leveraging the data dependencies between interactive intent trigger words and semantic instructions, it constructs parallel and nested intent request structures, ensuring that the language model can robustly handle multi-stage, logically complex natural language requests, thereby improving overall interaction quality and execution effectiveness. Attached Figure Description

[0052] Figure 1 This is a flowchart illustrating an embodiment of the interaction optimization method based on a big data language model according to the present invention.

[0053] Figure 2This is a structural block diagram of an embodiment of the interaction optimization system based on big data language models of the present invention. Detailed Implementation

[0054] It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention. The realization of the purpose, functional features, and advantages of the invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings.

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

[0056] Reference Appendix Figure 1 The interaction optimization method based on a big data language model in one embodiment of the present invention includes:

[0057] S1: Based on the pre-trained language model, obtain the user's complex request input to the language model;

[0058] S2: Determine whether the language model can completely execute the instruction requirements corresponding to the composite request;

[0059] S3: If not, identify the corresponding syntactic structure features from the composite request, construct a preset task structure diagram based on the syntactic structure features, extract the structure of the composite request based on the task structure diagram, and generate the user's interaction intent chain. The task structure diagram specifically includes task nodes and dependencies, and the structure extraction specifically includes actions, objects, conditions, and purposes.

[0060] S4: Determine whether the interaction intent chain matches the composite request;

[0061] S5: If a match is found, the interaction intent trigger word is extracted from the interaction intent chain. Based on the interaction intent trigger word, the corresponding semantic instruction is executed through the language model to obtain the data dependency between the semantic instructions. According to the data dependency, the user's intent request structure is generated. The interaction intent trigger word specifically includes interaction verbs and conjunctions. The semantic instruction specifically includes agent, patient, manner, time, and scope. The intent request structure specifically includes parallel intent structures and nested intent structures.

[0062] In this embodiment, the system obtains the user's complex request input to the language model based on a pre-trained language model. The system then determines whether the language model can fully execute the instructions corresponding to the complex request, and executes the corresponding steps accordingly. For example, when the system determines that the language model can fully execute the instructions corresponding to the complex request, the system considers that the semantic level, task structure, and logical relationships involved in the complex request can be accurately understood and completed by the current language model. The system then enables context and historical memory enhancement to generate the final response. Through pre-set lightweight rules, it determines whether the output covers the key points of the user's original intent. Furthermore, if the complex request includes a query task, then... The system will directly return text. However, for operational tasks (such as generating code or formatting data), the request will be transmitted to the backend module for execution. The interaction results and model response status will be recorded as positive samples to optimize the subsequent intent judgment model and train a "directly executable" request recognition model. For example, if the system determines that the language model cannot fully execute the instructions corresponding to a complex request, it will consider the complex request uncomprehensible to the language model. The system will then identify the corresponding syntactic structure features from the complex request and construct a pre-defined task structure diagram based on these features. This task structure diagram includes task nodes and dependencies. Based on these task structure diagrams, the system will then process the complex request. The system extracts the structure of complex requests, specifically actions, objects, conditions, and purposes, generating a chain of user interaction intents. By recognizing syntactic structural features (such as parallelism, conditional structures, and nesting), the system constructs a task structure graph, clarifying the relationships and hierarchies between various task units within the request. This effectively addresses the misunderstandings, omissions, or incomplete responses that traditional language models encounter when dealing with complex statements involving nested conditions, multi-step reasoning, and cross-intents. It improves the model's adaptability to complex inputs at the structural level. Simultaneously, the structure extraction process decomposes complex requests into basic semantic units, including actions, objects, conditions, and purposes, thereby transforming unstructured language into structured information with operational guidance. This not only helps form a complete interaction intent chain, but also provides a clear input basis for subsequent execution stages (such as instruction triggering, data dependency parsing, module distribution, etc.), significantly improving the accuracy and controllability of semantic reconstruction. Furthermore, based on the structure extraction results, the generated interaction intent chain can reflect key elements such as the sequential relationship, logical dependencies, and triggering order of multiple intents in a user request. This chain not only helps the system execute multi-step tasks sequentially, but also adjusts resource scheduling or strategy selection according to intent dependencies, avoiding intent conflicts, duplication, or omissions, and ensuring that the phased execution of complex tasks is more stable, interpretable, and intelligent. Then, the system determines whether the interaction intent chain matches a composite request in order to execute the corresponding steps.For example, when the system determines that the user's interaction intent chain cannot match a complex request, it assumes that the system failed to fully cover all the user's intent elements during the request's syntax parsing, semantic decomposition, or structural construction. The system will then reconstruct the syntax tree for the complex request, attempting to identify missing semantic components (such as complements and conditional adverbs), using Semantic Role Labeling (SRL) or dependency analysis to assist in repairing missing elements. Simultaneously, it compares the matching scores between the intent chain and the request, identifies potentially missed secondary intents, and, based on a preset semantic completion template, infers and fills in content not explicitly expressed in the structure. Furthermore, if structural deficiencies cannot be automatically repaired, it can provide... The system prompts the user to provide necessary information or break down the request, such as: "Your request contains multiple operational goals. Would you like me to execute them sequentially?" or "Should we query A before processing B?". For example, when the system determines that the user's interaction intent chain matches a complex request, it assumes that its understanding of the request covers all elements of the user's intent. The system extracts interaction intent trigger words from the interaction intent chain, specifically including interaction verbs and conjunctions. Based on different interaction intent trigger words, it executes corresponding semantic instructions through a language model. Semantic instructions specifically include agent, patient, manner, time, and scope, obtaining data dependencies between different semantic instructions. Based on this data, the system generates the user's intent request structure, which specifically includes parallel intent structures and nested intent structures. The system ensures that every semantic unit in the user input is fully covered by judging whether the interaction intent chain matches the composite request. Once a match is confirmed, the extracted interaction intent trigger words (such as "then," "and," "if," etc.) serve as logical demarcation markers, enabling the language model to clearly identify the boundaries and execution order of each semantic segment. This improves the completeness and response consistency when processing multiple intent requests. Simultaneously, the matched interaction intent chain is mapped into structured semantic instructions (including agent, patient, manner, time, scope, etc.) and its meaning is parsed. By clearly defining data dependencies between tasks, the system clarifies the input and output conditions between each task step, avoiding conflicts or redundant calculations. This structured approach enables automatic sorting, concurrency analysis, and condition control of complex task chains, effectively improving the coherence and efficiency of task execution. Furthermore, by identifying parallel relationships (e.g., "check the weather first, then book a hotel") and nested relationships (e.g., "book if there are vacancies") in user intents, the system maps the original semantics into a multi-level intent request structure. This provides excellent scalability and control granularity, allowing the language model to flexibly respond to various interaction scenarios while maintaining semantic integrity, thereby achieving higher-level intelligent dialogue and multi-step execution capabilities.

[0063] It should be noted that the interaction intent trigger words are extracted from the interaction intent chain. Based on the interaction intent trigger words, the corresponding semantic instructions are executed through the language model to obtain the data dependencies between the semantic instructions. Based on the data dependencies, the user's intent request structure is generated. A specific example is as follows:

[0064] Suppose a user's complex request is, "Please first calculate my sales data from last month, then generate a sales trend chart based on this data, and finally email me the results;", then the detailed processing steps are as follows:

[0065] 1. First, extract the interaction intent trigger words. Three main interaction intent trigger words are identified from the input statement:

[0066] "Statistics" → interactive verb (marks the first subtask);

[0067] "Generate based on these data" → Connective + Interaction Verb (marks the second subtask, which depends on the result of the first step);

[0068] "Send email" → Interactive verb (third subtask, based on the result of step two);

[0069] 2. Decompose semantic instructions (to form structured units);

[0070] Instruction 1: Compile sales data;

[0071] Agent: System;

[0072] Patient: Sales data;

[0073] Scope: Last month;

[0074] Method: Statistics;

[0075] Command 2: Generate a trend chart;

[0076] Agent: System;

[0077] Patient: Trend chart;

[0078] Data source: Output of instruction 1 (statistically compiled data);

[0079] Method: Generation;

[0080] Command 3: Send email;

[0081] Agent: System;

[0082] Patient: Trend chart (from instruction 2);

[0083] Method: Send;

[0084] Channel: Email;

[0085] Recipient: The user themselves;

[0086] 3. Analyze the data dependencies between semantic instructions;

[0087] Instruction 2 ← Instruction 1: Generate trend charts based on statistical results;

[0088] Command 3 ← Command 2: Send an email containing a trend chart;

[0089] The data dependency chain is as follows:

[0090] Statistics on sales data → Generation of trends Figure 1 Email sending;

[0091] 4. Construct the user intent request structure, which is a strongly sequential data flow dependency chain, belonging to a nested, serial intent structure. The system expresses it as follows:

[0092]

[0093]

[0094] In summary, the above examples demonstrate that the system, through explicit structure, can precisely control the data flow and execution order between tasks, while ensuring that no semantic actions or conditions are omitted, avoiding execution interruptions or misunderstandings. Furthermore, the structured instructions are more suitable for step-by-step execution by the language model, supporting subsequent debugging and human-computer collaboration.

[0095] In this embodiment, after step S3 of constructing a preset task structure graph based on the grammatical structure features, the method further includes:

[0096] S301: Based on the intent units corresponding to the task structure graph, establish dependency edge information between the intent units, wherein the dependency edge information specifically includes sequential dependency edges and conditional dependency edges;

[0097] S302: Determine whether the dependency edge information matches a preset task scheduling queue;

[0098] S303: If not, identify the verb object in the intent unit, use the verb object as the prerequisite task dependency of each node, and dynamically adjust the triggering condition of the prerequisite task dependency according to the execution scenario of the task structure graph, wherein the execution scenario specifically includes concurrent scenario and asynchronous scenario.

[0099] In this embodiment, the system establishes dependency edge information between intent units based on the intent units corresponding to the task structure graph. This dependency edge information specifically includes sequential dependency edges and conditional dependency edges. The system then determines whether this dependency edge information matches a pre-defined task scheduling queue to execute the corresponding steps. For example, when the system determines that the dependency edge information between intent units matches a pre-defined task scheduling queue, the system considers that the identified user interaction intent structure, its task execution order, and dependency logic can be effectively supported and scheduled by the existing task scheduling mechanism. The system's understanding of the composite request is accurate and executable. The system will then execute the corresponding steps according to the execution rules defined in the task scheduling queue (such as order, priority, etc.). (Concurrency, etc.) The system executes the semantic instructions corresponding to each intent unit by calling the language model step by step or in parallel. It maintains a state node for each semantic instruction, such as "not started," "in execution," "completed," or "failed," and performs state propagation and blocking control based on dependencies (e.g., the next node waits for the output of the previous node). After all intent units have completed their scheduled execution, the system generates the final output, providing the user with structured feedback, a summary of results, or suggestions for the next interaction. For example, if the system determines that the dependency information between intent units cannot match the pre-set task scheduling queue, it will consider that the identified interaction intent has a logical or structural problem, meaning that the task requested by the user cannot be executed according to the preset order. When tasks are scheduled and executed normally according to their order or dependencies, the system identifies the verb objects in the intent unit and uses different verb objects as prerequisite tasks for each node. Based on the execution scenario of different task structure graphs (including concurrent and asynchronous scenarios), the system dynamically adjusts the triggering conditions of prerequisite task dependencies. By identifying the verb objects in the intent unit, the system can more accurately decompose the relationships between tasks, thereby rationally arranging the execution order or concurrent execution of tasks and dynamically adjusting the prerequisite dependencies. This makes the dependencies between different tasks more flexible and adaptable to user needs. This allows task scheduling to move beyond fixed sequences and handle complex task structures, as well as concurrent and asynchronous scenarios. Processing can greatly improve task execution efficiency. In concurrent scenarios, multiple tasks can be executed simultaneously, while in asynchronous scenarios, tasks can continue to execute after certain conditions are met. This avoids blocking during task execution and improves the system's response speed and processing capacity. By dynamically adjusting the triggering conditions of the dependencies of preceding tasks, the system can flexibly handle different scenarios according to the actual execution situation, ensuring that tasks are completed efficiently. Furthermore, by analyzing the verbs and objects in user input, the system can accurately identify the dependencies between tasks, avoiding task execution failures due to logical or structural problems. This process not only improves the system's ability to understand complex user requests but also enhances the system's execution capabilities in multi-step, multi-task environments.

[0100] It should be noted that the verb object in the intent unit is identified, and the verb object is used as the prerequisite task dependency for each node. The triggering conditions of the prerequisite task dependency are dynamically adjusted according to the execution scenario of the task structure graph. A specific example is as follows:

[0101] Suppose the user request is: "Check if the door is closed; if closed, turn on the light; if not closed, close the door first, then turn on the light."

[0102] Step 1: First, identify the verb object in the intent unit. Verb object identification:

[0103] Verbs: Check (Task 1), Close (Task 2), Open (Task 3);

[0104] Objects: door (task 1), door (task 2), light (task 3);

[0105] By recognizing verbs and objects in a user's request, the system can break down this complex request into multiple task nodes:

[0106] Task 1: Check if the door is closed;

[0107] Task 2: Close the door;

[0108] Task 3: Turn on the lights;

[0109] Step 2: Establish task dependencies based on the task structure diagram. Task dependencies:

[0110] Task 2 (closing the door) and Task 1 (checking if the door is closed) have a sequential dependency; Task 2 (closing the door) will only be executed if Task 1 succeeds (the door is not closed).

[0111] Task 3 (turn on the light) depends on Task 1 (check if the door is closed); if Task 1 determines that the door is closed, then Task 3 (turn on the light) is executed directly; if Task 1 determines that the door is not closed, then Task 2 (close the door) is executed first, and then Task 3 (turn on the light) is executed.

[0112] A task structure diagram can be represented in the following form:

[0113] Task 1 (Inspect the door) → Task 2 (Close the door) → Task 3 (Turn on the lights);

[0114] or,

[0115] Task 1 (Check the door) → Task 3 (Turn on the light) #If the door is already closed;

[0116] Step 3, identify prerequisite task dependencies. Prerequisite task dependencies:

[0117] The trigger condition for Task 3 (turn on the light) is the result of Task 1 (check if the door is closed); after Task 1 is executed, if the door is closed, turning on the light will be triggered directly; if the door is not closed, Task 2 (close the door) becomes the prerequisite task for Task 3 (turn on the light).

[0118] Step 4, Identification and dynamic adjustment of execution scenarios, execution scenarios:

[0119] Synchronous execution: Task 1 (checking if the door is closed) must be completed before it can be determined whether to execute Task 2 (closing the door) or Task 3 (turning on the light); this is the task scheduling for synchronous execution.

[0120] Task dependencies:

[0121] If Task 1 (check if the door is closed) returns "door closed", the system will directly execute Task 3 (turn on the light);

[0122] If Task 1 (check if the door is closed) returns "door not closed", the system executes Task 2 (close the door), and then executes Task 3 (turn on the light);

[0123] Step 5: Dynamically adjust the triggering conditions. Assume that Task 1 (checking whether the door is closed) requires external sensors to obtain the door's status information; if the sensor data is delayed or there is a network problem, Task 1 cannot be completed in time.

[0124] The system will dynamically adjust the triggering conditions for Task 3 (turn on the lights) and postpone the execution of Task 3 until Task 1 (check if the door is closed) is successfully completed. In addition, the system will execute Task 3 (turn on the lights) only after Task 2 (close the door) is completed, as needed.

[0125] Final task scheduling: The system first executes task 1 (check if the door is closed). If the door is closed, it directly executes task 3 (turn on the light). If the door is not closed, the system executes task 2 (close the door) and then executes task 3 (turn on the light). If there is a delay in the execution of task 1, the execution of task 3 (turn on the light) will be delayed until the door status is confirmed.

[0126] In summary, as illustrated above, by recognizing verb objects in user requests, the system can not only correctly identify task nodes but also dynamically adjust task scheduling based on the dependencies between these nodes. Furthermore, it can flexibly schedule tasks according to the execution scenarios (such as synchronous and asynchronous) defined in the task structure diagram, ensuring that tasks are executed in the correct order and under the correct conditions. This improves the system's ability to handle complex user requests, and the system can also adjust the execution order based on external factors to avoid conflicts or logical errors between tasks.

[0127] In this embodiment, step S3, which involves extracting the structure of the composite request based on the task structure diagram to generate the user's interaction intent chain, further includes:

[0128] S31: Based on the core intent features of each task node, obtain the logical connection relationship of the task structure graph, wherein the core intent features specifically include operation intent, behavior object, condition features and output expectation, and the logical connection relationship specifically includes sequential execution, conditional execution, loop execution and concurrent execution;

[0129] S32: Determine whether the logical connection relationship refers to the same object to be executed;

[0130] S33: If so, the intent flow path of the task structure graph is collected, and the upstream data input of the task node is detected according to the intent flow path. Based on the upstream data input, the intent of the task structure graph is merged to construct the user's intent chain context. The intent flow path specifically includes semantic reference path, exception rollback path and state flow path.

[0131] In this embodiment, the system obtains the logical connection relationships of different task structure diagrams based on the core intent features of each task node. These core intent features specifically include operation intent, behavior object, conditional features, and output expectation. The logical connection relationships specifically include sequential execution, conditional execution, loop execution, and concurrent execution. The system then determines whether these logical connection relationships target the same object to be executed, and executes the corresponding steps accordingly. For example, when the system determines that the logical connection relationships of different task structure diagrams do not target the same object to be executed, the system considers a potential logical conflict or inconsistency to have occurred in identifying the task structure. The system will identify which task structure diagrams have inconsistent logical connection relationships. For instance, in the same task scheduling, some tasks may point to different objects or system components (e.g., one task may operate on device A, while another task operates on device B). The logical connections between these tasks are no longer targeting the same object to be executed. Furthermore, if the objects operated on by the tasks are different, the system should determine the appropriate steps based on the task object. Different tasks are grouped to ensure that tasks in the same group operate on the same or related objects. Based on the differences between objects, the system may need to adjust the order of tasks to avoid conflicts caused by operating on different objects simultaneously. Different operations on the same device may need to be executed in a certain order. The system also checks whether the logical relationships between different task nodes can be properly linked. If the logical connections of the task structure diagram do not conform to the expected execution flow, the system ensures that they are executed in the correct order, are independent, and do not conflict with each other. For example, when the system determines that the logical connections of different task structure diagrams are for the same object to be executed, the system will consider that there is no logical conflict or inconsistency in identifying the task structure. The system will collect the intent flow path of the task structure diagram. The intent flow path specifically includes semantic reference path, exception rollback path, and state flow path. Based on different intent flow paths, the system will detect the upstream data input of the task nodes and merge the intents of the task structure diagram according to these upstream data inputs to construct the user's intent chain context.By collecting and analyzing semantic reference paths, exception rollback paths, and state transition paths, the system can accurately track the logical flow and semantic continuity of user intent. This ensures that even in complex, multi-step requests, the connection between tasks remains semantically clear, avoiding misunderstandings or task disconnections caused by lost context. This improves the accuracy of the language model when handling multi-level, multi-round tasks. Simultaneously, by detecting the upstream data input of each task node, the system can accurately identify the execution dependencies between tasks. This dependency awareness allows the system to rationally arrange resource scheduling and condition judgments before task execution. Especially when dealing with abnormal situations or state changes, the system can proactively roll back or replan the process, ensuring the overall task execution stability and fault tolerance. Furthermore, under the premise of unified logical connections, multiple task structure graphs are merged through intent to construct a unified and ordered user intent chain context. This helps the system achieve deeper semantic understanding and task orchestration. This not only supports the execution of complex interactions such as concurrency, multi-step processes, and conditional branches, but also provides a structured data foundation for subsequent intent reasoning, interaction learning, and multi-round task tracking.

[0132] It should be noted that the process involves collecting the intent flow path of the task structure graph, detecting the upstream data input of the task node based on the intent flow path, and merging the intents of the task structure graph according to the upstream data input to construct the user's intent chain context. A specific example is as follows:

[0133] Suppose a user request is as follows: "Please first extract daily transaction data from last week's sales database, then classify and statistically analyze this data to generate a trend chart by category, then compress and package the chart and the original data together, and send it to the product manager via email; if generating the chart fails, skip the packaging and sending steps, and simply save the statistical results locally."

[0134] Detailed explanation of the system processing procedure and construction of the task structure diagram: First, the composite request is broken down into multiple intent units, and the corresponding task nodes include:

[0135] Node A: Extract daily transaction data;

[0136] Node B: Performs data classification and statistics;

[0137] Node C: Generates a trend chart by product category;

[0138] Node D: Packages the chart and raw data;

[0139] Node E: Send an email to the product manager;

[0140] Node F: Saves the statistical results locally;

[0141] The system identifies that C depends on B, D depends on A and C, and E depends on D; meanwhile, F is a task triggered by an abnormal path; the following three types of paths are extracted:

[0142] Semantic reference path: "These data" refers to "daily transaction data"; "charts" refers to "trend charts categorized by product category"; and "statistical results" refers to the results of "categorical statistics".

[0143] Abnormal rollback path: When node C (generating charts) fails, the system automatically activates the abnormal path: D and E are not executed, and node F (saving statistical results) is executed instead;

[0144] The main task is A→B→C→D→E; if C fails, A→B→F is the backup path.

[0145] The system checks the upstream data input. B needs to obtain daily transaction data from A, C depends on B's statistical results as input, D needs to obtain both the raw data output by A and the charts generated by C, E needs to obtain the compressed package output by D, and F only needs B's output to execute. The system checks whether the data flow between all nodes is smooth to ensure that there are no missing dependencies.

[0146] Task structure diagram intent merging and context construction: The system organizes the above task nodes and flow paths into a complete task structure diagram; Since these tasks revolve around the same object: sales data processing, the system determines that they can be merged into a unified user intent context chain.

[0147] The constructed intent chain context includes: Intent graph chain: with "data processing → chart generation → packaging → email sending" as the core process; Abnormal chain: when chart generation fails, it automatically switches to "data processing → local saving of statistical results";

[0148] In summary, in the examples above, the system dynamically senses the switching conditions between the main process and the abnormal process, ensuring the semantic coherence and data dependency integrity between multi-step operations, and significantly improving the language model's understanding, execution accuracy and fault tolerance when processing complex, multi-step instructions.

[0149] In this embodiment, step S5, which involves obtaining the data dependencies between the semantic instructions and generating the user's intent request structure based on the data dependencies, further includes:

[0150] S51: Based on the dependency edge type of the data dependency, generate the data identifier of the intent request structure, wherein the dependency edge type specifically includes result inheritance, condition binding, aggregation precondition, and context reference;

[0151] S52: Determine whether the data identifier can break the preset circular dependency;

[0152] S53: If possible, insert a preset buffer intent node, configure the scheduling resources required by the data identifier according to the buffer intent node, and perform dependency isolation processing in the pre-received interaction instructions through the scheduling resources. The scheduling resources specifically include execution conditions, data input sources and data output destinations, and the interaction instructions specifically include concurrent instructions and asynchronous instructions.

[0153] In this embodiment, the system generates data identifiers for the intent request structure based on the dependency edge types of data dependencies, specifically including result inheritance, condition binding, aggregation preconditions, and context references. The system then determines whether these data identifiers can break pre-defined circular dependencies to execute the corresponding steps. For example, if the system determines that the data identifiers of the intent request structure cannot break pre-defined circular dependencies, it considers multiple task nodes to have formed unresolvable circular references, such as task A depending on the result of task B, and task B depending on the output of task A. The system cannot determine which side to execute first, resulting in a "deadlock" state. The system will then locate the circular dependency. By identifying key nodes and edges in the dependency chain, and pinpointing scenarios where a data identifier is repeatedly referenced across multiple tasks, the system attempts to segment the logic. For "result inheritance" dependencies, the system might cache data as temporary output. For "context references," certain tasks might be made asynchronous or delayed, creating breakable points. To break cyclic dependencies of data identifiers, the system can remap identifiers, ensuring that the same data object has a unique identifier across different nodes, preventing logical confusion. For example, when the system determines that the data identifier in the intent request structure can break a pre-defined cyclic dependency, the system will consider that there is no cyclic dependency between the data inputs and outputs of each intent node. The system forms a closed loop, with a clear start and end point for the data flow. This indicates that the user's multiple intents are structurally ordered, non-conflicting, and executable. The system inserts pre-defined buffered intent nodes and configures the scheduling resources required for the data identifiers based on these nodes. These scheduling resources specifically include execution conditions, data input sources, and data output destinations. Through different scheduling resources, dependency isolation is performed on pre-received interactive instructions, which include concurrent and asynchronous instructions. By inserting buffered intent nodes and configuring scheduling resources, the system effectively isolates dependency conflicts between different data flows, ensuring that concurrent or asynchronous instructions do not experience data read conflicts during execution. The timing issues in writing prevent system errors or abnormal termination, thus ensuring the stability of the overall execution process. At the same time, data identifiers and scheduling resources work together to enable the system to manage nested logic and conditional branches in complex requests in a fine-grained manner. Especially when circular dependencies are broken, it can better guide the linear evolution of intent and condition-driven processes, improve the scheduling intelligence of the task structure graph, and by configuring appropriate data input sources and output destinations, the system can allocate processing units, memory or execution threads as needed when scheduling multiple tasks, avoiding resource waste. Dependency isolation reduces the coupling between interactive instructions, which is conducive to the system supporting more concurrent user requests.

[0154] In this embodiment, step S2, which determines whether the language model can fully execute the instruction requirement corresponding to the composite request, further includes:

[0155] S21: Obtain the execution exception information of the composite request, wherein the execution exception information specifically includes the need for tool assistance, the model's inability to understand, insufficient logical judgment, reliance on external context, and information to be supplemented by the user;

[0156] S22: Determine whether the execution exception information detects a preset non-executable item;

[0157] S23: If so, then based on the non-executable item, mark the preset reconstruction content in the composite request, and restrict the user from performing preset clarification interaction mode on the language model according to the reconstruction content.

[0158] In this embodiment, the system acquires execution exception information for composite requests. Specific exception information includes requests for tool assistance, model incomprehensibility, insufficient logical judgment, reliance on external context, and requests for user-supplemented information. The system then determines whether these exceptions detect pre-defined non-executable items and executes the corresponding steps accordingly. For example, if the system determines that no pre-defined non-executable items are detected in the execution exception information, the system considers that although the current composite request has certain execution exceptions or comprehension difficulties, it still has the potential to be converted into an executable structure. The system will use the identified exception types (such as requests for tool assistance, insufficient logical judgment, etc.) to further enhance model capabilities, add prompts, or adjust parsing strategies to correct the abnormal parts of the current composite request, restoring it to an executable state. Simultaneously, it may call backup parsing modules or tool components (such as external search tools, calculators, knowledge query services, etc.) to assist in completing some sub-tasks, thereby compensating for the model's shortcomings. Semantic reasoning mechanisms are used to supplement explanations for incomplete logic or missing context. Furthermore, when necessary, the system can initiate targeted clarification or prompt requests to the user, combining the currently identified structured content to guide the user to supplement missing information or confirm unclear instructions. This approach reduces interaction costs and improves the overall request completion rate. For example, when the system detects pre-defined non-executable items in execution exception information, it considers the current composite request unexecutable. Based on these non-executable items, the system marks pre-defined refactoring content in the composite request. Depending on the refactoring content, the system restricts the user to only using pre-defined clarification interaction modes with the language model. By pre-defining and detecting non-executable items (such as logical conflicts, structural loops, and ambiguous expressions that cannot be modeled), the system can accurately identify composite requests that cannot be executed correctly, avoiding incorrect parsing. This approach prevents system execution failures or erroneous operations, enhancing overall stability and robustness. It also reconstructs content based on non-executable items and restricts users to making additions or modifications only within preset clarification interaction modes. This allows users to focus on key conflict points for interactive confirmation or correction instead of re-entering requests from the beginning, optimizing the efficiency and controllability of the human-computer dialogue process. Furthermore, by restricting users to operating only within preset clarification paths, the system avoids new request levels interfering with the reconstruction logic of the current task flow, ensuring that data dependencies and semantic paths are not disrupted by free interaction, further guaranteeing the integrity and maintainability of the entire multi-turn interaction intent chain.

[0159] It should be noted that, based on the non-executable items, preset refactoring content is marked in the composite request. According to the refactoring content, the user's preset clarification interaction mode with the language model is restricted. A specific example is as follows:

[0160] Suppose a user makes a complex request, asking the system to perform multiple tasks, including operational and reasoning tasks; during processing, the system discovers that some tasks cannot be performed by the current language model because they rely on additional contextual data or logical reasoning, which is currently unavailable.

[0161] The user's combined request is, "Help me organize yesterday's meeting minutes, extract the key points of discussion, and predict our revenue for next quarter based on the budget information from the meeting."

[0162] Organizing meeting minutes and extracting key discussion points: This part of the request is a typical information extraction task that a language model can handle; Predicting next quarter's revenue based on budget information from the meeting: This part of the request involves two issues: relying on external context (i.e., budget information) and involving complex prediction tasks (requiring reasoning and calculation);

[0163] If the system detects an unexecutable item, it will perform the following checks:

[0164] Task 1: "Organize meeting minutes and extract key discussion points" - Can be executed;

[0165] Task 2: "Predict next quarter's revenue based on the budget information from the meeting"—This task cannot be performed for the following reasons:

[0166] Missing external context: Budget information was not provided during the meeting, and the language model was unable to reason based on external documents, data, or actual budget information;

[0167] Insufficient complex reasoning: Even with budget information provided, relying solely on language models may not result in accurate predictions, as this requires more reasoning and computational support.

[0168] The system marks the parts that cannot be executed (i.e., the second part) as "requires reconstruction"; the system automatically identifies this problem and prompts it in the user request:

[0169] Issue detected: The request to "predict next quarter's revenue based on budget information from the meeting" could not be executed due to a lack of necessary external data (budget information) and reasoning ability; please provide the relevant data or revise the request.

[0170] To restrict the user's clarification interaction mode, since the system cannot directly execute this task, it guides the user to revise their request by restricting the user to a preset clarification interaction mode. In this case, the system provides the following clarification interaction options:

[0171] Option 1: Upload the missing data;

[0172] Please upload your meeting's budget information file so I can analyze its contents and provide revenue forecasts.

[0173] Option 2: Simplify the task and remove complex reasoning;

[0174] "If you would like me to make a forecast based on past quarterly data, I can provide a simple revenue forecast based on historical data;"

[0175] Option 3: Select another task to perform;

[0176] "If you don't need a revenue forecast, I can continue to summarize the key points of the meeting minutes and provide relevant information;"

[0177] When the user selects option 1: Upload missing data, the system executes subsequent steps. Once the user uploads the relevant meeting budget file, the system receives and processes the file, re-executes the forecasting task, and continues to complete the "compile meeting minutes" part of the task. Assuming the budget information is clear enough, the system can make revenue forecasts based on simple rules or existing models.

[0178] In summary, in the examples above, the system did not attempt to execute tasks that could not be completed without the user providing complete data. Instead, it clearly identified the non-executable items and provided appropriate guidance. At the same time, through the preset clarification interaction mode, the system helped the user focus and provide necessary supplementary information, such as uploading files or simplifying requests, to ensure that the task could be executed smoothly. Furthermore, the clarification mode provided structured options, avoiding lengthy and repetitive interactions for the user without understanding the system's limitations, thus greatly improving the efficiency of the interaction between the system and the user.

[0179] In this embodiment, step S4, which determines whether the interaction intent chain matches the composite request, further includes:

[0180] S41: Based on the interaction intent chain, the composite request is semantically segmented according to a preset method, and the corresponding number of semantic segments is collected. The semantic segmentation specifically includes task action, data object, condition constraint and expected result.

[0181] S42: Determine whether the number of semantic fragments matches the number of nodes in the interaction intent chain;

[0182] S43: If not, then based on the number of semantic fragments, map the corresponding abnormal node in the interaction intent chain, and based on the abnormal node, translate the corresponding matching gap from the composite request.

[0183] In this embodiment, the system performs pre-defined semantic segmentation on complex requests based on the interaction intent chain. Semantic segmentation specifically includes task actions, data objects, conditional constraints, and expected results. The system collects the corresponding number of semantic fragments and then determines whether these semantic fragment numbers match the number of nodes in the interaction intent chain to execute the corresponding steps. For example, when the system determines that the number of semantic fragments matches the number of nodes in the interaction intent chain, the system considers itself to have identified and understood all the key components of the user's complex request, and the function of each intent node is clear. The system then performs semantic segmentation on the user's complex request, decomposing it into different semantic fragments, specifically including task actions (e.g., query, execute, delete), data objects (e.g., data table, user information, device status), and conditional constraints (e.g., date range). The system considers the context, state conditions, and expected results (e.g., returned data, output report, task completion). Based on the relationship between semantic fragments and intent nodes, the system breaks down the tasks in the request into specific execution steps, allocates resources to each step, and executes these tasks according to a predefined order and logic. This ensures that data is processed, operations are performed, and the expected results are output. During execution, the system monitors the status of each task in real time and provides progress or completion status feedback to the user based on the execution results. For example, if the system determines that the number of semantic fragments cannot match the number of nodes in the interaction intent chain, it considers itself unable to fully understand the user's complex request. The system then maps corresponding abnormal nodes in the interaction intent chain based on the number of semantic fragments and translates the corresponding matching gaps from the complex request based on different abnormal nodes.By matching the number of semantic fragments with the number of nodes in the interaction intent chain, the system can promptly identify incomplete or ambiguous parts of complex requests. This helps the system identify "matching gaps" in requests—parts where users fail to clearly or completely express their needs. These gaps may involve omissions of task actions, data objects, conditional constraints, or expected results. The system identifies these gaps as anomalous nodes and processes them. Furthermore, by mapping unmatched semantic fragments in complex requests to anomalous nodes, the system can guide users to supplement or clarify their requests, avoiding misunderstandings or incorrect task execution. This enhances the accuracy and fluency of the interaction, allowing users to quickly receive feedback from the system and adjust or supplement their requests. This not only improves the user experience but also ensures that requests are executed logically. The system processes the requests and, based on identified anomaly nodes, dynamically adjusts subsequent request processing flows. This not only corrects problems through simple interactions but also optimizes the system's processing flow, preventing interruptions due to missing information or incorrect request structures. By mapping anomaly nodes to "matching gaps," the system can perform necessary clarification interactions before request execution, ensuring smooth execution of subsequent processes. Furthermore, by identifying and mapping anomaly nodes, the system can provide clear feedback even when it cannot fully understand the user's request. This mechanism gives the system high fault tolerance, allowing it to accept a certain degree of semantic incompleteness. The system gradually corrects the user's request through subsequent interactions, eliminating the need for the user to resubmit the request; the system can correct the error through interactive steps, thus ensuring accurate request execution.

[0184] In this embodiment, step S1, which involves obtaining a complex request from the user to the language model based on a pre-trained language model, further includes:

[0185] S11: Based on the user's input carrier to the language model, obtain the input type of the composite request, wherein the input type specifically includes single-turn natural language text input, multi-turn dialogue aggregation input, and structured template triggered input;

[0186] S12: Determine whether the input type belongs to a pre-recorded continuation request;

[0187] S13: If so, identify the structured representation information in the composite request, and dynamically construct the execution instruction corresponding to the composite request based on the structured representation information. The structured representation information specifically includes action semantics, target semantics, limiting conditions, and sequence relationships.

[0188] In this embodiment, the system obtains the input type of the complex request based on the user's input carrier to the language model. The input types specifically include single-turn natural language text input, multi-turn dialogue aggregation input, and structured template-triggered input. The system then determines whether these input types belong to pre-recorded continuation requests to execute corresponding steps. For example, if the system determines that the input type of the complex request does not belong to a pre-recorded continuation request, it considers that the request type has not been pre-identified or defined as a continuation request. The system returns to the initial input parsing stage and attempts to re-analyze the user's request to identify whether it is a completely new request or requires more explicit contextual information for proper processing. This can be achieved by prompting the user to reconfirm their request or by processing the request as a separate, independent task to avoid prematurely assuming it is a continuation request. Simultaneously, the system clarifies the intent and context of the request by questioning the user; for example, the system can provide... The system prompts the user with "Do you want to continue the previous question? If so, please provide more details." This confirmation helps the system correctly categorize the user's intent as a continuation request and guides the user to provide more background information or task context. For example, the system can ensure accurate subsequent processing by providing interactive prompts and asking the user for more details (such as date ranges, specific conditions, or specific goals). For instance, when the system determines that the input type of a composite request belongs to a pre-recorded continuation request, the system considers the request type to be successfully identified. The system will identify the structured representation information in the composite request, which specifically includes action semantics, target semantics, limiting conditions, and sequential relationships. Based on this structured representation information, the system dynamically constructs the execution instructions corresponding to the composite request. Through the analysis of structured representation information (such as action semantics, target semantics, limiting conditions, and sequential relationships), the system can dynamically construct the execution instructions. This not only improves processing speed but also enables precise task execution without the need for repeated parsing or regeneration of instructions. The structured task instructions effectively reduce comprehension biases and ensure that the system's operations meet user needs. At the same time, it can dynamically generate instructions to be executed based on structured representation information, making complex requests more flexible during execution. It can automatically adjust the order or operation method of task execution according to the current task and existing conditions, thereby dealing with more complex scenarios.

[0189] Reference Appendix Figure 2 An embodiment of the present invention provides an interaction optimization system based on a big data language model, comprising:

[0190] The acquisition module 10 is used to acquire a complex request input by the user to the language model based on a pre-trained language model.

[0191] The judgment module 20 is used to determine whether the language model can completely execute the instruction requirements corresponding to the composite request;

[0192] The execution module 30 is used to identify the corresponding syntactic structure features from the composite request if not, construct a preset task structure diagram based on the syntactic structure features, extract the structure of the composite request based on the task structure diagram, and generate the user's interaction intent chain. The task structure diagram specifically includes task nodes and dependencies, and the structure extraction specifically includes actions, objects, conditions, and purposes.

[0193] The second judgment module 40 is used to determine whether the interaction intent chain matches the composite request;

[0194] The second execution module 50 is used to extract the interaction intent trigger word from the interaction intent chain if a match is found, execute the corresponding semantic instruction through the language model based on the interaction intent trigger word, obtain the data dependency between the semantic instructions, and generate the user's intent request structure according to the data dependency. The interaction intent trigger word specifically includes interaction verbs and conjunctions, the semantic instruction specifically includes agent, patient, manner, time and scope, and the intent request structure specifically includes parallel intent structure and nested intent structure.

[0195] In this embodiment, the acquisition module 10 acquires the user's complex request input to the language model based on a pre-trained language model. Then, the judgment module 20 determines whether the language model can completely execute the instruction requirements corresponding to the complex request in order to execute the corresponding steps. For example, when the system determines that the language model can completely execute the instruction requirements corresponding to the complex request, the system will consider that the semantic level, task structure, and logical relationship involved in the complex request can be accurately understood and completed by the current language model. The system will enable context and history memory enhancement to generate the final response. Through pre-set lightweight rules, it will determine whether the output covers the key points in the user's original intent. At the same time, if the complex request includes query tasks... If the task is not explicitly executed, the system will directly return the text. However, if it is an operational task (such as generating code or formatting data), it will be transmitted to the backend module for execution. The interaction results and model response status will be recorded as positive samples to optimize the subsequent intent judgment model and train a "directly executable" request recognition model. For example, if the system determines that the language model cannot fully execute the instructions corresponding to a complex request, the execution module 30 will consider that the complex request cannot be accurately understood by the language model. The system will identify the corresponding syntactic structure features from the complex request and construct a pre-defined task structure graph based on these features. The task structure graph specifically includes task nodes and dependencies. Based on these task structure graphs... The system extracts the structure of the complex request, specifically including actions, objects, conditions, and purposes, generating a user's interaction intent chain. By identifying syntactic structural features (such as parallelism, conditions, and nesting), the system constructs a task structure graph, clarifying the relationships and hierarchies between various task units in the request. This effectively addresses the misunderstandings, omissions, or incomplete responses that traditional language models encounter when facing complex statements with nested conditions, multi-step reasoning, and cross-intents. It improves the model's adaptability to complex inputs from a structural perspective. Simultaneously, the structure extraction process decomposes the complex request into basic semantic units, including actions, objects, conditions, and purposes, thereby transforming unstructured language into structured information with operational direction. This not only helps to form a complete interaction intent chain, but also provides a clear input basis for subsequent execution steps (such as instruction triggering, data dependency parsing, module distribution, etc.), significantly improving the accuracy and controllability of semantic reconstruction. Furthermore, based on the structure extraction results, the generated interaction intent chain can reflect key elements such as the sequential relationship, logical dependency, and triggering order of multiple intents in the user request. This chain not only helps the system execute multiple tasks in sequence, but also adjusts resource scheduling or strategy selection according to intent dependencies, avoiding intent conflicts, repetitions, or omissions, and ensuring that the phased execution of complex tasks is more stable, interpretable, and intelligent. Then, the second judgment module 40 judges whether the interaction intent chain matches the composite request in order to execute the corresponding steps.For example, when the system determines that the user's interaction intent chain cannot match a complex request, it assumes that the system failed to fully cover all the user's intent elements during the request's syntax parsing, semantic decomposition, or structural construction. The system will then reconstruct the syntax tree for the complex request, attempting to identify missing semantic components (such as complements and conditional adverbs), using Semantic Role Labeling (SRL) or dependency analysis to assist in repairing missing elements. Simultaneously, it compares the matching score between the intent chain and the request, identifies potentially missed secondary intents, and, based on a preset semantic completion template, infers and fills in content not explicitly expressed in the structure. Furthermore, if structural deficiencies cannot be automatically repaired, it can provide suggestions. The system allows users to supplement necessary information or break down requests, such as: "Your request contains multiple operational objectives. Do you want me to execute them sequentially?" or "Do we need to query A before processing B?". For example, when the system determines that the user's interaction intent chain matches a complex request, the second execution module 50 considers that its understanding of the request has covered all the user's intent elements. The system extracts interaction intent trigger words from the interaction intent chain, which specifically include interaction verbs and conjunctions. Based on different interaction intent trigger words, the system executes corresponding semantic instructions through a language model. Semantic instructions specifically include agent, patient, manner, time, and scope, and obtains the data dependencies between different semantic instructions. Based on these data dependencies, the system generates the user's intent request structure, which specifically includes parallel intent structures and nested intent structures. The system ensures that every semantic unit in the user input is fully covered by judging whether the interaction intent chain matches the composite request. Once a match is confirmed, the extracted interaction intent trigger words (such as "then," "and," "if," etc.) serve as logical demarcation markers, enabling the language model to clearly identify the boundaries and execution order of each semantic segment, improving the completeness and response consistency when processing multiple intent requests. Simultaneously, the matched interaction intent chain is mapped into structured semantic instructions (including agent, patient, manner, time, scope, etc.) and parsed. The data dependencies between tasks clearly define the input and output conditions between each task step, avoiding conflicts or redundant calculations. This structured processing approach enables automatic sorting, concurrent analysis, and condition control of complex task chains, effectively improving the coherence and efficiency of task execution. Furthermore, by identifying parallel relationships (such as "check the weather first, then book a hotel") and nested relationships (such as "book if there are rooms available") in user intents, the system maps the original semantics into a multi-level intent request structure. This provides good scalability and control granularity, allowing the language model to flexibly respond to various interaction scenarios while ensuring semantic integrity, thereby achieving higher-level intelligent dialogue and multi-step execution capabilities.

[0196] In this embodiment, it also includes:

[0197] A module is established to establish dependency edge information between intent units based on the intent units corresponding to the task structure graph, wherein the dependency edge information specifically includes sequential dependency edges and conditional dependency edges.

[0198] The third judgment module is used to determine whether the dependency edge information matches the preset task scheduling queue;

[0199] The third execution module is used to identify the verb object in the intent unit if no, and use the verb object as the prerequisite task dependency of each node. According to the execution scenario of the task structure graph, the triggering conditions of the prerequisite task dependency are dynamically adjusted. The execution scenario specifically includes concurrent scenario and asynchronous scenario.

[0200] In this embodiment, the system establishes dependency edge information between intent units based on the intent units corresponding to the task structure graph. This dependency edge information specifically includes sequential dependency edges and conditional dependency edges. The system then determines whether this dependency edge information matches a pre-defined task scheduling queue to execute the corresponding steps. For example, when the system determines that the dependency edge information between intent units matches a pre-defined task scheduling queue, the system considers that the identified user interaction intent structure, its task execution order, and dependency logic can be effectively supported and scheduled by the existing task scheduling mechanism. The system's understanding of the composite request is accurate and executable. The system will then execute the corresponding steps according to the execution rules defined in the task scheduling queue (such as order, priority, etc.). (Concurrency, etc.) The system executes the semantic instructions corresponding to each intent unit by calling the language model step by step or in parallel. It maintains a state node for each semantic instruction, such as "not started," "in execution," "completed," or "failed," and performs state propagation and blocking control based on dependencies (e.g., the next node waits for the output of the previous node). After all intent units have completed their scheduled execution, the system generates the final output, providing the user with structured feedback, a summary of results, or suggestions for the next interaction. For example, if the system determines that the dependency information between intent units cannot match the pre-set task scheduling queue, it will consider that the identified interaction intent has a logical or structural problem, meaning that the task requested by the user cannot be executed according to the preset order. When tasks are scheduled and executed normally according to their order or dependencies, the system identifies the verb objects in the intent unit and uses different verb objects as prerequisite tasks for each node. Based on the execution scenario of different task structure graphs (including concurrent and asynchronous scenarios), the system dynamically adjusts the triggering conditions of prerequisite task dependencies. By identifying the verb objects in the intent unit, the system can more accurately decompose the relationships between tasks, thereby rationally arranging the execution order or concurrent execution of tasks and dynamically adjusting the prerequisite dependencies. This makes the dependencies between different tasks more flexible and adaptable to user needs. This allows task scheduling to move beyond fixed sequences and handle complex task structures, as well as concurrent and asynchronous scenarios. Processing can greatly improve task execution efficiency. In concurrent scenarios, multiple tasks can be executed simultaneously, while in asynchronous scenarios, tasks can continue to execute after certain conditions are met. This avoids blocking during task execution and improves the system's response speed and processing capacity. By dynamically adjusting the triggering conditions of the dependencies of preceding tasks, the system can flexibly handle different scenarios according to the actual execution situation, ensuring that tasks are completed efficiently. Furthermore, by analyzing the verbs and objects in user input, the system can accurately identify the dependencies between tasks, avoiding task execution failures due to logical or structural problems. This process not only improves the system's ability to understand complex user requests but also enhances the system's execution capabilities in multi-step, multi-task environments.

[0201] In this embodiment, the execution module further includes:

[0202] The acquisition unit is used to acquire the logical connection relationship of the task structure graph based on the core intent features of each task node. Specifically, the core intent features include operation intent, behavior object, condition features and output expectation, and the logical connection relationship includes sequential execution, conditional execution, loop execution and concurrent execution.

[0203] A judgment unit is used to determine whether the logical connection relationship refers to the same object to be executed;

[0204] An execution unit is configured to, if so, collect the intent flow path of the task structure graph, detect the upstream data input of the task node based on the intent flow path, merge the intents of the task structure graph based on the upstream data input, and construct the user's intent chain context. The intent flow path specifically includes a semantic reference path, an exception rollback path, and a state flow path.

[0205] In this embodiment, the system obtains the logical connection relationships of different task structure diagrams based on the core intent features of each task node. These core intent features specifically include operation intent, behavior object, conditional features, and output expectation. The logical connection relationships specifically include sequential execution, conditional execution, loop execution, and concurrent execution. The system then determines whether these logical connection relationships target the same object to be executed, and executes the corresponding steps accordingly. For example, when the system determines that the logical connection relationships of different task structure diagrams do not target the same object to be executed, the system considers a potential logical conflict or inconsistency to have occurred in identifying the task structure. The system will identify which task structure diagrams have inconsistent logical connection relationships. For instance, in the same task scheduling, some tasks may point to different objects or system components (e.g., one task may operate on device A, while another task operates on device B). The logical connections between these tasks are no longer targeting the same object to be executed. Furthermore, if the objects operated on by the tasks are different, the system should determine the appropriate steps based on the task object. Different tasks are grouped to ensure that tasks in the same group operate on the same or related objects. Based on the differences between objects, the system may need to adjust the order of tasks to avoid conflicts caused by operating on different objects simultaneously. Different operations on the same device may need to be executed in a certain order. The system also checks whether the logical relationships between different task nodes can be properly linked. If the logical connections of the task structure diagram do not conform to the expected execution flow, the system ensures that they are executed in the correct order, are independent, and do not conflict with each other. For example, when the system determines that the logical connections of different task structure diagrams are for the same object to be executed, the system will consider that there is no logical conflict or inconsistency in identifying the task structure. The system will collect the intent flow path of the task structure diagram. The intent flow path specifically includes semantic reference path, exception rollback path, and state flow path. Based on different intent flow paths, the system will detect the upstream data input of the task nodes and merge the intents of the task structure diagram according to these upstream data inputs to construct the user's intent chain context.By collecting and analyzing semantic reference paths, exception rollback paths, and state transition paths, the system can accurately track the logical flow and semantic continuity of user intent. This ensures that even in complex, multi-step requests, the connection between tasks remains semantically clear, avoiding misunderstandings or task disconnections caused by lost context. This improves the accuracy of the language model when handling multi-level, multi-round tasks. Simultaneously, by detecting the upstream data input of each task node, the system can accurately identify the execution dependencies between tasks. This dependency awareness allows the system to rationally arrange resource scheduling and condition judgments before task execution. Especially when dealing with abnormal situations or state changes, the system can proactively roll back or replan the process, ensuring the overall task execution stability and fault tolerance. Furthermore, under the premise of unified logical connections, multiple task structure graphs are merged through intent to construct a unified and ordered user intent chain context. This helps the system achieve deeper semantic understanding and task orchestration. This not only supports the execution of complex interactions such as concurrency, multi-step processes, and conditional branches, but also provides a structured data foundation for subsequent intent reasoning, interaction learning, and multi-round task tracking.

[0206] In this embodiment, the second execution module further includes:

[0207] The generation unit is used to generate a data identifier for the intent request structure based on the dependency edge type of the data dependency, wherein the dependency edge type specifically includes result inheritance, condition binding, aggregation preconditioning, and context reference;

[0208] The second judgment unit is used to determine whether the data identifier can break the preset circular dependency;

[0209] The second execution unit is used to insert a preset buffer intent node if possible, configure the scheduling resources required by the data identifier according to the buffer intent node, and perform dependency isolation processing in the pre-received interactive instructions through the scheduling resources. The scheduling resources specifically include execution conditions, data input sources and data output destinations, and the interactive instructions specifically include concurrent instructions and asynchronous instructions.

[0210] In this embodiment, the system generates data identifiers for the intent request structure based on the dependency edge types of data dependencies, specifically including result inheritance, condition binding, aggregation preconditions, and context references. The system then determines whether these data identifiers can break pre-defined circular dependencies to execute the corresponding steps. For example, if the system determines that the data identifiers of the intent request structure cannot break pre-defined circular dependencies, it considers multiple task nodes to have formed unresolvable circular references, such as task A depending on the result of task B, and task B depending on the output of task A. The system cannot determine which side to execute first, resulting in a "deadlock" state. The system will then locate the circular dependency. By identifying key nodes and edges in the dependency chain, and pinpointing scenarios where a data identifier is repeatedly referenced across multiple tasks, the system attempts to segment the logic. For "result inheritance" dependencies, the system might cache data as temporary output. For "context references," certain tasks might be made asynchronous or delayed, creating breakable points. To break cyclic dependencies of data identifiers, the system can remap identifiers, ensuring that the same data object has a unique identifier across different nodes, preventing logical confusion. For example, when the system determines that the data identifier in the intent request structure can break a pre-defined cyclic dependency, the system will consider that there is no cyclic dependency between the data inputs and outputs of each intent node. The system forms a closed loop, with a clear start and end point for the data flow. This indicates that the user's multiple intents are structurally ordered, non-conflicting, and executable. The system inserts pre-defined buffered intent nodes and configures the scheduling resources required for the data identifiers based on these nodes. These scheduling resources specifically include execution conditions, data input sources, and data output destinations. Through different scheduling resources, dependency isolation is performed on pre-received interactive instructions, which include concurrent and asynchronous instructions. By inserting buffered intent nodes and configuring scheduling resources, the system effectively isolates dependency conflicts between different data flows, ensuring that concurrent or asynchronous instructions do not experience data read conflicts during execution. The timing issues in writing prevent system errors or abnormal termination, thus ensuring the stability of the overall execution process. At the same time, data identifiers and scheduling resources work together to enable the system to manage nested logic and conditional branches in complex requests in a fine-grained manner. Especially when circular dependencies are broken, it can better guide the linear evolution of intent and condition-driven processes, improve the scheduling intelligence of the task structure graph, and by configuring appropriate data input sources and output destinations, the system can allocate processing units, memory or execution threads as needed when scheduling multiple tasks, avoiding resource waste. Dependency isolation reduces the coupling between interactive instructions, which is conducive to the system supporting more concurrent user requests.

[0211] In this embodiment, the determination module further includes:

[0212] The second acquisition unit is used to acquire the execution exception information of the composite request, wherein the execution exception information specifically includes the need for tool assistance, the model's inability to understand, the insufficient logical judgment, the dependence on external context, and the need for information to be supplemented by the user.

[0213] The third judgment unit is used to determine whether the execution exception information detects a preset non-executable item;

[0214] The third execution unit is configured to, if so, mark the preset reconstruction content in the composite request based on the non-executable item, and restrict the user from performing a preset clarification interaction mode on the language model according to the reconstruction content.

[0215] In this embodiment, the system acquires execution exception information for composite requests. Specific exception information includes requests for tool assistance, model incomprehensibility, insufficient logical judgment, reliance on external context, and requests for user-supplemented information. The system then determines whether these exceptions detect pre-defined non-executable items and executes the corresponding steps accordingly. For example, if the system determines that no pre-defined non-executable items are detected in the execution exception information, the system considers that although the current composite request has certain execution exceptions or comprehension difficulties, it still has the potential to be converted into an executable structure. The system will use the identified exception types (such as requests for tool assistance, insufficient logical judgment, etc.) to further enhance model capabilities, add prompts, or adjust parsing strategies to correct the abnormal parts of the current composite request, restoring it to an executable state. Simultaneously, it may call backup parsing modules or tool components (such as external search tools, calculators, knowledge query services, etc.) to assist in completing some sub-tasks, thereby compensating for the model's shortcomings. Semantic reasoning mechanisms are used to supplement explanations for incomplete logic or missing context. Furthermore, when necessary, the system can initiate targeted clarification or prompt requests to the user, combining the currently identified structured content to guide the user to supplement missing information or confirm unclear instructions. This approach reduces interaction costs and improves the overall request completion rate. For example, when the system detects pre-defined non-executable items in execution exception information, it considers the current composite request unexecutable. Based on these non-executable items, the system marks pre-defined refactoring content in the composite request. Depending on the refactoring content, the system restricts the user to only using pre-defined clarification interaction modes with the language model. By pre-defining and detecting non-executable items (such as logical conflicts, structural loops, and ambiguous expressions that cannot be modeled), the system can accurately identify composite requests that cannot be executed correctly, avoiding incorrect parsing. This approach prevents system execution failures or erroneous operations, enhancing overall stability and robustness. It also reconstructs content based on non-executable items and restricts users to making additions or modifications only within preset clarification interaction modes. This allows users to focus on key conflict points for interactive confirmation or correction instead of re-entering requests from the beginning, optimizing the efficiency and controllability of the human-computer dialogue process. Furthermore, by restricting users to operating only within preset clarification paths, the system avoids new request levels interfering with the reconstruction logic of the current task flow, ensuring that data dependencies and semantic paths are not disrupted by free interaction, further guaranteeing the integrity and maintainability of the entire multi-turn interaction intent chain.

[0216] In this embodiment, the second determination module further includes:

[0217] The acquisition unit is used to perform a preset semantic segmentation on the composite request based on the interaction intent chain and acquire the corresponding number of semantic segments. The semantic segmentation specifically includes task actions, data objects, conditional constraints, and expected results.

[0218] The fourth judgment unit is used to determine whether the number of semantic fragments matches the number of nodes in the interaction intent chain;

[0219] The fourth execution unit is used to, if not, map the corresponding abnormal node in the interaction intent chain according to the number of semantic fragments, and translate the corresponding matching gap from the composite request according to the abnormal node.

[0220] In this embodiment, the system performs pre-defined semantic segmentation on complex requests based on the interaction intent chain. Semantic segmentation specifically includes task actions, data objects, conditional constraints, and expected results. The system collects the corresponding number of semantic fragments and then determines whether these semantic fragment numbers match the number of nodes in the interaction intent chain to execute the corresponding steps. For example, when the system determines that the number of semantic fragments matches the number of nodes in the interaction intent chain, the system considers itself to have identified and understood all the key components of the user's complex request, and the function of each intent node is clear. The system then performs semantic segmentation on the user's complex request, decomposing it into different semantic fragments, specifically including task actions (e.g., query, execute, delete), data objects (e.g., data table, user information, device status), and conditional constraints (e.g., date range). The system considers the context, state conditions, and expected results (e.g., returned data, output report, task completion). Based on the relationship between semantic fragments and intent nodes, the system breaks down the tasks in the request into specific execution steps, allocates resources to each step, and executes these tasks according to a predefined order and logic. This ensures that data is processed, operations are performed, and the expected results are output. During execution, the system monitors the status of each task in real time and provides progress or completion status feedback to the user based on the execution results. For example, if the system determines that the number of semantic fragments cannot match the number of nodes in the interaction intent chain, it considers itself unable to fully understand the user's complex request. The system then maps corresponding abnormal nodes in the interaction intent chain based on the number of semantic fragments and translates the corresponding matching gaps from the complex request based on different abnormal nodes.By matching the number of semantic fragments with the number of nodes in the interaction intent chain, the system can promptly identify incomplete or ambiguous parts of complex requests. This helps the system identify "matching gaps" in requests—parts where users fail to clearly or completely express their needs. These gaps may involve omissions of task actions, data objects, conditional constraints, or expected results. The system identifies these gaps as anomalous nodes and processes them. Furthermore, by mapping unmatched semantic fragments in complex requests to anomalous nodes, the system can guide users to supplement or clarify their requests, avoiding misunderstandings or incorrect task execution. This enhances the accuracy and fluency of the interaction, allowing users to quickly receive feedback from the system and adjust or supplement their requests. This not only improves the user experience but also ensures that requests are executed logically. The system processes the requests and, based on identified anomaly nodes, dynamically adjusts subsequent request processing flows. This not only corrects problems through simple interactions but also optimizes the system's processing flow, preventing interruptions due to missing information or incorrect request structures. By mapping anomaly nodes to "matching gaps," the system can perform necessary clarification interactions before request execution, ensuring smooth execution of subsequent processes. Furthermore, by identifying and mapping anomaly nodes, the system can provide clear feedback even when it cannot fully understand the user's request. This mechanism gives the system high fault tolerance, allowing it to accept a certain degree of semantic incompleteness. The system gradually corrects the user's request through subsequent interactions, eliminating the need for the user to resubmit the request; the system can correct the error through interactive steps, thus ensuring accurate request execution.

[0221] In this embodiment, the acquisition module further includes:

[0222] The third acquisition unit is used to acquire the input type of the composite request based on the user's input carrier to the language model, wherein the input type specifically includes single-turn natural language text input, multi-turn dialogue aggregation input, and structured template triggered input;

[0223] The fifth judgment unit is used to determine whether the input type belongs to a pre-recorded continuation request;

[0224] The fifth execution unit is used to identify the structured representation information in the composite request if the condition is met, and dynamically construct the instruction to be executed corresponding to the composite request based on the structured representation information. The structured representation information specifically includes action semantics, target semantics, limiting conditions, and sequence relationships.

[0225] In this embodiment, the system obtains the input type of the complex request based on the user's input carrier to the language model. The input types specifically include single-turn natural language text input, multi-turn dialogue aggregation input, and structured template-triggered input. The system then determines whether these input types belong to pre-recorded continuation requests to execute corresponding steps. For example, if the system determines that the input type of the complex request does not belong to a pre-recorded continuation request, it considers that the request type has not been pre-identified or defined as a continuation request. The system returns to the initial input parsing stage and attempts to re-analyze the user's request to identify whether it is a completely new request or requires more explicit contextual information for proper processing. This can be achieved by prompting the user to reconfirm their request or by processing the request as a separate, independent task to avoid prematurely assuming it is a continuation request. Simultaneously, the system clarifies the intent and context of the request by questioning the user; for example, the system can provide... The system prompts the user with "Do you want to continue the previous question? If so, please provide more details." This confirmation helps the system correctly categorize the user's intent as a continuation request and guides the user to provide more background information or task context. For example, the system can ensure accurate subsequent processing by providing interactive prompts and asking the user for more details (such as date ranges, specific conditions, or specific goals). For instance, when the system determines that the input type of a composite request belongs to a pre-recorded continuation request, the system considers the request type to be successfully identified. The system will identify the structured representation information in the composite request, which specifically includes action semantics, target semantics, limiting conditions, and sequential relationships. Based on this structured representation information, the system dynamically constructs the execution instructions corresponding to the composite request. Through the analysis of structured representation information (such as action semantics, target semantics, limiting conditions, and sequential relationships), the system can dynamically construct the execution instructions. This not only improves processing speed but also enables precise task execution without the need for repeated parsing or regeneration of instructions. The structured task instructions effectively reduce comprehension biases and ensure that the system's operations meet user needs. At the same time, it can dynamically generate instructions to be executed based on structured representation information, making complex requests more flexible during execution. It can automatically adjust the order or operation method of task execution according to the current task and existing conditions, thereby dealing with more complex scenarios.

[0226] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. An interaction optimization method based on a big data language model, characterized in that, Includes the following steps: Based on a pre-trained language model, obtain the user's complex request input to the language model; Determine whether the language model can fully execute the instruction requirements corresponding to the composite request; If not, the corresponding syntactic structure features are identified from the composite request. Based on the syntactic structure features, a preset task structure diagram is constructed. Based on the task structure diagram, the structure of the composite request is extracted to generate the user's interaction intent chain. The task structure diagram specifically includes task nodes and dependencies, and the structure extraction specifically includes actions, objects, conditions, and purposes. Determine whether the interaction intent chain matches the composite request; If a match is found, the interaction intent trigger word is extracted from the interaction intent chain. Based on the interaction intent trigger word, the corresponding semantic instruction is executed through the language model to obtain the data dependency between the semantic instructions. According to the data dependency, the user's intent request structure is generated. The interaction intent trigger word specifically includes interaction verbs and conjunctions. The semantic instruction specifically includes agent, patient, manner, time and scope. The intent request structure specifically includes parallel intent structure and nested intent structure. The step of extracting the structure of the composite request based on the task structure diagram to generate the user's interaction intent chain further includes: Based on the core intent features of each task node, the logical connection relationship of the task structure graph is obtained. Specifically, the core intent features include operation intent, behavior object, condition features and output expectation, and the logical connection relationship includes sequential execution, conditional execution, loop execution and concurrent execution. Determine whether the logical connection relationships refer to the same object to be executed; If so, the intent flow path of the task structure graph is collected, and the upstream data input of the task node is detected based on the intent flow path. Based on the upstream data input, the intent of the task structure graph is merged to construct the user's intent chain context. The intent flow path specifically includes semantic reference path, exception rollback path and state flow path.

2. The interaction optimization method based on big data language model according to claim 1, characterized in that, After the step of constructing a preset task structure graph based on the grammatical structure features, the method further includes: Based on the intent units corresponding to the task structure graph, dependency edge information between the intent units is established, wherein the dependency edge information specifically includes sequential dependency edges and conditional dependency edges. Determine whether the dependency edge information matches a preset task scheduling queue; If not, the verb object in the intent unit is identified, and the verb object is used as the prerequisite task dependency for each node. The triggering conditions of the prerequisite task dependency are dynamically adjusted according to the execution scenario of the task structure graph. Specifically, the execution scenario includes concurrent scenarios and asynchronous scenarios.

3. The interaction optimization method based on big data language model according to claim 1, characterized in that, The step of obtaining the data dependencies between the semantic instructions and generating the user's intent request structure based on the data dependencies further includes: Based on the dependency edge type of the data dependency, a data identifier for the intent request structure is generated, wherein the dependency edge type specifically includes result inheritance, condition binding, aggregation preconditioning, and context reference; Determine whether the data identifier can break the preset circular dependency; If possible, a preset buffer intent node is inserted. Based on the buffer intent node, the scheduling resources required by the data identifier are configured. Through the scheduling resources, dependency isolation processing is performed in the pre-received interaction instructions. Specifically, the scheduling resources include execution conditions, data input sources, and data output destinations. The interaction instructions specifically include concurrent instructions and asynchronous instructions.

4. The interaction optimization method based on big data language model according to claim 1, characterized in that, The step of determining whether the language model can fully execute the instruction requirement corresponding to the composite request further includes: Obtain the execution exception information of the composite request, wherein the execution exception information specifically includes the need for tool assistance, the model's inability to understand, insufficient logical judgment, dependence on external context, and information to be supplemented by the user; Determine whether the execution exception information detects a preset non-executable item; If so, based on the non-executable item, a preset reconstruction content is marked in the composite request, and according to the reconstruction content, the user is restricted from using a preset clarification interaction mode with the language model.

5. The interaction optimization method based on big data language model according to claim 1, characterized in that, The step of determining whether the interaction intent chain matches the composite request further includes: Based on the interaction intent chain, the composite request is semantically segmented according to a preset method, and the corresponding number of semantic segments is collected. Specifically, the semantic segmentation includes task action, data object, condition constraint and expected result. Determine whether the number of semantic fragments matches the number of nodes in the interaction intent chain; If not, then based on the number of semantic fragments, the corresponding abnormal node is mapped in the interaction intent chain, and based on the abnormal node, the corresponding matching gap is translated from the composite request.

6. The interaction optimization method based on big data language model according to claim 1, characterized in that, The step of obtaining a complex request from a user to the language model based on a pre-trained language model further includes: Based on the user's input carrier to the language model, the input type of the composite request is obtained, wherein the input type specifically includes single-turn natural language text input, multi-turn dialogue aggregation input, and structured template triggered input; Determine whether the input type belongs to a pre-recorded continuation request; If so, the structured representation information in the composite request is identified, and the execution instructions corresponding to the composite request are dynamically constructed based on the structured representation information. Specifically, the structured representation information includes action semantics, target semantics, limiting conditions, and sequence relationships.

7. An interaction optimization system based on a big data language model, characterized in that, include: The acquisition module is used to acquire the user's complex request to the language model based on the pre-trained language model; The judgment module is used to determine whether the language model can completely execute the instruction requirements corresponding to the composite request; An execution module is used to identify the corresponding syntactic structure features from the composite request if not otherwise, construct a preset task structure graph based on the syntactic structure features, extract the structure of the composite request based on the task structure graph, and generate the user's interaction intent chain. The task structure graph specifically includes task nodes and dependencies, and the structure extraction specifically includes actions, objects, conditions, and purposes. The second judgment module is used to determine whether the interaction intent chain matches the composite request; The second execution module is used to extract the interaction intent trigger word from the interaction intent chain if a match is found, execute the corresponding semantic instruction through the language model based on the interaction intent trigger word, obtain the data dependency between the semantic instructions, and generate the user's intent request structure according to the data dependency. The interaction intent trigger word specifically includes interaction verbs and conjunctions, the semantic instruction specifically includes agent, patient, manner, time and scope, and the intent request structure specifically includes parallel intent structure and nested intent structure. The execution module further includes: The acquisition unit is used to acquire the logical connection relationship of the task structure graph based on the core intent features of each task node. Specifically, the core intent features include operation intent, behavior object, condition features and output expectation, and the logical connection relationship includes sequential execution, conditional execution, loop execution and concurrent execution. A judgment unit is used to determine whether the logical connection relationship refers to the same object to be executed; An execution unit is configured to, if so, collect the intent flow path of the task structure graph, detect the upstream data input of the task node based on the intent flow path, merge the intents of the task structure graph based on the upstream data input, and construct the user's intent chain context. The intent flow path specifically includes a semantic reference path, an exception rollback path, and a state flow path.

8. The interaction optimization system based on big data language model according to claim 7, characterized in that, Also includes: A module is established to establish dependency edge information between intent units based on the intent units corresponding to the task structure graph, wherein the dependency edge information specifically includes sequential dependency edges and conditional dependency edges. The third judgment module is used to determine whether the dependency edge information matches the preset task scheduling queue; The third execution module is used to identify the verb object in the intent unit if no, and use the verb object as the prerequisite task dependency of each node. According to the execution scenario of the task structure graph, the triggering conditions of the prerequisite task dependency are dynamically adjusted. The execution scenario specifically includes concurrent scenario and asynchronous scenario.

Images