Design Method of Embodied Intelligence System Based on Artificial Intelligence

Abstract

A design method for an embodied intelligent system based on artificial intelligence, belonging to the field of artificial intelligence technology, automatically generates and optimizes the robot hardware design through modules such as configuration generation, size adjustment, joint information replacement, performance verification, and parameter optimization. Specifically, it includes: using the configuration rule sub-module to automatically generate an initial configuration that meets the requirements; the size rule sub-module adjusts the component size according to the size parameter number; the performance verification module optimizes the controller parameters through the reinforcement learning algorithm and evaluates the robot motion performance through the simulation environment; the parameter optimization module performs performance optimization through the iterative optimization algorithm and feeds the results back to the configuration generation module to achieve a closed-loop of design and optimization. This method can realize the automation of robot hardware design, intelligently optimize performance, significantly improve the design efficiency, reduce manual intervention, lower costs, and accelerate the product iteration speed.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and particularly to a design method for embodied intelligent systems based on artificial intelligence. Background Art

[0002] With the rapid development of robotics technology, the demand for embodied intelligent systems in fields such as industry, healthcare, and services is increasing continuously. Traditional robot design methods usually rely on human experience, require a large amount of time and resources for iterative optimization, and are difficult to meet the requirements of complex and changing application scenarios. In addition, existing design methods usually cannot fully consider the performance of robots in the actual environment during the design stage, resulting in a large gap between the design and actual applications.

[0003] In recent years, significant progress has been made in the field of robot control with artificial intelligence technology, especially reinforcement learning. However, the following deficiencies still exist in the existing technologies in aspects such as robot configuration design, size optimization, and performance verification:

[0004] Limitations in configuration design: Traditional robot configuration design relies on engineers' experience and preset configuration templates, making it difficult to achieve diverse and innovative designs. Existing methods lack systematic theoretical support and cannot efficiently explore the design space, resulting in design results often being limited to known configuration patterns.

[0005] Disconnection between size and performance: During the robot design process, the adjustment of size parameters is usually separated from performance verification, lacking a real-time feedback mechanism. This leads to the designed robot may not meet the expected performance indicators in actual applications, requiring repeated adjustment and testing, increasing the design cost and time.

[0006] Insufficiency in performance verification: Existing technologies mainly rely on physical experiments during the performance verification stage, which are costly and inefficient. At the same time, existing technologies lack adaptability to complex environments and comprehensive evaluation of the performance limits of robots during the simulation stage.

[0007] Limitations of optimization algorithms: Traditional optimization methods such as grid search and random search are inefficient and difficult to quickly locate high-performance regions in a large-scale design space. In addition, existing methods usually only focus on a single performance indicator and cannot meet the requirements of multi-objective optimization.

[0008] The Chinese patent application document with the publication number CN117549310A discloses a general system, construction method and usage method of an embodied intelligent robot. The method includes "an information self-organizing core neural network and an ontology device configured on the robot. Among them, the information self-organizing core neural network includes a large language model, a memory model, a multi-modal perception model and a motion control model, and the ontology device includes a drive system, a mechanical system and a sensor system". It mainly focuses on how to enable the robot to better interact with the environment through multi-modal perception and neural networks. It does not involve: how to automatically design the hardware configuration, size parameters and joint parameters of the robot using artificial intelligence algorithms; how to dynamically adjust the robot model through rule numbers; how to model and predict the parameter space through a Gaussian process model; how to match the generated robot model with the parts in the Mesh library and generate a complete three-dimensional robot model through scaling and replacement; how to optimize the robot control strategy through reinforcement learning, and how to combine the simulation environment for training and verification.

[0009] In summary, there is an urgent need to develop a design method that can achieve the automation and intelligent optimization of robot hardware design to meet the need for quickly generating high-performance robot hardware, while improving design efficiency, reducing costs, and adapting to complex and changing application scenarios. Summary of the Invention

[0010] This application aims to at least partially solve one of the above technical problems.

[0011] To this end, this application provides a design method for an embodied intelligent system based on artificial intelligence, including the following steps:

[0012] According to requirements, an initial robot model description file is generated through an initialization sub-module, and the file contains configuration rule numbers, size parameter numbers and joint parameter numbers;

[0013] Through a robot optimization sub-module, the initial robot model description file generated by the initialization sub-module is received, and iterative optimization is performed based on the selected robot coding data, the parameters in the initial robot model description file are dynamically adjusted, and the updated configuration rule numbers, size parameter numbers and joint parameter numbers are updated;

[0014] Through a configuration rule sub-module, based on the configuration rule numbers output by the robot optimization sub-module, the robot model description file is dynamically adjusted to generate an initial robot configuration that meets the requirements;

[0015] Through a size rule sub-module, based on the size parameter numbers output by the robot optimization sub-module, the size of the robot model is adjusted to update the size information of each component;

[0016] Through the joint library sub-module, based on the joint parameter numbers output by the robot optimization sub-module, search for the most matching joint information in its joint library and replace the corresponding joint information in the original robot model description file;

[0017] Through the performance verification module, use the reinforcement learning algorithm to train the robot model, and dynamically adjust the model parameters according to the performance feedback to optimize the robot performance;

[0018] Through the parameter optimization module, based on the performance parameters fed back by the performance verification module, use the optimization algorithm to iteratively optimize the configuration rule numbers, dimension parameter numbers, and joint parameter numbers of the robot model, and feed the optimization results back to the model generation module to form a closed loop of design and optimization.

[0019] Preferably, the selected robot coding data is obtained through Gaussian process prediction, and the data source is the historical "robot - performance" coding data obtained through the data reading sub-module; when there is no historical data, it is formed after iterative optimization of the initial robot coding randomly generated by the robot optimization sub-module.

[0020] Preferably, the configuration generation steps of the configuration rule sub-module include:

[0021] Configuration rule definition and numbering: Preset configuration generation rules to describe the movement modes and generation methods of the robot in different dimensions in space, and assign a unique number to each rule to support automated operations in the configuration generation process;

[0022] Initial configuration generation: Call the configuration rule number, and according to the configuration generation rule, adjust and replace the configuration information in the robot model description file to generate an initial configuration that conforms to the configuration rule definition.

