Large language model end-cloud collaborative reasoning system based on low-rank fine-tuning

Abstract

The application discloses a large language model end-cloud collaborative reasoning system based on low-rank fine-tuning, and belongs to the technical field of inference optimization of end-edge-cloud computing. An end-cloud collaborative reasoning architecture is established. In an offline stage, a large language model is fine-tuned based on training data of different downstream tasks on a cloud side. In an online stage, a user request is classified through a "variational autoencoder-Gaussian mixture model" clustering, and it is judged whether a low-rank adapter matching a current task exists in an end-side cache. If yes, reasoning is performed on the end side. Otherwise, the task is forwarded to the cloud side. After the architecture processes a plurality of user requests, a Mamba model is used to analyze user historical requests and a cache state, and an end-side low-rank adapter library is dynamically updated. End-cloud load and reasoning delay are monitored in real time, and a new adapter is incrementally issued to the end side according to a task repetition rate. The application realizes dynamic balance of the system, reduces computing and storage overhead, and ensures high efficiency and adaptability of the system.

Description

Technical Field

[0001] This invention belongs to the field of reasoning optimization technology in edge-cloud computing, specifically referring to an edge-cloud collaborative reasoning system based on a large language model with low-rank fine-tuning. Background Technology

[0002] In recent years, inference services for large language models have been widely adopted globally, used by users to perform various general machine learning tasks, including but not limited to text translation, content summarization, knowledge retrieval, and logical reasoning. With the rapid growth of the user base, service providers have had to continuously expand their cloud computing resources to maintain service quality. However, this expansion has directly resulted in a sharp increase in the cost of inference services, in some cases exceeding the cost of the pre-training phase of large language models. The high cost of GPU usage in cloud servers has become a major component of the total cost of inference services. Faced with this challenge, a new research direction has gradually gained attention in recent years: leveraging the continuously increasing computing power and storage efficiency of terminal devices to reduce the dependence of large language model inference services on cloud computing resources. In particular, deploying lightweight, small language models for inference on the edge has become a promising solution. Although small language models for edge devices have emerged in recent years, and their quality has continued to improve, the limited computing resources and storage capacity of edge devices still make it difficult to avoid a decline in user experience when using these small models for inference.

[0003] Research shows that increasing the parameter size of large language models can significantly improve their accuracy and responsiveness. Generally, a language model with strong expressive power requires at least 1 billion parameters, while multi-task understanding typically requires over 30 billion parameters. However, limited by the memory capacity and power consumption constraints of edge devices, small language models based on the Transformer architecture struggle to exceed 8 billion parameters. This limitation in parameter size directly leads to a significant performance gap between edge models and large-scale language models when handling complex tasks. Therefore, how to reduce the cloud computing cost of large language model inference services without sacrificing user experience has become a crucial scientific problem that urgently needs to be solved.

[0004] To address this challenge, academia and industry have proposed a variety of optimization solutions, mainly including two categories of strategies: model compression and system coordination.

[0005] Model compression: Model compression techniques aim to reduce the computational and storage requirements of language models, enabling them to run more efficiently in constrained hardware environments. Current mainstream methods include knowledge distillation, pruning, low-rank decomposition, and quantization. Knowledge distillation trains a small "student model" to mimic the output of a large "teacher model," thus preserving some performance at a smaller model size. Pruning techniques reduce computational complexity by removing network weights that contribute less to inference. Low-rank decomposition uses matrix factorization to reduce the number of model parameters, while quantization reduces storage and computational overhead by decreasing the bit precision of model parameters. However, while these methods effectively reduce computational costs, they often sacrifice some inference accuracy, and the model's adaptability and generality are also affected.

[0006] System Collaboration: At the system level, researchers explored various edge-cloud collaborative inference strategies to find the optimal balance between computational cost, accuracy, and inference latency. Typical methods include model segmentation and multi-model collaborative inference. Model segmentation breaks down large language models into multiple sub-models, with some computation performed on the edge and the remaining tasks handled in the cloud. This approach reduces the computational burden on the edge while retaining significant model capabilities. However, due to the latency overhead of edge-cloud data transmission, model segmentation still faces challenges in applications with high real-time requirements. Multi-model collaborative inference (such as speculative decoding) attempts to run a lightweight model on the edge, generating partial inference results, which are then corrected or completed by the cloud model. This strategy reduces cloud computing requirements to some extent but is still affected by mobile network round-trip time, potentially failing to meet user needs in highly interactive tasks.

