Design method of intelligent system with body based on artificial intelligence

Abstract

The invention relates to an artificial intelligence-based design method for an intelligent system with a body, belongs to the technical field of artificial intelligence, and automatically generates and optimizes robot hardware design through modules of configuration generation, size adjustment, joint information replacement, performance verification, parameter optimization and the like. The method specifically comprises the following steps: automatically generating an initial configuration meeting requirements by utilizing a configuration rule sub-module; the size rule sub-module adjusts the component size according to the size parameter number; the performance verification module optimizes controller parameters through a reinforcement learning algorithm, and evaluates the motion performance of the robot through a simulation environment; and the parameter optimization module performs performance optimization through an iterative optimization algorithm and feeds back a result to the configuration generation module, so that a closed loop of design and optimization is realized. According to the method, automation and intelligent optimization performance of robot hardware design can be realized, the design efficiency is remarkably improved, manual intervention is reduced, the cost is reduced, and the product iteration speed is increased.

Description

Technical Field

[0001] The present application relates to the field of artificial intelligence technology, and specifically to an embodied intelligent system design method based on artificial intelligence. Background Art

[0002] With the rapid development of robotics technology, the demand for embodied intelligent systems in the fields of industry, medicine and services is increasing. Traditional robot design methods usually rely on manual experience, require a lot of time and resources for iterative optimization, and are difficult to meet the needs of complex and changing application scenarios. In addition, existing design methods usually fail to fully consider the performance of robots in actual environments during the design stage, resulting in a large gap between design and actual application.

[0003] In recent years, artificial intelligence technology, especially reinforcement learning, has made significant progress in the field of robot control. However, the existing technology still has the following shortcomings in robot configuration design, size optimization and performance verification: Limitations of configuration design: Traditional robot configuration design relies on engineers’ experience and preset configuration templates, which makes it difficult to achieve diversified 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.

[0004] Disconnection between size and performance: In the robot design process, the adjustment of size parameters is usually separated from performance verification, and there is a lack of real-time feedback mechanism. This results in the designed robot not being able to achieve the expected performance indicators in actual applications, requiring repeated adjustments and testing, which increases design costs and time.

[0005] Insufficient performance verification: The existing technology mainly relies on physical experiments in the performance verification stage, which is costly and inefficient. At the same time, the existing technology lacks adaptability to complex environments and comprehensive evaluation of the robot's performance limits in the simulation stage.

[0006] Limitations of optimization algorithms: Traditional optimization methods such as grid search and random search are inefficient and have difficulty quickly locating high-performance areas in large-scale design spaces. In addition, existing methods usually only focus on a single performance indicator and cannot meet the needs of multi-objective optimization.

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

[0008] In summary, there is an urgent need to develop a design method that can realize the automation and intelligent optimization of robot hardware design to meet the needs of rapid generation of high-performance robot hardware, while improving design efficiency, reducing costs, and adapting to complex and changing application scenarios. Summary of the invention

[0009] The present application aims to at least partially solve one of the above technical problems.

[0010] To this end, the present application provides an artificial intelligence-based embodied intelligent system design method, comprising 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 screened robot coding data, dynamically adjusts the parameters in the initial robot model description file, and updates the optimized configuration rule number, size parameter number, and joint parameter number; Through the configuration rule submodule, based on the configuration rule number output by the robot optimization submodule, the robot model description file is dynamically adjusted to generate an initial robot configuration that meets the requirements; Through the size rule submodule, the robot model is resized based on the size parameter number output by the robot optimization submodule, and the size information of each component is updated; Through the joint library submodule, based on the joint parameter number output by the robot optimization submodule, the joint library is searched for the joint information that best matches it, and the corresponding joint information in the original robot model description file is replaced; 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; Through the parameter optimization module, based on the performance parameters fed back by the performance verification module, the optimization algorithm is used to iteratively optimize the configuration rule number, size parameter number and joint parameter number of the robot model, and the optimization results are fed back to the model generation module to form a closed loop of design and optimization.

