DNN side-end collaborative reasoning method, system and device and readable storage medium

Abstract

The invention provides a DNN side-end collaborative reasoning method, system and device and a readable storage medium. The method comprises the following steps: sending a registration request to an edge server and establishing a communication link with the edge server; the DNN task model of the user is converted into a chained task sequence, the chained task sequence is composed of a plurality of chained subtasks, and each subtask comprises local execution time delay, server execution time delay and transmission time delay attributes; calculating queuing time delay of the tasks on the edge server based on time interval distribution and priority division of the tasks arriving at the edge server; and determining an unloading point of the chained task sequence, processing a chained subtask on one side, close to the terminal equipment, of the unloading point by the terminal equipment, and processing a chained subtask on one side, close to the edge server, of the unloading point by the edge server. Compared with the prior art, the method solves the key bottlenecks of inaccurate queuing delay prediction, lack of multi-priority task scheduling, insufficient DNN partition flexibility and the like in the existing method.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of edge-end collaboration, and particularly relates to a DNN edge-end collaborative reasoning method, system, device and readable storage medium. BACKGROUND

[0002] In recent years, deep learning has achieved great application in many fields, such as natural language processing, computer vision, big data analysis, etc. Deep neural network (DNN) is one of the core models of deep learning. However, the execution of DNN on terminal devices faces problems such as computing resources, memory, energy consumption and real-time performance. Due to the limited computing power of terminal devices, the complex operation of DNN is difficult to complete efficiently on such devices, and the huge parameter quantity of the model also poses a challenge to the storage space. The requirement for response speed in real-time application scenarios (such as autonomous driving) makes it difficult for DNN to meet the needs of resource-constrained devices.

[0003] Although the prior art has made certain progress in cloud-edge collaborative reasoning and DNN model offloading, there are still many deficiencies in the multi-user environment. First, the multi-user task scheduling efficiency is low. Most of the existing solutions focus on single-user or single-task scenarios. For the case where multiple users simultaneously request task processing, there is a lack of effective scheduling mechanism, especially when the task arrival rate is fast, the task will be immediately executed and the edge server task will be accumulated, affecting the timely response of the task and thus reducing the overall processing efficiency of the system. In addition, the existing technology does not fully consider the priority of tasks. High-priority tasks often cannot be guaranteed in a multi-user environment, especially in scenarios with high real-time requirements, the existing scheduling mechanism is difficult to meet the timeliness requirements of these tasks.

[0004] Therefore, in view of the above technical problems, it is necessary to provide a DNN edge-end collaborative reasoning method, system, device and readable storage medium.

[0005] The information disclosed in this BACKGROUND section is only intended to increase an understanding of the general context in which the present application can be practiced. It is not admitted that any of the information provided in this BACKGROUND section constitutes prior art against the present application. SUMMARY

[0006] The purpose of the present application is to provide a DNN edge-end collaborative reasoning method, system, device and readable storage medium, which can improve the scheduling efficiency of multi-user tasks and solve the problem of multi-task accumulation.

[0007] In order to achieve the above-mentioned purpose, the technical scheme provided by an embodiment of the present application is as follows:

[0008] In a first aspect, the present application provides a DNN edge-end collaborative reasoning method, comprising:

[0009] Each user sends a registration request to the edge server and establishes a communication link with the edge server, the request containing device ID, computing power, network bandwidth, task type and priority information;

[0010] The DNN task model of the user is converted into a chain task sequence composed of a plurality of chain sub-tasks, each of the sub-tasks containing local execution delay, server execution delay and transmission delay attributes;

[0011] The users are divided into a first group and a second group; including, based on the priority of the user, adding the user meeting the terminal device task queue stability condition to the first group, whose task can be executed on the terminal device without accumulation; adding the remaining tasks to the second group;

[0012] The offloading point generated in the last round and the corresponding local execution delay, server execution delay, transmission delay and user corresponding priority are obtained, and the queuing delay of the task on the edge server is calculated;

[0013] Based on the queuing delay on the edge server, the offloading point of the chain task sequence is updated, and the chain sub-tasks close to the terminal device side of the offloading point are processed by the terminal device, and the chain sub-tasks close to the edge server side of the offloading point are processed by the edge server.

[0014] In one or more embodiments of the present application, the DNN task model of the user is converted into a chain task sequence, including converting the DNN task model into a directed acyclic graph, and converting the directed acyclic graph into the chain task sequence; wherein converting the DNN task model into a directed acyclic graph specifically includes:

[0015] Initializing the graph structure, including data input nodes, terminal device virtual nodes and edge server virtual nodes;

[0016] Determining whether each layer of the DNN task model is a block structure, if not, adding a first input node and a first output node in the graph, and setting the weight of the edge connecting the first input node and the first output node as the transmission delay of the data of the layer; if yes, dividing the block structure into a plurality of sub-modules, recursively processing each of the sub-modules, and setting the weight of the connecting edge as the difference between the minimum transmission delay of the sub-module and the delay of the layer executed by the edge server;

[0017] Adding virtual edges, including edges connecting from the first input node to the terminal device virtual node, with the weight set as the delay of the layer executed by the edge server, and edges connecting from the first output node to the server virtual node, with the weight set as the delay of the layer executed by the terminal device;

[0018] The minimum cut algorithm is applied to solve the optimal cut point of the graph structure, and a minimum cut scheme and a corresponding directed acyclic graph are output.

[0019] In one or more embodiments of the present application, the DNN edge-side collaborative inference method according to claim 1 is characterized in that converting a user's DNN task model into a chain task sequence comprises converting the DNN task model into a directed acyclic graph and converting the directed acyclic graph into the chain task sequence; wherein converting the directed acyclic graph into the chain task sequence specifically comprises:

[0020] traversing each node in the directed acyclic graph;

[0021] for a node corresponding to a non-block structure, creating an independent task node and setting its attributes to include the time delay of the layer executed by the terminal, the time delay of the layer executed by the edge server, and the transmission time delay of the layer;

[0022] for a node corresponding to a block structure layer, creating a first sub-task node and a second sub-task node, setting the attribute of the first sub-task node to the sum of the time delays corresponding to the tasks allocated to the terminal device for execution, and setting the attribute of the second sub-task node to the sum of the time delays corresponding to the tasks allocated to the edge server for execution;

[0023] sequentially arranging the independent task node, the first sub-task node, and the second sub-task node to form the chain task sequence.

