Intelligent doll-oriented multi-modal data processing task scheduling optimization method and system

Abstract

The invention relates to the technical field of intelligent dolls, and discloses a multi-modal data processing task scheduling optimization method and system for an intelligent doll, and the system comprises a multi-modal collection module which obtains voice, visual images and environment sensor data in real time; the task decomposition module analyzes the data into parallel tasks according to a preset mapping table, and the tasks are matched after feature extraction, image segmentation and timestamp alignment data fusion; the resource allocation module allocates an isolation container instance with a running environment and a resource quota according to a node load and a task demand; the scheduling execution module distributes tasks to edge nodes for execution according to the priority queues, monitors states and receives results; and the dynamic updating module periodically adjusts the queue weight coefficient according to the result. The method correspondingly executes each step. According to the scheme, the multi-modal task processing efficiency and the system stability of the intelligent doll are improved, and the method is suitable for related scheduling scenes.

Description

Technical Field

[0001] The present invention relates to the technical field of intelligent dolls, and specifically to a multi-modal data processing task scheduling optimization method and system for intelligent dolls. Background Art

[0002] With the rapid development of artificial intelligence technology, intelligent dolls, as intelligent devices integrating multi-modal interaction, are gradually becoming important carriers in the fields of children's companionship, education, etc. Intelligent dolls need to process multi-modal data such as speech, vision, and environmental perception in real time to achieve complex functions such as natural language interaction, visual recognition, and environmental adaptation. However, existing intelligent dolls face many challenges in the process of multi-modal data processing, resulting in system performance and user experience that are difficult to meet actual needs.

[0003] From the perspective of multi-modal data acquisition and processing, traditional intelligent dolls often adopt a single-modal data processing architecture, which cannot efficiently fuse multi-type data such as speech signal sequences, visual image sequences, and environmental sensor data streams. The asynchrony of different modal data in the time dimension makes the data fusion process prone to timing misalignment problems, which in turn affects the accuracy of subsequent task parsing. For example, the time synchronization deviation between voice commands and visual images may cause the doll to fail to correctly understand the user's composite commands.

[0004] In terms of task scheduling and resource management, existing systems lack refined task decomposition and dynamic resource allocation mechanisms. On the one hand, multi-modal data processing tasks usually include multiple parallel subtasks such as speech recognition, image analysis, and sensor data fusion. The traditional fixed-priority task scheduling method is difficult to flexibly adjust according to the real-time characteristics of tasks (such as timeliness, computational complexity), which is likely to cause delays in processing urgent tasks (such as sudden voice commands) and affect the real-time interaction. On the other hand, the resource allocation of edge computing nodes is often based on static configuration, and it cannot real-time perceive the node load status (such as memory capacity, processor occupancy) and the dynamic resource requirements of tasks (such as computational volume fluctuations), which may cause resource waste or tasks to be blocked due to insufficient resources.

[0005] In addition, the priority queue mechanism of existing systems lacks the ability to dynamically update, and it cannot optimize the scheduling strategy according to the historical data of task execution (such as average execution duration, resource consumption). With the diversification of the usage scenarios of intelligent dolls and the complexity of task types, the fixed-weight priority queue is likely to lead to a decline in scheduling efficiency after long-term operation of the system, and it is difficult to adapt to different users' usage habits and the dynamic changing environmental requirements. For example, in the education scenario, the complexity of interaction instructions for children of different ages is different, and fixed priorities may not be able to give priority to processing high-timeliness learning guidance tasks.

[0006] In terms of containerized deployment and isolation, the traditional process-level task execution method lacks an effective isolation mechanism, and resource competition and interference are likely to occur between different tasks. Especially when multiple tasks are processed in parallel, it may lead to a decline in system stability or even system crashes. At the same time, the configuration management of the runtime environment is rather cumbersome, and it is difficult to quickly provide customized execution environments for different types of tasks (such as specific acoustic model runtime environments required for speech recognition and computer vision library support required for image analysis), increasing the cost of system deployment and maintenance. Summary of the Invention

[0007] The purpose of the present invention is to provide a multi-modal data processing task scheduling optimization method and system for intelligent dolls to solve the problems raised in the above background technology.

[0008] To achieve the above purpose, the present invention provides the following technical solution: A multi-modal data processing task scheduling optimization system for intelligent dolls, the system includes: A multi-modal acquisition module, used to obtain multi-modal input data generated during the operation of the intelligent doll in real time; the multi-modal input data includes voice signal sequences, visual image sequences, and environmental sensor data streams; A task decomposition module, used to parse the multi-modal input data into K parallel processing tasks according to a preset task type mapping table; the task type mapping table contains the corresponding relationship between data modalities and computing tasks; A resource allocation module, used to allocate independent running container instances for each processing task based on the real-time load status of computing nodes; the container instances contain pre-configured runtime environments and computing resource quotas; A scheduling execution module, used to distribute the container instances to the corresponding edge computing nodes for operation according to a preset priority queue and synchronously receive the calculation result data; A dynamic update module, used to periodically adjust the execution weight coefficients of the priority queue according to the calculation result data.

[0009] Preferably, the task decomposition module includes: A feature extraction unit, used to perform time-frequency feature analysis on the voice signal sequence to generate a voice feature vector set; An image segmentation unit, used to perform dynamic object detection on the visual image sequence to generate an image region coordinate data set; A data fusion unit, used to align the voice feature vector set, the image region coordinate data set, and the environmental sensor data stream according to timestamps to generate a synchronous fusion data packet; A task generation unit, used to match the corresponding K processing tasks from the task type mapping table according to the data types of the synchronous fusion data packet.

[0010] Preferably, the resource allocation module includes: A node detection unit for obtaining the available memory capacity and processor occupancy rate of edge computing nodes in real time; A resource prediction unit for predicting the computing resource requirements of each processing task according to historical task execution time data; An instance configuration unit for generating container configuration parameters including memory upper limit and number of cores for each processing task according to the computing resource requirements; An instance deployment unit for creating isolated container instances on edge computing nodes with load status meeting the requirements according to the container configuration parameters.

[0011] Preferably, the scheduling execution module includes: A queue generation unit for generating a priority sorted list including emergency task identifiers according to task processing timeliness requirements; A distribution control unit for pushing container instances to the task execution queues of target edge computing nodes in sequence according to the priority sorted list; A status monitoring unit for capturing the execution status of container instances in real time and recording the task completion timestamp; A feedback receiving unit for receiving the computing result data returned by edge computing nodes through an asynchronous message channel.

[0012] Preferably, the dynamic update module includes: A weight calculation unit for counting the historical average execution duration and resource consumption of each task type; A coefficient adjustment unit for dynamically attenuating and compensating the task weight coefficients in the priority queue according to the historical average execution duration; A queue reconstruction unit for regenerating an optimized priority sorted list based on the updated weight coefficients.

[0013] Preferably, the present invention further includes a method for optimizing the scheduling of multi-modal data processing tasks for intelligent dolls, and the method includes: Obtaining in real time the multi-modal input data generated during the operation of the intelligent doll; the multi-modal input data includes a voice signal sequence, a visual image sequence, and an environmental sensor data stream; Parsing the multi-modal input data into K parallel processing tasks according to a preset task type mapping table; the task type mapping table includes the correspondence between data modalities and computing tasks; Allocating independent running container instances for each processing task based on the real-time load status of computing nodes; the container instances include a pre-configured runtime environment and computing resource quotas; Distribute the container instances to the corresponding edge computing nodes for operation according to the preset priority queue, and synchronously receive the calculation result data; Periodically adjust the execution weight coefficient of the priority queue according to the calculation result data.

