Space-air-ground integrated multi-agent collaborative large model online training method and system

Abstract

The invention discloses an air-space-ground integrated multi-agent collaborative large model online training method and system. According to the method, a distributed mixing precision quantitative configuration table is dynamically generated based on multi-node resource heterogeneity, and appropriate parameter precision is allocated to different nodes; a cross-node gradient residual error distribution and local compensation strategy is adopted, only compressed gradient residual errors are transmitted between nodes, errors are locally accumulated, and high-precision compensation updating is carried out regularly; elastic division and dynamic scheduling of model parameters and learning tasks among multiple nodes are supported, and task allocation and model segmentation are adjusted in real time according to the performance of each node and the network condition; when the nodes are lost or the calculation load is uneven, the system has fault-tolerant and adaptive scheduling capabilities, and can automatically redistribute model fragments or adjust the training process. According to the method, the computing power resources of the heterogeneous multi-agent are fully utilized, and efficient cooperative training of the super-large-scale model under the scene that the bandwidth is limited and the nodes dynamically change is realized.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of artificial intelligence, distributed machine learning and edge computing, and particularly relates to a space-ground-air integrated multi-agent collaborative large model online training method and system. BACKGROUND

[0002] With the exponential growth of deep learning model parameter size and data volume, model training in resource-constrained edge environments becomes extremely difficult. In the prior art, methods such as federated learning allow multiple devices to train models and periodically aggregate parameters, but usually assume that participating devices use the same precision and that the training process is synchronized, which is less efficient in heterogeneous computing power and unstable network environments. Traditional data parallel or model parallel distributed training mainly targets data centers or homogeneous clusters, requiring high-bandwidth interconnection between nodes, and has not been optimized for the dynamics of space-ground-air distributed agent networks.

[0003] In the space-ground-air integrated agent collaborative computing scenario, multiple types of nodes often collaborate to perform intelligent tasks, such as satellites, unmanned aerial vehicles, ground vehicles, and edge servers, which jointly train large-scale AI models. The computing power, storage capacity, and communication bandwidth of these nodes are different (i.e., significant heterogeneity), and the network connection has dynamic topology and intermittency: such as satellites can only communicate when they are over the top, unmanned aerial vehicles may experience link interruption due to flight distance, and ground nodes may experience performance bottlenecks due to load fluctuations. These challenges make it difficult to directly apply traditional centralized training.

[0004] How to enable multi-agents to efficiently collaborate in such a heterogeneous distributed environment to train large models has become a problem to be solved. On the one hand, large models have a large number of parameters and are computationally intensive, making it difficult for a single node to handle all training; on the other hand, frequently transmitting complete gradients or model parameters between nodes will consume a large amount of bandwidth and even slow down the training process. In addition, when some nodes fail to connect or have a much lower computing speed than other nodes, if there is no fault tolerance and scheduling mechanism, the overall training may be forced to stop or significantly slow down. As can be seen, the prior art lacks a solution that can optimize mixed-precision training for heterogeneous resources and reduce communication overhead while adapting to node dynamics. SUMMARY

[0005] The main purpose of the present application is to overcome the shortcomings of the prior art in distributed multi-agent collaborative training, and to provide a large model learning method and system that supports multi-node collaborative decision-making and flexible precision training scheduling. The present application aims to utilize the collaborative action of distributed heterogeneous nodes to achieve efficient training of super-large models with lower communication cost, while ensuring model precision and the robustness of the training process.

[0006] To achieve the above object, the application provides a space-ground-terrestrial integration multi-agent collaborative large model online training method, comprising the following steps:

[0007] 1. Heterogeneous resource perception and configuration table generation: obtain the resource status of each computing node in the distributed environment, including computing power (processor type, peak computing power), available memory capacity, network bandwidth and delay information, and the sensitivity index of model layer parameters to model accuracy, and the specific calculation method is as follows:

[0008] S i,j =ω i *H j

[0009] Wherein S i,j is used to quantify the adaptation degree of node j to execute the i-th layer task of the model, H j represents the hardware capability score, and the calculation method is as follows:

[0010]

