An autonomously controllable kernel sharing collaborative design method

Abstract

This invention discloses an autonomous and controllable kernel-shared collaborative design method, relating to the field of collaborative design control technology. The method includes reading nodes and task packages, constructing effective collaborative edges and calculating a consistency weight matrix, extracting the number of tasks to define a design state vector, completing a first-order state update through deviation identification and quantization step size control, calculating propagation weights and received aggregation quantities based on activation markers, updating shared change tracking quantities, identifying continuously deviating nodes, correcting the state vector through second-order coordination, constructing a quality prediction quantity and performing intervention, and using the corrected state and tracking quantity as the initial values ​​for the next cycle to form a complete iterative closed loop. This invention achieves stable convergence and efficient propagation of the decentralized collaborative design state by constructing an effective collaborative edge set and combining directional quantization synchronization and a shared change tracking mechanism.

Description

Technical Field

[0001] This invention relates to the field of collaborative design control technology, and in particular to an autonomous and controllable kernel-sharing collaborative design method. Background Technology

[0002] Existing collaborative design technologies typically revolve around mechanisms such as unified data environment, version management, access control, task distribution, and review and approval processes. These technologies can support, to some extent, design file sharing, inter-professional information sharing, and process traceability management. With the development of an independent and controllable software ecosystem, domestic industrial infrastructure platforms, and kernel-level collaborative support capabilities, more and more research is beginning to focus on collaborative models based on locally shared kernel instances. This involves sinking design status, version status, and collaborative confirmation status to the local location of each design node and achieving collaborative diffusion through controlled exchange between nodes. This enhances the system's adaptability to central node failures, heterogeneous network environments, and asynchronous rhythms across multiple roles.

[0003] However, existing technologies still have shortcomings. The collaborative relationships between nodes in existing collaborative design systems are usually propagated according to a preset topology. They lack an effective set of collaborative edges built based on the actual communication capabilities of nodes, professional relationships, and task collaboration requirements. This can easily lead to situations where irrelevant nodes participate in synchronization or key nodes are not included in the collaborative link, resulting in reduced collaboration efficiency, increased network load, and unreasonable design state propagation paths. When synchronizing the states of multiple nodes, existing collaborative design technologies use a simple average synchronization method, which lacks a mechanism for quantitative adjustment based on the direction of node state deviation and continuous tracking of the propagation trend of shared changes. This can easily lead to problems such as state oscillation, slow convergence speed, or continuous accumulation of local deviations, making it difficult to achieve stable convergence and efficient propagation of design states in a decentralized environment. Summary of the Invention

[0004] In view of the aforementioned existing problems, the present invention is proposed.

[0005] Therefore, this invention provides an autonomous and controllable kernel-shared collaborative design method, which solves the problem that the collaborative relationships between nodes in existing collaborative design systems are usually propagated according to a preset topology. This lacks an effective set of collaborative edges built based on the actual communication capabilities of nodes, professional relationships, and task collaboration requirements. As a result, irrelevant nodes may participate in synchronization or key nodes may not be included in the collaborative link, leading to problems such as reduced collaboration efficiency, increased network load, and unreasonable design state propagation paths. Existing collaborative design technologies use a simple average synchronization method when synchronizing the states of multiple nodes. They lack a mechanism for quantitative adjustment based on the direction of node state deviation and for continuous tracking of the propagation trend of shared changes. This can easily lead to problems such as state oscillation, slow convergence speed, or continuous accumulation of local deviations, making it difficult to achieve stable convergence and efficient propagation of design states in a decentralized environment.

[0006] To solve the above-mentioned technical problems, the present invention provides the following technical solution: Firstly, this invention provides an autonomous and controllable kernel sharing and collaborative design method, which includes: Read the project nodes and initial task packages of the current cycle, construct a set of effective collaborative edges, and calculate the consistency weight matrix; Based on the initial task package, extract the number of direct loading and collaborative reference tasks, define the design state vector, calculate the state deviation vector and the original state increment, determine the quantization direction benchmark based on the state deviation vector, quantize the original state increment to obtain the quantized state increment, and update the design state vector. Based on the random propagation weight of the quantized state increment calculation column, the receiving aggregation quantity is constructed, the shared change tracking quantity is calculated and updated, the main trend deviation quantity and the continuous deviation judgment quantity are solved, and the updated design state vector is corrected by combining the consistency weight matrix. The quality gap prediction is calculated and an intervention is performed based on the design state vector and shared change tracking quantity. The next cycle is then iterated using the corrected design state vector and updated shared change tracking quantity.

[0007] As a preferred embodiment of the autonomous and controllable kernel sharing collaborative design method described in this invention, the step of extracting the number of direct loading and collaborative reference tasks based on the initial task package and defining the design state vector refers to defining the initial shared kernel state vector of each node as the current local shared kernel availability, the current local shared kernel cache usage, the current local shared kernel version baseline value, and the node task background load. The number of direct loading tasks and collaborative reference tasks are extracted from the project's initial task package, and the design state vector of the node is defined in combination with the initial shared kernel state vector. The design state vector is then arithmetically averaged to obtain the average design state.

