A method for calculating the dynamic equilibrium edge of a connectionless system

Abstract

This invention discloses a connectionless dynamic equilibrium edge computing method, relating to the field of edge computing, comprising the following steps: Ⅰ. An edge management layer constructs and maintains a set of intent graphs. When a task flow arrives at the edge network, it parses the metadata features of the task flow and performs online subgraph matching to obtain the task intent; Ⅱ. During operation, the resource entropy values ​​of each edge node are periodically acquired, and each edge node constructs a dynamic network entropy field through a connectionless broadcast protocol. This invention achieves high affinity matching between tasks and nodes, improves resource utilization and task completion efficiency, significantly reduces dependence on central control, enhances system behavior transparency, facilitates auditing, anomaly detection and continuous optimization, strengthens the stability of edge computing, enables decentralized storage of state information, ensures that node failures do not lead to loss of computing state, and improves task recovery and reorganization capabilities.

Description

Technical Field

[0001] This invention relates to the field of edge computing, and more specifically to a method for connectionless dynamic equilibrium edge computing. Background Technology

[0002] With the rapid growth of applications such as large-scale IoT terminals, real-time video analytics, and smart mobile devices, edge computing has gradually become an indispensable component of modern network infrastructure. However, traditional edge computing systems face significant challenges in three key areas: First, task scheduling generally relies on centralized control, fixed connections, or stable routing, making it difficult to adapt to highly dynamic, weakly connected, or even connectionless scenarios. Second, resource fluctuations between edge nodes are significant, and computational load, network quality, and data traffic exhibit high randomness, making it difficult for traditional scheduling strategies based on static load indicators to maintain overall system stability and performance. Third, task state management and fault tolerance still heavily rely on centralized backup or fixed communication links, making the system prone to performance bottlenecks when nodes fail, links are interrupted, or a large influx of tasks occurs. Against this backdrop, there is an urgent need for a new edge computing method that can continue to operate under connectionless or weakly connected conditions and automatically maintain system dynamic balance in a dynamically fluctuating environment.

[0003] Existing methods for connectionless dynamic balancing edge computing cannot guarantee high affinity matching between tasks and nodes, reducing resource utilization and task completion efficiency. They also rely heavily on central control, have low transparency of system behavior, are not conducive to auditing, anomaly detection and continuous optimization, reduce the stability of edge computing, and pose a risk of loss of computing state due to node failure. To address these issues, we propose a connectionless dynamic balancing edge computing method. Summary of the Invention

[0004] The purpose of this invention is to address the shortcomings of existing technologies and provide a method for calculating unconnected dynamic equilibrium edges.

[0005] This invention proposes a method for calculating unconnected dynamic equilibrium edges, and the technical solution adopted to solve the technical problem is as follows:

[0006] Ⅰ. The edge management layer constructs and maintains a set of intent graphs. When a task flow arrives at the edge network, it parses the metadata features of the task flow and performs online subgraph matching to obtain the task intent.

[0007] II. During operation, the resource entropy values ​​of each edge node are periodically acquired, and each edge node constructs a dynamic network entropy field through a connectionless broadcast protocol.

[0008] Ⅲ. Based on the current task intent and network entropy field, automatically select a node group and issue a potential well generation instruction to each selected edge node to create a computational potential well for the corresponding task;

[0009] IV. The task flow data packet is matched with the potential well node based on its own task intent. After the matching is completed, the potential well node starts to execute the task.

[0010] V. Monitor the entropy changes of each potential well node in real time, and automatically generate potential wells in new edge network regions based on the monitoring results;

[0011] VI. During the task execution, each potential well node generates a corresponding state vector, and at the same time, the state vector is split into multiple sets of state fragments and randomly spread to neighboring nodes.

[0012] VII. When it is necessary to restore the task or verify the results, collect the state fragments on each node and reconstruct the complete state.

[0013] As a further aspect of the present invention, the specific steps for constructing and maintaining a set of intent graphs in step I are as follows:

[0014] S1.1: Deploy multiple lightweight collectors in the edge network acquisition layer and extract non-load-intrusive metadata from each task flow accessed by the edge network. Map each type of metadata to a set of corresponding original feature fields according to a preset template, perform corresponding type cleaning on each type of original feature field, and then fill in the missing values ​​using the median interpolation method.

[0015] S1.2: The various feature fields after cleaning and filling are linearly combined according to the preset domain importance weights to obtain the normalized feature scalar of a single task sample, and used as the input description when building nodes. Then, the computational actions and data objects in the task sample are used as two major categories of entity nodes. At the same time, the attribute template of each type of node in the intent graph is set, a corresponding attribute dictionary is generated for each type of node, and each attribute dictionary is converted into a machine-verifiable pattern.

[0016] S1.3: The conformity between each candidate node sample and each node type template is evaluated by the pattern matching function, and an archiveable node instance record containing timestamps and version numbers is generated. Then, the "action-object" candidate relationship is extracted in parallel by the rule base based on semantic templates and patterns and the lightweight learning model. At the same time, each candidate relationship contains multiple sets of supporting evidence fragments.

[0017] S1.4: Calculate the semantic similarity and statistical trigger strength of each candidate relationship, and concatenate the semantic similarity and statistical trigger strength to form the confidence score of the corresponding candidate relationship. If the confidence score is higher than the preset threshold, the candidate relationship is written into the intent graph as a confirmation edge. Otherwise, it is added to the observation pool to wait for new evidence fragments to be added. Then, the relationship confidence score and evidence fragments are recorded as edge attributes.

