Modeling operations of functional structures

Abstract

The invention particularly relates to a computer-implemented method for learning a generative autoencoder. The generative autoencoder is configured for generating a functional structure. The functional structure is a data structure representing a mechanical assembly of rigid parts. The data structure comprises a tree. The tree comprises leaf nodes. Each leaf node represents a shape and a positioning of a respective rigid part and a force exerted on the respective rigid part. The tree further comprises non-leaf nodes, each non-leaf node having a number of child nodes. Each non-leaf node having a number of child nodes represents a mechanical link between sub-assemblies. Each sub-assembly is represented by a respective one of the number of child nodes. The tree further comprises non-leaf nodes having a single child node. Each non-leaf node having a single child node represents a copy of a sub-assembly represented by the single child node. The method comprises providing a dataset comprising the functional structure. The method further comprises learning the generative autoencoder on the dataset. This constitutes an improved method for learning a generative autoencoder configured for generating a functional structure.

Description

Technical Field

[0001] This invention relates to the field of computer programs and systems, and more particularly to methods, systems, and programs for learning generative autoencoders configured to generate functional structures. Background Technology

[0002] The market offers numerous systems and programs for the design, engineering, and manufacturing of objects. CAD stands for Computer-Aided Design, and for example, CAD involves software solutions for designing objects. CAE stands for Computer-Aided Engineering, and for example, CAE involves software solutions for simulating the physical behavior of future products. CAM stands for Computer-Aided Manufacturing, and for example, CAM involves software solutions for defining manufacturing processes and operations. In such computer-aided design systems, graphical user interfaces play a crucial role in the efficiency of the technology. These technologies can be embedded in Product Lifecycle Management (PLM) systems. PLM refers to a business strategy that helps companies share product data, apply common processes, and leverage enterprise knowledge across extended enterprise concepts to develop products from concept to the end of their lifecycle. Dassault Systèmes (traded as CATIA, ENOVIA, and DELMIA) provides PLM solutions that offer an engineering center for organizing product engineering knowledge, a manufacturing center for managing manufacturing engineering knowledge, and an enterprise center for achieving enterprise integration and connecting the engineering and manufacturing centers. The entire system provides an open object model that links products, processes, and resources to enable dynamic, knowledge-based product creation and decision support, driving optimized product definition, manufacturing preparation, production, and service.

[0003] In this context and other contexts, machine learning is becoming increasingly important.

[0004] Existing methods involve the context of the learning task on 3D shapes, but they deliver unrealistic results in the context of CAD. In reality, unlike images or videos, 3D shapes do not possess natural parametric characteristics on a conventional raster. Existing methods choose to represent 3D shapes using meshes, point clouds, voxels, or multi-view representations. These representations of 3D do not consider a fundamental characteristic of 3D shapes: their hierarchical structure. CAD 3D data inherently incorporates this aspect through the product structure definition.

[0005] Recent successes of deep neural networks in computer vision, speech recognition, and natural language processing have inspired researchers to apply this model to 3D shape analysis. Much of this work has focused on extending computer vision techniques developed for images (2D graticets of pixels) to 3D graticets of voxels. Methods such as those by J. Wu et al. (J. Wu, C. Zhang, T. Xue, WT Freeman, JBTenenbaum, Learning a Probabilistic Latent Space of Object Shapes via 3D Generative-Adversarial Modeling, 2016) have successfully learned the probabilistic latent space of object shapes in voxel form. At its core, their model is a generative decoder that takes shape codes as input and generates voxel graticets as output. The decoder is trained adversarially and can be linked to existing encoders that map, for example, 2D images to corresponding shape codes. This approach supports simple arithmetic and interpolation of the codes, enabling variations such as topological transformations between different shapes. However, these methods are unable to handle hierarchical data such as CAD data.

[0006] In this context, there is still a need for an improved method for learning generative autoencoders configured to generate functional structures. Summary of the Invention

[0007] Therefore, a method for learning a computer implementation of a generative autoencoder is provided. The generative autoencoder is configured to generate functional structures. The functional structure is a data structure representing a mechanical assembly of rigid parts. The data structure includes a tree. The tree includes leaf nodes. Each leaf node represents the shape and positioning of the corresponding rigid part and the forces applied to the corresponding rigid part. The tree also includes non-leaf nodes, each having several child nodes. Each non-leaf node with several child nodes represents a mechanical link between sub-assemblies. Each sub-assembly is represented by a corresponding child node from the several child nodes. The tree also includes non-leaf nodes with a single child node. Each non-leaf node with a single child node represents a copy of the sub-assembly represented by that single child node. The method includes providing a dataset comprising the functional structures. The method also includes learning a generative autoencoder on the dataset.

[0008] The method may include one or more of the following:

[0009] - A mechanical link is an adjacency relationship between subassemblies, which may optionally belong to a predetermined set of adjacency relationships;

[0010] - A copy is a symmetry relation between instances of a subassembly, which optionally belongs to a predetermined set of symmetry relations;

[0011] - The shape and position of the corresponding rigid part are represented by the data of the specifications including the bounding box around the corresponding rigid part, and the force applied to the corresponding rigid part is the resultant force;

[0012] -Generative autoencoders include:

[0013] • An encoder, comprising a leaf encoding module, a mechanically linked encoding module, and a copy encoding module; and

[0014] • The decoder includes a node classifier, a leaf decoding module, a mechanical link decoding module, and a copy decoding module;

[0015] The encoder is configured to encode a tree into a single latent vector based on a recursive bottom-up process, given a functional structure, where:

[0016] • The leaf coding module outputs a corresponding latent vector for each leaf node based on the data including the bounding box specifications and the resultant force;

[0017] The mechanical link encoding module outputs a corresponding latent vector for each non-leaf node representing a mechanical link, based on several latent vectors encoded from several child nodes of the corresponding non-leaf nodes; and

[0018] The replica encoding module outputs a corresponding latent vector for each non-leaf node representing a replica, based on the latent vector encoded for the corresponding individual child nodes of the non-leaf nodes.

[0019] The decoder is configured to decode a given single latent vector into a tree of functional structures according to a recursive top-down process, where:

[0020] • The node classifier classifies each latent vector generated during decoding as corresponding to a leaf node, a non-leaf node representing a mechanical link, or a non-leaf node representing a copy;

[0021] The leaf decoding module, based on latent vectors, outputs data including the specifications of the corresponding bounding box and the corresponding resultant force for each latent vector classified as corresponding to a leaf node during decoding.

[0022] The mechanical link decoding module, based on latent vectors, outputs several sub-latest vectors for each latent vector classified during decoding as corresponding to a non-leaf node representing a mechanical link; and

[0023] • The replica decoding module outputs a single sub-latent vector based on the latent vector, for each latent vector that is classified during decoding as corresponding to a non-leaf node representing a replica;

[0024] - Each node in one or more nodes of at least a portion of the functional structure of the dataset is labeled with a label from a predetermined list, and the method further includes learning a latent space classifier configured to take a latent vector as input and label the latent vector using a label from a predetermined list of labels; and / or

[0025] - The bounding box and the resultant force are represented by the first and second coordinates of the same vector, respectively.

[0026] A generative autoencoder capable of learning based on the method is also proposed. The generative autoencoder has an encoder and a decoder.

[0027] A method for using a computer-based implementation of a generative autoencoder is also proposed. The method includes providing one or more latent vectors. The method also includes generating a functional structure. Generation involves decoding each latent vector using a decoder.

[0028] The usage method may include one or more of the following:

[0029] - Perform topology optimization on mechanical assemblies of rigid parts represented by the generated functional structures;

[0030] - Generate generating forces, each force represented by a leaf node of the tree included in the generated functional structure, and wherein the generated forces form the input for topology optimization; and / or

[0031] - The autoencoder is able to learn according to claim 6:

[0032] One or more latent vectors include a first latent vector and a second latent vector;

[0033] • Decoding generates a corresponding latent vector for each of the first and second latent vectors, the corresponding latent vector including the corresponding intermediate latent vector;

[0034] The generation of the functional structure includes performing interpolation operations between the first intermediate latent vector of the first latent vector and the second intermediate latent vector of the second latent vector, based on the same label used to label the first intermediate latent vector and the second intermediate latent vector of the second latent vector.

[0035] A computer program is also provided, which includes instructions for performing the method and / or using the method.

[0036] An apparatus is also provided, which includes a data storage medium on which a generative automatic encoder and / or a computer program are recorded.

[0037] The device can be formed or used as a non-transitory computer-readable medium, such as on SaaS (Software as a Service) or other server or cloud-based platforms. The device may alternatively include a processor coupled to the data storage medium. Therefore, the device can form wholly or partially of a computer system (e.g., the device is a subsystem of the overall system). The system may also include a graphical user interface coupled to the processor. Attached Figure Description

[0038] Embodiments of the invention will now be described by way of non-limiting example and with reference to the accompanying drawings, wherein:

[0039] - Figure 1 The flowcharts for the integration method and the usage method are shown;

[0040] - Figure 2 An example of the system is shown; and

[0041] - Figures 3 to 15 The method is shown. Detailed Implementation

[0042] A method for learning a computer implementation of a generative autoencoder is proposed. The generative autoencoder is configured to generate functional structures. The functional structure is a data structure representing mechanical assemblies of rigid parts. The data structure includes a tree. The tree includes leaf nodes. Each leaf node represents the shape and positioning of the corresponding rigid part and the forces applied to the corresponding rigid part. The tree also includes non-leaf nodes, each with several child nodes. Each non-leaf node with several child nodes represents a mechanical link between sub-assemblies. Each sub-assembly is represented by a corresponding child node from the several child nodes. The tree also includes non-leaf nodes with a single child node. Each non-leaf node with a single child node represents a copy of the sub-assembly represented by that single child node. The method includes providing a dataset comprising the functional structures. The method also includes learning a generative autoencoder on the dataset. Such a method may be referred to as a "learning method".

[0043] This constitutes an improved method for learning generative autoencoders configured to generate functional structures.

[0044] It should be noted that the generative autoencoder learned according to the learning method is configured to generate functional structures on the fly (because the autoencoder is generative), each functional structure representing a corresponding mechanical assembly of a rigid part, since the generative autoencoder is learned on a dataset that includes such functional structures. The generative autoencoder accurately generates these functional structures (i.e., the level of realism of the generated functional structures is as close as possible to the level of realism of the functional structures in the dataset), because the generative autoencoder is learned to do so. Such functional structures are hierarchical data structures, as they comprise a tree comprising: leaf nodes, each leaf node representing the shape and location of the corresponding rigid part and the forces applied to the corresponding rigid part; non-leaf nodes, each non-leaf node having several child nodes, and each non-leaf node representing a mechanical link between sub-assemblies (each sub-assembly represented by a corresponding child node among several child nodes); and non-leaf nodes having a single child node, and each non-leaf node representing a copy of the sub-assembly represented by that single child node. In other words, the tree captures the relationships between parts and / or sub-assemblies of a mechanical assembly of a part (i.e., mechanical links (e.g., adjacency relationships) and copies (e.g., symmetry relationships)) and their hierarchical arrangement. In other words, the learning method can process the hierarchical data structure of the mechanical assembly of a design part and generate an autoencoder capable of generating such a data structure on the fly. Therefore, this learning method allows for the generation of physically realistic CAD data that can be directly utilized in the design and / or manufacturing process, as explained below.

[0045] Furthermore, functional structures are particularly well-suited for (e.g., as) datasets used to learn generative autoencoders; for example, functional structures allow for robust learning of generative autoencoders on provided datasets that include functional structures. Additionally, a functional structure is a data structure that is much more compact than a low-level 3D model.

[0046] Furthermore, each tree in the dataset on which the generative autoencoder learns according to the learning method has leaf nodes representing the shape and positioning of the corresponding rigid part. This means that the functional structure generated by the generative autoencoder includes trees with such leaf nodes. This generated functional structure is thus suitable for topology optimization (i.e., suitable for performing topology optimization on the functional structure). In fact, as is known in the field of topology optimization itself, the topology optimization algorithm / method / process to be performed on the mechanical assembly of a part (or on the data structure or 3D modeling object representing the mechanical assembly) specifically takes physical forces (e.g., loads applied to the parts of the assembly) as input. The learning method produces an autoencoder capable of generating data structures (i.e., leaf nodes) that include data representing such forces. Therefore, the learning method produces an autoencoder capable of generating on-the-fly data structures representing the mechanical assembly of a part and suitable for topology optimization.

[0047] In examples of learning methods, which will be discussed further below, generative autoencoders include an encoder configured to encode a tree into a single latent vector with respect to a given functional structure, following a recursive bottom-up process. In these examples, generative autoencoders include a decoder configured to decode a given single latent vector into a tree of the functional structure, following a recursive top-down process. In these examples, each of one or more nodes in the tree of at least a portion (e.g., the entire functional structure) of the dataset can be labeled with a label from a predetermined list of labels, and the learning method may further include learning a latent space classifier. A latent space classifier is a neural network configured to take a latent vector as input and label the latent vector using a label from a predetermined list of labels.