[0008] As a preferred embodiment of the autonomous and controllable kernel sharing and collaborative design method described in this invention, the calculation of the state deviation vector and the original state increment refers to subtracting the average design state from the design state vector of the current cycle to obtain the state deviation vector of the node, subtracting the average design state of the previous cycle from the design state vector of the current cycle to obtain the original state increment of the node, and determining the components in the state deviation vector to obtain the quantization direction reference.

[0009] As a preferred embodiment of the autonomous and controllable kernel sharing and collaborative design method described in this invention, the updated design state vector refers to quantizing the original state increment using a quantization direction benchmark to obtain the quantized state increment, and defining the design state vector for the next cycle based on the design state vector, consistency weight, and quantized state increment.

[0010] As a preferred embodiment of the autonomous and controllable kernel sharing and collaborative design method described in this invention, the calculation of column random propagation weights based on quantized state increments refers to calculating the vector length of the quantized state increments using the Euclidean norm method, and calculating the column random propagation weights by comparing the set of active nodes of a set node in the current period with a threshold.

[0011] As a preferred embodiment of the autonomous and controllable kernel sharing and collaborative design method described in this invention, the construction of the received aggregation quantity refers to calculating the outbound message with input tracking status and the normalized outbound message based on the column random propagation weight, and aggregating the outbound messages to obtain the received aggregation quantity.

[0012] As a preferred embodiment of the autonomous and controllable kernel sharing collaborative design method described in this invention, the calculation of the shared change tracking quantity and the updating of the shared change tracking quantity refer to adding the rate compensation input to the tracking receive aggregation quantity with input, and then subtracting the rate compensation input of the current period to obtain the updated tracking state to be input, and updating the normalized state to the normalized receive aggregation quantity, and dividing the updated tracking state to be input by the updated normalized state to obtain the updated shared change tracking quantity.

[0013] As a preferred embodiment of the autonomous and controllable kernel sharing collaborative design method described in this invention, the step of solving the main trend deviation and the continuous deviation judgment quantity, and correcting the updated design state vector by combining the consistency weight matrix, refers to calculating the main trend deviation and the continuous deviation judgment quantity for the shared change tracking quantity and making a judgment to obtain the continuous deviation main trend mark, and correcting the updated design state vector by calculating the second-order coordination direction of the node by combining the consistency weight matrix.

[0014] As a preferred embodiment of the autonomous and controllable kernel shared collaborative design method described in this invention, the step of using the modified design state vector and updated shared change tracking quantity for the next cycle iteration refers to constructing the quality gap prediction quantity for the next cycle based on the design state vector and shared change tracking quantity of the current cycle, setting intervention rules, setting an archive index for the node, counting the number of valid rules for the node in the current cycle, calculating the rule increment, writing the rule increment and archive index back to the shared kernel rule base, and using the updated shared change tracking quantity and modified design state vector for iteration.

[0015] As a preferred embodiment of the autonomous and controllable kernel sharing and collaborative design method described in this invention, the steps of reading the project nodes and initial task packages of the current cycle, constructing a set of effective collaborative edges, and calculating the consistency weight matrix refer to reading the project nodes, determining whether there is direct communication capability between any two nodes, constructing an edge set, filtering the edge set for effective collaborative edges, obtaining a set of effective collaborative edges, and calculating and generating the consistency weight matrix.

[0016] The beneficial effects of this invention are as follows: By constructing an effective set of collaborative edges based on direct node communication capabilities, professional associations, and professional mutual support relationships, and generating a consistency weight matrix, this invention enables the collaborative topology to truly reflect the business collaborative relationships between design nodes, avoiding the problems of irrelevant nodes participating in synchronization or key nodes not being included in the collaborative link in traditional centralized collaboration. By constructing a design state vector and calculating the state deviation vector and the original state increment, and using a direction quantization mechanism to perform controlled synchronization of state changes, this invention reduces communication burden while improving state convergence efficiency. By sharing change tracking quantities, main trend deviation quantities, and continuous deviation judgment quantities, this invention dynamically analyzes the node change propagation trend, and combines a second-order coordination mechanism to perform differentiated correction for nodes with continuous deviations, enabling the system to maintain stable convergence in a multi-node asynchronous collaborative environment. By constructing a quality gap prediction quantity and establishing a rule feedback mechanism, this invention enables the collaborative system to identify potential quality risks in advance and intervene during the error coupling stage, thereby improving the stability and efficiency of the collaborative design process and the system's autonomous controllability. Attached Figure Description

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

[0018] Figure 1 This is a flowchart of the autonomous and controllable kernel sharing and collaborative design method in Example 1.

[0019] Figure 2 This is a schematic diagram of the collaborative topology construction of the autonomous and controllable kernel sharing collaborative design method in Example 1.

[0020] Figure 3 This is a schematic diagram of the tracking quantity aggregation and update flowchart of the autonomous and controllable kernel sharing collaborative design method in Example 1.

[0021] Figure 4 This is a schematic diagram of the message construction and propagation process of the autonomous and controllable kernel sharing collaborative design method in Example 1. Detailed Implementation

