An edge intelligence collaborative inference system and inference method based on task slicing and heterogeneous fusion

Abstract

The application discloses an edge intelligent collaborative inference system based on task slicing and heterogeneous fusion, and aims to solve the problems of strong network dependency, high delay and insufficient utilization of heterogeneous computing resources in the prior art. The system comprises a task slicing module, a dynamic distribution module and a heterogeneous fusion module. The task slicing module is used for constructing an AI inference task into a directed acyclic graph and adaptively slicing. The dynamic distribution module is used for dynamically distributing the task slices to heterogeneous edge devices based on a reinforcement learning PPO algorithm. The heterogeneous fusion module is used for calculating heterogeneous confidence according to device types, historical accuracy and the like, and performing weighted fusion on multi-source inference results. The application realizes low-delay (<50ms), high-reliability and high-resource-utilization edge intelligent inference, and is particularly suitable for high real-time requirement scenes such as smart home and smart aging.

Description

Technical Field

[0001] This invention relates to the field of edge intelligence and distributed computing technology, specifically to an edge intelligence collaborative inference system and method based on task slicing, dynamic distribution, and heterogeneous fusion technologies. This invention dynamically slices AI inference tasks and distributes them to heterogeneous edge devices for collaborative computing, fusing multi-source inference results to achieve low-latency, high-reliability intelligent decision-making. It is suitable for applications with extremely high real-time requirements, such as smart homes, smart elderly care, and smart security. Background Technology

[0002] With the deep integration of artificial intelligence and the Internet of Things (IoT) technologies, applications such as smart homes, smart security, and smart elderly care are increasingly demanding real-time data processing and intelligent decision-making. However, existing smart systems generally suffer from the following technical problems: 1. Excessive network dependence: The core computing and decision-making logic of the existing system is deployed in the cloud. When the network is interrupted, the system functions are severely limited or even completely fail, which cannot meet the needs of scenarios with extremely high continuity requirements such as security and health monitoring.

[0003] 2. High privacy and security risks: Users' home environment data, behavioral habit data, and audio and video data need to be continuously uploaded to the cloud, which poses risks of data leakage, misuse, and unauthorized access, violating the principle of data minimization.

[0004] 3. High system complexity: Poor interoperability between devices of different brands and protocols, requiring users to install multiple apps and perform complex network configuration and scenario setup, resulting in a high barrier to entry.

[0005] 4. Large response delay: The data transmission to the cloud for processing and then back results in a control delay of 100-500ms, which cannot meet the requirements of scenarios with high real-time requirements (such as security alarms and fall detection for the elderly).

[0006] 5. Lack of personalization: Most systems adopt a uniform control strategy and cannot adapt to different users' lifestyles and preferences.

[0007] 6. High energy consumption: The continuous data transmission and cloud computing in cloud communication result in high overall system energy consumption, making it unsuitable for battery-powered portable and wearable scenarios.

[0008] In addition, although there are attempts at edge computing and distributed inference in the existing technologies, the following shortcomings exist: (1) The task allocation adopts a static strategy and cannot be dynamically adjusted according to the real-time load of the device and the network conditions; (2) It only supports task distribution between homogeneous devices and cannot make full use of the differentiated computing capabilities of heterogeneous devices (MCU, NPU, GPU, CPU); (3) The task granularity is fixed and cannot be flexibly sliced ​​according to the task complexity and device capabilities; (4) The result fusion adopts simple averaging or voting and lacks a weighted fusion mechanism for the characteristics of heterogeneous devices; (5) There is a lack of fault tolerance mechanism at the task slice level, and the failure of a single slice leads to the failure of the entire task. Summary of the Invention

[0009] To address the aforementioned technical problems, this invention provides an edge intelligent collaborative reasoning system and reasoning method based on task slicing and heterogeneous fusion.

[0010] An edge intelligent collaborative reasoning system based on task slicing and heterogeneous fusion includes: The task slicing module is used to break down AI inference tasks into multiple independently executable task slices; The dynamic distribution module is used to allocate the task slices to the corresponding devices for inference execution based on the real-time status information of each edge heterogeneous device, according to the reinforcement learning strategy. The heterogeneous fusion module is used to obtain the results of inference performed by each device, calculate the heterogeneous confidence of each result based on the device type and historical performance, and perform weighted fusion of the inference results based on the heterogeneous confidence to output the final inference result.

[0011] Furthermore, the task slicing module is specifically used for: The AI ​​inference task is abstracted as a directed acyclic graph, where nodes represent computational operations and edges represent data dependencies. It supports three slicing modes: slice by layer, slice by data, and slice by operator. The granularity of the slices is dynamically adjusted based on the complexity of the task and the number of devices, with the number of slices ranging from 2 to 20.

[0012] Furthermore, the task slicing module is also used for: Evaluate the computational cost S_c, communication cost S_m, and storage cost S_e for each task slice; The optimal slicing scheme is determined based on the total cost function S_t = Σ w1·S_c + Σw2·S_m + w3·S_e, where w1, w2, and w3 are weight coefficients. The computational cost model is S_c = F / P, where F is the floating-point operation volume of the slice and P is the computing performance of the device; the communication cost model is S_m = D / B + L, where D is the data volume between slices, B is the bandwidth, and L is the latency.