[0024] In one or more embodiments of the present application, the calculation of the queuing delay of tasks on the edge server based on the time interval distribution and priority division of the tasks arriving at the edge server comprises:

[0025] decomposing the queuing delay on the edge server into a plurality of decomposition delays, the decomposition delays including a remaining processing delay of a task being executed, a high-priority task queuing delay, a same-priority task queuing delay, and a same-user task queuing delay;

[0026] based on a preset probability model and a state transition equation, calculating the expected value of each decomposition delay until the calculation result of the expected value converges within a preset threshold range;

[0027] based on the calculation result of the expected value of each decomposition delay, predicting the expected queuing delay of each priority task on the edge server.

[0028] In one or more embodiments of the present application, determining the offloading point of the chain task sequence comprises:

[0029] The offloading point of the chain task sequence is moved from the terminal device side to the edge server side by a first preset hop number, and an offloading point position is recorded, which makes the edge server load lower than a load threshold and meets a terminal device queue stability constraint;

[0030] An adjustment scheme that maximizes the total delay reduction is selected;

[0031] Based on the recorded offloading point position, a feasible range of the offloading point is determined, within which, based on a second preset hop number, the position of the offloading point is adjusted, the time delay change is calculated, and an optimal solution is iteratively obtained, the second preset hop number being less than or equal to the first preset hop number.

[0032] In one or more embodiments of the present application, the method further comprises:

[0033] The deployment decision of the offloading point is distributed to the terminal device and the edge server;

[0034] The system state is monitored, and the offloading point of the chain task sequence is re-determined when the task characteristics or the load change, so as to realize adaptive scheduling.

[0035] In one or more embodiments of the present application, the method further comprises:

[0036] The users are divided into a first group and a second group; wherein the first group of users meets the terminal device task queue stability condition, and their tasks can be executed on the terminal device without accumulation; the second group of users can not meet the terminal device task queue stability condition, and their tasks are preferentially offloaded to the edge server; the user grouping is based on the task arrival rate and the local execution time delay to calculate the local queue occupancy rate and adjust the grouping result.

[0037] In a second aspect, the present application provides a DNN edge-end collaborative inference system, which comprises:

[0038] A connection module is configured to send a registration request to an edge server and establish a communication link with the edge server, the request containing device ID, computing power, network bandwidth, task type and priority information;

[0039] A conversion module is configured to convert a user's DNN task model into a chain task sequence, the chain task sequence being composed of a plurality of chain sub-tasks, each of the sub-tasks containing local execution time delay, server execution time delay and transmission time delay attributes;

[0040] A calculation module is configured to calculate the queuing time delay of the task on the edge server based on the time interval distribution of the task arriving at the edge server and the priority division;

[0041] An offloading module is configured to determine an offloading point of the chain task sequence, and the chain sub-tasks close to the terminal device side are processed by the terminal device, and the chain sub-tasks close to the edge server side are processed by the edge server.

[0042] In a third aspect, the present application provides a computer device, comprising a memory and a processor, which are communicatively connected with each other, and the memory stores computer instructions, and the processor executes the DNN edge-end collaborative inference method by executing the computer instructions.

[0043] In a fourth aspect, the present application provides a computer readable storage medium, which stores computer instructions, and the computer instructions are used to make a computer execute the DNN edge-end collaborative inference method.

[0044] The present application has significant beneficial effects in the field of deep neural network (DNN) task collaborative inference in edge computing environment compared with the prior art, mainly in solving the key bottlenecks of inaccurate prediction of queuing delay, lack of multi-priority task scheduling and insufficient flexibility of DNN partition in the prior art.

[0045] Firstly, the prior art ignores the non-Poisson characteristics and priority differences of task arrival, resulting in large prediction deviation; and the present application realizes more accurate delay prediction by deriving the queuing delay model of multi-priority tasks, combined with iterative calculation and state transition equation, and improves the reliability of system scheduling.

[0046] Secondly, the prior art is not good at handling the urgent needs of high-priority tasks, and often uses static partition strategy; the present application designs a dynamic offloading decision algorithm, which determines and optimizes the range of offloading points through user grouping, to preferentially guarantee low-delay processing of high-priority tasks, while minimizing the end-to-end delay of all users, and enhances the response capability of the system in real-time scenarios.

[0047] In addition, the existing DNN partition method is difficult to adapt to complex model structures; the chain conversion technology introduced in the present application supports flexible partition and reduces the task execution bottleneck. Overall, the present application improves the throughput, stability and quality of service of the edge computing system by integrating accurate delay prediction, intelligent scheduling and adaptive partitioning, and is particularly suitable for delay-sensitive application scenarios such as autonomous driving and intelligent medical care. BRIEF DESCRIPTION OF DRAWINGS

[0048] In order to make the technical solutions in the embodiments of the present application or the prior art clearer, the accompanying drawings needed in the embodiments or prior art description will be briefly introduced below. Obviously, the accompanying drawings in the following description only need to be some embodiments of the present application, and for those skilled in the art, other drawings can also be obtained without creative labor.

[0049] Figure 1 is a flow chart of the DNN edge-end collaborative inference method in an embodiment of the present application.

[0050] Figure 2 is a structural block diagram of the DNN edge-end collaborative inference system in another embodiment of the present application.

[0051] Figure 3 is a structural block diagram of the electronic device in an embodiment of the present application.

[0052] Figure 4 is a construction schematic diagram of the first sub-task node and the second sub-task node in an embodiment of the present application.

[0053] Figure 5 is a pseudo code schematic diagram of the SQDP algorithm in an embodiment of the present application.

[0054] Figure 6 is a pseudo code schematic diagram of the DLOP algorithm in an embodiment of the present application.

[0055] Figure 7 is a pseudo code schematic diagram of the FMUN algorithm in an embodiment of the present application.

[0056] Figure 8 is a pseudo code schematic diagram of the FBP algorithm in an embodiment of the present application.

[0057] Figure 9 is a pseudo code schematic diagram of the MUPOD algorithm in an embodiment of the present application. DETAILED DESCRIPTION

[0058] In order to make the technical solutions in the embodiments of the present application or the prior art clearer, the accompanying drawings needed in the embodiments or prior art description will be briefly introduced below. Obviously, the accompanying drawings in the following description only need to be some embodiments of the present application, and for those skilled in the art, other drawings can also be obtained without creative labor.

