A cloud computing platform supports edge coordination computing power allocation method and system

Abstract

The application relates to the technical field of computing power allocation, and provides a computing power allocation method and system supported by an edge collaboration of a cloud computing platform, which comprises an architecture of deploying a complete dialogue model by a center node, carrying a light node model by an edge node, and configuring a semantic recognition module by a local node, the local node generates a conversation constraint set through a semantic recognition and semantic compression algorithm, long conversation model omission of user early demands is avoided, and dialogue accuracy is improved. In addition, a semantic complexity coefficient is obtained by analyzing the constraint set, the edge node collects self-computing power related parameters to evaluate node states, divides computing power rich and tight nodes, the computing power tight node processes low complexity tasks according to the self-computing power margin, the rest of the tasks are scheduled to the center node or adjacent computing power rich nodes, the tasks are distributed according to the complexity coefficient, the edge node computing power is fully utilized, and the overall computing power utilization efficiency is improved.

Description

Technical Field

[0001] This invention relates to the field of computing power allocation technology, and more specifically, to a computing power allocation method and system that supports edge collaboration in a cloud computing platform. Background Technology

[0002] The content in this section only provides background information related to this invention and may not constitute prior art.

[0003] With the rapid iteration of Artificial Intelligence (AI) and Internet of Things (IoT) technologies, conversational AI dialogue systems (DS) have been widely applied in various scenarios such as intelligent customer service, personal assistants, and industrial interaction. The efficient operation of these systems relies on the collaborative support of cloud computing and edge computing. Cloud computing refers to a service model that provides elastically scalable computing, storage, and network resources via the Internet. It can provide powerful computing power and global management capabilities for AI dialogue models, and can deploy large-scale, highly complex complete AI models to meet the dialogue needs of various complex scenarios. Edge computing, on the other hand, is a distributed architecture that deploys computing and storage resources close to end users or data generation points. Its core function is to shorten data transmission distances, reduce network latency, alleviate the load pressure on cloud central nodes, and achieve rapid local data processing.

[0004] In existing cloud-edge collaborative architectures, edge nodes, as key hubs connecting the cloud and end users, mostly perform auxiliary functions such as request preprocessing, caching acceleration, intelligent routing, and traffic optimization. They primarily optimize data transmission efficiency and alleviate bandwidth pressure on the core network, without deeply participating in the core computational aspects of AI dialogue tasks. Their own computing resources are not fully explored and utilized. Furthermore, the AI ​​models relied upon by current AI dialogue systems have fixed-length context windows. These context windows, essentially the AI's short-term memory, determine the length of historical interaction information the model can reference and access in a single dialogue. When the conversation is long and involves many rounds of interaction, early dialogue information exceeding the window length is automatically truncated. This prevents the AI ​​model from fully retaining and recognizing user requests from earlier stages of the conversation, leading to responses deviating from user expectations and missing prior requests, severely impacting the user experience. Summary of the Invention

[0005] The purpose of this invention is to provide a computing power allocation method and system for cloud computing platforms that support edge collaboration, thereby improving the aforementioned problems. To achieve the above objective, the technical solution adopted by this invention is as follows:

[0006] Firstly, this application provides a method for allocating computing power to support edge collaboration in a cloud computing platform, including a central node and multiple edge nodes communicatively connected to the central node, each edge node connecting to multiple local nodes; the central node deploys a complete model for dialogue, and the edge nodes deploy lightweight node models of the complete model; the local nodes deploy semantic recognition modules; the method includes:

[0007] The system collects all user-inputted requests within the corresponding session process via local nodes. The semantic recognition module identifies user-marked unsatisfactory interactions within these requests and generates corresponding prohibitive constraints. Simultaneously, it extracts all user-asked questions and user-expressed satisfaction feedback statements and uses a semantic compression algorithm to treat these extracted statements as session preconditions. The constraints and preconditions are then merged to form a constraint set.

[0008] Perform semantic complexity parsing on the constraint set to quantify and generate constraint complexity coefficients; use the constraint set as constraints for the new dialogue, package it with the user's new requests, and submit it to the corresponding edge node;

[0009] Each edge node collects its own target parameters in real time, including processor utilization, memory usage, and task waiting queue length; the collected target parameters are input into a preset node status evaluation function, which outputs the node status value of the corresponding edge node; based on the comparison results between the node status value and the preset status threshold, all edge nodes are marked as nodes with abundant computing power and nodes with scarce computing power.

[0010] For nodes with limited computing power, calculate the current executable computing power reserve of the node; based on the executable computing power reserve, select packages with a total computation amount not exceeding the reserve and a complexity coefficient lower than the threshold, input them into the node model for computation; and feed the computation results back to the corresponding local node; the remaining packages are uploaded to the central node or nearby nodes with abundant computing power for computation, and the computation results are forwarded to the corresponding local node via the nodes with limited computing power.

[0011] Furthermore, the steps of collecting all user-inputted requests within the corresponding session process via local nodes specifically include:

[0012] While starting the corresponding session process on the local node, a dedicated interactive content collection channel for the session process is simultaneously established. The collection channel is only connected to the input port within the session process for users to enter content.

[0013] Throughout the entire lifecycle of the session, the source attribution of all interactive content flowing within the session is continuously verified to distinguish between content entered by the user and AI responses generated by the node model or the complete model.

[0014] Completely remove content that is confirmed to be AI-generated after verification, retaining only all content entered by the user after verification. At the same time, the retained user-entered content is sequentially collected according to the interaction timeline within the conversation process to form a complete set of user request content for the corresponding conversation process.

[0015] Furthermore, the steps for generating the corresponding prohibitive constraints specifically include:

[0016] The system monitors the human-computer interaction interface at the local node in real time. When a negative feedback control is triggered on the human-computer interaction interface, the system locates the preset time window before the negative feedback control is triggered and marks the last AI response within the preset time window as content to be processed. At the same time, the system collects the user's opinion text after the negative feedback control is triggered.

[0017] The semantic recognition module breaks down the content to be processed sentence by sentence to extract the target sentences that trigger the negative feedback control; the opinion text is semantically parsed to extract the prohibited points; the target sentences and prohibited points are associated and encapsulated to generate prohibitive constraints.

[0018] Furthermore, the steps of performing semantic complexity parsing on the constraint set specifically include:

[0019] Edge nodes perform syntactic structure parsing on the received constraint set, decompose the constraint set into multiple independent constraint units according to the preset semantic boundaries, identify the subject-verb-object structure and modifiers in each constraint unit, and count the number of entities and the length of the relation chain contained in the constraint unit.

[0020] Based on the statistically determined number of entities and the length of the relationship chain, combined with the distribution density of negation words and condition words in the constraint unit, the structural complexity coefficient of the constraint unit is calculated.

[0021] The structural complexity coefficients of all constraint units are summed by weight, and an association correction factor is introduced during the summation process based on the degree of logical association between each constraint unit. The result of the weighted summation is then quantified as the constraint complexity coefficient of the entire constraint set.

[0022] Furthermore, the node state evaluation function is constructed through the following steps:

[0023] Collect all target parameters of the edge nodes during the historical steady-state operation period, perform mean calculation on the target parameters of the same type to obtain the steady-state reference value of each type of target parameter of the corresponding edge node; subtract the target parameter collected at the corresponding time from the steady-state reference value of each target parameter to obtain the remaining capacity value of each target parameter.

[0024] Perform a product calculation on all remaining capacity values ​​collected at the same time, and then take the reciprocal of the calculation result to obtain the node state value of the edge node at the corresponding time; solidify the above calculation logic into a node state evaluation function.

[0025] Furthermore, the node state evaluation function is:

[0026]

[0027] In the formula, This refers to the node's state value. This represents the total number of samples taken within the steady-state period. For the first The next sampling time; For sampling index; In order to be in Processor utilization rate collected in real time; In order to be in Memory usage rate collected in real time; In order to be in The length of the task waiting queue for real-time data collection.

[0028] Furthermore, the step of calculating the current executable computing power reserve of the node specifically includes:

[0029] By collecting the current processor utilization, memory usage, and task waiting queue length of nodes with high computing power, the amount of computing resources already put into service can be determined based on the processor utilization and memory usage.

[0030] Iterate through each unprocessed packet in the task waiting queue, read the constraint complexity coefficient carried by each packet, input the constraint complexity coefficient into the preset computing power consumption mapping table, the computing power consumption mapping table records the correspondence between different complexity coefficient ranges and the required computing power resources, obtain the expected computing power resources consumed by each packet through mapping, and then add up the expected computing power resources consumed by all packets to form the estimated value of computing power resources required to complete the task waiting queue.

[0031] Subtract the total computing power resources of nodes with tight computing power from the computing power resources already put into service, and then subtract the estimated value of computing power resources. The difference is taken as the executable computing power reserve.

[0032] Furthermore, the process of uploading the remaining packets to nearby nodes with abundant computing power includes:

[0033] Based on a pre-defined network topology table, nodes with limited computing power select several nodes with abundant computing power that have the lowest communication latency as candidate collaborative nodes.

[0034] Send computation requests carrying constraint complexity coefficients to each candidate collaborative node, and receive the current node status value and available computing power commitment duration returned by the candidate collaborative nodes;

[0035] The candidate cooperating node with the highest node status value and the longest available computing power commitment time is selected as the target cooperating node, and the remaining packets are split and transmitted to the target cooperating node through an encrypted tunnel.

[0036] Upon receiving the computation results returned by the target cooperating node, the node with limited computing power reassembles the computation results according to the numbering order at the time of splitting, and forwards the reassembled complete computation results to the corresponding local node.

[0037] Furthermore, it also includes:

[0038] The central node periodically broadcasts a computing power status query command to all edge nodes, and each edge node reports its own node status value and available computing power. The central node generates a preset network topology table based on the reported information and distributes it to each edge node.

[0039] Secondly, this application also provides a computing power allocation system for edge collaboration supported by a cloud computing platform, comprising:

[0040] The constraint set generation module is used to collect all user-inputted requests within the corresponding session process through local nodes, identify user-marked unsatisfactory interactions in the request content through the semantic recognition module, and generate corresponding prohibitive constraints; at the same time, it extracts all user-asked questions and user-expressed satisfaction feedback statements, and uses a semantic compression algorithm to use the extracted statements as session preconditions; the constraint conditions and preconditions are merged to form a constraint set;

[0041] The constraint quantization module is used to perform semantic complexity parsing on the constraint set, quantize and generate constraint complexity coefficients; and package the constraint set as constraints for a new dialogue with the user's new requests and submit them to the corresponding edge node.

[0042] The node evaluation module is used to collect target parameters of each edge node in real time, including processor utilization, memory usage, and task waiting queue length; input the collected target parameters into a preset node status evaluation function, and output the node status value of the corresponding edge node; based on the comparison result of the node status value and the preset status threshold, all edge nodes are marked as nodes with abundant computing power and nodes with scarce computing power.

[0043] The computing power scheduling module is used to calculate the current executable computing power reserve of nodes with limited computing power; based on the executable computing power reserve, it selects packages with a total computation amount not exceeding the reserve and a complexity coefficient lower than the threshold, inputs them into the node model for computation, and feeds back the computation results to the corresponding local node; the remaining packages are uploaded to the central node or nearby nodes with abundant computing power for computation, and the computation results are forwarded to the corresponding local node via the nodes with limited computing power.

[0044] The beneficial effects of this invention are as follows:

[0045] This invention utilizes a hierarchical architecture: a central node deploying a complete dialogue model, edge nodes equipped with lightweight processing node models, and local nodes configured with semantic recognition modules. This architecture enables coordinated allocation of computing power. First, local nodes collect the user's requests throughout the entire conversation. The semantic recognition module identifies user-marked unsatisfactory interactions and generates constraints. Simultaneously, it extracts user questions and feedback statements expressing satisfaction. Using a semantic compression algorithm, it forms preconditions for the conversation. The constraints and preconditions are then merged into a constraint set, thereby refining and retaining the core user requests throughout the conversation. This effectively avoids missing user requests from earlier stages during long conversations, significantly improving the accuracy of user interaction. Subsequently, the constraint set undergoes semantic compression... The system parses and generates corresponding constraint complexity coefficients. These constraint sets are then packaged as new dialogue restrictions and user requests and sent to the corresponding edge nodes. Each edge node collects its processor utilization, memory usage, and task queue length in real time. A pre-defined node state evaluation function is used to obtain node state values, thus classifying edge nodes into those with abundant and those with limited computing power. For edge nodes with limited computing power, the available computing power is calculated. Task packages with low complexity and matching total computational load are selected based on the constraint complexity coefficients and assigned to the lightweight node model of that edge node for computation. The remaining task packages are uploaded to the central node or nearby nodes with abundant computing power for computation. Finally, the computation results are fed back to the local node. This approach fully utilizes the computing power of edge nodes beyond routine request preprocessing, caching acceleration, intelligent routing, and traffic optimization. The technique of allocating computational tasks based on complexity coefficients effectively improves the overall efficiency of computing power utilization. Attached Figure Description

