Robot-based task processing method and device, computer equipment and medium

Abstract

The invention belongs to the technical field of artificial intelligence, and relates to a robot-based task processing method and device, computer equipment and a medium, and the method comprises the steps: carrying out the demand analysis of a task instruction, and obtaining task demand data; analyzing the task demand data and the collected hardware state data and environment characteristic data of the robot to generate a demand instruction; performing module splitting and priority ranking processing on a core algorithm of the robot based on the demand instruction to obtain a modular algorithm structure and priority data corresponding to the sub-modules; optimizing the modular algorithm structure based on the priority data and a strategy library to obtain a target modular algorithm structure; generating a resource allocation scheme based on the target modular algorithm structure and the hardware resource condition; and performing task execution processing based on the target modular algorithm structure and the resource allocation scheme. The task processing method and device can be applied to task processing scenes in the financial science and technology field and the digital medical field, and the task processing accuracy can be improved through the task processing method and device.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology and can be applied to fields such as fintech and digital healthcare, particularly to robot-based task processing methods, devices, computer equipment, and storage media. Background Technology

[0002] In existing robot algorithm deployment technologies, algorithm lightweighting is often completed all at once before robot deployment, typically using methods such as model pruning and quantization to fix algorithm parameters. While this fixed-parameter approach can reduce algorithm complexity and improve deployment efficiency to some extent, it cannot dynamically adjust based on the robot's actual operating state after deployment. Because the actual operating environment of robots is complex and variable, and the performance requirements of algorithms differ significantly in different scenarios, fixed algorithm parameters are difficult to adapt to diverse operational needs. This leads to a sharp drop in the accuracy of the robot when performing tasks, severely impacting the task execution effect and quality.

[0003] In the financial and insurance sector, taking insurance risk assessment robots as an example, traditional methods involve a one-time optimization of the risk assessment algorithm with fixed parameters before deployment. However, in real-world insurance scenarios, a customer's risk profile changes dynamically over time and with varying market conditions. For instance, a customer's risk level may change after purchasing insurance due to changes in occupation or health status. Because the robot's algorithm parameters are fixed, it cannot adjust its assessment strategy in a timely manner and continues to perform risk assessments based on the initial parameters. This results in significant discrepancies between the assessment results and the actual situation, failing to provide insurance companies with accurate risk references and impacting reasonable pricing and risk management in the insurance business.

[0004] In the field of digital healthcare, similar problems exist, exemplified by medical analytics robots. After lightweighting and fixing parameters of medical analytics algorithms before deployment, these robots struggle to dynamically adjust their algorithms based on new data and features generated during the actual analysis process, especially when faced with the complex and ever-changing conditions of different patients. For instance, for patients with rare diseases or rapidly progressing conditions, fixed algorithm parameters may fail to accurately identify disease characteristics, leading to inaccurate medical analysis results, delaying treatment, and reducing the quality of healthcare services.

[0005] Therefore, there is an urgent need for a task processing method that can improve the accuracy and adaptability of robots in performing tasks after deployment. Summary of the Invention

[0006] The purpose of this application is to provide a robot-based task processing method, apparatus, computer device, and storage medium to solve the technical problem of low accuracy in existing robots when performing tasks.

[0007] Firstly, a robot-based task processing method is provided, including: Receive the task instruction corresponding to the task to be processed, and perform requirement parsing on the task instruction to obtain the corresponding task requirement data; Collect hardware status data of the robot, as well as current environmental characteristic data; Based on a preset requirement modeling engine, the task requirement data, hardware status data, and environmental feature data are analyzed and processed to generate corresponding requirement instructions. Based on the aforementioned requirements, the core algorithm of the robot is modularized and prioritized to obtain modular algorithm structures and priority data corresponding to the sub-modules; wherein, the number of sub-modules includes multiple modules. The modular algorithm structure is optimized based on the priority data and the preset strategy library to obtain the corresponding target modular algorithm structure. Based on the target modular algorithm structure and the preset hardware resource conditions, a corresponding resource allocation scheme is generated; Based on the target modular algorithm structure and the resource allocation scheme, the task is executed to obtain the corresponding task processing result.

[0008] Secondly, a robot-based task processing device is provided, comprising: The receiving module is used to receive the task instruction corresponding to the task to be processed, and to perform requirement parsing on the task instruction to obtain the corresponding task requirement data. The first acquisition module is used to acquire the robot's hardware status data and the current environmental feature data. The analysis module is used to analyze and process the task requirement data, hardware status data and environmental feature data based on a preset requirement modeling engine, and generate corresponding requirement instructions. The processing module is used to perform module splitting and priority sorting of the core algorithm of the robot based on the demand instructions, so as to obtain the modular algorithm structure and priority data corresponding to the sub-modules; wherein, the number of the sub-modules includes multiple; An optimization module is used to optimize the modular algorithm structure based on the priority data and a preset strategy library to obtain the corresponding target modular algorithm structure. The generation module is used to generate a corresponding resource allocation scheme based on the target modular algorithm structure and the preset hardware resource conditions; The execution module is used to perform the execution processing of the task based on the target modular algorithm structure and the resource allocation scheme, and obtain the corresponding task processing result.

[0009] Thirdly, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the above-described robot-based task processing method.

[0010] Fourthly, a computer-readable storage medium is provided, which stores a computer program that, when executed by a processor, implements the steps of the robot-based task processing method described above.

[0011] In the above-described robot-based task processing method, apparatus, computer equipment, and storage medium, the following steps are implemented: First, a task instruction corresponding to the task to be processed is received, and the task instruction is parsed to obtain corresponding task requirement data. Then, the robot's hardware status data and current environmental feature data are collected. Based on a preset requirement modeling engine, the task requirement data, hardware status data, and environmental feature data are analyzed and processed to generate corresponding requirement instructions. Next, based on the requirement instructions, the robot's core algorithm is modularized and prioritized to obtain modular algorithm structures and priority data corresponding to the sub-modules. The number of sub-modules includes multiple modules. Subsequently, the modular algorithm structure is optimized based on the priority data and a preset strategy library to obtain a corresponding target modular algorithm structure. Further, a corresponding resource allocation scheme is generated based on the target modular algorithm structure and preset hardware resource conditions. Finally, the task is executed based on the target modular algorithm structure and the resource allocation scheme to obtain the corresponding task processing result. Based on the above automated processing flow, this solution provides a task processing flow based on dimensional state perception and requirements analysis, adaptive decomposition and prioritization of algorithm modules, dynamic generation and execution of lightweight strategies, and task execution. This achieves a precise match between lightweight algorithms and dynamic scenario requirements. Through continuous information interaction and strategy adjustment, this task processing flow enables the robot to dynamically optimize the algorithm structure and parameters according to real-time status and task requirements. While ensuring the quality of task completion, it rationally utilizes hardware resources, effectively improving the accuracy of task processing, and thus enhancing the execution effect and quality of the task. Attached Figure Description

[0012] To more clearly illustrate the solutions in this application, the accompanying drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the accompanying drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0013] Figure 1This is an exemplary system architecture diagram to which this application can be applied; Figure 2 This is a flowchart of an embodiment of the robot-based task processing method according to this application; Figure 3 This is a schematic diagram of a structure of one embodiment of the robot-based task processing device according to this application; Figure 4 This is a schematic diagram of the structure of one embodiment of the computer device according to this application. Detailed Implementation

[0014] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains; the terminology used herein in the specification of the application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application; the terms "comprising" and "having," and any variations thereof, in the specification, claims, and foregoing drawings of this application, are intended to cover non-exclusive inclusion. The terms "first," "second," etc., in the specification, claims, or foregoing drawings of this application are used to distinguish different objects, not to describe a particular order.

[0015] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0016] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings.