[0059] Unless otherwise expressly stated, throughout the specification and claims, the term "comprising" or its variations such as "including" or "comprises" shall be understood to include the stated elements or components without excluding other elements or other components.

[0060] Please refer to Figure 1 The diagram shown illustrates the flowchart of DNN edge-end collaborative inference in one embodiment of the present invention. This DNN edge-end collaborative inference method specifically includes the following steps:

[0061] S101: Each user sends a registration request to the edge server and establishes a communication link with the edge server. The request includes device ID, computing power, network bandwidth, task type, and priority information.

[0062] In the edge computing system of this invention, the fundamental step in building the collaborative reasoning framework is for the user-end device, i.e., the terminal device, to first send a registration request to the edge server. The core purpose of this process is to establish a trusted end-to-end connection, enabling the edge server to globally perceive the system resource status and user needs, thereby achieving dynamically optimized task scheduling. The registration request is equivalent to an "admission credential" for the device to join the edge computing system, ensuring that only legitimate devices with matching resources can participate in collaborative reasoning.

[0063] It should be noted that establishing a stable communication link can provide a dedicated channel for subsequent control information such as offloading decisions and heartbeat detection; ensure that intermediate results and inference results of DNN tasks can be transmitted efficiently and reliably; and enable edge servers to monitor device status in real time and adjust resource allocation strategies in a timely manner.

[0064] It should also be noted that the device ID, computing power, network bandwidth, task type, and priority information included in the registration request work together to build a global resource view and optimize task scheduling. Specifically, the device ID serves as a unique identifier to distinguish user devices and establish session management, ensuring the correct mapping between tasks and devices; computing power information helps assess the local processing performance of the end device, used to accurately predict task execution latency and determine DNN task partitioning points; network bandwidth information is used to estimate data transmission latency, thereby optimizing offloading strategies to avoid network bottlenecks; task type information specifies the structure of the DNN model (such as chained or DAG), enabling the system to match corresponding inference resources and workflows; priority information directly guides server queuing and scheduling, ensuring that high-priority tasks are processed first, improving system real-time performance and service quality. This information collectively supports dynamic offloading decisions and resource allocation, enabling the system to adapt to multi-user environments, balance load, and minimize end-to-end latency.

[0065] S102: convert the DNN task model of the user into a chain task sequence composed of multiple chain sub-tasks;

[0066] In an exemplary embodiment of the present application, converting the DNN task model of the user into a chain task sequence includes two parts: converting the DNN task model into a directed acyclic graph (DAG), and converting the DAG into the chain task sequence. The DAG and the chain task sequence are two different representations of the deep neural network task in the edge computing environment, and in this implementation, there is a progressive and simplified relationship between the two.

[0067] Among them, the DAG can completely retain the topological structure of the DNN model, including the parallelism, branching and dependency relationship of the layer, and through the node representing the calculation layer and the edge representing the data flow, it provides comprehensive structural information for task partitioning. The chain task sequence is a linearization of the DAG, which simplifies the complex graph structure into sequentially executed task units, each unit containing local execution delay, server execution delay and transmission delay, etc. Quantitative attributes. This conversion relationship makes the system not only able to utilize the structural integrity of the DAG for accurate partitioning decisions, but also to achieve efficient scheduling through the simplicity of the chain sequence. For example, parallel branches in the DAG may be split into consecutive sub-tasks in the chain sequence, but through reasonable setting of the delay attribute, the equivalence of the execution logic can still be guaranteed.

[0068] The reason why the DNN needs to be converted into a DAG and then into a chain task sequence is that this phased conversion can balance the accuracy of model expression and the efficiency of scheduling and execution. As an intermediate representation, the DAG first captures the complex dependency relationships and multi-path possibilities between tasks through recursive processing of DNN layers and introduction of virtual nodes, providing complete optimization space for the minimum cut algorithm to ensure the global optimality of the partitioning scheme. However, the complexity of the DAG is not conducive to real-time scheduling and resource allocation in edge computing systems; therefore, it is further converted into a chain task sequence, which simplifies the complexity of task management through attribute quantization and sequential arrangement of task nodes, enabling the offloading decision algorithm to quickly evaluate the impact of different cut points on end-to-end latency. This step-by-step conversion avoids the loss of key structural information that may be lost by direct simplification, and provides operational task units for multi-user priority scheduling, ultimately ensuring inference accuracy while improving system response speed.

[0069] In an exemplary embodiment, converting the DNN task model into a directed acyclic graph can specifically include: initializing a graph structure including a data input node, an edge server virtual node, and an end device virtual node; determining whether each layer of the DNN task model is a block structure, if not, adding a first input node and a first output node in the graph, and setting the weight of the edge connecting the first input node and the first output node as the transmission delay of the data of the layer; if yes, adding a second input node and a second output node in the graph, dividing the block structure into a plurality of sub-modules, recursively processing each of the sub-modules, and setting the weight of the edge connecting the second input node and the second output node as the difference between the minimum transmission delay of the sub-module and the delay of the layer executed by the edge server; adding a virtual edge including an edge connecting from the first input node to the end device virtual node, the weight of which is set as the delay of the layer executed by the edge server, and an edge connecting from the first output node to the server virtual node, the weight of which is set as the delay of the layer executed by the end device; applying a minimum cut algorithm to solve the optimal cut point of the graph structure, and outputting a minimum cut scheme and a corresponding directed acyclic graph.

[0070] By creating three virtual nodes (a data input node, an end device virtual node, and an edge server virtual node), all possible partitioning modes can be ensured to be covered by the generated directed acyclic graph, avoiding the occurrence of missing boundary conditions. When initializing the edge set, an edge from the end device virtual node to the data input node can be added, for example, with the weight set to infinity to prevent invalid partitioning. That is, let a point represents an end device, a point represents an edge server, and a data input node represents the data input of the first layer, the point set is initialized as , and the edge set is initialized as to prevent missing the case of full offloading to the edge server.

[0071] The distinction between block structures and non-block structures is that non-block structures such as ordinary fully connected layers and convolutional layers usually only have simple input-output mapping and do not have internal sub-layers or complex branches, so they can only represent the data entrance and exit of the layer by two nodes (a first input node and a first output node). This representation simplifies the graph structure and reduces the computational complexity, because the execution of a simple layer is atomic and does not require internal cutting. The computing delay of the entire layer (local execution delay, server execution delay, etc.) can be directly associated with the edge between the two nodes, so that only the execution position of the entire layer needs to be considered when optimizing the offloading decision.