[0048] In other words, intermediate latent vectors are generated through a recursive top-down decoding process that produces the trees included in the functional structure by decoding a given single latent vector into a tree. An intermediate latent vector is a latent vector encoding one of three nodes, which can be a root node, a leaf node, or a non-leaf node that is not a root node. Each of these nodes can correspond to a meaningful substructure of a part's mechanical assembly. This means that intermediate latent vectors encoding nodes corresponding to meaningful substructures of a part's mechanical assembly (e.g., particularly meaningful subassemblies of the part) are generated during the decoding process. This learning method produces a latent space classifier on the tree that can take the intermediate latent vectors generated during the decoding process as input and label them using labels from a predetermined list of labels for the nodes of these trees corresponding to such substructures. The labels can instruct the intermediate latent vector to encode nodes corresponding to meaningful substructures, or specifically, nodes without corresponding substructures (e.g., labels that might correspond to labels that do not exist). In the first case, the latent space classifier is, in other words, able to identify and label meaningful substructures in the middle during the decoding process. This allows operations to be performed on and / or between substructures, such as interpolation or hybrid operations as the limiting case of interpolation (which will be discussed further below). Therefore, more and / or more diverse functional structures can be generated by generative autoencoders.

[0049] A generative autoencoder capable of learning based on a learning method is also proposed. The generative autoencoder has an encoder and a decoder.

[0050] A method for using a computer-based implementation of a generative autoencoder is also proposed. The method involves providing one or more latent vectors. The method also includes generating a functional structure. Generation involves decoding each latent vector using a decoder. This method may be referred to as a "generative method".

[0051] Therefore, the generative method generates one or more functional structures. The generative method can generate more than one functional structure. For example, generation can include fully decoding each latent vector individually (i.e., until recursive top-down decoding is complete) into the corresponding functional structure. Thus, the generative method generates hierarchical data structures on the fly, each hierarchical data structure representing the corresponding mechanical assembly of the part in a physically realistic way.

[0052] Alternatively or additionally, one or more latent vectors may include a first latent vector and a second latent vector. In this case, decoding generates a corresponding latent vector for each of the first and second latent vectors, which includes a corresponding intermediate latent vector. The generation of the functional structure may then include performing an interpolation operation between the first intermediate latent vector of the first latent vector and the second intermediate latent vector of the second latent vector, based on the same label that labels both the first and second intermediate latent vectors. This same label can be obtained, in particular, by applying a latent space classifier to both the first and second intermediate latent vectors. In any case, performing this interpolation operation (or a hybrid operation, such as the limiting case of interpolation discussed earlier) by merging / mixing meaningful substructures of the generated data structure will generate more and / or more diverse functional structures.

[0053] The generation method may further include performing topology optimization on mechanical assemblies of rigid parts represented by the generated functional structures. This is possible because, as previously discussed, the tree of the generated functional structures has leaf nodes, each representing the shape and location of a corresponding rigid part and the forces applied to that rigid part. Topology optimization may specifically take these forces (or at least a portion of these forces) represented in the generated functional structures as input. Topology optimization may be performed on each mechanical assembly of rigid parts represented by each functional structure generated according to the generation method, or on at least a portion of these mechanical assemblies. Therefore, the generation method can produce as many topology-optimized mechanical assemblies of parts as the generated functional structures.

[0054] The learning and generative methods can be executed independently, for example, by different users and / or on different computers. Alternatively, the learning and generative methods can be included in a modeling process implemented on the same computer. (See now for reference.) Figure 1 Briefly discuss this modeling process. Figure 1 A flowchart of the modeling process is shown.

[0055] The modeling process includes an offline phase. The offline phase includes a learning method. Therefore, the offline phase specifically includes providing a dataset with functional structure S10 according to the learning method, and learning a generative autoencoder S20 on the dataset according to the learning method. The offline phase may also include learning a latent space classifier S30 according to the learning method. The modeling process may also include storing the learned generative autoencoder and the learned latent space classifier (where appropriate) in memory.

[0056] The process also includes an online phase. The online phase includes a generative method for the generative autoencoder learned in the offline phase according to the learning method. The online phase may specifically include (e.g., from a remote computer) retrieving the generative autoencoder learned in the offline phase and stored in memory, along with a latent space classifier (where appropriate), as previously discussed. In any case, the online phase includes providing one or more latent vectors (S100) according to the generative method and generating a functional structure (S200) according to the generative method. The online phase may also include performing topology optimization (S300) on a mechanical assembly of rigid parts represented by the generated functional structure, according to the generative method.

[0057] It should be noted that the offline and online phases can be executed independently, for example, by different users, at different times / phases and / or on different computers.

[0058] Learning methods, generative methods, and / or modeling processes can be included in the design process of mechanical assemblies used to design rigid parts. Designing a mechanical assembly of a part specifies any action or series of actions, which is at least part of creating a 3D modeling object representing the mechanical assembly of the part. The design process may specifically include generating a functional structure representing the mechanical assembly of the part by using a generative autoencoder learned through an offline phase of the learning method and / or modeling process. Generation can be generation during an online phase of the generative method and / or modeling process. In any case, the generated data structure allows for the direct inference of a 3D modeling object representing the mechanical assembly of the rigid part from the generated data structure, and the design process may include inference and optionally display of the 3D modeling object.

[0059] The design process can be a process for designing a mechanical assembly of rigid parts via topology optimization, or a design process for a 3D modeling object representing such a mechanical assembly. In this case, the design process may specifically include performing S300 topology optimization according to an online phase of the generative method and / or modeling process. As is known per se, topology optimization is a computer-implemented technique that connects the fields of product design and physical simulation. Topology optimization is applied to design modeling objects that represent mechanical parts (e.g., mechanical assemblies of rigid parts) formed from materials, subjected to loads in use, and having one or more constraint boundaries. This technique focuses on automatically generating optimized generative designs based on modifications to the physical properties and behaviors typically simulated via finite element analysis (FEA) of the generative design. More specifically, topology optimization works by providing a finite element mesh (FEM), for example, by discretizing the design space in small elements and the data associated with the mesh. The technique then finds the optimal distribution and layout of material in a given discrete space by iteratively finding the most efficient elements relative to a given objective function (e.g., involving the stiffness of the design) and a set of constraints (e.g., involving the total amount of allowable material).

[0060] The design process can also be included in the manufacturing process, which can include producing a physical product corresponding to the 3D modeled object designed / generated through the design process, following the execution of the design process. In any case, the 3D modeled object designed through the design process can represent the manufactured object. Therefore, the modeled object can be a modeled entity (i.e., a modeled object representing an entity).

[0061] Learning methods, generative methods, and modeling processes are implemented by computers. We will now discuss the concept of computer-implemented methods (and corresponding processes).

[0062] "A method (corresponding process) is computer-implemented" means that the steps (or substantially all steps) of the method (corresponding process) are executed by at least one computer or any similar system. Therefore, the execution of the steps of the method (corresponding process) by a computer may be fully automatic or semi-automatic. In the example, the triggering of at least some steps of the method (corresponding process) can be performed through user-computer interaction. The required level of user-computer interaction can depend on the level of automation anticipated and be balanced with the need to fulfill the user's intentions. In the example, this level can be user-defined and / or predefined.

[0063] A typical example of a computer implementation of a method (and corresponding procedure) is to execute the method (and corresponding procedure) using a system suitable for that purpose. The system may include a processor coupled to memory and a graphical user interface (GUI), on which a computer program is stored, containing instructions for executing the method (and corresponding procedure). The memory may also store a database. The memory is any hardware suitable for such storage, and may comprise several physically distinct parts (e.g., one part for the program and possibly another for the database).

[0064] Figure 2 An example of a system is shown, where the system is a client computer system, such as a user's workstation.

[0065] The client computer in this example includes a central processing unit (CPU) 1010 connected to an internal communication bus 1000 and random access memory (RAM) 1070 also connected to the bus. The client computer is also provided with a graphics processing unit (GPU) 1110, which is associated with video random access memory 1100 connected to the bus. The video RAM 1100 is also referred to in the art as a frame buffer. A mass storage device controller 1020 manages access to a mass storage device (e.g., a hard disk drive 1030). Mass storage devices suitable for tangibly representing computer program instructions and data include all forms of non-volatile memory, and by way of example, mass storage devices include: semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; disks, such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM disks 1040. Any of the foregoing may be supplemented by or incorporated into a specially designed ASIC (Application-Specific Integrated Circuit). A network adapter 1050 manages access to a network 1060. The client computer may also include a tactile device 1090, such as a cursor control device, a keyboard, etc. The cursor control device is used in the client computer to allow the user to selectively position the cursor at any desired location on the display 1080. Additionally, the cursor control device allows the user to select various commands and input control signals. The cursor control device includes multiple signal generating devices for inputting control signals to the system. Typically, the cursor control device may be a mouse, with buttons used to generate signals. Alternatively or additionally, the client computer system may include a sensitive pad and / or a sensitive screen.

[0066] A computer program may include computer-executable instructions, including units for causing the system to perform learning methods, generative methods, and / or modeling processes. The program may be recordable on any data storage medium, including the system's memory. The program may be implemented, for example, as digital electronic circuitry or computer hardware, firmware, software, or a combination thereof. The program may be implemented as an apparatus, for example, tangibly embodied in a machine-readable storage device for execution by a programmable processor. The process / method steps may be performed by executing the instruction program via a programmable processor to perform the function of the process by manipulating input data and generating output. Therefore, the processor may be programmable and coupled to receive data and instructions from the data storage system, at least one input device, and at least one output device, and to send data and instructions to the data storage system, at least one input device, and at least one output device. The application may be implemented in a high-level procedural language or an object-oriented programming language, or assembly or machine language, if desired. In any case, the language may be a compiled language or an interpreted language. The program may be a complete installation or update program. In any case, the application of the program on the system results in instructions for performing learning methods, generative methods, and / or modeling processes.

[0067] Mechanical assemblies of rigid parts, represented by the functional structure anticipated by methods, generation methods, and / or modeling processes, can also be represented by modeling objects (e.g., modeling objects inferred from the functional structure, as previously discussed). A modeling object is any object defined by data stored, for example, in a database. By extension, the expression "modeling object" refers to the data itself. Depending on the type of system, modeling objects can be defined by different kinds of data. The system can be a CAD system. In such a system, modeling objects are defined by corresponding data. Therefore, one can talk about CAD objects.

[0068] A CAD system also means at least any system suitable for designing modeling objects based on their graphical representation, such as CATIA. In this case, the data defining the modeling object includes the data that allows the modeling object to be represented. A CAD system can provide a representation of a CAD modeling object, for example, using edges or lines (and in some cases, faces or surfaces). Lines, edges, or surfaces can be represented in various ways (e.g., non-uniform rational B-splines (NURBS)). Specifically, a CAD file contains specifications from which geometry can be generated, which in turn allows for the generation of representations. The specifications of the modeling object can be stored in a single CAD file or multiple CAD files. The typical size of a file representing a modeling object in a CAD system is in the range of one megabyte per part. And the modeling object can typically be an assembly of thousands of parts.

[0069] In the context of CAD, a modeling object can typically be a 3D modeling object, which represents, for example, a product such as a part or an assembly of parts, or possibly an assembly of products. "3D modeling object" means any object modeled from data that allows for its 3D representation. 3D representation allows a part to be viewed from various angles. For example, when a 3D modeling object is represented in 3D, it can be manipulated and rotated about any of its axes or about any of the axes on the screen on which its representation is displayed. Specifically, this does not include 2D icons that are not 3D modeled. The display of 3D representations facilitates design (i.e., increases the speed at which designers statistically complete their tasks). Since product design is part of the manufacturing process, this can accelerate manufacturing processes in industry.

[0070] 3D modeling objects can represent the geometry of a product to be manufactured in the real world after its virtual design has been completed using, for example, CAD software solutions or CAD systems. Examples include (e.g., machinery) parts or assemblies of parts (or equivalents of assemblies of parts, since, from the perspective of this disclosure, assemblies of parts can be considered as parts themselves), or more generally, any rigid body assembly (e.g., a moving mechanism). CAD software solutions allow for the design of products in a wide and unlimited range of industrial sectors, including: aerospace, architecture, construction, consumer goods, high-tech equipment, industrial installations, transportation, and marine and / or offshore oil / gas production or transportation. Therefore, the 3D modeling object designed according to this disclosure can represent industrial products, which can be any mechanical parts, such as parts of land vehicles (including, for example, automobiles and light truck equipment, racing cars, motorcycles, trucks and motor vehicle equipment, trucks and buses, trains), parts of aircraft (including, for example, fuselage equipment, aerospace equipment, propulsion equipment, defense products, aviation equipment, space equipment), parts of warships (including, for example, naval equipment, commercial ships, marine equipment, yachts and workboats, marine equipment), general mechanical parts (including, for example, industrial manufacturing machinery, heavy mobile machinery or equipment, installation equipment, industrial equipment products, metal structure products, tire manufacturing products), electromechanical or electronic parts (including, for example, consumer electronics, safety and / or control and / or instrument products, computing and communication equipment, semiconductors, medical devices and equipment), consumer goods (including, for example, furniture, home and garden products, leisure goods, fashion products, products of hard goods retailers, products of soft goods retailers), and packaging (including, for example, food and beverage and tobacco, beauty and personal care, and household product packaging).