[0046] Figure 1 A flowchart illustrating a cloud computing platform-supported edge collaboration computing power allocation method provided by the present invention;

[0047] Figure 2 This is a system architecture diagram of the collaboration between the cloud computing platform and edge nodes in this invention;

[0048] Figure 3 This is a flowchart of constraint set generation in this invention;

[0049] Figure 4 This is a flowchart of the computing power allocation and scheduling for nodes with high computing power in this invention;

[0050] Figure 5 This is a schematic diagram of a cloud computing platform supporting edge collaboration computing power allocation system provided by the present invention.

[0051] In the diagram: 201, constraint set generation module; 202, constraint quantization module; 203, node evaluation module; 204, computing power scheduling module. Detailed Implementation

[0052] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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 some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0053] like Figure 1 As shown in the figure, the cloud computing platform supporting edge collaboration proposed in this embodiment of the invention has the following architecture: Figure 2 As shown, the method includes a central node and multiple edge nodes that communicate with the central node, with each edge node connecting to multiple local nodes; the central node deploys a complete model for dialogue, and the edge nodes deploy lightweight node models of the complete model; the local nodes deploy semantic recognition modules; the method includes:

[0054] S101: Collect all user-inputted requests within the corresponding session process through local nodes; identify user-marked unsatisfactory interactions in the request content using a semantic recognition module and generate corresponding prohibitive constraints; simultaneously extract all user-asked questions and user-expressed satisfaction feedback statements, and use a semantic compression algorithm to use the extracted statements as session preconditions; merge the constraints and preconditions to form a constraint set.

[0055] The principle behind this step is to accurately collect and filter user conversation requests through local nodes, and combine semantic recognition technology to extract prohibitive requirements and core needs from user interactions, forming a unified constraint set. This avoids ineffective computing power consumption, ensures that subsequent computing power allocation aligns with actual user needs, improves human-computer interaction experience and computing power utilization efficiency, and at the same time, the semantic recognition module of the local node can determine the user's requirements (i.e., the constraint set) in advance, so that the model will not miss the user's requirements due to contextual limitations during dialogue, thereby improving the accuracy of the dialogue content.

[0056] Specifically, such as Figure 3As shown, this step first collects all the requests input by the user within the corresponding session process through local nodes. The principle is that local nodes are equipped with semantic recognition modules and are close to the user terminal, enabling real-time collection of session content. Compared with remote collection by central or edge nodes, this can effectively reduce data transmission latency and redundancy, while avoiding content loss caused by cross-node transmission. It ensures that the collected requests are authentic and complete, providing a reliable data foundation for the generation of subsequent constraints and preconditions, while reducing the collection pressure on central and edge nodes.

[0057] The purpose of collecting all user-inputted requests within the corresponding session process is to further ensure the relevance and purity of the collected content, and to avoid irrelevant data interfering with subsequent processing. The specific steps are as follows: Simultaneously, a dedicated interactive content collection channel is established for the corresponding session process when it is started on the local node. This collection channel only connects to the input port within the session process where users can enter content. The principle is that the dedicated collection channel enables targeted collection of interactive content. Connecting only to the user input port allows for precise targeting of user-entered content, avoiding confusion with content from other session processes or system processes, and preventing the collection of redundant data not input by the user. This reduces collection redundancy, improves collection efficiency, and ensures the privacy of session data, preventing interference between the session content of different users.

[0058] Throughout the entire session, source attribution verification is continuously performed on all interactive content flowing within the session to distinguish between content entered by the user and AI responses generated by the node model or the complete model. The principle is that user input and AI feedback will coexist in the session. Without attribution verification, AI responses will be mixed in with user requests, leading to deviations in subsequent semantic parsing. Attribution verification can be accurately distinguished through content features (such as the natural language coherence of user input and the formatting features of AI output). This verification process ensures that only the user's true requests are processed, eliminating invalid interference from AI responses and improving the accuracy of subsequent constraint and precondition generation. Content confirmed as AI responses after verification is completely removed, retaining only all user-entered content verified through verification. Simultaneously, the retained user-entered content is sequentially aggregated according to the interaction timeline within the conversation, forming a complete set of user requests for that conversation. The principle is that removing AI responses avoids invalid data consuming processing resources, and the chronological aggregation restores the logical evolution of user requests, conforming to the natural laws of conversational interaction. This reduces data volume, lowers processing pressure on edge nodes, and the chronologically aggregated request set fully reflects changes in user needs, facilitating accurate extraction of key information and avoiding constraint deviations caused by content chaos.

[0059] After collecting user requests, a semantic recognition module deployed on local nodes identifies user-marked unsatisfactory interactions within the request content and generates corresponding prohibitive constraints. The principle behind this is that the semantic recognition module possesses the ability to analyze sentiment and extract key information (e.g., the deep learning-based text semantic analysis system disclosed in CN119721046A), accurately capturing negative user feedback and transforming unsatisfactory interactions into explicit prohibitive requirements, preventing similar issues from recurring in subsequent AI responses. By limiting the direction of subsequent calculations through constraints, the prohibitive requirements of the customer are determined in advance, enriching the constraint set and preventing the model from overlooking the customer's core taboos due to contextual limitations, thus ensuring the accuracy of the dialogue content. Simultaneously, it reduces invalid computation and minimizes the waste of computing power between central and edge nodes.