[0072] On the other hand, block structures are usually composed of several sub-layers, with internal computation paths or branches. These structures can contain parallel or sequential sub-layers, requiring more fine-grained representation to support internal cutting. Therefore, in addition to input nodes and output nodes, intermediate nodes can be created to represent the sub-layer output points inside the block, to capture the internal computation state.

[0073] It should be noted that when processing the block structure of the DNN model, the intermediate nodes do not need to be explicitly connected in the upper graph. This is because the algorithm processes the internal sub-modules of the block structure in a recursive manner, and only considers the block structure as a whole at the current level, adding only input nodes and output nodes, and aggregating sub-module information through weights. The connection details of the intermediate nodes are internally processed in the recursive call, and finally represented by a single connection edge (from the second input node to the second output node) in the upper graph, representing the aggregated behavior of the entire block structure. That is, the recursive call itself processes the sub-modules of the block structure. Inside the sub-module, a local DAG is constructed, including the input nodes, output nodes and possibly intermediate nodes of the sub-module, and the optimal cutting scheme of the sub-module is solved based on the minimum cut algorithm. This recursive process ensures that the connection of the intermediate nodes is accurately processed at the sub-module level, but the result is returned to the upper level in an aggregated form (such as the minimum transmission delay of the sub-module). In the upper graph, a connection edge is added from the input node to the output node, with a weight set to the difference between the minimum transmission delay of the sub-module and the delay of the entire block structure executed by the edge server. This weight reflects the efficiency difference of the cutting scheme relative to the entire server execution, without exposing the internal intermediate nodes.

[0074] Further, the edge connected from the first input node to the terminal device virtual node can represent the cost of the "all offloading" scenario. The edge connected from the first output node to the edge server virtual node can represent the cost of the "all local execution" scenario. The virtual edge ensures the integrity of the graph, enabling the minimum cut algorithm to enumerate all partition options. The DAG is analyzed using the minimum cut algorithm in graph theory to find a set of edges that minimizes the total weight (i.e., total latency) after cutting. The tasks on the left side of the cutting point are executed on the end device, and the tasks on the right side are offloaded to the server. The output includes the minimum cutting scheme (such as cutting position, local execution latency, server execution latency, and transmission latency) and the corresponding DAG graph.

[0075] In one exemplary embodiment, transforming the directed acyclic graph (DAG) into the chained task sequence specifically includes: traversing each node in the DAG; for nodes corresponding to non-block structures, creating independent task nodes and setting their attributes, including the latency of the layer executed by the terminal, the latency of the layer executed by the edge server, and the transmission latency of the layer; for nodes corresponding to block structures, creating a first sub-task node and a second sub-task node, wherein the attribute of the first sub-task node is set to the sum of the latency corresponding to the tasks assigned to the terminal device for execution, and the attribute of the second sub-task node is set to the sum of the latency corresponding to the tasks assigned to the edge server for execution; and arranging the independent task nodes, the first sub-task node, and the second sub-task node in sequence to form the chained task sequence.

[0076] As discussed above regarding block-like and non-block-like structures, when generating chained task sequences, non-block-like structures do not involve unloading internal tasks, so only independent task nodes need to be created. On the other hand, block-like structures have the potential for further unloading, therefore, creating first and second sub-task nodes is possible. Figure 4 As shown, by using the first and second sub-task nodes, the system can consider executing some sub-layers locally and offloading others to edge servers, thus optimizing latency more flexibly. This representation improves the accuracy of task chaining, allowing offloading decisions to leverage the parallelism or dependencies within a block, avoiding the potential loss of optimization opportunities by treating the entire block as a single unit. The weights of the connecting edges quantify the efficiency difference between the splitting scheme and execution on all servers; negative values ​​indicate that the splitting is superior.

[0077] S103: Divide users into a first group and a second group; including, based on user priority, adding users who meet the terminal device task queue stability conditions to the first group, whose tasks can be executed on the terminal device without backlog; adding the remaining tasks to the second group;

[0078] S104: Obtain the unload point generated in the previous round, as well as the corresponding local execution latency, server execution latency, transmission latency, and user priority, and calculate the queuing latency of the task on the edge server;

[0079] In an exemplary embodiment of the present application, the queuing delay of a computing task on an edge server is calculated by decomposing the queuing delay on the edge server into a plurality of decomposed delays, including a remaining processing delay of a task being executed, a high-priority task queuing delay, a same-priority task queuing delay, and a same-user task queuing delay; calculating an expected value of each of the decomposed delays based on a preset probability model and a state transition equation until a calculation result of the expected value converges within a preset threshold range; and predicting an expected queuing delay of each priority task on the edge server based on the calculation result of the expected value of each of the decomposed delays.

[0080] In a multi-user edge computing system, the queuing delay of a task on an edge server directly affects the end-to-end delay and the real-time performance of the system. The present application realizes the prediction of the queuing delay by precisely modeling the task arrival process and the priority scheduling, and provides a key basis for the offloading decision. The prior art cannot handle the multi-priority and non-Poisson arrival process, and the scheduling accuracy is improved.

[0081] In an embodiment of the present application, the queuing delay of a task on the edge server is decomposed into four components to ensure the comprehensiveness and accuracy of the prediction.

[0082] The remaining processing delay of a task being executed : When a new task arrives, if the server is executing a task of another user, it needs to wait for the remaining execution time of the task. Assuming that the remaining execution time of a task obeys a uniform distribution, the expected value is calculated by weighted summation of the service occupancy rate of each task.

[0083] The high-priority task queuing delay : Tasks with higher priority than the current user's task will be executed first. Based on the Little's law, the expected value is calculated by weighted summation of the product of the service occupancy rate of a high-priority task and its waiting time .

[0084] The same-priority task queuing delay : Other user tasks with the same priority as the current task will contribute to the waiting time according to the first-come-first-served principle. The calculation method is similar to , but is limited to the same-priority user.

[0085] The same-user task queuing delay : Other pending tasks of the same user in the server will increase the waiting time. The probability distribution of the number of tasks is solved by a state transition equation, and then is calculated.

[0086] This decomposition ensures that all factors that can affect the queuing time are taken into account, in particular the effect of priority differences.