[0017] like Figure 1 As shown, system architecture 100 may include terminal device 101, network 102, and server 103. Terminal device 101 may be a laptop 1011, tablet 1012, or mobile phone 1013. Network 102 is used as a medium to provide a communication link between terminal device 101 and server 103. Network 102 may include various connection types, such as wired, wireless communication links, or fiber optic cables, etc.

[0018] Users can use terminal device 101 to interact with server 103 via network 102 to receive or send messages, etc. Various communication client applications can be installed on terminal device 101, such as web browser applications, shopping applications, search applications, instant messaging tools, email clients, social media platform software, etc.

[0019] Terminal device 101 can be various electronic devices with a display screen and support web browsing. In addition to laptops 1011, tablets 1012, or mobile phones 1013, terminal device 101 can also be an e-book reader, an MP3 player (Moving Picture Experts Group Audio Layer III), an MP4 player (Moving Picture Experts Group Audio Layer IV), a laptop computer, and a desktop computer, etc.

[0020] Server 103 can be a server that provides various services, such as a backend server that provides support for the pages displayed on terminal device 101.

[0021] It should be noted that the robot-based task processing method provided in this application embodiment is generally executed by a server / terminal device, and correspondingly, the robot-based task processing device is generally set in the server / terminal device.

[0022] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0023] Continue to refer to Figure 2 The flowchart illustrates an embodiment of the robot-based task processing method according to this application. The order of steps in the flowchart can be changed, and some steps can be omitted, depending on different needs. The robot-based task processing method provided in this application embodiment can be applied to any scenario requiring robot task processing, and therefore can be applied to products in these scenarios, such as robot products in the financial insurance field or the digital healthcare field. The robot-based task processing method includes the following steps: Step S201: Receive the task instruction corresponding to the task to be processed, and perform requirement parsing on the task instruction to obtain the corresponding task requirement data.

[0024] In this embodiment, the robot-based task processing method runs on an electronic device (e.g., Figure 1The server / terminal device shown can obtain task instructions corresponding to the task to be processed via wired or wireless connection. It should be noted that the aforementioned wireless connection methods may include, but are not limited to, 3G / 4G / 5G connections, WiFi connections, Bluetooth connections, WiMAX connections, Zigbee connections, UWB (ultra-wideband) connections, and other currently known or future developed wireless connection methods. The executing entity of this application is specifically a robot-based task processing system, which can be simply referred to as the system.

[0025] The aforementioned task instructions are those input by the user based on actual business needs and related to the task to be processed. The process of parsing these task instructions includes: Task type determination: Classifying the task according to the user-input instructions or preset rules. For example, if the instruction contains the keyword "recognize objects," the task type is determined to be a target recognition task; if the instruction contains the keyword "grab items," the task type is determined to be a grasping task.

[0026] Priority assessment: Tasks are assigned priorities based on factors such as urgency, importance, and impact on overall system performance. For example, safety-critical tasks, such as obstacle avoidance, are given the highest priority; routine, non-urgent tasks, such as environmental monitoring, are given lower priority.

[0027] Performance metrics determination: Based on the task type and actual application scenario, determine the required performance metrics for the task. For example, for target recognition tasks, it may be necessary to determine performance metrics such as recognition accuracy and recognition speed; for grasping tasks, it may be necessary to determine performance metrics such as grasping success rate and grasping accuracy.

[0028] Furthermore, this application can be applied to task processing scenarios in the fintech and digital healthcare fields. For example, in a policy consultation scenario within the fintech field, the task instruction could be: "Help me check the effective date and coverage of my car insurance policy." The corresponding task type is determined by the robot analyzing the keywords "car insurance policy," "effective date," and "coverage" in the instruction, identifying the task type as a car insurance policy consultation task. Regarding hardware status awareness, after receiving the instruction, the processor will initiate the relevant policy query program, at which point the hardware monitoring interface begins collecting processor load data. If the processor has 8 cores, and during the query process, 5 cores are busy handling various data reading and calculation tasks, while 3 cores are relatively idle, then the processor load is approximately 62.5%.

[0029] Alternatively, in a risk assessment scenario within the fintech field, the aforementioned task instruction could be: "Conduct a typhoon risk assessment of a warehouse in a coastal area, evaluating the warehouse's wind resistance and the risks to the surrounding environment." The corresponding task type is determined by keywords such as "typhoon risk assessment," "wind resistance," and "surrounding environment risk" in the instruction; the robot identifies the task as a warehouse typhoon risk assessment task. When executing this task, the processor will access and analyze geographic information and meteorological data, and the hardware monitoring interface will collect the processor's status. Assuming the processor has 10 cores, 7 cores will be busy performing data analysis and model calculations during task processing, while 3 cores will be relatively idle, resulting in a processor load of 70%.

[0030] For example, in a patient data analysis scenario within the digital healthcare field, the aforementioned task instruction could be: "Analyze the patient's electrocardiogram (ECG) data to determine if there is an arrhythmia." The corresponding task type is determined by the robot using keywords such as "ECG data" and "arrhythmia" in the instruction, identifying it as an ECG analysis task. After receiving the ECG data, the processor runs specialized analysis algorithms for data processing and diagnosis, and the hardware monitoring interface collects the processor load. If the processor has 12 cores, during the analysis process, 9 cores will be running at high load, handling complex data calculations and pattern recognition tasks, while 3 cores will be at low load, resulting in a processor load of 75%.

[0031] Alternatively, in a medical analytics scenario within the digital healthcare field, the aforementioned task instruction could be: "Based on the patient's medical records and genetic testing reports, develop a personalized recommendation plan for the patient." The corresponding task type is determined by keywords such as "medical records," "genetic testing reports," and "personalized recommendation plan" in the instruction; the robot identifies this as a personalized recommendation plan development task. When processing this task, the processor integrates multi-source data for comprehensive analysis and decision-making, and the hardware monitoring interface collects the processor's status in real time. Assuming the processor has 8 cores, during the plan development process, 6 cores are operating at high speed, handling data fusion and algorithm calculations, while 2 cores are idle or under low load, resulting in a processor load of 75%.

[0032] Step S202: Collect the robot's hardware status data and the current environmental feature data.

[0033] In this embodiment, the process of collecting the aforementioned hardware status data includes: real-time collection of data such as processor load, memory usage, battery level, and sensor accuracy through the robot's built-in hardware monitoring interface. For example, using the system's built-in performance monitoring tool, information such as the current processor load percentage and remaining memory space is obtained at regular intervals (e.g., 100 milliseconds); for battery level, accurate battery level values ​​are obtained through a dedicated power monitoring chip; and sensor accuracy is determined through comparative testing with standard equipment or through a built-in calibration mechanism.

[0034] The process of collecting the aforementioned environmental feature data includes: Obstacle density detection: Using visual sensors (such as cameras) or LiDAR, the environment around the robot is scanned. Image processing algorithms or point cloud analysis algorithms are used to identify obstacles in the environment and count the number of obstacles per unit area or volume, thereby calculating the obstacle density. For example, on a two-dimensional plane, the area around the robot is divided into several small grids, the number of obstacles in each grid is counted, and then the average obstacle density of the entire area is calculated. Light intensity measurement: Light sensors (such as photoresistors, photodiodes, etc.) are used to monitor the light intensity in the environment in real time. The light sensor converts the light signal into an electrical signal, and the light intensity is obtained by measuring the intensity of the electrical signal. For example, the resistance of a photoresistor changes with the light intensity; by measuring the change in resistance, the light intensity can be calculated. Sound feature analysis: Sound signals in the environment are collected using auditory sensors such as microphones. Signal processing algorithms, such as Fourier transform, are used to convert the sound signal from the time domain to the frequency domain, and the frequency components, energy distribution, and other characteristics of the sound are analyzed. For example, it can identify specific sound types in the environment, such as the sound of a robot moving or the sound of people talking, and analyze the characteristic parameters of these sounds.

[0035] Step S203: Based on a preset requirement modeling engine, analyze and process the task requirement data, the hardware status data, and the environmental feature data to generate corresponding requirement instructions.

[0036] In this embodiment, the collected task requirement data, hardware status data, and environmental characteristic data can be input into a pre-built requirement modeling engine. This engine uses specific algorithms and models to comprehensively analyze this data, generating a three-dimensional model of "hardware capability - task requirements - environmental constraints." For example, based on processor load and memory usage, the current processing capacity limit of the hardware is determined; combined with task type, priority, and performance indicators, the specific requirements of the task are clarified; and based on environmental characteristics, the impact and constraints of the environment on task execution are considered. Finally, standardized requirement instructions (i.e., requirement commands) are output, such as "High-priority target identification task, requiring 95% accuracy, resource limit is 50% processor load."

[0037] By comprehensively acquiring information about the robot, the task, and the environment, and constructing a three-dimensional requirements model, clear goals and directions are provided for subsequent algorithm decomposition and optimization. Only by accurately understanding the current state of the system, task requirements, and environmental constraints can reasonable and effective optimization strategies be formulated, ensuring that subsequent steps are targeted and effective.

[0038] Step S204: Based on the requirement instruction, the core algorithm of the robot is modularized and prioritized to obtain the modular algorithm structure and priority data corresponding to the sub-modules; wherein, the number of the sub-modules includes multiple.

[0039] In this embodiment, the specific implementation process of performing module decomposition and priority sorting of the core algorithm of the robot based on the demand instructions to obtain the modular algorithm structure and priority data corresponding to the sub-modules will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0040] Step S205: Optimize the modular algorithm structure based on the priority data and the preset strategy library to obtain the corresponding target modular algorithm structure.