[0023] Preferably, based on the dimension parameters in the robot model description file adjusted by the dimension rule sub-module, search for matching three-dimensional parts in the Mesh library through the Mesh file call and generation sub-module, and dynamically adjust the part dimensions to meet the configuration requirements; when the parts in the mesh library do not match the dimension parameters in the robot model description file, generate an equi-proportional capsule to replace the unmatched parts to ensure the normal progress of the subsequent simulation process.

[0024] Preferably, the joint parameter numbers include the type, torque, and rotational speed information of the joint. The joint library sub-module automatically matches the joint models that match the torque and rotational speed from the joint library according to the input joint parameter numbers, and generates the corresponding stiffness and damping control parameter files.

[0025] Preferably, the parameter optimization module performs iterative optimization through the optimization algorithm combined with the Gaussian process model, specifically including the following steps:

[0026] Based on the initial robot model description file, several initial robot models are randomly generated, and their performance metrics are obtained through a performance verification module. Each robot model parameter and its performance parameter are stored as a "robot - performance" code;

[0027] Using the "robot - performance" code data, combined with the Gaussian process model, the design parameter space is modeled and predicted to predict new "robot - performance" codes that may have high performance;

[0028] Based on the "robot" code in the new "robot - performance" code, a corresponding simulation model is generated;

[0029] The newly generated simulation model is evaluated for performance through a performance verification module, and the evaluation results are updated to the "performance" code in the "robot - performance" code data;

[0030] Based on the updated "robot - performance" code data, the Gaussian process is used to predict a potentially better configuration and continue iterative optimization;

[0031] After reaching the set number of iterations, the optimal "robot - performance" code is output.

[0032] Preferably, the "robot - performance" code is a series of numbers, respectively representing the configuration rule number and relevant parameter information, forming a unique code. Through this code, the design of the robot can be accurately reproduced, ensuring the uniqueness and traceability of each robot structure.

[0033] Preferably, the performance verification module includes a hyperparameter pre - tuning sub - module. The hyperparameter pre - tuning sub - module obtains robot drive component information by parsing the robot model description json file, and adjusts the controller parameters of the robot in combination with the stiffness and damping control parameter json files corresponding to the components to form a hyperparameter configuration file required for subsequent reinforcement learning, which is used for the configuration of the subsequent reinforcement learning control sub - module.

[0034] Preferably, the performance verification module includes a reinforcement learning control sub - module. The specific operation steps of the reinforcement learning control sub - module are as follows:

[0035] A reinforcement learning controller is established to control the motion behavior of the robot in the simulation environment, and multiple reward functions applicable to the robot are integrated;

[0036] The hyperparameter configuration file generated by the hyperparameter pre - tuning sub - module is input to initialize the training parameters of the controller;

[0037] By running the controller in the simulator to interact with the simulation environment, real-time observation data during the robot's movement is obtained. Based on the reinforcement learning algorithm, training and optimization are carried out using the reward function to improve the robot's movement ability and adaptability in different task environments.

[0038] Preferably, the performance verification module includes a simulator sub-module, and the simulator sub-module includes the following operating steps:

[0039] Load the terrain model and robot model file in the simulation environment to generate a virtual simulation environment and a virtual robot model;

[0040] Start the reinforcement learning controller, perform multiple rounds of reinforcement learning training in the simulation environment, and optimize the control strategy of the robot on different terrains;

[0041] During the simulation training process, output the performance parameters of the robot under the specified terrain through the observation data. The output performance parameters serve as the evaluation results of the robot structure and control strategy, providing a reference basis for subsequent design optimization and practical applications.

[0042] Based on the above technical solutions, it can be seen that this application has at least one of the following beneficial effects compared with the prior art:

[0043] 1. Achieve the automation of robot hardware design

[0044] In the prior art, the robot hardware design usually relies on manual experience and repeated experiments, with low efficiency and difficulty in meeting diverse requirements. This application realizes the automatic generation and optimization of the robot configuration, size, and joint parameters through advanced artificial intelligence algorithms. Specifically:

[0045] (1) Configuration generation

[0046] The system can automatically generate the initial configuration of the robot according to user requirements through the configuration rule sub-module, support the dynamic adjustment of multiple configuration rules, and generate diverse robot structures.

[0047] (2) Size adjustment

[0048] The system realizes the automatic adjustment of the size parameters of each component of the robot through the size rule sub-module. Based on the input size parameter numbers and the robot model description file, it accurately calculates and updates the size parameters of each component to ensure that the designed robot can accurately adapt to the requirements of the actual application scenario.

[0049] (3) Joint parameter optimization and rapid 3D part matching

[0050] The system, through the joint library sub-module, automatically matches the most suitable joint model from the joint library according to the input joint parameter number, and generates corresponding control parameter files such as stiffness and damping. At the same time, based on the description information of the robot model (such as joint type, dimension parameters, etc.), the system searches for matching 3D parts in the mesh library. For the matching parts, the system will adjust them according to the actual size and position requirements, such as scaling the part size to fit the structure of the robot model. It realizes the rapid docking of the robot model with the existing 3D part library, reduces the workload of manual modeling, improves the design efficiency, and ensures the performance and accuracy of the model.

[0051] 2. Intelligent optimization of robot performance

[0052] In the prior art, the verification of robot performance usually relies on physical experiments, which are costly and inefficient. Through simulation verification and optimization algorithms, this application can quickly evaluate and optimize the performance of robots in a virtual environment, such as speed, climbing ability, and stability. This optimization method not only improves the performance but also reduces the dependence on physical experiments and speeds up the product iteration speed.

[0053] 3. Achieving seamless connection between design and manufacturing

[0054] The system can directly output the 3D model of the robot, support the matching with the existing hardware part library and 3D printing processing, and achieve seamless connection from design to manufacturing. This design reduces manual intervention, improves production efficiency, and ensures the consistency between design and manufacturing.

[0055] Other features and advantages of this application will be described in the following specification. And, partly, they will become obvious from the specification, or can be understood by implementing this application. The purpose and other advantages of this application can be realized and obtained through the structures specifically pointed out in the written specification and the attached drawings. Description of the drawings

[0056] Figure 1 It is a schematic diagram of the leg-foot type robot generation system exemplary in this application. Detailed implementation manners

[0057] To make the purpose, technical solutions, and advantages of this application clearer and more understandable, the following further elaborates on this application in detail with reference to specific embodiments and the attached drawings.