[0087] Specifically, in a specific embodiment, S203 can specifically include: the interval time of the task passing through the part of the local end device to the execution on the edge server Reasoning. For convenience, define The task local execution delay of the user is Satisfy:

[0088]

[0089] Define The time interval of the task arriving at the end device, then according to the system modeling Subject to the exponential distribution with parameters :

[0090]

[0091] For a task leaving the end device If the queue on the end device is not empty when the task leaves, then = , the probability is ; If the queue on the end device is empty, then , the probability is . Therefore The probability density function of

[0092]

[0093] The cumulative distribution function is

[0094]

[0095] Therefore

[0096]

[0097] The expected rate of tasks arriving at the server of the user is

[0098]

[0099] Where, The Heaviside unit step function, The Dirac function.

[0100] Assume that the number of users with tasks at a certain time is ​A non-decreasing queue is formed according to priority order, that is... .

[0101] Suppose a user Task Arriving at a certain time, define the number of users in the server at that moment (which may be in a waiting queue or currently executing). The list of other tasks to be executed is as follows When a user Task The latency it needs to wait when the sorter is offloaded from the local device to the edge server. It consists of several parts. The first part is related to the users being served and... The execution time of all users with the same or higher priority in the queue upon arrival is referred to as this part. The second part is... Tasks from higher-priority users arriving during this period will be prioritized and given priority over others. Execution, this part of the delay is called Then, the third part. yes The task inference latency for higher-priority users arriving during the period, and so on.

[0102] Therefore, users The average waiting time is:

[0103]

[0104] Assumption The probability density distribution is Then there is

[0105]

[0106]

[0107] therefore

[0108]

[0109] and then

[0110]

[0111] make ,but

[0112] Therefore, we focus on finding the first part of the time.

[0113] of It consists of the following parts:

[0114] (1) Other user tasks being executed

[0115] Since the model is based on non-preemptive queues, the task cannot interrupt the task being executed and has to wait until its execution ends. Assume that the server is executing a task of user , then needs to be executed to completion. The remaining execution time until the end of the execution is defined as , assuming that obeys a uniform distribution between , i.e. , then

[0116]

[0117] Therefore the expected time to wait and the variance of the waiting time are

[0118]

[0119] In this section, the time to wait for all the tasks of the users being executed is calculated, but the time to wait for the tasks that can be executing in is excluded, since this time will be included in the following (4). Therefore, there is

[0120]

[0121] (2) User queued tasks with higher priority than the task

[0122] The time of stay of the tasks of user from their arrival to the server to the end of the reasoning is , then there is

[0123]

[0124] The average number of users in the system (i.e. the outside world) seems to be

[0125]

[0126] The average number of users in queue (outside world) seems to be ​​​​​​​​

[0127]

[0128] Thus The user needs to wait for The queueing delay is:

[0129]

[0130] For all users whose priority is higher than user 's, the task needs to wait. Thus

[0131]

[0132]

[0133] (3) Other tasks of the same priority as the task

[0134] Since for different users' tasks of the same priority, the execution order on the server side is in the order of the tasks arriving at the server side, similarly to (2), when arrives at the edge server, for all users' tasks whose priority is equal to user 's (excluding the same user's task), the task needs to wait. Therefore

[0135]

[0136] (4) Other tasks of the same user

[0137] Since the arrival of does not satisfy the Poisson distribution, the number of in the server when arrives is not the same as the number of that the outside world sees, so the reasoning in (2) does not apply. This part of the waiting time needs to be solved separately.

[0138] Sort all users in descending order of priority, and enumerate a batch of users with the same priority each time. In this way, when the batch of users is enumerated, the expected value and variance of the waiting delay of the users whose priority is higher than user 's have been calculated, so the and of this batch of users are equal and have been calculated. Therefore

[0139] ​​

[0140] Let the expected coefficient matrix

[0141]

[0142] vector

[0143]

[0144] but Solution That is, the user The expected waiting time. Similarly, the corresponding variance matrix can be calculated. Variance of waiting time.

[0145] In this system of equations Unknown, in the first solution season ] = 0, solve for Later Solve again. Definition for The content does not include waiting. Other waiting delays The sum of This excludes latency from waiting for tasks to be executed. The sum of other waiting delays.

[0146]

[0147] and The expected value and variance in the solution and You can get it later.

[0148] when When the request arrives, if the server is not idle at that time, the server may be executing user requests. The task being performed, or the task being executed by another user. Let's first discuss the scenario where the task is being executed by another user, and the probability of this happening. This is the ratio of the sum of the server's ownership percentages of other users to the sum of the ownership percentages of all users on the server.

[0149]

[0150] Defined between two adjacent users Time interval between tasks arriving at the edge server Internal execution indivual The sum of probabilities is (c) Assumption ~ If the value of (c) is the probability that is completed is

[0151]

[0152] where is the cumulative distribution function of the standard normal distribution.

[0153] Similarly, when arrives, if the server is not idle at this time, the server can also be executing other tasks of user at this time, the probability is the ratio of the occupancy of the server by user to the sum of the occupancy of the server by all users.

[0154]

[0155] At this time, define the probability that tasks of two adjacent users arrive at the edge server within the time interval is Assume that the remaining execution time of the task of user being executed is

[0156] The probability that

[0157]

[0158] Define to represent the probability that at least is completed within to control the classification of the task being executed by the console, there is

[0159] In particular, define to be the probability that

[0160] is completed when arrives is 0, because at this time the server has no task of user , so the server can be idle, or it is executing tasks of other users, the probabilities of the two cases are

[0161] ​​​​

[0162] Definition Indicates For When in All The probability of completing all tasks, then

[0163]

[0164] Define when the user The first Task arrives at the edge server, the number of tasks of the user In the system is , The probability that the number of tasks at this time is n, that is

[0165] Define

[0166] The number of users Executed in , then the number of tasks of the user In the front and rear servers satisfies

[0167] Therefore, the state transition equation about

[0168] Can be obtained

[0169]

[0170] Solving this equation set can obtain When it arrives, the number of In the edge server And The time Need to wait . Since May have been being executed when The probability is At this time, the remaining waiting time of Should be subtracted, so

[0171]

[0172] Since the solving process of And Is needed for each other, we first let , get Reget , such iterative solution, until the adjacent two​​ and the difference is not more than a preset threshold.