[0013] Furthermore, the dynamic distribution module is specifically used for: Real-time monitoring of the computing power, storage capacity, communication capacity, and energy consumption status of each device, and construction of device capability vector V = [P, M, B, E]; The state space of the reinforcement learning policy is S = {V1, V2, ..., V}. n Action space A = {a1, a2, ..., a}, T, Q} m}, where a i This indicates that slice s i When assigned to device j, the reward function is R = -α·T β·E γ·F, where T is the total delay, E is the total energy consumption, F is the failure penalty, and α, β, and γ are weighting coefficients. The distribution strategy is trained using the Proximal Policy Optimization (PPO) algorithm.

[0014] Furthermore, the heterogeneous fusion module is specifically used for: The confidence level η of the inference results of each device is calculated according to the formula η = f(w1α + w2β + w3γ) · δ; Where α is the historical accuracy, β is the reliability score, γ is the data freshness, δ is the baseline confidence level of the equipment type, w1, w2, and w3 are weighting coefficients, and f(·) is the modified Sigmoid normalization function. For classification tasks, the weighted voting formula R = argmax_c Σ is used. j η j · I(p j = c) Perform fusion; for regression tasks, use the weighted average formula R = Σ j η j · p j / Σ j η j To integrate.

[0015] Furthermore, the heterogeneous fusion module is also used for: Set the conflict detection threshold T = μ + 2σ, where μ is the mean of the differences in historical inference results and σ is the standard deviation of the differences in historical inference results; When the differences in the inference results of multiple devices exceed the conflict detection threshold, a conflict resolution strategy is triggered. The conflict resolution strategies include: a confidence-first strategy, which selects the result with the highest confidence; a redundancy verification strategy, which redistributes conflict slices to other devices for verification; and a degradation processing strategy.

[0016] Furthermore, the dynamic distribution module is also used for: Real-time monitoring of task execution progress and device status changes; triggering task reassignment within less than 10ms when device load changes suddenly or network conditions change. The task reassignment supports task preemption and migration.

[0017] Furthermore, the inference system also includes a feedback optimization module, which feeds back the fused inference results to the task slicing module and the dynamic distribution module to optimize the subsequent slicing and distribution strategies.

[0018] An edge intelligence collaborative reasoning method based on task slicing and heterogeneous fusion includes: The task slicing step breaks down the AI ​​inference task into multiple independently executable task slices. The dynamic distribution step, based on a reinforcement learning strategy, allocates the task slices to the corresponding devices for inference execution according to the real-time status information of each edge heterogeneous device; The heterogeneous fusion step involves obtaining the results of inference performed by each device, calculating the heterogeneous confidence of each result based on the device type and historical performance, and then weighting and fusing the inference results based on the heterogeneous confidence to output the final inference result.

[0019] A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the reasoning method of the present invention.

[0020] By adopting the above technical solution, the present invention has the following beneficial effects: 1. Low-latency inference: Through task slicing and dynamic distribution, inference tasks are assigned to the nearest or fastest device for execution, with end-to-end inference latency <50ms, which is more than 60% lower than single-device execution latency and more than 90% lower than cloud execution latency.

[0021] 2. High-precision fusion: By using a weighted fusion algorithm based on heterogeneous perception, the differentiated capabilities of heterogeneous devices such as NPU, GPU, CPU, and MCU are fully utilized. The accuracy after fusion is improved by 5-10% compared to single device, and the robustness is significantly improved.

[0022] 3. High resource utilization: Through dynamic allocation strategy, the overall resource utilization of the system is >85%, which is more than 30% higher than the static allocation strategy, avoiding the situation where some devices are overloaded while other devices are idle.

[0023] 4. High reliability: Fault tolerance mechanism at the task slice level, failure of a single slice does not affect the overall task, slice re-execution time <10ms, system availability >99.9%.

[0024] 5. Strong adaptability: The reinforcement learning distribution strategy can adapt to environmental changes such as dynamic device joining / leaving, changes in network conditions, and load fluctuations, with an adaptation time of <100ms.

[0025] 6. Low energy consumption: By distributing computationally intensive tasks to energy-efficient devices (such as NPUs), the overall system energy consumption is reduced by more than 40%, and the battery life of devices is extended by more than 50%.

[0026] 7. Low bandwidth usage: Only necessary intermediate features (rather than raw data) are transmitted between task slices, reducing bandwidth usage by more than 70% and packet loss retransmission rate by more than 80%.

[0027] 8. Scalability: Supports collaborative inference for 2-100+ heterogeneous devices. Inference latency increases sublinearly with the number of devices, demonstrating good horizontal scalability. Attached Figure Description

[0028] Figure 1 This is a flowchart of the heterogeneous confidence weighted fusion method of the present invention.

[0029] Figure 2 This is a diagram of the collaborative reasoning system architecture of the present invention.

[0030] Figure 3 A flowchart illustrating the collaborative process of task slicing and dynamic distribution.

[0031] Figure 4 This is a diagram illustrating an application scenario for fall detection in smart elderly care.

[0032] Figure 5 This is a block diagram of the end-to-end data flow of the present invention. Detailed Implementation