[0007] Overall, reducing the cloud computing costs of large-scale language model inference services is a comprehensive issue involving model architecture, system optimization, and intelligent scheduling. Although industry and academia have made extensive efforts to optimize video parameter configuration, large-scale language model edge-cloud collaborative inference technology still needs further exploration in terms of more efficient computing architectures and collaborative mechanisms while ensuring user experience. Summary of the Invention

[0008] This invention proposes a cloud-edge collaborative reasoning system for large language models based on low-rank fine-tuning, which aims to optimize the reasoning service of large language models, thereby improving task accuracy and reducing end-to-end reasoning latency while reducing cloud computing costs.

[0009] The construction process of a cloud-based collaborative reasoning system for large language models based on low-rank fine-tuning includes the following steps:

[0010] Step 1: Establish an edge-cloud collaborative inference architecture. Deploy a lightweight language model on the edge and introduce a low-rank adapter and an intelligent classifier. On the cloud side, store the low-rank adapter set in a low-rank adapter library for use in assigning and calling cloud-side computation after edge-side task classification.

[0011] Step 2: In the offline phase, the cloud side fine-tunes the parameters of the large language model based on training data from different downstream tasks.

[0012] The fine-tuning process is as follows:

[0013] The weight matrix of the pre-trained model is decomposed into directional and magnitude components, and the directional components are frozen while the magnitude components are retained. At the same time, a shared low-rank matrix A and a task-specific matrix B are initialized, and matrix A is frozen while B is retained for training.

[0014] Weights of the pre-trained model Decomposed into directional components and amplitude components Its mathematical expression is:

[0015]

[0016] in, It is the column norm of the weight matrix, used to capture the magnitude components; The directional component is obtained through column normalization.

[0017] During low-rank fine-tuning, the shared frozen matrix Only update the amplitude component. and low-rank fine-tuning task-specific matrix The specific weight update process is represented as follows:

[0018]

[0019] and These represent the updated magnitude components and the task-specific matrix, respectively. Represents the initial weight matrix; This indicates the column norm of the parameter after using LoRA.

[0020] The edge device only needs to store a single matrix during training. And when needed, it transmits new tasks via a low-rank adapter (i.e., a matrix). and the fine-tuned amplitude parameters This is used to update the small language model.

[0021] Step 3, Online Phase: When a user issues a request, the request is classified using "Variational Autoencoder-Gaussian Mixture Model" clustering. It is then determined whether a low-rank adapter (B, m) matching the current task exists in the client-side cache. If so, it is loaded into the client-side small language model, inference is performed, and the task result is obtained; otherwise, the task is forwarded to the cloud side for inference.

[0022] The task classification process is modeled using the following formula:

[0023]

[0024]

[0025] in, and These represent the input data (text) and the implicit variables, respectively. and It is the output of the variational autoencoder, representing the mean and variance of the latent variables.

[0026] The task classification process is as follows: A variational autoencoder maps the input data to a Gaussian-distributed latent space using the mean and variance of the latent variables. Then, a Gaussian mixture model models the task subcategories using multiple Gaussian components, yielding the task classification result. Based on the task classification result, the system can decide whether the task is executed on the edge device or forwarded to the cloud for processing.

[0027] Step four: After the architecture has processed a number of user requests, it analyzes the user's historical requests and cache status based on the Mamba model, dynamically updates the low-rank adapter library on the client side, and prioritizes the retention of parameters for high-frequency tasks.

[0028] Utilizing user historical access sequences and the current low-rank adapter library storage state Dual-modal data, through learning The algorithm makes the optimal update decision based on its decision-making process, which is as follows:

[0029] During model training, the Mamba model, based on a state-space model architecture, was used to extract temporal features of user access behavior. The hidden state update equation of the Mamba model is:

[0030]

[0031] in, It is a selective update gate. It represents a state-space model and supports parallel computing. These are the residual coefficients. During the inference phase, this calculation process switches to a serial mode.

[0032] To further enhance prediction capabilities, the system uses two independently initialized projection matrices. and Embed user access data and cache information separately:

[0033]

[0034]

[0035] in, This represents the embedded user access data. For embedded cache information; position encoding It is generated using a sine function.