[0173] The server queuing delay prediction algorithm (SQDP) is shown in the pseudo code algorithm 3 as shown in Figure 5 . The algorithm inputs a user information list and a task list . The output is the server queuing delay of all users . The algorithm first calculates all users and list , , and initializes the variables and to record the sum of , and of all users that have been calculated. Then, all users are sorted by priority, and a batch of users with the same priority is enumerated in order of priority from high to low. This batch of users has the same and . First, set the of this batch of users to obtain the initial waiting time related vector of this batch of users, and then proceed to the calculation of . In a round of calculation, first save the in the vector under the last round or initial condition, and clear to recalculate. Then calculate and , solve the equation group to obtain the vector composed of the of this batch of users, and similarly obtain the vector composed of by the variance equation group, and then calculate the and of each user, and solve the equation group to obtain the new . If the absolute value of and is less than the set threshold, the algorithm stops, otherwise a new round of calculation is performed using . When the loop exits, the last calculated queuing delay of this batch of users is the queuing delay of this batch of users, and finally updates , and for solving the waiting time of low-priority users.

[0174] S104: updating the offloading point of the chain task sequence based on the queuing delay on the edge server, the chain sub-tasks close to the terminal device side of the offloading point being processed by the terminal device, and the chain sub-tasks close to the edge server side of the offloading point being processed by the edge server.

[0175] In an exemplary embodiment, determining the offloading point of the chain task sequence can include: moving the offloading point of the chain task sequence by a first preset number of hops from the terminal device side to the edge server side, recording the offloading point position that makes the edge server load lower than the load threshold and meets the terminal device queue stability constraint; selecting an adjustment scheme that maximizes the total delay reduction; determining an offloading point feasible range based on the recorded offloading point position, within the offloading point feasible range, adjusting the position of the offloading point based on a second preset number of hops, calculating the change in delay, and iteratively obtaining an optimal solution, the second preset number of hops being less than or equal to the first preset number of hops.

[0176] It can be understood that in the edge computing scenario to which the application is applied, determining the offloading point of the chain task sequence is a key step for optimizing task collaborative inference, directly affecting end-to-end latency and system stability. The application dynamically adjusts the position of the offloading point to ensure that high-priority tasks are processed first, while minimizing the total delay of all users. The core of the method is to balance the load of the terminal device and the edge server to avoid queue accumulation, and it is particularly suitable for multi-user priority scenarios.

[0177] In a specific embodiment of the application, step S204 can include:

[0178] dividing all users into two sets according to the indicator function

[0179]

[0180] According to the definition of the indicator function , assuming that the users are arranged in descending order of priority as , then The subscript of the user in should be continuous, and is the separation point, let

[0181]

[0182] Let When does there exist an offloading scheme such that satisfies while the user terminal devices in can all satisfy regardless of whether the users in satisfy, i.e.

[0183]

[0184] First fix Value discussion To achieve this, we will first discuss... The upper limit. For users in Because it needs to meet ,therefore There is an upper limit This means that to ensure the stability of the terminal device, the tasks executed on the terminal device cannot be too large, and its upper limit can be calculated using a binary search method; for The maximum number of users in the system is [number]. All users Upper limit composition Vector. When Once confirmed, This can also be determined accordingly. And to meet the stability constraints of the edge server, the offloading vector... There should also be a lower limit. Furthermore, this lower limit is not unique.

[0185] In this embodiment of the invention, a Determine Local Offloading Point (DLOP) algorithm is provided. This algorithm is used to determine a given... Below The value is determined by minimizing the combined increase in latency (excluding server queuing latency) by moving the user's unload point several steps to the right each time, until a possible lower limit is found. The algorithm attempts to change a user's behavior. The unload point is moved to the right by several positions (assuming the user...). The unload point from Move to The sum of all latency for the user before and after each move, excluding the queuing latency on the server. (Right now - ) difference Sort in ascending order, and select each time. Move using the minimum move strategy, and repeat this process until the sum of all users' share of the server is reached. Less than or equal to 1, then we can get ,as well as Exit the loop; if the vector is unloaded. It has exceeded Still unable to satisfy If the condition is less than or equal to 1, then in this... To reduce time complexity, the DLOP algorithm uses a priority queue. Maintenance is required. Specifically, the DLOP algorithm takes user information as input. Task List as well as Upper limit of the corresponding unloading vector The output is The value, and if A legal lower limit for time First, DLOP will Initialized to 0, according to Calculate the sum of the current server occupancy rates. .like If less than or equal to 1, then If it's a valid lower bound, return; otherwise, you need to... Adjustments are made. The adjustment process initializes the priority queue. The queue is for users of Sort by primary keyword, and record user information. and the changed unloading location For all users, enumerate the user's... Calculate the possible unloading points. and put Select in order The first element of the team ,like Exceed Then Set as ,renew Conversely, this indicates This is no longer the latest uninstallation point, skip it. Repeat this process until... Less than or equal to 1 or If the value is empty, the loop ends. Empty, indicating If the operation fails, it returns a failure flag; otherwise, it returns a success flag and the found valid unloading vector. The pseudocode for the DLOP algorithm is as follows: Figure 6 As shown:

[0186] Due to The increase, The constraints must be satisfied. As the number of users increases, the constraints are simultaneously satisfied. and constraints It becomes increasingly difficult, that is, as The increase, It is a monotonically non-increasing function, and has

[0187]

[0188] That is, in satisfying In the most cases there are One user terminal device can meet ,therefore Binary search Find the answer.

[0189] The Find Most User Number (FMUN) algorithm is a binary search algorithm. The process involves first using binary search to find all users' results. Initialize left and right pointers and Then perform binary search enumeration. When fixed Then the corresponding Substituting this into the DLOP algorithm yields... The value of the pointer is used to move the left and right pointers based on the result. When exiting the loop... pointer (or The value of the pointer is... The maximum value of 1 And then according to To obtain the final and The pseudocode for the FMUN algorithm is as follows: Figure 7 As shown.

[0190] After obtaining and the corresponding and Next, we will discuss how to maximize .