[0011] Wherein P j represents the processor type quantization value (such as GPU=1, TPU=0.8, CPU=0.5, embedded=0.3), A j / A max represents the ratio of current computing power to the maximum computing power of the system, M j / M max represents the ratio of memory capacity to the maximum memory of the system, B j / B max represents the ratio of bandwidth to the maximum bandwidth of the system, and the weight coefficient α+β+γ+δ=1.

[0012] ω i is the model sensitivity.

[0013] Optionally, the model layer sensitivity is obtained by statistical average one norm of each layer gradient in historical training, and the calculation method is as follows:

[0014]

[0015] Wherein represents the gradient of the i-th layer parameter under the k-th batch of data, and N is the statistical batch number. ω i is the quantization of the i-th layer to the training degree, ω i The larger the value is, the greater the influence of the layer on the training performance is.

[0016] Based on the above information, a "distributed mixed precision quantization configuration table" is dynamically generated, which defines the representation precision strategy of each part of the model on each node, for example, assigning higher precision parameters (FP32 or FP16) to nodes with strong computing power, and assigning low precision parameters (such as INT8) to resource-constrained nodes, while still using higher precision for key model layers to maintain model performance. The configuration table can be updated in real time according to the preset period or event trigger mechanism during the training process to adapt to changes in node performance or task requirements.

[0017] 2. Model partitioning and task elastic scheduling: According to the configuration table and the real-time state of each node, the model parameters and training tasks are elastically partitioned and distributed among multiple nodes.

[0018] Specifically, the partitioning strategy can assign different layers or modules to different nodes based on the model structure (model parallelism), or distribute training data batches to different nodes for parallel computation (data parallelism), or a combination of both. During the scheduling process, the current computing load and network status of each node are considered to ensure load balancing of task distribution.

[0019] The calculation method of node load is as follows:

[0020]

[0021] wherein represents the computing power utilization rate of the node, represents the memory utilization rate, B j (t) represents the network delay, B base represents the delay reference value.

[0022] When a node has strong computing power or is idle, the task share or model slice allocated to it can be dynamically increased; otherwise, the task amount or layer number can be reduced to fully utilize the overall computing power and not cause performance bottlenecks for individual nodes. This elastic scheduling mechanism supports adjusting the model slicing scheme during operation, allowing nodes to join or exit collaborative computation as needed.

[0023] 3. Cross-node gradient residual distribution and local compensation update: In the multi-node collaborative training iteration, each node independently performs forward propagation and backward propagation calculations based on the partitioning to obtain local gradient or parameter update values. For gradient information that needs to be synchronized between nodes, instead of transmitting complete precision gradient data, the precision is first reduced according to the quantization configuration (such as quantization to FP16 or INT8, or extraction of important gradient sparsification), and the compression error (gradient residual) is calculated.

[0024] Optionally, quantization is performed according to the following formula:

[0025]

[0026] wherein represents the gradient calculated in theory with full precision (such as FP32) (ideal value), and Δ is the quantization step, which is calculated as

[0027]

[0028] wherein max(g t ) and min(g t ) represent the maximum value and the minimum value in the gradient vector, respectively. The quantization step determines the resolution in the mapping, and the smaller the step, the narrower the interval between discrete levels, and the quantized value can more finely approach the original value, but at the same time, higher calculation precision can be required. Through the above quantization operation, the full-precision gradient g t is mapped to a discrete set of values, so that lower numerical precision (INT8) is used for updating and transmission, achieving the purpose of reducing the calculation and communication overhead.

[0029] Each node only sends the compressed gradient or model update increment to the relevant node or central aggregation server, while saving the unsent gradient residual in the local residual buffer. The receiving end node updates the parameters according to the gradient increment from other nodes.

[0030] In addition, the system sets a gradient residual compensation trigger strategy: when the residual accumulation amount of a node exceeds a preset threshold or reaches a set synchronization period, a high-precision parameter correction step is triggered. This step can inject the fine gradient information discarded before into the global model in the form of each node sending accumulated residual or re-synchronizing key gradients with higher precision, so as to eliminate the error accumulation caused by low-precision transmission. Optionally, the compensation update is obtained by summing the errors in the residual buffer in a decaying form to obtain the compensation gradient G comp :

[0031]