[0011] Preferably, the screened robot coding data is obtained through Gaussian process prediction, and the source of the data is the historical "robot-performance" coding data obtained through the data reading submodule; when there is no historical data, the initial robot coding randomly generated by the robot optimization submodule is iteratively optimized and formed.

[0012] Preferably, the configuration generating 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 configuration generation: Call the configuration rule number, adjust and replace the configuration information in the robot model description file according to the configuration generation rule, and generate an initial configuration that meets the configuration rule definition.

[0013] Preferably, based on the size parameters in the robot model description file adjusted by the size rule submodule, the matching three-dimensional parts are searched in the Mesh library through the Mesh file call and generation submodule, 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, a proportional capsule body is generated to replace the mismatched parts to ensure the normal progress of the subsequent simulation process.

[0014] Preferably, 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.

[0015] Preferably, the parameter optimization module performs iterative optimization by combining an optimization algorithm with a Gaussian process model, specifically comprising the following steps: Based on the initial robot model description file, several initial robot models are randomly generated, and their performance indicators are obtained through the performance verification module. Each robot model parameter and its performance parameter are stored as a "robot-performance" code; Using the robot-performance coding data and the Gaussian process model to model and predict the design parameter space, we can predict new robot-performance codings that may have high performance. Generate a 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 possible optimal configuration and continue iterative optimization; After reaching the set number of iterations, the optimal "robot-performance" code is output.

[0016] Preferably, the "robot-performance" code is a series of numbers, which respectively represent the configuration rule number and related parameter information, forming a unique code, through which the design of the robot can be accurately reproduced, ensuring the uniqueness and traceability of each robot structure.

[0017] Preferably, the performance verification module includes a hyperparameter pre-tuning submodule, which obtains the robot driving component information by parsing the robot model description json file, and adjusts the robot's controller parameters in combination with the stiffness and damping control parameter json file 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.

[0018] Preferably, the performance verification module includes a reinforcement learning control submodule, and the specific operation steps of the reinforcement learning control submodule include: Build a reinforcement learning controller to control the robot's motion behavior in a simulation environment and integrate multiple reward functions applicable to the robot; 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 and making it interact with the simulation environment, the observation data of the robot's 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's motion ability and adaptability in different task environments.

[0019] Preferably, 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; Start the reinforcement learning controller and perform multiple rounds of reinforcement learning training in the simulation environment to optimize the robot's control strategy on different terrains; During the simulation training process, the performance parameters of the robot under the specified terrain are output through observation. The output performance parameters serve as the evaluation results of the robot structure and control strategy, providing a reference for subsequent design optimization and practical application. Based on the above technical solution, it can be seen that the present application has at least one of the following beneficial effects compared with the prior art: 1. Automating Robot Hardware Design In the prior art, robot hardware design usually relies on manual experience and repeated experiments, which is inefficient and difficult to meet diverse needs. This application uses advanced artificial intelligence algorithms to achieve automatic generation and optimization of robot configuration, size and joint parameters. Specifically: (1) Configuration generation Through the configuration rule submodule, the system can automatically generate the initial configuration of the robot according to user needs, support dynamic adjustment of multiple configuration rules, and generate diverse robot structures.

[0020] (2) Size adjustment The system uses the size rule sub-module to automatically adjust the size parameters of each component of the robot. Based on the input size parameter number and 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 needs of actual application scenarios.

[0021] (3) Joint parameter optimization and rapid matching of 3D parts Through the joint library submodule, the system automatically matches the joint model that best meets the performance requirements from the joint library according to the input joint parameter number, and generates corresponding stiffness, damping and other control parameter files. At the same time, the system searches for matching 3D parts in the mesh library according to the description information of the robot model (such as joint type, size parameters, etc.). For 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. The robot model is quickly connected to the existing 3D parts library, which reduces the workload of manual modeling, improves design efficiency, and ensures the performance and accuracy of the model.

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

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