[0191] Since this problem is NP-hard, we use the Find Best Points (FBP) algorithm to find a better solution. The input to the FBP algorithm is the solution obtained above. and and user list and task list The output is maximized. unloading vector The FBP algorithm moves a user's uninstallation point several steps at a time, greedily searching for the maximum value in the current situation. The optimal move. To reduce redundant calculations, use... Record user of First, initialize. for ,calculate , then we enter the trial update process. In each trial update process, first initialize the optimal solution found in this update process , is composed of three parts, which are the minimum total delay of all users , and the offloading point of the mobile user in this update process . Then enumerate all users , and enumerate all possible offloading point moving schemes of , if a better solution is found in the enumeration process, use to update . Here, in order to reduce the number of enumerations, the step size of enumeration can be set. After the optimal offloading point moving scheme is determined, the corresponding user and the moved offloading point [ ] are taken out of , and enumeration is performed again in the interval around [ ] to find whether there is a better offloading scheme than [ ]. If there is, it is also recorded in . After this trial update is completed, use to update . If this update does not find a better solution than the last update, exit the loop and return the result. At this point, we have achieved the maximization of under the given . The pseudo code of the FBP algorithm is shown in . Figure 8

[0192] So far, we have implemented various algorithms. Next, we will integrate all the algorithms together to form the Multi-User Priority Offloading Decision-Making (MUPOD) algorithm. The MUPOD algorithm continuously monitors whether the user information has changed. Once changes, the offloading vector is re-decided. The decision-making process first obtains the task list of all users by the DTTC algorithm, then calculates the server queuing delay using the SQDP algorithm, and finally obtains the optimal value of the indicator , as well as the corresponding upper and lower limits of the offloading vector and ​Finally, the FBP algorithm is used to find the optimal offloading vector to maximize the metric . The is distributed to all user devices for offloading. The pseudo code of the MUPOD algorithm is shown in Figure 9 .

[0193] Referring to Figure 2 , based on the same inventive concept as the foregoing DNN edge-end collaborative inference method, an embodiment of the present application provides a DNN edge-end collaborative inference system 200, which comprises a connection module 201, a conversion module 202, a calculation module 203, and an offloading module 204.

[0194] Specifically, the connection module 201 is configured to send a registration request to an edge server and establish a communication link with the edge server, and the request contains device ID, computing power, network bandwidth, task type, and priority information.

[0195] The conversion module 202 is configured to convert the user's DNN task model into a chain task sequence, and the chain task sequence is composed of a plurality of chain sub-tasks, and each sub-task contains local execution delay, server execution delay, and transmission delay attributes.

[0196] The calculation module 203 is configured to calculate the queuing delay of the task on the edge server based on the time interval distribution and priority division of the task arriving at the edge server.

[0197] The offloading module 204 is configured to determine the offloading point of the chain task sequence, and the chain sub-tasks close to the terminal device side are processed by the terminal device, and the chain sub-tasks close to the edge server side are processed by the edge server.

[0198] Referring to Figure 3 , the present application further provides an electronic device 300, which comprises at least one processor 301, a memory 302 (such as a non-volatile memory), a memory 303, and a communication interface 304, and the at least one processor 301, the memory 302, the memory 303, and the communication interface 304 are connected together via an internal bus 305. The at least one processor 301 is configured to invoke at least one program instruction stored or encoded in the memory 302, so as to enable the at least one processor 301 to perform various operations and functions of the DNN edge-end collaborative inference method described in various embodiments of the present application.

[0199] In embodiments of the present specification, the electronic device 300 can include, but is not limited to, a personal computer, a server computer, a workstation, a desktop computer, a laptop computer, a notebook computer, a mobile electronic device, a smart phone, a tablet computer, a cellular phone, a personal digital assistant (PDA), a handheld device, a messaging device, a wearable electronic device, a consumer electronic device, and the like.

[0200] The embodiments of the present disclosure also provide a computer readable medium, which carries computer execution instructions, and the computer execution instructions can be used to implement various operations and functions of the DNN edge-end collaborative inference method described in various embodiments of the present specification when executed by a processor.

[0201] The computer readable medium in the present disclosure can be a computer readable signal medium or a computer readable storage medium or any combination of the two. The computer readable storage medium may, for example, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or apparatus, or any combination of the above. More specific examples of the computer readable storage medium can include, but are not limited to, an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present disclosure, the computer readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, device or apparatus.

[0202] In the present disclosure, the computer readable signal medium can include a data signal propagating in a baseband or as a carrier wave in a propagated data signal, which carries computer readable program code. Such a propagated data signal can take many forms, including but not limited to electro-magnetic, optical, or any suitable combination thereof. The computer readable signal medium can also be any computer readable medium that can send, propagate or transfer program for use by or in connection with an instruction execution system, device or apparatus, other than the computer readable storage medium. The program code contained on the computer readable medium can be transmitted by any suitable medium, including but not limited to wireless, wire line, optical cable, RF, or the like, or any suitable combination thereof.

[0203] Those skilled in the art will appreciate that embodiments of the present application can be devised for a variety of applications. It is intended that the present application covers all such applications of the embodiments disclosed herein, whether or not the specific data is disclosed. It is intended to embrace all alternatives, modifications and sub-combinations of the embodiments disclosed herein and to cover all changes, alterations and modifications to the embodiments disclosed herein that are within the spirit and scope of the present application. It is intended to cover all such changes, alterations and modifications as fall within the scope of the appended claims and their equivalents. It is intended to cover all alternatives, modifications and sub-combinations falling within the scope of the claims.

[0204] The present application is described in reference to the drawings using specific terminology to describe embodiments thereof. But, the description herein is presented for purposes of illustration and description and is not intended to limit the scope of the application in the form disclosed herein. The present application is well suited to achieving the objects and advantages hereinabove set forth together with others. It is appreciated that the present application is not limited to the embodiments disclosed herein, but is applicable to any embodiments within the spirit and scope of the present application. Accordingly, the drawings and descriptions are to be regarded as illustrative in nature and explanations in the following description are to be taken in a manner known to those skilled in the art. While the specification concludes with claims particularly pointing out applications of the present application, it is believed that the application will be better understood from the description and drawings. Figure 1 one or more of the individual steps or acts Figure 1 an apparatus with that function specified in the flow or flows and / or block or blocks.

[0205] The foregoing description of specific exemplary embodiments of the application has been presented for the purposes of illustration and description. They are not intended to be exhaustive or to limit the application to the precise forms disclosed, and various modifications and variations are possible in light of the above teachings. The description and examples are not intended to limit or restrict the scope of the application. Determination of appropriate treatment for any particular case involves the exercise of discretion by the practitioner, and the disclosure made herein enables others skilled in the art to exercise that discretion.