[0041] In this embodiment, the specific implementation process of optimizing the modular algorithm structure based on the priority data and the preset strategy library to obtain the corresponding target modular algorithm structure will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0042] Step S206: Generate a corresponding resource allocation scheme based on the target modular algorithm structure and the preset hardware resource conditions.

[0043] In this embodiment, a resource allocation scheme can be generated based on the optimized target modular algorithm and hardware resources. This is achieved by clearly defining the proportion of hardware resources used by each module, such as allocating 80% of the computing power to high-priority modules, 10% to medium-priority modules, and 10% to low-priority modules. Simultaneously, memory space and energy resources are allocated reasonably to ensure that all modules can operate normally.

[0044] Step S207: Based on the target modular algorithm structure and the resource allocation scheme, perform the execution processing of the task to obtain the corresponding task processing result.

[0045] In this embodiment, the specific implementation process of executing the task based on the target modular algorithm structure and the resource allocation scheme to obtain the corresponding task processing result will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0046] This application first receives a task instruction corresponding to the task to be processed, and performs requirement parsing on the task instruction to obtain corresponding task requirement data; then, it collects the robot's hardware status data and current environmental feature data; and analyzes and processes the task requirement data, hardware status data, and environmental feature data based on a preset requirement modeling engine to generate corresponding requirement instructions; then, based on the requirement instructions, it performs module decomposition and priority sorting on the robot's core algorithm to obtain modular algorithm structures and priority data corresponding to sub-modules; wherein, the number of sub-modules includes multiple; subsequently, it optimizes the modular algorithm structure based on the priority data and a preset strategy library to obtain a corresponding target modular algorithm structure; further, it generates a corresponding resource allocation scheme based on the target modular algorithm structure and preset hardware resource conditions; finally, it executes the task based on the target modular algorithm structure and the resource allocation scheme to obtain the corresponding task processing result. Based on the above automated processing flow, this solution provides a task processing flow based on dimensional state perception and requirement analysis, adaptive algorithm module decomposition and priority sorting, dynamic generation and execution of lightweight strategies, and task execution, which can achieve precise matching between algorithm lightweighting and dynamic scene requirements. This task processing flow, through continuous information exchange and strategy adjustment, enables the robot to dynamically optimize the algorithm structure and parameters based on real-time status and task requirements. While ensuring the quality of task completion, it makes reasonable use of hardware resources, effectively improving the accuracy of task processing, and thus enhancing the execution effect and quality of the task.

[0047] In some optional implementations, the process of generating a resource allocation scheme based on the optimized target modular algorithm and hardware resources includes: I. Resource Requirements Assessment. 1. Module Characteristic Analysis. High-priority modules: In-depth analysis of their functional implementation process to determine key computational tasks and data processing flows. For example, if a high-priority module is an image processing module, it is necessary to clarify the image resolution, the computational power requirements of processing algorithms (such as convolution, pooling, etc.), and the time required to process each frame of image, thereby estimating the computational power resources required for its stable operation. Medium-priority modules: Similarly, analyze their core functions, but focus on balancing performance and resource consumption. For example, for a text analysis module, analyze the impact of text length and algorithm complexity (such as word frequency statistics, semantic analysis, etc.) on computational power, while considering the computational power overhead caused by additional calculations during knowledge distillation. Low-priority modules: Focus on their simplified functions to determine the basic computational requirements of the compressed and simplified models. For example, for a simple data statistics module, understand the types and frequencies of statistical operations to estimate computational power requirements. 2. Memory Requirements Assessment. Data Storage: Analyze the data that each module needs to store during operation, including input data, intermediate results, and output data. For example, the image preprocessing module needs to store the original image, temporary images during processing, and the processed image. Memory usage should be estimated based on image size and format. Model parameters: For model-based modules, the number and size of model parameters should be calculated. Different optimization strategies (such as quantization and pruning) will affect the storage requirements of model parameters; memory estimation should be performed in conjunction with the optimized model. 3. Energy consumption requirement assessment. Hardware component power consumption: Understand the power consumption characteristics of the hardware components (such as CPU, GPU, memory, etc.) involved in running each module. Different hardware components have different power consumption under different loads; refer to the datasheets provided by the hardware manufacturers. Running time: Estimate the running time of each module during task execution, and calculate the module's energy consumption based on the hardware component power consumption. For example, high-priority modules have longer running times and therefore relatively higher energy consumption.

[0048] II. Hardware Resource Measurement. 1. Computing Power Measurement. Benchmarking: Use standard benchmarking tools (such as SPEC CPU benchmark) to measure the hardware's computing power, understand its performance under different computing tasks, and determine the total computing power. Real-time Monitoring: During system operation, monitor the hardware's computing power usage in real time through hardware performance counters, including current computing power occupancy and remaining computing power. 2. Memory Measurement. System Information Query: Obtain the total memory capacity and current usage through the system information query interface provided by the operating system (such as Windows WMI, Linux / proc / meminfo). Memory Allocation Tracking: Track the memory allocation of each module during program operation to ensure the accuracy and rationality of memory allocation. 3. Energy Consumption Measurement. Hardware Sensors: If the hardware is equipped with energy consumption sensors, obtain the hardware's real-time energy consumption by reading sensor data. Indirect Estimation: For hardware without energy consumption sensors, energy consumption can be indirectly estimated by measuring the current and voltage during hardware operation and combining this with the operating time.

[0049] III. Resource Allocation Scheme Formulation. 1. Computing Power Allocation. * **Proportion Determination:** Based on module priority and resource requirement assessment results, determine the computing power allocation ratio for each module. For example, high-priority modules, due to their high performance requirements and critical tasks, are allocated 80% of the computing power; medium-priority modules are allocated 10%; and low-priority modules are allocated 10%. * **Dynamic Adjustment Mechanism:** Considering dynamic changes in hardware load, establish a dynamic computing power adjustment mechanism. When the hardware load is too high, appropriately reduce the computing power allocation for low-priority modules to ensure the normal operation of high-priority and medium-priority modules; when the hardware load is low, appropriately increase the computing power allocation for low-priority modules to improve resource utilization. 2. Memory Allocation. * **Initial Allocation:** Based on the module's memory requirement assessment results, allocate initial memory space to each module. For example, allocate a larger memory space to high-priority modules to ensure efficient data processing; allocate an appropriate amount of memory space to medium-priority modules to meet their basic operating needs; and allocate a smaller memory space to low-priority modules. Dynamic memory management: Implements a dynamic memory management mechanism. When a module needs more memory, it can reclaim memory from other idle modules. When a module's memory usage is too high, it can temporarily store some of its data on external storage devices such as disks to free up memory space.