[0058] The terms used in the embodiments of this application are only for the purpose of describing specific embodiments and are not intended to limit the embodiments of this application. The singular forms of "a", "the", and "said" used in the embodiments of this application are also intended to include the plural forms unless the context clearly indicates otherwise.

[0059] Aiming at the deficiencies of the prior art, the purpose of this application is to provide a design method for an embodied intelligent system based on artificial intelligence.

[0060] Specifically, the design method for an embodied intelligent system based on artificial intelligence provided by this application includes three main modules: a robot model generation module, a performance verification module, and a parameter optimization module. The three main modules include multiple sub-modules as described below, such as Figure 1 shown, and the following is a detailed description of the specific implementation of each module and its sub-modules.

[0061] 1. Robot Model Generation Module

[0062] Through the robot model generation module, based on the configuration rule numbers, dimension parameter numbers, and joint parameter numbers output by the 3.1 robot optimization sub-module, a robot model that meets the requirements is generated. The robot model generation module includes:

[0063] 1.1 Configuration Rule Sub-module

[0064] Input: The description file of the current robot model (stored in JSON format), configuration rule number.

[0065] Output: The modified new robot model description file (stored in JSON format).

[0066] Function: Based on the preset configuration rules, according to the configuration rule numbers output by the robot optimization sub-module, dynamically modify the optimized robot model description file output by the robot optimization sub-module to generate an initial robot configuration that meets the requirements.

[0067] Configuration Rule Number: The configuration rule number is used to guide the generation and update of the robot model configuration. The configuration rules are defined in number form. Each rule is identified by a unique number and corresponds to specific rule content. For example, rule '1' stipulates that when ['S'] (representing spherical motion) in the model description JSON file is called, it is replaced with ['R', 'R', 'R'] (three rotational motions), and at the same time, the axis direction is modified from ['-'] to [1,0,0], [0,1,0], [0,0,1]; while rule '2' replaces ['S'] with ['R', 'R', 'R'], and the axis direction is modified to [0,1,0], [1,0,0], [0,0,1]. This kind of configuration rule based on numbers, through the dynamic call and combination of rule numbers, enables the system to generate various robot configurations, realizes flexible adjustment and diversified design of the robot model configuration, expands the design space and supports personalized needs, ensures that the generated robot model can meet the requirements of specific application scenarios, and provides a basis for further dimension adjustment and simulation verification.

[0068] Implementation method: Preset a set of configuration generation rules to describe the motion modes and generation methods of the robot in different dimensions of space, and assign a unique number to each rule. By calling the rule number, update the information in the robot model description file, adjust and replace the configuration information in the robot model description file to generate an initial configuration that conforms to the definition of the configuration rules.

[0069] For example, the rules are classified according to the motion characteristics of the robot:

[0070] D (6D rigid body motion): Represents the free motion of the robot in 3 translational directions (u, v, w) and 3 rotational directions;

[0071] G(u) (planar motion): Represents the motion of the robot in a plane perpendicular to a certain axis (such as the u-axis).

[0072] S(N1) (spherical motion): Describes the three-dimensional rotational motion of the robot at a certain point (such as point N1).

[0073] Each configuration rule is assigned a unique number to identify a specific motion mode and its generation method. For example:

[0074] Rule 1: D is decomposed into 'R(N1, u)', 'R(N1, v)', 'G(w)', 'R(N2, u)', that is, the robot rotates around the u and v axes, performs the planar motion G(w), and then rotates around the u axis.

[0075] Rule 4: G(w) is further decomposed into 'R(N3, w)', 'R(N4, w)', 'R(N5, w)', that is, the planar motion is refined into three rotations around different points (N3, N4, N5).

[0076] Assume that the design goal is a biped robot, and each leg requires 6 degrees of freedom. The initial configuration can start from the D rule, such as 'R(N1, u)', 'R(N1, v)', 'G(w)', 'R(N2, u)'.

[0077] Further call the rule number, for example, use Rule 4 to replace G(w) with 'R(N3, w)', 'R(N4, w)', 'R(N5, w)'. The generated leg configuration is: 'R(N1, u)', 'R(N1, v)', 'R(N3, w)', 'R(N4, w)', 'R(N5, w)', 'R(N2, u)'.

[0078] The configuration rule sub-module executes sequentially according to the order of the configuration rule numbers until there are no replaceable motion elements in the current configuration, and the structure generation is completed.

[0079] As in the above generation process, when all planar motions or rotational motions are refined by rules, the system determines the final configuration.

[0080] Preferably, configurations are generated based on the decomposition and combination rules of group theory.

[0081] The union operation of group theory allows different rule combinations to generate diverse configurations. Group theory decomposes complex robot motion requirements into simple motion elements by specifying a series of rules. Each motion element represents the motion of each degree of freedom of the robot, such as R(N1, u), G(w), etc. Under the rules of group theory, these motion elements can be continuously combined or decomposed to finally generate a specific mechanical configuration.

[0082] The union operation and rule combination characteristics of group theory make the configuration generation highly flexible. When facing diverse design requirements, group theory can generate multiple feasible design schemes according to different constraint conditions and degrees of freedom, and optimize by selecting appropriate rules. This provides more degrees of freedom and creative space for the design of complex mechanical systems.

[0083] In addition, the system can automatically identify and generate configurations with symmetry and regularity. For example, the mirror symmetry of the left and right legs of a quadruped robot, the cyclic symmetry of the joint distribution of a hexapod robot, etc. Through the generation of single-leg configurations by group theory, the optimization design process of the entire robot can be quickly realized.

[0084] Preferably, a recursive decomposition method is used for configuration expansion.

[0085] Specifically, recursive decomposition uses multiple rules defined in the group theory rule library to gradually decompose the high-level degrees of freedom in the initial configuration into more refined and specific motion elements. For example, for a robot leg that requires six degrees of freedom, group theory first selects the initial rule D, and then by applying different rules step by step, decomposes the D structure into multiple sub-motion elements, such as R(N1, u), R(N1, v), G(w), R(N2, u), etc. Then, for the elements that can still be further decomposed, such as G(w), group theory continues to apply rules (such as the rules of G(w)) to further decompose it into R(N3, w), R(N4, w), R(N5, w), etc., until all elements reach the simplest form that cannot be further decomposed.