[0032] wherein T is the number of training steps in the compensation period, γ ∈ (0, 1], which is a decay factor, and its role is to give higher weight to the most recent error, and the farther error is considered in a decaying form to control the weight of historical error in the compensation update; the compensation gradient G comp represents the weighted sum of the accumulated errors of all low-precision updates in the current period. Subsequently, the full-precision is used to inject G comp into the model parameters to correct the deviation caused by low-precision quantization. After completing the compensation, the residual buffer G res is emptied to start the error accumulation for the next period.

[0033] Through the above gradient compression transmission combined with error compensation strategy, the amount of cross-node communication data is greatly reduced, while the convergence accuracy of distributed training is ensured.

[0034] 4. Fault tolerance and adaptive co-scheduling: During the training process, the online state and running performance of each node are monitored in real time. When it is detected that a node is out of connection, communication is abnormal, or the computing performance is significantly reduced, the fault tolerance mechanism is started: the fault node is temporarily isolated and the scheduling module is notified to adjust the task allocation.

[0035] Specifically: for the temporarily disconnected node, the model parameter update it is responsible for can be compensated by other nodes based on the latest global parameters, or it can be synchronized after the node is restored; for the node that is unavailable for a long time, the model shard and unfinished task held by the node are re-divided to other available nodes for execution, and if necessary, the precision requirement of the re-allocated part is reduced to adapt to the resource limit of the receiving node, so as to ensure that the training continues without interruption.

[0036] Similarly, when it is found that a node has too high load and becomes a training bottleneck, the scheduling module can transfer part of the task of the node to an idle node according to the situation, or dynamically adjust the quantization configuration in the node to reduce the precision to speed up the calculation speed and relieve the overall imbalance. At the same time, the present application supports the dynamic joining of new nodes: when a new computing node accesses the distributed system, the configuration table is updated and the model splitting and task allocation are adjusted accordingly, so that the new node can immediately participate in collaborative training to further speed up the convergence. The above adaptive co-scheduling strategy improves the adaptability and robustness of the system to uncertain environments, and the training task can still be completed stably in the case of changes in node size or capacity.

[0037] The present application also provides a training system for implementing the above method. The system is composed of a plurality of heterogeneous computing nodes, each node is provided with a local training unit, and a central coordinator or distributed control logic is used to realize the following component functions:

[0038] Resource monitoring and quantization configuration module: used to collect real-time resource information and model layer sensitivity indicators of each node, run a predetermined algorithm to generate the distributed mixed precision quantization configuration table, and distribute the configuration to each node for execution. This module supports dynamic updating of the configuration table, ensuring that the precision allocation strategy always matches the node capacity and task demand.

[0039] Task division and scheduling module: used to divide and allocate model parameters and training data tasks among nodes according to the configuration table, and continuously monitor node state during training to adaptively adjust the scheduling scheme. This module can real-time re-plan the distribution of the model and the allocation of the computing task according to the joining, exiting or performance change of the nodes, ensuring load balancing and efficient utilization of multi-node collaboration.

[0040] Gradient communication and error compensation module: used for controlling the exchange and merging of gradients across nodes. This module receives gradient increments uploaded on each node (after quantization and compression processing) in each training iteration, performs necessary aggregation calculations to update global model parameters, and broadcasts or sends the update results to relevant nodes; at the same time, it is responsible for maintaining the gradient residual buffer of each node, triggering high-precision compensation update operations according to the preset strategy, and guiding each node to perform residual correction on its local model, thereby improving the distributed training accuracy.

[0041] Fault-tolerant control module: used for coordinating the adjustment of the training process when a node fails or has abnormal performance. This module can detect node timeouts or error events and notify the task scheduling module in a timely manner to reassign the model parts and data tasks that the node is responsible for; when a faulty node is restored online, it can decide whether and how to re-integrate it into the training according to the needs. For example, when a UAV node temporarily loses connection, the fault-tolerant module instructs other nodes to temporarily take over its calculations; after its recovery, the corresponding tasks are returned or the latest model parameters are synchronized to make it catch up with the global progress. The fault-tolerant control module is also responsible for recording the fault occurrence point and the training state, so that in extreme cases (such as the restart of the coordination server), it can continue training from the nearest checkpoint to ensure the robustness of the system.

[0042] The above method steps and system modules cooperate with each other to form a large model collaborative training scheme suitable for a heterogeneous multi-agent environment. The scheme of the present application can be effectively deployed in an aerospace integrated agent network: for example, in satellite-UAV-ground cooperative target detection model training, each node performs its own function according to its ability, and efficiently shares learning results through the method of the present application, thereby significantly shortening the model convergence time and improving the overall performance.