[0050] 3. Energy Consumption Allocation. Energy Budget Formulation: An energy budget is formulated based on the total energy consumption of the hardware and the importance of each module. High-priority modules receive relatively higher energy budgets to ensure stable operation; the energy budgets for medium-priority and low-priority modules are allocated reasonably based on actual conditions. Energy Optimization Strategies: Energy optimization strategies are adopted, such as dynamically adjusting hardware frequency and shutting down unnecessary hardware components, to reduce the overall system energy consumption while meeting task requirements.

[0051] In some alternative implementations, step S204 includes the following steps: The core algorithm of the robot is functionally decoupled to obtain multiple corresponding sub-modules.

[0052] In this embodiment, the process of functionally decoupling the robot's core algorithm includes: 1) Algorithm analysis: In-depth research and analysis of the robot's core algorithm to understand its overall function and implementation principle. For example, for a robot algorithm that includes perception, decision-making, and execution functions, analyze the specific role of each functional module and the data flow relationship between them. 2) Module decomposition: Based on the functional hierarchy and logical structure of the algorithm, it is decomposed into independent sub-modules. Taking the perception algorithm as an example, it can be decomposed into sub-modules such as image preprocessing, feature extraction, and target recognition. The image preprocessing module is responsible for denoising and enhancing the acquired images to improve image quality; the feature extraction module extracts representative features from the preprocessed images; and the target recognition module classifies and identifies targets based on the extracted features. Each sub-module has a clear function and input / output data. For example, the input of the image preprocessing module is the original image data, and the output is the processed image data, which serves as the input of the feature extraction module.

[0053] All the aforementioned sub-modules are processed to generate the corresponding modular algorithm structure.

[0054] In this embodiment, the composition and function of each sub-module can be clearly defined by organizing and describing the decoupled functionalities. The modular algorithm structure can then be output in the form of documents or diagrams, facilitating subsequent development and maintenance.

[0055] This process records the priority level of each submodule and the performance metrics required to meet the task requirements. For example, for a high-priority target recognition module, it records the required recognition accuracy and processing time; for a medium-priority feature extraction module, it records the required accuracy and efficiency of feature extraction. These results provide accurate objects for the lightweight strategy generation in step 3.

[0056] Obtain the preset priority evaluation strategy.

[0057] In this embodiment, the selection of the aforementioned priority evaluation strategy is not specifically limited and can be determined according to actual business needs. For example, expert evaluation and the Analytic Hierarchy Process (AHP) can be used to prioritize each submodule. Expert evaluation involves inviting experts in relevant fields to score the priority of submodules based on their experience and professional knowledge; the Analytic Hierarchy Process (AHP) decomposes complex problems into multiple levels by constructing a hierarchical model, then determines the relative importance of each factor through pairwise comparisons, and finally calculates the priority weight of each submodule.

[0058] The priority evaluation strategy is used to evaluate each of the sub-modules to obtain priority data corresponding to each of the sub-modules.

[0059] In this embodiment, priority evaluation of each sub-module can be performed according to the selected priority evaluation strategy to generate priority data corresponding to each sub-module.

[0060] This application decouples the core algorithm of the robot functionally, breaking it down into multiple sub-modules. Then, all sub-modules are organized to generate a corresponding modular algorithm structure. A preset priority evaluation strategy is then obtained. Subsequently, each sub-module is evaluated based on this priority evaluation strategy to obtain priority data corresponding to each sub-module. Based on the above processing flow, this application provides a module adaptive splitting and priority sorting method based on the use of demand instructions, which can further refine and optimize the robot's core algorithm. Functional decoupling breaks down the complex core algorithm into independent sub-modules, making the function of each sub-module clearer and more singular, facilitating subsequent optimization and management. Furthermore, priority evaluation assigns priority to each sub-module based on its importance to task completion, providing an accurate basis for formulating subsequent optimization strategies.

[0061] In some optional implementations of this embodiment, step S205 includes the following steps: Call the preset strategy library.

[0062] In this embodiment, a strategy library containing various optimization strategies is pre-built. These optimization strategies stored in the strategy library are designed for different types of modules and different priority levels, such as the "parameter fine-tuning + quantization" strategy, the "structured pruning + knowledge distillation" strategy, and the "model compression + function simplification" strategy. Each optimization strategy has its applicable scenarios and advantages and disadvantages. For example, the "parameter fine-tuning + quantization" strategy is suitable for modules with high performance requirements and limited resources, and can minimize resource consumption while ensuring a certain level of performance.

[0063] Query the strategy library to find the optimization strategy that matches the priority data.

[0064] In this embodiment, a suitable optimization strategy is selected from the strategy library based on the priority data of the aforementioned sub-modules. For high-priority modules, a conservative but effective strategy, such as "parameter fine-tuning + quantization," is adopted to ensure performance while minimizing resource consumption. For medium-priority modules, a "structured pruning + knowledge distillation" strategy is used to reduce model complexity through pruning and transfer knowledge from high-priority modules to medium-priority modules through knowledge distillation, thereby improving their performance. For low-priority modules, a "model compression + functional simplification" strategy is adopted to significantly compress and simplify the model to save resources.

[0065] The optimization strategy is dynamically adjusted to obtain the corresponding target optimization strategy.

[0066] In this embodiment, the specific implementation process of dynamically adjusting the optimization strategy to obtain the corresponding target optimization strategy will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0067] Based on the target optimization strategy, the sub-modules contained in the modular algorithm structure are optimized to obtain the corresponding target sub-modules.

[0068] In this embodiment, the sub-modules within the aforementioned modular algorithm structure can be optimized according to the obtained target optimization strategy. Specifically, a corresponding target optimization strategy is applied to each sub-module. For example, the image preprocessing module uses a quantization strategy to reduce data storage and computation, while the target recognition module uses a parameter fine-tuning strategy to improve recognition accuracy, thereby obtaining the optimized target sub-modules. These optimized target sub-modules cooperate and are organically integrated to form the optimized target modular algorithm structure. Compared to the original modular algorithm structure, it improves performance and resource consumption, enabling it to complete specific tasks more efficiently and accurately. For example, in image recognition tasks, the optimized modular algorithm may have a faster overall processing speed, higher recognition accuracy, and consume fewer hardware resources.

[0069] The target submodule is processed to obtain the processed structural data.

[0070] In this embodiment, the composition and function of each target sub-module can be clarified by organizing and describing the sub-modules processed by the target optimization strategy. The corresponding structural data, i.e., the target modular algorithm structure, can then be output in the form of a document or chart.

[0071] Each target submodule employs a corresponding target optimization strategy to optimize performance and resource consumption. For example, the image preprocessing module may use a quantization strategy to reduce data storage and computation; the target recognition module may use a parameter fine-tuning strategy to improve recognition accuracy.

[0072] The sorted structured data is used as the target modular algorithm structure.

[0073] This application calls a preset strategy library and queries the strategy library to find optimization strategies that match the priority data. Then, it dynamically adjusts the optimization strategies to obtain corresponding target optimization strategies. Next, based on the target optimization strategies, it optimizes the sub-modules within the modular algorithm structure to obtain corresponding target sub-modules. Subsequently, it organizes the target sub-modules to obtain organized structure data. Finally, it uses the organized structure data as the target modular algorithm structure. Based on the above processing flow, this application provides suitable optimization strategies for sub-modules of different types and priorities by using strategy library matching, making the optimization process more targeted and effective. It intelligently and dynamically adjusts the optimization strategies to obtain target optimization strategies, so that the sub-modules within the modular algorithm structure can be optimized based on the target optimization strategies to obtain target sub-modules. The target sub-modules are then organized, and the generated structure data serves as the corresponding target modular algorithm structure. This provides an optimized target modular algorithm structure and resource allocation basis for task execution, enabling tasks to execute efficiently in an optimized environment, thereby improving the efficiency and quality of task completion.