[0086] The condition for the recursion to stop is that when all moving elements can no longer be further decomposed (for example, when the rotating element R can no longer be decomposed), the recursive process automatically terminates, and the configuration is finally determined. The innovation of this method lies in that through recursion, group theory can maximize the expansion of the design space while maintaining design consistency, automatically generate the optimal configuration, and greatly improve the efficiency and accuracy of the design.

[0087] 1.2 Dimension Rule Sub-module

[0088] Input: The current robot model description file (stored in JSON format), dimension parameter number.

[0089] Output: The robot model description file after dimension adjustment (stored in JSON format).

[0090] Function: According to the dimension parameter number output by the robot optimization sub-module, adjust the dimensions of the initial robot configuration, update the dimension information of each component, and output the robot model description file after dimension adjustment.

[0091] Implementation method:

[0092] (1) Read the robot model description file

[0093] Extract the node position information of each component from the JSON file of the robot model description. For example, for a leg, its node position information may be expressed as:

[0094] "pos": [[0,0.15,0],[0,0.15,-0.42],[0,0.15,-0.84],[0,0.15,-0.84]]

[0095] (2) Calculate the dimension parameters

[0096] For each leg, calculate the rod length between adjacent nodes (i.e., the dimension parameter). The calculation method is: take the coordinate difference between adjacent nodes and calculate its Euclidean distance (modulus length). The calculation formula is:

[0097] ; where

[0098] (x1, y1, z1) and (x2, y2, z2): These two sets of coordinates respectively represent the coordinates of two adjacent nodes of a leg in the robot model in three-dimensional space;

[0099] L: Represents the distance between the two points calculated according to the above two-point coordinates, that is, the rod length of this section of the leg in the robot model (i.e., the dimension parameter).

[0100] For the above example, the calculation result is:

[0101] Length of the first rod segment: = 0.15;

[0102] Length of the second rod segment: = 0.42;

[0103] Length of the third rod segment: = 0.42;

[0104] Therefore, the dimensional parameters of this leg are: [0.15, 0.42, 0.42]

[0105] (3)Update dimensional parameters

[0106] According to the input dimensional parameter numbers, update the node positions of each leg. For example, if the input dimensional parameter numbers are [0.2, 0.3, 0.5], assign the input dimensional parameters (such as [0.2, 0.3, 0.5]) to the lengths of each rod segment, recalculate the coordinates of each node, and the updated node coordinates are:

[0107] "pos": [[0, 0.2, 0], [0, 0.2, -0.3], [0, 0.2, -0.8], [0, 0.2, -0.8]]

[0108] (4)Update the robot model description file

[0109] Write the calculated and updated dimensional parameters and node positions into the JSON file describing the robot model to form a new robot model description file with adjusted dimensions, completing the adjustment of the dimensional parameters.

[0110] 1.3 XML file generation sub-module

[0111] Input: The current JSON file describing the robot model.

[0112] Output: The robot XML model file.

[0113] Function: Convert the JSON file describing the robot model into an XML format model file for simulation or other purposes. The finally generated XML file will organize the information of each component according to the hierarchical relationship of the robot model. The XML format is supported by many simulation platforms, modeling tools, and control systems. Converting to XML can more conveniently exchange data between different platforms. A robot is usually composed of multiple components such as links, joints, sensors, etc. There are clear parent-child relationships and connection relationships between these components. Using the XML format can clearly express this hierarchical structure.

[0114] Implementation method: Parse the JSON file, organize the information of each component according to the hierarchical relationship of the robot model, and generate an XML file.

[0115] Take the legged robot as an example:

[0116] Step 1: Check the information about the robot base (base link) in the JSON file and convert it into the first body in the XML file as the robot base.

[0117] Step 2: Check whether the parent of other components (link) is the base. If so, create these components as new bodies and connect them to the specified position of the base.

[0118] Step 3: Continue to check whether the parent of other components is the component that has been processed in the previous round. If so, process it in the same way and gradually build the robot model downwards until the traversal is complete.

[0119] Step 4: According to the name of each component in the JSON file, call the following 1.4 Mesh file call and generation sub-module to generate the mesh model (mesh) of the component, so as to build a complete robot simulation model.

[0120] 1.4 Mesh File Call and Generation Sub-module

[0121] Input: The current robot model description JSON file.

[0122] Output: Mesh files of each part of the robot.

[0123] Function: According to the information in the robot model description file after size adjustment, call the matching 3D parts from the mesh library and make adjustments.

[0124] Implementation method:

[0125] (1) Read the model description JSON file

[0126] Open and read the JSON file to find the description information of each component (link). The information includes the connection position of the component and the motor installation position, etc.

[0127] (2) Call the matching file from the mesh file library

[0128] According to the description in the JSON file, retrieve the mesh files that match these components in the existing mesh file library and make dynamic adjustments to adapt to the size parameters and configuration requirements of the robot model.

[0129] If there is a model in the Mesh library whose robot joint orientation is consistent with the current robot description and the link (robot component) length ratio is similar, it is determined that the matching is successful. The three-dimensional model of the robot is called, and the lengths of each link are scaled to conform to the current robot model. At the same time, parameters such as mass inertia are adjusted accordingly.

[0130] If some links (robot components) cannot be matched, search for the model with the highest similarity in the Mesh library and perform size adjustment based on this model; if the matching requirements are still not met, use equi-proportioned capsules to replace the unmatched link components to ensure the integrity and normal operation of the robot model during the simulation process.

[0131] (3)Rename and save

[0132] After the adjustment is completed, rename each mesh file according to the name of the component in the JSON file. For example: if the name of a component in the JSON is arm_link1, then the corresponding mesh file is named arm_link1.stl. Save all the generated mesh files in the same folder for easy reference in the subsequent XML file.

[0133] 1.5 Joint library sub-module

[0134] Input: The current robot model description JSON file, joint parameter number (the joint parameter number includes information such as the type, torque, and rotational speed of the joint).

[0135] Output: The new robot model description file after joint adjustment, joint mesh file, and the JSON file of the stiffness and damping control parameters corresponding to the joint.

[0136] Function: According to the joint parameter number output by the robot optimization sub-module, match the closest joint model from the joint library, replace the corresponding joint information in the robot model description file after size adjustment, and output the robot model description file after joint adjustment.