[0036] User access data and cached information are projected onto a unified feature space, and the concatenated features are then used to... To represent the characteristics after fusion:

[0037]

[0038] in, It is a projection matrix, through Will Projected to and A hidden space where we are together.

[0039] During training, a binary cross-entropy loss function is used to guide the model in learning task classification and cache replacement strategies.

[0040]

[0041] Where i=1,…,Q is the number of edge-side caches. It is the result of strategy prediction. It is LayerNorm ( ). Refers to the actual result. It is a vector of length Q. This refers to the strategy for whether the edge cache at position i should be replaced.

[0042] The cache replacement strategy is as follows: release one of the adapters in the client-side low-rank adapter library and replace it with an adapter suitable for the new task category. When this cache replacement strategy minimizes the aforementioned loss function, the updated client-side low-rank adapter library is obtained. This strategy maintains the dynamic nature of the client-side cached adapters.

[0043] Step 5: Monitor the cloud load and inference latency in real time. When the confidence level on the edge is insufficient, trigger a rollback on the cloud side and send a new adapter to the edge side based on the incremental task repetition rate.

[0044] The trigger condition for the cloud to send a new adapter to the end side is as follows: set a hyperparameter as the cloud access threshold, count the number of cloud accesses of a certain task within a unit of time, and if the cloud side has a corresponding adapter, then when the number of cloud accesses of the task exceeds the threshold, the cloud side sends a new adapter to the end side.

[0045] Step six: Periodically optimize the task classification threshold and the edge cache capacity to achieve a dynamic balance between cost, latency, and accuracy.

[0046] The advantages and beneficial effects of this invention are as follows:

[0047] The cloud-based collaborative reasoning system for large language models based on low-rank fine-tuning proposed in this invention reduces computational and storage overhead while ensuring the system's efficiency and adaptability by reducing parameter transmission and storage requirements, optimizing task classification and allocation, and dynamically updating model parameters. Attached Figure Description

[0048] Figure 1 This is a schematic diagram of the architecture of the cloud-edge collaborative reasoning system based on a large language model with low-rank fine-tuning, as described in this invention.

[0049] Figure 2 This is a flowchart illustrating the implementation of the cloud-edge collaborative reasoning system based on a large language model with low-rank fine-tuning, as described in this invention. Detailed Implementation

[0050] The present invention will now be described in further detail with reference to the accompanying drawings and embodiments.

[0051] Existing edge-cloud collaborative reasoning methods have limited reasoning capabilities on edge devices, making them unsuitable for complex tasks. Furthermore, these methods typically rely on cloud computing resources for primary reasoning, while the edge devices perform only shallow computations, failing to fully utilize their potential and resulting in low overall system computing resource utilization. Therefore, this invention proposes a novel edge-cloud collaborative reasoning system based on the following key observations:

[0052] First, while edge devices have limited computing power, they still possess the potential to perform some inference tasks, especially for high-frequency, low-complexity tasks. Appropriate model optimization can enable more computation on the edge, thereby reducing the load on the cloud. Second, most existing edge-cloud collaboration methods employ static partitioning strategies, failing to adapt to dynamic changes in task complexity, thus limiting inference efficiency. Finally, low-rank fine-tuning techniques have demonstrated significant computational and storage efficiency advantages in model optimization, making them an ideal choice for edge-side model optimization.

[0053] Therefore, this invention combines low-rank fine-tuning technology to deploy a highly efficient lightweight model on the edge, and achieves the optimization goal of edge-cloud collaborative inference through intelligent task scheduling and cache optimization mechanisms, thereby improving inference efficiency and reducing overall computational overhead. Its core idea is to introduce a small number of low-rank adapters into the edge model to enhance its inference capability for high-frequency tasks, while intelligently classifying complex tasks and dynamically allocating them to cloud computing. This reduces cloud load while ensuring improved inference accuracy and minimizes storage and transmission overhead on edge devices.

[0054] like Figure 1 As shown, the overall architecture of this system consists of an offline phase and an online phase, and the allocation strategy of cloud computing resources is optimized collaboratively.

[0055] 1. During the offline phase, the system performs decoupling of large model weights, optimization of low-rank adapters, and edge storage management to reduce edge-cloud transmission overhead and lower fine-tuning computation costs.