[0043] Compared with the prior art, the present application has the following beneficial effects:

[0044] 1. Make full use of heterogeneous computing resources and improve training efficiency: by dynamically generating a distributed mixed-precision quantization configuration table, the present application can allocate appropriate calculation precision and model segments to different nodes according to their hardware characteristics, so that each node works efficiently within its ability range. For example, nodes with strong GPU computing power undertake main calculations and can use higher precision, while embedded devices participate in part of the model calculation with low precision, thereby maximizing the overall performance. Compared with the method of single edge device isolated training or fixed precision training of each node, the present application significantly improves the utilization rate of the computing power of the multi-agent cluster and shortens the training time.

[0045] 2. Reduce communication overhead and achieve efficient collaboration: The combination of gradient residual distribution and local compensation strategy greatly reduces the data redundancy of cross-node communication. Each node only needs to transmit the compressed important gradient information, and the subtle gradient changes are retained locally to avoid frequent transmission of massive parameter updates.

[0046] 3. Ensure model accuracy and stable convergence: Despite the use of low-precision calculation and compressed communication, the invention avoids error accumulation caused by precision reduction through local residual compensation and periodic high-precision correction, enabling model training to achieve similar convergence accuracy to full-precision training. At the same time, dynamic quantization configuration allocates precision according to the sensitivity of each part of the model, ensuring that the calculation precision of key layers is not weakened, so that the model performance remains stable and reliable under the joint training of heterogeneous nodes.

[0047] 4. Elastic fault tolerance, improve system robustness: The invention supports dynamic joining, exiting and fault recovery of nodes. When a node fails or loses connection, the system can quickly adjust the allocation of models and tasks, ensuring uninterrupted or only temporary suspension of training without completely stopping training. Compared with traditional distributed training without fault tolerance mechanism, the invention can adapt to the frequent node fluctuations in space-air-ground multi-agent networks, ensuring the continuous advancement of training tasks over a long period of time.

[0048] 5. Expand application scenarios and achieve collaborative intelligence: The invention is particularly suitable for space-air-ground integration, edge computing clusters, and other scenarios, and can be deployed in multi-agent collaborative environments such as unmanned vehicle formation, Internet of Vehicles, remote sensing satellites, etc. Through this solution, multiple agents can jointly train and share AI models, such as joint learning of target recognition and environment perception tasks, and update models in real time to adapt to environmental changes, significantly improving the autonomous learning ability and collaborative decision-making level of distributed intelligent systems, and having important industrial application value.

[0049] In summary, the multi-agent collaborative large model training method and system provided by the invention realizes efficient and reliable training of super-large scale models in a heterogeneous distributed environment, filling the gap in this field in the prior art. BRIEF DESCRIPTION OF DRAWINGS

[0050] Figure 1 The figure is a schematic diagram of the multi-agent collaborative large model training system architecture of the embodiment of the invention, which shows a distributed training system composed of heterogeneous nodes such as satellites, unmanned aerial vehicles, ground vehicles and a central coordination unit. The interaction between each module is shown in the figure.

[0051] Figure 2 The figure is a flow chart of the training task scheduling process of the embodiment of the invention, which illustrates the process steps of resource perception, configuration generation, model division, gradient communication and fault tolerance scheduling.

[0052] Figure 3 As a typical cooperative scenario of the embodiments of the present application, taking the satellite, unmanned aerial vehicle and ground vehicle cooperative target recognition model training as an example, the workflow and data interaction of multi-agent cooperative training are shown. DETAILED DESCRIPTION

[0053] In order to better understand the present application, the application scheme will be described in detail below in combination with the drawings and specific embodiments. It should be emphasized that the following embodiments are intended to illustrate the technical principles and preferred implementation of the present application, and are not a limitation on the protection scope of the present application. Based on the idea of the present application, those skilled in the art can make various modifications and substitutions in specific applications, as long as they do not deviate from the principles of the present application, which should belong to the protection scope of the present application.

[0054] Embodiment: Space-air-ground cooperative multi-agent target recognition model training