[0018] S1.5: Collect generated nodes and confirmed edges through a sliding window of a preset size to form short-term graph samples. Perform subgraph mining on each short-term graph sample based on graph isomorphism algorithm to obtain action-object combination templates and count the occurrence frequency of each subgraph. If the frequency is higher than a preset threshold, the subgraph is regarded as a high-frequency subgraph. Calculate the activity and decay of the subgraph under the current workload based on the counter of each type of subgraph template and the most recent occurrence time series. At the same time, for newly appearing subgraph templates, register them as candidate intent fragments. When a new set of candidate nodes is input, subgraph matching is used to identify whether it matches the registered pattern. If the matching degree is higher than a preset threshold, the active evidence count of the subgraph is updated.

[0019] S1.6: Predefine a set of semantic basis vectors for each type of high-frequency subgraph pattern, map each matching result to the activation weights on the corresponding basis vectors, merge multiple local matching indices of the subgraph into weight coefficients on the basis vectors to generate unnormalized intent synthesis vectors, normalize each intent synthesis vector, and output the final intent vector.

[0020] S1.7: For each generated intent vector, construct a set of corresponding discretized candidate interpretation distributions. Calculate the weight distribution of each candidate interpretation distribution based on historical matching frequency and current evidence. Simultaneously, calculate the information entropy of each candidate interpretation distribution to assess its uncertainty. Periodically record the entropy evolution curve and trigger corresponding manual audits using a threshold strategy. After a new task sample is confirmed, locally update the confidence weights of relevant edges and node attribute statistics according to a predetermined learning rate. Then, broadcast the local update in summary form to the adjacent management node set to merge and form a more comprehensive graph-consistent view.

[0021] As a further aspect of the present invention, the specific calculation formula for the feature scalar in S1.2 is as follows:

[0022]

[0023] In the formula, A normalized overall feature scalar representing a single task sample; Representing the Domain importance weights for each feature field; Representing the Numerical representation of each field after cleaning and scaling transformation; This represents the total number of feature fields that are retained and participate in linear combination under the current sampling template;

[0024] The specific calculation formula for the intent vector mentioned in S1.6 is as follows:

[0025]

[0026] In the formula, This represents the normalized intent vector; This represents the number of semantic basis vectors activated in this synthesis. Representing the The activation weight coefficients of the semantic basis vectors; Representing the semantic basis vectors; It represents the vector norm.

[0027] As a further aspect of the present invention, the non-load-intrusive metadata in S1.1 includes: metadata packet size, time interval, encapsulation protocol tag, transmission rate estimation, header statistics, etc.; the feature fields include: numerical fields and category fields; the initial knowledge includes: system manual, historical task logs (anonymized summary), expert annotation table, public domain rule base, etc.

[0028] The computational actions described in S1.2 include encoding, decoding, feature extraction, aggregation, and fitting; the data objects include video streams, frames, log lines, sensor readings, model weight segments, etc.; the attribute template specifically includes required attributes, optional attributes, and meta-attributes; the attribute dictionary includes attribute name, type, value range, measurement method, update frequency, and privacy level.

[0029] As a further aspect of the present invention, the specific steps for constructing the dynamic network entropy field in step II are as follows:

[0030] S2.1: Select a set of original resource indicators at the local edge node, and sample each resource indicator at a fixed time interval to obtain the original sampling sequence. Use exponential weighted moving average to smooth each indicator for a short time. Then, concatenate all smoothed resource indicators into a local smoothing vector. Perform stabilization mapping on each local smoothing vector to generate state components in the range of [0, 1). Then, perform small-scale smoothing and pruning on each mapped state component.

[0031] S2.2: Through the softmax variant function, each group of state components is transformed into a corresponding discrete probability distribution. Based on the obtained discrete probability distribution, the resource entropy value of the corresponding node is calculated and used as the initial value of local resource uncertainty. Then, the short-time variance correction coefficient of each resource entropy value is calculated. The resource entropy value and the corresponding short-time variance correction coefficient are linearly or nonlinearly combined to generate the resource entropy score of each node.

[0032] S2.3: Random projection is used to compress the dimension of the smooth vector or state vector corresponding to each node. Then, each compressed component is quantized to obtain a low-dimensional discrete signature vector. The corresponding discrete signature vector, node identity, resource entropy score and timestamp are then encapsulated into a message packet. A unique check code is added to each broadcast message body. Then, connectionless lightweight broadcast is used. The unicast probability, maximum number of hops and backoff factor control parameters are set. Then, based on the preset control parameters, each edge node sends message packets to its neighbor nodes according to the probability.

[0033] S2.4: When each node receives message packets from multiple groups of neighboring nodes, it performs deduplication on duplicate message packets within the same time window, performs fast similarity judgment on message signatures, and if the similarity error between the received message packet signature and the locally known signature is higher than a preset threshold, or the resource entropy score in the message packet is higher than the local preset view threshold, the message packet is regarded as a valid new observation.

[0034] S2.5: The network distance from the local node to the neighboring nodes is used to perform spatial decay processing on the resource entropy score corresponding to the effective observation, and the processing result is used as the perceptual entropy contribution of the corresponding neighboring node to the local node. Weighted smoothing is used to merge the perceptual entropy contributions into the perceptual entropy field value of the local node. Based on the perceptual entropy field value of each node, a complete network entropy field is established, and the perceptual entropy field value of each node is dynamically updated according to the real-time task flow.

[0035] As a further aspect of the present invention, the specific calculation formula for the resource entropy score in S2.2 is as follows:

[0036]

[0037]

[0038]

[0039] In the formula, Representing the The resource entropy value corresponding to the probability distribution of the item; Representing the Item probability distribution; Represents the total number of nodes; Represents the volatility correction coefficient; Representative near Time variance estimation of each index in a smoothed vector of each period; This represents the variance amplification factor; The final resource entropy score publicly announced by the node; Representing the A normalized queue length metric; Represents the weight of the queue item; This represents the upper bound of the entropy score design.

[0040] As a further aspect of the present invention, the specific steps for creating the computational potential well corresponding to the task in step III are as follows:

[0041] S3.1: Construct a local entropy field matrix by combining the perceived entropy field value of the local node with the entropy observation value of the neighboring node. Each element in the local entropy field matrix represents the perceived entropy value between the two groups of nodes. Then, perform preliminary sorting of each node according to the perceived entropy field value from high to low, and select each node whose entropy value is lower than a preset threshold to establish a candidate potential well node pool.

[0042] S3.2: Calculate the candidate priority score of each node based on the topological distance between each node in the candidate potential well node pool and the task flow entry node. If the candidate priority score is higher than the preset threshold, the corresponding candidate node is added to the available node set.

[0043] S3.3: Match the intention vector predicted by the task with the feature vector of each candidate node in the available node set, calculate the affinity score between each candidate node and the task, sort the candidate nodes from high to low according to the affinity score, and select a preset number of candidate nodes from high to low to generate potential well nodes.

[0044] S3.4: Generate a potential well generation instruction for each selected node, and encrypt or sign the content of each potential well generation instruction. Then, each potential well generation instruction is sent to the corresponding potential well node on the edge network in the form of a connectionless or lightweight message. After receiving the potential well generation instruction, the potential well node loads the corresponding computation template and the data element information required by the task from the local template library according to the template type.

[0045] S3.5: Each potential well node sets the initial state value of the template according to the potential well generation instruction to form a computational mold that can immediately accept task flow. After each potential well node completes the loading of template and meta-information, it writes the initialization state, instruction version number and timestamp into the local potential well registration table. At the same time, it generates summary information based on each indicator and chooses to send it to the adjacent node or management node for redundancy backup. When the node entropy value or resource status changes, or a new task intent vector appears, the potential well status is re-evaluated and updated, and the local potential well registration table is updated.

[0046] As a further aspect of the present invention, the specific calculation formula for the candidate priority score in S3.2 is as follows:

[0047]

[0048] In the formula, Representative node Candidate priority scores; Representative node The overall entropy value; Represents the topological attenuation coefficient; Representative node Topological distance to the task entry point or central node;

[0049] The specific formula for calculating the affinity score mentioned in S3.3 is as follows:

[0050]

[0051] In the formula, Representative node Affinity score for the current task intent; This represents the predicted task intent vector; Representative node eigenvectors.

[0052] As a further embodiment of the present invention, the potential well generation instruction in S3.4 includes: target node ID, task intent vector summary, required template type, initial parameters, data metadata index, generation timestamp, and version number; the calculation template includes: function entry point, executable parameter placeholders, and some pre-set calculation units; the data metadata required by the task includes: input data index, data format, size, dependency relationships, and other metadata.

[0053] As a further aspect of the present invention, the specific steps for matching the task flow data packet with the potential well node based on its own task intent in step IV are as follows:

[0054] S4.1: When a task flow is generated, an intent vector is attached to each task data packet. Then, each task data packet encrypts or digests each intent vector, initializes the current position marker and hop count counter of each task data packet, and after each potential well node is initialized, its node intent vector digest is integrated with the current maximum number of tasks it can carry and the current entropy value to generate an intent affinity announcement, and the intent affinity announcement is updated in real time based on a preset period.

[0055] S4.2: Using lightweight broadcast, the intention affinity announcement of each potential well node is propagated to the edge network. When each task data packet is transmitted to each edge network node, a set of affinity scores of reachable potential well nodes is obtained through local caching. Based on the affinity score, the selection probability of each candidate potential well node is calculated, and the candidate node list is appended to the routing metadata.

[0056] S4.3: Based on the selection probability of each candidate potential well node, calculate the cumulative affinity value of reaching each candidate potential well node, filter out candidate potential well nodes with a cumulative affinity value lower than a preset threshold, and then randomly select the next jump node from each candidate potential well node. In each jump, update the intent vector summary, current position and jump count counter of the data packet, repeat the jump multiple times until the potential well node with the highest cumulative affinity value is reached.

[0057] S4.4: When the task data packet arrives at the target potential well node, register the task flow locally on the node, mark the corresponding task data packet as the task is trapped, and trigger the local potential well of the node to start the corresponding calculation template to execute the task.

[0058] As a further aspect of the present invention, the intent vector in S4.1 is specifically a high-dimensional vector that quantifies the task's requirements in multiple dimensions such as computation, storage, network, and real-time performance.

[0059] As a further aspect of the present invention, the specific steps of step VI, which involves splitting the state vector into multiple sets of state fragments and randomly distributing them to neighboring nodes, are as follows:

[0060] S5.1: When the task is executed within the computation potential well, the intermediate results of each computation step are collected and an intermediate state set is established. Then, the established intermediate state set is mapped to an intermediate state vector, where each intermediate state vector represents a quantifiable computational state index. Then, each intermediate state vector is normalized and encoded.

[0061] S5.2: According to the preset dimensions or logic, the normalized intermediate state vectors are divided into blocks to generate multiple state segments. Redundant coding is used to expand each state segment, and original index, redundancy coefficient, generation timestamp and segmentation version number are added to each state segment. Random walk instructions are generated for each state segment.

[0062] S5.3: Each state segment jumps between nodes in the edge network according to the random walk instruction. At the same time, each state segment pauses and caches at the next node. The currently paused node dynamically adjusts the jumping frequency or delay of the state segment according to its own load and entropy value. Then, during the random walk, each state segment jumps and accumulates between nodes in the edge network. At the same time, each node performs local weighted superposition of its cached state segments to form a local distributed state vector approximation of the node.

[0063] As a further aspect of the present invention, the intermediate results of the calculation step in S5.1 specifically include: cached data, temporary calculation matrix, partial output, etc.; the calculation status indicators include memory usage, numerical statistics, or local hash digests, etc.

[0064] The random walk instruction described in S5.2 includes a jump probability matrix, a maximum number of hops, a random delay parameter, and an access strategy.

[0065] The beneficial effects of this invention are:

[0066] This invention deploys a lightweight collector at the edge acquisition layer to extract non-intrusive metadata and map it to original features according to a template. After preprocessing each original feature, sample features are obtained by linear combination according to domain weights. Calculation actions and data objects are built into two types of nodes, generating an attribute dictionary and converting it into a verifiable pattern. Node instances with version and timestamps are generated through pattern matching. Action-object relationships are extracted in parallel using a rule base and lightweight learning, relationship confidence is calculated, and the results are written into the graph or observation pool. Short-term subgraph mining is performed based on a sliding window to identify high-frequency subgraphs. Semantic basis vectors are defined for high-frequency subgraphs. Matching results are mapped and synthesized into intent vectors. The probability distribution and entropy of candidate interpretations of intent are calculated to measure uncertainty. After sample confirmation, the graph weights are updated locally incrementally according to the learning rate, and the difference is broadcast in the form of a summary. Nodes periodically sample resource indicators locally, smooth them using EWMA, map them to state components, and calculate resource entropy through softmax normalization. Then, an entropy score is generated and mapped to a discrete signature using random projection. This signature is packaged with the entropy score and broadcast. The receiving end processes each received message... The perceptual entropy field is formed by combining repetition and similarity judgment, spatial decay and weighted fusion. A local entropy field matrix is ​​constructed and candidate potential well nodes with low entropy and suitable topology are selected. The task intent is matched with the candidate nodes to generate affinity. Several nodes are selected to generate and encrypt potential well instructions. The target node is preloaded with a minimal template and data element information and registered. The task packet carries the intent vector and is matched and jumped through the network in a distributed manner. After the self-organized trap falls to the potential well with the highest affinity, the computation is triggered. The intermediate state of execution is vectorized, fragmented, redundantly encoded and diffused among network nodes in a random walk. There is no need to maintain a stable connection, which significantly reduces the link maintenance overhead. The computation can still maintain sustainable operation in edge networks with high packet loss, strong dynamism and frequent topology changes. It achieves high affinity matching from task to node, improves resource utilization and task completion efficiency, significantly reduces dependence on central control, and improves the transparency of system behavior, which is convenient for auditing, anomaly detection and continuous optimization. It enhances the stability of edge computing, enables decentralized storage of state information, ensures that node failure will not lead to loss of computation state, and improves task recovery and reorganization capabilities. Attached Figure Description

[0067] The present invention will now be further described with reference to the accompanying drawings.

[0068] Figure 1 This is a framework diagram for a method of calculating unconnected dynamic equilibrium edges. Detailed Implementation

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

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

[0071] Example 1: This embodiment of the invention provides a method for calculating unconnected dynamic equilibrium edges. See also... Figure 1 , Figure 1 This is a framework diagram of a method for calculating unconnected dynamic equilibrium edges, provided by an embodiment of the present invention. The method includes the following steps:

[0072] The edge management layer constructs and maintains a set of intent graphs. When a task flow arrives at the edge network, it parses the metadata features of the task flow and performs online subgraph matching to obtain the task intent.

[0073] Specifically, multiple lightweight collectors are deployed at the edge network acquisition layer to extract non-load-intrusive metadata from each task flow accessed by the edge network. Each type of metadata is mapped to a set of corresponding original feature fields according to a preset template. Each type of original feature field is then categorized and cleaned. Missing values ​​are then filled using median interpolation. The cleaned and filled feature fields are linearly combined according to preset domain importance weights to obtain the normalized feature scalar of a single task sample, which is used as the input description when constructing nodes. The computational actions and data objects in the task samples are then treated as two main types of entity nodes. Attribute templates for each type of node in the intent graph are set, generating a corresponding attribute dictionary for each type of node, and assigning each attribute... The dictionary is converted into machine-verifiable patterns. A pattern matching function is used to evaluate the conformity of each candidate node sample with each node type template, generating archiveable node instance records containing timestamps and version numbers. Then, a rule base based on semantic templates and patterns, along with a lightweight learning model, is used to extract "action-object" candidate relationships in parallel. Each candidate relationship contains multiple sets of supporting evidence fragments. The semantic similarity and statistical trigger strength of each candidate relationship are calculated, and these are concatenated to form the confidence score of the corresponding candidate relationship. If the confidence score is higher than a preset threshold, the candidate relationship is written into the intent graph as a confirmation edge; otherwise, it is added to the observation pool to await the addition of new evidence fragments. Finally, the relationship confidence score and evidence fragments are recorded as follows: Edge attributes are collected using a sliding window of a preset size to generate nodes and confirmed edges, forming short-term graph samples. Subgraph mining is then performed on each short-term graph sample based on a graph isomorphism algorithm to obtain action-object combination templates. The frequency of each subgraph is counted; if the frequency exceeds a preset threshold, the subgraph is considered a high-frequency subgraph. The activity and decay of each subgraph template under the current workload are calculated based on its counter and most recent occurrence time series. Newly appearing subgraph templates are initially registered as candidate intent fragments. When a new set of candidate nodes is input, subgraph matching is used to identify whether it conforms to the registered patterns. If the matching degree exceeds a preset threshold, the active evidence count of the subgraph is updated. A predefined pattern is defined for each high-frequency subgraph pattern. The process involves creating semantic basis vectors and mapping each matching result to the corresponding activation weights on these basis vectors. Multiple local matching metrics from the subgraph are then merged into weight coefficients on the basis vectors to generate unnormalized intent synthesis vectors. These intent synthesis vectors are then normalized, resulting in the final intent vector. For each generated intent vector, a set of corresponding discrete candidate interpretation distributions is constructed. The weight distribution of each candidate interpretation distribution is calculated based on historical matching frequencies and current evidence. Simultaneously, the information entropy of each candidate interpretation distribution is calculated to assess its uncertainty. The entropy evolution curve is periodically recorded, and a threshold strategy is used to trigger corresponding manual audits. Subsequently, when a new task sample is confirmed, the confidence weights of relevant edges and node attribute statistics are locally updated according to a predetermined learning rate.The local updates are then broadcast as a summary to the set of adjacent management nodes to be merged into a more widespread, graph-consistent view.