[0014] Preferably, parsing the multimodal input data into K parallel processing tasks according to the preset task type mapping table specifically includes: Perform time-frequency feature analysis on the voice signal sequence to generate a voice feature vector set; Perform dynamic target detection on the visual image sequence to generate an image region coordinate data set; Align the voice feature vector set, the image region coordinate data set, and the environmental sensor data stream according to the time stamp to generate a synchronous fusion data packet; Match the corresponding K processing tasks from the task type mapping table according to the data type of the synchronous fusion data packet.

[0015] Preferably, allocating independent running container instances for each processing task based on the real-time load status of the computing nodes specifically includes: Obtain the available memory capacity and processor occupancy rate of the edge computing node in real time; Predict the computing resource requirements of each processing task according to the historical task execution time data; Generate container configuration parameters including the memory upper limit and the number of cores for each processing task according to the computing resource requirements; Create isolated container instances on the edge computing nodes whose load status meets the requirements according to the container configuration parameters.

[0016] Preferably, distributing the container instances to the corresponding edge computing nodes for operation according to the preset priority queue specifically includes: Generate a priority sorting list including emergency task identifiers according to the task processing timeliness requirements; Push the container instances to the task execution queue of the target edge computing node in sequence according to the priority sorting list; Capture the execution status of the container instance in real time and record the task completion time stamp; Receive the calculation result data returned by the edge computing node through the asynchronous message channel.

[0017] Preferably, periodically adjusting the execution weight coefficient of the priority queue according to the calculation result data specifically includes: Statistically analyze the historical average execution duration and resource consumption of each task type; Dynamically decay and compensate the task weight coefficients in the priority queue according to the historical average execution duration; Regenerate an optimized priority sorting list based on the updated weight coefficients.

[0018] Compared with the prior art, the beneficial effects of the present invention are as follows: At the multi-modal data processing level, the multi-modal acquisition module obtains voice, vision, and environmental sensor data in real time. The task decomposition module realizes the temporal alignment and refined analysis of multi-modal data through feature extraction, image segmentation, data fusion, and task generation units. For example, perform time-frequency feature analysis on voice signals to generate a set of feature vectors, perform dynamic target detection on visual images to generate a coordinate data set, and align them according to timestamps to generate synchronized fusion data packets, ensuring the consistency of different modal data in the time dimension, providing accurate input for subsequent task processing, effectively solving the problem of temporal misalignment in traditional multi-modal data fusion, and improving the accuracy and reliability of data processing.

[0019] In terms of task scheduling and resource management, the resource allocation module realizes the dynamic allocation and containerized deployment of computing resources through node detection, resource prediction, instance configuration, and instance deployment units. Real-time obtain the load status of edge computing nodes, combine historical task execution data to predict resource requirements, generate container configuration parameters including memory upper limit and core number for each task, and create isolated container instances on appropriate nodes. This dynamic resource allocation mechanism based on real-time load and task requirements avoids the problems of waste or insufficiency caused by static resource allocation, and improves resource utilization. At the same time, the isolation of container instances ensures that resources between different tasks do not interfere with each other, enhancing the stability and reliability of the system. For example, when processing voice interaction and visual tracking tasks simultaneously, it avoids resource competition between processes.

[0020] The scheduling and execution module realizes the priority scheduling and real-time monitoring of tasks through queue generation, distribution control, status monitoring, and feedback receiving units. Generate a priority sorting list including emergency task identifiers according to task timeliness, ensure that high-priority tasks (such as emergency voice commands) are executed first, and improve the real-time performance of interactions. The status monitoring unit captures the execution status of container instances in real time and records the completion timestamp. Combining with the feedback receiving unit to obtain calculation results through an asynchronous message channel, it realizes the real-time monitoring and data feedback of the entire process of task execution, facilitating the timely discovery and handling of abnormal situations during task execution, and ensuring the stable operation of the system.

[0021] In terms of the dynamic optimization mechanism, the dynamic update module realizes the dynamic optimization of the priority queue through the weight calculation, coefficient adjustment, and queue reconstruction units. It statistically analyzes the historical average execution duration and resource consumption of task types, dynamically decays and compensates the weight coefficients based on the execution duration, and regenerates an optimized priority sorting list. This dynamic adjustment mechanism based on historical data enables the system to automatically optimize the scheduling strategy according to the actual operating conditions and adapt to changes in different usage scenarios and task types. For example, in an educational scenario, if the average execution duration of a certain type of learning task is relatively long, the system will automatically adjust its weight coefficient to ensure that subsequent tasks of the same type can be more reasonably allocated resources and priorities, thereby improving the overall processing efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] Figure 1 FIG. is a working principle diagram of the multi-modal data processing task scheduling optimization system for intelligent dolls according to the present invention; Figure 2 FIG. is a working principle diagram of the scheduling execution module; Figure 3 FIG. is a flowchart of the multi-modal data processing task scheduling optimization method. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0023] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all of the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0024] Please refer to Figures 1 - 3 , a multi-modal data processing task scheduling optimization system for intelligent dolls according to the present invention. The system realizes the optimized scheduling of multi-modal data processing tasks during the operation of intelligent dolls through the collaborative work of a multi-modal acquisition module, a task decomposition module, a resource allocation module, a scheduling execution module, and a dynamic update module. The specific implementation steps are as follows: When the system is running, first, the multi-modal acquisition module obtains the multi-modal input data generated during the operation of the intelligent doll in real time. The multi-modal input data includes a voice signal sequence, a visual image sequence, and an environmental sensor data stream. The acquisition module can collect voice signals through a microphone array integrated in the intelligent doll, capture visual image sequences through a high-definition camera, obtain real-time environmental data streams through environmental sensors such as temperature and acceleration deployed on the doll body, and synchronously transmit various types of data to the task decomposition module at a preset frequency.

[0025] After receiving multi-modal input data, the task decomposition module parses it into K parallel processing tasks according to a preset task type mapping table. The task type mapping table is pre-stored in the system database and contains the correspondence between data modalities and computing tasks. For example, voice signals correspond to semantic understanding tasks, and visual images correspond to object recognition tasks, etc.

[0026] Based on the real-time load status of computing nodes, the resource allocation module assigns container instances for independent operation to each processing task. The container instances contain pre-configured runtime environments and computing resource quotas, such as Python runtime environments, CPU core number quotas, etc., to ensure that different tasks run in isolated containers and avoid resource conflicts.

[0027] The scheduling and execution module distributes the container instances to the corresponding edge computing nodes for operation according to a preset priority queue and synchronously receives the calculation result data. The priority queue is preset according to factors such as the timeliness requirements and resource demands of tasks. For example, the priority of an urgent voice interaction task is higher than that of a non-real-time environmental data statistics task.

[0028] The dynamic update module periodically adjusts the execution weight coefficients of the priority queue according to the calculation result data to adapt to the actual execution situation of different tasks and optimize the scheduling efficiency of subsequent tasks.

[0029] The technical solution of the present invention will be further described in detail below with reference to specific embodiments.