[0074] In some optional implementations, the dynamic adjustment of the optimization strategy based on preset adjustment rules to obtain the corresponding target optimization strategy includes the following steps: Invoke the preset monitoring algorithm.

[0075] In this embodiment, the monitoring algorithm described above can specifically employ a reinforcement learning algorithm.

[0076] The monitoring algorithm is used to monitor the current hardware load information in real time.

[0077] In this embodiment, the process of real-time monitoring of current hardware load information based on the monitoring algorithm includes: 1) State definition: Using the currently collected hardware load data as the state input of the reinforcement learning algorithm. For example, combining the current processor load and memory usage into a state vector. 2) Action definition: Defining the actions that the reinforcement learning algorithm can take, such as "predicting the hardware load trend (rising, falling, stable) in the future". 3) Reward function design: Designing a reward function to evaluate the accuracy of the algorithm's prediction. For example, if the predicted load trend matches the actual trend, a higher positive reward is given; if the prediction is wrong, a negative reward is given. 4) Model training: Training the reinforcement learning model using historically collected hardware load data. Reinforcement learning algorithms such as Q-learning and Deep Q-Network (DQN) can be used for training. By continuously iterating and updating the model parameters, the model can more accurately predict the hardware load trend. 5) Real-time prediction: During system operation, the real-time collected hardware load data is input into the trained reinforcement learning model to obtain the predicted trend of hardware load in the future, which is used as the corresponding hardware load information.

[0078] The process of collecting the aforementioned hardware load data includes: Determining monitoring indicators: Identifying the hardware load indicators to be monitored, such as processor load (obtained through system-built-in performance counters, such as CPU utilization data obtained from tools like Windows Performance Monitor or the Linux `top` command), and memory usage (obtained by querying the system memory information interface to obtain used memory and total memory data). Setting the collection frequency: Setting the data collection frequency according to the system's real-time requirements. For example, for systems with high real-time requirements, data can be collected once per second; for systems with relatively low real-time requirements, data can be collected once every 5-10 seconds. Data storage: The collected hardware load data is stored in chronological order, using a database or file system for subsequent analysis and prediction.

[0079] Based on preset parameter adjustment rules, the strategy parameters of the optimization strategy are dynamically adjusted according to the hardware load information to obtain the adjusted optimization strategy.

[0080] In this embodiment, the construction of the above parameter adjustment rules includes: Rule classification: Classifying rules according to different hardware load indicators (processor load, memory usage, etc.) and different load thresholds (e.g., processor load exceeding 80%, memory usage exceeding 90%, etc.). Rule content determination: Determining the corresponding parameter adjustment rules for each category. For example, when the processor load exceeds 80%, the rule content is "increase the pruning ratio of medium-priority modules"; when memory usage is too high (exceeding 90%), the rule content is "perform greater model compression on low-priority modules". Rule priority setting: Considering that multiple rules may be triggered simultaneously, a priority is set for each rule. For example, a high processor load situation may be more urgent than a high memory usage situation, therefore, rules related to processor load have a higher priority.

[0081] The triggering and execution process based on parameter adjustment rules includes: Real-time monitoring and judgment: During system operation, the hardware load is monitored in real time, and the current load data is compared with the threshold in the rule base to determine whether to trigger the corresponding rule. Rule execution: When a rule is triggered, the parameters of the optimization strategy are adjusted according to the rule content. For example, if the rule "increase the pruning ratio of the medium-priority module" is triggered, the pruning parameters of the medium-priority module are modified according to the preset adjustment range (such as increasing the pruning ratio from the original 20% to 30%). Adjustment effect evaluation: After parameter adjustment, the hardware load continues to be monitored to evaluate the effect of the adjustment. If the hardware load is effectively alleviated, the current parameters are maintained; if the hardware load is still too high, further parameter adjustments or triggering other higher-level rules are considered.

[0082] The adjusted optimization strategy is taken as the target optimization strategy.

[0083] This application employs a pre-defined monitoring algorithm; then, based on this algorithm, it monitors the current hardware load information in real time; subsequently, based on pre-defined parameter adjustment rules, it dynamically adjusts the strategy parameters of the optimization strategy according to the hardware load information to obtain an adjusted optimization strategy; finally, it uses the adjusted optimization strategy as the target optimization strategy. Based on this processing flow, this application monitors the current hardware load information using a monitoring algorithm, then dynamically adjusts the strategy parameters of the optimization strategy according to pre-defined parameter adjustment rules, and uses the resulting adjusted optimization strategy as the corresponding target optimization strategy. In this way, dynamic adjustment adjusts the strategy parameters in real time according to the hardware load, effectively ensuring stable system operation under different operating conditions and improving the system's adaptability and robustness.

[0084] In some alternative implementations, step S207 includes the following steps: Obtain the target sub-modules corresponding to the target modular algorithm structure; wherein, the number of target sub-modules includes multiple sub-modules.

[0085] In this embodiment, the target sub-module is the target sub-module included in the target modular algorithm structure after optimization strategy processing.

[0086] Construct a corresponding module dependency graph based on the target sub-module.

[0087] In this embodiment, the specific implementation process of constructing the corresponding module dependency graph based on the target sub-module will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0088] The execution order of each target sub-module is determined based on the module dependency graph, and corresponding hardware resources are allocated to each target sub-module based on the resource allocation scheme to obtain the corresponding designated sub-module.

[0089] In this embodiment, the module dependency graph described above is a structural diagram used to describe the execution order and dependencies between various modules. In an algorithm, different modules often need to be executed sequentially in a certain order, or the output of some modules is the input of other modules, which forms the dependencies between modules.

[0090] During the task execution phase, the optimized target modular algorithm structure and module dependency graph jointly guide the entire task, while the resource allocation scheme provides hardware support for task execution.

[0091] Specifically, the execution order of each target sub-module can be determined based on the module dependency graph. For example, in an image recognition task, the image preprocessing module is started first to process the input raw image. Then, according to the resource allocation scheme, corresponding hardware resources are allocated to the currently executing module. For high-priority modules (such as the target recognition module), more processor computing power and memory space are allocated; for low-priority modules (such as some non-critical steps in the image preprocessing module), fewer resources are allocated. For example, when the image preprocessing module is executed, it is allocated an appropriate amount of processor resources and memory space to ensure that it can successfully complete the image preprocessing operation.

[0092] The task is executed based on the specified submodule to obtain the corresponding task processing result.

[0093] In this embodiment, specific task processing is performed using modules with allocated resources (empty designated sub-modules). The image preprocessing module uses its allocated resources to perform operations such as denoising and scaling on the original image, and then passes the processed image data to the feature extraction module. After receiving the data, the feature extraction module uses its allocated resources to extract image features and passes the feature data to the target recognition module. The target recognition module uses its allocated computing power to recognize and classify the feature data, and finally outputs the recognition result, which serves as the corresponding task processing result.

[0094] During task execution, hardware resource usage is monitored in real time. If a module encounters resource shortages while other modules have surplus resources, dynamic resource allocation can be implemented based on the actual situation. For example, if the target recognition module experiences insufficient computing power due to a sudden increase in data volume, but the image preprocessing module has already completed most of its work and has surplus resources, some resources can be temporarily allocated to the target recognition module to ensure its normal operation.

[0095] This application obtains target sub-modules corresponding to the target modular algorithm structure; wherein the number of target sub-modules includes multiple; then, a corresponding module dependency graph is constructed based on the target sub-modules; subsequently, the execution order of each target sub-module is determined based on the module dependency graph, and corresponding hardware resources are allocated to each target sub-module based on the resource allocation scheme to obtain the corresponding designated sub-module; subsequently, the task is executed based on the designated sub-module to obtain the corresponding task processing result. Based on the above processing flow, this application provides an overall framework for task processing and optimized sub-modules by using an optimized target modular algorithm structure, determines the execution order and data flow of modules by using a module dependency graph, and provides hardware resource support for module execution by using a resource allocation scheme. The three work together to effectively ensure that the task can be completed efficiently and accurately.