[0055] This embodiment combines Figure 1 and Figure 3 is shown, a typical application scenario of satellite, unmanned aerial vehicle and ground vehicle cooperative training of large-scale target recognition model is described. It is assumed that the model is a deep neural network (such as an improved Transformer model) containing tens of billions of parameters, which needs to be incrementally trained in a distributed multi-agent environment to identify new target types. The system hardware environment includes: one low-orbit remote sensing satellite running at high altitude, carrying a limited power embedded AI module; multiple unmanned aerial vehicles, equipped with small GPU accelerators for edge computing; several ground vehicles or edge servers, with strong GPU / CPU computing power; each node forms a self-organizing network through wireless link and satellite relay.

[0056] 1. Heterogeneous resource perception and configuration:

[0057] As shown in Figure 2 , the central coordination unit first collects the hardware capabilities and state information of each node. The satellite node has only a low-power embedded computing unit due to power consumption limitations, which is suitable for performing low-precision inference and a small amount of simple update; the unmanned aerial vehicle node is equipped with a medium-power GPU, with limited memory; the ground node has the strongest computing and storage capabilities and a relatively stable power supply. The central coordination unit also counts the influence of each layer parameter of the current training model on the recognition accuracy, for example, according to the past gradient amplitude to evaluate the sensitivity of each layer. The specific calculation method is as follows:

[0058] S i,j =ω i *H j

[0059] Where H j represents the hardware capability score, which is calculated as follows:

[0060]

[0061] where P j represents the processor type quantization value (such as GPU = 1, TPU = 0.8, CPU = 0.5, embedded = 0.3), A j / A max represents the ratio of accelerator computing power to the maximum computing power of the system, M j / M max represents the ratio of memory capacity to the maximum memory of the system, B j / B max represents the ratio of bandwidth to the maximum bandwidth of the system, and the weight coefficients α + β + γ + δ = 1.

[0062] ω i is the model sensitivity, which is optional. The model layer sensitivity is obtained by statistically averaging the gradient of each layer in the historical training, and the calculation method is as follows:

[0063]

[0064] where represents the gradient of the i-th layer parameter under the k-th batch of data, N is the number of statistical batches, ω i is the quantization of the i-th layer to the training impact, ω i The larger the value is, the greater the impact of the layer on the training performance.

[0065] Based on this information, the system generates a distributed mixed precision quantization configuration table, as shown in the following table:

[0066]

[0067] For example: the convolution feature extraction layer and the Transformer attention layer of the model are run on the ground node with FP16 precision, and some computationally intensive secondary layers (such as embedding layers, normalization layers) are quantized to INT8 by satellite and unmanned aerial vehicle nodes; at the same time, for each node, the gradient precision used in local update is limited, such as the satellite node gradient is quantized to 8 bits, and the ground node can use 16-bit precision.

[0068] The configuration table also indicates the range of model layers responsible by each node, so as to clearly define the model splitting scheme. The configuration process takes into account the communication bandwidth between nodes: since the satellite link bandwidth is the narrowest, the configuration table tends to reduce the amount of data that the satellite needs to transmit, for example, the satellite only provides image data and performs simple forward calculation, and the complex backward gradient calculation is handed over to the downstream node. After the configuration table is generated, it is distributed to each node, and the cooperative parameter update strategy of this training is determined accordingly.

[0069] 2. Model partitioning and task scheduling:

[0070] As Figure 2 shown in the training start phase, the parameters of the model are distributed to each node according to the scheme specified in the configuration table: the ground server loads and maintains a complete copy of the model parameters for updating; at the same time, part of the network layer weight is issued to the UAV and satellite, so that they undertake part of the forward calculation responsibility.

[0071] In terms of training data, the satellite continuously takes high-altitude images as new training samples; the UAV also uses the on-board camera to collect regional photos for training.

[0072] The coordination unit adjusts the execution order and rhythm of the training task according to the node performance and current load: the satellite node preprocesses and extracts the initial features of each frame of image, and then sends the intermediate features to the ground or UAV node; the ground node is responsible for the back propagation calculation and parameter update of the complete model, but in order to reduce the burden, part of the gradient calculation task is shared by the UAV node (for example, the UAV calculates the gradient of the part of the model layer it is responsible for and returns the result). If a UAV is short of computing resources at a certain moment because it is executing other tasks, the scheduling module will reduce the task batch allocated to it and more data will be directly processed by the ground node; on the contrary, when the ground node is temporarily overloaded (for example, it needs to process data from multiple UAVs at the same time), part of the UAVs can be allowed to complete a few training steps independently and then combine the results. Through this flexible scheduling, the computing load of each node remains relatively balanced, and the overall hardware resources are used efficiently.