[0033] The technical solution of the present invention will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0034] An edge intelligent collaborative reasoning system based on task slicing and heterogeneous fusion. It includes the following modules: (I) Task Slicing Module This invention employs adaptive task slicing technology to decompose complex AI inference tasks into independently executable task slices: 1. Task Graph Construction: The AI ​​inference task is abstracted as a Directed Acyclic Graph (DAG), where nodes represent computational operations and edges represent data dependencies. The system supports three slicing modes: layer-based slicing (assigning model layers to different devices), data-based slicing (partitioning input data for parallel processing), and operator-based slicing (decomposing a single operator into sub-operations). The slicing granularity is adaptive, dynamically adjusting according to task complexity and the number of devices, with the number of slices ranging from 2 to 20.

[0035] 2. Slice Cost Evaluation: For each task slice, evaluate the computational cost, communication cost, and storage cost. The computational cost model is: S_c = F / P, where F is the floating-point operation volume of the slice, and P is the device's computing performance. The communication cost model is: S_m = D / B + L, where D is the data volume between slices, B is the bandwidth, and L is the latency. The total cost function is: S_t = Σ w1·S_c + Σ w2·S_m + w3·S_e, where w1, w2, and w3 are weighting coefficients.

[0036] 3. Slice Boundary Optimization: Identify computationally intensive and communication-intensive layers in the model, and set slice boundaries at locations with minimal communication. A dynamic programming algorithm is used to find the optimal slice points, minimizing data transfer between slices. Furthermore, slice merging is supported; when the communication cost of two adjacent slices exceeds the computational cost of the merged slice, they are automatically merged into one slice.

[0037] (II) Dynamic Distribution Module This invention employs a reinforcement learning-based dynamic task distribution strategy to intelligently allocate task slices to heterogeneous devices: 1. Device Capability Modeling: Real-time monitoring of each device's computing power (CPU / NPU / GPU computing power), storage capacity (available memory), communication capabilities (bandwidth, latency), and energy consumption status (battery level, power consumption) to construct a device capability vector: V = [P,M, B, E], representing computing performance, available memory, available bandwidth, and remaining power, respectively. The system supports heterogeneous device types, including MCUs (such as ESP32, STM32), NPUs (such as K210, Himax), GPUs (such as Jetson Nano), and CPUs (such as Raspberry Pi).

[0038] 2. Reinforcement learning distribution strategy: The state space is S = {V1, V2, ..., V} n The action space is A = {a1, a2, ..., a}, which contains all device capability vectors, task slice features T, and network states Q. m}, where a i This indicates that slice s iThe reward is assigned to device j. The reward function is R = -α·T β·E γ·F, where T is the total latency, E is the total energy consumption, and F is the failure penalty. The system uses the Proximal Policy Optimization (PPO) algorithm to train the distribution strategy. After offline training, the online inference time is less than 1ms.

[0039] 3. Dynamic Adjustment Mechanism: Real-time monitoring of task execution progress and device status changes. When device load suddenly changes or network conditions deteriorate, task reallocation is triggered, with a reallocation time of less than 10ms. The system supports task preemption and migration, allowing high-priority tasks to preempt the computing resources of low-priority tasks.

[0040] (III) Heterogeneous Fusion Module This invention employs heterogeneous perception result fusion technology to integrate inference results from different types of devices: 1. Heterogeneous Confidence Assessment: The confidence of inference results for each device is assessed based on device type, model accuracy, and historical performance. The confidence model is: η = f(w1α + w2β + w3γ) · δ. Where α = N_c / N_t is the historical accuracy, N_c is the number of correct inferences, and N_t is the total number of inferences; β = max(0, 1 σ / μ) is the reliability score, σ is the standard deviation of recent inference results, and μ is the mean; γ = e^(-λt) is the data freshness, t is the time difference, and λ=0.1 is the decay coefficient; δ is the baseline confidence for device type, calibrated through offline experiments. The baseline confidence range for device type is: NPU (0.90-0.95), GPU (0.85-0.90), CPU (0.80-0.85), and MCU (0.75-0.80). The weighting coefficients w1=0.5, w2=0.3, w3=0.2 were determined by optimization on the validation set through grid search.

[0041] 2. Conflict Detection and Resolution: The system sets conflict detection thresholds. For classification tasks, the threshold T_c = μ_c + 2σ_c, where μ_c and σ_c are the mean and standard deviation of historical L1 distances; for regression tasks, the threshold T_r = μ_r + 2σ_r, where μ_r and σ_r are the mean and standard deviation of historical relative errors. When there are significant differences in the inference results of multiple devices, conflict resolution strategies are triggered, including: confidence priority (selecting the result with the highest confidence), redundant verification (redistributing conflict slices to other devices for verification), and degradation processing (adopting a conservative strategy when consensus cannot be reached).

[0042] 3. Weighted Fusion Algorithm: For classification tasks, weighted voting is used: R = argmax_c Σ j η j · I(pj =c); For regression tasks, a weighted average is used: R = Σ j η j · p j / Σ j η j For detection tasks, weighted NMS (non-maximum suppression) is used, and the IoU threshold is adjusted according to the confidence level, with results from high-confidence devices being retained first.

[0043] 4. Fusion Quality Assessment: The quality of the fusion results is assessed in real time using a consistency metric: Q = 1 / std(p) / mean(p). When the consistency falls below a threshold, adaptive weight adjustment is triggered, reducing the weight of abnormal devices.