[0060] The generation of corresponding prohibitive constraints is to ensure the accuracy and enforceability of the constraints and avoid deviations in subsequent computing power allocation caused by fuzzy constraints. The specific steps are as follows: Real-time monitoring of the human-computer interaction interface at the local node; when a negative feedback control is triggered on the human-computer interaction interface, the preset time window before the negative feedback control is triggered is located, and the last AI answer within the preset time window is marked as content to be processed. At the same time, the user's input opinion text after the negative feedback control is triggered is collected. The principle is that the negative feedback control is a direct interactive entry point for users to express dissatisfaction, the preset time window can accurately locate the specific AI answer that caused the user's dissatisfaction, and the opinion text can clearly point out the user's specific dissatisfaction. The combination of the two can ensure the pertinence of the constraints. The beneficial effect of this monitoring and collection method is that it can quickly locate the AI ​​answer to the problem, avoid blind screening, and, combined with the opinion text, can greatly improve the accuracy of the constraints and reduce the generation of invalid constraints. The semantic recognition module breaks down the content to be processed sentence by sentence, extracts the target sentences that trigger negative feedback controls, performs semantic parsing on the opinion text, extracts the prohibited points, and associates and encapsulates the target sentences with the prohibited points to generate prohibitive constraints. The principle is that sentence-by-sentence breakdown of the content to be processed can accurately locate the core of the problem, semantic parsing of the opinion text can clearly identify the specific content that the user prohibits, and associative encapsulation can make the constraints clear in direction and executable, making it easier for subsequent node models or complete models to avoid related problems when performing calculations. It ensures that the prohibitive constraints accurately correspond to the user's dissatisfaction. In subsequent computing power allocation, edge nodes or central nodes can avoid invalid calculations based on the constraints, improve the accuracy of AI answers, and further optimize the user interaction experience.

[0061] While generating prohibitive constraints, all user queries and feedback statements expressing satisfaction are extracted. A semantic compression algorithm is then used to apply these extracted statements as preconditions for the conversation. The principle is that user queries directly reflect core needs, and satisfactory feedback statements serve as a reference for effective interaction. Semantic compression algorithms can streamline statements while preserving core information (e.g., using lightweight pre-trained compression models like DistilBERT / TinyBERT), avoiding redundant information that consumes transmission and processing resources. The extracted preconditions provide clear demand guidance for subsequent new dialogues, clarifying the user's core needs and preferences. Semantic compression reduces data transmission volume and processing pressure on edge nodes, improving processing efficiency while ensuring the simplicity and effectiveness of the preconditions.

[0062] Finally, the constraints and preconditions are merged to form a constraint set. The principle behind this is that the constraint set integrates the user's prohibitive and referential requirements, providing a unified and complete basis for subsequent semantic complexity parsing and computing power allocation in S102, avoiding unreasonable computing power allocation caused by scattered requirements. The beneficial effects of this merging operation are that it makes subsequent computing power allocation decisions more targeted, simplifies the processing flow of edge nodes, improves the efficiency and accuracy of computing power allocation, and lays the foundation for the orderly advancement of the entire computing power allocation method. Simultaneously, by pre-integrating a complete constraint set through local nodes, all customer requirements are clearly defined, completely resolving the problem of the model omitting customer requirements due to contextual limitations, and further improving the accuracy of the dialogue content.

[0063] Based on the above, this invention illustrates a specific application scenario: Suppose a customer initiates a session on a local node and inquires about "how to write a letter home, starting with greetings to parents and siblings, with a word limit of 1500 words, using simple and sincere language, avoiding flowery language." During the interaction, the edge node's node model outputs an AI response: "When writing a letter home, you can start with a simple greeting to parents, then describe your current situation. There is no need to strictly limit the order of greetings, and the word count should be controlled between 1200 and 1800 words." The customer believes that this response does not meet the core requirement of "greeting parents and siblings first" and that the word count range is inaccurate. Therefore, the customer clicks the "Dissatisfied" negative feedback control on the local node's human-computer interaction interface and enters the feedback text: "You must greet parents and siblings in order, then expand on other content. The word count is strictly limited to around 1500 words, not exceeding the range of 1450-1550 words, and vague expressions are prohibited." While initiating the session, the local node simultaneously establishes a dedicated data collection channel, connecting only to the customer's input port. Throughout the session, it continuously verifies the source attribution, discarding the AI-generated answers from the node model and retaining only the customer's input, such as "How to write a family letter, greeting parents and brothers first, with a word limit of 1500 words, using simple and sincere language, avoiding flowery language," and "You must greet parents and brothers in order before expanding on other content, with a strict word limit of around 1500 words, not exceeding the range of 1450-1550 words, and prohibiting vague expressions." This information is then compiled into a complete set of requests according to the interaction sequence. After the semantic recognition module detects the triggering of the negative feedback control, it locates the aforementioned AI response within the preset time window before the trigger and marks it as content to be processed. After breaking it down sentence by sentence, it extracts the target statement "When writing a letter home, you can first greet your parents simply, and then describe your recent situation. There is no need to strictly limit the order of greetings, and the word count should be controlled between 1200-1800 words." It analyzes the customer's opinion text to extract the prohibition points "prohibit vaguely limiting the order of greetings, prohibit the word count range from 1450-1550 words, and prohibit vague expressions," and associates and encapsulates them to generate prohibitive constraints. At the same time, it extracts the customer's question statement "How to write a letter home, where you should greet your parents and brothers first, limit the word count to 1500 words, and use simple and sincere language, avoiding flowery language" as a precondition for the conversation. It merges the two to form a constraint set, providing a foundation for the semantic complexity analysis in S102.

[0064] S102, perform semantic complexity parsing on the constraint set, quantize and generate constraint complexity coefficients; use the constraint set as constraints for the new dialogue, package it with the user's new requests and submit it to the corresponding edge node.

[0065] Specifically, the semantic complexity parsing of constraint sets essentially transforms abstract natural language constraints into quantifiable numerical indicators, providing an intuitive and computable basis for subsequent computing power allocation decisions. This avoids unreasonable computing power allocation caused by semantic ambiguity or unclear complexity of constraint sets. Meanwhile, the packaged submission operation ensures that edge nodes can synchronously obtain complete user constraint requirements when receiving new requests, without having to repeatedly call local node resources to obtain constraint sets, reducing cross-node data transmission and lowering latency.

[0066] The step of performing semantic complexity parsing on the constraint set is a key prerequisite for achieving accurate allocation of computing power. Specifically, it includes: edge nodes performing syntactic structure parsing on the received constraint set, decomposing the constraint set into multiple independent constraint units according to the preset semantic boundaries, identifying the subject-verb-object structure and modifiers in each constraint unit, and counting the number of entities and the length of the relation chain contained in the constraint unit. The principle is that a constraint set is usually a collection of multiple interrelated or independent constraints. If the complexity of the entire constraint set is directly evaluated, semantic interference between constraints can easily lead to evaluation bias. By pre-setting semantic boundaries, the constraint set can be decomposed into independent and complete constraint units based on the syntactic rules and semantic logic of natural language. Each constraint unit corresponds to a specific user requirement. Identifying subject-verb-object structures and modifiers, and counting the number of entities and the length of relational chains, is because the more entities and the longer the relational chains, the richer the semantic information and the more complex the logic of the constraint unit, and the more computational resources are required. This achieves a refined decomposition of the constraint set, eliminates semantic interference between constraint units, and provides reliable data support for subsequent complexity quantification by statistically analyzing core indicators, ensuring the accuracy of complexity evaluation, avoiding evaluation bias caused by overall parsing, and laying the foundation for the rational allocation of subsequent computing power.