[0030] Embodiment 1: The task decomposition module of the system is further refined into a feature extraction unit, an image segmentation unit, a data fusion unit, and a task generation unit. Each unit realizes the parsing and task generation of multi-modal input data through orderly cooperation. The following are the specific implementation manners of each unit: The feature extraction unit is responsible for performing time-frequency feature analysis on the speech signal sequence and generating a set of speech feature vectors. The microphone array built into the intelligent doll continuously collects speech signals in the environment at a preset sampling rate (such as 16 kHz), forming a continuous speech signal sequence. The feature extraction unit first preprocesses the speech signal, including endpoint detection to remove the silent segments and pre-emphasis processing to enhance the energy of high-frequency signals. The preprocessed speech signal is segmented into multiple short-time frames (such as 25 ms per frame with a frame shift of 10 ms), and each short-time frame is windowed (such as Hamming window) to reduce spectral leakage. Subsequently, the speech signal of each short-time frame is transformed from the time domain to the frequency domain through the short-time Fourier transform (STFT) to obtain the corresponding spectral matrix. Based on the spectral matrix, the Mel-frequency cepstral coefficients (MFCC) are calculated. The specific steps are as follows: First, the linear frequency axis is transformed into the Mel frequency axis, and the spectrum is filtered through the Mel filter bank to obtain the Mel spectrum; then, the logarithm of the Mel spectrum is taken and the discrete cosine transform (DCT) is performed to extract the first 12 - 40 order coefficients as the MFCC feature parameters. In addition, auxiliary features such as fundamental frequency and short-time energy can also be extracted, and finally, a set of speech feature vectors containing multi-dimensional feature parameters is generated, with each vector corresponding to the feature representation of one frame of speech signal.

[0031] The function of the image segmentation unit is to perform dynamic object detection on the visual image sequence and generate a dataset of image region coordinates. The high-definition camera equipped on the intelligent doll collects visual images at a fixed frame rate (such as 30 fps), forming a continuous visual image sequence. The image segmentation unit uses a deep learning object detection algorithm (such as the YOLOv5 model) to process each frame of the image. First, the input image is scaled (such as scaled to 640×640 pixels) and normalized to meet the model input requirements. Then, the preprocessed image is input into the YOLOv5 network, which extracts the high-level semantic features of the image through the backbone feature extraction network (such as CSPDarknet), performs feature fusion through the neck network (such as FPN+PAN), and finally completes object classification and bounding box regression in the head network. For each detected object, its class label (such as "person", "toy"), bounding box coordinates (x1, y1, x2, y2, representing the upper left and lower right coordinates respectively), and confidence score are output. The image segmentation unit filters all the detected objects in each frame of the image, retains the objects with a confidence score higher than the preset threshold (such as 0.5), and generates a dataset of image region coordinates containing object classes, coordinates, and confidences. To meet the real-time processing requirements of the intelligent doll, the image segmentation unit can adopt model lightweight techniques (such as channel pruning, quantization) to reduce the computational complexity and ensure efficient operation on the edge computing node.

[0032] The role of the data fusion unit is to align the speech feature vector set, the image region coordinate data set, and the environmental sensor data stream according to timestamps and generate a synchronous fusion data packet. The environmental sensor data stream includes data collected by sensors such as temperature, acceleration, and gyroscope. Each sensor outputs data at its own sampling frequency (e.g., the temperature sensor at 1 Hz and the acceleration sensor at 100 Hz), and each piece of data carries the acquisition timestamp. The speech feature vector set and the image region coordinate data set also record the corresponding timestamps (such as the start time of the speech frame and the acquisition time of the image frame) when they are generated. The data fusion unit first establishes a time alignment buffer for storing data from the three modalities. For the speech feature vector, the start time of its corresponding speech frame is used as the timestamp; for the image region coordinate data, the acquisition time of the image frame is used as the timestamp; for the environmental sensor data, its actual acquisition time is used as the timestamp. Then, the data fusion unit traverses the data of each modality in chronological order. Based on the modality data with the smallest timestamp, interpolation or sampling is performed on the data of other modalities so that the three modalities of data have corresponding data items at the same time point. For example, if there are speech feature vectors and environmental sensor data at a certain moment but no image region coordinate data, the target coordinates at that moment are estimated by linear interpolation according to the image data at the previous and subsequent moments. The three modalities of data after alignment are encapsulated into a synchronous fusion data packet, which includes the timestamp, speech feature vectors, image region coordinates (if any), and environmental sensor data, providing a unified input format for subsequent task generation.

[0033] The core function of the task generation unit is to match the corresponding K processing tasks from the task type mapping table according to the data type of the synchronous fusion data packet. The task type mapping table is a predefined modality-task mapping relationship table stored in the non-volatile memory of the system and can be configured and updated through the management interface. Each record in the mapping table contains a data modality combination and the corresponding processing task type. For example: Single speech modality → Speech recognition task; Single vision modality → Image classification task; Speech + vision modality → Audio-visual interaction task; Speech + environmental sensor modality → Environmental perception speech feedback task; Vision + environmental sensor modality → Visual navigation task; Speech + vision + environmental sensor modality → Multimodal scene understanding task.

[0034] The task generation unit analyzes the modal composition of the synchronous fusion data packet. For example, if a data packet contains voice feature vectors, image region coordinates, and environmental temperature data, its modal combination is voice + vision + environmental sensor. Then, it looks up the matching modal combination in the task type mapping table. If there is a completely matching record, it generates the corresponding processing task (such as a multi-modal scene understanding task); if there is no completely matching record, it performs fuzzy matching according to the similarity of the modal combination. For example, it preferentially matches the record that contains more identical modalities. For each matching processing task, the task generation unit generates an independent task descriptor, which contains information such as task type, input data pointer, and priority identifier. Multiple task descriptors form K parallel processing tasks, which are transmitted to the resource allocation module through the task queue for subsequent processing. To ensure the accuracy of task generation, the task type mapping table can set a default task type. When no record can be matched, it generates a default general data processing task to avoid data loss.

[0035] In the overall operation process of the task decomposition module, each unit collaborates through the data buffer and the event-driven mechanism. The feature extraction unit and the image segmentation unit process voice and visual data respectively, and the generated feature vectors and coordinate data are stored in the shared data buffer in real time. The data fusion unit regularly reads data from the buffer, performs time alignment and fusion operations, and stores the generated synchronous fusion data packet in the task generation queue. The task generation unit monitors the task generation queue. Once a new data packet is detected, it immediately triggers the task matching and generation process. The whole process adopts a pipeline architecture design to ensure the real-time processing of multi-modal data and the task generation efficiency, and provides an accurate and orderly set of input tasks for subsequent resource allocation and task scheduling. Through the multi-dimensional feature analysis of the feature extraction unit, the efficient target detection of the image segmentation unit, the precise time alignment of the data fusion unit, and the flexible task matching of the task generation unit, the task decomposition module realizes the automatic conversion from the original multi-modal data to executable processing tasks, laying a solid foundation for the optimization of the multi-modal data processing task scheduling of the intelligent doll.