[0022] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0023] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0024] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0025] Example 1, referring to Figures 1 to 4 This is the first embodiment of the present invention, which provides an autonomous and controllable kernel sharing and collaborative design method, including the following steps: S1. Read the project nodes and initial task packages of the current cycle, construct a set of effective collaborative edges, and calculate the consistency weight matrix; S1.1 Read the project nodes and initial task packages of the current cycle, construct a set of effective collaborative edges, and calculate the consistency weight matrix. This means reading the project nodes, determining whether there is direct communication capability between any two nodes, constructing an edge set, filtering the edge set for effective collaborative edges, obtaining the set of effective collaborative edges, and calculating and generating the consistency weight matrix. Specifically, read the project nodes. The nodes are then arranged horizontally according to the order in which they were connected to the project collaboration system, resulting in a node set. It should be noted that a node refers to a collaborative terminal capable of independently hosting a local shared kernel instance and exchanging design state summaries, version summaries, and mutual confirmation information with other nodes. Examples include a designer's workstation, as well as a professional design workstation, proofreading workstation, or task distribution workstation. Number the nodes; Read the major to which the node belongs and set the major number as... And read the current shared kernel instance state of the node. ; It should be noted that the current shared kernel instance status... Used to represent the raw, unprocessed state of a node's current local shared kernel; Read the initial task package of the project, count the number of task items in it, and get the total number of initial tasks of the project; It should be noted that this step first fixes the four basic quantities: "who participates in the collaboration, what profession they belong to, what is the current kernel status, and what is the scale of the project startup." The reason is that the decentralized shared kernel topology is not an abstract graph structure, but is built on real design nodes, real professional division of labor, and real project load. This ensures that the topology and weights generated later are not empty networks detached from the business scenario, but directly serve the autonomous and controllable collaborative design kernel. Based on the node set, determine whether there is direct communication capability between any two nodes. If so, construct a decentralized collaborative edge between the two nodes. Summarize all node pairs with direct communication capability to obtain the edge set. It should be noted that direct communication means that the two nodes can directly exchange shared kernel state summaries, design version summaries, or mutual confirmation information without going through the central server's state master write-back. Based on the edge set, extract all nodes... For nodes with decentralized collaborative edge connections, we obtain adjacent nodes, count the adjacent nodes, and obtain the node degree. It should be noted that this sub-step does not introduce the central server main topology, but directly generates the edge set from the communicable relationships between nodes. The reason is that the subject of this invention is "autonomous and controllable kernel sharing and collaborative design method". The core is not the traditional centralized broadcast, but the local collaborative diffusion between decentralized nodes. By first obtaining the adjacency relationship and degree, the subsequent consistency weight can strictly depend on the real topology, rather than being manually specified. By filtering the edge set for effective collaborative edges, a set of effective collaborative edges is obtained. It should be noted that if the two ends of a decentralized collaborative edge in the edge selection set have the same major ID, the edge is set as a valid collaborative edge within the same major. If the two ends have different major IDs, the professional cross-submission list corresponding to the initial task package of the project is read to determine whether there is a cross-submission relationship between the majors of the two ends. If there is a cross-submission relationship, the edge is set as a valid collaborative edge across majors. Otherwise, the edge is temporarily suspended. All valid collaborative edges within the same major and valid collaborative edges across majors are summarized to obtain a set of valid collaborative edges. It should be noted that this sub-step does not perform task scheduling, but uses "professional association + project startup load background" to correct the topology sparsity, so that the resulting decentralized edge set is more in line with the actual collaborative design scenario. This can avoid the proliferation of invalid cross-professional synchronization in the initial stage, while not suppressing necessary cross-professional collaboration when the task scale is large. The node degrees are re-extracted from the set of effective collaborative edges to generate a consistency weight matrix, as shown in the formula: , , in, For consistency weight, Number the nodes. Number the adjacent nodes. and For the re-extracted effective degree, To effectively coordinate edge sets, To create a consistent weight matrix, all weight elements are... Arranged by node number OK The list is obtained, It is a periodic index.