[0073] 3. Gradient residual transmission and local compensation:

[0074] In each training iteration, the ground node as the master node cooperates with other collaborative nodes to complete the forward and reverse calculation of the model.

[0075] Specifically, the satellite node sends the preprocessed image features to the UAV and ground node for middle layer calculation in the model; the UAV node continues to perform forward calculation of part of the model layer on the received features and produces local gradient; finally, the ground node completes the forward inference of the remaining layers and aggregates the gradient information from the UAV for global error back propagation.

[0076] In order to reduce the communication volume, the UAV and satellite first quantize and compress the data according to the configuration table when sending the gradient or intermediate activation, for example, reducing the floating-point gradient value to 8-bit representation and only transmitting the change of important coefficients. Optionally, quantization is performed according to the following formula:

[0077]

[0078] Where denotes the theoretically full-precision (e.g. FP32) computed gradient (ideal value), and is the quantization step size, which is calculated as

[0079]

[0080] where max(g t ) and min(g t ) denote the maximum and minimum value in the gradient vector respectively. The quantization step size determines the resolution in the mapping process, the smaller the step size, the narrower the interval between discrete levels, and the quantized value can be closer to the original value with higher precision, but meanwhile, higher computation precision is required.

[0081] Through the above quantization operation, the full-precision gradient g t is mapped to a discrete set of values, so that the update and transmission are performed using lower numerical precision (INT8), achieving the purpose of reducing the computation and communication overhead.

[0082] On the ground node side, the gradient communication and error compensation module receives the compressed gradient and decodes and aggregates it. For each gradient tensor from the UAV, the module compares the approximate gradient with the ideal full-precision gradient (which can be obtained by local re-computation or accumulated residual error estimation before the ground node) and adds the difference to the residual buffer of the corresponding UAV node. The accumulation process of the residual error is as follows:

[0083]

[0084] where is the ideal full-precision gradient, is the approximate gradient, and G res is the accumulated error in the residual buffer.

[0085] The satellite node, since it only participates in the forward process, the feature map it provides can also be transmitted with low-precision compression, and the ground node also records the reconstruction error. After several iterations, when the error norm of G res in the residual buffer of a UAV node exceeds a threshold, the system will notify the UAV to increase the gradient transmission precision or directly send the accumulated residual error for a compensation update in the next training period. Optionally, the compensation update is obtained by summing the errors in the residual buffer in a decaying form to obtain the compensation gradient G comp :

[0086]

[0087] where T is the number of training steps in the compensation period, and γ e (0, 1] is a decay factor, which gives higher weight to the most recent error and considers the farther error in a decaying form to control the weight of historical error in the compensation update; the compensation gradient G compdenotes the total sum of the weighted error accumulated by all low-precision updates in the current cycle. Then, G comp The injected model parameters correct the bias caused by low-precision quantization. After compensation, the residual buffer G res The error accumulation for the next cycle is restarted.

[0088] At the same time, the ground node also periodically corrects the previous accumulated error using high-precision calculation for its own parameter update. For example, after every 10 low-precision synchronizations, the ground node initiates a full-precision All-reduce operation to synchronize the full-precision values of the key gradients among all nodes, ensuring that the model parameters of each node are consistent with full-precision training. Through this mechanism of local multiple low-precision updates combined with occasional high-precision correction, this embodiment greatly saves communication while achieving convergence effects comparable to centralized full-precision training.

[0089] 4. Fault-tolerant mechanism and adaptive adjustment

[0090] At the 50th round of training, assume that a UAV temporarily loses contact because it has flown out of the communication range. At this time, the fault-tolerant control module detects that the node has not uploaded the gradient within the timeout period, and immediately starts the fault-tolerant process: first, mark the missing data as missing, and instruct the ground node to skip the gradient update for the part responsible by the UAV, and approximate the model parameters at the last time the node participated (i.e., temporarily do not update those parameters); at the same time, the task scheduling module reduces the subsequent data allocation to the UAV, and sends more newly collected images to other online UAVs and ground nodes for processing.