[0137] Implementation method: The joint library contains various joint parameters and appearance models, and there is a corresponding JSON file of stiffness and damping control parameters. According to the input joint parameter number, search for the closest joint information in the joint library, replace the corresponding joint information in the robot model description file after size adjustment, and generate the corresponding mesh file (mesh) and control parameter file. The specific steps are as follows:

[0138] (1)Load the joint library

[0139] The joint library contains information on various common joints in the market and self-made joints. Each joint includes the following data in the library:

[0140] Joint parameters: including performance parameters such as type, torque, rotational speed, and self-weight.

[0141] Appearance model (Mesh): used to represent the appearance of the joint.

[0142] Control parameters: such as stiffness and damping, etc., used to describe the dynamic control characteristics of the joint.

[0143] (2) Match joint information

[0144] According to the input joint parameter number, search for the joint information closest to the input parameters in the joint library, and replace the information of the corresponding joint in the current robot model description file with the found joint parameters.

[0145] (3) Output results

[0146] Generate the corresponding mesh file (mesh) and control parameter file (including stiffness, damping, etc.) for each replaced joint, and output the robot model description JSON file after joint adjustment, the joint mesh mesh file, and the stiffness and damping control parameter JSON file to prepare for subsequent simulation or control.

[0147] 2. Performance verification module

[0148] 2.1 Terrain generation sub-module

[0149] Input: Terrain type and parameters.

[0150] Output: Terrain model in the simulation environment.

[0151] Function: Generate a simulation terrain of the specified type and parameters for testing the performance of the robot on this terrain.

[0152] Implementation method: The terrain generation sub-module includes several types of fixed terrains, such as flat ground, slopes, steps, etc. Each terrain has variable parameters to adjust the passing difficulty of the terrain, such as the slope of the slope, the number of steps and height of the steps, etc. The corresponding simulation terrain can be directly generated through the input terrain type and parameters.

[0153] Example: Suppose the input terrain type is "slope" and the slope is 30 degrees. The terrain generation sub-module will generate a simulation terrain model of a 30-degree slope.

[0154] 2.2 Hyperparameter pre-tuning sub-module

[0155] Input: Robot model description JSON file, joint corresponding stiffness and damping control parameter JSON file.

[0156] Output: Reinforcement learning hyperparameter configuration file.

[0157] Function: Obtain information about drive components such as the number of robot drive joints, drive joint names, and stiffness and damping control parameters of drive joints according to the robot model description file after joint adjustment. Combine the stiffness and damping control parameter files corresponding to the components to adjust the controller parameters of the robot model, and form a hyperparameter configuration file required for reinforcement learning for the subsequent configuration of the reinforcement learning control sub-module.

[0158] Implementation method:

[0159] (1) Parse the robot model description JSON file and read information such as the number of robot drive joints and drive joint names;

[0160] (2) Read the JSON file of the stiffness and damping control parameters corresponding to the joints to obtain the control parameter values of the joints, such as stiffness and damping coefficients.

[0161] (3) Adjust and optimize the hyperparameters of the reinforcement learning controller, such as the control parameters of PD (Proportional-Derivative controller), according to the parsed model information and control parameters.

[0162] Example: Assume that the robot model description file contains 6 drive joints. The hyperparameter pre-tuning sub-module will parse this file and combine the parameter values (such as stiffness coefficient and damping coefficient) in the stiffness and damping control parameter JSON file of the joints to adjust and configure the parameters of the controller (such as proportional gain and derivative gain). Finally, a reinforcement learning hyperparameter configuration file will be generated. This configuration file contains the optimized control parameters for this robot model and is used for subsequent reinforcement learning training.

[0163] 2.3 Reinforcement Learning Control Sub-module

[0164] Input: Reinforcement learning hyperparameter configuration file.

[0165] Output: Reinforcement learning controller, the trained controller model file, which will be named and stored with the robot-specific data encoding to ensure the uniqueness of each controller file for clear correspondence to the specific robot model.

[0166] Function: Establish a reinforcement learning controller to optimize the robot motion control strategy in the simulation environment.

[0167] Implementation method: Based on the existing reinforcement learning algorithms, a reinforcement learning training system is developed, which is specifically used to optimize the robot control strategy to meet the specific requirements of robot control. A reward function library designed for such robots is constructed. By reading the reinforcement learning hyperparameter configuration file and connecting to the emulator to read the observed quantities, the reinforcement learning training can be directly carried out. The specific steps are as follows:

[0168] (1) Establish a reinforcement learning controller

[0169] Based on the design method of existing general reinforcement learning frameworks (such as NVIDIA Isaac Gym, Legged Gym, etc.), for the target robot type (such as legged robots), a reinforcement learning controller is constructed to control the motion behavior of the robot in the simulation environment, and a proprietary reward function library applicable to this type of robot is integrated. The reward function is optimized for the motion control of the robot, and the setting of the reward function takes into account multiple key performance indicators, specifically including but not limited to:

[0170] Punish the angular velocity of the robot on the plane (x and y axes): to encourage the robot to avoid unnecessary horizontal rotation, and the penalty term is the penalty coefficient multiplied by the sum of the squares of the angular velocities;

[0171] Punish the robot for deviating from the horizontal attitude: that is, encourage the robot to maintain a stable horizontal attitude, and the penalty term is the penalty coefficient multiplied by the sum of the squares of the horizontal components of the projection of the gravity vector in the robot's base coordinate system;

[0172] Punish the linear velocity of the robot along the vertical direction (z axis): encourage the robot to maintain horizontal motion, and the penalty term is the penalty coefficient multiplied by the square value of the z-axis velocity;

[0173] Punish excessive joint torques: to avoid the robot exerting excessive force and ensure smooth joint operation, and the penalty term is the penalty coefficient multiplied by the sum of the squares of the joint torques;

[0174] Punish excessive joint velocities: encourage the robot to maintain a smooth motion speed, and the penalty term is the penalty coefficient multiplied by the sum of the squares of the joint velocities;

[0175] Punish high joint accelerations: to reduce unnecessary accelerations and ensure the smoothness of the robot's motion, and the penalty term is the penalty coefficient multiplied by the sum of the squares of the joint accelerations;

[0176] Punish rapid changes in actions: avoid sudden changes in the robot's actions and maintain smooth and stable actions, and the penalty term is the penalty coefficient multiplied by the sum of the squares of the action changes;