[0067] Based on the statistically determined number of entities and the length of the relational chain, combined with the distribution density of negation words and conditional words in the constraint unit, the structural complexity coefficient of the constraint unit is calculated. The principle behind this step is that while the number of entities and the length of the relational chain are fundamental indicators of the structural complexity of a constraint unit, these two indicators alone cannot fully reflect the computational difficulty of the constraint. The presence of negation words (such as "prohibited" and "cannot") increases the difficulty of semantic parsing, requiring additional computing power to identify negation logic and circumvent prohibitive requirements. Conversely, a higher distribution density of conditional words (such as "must" and "only if") indicates a stricter execution boundary and more rigorous logic for the constraint, resulting in higher computational complexity. Combining these three factors in the calculation comprehensively covers the factors influencing the complexity of the constraint unit, thus overcoming the limitations of a single indicator evaluation. By integrating multi-dimensional indicators, the structural complexity coefficient of each constraint unit is made more closely aligned with actual computational needs, accurately reflecting the computational power required by the constraint unit, and providing a precise unit foundation for the subsequent quantification of the overall constraint set complexity.

[0068] The structural complexity coefficients of all constraint units are weighted and summed. During the summation process, a correlation correction factor is introduced based on the degree of logical correlation between each constraint unit. The result of the weighted summation is then quantified as the overall constraint complexity coefficient of the constraint set. The principle behind this step is that different constraint units have different levels of importance in the constraint set, and their corresponding weights also differ. The weighted summation can reflect the differences in importance among the constraint units. Furthermore, there may be logical correlations between constraint units, such as parallel, progressive, or mutually exclusive relationships. For example, "prohibit fuzzy expressions" and "strictly limit the number of words to 1450-1550" are parallel constraints. The superposition of their complexities needs to consider the correlation relationship. The correlation correction factor can correct the complexity deviation caused by this correlation, avoiding the distortion of the overall complexity assessment caused by simple summation.

[0069] The specific formula for calculating the constraint complexity coefficient is as follows:

[0070] (1)

[0071] In the formula, The constraint complexity coefficient for the entire constraint set; The total number of independent constraint units obtained after parsing the syntactic structure of the constraint set; For indexing; For the first The weights of each constraint element are allocated according to the importance of each constraint element in the constraint set, and the total weights are 1. For the first The structural complexity coefficient of a constraint unit is calculated from the number of entities in the constraint unit, the length of the relation chain, and the distribution density of negation words and condition words. The larger the value, the higher the computational complexity of the constraint unit. The correlation correction factor is set according to the degree of logical correlation between each constraint unit, and its value range is (0,1]. If the constraint units are parallelly correlated, the correlation correction factor value is close to 1. If there are complex correlations such as mutual exclusion or progression, the value is appropriately reduced to correct the complexity assessment deviation caused by the correlation relationship between constraint units.

[0072] To illustrate with a specific application scenario: Following the constraint set generated by S101, this constraint set includes the constraints "prohibit vague restrictions on the order of greetings, prohibit the word count range from 1450-1550 words, prohibit vague expressions" and the preconditions "when writing a family letter, you must first greet your parents and brothers, the word count should be around 1500 words, the language should be simple and sincere, and avoid flowery language". After receiving the constraint set, the edge node first performs syntactic structure parsing, breaking it down into four independent constraint units according to the preset semantic boundaries: Unit 1 "prohibits ambiguous restrictions on greeting order", Unit 2 "prohibits word count range exceeding 1450-1550 characters", Unit 3 "prohibits ambiguous expressions", and Unit 4 "when writing a family letter, one must first greet parents and elder brothers, with a word count of around 1500 characters, using simple and sincere language, and avoiding ornate language". Then, it identifies the subject, verb, object, and modifiers of each unit, and counts the entities for Unit 1 as "greeting order" with a relation chain length of 1; Unit 2 as "word count range" and "1450-1550 characters" with a relation chain length of 2; Unit 3 as "expression" with a relation chain length of 1; and Unit 4 as "family letter", "parents and elder brothers", "word count", and "language" with a relation chain length of 4. Next, considering the distribution density of negation words and condition words in each unit, units 1, 2, and 3 contain one negation word and have low condition word density, with structural complexity coefficients of 0.3, 0.4, and 0.3 respectively; unit 4 contains one condition word "need", has many entities and a long relationship chain, with a structural complexity coefficient of 0.8. Finally, the coefficients of each unit are weighted and summed (weights are allocated according to the importance of constraints, with unit 4 having a weight of 0.4 and the others 0.2), and since the four units are parallelly related, a correlation correction factor of 0.9 is introduced. Based on formula (1), the overall constraint complexity coefficient is calculated to be 0.522. At the same time, this constraint set is used as a new dialogue constraint, packaged with the user's new request "generate a family letter that meets the requirements", and submitted to the corresponding edge node to provide a basis for subsequent computing power allocation.

[0073] S103 collects its own target parameters in real time through each edge node, including processor utilization, memory usage and task waiting queue length; inputs the collected target parameters into a preset node status evaluation function, and outputs the node status value of the corresponding edge node; based on the comparison result of the node status value and the preset status threshold, all edge nodes are marked as nodes with abundant computing power and nodes with scarce computing power.

[0074] Specifically, each edge node first collects its own target parameters in real time. The aim is to directly reflect the node's computing resource utilization by collecting processor utilization, the consumption of memory resources by memory utilization, and the task queue length by task waiting length, which reflects the pressure of currently pending tasks on the node. The combination of these three metrics provides a comprehensive and accurate reflection of the real-time computing load status of the edge nodes. After collection, the collected target parameters are input into a preset node status evaluation function, which outputs the corresponding node status value. The principle is that the node status evaluation function can transform abstract target parameters into quantifiable and comparable node status values, solving the problem of incomparable direct comparison of different types of target parameters. This quantitative evaluation enables a unified standard for measuring the status of each edge node. Subsequently, based on the comparison results between the node status value and the preset status threshold, all edge nodes are marked as nodes with abundant computing power and nodes with strained computing power. The principle is that the preset status threshold is set based on the load limit of the normal operation of the edge node. The higher the node status value, the less remaining computing power the node has and the heavier the load. Conversely, the lower the value, the more abundant the computing power. By clearly classifying the nodes, the computing power status of each node can be quickly located, avoiding the assignment of tasks to nodes with strained computing power, which would lead to computing delays. At the same time, the remaining resources of nodes with abundant computing power can be fully utilized to achieve reasonable allocation of computing power resources.