[0024] Other features and advantages of the present application will be described in the subsequent description, and in part will become apparent from the description, or it may be understood through the implementation of the present application that the objects and other advantages of the present application can be realized and obtained through the written description and the structures particularly pointed out in the drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0025] Figure 1 Generate a system schematic for the exemplary legged robot in this application. DETAILED DESCRIPTION

[0026] In order to make the objectives, technical solutions and advantages of the present application more clearly understood, the present application is further described in detail below in combination with specific embodiments and with reference to the accompanying drawings.

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

[0028] In view of the deficiencies of the prior art, the purpose of this application is to provide an embodied intelligent system design method based on artificial intelligence.

[0029] Specifically, the artificial intelligence-based embodied intelligent system design method provided in 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 As shown, the following is a detailed description of the specific implementation of each module and its sub-modules.

[0030] 1. Robot model generation module Through the robot model generation module, based on the configuration rule number, size parameter number and joint parameter number output by the 3.1 robot optimization submodule, a robot model that meets the requirements is generated. The robot model generation module includes: 1.1 Configuration rule submodule Input: description file of the current robot model (stored in JSON format), configuration rule number.

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

[0032] Function: Based on the preset configuration rules and the configuration rule number output by the robot optimization submodule, the optimized robot model description file output by the robot optimization submodule is dynamically modified to generate an initial robot configuration that meets the requirements.

[0033] Configuration rule number: The configuration rule number is used to guide the configuration generation and update of the robot model. The configuration rules are defined in the form of numbers. Each rule is identified by a unique number and corresponds to a specific rule content. For example, rule '1' stipulates that when ['S'] (indicating spherical motion) in the model description JSON file is called, it is replaced with ['R', 'R', 'R'] (three rotational motions), and the axis is changed from ['-'] to [1,0,0], [0,1,0], [0,0,1]; while rule '2' replaces ['S'] with ['R', 'R', 'R'], and the axis is changed to [0,1,0], [1,0,0], [0,0,1]. This number-based configuration rule, through the dynamic calling and combination of rule numbers, the system can generate a variety of robot configurations, realize flexible adjustment and diversified design of robot model configurations, expand the design space and support personalized needs, ensure that the generated robot model can meet the needs of specific application scenarios, and provide a basis for further size adjustment and simulation verification.

[0034] Implementation method: preset a set of configuration generation rules to describe the movement and generation methods of the robot in different dimensions in space, and assign a unique number to each rule. By calling the rule number, the information in the robot model description file is updated, the configuration information in the robot model description file is adjusted and replaced, and the initial configuration that meets the definition of the configuration rule is generated.

[0035] For example, the rules are classified according to the robot's motion characteristics: D (6-dimensional rigid body motion): represents the free motion of the robot in three translation directions (u, v, w) and three rotation directions; G(u) (plane motion): represents the motion of the robot in a plane perpendicular to an axis (such as the u axis); S(N1) (spherical motion): describes the three-dimensional rotational motion of the robot at a certain point (such as point N1).

[0036] Each configuration rule is assigned a unique number that identifies a specific motion pattern and how it is generated. For example: Rule 1: D is decomposed into 'R(N1, u)', 'R(N1, v)', 'G(w)', 'R(N2, u)', i.e. the robot rotates around the u and v axes, performs the planar motion G(w), and then rotates around the u axis.

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

[0038] Assuming the design goal is a bipedal robot, each leg needs 6 degrees of freedom, and the initial configuration can start from the D rule, such as 'R(N1, u)', 'R(N1, v)', 'G(w)', 'R(N2, u)'.

[0039] Further calling the rule number, for example, using rule 4, replacing G(w) with 'R(N3, w)', 'R(N4, w)', 'R(N5, w)', the generated leg configurations are: 'R(N1, u)', 'R(N1, v)', 'R(N3, w)', 'R(N4, w)', 'R(N5, w)', 'R(N2, u)'.

[0040] The configuration rule submodule is executed in sequence according to the configuration rule number order until there is no replaceable motion element in the current configuration, and the structure generation is completed.

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

[0042] Preferably, the configuration is generated based on decomposition and combination rules of group theory.