[0044] An edge intelligence collaborative reasoning method based on task slicing and heterogeneous fusion includes: The task slicing step breaks down the AI ​​inference task into multiple independently executable task slices. The dynamic distribution step, based on a reinforcement learning strategy, allocates the task slices to the corresponding devices for inference execution according to the real-time status information of each edge heterogeneous device; The heterogeneous fusion step involves obtaining the results of inference performed by each device, calculating the heterogeneous confidence of each result based on the device type and historical performance, and then weighting and fusing the inference results based on the heterogeneous confidence to output the final inference result.

[0045] I. Derivation of Core Formulas The core algorithm of this invention is based on the following rigorously derived mathematical formula.

[0046] Formula 1: Heterogeneous confidence calculation formula: η = f(w1α + w2β + w3γ) · δ; Where η: heterogeneous confidence of device inference results; f(·): modified Sigmoid normalization function, f(x)=1 / (1+e^(-k(x-x0))), k=5, x0=0.5; α: historical accuracy, α = N_c / N_t; β: reliability score, β = max(0, 1σ / μ); γ: data freshness, γ = e^(-λt); δ: device type baseline confidence; NPU takes 0.90-0.95, GPU takes 0.85-0.90, CPU takes 0.80-0.85, MCU takes 0.75-0.80; w1, w2, w3: weight coefficients, w1+w2+w3=1, take w1=0.5, w2=0.3, w3=0.2.

[0047] Derivation process: Step 1: Problem Modeling. In a heterogeneous edge device environment, the reliability of inference results for the same task varies among different devices. Assume the reliability of device inference results is affected by three factors: historical accuracy α, reliability score β, and data freshness γ.

[0048] Step 2: Multi-factor weighted combination. The three factors are combined into a comprehensive evaluation value x = w1α + w2β + w3γ using a weighted linear combination; where w1+w2+w3=1. The values ​​w1=0.5, w2=0.3, and w3=0.2 are determined by grid search on the validation set.

[0049] Step 3: Normalization. Since the values ​​of α, β, and γ are all in the range [0,1], and the value range of the weighted sum x is also in the range [0,1], it needs to be mapped to the (0,1) interval and has non-linear characteristics. The Sigmoid function σ(x) = 1 / (1+e^(-x)) is chosen for mapping.

[0050] Step 4: Modify the Sigmoid design. The standard Sigmoid output range is [0.5, 0.73] when x∈[0,1], causing the confidence of high-performance devices to be overcompressed. Introduce correction parameters k and x0: f(x) = 1 / (1+e^(-k(x-x0))); take k=5, x0=0.5, so that f(0.5)=0.5 (medium performance corresponds to medium confidence), f(0.8)=0.82 (high performance obtains high confidence), f(0.2)=0.18 (low performance obtains low confidence).

[0051] Step 5: Introduce a baseline confidence level based on device type. Different hardware architectures impose structural constraints on inference capabilities (e.g., NPU precision is higher than MCU precision). This "ceiling effect" is expressed using a multiplicative factor δ: η = f(x) · δ; even if the device performs perfectly online (f(x)→1), the final confidence level will not exceed δ.

[0052] Formula 2: Reliability scoring formula: β = max(0, 1 σ / (μ + ε)); Where β is the reliability score; σ is the standard deviation of recent inference results; μ is the mean of recent inference results; and ε is a smoothing constant, set to 0.01. This formula is normalized based on the reciprocal of the coefficient of variation and incorporates a non-negativity constraint.

[0053] Derivation process: Step 1: Problem Definition. The stability of recent inference results from the device can be measured by the coefficient of variation (CV): CV = σ / μ, where σ is the standard deviation and μ is the mean. The smaller the CV, the more stable the output.

[0054] Step 2: Normalization. To map CV to the [0,1] interval (larger values ​​are more reliable), invert the CV and add 1: β = 1 - CV = 1 - σ / μ; Step 3: Zero-prevention processing. When μ→0, CV→∞. Introduce a smoothing constant ε=0.01: β = 1 - σ / (μ +ε); Step 4: Non-negativity constraint. β may be negative when σ > μ. Take max(0, ·) to ensure the score is non-negative: β = max(0, 1 - σ / (μ + ε)).

[0055] Formula 3: Data freshness formula: γ = e^(-λt); Where γ represents data freshness; λ is the decay coefficient, set to 0.1; and t is the time difference (in seconds) between the moment the inference result is generated and the current moment. This formula is based on an exponential decay model, with a decay coefficient λ = 0.1, which matches the typical cycle (approximately 10 seconds) of device state changes in edge inference scenarios.

[0056] Derivation process: Step 1: Problem Definition. The timeliness of the reasoning results decays over time, so it is necessary to quantify the "freshness".

[0057] Step 2: Exponential decay model. Choose the exponential decay function because: the decay rate is proportional to the current value: dγ / dt = -λγ; Solving this differential equation, we get: γ(t) = γ(0) · e^(-λt); with the initial condition γ(0)=1, we get γ = e^(-λt); Step 3: Determine the attenuation coefficient. Take λ=0.1, then: when t=0 seconds, γ=1 (latest data); when t=10 seconds, γ=e^(-1) ≈ 0.37; when t=20 seconds, γ=e^(-2) ≈ 0.14.

[0058] This timescale matches the typical cycle (on the order of 10 seconds) of device state changes in edge inference scenarios.