[0075] The construction of the node state evaluation function is based on calibrating the evaluation criteria by combining the historical operating characteristics of the edge nodes themselves, thus avoiding deviations caused by general evaluation logic. The specific construction steps are as follows: first, collect all target parameters of the edge nodes during their historical steady-state operating cycles, including processor utilization. Memory usage Task waiting queue length For target parameters of the same type, mean calculation is performed to obtain the steady-state benchmark values ​​of each type of target parameter for the corresponding edge node. The principle is that the target parameters within the historical steady-state operating cycle can reflect the load benchmark when the node is operating normally. Mean calculation can eliminate the influence of instantaneous fluctuations on the benchmark value, ensuring the stability and representativeness of the benchmark value. The corresponding formula is as follows:

[0076] (2)

[0077] (3)

[0078] (4)

[0079] In the formula, This represents the arithmetic mean of processor utilization. This is the arithmetic mean of memory usage. This is the arithmetic mean of the lengths of the task waiting queues; This represents the total number of samples taken within the steady-state period. For the first The next sampling time; This is the sampling index.

[0080] Next, the steady-state baseline value of each target parameter is subtracted from the target parameter collected at the corresponding time point to obtain the remaining capacity value of each target parameter. The principle is that the remaining capacity value directly reflects the available resources for each target parameter. A larger remaining capacity value for the processor and memory indicates more abundant resources, and a larger remaining capacity value for the task waiting queue length indicates a higher queue idle rate. The corresponding calculation formula is as follows:

[0081] (5)

[0082] (6)

[0083] (7)

[0084] In the formula, This represents the remaining capacity of the processor. This represents the remaining memory capacity. The remaining capacity value of the task waiting queue.

[0085] Finally, the remaining capacity values ​​collected at the same time are multiplied together, and the reciprocal of the result is taken to obtain the node state value of the edge node at the corresponding time. This calculation logic is then solidified into a node state evaluation function. The principle is that the product calculation can comprehensively consider the remaining status of various target parameters, avoiding the one-sidedness of single-parameter evaluation. Taking the reciprocal ensures a positive correlation between the node state value and the load; that is, the smaller the remaining capacity, the larger the state value, and the heavier the load. In other words, when the remaining capacity of any resource approaches 0, the node state value will increase sharply, accurately reflecting the critical state of the node about to be overloaded. The specific calculation formula is as follows:

[0086] (8)

[0087] In the formula, This represents the node state value. Combining formulas (2) to (8), we obtain:

[0088] (9)

[0089] S104: For nodes with limited computing power, calculate the current executable computing power reserve of the node; based on the executable computing power reserve, select packages whose total computation amount does not exceed the reserve and whose complexity coefficient is lower than the threshold, input them into the node model for computation; and feed back the computation results to the corresponding local node; the remaining packages are uploaded to the central node or nearby nodes with abundant computing power for computation, and the computation results are forwarded to the corresponding local node via the nodes with limited computing power.

[0090] Specifically, such as Figure 4 As shown, the current executable computing power reserve of the node is first calculated. The principle is to accurately grasp the remaining available computing power of the node and avoid blindly allocating tasks, which may lead to node overload or resource waste. The specific implementation method is as follows: First, the current processor utilization rate, memory usage rate and task waiting queue length are collected by the node with computing power shortage. The amount of computing power resources already put into service is determined based on the processor utilization rate and memory usage rate. The principle is that the processor utilization rate and memory usage rate directly reflect the core computing power resources currently consumed by the node. The combination of the two can accurately quantify the scale of computing power put into service and avoid the calculation deviation caused by a single parameter. Next, the process iterates through each pending packet in the task waiting queue, reads the constraint complexity coefficient carried by each packet, and inputs the constraint complexity coefficient into a preset computing power consumption mapping table. This mapping table records the correspondence between different complexity coefficient ranges and the required computing power resources. The estimated computing power resource consumption for each packet is obtained through mapping. Then, the estimated computing power resource consumption of all packets is summed to form the estimated computing power resource value required to complete the task waiting queue. The principle is that the constraint complexity coefficient is positively correlated with computing power consumption. The mapping table can transform abstract complexity indicators into specific computing power requirements. The cumulative calculation can clearly define the total computing power required to complete the existing waiting tasks. The beneficial effect is to avoid subsequent task allocation exceeding the node's carrying capacity due to estimation errors, while providing an accurate basis for surplus calculation. Among these, the estimated computing power resource value... The calculation formula is as follows:

[0091] (10)

[0092] In the formula, The total number of packets waiting to be processed in the task waiting queue; For the package index; For the first The constraint complexity coefficient carried by each package; The preset computing power consumption mapping function maps the constraint complexity coefficient range to the expected computing power resource consumption.

[0093] Finally, the total computing power of nodes with tight computing power is subtracted from the computing power already put into service, and then the estimated computing power is subtracted. The difference is taken as the executable computing power reserve. The principle is to accurately separate the occupied and unoccupied computing power through subtraction to obtain the actual remaining computing power available to the nodes. This provides a clear standard for subsequent task selection and ensures that the tasks allocated to the nodes do not exceed their capacity.

[0094] After obtaining the available computing power reserve, packages with a total computational load not exceeding this reserve and a complexity coefficient below a threshold are selected and input into the node model for computation. The computation results are then fed back to the corresponding local node. The principle is that the available computing power reserve determines the maximum computational load a node can currently handle. Packages with a complexity coefficient below the threshold are selected because these packages have low computational difficulty, require less computing power, and are well-suited to the node's remaining computing power. Furthermore, the node model, as a lightweight version of the complete model, can efficiently handle low-complexity tasks without consuming excessive computing power. This fully utilizes the node's remaining computing power to complete low-complexity tasks, reducing task waiting time. Simultaneously, local computation by the node model reduces data transmission latency, quickly feeding results back to the local node and improving the user experience.