[0177] Punish collisions in certain parts: such as collisions between the legs, to ensure the stability and safety of the robot during motion, and the penalty term is the penalty coefficient multiplied by the number of leg collisions;

[0178] Punish the joint positions approaching the limit range: encourage the robot to avoid excessive joint extension or contraction and maintain the stability of motion;

[0179] Reward the accuracy of the robot base tracking the linear velocity command: encourage the robot to move at the expected speed, and the reward term is the reward coefficient multiplied by the square of the difference between the actual speed and the desired speed of the base;

[0180] Reward the robot for a longer hanging time of its legs: Encourage the robot to maintain a stable gait. The reward is the reward coefficient multiplied by the value of the recorded air time of the legs.

[0181] These reward functions are designed for specific tasks of the robot, ensuring that the robot can effectively learn behaviors that meet the task requirements during the reinforcement learning process. These professional reward functions dynamically guide the optimization of the control strategy during training, enabling the reinforcement learning control sub-module to efficiently train the robot to perform tasks in the simulation environment while improving its motion performance to adapt to the diverse needs in practical applications.

[0182] (2)Read the hyperparameter configuration file

[0183] By parsing the input reinforcement learning hyperparameter configuration file, initialize the training parameters of the controller, mainly including parameters such as the proportional gain and derivative gain of the controller. These parameters are used to adjust the performance of the reinforcement learning controller to adapt to the specific hardware characteristics of the robot (such as joint stiffness and damping).

[0184] Example: Suppose the gait smoothness reward and energy consumption efficiency reward are defined in the reinforcement learning hyperparameter configuration file. The reinforcement learning control sub-module will train according to these reward functions to generate an optimized control strategy.

[0185] (3)Connect to the simulation environment and perform reinforcement learning training

[0186] Run the controller in the simulator to interact with the simulation environment for reinforcement learning of robot control. In the simulation environment, based on the reinforcement learning algorithm, the controller, according to the feedback of the reward function, continuously optimizes its behavior strategy through trial and error and iterative learning. During training, the controller reads the observation data (such as sensor information of speed, position, angle, etc.) during the robot's movement in real time and trains and optimizes according to the reward function, continuously adjusting the control strategy to gradually achieve the target action, so as to improve the robot's motion ability and adaptability in different task environments.

[0187] In each training iteration, the system generates a set of "robot - performance" codes to record the optimization results of the current iteration. The "robot - performance" code includes a "robot" code and a "performance" code. Among them, the "robot" code is generated from the robot model parameters, and the "performance" code is generated from the performance parameters. Suppose the maximum speed reached by the robot in this round of training is 2.3 m / s, then the result of this round of training will be encoded as a set of numbers, which includes the various parameters of the robot (such as configuration rule numbers and related parameter information, etc.), as well as the final performance (i.e., the maximum speed). An example of the "robot - performance" code for this round of iteration is as follows:

[0188] ‘[[1], [0.2, 0.3, 0.5], [121, 50, 135, 54, 30, 60, 80, 120, 30, 30,60, 80]], [2.3]’, where [[1], [0.2, 0.3, 0.5], [121, 50, 135, 54, 30, 60, 80,120, 30, 30, 60, 80]] represents the "robot" code in the "robot - performance" coding data, including various model parameters of the robot. The model parameters include information composed of the configuration rule number, dimension parameter number, and joint parameter number arrangement, and a corresponding simulation model can be generated based on this; [2.3] represents the "performance" code in the "robot - performance" coding data, and 2.3 represents the maximum speed in the training result.

[0189] This set of codes will be stored by the data storage sub - module. A set of such codes will be generated in each iteration to record the optimization results at that time. After reaching the set number of iterations, the "robot - performance" code with the highest performance parameter among all the codes will be selected and output to the user as the robot model with the optimal performance. This code is a unique code, and through this code, the design of the robot can be accurately reproduced, ensuring the uniqueness and traceability of each robot structure.

[0190] 2.4 Simulator Sub - module

[0191] Input:

[0192] (1) Terrain model in the simulation environment: Define the virtual terrain scenarios for the robot to move, such as flat ground, slopes, complex terrains, etc.;

[0193] (2) Robot xml model and mesh file: Model files describing the structure and appearance of the robot, including information such as geometric shape, material, joint configuration, etc.;

[0194] (3) Reinforcement learning controller: Used to control the movement behavior of the robot in the simulation environment.

[0195] Output: Robot performance parameters, including performance indicators such as the average speed, energy consumption, self - weight, and terrain passing ability of the robot under the specified terrain.

[0196] Function: The simulator sub - module provides an efficient and repeatable training environment, allowing the robot to perform multiple rounds of reinforcement learning under different terrain conditions, evaluating the performance of the current robot structure on specific terrains, and providing a simulation environment for the training of the reinforcement learning controller. Through simulation verification, the performance parameters of the robot in the virtual environment can be quickly obtained, avoiding cumbersome or costly tests in the actual environment, and thus guiding the optimization of robot design and the adjustment of control strategies.

[0197] Implementation method: Based on the existing emulator, functions such as input of control quantities and output of observed quantities for the robot are realized, which can be called by the reinforcement learning control sub-module for learning to meet more advanced robot control requirements. After multiple rounds of learning, the robot can move on the specified terrain, and performance indicators such as the average speed, power consumption, self-weight, and terrain passing ability passed by the robot can be calculated through the observed quantities, and the performance parameters corresponding to the current robot model are output.

[0198] Example: Suppose the robot has completed one round of training in the simulation environment. The emulator sub-module will output that the average speed of the robot is 2.3 m / s, the power consumption is 100 W, the self-weight is 50 kg, and the terrain passing ability is a 30-degree slope.

[0199] 3. Parameter Optimization Module

[0200] 3.1 Robot Optimization Sub-module

[0201] Input: Set the number of iterations, type of performance requirements, initial robot model description JSON file, and "robot - performance" historical encoding.

[0202] Output: The potentially high-performance "robot - performance" encoding obtained through the optimization process, and at the same time output the optimized configuration rule number, dimension parameter number, and joint parameter number.

[0203] Function: Used to quickly search and optimize various robot structural forms within the preset rules to find the optimal design that may meet the performance requirements.