[0096] In some optional implementations of this embodiment, the step of constructing a corresponding module dependency graph based on the target sub-module includes the following steps: Input-output analysis is performed on all the target sub-modules to obtain the corresponding input-output relationships.

[0097] In this embodiment, the input-output analysis includes: clarifying the input-output relationships between each target sub-module. For each target sub-module, it determines which modules its input data originates from and which modules its output data will be passed to. For example, the output of the image preprocessing module is the input of the feature extraction module, and the output of the feature extraction module is the input of the target recognition module.

[0098] Invoke the default graphical tools.

[0099] In this embodiment, the selection of the above-mentioned graphical tools is not specifically limited, and can be determined according to actual business needs. For example, flowcharts, dependency diagrams, etc. can be used.

[0100] The input-output relationship is plotted using the graphical tool to obtain the corresponding generated graph.

[0101] In this embodiment, the input-output relationships between each target sub-module can be visually represented using a selected graphical tool, constructing a dependency graph, i.e., generating a graph (referred to as the graph). In the graph, each module is represented by a node, and the input-output relationships between modules are represented by directed edges, with the direction of the edges indicating the direction of data flow. Through the dependency graph, the data flow and collaboration relationships between modules can be clearly understood, ensuring that modules can be executed sequentially in the correct order during subsequent task execution.

[0102] The generated graph is used as the module dependency graph.

[0103] This application analyzes the input and output of all target sub-modules to obtain corresponding input-output relationships; then, it calls a preset graphical tool; subsequently, it uses the graphical tool to perform graphing processing on the input-output relationships to obtain corresponding generated graphs; and finally, it uses the generated graphs as the module dependency graphs. Based on the above processing flow, this application obtains input-output relationships by analyzing the input and output of all target sub-modules, then uses a graphical tool to perform graphing processing on the input-output relationships, and uses the obtained generated graphs as the corresponding module dependency graphs, thereby achieving efficient construction of module dependency graphs and improving the construction efficiency of module dependency graphs. Furthermore, the construction of module dependency graphs clarifies the data flow and collaboration relationships between target sub-modules, effectively ensuring that target sub-modules can be executed sequentially in the correct order during task execution, avoiding data conflicts and logical errors.

[0104] In some optional implementations of this embodiment, after step S207, the electronic device may further perform the following steps: During the processing of the task, performance feedback data is collected based on a preset performance monitoring strategy.

[0105] In this embodiment, the process of collecting the aforementioned performance feedback data includes: embedding a performance monitoring mechanism in each module (target sub-module) to monitor the output accuracy and response time of the module in real time. For example, in the target recognition module, the accuracy of the recognition result is recorded and compared with a preset performance indicator. If the accuracy is lower than the preset value, the deviation information is recorded. At the same time, the processing time from input data to output result is calculated to evaluate the module's response speed. If the processing time exceeds a preset threshold, timeout information is recorded.

[0106] Hardware feedback data is collected based on preset hardware monitoring tools.

[0107] In this embodiment, the process of collecting the aforementioned hardware feedback data includes: using hardware monitoring tools to collect data such as processor load, memory usage, and power consumption. For example, at regular intervals, the current processor load percentage, remaining memory space, and battery power consumption are obtained. By analyzing this data, the usage and performance status of hardware resources are understood, providing a basis for subsequent resource adjustments and optimizations.

[0108] Environmental feedback data is collected based on preset sensors.

[0109] In this embodiment, the process of collecting the aforementioned environmental feedback data includes: continuously capturing scene changes through sensors, such as sudden changes in illumination or the addition of obstacles. Visual sensors can monitor changes in image brightness in real time to determine if sudden changes in illumination have occurred; simultaneously, image analysis algorithms detect changes in the number and position of obstacles in the scene, promptly identifying newly added obstacles. Environmental feedback data helps the robot adjust its task execution strategy in a timely manner to adapt to changes in the environment.

[0110] The performance feedback data, hardware feedback data, and environmental feedback data are integrated based on timestamps to obtain the corresponding target feedback data.

[0111] In this embodiment, the timestamp-based integration process includes: Timestamp addition: adding timestamps to the collected performance feedback data, hardware feedback data, and environmental feedback data to record the specific time of data collection. Data integration: integrating different types of collected data according to timestamps to form an "optimization-execution-state change" data chain. For example, associating data such as target recognition accuracy, processor load, and light intensity at a certain moment to facilitate subsequent analysis of the interrelationships and influences between these data. Through data association, problems and shortcomings of the algorithm in actual execution can be discovered. For example, under low light intensity, target recognition accuracy decreases while processor load increases. This may be because the performance of the visual sensor degrades under low light conditions, requiring more computing resources to process image data.

[0112] The target feedback data is stored and processed.

[0113] In this embodiment, the storage method for the above-mentioned target feedback data is not specifically limited, and can be determined according to the actual storage needs. For example, blockchain storage, local database storage, cloud server storage, etc. can be used.

[0114] This application collects performance feedback data based on a preset performance monitoring strategy during the task processing; simultaneously, it collects hardware feedback data based on a preset hardware monitoring tool; and it collects environmental feedback data based on preset sensors. Then, it integrates the performance feedback data, hardware feedback data, and environmental feedback data based on timestamps to obtain corresponding target feedback data. This target feedback data is then stored. Based on the above processing flow, this application comprehensively understands the actual situation during task execution by collecting multi-dimensional feedback data from multiple dimensions such as performance, hardware, and environment during the feedback collection phase. Data association integrates different types of data in chronological order to form a data chain, providing rich information for subsequent strategy iterations. Furthermore, by analyzing and mining this feedback data, problems and shortcomings in the algorithm during actual execution can be identified, allowing for targeted optimization and continuously improving the robot's task processing capabilities and performance.

[0115] In some optional implementations, the system also has the function of iterative optimization of strategy and algorithm parameters. The specific implementation process includes: Bottleneck analysis: Compare the collected feedback data with the preset demand thresholds to identify the gap between actual performance and requirements, and analyze the bottleneck problems in the system. For example, if the target recognition accuracy of high-priority modules does not reach the preset 95%, analyze whether it is due to unreasonable algorithm parameter settings, insufficient hardware resources, or environmental factors; if the processor load is too high, causing the system response to be slow, analyze which module is consuming too many resources.

[0116] Parameter Tuning: For the identified bottleneck issues, optimization algorithms such as gradient descent are used to adjust the lightweight parameters. For example, if the quantization bit depth of the feature extraction module is found to cause excessive accuracy loss, the feature extraction quantization bit depth can be restored to 32 bits to improve recognition accuracy; if the pruning ratio of the medium-priority module is too high, causing performance degradation, the pruning ratio can be appropriately reduced.

[0117] Rule Update: Based on the environmental changes and task requirements reflected in the feedback data, new scene adaptation rules have been added. For example, if it is found that image preprocessing is not effective in strong light scenes, affecting the accuracy of target recognition, a new rule of "priority enhancement for image preprocessing in strong light scenes" has been added to prioritize image preprocessing in strong light scenes in order to improve image quality.

[0118] Synchronous Updates: The optimized strategies and parameters are fed back to the preceding processes, updating model parameters, algorithm module priorities, and dependencies in the requirements modeling engine, forming a closed loop. For example, the adjusted algorithm parameters are updated in the corresponding modules, and the priority and performance requirements of the modules are reassessed, providing a more accurate basis for the next round of task processing.

[0119] This step enables the system to "self-evolve," continuously optimizing strategies and parameters based on feedback data to allow the system to adapt to long-term scenario changes and hardware aging. As the environment and tasks change, the system can automatically adjust its strategies and parameters to maintain optimal performance and resource utilization efficiency, thereby improving system stability and reliability.