[0095] For packets exceeding the node's executable computing power margin or with complexity coefficients higher than the threshold, they are uploaded to the central node or nearby nodes with abundant computing power for computation. The computation results are then forwarded to the corresponding local node via nodes with limited computing power. The principle is that these types of packets have high computational difficulty and require a large amount of computing power, which nodes with limited computing power cannot process efficiently. The central node, on the other hand, has a complete model, sufficient computing power, and strong processing capabilities. Nearby nodes with abundant computing power have low load and low communication latency. Therefore, most computations are performed by the central node, while a small portion that can be handled by nodes with abundant computing power are performed by those nodes. Furthermore, forwarding results by nodes with limited computing power ensures that local nodes can receive computation results uniformly, avoiding confusion caused by feedback from multiple nodes.

[0096] The process of uploading the remaining packets to nearby nodes with abundant computing power specifically includes: First, nodes with limited computing power select several nodes with abundant computing power and the lowest communication latency as candidate collaborative nodes based on a preset network topology table. The principle is that the network topology table records information such as the location and communication link status of each edge node. Selecting low-latency nodes can reduce data transmission time and lower the overall task processing latency. The preset network topology table is obtained in the following way: The central node periodically broadcasts computing power status query commands to all edge nodes, and each edge node reports its own node status value and available computing power. The central node generates a preset network topology table based on the reported information and distributes it to each edge node. The principle is that the central node, as the core of collaborative scheduling, can grasp the status of each edge node in real time through periodic queries. The generated network topology table can accurately reflect the communication relationship and computing power distribution between nodes, and distributing it to each node ensures that the node can quickly obtain candidate collaborative node information.

[0097] Subsequently, the node with limited computing power sends computation requests carrying constraint complexity coefficients to each candidate collaborative node, and receives the current node status value and available computing power commitment duration returned by the candidate collaborative nodes. The principle is that the constraint complexity coefficient allows candidate nodes to predict the required computing power in advance, and the node status value and available computing power commitment duration reflect the candidate node's current load and continuous service capability. Next, the candidate collaborative node with the highest node status value and the longest available computing power commitment duration is selected as the target collaborative node. The remaining packets are split and transmitted to the target collaborative node through an encrypted tunnel. The principle is that the highest node status value indicates sufficient remaining computing power, the longest available duration indicates stable task completion, packet splitting enables parallel computing and improves efficiency, and the encrypted tunnel ensures data transmission security, preventing the leakage of sensitive data such as constraint sets and user requests. Finally, the node with limited computing power receives the computation results returned by the target collaborative node, reassembles the computation results according to the numbering order at the time of splitting, and forwards the reassembled complete computation results to the corresponding local node.

[0098] like Figure 5 As shown, based on the same inventive concept, this embodiment provides a computing power allocation system for edge collaboration in a cloud computing platform, including:

[0099] The constraint set generation module 201 is used to collect all the request content input by the user in the corresponding session process through the local node, identify the interactive content marked as unsatisfactory by the user in the request content through the semantic recognition module, and generate corresponding prohibitive constraints; at the same time, it extracts all the user's question statements and the user's feedback statements expressing satisfaction, and uses the semantic compression algorithm to use the extracted statements as the session preconditions; the constraints and preconditions are merged to form a constraint set.

[0100] The constraint quantization module 202 is used to perform semantic complexity parsing on the constraint set, quantize and generate constraint complexity coefficients; and package the constraint set as constraints for the new dialogue with the user's new requests and submit them to the corresponding edge node.

[0101] The node evaluation module 203 is used to collect the target parameters of each edge node in real time, including processor utilization, memory usage and task waiting queue length; input the collected target parameters into the preset node status evaluation function, and output the node status value of the corresponding edge node; based on the comparison result of the node status value and the preset status threshold, all edge nodes are marked as nodes with abundant computing power and nodes with scarce computing power respectively.

[0102] The computing power scheduling module 204 is used to calculate the current executable computing power reserve of nodes with tight computing power; based on the executable computing power reserve, it selects packages with a total computing volume not exceeding the reserve and a complexity coefficient lower than the threshold, inputs them into the node model for calculation operations, and feeds back the calculation results to the corresponding local node; the remaining packages are uploaded to the central node or nearby nodes with abundant computing power for calculation, and the calculation results are forwarded to the corresponding local node through the nodes with tight computing power.

[0103] It should be noted that the specific methods by which each module performs operations in the system described in the above embodiments have been described in detail in the embodiments related to the method, and will not be elaborated here.

[0104] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for allocating computing power to support edge collaboration in a cloud computing platform, characterized in that, The method includes a central node and multiple edge nodes communicatively connected to the central node, each edge node connecting to multiple local nodes; the central node deploys a complete dialogue model, and the edge nodes deploy lightweight node models of the complete model; the local nodes deploy semantic recognition modules; the method includes: The local node collects all user-inputted requests within the corresponding session process. The semantic recognition module identifies user-marked unsatisfactory interactions within these requests and generates corresponding prohibitive constraints. Simultaneously, all user-asked questions and user-expressed satisfaction feedback are extracted, and a semantic compression algorithm is used to extract these statements as session preconditions. The constraints and preconditions are then merged to form a constraint set. The constraint set is subjected to semantic complexity parsing to quantify and generate constraint complexity coefficients; the constraint set is used as the constraint of the new dialogue and packaged with the user's new request and submitted to the corresponding edge node; The step of performing semantic complexity parsing on the constraint set specifically includes: The edge node performs syntactic structure parsing on the received constraint set, decomposes the constraint set into multiple independent constraint units according to the preset semantic boundaries, identifies the subject-verb-object structure and modifying components in each constraint unit, and counts the number of entities and the length of the relation chain contained in the constraint unit. Based on the statistically determined number of entities and the length of the relationship chain, and combined with the distribution density of negation words and condition words in the constraint unit, the structural complexity coefficient of the constraint unit is calculated. The structural complexity coefficients of all the constraint units are weighted and summed, and an association correction factor is introduced during the summation process based on the degree of logical association between each constraint unit. The result of the weighted summation is quantified as the constraint complexity coefficient of the entire constraint set. Each edge node collects its own target parameters in real time, including processor utilization, memory usage, and task waiting queue length; the collected target parameters are input into a preset node status evaluation function, which outputs the node status value of the corresponding edge node; based on the comparison results between the node status value and the preset status threshold, all edge nodes are marked as nodes with abundant computing power and nodes with scarce computing power. For the node with limited computing power, calculate the current executable computing power reserve of the node; based on the executable computing power reserve, select packages with a total computation amount not exceeding the reserve and a complexity coefficient lower than the threshold, input them into the node model for computation operation; and feed the computation results back to the corresponding local node; the remaining packages are uploaded to the central node or a nearby node with abundant computing power for computation, and the computation results are forwarded to the corresponding local node via the node with limited computing power.