[0071] Now we will discuss the concept of mechanical assemblies of rigid parts.

[0072] A mechanical assembly of rigid parts specifies a collection of rigid parts linked together by a set of relationships. A rigid part is a part whose deformability is negligible compared to other types of parts (e.g., deformable parts). Each relationship is between two or more rigid parts and represents the relative arrangement of the two or more rigid parts relative to each other, such that the two or more rigid parts satisfy one or more geometric constraints (e.g., symmetrical positioning of two or more parts) and / or one or more physical constraints (e.g., mechanical links connecting two or more parts). Thus, a relationship defines the set of positions or possible positions of the two or more rigid parts involved in that relationship. However, the set of relationships incorporates several such relationships in a hierarchical manner, such that all rigid parts in the set are positioned relative to each other to comply with all relationships in a certain order, thereby forming a 3D mechanical assembly of rigid parts. Therefore, the assembly of rigid parts and the way rigid parts are assembled together are captured by the underlying hierarchical structure of relationships that organize rigid parts and / or sub-assemblies of rigid parts relative to each other. This assembly is referred to as a "mechanical assembly" because the relationship between rigid parts and their hierarchy stems from mechanical constraints (e.g., structural constraints, functional constraints, and / or manufacturing constraints) and / or mechanical requirements (e.g., structural requirements, functional requirements, and / or manufacturing requirements). An assembly of rigid parts includes sub-assemblies of rigid parts, which are themselves assemblies of rigid parts included in the assembly. It should be understood that a single rigid part can be considered a sub-assembly.

[0073] A subassembly can be a so-called "meaningful substructure". A meaningful substructure specifies a subassembly of a mechanical assembly of parts that satisfies any one or any combination of the following:

[0074] - Subassemblies are functional groups, that is, they perform specific mechanical functions;

[0075] - Sub-assemblies have specific functions;

[0076] - A sub-assembly includes a specific, independent sub-assembly;

[0077] - Subassemblies comply with a specific set of manufacturing, structural and / or functional constraints;

[0078] - Subassemblies are manufactured in a specific manufacturing process (e.g., a different manufacturing process than those used to manufacture other subassemblies); and / or

[0079] - Subassemblies are manufactured in specific steps of the manufacturing process (e.g., steps that differ from other steps in the manufacturing process used to manufacture mechanical assemblies), such as steps involving specific mechanical and / or manufacturing considerations.

[0080] Generative autoencoders are configured to generate functional structures, which are data structures representing mechanical assemblies of rigid parts. The data structures will now be discussed.

[0081] Data structures include trees (e.g., a tree). A tree is a data structure that describes and captures the relationships between rigid parts and the organization of a mechanical assembly of rigid components, as well as the hierarchy of relationships between parts. A tree can be any tree, such as a binary tree. As is known by itself, each non-leaf node of a binary tree has a single child node or two child nodes. A tree includes a root node, which represents (e.g., corresponds to) the entire mechanical assembly of rigid parts. A tree also includes leaf nodes and non-leaf nodes (also called internal nodes), each leaf node corresponding to a rigid part of the assembly, and each non-leaf node corresponding to a sub-assembly of a rigid part within the assembly. Leaf nodes and non-leaf nodes will now be discussed.

[0082] The tree consists of leaf nodes, each representing the shape and location of a corresponding rigid part and the force applied to that rigid part. In other words, a leaf node corresponds to an atomic part of a mechanical assembly of rigid parts, that is, an individual rigid part of the assembly. We will now discuss these leaf nodes.

[0083] "Representing the shape and location of the corresponding rigid part and the force applied to the corresponding rigid part" means that the leaf node includes data representing the shape and location of the corresponding rigid part and data representing the force applied to the corresponding rigid part.

[0084] Data representing the shape and location of a corresponding rigid part may include any information describing the shape, geometry, type of geometry (e.g., type of geometric primitives), and / or (e.g., position in space relative to other rigid parts and / or a 3D coordinate system) and / or the semantics of the corresponding rigid part. This information may be based on a simple representation of the corresponding rigid part, such as a bounding box and / or a canonical shape.

[0085] Data representing the forces applied to a given rigid component may include any information describing the resultant external force applied to the given rigid component. Therefore, the forces applied to a given rigid component can specify the resultant external force applied to the given rigid component. The resultant force can be the combined force of limiting external forces, which can be applied to the given rigid component before it fractures and / or cause the given rigid component to comply with constraints (e.g., manufacturing constraints, structural constraints, and / or functional constraints).

[0086] In the examples, the shape and position of the corresponding rigid parts are represented by data including specifications of the bounding box surrounding the corresponding rigid parts (e.g., parameters and / or coordinates characterizing the bounding box). In these examples, the force applied to the corresponding rigid parts is a resultant force, as previously discussed. The data including the specifications of the bounding box may also include specifications of the geometry of the corresponding rigid parts, such as one or more parameters characterizing (e.g., specifying) the type of geometric primitives.

[0087] In the example, the bounding box and the resultant force are represented by the same vector of first and second coordinates, respectively. In other words, the leaf nodes include vectors with first and second coordinates. The first coordinate is a parameter characterizing the bounding box around the corresponding rigid part. The second coordinate is a parameter characterizing the resultant force, for example, the coordinate of the external resultant force vector corresponding to the sum of all external force vectors applied around the bounding box (e.g., its points) around the corresponding rigid part. The vector may optionally include one or more third coordinates, which characterize (e.g., specify) the type of geometric primitive corresponding to the shape of the corresponding rigid part.

[0088] The tree also includes non-leaf nodes, each with several child nodes, and each non-leaf node represents a mechanical link between subassemblies. Each subassembly is represented by a corresponding child node from among its several child nodes. We will now discuss these non-leaf nodes.

[0089] Each of the several child nodes is either a leaf node (i.e., corresponding to a rigid part of an assembly, which itself is also a sub-assembly of the part) or a non-leaf node (i.e., corresponding to a sub-assembly of a rigid part within an assembly). A mechanical link is a relationship that links a part and a sub-assembly of the part, each represented by a child node. Therefore, a mechanical link characterizes the positioning of the part and its sub-assemblies relative to each other, as previously discussed. In the examples, mechanical links are described by vectors of mechanical link parameters. In other words, in these examples, non-leaf nodes include vectors of mechanical link parameters, i.e., vectors with coordinates representing the parameters of the mechanical link. In other words, in addition to describing the positioning of sub-assemblies or parts relative to each other, non-leaf nodes may also include vectors of parameters that also specify the mechanical link between the sub-assemblies that causes their relative positioning. In alternative examples, non-leaf nodes may not include such vectors of parameters, since in these alternative examples, the mechanical link is entirely characterized by the several child nodes.

[0090] In the example, a mechanical link is an adjacency relationship between subassemblies, which optionally belongs to a predetermined set of adjacency relationships. The predetermined set of adjacency relationships may include (e.g., constituted by) adjacency relationships referred to as static adjacency relationships and / or adjacency relationships referred to as kinematic relationships. In other words, a mechanical link can be one of static adjacency relationships and kinematic adjacency relationships. A static adjacency relationship between two or more subassemblies of a rigid part is a relationship describing the static contact and / or relative positioning between the two or more subassemblies (e.g., via a static mechanical link). A static adjacency relationship can be defined as an adjacency relationship with zero degrees of freedom. Subassemblies mechanically linked by a static adjacency relationship have a fixed relative position; that is, these subassemblies cannot move relative to each other. A kinematic adjacency relationship between two or more subassemblies of a rigid part is a relationship describing the kinematic contact and / or relative positioning between the two or more subassemblies (e.g., via a kinematic mechanical link). A kinematic adjacency relationship can be defined as an adjacency relationship with one or more degrees of freedom. Sub-assemblies that are mechanically linked by kinematic adjacency have non-fixed relative positions, that is, these sub-assemblies can move relative to each other.

[0091] The tree also includes non-leaf nodes with a single child node, and each non-leaf node represents a copy of the subassembly represented by that single child node. We will now discuss such non-leaf nodes.

[0092] A single child node can be a leaf node or another non-leaf node. "Representing a copy of the sub-assembly represented by this single child node" means that a non-leaf node represents several instances of the same rigid part or sub-assemblies of rigid parts within an assembly. Non-leaf nodes may also include data specifying the positioning of these instances relative to each other and / or the number of these instances.

[0093] In the example, a copy is a symmetry relationship between instances of a subassembly, which optionally belongs to a predetermined set of symmetry relationships. A symmetry relationship between instances of a subassembly is a relationship specifying the symmetrical positioning of instances relative to each other. The predetermined set of symmetry relationships can include pairwise reflection symmetry, k-fold rotational symmetry, and k-fold translational symmetry (e.g., constituted by them). In other words, a symmetry relationship can be one of reflection symmetry, k-fold rotational symmetry, and k-fold translational symmetry.

[0094] Paired reflection symmetry is a symmetry relationship between two instances of identical subassemblies. Paired reflection symmetry is parameterized by the plane of reflection and specifies that the positions of the two instances are symmetric with respect to that plane.

[0095] k-fold rotational symmetry is a symmetry relationship between the number k (an integer greater than or equal to 2) of instances of identical subassemblies. k-fold rotational symmetry is parameterized by the number k and the axis of rotation. k-fold rotational symmetry specifies that the instances are positioned such that they are 2x2 images of each other rotated in the same way around the axis of rotation.

[0096] k-times translational symmetry is a symmetry relationship between the number k (an integer greater than or equal to 2) of instances of identical subassemblies. k-times translational symmetry is parameterized by the number k and translation offsets. k-times translational symmetry specifies that the locations of instances are two-by-two images of each other with the same translations characterized by the translation offsets.

[0097] In the example, the symmetry relation is described by a vector of symmetry relation parameters. In other words, non-leaf nodes consist of vectors with coordinates that serve as parameters for the symmetry relation. The coordinates can include one or more first coordinates specifying the type of symmetry relation between pairwise reflection symmetry, k-fold rotational symmetry, and k-fold translational symmetry. The coordinates can include one or more second coordinates specifying the number of instances replicated by the symmetry relation. The coordinates can include one or more third coordinates specifying geometric parameters of the symmetry relation, such as the plane of reflection, axis of rotation, or translational offset discussed earlier.

[0098] Now we will discuss examples of mechanical assemblies of parts and their functional structures.

[0099] In the context of this disclosure, the mechanical assembly of the parts can be a chair. A chair can often (but not always) include four meaningful substructures: a leg substructure (i.e., a grouping of the chair's legs), an arm substructure (i.e., a grouping of the chair's arms), a seat, and a backrest.

[0100] Now for reference Figure 3 and Figure 4 Discuss examples of this type of chair and examples of its functional structure. Figure 4 The 3D representation of the chairs shown together is shown in Figure 30, and Figure 3 Tree 32, representing the functional structure of chair 30, is shown.

[0101] Tree 32 includes a leaf node “arm.1”, which represents the shape and positioning of a corresponding arm of the chair, as well as the force applied to it. The leaf node “arm.1” is a child node of a non-leaf node “arm” representing a copy of “arm.1”. The copy is the symmetrical relationship between the arm represented by “arm.1” and the other arm of the chair. For convenience only, the node “arm.2” representing the other arm of the chair is... Figure 3 The other child node is shown as the "arm". The symmetry relationship is a pairwise reflection symmetry (see reference). Figure 4Reflective symmetry is a symmetry about the backrest 4000, which is usually perpendicular to the vertical mid-plane of the chair 30, and reflective symmetry can be stored as a vector specifying the position of the plane and the type of symmetry. Non-leaf nodes “arms” represent meaningful substructures formed by the arms of the chair.

[0102] Tree 32 also includes two leaf nodes, “Leg.1.1.1” and “Leg.1.1.2”, each representing the shape and positioning of a corresponding portion of the two parts 34 and 36 of the chair leg, and the force applied to that corresponding portion. Tree 32 also includes a non-leaf node “Leg.1.1”, which represents the adjacency relationship of the two parts 34 and 36 represented by its two child nodes “Leg.1.1.1” and “Leg.1.1.2”. “Leg.1.1” is a child node of “Leg.1” representing a copy of the assembly represented by “Leg.1.1”. The copy is a symmetric relationship between the assembly represented by “Leg.1.1” and another instance thereof. For convenience only, the node “Leg.1.2” representing the other instance is shown as another child node of “Leg.1”. The symmetry relationship is a pairwise reflective symmetry. "Leg 1.2" indicates the other of the two legs of the chair, which is composed of the assembly of parts 340 and 360. For convenience only, parts 340 and 360 are referred to as... Figure 3 The tree 32 contains leaf nodes “leg.1.2.1” and “leg.1.2.2”, which are paired, reflectively symmetrical images of part 34 and part 36, respectively. Tree 32 also includes a leaf node “leg.2”, which represents the shape and location of part 38 and the forces applied to it. The leaf node “leg.2” and the non-leaf node “leg.1” are two child nodes of the non-leaf node “leg”, which represents the adjacency relationship that assembles the two symmetrical legs of the chair (represented by node “leg.1”) with part 38 (represented by node “leg.2”). The non-leaf node “leg” represents a meaningful substructure formed by the chair legs.