[0120] In some alternative implementations, the user information obtained is subject to user consent and complies with relevant laws and policies.

[0121] Furthermore, any software tools or components not belonging to our company that appear in the embodiments of this application are merely illustrative examples and do not represent actual use.

[0122] Furthermore, the core innovations of this application can be summarized in the following three points: 1. Dynamic lightweight architecture driven by multi-dimensional requirements: Innovatively construct a three-dimensional requirement model of "hardware-task-environment", break through the limitations of traditional static optimization, realize the real-time adjustment of algorithm lightweighting strategy according to the scene, task and hardware status, and solve the problem of the disconnect between lightweighting and scene requirements.

[0123] 2. Modular priority-oriented differentiated optimization mechanism: By decoupling algorithm functions and marking module priorities, a layered lightweight strategy is adopted for modules of different importance. This maximizes resource conservation while ensuring the performance of core functions, thus balancing the contradiction between lightweighting and task accuracy.

[0124] 3. Iterative optimization system with full-link feedback loop: Construct a complete closed loop of "optimization-execution-feedback-iteration", and use multi-dimensional feedback data such as task performance, hardware status, and environmental changes for strategy and algorithm parameter updates to achieve continuous evolution of system performance and solve the problem of insufficient motivation for optimization of existing technologies.

[0125] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0126] It should be emphasized that, to further ensure the privacy and security of the above resource allocation scheme, the above resource allocation scheme can also be stored in a blockchain node.

[0127] The blockchain referred to in this application is a novel application model of computer technologies such as distributed data storage, peer-to-peer transmission, consensus mechanisms, and encryption algorithms. Essentially, a blockchain is a decentralized database, a chain of data blocks linked together using cryptographic methods. Each data block contains information about a batch of network transactions, used to verify the validity of the information (anti-counterfeiting) and generate the next block. A blockchain can include an underlying blockchain platform, a platform product service layer, and an application service layer.

[0128] The embodiments of this application can acquire and process relevant data based on artificial intelligence technology. Artificial intelligence (AI) refers to the theories, methods, technologies, and application systems that use digital computers or machines controlled by digital computers to simulate, extend, and expand human intelligence, perceive the environment, acquire knowledge, and use that knowledge to obtain optimal results. Foundational technologies for artificial intelligence generally include sensors, dedicated AI chips, cloud computing, distributed storage, big data processing, operating / interactive systems, and mechatronics. AI software technologies mainly encompass computer vision, robotics, biometrics, speech processing, natural language processing, and machine learning / deep learning.

[0129] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing related hardware through computer-readable instructions. These computer-readable instructions can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the embodiments of the above methods. The aforementioned storage medium can be a non-volatile storage medium such as a magnetic disk, optical disk, or read-only memory (ROM), or random access memory (RAM).

[0130] It should be understood that although the steps in the flowcharts of the accompanying figures are shown sequentially as indicated by the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the accompanying figures may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the sub-steps or stages of other steps.

[0131] Further reference Figure 3 As a response to the above Figure 2 The implementation of the method shown in this application provides an embodiment of a robot-based task processing device, which is similar to... Figure 2 Corresponding to the method embodiments shown, this device can be specifically applied to various electronic devices.

[0132] like Figure 3 As shown, the robot-based task processing device 300 described in this embodiment includes: a receiving module 301, a first acquisition module 302, an analysis module 303, a processing module 304, an optimization module 305, a generation module 306, and an execution module 307. Wherein: The receiving module 301 is used to receive the task instruction corresponding to the task to be processed, and to perform requirement parsing on the task instruction to obtain the corresponding task requirement data. The first acquisition module 302 is used to acquire the robot's hardware status data and the current environmental feature data. Analysis module 303 is used to analyze and process the task requirement data, the hardware status data and the environmental feature data based on a preset requirement modeling engine, and generate corresponding requirement instructions. The processing module 304 is used to perform module splitting and priority sorting of the core algorithm of the robot based on the demand instruction, so as to obtain the modular algorithm structure and priority data corresponding to the sub-modules; wherein, the number of the sub-modules includes multiple; The optimization module 305 is used to optimize the modular algorithm structure based on the priority data and the preset strategy library to obtain the corresponding target modular algorithm structure. The generation module 306 is used to generate a corresponding resource allocation scheme based on the target modular algorithm structure and the preset hardware resource conditions; The execution module 307 is used to perform execution processing on the task based on the target modular algorithm structure and the resource allocation scheme, and obtain the corresponding task processing result.

[0133] In some optional implementations of this embodiment, the processing module 304 includes: The core algorithm of the robot is decoupled into sub-modules to decouple its functions, resulting in multiple corresponding sub-modules. The first sorting submodule is used to sort and process all the submodules to generate the corresponding modular algorithm structure; The first acquisition submodule is used to acquire the preset priority evaluation strategy; An evaluation submodule is used to evaluate each of the submodules based on the priority evaluation strategy to obtain priority data corresponding to each of the submodules.

[0134] In some optional implementations of this embodiment, the optimization module 305 includes: Calling submodules is used to invoke preset strategy libraries; The query submodule is used to query the strategy library for optimization strategies that match the priority data; The adjustment submodule is used to dynamically adjust the optimization strategy to obtain the corresponding target optimization strategy; An optimization submodule is used to optimize the submodules contained in the modular algorithm structure based on the target optimization strategy to obtain the corresponding target submodule. The second sorting submodule is used to sort the target submodule to obtain the sorted structure data; A submodule is determined to use the sorted structured data as the target modular algorithm structure.

[0135] In some optional implementations of this embodiment, the adjustment submodule includes: The first calling unit is used to call the preset monitoring algorithm; The monitoring unit is used to monitor the current hardware load information in real time based on the monitoring algorithm. An adjustment unit is used to dynamically adjust the strategy parameters of the optimization strategy based on preset parameter adjustment rules and the hardware load information to obtain the adjusted optimization strategy. The first determining unit is used to take the adjusted optimization strategy as the target optimization strategy.

[0136] In some optional implementations of this embodiment, the execution module 307 includes: The second acquisition submodule is used to acquire the target submodule corresponding to the target modular algorithm structure; wherein, the number of the target submodules includes multiple submodules. Construct submodules to build corresponding module dependency graphs based on the target submodules; The processing submodule is used to determine the execution order of each target submodule based on the module dependency graph, and to allocate corresponding hardware resources to each target submodule based on the resource allocation scheme, so as to obtain the corresponding designated submodule; An execution submodule is used to perform task execution processing based on the specified submodule to obtain the corresponding task processing result.

[0137] In some optional implementations of this embodiment, the construction submodule includes: The analysis unit is used to perform input-output analysis on all the target sub-modules to obtain the corresponding input-output relationships; The second calling unit is used to call the preset graphical tools; The drawing unit is used to perform graph drawing processing on the input-output relationship based on the graphical tool to obtain the corresponding generated graph; The second determining unit is used to use the generated graph as the module dependency graph.

[0138] In some optional implementations of this embodiment, the robot-based task processing device further includes: The second acquisition module is used to acquire performance feedback data based on a preset performance monitoring strategy during the processing of the task. The third acquisition module is used to acquire hardware feedback data based on preset hardware monitoring tools; The fourth acquisition module is used to acquire environmental feedback data based on preset sensors; The integration module is used to perform timestamp-based integration processing on the performance feedback data, hardware feedback data, and environmental feedback data to obtain the corresponding target feedback data. The storage module is used to store and process the target feedback data.

[0139] To address the aforementioned technical problems, embodiments of this application also provide a computer device. Please refer to [link / reference needed]. Figure 4 , Figure 4 This is a basic structural block diagram of the computer device in this embodiment.