2. The computing power allocation method for edge collaboration in a cloud computing platform according to claim 1, characterized in that, The step of collecting all user-inputted requests within the corresponding session process via the local node specifically includes: While starting the corresponding session process on the local node, a dedicated interactive content collection channel for the session process is simultaneously established. The collection channel is only connected to the input port within the session process for users to enter content. Throughout the entire lifecycle of the session, the source attribution of all interactive content flowing within the session is continuously verified to distinguish between content entered by the user and AI response content generated by the node model or the complete model. The content that is confirmed to be an AI answer after verification is completely removed, and only the content that has been verified and confirmed to be entered by the user is retained. At the same time, the retained user-entered content is sequentially collected according to the interaction time sequence within the conversation process to form a complete set of user request content corresponding to the conversation process.

3. The computing power allocation method for edge collaboration in a cloud computing platform according to claim 1, characterized in that, The step of generating the corresponding prohibition constraint conditions specifically includes: The system monitors the human-computer interaction interface at the local node in real time. When a preset negative feedback control is triggered on the human-computer interaction interface, the system locates the preset time window before the negative feedback control is triggered and marks the last AI answer in the preset time window as content to be processed. At the same time, the system collects the opinion text entered by the user after the negative feedback control is triggered. The semantic recognition module breaks down the content to be processed sentence by sentence to extract the target sentence that triggers the negative feedback control; the opinion text is semantically parsed to extract the prohibited pointer; the target sentence and the prohibited pointer are associated and encapsulated to generate the prohibitive constraint.

4. The computing power allocation method for edge collaboration in a cloud computing platform according to claim 1, characterized in that, The node state evaluation function is constructed through the following steps: The node state evaluation function is obtained by solidifying the node state value calculation logic, which includes: Collect all target parameters of the edge node during its historical steady-state operation cycle, perform mean calculation on the target parameters of the same type to obtain the steady-state reference value of each type of target parameter corresponding to the edge node; subtract the target parameter collected at the corresponding time from the steady-state reference value of each target parameter to obtain the remaining capacity value of each target parameter; Perform a product calculation on all the remaining capacity values ​​collected at the same time, and then take the reciprocal of the calculation result to obtain the node state value of the edge node at the corresponding time.

5. A method for allocating computing power to support edge collaboration in a cloud computing platform according to claim 1, characterized in that, The step of calculating the current executable computing power reserve of the node specifically includes: The computing power stress node collects its current processor utilization, memory usage, and task waiting queue length, and determines the amount of computing power resources already put into service based on the processor utilization and memory usage. The process iterates through each pending packet in the task waiting queue, reads the constraint complexity coefficient carried by each pending packet, and inputs the constraint complexity coefficient into a preset computing power consumption mapping table. The computing power consumption mapping table records the correspondence between different complexity coefficient ranges and the required computing power resources. The estimated computing power resources consumed by each pending packet are obtained through mapping. The estimated computing power resources consumed by each pending packet are then added together to form the estimated computing power resources required to complete the task waiting queue. The difference between the total computing power resources of the nodes with tight computing power and the computing power resources already put into service, and the estimated value of computing power resources, is used as the executable computing power reserve.

6. A method for allocating computing power to support edge collaboration in a cloud computing platform according to claim 1, characterized in that, The process of uploading the remaining packets to nearby nodes with abundant computing power includes: The nodes with limited computing power select several nodes with abundant computing power as candidate cooperative nodes based on a preset network topology table. Send a calculation request carrying the constraint complexity coefficient to each of the candidate collaborative nodes, and receive the current node status value and available computing power commitment duration returned by the candidate collaborative nodes; The candidate collaborative node with the highest node status value and the longest commitment duration of available computing power is selected as the target collaborative node, and the remaining packets are split and transmitted to the target collaborative node through an encrypted tunnel; Upon receiving the calculation results returned by the target collaborative node, the computing power-constrained node reassembles the calculation results according to the numbering order at the time of splitting, and forwards the reassembled complete calculation results to the corresponding local node.

7. A method for allocating computing power to support edge collaboration in a cloud computing platform according to claim 6, characterized in that, Also includes: The central node periodically broadcasts a computing power status query command to all edge nodes, and each edge node reports its own node status value and available computing power. The central node generates the preset network topology table based on the reported information and sends it to each of the edge nodes.

8. A computing power allocation system for edge collaboration in a cloud computing platform, based on the computing power allocation method for edge collaboration in a cloud computing platform as described in claim 1, characterized in that, include: The constraint set generation module is used to collect all the request content input by the user in the corresponding session process through the local node, identify the interaction content marked as unsatisfactory by the user in the request content through the semantic recognition module, and generate corresponding prohibitive constraint conditions; at the same time, it extracts all the user's question statements and the user's feedback statements expressing satisfaction, and uses a semantic compression algorithm to use the extracted statements as the preconditions of the session. The constraints and preconditions are combined to form a constraint set; The constraint quantization module is used to perform semantic complexity parsing on the constraint set, quantize and generate constraint complexity coefficients; and package the constraint set as constraints for a new dialogue with the user's new requests and submit it to the corresponding edge node. The node evaluation module is used to collect target parameters of each edge node in real time, including processor utilization, memory usage, and task waiting queue length. The collected target parameters are input into a preset node state evaluation function, and the node state value of the corresponding edge node is output. Based on the comparison results between the node state value and the preset state threshold, all edge nodes are marked as nodes with abundant computing power and nodes with scarce computing power. The computing power scheduling module is used to calculate the current executable computing power reserve of the node with computing power shortage; based on the executable computing power reserve, select packages with a total computing volume not exceeding the reserve and a complexity coefficient lower than the threshold, input them into the node model for calculation operation; and feed back the calculation results to the corresponding local node; the remaining packages are uploaded to the central node or a nearby computing power surplus node for calculation, and the calculation results are forwarded to the corresponding local node through the computing power shortage node.

Images