[0204] Implementation method: Through the iterative optimization algorithm combined with the Gaussian process model for performance prediction and optimization. Based on the initial model description JSON file, several initial robot models are randomly generated, and their performance parameters are obtained through the performance verification module. Each robot model parameter and its performance parameter are stored as a "robot - performance" encoding; the Gaussian process model is used to model and predict the design parameter space to identify the "robot - performance" encoding that may have high performance; based on the new "robot - performance" encoding, the corresponding new simulation model is generated;

[0205] The newly generated simulation model is continuously iteratively optimized and performance evaluated through the performance verification module, and the evaluation results are updated to the "performance" encoding in the "robot - performance" encoding data; then based on all the updated encoding data, the Gaussian process is used to predict the possible better configuration and continue the next round of iteration; after reaching the set number of iterations, the optimal "robot - performance" encoding is output, and the optimization result is fed back to the model generation module for further optimization of the configuration, forming a closed loop of design and optimization.

[0206] The operation of the entire system starts from the 3.1 robot optimization submodule, which reads the historical "robot-performance" coding data through the 3.4 data reading submodule, predicts a set of "robot-performance" coding with the best performance through the Gaussian process model based on the historical coding data, and starts the next round of iteration. If there is no historical coding data, the 3.1 robot optimization submodule will randomly generate several initial robot models based on the initial model description JSON file provided by the 3.2 initialization submodule, and obtain its performance indicators through the performance verification module to form the initial "robot-performance" coding.

[0207] Subsequently, the system enters an iterative optimization process based on the above robot coding data, and continues to use the Gaussian process model to predict potentially better robot coding until the set maximum number of iterations is reached.

[0208] After reaching the set number of iterations, the system outputs the optimal "robot-performance" code, and at the same time outputs the corresponding configuration rule number, size parameter number, and joint parameter number. These numbers are used to guide the specific operations of subsequent modules (such as configuration rule submodule, size rule submodule, and joint library submodule) to achieve further optimization of the robot model. The final optimization result not only provides a high-performance robot model for the current design, but also provides a reference for subsequent designs, forming a closed loop of design and optimization.

[0209] Through the collaborative work of these modules, the system can automatically generate and optimize the design of the robot, and finally output a unique code representing a high-performance robot model. This process not only improves design efficiency, but also ensures the advancement and adaptability of robot design.

[0210] 3.2 Initializing submodules

[0211] Input: User's basic description of the robot's morphology.

[0212] Output: JSON file describing the robot's initial model, configuration rule number, size parameter number, and joint parameter number.

[0213] Function: Initialize the basic model parameters of the robot according to user requirements.

[0214] Implementation method: Based on the LLM model, an initial robot JSON description file is output according to user requirements (such as: needing a bipedal robot with humanoid legs), which includes information such as the number of legs and feet, base information, and single-leg degrees of freedom.

[0215] Example: Assuming the user requirement is "need a bipedal robot with human-like legs", the initialization submodule will generate an initial robot model description file containing two legs, each with 6 degrees of freedom.

[0216] 3.3 Data Saving Sub-module

[0217] Function: Record the data generated after each iteration in the robot optimization sub-module, including: "robot - performance" encoding, iteration algebra, optimal robot encoding and other data.

[0218] Implementation method: Save through a JSON file for subsequent reading, updating and expansion.

[0219] 3.4 Data Reading Sub-module

[0220] Function: Read all the recorded "robot - performance" encoding data, iteration algebra, optimal robot encoding and other data.

[0221] Implementation method: Read the data in the saved file.

[0222] Seamless Connection between Design and Manufacturing

[0223] The system allows users to customize the application scenarios and working environments of the robot and optimize the performance of the robot model in these scenarios. The system can automatically generate and optimize the robot design, and output configuration parameters (such as degrees of freedom, joint orientations, and connection relationships), main dimension parameters (such as motor installation positions, joint positions, leg lengths, etc.), and drive parameters (such as joint motor models, battery models, etc.). In addition, if the Mesh library in the system contains existing Mesh parts that match the design, the system can directly output the three-dimensional model of the whole machine, which can be used for the final manual design or directly for 3D printing and processing. The parts printed by 3D printing can be precisely assembled to form a complete robot hardware body, realizing the seamless connection from design to manufacturing. This method not only improves the automation degree of the design, but also ensures that the designed robot model can be efficiently converted into an actual hardware product to meet specific application requirements. At the same time, through the integration with the Mesh library, the design efficiency is further improved, providing users with an efficient, flexible and cost-effective robot development experience.

[0224] The specific embodiments of the present application have been described above. Additionally, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In certain embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0225] In the description of the embodiments of the present application, the descriptions referring to terms such as "one embodiment", "some embodiments", "examples", "specific examples", or "some examples" mean that the specific features, structures, materials, or characteristics described in connection with the embodiment or example are included in at least one embodiment or example of the embodiments of the present application. In the embodiments of the present application, the schematic expressions of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials, or characteristics described can be combined in any one or more embodiments or examples in a suitable manner. In addition, without contradiction, those skilled in the art can combine and combine the different embodiments or examples described in the embodiments of the present application and the features of different embodiments or examples.

[0226] In addition, the terms "first" and "second" are used only for descriptive purposes and cannot be understood as indicating or implying relative importance or implicitly specifying the quantity of the indicated technical features, excluding any order. Thus, the features defined with "first" and "second" may explicitly or implicitly include at least one of such features and are used to distinguish each other. In the description of the embodiments of the present application, the meaning of "a plurality" is at least two, such as two, three, etc., unless otherwise specifically and clearly defined.

[0227] Any process or method description shown in a flowchart or described in other ways herein can be understood as representing a module, segment, or part of code including one or more executable instructions for implementing a customized logic function or process, and the scope of the preferred embodiments of the embodiments of the present application includes additional implementations, where the functions may be executed in a manner that is not in the order shown or discussed, including in a substantially simultaneous manner according to the functions involved or in a reverse order, which should be understood by those skilled in the art to which the embodiments of the present application belong.

[0228] The above are only the preferred embodiments of the embodiments of the present application and are not intended to limit the embodiments of the present application. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the embodiments of the present application shall be included within the scope of protection of the embodiments of the present application.

Claims