[0074] In this embodiment, non-load-intrusive metadata includes: metadata packet size, time interval, encapsulation protocol tag, transmission rate estimation, header statistics, etc.; feature fields include: numerical fields and category fields; initial knowledge includes: system manual, historical task logs (anonymized summary), expert annotation table, public domain rule base, etc.; computational actions include: encoding, decoding, feature extraction, aggregation, fitting, etc.; data objects include video streams, frames, log lines, sensor readings, model weight segments, etc.; attribute templates specifically include: required attributes, optional attributes, and meta-attributes; the attribute dictionary includes: attribute name, type, value range, measurement method, update frequency, and privacy level.

[0075] The specific calculation formula for the characteristic scalar is as follows:

[0076]

[0077] In the formula, A normalized overall feature scalar representing a single task sample; Representing the Domain importance weights for each feature field; Representing the Numerical representation of each field after cleaning and scaling transformation; This represents the total number of feature fields that are retained and participate in linear combination under the current sampling template;

[0078] The specific formula for calculating the intent vector is as follows:

[0079]

[0080] In the formula, This represents the normalized intent vector; This represents the number of semantic basis vectors activated in this synthesis. Representing the The activation weight coefficients of the semantic basis vectors; Representing the semantic basis vectors; It represents the vector norm.

[0081] During operation, the resource entropy values ​​of each edge node are periodically acquired, and each edge node constructs a dynamic network entropy field through a connectionless broadcast protocol.

[0082] Specifically, a set of original resource indicators is selected at the local edge node, and each resource indicator is sampled at fixed time intervals to obtain the original sampling sequence. An exponentially weighted moving average is used to perform short-term smoothing on each indicator. Then, all smoothed resource indicators are concatenated into a local smoothing vector. Each local smoothing vector is then stabilized and mapped to generate state components within the range [0, 1). These mapped state components are then subjected to a small amount of smoothing and pruning. A softmax variant function is used to transform each set of state components into a corresponding discrete probability distribution. Based on the obtained discrete probability distribution, the resource entropy value of the corresponding node is calculated and used as the initial value for local resource uncertainty. Then, the short-term variance correction coefficient for each resource entropy value is calculated. Each resource entropy value is then linearly or non-linearly combined with its corresponding short-term variance correction coefficient to generate a resource entropy score for each node. Random projection is used to compress the dimension of the smoothing vector or state vector corresponding to each node. Subsequently, each compressed component is quantized to obtain a low-dimensional discrete signature vector. Finally, the corresponding discrete signature vector, node identity, and resource... Source entropy scores and timestamps are encapsulated into message packets, and a unique checksum is added to each generated broadcast message body. Then, connectionless lightweight broadcasting is adopted, and control parameters such as unicast probability, maximum hop count, and backoff factor are set. Based on the preset control parameters, each edge node sends message packets to neighbor nodes according to probability. When a node receives message packets from multiple groups of neighbor nodes, duplicate message packets within the same time window are deduplicated, and message signatures are quickly similar. If the similarity error between the received message packet signature and the locally known signature is higher than a preset threshold, or the resource entropy score in the message packet is higher than the local preset view threshold, the message packet is regarded as a valid new observation. The network distance from the local node to the neighbor node is used to spatially decay the resource entropy score corresponding to the valid observation, and the processing result is used as the perceptual entropy contribution of the corresponding neighbor node to the local node. Weighted smoothing is used to merge the perceptual entropy contributions into the perceptual entropy field value of the local node. Based on the perceptual entropy field values ​​of each node, a complete network entropy field is established, and the perceptual entropy field values ​​of each node are dynamically updated according to the real-time task flow.

[0083] It should be noted that the specific formula for calculating the resource entropy score is as follows:

[0084]

[0085]

[0086]

[0087] In the formula, Representing the The resource entropy value corresponding to the probability distribution of the item; Representing the Item probability distribution; Represents the total number of nodes; Represents the volatility correction coefficient; Representative near Time variance estimation of each index in a smoothed vector of each period; This represents the variance amplification factor; The final resource entropy score publicly announced by the node; Representing the A normalized queue length metric; Represents the weight of the queue item; This represents the upper bound of the entropy score design.

[0088] Based on the current task intent and network entropy field, the system automatically selects a node group and issues a potential well generation instruction to each selected edge node to create a computational potential well for the corresponding task.

[0089] Specifically, a local entropy field matrix is ​​constructed by combining the perceived entropy field value of the local node with the entropy observation values ​​of its neighboring nodes. Each element in the local entropy field matrix represents the perceived entropy value between the two sets of nodes. Then, nodes are initially sorted from high to low based on their perceived entropy field values, and nodes with entropy values ​​below a preset threshold are selected to establish a candidate potential well node pool. Based on the topological distance between each node in the candidate potential well node pool and the task flow entry node, a candidate priority score is calculated for each node. If the candidate priority score is higher than a preset threshold, the corresponding candidate node is added to the available node set. The task's predicted intent vector is matched with the feature vector of each candidate node in the available node set, and the affinity score between each candidate node and the task is calculated. Candidate nodes are sorted from high to low based on their affinity scores, and a preset number of candidate nodes are selected from high to low to generate potential well nodes. Each node generates a potential well generation instruction and encrypts or signs the content of each instruction. Then, each instruction is sent to the corresponding potential well node on the edge network in a connectionless or lightweight message format. Upon receiving the instruction, the node loads the corresponding computation template and the required data metadata from its local template library based on the template type. Each node sets the initial state of the template according to the instruction to form a computational mold that can immediately accept task flows. After loading the template and metadata, each node writes the initialization state, instruction version number, and timestamp into its local potential well registration table. Simultaneously, it generates summary information based on various indicators and chooses to send it to adjacent nodes or the management node for redundancy backup. When the node entropy or resource status changes, or a new task intent vector appears, the potential well state is re-evaluated and updated, and the local potential well registration table is updated.