[0103] Tree 32 also includes a leaf node “back.1.1”, which represents the shape and positioning of part 40 and the forces applied to it. Node “back.1.1” is a child node of the non-leaf node “back.1” representing a copy of part 40. The copy is the symmetric relationship between part 40 and its other instance (i.e., part 400). For convenience only, the node “back.1.2” representing part 400 is... Figure 3The other child node is shown as "Backrest.1". The leaf node "Backrest.2" represents the shape and positioning of part 4000 and the forces applied to it. Tree 32 also includes a non-leaf node "Backrest", which represents the adjacency relationship that assembles two instances of part 400 and part 40 (represented by node "Backrest.1") together. The node "Backrest" represents a meaningful substructure formed by the chair's backrest.

[0104] Tree 32 also includes a non-leaf node “Assembly 1”, which represents the adjacency relationship of assembling the chair seat (represented by the leaf node “seat”) and the chair arm (represented by the non-leaf node “arm”) together.

[0105] Tree 32 also includes a non-leaf node “Assembly 2”, which represents the adjacency relationship of assembling a child assembly (represented by node “Assembly 1”) with a chair leg (represented by non-leaf node “Leg”).

[0106] Tree 32 also includes a root node “chair”, which represents the entire chair and the adjacency relationship of assembling the sub-assemblies (represented by the node “assembly 2”) with the chair back (represented by the non-leaf node “back”).

[0107] In the context of this disclosure, a mechanical assembly of rigid parts can be a vehicle. A vehicle can often (but not always) include the following meaningful substructures:

[0108] - Body substructure, which may include one or more of the following: hood, bumper, fenders, pillars, rocker arms, roof, rear side panels, trunk, doors, windows and / or

[0109] floor;

[0110] - Internal substructure, which may include: seats and / or dashboard; and

[0111] - Chassis structure, which may include one or more of the following: suspension, wheels, drive axle, braking system, steering system and / or engine components.

[0112] A tree representing the functional structure of a car can often (but not always) contain one or more of the following nodes:

[0113] - Non-leaf nodes, each non-leaf node represents the front door (represented by a leaf node), the back door (represented by a leaf node), the mirror (represented by a leaf node), the headlight (represented by a leaf node), or...

[0114] The pairwise reflection symmetry relationship between instances of chair seats (represented by leaf nodes);