[0036] Embodiment 2: The implementation method of the resource allocation module involves the collaborative work of the node detection unit, the resource prediction unit, the instance configuration unit, and the instance deployment unit, and realizes the dynamic and reasonable allocation of computing resources through hierarchical processing. The following are the specific implementation methods of each unit: The node detection unit is responsible for real-time monitoring of the operating system interface of edge computing nodes, and obtaining real-time load status information such as the available memory capacity and processor occupancy rate of edge computing nodes. This unit triggers the monitoring process through a timed task (such as executing once every 500ms). First, it establishes a communication connection with the edge computing node. For Linux system nodes, it accesses the operating system of the node through the SSH protocol or RESTAPI interface. When obtaining the available memory capacity, the node detection unit reads the / proc / meminfo file, parses the MemFree and Buffers / Cached fields in it, and calculates the total current available memory. For example, MemFree represents the unused physical memory, Buffers represents the block device cache, and Cached represents the file system cache. The sum of the three is the actual available memory. When obtaining the processor occupancy rate, it uses the CPU time statistical information in the / proc / stat file. By calculating the ratio of the CPU idle time to the total time between two samplings, the CPU utilization rate is obtained. Specifically, it reads the cpu line data in the / proc / stat file, which contains time fields such as user, nice, system, idle, etc. The ratio of the change in idle time to the change in total time between two samplings is the CPU idle rate, and 1 minus the idle rate is the CPU occupancy rate. The node detection unit also obtains other system information, such as disk I / O status, network bandwidth utilization rate, etc. These information are used as auxiliary indicators to evaluate the overall load situation of the node. All monitoring data are encapsulated into a node status report, which contains fields such as node ID, timestamp, memory capacity, CPU occupancy rate, etc., and are sent to the resource prediction unit through a message queue.

[0037] The resource prediction unit predicts the computing resource requirements for each processing task based on historical task execution time data using time series analysis algorithms. This unit maintains a historical task execution database that records information such as the type of each completed task, the scale of input data, start time, end time, CPU usage duration, memory peak, etc. For newly received processing tasks, the resource prediction unit first filters out the execution records of similar historical tasks from the database according to the task type. For example, for speech recognition tasks, it filters out the execution data of all historical speech recognition tasks. Then, it uses time series analysis algorithms (such as the ARIMA model) to model and predict the historical execution time data. The specific steps are as follows: First, perform a stationarity test (such as the ADF test) on the historical execution time series. If the series is non-stationary, perform differencing to make it stationary. Then, determine the order (p, d, q) of the ARIMA model based on the autocorrelation function (ACF) and partial autocorrelation function (PACF) of the stationary series. Next, use the maximum likelihood estimation method to estimate the model parameters. Finally, use the trained model to predict the execution time of the current task. In addition to execution time prediction, the resource prediction unit also analyzes the resource consumption patterns of historical tasks. For example, speech recognition tasks usually require high CPU computing power, while image recognition tasks have greater demands for memory and GPU resources. Combining the scale of the task's input data (such as speech duration, image resolution), it predicts the CPU core requirements and memory space requirements for the current task. For example, for longer speech segments, it predicts that more CPU computing time and memory space are needed to complete the recognition. The prediction results are output in the form of resource requirement descriptors, including information such as predicted execution time, CPU core number requirements, memory space requirements, etc., and are transmitted to the instance configuration unit.

[0038] The instance configuration unit generates container configuration parameters including memory limits and the number of cores for each processing task according to the computing resource requirements. This unit receives the resource requirement descriptors output by the resource prediction unit, combines with the actual resource situation of the edge computing node, and generates an optimal container configuration plan. First, the instance configuration unit checks the total available resources of the edge computing node to ensure that the allocated resources do not exceed the node's carrying capacity. For example, if the available memory of a certain node is 8GB and the task prediction requires 10GB of memory, then the configuration needs to be adjusted or other nodes need to be selected. Then, according to the priority and resource requirements of the task, the memory limit and the number of CPU cores of the container are determined. For high-priority tasks, their resource requirements are preferentially met; for low-priority tasks, the configuration is appropriately reduced in case of resource tension. For example, for an urgent voice interaction task, 100% of its predicted memory requirement and 120% of its predicted CPU core number are allocated as a safety margin; for a non-urgent environmental data processing task, 80% of its predicted memory requirement and 90% of its predicted CPU core number are allocated. The instance configuration unit also considers the resource elasticity requirements of the task and sets resource limit and resource request parameters for the container. The resource limit parameter defines the maximum amount of resources that the container can use, preventing the container from overusing resources and affecting other tasks; the resource request parameter defines the amount of resources requested when the container starts, serving as a reference for the scheduler to allocate resources. For example, for a certain task, the memory limit is configured to be 2GB, the memory request is 1.5GB, the CPU limit is 2 cores, and the CPU request is 1 core. In addition, the instance configuration unit also generates other container configuration parameters, such as the container image address, environment variables, mount points, etc. These parameters together constitute a complete container configuration file, usually in JSON or YAML format, which is used to guide the creation and operation of the container.

[0039] The instance deployment unit creates isolated container instances on edge computing nodes where the load status meets the requirements according to the container configuration parameters. This unit receives the container configuration file generated by the instance configuration unit, combines it with the node status report provided by the node detection unit, and selects the most suitable edge computing node for container deployment. First, the instance deployment unit filters all available nodes, excluding nodes with excessive load or unavailability. For example, nodes with a CPU occupancy rate exceeding 80% or available memory lower than the task memory request are excluded. Then, among the remaining candidate nodes, the optimal node is selected according to the node load balancing strategy. The load balancing strategy can be based on various factors, such as the current load of the node, historical performance, network latency, etc. For example, select the node with the lowest CPU occupancy rate, or select the node with the minimum communication latency with the intelligent doll. Once the target node is selected, the instance deployment unit establishes a connection with the target node through the container engine API (such as Docker API) and sends a container creation request. The request contains the content of the container configuration file, instructing the container engine to create a container instance with specified resource limits and configuration parameters. After receiving the request, the container engine first pulls the required container image (if it does not exist locally), and then creates a container and starts the application according to the configuration parameters. The instance deployment unit monitors the container creation process to ensure that the container is successfully started and running properly. For containers that fail to be created, error messages are recorded and an attempt is made to redeploy them on other candidate nodes. After the container is successfully created, the instance deployment unit feeds back the running status of the container (such as container ID, running status, resource usage) to the scheduling execution module, and at the same time updates the node status report to reflect the latest load situation of the node.

[0040] In the overall operation process of the resource allocation module, data flow and collaborative work are achieved among units through message queues and status databases. The node detection unit regularly writes the node status report into the shared status database for other units to query. The resource prediction unit obtains historical task data and the current node status from the database, and sends the results to the instance configuration unit after executing the prediction algorithm. The instance configuration unit generates container configuration parameters according to the prediction results and passes them to the instance deployment unit through the message queue. The instance deployment unit deploys containers according to the configuration parameters and feeds back the deployment results to the scheduling execution module and updates the status database. The entire process adopts an asynchronous processing mode to ensure that each unit can operate independently and efficiently. Through the hierarchical processing of the resource allocation module, the system can dynamically and reasonably allocate computing resources according to the actual needs of tasks and the real-time status of nodes, realizing the optimal utilization of edge computing node resources and the efficient execution of multi-modal data processing tasks. The design of the resource allocation module fully considers the characteristics of the intelligent doll application scenario, such as limited edge computing resources, high task real-time requirements, multi-task concurrent execution, etc. Through refined resource management and scheduling, it provides a stable and efficient computing support environment for the intelligent doll.