[0091] After several rounds of training, the disconnected UAV restores communication and attempts to rejoin the training. The system immediately issues the current latest model parameter snapshot to it, and reassigns an appropriate amount of tasks according to its performance status at the time of recovery. If the model has undergone significant changes during the period the UAV was missing, the system can also arrange an additional synchronization to make its model state consistent with the global state before continuing normal training.

[0092] For example, if it is found during training that the satellite node is always the speed bottleneck due to hardware limitations, and it takes significantly longer to process a batch of data than other nodes, the system will perform adaptive adjustment: on the one hand, reduce the number of layers of the model that the satellite needs to participate in (possibly transfer part of the network front several layers originally executed by the satellite to the unmanned aerial vehicle or ground node), on the other hand, further reduce the accuracy of the satellite's calculation when updating the configuration table (for example, use simpler arithmetic operations or higher compression ratio), in order to speed up its processing. Through the above fault tolerance and adjustment measures, the entire multi-agent system still maintains the continuity and efficiency of collaborative work in the case of dynamic changes in nodes. It has been proved that the method of the present application can significantly improve the training robustness in the air-ground collaborative training scene: even if a single unmanned aerial vehicle node is offline for a long time, the remaining nodes can still complete the model training relatively smoothly; when it is restored, it only needs a short synchronization to catch up with the progress, and does not affect the final model accuracy.

[0093] In summary, the present embodiment verifies the effectiveness of the present application in distributed multi-agent collaborative training. In the space-air-ground heterogeneous network environment, using the method of the present application, each node shares the model training task according to its own ability, which not only avoids single-point bottleneck but also maximally reduces communication cost, and realizes efficient incremental training of a super-large-scale target recognition model. This scheme is also applicable to other similar multi-agent collaborative learning scenarios (such as automatic driving model joint training in Internet of Vehicles, multi-robot collaborative learning in intelligent factory, etc.), and can promote distributed intelligent systems to achieve better learning results.

[0094] The above are only the preferred embodiments of the present application and the technical principles applied, and those skilled in the art will understand that the present application is not limited to the specific embodiments described herein, and those skilled in the art can make various obvious changes, re-adjustments and substitutions without departing from the scope of the present application. Therefore, although the present application has been described in more detail through the above embodiments, the present application is not limited to the above embodiments, and can include more other equivalent embodiments without departing from the concept of the present application, and the scope of the present application is determined by the scope of the appended claims.

Claims

1. A method for online training of a large-scale model of space-ground integrated multi-agent collaboration, characterized in that: The following steps are involved: (1) Obtain resource information and model parameter sensitivity indicators of each computing node in the distributed environment, and dynamically generate a distributed mixed-precision quantization configuration table based on the heterogeneity of node computing power. The configuration table defines the computing precision allocation strategy for each part of the model on each node; (2) flexibly dividing and allocating the parameters of the model to be trained and the training tasks among multiple nodes according to the configuration table, and dynamically adjusting the task scheduling according to the node status during the training process; (3) Each node independently performs the forward reasoning and gradient calculation of the assigned model part. When cross-node synchronization is required, only the quantized and compressed gradient residual information is transmitted, and the gradient error of the untransmitted part is stored locally for accumulation; (4) Periodically or when the residual accumulation exceeds a preset threshold, a high-precision model update compensation step is triggered, including exchanging the accumulated gradient residuals of each node or improving the gradient synchronization accuracy to correct the model error caused by low-precision calculation and transmission; (5) When a node is detected to be disconnected or has abnormal performance, the fault tolerance mechanism is automatically enabled to readjust the model parameters and the distribution of tasks among the remaining nodes. When the failed node is restored online, it is synchronized with the latest model state and rejoined for training, thereby ensuring that the training process continues to converge.

2. The method according to claim 1, characterized in that The distributed mixed-precision quantization configuration table generated in step (1) comprehensively considers the processor type, hardware acceleration capability, memory capacity and network bandwidth of each node and the sensitivity of each layer of the model to the final accuracy. The specific calculation method is as follows: S i,j =ω i *H j Among them S i,j It is used to quantify the degree of adaptation of node j to perform the i-th layer task of the model, H j represents the hardware capability score, ω i is the model sensitivity; For model layers with high computational sensitivity, higher computational precision is specified on most nodes. For parts with low sensitivity or high computational overhead, low-precision quantization is used and assigned to resource-constrained nodes for execution to balance model accuracy and training speed.