[0140] The computer device 4 includes a memory 41, a processor 42, and a network interface 43 that are interconnected via a system bus. It should be noted that only the computer device 4 with components 41-43 is shown in the figure; however, it should be understood that it is not required to implement all the shown components, and more or fewer components can be implemented alternatively. Those skilled in the art will understand that the computer device described here is a device capable of automatically performing numerical calculations and / or information processing according to pre-set or stored instructions, and its hardware includes, but is not limited to, microprocessors, application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), embedded devices, etc.

[0141] The computer device can be a desktop computer, laptop, handheld computer, or cloud server, etc. The computer device can interact with the user via a keyboard, mouse, remote control, touchpad, or voice control.

[0142] The memory 41 includes at least one type of readable storage medium, including flash memory, hard disk, multimedia card, card-type memory (e.g., SD or DX memory), random access memory (RAM), static random access memory (SRAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the memory 41 may be an internal storage unit of the computer device 4, such as the hard disk or memory of the computer device 4. In other embodiments, the memory 41 may also be an external storage device of the computer device 4, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., equipped on the computer device 4. Of course, the memory 41 may also include both the internal storage unit and its external storage device of the computer device 4. In this embodiment, the memory 41 is typically used to store the operating system and various application software installed on the computer device 4, such as computer-readable instructions for robot-based task processing methods. In addition, the memory 41 can also be used to temporarily store various types of data that have been output or will be output.

[0143] In some embodiments, the processor 42 may be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip. The processor 42 is typically used to control the overall operation of the computer device 4. In this embodiment, the processor 42 is used to execute computer-readable instructions stored in the memory 41 or to process data, for example, to execute computer-readable instructions of the robot-based task processing method.

[0144] The network interface 43 may include a wireless network interface or a wired network interface, which is typically used to establish communication connections between the computer device 4 and other electronic devices.

[0145] This application also provides another embodiment, namely, providing a computer-readable storage medium storing computer-readable instructions that can be executed by at least one processor to cause the at least one processor to perform the steps of the robot-based task processing method described above.

[0146] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal device (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0147] Obviously, the embodiments described above are only some embodiments of this application, not all embodiments. The accompanying drawings show preferred embodiments of this application, but do not limit the patent scope of this application. This application can be implemented in many different forms; rather, the purpose of providing these embodiments is to provide a more thorough and comprehensive understanding of the disclosure of this application. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing specific embodiments, or make equivalent substitutions for some of the technical features. Any equivalent structures made using the content of this application's specification and drawings, directly or indirectly applied to other related technical fields, are similarly within the scope of patent protection of this application.

Claims

1. A robot-based task processing method, characterized in that, Includes the following steps: Receive the task instruction corresponding to the task to be processed, and perform requirement parsing on the task instruction to obtain the corresponding task requirement data; Collect hardware status data of the robot, as well as current environmental characteristic data; Based on a preset requirement modeling engine, the task requirement data, hardware status data, and environmental feature data are analyzed and processed to generate corresponding requirement instructions. Based on the aforementioned requirements, the core algorithm of the robot is modularized and prioritized to obtain modular algorithm structures and priority data corresponding to the sub-modules; wherein, the number of sub-modules includes multiple modules. The modular algorithm structure is optimized based on the priority data and the preset strategy library to obtain the corresponding target modular algorithm structure. Based on the target modular algorithm structure and the preset hardware resource conditions, a corresponding resource allocation scheme is generated; Based on the target modular algorithm structure and the resource allocation scheme, the task is executed to obtain the corresponding task processing result.

2. The robot-based task processing method according to claim 1, characterized in that, The step of performing module decomposition and priority sorting of the robot's core algorithm based on the demand instructions to obtain the modular algorithm structure and priority data corresponding to the sub-modules specifically includes: The core algorithm of the robot is functionally decoupled to obtain multiple corresponding sub-modules; All the aforementioned sub-modules are processed to generate the corresponding modular algorithm structure; Obtain the preset priority evaluation strategy; The priority evaluation strategy is used to evaluate each of the sub-modules to obtain priority data corresponding to each of the sub-modules.

3. The robot-based task processing method according to claim 1, characterized in that, The step of optimizing the modular algorithm structure based on the priority data and a preset strategy library to obtain the corresponding target modular algorithm structure specifically includes: Call the preset strategy library; Retrieve optimization strategies that match the priority data from the strategy library; The optimization strategy is dynamically adjusted to obtain the corresponding target optimization strategy; Based on the target optimization strategy, the sub-modules contained in the modular algorithm structure are optimized to obtain the corresponding target sub-modules; The target sub-module is processed to obtain the processed structural data; The sorted structured data is used as the target modular algorithm structure.

4. The robot-based task processing method according to claim 3, characterized in that, The step of dynamically adjusting the optimization strategy based on preset adjustment rules to obtain the corresponding target optimization strategy specifically includes: Invoke the preset monitoring algorithm; The current hardware load information is monitored in real time based on the aforementioned monitoring algorithm; Based on preset parameter adjustment rules, the strategy parameters of the optimization strategy are dynamically adjusted according to the hardware load information to obtain the adjusted optimization strategy. The adjusted optimization strategy is taken as the target optimization strategy.

5. The robot-based task processing method according to claim 1, characterized in that, The step of executing the task based on the target modular algorithm structure and the resource allocation scheme to obtain the corresponding task processing result specifically includes: Obtain the target sub-modules corresponding to the target modular algorithm structure; wherein, the number of target sub-modules includes multiple sub-modules; Construct a corresponding module dependency graph based on the target sub-module; The execution order of each target sub-module is determined based on the module dependency graph, and corresponding hardware resources are allocated to each target sub-module based on the resource allocation scheme to obtain the corresponding designated sub-module; The task is executed based on the specified submodule to obtain the corresponding task processing result.

6. The robot-based task processing method according to claim 5, characterized in that, The step of constructing the corresponding module dependency graph based on the target sub-module specifically includes: Perform input-output analysis on all the target sub-modules to obtain the corresponding input-output relationships; Invoke the preset graphical tools; The input-output relationship is plotted using the graphical tool to obtain the corresponding generated graph. The generated graph is used as the module dependency graph.

7. The robot-based task processing method according to claim 1, characterized in that, After the step of executing the task based on the target modular algorithm structure and the resource allocation scheme to obtain the corresponding task processing result, the method further includes: During the processing of the task, performance feedback data is collected based on a preset performance monitoring strategy; Hardware feedback data is collected based on preset hardware monitoring tools; Environmental feedback data is collected based on preset sensors; The performance feedback data, hardware feedback data, and environmental feedback data are integrated based on timestamps to obtain the corresponding target feedback data; The target feedback data is stored and processed.

8. A robot-based task processing device, characterized in that, include: The receiving module is used to receive the task instruction corresponding to the task to be processed, and to perform requirement parsing on the task instruction to obtain the corresponding task requirement data. The first acquisition module is used to acquire the robot's hardware status data and the current environmental feature data. The analysis module is used to analyze and process the task requirement data, hardware status data and environmental feature data based on a preset requirement modeling engine, and generate corresponding requirement instructions. The processing module is used to perform module splitting and priority sorting of the core algorithm of the robot based on the demand instructions, so as to obtain the modular algorithm structure and priority data corresponding to the sub-modules; wherein, the number of the sub-modules includes multiple; An optimization module is used to optimize the modular algorithm structure based on the priority data and a preset strategy library to obtain the corresponding target modular algorithm structure. The generation module is used to generate a corresponding resource allocation scheme based on the target modular algorithm structure and the preset hardware resource conditions; The execution module is used to perform the execution processing of the task based on the target modular algorithm structure and the resource allocation scheme, and obtain the corresponding task processing result.

9. A computer device, characterized in that, The system includes a memory and a processor, wherein the memory stores computer-readable instructions, and the processor executes the computer-readable instructions to implement the steps of the robot-based task processing method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-readable instructions, which, when executed by a processor, implement the steps of the robot-based task processing method as described in any one of claims 1 to 7.

Images