[0090] In addition, it should be noted that the potential well generation instruction includes: target node ID, task intent vector summary, required template type, initial parameters, data metadata index, generation timestamp, and version number; the computation template includes: function entry point, executable parameter placeholders, and some pre-set computation units; the data metadata required by the task includes: input data index, data format, size, dependencies, and other metadata.

[0091] The specific formula for calculating the candidate priority score is as follows:

[0092]

[0093] In the formula, Representative node Candidate priority scores; Representative node The overall entropy value; Represents the topological attenuation coefficient; Representative node Topological distance to the task entry point or central node;

[0094] The specific formula for calculating the affinity score is as follows:

[0095]

[0096] In the formula, Representative node Affinity score for the current task intent; This represents the predicted task intent vector; Representative node eigenvectors.

[0097] Example 2: This embodiment of the invention provides a method for calculating unconnected dynamic equilibrium edges. See also... Figure 1 , Figure 1 This is a framework diagram of a method for calculating unconnected dynamic equilibrium edges, provided by an embodiment of the present invention. The method includes the following steps:

[0098] The task flow data packet is matched with the potential well node based on its own task intent. After the matching is completed, the potential well node starts to execute the task.

[0099] Specifically, when a task flow is generated, an intent vector is appended to each task data packet. Then, each task data packet encrypts or digests its intent vectors, initializes its current position marker and hop count counter, and simultaneously, after initialization, each potential well node integrates its node intent vector digest with its current task capacity limit and current entropy value to generate an intent affinity announcement. This announcement is updated in real-time at a preset period. Lightweight broadcasting is used to propagate the intent affinity announcements of each potential well node to the edge network. When each task data packet is transmitted to each edge network node, it obtains a set of affinity scores for reachable potential well nodes through local caching. Based on the affinity score, it is then categorized... Calculate the selection probability of each candidate potential well node and append the candidate node list to the routing metadata. Based on the selection probability of each candidate potential well node, calculate the cumulative affinity value of reaching each candidate potential well node, filter out candidate potential well nodes with a cumulative affinity value lower than a preset threshold, and then randomly select the next hop node from each candidate potential well node. In each hop, update the intent vector summary, current position and hop count counter of the data packet. Repeat the hop multiple times until the potential well node with the highest cumulative affinity value is reached. When the task data packet reaches the target potential well node, register the task flow locally on the node, mark the corresponding task data packet as the task is trapped, and trigger the local potential well of the node to start the corresponding calculation template to execute the task.

[0100] In this embodiment, the intent vector is specifically a high-dimensional vector that quantifies the task's requirements in multiple dimensions such as computation, storage, network, and real-time performance.

[0101] The entropy changes of each potential well node are monitored in real time, and potential wells are automatically generated in new edge network regions based on the monitoring results.

[0102] During task execution, each potential well node generates a corresponding state vector, and at the same time, the state vector is split into multiple sets of state fragments and randomly diffused to neighboring nodes.

[0103] Specifically, when the task is executed within the computation potential well, intermediate results of each computation step are collected, and an intermediate state set is established. This intermediate state set is then mapped to intermediate state vectors, where each vector represents a quantifiable computational state indicator. These vectors are then normalized and encoded. Following a preset dimension or logic, the normalized intermediate state vectors are divided into blocks, generating multiple state fragments. Redundant encoding is used to expand each state fragment, and each fragment is augmented with its original index, redundancy coefficient, generation timestamp, and fragment version number. Random walk instructions are generated for each state fragment. Each state fragment jumps between nodes in the edge network according to these instructions. Simultaneously, each state fragment pauses and caches at the next node, dynamically adjusting the jump frequency or delay based on its load and entropy. During the random walk, each state fragment continuously jumps and accumulates between nodes in the edge network. Each node also locally weights and superimposes its cached state fragments, forming a locally distributed state vector approximation.

[0104] In addition, the intermediate results of the calculation steps specifically include: cached data, temporary calculation matrix, partial output, etc.; the calculation status indicators include memory usage, numerical statistics or local hash digest, etc.; the random walk instructions include jump probability matrix, maximum number of hops, random delay parameters and access strategy.

[0105] When it is necessary to restore a task or verify results, collect state fragments from each node and reconstruct the complete state.

[0106] The foregoing has provided a detailed description of one embodiment of the present invention, but this description is merely a preferred embodiment and should not be construed as limiting the scope of the invention. All equivalent variations and modifications made within the scope of the claims of this invention should still fall within the patent coverage of this invention.

Claims