[0026] S2. Extract the number of direct loading and collaborative reference tasks based on the initial task package, define the design state vector, calculate the state deviation vector and the original state increment, determine the quantization direction benchmark based on the state deviation vector, quantize the original state increment, obtain the quantized state increment, and update the design state vector. S2.1. Extract the number of direct load and collaborative reference tasks based on the initial task package, and define the design state vector. Define the initial shared kernel state vector of each node as the current local shared kernel availability, the current local shared kernel cache usage, the current local shared kernel version baseline value, and the node task background load. Extract the number of direct load tasks and collaborative reference tasks from the project's initial task package, combine the initial shared kernel state vector to define the node's design state vector, and perform an arithmetic average on the design state vectors to obtain the average design state. Specifically, the initial shared kernel state vector of each node is defined as the current local shared kernel availability, the current local shared kernel cache usage, the current local shared kernel version baseline value, and the node task background load. It should be noted that extracting the current shared kernel instance state The current local shared kernel availability, current local shared kernel cache usage, and current local shared kernel version baseline value are displayed. It should be noted that the current local shared kernel availability is obtained by dividing the current idle schedulable kernel resources of the node by the total kernel resources of the node; the current local shared kernel cache occupancy is obtained by dividing the current occupied cache space of the node by the total cache space of the node; and the current local shared kernel version baseline value is obtained by reading the version number of the current shared kernel instance of the node and mapping it to the corresponding integer value. It should be noted that the node task background load is obtained by dividing the number of task entries in the initial task package of the node project whose professional number is equal to the professional number to which the node belongs by the total number of initial tasks in the project. It should be noted that this step does not make the initial state vector a vague identifier, but explicitly includes five components: resource availability, cache usage, version baseline, professional attributes, and task background. This ensures that the "original kernel state, professional information, and initial task package" in the input are substantially used. The resulting state vector can be directly used for task loading and state synchronization in the next step without having to go back and read the original input again. Extract nodes with a consistency weight greater than 0 from the consistency weight matrix that are not the same node to obtain the collaborative coverage node set; It should be noted that this step, by transforming the decentralized weighted topology into a node collaborative coverage domain, achieves explicit fixing of the shared kernel collaborative range, thus establishing a real network foundation for task loading and state propagation in autonomous and controllable collaborative design. Extract the number of directly loaded tasks and the number of collaboratively referenced tasks from the initial task package of the project, combine them with the initial shared kernel state vector to define the design state vector of the node, and perform an arithmetic average on the design state vector to obtain the average design state. It should be noted that, based on the initial task package of the project, tasks whose professional IDs match the professional IDs of the nodes are selected to obtain the direct loading task set. Tasks whose professional IDs do not match the professional IDs of the nodes are selected, but there is a node whose professional ID matches the professional ID of the task in the collaborative coverage node set of the node, and the task has a mutual reference relationship with the defined task in the professional mutual reference list, to obtain the collaborative reference task set. The direct loading task set and the collaborative reference task set are counted respectively to obtain the number of direct loading tasks and the number of collaborative reference tasks of the node. It should be noted that this step establishes the project task loading relationship on the dual constraints of "professional matching + collaborative coverage", thereby achieving the business-oriented fixation of the shared kernel task entry method, and enabling the collaborative design status to simultaneously reflect the professional execution responsibility and cross-professional collaborative dependency. It should be noted that the design state vector includes task load degree, cooperative dependency degree, shared kernel capacity, and version readiness degree. The task load degree is obtained by dividing the number of directly loaded tasks by the task background load. The cooperative dependency degree is obtained by first calculating the sum of the number of cooperative reference tasks and the number of directly loaded tasks, and then dividing the number of cooperative reference tasks by the sum. The shared kernel capacity is obtained by first calculating the sum of the current local shared kernel availability and the current local shared kernel cache usage, and then dividing the current local shared kernel availability by the sum. The version readiness degree is obtained by dividing the current local shared kernel version baseline value by the maximum current local shared kernel version baseline value of all nodes. It should be noted that this step, by deeply integrating the task loading results with the original state of the shared kernel, forms node design state components for collaborative design scenarios, transforming all preceding input data into effective representations that can be used for subsequent state modeling. It should be noted that this step, by constructing a unified node design state vector and extracting the global average design state, achieves an overall expression of the shared kernel collaborative state, providing a central reference for subsequent judgment of node deviation and construction of feasible neighborhoods; The deviation from the design state vector to the average design state is calculated using the Euclidean norm method. The vectors are sorted in descending order, and the largest deviation is selected. The sum of 1 and the task background load is calculated first, and then the largest deviation is divided by the sum to obtain the baseline step size factor. The product of the adjustable coefficient and the task background load is calculated first, and then the sum of the product and 1 is calculated. Finally, the baseline step size factor is multiplied by the sum to obtain the feasible neighborhood radius for the current cycle. It should be noted that 1 is a correction constant to avoid the denominator being too small when the background load of node tasks is small; it is an adjustable coefficient. It should be noted that this step establishes the allowable deviation boundary of the initial state of the shared kernel collaborative design by constructing a feasible neighborhood radius that matches the project startup load, providing reasonable constraints for subsequent state synchronization and collaborative convergence.

[0027] S2.2 Calculating the state deviation vector and the original state increment refers to subtracting the average design state from the design state vector of the current cycle to obtain the state deviation vector of the node, and subtracting the average design state of the previous cycle from the design state vector of the current cycle to obtain the original state increment of the node. The components in the state deviation vector are judged to obtain the quantization direction reference. Specifically, the node's state deviation vector is obtained by subtracting the average design state from the current cycle's design state vector. It should be noted that by truly applying the average design state to the identification of local deviations of each node, subsequent synchronization is no longer a blind averaging, but a controlled correction based on the "direction and degree of node deviation from the global center", thereby improving the synchronization targeting in autonomous and controllable collaborative design. The original state increment of a node is obtained by subtracting the average design state of the previous period from the design state vector of the current period. If a component in the state deviation vector is greater than 0, it means that the component is currently higher than the average design state. The component of the original state increment is compressed downward. Otherwise, it means that the component is currently lower than or equal to the average design state. The component of the original state increment is compensated upward to obtain the quantized direction reference. It should be noted that by binding the actual change of a node in the current period to its deviation direction relative to the global average, subsequent quantization is not a directionless approximation, but a controlled synchronization action with the intention of collaborative convergence, thereby improving the effectiveness of shared kernel state synchronization. S2.3, Updating the design state vector refers to quantizing the original state increment using the quantization direction benchmark to obtain the quantized state increment, and defining the design state vector for the next cycle based on the design state vector, consistency weight, and quantized state increment. Specifically, the original state increment is quantized using a quantization direction reference to obtain the quantized state increment, as shown in the formula: , in, This is the quantized state increment. Number the state components in the design state vector. For the original state increment component, The feasible neighborhood radius, These are the components of the state deviation vector. To round down, To round up; It should be noted that the feasible neighborhood radius is directly used for synchronization step control. When the background load of the project task is high, the synchronization step can be appropriately increased to avoid slow synchronization. When the background load of the project task is low, a finer synchronization step is maintained to avoid the initial deviation being coarsely amplified. This ensures that the quantization action does not deviate from the background load of the project or the direction of the node deviation, thereby achieving directional state synchronization under low communication burden without introducing the central master write-back. The design state vector for the next cycle is defined based on the design state vector, consistency weight, and quantized state increment. The formula is as follows: , in, This is the design state vector for the next cycle. To obtain the number of nodes participating in the collaboration, To design the state vector; It should be noted that this step is a first-order synchronization, which is a basic update; It should be noted that since the weight of nodes without cooperative coverage relationships is 0 in the consistency weight matrix, although the formula sums all nodes in form, it actually only retains the effective state contribution of the node itself and its cooperative coverage nodes. This maintains the consistency of expression and does not deviate from the real topology, realizing the core state advancement in the decentralized shared kernel cooperative design. That is, it merges the adjacent states within the real cooperative coverage range and completes the local state update by combining the advancement amount of the node in this cycle, thereby realizing the diffusion of shared kernel state without relying on the central server master control write-back.