[0206] It is apparent that the application is not limited to the specific embodiments described herein, but that many changes, modifications, and variations thereof will be apparent to those skilled in the art. It is therefore intended that the present application covers all such changes and modifications that come within the spirit and scope of the application. It is intended that the scope of the present application be defined by the following claims and their equivalents.

[0207] Furthermore, it should be understood that although the specification is described in terms of embodiments, not every embodiment includes every feature or implementation described herein. The specification can include implicit combinations of explicitly mentioned features and / or implicit combinations of implicitly mentioned features. Such combinations are also expressly included within the scope of the specification and an embodiment.

Claims

1. A DNN edge-end collaborative inference method, characterized in that, Comprising: Each user sends a registration request to the edge server and establishes a communication link with the edge server, the request contains device ID, computing power, network bandwidth, task type and priority information; Convert the user's DNN task model into a chain task sequence, which is composed of multiple chain sub-tasks, each of which contains local execution delay, server execution delay and transmission delay attributes; Divide the users into a first group and a second group; Comprising, based on the priority of the user, add the user who meets the terminal device task queue stability condition to the first group, whose task can be executed on the terminal device without accumulation; Add the remaining tasks to the second group; Get the offloading point generated in the last round and the corresponding local execution delay, server execution delay, transmission delay and user's priority, calculate the queuing delay of the task on the edge server; Based on the queuing delay on the edge server, update the offloading point of the chain task sequence, the chain sub-tasks near the terminal device side are processed by the terminal device, and the chain sub-tasks near the edge server side are processed by the edge server.

2. The DNN edge-cooperative inference method of claim 1, wherein, Convert the user's DNN task model into a chain task sequence, comprising converting the DNN task model into a directed acyclic graph, and converting the directed acyclic graph into the chain task sequence; wherein converting the DNN task model into a directed acyclic graph specifically comprises: Initialize the graph structure, including data input node, terminal device virtual node and edge server virtual node; Determine whether each layer of the DNN task model is a block structure, if not, add a first input node and a first output node in the graph, and set the weight of the edge connecting the first input node and the first output node as the transmission delay of the layer data; if yes, add a second input node and a second output node in the graph, divide the block structure into multiple sub-modules, recursively process each of the sub-modules, and set the weight of the edge connecting the second input node and the second output node as the difference between the minimum transmission delay of the sub-module and the delay of the layer executed by the edge server; Add virtual edges, including edges connecting from the first input node to the terminal device virtual node, with the weight set as the delay of the layer executed by the edge server, and edges connecting from the first output node to the server virtual node, with the weight set as the delay of the layer executed by the terminal device; Apply the minimum cut algorithm to solve the optimal cutting point of the graph structure, and output the minimum cutting scheme and the corresponding directed acyclic graph.

3. The DNN edge-cooperative inference method of claim 1, wherein, The DNN edge-end collaborative inference method according to claim 1, wherein converting the user's DNN task model into a chain task sequence comprises converting the DNN task model into a directed acyclic graph, and converting the directed acyclic graph into the chain task sequence; wherein converting the directed acyclic graph into the chain task sequence specifically comprises: Traverse each node in the directed acyclic graph; For the node corresponding to the non-block structure, an independent task node is created, and its attributes include the time delay of the layer executed by the terminal, the time delay of the layer executed by the edge server, and the transmission time delay of the layer; For the node corresponding to the layer of the block structure, a first sub-task node and a second sub-task node are created, the attribute of the first sub-task node is set to the total time delay of the task allocated to the terminal device for execution, and the attribute of the second sub-task node is set to the total time delay of the task allocated to the edge server for execution; The independent task node, the first sub-task node and the second sub-task node are arranged in sequence to form the chain task sequence.

4. The DNN edge-cooperative inference method of claim 1, wherein, The queuing time delay of the computing task on the edge server includes: The queuing time delay on the edge server is decomposed into a plurality of decomposition time delays, including a remaining processing time delay of a task being executed, a high-priority task queuing time delay, a same-priority task queuing time delay, and a same-user task queuing time delay; Based on a preset probability model and a state transition equation, the expected values of each of the decomposition time delays are calculated until the calculation results of the expected values converge within a preset threshold range; Based on the calculation results of the expected values of each of the decomposition time delays, the expected queuing time delay of each priority task on the edge server is predicted.

5. The DNN edge-cooperative inference method of claim 1, wherein, Updating the offloading point of the chain task sequence includes: Moving the offloading point of the chain task sequence by a first preset number of hops from the terminal device side to the edge server side, and recording the offloading point position that makes the edge server load lower than the load threshold and meets the terminal device queue stability constraint; Selecting an adjustment scheme that reduces the total delay the most; Based on the recorded offloading point position, determining an offloading point feasible range, within the offloading point feasible range, adjusting the position of the offloading point based on a second preset number of hops, calculating the time delay change, and iteratively obtaining an optimal solution, the second preset number of hops being less than or equal to the first preset number of hops.

6. The DNN edge-cooperative inference method of claim 5, wherein, The method further includes: Distributing the deployment decision of the offloading point to the terminal device and the edge server; Monitoring the system state, and re-determining the offloading point of the chain task sequence when the task characteristics or the load change to achieve adaptive scheduling.

7. A DNN edge-cooperative inference system, comprising: It includes: A connection module for sending a registration request to an edge server and establishing a communication link with the edge server, the request containing device ID, computing power, network bandwidth, task type and priority information; A conversion module for converting a user's DNN task model into a chain task sequence, the chain task sequence being composed of a plurality of chain sub-tasks, each of the sub-tasks containing local execution time delay, server execution time delay and transmission time delay attributes; A calculation module for calculating the queuing time delay of the task on the edge server based on the time interval distribution of the task arriving at the edge server and the priority division; An offloading module for determining the offloading point of the chain task sequence, the chain sub-tasks close to the terminal device side being processed by the terminal device, and the chain sub-tasks close to the edge server side being processed by the edge server.

8. A computer device, comprising: It includes: A memory and a processor in communication connection with each other, the memory storing computer instructions, and the processor executing the computer instructions to perform the DNN edge-side collaborative inference method of any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, The computer readable storage medium stores computer instructions for causing a computer to perform the DNN edge-side collaborative inference method of any one of claims 1-6.

Images