[0043] The combination of group theory allows different rules to generate a variety of 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. These motion elements can be continuously combined or decomposed under the rules of group theory to eventually generate a specific mechanical configuration.

[0044] The parallel operation and rule combination characteristics of group theory make configuration generation highly flexible. When faced with diverse design requirements, group theory can generate multiple feasible design solutions based on different constraints and degrees of freedom, and optimize them by selecting appropriate rules. This provides more freedom and creative space for the design of complex mechanical systems.

[0045] 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. By generating single-leg configurations using group theory, the optimization design process of the entire robot can be quickly realized.

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

[0047] Specifically, recursive decomposition uses multiple rules defined in the group theory rule base to gradually decompose the high-level degrees of freedom in the initial configuration into more detailed 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 decomposes the D structure into multiple sub-motion elements by applying different rules step by step, such as R(N1, u), R(N1, v), G(w), R(N2, u), etc. Then, for elements that can still be decomposed, such as G(w), group theory continues to apply rules (such as the rule 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.

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

[0049] 1.2 Size rule submodule Input: current robot model description file (stored in JSON format), size parameter number.

[0050] Output: The resized robot model description file (stored in JSON format).

[0051] Function: According to the size parameter number output by the robot optimization submodule, adjust the size of the initial robot configuration, update the size information of each component, and output the robot model description file after the size adjustment.

[0052] Implementation: (1) Read the robot model description file Extract the node position information of each component from the JSON file describing the robot model. For example, for a leg, its node position information may be represented as: "pos": [[0,0.15,0],[0,0.15,-0.42],[0,0.15,-0.84],[0,0.15,-0.84]] (2) Calculate size parameters For each leg, calculate the rod length (i.e., size parameter) between adjacent nodes. The calculation method is: take the coordinate difference of adjacent nodes and calculate their Euclidean distance (modulus length). The calculation formula is: ;in, (x1, y1, z1) and (x2, y2, z2): These two sets of coordinates represent the coordinates of two adjacent nodes of a leg in the robot model in three-dimensional space; L: represents the distance between the two points calculated based on the coordinates of the above two points, that is, the rod length of the leg in the robot model (i.e., the size parameter).

[0053] For the above example, the calculation results are: First section length: =0.15; Length of the second section: =0.42; Length of the third section: =0.42; Therefore, the size parameters of this leg are: [0.15, 0.42, 0.42] (3) Update size parameters Update the node position of each leg according to the input size parameter number. For example, if the input size parameter number is [0.2, 0.3, 0.5], assign the input size parameter (such as [0.2, 0.3, 0.5]) to the length of each segment, and recalculate the coordinates of each node. The updated node coordinates are: "pos": [[0, 0.2, 0], [0, 0.2, -0.3], [0, 0.2, -0.8], [0, 0.2, -0.8]] (4) Update the robot model description file The calculated and updated size parameters and node positions are written into the JSON file describing the robot model to form a new size-adjusted robot model description file, thus completing the size parameter adjustment.

[0054] 1.3 XML file generation submodule Input: Current robot model description JSON file.

[0055] Output: Robot XML model file.

[0056] Function: Convert the JSON file describing the robot model into a model file in XML format for simulation or other purposes. The resulting 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 make it easier to exchange data between different platforms. Robots are usually composed of multiple links, joints, sensors, and other components. These components have clear parent-child relationships and connection relationships. Using XML format can clearly express this hierarchical structure.

[0057] 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.

[0058] Take the legged robot as an example: Step 1: Check the information about the robot base link in the JSON file and convert it into the first body in the XML file as the robot base.

[0059] Step 2: Check if 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.

[0060] Step 3: Continue to check whether the parent components of other components are components that have been processed in the previous round. If so, process them in the same way and gradually build the robot model downward until the traversal is completed.

[0061] Step 4: According to the name of each component in the JSON file, call the following 1.4mesh file call and generate sub-modules to generate the mesh model (mesh) of the component, thereby building a complete robot simulation model.

[0062] 1.4 Mesh file call and generation submodule Input: Current robot model description JSON file.

[0063] Output: mesh files of each part of the robot.

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

[0065] Implementation: (1) Read the model description JSON file 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.

[0066] (2) Call the matching file from the mesh library According to the description in the JSON file, mesh files matching these parts are retrieved from the existing mesh file library (mesh), and dynamically adjusted to adapt to the size parameters and configuration requirements of the robot model.

[0067] If there is a model in the Mesh library whose robot joint orientation is consistent with the current robot description and whose link (robot component) length ratio is similar, the match is considered successful, the robot 3D model is called, and the length of each link is scaled to match the current robot model, and parameters such as mass inertia are adjusted accordingly.

[0068] If some links (robot components) cannot be matched, the model with the highest similarity is found in the Mesh library and the size is adjusted based on the model; if the matching requirements still cannot be met, the unmatched link components are replaced with proportional capsules to ensure that the robot model can maintain integrity and operate normally during the simulation process.

[0069] (3) Rename and save 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 generated mesh files in the same folder for easy reference in subsequent XML files.

[0070] 1.5 Joint Library Submodule Input: current robot model description JSON file, joint parameter number (joint parameter number includes joint type, torque, speed and other information).

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

[0072] Function: According to the joint parameter number output by the robot optimization submodule, 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.

[0073] Implementation method: The joint library contains a variety of joint parameters and appearance models, and a set of corresponding stiffness and damping control parameter JSON files. 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 the size adjustment, and generate the corresponding mesh file (mesh) and control parameter file. The specific steps are as follows: (1) Loading the joint library The joint library contains information about many common types of joints on the market and self-made joints. Each joint in the library includes the following data: Joint parameters: including type, torque, speed, weight and other performance parameters.

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

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

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

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

[0078] 2. Performance verification module 2.1 Terrain generation submodule Input: Terrain type and parameters.

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

[0080] Function: Generate a simulated terrain of specified type and parameters to test the performance of the robot under the terrain.

[0081] Implementation method: The terrain generation submodule contains several types of fixed terrains, such as flat land, slopes, stairs, etc. Each terrain has variable parameters to adjust the difficulty of passing the terrain, such as the slope of the slope, the number and height of the stairs, etc. The corresponding simulated terrain can be directly generated by inputting the terrain type and parameters.

[0082] Example: Assuming the input terrain type is "slope" and the slope is 30 degrees, the terrain generation submodule will generate a simulated terrain model with a 30-degree slope.

[0083] 2.2 Hyperparameter Pre-tuning Module Input: robot model description JSON file, joint corresponding stiffness and damping control parameter JSON file.

[0084] Output: Reinforcement learning hyperparameter configuration file.

[0085] Function: According to the robot model description file after joint adjustment, obtain the driving component information such as the number of robot driving joints, driving joint names, driving joint stiffness and damping control parameters, and adjust the controller parameters of the robot model in combination with the stiffness and damping control parameter files corresponding to the components to form the hyperparameter configuration file required for reinforcement learning, which is used for the configuration of the subsequent reinforcement learning control submodule.

[0086] Implementation: (1) Parse the robot model description JSON file and read the number of robot drive joints, drive joint names and other information; (2) Read the JSON file of the joint's corresponding stiffness and damping control parameters to obtain the joint's control parameter values, such as stiffness and damping coefficient.

[0087] (3) Based on the analyzed model information and control parameters, the hyperparameters of the reinforcement learning controller, such as the control parameters of the PD (proportional-derivative controller), are adjusted and configured for optimization.

[0088] Example: Assuming that the robot model description file contains 6 driving joints, the hyperparameter tuning module will parse the file and adjust and configure the controller parameters (such as proportional gain and differential gain) in combination with the parameter values ​​(such as stiffness coefficient and damping coefficient) in the joint stiffness and damping control parameter JSON file. Finally, a reinforcement learning hyperparameter configuration file is generated, which contains the control parameters optimized for the robot model for subsequent reinforcement learning training.

[0089] 2.3 Reinforcement Learning Control Submodule Input: Reinforcement learning hyperparameter configuration file.

[0090] Output: reinforcement learning controller. The trained controller model file will be named and stored with the robot-specific data encoding to ensure the uniqueness of each controller file so that it can clearly correspond to the specific robot model.

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

[0092] Implementation: Based on the existing reinforcement learning algorithm, a reinforcement learning training system is developed to optimize the robot control strategy to meet the specific needs of robot control. A reward function library designed specifically for this type of robot is built. Reinforcement learning training can be directly performed by reading the reinforcement learning hyperparameter configuration file and connecting the simulator to read the observations. The specific steps are as follows: (1) Building a reinforcement learning controller Based on the design methods of existing general reinforcement learning frameworks (such as NVIDIA Isaac Gym, Legged Gym, etc.), a reinforcement learning controller is built for the target robot type (such as legged robots) to control the robot's motion behavior in the simulation environment. A proprietary reward function library suitable for this type of robot is integrated. The reward function is optimized for the robot's motion control. The setting of the reward function takes into account multiple key performance indicators, including but not limited to: Penalize the robot's angular velocity on the plane (x and y axis): to encourage the robot to avoid unnecessary horizontal rotations. The penalty term is the penalty coefficient multiplied by the sum of the squares of the angular velocities. Penalize the robot for deviation from the horizontal posture: that is, encourage the robot to maintain a stable horizontal posture. The penalty term is the penalty coefficient multiplied by the square sum of the horizontal components of the projection of the gravity vector in the robot's base coordinate system. Penalize the robot's linear velocity along the vertical direction (z-axis): encourage the robot to maintain horizontal movement, and the penalty term is the penalty coefficient multiplied by the square of the z-axis velocity; Penalize excessive joint torque: to avoid excessive force on the robot and ensure smooth joint operation. The penalty term is the penalty coefficient multiplied by the square sum of the joint torques. Penalize excessive joint speed: Encourage the robot to maintain a stable movement speed. The penalty term is the penalty coefficient multiplied by the square sum of the joint speeds. Penalize high acceleration of joints: to reduce unnecessary acceleration and ensure the smoothness of robot motion. The penalty term is the penalty coefficient multiplied by the square sum of joint accelerations. Penalize rapid changes in action: Avoid sudden changes in the robot's action and keep the action smooth and stable. The penalty term is the penalty coefficient multiplied by the sum of the squares of the action changes. Penalize collisions of certain parts: for example, collisions between the legs, to ensure the stability and safety of the robot during movement. The penalty term is the penalty coefficient multiplied by the number of collisions between the legs. Penalize joint positions close to the limit range: Encourage the robot to avoid excessive extension or contraction of joints and maintain stability of movement; Reward the accuracy of the robot base tracking line speed 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 of the base and the expected speed; Reward the robot's legs for a longer hanging time: Encourage the robot to maintain a stable gait. The reward is the reward coefficient multiplied by the value of the recorded leg air time.

[0093] 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 the training process, allowing the reinforcement learning control submodule to efficiently train the robot to perform tasks in a simulation environment while improving its motion performance to meet the diverse needs of practical applications.

[0094] (2) Read the hyperparameter configuration file By parsing the input reinforcement learning hyperparameter configuration file, the training parameters of the controller are initialized, mainly including the controller's proportional gain and differential gain. 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).

[0095] Example: Assuming that gait smoothness reward and energy efficiency reward are defined in the reinforcement learning hyperparameter configuration file, the reinforcement learning control submodule will be trained according to these reward functions to generate an optimized control policy.

[0096] (3) Connecting to the simulation environment to enhance learning training Run the controller in the simulator to interact with the simulation environment and conduct reinforcement learning of robot control. In the simulation environment, based on the reinforcement learning algorithm, the controller continuously optimizes its behavior strategy through trial and error and iterative learning according to the feedback of the reward function. During the training process, the controller reads the observed data of the robot's motion in real time (such as sensor information such as speed, position, angle, etc.), and performs training optimization according to the reward function, continuously adjusts the control strategy, and gradually achieves the target action to improve the robot's motion ability and adaptability in different task environments.

[0097] At 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 the "robot" code and the "performance" code, where the "robot" code is generated by the robot model parameters and the "performance" code is generated by the performance parameters. Assuming that the maximum speed achieved by the robot in this round of training is 2.3m / s, 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 the configuration rule number and related parameters, etc.), as well as the final performance (i.e., the maximum speed). The "robot-performance" code example for this iteration is as follows: '[[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" code data, including various model parameters of the robot. The model parameters include information composed of the configuration rule number, size parameter number and joint parameter number arrangement, based on which the corresponding simulation model can be generated; [2.3] represents the "performance" code in the "robot-performance" code data, and 2.3 represents the highest speed in the training result.