[0059] Formula 4: Collision detection threshold formula: T = μ + 2σ; Where T is the conflict detection threshold; μ is the mean of the differences in historical inference results; and σ is the standard deviation of the differences in historical inference results.

[0060] Derivation process: Step 1: Problem Definition. It is necessary to determine whether there is a "significant difference" in the inference results of the two devices, i.e., whether the difference exceeds the normal fluctuation range.

[0061] Step 2: Normal distribution assumption. Assume that the differences in historical inference results follow a normal distribution N(μ, σ²).

[0062] Step 3: Confidence Interval Selection. Based on the properties of the normal distribution: P(|X-μ|<σ) ≈ 68%; P(|X-μ|<2σ) ≈ 95%; P(|X-μ|<3σ) ≈ 99.7%.

[0063] Step 4: Threshold Determination. 2σ is chosen as the threshold, corresponding to the 95% confidence interval. When the difference exceeds μ+2σ, it is considered an abnormal conflict (there is only a 5% probability that it is normal fluctuation).

[0064] Step 5: Adaptation to Classification / Regression Tasks: Classification task: The dissimilarity is the L1 distance, T_c = μ_c + 2σ_c; Regression task: The variance is the relative error, T_r = μ_r + 2σ_r; Based on the assumption of normal distribution, 2σ is chosen as the threshold, corresponding to the 95% confidence interval. When the difference exceeds μ+2σ, it is judged as an abnormal conflict.

[0065] Formula 5: Task slice cost formula: S = D / B + L; Where S is the slice cost, which is the communication overhead for data transmission across devices; D is the data volume, which is the amount of intermediate data (bytes) transmitted between slices; B is the bandwidth, which is the effective bandwidth between devices (bytes / second); and L is the latency, which is the fixed network latency (seconds).