[0028] S3. Based on the quantized state increment, calculate the random propagation weight of the column, construct the receiving aggregation quantity, calculate the shared change tracking quantity and update the shared change tracking quantity, solve the main trend deviation quantity and the continuous deviation judgment quantity, and modify the updated design state vector in combination with the consistency weight matrix. S3.1, The column random propagation weight is calculated based on the quantized state increment. The vector length of the quantized state increment is calculated using the Euclidean norm method. The set of active nodes of the node in the current period is compared with a threshold to calculate the column random propagation weight. Specifically, based on the quantized state increment, the activation flag of the node in the current period is set, and the nodes with the activation flag of 1 are counted to obtain the set of active nodes in the current period. It should be noted that the activation flag refers to the vector length of the quantized state increment calculated using the Euclidean norm method. If the vector length is greater than 0, the activation flag is set to 1. If the total number of messages to be sent in the node's transmit buffer in the current period is greater than 0 or the total number of messages that have arrived but not been processed in the node's receive buffer in the current period is greater than 0, the activation flag is set to 1; otherwise, it is set to 0. It should be noted that if a node has a non-zero quantized state increment in this cycle, it means that the node has already undergone shared kernel state advancement. If there are change messages to be sent in the node's send buffer, it means that the node needs to propagate its changes to downstream cooperating nodes in this cycle. If there are messages that have arrived but not been processed in the node's receive buffer, it means that the node needs to process shared changes from upstream nodes in this cycle. If any of the above situations occur in this cycle, the node is considered to be in an active state in this cycle. It should be noted that "shared change tracking" is based on real collaborative actions, rather than on the ideal premise that all nodes are processed at the same time. This allows the autonomous and controllable shared kernel collaborative design system to adapt to the actual scenarios where the pace of different positions such as lead designer, reviewer, mutual proposal, and approval is inconsistent, thereby reducing the drag on the overall progress caused by slow nodes. The column random propagation weight is calculated based on the set of activated nodes, and the formula is as follows: , , in, For the original propagation proximity, For the receiving node number, For the sending node number, and For buffer changes, it represents the magnitude of the quantized state increment carried in the message that a node is preparing to process in the current period's send buffer, and the magnitude of the quantized state increment carried in the message that a node is preparing to send to another node in the current period's send buffer. To activate the flag, For column random propagation weights, To find the sum index, iterate through each node from 1 to the total number of nodes. and For the number and numbered The node that sends the message in this formula. This is the activated node; It should be noted that this step enables the system to continuously retain the "most recent trusted adjacency sharing change" in asymmetric mutual link, one-way approval link and asynchronous reception scenarios, thereby avoiding the break in the propagation of sharing changes due to inconsistent message arrival times and improving the continuous collaboration capability in autonomous and controllable collaborative design. It should be noted that in collaborative design scenarios, the pace and magnitude of changes among different professional nodes often differ. If a fixed weight is still used, highly heterogeneous shared changes will be propagated proportionally, which can easily cause tracking value oscillations. However, by using proximity-driven adaptive weights, adjacent changes that are closer to the current node can receive a higher propagation ratio. By directly mapping the proximity of shared changes to propagation weights, "propagation according to the similarity of shared changes" can be achieved in directed collaborative design networks, thereby reducing the impact of statistical heterogeneity and improving the stability of shared change propagation in unidirectional link scenarios.