[0098] This set of codes will be stored by the data storage submodule. In each round of iteration, a set of codes will be generated to record the optimization results at that time. After reaching the set number of iterations, the "robot-performance" code with the highest performance parameters among all codes will be selected and output to the user as the robot model with the best performance. This code is a unique code, which can accurately reproduce the design of the robot and ensure the uniqueness and traceability of each robot structure.

[0099] 2.4 Simulator submodule enter: (1) Terrain model in the simulation environment: defines the virtual terrain scene in which the robot moves, such as flat ground, slopes, complex terrain, etc. (2) Robot XML model and mesh file: Model files that describe the robot structure and appearance, including information such as geometry, material, and joint configuration; (3) Reinforcement learning controller: used to control the robot’s motion behavior in a simulation environment.

[0100] Output: Robot performance parameters, including average speed, energy consumption, weight, terrain passability and other performance indicators of the robot in the specified terrain.

[0101] Function: The simulator submodule provides an efficient and repeatable training environment, allowing the robot to conduct multiple rounds of reinforcement learning under different terrain conditions, evaluate the performance of the robot's current structure on a specific terrain, and provide a simulation environment for the training of reinforcement learning controllers. Through simulation verification, the performance parameters of the robot in the virtual environment can be quickly obtained, avoiding tedious or costly testing in the actual environment, thereby guiding the robot design optimization and control strategy adjustment.