[0115] - Non-leaf node "a_1", which represents the left front wheel (represented by a leaf node) and the left front suspension (its

[0116] The adjacency relationships between (represented by leaf nodes);

[0117] - Non-leaf node “s_1”, which represents a pairwise reflective symmetry relationship between instances of symmetrical assemblies represented by node “a_1”, one of which is an assembly consisting of the right front wheel and the right front suspension;

[0118] - Non-leaf node "s_2" represents a pairwise reflective symmetry relationship between instances of symmetrical assemblies represented by node "s_1", one of which is the rear wheel and the suspension;

[0119] - Non-leaf node "a_2", which represents the symmetrical assembly represented by node "s_2" and the drive shaft (its

[0120] The adjacency relationships between (represented by leaf nodes);

[0121] - The non-leaf node "s_3" represents the sequence of events between instances of the rear seats (which are represented by leaf nodes).

[0122] One example of this reflective symmetry is the front row of seats;

[0123] - The non-leaf node "a_3" represents the car floor (which is represented by a leaf node) and is related to node "s_3".

[0124] The adjacency relationship between symmetrically assembled components; and / or

[0125] - The non-leaf node "a_4" represents the adjacency relationship between the assembly represented by node "a_3" and the car's dashboard (represented by leaf nodes). Node "a_4" also represents the car's "interior".

[0126] Substructure.

[0127] In the context of this disclosure, a mechanical assembly of rigid parts can be a multi-joint robot. A multi-joint robot can include meaningful substructures, each corresponding to a specific function of the robot (e.g., a grasping function), and can be represented by adjacency relationships.

[0128] We will now discuss mechanical assemblies of parts and other examples of their functional structures.

[0129] In the context of this disclosure, a mechanical assembly of rigid parts can be any type of vehicle, such as an automobile (as previously discussed), a motorcycle, a truck, or an airplane. Alternatively, a mechanical assembly of rigid parts can also be any type of furniture, such as a chair (as previously discussed). Alternatively, a mechanical assembly of rigid parts can be any type of robot, such as a multi-joint robot (as previously discussed). In the examples, all these object classes / categories present a high level of symmetry relationships between parts and / or subassemblies. For example, these object classes / categories may make at least 50% of the parts and / or subassemblies directly or indirectly involve symmetry relationships. Alternatively or additionally, these object classes / categories may make parts organized in several (e.g., more than three) consistent substructures. Adjacency relationships allow for the representation / creation of such substructures. These substructures may correspond in a functional sense to meaningful substructures or independent subassemblies. A representation with such substructures helps designers focus on specific substructures.

[0130] We will now discuss the dataset that provides the S10 functional structure.

[0131] Providing the S10 dataset may include retrieving at least a portion (e.g., the entire functional structure) from memory (e.g., from a remote computer). Providing the S10 functional structure may additionally or alternatively include each functional structure that creates at least another portion of the functional structure. Creating the functional structure may include creating the functional structure from scratch (e.g., graphically), particularly including specifying nodes and their arrangement to form a tree of functional structures. Alternatively, creating the functional structure may include retrieving an existing initial functional structure (e.g., from memory or a library such as Shapenet for a chair model) and modifying that initial functional structure to obtain the functional structure. For example, the initial functional structure may include a tree, but the leaf nodes (or at least a portion of the leaf nodes) may not include data representing forces applied to rigid parts represented by the leaf nodes. In this case, modification may include adding the data representing the forces to the leaf nodes. Providing the S10 dataset may be performed by a user.

[0132] The dataset may include, or substantially include, functional structures representing mechanical assemblies of rigid parts, all of which belong to the same class of mechanical assemblies of rigid parts. In the example, if all mechanical assemblies of rigid parts conform to one or more criteria, then these mechanical assemblies form a class of mechanical assemblies of rigid parts. Each of these one or more criteria can be any one or any combination of the following conditions:

[0133] - Rigid parts are mechanically assembled entirely in the same manufacturing process or in the same manufacturing process.

[0134] Manufactured in combination;

[0135] - All mechanical assemblies of rigid parts come from the same field of technology and / or industry;

[0136] - Mechanical assemblies of rigid parts all perform the same or similar mechanical functions;

[0137] - Mechanical assemblies of rigid parts are all composed of the same or at least substantially similar rigid parts;

[0138] - All mechanical assemblies of rigid parts have the same or at least similar basic levels;

[0139] - Mechanical assemblies of rigid parts have similar meaningful substructures;

[0140] - All mechanical assemblies of rigid parts have the same or substantially the same shape; and / or

[0141] - All mechanical assemblies of rigid parts comply with the same mechanical constraints, functional constraints, manufacturing constraints, and / or structural constraints.

[0142] In the example, the dataset consists of, or is essentially composed of, the functional structures that each represent a car (i.e., mechanical assemblies of parts belonging to the class of cars).

[0143] In other examples, the dataset consists of, or is essentially composed of, functional structures that each represent a plane (i.e., mechanical assemblies of parts belonging to classes of planes).

[0144] In other examples, the dataset consists of, or is essentially composed of, functional structures that represent chairs (i.e., mechanical assemblies of parts belonging to the class of chairs).

[0145] In other examples, the dataset consists of, or is essentially composed of, functional structures that each represent a multi-joint robot (i.e., mechanical assemblies of parts belonging to a class of multi-joint robots).

[0146] We will now discuss learning the S20 generative autoencoder. First, we will discuss the general concepts of "machine learning" and "learning neural networks," as well as other related concepts.

[0147] As is known in the field of machine learning, processing input via a neural network involves applying operations to the input, defined by data including weight values. Therefore, learning a neural network involves determining the values ​​of the weights based on a dataset configured for such learning, which may be referred to as a learning dataset or training dataset. For this purpose, the dataset comprises data fragments, each forming a corresponding training sample. The training samples represent the diversity of situations in which the neural network will be used after learning. Any dataset referenced herein may include a number of training samples greater than 1,000, 10,000, 100,000, or 1,000,000. In the context of this disclosure, "learning a neural network on a dataset" means that the dataset is the learning / training set of the neural network.

[0148] Generative autoencoders are deep neural networks (hereinafter referred to as "DNNs") that are combinations of variational autoencoders (hereinafter referred to as "VAEs") and generative adversarial networks (hereinafter referred to as "GANs"). A generative autoencoder is a VAE with an additional discriminative network added during the learning of S20. This discriminative network is trained (during the learning of S20) to perform binary classification by classifying the output of the VAE between two classes ("real" or "fake"). As is known per se, "fake" means that the output is actually generated by the VAE, and "real" means that the output comes from the dataset provided with the S10 functional structure. A generative autoencoder can be referred to as a VAE-GAN. An S30 generative autoencoder can be trained / learned using any machine learning technique suitable for training such a neural network. Learning can specifically involve minimizing several losses (including reconstruction loss, adversarial loss, cross-entropy loss, and GAN loss) through, for example, one or more gradient descent algorithms. The reconstruction loss may include a so-called KL divergence term. Specifically, a generative autoencoder can be learned, S20, to accurately reconstruct the input tree of the functional structure. This reconstruction loss measures the (e.g., L2) distance between the input tree reconstructed by the autoencoder and the output tree. Therefore, the encoding and decoding functions of the autoencoder are bijective functions.

[0149] As is known by itself, deep neural networks are neural networks that learn through deep learning techniques, a powerful collection of techniques used for learning within neural networks. Neural networks are a biologically inspired programming paradigm that enables computers to learn from observed data. In image recognition, unlike the manually designed low-level features (Zernike moments, HOG, Bag-of-Words, SIFT, etc.) used in other image classification methods (SVM, Boosting, Random Forest, etc.), DNNs are capable of learning rich, mid-level media representations. More specifically, DNNs focus on end-to-end learning based on raw data. In other words, by performing end-to-end optimization starting from raw features and ending with labels, DNNs minimize the need for feature engineering.

[0150] As is known by itself, a discriminative deep neural network is a function that is learned to estimate discrete or continuous values ​​y given an input x. Discriminative deep neural networks learn on a dataset of (x, y).

[0151] As is known, deep generative models are a class of deep neural networks that learn a copy of the data distribution of the dataset on which they are trained. There are two classes of deep generative models: variational autoencoders and generative adversarial networks (GANs). Hybrid generative models can be constructed based on these two classes: variational autoencoders-GANs, for example, generative autoencoders.

[0152] As is known by itself, a variational autoencoder consists of two parts: an encoder and a decoder. The encoder takes an input x and outputs a probability distribution. This distribution is set to a Gaussian distribution, so the encoder outputs two vectors mu and sigma of the same size. The decoder then attempts to reconstruct x given z sampled from the distribution of the encoder output.

[0153] As is known by itself, during the training phase, given a dataset of real samples, a GAN is learned to generate “real” samples. For example, if a GAN learns on a dataset of flower images, once trained, it will be able to generate images of flowers that look very realistic. A GAN consists of two networks: a generator and a discriminator. The generator takes a low-dimensional latent variable z as input, which is sampled from a Gaussian distribution. The output of the generator f(z) is a sample of the same type as the data in the training dataset. For example, if the training data is 512×512 images, then f(z) is a 512×512 image; if the training data is a binary tree, then f(z) is a binary tree. The trick to learning the generator involves using a discriminator, which is learned to perform binary classification of its input between two categories (“real” or “fake”). If the discriminator’s input comes from the training dataset, it must be classified as “real”, and if the discriminator’s input comes from the generator, it must be classified as “fake”. During the learning process, while the discriminator is learned to perform its binary classification task, the generator is learned to "fool" the discriminator by producing samples that the discriminator classifies as "real". To enable both networks to learn together, a special type of loss called adversarial loss can be used.

[0154] Therefore, generative autoencoders are generative. As explained above, a neural network is called "generative" if it learns the distribution of the training data. Only generative models can generate new data. Non-generative autoencoders can only compress the latent vectors of small-sized input data (3D shapes of images) and then reconstruct them, but cannot generate new data (e.g., from random latent vectors). Therefore, generative autoencoders are able to generate new functional structures on the fly, producing "real" functional structures similar to those in the provided S10 dataset.

[0155] Furthermore, the generative autoencoder is a recurrent neural network, which makes it particularly suitable for learning S20 on datasets with functional structures that include trees.

[0156] As is known by default, a recurrent neural network is a deep neural network composed of recurrent modules. These modules can be of two types: encoder modules and decoder modules. An encoder module takes several (e.g., two) fixed-size vectors as input and outputs a fixed-size vector. The number of inputs to an encoder module is fixed. A decoder module takes a vector as input and outputs several (e.g., two) fixed-size vectors. The number of outputs of a decoder module is fixed and equal to the number of inputs to the corresponding encoder module. Therefore, a generative autoencoder is a VAE-GAN with recurrent modules, as previously discussed. The encoder network transforms a variable-size input tree structure into a fixed-size latent vector by repeatedly folding child nodes represented as codes into merged codes in a bottom-up manner. By reversing this process, the decoder network is trained to reconstruct the input tree structure from the final latent codes output by the encoder network. Learning the S20 generative neural network can be done using any machine learning technique capable of learning a VAE-GAN with recurrent modules.

[0157] We will now further discuss the recursive module of the generative autoencoder.

[0158] In the examples, the generative autoencoder includes an encoder and a decoder. In these examples, the encoder includes a leaf encoding module, a mechanically linked encoding module, and a copy encoding module. The leaf encoding module, mechanically linked encoding module, and copy encoding module are recursive modules, as discussed previously. In these examples, the decoder includes a node classifier, a leaf decoding module, a mechanically linked decoding module, and a copy decoding module. The leaf decoding module, mechanically linked decoding module, and copy decoding module are recursive modules.

[0159] Now let's discuss these examples further.

[0160] In these examples currently discussed, the encoder is configured to encode a tree (i.e., a tree of a given functional structure) into a single latent vector according to a recursive bottom-up process, given a functional structure. In other words, the encoder takes a tree of a given functional structure as input and outputs a single latent vector. The encoder does this by recursively aggregating (or folding) the nodes of the tree into consecutive latent vectors using its encoding modules until the root node is reached. At the end of this recursive bottom-up encoding process, the tree is encoded into a single latent vector.

[0161] During the bottom-up encoding process, the leaf encoding module outputs a corresponding latent vector for each leaf node. The leaf encoding module does this based on data including the specifications of the bounding box and the resultant force. In the example, this means that for each leaf node, the leaf encoding module takes data including the specifications of the bounding box (i.e., the bounding box surrounding the shape and positioning of the rigid part represented by the leaf node) and the resultant force (i.e., the resultant force applied to the rigid part) as input and outputs a corresponding latent vector. As previously discussed, this data can be a vector or a vector comprising a first coordinate representing the bounding box surrounding the corresponding rigid part, a second coordinate representing the resultant force, and an optional third coordinate(s) representing the type of geometric primitive. In this case, the leaf encoding module converts this vector into a corresponding latent vector.

[0162] In the bottom-up encoding process, the mechanical link encoding module outputs a corresponding latent vector for each non-leaf node representing a mechanical link. The mechanical link encoding module does this based on several latent vectors encoded for several corresponding child nodes of the non-leaf node. In the example, this means that for each non-leaf node representing a mechanical link, each corresponding child node of the non-leaf node has already been previously encoded as a latent vector, and the mechanical link encoding module takes all these latent vectors as input and outputs the corresponding latent vector. As previously discussed, non-leaf nodes may also include vectors of mechanical link parameters. In this case, in addition to the latent vectors, the mechanical link encoding module may also take a vector of mechanical link parameters as input and output the corresponding latent vector, which, for example, is empty when there is no mechanical link. Alternatively, the encoder may include a first mechanical link encoding module and a second mechanical link encoding module. For each non-leaf node representing a mechanical link without a vector of mechanical link parameters, the first mechanical link encoding module takes all the latent vectors representing the child nodes of that non-leaf node as input and outputs the corresponding latent vector. For each non-leaf node representing a vector with mechanical link parameters, the second mechanical link encoding module takes all the latent vectors representing the child nodes of the non-leaf node and the vectors representing the mechanical link parameters as input, and outputs the corresponding latent vectors.

[0163] In the bottom-up encoding process, the replica encoding module outputs a corresponding latent vector for each non-leaf node representing a replica. The replica encoding module does this based on the latent vector encoded for the corresponding individual child nodes of the non-leaf node. In the example, this means that for each non-leaf node representing a replica, the individual child nodes of the non-leaf node have already been previously encoded as latent vectors, and the replica encoding module takes these latent vectors as input and outputs the corresponding latent vector. The replica encoding module can also take, as previously discussed, data specifying the positioning of several instances of subassemblies represented by individual child nodes relative to each other as input. It should be noted that, as previously discussed, in examples where the replicas are symmetric, this data can be or includes a vector of symmetry relation parameters. In this case, the replica encoding module takes the latent vector and the vector of symmetry relation parameters as input and outputs the corresponding latent vector.

[0164] In the example currently discussed, the decoder is configured to decode a given single latent vector into a tree of functional structure according to a recursive top-down process. In other words, the decoder takes a given single latent vector as input and outputs a tree. The decoder does this by recursively decoding successive latent vectors (i.e., latent vectors generated consecutively during and through the decoding process) into sub-latent vectors using its decoding modules until the sub-latent vectors are finally decoded into leaf nodes.

[0165] In the top-down decoding process, the node classifier classifies each latent vector generated during decoding as corresponding to a leaf node, a non-leaf node representing a mechanical link, or a non-leaf node representing a replica. In other words, for each consecutive latent vector generated in decoding (i.e., a given single latent vector and the latent vector output by the decoding module), the node classifier takes the latent vector as input and classifies it as corresponding to a leaf node, a non-leaf node representing a mechanical link, or a non-leaf node representing a replica. In other words, the node classifier guides recursive decoding by classifying each consecutive latent vector as corresponding to a node type, ensuring that the correct decoding module is applied to the latent vector. In practice, the node classifier can select the decoding module to apply to a latent vector during its classification. In the example, decoding a latent vector includes: classifying the latent vector by invoking the node classifier; selecting the correct decoding module to decode the latent vector as a result of the classification; and applying the selected decoding module to the latent vector.

[0166] During the top-down decoding process (e.g., and when selected by the node classifier), the leaf decoding module outputs data including the corresponding bounding box and the corresponding resultant force for each latent vector classified as corresponding to a leaf node during decoding. The leaf decoding module does this based on the latent vector. In the example, this means that since the latent vector is classified as corresponding to a leaf node, the leaf decoding module takes the latent vector as input and outputs data including the specifications of the corresponding bounding box (i.e., the bounding box around the rigid part) and the corresponding resultant force (i.e., the resultant force applied to the rigid part). The data can be a vector or a vector comprising a first coordinate representing the bounding box around the corresponding rigid part, a second coordinate representing the resultant force, and an optional third coordinate(s) representing the type of geometric primitive. This is equivalent to saying that the leaf decoding module outputs the leaf node.

[0167] During the top-down decoding process (e.g., and when selected by the node classifier), the mechanical link decoding module outputs several sub-latent vectors for each latent vector classified during decoding as corresponding to a non-leaf node representing a mechanical link. The mechanical link decoding module does this based on the latent vector. In the example, this means that since the latent vector is classified as corresponding to a non-leaf node representing a mechanical link, the mechanical link decoding module takes the latent vector as input and outputs several sub-latent vectors. In other words, the mechanical link decoding module outputs several latent vectors that encode several child nodes of the non-leaf node corresponding to that latent vector. In the example, the mechanical link decoding module may also output a vector of mechanical link parameters, which, for example, is empty when there is no mechanical link. Alternatively, the decoder may include a first mechanical link decoding module and a second mechanical link decoding module. For each latent vector classified as corresponding to a non-leaf node representing a mechanical link without mechanical link parameters, the first mechanical link decoding module takes that latent vector as input and outputs several latent vectors that encode several child nodes of the non-leaf node corresponding to that latent vector. For each latent vector that is classified as a non-leaf node corresponding to a vector representing a mechanical link with mechanical link parameters, the second mechanical link decoding module takes the latent vector as input and outputs several latent vectors that encode several child nodes of the non-leaf node corresponding to the latent vector, as well as a vector of mechanical link parameters.

[0168] During the top-down decoding process (e.g., and during node classifier selection), the replica decoding module outputs a single sub-latent vector for each latent vector classified during decoding as corresponding to a non-leaf node representing a replica. The replica decoding module does this based on the latent vector. In the example, this means that since the latent vector is classified as corresponding to a non-leaf node representing a replica, the replica decoding module takes the latent vector as input and outputs a single sub-latent vector. In other words, the mechanical link decoding module outputs a single latent vector encoding a single child node of the non-leaf node corresponding to that latent vector. In the example, the mechanical link decoding module may also output data specifying the positions of several instances of a sub-assembly represented by a single child node relative to each other, for example, a vector of symmetry parameters.

[0169] In examples of the learning method (or in examples of the offline phase of the modeling process), each node (e.g., all nodes) in one or more nodes of a tree representing at least a portion (e.g., the entire functional structure) of the dataset is labeled with a label from a predetermined list of labels. In these examples, the learning method (or the offline phase of the modeling process) also includes learning an S30 latent space classifier. The latent space classifier is a neural network configured to take a latent vector as input and label that latent vector using a label from a predetermined list of labels.

[0170] Now let's discuss this example.

[0171] Each tree in S10 may be provided to the dataset with at least a portion of the trees already labeled with a predetermined list(s). The tree being labeled with a predetermined list(s) means that one or more first nodes of the tree are labeled with a first label of the predetermined list. One or more second nodes of the tree may be labeled with a second label of the predetermined list. One or more third nodes may be labeled with a third label of the predetermined list, thus causing each node of the tree to be labeled with a corresponding label belonging to the predetermined list. Alternatively or additionally, providing S10 may include, for example, labeling one or more of the at least a portion of the trees (e.g., all trees) with the predetermined list(s) upon user action.

[0172] The pre-defined list of labels can be provided by the user (e.g., before or during the provision of S10). The pre-defined list of labels can relate to (e.g., specific to) the classes of mechanical assemblies of rigid parts in the provided dataset of functional structures. This means that all or substantially all functional structures in the provided dataset represent mechanical assemblies of rigid parts that all belong to the same class of mechanical assemblies of rigid parts, as previously discussed, and the pre-defined list of labels relates to that class. The pre-defined list of labels can specifically consist of special labels and other labels. Special labels indicate the absence of a label, while each corresponding label in the other list represents (e.g., indicates) a typical meaningful substructure of that class. One of the other labels can be a label indicating the class, which is only labeled on the root node. In other words, a tree representing mechanical assemblies of rigid parts belonging to that class and labeled with such a list of labels can be labeled as follows:

[0173] - Any node representing a subassembly may be labeled with a tag indicating a meaningful substructure, which is also a meaningful substructure of a rigid mechanical assembly. It should be understood that all child nodes of that node (if any) are also part of a meaningful substructure and therefore are not labeled with tags indicating a meaningful substructure. Only the parent node of the substructure is labeled. However, child nodes (if any) may be labeled with another tag in the list, for example, if the child node corresponds to another meaningful substructure within the substructure.

[0174] - Other nodes are marked with special labels because these nodes are not the parent nodes of meaningful substructures.

[0175] For example, when the class of the mechanical assembly of rigid parts in the provided functional structure dataset is the class of automobile, the predefined list of labels can consist of the following labels: special label, label "automobile" (indicating class, used to label the root node), label "body substructure", label "internal substructure", and label "chassis".

[0176] For example, when the class of the mechanical assembly of rigid parts in the provided functional structure dataset is the class of chair, the predefined list of labels can consist of the following labels: special label, label "chair" (indicating class, used to label the root node), label "arm", label "leg", label "seat", and label "backrest".

[0177] By using any machine learning technique capable of learning a neural network configured to take latent vectors as input and label the latent vectors with a label from a predetermined list of labels, the latent space classifier can be learned co-learned with the generative autoencoder (i.e., learning the S30 latent space classifier and learning the S20 generative autoencoder are performed together), or the latent space classifier can be learned subsequently (i.e., learning the S30 latent space classifier is performed after learning the S20 generative autoencoder).

[0178] As previously explained, both the recursive bottom-up encoding process and the recursive top-down decoding process recursively produce consecutive latent vectors. Each such consecutive latent vector corresponds to a node in the tree (i.e., the functional structure) or encodes a node in the tree, which can be any of a leaf node, root node, or internal node (i.e., a non-leaf node that is not the root node). In other words, consecutive latent vectors can belong to an intermediate latent space, that is, a latent space containing latent vectors corresponding to leaf nodes, root nodes, or any non-leaf nodes in the middle. The latent space classifier takes such latent vectors as input and labels the corresponding nodes using a list of labels. In other words, the latent space classifier can identify and label intermediate latent vectors, that is, latent vectors belonging to the intermediate latent space, each intermediate latent vector having a predetermined list of labels. It should be understood that intermediate latent vectors belonging to the same intermediate latent space are all labeled with the same label. Conversely, intermediate latent vectors labeled with the same label all belong to the same intermediate latent space.

[0179] In the example, the intermediate latent vector corresponding to the node representing a meaningful substructure is labeled with an indication of that meaningful substructure. As discussed earlier, the child nodes (if any) of that node correspond to the sub-latent vectors of the intermediate latent vector (e.g., encoded by them). The latent space classifier (e.g., in a later stage / step of the decoding process) takes each of these sub-latent vectors as input and labels them using labels that are not the labels indicating a meaningful substructure, since only the parent node representing the substructure is labeled with that label indicating a meaningful substructure. However, such a sub-latent vector may be labeled with a label corresponding to another meaningful substructure, for example, another meaningful substructure being a substructure of the substructure represented by the parent node. Otherwise, the child nodes are labeled with special labels.

[0180] Labeling latent vectors corresponding to meaningful substructures allows for the identification of these substructures during recursive decoding based solely on intermediate latent vectors that encode the substructures, by applying a latent space classifier to these latent vectors. This allows operations to be performed on meaningful substructures, such as interpolation operations, as discussed further below. Interestingly, such operations can be performed on the entire mechanical assembly of a rigid part, as well as on any of its meaningful subassemblies.

[0181] Now for reference Figures 5 to 7 This paper discusses the functional structure and implementation of generative autoencoders.

[0182] In this implementation, the dataset consists of functional structures, each including (e.g., containing) a binary tree, as previously discussed, comprising: leaf nodes; non-leaf nodes, each having two child nodes, and each non-leaf node representing an adjacency relationship between two subassemblies, each subassembly represented by a corresponding child node of the two child nodes; and non-leaf nodes, each having a single child node representing a symmetric relationship between instances of the subassemblies represented by that single child node. For simplicity, in the discussion of this implementation, a non-leaf node with two child nodes will be referred to as an "adjacency node," and a non-leaf node with a single child node will be referred to as a "symmetric node." In this implementation, as previously discussed, each tree or substantially each node of each tree in the dataset is labeled with a predetermined list of labels, and an S30 latent space classifier is learned on the dataset.

[0183] The nodes of the tree will now be discussed further. For clarity, in this discussion, the symbol nD stands for "n-dimensional" or "n-dimensional".

[0184] Each leaf node of the tree corresponds to (e.g., an atom) a rigid part (i.e., a rigid part of a mechanical assembly represented by a tree) and represents information about the geometry, external physical forces, and semantics of the rigid part in a fixed-size vector. In other words, and as previously discussed, the leaf nodes comprise vectors having a first coordinate representing the bounding box around the rigid part and a second coordinate representing the resultant force applied to the rigid part. Specifically, through a type... An 18-dimensional vector is used to describe (e.g., encode) the leaf nodes. The first 12 coordinates / parameters (b1,…,b) 12The bounding box coordinates are represented by the first 12 coordinates. The last 6 coordinates / parameters (f1, ..., f6) represent the resultant external force. The 12 parameters for the bounding box coordinates concatenate the coordinates of the box center, three dimensional parameters (height, width, and length), and two axes for the orientation of the bounding box in the absolute coordinate system. The resultant external force is a vector corresponding to the sum of all external force vectors applied to the bounding box. The (f1, f2, f3) parameters correspond to the point where the resultant force is applied, and the (f4, f5, f6) parameters correspond to the resultant vector. The 18-dimensional vector may include a third coordinate representing the type of geometry of the rigid part. Specifically, the 18-dimensional vector may include an additional integer coordinate / parameter b0 indicating the type of geometric primitive of the rigid part, which can be a geometric primitive represented by up to 12 parameters, such as a cylinder, torus, pyramid, or sphere.

[0185] Each adjacent node in the tree has two child nodes, which are either leaf nodes, one leaf node and one internal node, or both internal nodes. Adjacent nodes may also include a fixed-size vector of adjacency parameters, which represents the mechanical link between two subassemblies represented by the two child nodes. This fixed-size vector can be of the following type: Coordinates / parameters (u1,…,u6) characterize changes in the 3D frame. Coordinates / parameters (u1,…,u3) are three angles ∈ [0; 2π], used to characterize any transformation with the same frame origin. Coordinates / parameters (u4,…,u6) correspond to the translation 3D vectors used for changes in the frame origin. Coordinates / parameters (u7,…,u6) correspond to the translation 3D vectors used for changes in the frame origin. 12 )∈{0;1} 6 Characterized by type The kinematic tensor of , where u7, u8, and u9 are the degrees of freedom with respect to the three gauge rotations, and u 10 u 11 u 12 This refers to the degrees of freedom for the three gauge translations. The coordinates / parameters (f1, f2, f3) and (f4, f5, f6) of the 3D point where the resultant force is applied correspond to the 3D resultant vector. It should be understood that if u7 = u8 = u9 = u 10 =u 11 =u 12 If the adjacency is 0, then there is no kinematic link between the two subassemblies. This adjacency can then be called a static adjacency, as discussed previously. Conversely, if one of the degrees of freedom of the kinematic tensor is not zero, then the adjacency can be called a kinematic adjacency, as discussed previously.

[0186] Each symmetric node has a single child node, as explained previously. In the implementation currently discussed, the symmetric node also includes a vector of symmetry relation parameters, as explained previously. The vector of symmetry relation parameters can be of the following type: The vector of symmetry relation parameters is the second input (and corresponding output) of the symmetry encoding (and corresponding decoding) module, as discussed further below. Coordinates / parameters s1 correspond to the type of symmetry relation (reflection, rotation, and translation). Coordinates / parameters s2 correspond to the number of repetitions for rotational and translational symmetry relations. Coordinates / parameters (s3,…,s8) either correspond to parameters of the plane of reflection for reflection symmetry (including the 3D normal vector and the specifications (e.g., coordinates) of a 3D point belonging to that plane), or parameters of the axis of rotation for rotational symmetry (including a 3D vector collinear with that axis and the specifications / coordinates of a point belonging to that axis), or parameters of the displacement vector for translational symmetry.

[0187] Now let's discuss generative autoencoders. Figure 5 A schematic view of the VAE-GAN structure of a generative autoencoder is shown. The generative autoencoder also includes an encoder and a decoder, each comprising a recursive encoding module and a decoding module, respectively. (Refer to...) Figure 6 and Figure 7 The recursive encoding and decoding modules are discussed. Each recursive encoding module and each decoding module can be a two-layer perceptron network, for example, with a 100-D hidden layer and an 80-D output layer.

[0188] Figure 6 A schematic view of the encoder's recursive encoding module and the recursive bottom-up encoding process is shown, as previously discussed. Figure 6 As shown, the encoder takes a given tree 60 of the functional structure as input and encodes the tree 60 into a single, fixed-size latent vector. Adjacent nodes of tree 60 are represented as circles including "A", symmetric nodes are represented as circles including "S", and leaf nodes are represented as circles excluding letters. The encoder includes three recursive encoding modules (in... Figure 6 The following are represented as bounded boxes 64, 66, and 68: leaf encoding module 64, mechanical link encoding module 66 (also referred to as the "adjacency encoding module" in this implementation), and replica encoding module 68 (also referred to as the "symmetric encoding module" in this implementation). The recursive bottom-up encoding process recursively folds / aggregates the nodes of tree 60 in such a way that it proceeds upwards from the bottom level of the nodes of tree 60 to the root node of tree 60 in the direction indicated by arrow 62, and each time a node is encountered, it is encoded by applying the appropriate encoding module, as described below.

[0189] During the encoding process, the leaf encoding module 64 encodes encountered leaf nodes by taking a vector included in the leaf node (i.e., a vector having first and second coordinates representing the bounding box and the resultant force, respectively) as input and outputting a latent vector of fixed size. Specifically, the leaf encoding module 64 has an 18-D input (or optionally 19-D if the vector has a third coordinate as previously discussed) and an nD output corresponding to the vector of the leaf node. The parameters of the leaf encoding module 64 are the weight matrix W. ae ∈R n×18 Sum of deviation vector b ae ∈R n These parameters are used to obtain the latent vector of the parent node y from the child node x using the following formula: y = tanh(W ae .x+b ae ).

[0190] During the encoding process, the adjacency encoding module 66 encodes the encountered adjacent nodes in the following way:

[0191] - If the adjacent nodes do not include the vector of adjacency parameters (this is...) Figure 6 As shown in the diagram, two latent vectors (each encoding one of the corresponding child nodes of the two child nodes of an adjacent node) are taken as inputs and one latent vector is output. The adjacency coding module has two nD inputs and one nD output, where n is an integer. The parameters of the adjacency coding module are the weight matrix W. ae ∈R n×2n Sum of deviation vector b ae ∈R n These parameters are used to obtain the latent vector of the parent (merged) node y based on the child nodes x1 and x2 using the following formula: y = tanh(W ae [x1x2]+b ae ).

[0192] Alternatively, if the adjacent nodes also include a vector of adjacency parameters, this vector, along with two latent vectors (each encoding one of the corresponding child nodes of the adjacent node), are taken as inputs and a single latent vector is output. In this case, the adjacency coding module has two nD inputs, an mD input corresponding to the vector of adjacency parameters, and an nD output, where n and m are integers. The parameters of the adjacency coding module are the weight matrix W. ae ∈R n ×(2n+m) Sum of deviation vector b ae ∈R n These parameters are used to obtain the latent vector of the parent (merged) node y from the child nodes x1, x2, and p using the following formula: y = tanh(Wae [x1x2p]+b ae ).

[0193] During the encoding process, the symmetric encoding module 68 encodes encountered symmetric nodes by taking the latent vector encoding individual child nodes of the symmetric node and the vector of symmetric relation parameters as inputs and outputting a latent vector. Specifically, the symmetric encoding module has two inputs (an nD input and an sD input (s=8)) and an nD output. The parameters of the symmetric encoding module are the weight matrix W. se ∈R n×(n+s) Sum of deviation vector b se ∈R n These parameters are used to obtain the latent vector of the parent (merged) node y from the child node x1 and the symmetric parameter vector x2 using the following formula: y = tanh(W se [x1x2]+b se ).

[0194] Figure 7 A schematic view of the decoder's recursive decoding module and the recursive top-down decoding process is shown, as previously discussed. Figure 7 As shown, the decoder takes a given single latent vector 70 of the functional structure as input and decodes it into a tree 80 of the functional structure. Adjacent nodes of the tree are represented as circles containing "A", symmetric nodes as circles containing "S", and leaf nodes as circles excluding letters. The encoder includes three recursive decoding modules (in... Figure 7 The following are represented as bounded boxes 74, 76, and 78: Leaf Decoding Module 74, Mechanical Link Decoding Module 76 (also referred to as the "Adjacency Decoding Module" in this implementation), and Copy Decoding Module 78 (also referred to as the "Symmetric Decoding Module" in this implementation). The recursive top-down decoding process decodes the latent vectors generated by previous decoding steps recursively into sub-latent vectors, each representing a node of tree 80: proceeding downwards in the direction indicated by arrow 72 from a given single latent vector (representing the root node of tree 80) to the last sub-latent vector generated during decoding (and representing a node at the bottom level of tree 80). Each time a generated latent vector is encountered, it is decoded by applying the appropriate decoding module, as described below.

[0195] The decoder also includes a node classifier 700, which, each time a latent vector is generated during decoding, starts from a given single latent vector 70 and performs the following operations: takes the latent vector as input, classifies the latent vector as corresponding to a leaf node, an adjacent node, or a symmetric node, selects the correct decoding module, and then applies the decoding module to the latent vector. In other words, the decoder guides the decoding process, as previously discussed.

[0196] During the decoding process, the leaf decoding module 74 decodes the latent vectors generated corresponding to the leaf nodes by taking the latent vectors as input and outputting an 18-D vector (or optionally a 19-D vector) having first and second coordinates (and an optional third coordinate specifying the type of geometric primitive) representing the bounding box and resultant force, respectively. Specifically, the leaf decoding module has an nD input and an 18-D output (or optionally a 19-D output if the vector has a third coordinate as previously discussed) corresponding to the leaf node. The parameters of the leaf decoding module are the weight matrix W. ae ∈R 18×n Sum of deviation vector b ae ∈R 18 These parameters are used to obtain the latent vector of the leaf node x based on the parent node y using the following formula: x = tanh(W ae .y+b ae ).

[0197] During the decoding process, the adjacency decoding module 76 decodes the latent vectors generated corresponding to adjacent nodes in the following manner:

[0198] -If the latent vector is classified as the neighboring node corresponding to the vector that does not include the adjacency parameter (this is...) Figure 7 (As shown in the example), the latent vector is taken as input and two sub-latest vectors are output. Specifically, the adjacency decoding module 76 performs an exact mirror operation of one of the adjacency encoding modules. The adjacency decoding module 76 has one nD input and two nD outputs. The parameters of the adjacency decoding module 76 are the weight matrix W. ad ∈R 2n×n Sum of deviation vector b ad ∈R 2n These parameters are used to obtain two potential vectors for the two child nodes x′1 and x′2 based on the parent node y′ using the following formula: [x′1, x′2] = tanh(W ad [y′]+b ad ).

[0199] Alternatively, if the latent vector is classified as an adjacent node corresponding to a vector including adjacency parameters, then the latent vector is taken as input and the output is a vector of two sub-latest vectors and adjacency parameters. In this case, the adjacency decoding module has one nD input, two nD outputs, and one mD output corresponding to a vector of adjacency parameters, where n and m are integers. The parameters of the adjacency decoding module are the weight matrix W. a′d ∈R (2n+m)×n Sum of deviation vector b a′d ∈R (2n+m) These parameters are used to obtain the potential vectors of child nodes x′1 and x2′ and the vector of adjacency parameter p′ based on the potential vector of parent node y′ using the following formula: [x1′x2′p′]=tanh(W a′d [y′]+b a′d ).

[0200] During the decoding process, the symmetric decoding module 78 decodes the latent vectors generated corresponding to symmetric nodes by taking the latent vector as input and outputting a vector of single sub-latest vectors and symmetry relation parameters. Specifically, the symmetric decoding module 78 performs an exact mirror operation of one of the symmetric encoding modules: [x′1,x′2]=tanh(W sd [y′]+b sd Specifically, the symmetric decoding module has one nD input and two outputs (one nD output and one sD output (s=8)). The parameters of the symmetric decoding module are the weight matrix W. sd ∈R (n+s)×n Sum of deviation vector b sd ∈R n+s These parameters are used to obtain the child node x′ and the symmetric parameter vector p′ from the latent vector of the parent node y′ using the following formula: [x′p′]=tanh(W sd .y′+b sd ).

[0201] Figure 7 A latent space classifier 7000 is also shown, which takes the generated latent vector as input during the decoding process and labels the latent vector using a label from a predetermined list as previously discussed. The latent space classifier 7000 and the node classifier 700 can be learned jointly or separately, as previously discussed, and in this implementation, both the latent space classifier 7000 and the node classifier 700 are learned by minimizing a so-called "polynomial logistic loss" (also known as "cross-entropy loss"), the type of which is:

[0202]

[0203] In this formula, C is the number of classes. When learning the S20 node classifier, these classes are: leaf nodes, adjacent nodes, and symmetric nodes. When learning the S30 latent space classifier, the classes are labels from a predefined list. In the formula, if the category label i is the ground truth label, then... It is a binary indicator, and This is the predicted probability output by the network for this class. The node classifier takes an nD vector as input and outputs a probability for each of the following classes: "leaf node", "adjacent node", and "symmetric node". The label classifier takes an nD vector as input and outputs a probability for each label in the list.

[0204] Now we will discuss providing one or more potential vectors for S100.

[0205] Each latent vector can be provided from at least a portion (e.g., all latent vectors) of one or more latent vectors in S100 by sampling a Gaussian distribution. Alternatively or additionally, each latent vector can be provided from at least another portion (e.g., all latent vectors) of one or more latent vectors by applying an encoder to a tree to encode a corresponding tree of the functional structure (e.g., a corresponding tree of the functional structure of the provided S10 dataset or another dataset such as a test dataset, the concept of which is known in the field of machine learning). The encoder encodes the tree into a latent vector.

[0206] Now let's discuss generating the S200 functional architecture.

[0207] Generating S200 involves decoding each latent vector (i.e., a latent vector among the provided S100 one or more latent vectors) using a decoder. In other words, for each latent vector, generating S200 involves applying the decoder to that latent vector. As previously discussed, applying the decoder to the latent vector produces successive sub-latent vectors, e.g., until the decoder outputs a feature structure tree. In the example, particularly in the example where one or more of the provided S100 latent vectors are contained in a single latent vector, generating S200 may include decoding each provided S100 latent vector, which outputs a corresponding tree of the feature structure for each latent vector. In the case of a single provided S100 latent vector, there is a single generated S200 feature structure, which includes the corresponding tree decoded from the single latent vector.

[0208] In the examples, the latent space classifier has been learned S30, and one or more latent vectors include a first latent vector and a second latent vector. In these examples, decoding for each of the first and second latent vectors generates a corresponding latent vector including the corresponding intermediate latent vector. In these examples, generating the S200 functional structure involves performing an interpolation operation between the first intermediate latent vector of the first latent vector and the second intermediate latent vector of the second latent vector. The interpolation operation is performed based on the same labels used to label the first and second intermediate latent vectors.

[0209] In other words, decoding the first (and second) latent vectors produces first (and second) intermediate latent vectors. The first (and second) latent vectors encode a first (and second) tree of the functional structure, and each corresponding first (and second) intermediate latent vector encodes a corresponding node of the first (and second) tree, which represents a corresponding sub-assembly of the mechanical assembly of the rigid part represented by the first (and second) tree. As previously explained, the corresponding intermediate latent vector can represent any of a leaf node, an internal node, or a root node. Therefore, its corresponding sub-assembly can be either the entire mechanical assembly of the rigid part or a strictly defined sub-assembly of the mechanical assembly of the rigid part, for example, a unique rigid part.

[0210] During the decoding of the first (and second) latent vectors, for each corresponding first (and second) intermediate latent vector, the latent space classifier takes the corresponding first (and second) intermediate latent vector as input and labels it using a label from a predetermined list. The latent space classifier uses the same label to label the first and second intermediate latent vectors that perform interpolation between them. This means that the first intermediate latent vector encodes the nodes of the first tree representing the first meaningful substructure of the first mechanical assembly of the rigid part, and the second intermediate latent vector encodes the nodes of the second tree representing the second meaningful substructure of the second mechanical assembly of the rigid part. This also means that both the first and second intermediate latent vectors belong to the same intermediate latent vector space. This further means that the first and second meaningful substructures are of the same type, that is, they are corresponding substructures of the same class of the two mechanical assemblies of the rigid part.

[0211] Now let's discuss the interpolation operation. Let v1 and v2 be the first and second intermediate latent vectors, respectively. The interpolation operation is a linear interpolation operation that takes v1 and v2 as input and outputs a vector v3 = α.v1 + (1-α).v2, where α ∈ [0,1]. Performing the interpolation operation involves computing vector v3 and replacing one of the first and second intermediate latent vectors (such as v1) with the computed vector v3. The interpolation operation can be referred to as a hybrid operation in the limiting case where α = 1 or 0. Therefore, performing the hybrid operation involves replacing v1 with v2 (or v2 with v1).

[0212] Once the interpolation operation has been performed, decoding continues. More precisely, assume that due to the interpolation operation, v1 has been replaced with v3 (or, in the case of mixing with α=0, only v2). Decoding of the first latent vector then continues, and decoding includes decoding v1, which is now equal to v3, as well as other sub-latest vectors of the first latent vector that have not yet been decoded. Decoding of the first latent vector then produces a first tree of functional structure representing a mechanical assembly of rigid parts including the meaningful sub-assemblies represented by vector v3. Decoding of the second latent vector can also continue until a second tree is produced.

[0213] It should be understood that several operations can be performed using different values ​​of α.

[0214] Figure 8 , Figure 9 and Figure 10 The interpolation (or hybridization) operation is shown in example S20, where the generative autoencoder has been learned on a dataset representing the functional structure of a chair. The tree here is labeled with “chair,” “seat,” “backrest,” “arm,” and “leg,” as previously discussed.

[0215] like Figure 8 As shown, chair 82 is a 3D view of the functional structure obtained by decoding the first latent vector without performing any interpolation operations. Chair 84 is a 3D view of the functional structure obtained by decoding the second latent vector without performing any interpolation operations. For different values ​​of α, the other chairs represent the result of performing interpolation operations between the intermediate latent vectors representing the leg substructures of chairs 82 and 84.

[0216] Figure 9 Another example of the result of interpolation between the leg structures of a chair is shown.

[0217] Figure 10 A chair 104 is shown, which is the result of hybrid interpolation performed on chair 102, wherein the legs of chair 102 have been replaced with the legs of another chair.

[0218] In any case, regardless of whether the generation of S200 includes interpolation (or mixing), the generation of S200 produces a generated functional structure representing a mechanical assembly of the part, to which topology optimization can be performed, as previously discussed.

[0219] Now we will discuss performing S300 topology optimization. Before that, let's discuss the concept.

[0220] Performing S300 topology optimization on a mechanical assembly of rigid parts means performing any topology optimization method, process, or algorithm on the mechanical assembly of rigid parts or any data structure representing that mechanical assembly that is suitable for topology optimization. Such a data structure may be, in particular, a generated functional structure or inferred from a generated functional structure. Therefore, performing S300 topology optimization involves providing inputs for topology optimization (i.e., providing inputs for a topology optimization method, process, or algorithm).

[0221] As is known in the field of topology optimization itself, the inputs to topology optimization include a FEM (Feature Element Model). An FEM represents a space containing rigid parts or any modeled object representing that mechanical assembly. An FEM can be 2D or 3D. An FEM can be regular or irregular. Regular FEMs allow for simplified calculations during topology optimization. An FEM can be of any type, for example, where each finite element is a tetrahedron or a hexahedron. Providing an FEM may include defining and meshing the design space. Performing S300 topology optimization may include displaying the FEM to a user and having other inputs defined by the user for topology optimization, such as through graphical user interaction on the displayed FEM. "Graphical user interaction" in relation to defining elements means any user interaction where the designer uses a haptic system (e.g., a mouse or a touch device such as a sensitive / touchscreen or a sensitive / touchpad) to activate one or more locations of the display element and the location where the element is to be placed. Activating the location of the scene may include positioning a mouse cursor on it or performing a touch on it. After activation, a representation of the defined element can be displayed substantially in real time.

[0222] As is known from the field of topology optimization itself, the inputs to topology optimization also include data associated with FEM, and this data depends on the mechanical assembly of the rigid parts.

[0223] As is known in the field of topology optimization itself, this associated data includes parameters for the design materials, in other words, data representing the materials of the mechanical assemblies in which rigid parts are formed. These material parameters can specifically represent the mechanical properties of the material. Material parameters can include, for example, the Young's modulus and / or Poisson's ratio of the material. In the example, a user can specify a material, for example, by selecting from a list, and / or the system can automatically determine the material parameters and / or suggest selections to the user, for example, based on one or more formulas and / or a database. The material can be any material, for example, a solid and / or isotropic material, such as metals (e.g., steel, silver, gold, titanium), plastics (e.g., nylon, ABS, polycarbonate, resin), ceramics, or composite materials.

[0224] As is known from the field of topology optimization itself, the associated data also includes global quantity constraints. Global quantity constraints are relative to the global quantity of material in the FEM. In other words, global quantity constraints limit the total amount of material in the entire FEM. Global quantity constraints can be provided, for example, as boundaries of the fraction of the (entire) FEM that can be filled with material, such as an upper boundary of that fraction. Alternatively, global quantity constraints can be boundaries that provide values ​​to be achieved. However, topology optimization can optimize an objective function that tends to use as much material as is available in the optimal result, thus making such equality constraints equivalent to upper boundary constraints. In all cases, the fraction can be a volume fraction (also known in this case as GVC, such as "Global Volume Constraint"). In other examples, global quantity constraints can involve values ​​representing the weight of the material.

[0225] As is known in the field of topology optimization itself, the associated data also includes data representing the conditions of mechanical assemblies using rigid parts, and based on this data, topology optimization is able to optimize mechanical assemblies of rigid part models in view of such anticipated uses.

[0226] As is known in the field of topology optimization itself, the associated data specifically includes forces, such as forces represented in the leaf nodes of the functional structures of this disclosure. In other words, the associated data includes vectors (e.g., whose magnitude is in Newtons or multiples thereof), each vector applicable to and linked to one or more finite elements of the FEM. These forces partially represent the loads that the mechanical assembly of the rigid part will bear during use. In other words, for each of the one or more finite elements in the FEM for which there are corresponding forces in the data, the data represents the fact that the material of the mechanical assembly of the rigid part at the location corresponding to the one or more finite elements will bear the corresponding load. However, since the mechanical assembly of the rigid part may theoretically bear an infinite number of loads, not all loads are represented by the forces present in the data. Forces only represent the constraints of the entire set of loads, such as the most important and / or the most representative loads. Forces can be determined for each modeling problem, and the force can be selected as the largest (i.e., the largest magnitude) force that the object can withstand during its lifetime, because these forces tend to cause the largest deformation and mechanical stress. These forces can be grouped into a set called load cases. In the example, the industrial problem may have one to 12 load cases. In the example, the user can select the finite element of the FEM via a graphical user interface and then specify the forces that can be applied to it.

[0227] As is known in the field of topology optimization itself, the associated data also includes boundary conditions. Each boundary condition applies to and is linked to one or more finite elements of the mesh, and represents the corresponding constraint on the boundary that the mechanical assembly of a rigid part is subjected to during use. In other words, each boundary condition represents the fact that the material of the mechanical assembly of the rigid part at the location corresponding to the one or more finite elements is subject to constraints on its displacement, for example, using Dirichlet boundary conditions. An element may have its displacement (and others) constrained along a plane, along a curve, along / around an axis, or to / around a point, and / or its displacement may be constrained only in translation, only in rotation, or in both translation and rotation. When the displacement is constrained to a point in both translation and rotation, the element is fixed in 3D space and is referred to as "clamped". However, an element may have its displacement constrained in translation along a plane, but be free to move in said plane (e.g., if the element belongs to an object mounted on a bearing); have its displacement constrained in translation along an axis, but be free to move in said axis (e.g., in a piston); or have its displacement constrained in rotation about an axis (e.g., a joint of a robotic arm).

[0228] In the example, boundary conditions represent all constrained boundaries. In other words, for each finite element of the FEM designed to ultimately contain constrained material (e.g., material held still), boundary (e.g., clamping) conditions can be associated to incorporate that fact into the topology optimization. In the example, the user can select the finite element of the FEM via a graphical user interaction and then specify the boundary conditions that can be applied to it.

[0229] In the example, one or more constraint boundaries of the mechanical assembly of the rigid part include or consist of one or more fixed boundaries (i.e., the material at the one or more boundaries cannot move), and the corresponding one or more boundary conditions are clamping conditions.

[0230] As is well known, topology optimization can include automatically optimizing an objective function based on inputs. The objective function can represent any mechanical property to be optimized. Topology optimization can specifically maximize stiffness. For this purpose, the objective function can be a compliance function. Compliance is the reciprocal of the stiffness of a structure. Therefore, compliance encapsulates the amount of deformation of the structure, taking into account a given load condition and fixed boundary conditions. Thus, when the optimization process minimizes compliance, this corresponds to maximizing the stiffness for a design of a given mass. Free variables in the objective function can be the distribution (i.e., layout) of the amount of material (e.g., volume fraction) on the FEM. Therefore, topology optimization can change the amount of material (e.g., volume fraction) in each finite element of the mesh to optimize the objective function. The objective function can depend on material parameters (i.e., fixed variables in the objective function may involve material parameters), and optimization can be performed under constraints including global quantity constraints. Optimization can be performed according to any algorithm (e.g., iterative algorithms). In the case where the amount of material is the volume fraction of the material, the optimization process will produce a distribution of the material volume fraction according to the finite element. In this context, topology optimization or performing S300 topology optimization may include an additional step of (e.g., automatic) filtering, namely, determining whether each finite element is (fully) filled with material based on this volume fraction distribution. For example, this could be based on a comparison with (e.g., a predetermined) threshold (e.g., above 0.1 or 0.2 and / or below 0.9 or 0.8, on the order of 0.5), and if the optimized volume fraction is above (correspondingly below) the threshold, the finite element is considered fully filled with material (correspondingly completely empty). In the example, performing S300 topology optimization may also include (e.g., automatically) calculating 3D modeled objects, such as boundary representation (B-Rep) models, based on the results. For example, performing S300 topology optimization may calculate a swept volume based on and along a series of finite elements generated by optimization and / or filtering.

[0231] like Figure 11 As shown in the figure, Figure 11This describes the specifications of the topology optimization scenario. A typical topology optimization workflow requires the design space 112 (subdivided here into small square elements), a set of load cases 114 (forces to be applied to the design), and boundary conditions 116 (locations where the design is constrained by deformation (e.g., "clamped" locations), here located across the entire left side of the design space 112) as input. Additional parameters can be defined, such as the shell that must be preserved, the mechanical properties of the selected material, the target mass, the maximum allowable deformation, or any other constraints. Since the goal of topology optimization is to generate an optimized design from a blank canvas (which is the design space), the design workflow can exclude providing initial geometry other than the defined design space.

[0232] The output of a typical topology optimization workflow is the geometry of the optimized design, which conforms as closely as possible to the input specifications. Figure 12 An optimized design is shown, illustrating the evolution of the design during the optimization process. In this example, the global volume fraction is set to 30%. Figure 12 The initial design 122, the design 124 after five optimization iterations, the design 126 after ten optimization iterations, and the final convergent design 128 after twenty-five optimization iterations are shown.

[0233] like Figure 13 The typical topology optimization workflow shown in the example can be followed by the following eight steps:

[0234] 1. Grid-based design of space

[0235] Discretization of the design space, such as Figure 11 As shown in the diagram. This means subdividing the space into small, simply connected elements, such as tetrahedrons and hexahedrons. These small elements can then be used as both the FEM for simulation and the design variables for optimization.

[0236] 2. Application load conditions and boundary conditions

[0237] Here, the typical topology optimization workflow can take forces and boundary conditions for a given input specification and apply them to the nodes of the FEM. Figure 11 The diagram shows a grid in which the design space is subdivided into regular square elements. The nodes on the left are clamped (fixed in 2D space), and a downward force is applied to the right-hand side of the middle of the design space.

[0238] 3. Initialize design variables

[0239] Each element has a given relative density value, which defines whether it is empty or filled with material, defined by the values ​​"0" and "1" respectively. Additionally, to ensure the continuity of the optimization problem, the typical topology optimization workflow allows elements to take any value between 0 and 1. This can be called "relaxation". Since the interpretation of elements with intermediate densities can be fuzzy, the typical topology optimization workflow can introduce a penalty method that forces intermediate element densities to be less globally effective for structural behavior than elements with lower and upper boundaries of 0 or 1 respectively. This drives the optimizer to produce a final design with few intermediate densities while still maintaining... Figure 12 The effect of the continuous format shown in the figure.

[0240] 4. Solving for equilibrium

[0241] At this point, a typical topology optimization workflow can have a fully defined finite element model, which is meshed and accompanied by forces and boundary conditions, where each element has a relative density value. Thus, a typical topology optimization workflow can assemble the global stiffness matrix and solve for the nodal displacements in structural equilibrium. In other words, a typical topology optimization workflow can calculate the deformation of the structure in its current state given the applied forces and boundary conditions.

[0242] 5. Calculate the objective function value and its derivative.

[0243] The objective function that can be used in any topology optimization is the compliance of the structure. Compliance is the reciprocal of stiffness and thus encapsulates the amount of deformation of the structure, taking into account the given load conditions and boundary conditions. Therefore, when the optimization process minimizes compliance, this is equivalent to maximizing the stiffness of the design for a given mass. Furthermore, due to the large number of design variables in the process, gradient-based methods can be used to perform optimization. Therefore, the typical topology optimization workflow can also compute the derivative of the objective function with respect to each design variable. In other words, the typical topology optimization workflow can calculate how the relative density of each element should be changed to improve compliance and satisfy constraints. To achieve this, this can be performed using the well-known and classic "adjoint sensitivity analysis". Additionally, after calculating the derivatives, these derivatives can be smoothed by filtering to improve numerical stability. The typical topology optimization workflow can reduce erroneous checkerboard patterns and introduce a length scale in the optimization to make it well-defined.

[0244] 6. Calculate the constraint values ​​and derivatives.

[0245] In a typical topology optimization workflow, the constraint function can be the global volume fraction (GVC) of the structure. Such a GVC defines the maximum allowable material volume and, consequently, the maximum mass of the material constituting the design. Therefore, the optimizer must find the optimal distribution of this mass in the design space to maximize stiffness. Figure 12 Intermediate designs 124 and 126 in the optimization workflow are shown, where the global volume fraction is the same, but the material distribution changes during optimization iterations in the process. The derivative with respect to this constraint is equal to the element volume, and if the element sizes are equal, the derivative is constant for each element, and is therefore easy to compute.

[0246] 7. Update design variables using mathematical programming

[0247] Once the values ​​of the objective function and constraints, along with their derivatives, are known, the typical topology optimization workflow can then use gradient-based mathematical programming to modify the relative density of each element to improve structural compliance without violating the specified GVC. Once the relative density values ​​of each element have been modified through mathematical programming, and the given modified design in the optimization process has not yet converged, the typical topology optimization workflow can loop back to step 4. The simple mathematical programming for this problem is known as the optimal criterion (OC). Any other known mathematical programming can be used.

[0248] 8. Output the final design

[0249] Once convergence is achieved, the standard topology optimization workflow can present the final design in the design space, where each element has an optimized relative density value. Through a simple thresholding process, the standard topology optimization workflow can extract a geometry defined by the set of elements whose relative density values ​​are above a certain threshold (e.g., chosen to be 0.5). The standard topology optimization workflow can now present the optimized geometry of the design, which is the output of the standard topology optimization workflow. Figure 12 The description in step 2 is shown and Figure 11 The final design 128 is shown in the figure, optimized for specifications.

[0250] Performing S300 topology optimization on a mechanical assembly of rigid parts represented by the generated functional structure can achieve all the steps of the usual topology optimization workflow.

[0251] It should be noted that performing S300 topology optimization in the example includes providing a topology optimization algorithm, such as any algorithm that implements the typical topology optimization workflow discussed earlier.

[0252] In these examples, performing S300 topology optimization also includes providing inputs to the topology optimization algorithm. This includes retrieving at least a portion of the inputs from the generated functional structure. For example, generating S200 can generate forces, each force represented by a leaf node of the tree of the generated functional structure. These generated forces can form the inputs for topology optimization, and thus these inputs are retrieved from the generated functional structure. As previously discussed, the topology optimization algorithm can also take the FEM, data of the mechanical assembly associated with the FEM and dependent on the rigid parts, global quantity constraints, usage conditions of the mechanical assembly of the rigid parts, and / or boundary conditions (e.g., fixtures) as inputs.

[0253] In these examples, performing S300 topology optimization involves running the topology optimization algorithm on a mechanical assembly of rigid parts (e.g., or on any data structure representing that mechanical assembly and suitable for input into the algorithm).

[0254] Figure 14 An example of the result of performing S300 topology optimization on the generated functional structure representing a chair is shown. Figure 14 A 3D view 142 of the generated chair is shown, as well as a 3D view 144 showing the result of performing S300 topology optimization on the generated chair 142.

[0255] Figure 15 This is a pipeline that illustrates how the modeling process is implemented.

Claims

1. A computer-implemented method for learning a generative automatic encoder configured to generate functional structures, said functional structures being data structures representing mechanical assemblies of rigid parts, said data structures comprising a tree, said tree including: • Leaf nodes, each leaf node represents the shape and location of a corresponding rigid part and the force applied to the corresponding rigid part; • First non-leaf nodes, each first non-leaf node having a plurality of child nodes, and each first non-leaf node representing a mechanical link between sub-assemblies, each sub-assembly being represented by a corresponding child node from the plurality of child nodes, wherein the mechanical link is the adjacency relationship between the sub-assemblies represented by the plurality of child nodes; and • Second non-leaf nodes, each second non-leaf node having a single child node, and each second non-leaf node representing a copy of a sub-assembly represented by the single child node, wherein the copies are symmetric relationships between instances of the sub-assembly represented by the single child node; The method includes: - Provides a dataset including functional structures; and -Learn the generative autoencoder on the dataset, The shape and positioning of the corresponding rigid component are represented by data including specifications of a bounding box surrounding the corresponding rigid component, and the force applied to the corresponding rigid component is a resultant force. The generative autoencoder includes: • An encoder, comprising a leaf encoding module, a mechanically linked encoding module, and a copy encoding module; and • The decoder includes a node classifier, a leaf decoding module, a mechanical link decoding module, and a copy decoding module; The encoder is configured to encode the tree into a single latent vector with respect to a given functional structure, according to a recursive bottom-up process, where: • The leaf encoding module outputs a corresponding latent vector for each leaf node based on the data including the specifications of the bounding box and the resultant force; The mechanical link encoding module outputs a corresponding latent vector for each first non-leaf node based on several latent vectors encoded for corresponding child nodes representing each first non-leaf node of the mechanical link; and The replica encoding module outputs a corresponding latent vector for each second non-leaf node based on the latent vector encoded for the corresponding single child node representing each second non-leaf node. The decoder is configured to decode a given single latent vector into a tree of functional structures according to a recursive top-down process, wherein: The node classifier will classify each latent vector generated during the decoding process as corresponding to a leaf node, a first non-leaf node representing a mechanical link, or a second non-leaf node representing a copy. The leaf decoding module outputs data including the specifications of the corresponding bounding box and the corresponding resultant force for each latent vector classified as corresponding to a leaf node during the decoding process. The mechanical link decoding module outputs several sub-latent vectors for each latent vector classified during the decoding process as corresponding to a first non-leaf node representing a mechanical link; and The replica decoding module outputs a single sub-latent vector for each latent vector that is classified during the decoding process as corresponding to a second non-leaf node representing a replica.

2. The method according to claim 1, wherein, The adjacency relationship belongs to a predetermined set of adjacency relationships.

3. The method according to claim 1, wherein, The symmetry relation belongs to a predetermined set of symmetry relations.

4. The method according to claim 1, wherein, The method further includes learning a latent space classifier, which is configured to take a latent vector as input and label the latent vector using a label from the predetermined list of labels.

5. The method according to any one of claims 1 to 4, wherein, The bounding box and the resultant force are represented by the first and second coordinates of the same vector, respectively.

6. A generative autoencoder having an encoder and a decoder, the autoencoder being capable of learning using the method according to any one of claims 1 to 5.

7. A computer-implemented method using the generative autoencoder according to claim 6, the method comprising: - Provide one or more potential vectors; as well as - Generate a functional structure, the generation of which includes decoding each latent vector using the decoder.

8. The method of use according to claim 7, further comprising: - Perform topology optimization on the mechanical assembly of the rigid parts represented by the generated functional structure.

9. The method of use according to claim 8, wherein, The generation produces forces, each of which is represented by a leaf node of the tree included in the generated functional structure, and wherein the generated forces form the input to the topology optimization.

10. The method of use according to any one of claims 7 to 9, wherein, The autoencoder is capable of learning according to claim 4: -The one or more potential vectors include a first potential vector and a second potential vector; - The decoding generates a corresponding latent vector for each of the first latent vector and the second latent vector, the corresponding latent vector including a corresponding intermediate latent vector; - Generating the functional structure includes performing an interpolation operation between the first intermediate latent vector of the first latent vector and the second intermediate latent vector of the second latent vector, based on the same label of the first intermediate latent vector and the second intermediate latent vector.

11. A computer program product comprising instructions for performing the method according to any one of claims 1 to 5 and / or the method of use according to any one of claims 7 to 10.

12. An apparatus comprising a data storage medium on which a generative automatic encoder according to claim 6 and / or a computer program product according to claim 11 is recorded.

13. The device of claim 12, further comprising a processor coupled to the data storage medium.

Images