[0029] S3.2 Constructing the received aggregate quantity refers to calculating the outbound messages with input tracking status and normalized status outbound messages based on column random propagation weights, aggregating the outbound messages, and obtaining the received aggregate quantity; Specifically, the column random propagation weight is multiplied by the input tracking state to obtain the outbound message with the input tracking state, and the random column propagation weight is multiplied by the normalized state to obtain the normalized state outbound message. It should be noted that the pending input tracking state refers to the pending input tracking state of the node in the current cycle. If it is the first execution cycle, it is initialized to the quantized state increment. The normalized state refers to the normalized state of the node in the current cycle, which is initialized to 1 in the first execution cycle. It should be noted that outbound messages refer to message components that have been split by the sending node and are ready to be sent to the receiving node; Aggregate outbound messages to obtain the received aggregate volume, using the following formula: , , in, and To receive the aggregation amount, This is a status identifier with input tracking, used to characterize the propagation status carrying shared change inputs. For normalized state identifiers, For departure information, The original generation cycle number of the message. For the receive buffer message set, from the receiving node All unprocessed messages are read from the receive buffer to form a set; It should be noted that truly implementing the shared change tracking mechanism as an engineering process of "writing to the sending buffer - asynchronous transmission - processing to the receiving buffer" enables the autonomous and controllable collaborative design system to handle asynchronous directed propagation behaviors such as version distribution, mutual transfer, and approval feedback without relying on the central master control to write back.

[0030] S3.3 Calculating and updating the shared change tracking quantity refers to adding the rate compensation input to the tracking receive aggregate quantity with input, and then subtracting the rate compensation input of the current period to obtain the updated tracking state to be input, and updating the normalized state to the normalized receive aggregate quantity. The updated shared change tracking quantity is obtained by dividing the updated tracking state to be input by the updated normalized state. Specifically, the rate-compensated input is obtained by multiplying the activation flag by the quantized state increment and then dividing by the activation interval. It should be noted that the activation interval is calculated by subtracting the most recent activation period number from the current period number, and is set to 1 for the first activation. The updated tracking state (next cycle) is obtained by adding the rate compensation input to the tracking received aggregate with input and then subtracting the rate compensation input of the current cycle. The normalized state is then updated to the normalized receiving aggregate. The updated shared change tracking state is obtained by dividing the updated tracking received aggregate by the updated normalized state. It should be noted that the shared change tracking quantity is the input tracking status divided by the normalized status; It should be noted that the "asynchronously received directed shared change" is transformed into "bias-free shared change tracking quantity", and the difference in node update speed is further incorporated into the calculation, so that the subsequent steps will no longer see only the local change quantity, but a network-wide shared change trend estimate that has taken into account the differences in link directionality and node activation frequency.

[0031] S3.4 Solve for the main trend deviation and continuous deviation judgment, and correct the updated design state vector by combining the consistency weight matrix. Calculate the main trend deviation and continuous deviation judgment for the shared change tracking quantity and make a judgment to obtain the continuous deviation main trend mark. Combine the consistency weight matrix to calculate the second-order coordination direction of the node and correct the updated design state vector. Specifically, the arithmetic mean of the shared change tracking volume is used to obtain the network average shared change tracking volume. The main trend deviation is obtained by subtracting the network average shared change tracking volume from the shared change tracking volume. It should be noted that, in order to exclude short-term fluctuations, only "continuous deviation" is identified instead of "instantaneous deviation," and the same direction of the current period deviation and the previous period deviation is further calculated. Multiply the current cycle's main trend deviation by the previous cycle's main trend deviation to obtain the sustained deviation judgment value. If the continuous deviation judgment value is greater than 0 and the absolute value of the main trend deviation in the previous period is greater than or equal to the absolute value of the main trend deviation in the current period, it indicates that the node is continuously deviating in the same direction and the degree of deviation has not weakened. The node is marked as 1 in the current period; otherwise, it is marked as 0, and the continuous deviation from the main trend is obtained. It should be noted that the continuous deviation from the main trend marker indicates whether the node has continuously deviated in the same direction and the degree of deviation has not weakened. This enables the shared kernel collaborative design system to clearly identify "which nodes, although still in the collaborative chain, have continuously deviated from the main trend of the entire network in their shared change direction", thereby providing accurate target objects for subsequent second-order coordination or quality closure, and avoiding indiscriminate intervention of all nodes in subsequent steps. It should be noted that up to the previous step, the system already has the ability to synchronize and track changes in order. However, when the design enters a highly coupled stage, such as when there is intensive cross-professional communication, repeated version rollbacks, or when a certain type of error is repeatedly triggered, relying solely on order-level correction will result in the problem of "being able to make changes but being slow to recover". Therefore, this step introduces local curvature estimation to determine whether a node will deviate again due to high sensitivity after its current state has been corrected once. The vector length from the shared change tracking amount of the current period to the shared change tracking amount of the previous period is calculated using the Euclidean norm, and 1 is added to obtain the denominator. The vector length from the design state vector of the current period to the design state vector of the previous period is calculated using the Euclidean norm, and 1 is added to obtain the numerator. The local curvature estimate is obtained by dividing the denominator by the numerator. It should be noted that 1 is a stability correction value, a fixed positive number added to avoid the denominator being zero and to maintain calculation stability; The local curvature statistics are sorted in descending order. The curvature condition ratio is obtained by dividing the maximum local curvature statistic by the minimum local curvature statistic. The second-order coordination direction of the nodes is calculated and the updated design state vector is corrected. The formula is as follows: , , , , in, for Figure 1 The consistency spectral difference index indicates the degree to which the current topology deviates from perfectly consistent propagation. For consistency weight matrix, Given a column vector consisting entirely of one elements, construct a vector with a length equal to the total number of nodes. And each element is a column vector of one. For transpose, To ensure safe and coordinated step length, This is the estimate of the maximum local curvature. For curvature condition ratio, Second-order coordination direction of nodes, To share change tracking volume, For local curvature estimator, To update the design state vector, For consistency weight, To correct the state vector, For node indexing, To continuously deviate from the main trend marker, To strengthen the coefficient; It should be noted that this step corrects the state vector to a second-order coordination, which is a correction of the first-order one, to achieve differentiated accelerated convergence for nodes that continuously deviate from the target. It should be noted that the strengthening coefficient The setting is based on the weight of the impact of the degree of continuous deviation of nodes from the main trend on the convergence speed and stability of the system. Its core idea is to apply stronger correction pressure to nodes that have shown continuous deviation in the same direction and whose deviation has not weakened, so as to accelerate their return to the main trend of the whole network, thereby avoiding the continuous spread of local deviations in the cooperative network and causing quality deterioration. The value range is generally set to [0,1]. =0 indicates that no additional correction is made for persistent deviations from the node; state adjustment is performed solely based on the basic second-order coordination step size. As the value gradually increases to near 1, the correction strength for continuous deviations from the node will nearly double. This is suitable for scenarios in highly coupled design phases where rapid suppression of deviations is required. In practical applications, The initial value can be set to 0.3 to 0.5, and dynamically adjusted based on a rule base that has been proven effective in historical projects. If a project consistently has a high percentage of deviating nodes and the quality gap cannot be effectively reduced, then the value should be appropriately increased in subsequent projects. If the system experiences oscillations or overcorrection, then reduce... By By incorporating a rule-based feedback mechanism, the system can gradually accumulate optimal values ​​for different project types, enabling adaptive adjustment. It should be noted that this step does not mechanically apply the general Newton method to collaborative design, but rather transforms "local sensitivity" into a curvature estimate that can be directly used by the shared kernel, enabling the system to compress state divergences more quickly during the highly coupled design phase. On the one hand, it eliminates persistently deviating nodes faster than pure first-order synchronization; on the other hand, the step size is affected by both network consistency and local curvature, preventing large oscillations.