[0102] Implementation method: Based on the existing simulator, it is expanded to realize the functions of inputting control quantity and outputting observation quantity of the robot, which can be called by the reinforcement learning control submodule for learning to adapt to more advanced robot control requirements. After multiple rounds of learning, the robot can move under the specified terrain. The average speed, power consumption, weight, terrain passing ability and other performance indicators of the robot can be calculated through the observation quantity, and the performance parameters corresponding to the current robot model can be output.

[0103] Example: Assuming that the robot completes a round of training in a simulation environment, the simulator submodule will output that the robot's average speed is 2.3 m / s, power consumption is 100 W, weight is 50 kg, and terrain passability is 30 degree slope.

[0104] 3. Parameter optimization module 3.1 Robot Optimization Submodule Input: set the number of iterations, performance requirement type, initial robot model description JSON file, "robot-performance" history code.

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

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

[0107] Implementation method: Use iterative optimization algorithm combined with Gaussian process model to predict and optimize performance. Based on the initial model description JSON file, randomly generate several initial robot models, and obtain their performance parameters through the performance verification module. Store each robot model parameter and its performance parameter as a "robot-performance" code; use the Gaussian process model to model and predict the design parameter space, and identify the "robot-performance" code that may have high performance; based on the new "robot-performance" code, generate the corresponding new simulation model; The newly generated simulation model is iteratively optimized and evaluated through the performance verification module, and the evaluation results are updated to the "performance" code in the "robot-performance" coding data; then, based on all the updated coding 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" coding is output, and the optimization results are fed back to the model generation module for further optimization of the configuration, forming a closed loop of design and optimization.