1. A method for designing an embodied intelligent system based on artificial intelligence, characterized in that: The artificial intelligence-based embodied intelligent system design method comprises the following steps: According to the requirements, an initial robot model description file is generated through the initialization submodule, and the file includes a configuration rule number, a size parameter number, and a joint parameter number; The robot optimization submodule receives the initial robot model description file generated by the initialization submodule, performs iterative optimization based on the robot coding data, outputs the optimized robot model description file, and updates the optimized configuration rule number, size parameter number, and joint parameter number; A robot model that meets the requirements is generated through a robot model generation module based on the configuration rule number, size parameter number and joint parameter number output by the robot optimization submodule; the robot model generation module includes: A configuration rule submodule adjusts the optimized robot model description file based on the configuration rule number output by the robot optimization submodule to generate an initial robot configuration that meets the requirements; A size rule submodule, based on the size parameter number output by the robot optimization submodule, adjusts the size of the initial robot configuration, updates the size information of each component, and outputs a robot model description file after the size adjustment; A joint library submodule searches for the joint information that best matches the joint parameter number output by the robot optimization submodule in its joint library, replaces the corresponding joint information in the robot model description file after the size adjustment, and outputs the robot model description file after the joint adjustment; Through the performance verification module, the robot model is trained using the reinforcement learning algorithm, and the model parameters are dynamically adjusted according to performance feedback to optimize the robot performance parameters; Through the parameter optimization module, based on the performance parameters fed back by the performance verification module, the robot model is iteratively optimized using the optimization algorithm, and the optimization results are fed back to the configuration generation module to form a closed loop of design and optimization.

2. The method for designing an embodied intelligent system based on artificial intelligence according to claim 1, characterized in that: The robot coding data is obtained through Gaussian process prediction, and the data comes from the historical "robot-performance" coding data obtained through the data reading submodule; when there is no historical "robot-performance" coding data, the initial robot coding data is randomly generated through the robot optimization submodule.

3. The method for designing an embodied intelligent system based on artificial intelligence according to claim 1, characterized in that: The initial robot configuration generation step of the configuration rule submodule includes: Configuration rule definition and numbering: Preset configuration generation rules to describe the robot's movement and generation methods in different dimensions in space, and assign a unique number to each rule to support the automation of the configuration generation process; Initial robot configuration generation: calling the configuration rule number, adjusting and replacing the configuration information in the optimized robot model description file according to the configuration generation rule, and generating an initial robot configuration that meets the configuration rule definition.

4. The method for designing an embodied intelligent system based on artificial intelligence according to claim 1, characterized in that: Based on the size parameters in the robot model description file after the size adjustment, the matching three-dimensional parts are searched in the Mesh library through the Mesh file call and generation sub-module, and the part size is dynamically adjusted to meet the configuration requirements; if the parts in the mesh library do not match the size parameters in the robot model description file after the size adjustment, a proportional capsule body is generated to replace the mismatched parts to ensure the normal progress of the subsequent simulation process.

5. The method for designing an embodied intelligent system based on artificial intelligence according to claim 1, characterized in that: The joint parameter number includes the type, torque and speed information of the joint. The joint library submodule automatically matches the joint model that matches the torque and speed from the joint library through the input joint parameter number, and generates the corresponding stiffness and damping control parameter file.

6. The method for designing an embodied intelligent system based on artificial intelligence according to claim 1, characterized in that: The parameter optimization module performs iterative optimization by combining an optimization algorithm with a Gaussian process model, specifically including the following steps: Based on the initial robot model description file, a number of initial robot models are randomly generated, and their performance parameters are obtained through a performance verification module, and each robot model parameter and its performance parameter are stored as a "robot-performance" code, wherein the "robot-performance" code includes a "robot" code and a "performance" code, wherein the "robot" code is generated by the robot model parameter, and the "performance" code is generated by the performance parameter; Using the robot-performance coding data and the Gaussian process model to model and predict the design parameter space, a new robot-performance coding with high performance is predicted; Generate the corresponding simulation model based on the "robot" code in the new "robot-performance" code; The newly generated simulation model is evaluated for performance through the performance verification module, and the evaluation results are updated to the "Performance" code in the "Robot-Performance" code data; Based on the updated "robot-performance" coding data, the Gaussian process is used to predict the optimal configuration and continue iterative optimization; After reaching the set number of iterations, the optimal "robot-performance" code is output.

7. The method for designing an embodied intelligent system based on artificial intelligence according to claim 6, characterized in that: The "robot-performance" code is a series of numbers, and the "robot" code includes a configuration rule number, a size parameter number and a joint parameter number, which constitute a unique code. The design of the robot model can be accurately reproduced through the unique code, ensuring the uniqueness and traceability of each robot model structure.

8. The method for designing an embodied intelligent system based on artificial intelligence according to claim 1, characterized in that: The performance verification module includes a hyperparameter pre-tuning module, which obtains the robot driving component information by parsing the robot model description file after the joint adjustment, and adjusts the controller parameters of the robot model in combination with the stiffness and damping control parameter files corresponding to the components to form a hyperparameter configuration file required for reinforcement learning, which is used for the configuration of the subsequent reinforcement learning control submodule.

9. The method for designing an embodied intelligent system based on artificial intelligence according to claim 8, characterized in that: The performance verification module also includes a reinforcement learning control submodule, and the specific operation steps of the reinforcement learning control submodule include: Establish a reinforcement learning controller to control the motion behavior of the robot model in the simulation environment and integrate multiple reward functions applicable to the robot model; Input the hyperparameter configuration file generated by the hyperparameter pre-tuning module to initialize the training parameters of the controller; By running the controller in the simulator to interact with the simulation environment, the observation data of the robot model in motion is obtained in real time. Based on the reinforcement learning algorithm, the reward function is used for training and optimization to improve the robot model's motion ability and adaptability in different task environments.

10. The method for designing an embodied intelligent system based on artificial intelligence according to claim 9, characterized in that: The performance verification module includes a simulator submodule, and the simulator submodule includes the following operation steps: Load the terrain model and robot model files in the simulation environment to generate a virtual simulation environment and a virtual robot model; Starting the reinforcement learning controller, executing multiple rounds of reinforcement learning training in the simulation environment, and optimizing the control strategy of the robot model on different terrains; During the simulation training process, the performance parameters of the robot model under the specified terrain are output through observation quantities. The output performance parameters serve as the evaluation results of the robot model structure and control strategy, providing a reference for subsequent design optimization and practical application.

Images