[0032] S4. Calculate and construct the quality gap prediction based on the design state vector and shared change tracking quantity, and perform intervention operations. Use the corrected design state vector and updated shared change tracking quantity for the next cycle iteration. S4.1. Iterating for the next cycle using the modified design state vector and updated shared change tracking quantity refers to constructing the quality gap prediction quantity for the next cycle based on the design state vector and shared change tracking quantity of the current cycle, setting intervention rules, setting archive indexes for nodes, counting the number of valid rules for nodes in the current cycle, calculating rule increments, writing the rule increments and archive indexes back to the shared kernel rule base, and iterating using the updated shared change tracking quantity and modified design state vector. Specifically, the consistency error is calculated using the mean absolute deviation formula for the design state vector of the current cycle, the change tracking error is calculated using the mean absolute deviation formula for the shared change tracking quantity, the quality gap error is calculated, and the quality gap prediction for the next cycle is constructed using the following formula: , , in, For quality difference error, This is assigned a period number to indicate the gap between the current period's project quality and the target quality. The percentage of unclosed errors is calculated by dividing the current number of unclosed errors by the current total number of error items. If the total number of error items is zero, the value is zero. Because the required review and approval rate was not met, The percentage of overdue tasks is calculated by dividing the current number of overdue tasks by the total number of tasks currently in progress. If the total number of tasks is zero, the value is zero. For node indexing, For predicting quality gaps, For the next cycle, For the current cycle, the safe coordination step size, For consistency error, To change the tracking error; If the predicted quality gap for the next cycle is less than or equal to the predicted quality gap for the current cycle, it means that the current second-order coordination can compress the quality gap and allow normal flow to continue. If the predicted quality gap for the next cycle is greater than the predicted quality gap for the current cycle and the consistency error for the current cycle is the largest, consistency resynchronization is triggered. If the predicted quality gap for the next cycle is greater than the predicted quality gap for the current cycle and the change tracking error for the current cycle is the largest, mutual link review is triggered. If the predicted quality gap for the next cycle is greater than the predicted quality gap for the current cycle and the predicted quality gap for the current cycle is the largest, forced review and freeze and version upgrade is suspended. It should be noted that by placing "synchronization issues, change propagation issues, and quality issues" into the same evaluation framework, the traditional system avoids the disconnect between the synchronization module (which only focuses on synchronization), the quality module (which only focuses on reporting), and the version module (which only focuses on recording). The system no longer waits for quality issues to be exposed before intervening, but instead predicts whether the situation will worsen in the next cycle during the error coupling stage, thereby making adjustments in advance. Once the node has completed the above steps, an archive index is set for the node, including the project number, professional number, version level number, and archive group number; It should be noted that the version level number refers to the level number of the final approved version read in chronological order from the above task version chain, and the archive group number refers to the mapping obtained according to the six document groups: data collection, design, review, change, delivery, and archiving. The number of valid rules in the current period is counted, and the summation and average are calculated to obtain the rule increment. The rule increment and archive index are written back to the shared kernel rule library so that when the next project starts, it can directly inherit the better quantization bit width selection logic, more reasonable step size constraints and more stable closed loop judgment rules, instead of each project starting from scratch to tune parameters. It should be noted that a rule refers to a parameter value or intervention logic that has been verified as valid in historical projects. The number of valid rules refers to the number of rule items that are triggered in the current cycle and make the consistency error, change tracking error or quality gap error of the current cycle lower than that of the previous cycle. Each rule item is counted at most once in each cycle. If multiple error components are reduced at the same time, it is still counted as one rule. It should be noted that the updated shared change tracking will be used for change tracking error calculation and main trend deviation determination in the next cycle. The shared change tracking amount used in this cycle is still the same as that of the current cycle to ensure the real-time performance and accuracy of error calculation. The revised design state vector is used for calculation in the next cycle to form a complete iterative closed loop. It should be noted that archiving has been upgraded from "static archiving" to "rule feedback," enabling the shared kernel to truly possess the ability for autonomous and controllable continuous evolution.