[0056] Existing large language model fine-tuning schemes typically rely on full parameter updates or adapter fine-tuning, resulting in high storage and transmission costs, making them unsuitable for edge-cloud collaborative environments. To address this, this invention proposes a resource-friendly low-rank fine-tuning method to reduce the computational and storage costs of fine-tuning large language models.

[0057] First, this method decomposes the weight matrix of the pre-trained model into directional and magnitude components, allowing the edge device to store only the low-rank matrix instead of all model parameters, thus significantly reducing storage pressure and transmission costs. Simultaneously, this stage utilizes large-scale data for model training to ensure that the lightweight edge model still possesses high inference capabilities under limited computing resources. Furthermore, by freezing some shared parameters, this method ensures that models for different tasks on the edge can share optimized directional components, thereby reducing computational requirements on the edge and improving the generalization ability of the low-rank adapter.

[0058] The algorithm works by adjusting the weight matrix of the pre-trained model. This decomposition significantly reduces the computational cost of parameters during fine-tuning while maintaining high performance after fine-tuning. Specifically, the algorithm decomposes the pre-trained model weights... Decomposed into directional components and amplitude components Its mathematical expression is:

[0059]

[0060] in, It is the column norm of the weight matrix, used to capture the magnitude components; The directional components are obtained through column normalization. This decomposition method effectively reduces the computational complexity during fine-tuning and provides a more streamlined parameter structure for subsequent task optimization.

[0061] In the actual fine-tuning process, the algorithm uses a shared frozen matrix. Only update the amplitude component. and low-rank fine-tuning matrix This design allows the matrix to be fine-tuned during different tasks. It can remain shared and be frozen, while the matrix Then, optimization is performed based on task requirements. The specific weight update process can be represented as follows:

[0062]

[0063] In this process, the matrix It is fixed and shared among different tasks, while the matrix This design is intended for task-specific adjustments only. A key advantage of this approach is the reduction in the number of parameters transmitted, approximately 50%, while the low-rank fine-tuning focuses on optimizing the directional components, thus ensuring the stability of the model's performance after fine-tuning.

[0064] Furthermore, edge devices only need to store a single matrix during training. And when needed, it transmits new tasks via a low-rank adapter (i.e., a matrix). and the fine-tuned amplitude parameters This approach uses a different method to update the model. It not only reduces computational and storage overhead but also lowers the burden of data transfer, thus enabling more efficient inference on resource-constrained devices.

[0065] 2. During the online phase, the system achieves intelligent task scheduling based on task classification and cache management strategies.

[0066] During online inference, the system classifies tasks using imitation learning and combines this with a dynamic update strategy for the edge cache to improve task allocation efficiency and reduce inference latency. To further optimize edge inference efficiency, the system employs a cache management method based on a state-space model to dynamically update the edge low-rank adapter, enabling it to adapt to user inference needs at any time and improve the effective hit rate of the edge model.

[0067] The key task in the online phase is to optimize the execution of inference tasks through efficient task classification and dynamic allocation. In this phase, a user-aware model scheduling algorithm based on imitation learning is proposed. This algorithm can dynamically adjust the execution mode of inference tasks according to the characteristics of user requests. First, task classification is performed by combining variational autoencoders and Gaussian mixture models. This process can efficiently identify the underlying structure between different tasks and allocate appropriate resources to each task. The task classification process can be modeled by the following formula:

[0068]

[0069]

[0070] in, and The output of the variational autoencoder represents the mean and variance of the latent variables. Through these outputs, the variational autoencoder can effectively map the input data to a latent space that conforms to a Gaussian distribution. The Gaussian mixture model, on the other hand, models task subcategories using multiple Gaussian components, thus effectively classifying tasks. Based on the task classification results, the system can decide whether to execute the task on the edge device or forward it to the cloud for processing.

[0071] To further improve the adaptability of the endpoint model, the system designs a method for dynamically updating the endpoint low-rank fine-tuning parameter library. This method utilizes user historical access sequences. and the current low-rank fine-tuning library storage status Dual-modal data, through learning The algorithm makes the optimal update decision based on its decision-making.

[0072] During model training, the Mamba model, based on a state-space model architecture, was used to extract temporal features of user access behavior. The hidden state update equation of the Mamba model is:

[0073]

[0074] in, It is a selective update gate. It represents a state-space model that supports parallel computation. During the inference phase, this computation process switches to serial mode.