[0108] 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.

[0109] 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.

[0110] 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.

[0111] 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.

[0112] 3.2 Initializing submodules Input: User's basic description of the robot's morphology.

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

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

[0115] 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.

[0116] 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.

[0117] 3.3 Data Storage Submodule Function: Record the data generated after each iteration in the robot optimization submodule, including: "robot-performance" coding, iterative algebra, optimal robot coding and other data.

[0118] Implementation method: Save through JSON file to facilitate subsequent reading, updating and expansion.

[0119] 3.4 Data reading submodule Function: Read all recorded "robot-performance" coding data, iterative algebra, optimal robot coding and other data.

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

[0121] Seamless integration of design and manufacturing The system allows users to customize the robot's application scenarios and working environment, and optimize the performance of the robot model in these scenarios. The system can automatically generate and optimize the robot design, and the output includes configuration parameters (such as degrees of freedom, joint orientation and connection relationship, etc.), main size parameters (such as motor installation position, joint position, leg length, etc.), and driver parameters (such as joint motor model, battery model, etc.). In addition, if the Mesh library in the system contains existing Mesh parts that match the design, the system can directly output the 3D model of the whole machine, which can be used for manual final design or direct 3D printing. The parts printed by 3D can be precisely assembled to form a complete robot hardware body, realizing seamless connection from design to manufacturing. This method not only improves the degree of automation of 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 integration with the Mesh library, the design efficiency is further improved, providing users with an efficient, flexible and cost-effective robot development experience.