3. The method according to claim 1, characterized in that The elastic partitioning and task scheduling in step (2) include: continuously monitoring the computing load and communication delay of each node during the training process, and when a node is found to be in a performance bottleneck, reducing the subsequent training data or model shards allocated to the node and transferring its tasks to other idle nodes; when it is detected that the node has surplus computing power or a new node is added, increasing the model layer or data batch in which it participates, and updating the configuration table accordingly to keep the utilization of all nodes balanced.

4. The method according to claim 1, wherein In step (3), each node transmitting the gradient residual information includes: performing low-bit width quantization or sparse processing on the gradient vector calculated by the node, extracting only important gradient values ​​and their indexes and sending them to the target node or parameter aggregation server.

5. The method according to claim 1, wherein The high-precision model update compensation step in step (4) includes: each node or the central coordination unit detects the norm of the accumulated error in the local residual buffer, and when it exceeds a preset threshold or reaches a predetermined communication period, triggers all nodes to exchange their respective key gradients or residual information with the first precision; then the model parameters are globally synchronized and updated using the first precision, and the residual buffer of each node is cleared to zero, thereby eliminating the error accumulation caused by low-precision synchronization.

6. The method according to claim 1, characterized in that The fault-tolerance mechanism in step (5) specifically includes: when a node loses connection for more than a predetermined time threshold, the node is marked as failed and stops waiting for its gradient, and other nodes are asked to estimate and replace the missing gradient part or skip the update; at the same time, the scheduling module reallocates the model parameters that the node is responsible for to the still connected nodes for temporary hosting, to prevent training interruption due to single node failure; after the failed node is back online, the system incrementally synchronizes the model updates it missed, restores its model state to the current version, and then releases the hosting so that it can continue to participate in the remaining training.

7. A training system for implementing the method according to any one of claims 1 to 6, characterized in that: The system includes multiple heterogeneous computing nodes and a communication network connecting the nodes. The system is configured with a central coordination unit or a distributed control module to perform the functions of the following units: Resource monitoring and precision configuration unit, used to collect computing resource information and model layer importance indicators of each node, generate a distributed mixed precision quantization configuration table and send it to each node; A task division and scheduling unit, configured to divide and allocate model parameters and training tasks among the nodes according to the configuration table, and dynamically adjust the task load distribution of the nodes during the training process; The gradient communication and compensation unit is used to transmit the gradient information generated during the training process between nodes and aggregate and update the model parameters. It also maintains the gradient residual buffer of each node and triggers high-precision compensation updates to ensure the training convergence accuracy. A fault-tolerant control unit monitors the online status of nodes, coordinates task redistribution and model data migration when a node loses connection or has performance anomalies, and synchronizes model parameters when the node recovers to enable it to rejoin training.

8. The system according to claim 7, characterized in that: The resource monitoring and precision configuration unit includes a heterogeneous resource perception module and a precision allocation decision module. The former is used to detect the hardware type, computing power performance and communication bandwidth of each node, and the latter calculates the precision configuration plan of each node based on the detection results and the preset model layer sensitivity rules, and forms the mixed precision quantization configuration table.

9. The system according to claim 7, characterized in that: The gradient communication and compensation unit includes a compression coding submodule and an error compensation submodule. The compression coding submodule uses gradient quantization, truncation, or sparse coding algorithms to compress and aggregate the gradient information uploaded by each node. The error compensation submodule periodically triggers full-precision gradient synchronization operations or notifies relevant nodes to send accumulated residuals based on the content of the gradient residual buffer of each node for correcting model parameters.

10. The system according to claim 7, wherein: The fault-tolerant control unit is configured with a fault detection module and a scheduling interaction module. The fault detection module determines the online status of the node through a timeout mechanism, and sends a reconfiguration request to the scheduling interaction module when it detects that the node is offline. The scheduling interaction module responds to the request and adjusts the mapping of models and tasks on the remaining nodes, and coordinates the update of its model parameter copies after the faulty node comes back online to make its status consistent with the current global model.

Images