[0033] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A self-controllable kernel sharing and collaborative design method, characterized in that: include, Read the project nodes and initial task packages of the current cycle, construct a set of effective collaborative edges, and calculate the consistency weight matrix; Based on the initial task package, extract the number of direct loading and collaborative reference tasks, define the design state vector, calculate the state deviation vector and the original state increment, determine the quantization direction benchmark based on the state deviation vector, quantize the original state increment to obtain the quantized state increment, and update the design state vector. Based on the random propagation weight of the quantized state increment calculation column, the receiving aggregation quantity is constructed, the shared change tracking quantity is calculated and updated, the main trend deviation quantity and the continuous deviation judgment quantity are solved, and the updated design state vector is corrected by combining the consistency weight matrix. The quality gap prediction is calculated and an intervention is performed based on the design state vector and shared change tracking quantity. The next cycle is then iterated using the corrected design state vector and updated shared change tracking quantity.

2. The autonomous and controllable kernel sharing and collaborative design method as described in claim 1, characterized in that: The step of extracting the number of direct load and collaborative reference tasks based on the initial task package and defining the design state vector refers to defining the initial shared kernel state vector of each node as the current local shared kernel availability, the current local shared kernel cache usage, the current local shared kernel version baseline value, and the node task background load. The number of direct load tasks and collaborative reference tasks are extracted from the project's initial task package, and the design state vector of the node is defined in combination with the initial shared kernel state vector. The design state vector is then arithmetically averaged to obtain the average design state.

3. The autonomous and controllable kernel sharing and collaborative design method as described in claim 2, characterized in that: The calculation of the state deviation vector and the original state increment refers to subtracting the average design state from the design state vector of the current cycle to obtain the state deviation vector of the node, and subtracting the average design state of the previous cycle from the design state vector of the current cycle to obtain the original state increment of the node. The components in the state deviation vector are then determined to obtain the quantization direction reference.

4. The autonomous and controllable kernel sharing and collaborative design method as described in claim 3, characterized in that: The updated design state vector refers to quantizing the original state increment using a quantization direction benchmark to obtain the quantized state increment, and defining the design state vector for the next cycle based on the design state vector, consistency weight, and quantized state increment.

5. The autonomous and controllable kernel sharing and collaborative design method as described in claim 4, characterized in that: The calculation of column random propagation weights based on quantized state increments refers to calculating the vector length of the quantized state increments using the Euclidean norm method, and then calculating the column random propagation weights by comparing the set of active nodes of a given node in the current period with a threshold.

6. The autonomous and controllable kernel sharing and collaborative design method as described in claim 5, characterized in that: The construction of the received aggregate quantity refers to calculating the outbound messages with input tracking status and normalized status based on column random propagation weights, aggregating the outbound messages, and obtaining the received aggregate quantity.

7. The autonomous and controllable kernel sharing and collaborative design method as described in claim 6, characterized in that: The calculation and updating of the shared change tracking quantity refers to adding the rate compensation input to the tracking receive aggregate quantity with input, then subtracting the rate compensation input of the current period to obtain the updated tracking state to be input, updating the normalized state to the normalized receive aggregate quantity, and dividing the updated tracking state to be input by the updated normalized state to obtain the updated shared change tracking quantity.

8. The autonomous and controllable kernel sharing and collaborative design method as described in claim 7, characterized in that: The process of solving for the main trend deviation and the continuous deviation judgment quantity, and then correcting the updated design state vector by combining the consistency weight matrix, involves calculating the main trend deviation and the continuous deviation judgment quantity for the shared change tracking quantity and making a judgment to obtain the continuous deviation main trend mark. Then, by combining the consistency weight matrix, the second-order coordination direction of the node is calculated to correct the updated design state vector.

9. The autonomous and controllable kernel sharing and collaborative design method as described in claim 8, characterized in that: The iteration of the next cycle using the modified design state vector and updated shared change tracking quantity refers to constructing the quality gap prediction quantity for the next cycle based on the design state vector and shared change tracking quantity of the current cycle, setting intervention rules, setting archive indexes for nodes, counting the number of valid rules for nodes in the current cycle, calculating the rule increment, writing the rule increment and archive index back to the shared kernel rule base, and iterating using the updated shared change tracking quantity and modified design state vector.

10. The autonomous and controllable kernel sharing and collaborative design method as described in claim 9, characterized in that: The process of reading the project nodes and initial task packages of the current period, constructing a set of effective collaborative edges, and calculating the consistency weight matrix refers to reading the project nodes, determining whether there is direct communication capability between any two nodes, constructing an edge set, filtering the edge set for effective collaborative edges, obtaining the set of effective collaborative edges, and calculating and generating the consistency weight matrix.

Images