[0075] To further enhance prediction capabilities, the system uses two independently initialized projection matrices. and Embed user access data and cache information separately:

[0076]

[0077]

[0078] Among them, position encoding It is generated using a sine function. This process projects user access data and cached information onto a unified feature space, and then uses the concatenated features... To represent the characteristics after fusion:

[0079]

[0080] This fusion method preserves the complete information of the original features and effectively improves the accuracy of feature extraction and prediction. During training, a binary cross-entropy loss function is used to guide the model in learning task classification and cache replacement strategies.

[0081]

[0082] in, This is the result of strategy prediction.

[0083] The cache replacement strategy is as follows: release one adapter from the low-rank adapter library on the client side and replace it with an adapter suitable for the new task classification. When this cache replacement strategy minimizes the aforementioned loss function, the updated low-rank adapter library on the client side is obtained. This strategy maintains the dynamic nature of the adapters in the client-side cache. In this way, the algorithm can effectively learn cache update strategies from historical data, thereby improving the client-side cache hit rate and optimizing task allocation efficiency.

[0084] like Figure 2 As shown, the specific implementation of the edge-cloud collaborative reasoning system based on low-rank fine-tuning of a large language model includes the following main steps:

[0085] Step (1) In the offline stage, the pre-trained model weights are decomposed into directional and magnitude components, a shared low-rank matrix A and a task-specific matrix B are initialized, matrix A is frozen and B is kept trainable.

[0086] In step (2), during the online phase, user requests are classified by clustering using a variational autoencoder-Gaussian mixture model. If a matching low-rank adapter (B, m) exists in the client-side cache, it is loaded into the client-side model for inference; otherwise, it is forwarded to the cloud.

[0087] Step (3) Analyze the user's historical requests and cache status based on the Mamba model, dynamically update the low-rank adapter library on the client side, and prioritize the retention of high-frequency task parameters.

[0088] Step (4) Monitor the end-cloud load and inference latency in real time. When the end-side confidence is insufficient, trigger the cloud rollback and send a new adapter to the end-side according to the task repetition rate increment.

[0089] The trigger condition for the cloud to send a new adapter to the end side is as follows: set a hyperparameter as the cloud access threshold, count the number of cloud accesses of a certain task within a unit of time, and if the cloud side has a corresponding adapter, then when the number of cloud accesses of the task exceeds the threshold, the cloud side sends a new adapter to the end side.

[0090] Step (5) Periodically optimize the task classification threshold and cache capacity to achieve a dynamic balance between cost, latency and accuracy.

[0091] In summary, this invention proposes an edge-cloud collaborative inference system architecture for large language models based on low-rank fine-tuning, aiming to address the key issues of high cloud computing resource costs and the difficulty in balancing task accuracy and inference latency. The system employs a resource-efficient low-rank adaptation algorithm combined with a user-perceptual model replacement algorithm based on imitation learning, reducing parameter transmission by 50% while maintaining model inference accuracy, thereby significantly reducing cloud computing costs. Through dynamic allocation and optimization of edge-cloud tasks, this invention achieves an effective balance between model accuracy (task accuracy), edge response speed (latency), and resource efficiency.

Claims