[0066] Derivation process: Step 1: Problem Definition. In a directed acyclic graph, on each edge (v... i , v j When segmenting the model at a certain point, it is necessary to evaluate the communication overhead of cross-device data transmission.

[0067] Step 2: Communication Time Modeling. The total time for cross-device data transmission consists of two parts: transmission time: D / B, which is the data volume divided by the bandwidth; propagation delay: L, which is the fixed network delay.

[0068] Step 3: Total communication cost: S = D / B + L.

[0069] Step 4: Boundary selection strategy. Select the edge with the smallest S as the slice boundary because the communication overhead at this location is minimal, and the impact on system performance after slicing is minimal.

[0070] The total communication time for cross-device data transmission consists of two parts: transmission time (D / B) and propagation delay (L).

[0071] II. Core Algorithm Description Algorithm 1: Task Slicing Cost Evaluation and Boundary Optimization Algorithm This invention employs a dynamic programming algorithm to optimize the task slicing scheme and minimize the total execution cost. The cost function is defined as follows: S_t = Σ w1·S_c + Σ w2·S_m + w3·S_e; where w1=0.4, w2=0.4, and w3=0.2 are the weight coefficients of each cost term.

[0072] The pseudocode for slice boundary optimization is as follows: ``` Algorithm: Task slice boundary optimization; Input: computation graph G=(V,E), device set D, device capability vector {V}; Output: Optimal slicing scheme S; initialization: The set of candidate split points C = Identify_Split_Points(G); Optimal cost S_best = ∞; The optimal solution S = null; Function Optimize_Splits(G, D, C): For each slice combination S in Combinations(C): / / Calculate slice cost C_c = Σ i F / P(assigned_device(i)); S_m = Σ D / B + L; S_e = max(Memory(s i )) for all s i in S; S_t = 0.4 × S_c + 0.4 × S_m + 0.2 × S_e; / / Check if the constraints are satisfied if S_t <S_best and Satisfy(S, D) then S_best = S_t S = S end if end for / / Merge adjacent slices (when the communication cost is greater than the merging computation cost) for each adjacent slice pair (s i , s i+1 ) in S: S_g = F(s i ∪ si+1 ) / P S_c = S_m(s i , s i+1 ) if S_g <S_c then S = Merge(S, s i , s i+1 ) end if end for return S ``` Algorithm 2: Dynamic task distribution algorithm based on reinforcement learning: This invention uses the PPO (Proximal Policy Optimization) algorithm to train the task distribution strategy, and the pseudocode is as follows: ``` Algorithm: PPO dynamic task distribution; Input: State s = (Device Capability {V}, Task Slice {T}, Network State Q); Output: Dispatch action a (slice to device mapping); initialization: Policy network π_θ (input state, output action probability); Value network V_φ (input state, output state value); Discount factor γ = 0.99; The trimming parameter ε = 0.2; Learning rate α = 3e-4; Function Select_Action(s, π_θ): / / Construct state features features = Concat(V, T, Q); / / Policy network outputs action probabilities action_probs = π_θ(features); / / Sampling action (slicing-device mapping) a = Sample(action_probs); return a Function Train_PPO(trajectories): for each trajectory τ in trajectories: / / Calculate discount return R_t = Σ_{k=0}^{Tt} γ^k × r_{t+k}; / / Calculate the advantage function A_t = R_t V_φ(s_t); / / Calculate the strategy ratio ratio = π_θ(a_t|s_t) / π_θ_old(a_t|s_t); / / PPO trimming target L_clip = min(ratio × A_t, clip(ratio, 1-ε, 1+ε) × A_t); / / Update policy network θ = θ + α × L_clip; / / Update the value network φ = φ + α × (R_t V_φ(s_t))²; end for Reward function design: R = -α × T β × E γ × F; Where: T = max(completion time): the maximum time to complete all slices; E = Σ E j : Total system energy consumption; F = Number of failed slices × 100: Failure penalty; α = 0.5, β = 0.3, γ = 0.2 ``` Algorithm 3: Heterogeneous Confidence Weighted Fusion Algorithm This invention employs a weighted fusion algorithm based on heterogeneous sensing to integrate inference results from different types of devices: R = Ση j ·p j / Σ η j .

[0073] The pseudocode for heterogeneous fusion is as follows: ``` Algorithm: Heterogeneous confidence weighted fusion; Input: Inference results from each device {p j}, Device type {t j Historical accuracy {α} j}; Output: Fusion result R; initialization: Device baseline confidence levels: NPU=0.95, GPU=0.90, CPU=0.85, MCU=0.80; Weighting coefficients: w1=0.5, w2=0.3, w3=0.2; Function Fusion(p, t, h): / / Step 1: Calculate the confidence level of each device conf = [] for j = 1 to n: α = h[j].accuracy / / Historical accuracy β = h[j].reliability / / Reliability score γ = Fresh(h[j].timestamp) / / Data freshness / / Baseline confidence level (based on device type) δ = Base(t[j]) / / Calculate the overall confidence level η = σ(w1× α + w2× β + w3× γ) × δ conf.append(η) end for / / Step 2: Check for conflicting results if Conflict(p, threshold=0.3) then / / Conflict resolution: Select the result with the highest confidence level max_idx = argmax(conf) if max(conf) > 0.9 then R = p[max_idx] else / / Redundancy verification: redistribute conflicting slices R = Redistribute(conflict_slice) end if else / / Step 3: Weighted Fusion if Is_Classification_Task() then / / Classification task: Weighted voting R = argmax_c Σ j η j × I(p j == c) else / / Regression task: Weighted average R = Σ j η j × p j / Σ j η j end if end if / / Step 4: Evaluate fusion quality Q = 1 / std(p) / mean(p) if Q < 0.8 then / / Reduce the weight of abnormal devices Adjust(conf, p) end if return R ``` Example 1: Intelligent Elderly Care System This embodiment is the best preferred embodiment of the present invention because the elderly care scenario has the most stringent requirements for low latency (fall detection must be completed within 2 seconds) and offline reliability (network interruption should not affect safety monitoring when the elderly live alone), and best reflects the core value of the present invention.

[0074] (1) System hardware composition This embodiment provides an intelligent elderly care system based on the system of the present invention, specifically designed to address the needs of elderly people for daily care, health monitoring, and safety assurance. The hardware components are as follows: Multimodal sensor networks: Millimeter-wave radar module: using IWR1443 chip, operating frequency 60GHz, detection accuracy ±2cm, sampling rate 20fps, used for non-contact fall detection and vital sign monitoring.

[0075] Smart mattress module: Built-in 16×16 pressure sensor array to monitor sleep quality and bed exit status.

[0076] Smart pillbox module: 6-compartment pillbox with RTC clock and open detection sensor.

[0077] Environmental sensor group: including temperature and humidity sensor, air quality sensor, and smoke sensor.

[0078] Edge computing gateway: Utilizes a Raspberry Pi 4 Model B to deploy a multi-sensor fusion analysis model.

[0079] Emergency call devices: including wireless emergency buttons and voice call devices.

[0080] Smart home control module: Controls devices such as lights, air conditioners, and curtains via the Matter / Thread protocol.

[0081] Family mobile app: Supports iOS and Android, used to receive alarms and view data.

[0082] Power management module: Equipped with UPS backup power supply, with a battery life of >4 hours.

[0083] (2) Implementation of core algorithm This embodiment uses Algorithm 1, Algorithm 2, and Algorithm 3 as the core algorithms: Task slicing implementation: The fall detection task is constructed as a DAG, including data preprocessing, feature extraction, single-sensor detection, and fusion decision nodes. Six task slices are generated using a data slicing model.

[0084] Dynamic distribution implementation: After device capability vector modeling, the PPO strategy distributes computationally intensive feature extraction slices to the K210 (NPU), fusion decision slices to the Raspberry Pi 4, and data preprocessing slices to the ESP32-C3.

[0085] Heterogeneous fusion was implemented: the confidence level was 0.95 for K210, 0.90 for Raspberry Pi 4, and 0.85 for ESP32-C3. Weighted fusion was used to calculate the probability of falling.

[0086] The fall detection algorithm is implemented by coordinating millimeter-wave radar data preprocessing (ESP32-C3), feature extraction (K210 NPU), and fusion decision-making (Raspberry Pi 4). An alarm is triggered after confirmation of three consecutive sampling cycles.

[0087] Action recognition algorithm implementation: A lightweight LSTM network is used for layer slicing, with a total inference time of <50ms.

[0088] (3) Detailed Work Process 1. Routine monitoring phase: Millimeter-wave radar, smart mattress, and environmental sensors continuously collect data, which is then stored and processed locally.

[0089] 2. Behavior analysis phase: The edge computing gateway runs a behavior analysis model to identify daily activities such as getting up, eating, and taking medication.

[0090] 3. Anomaly detection phase: Integrating data from multiple sensors to detect falls, prolonged inactivity, abnormal breathing, and missed medication.

[0091] 4. Emergency Response Phase: Upon detecting a fall, the system triggers a response at T+0ms, turns on the lights at T+100ms, shuts off the gas at T+200ms, activates a local alarm at T+500ms, and notifies the family at T+2000ms. The critical response chain is entirely based on local processing and does not rely on the network.

[0092] 5. Personalized Service Stage: The EWC incremental learning algorithm is used to learn the elderly's living habits and automatically adjust the indoor environment and reminder services.

[0093] 6. Health Report Generation: Automatically generates daily health reports including sleep quality, activity level, medication status, etc.

[0094] 7. Remote care function: Family members can view real-time status and historical trends through the application, and conduct video calls and remote control.

[0095] This embodiment fully demonstrates the core technical advantages of the present invention: Low latency: End-to-end inference latency <50ms, emergency response chain <100ms.

[0096] High reliability: The security monitoring function is 100% available after network outage, and it can run offline for more than 72 hours.

[0097] Privacy protection: All data is processed locally and not uploaded to the cloud.

[0098] Low power consumption: Overall system power consumption <5W.

[0099] High accuracy: Fall detection accuracy >95%, false alarm rate <2%.

[0100] Example 2: Intelligent Lighting System Employing a light sensor and a human infrared sensor, the ESP32-C3 MCU runs a quantized MobileNetV3 model with an inference latency of <50ms, supports Bluetooth Mesh multi-device collaboration, and can operate offline for >72 hours without network access.

[0101] Example 3: Intelligent Temperature Control System Using temperature and humidity sensors, an STM32L4 MCU runs an LSTM temperature prediction model with an inference latency of <30ms. Combined with peak and off-peak electricity pricing, the system optimizes air conditioning operation strategies, reducing energy consumption by more than 30%.

[0102] Example 4: Intelligent Security System Employing a camera, motion sensor, and sound sensor, the Raspberry Pi 4 runs a behavior recognition model with an inference latency of <60ms, and can still generate local alarms even when the network is offline.

[0103] Example 5: Intelligent Energy Management System Employing current and voltage sensors, the nRF52840 MCU runs a device identification and energy consumption prediction model, achieving an overall energy saving effect of >20%.

[0104] Example 6: Intelligent Health Monitoring System Employing wearable sensors, the nRF5340 MCU runs a health analysis model with an inference latency of <40ms, and local processing of health data protects privacy.

[0105] Figure 1 This is a flowchart of the heterogeneous confidence weighted fusion method of the present invention, wherein S1 is the step of obtaining device information (obtaining the hardware architecture type, historical accuracy, and recent inference records of each device), S2 is the step of calculating heterogeneous confidence (calculating the confidence for each device according to the formula η = f(w1α + w2β + w3γ) · δ), S3 is the weighted fusion step (weighted voting or weighted averaging with the confidence of each device as the weight), S4 is the conflict detection step (calculating the L1 distance for the classification task and the relative error for the regression task, and comparing them with the corresponding thresholds respectively), and S5 is the step of outputting the fusion result.

[0106] Figure 2 This is a diagram of the collaborative reasoning system architecture of the present invention, where 100 is the task slicing module, 200 is the dynamic distribution module, 300 is the heterogeneous fusion module (including confidence evaluation unit 301, weighted fusion unit 302, and conflict resolution unit 303), and 400 is the feedback optimization module. The arrows indicate the directions of data flow (solid line) and control flow (dashed line).

[0107] Figure 3 This is a flowchart of the collaborative process for task slicing and dynamic distribution, where S10 is the task graph construction step, S20 is the slice boundary calculation step, S30 is the equipment capability monitoring step, S40 is the PPO reinforcement learning distribution step, S50 is the slice execution step, and S60 is the result output and confidence evaluation step.

[0108] Figure 4 This diagram illustrates an application scenario for fall detection in smart elderly care. 501 represents a millimeter-wave radar device (NPU type, responsible for human posture feature extraction), 502 a smart mattress device (MCU type, responsible for pressure distribution data preprocessing), 503 an edge computing gateway (CPU type, responsible for fusion decision-making), 504 a heterogeneous fusion processing unit (deploying the method of this invention), and 505 an emergency response execution unit.

[0109] Figure 5This is the end-to-end data flow diagram of the present invention, where D1 is the sensor / data acquisition layer (including heterogeneous edge devices such as NPU device 601, MCU device 602, and CPU device 603), D2 is the data preprocessing layer (performing preprocessing operations such as filtering and normalization on the acquired raw data), D3 is the task slicing layer (constructing the AI ​​inference task into a directed acyclic graph and adaptively slicing it), D4 is the dynamic distribution layer (allocating slices to the optimal device using the PPO algorithm based on device capability vectors and network status), and D5 is the heterogeneous device parallel inference layer. (Each device independently executes its assigned slice, outputting inference results and confidence vectors). D6 is the heterogeneous confidence fusion layer (calculating heterogeneous confidence based on device type baseline confidence and online evaluation, and performing weighted fusion). D7 is the conflict detection and resolution layer (using L1 distance for classification tasks and relative error for regression tasks, performing redundant verification or degradation processing when conflicts are triggered). D8 is the final output layer (outputting the fused inference results and feeding them back to the slice layer and distribution layer to optimize subsequent strategies). Solid arrows indicate data flow, and dashed arrows indicate feedback control flow.

[0110] The edge intelligent collaborative reasoning system and method based on task slicing and heterogeneous fusion provided by this invention can be widely applied in fields such as smart homes, smart elderly care, smart security, and smart energy management. Compared with existing technologies, this invention has significant advantages such as low-latency reasoning (latency <50ms), high-precision fusion (accuracy improvement of 5-10%), high resource utilization (>85%), high reliability (availability >99.9%), strong adaptability, and low energy consumption (reduction of more than 40%), and has extremely high industrial application value.

[0111] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. An edge intelligent collaborative reasoning system based on task slicing and heterogeneous fusion, characterized in that, include: The task slicing module is used to break down AI inference tasks into multiple independently executable task slices; The dynamic distribution module is used to allocate the task slices to the corresponding devices for inference execution based on the real-time status information of each edge heterogeneous device, according to the reinforcement learning strategy. The heterogeneous fusion module is used to obtain the results of inference performed by each device, calculate the heterogeneous confidence of each result based on the device type and historical performance, and perform weighted fusion of the inference results based on the heterogeneous confidence to output the final inference result.

2. The reasoning system according to claim 1, characterized in that, The task slicing module is specifically used for: The AI ​​inference task is abstracted as a directed acyclic graph, where nodes represent computational operations and edges represent data dependencies. It supports three slicing modes: slice by layer, slice by data, and slice by operator. The granularity of the slices is dynamically adjusted based on the complexity of the task and the number of devices, with the number of slices ranging from 2 to 20.

3. The reasoning system according to claim 2, characterized in that, The task slicing module is also used for: Evaluate the computational cost S_c, communication cost S_m, and storage cost S_e for each task slice; The optimal slicing scheme is determined based on the total cost function S_t = Σw1·S_c + Σw2·S_m + w3·S_e, where w1, w2, and w3 are weight coefficients. The computational cost model is S_c = F / P, where F is the floating-point operation volume of the slice and P is the computing performance of the device; the communication cost model is S_m = D / B + L, where D is the data volume between slices, B is the bandwidth, and L is the latency.

4. The reasoning system according to claim 1, characterized in that, The dynamic distribution module is specifically used for: Real-time monitoring of the computing power, storage capacity, communication capacity, and energy consumption status of each device, and construction of device capability vector V = [P, M, B, E]; The state space of the reinforcement learning policy is S = {V1, V2, ..., V}. n Action space A = {a1, a2, ..., a}, T, Q} m }, where a i This indicates that slice s i When assigned to device j, the reward function is R = -α·T β·E γ·F, where T is the total delay, E is the total energy consumption, F is the failure penalty, and α, β, and γ are weighting coefficients. The distribution strategy is trained using a near-end strategy optimization algorithm.