1. A method for calculating unconnected dynamic equilibrium edges, characterized in that, Includes the following steps: Ⅰ. The edge management layer constructs and maintains a set of intent graphs. When a task flow arrives at the edge network, it parses the metadata features of the task flow and performs online subgraph matching to obtain the task intent. II. During operation, the resource entropy values ​​of each edge node are periodically acquired, and each edge node constructs a dynamic network entropy field through a connectionless broadcast protocol. Ⅲ. Based on the current task intent and network entropy field, automatically select a node group and issue a potential well generation instruction to each selected edge node to create a computational potential well for the corresponding task; IV. The task flow data packet is matched with the potential well node based on its own task intent. After the matching is completed, the potential well node starts to execute the task. V. Monitor the entropy changes of each potential well node in real time, and automatically generate potential wells in new edge network regions based on the monitoring results; VI. During the task execution, each potential well node generates a corresponding state vector, and at the same time, the state vector is split into multiple sets of state fragments and randomly spread to neighboring nodes. VII. When it is necessary to restore the task or verify the results, collect the state fragments on each node and reconstruct the complete state; The specific steps for the edge management layer to construct and maintain a set of intent graphs described in step I are as follows: S1.1: Deploy multiple lightweight collectors in the edge network acquisition layer and extract non-load-intrusive metadata from each task flow accessed by the edge network. Map each type of metadata to a set of corresponding original feature fields according to a preset template, perform corresponding type cleaning on each type of original feature field, and then fill in the missing values ​​using the median interpolation method. S1.2: The various feature fields after cleaning and filling are linearly combined according to the preset domain importance weights to obtain the normalized feature scalar of a single task sample, and used as the input description when building nodes. Then, the computational actions and data objects in the task sample are used as two major categories of entity nodes. At the same time, the attribute template of each type of node in the intent graph is set, a corresponding attribute dictionary is generated for each type of node, and each attribute dictionary is converted into a machine-verifiable pattern. S1.3: The conformity between each candidate node sample and each node type template is evaluated by the pattern matching function, and an archiveable node instance record containing timestamps and version numbers is generated. Then, the "action-object" candidate relationship is extracted in parallel by the rule base based on semantic templates and patterns and the lightweight learning model. At the same time, each candidate relationship contains multiple sets of supporting evidence fragments. S1.4: Calculate the semantic similarity and statistical trigger strength of each candidate relationship, and concatenate the semantic similarity and statistical trigger strength to form the confidence score of the corresponding candidate relationship. If the confidence score is higher than the preset threshold, the candidate relationship is written into the intent graph as a confirmation edge. Otherwise, it is added to the observation pool to wait for new evidence fragments to be added. Then, the relationship confidence score and evidence fragments are recorded as edge attributes. S1.5: Collect generated nodes and confirmed edges through a sliding window of a preset size to form short-term graph samples. Perform subgraph mining on each short-term graph sample based on graph isomorphism algorithm to obtain action-object combination templates and count the occurrence frequency of each subgraph. If the frequency is higher than a preset threshold, the subgraph is regarded as a high-frequency subgraph. Calculate the activity and decay of the subgraph under the current workload based on the counter of each type of subgraph template and the most recent occurrence time series. At the same time, for newly appearing subgraph templates, register them as candidate intent fragments. When a new set of candidate nodes is input, subgraph matching is used to identify whether it matches the registered pattern. If the matching degree is higher than a preset threshold, the active evidence count of the subgraph is updated. S1.6: Predefine a set of semantic basis vectors for each type of high-frequency subgraph pattern, map each matching result to the activation weights on the corresponding basis vectors, merge multiple local matching indices of the subgraph into weight coefficients on the basis vectors to generate unnormalized intent synthesis vectors, normalize each intent synthesis vector, and output the final intent vector. S1.7: For each generated intent vector, construct a set of corresponding discretized candidate interpretation distributions. Calculate the weight distribution of each candidate interpretation distribution based on historical matching frequency and current evidence. Simultaneously, calculate the information entropy of each candidate interpretation distribution to assess its uncertainty. Periodically record the entropy evolution curve and trigger corresponding manual audits using a threshold strategy. After a new task sample is confirmed, locally update the confidence weights of relevant edges and node attribute statistics according to a predetermined learning rate. Then, broadcast the local update in summary form to the adjacent management node set to merge and form a more comprehensive graph-consistent view. The specific steps for constructing the dynamic network entropy field described in step II are as follows: S2.1: Select a set of original resource indicators at the local edge node, and sample each resource indicator at a fixed time interval to obtain the original sampling sequence. Use exponential weighted moving average to smooth each indicator for a short time. Then, concatenate all smoothed resource indicators into a local smoothing vector. Perform stabilization mapping on each local smoothing vector to generate state components in the range of [0, 1). Then, perform small-scale smoothing and pruning on each mapped state component. S2.2: Through the softmax variant function, each group of state components is transformed into a corresponding discrete probability distribution. Based on the obtained discrete probability distribution, the resource entropy value of the corresponding node is calculated and used as the initial value of local resource uncertainty. Then, the short-time variance correction coefficient of each resource entropy value is calculated. The resource entropy value and the corresponding short-time variance correction coefficient are linearly or nonlinearly combined to generate the resource entropy score of each node. S2.3: Random projection is used to compress the dimension of the smooth vector or state vector corresponding to each node. Then, each compressed component is quantized to obtain a low-dimensional discrete signature vector. The corresponding discrete signature vector, node identity, resource entropy score and timestamp are then encapsulated into a message packet. A unique check code is added to each broadcast message body. Then, connectionless lightweight broadcast is used. The unicast probability, maximum number of hops and backoff factor control parameters are set. Then, based on the preset control parameters, each edge node sends message packets to its neighbor nodes according to the probability. S2.4: When each node receives message packets from multiple groups of neighboring nodes, it performs deduplication on duplicate message packets within the same time window, performs fast similarity judgment on message signatures, and if the similarity error between the received message packet signature and the locally known signature is higher than a preset threshold, or the resource entropy score in the message packet is higher than the local preset view threshold, the message packet is regarded as a valid new observation. S2.5: The network distance from the local node to the neighboring node is spatially decayed for the resource entropy score corresponding to the effective observation, and the processing result is used as the perceptual entropy contribution of the corresponding neighboring node to the local node. Weighted smoothing is used to merge the perceptual entropy contributions into the perceptual entropy field value of the local node. Based on the perceptual entropy field value of each node, a complete network entropy field is established, and the perceptual entropy field value of each node is dynamically updated according to the real-time task flow. The specific steps for creating the computational potential well for the corresponding task as described in step III are as follows: S3.1: Construct a local entropy field matrix by combining the perceived entropy field value of the local node with the entropy observation value of the neighboring node. Each element in the local entropy field matrix represents the perceived entropy value between the two groups of nodes. Then, perform preliminary sorting of each node according to the perceived entropy field value from high to low, and select each node whose entropy value is lower than a preset threshold to establish a candidate potential well node pool. S3.2: Calculate the candidate priority score of each node based on the topological distance between each node in the candidate potential well node pool and the task flow entry node. If the candidate priority score is higher than the preset threshold, the corresponding candidate node is added to the available node set. S3.3: Match the intention vector predicted by the task with the feature vector of each candidate node in the available node set, calculate the affinity score between each candidate node and the task, sort the candidate nodes from high to low according to the affinity score, and select a preset number of candidate nodes from high to low to generate potential well nodes. S3.4: Generate a potential well generation instruction for each selected node, and encrypt or sign the content of each potential well generation instruction. Then, each potential well generation instruction is sent to the corresponding potential well node on the edge network in the form of a connectionless or lightweight message. After receiving the potential well generation instruction, the potential well node loads the corresponding computation template and the data element information required by the task from the local template library according to the template type. S3.5: Each potential well node sets the initial state value of the template according to the potential well generation instruction to form a computational mold that can immediately accept task flow. After each potential well node completes the loading of template and meta-information, it writes the initialization state, instruction version number and timestamp into the local potential well registration table. At the same time, it generates summary information based on each indicator and chooses to send it to the adjacent node or management node for redundancy backup. When the node entropy value or resource status changes, or a new task intent vector appears, the potential well status is re-evaluated and updated, and the local potential well registration table is updated.