[0041] Example 3: The implementation of the scheduling and execution module covers the collaborative operation of a queue generation unit, a distribution control unit, a status monitoring unit, and a feedback receiving unit, and realizes the orderly distribution, real-time monitoring, and result reception of tasks through a process-based design. The following are the specific implementation methods of each unit: The core function of the queue generation unit is to generate a priority sorted list containing emergency task identifiers according to the timeliness requirements of task processing. The system pre-defines timeliness tags for each task type in the task type mapping table. For example, the voice interaction task is marked as a "real-time task" with a required response time of less than 200 ms; the environmental data storage task is marked as a "non-real-time task" with an allowed response time within 5 s. When the task generation unit outputs K parallel processing tasks, each task descriptor already contains the corresponding task type information. The queue generation unit parses the task descriptor, obtains the timeliness tag of the task from the task type mapping table, and assigns a priority level to the task according to the preset priority rules. The priority rules can be set as follows: real-time tasks have a higher priority than quasi-real-time tasks, and quasi-real-time tasks are higher than non-real-time tasks; within the same timeliness level, the priority is adjusted according to the task data volume, and tasks with a smaller data volume are processed first.

[0042] In specific implementation, the queue generation unit maintains a priority rule configuration table, for example: Real-time tasks (such as speech recognition, emergency control instructions) → Priority level 1 (highest); Quasi-real-time tasks (such as image target tracking, environmental parameter warning) → Priority level 2; Non-real-time tasks (such as historical data statistics, firmware upgrade) → Priority level 3 (lowest).

[0043] For each task, the queue generation unit first determines whether it is an emergency task. Emergency tasks are usually triggered by timeliness tags or specific task types (such as fault alarm tasks). For example, when the task type is "collision detection alarm", it is automatically marked as an emergency task, given the highest priority, and inserted at the top of the priority sorted list. Non-emergency tasks are sorted according to the priority level and data volume. The data volume is measured by the number of bytes or feature dimensions of the task input data, such as the dimension of the voice feature vector set, the number of targets in the image region coordinate data set, etc. The queue generation unit uses a quick sorting algorithm (such as heap sorting) to sort the tasks, generating a priority sorted list containing fields such as task ID, priority level, emergency task identifier (yes / no), and data volume. This list is stored in a linked list structure for easy subsequent access and deletion of processed tasks by the distribution control unit.

[0044] The distribution control unit is responsible for pushing container instances to the task execution queue of the target edge computing node in sequence according to the priority sorted list. This unit interacts with the queue generation unit through shared memory or message queue to obtain the latest priority sorted list in real time. The distribution control process is as follows: First, the distribution control unit extracts the container instance information corresponding to the task with the highest priority from the priority sorted list, including container configuration parameters, target edge computing node list (pre-specified by the resource allocation module), etc. Then, it establishes a communication connection with the target node through a message middleware (such as RabbitMQ). The message middleware supports the publish-subscribe mode to ensure the reliability and asynchrony of task distribution.

[0045] When pushing a container instance, the distribution control unit serializes the container configuration parameters into binary data (such as using the ProtocolBuffers format) and transmits them over the network to the task execution queue of the target node. The task execution queue is a first-in-first-out (FIFO) queue maintained locally by the edge computing node and is used to temporarily store container instances to be executed. To avoid network congestion, the distribution control unit sets a sending rate limit. For example, it can push at most 5 container instances per second to a single node. For urgent tasks, the distribution control unit adopts a preemptive strategy, that is, it interrupts the currently being pushed non-urgent tasks and preferentially sends the container instances of urgent tasks to ensure the timeliness of urgent tasks.

[0046] In addition, the distribution control unit maintains a task distribution log, recording information such as the push time, target node, and task priority of each container instance for subsequent troubleshooting and performance analysis. If a network interruption or node unreachability occurs during the push process, the distribution control unit re-adds the task to the priority sorted list and marks it as the "undelivered" state, waiting for the next round of distribution attempts. When the number of retries exceeds a preset threshold (such as 3 times), an error report is generated and sent to the system management module to trigger the manual intervention process.