1. A cloud-based collaborative reasoning system for large language models based on low-rank fine-tuning, characterized in that: The construction process is as follows: The first phase involves establishing an edge-cloud collaborative reasoning architecture. The architecture includes an edge side and a cloud side. The edge side deploys a lightweight language model and introduces a low-rank adapter and an intelligent classifier. The cloud side stores the low-rank adapter set in a low-rank adapter library, which is used to allocate and call cloud side computing after the edge side tasks are classified. The architecture development process includes offline and online phases, specifically: (1) In the offline stage, the cloud side performs parameter fine-tuning on the large language model based on training data from different downstream tasks; (2) During the online phase, when a user makes a request, the user request is classified by "variational autoencoder-Gaussian mixture model" clustering. It is determined whether there is a low-rank adapter (B, m) matching the current task in the edge cache. If so, it is loaded into the edge small language model, inference is performed, and the task result is obtained; otherwise, the task is forwarded to the cloud side for inference. Wherein, B is the low-rank fine-tuning task-specific matrix, and m is the amplitude component. In the second phase, the edge-cloud collaborative inference architecture is monitored and updated in real time based on the processing status of user requests. S1, after the architecture has processed several user requests, it analyzes the user's historical requests and cache status based on the Mamba model, dynamically updates the low-rank adapter library on the client side, and prioritizes the retention of high-frequency task parameters. Utilizing user historical access sequences and the current low-rank adapter library storage state Dual-modal data, through learning The algorithm makes the optimal update decision based on its decision-making process, which is as follows: During the training process, the Mamba model, based on a state-space model architecture, was used to extract the temporal features of user access behavior. The hidden state update equation of the Mamba model is as follows: in, It is a selective update gate. Represents a state-space model that supports parallel computation. These are the residual coefficients; A is a shared low-rank matrix; The system uses two independently initialized projection matrices. and Embed user access data and cache information separately: in, This represents the embedded user access data. For embedded cache information; position encoding It is generated using a sine function; User access data and cached information are projected onto a unified feature space, and the concatenated features are then used to... To represent the characteristics after fusion: in, It is a projection matrix, through Will Projected to and A hidden space where people are together; During training, a binary cross-entropy loss function is used to guide the model in learning task classification and cache replacement strategies. Where i=1,…,Q is the number of edge-side caches. It is the result of strategy prediction. It is LayerNorm ( ); Refers to the actual result. It is a vector of length Q. This refers to the strategy for whether the edge cache at position i should be replaced; The cache replacement strategy is as follows: release one of the adapters in the low-rank adapter library on the client side and replace it with an adapter suitable for the new task category; when the cache replacement strategy minimizes the above loss function, the updated low-rank adapter library on the client side is obtained. This strategy maintains the dynamism of the adapters cached on the client side. S2 monitors the cloud load and inference latency in real time. When the confidence level on the edge is insufficient, it triggers a rollback on the cloud side and sends a new adapter to the edge side based on the incremental task repetition rate. S3 periodically optimizes task classification thresholds and edge cache capacity to achieve a dynamic balance between cost, latency, and accuracy.

2. The edge-cloud collaborative reasoning system based on low-rank fine-tuning of a large language model according to claim 1, characterized in that, The fine-tuning process is as follows: The weight matrix of the pre-trained model is decomposed into directional and magnitude components, and the directional components are frozen while the magnitude components are retained. At the same time, a shared low-rank matrix A and a task-specific matrix B are initialized, and matrix A is frozen while B is retained for training. During low-rank fine-tuning, the shared frozen matrix Only update the amplitude component. and low-rank fine-tuning task-specific matrix The specific weight update process is represented as follows: and These represent the updated magnitude components and the task-specific matrix, respectively. Represents the initial weight matrix; Indicates the column norm of the parameter after using LoRA; The edge device only needs to store a single matrix during training. and, when needed, transmit new tasks via a low-rank adapter ( This is used to update the small language model.

3. The edge-cloud collaborative reasoning system based on low-rank fine-tuning of a large language model according to claim 2, characterized in that, The weights of the pre-trained model Decomposed into directional components and amplitude components Its mathematical expression is: in, It is the column norm of the weight matrix, used to capture the magnitude components; The directional component is obtained through column normalization.

4. The edge-cloud collaborative reasoning system based on low-rank fine-tuning of a large language model according to claim 1, characterized in that, User requests are classified using a "variational autoencoder-Gaussian mixture model" clustering approach, modeled using the following formula: in, and These represent the input data and the implicit variables, respectively. and It is the output of the variational autoencoder, representing the mean and variance of the latent variables.

5. The large language model edge-cloud collaborative reasoning system based on low-rank fine-tuning according to claim 1 or 4, characterized in that, The process of classifying user requests is as follows: the variational autoencoder maps the input data to a latent space that conforms to a Gaussian distribution through the mean and variance of the latent variables; then, the Gaussian mixture model models the task subcategories through multiple Gaussian components to obtain the task classification results; finally, based on the task classification results, the system can decide whether the task is executed on the edge device or forwarded to the cloud for processing.

6. The large language model edge-cloud collaborative reasoning system based on low-rank fine-tuning according to claim 1, characterized in that, The trigger condition for the cloud to send a new adapter to the end side is as follows: set a hyperparameter as the cloud access threshold, count the number of cloud accesses of a certain task within a unit of time, and if the cloud side has a corresponding adapter, then when the number of cloud accesses of the task exceeds the threshold, the cloud side sends a new adapter to the end side.

Images