2. The method for calculating unconnected dynamic equilibrium edges according to claim 1, characterized in that, The specific calculation formula for the characteristic scalar mentioned in S1.2 is as follows: In the formula, A normalized overall feature scalar representing a single task sample; Representing the Domain importance weights for each feature field; Representing the Numerical representation of each field after cleaning and scaling transformation; This represents the total number of feature fields that are retained and participate in linear combination under the current sampling template; The specific calculation formula for the intent vector mentioned in S1.6 is as follows: In the formula, This represents the normalized intent vector; This represents the number of semantic basis vectors activated in this synthesis. Representing the The activation weight coefficients of the semantic basis vectors; Representing the semantic basis vectors; It represents the vector norm.

3. The method for calculating unconnected dynamic equilibrium edges according to claim 1, characterized in that, The specific calculation formula for the resource entropy score mentioned in S2.2 is as follows: In the formula, Representing the The resource entropy value corresponding to the probability distribution of the item; Representing the Item probability distribution; Represents the total number of nodes; Represents the volatility correction coefficient; Representative near Time variance estimation of each index in a smoothed vector of each period; This represents the variance amplification factor; The final resource entropy score publicly announced by the node; Representing the A normalized queue length metric; Represents the weight of the queue item; This represents the upper bound of the entropy score design.

4. The method for calculating unconnected dynamic equilibrium edges according to claim 1, characterized in that, The specific calculation formula for the candidate priority score mentioned in S3.2 is as follows: In the formula, Representative node Candidate priority scores; Representative node The overall entropy value; Represents the topological attenuation coefficient; Representative node Topological distance to the task entry point or central node; The specific formula for calculating the affinity score mentioned in S3.3 is as follows: In the formula, Representative node Affinity score for the current task intent; This represents the predicted task intent vector; Representative node eigenvectors.

5. The method for calculating unconnected dynamic equilibrium edges according to claim 1, characterized in that, The specific steps for matching the task flow data packet with the potential well node based on its own task intent in step IV are as follows: S4.1: When a task flow is generated, an intent vector is attached to each task data packet. Then, each task data packet encrypts or digests each intent vector, initializes the current position marker and hop count counter of each task data packet, and after each potential well node is initialized, its node intent vector digest is integrated with the current maximum number of tasks it can carry and the current entropy value to generate an intent affinity announcement, and the intent affinity announcement is updated in real time based on a preset period. S4.2: Using lightweight broadcast, the intention affinity announcement of each potential well node is propagated to the edge network. When each task data packet is transmitted to each edge network node, a set of affinity scores of reachable potential well nodes is obtained through local caching. Based on the affinity score, the selection probability of each candidate potential well node is calculated, and the candidate node list is appended to the routing metadata. S4.3: Based on the selection probability of each candidate potential well node, calculate the cumulative affinity value of reaching each candidate potential well node, filter out candidate potential well nodes with a cumulative affinity value lower than a preset threshold, and then randomly select the next jump node from each candidate potential well node. In each jump, update the intent vector summary, current position and jump count counter of the data packet, repeat the jump multiple times until the potential well node with the highest cumulative affinity value is reached. S4.4: When the task data packet arrives at the target potential well node, register the task flow locally on the node, mark the corresponding task data packet as the task is trapped, and trigger the local potential well of the node to start the corresponding calculation template to execute the task.

6. The method for calculating unconnected dynamic equilibrium edges according to claim 1, characterized in that, The specific steps of splitting the state vector into multiple state fragments and randomly spreading them to neighboring nodes as described in step VI are as follows: S5.1: When the task is executed within the computation potential well, the intermediate results of each computation step are collected and an intermediate state set is established. Then, the established intermediate state set is mapped to an intermediate state vector, where each intermediate state vector represents a quantifiable computational state index. Then, each intermediate state vector is normalized and encoded. S5.2: According to the preset dimensions or logic, the normalized intermediate state vectors are divided into blocks to generate multiple state segments. Redundant coding is used to expand each state segment, and original index, redundancy coefficient, generation timestamp and segmentation version number are added to each state segment. Random walk instructions are generated for each state segment. S5.3: Each state segment jumps between nodes in the edge network according to the random walk instruction. At the same time, each state segment pauses and caches at the next node. The currently paused node dynamically adjusts the jumping frequency or delay of the state segment according to its own load and entropy value. Then, during the random walk, each state segment jumps and accumulates between nodes in the edge network. At the same time, each node performs local weighted superposition of its cached state segments to form a local distributed state vector approximation of the node.

Images