[0122] The above describes specific embodiments of the present application. In addition, the processes depicted in the accompanying drawings do not necessarily require the specific order or sequential order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0123] In the description of the embodiments of the present application, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" etc. means that the specific features, structures, materials or characteristics described in conjunction 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 representations of the above terms do not necessarily refer to the same embodiments or examples. Moreover, the specific features, structures, materials or characteristics described may be combined in any one or more embodiments or examples in a suitable manner. In addition, those skilled in the art may combine and combine the different embodiments or examples described in the embodiments of the present application and the features of the different embodiments or examples, without contradicting each other.

[0124] In addition, the terms "first" and "second" are used for descriptive purposes only and are not to be understood as indicating or implying relative importance or implicitly indicating the number of indicated technical features, and do not include any ordering. Thus, the features defined as "first" and "second" may explicitly or implicitly include at least one of the features and are used to distinguish each other. In the description of the embodiments of the present application, the meaning of "multiple" is at least two, for example, two, three, etc., unless otherwise clearly and specifically defined.

[0125] Any process or method description in a flowchart or otherwise described herein may be understood to represent a module, fragment or portion of code comprising one or more executable instructions for implementing the steps of a custom logical function or process, and the scope of the preferred implementation of the embodiments of the present application includes alternative implementations in which functions may not be performed in the order shown or discussed, including performing functions in a substantially simultaneous manner or in reverse order depending on the functions involved, which should be understood by technicians in the technical field to which the embodiments of the present application belong.

[0126] The above description is only a preferred embodiment of the embodiments of the present application and is not intended to limit the embodiments of the present application. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the embodiments of the present application should be included in 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; Generate a robot model that meets the requirements based on the configuration rule number, size parameter number and joint parameter number output by the robot optimization submodule through the robot model generation module; 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 model generation module comprises: 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; The joint library submodule searches for the best-matching joint information in its joint library based on the joint parameter number output by the robot optimization submodule, replaces the corresponding joint information in the size-adjusted robot model description file, and outputs the robot model description file after joint adjustment.

3. 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.

4. The method for designing an embodied intelligent system based on artificial intelligence according to claim 2, 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.

5. The method for designing an embodied intelligent system based on artificial intelligence according to claim 2, 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.

6. The method for designing an embodied intelligent system based on artificial intelligence according to claim 2, 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.

7. 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.

8. The method for designing an embodied intelligent system based on artificial intelligence according to claim 7, 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.

9. The method for designing an embodied intelligent system based on artificial intelligence according to claim 2, 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.

10. The method for designing an embodied intelligent system based on artificial intelligence according to claim 9, 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.

11. The method for designing an embodied intelligent system based on artificial intelligence according to claim 10, 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 observations. 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