5. The reasoning system according to claim 1, characterized in that, The heterogeneous fusion module is specifically used for: The confidence level η of the inference results of each device is calculated according to the formula η = f(w1α + w2β + w3γ) · δ; Where α is the historical accuracy, β is the reliability score, γ is the data freshness, δ is the baseline confidence level of the equipment type, w1, w2, and w3 are weighting coefficients, and f(·) is the modified Sigmoid normalization function. For classification tasks, the weighted voting formula R = argmax_c Σ is used. j η j · I(p j = c) Perform fusion; for regression tasks, use the weighted average formula R = Σ j η j · p j / Σ j η j To integrate.

6. The reasoning system according to claim 5, characterized in that, The heterogeneous fusion module is also used for: Set the conflict detection threshold T = μ + 2σ, where μ is the mean of the differences in historical inference results and σ is the standard deviation of the differences in historical inference results; When the differences in the inference results of multiple devices exceed the conflict detection threshold, a conflict resolution strategy is triggered. The conflict resolution strategies include: a confidence-first strategy, which selects the result with the highest confidence; a redundancy verification strategy, which redistributes conflict slices to other devices for verification; and a degradation processing strategy.

7. The reasoning system according to claim 6, characterized in that, The dynamic distribution module is also used for: Real-time monitoring of task execution progress and device status changes; triggering task reassignment within less than 10ms when device load changes suddenly or network conditions change. The task reassignment supports task preemption and migration.

8. The reasoning system according to claim 7, characterized in that, The inference system also includes a feedback optimization module, which feeds back the fused inference results to the task slicing module and the dynamic distribution module to optimize the subsequent slicing and distribution strategies.

9. A collaborative reasoning method for edge intelligence based on task slicing and heterogeneous fusion, characterized in that, include: The task slicing step breaks down the AI ​​inference task into multiple independently executable task slices. The dynamic distribution step, based on a reinforcement learning strategy, allocates the task slices to the corresponding devices for inference execution according to the real-time status information of each edge heterogeneous device; The heterogeneous fusion step involves obtaining the results of inference performed by each device, calculating the heterogeneous confidence of each result based on the device type and historical performance, and then weighting and fusing the inference results based on the heterogeneous confidence to output the final inference result.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the method as described in claim 9.

Images