[0047] The main responsibility of the status monitoring unit is to capture the execution status of container instances in real time and record the task completion timestamp. This unit interacts with the edge computing node through the status monitoring interface provided by the container engine (such as Docker's events API or crictl command) to obtain the life cycle events of container instances in the form of streaming data, including status changes such as "created", "started", "running", "paused", "exited", "failed", etc. For each container instance, the status monitoring unit maintains a status tracking table, recording information such as container ID, task ID, current status, status change time, and cumulative running duration.

[0048] During the task execution process, the status monitoring unit polls the container status of the edge computing nodes regularly (e.g., every 100 ms) to ensure that status changes are captured in a timely manner. When it detects that the container status changes to "exited" or "failed", the status monitoring unit immediately records the task completion timestamp or failure timestamp and analyzes the failure reasons (such as insufficient memory, high CPU occupancy, application crash, etc.). For failed tasks, the status monitoring unit marks their status as "execution failed", writes the failure reasons into the task log, and notifies the distribution control unit to reschedule the task (if a retry policy is configured).

[0049] To reduce the monitoring overhead, the status monitoring unit adopts an event-driven mechanism, triggering data updates only when the container status changes, rather than continuously polling all containers. At the same time, the status monitoring unit supports parallel monitoring of multiple edge computing nodes, achieving status capture in high-concurrency scenarios through multi-threading or asynchronous I / O technologies. The monitoring data is transmitted to the system core module in real-time through a message queue for use by the scheduling execution module and the dynamic update module. For example, the dynamic update module can adjust the weight coefficients of the priority queue according to the task execution status.

[0050] The feedback receiving unit receives the calculation result data returned by the edge computing nodes through an asynchronous message channel. The asynchronous message channel adopts a non-blocking communication mode, implemented based on the HTTP long connection or WebSocket protocol, ensuring that the calculation results can be obtained in a timely manner without blocking the system main thread. After the edge computing node completes the operation of the container instance, it serializes the calculation result data (such as in JSON format) and sends it to the feedback receiving unit through the message channel.

[0051] The format of the calculation result data is related to the task type. For example: Speech recognition task → return a text string (such as "Hello, I'm a smart doll"); Image target tracking task → return a sequence of target coordinates (such as [[x1,y1,t1],[x2,y2,t2],…]); Environmental data processing task → return statistical values (such as "Temperature: 25℃, Humidity: 60%").

[0052] After receiving the data, the feedback receiving unit first performs integrity verification, ensuring that the data has not been lost or damaged during transmission by verifying fields such as the data length and checksum. After passing the verification, the calculation result data is routed to the business logic module of the smart doll according to the task ID. For example, the speech recognition result is sent to the dialogue management module, and the image tracking result is sent to the motion control module. For data that fails the verification, the feedback receiving unit records an error log and requests the edge computing node to resend the result (if a retransmission mechanism is configured).

[0053] To handle the return of calculation results in high-concurrency scenarios, the feedback receiving unit adopts the thread pool technology, allocating independent processing threads for each message channel connection to avoid blocking problems caused by single-threaded processing. At the same time, the system sets up a result cache queue to cache calculation results that cannot be processed temporarily, preventing system crashes caused by data backlogs. The cache queue is designed with a finite length. When the queue is full, old data is discarded according to the first-in-first-out principle, and discard logs are recorded for system optimization reference.

[0054] The four units of the scheduling and execution module cooperate closely through data links and control logic to form a complete task scheduling and execution process: ① The queue generation unit generates a priority sorted list based on task timeliness and data volume, triggering the task push process of the distribution control unit; ② The distribution control unit pushes the container instances to the edge computing nodes in the order of priority, and at the same time updates the task tracking information of the status monitoring unit; ③ The status monitoring unit captures the container status in real time, and triggers the data receiving process of the feedback receiving unit when the task is completed; ④ The feedback receiving unit obtains the calculation results and routes them to the business module, and at the same time feeds back the task completion information to the dynamic update module for adjusting the priority queue weights.

[0055] In the actual application scenario of the intelligent doll, for example, when the user has a voice interaction with the doll, the queue generation unit marks the speech recognition task as an urgent task, and the distribution control unit preferentially pushes its container instance to the edge node with stronger computing power. The status monitoring unit tracks the task execution status in real time. When it detects that the task is successfully completed, the feedback receiving unit immediately obtains the recognition result and transmits it to the dialogue module to drive the doll to make a real-time response. At the same time, the status monitoring unit records the task completion timestamp and resource consumption data, providing an optimization basis for the dynamic update module. The whole process ensures the efficient and reliable execution of multi-modal data processing tasks in the edge computing environment through modular design and asynchronous communication mechanism, meeting the strict requirements of the intelligent doll for real-time performance and stability.

[0056] Embodiment 4: The implementation method of the dynamic update module consists of a weight calculation unit, a coefficient adjustment unit, and a queue reconstruction unit, realizing the adaptive update of the priority queue through periodic data statistics, coefficient adjustment, and queue optimization. The following are the specific implementation methods of each unit: The core function of the weight calculation unit is to calculate the historical average execution duration and resource consumption of each task type. This unit maintains a historical task database that stores detailed information about all completed tasks over a certain period in the past (such as the most recent 24 hours). Each record contains fields such as task type, execution start time, execution end time, CPU core usage duration, peak memory occupancy, and data input scale. The database uses a time series database (such as InfluxDB) for storage to support efficient time series data querying and statistical analysis.

[0057] The specific process of weight calculation is as follows: First, the weight calculation unit groups the historical task records according to the task type. For example, all speech recognition tasks are grouped into one group, and image recognition tasks are grouped into another group. For each task group, the following statistical operations are performed: Extract the time difference between the execution end time and start time of all tasks in this group, and calculate the arithmetic mean to obtain the historical average execution duration of this task type. For example, a task group contains 1000 speech recognition task records, and the total execution time is 500000 ms, then the average execution duration is 500 ms.

[0058] CPU core usage duration: Accumulate the CPU core usage duration of each task (such as the number of CPU cores in each task record multiplied by the execution time), and then divide by the number of tasks to obtain the average CPU core usage duration of this task type. For example, the total CPU core usage duration of 1000 tasks is 300000 ms·core, then the average CPU core usage duration is 300 ms·core.

[0059] Peak memory occupancy: Extract the peak memory occupancy of all tasks in this group, and calculate the median or average value as the average peak memory occupancy of this task type. Using the median can reduce the impact of outliers on the statistical results. For example, if the memory peak data is [1.2 GB, 1.5 GB, 1.8 GB, 2.0 GB, 10 GB], then the median is 1.8 GB, which can better reflect the memory consumption under normal circumstances.

[0060] The weight calculation unit triggers the statistical process regularly (such as every 10 minutes) to ensure the timeliness of historical data. The statistical results are stored in a hash table in memory with the task type as the key, including fields such as average execution duration, average CPU core usage duration, and average peak memory occupancy, for quick query and use by the coefficient adjustment unit.

[0061] The coefficient adjustment unit dynamically compensates for the decay of the task weight coefficients in the priority queue according to the historical average execution duration output by the weight calculation unit. The system pre-defines a set of weight coefficient adjustment rules, which are based on the comparison result between the average execution duration of the task type and the preset reference value to achieve quantitative adjustment of the weight coefficients. The specific design of the adjustment rules is as follows: a. Reference value setting: Preset an ideal execution duration reference value (T_base) for each task type, which is determined according to the timeliness requirements of the task and the average processing capacity of the edge computing node. For example, the reference value for the speech recognition task is set to 400 ms, and the reference value for the image recognition task is set to 800 ms.

[0062] b. Deviation calculation: For each task type, calculate the deviation rate (ΔT) between its historical average execution duration (T_avg) and the reference value. The formula is: ΔT = (T_avg - T_base) / T_base × 100%. If ΔT is positive, it means that the actual execution duration exceeds the reference value; if ΔT is negative, it means that the actual execution duration is better than the reference value.

[0063] c. Decay compensation strategy: When ΔT > 0 (execution duration is too long): Decay the weight coefficient according to the deviation rate, and the decay amplitude is proportional to the deviation rate. For example, it is set that for every 10% exceeding the reference value, the weight coefficient decays by 5%. Suppose the ΔT of a certain task type is 20%, then the weight coefficient decays from the initial value of 1.0 to 1.0×(1 - 20% / 10%×5%) = 0.9.

[0064] When ΔT < 0 (execution duration is too short): Compensate and increase the weight coefficient according to the deviation rate, and the increase amplitude is proportional to the absolute value of the deviation rate. For example, it is set that for every 10% lower than the reference value, the weight coefficient increases by 3%. If the ΔT of a certain task type is -15%, then the weight coefficient increases to 1.0×(1 + 15% / 10%×3%) = 1.045.

[0065] d. Boundary limit: To prevent excessive fluctuations in the weight coefficient, set the value range of the weight coefficient (such as 0.5 ≤ weight coefficient ≤ 2.0). When the calculated coefficient exceeds this range, take the boundary value as the final adjustment result.

[0066] When the coefficient adjustment unit performs the adjustment, it traverses all task types in the priority queue and updates the weight coefficient according to their corresponding deviation rates and adjustment rules. The adjusted weight coefficients are stored in the system's shared configuration center in real time for access by the queue reconstruction unit and the queue generation unit.

[0067] The queue reconstruction unit regenerates an optimized priority sorted list based on the updated weight coefficients. The core logic of priority sorting is to combine the weight coefficients of task types with the real-time attributes of tasks (such as data volume and urgency) to form a comprehensive priority score. The specific implementation steps are as follows: ① Comprehensive score calculation: For each task type, define the comprehensive priority score formula as: Score = Weight coefficient × Priority level coefficient × Urgency coefficient × Data volume adjustment factor Priority level coefficient: Assign values according to the timeliness level of the task type (for example, the real-time task level coefficient is 3, quasi-real-time is 2, and non-real-time is 1).

[0068] Urgency coefficient: Assign 1.5 to urgent tasks and 1.0 to non-urgent tasks.

[0069] Data volume adjustment factor: Adjust according to the size of the task input data volume. For every 10% increase in the data volume, the factor is multiplied by 0.95 (indicating that the priority of tasks with large data volumes is slightly reduced to avoid blocking small tasks).

[0070] ② Task sorting: The queue reconstruction unit sorts all tasks to be processed in descending order of the comprehensive score. The sorting algorithm uses a stable sorting algorithm (such as merge sort) to ensure that tasks with the same score maintain their original order and avoid affecting the scheduling stability due to sorting jitter.

[0071] ③ Insertion of urgent tasks: In the sorted list, check if there are newly arrived urgent tasks. If so, directly insert the urgent tasks at the top of the list and adjust the order of other tasks to ensure that urgent tasks are executed first.

[0072] ④ Queue persistence: The reconstructed priority sorted list is stored in a circular buffer in memory, supporting fast insertion, deletion, and query operations. At the same time, the key information of the list (such as task ID and priority score) is periodically synchronized to the disk database to prevent the loss of queue information caused by system power failure.

[0073] The three units of the dynamic update module achieve closed-loop optimization through data transfer and rule-driven. The specific process is as follows: ① Data collection and statistics: The weight calculation unit regularly extracts data from the historical task database, calculates the average execution duration and resource consumption of each task type, and updates them to the in-memory hash table.

[0074] ② Coefficient adjustment and rule application: The coefficient adjustment unit adjusts the weight coefficients of task types according to the deviation between the average execution duration and the benchmark value, and applies preset rules to ensure that the weight coefficients reflect the actual execution efficiency of tasks.

[0075] ③Queue Reconstruction and Priority Update: The queue reconstruction unit recalculates the comprehensive priority score of tasks based on the new weight coefficients and real-time task attributes, generating an optimized priority sorted list for the distribution control unit of the scheduling execution module to use.

[0076] ④Feedback and Iteration: The adjusted priority queue generates new execution data during the task scheduling process. These data are collected again by the weight calculation unit, forming a closed-loop iterative process of "statistics - adjustment - reconstruction - feedback", enabling the priority queue to continuously adapt to changes in system load and task characteristics.

[0077] In the actual operation scenario of the intelligent doll, for example, when the doll enters a darker environment, the average execution duration of the visual image recognition task may increase due to increased image noise. The weight calculation unit detects that the average execution duration of this task type exceeds the benchmark value, and the coefficient adjustment unit attenuates its weight coefficient according to the deviation rate. After the queue reconstruction unit reorders, the priority of the visual task decreases, and the system will preferentially schedule the voice interaction task with a shorter execution duration to ensure the doll's real-time response to user instructions. As the environmental light improves, the execution duration of the visual task shortens, the weight coefficient gradually rebounds, and the priority returns to normal. Through the continuous optimization of the dynamic update module, the system can automatically adjust the scheduling strategy under the condition of multi-modal task load fluctuations, balance task timeliness and resource utilization rate, and improve the stability and response ability of the overall data processing system of the intelligent doll.

[0078] Data Consistency: The weight calculation unit and the coefficient adjustment unit ensure the consistency of statistical data during the adjustment process through atomic operations and lock mechanisms, avoiding data errors caused by concurrent access.

[0079] Adjustment Frequency Control: The period of the dynamic update module is set to be more than 10 times the average task execution duration (such as 10 minutes) to avoid queue instability caused by overly frequent adjustments.

[0080] Fault Tolerance Mechanism: If the weight calculation unit cannot obtain historical data (such as database failure), the default weight coefficient (initial value is 1.0) is used for queue reconstruction to ensure that the system will not crash due to data loss.

[0081] Example 5: The implementation method of the dynamic load balancing module consists of a resource monitoring unit, a load prediction unit, a migration decision unit, and an execution control unit. Through real-time resource monitoring, load trend prediction, intelligent migration decision-making, and precise execution control, it realizes the dynamic load balance among edge computing nodes. The following are the specific implementation methods of each unit: The resource monitoring unit obtains the CPU, memory, and network bandwidth usage of each edge computing node in real time through the monitoring API of the container orchestration platform. This unit uses a timed polling mechanism (such as once every 30 seconds) to establish a connection with the API servers of container orchestration platforms such as Kubernetes and DockerSwarm, and sends resource query requests. For each edge computing node, the following key metrics are obtained: CPU usage rate (calculated by accumulating the CPU time of all containers on the node), memory usage rate (percentage of physical memory used), and network bandwidth utilization rate (inbound and outbound traffic rates). At the same time, the resource monitoring unit also collects fine-grained metrics at the container level, such as the CPU limit, memory request, and network IOPS of a single container. To reduce the amount of data transmission, the monitoring data uses an incremental update method, and only transmits the metric data whose change exceeds the threshold (such as 5%). All monitoring data is stored in a time series database (such as Prometheus), and the historical data of the last 7 days is retained for trend analysis and anomaly detection.

[0082] Based on historical monitoring data, the load prediction unit uses time series analysis algorithms to predict the load trends of each edge computing node within the next 30 minutes. This unit extracts the historical resource usage data of each node from the time series database and performs data preprocessing, including missing value filling (using linear interpolation method) and outlier smoothing (using a moving average filter). Then, ARIMA (Autoregressive Integrated Moving Average Model) is applied to model the preprocessed data. The specific steps are as follows: First, perform a stationarity test (ADF test), and if the sequence is non-stationary, perform differencing; then determine the model order (p, d, q) according to the autocorrelation function (ACF) and partial autocorrelation function (PACF); finally, use the maximum likelihood estimation method to fit the model parameters. For the prediction results, calculate the 95% confidence interval to evaluate the uncertainty of the prediction. In addition to the ARIMA model, the load prediction unit also supports deep learning models such as LSTM (Long Short-Term Memory Network). For load patterns with obvious periodicity (such as high during weekdays during the day and low at night), more accurate prediction results can be obtained. The prediction results include the predicted values of CPU usage rate, memory usage rate, and network bandwidth utilization rate at 5-minute intervals within the next 30 minutes.

[0083] The migration decision-making unit decides whether to migrate a container instance and to which target node based on the load prediction results and a cost-benefit analysis model. This unit maintains a migration cost assessment model that takes into account the following factors: the service interruption time caused by container migration (related to the container memory size and the number of network connections), the remaining resources of the target node, and the network latency between the source node and the target node. For each edge computing node, the migration decision-making unit calculates its load pressure index (LPI) using the formula: LPI = α × predicted CPU usage rate + β × predicted memory usage rate + γ × predicted network bandwidth usage rate, where α, β, and γ are weight coefficients (default values are 0.4, 0.4, and 0.2 respectively). When the LPI of a certain node exceeds a threshold (such as 0.8), the container migration process is triggered. When selecting a target node, the migration decision-making unit adopts a multi-objective optimization algorithm to minimize both the migration cost and the load balance degree. The specific steps are as follows: First, filter out candidate nodes whose remaining resources meet the container resource requests; then calculate the migration benefit of each candidate node (the decrease in the source node's LPI - the increase in the target node's LPI); finally, select the node with the largest migration benefit and the lowest migration cost as the target node. For migration decisions, a two-level confirmation mechanism is adopted: First, the algorithm generates a recommended migration plan, and then it is submitted to manual review (which can be executed automatically in case of emergency).

[0084] The execution control unit is responsible for safely migrating the container instance and updating the resource allocation according to the results of the migration decision-making unit. This unit uses the API of the container orchestration platform to perform the migration operation and adopts a rolling update strategy to ensure service continuity. The specific process is as follows: First, create a new container instance with the same configuration as the source container on the target node, wait for the new container to start and complete initialization; then gradually switch the client traffic from the source container to the new container (achieved through a load balancer or a service discovery mechanism); finally, after confirming that the new container is running normally, stop and delete the source container. During the migration process, the execution control unit monitors the service availability and performance metrics in real time. If any abnormalities are found (such as the request success rate drops by more than 10%), it immediately rolls back to the source container. After the migration is completed, the execution control unit updates the resource monitoring data and the load prediction model, incorporates the new node resource usage into the historical data, and adjusts the prediction model parameters to improve the future prediction accuracy. In addition, the execution control unit also records detailed migration logs, including the migration time, the migrated container information, the source node and target node information, the resource usage before and after migration, etc., for subsequent analysis and auditing purposes.

[0085] In the overall operation process of the dynamic load balancing module, the resource monitoring unit continuously collects the resource usage data of edge computing nodes. The load prediction unit predicts the future load trend based on this data. The migration decision unit formulates a container migration plan according to the prediction results, and the execution control unit is responsible for implementing the migration safely and efficiently. The four units form a closed-loop feedback system, continuously adjusting the load distribution according to real-time changes. For example, when the CPU usage rate of a certain edge computing node continuously increases due to processing a large number of visual recognition tasks, the load prediction unit predicts that its LPI will exceed the threshold after 15 minutes. The migration decision unit plans in advance to migrate some non-critical containers to other nodes. The execution control unit performs the migration operation during the low peak period to ensure that the service is not affected. Through this dynamic adjustment, the system can improve resource utilization while maintaining service availability, and avoid the situation where some nodes are overloaded while other nodes have idle resources. The design of the entire module fully considers the characteristics of the edge computing environment, such as limited node resources and unstable network connections. Through the prediction-driven proactive migration strategy, it can effectively cope with the dynamic changes of multi-modal data processing tasks and improve the overall performance and reliability of the intelligent doll system.

[0086] It should be noted that in this article, relational terms such as first and second are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, article or device comprising a series of elements not only includes those elements, but also includes other elements not expressly listed, or further includes elements inherent to such process, method, article or device.

[0087] Although the embodiments of the present invention have been shown and described, those of ordinary skill in the art can understand that various changes, modifications, substitutions and variations can be made to these embodiments without departing from the principles and spirit of the present invention. The scope of the present invention is defined by the appended claims and their equivalents.

Claims

1. A multi-modal data processing task scheduling optimization system for intelligent dolls, characterized in that, The system includes: A multimodal acquisition module for real-time acquisition of multimodal input data generated during the operation of the intelligent doll; the multimodal input data includes a voice signal sequence, a visual image sequence, and an environmental sensor data stream; A task decomposition module for parsing the multimodal input data into K parallel processing tasks according to a preset task type mapping table; the task type mapping table contains the correspondence between data modalities and computing tasks; A resource allocation module for allocating independent running container instances for each processing task based on the real-time load status of the computing nodes; the container instances contain pre-configured runtime environments and computing resource quotas; A scheduling execution module for distributing the container instances to the corresponding edge computing nodes for operation according to a preset priority queue and synchronously receiving the calculation result data; A dynamic update module for periodically adjusting the execution weight coefficients of the priority queue according to the calculation result data.

2. The multi-modal data processing task scheduling optimization system for intelligent dolls according to claim 1, wherein The task decomposition module includes: A feature extraction unit for performing time-frequency feature analysis on the voice signal sequence to generate a voice feature vector set; An image segmentation unit for performing dynamic object detection on the visual image sequence to generate an image region coordinate data set; A data fusion unit for aligning the voice feature vector set, the image region coordinate data set, and the environmental sensor data stream according to timestamps to generate a synchronous fusion data packet; A task generation unit for matching the corresponding K processing tasks from the task type mapping table according to the data type of the synchronous fusion data packet.

3. The multimodal data processing task scheduling optimization system for intelligent dolls according to claim 1, wherein The resource allocation module includes: A node detection unit for real-time acquisition of the available memory capacity and processor occupancy rate of the edge computing nodes; A resource prediction unit for predicting the computing resource requirements of each processing task according to historical task execution time data; An instance configuration unit for generating container configuration parameters including memory upper limits and core numbers for each processing task according to the computing resource requirements; An instance deployment unit for creating isolated container instances on edge computing nodes with load status meeting the requirements according to the container configuration parameters.

4. The multi-modal data processing task scheduling optimization system for intelligent dolls according to claim 1, characterized in that, The scheduling execution module includes: A queue generation unit for generating a priority sorted list including emergency task identifiers according to task processing timeliness requirements; A distribution control unit for sequentially pushing the container instances to the task execution queue of the target edge computing node according to the priority sorted list; A status monitoring unit for real-time capturing the execution status of the container instances and recording the task completion timestamps; A feedback receiving unit for receiving the calculation result data returned by the edge computing nodes through an asynchronous message channel.

5. The multi-modal data processing task scheduling optimization system for intelligent dolls according to claim 4, wherein, The dynamic update module includes: A weight calculation unit for statistically calculating the historical average execution duration and resource consumption of each task type; A coefficient adjustment unit for dynamically attenuating and compensating the task weight coefficients in the priority queue according to the historical average execution duration; A queue reconstruction unit for regenerating an optimized priority sorted list based on the updated weight coefficients.

6. A multi-modal data processing task scheduling optimization method for intelligent dolls, characterized in that, The method includes: Obtain the multi-modal input data generated during the operation of the intelligent doll in real time; the multi-modal input data includes a voice signal sequence, a visual image sequence, and an environmental sensor data stream; Parse the multi-modal input data into K parallel processing tasks according to a preset task type mapping table; the task type mapping table contains the correspondence between data modalities and computing tasks; Allocate independent running container instances for each processing task based on the real-time load status of the computing nodes; the container instances contain pre-configured runtime environments and computing resource quotas; Distribute the container instances to the corresponding edge computing nodes for operation according to a preset priority queue, and synchronously receive the calculation result data; Periodically adjust the execution weight coefficients of the priority queue according to the calculation result data.

7. The multi-modal data processing task scheduling optimization method for intelligent dolls according to claim 6, characterized in that, The parsing of the multi-modal input data into K parallel processing tasks according to the preset task type mapping table specifically includes: Perform time-frequency feature analysis on the voice signal sequence to generate a voice feature vector set; Perform dynamic object detection on the visual image sequence to generate an image region coordinate data set; Align the voice feature vector set, the image region coordinate data set, and the environmental sensor data stream according to timestamps to generate a synchronous fusion data packet; Match the corresponding K processing tasks from the task type mapping table according to the data type of the synchronous fusion data packet.

8. The multimodal data processing task scheduling optimization method for intelligent dolls according to claim 6, wherein The allocation of independent running container instances for each processing task based on the real-time load status of the computing nodes specifically includes: Obtain the available memory capacity and processor occupancy rate of the edge computing nodes in real time; Predict the computing resource requirements of each processing task according to the historical task execution time data; Generate container configuration parameters including memory upper limit and core number for each processing task according to the computing resource requirements; Create isolated container instances on the edge computing nodes whose load status meets the requirements according to the container configuration parameters.

9. The multi-modal data processing task scheduling optimization method for intelligent dolls according to claim 6, characterized in that, The distribution of the container instances to the corresponding edge computing nodes for operation according to the preset priority queue specifically includes: Generate a priority sorting list including emergency task identifiers according to the requirements of task processing timeliness; Push the container instances to the task execution queue of the target edge computing node in sequence according to the priority sorting list; Capture the execution status of the container instances in real time and record the task completion timestamps; Receive the calculation result data returned by the edge computing node through an asynchronous message channel.

10. The multi-modal data processing task scheduling optimization method for intelligent dolls according to claim 9, wherein, The periodic adjustment of the execution weight coefficients of the priority queue according to the calculation result data specifically includes: Statistical analysis of the historical average execution duration and resource consumption of each task type; Perform dynamic decay compensation on the task weight coefficients in the priority queue according to the historical average execution duration; Regenerate an optimized priority sorting list based on the updated weight coefficients.

Images