Machine learning techniques for generating designs of three-dimensional objects

Abstract

In various embodiments, a topology optimization application solves topology optimization problems associated with designing a three-dimensional ("3D") object. The topology optimization application converts a first shape having a first resolution and representing the 3D object to a coarse shape having a second resolution, which is lower than the first resolution. Subsequently, the topology optimization application computes coarse structure analysis data based on the coarse shape. Then, the topology optimization application uses a trained machine learning model to generate a second shape having the first resolution and representing the 3D object based on the first shape and the coarse structure analysis data. The trained machine learning model modifies a portion of a shape having the first resolution based on structure analysis data having the second resolution. Advantageously, relative to the prior art, generating the second shape based on structure analysis data having a lower resolution reduces computational complexity.

Description

Background Technology Technical Field

[0001] The various implementation schemes generally involve computer science and computer-aided design, and more specifically, machine learning techniques for generating designs of three-dimensional objects.

[0002] Description of related technologies

[0003] Generative design of three-dimensional (“3D”) objects is a computer-aided design process that automatically generates designs of 3D objects that satisfy any number and type of design goals and constraints specified by the user. In some implementations, the generative design application specifies any number of topology optimization problems based on design goals and constraints. Each problem specification includes shape boundaries and values ​​for any number of parameters associated with the topology optimization problem. Some examples of parameters include, but are not limited to, material type, manufacturing method, manufacturing constraints, load use cases, design constraints, design goals, and completion criteria. The generative design application then configures a topology optimization application to solve each topology optimization problem independently. To solve a given topology optimization problem, a typical topology optimization application generates a shape based on the shape boundaries and then iteratively optimizes the shape based on the values ​​of different parameters. The generative design application presents the resulting optimized shape as a design in a design space to the user. Finally, the user explores the “generative” design space to select one or more of the designs included in the design space for additional design and / or manufacturing activities.

[0004] In one approach to solving a given topology optimization problem, the topology optimization application transforms the shape boundary into a shape represented as a mesh of shape elements corresponding to a 3D grid. The 3D grid defines the resolution of the optimized shape. During each iteration, the topology optimization application performs a structural analysis on the shape to compute the response of each shape element to each load use case. Some examples of responses include, but are not limited to, strain energy values, displacements, and rotations. Based on the responses, design constraints, and design objectives, the topology optimization application executes any number of optimization algorithms that modify any number of shape elements. For example, the topology optimization application might remove material from a subset of shape elements associated with the lowest strain energy values ​​to reduce the overall mass of the corresponding shape. The topology optimization application continues to iteratively analyze and modify the shape in this manner until it determines that one or more completion criteria have been met. The topology optimization application then outputs the shape generated during the final iteration as the optimized shape.

[0005] One drawback of the above methods is that solving each of the topology optimization problems involves performing computationally complex structural analysis operations on each shape element during each topology optimization iteration. Therefore, if the amount of time and / or computational resources allocated to design activities is limited, users may be forced to limit the total number of structural analysis operations performed during different topology optimization iterations in order to reduce overall computational complexity. For example, users could limit the total number of iterations performed by the topology optimization application to solve each topology optimization problem and / or limit the total number of topology optimization problems defined by the generative design application. By reducing the total number of structural analysis operations performed during different topology optimization iterations, users inevitably reduce the design space explored by the generative design application. Therefore, the generative design application may not produce many designs that converge more closely to the design objective compared to designs generated by the generative design application based on a reduced number of structural analysis operations. In this case, a suboptimal design may be chosen for additional design and / or manufacturing activities.

[0006] As mentioned above, there is a need in the art for more effective techniques to solve topology optimization problems when designing three-dimensional objects. Summary of the Invention

[0007] One embodiment of the present invention describes a computer-implemented method for solving topology optimization problems when designing 3D objects. The method includes: converting a first shape representing the 3D object with a first resolution into a coarse shape with a second resolution lower than the first resolution; calculating coarse structure analysis data based on the coarse shape; and generating a second shape representing the 3D object with the first resolution based on the first shape and the coarse structure analysis data via a trained machine learning model, wherein the trained machine learning model modifies a portion of the shape with the first resolution based on the structure analysis data with the second resolution.

[0008] At least one technical advantage of the disclosed technique over the prior art is that it significantly reduces the computational complexity associated with solving topology optimization problems when designing 3D objects. Specifically, the trained machine learning model modifies portions of a shape associated with a resolution based on corresponding structural analysis data associated with a lower resolution, thereby reducing the overall computational complexity associated with solving the corresponding topology optimization problem. When the computational complexity associated with solving the topology optimization problem is reduced, the generative design application can explore the overall design space more comprehensively than prior art methods. Therefore, the generative design application can produce designs that are more convergent to the design objective, enabling the selection of more optimized designs for additional design and / or manufacturing activities. These technical advantages provide one or more technical improvements over prior art methods. Attached Figure Description

[0009] To gain a detailed understanding of the features described above in the various embodiments, reference can be made to the various embodiments for a more specific description of the inventive concept briefly outlined above, some of which are illustrated in the accompanying drawings. However, it should be noted that the drawings illustrate only typical embodiments of the inventive concept and should therefore not be considered as limiting the scope, and that other equally effective embodiments exist.

[0010] Figure 1 It is a conceptual diagram of a system configured to implement one or more aspects of various implementation schemes;

[0011] Figure 2 It is based on various implementation plans. Figure 1 A more detailed diagram of the inference engine;

[0012] Figure 3 It is a flowchart of the steps for solving topology optimization problems when designing 3D objects, based on various implementation schemes;

[0013] Figure 4 It is based on various implementation plans. Figure 1 A more detailed illustration of the training application;

[0014] Figure 5 It is based on various implementation plans. Figure 1 A more detailed illustration of the trained machine learning model; and

[0015] Figure 6 It is a flowchart of the method steps for training a machine learning model to modify parts of the shape when designing 3D objects, according to various implementation schemes. Detailed Implementation

[0016] In the following description, numerous specific details are set forth to provide a more thorough understanding of various embodiments. However, it will be apparent to those skilled in the art that the inventive concept can be practiced without one or more of these specific details.

[0017] System Overview

[0018] Figure 1This is a conceptual illustration of system 100 configured to implement one or more aspects of various implementation schemes. As shown, system 100 includes, but is not limited to, computational instance 110(1) and computational instance 110(2). For illustrative purposes, multiple instances of similar objects are indicated by reference numerals identifying the objects and, when necessary, by bracketed alphanumeric characters identifying the instances. Multiple versions of a single object (where each version is associated with a different point in time) are indicated by reference numerals identifying the objects and, when necessary, by alphanumeric subscripts identifying the versions.

[0019] In various implementations, any number of components of system 100 may be distributed across multiple geographical locations or in any combination within one or more cloud computing environments. Right now Implemented within encapsulated shared resources, software, data, etc. For illustrative purposes only, compute instance 110(1) and compute instance 110(2) are also individually referred to herein as “compute instance 110” and collectively as “compute instance 110”. In some embodiments, system 100 may include any number of compute instances 110. In the same or other embodiments, each compute instance 110 may be implemented in a cloud computing environment, as part of any other distributed computing environment, or independently.

[0020] As shown in the figure, computing instance 110(1) includes, but is not limited to, processor 112(1) and memory 116(1), and computing instance 110(2) includes, but is not limited to, processor 112(2) and memory 116(2). Processors 112(1) and 112(2) are also referred to individually as “processor 112” and collectively as “processor 112” herein. Memory 116(1) and 116(2) are also referred to individually as “memory 116” and collectively as “memory 116” herein.

[0021] Each of the processors 112 can be any instruction execution system, device, or apparatus capable of executing instructions. For example, each of the processors 112 may include a central processing unit, a graphics processing unit, a controller, a microcontroller, a state machine, or any combination thereof. The memory 116 of each of the computing instances 110 stores content used by the processors 112 of the computing instance 110, such as software applications and data. In some alternative embodiments, each of any number of computing instances 110 may include any number of processors 112 and any number of memories 116 in any combination. In particular, any number of computing instances 110 (including one) may provide a multiprocessing environment in any technically feasible manner.

[0022] Memory 116 may be one or more readily available memories, such as random access memory, read-only memory, floppy disk, hard disk, or any other form of local or remote digital storage device. In some embodiments, a storage device (not shown) may supplement or replace memory 116. The storage device may include any number and type of external memory accessible to processor 112. For example, but not limited to, the storage device may include a secure digital card, external flash memory, portable optical disc read-only memory, optical storage device, magnetic storage device, or any suitable combination of the foregoing.

[0023] Generally, each of the computing instances 110 is configured to implement one or more software applications. For illustrative purposes only, each application is described as residing in the memory 116 of one of the computing instances 110 and executing on the processor 112 of the computing instance 110. However, in some embodiments, the functionality of any number of software applications may be distributed across any number of other software applications residing in the memory 116 of any number of computing instances 110 and executing in any combination on the processor 112 of any number of computing instances 110. Furthermore, the functionality of any number of software applications may be combined into a single software application.

[0024] Specifically, computational instance 110(1) is configured to solve a topology optimization problem as defined by specification 132. Specification 132 includes, but is not limited to, any quantity and / or type of data associated with the topology optimization problem. As shown, specification 132 includes, but is not limited to, parameter set 140 and shape definition 148.

[0025] Parameter set 140 specifies the values ​​of any number and / or type of parameters associated with the topology optimization problem. Some examples of parameters include, but are not limited to, materials, manufacturing methods, manufacturing constraints, load use cases, design constraints, design objectives, completion criteria, etc. For illustrative purposes only, the parameter values ​​specified in parameter set 140 are also referred to individually as "parameter values" and collectively as "parameter values" in this document.

[0026] Shape definition 148 characterizes any number and / or type of aspects of the initial shape of a 3D object associated with a topology optimization problem in any technically feasible manner. In some embodiments, shape definition 148 specifies, but is not limited to, a shape boundary specifying the maximum volume associated with the 3D object. For example, in some embodiments, shape definition 148 specifies a 3D cube defining the maximum volume. In some embodiments, shape definition 148 specifies the initial shape of the 3D object. In the same or other embodiments, shape definition 148 specifies, but is not limited to, any number and / or type of "reservations," where each reservation specifies the initial shape (…). For exampleThe portion to be retained (the mounting plate). This can be done in any technically feasible way ( For example Reserved items are specified via the reserved item label.

[0027] As previously described herein, in one approach to designing 3D objects, a generative design application specifies any number of topology optimization problems based on user-defined design goals and constraints. The generative design application then configures a topology optimization application to solve each topology optimization problem independently. To solve a given topology optimization problem, the topology optimization application iteratively optimizes the initial shape to generate an optimized shape that converges more closely to the design goals than the initial shape.

[0028] In one approach to solving a given topology optimization problem, a conventional topology application represents the initial shape as a mesh of shape elements corresponding to a 3D grid with a given resolution. During each iteration, the conventional topology application performs a structural analysis to compute the response of each shape element to any number of load use cases. The conventional topology application then optimizes any number of shape elements based on the responses, design constraints, and design objectives.

[0029] One drawback of the above methods is that solving each topology optimization problem involves performing computationally complex structural analysis operations on each shape element during each iteration. If the amount of time and / or computational resources allocated to design activities is limited, users may be forced to limit the total number of structural analysis operations performed during different topology optimization iterations in order to reduce overall computational complexity. By reducing the total number of structural analysis operations performed during different topology optimization iterations, users will inevitably reduce the quantity and / or quality of optimized designs generated by generative design applications. In this case, a suboptimal design may be chosen for additional design and / or manufacturing activities.

[0030] Using machine learning techniques to reduce computational complexity

[0031] To address the aforementioned issues, in some implementations, computational instance 110(1) includes, but is not limited to, topology optimization application 120. In solving the topology optimization problem as defined via specification 132, topology optimization application 120 selectively uses one or more versions of a trained machine learning model 192( Figure 1 (Not explicitly shown) to reduce overall computational complexity. In some implementations, computational instance 110(2) includes, but is not limited to, training application 190, which performs any number and / or type of machine learning operations to generate any number of versions of trained machine learning model 192.

[0032] For illustrative purposes only, different versions of the trained machine learning model 192 are referred to in this paper as trained machine learning models 1921 to 192. Q , where Q can be any positive integer. Each trained machine learning model 1921 to 192 Q Corresponding to different time points. The trained machine learning model from 1921 to 192... Q In this paper, it is also referred to separately as "trained machine learning model 192" and collectively as "trained machine learning model 192".

[0033] As shown in the figure, in some embodiments, the topology optimization application 120 resides in memory 116(1) of computing instance 110(1) and executes on processor 112(1) of computing instance 110(1). In the same or other embodiments, the training application 190 resides in memory 116(2) of computing instance 110(2) and executes on processor 112(2) of computing instance 110(2). More generally, in some embodiments, the functionality of the topology optimization application 120 and / or the functionality of the training application 190 are distributed across any number of software applications. Each software application may reside in any number of memories 116 of any number of computing instances 110 and execute in any combination on any number of processors 112 of any number of computing instances 110. In some other embodiments, the functionality of the topology optimization application 120 and the functionality of the training application 190 are combined into a single software application.

[0034] In some embodiments, the topology optimization application 120 generates an optimized shape 198 based on specification 132. As previously described herein, specification 132 includes, but is not limited to, any quantity and / or type of data associated with the topology optimization problem. The topology optimization application 120 may obtain specification 132 in any technically feasible manner. In some embodiments, the topology optimization application 120 receives specification 132 from a generative design application (not shown) performing a generative design process. As previously described here, in some embodiments, specification 132 includes, but is not limited to, parameter set 140 and shape definition 148.

[0035] Parameter set 140 specifies, but is not limited to, any number of parameter values ​​of any number and / or type of parameters associated with the topology optimization problem. As shown in the figure, in some embodiments, parameter set 140 includes, but is not limited to, fine grid size 142, grid ratio 144, fine block size 146, and any number and / or type of other parameter values ​​(indicated by ellipses) organized in any technically feasible manner. For example, in some embodiments, specification 132 includes, but is not limited to, any combination of manufacturing, load use cases, design constraints, design objectives, and solving the topology optimization problem (…). For example (Completion criteria) and any number and / or type of parameter values ​​associated with generating the trained machine learning model 192.

[0036] A fine grid size of 142 is specified, but not limited to, fine grids. Figure 1 The 3D dimensions (not shown in the diagram). In some implementations, the fine grid defines a 3D mesh of voxels, where each voxel corresponds to a different portion of 3D space. The fine grid at least partially determines the resolution of the initial shape associated with topology optimization. A grid ratio of 144 specifies the fine grid compared to a coarse grid, which is a downsampled version of the fine grid. Figure 1 The ratio between (not shown in the image). The grid ratio can be specified in any technically feasible way.

[0037] For example, in some embodiments, the fine grid size 142 specifies a 3D size of 160×160×160 for the fine grid, and the grid ratio 144 is 2:1. Therefore, the fine grid is a 160×160×160 grid of 4,096,000 voxels, and the coarse grid is an 80×80×80 grid of 512,000 “coarse” voxels, and the fine and coarse grids represent the same portion of 3D space. In some other embodiments, the fine grid size 142 specifies a 3D size of 160×160×160 for the fine grid, and the grid ratio 144 is 2:1. Therefore, the fine grid is a 160×160×160 grid of 4,096,000 voxels, and the coarse grid is a 40×40×40 grid of 64,000 “coarse” voxels, and the fine and coarse grids represent the same portion of 3D space.

[0038] As described in more detail below, in some implementations, a trained machine learning model 192 is generated and subsequently invoked based on any number of model blocks (not shown). Each of the model blocks defines a different portion of the 3D space associated with both the fine and coarse grids. The fine block size 146 defines the 3D size of the model block relative to the fine grid. As described in more detail below, the model block associated with training the trained machine learning model 192 may be different from the model block associated with invoking the trained machine learning model 192. The model block associated with training the trained machine learning model 192 is also referred to herein as a "training block," and the model block associated with invoking the trained machine learning model 192 is also referred to herein as an "inference block."

[0039] Shape definition 148 characterizes, but is not limited to, any number and / or type of aspects of the initial shape associated with the topology optimization problem in any technically feasible manner. Optimized shape 198 is the solution to the topology optimization problem associated with specification 132. More precisely, optimized shape 198 is a version of the initial shape used for topology optimization based on parameter set 140. Topology optimization application 120 can generate and specify optimized shape 198 in any technically feasible manner.

[0040] Although not shown, in some embodiments, any number of instances of the topology optimization application 120 may each solve any number of different topology optimization problems sequentially, in parallel, or in any combination thereof. Each topology optimization problem is associated with different specifications in any number of specifications 132. For each topology optimization problem, the associated instances of the topology optimization application 120 generate different optimization shapes 198.

[0041] As shown in the figure, in some implementations, the topology optimization application 120 includes, but is not limited to, specification 132, mesh engine 134, workflow 150, fine grid engine 160, and coarse grid engine 170. In some implementations, the topology optimization application 120 performs any number and / or type of input, output, transformation, etc., operations, and coordinates the overall topology optimization process for resolving the topology optimization problem associated with specification 132.

[0042] In some implementations, after obtaining specification 132, topology optimization application 120 inputs fine grid size 142 and shape definition 148 into mesh engine 134. In response, mesh engine 134 generates and outputs shape 128(0), which is a representation of the initial shape associated with the topology optimization problem defined by specification 132. In some implementations, shape 128(0) is, but is not limited to, any number of fine shape elements (…). Figure 1A 3D mesh (not shown), where each fine shape element corresponds to a different voxel in the fine grid and is specified, but not limited to, any number and / or type of value.

[0043] For example, in some embodiments, the fine grid size 142 is 160×160×160, and the mesh engine 134 generates a shape 128(0) including but not limited to 3,096,000 fine shape elements. The mesh engine 134 can generate the shape 128(0) in any technically feasible manner and in any format. In some embodiments, the mesh engine 134 performs any number and type of transformation operations, meshing operations, partitioning operations, or any combination thereof based on the shape definition 148 and the fine grid size 142 to generate the shape 128(0).

[0044] In some embodiments, mesh engine 134 generates shape 128(0) according to a spatial data format (“SDF”). In SDF, each fine shape element includes, but is not limited to, any amount and / or type of spatial data and optionally any amount and / or type of attributes. In some embodiments, each fine shape element includes, but is not limited to, a directed distance field representing the associated spatial data. In some embodiments, the absolute value of each directed distance field is related to the distance to the shape it represents (…). example like The distance to the surface of shape 128(0) is related. In the same or other embodiments, negative, positive, and zero values ​​of the directed distance field respectively specify the portion of the represented shape inside, outside, and on the surface of the represented shape. In some other embodiments, each fine shape element includes, but is not limited to, a density field representing associated spatial data.

[0045] In some implementations, each fine shape element includes, but is not limited to, a value for a reservation label, in addition to spatial data. In some implementations, the value of the reservation label corresponds to a reservation specified in shape definition 148. If the reservation label has a true value, then the associated spatial data corresponds to the reservation and is not modified. Otherwise, the associated spatial data can be modified. Mesh engine 134 can generate the values ​​of the reservation labels in any technically feasible manner.

[0046] In some implementations, topology optimization application 120 determines and executes workflow 150 based on specification 132. Workflow 150 describes, but is not limited to, how topology optimization application 120 configures fine grid engine 160, coarse grid engine 170, and training application 190 to solve a topology optimization problem in any technically feasible manner. In some implementations, workflow 150 describes, but is not limited to, how and / or when topology optimization application 120 routes any amount and / or type of data among any number of topology optimization applications 120, grid engine 134, fine grid engine 160, coarse grid engine 170, and training application 190 in any combination. Workflow 150 may describe how topology optimization application 120 implicitly, explicitly, or in any combination thereof routes any amount and / or type of data.

[0047] In some implementations, to solve the topology optimization problem, the topology optimization application 120 sequentially coordinates the generation of Z topology optimization iterations of shapes 128(1) to 128(Z) (not explicitly shown), where Z can be any positive integer. For illustrative purposes only, shapes 128(0) to 128(Z) are also collectively referred to herein as "shape 128" and are referred to individually as "shape 128". As described herein, for an integer i from 0 to (Z-1), one of the inputs to the i-th topology optimization iteration is shape 128(i), and one of the outputs of the i-th topology optimization iteration is shape 128(i+1).

[0048] The topology optimization application 120 can determine the final topology optimization iteration in any technically feasible manner, denoted herein as the (Z-1)th topology optimization iteration. In some embodiments, the topology optimization application 120 determines the final topology optimization iteration based on a completion criterion of desired convergence between a specified shape 128(Z) and the design objective. After the topology optimization application 120 completes the execution of the final topology optimization iteration, it sets the optimized shape 198 to be equal to the shape 128(Z) that is the output of the final topology optimization iteration.

[0049] As shown in the figure, in some embodiments, workflow 150 includes, but is not limited to, fine grid stages 152(0) to 152(R), training stage 154, and coarse grid stages 156(1) to 156(R), where R can be any positive integer. For illustrative purposes only, fine grid stages 152(0) to 152(R) are also collectively referred to herein as “fine grid stage 152” and are individually referred to as “fine grid stage 152”. Coarse grid stages 156(1) to 156(R) are also collectively referred to herein as “coarse grid stage 156” and are individually referred to as “coarse grid stage 156”. In some other embodiments, workflow 150 may include any number of fine grid stages 152, any number of training stages 154, and any number of coarse grid stages 156 in any combination.

[0050] In some implementations, the topology optimization application 120 distributes Z topology optimization iterations across a fine grid stage 152 and a coarse grid stage 156. The topology optimization application 120 configures a fine grid engine 160 to perform the topology optimization iterations included in the fine grid stage 152 and a coarse grid engine 170 to perform the topology optimization iterations included in the coarse grid stage 156. For illustrative purposes only, at any given point in time during the execution of topology optimization iterations, the topology optimization application 120 is in a “current grid stage,” which is either one of the fine grid stages 152 or one of the coarse grid stages 156.

[0051] In some implementations, the topology optimization application 120 executes the fine grid stage 152 and the coarse grid stage 156 in a sequential and alternating manner (according to workflow 150). In the same or other implementations, the topology optimization application 120 configures the training application 190 to execute the training stage 154 at least partially in parallel with any number of fine grid stages 152 and any number of coarse grid stages 156.

[0052] In some implementations, to initialize workflow 150, topology optimization application 120 executes the fine grid stage 152(0) and training stage 154 at least partially in parallel. After completing fine grid stage 152(0), topology optimization application 120 executes coarse grid stage 156(1) and fine grid stage 152(1) sequentially. Although not shown, however, sequentially and for each integer i from 2 to (R-1), topology optimization application 120 then executes coarse grid stage 156(i), followed by fine grid stage 152(i). Subsequently, as shown, topology optimization application 120 executes coarse grid stage 156(R) sequentially, followed by fine grid stage 152(R).

[0053] Each of the fine grid stages 152 includes, but is not limited to, multiple topology optimization iterations performed by the topology optimization application 120 via the fine grid engine 160. In some embodiments, the number of iterations may optionally vary across the fine grid stages 152. As depicted in italics, in some embodiments, fine grid stage 152(0) is associated with N topology optimization iterations, and each of fine grid stages 152(1) through 152(R) is associated with P topology optimization iterations. Thus, in such an embodiment, the topology optimization application 120 performs a total of N+R*P topology optimization iterations via the fine grid engine 160.

[0054] Each of the coarse raster stages 156 includes, but is not limited to, multiple topology optimization iterations performed by the topology optimization application 120 via the coarse raster engine 170. As described in more detail below, the coarse raster engine 170 uses a trained machine learning model 192. As depicted in italics, in some embodiments, each coarse raster stage 156 is associated with M topology optimization iterations. Thus, in such embodiments, the topology optimization application 120 performs a total of M*R topology optimization iterations via the coarse raster engine 170. In some other embodiments, the number of iterations may optionally vary across the coarse raster stages 156.

[0055] The topology optimization application 120 can determine the number of topology optimization iterations to be performed on each of the fine grid stages 152 and each of the coarse grid stages 156 in any technically feasible manner. In some embodiments, the values ​​of N, M, and P are specified in parameter set 140. As described in more detail below, in some embodiments, the training application 190 generates a trained machine learning model 192 based on any number of iteration datasets 178 (not explicitly shown) optionally generated by the fine grid engine 160. In the same or other embodiments, the coarse grid engine 170 uses the trained machine learning model 192. Therefore, in some embodiments, the value of N is chosen to ensure that the trained machine learning model 192 is trained on a minimum number of iteration datasets 178 before the topology optimization application 120 performs any coarse grid stage 156.

[0056] Each of the iterative datasets 178 is a distinct instance of iterative dataset 178. For illustrative purposes only, iterative dataset 178 is also referred to as "iterative dataset 178" in this document and is collectively referred to as "iterative dataset 178". Furthermore, parenthesized alphanumeric characters are used to identify distinct instances of iterative dataset 178 when necessary.

[0057] For illustrative purposes only, the functionality of the fine grid engine 160 is described herein within the context of an exemplary topology optimization iteration, denoted as the x-th iteration. To perform the x-th iteration via the fine grid engine 160, the topology optimization application 120 inputs any part (including none or all) of the shape 128(x) and parameter set 140 into the fine grid engine 160. In response, the fine grid engine 160 performs any number and / or type of topology optimization operations on the shape 128(x) to generate shape 128(x+1). In some embodiments, the topology optimization application 120 may optionally configure the fine grid engine 160 to generate an iterative dataset 178(x), which includes, but is not limited to, any amount and / or type of data related to the generation of the trained machine learning model 192.

[0058] As shown in the figure, in some embodiments, the fine grid engine 160 includes, but is not limited to, a structure analyzer 162(1) and a shape optimizer 168. In some embodiments, the structure analyzer 162(1) is an instance of a structure analyzer 162 (not shown). The fine grid engine 160 inputs any part (including all or none) of the shape 128(x) and parameter set 140 into the structure analyzer 162(1). In response, the structure analyzer 162(1) performs any number and / or type of structural analysis operations based on any number of parameter values ​​included in the shape 128(x) and parameter set 140 to generate and output a fine analysis result 166(x).

[0059] The parameter set 140 used by the structural analyzer 162(1) may include, but is not limited to, any amount and / or type of data related to the structural analysis of shape 128(x). In some embodiments, the parameter set 140 used by the structural analyzer 162(1) includes, but is not limited to, data related to manufacturing ( For example Any number of parameter values ​​associated with materials, manufacturing processes, load use cases, etc.

[0060] In some embodiments, the fine analysis results 166(x) include, but are not limited to, any amount and / or type of structural analysis data associated with the response of each of the fine shape elements included in shape 128(x) to any number of load use cases. In the same or other embodiments, the structural analysis data includes, but is not limited to, different discrete portions of the structural analysis data for each voxel included in the fine grid.

[0061] For example, in some embodiments, the fine analysis result 166(x) includes, but is not limited to, each of the two fine shape elements included in shape 128(x) and therefore the different strain energy values ​​(not shown) for each voxel included in the fine grid. In the same or other embodiments, the fine analysis result 166(x) may include, but is not limited to, any number of strain energy values, any number of displacements, any number of rotations, any amount and / or type of other structural analysis data, or any combination thereof. Since the fine analysis result 166(x) specifies data for each of the fine shape elements, the resolution of the fine analysis result 166(x) is equal to the resolution of shape 128(x).

[0062] As shown in the figure, in some embodiments, shape optimizer 168 performs, but is not limited to, any number and / or type of topology optimization operations on shape 128(x) based on the fine analysis result 166(x) and any part (including all or none) of parameter set 140 to generate shape 128(x+1). The portion of parameter set 140 used by shape optimizer 168 may include, but is not limited to, any amount and / or type of data related to the topology optimization of shape 128(x). In some embodiments, the portion of parameter set 140 used by shape optimizer 168 includes, but is not limited to, any number and / or type of parameter values ​​associated with design constraints, any number and / or type of parameter values ​​associated with design objectives, etc. In the same or other embodiments, shape optimizer 168 generates shape 128(x+1) that is more convergent to one or more design objectives than shape 128(x).

[0063] In some implementations, after generating and outputting shape 128(x+1), the fine raster engine 160 optionally generates an iterative dataset 178(x). The iterative dataset 178(x) includes, but is not limited to, any amount and / or type of data associated with the x-th iteration. (See below for further details.) Figure 2 In more detail, in some embodiments, the iterative dataset 178(x) includes, but is not limited to, shape 128(x), fine analysis result 166(x), and shape 128(x+1). In the same or other embodiments, the fine raster engine 160 stores the iterative dataset 178(x) in any memory accessible to the training application 190 and / or transfers the iterative dataset 178(x) to the training application 190. As depicted by the dashed arrows and dashed boxes, in some embodiments, the fine raster engine 160 stores the iterative dataset 178(x) in memory 116(2) of the computation instance 110(2).

[0064] As shown in the figure, in some embodiments, the topology optimization application 120 configures the fine grid engine 160 to generate iterative datasets 178(1) to 178(N), where N is the total number of topology optimization iterations included in the fine grid stage 152(0). In some other embodiments, the topology optimization application 120 may configure the fine grid engine 160 to generate any number of iterative datasets 178 during any number (including none or all) of the topology optimization iterations included in any number of fine grid stages 152. For example, in some embodiments, the topology optimization application 120 configures the fine grid engine 160 to generate different iterative datasets 178 when each of the topology optimization iterations is performed during each of the fine grid stages 152. In the same or other embodiments, the fine grid engine generates N+R*P different iterative datasets 178.

[0065] In some implementations, the topology optimization application 120 configures the training application 190 to perform the training phase 154 based on any part of the iterative dataset 178 and the parameter set 140. (See below for further details.) Figure 4 and Figure 5 In more detail, in some implementations, the training application 190 will use the current machine learning model ( Figure 1 (Not shown in the image) is initialized as an untrained machine learning model or a pre-trained machine learning model. In obtaining ( For example After iterating over the dataset 178(x) from the fine raster engine 160 and reading from memory 116(2), the application 190 is trained to generate a coarse shape 174(x) based on the raster ratio 144. Figure 1 (not shown in the image) and coarse analysis results 176(x)( Figure 1 (Not shown in the image). The coarse shape 174(x) and coarse analysis result 176(x) are downsampled versions of the coarse grid shape 128(x) and fine analysis result 166(x), respectively.

[0066] The training application 190 can generate the coarse shape 174(x) and coarse analysis results 176(x) in any technically feasible manner and in any format. In some embodiments, the coarse shape 174(x) is, but is not limited to, any number of coarse shape elements (…). Figure 1 A 3D mesh (not shown). Each of the coarse shape elements corresponds to a different coarse voxel in the coarse grid and is specified, but not limited to, any number and / or type of value. Thus, the resolution of the coarse shape 174(x) is defined by the resolution of the shape 128(x) and the grid ratio 144.

[0067] In some embodiments, the coarse analysis result 176(x) includes, but is not limited to, different discrete portions of the structural analysis data for each of the coarse shape elements included in the coarse shape 174(x). In the same or other embodiments, the training application 190 generates the coarse analysis result 176(x), which includes, but is not limited to, different discrete portions of the structural analysis data for each voxel included in the coarse grid. For example, in some embodiments, the coarse analysis result 176(x) includes, but is not limited to, different strain energy values ​​for each of the coarse shape elements included in the coarse shape 174(x) and therefore for each of the voxels included in the coarse grid. Therefore, the resolution of the coarse analysis result 176(x) is equal to the resolution of the coarse shape 174(x).

[0068] The training application 190 then generates distinct training sets for each of any number of training blocks based on the fine block size 146, shape 128(x), coarse shape 174(x), coarse analysis result 176(x), and shape 128(x+1). Figure 1 (Not shown in the image). In some embodiments, any number of training blocks may partially overlap with any number of other training blocks. The training application 190 may determine the training blocks in any technically feasible manner. (See below for reference.) Figure 4 In more detail, in some implementations, the training application 190 is based on the fine patch size 146 and the fine step size included in the parameter set 140. Figure 1 (not shown in the image) to determine the training block.

[0069] although Figure 1 Not shown, but in some implementations, each of the elements in the training set includes, but is not limited to, a fine input block, a coarse block, a coarse result block, and a fine output block corresponding to an associated training block. The fine input block and fine output block are portions of shape 128(x) and shape 128(x+1), respectively, corresponding to parts of the 3D space defined by the associated training block. The coarse block is a portion of the coarse shape 174(x) corresponding to the fine input block. The coarse result block is an optionally normalized portion of the coarse analysis result 176(x) corresponding to the coarse block.

[0070] In some implementations, the training application 190 incrementally trains the current machine learning model based on a training dataset to map fine input blocks, coarse blocks, and coarse result blocks to fine output blocks. The fine output blocks are predictions of associated blocks of shape 128(i+1) generated by the fine raster engine 160 based on shape 128(i), where i can be any integer.

[0071] In some implementations, the topology optimization application 120 configures the training application 190 to sequentially and repeatedly save the current machine learning model as trained machine learning models 1921 to 1921. QThe topology optimization application 120 can configure the training application 190 to store the current machine learning model based on any quantity and / or type of criterion. For example, in some implementations, the parameter set 140 includes, but is not limited to, any number and / or type of parameter values ​​associated with the activation trigger. For example (The time interval between activations, the number of iterative datasets 178 received between activations, etc.). When activated, the trigger causes the training application 190 to save the current machine learning model.

[0072] It should be noted that the techniques and functionality of the trained machine learning model 192 described herein are illustrative and not restrictive, and can be modified without departing from the broader spirit and scope of the invention. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments and techniques.

[0073] For example, in some other embodiments, training application 190 can generate any type of trained machine learning model 192, which can be used to generate a modified version of shape 128 associated with a given resolution based on any amount and / or type of structural analysis data associated with a lower resolution. In the same or other embodiments, the functionality of topology optimization application 120, fine grid engine 160, and coarse grid engine 170 is modified accordingly.

[0074] For illustrative purposes only, the functionality of the coarse grid engine 170 is described herein in the context of an exemplary topology optimization iteration, denoted as the y-th iteration. To perform the y-th iteration via the coarse grid engine 170, the topology optimization application 120 inputs shape 128(y) and any part (including none or all) of the parameter set 140 into the coarse grid engine 170. In response, the coarse grid engine 170 uses a trained machine learning model 192 to generate shape 128(y+1). In some embodiments, shape 128(y+1) is predicted to converge more to one or more design objectives than shape 128(y). In the same or other embodiments, shape 128(y+1) is a modified version of shape 128(y) predicted to be used for topology optimization relative to shape 128(y) according to one or more design objectives.

[0075] As shown in the figure, in some embodiments, the coarse raster engine 170 includes, but is not limited to, a remeshing engine 172, a structure analyzer 162(2), and an inference engine 180. In some embodiments, the coarse raster engine 170 inputs a shape 128(y) and a raster ratio 144 into the remeshing engine 172. In response, the remeshing engine 172 converts the shape 128(y) into a coarse shape 174(y). The coarse shape 174(y) is a downsampled version of the shape 128(y) associated with the coarse raster and can be represented in any technically feasible manner. For illustrative purposes only, any number of downsampled versions of the shape 128 associated with the coarse raster are also collectively referred to herein as “coarse shape 174” and are referred to individually as “coarse shape 174”.

[0076] The remeshing engine 172 can generate a coarse shape 174(y) in any technically feasible manner and in any format. In some embodiments, the remeshing engine 172 performs any number and / or type of downsampling operation on shape 128(y) based on a raster ratio of 144 and / or a coarse raster to generate the coarse shape 174(y). Some examples of downsampling operations include, but are not limited to, field transfer operations, remeshing operations, etc. The remeshing engine 172 generates a coarse shape 174(y) with the same format as shape 128(y). In some embodiments, the remeshing engine 172 generates the coarse shape 174(y) according to an SDF.

[0077] In some embodiments, structural analyzer 162(2) is an instance of structural analyzer 162. As shown, in some embodiments, coarse grid engine 170 inputs any portion (including all or none) of coarse shape 174(y) and parameter set 140 into structural analyzer 162(2). In response, structural analyzer 162(2) performs any number and / or type of structural analysis operations based on any number of parameter values ​​included in coarse shape 174(y) and parameter set 140 to generate coarse analysis result 176(y). The portion of parameter set 140 used by structural analyzer 162(2) may include, but is not limited to, any amount and / or type of data related to the structural analysis of coarse shape 174(y). In some embodiments, the portion of parameter set 140 used by structural analyzer 162(2) includes, but is not limited to, data related to manufacturing ( For example Any number of parameter values ​​associated with materials, manufacturing processes, load use cases, etc.

[0078] In some embodiments, the coarse analysis result 176(y) includes, but is not limited to, any quantity and / or type of structural analysis data associated with the response of each of the coarse shape elements included in the coarse shape 174(y) to any number of load use cases. For example, in some embodiments, the coarse analysis result 176(y) includes, but is not limited to, different strain values ​​(not shown) of each of the coarse shape elements included in the coarse shape 174(y). In the same or other embodiments, the coarse analysis result 176(y) may include, but is not limited to, any quantity and / or type of strain energy values, any quantity of displacement, any quantity of rotation, any quantity and / or type of other structural analysis data, or any combination thereof. Since the coarse analysis result 176(x) specifies data for each of the coarse shape elements, the resolution of the coarse analysis result 176(x) is equal to the resolution of the coarse shape 174(y), and therefore lower than the resolution of shape 128(y).

[0079] As shown in the figure, in some embodiments, the coarse raster engine 170 inputs shape 128(y), coarse shape 174(y), coarse analysis result 176(y), and any part of parameter set 140 into inference engine 180. In response, inference engine 180 generates shape 128(y+1). In some embodiments, shape 128(y+1) is predicted to converge more to one or more design objectives than shape 128(y). In the same or other embodiments, shape 128(y+1) is a modified version of shape 128(y) predicted to be topology optimized relative to shape 128(y) according to one or more design objectives. It should be noted that shape 128(y+1) is associated with the fine raster and has the same resolution as shape 128(y). Inference engine 180 can generate shape 128(y+1) in any technically feasible manner using a trained machine learning model 192.

[0080] Combined with the following text Figure 2 In more detail, in some embodiments, inference engine 180 performs any number and / or type of normalization operation on any portion of the coarse analysis result 176(y) to generate a normalized coarse analysis result (not shown). Inference engine 180 then determines any number of non-overlapping inference blocks based on the fine block size 146. Commonly, the non-overlapping inference blocks span the 3D space associated with the fine and coarse grids. In some embodiments, the fine block size 146 defines the 3D size of each inference block relative to the fine grid. In the same or other embodiments, the fine block size 146 and the grid ratio 144 define the 3D size of each inference block relative to the coarse grid.

[0081] In some implementations, based on inference blocks, inference engine 180 divides shape 128(x), coarse shape 174(x), and normalized coarse analysis results into fine input blocks, coarse blocks, and coarse result blocks, respectively. For each of the inference blocks, inference engine 180 generates an inference set ( Figure 1 (not shown in the image), the inference set includes, but is not limited to, fine input blocks, coarse blocks, and coarse result blocks corresponding to the inference blocks.

[0082] For example, in some implementations, the fine block size is 4×4×4 and the raster ratio 144 is 2:1. In some such implementations, the inference engine 180 divides shape 128(x) into non-overlapping 4×4×4 fine input blocks, each fine input block corresponding to a different block of 4×4×4 fine shape elements. The inference engine 180 divides coarse shape 174(x) into non-overlapping 2×2×2 coarse blocks, each coarse block corresponding to a different fine input block in the 4×4×4 fine input blocks. The inference engine 180 divides the normalized coarse analysis results into non-overlapping 2×2×2 coarse result blocks, each coarse result block corresponding to a different coarse block in the 2×2×2 coarse blocks and therefore to a different fine input block in the 4×4×4 fine input blocks. For each of the inference blocks, the inference engine 180 generates a different inference set, which includes, but is not limited to, the 4×4×4 fine input blocks, the 2×2×2 coarse blocks, and the 2×2×2 coarse result blocks corresponding to the inference block.

[0083] In some implementations, inference engine 180 acquires the latest version of the trained machine learning model 192 in any technically feasible manner. For example, in some implementations, inference engine 180 reads the trained machine learning model 192 from memory 116(2). q , where q is an integer between 1 and Q representing the most recently generated version of the trained machine learning model 192. In the same or other implementations, the integer q varies from 1 to Q over time, and therefore, the version of the trained machine learning model 192 used by the inference engine 180 can vary during topology optimization iterations.

[0084] The inference engine 180 inputs each element in the inference set into the trained machine learning model 192. q In the middle, and in response, for each in the inference set, the trained machine learning model 192 qDifferent fine output blocks are output. Each fine output block is a modified version of the associated fine input block and has the same resolution as the fine input block. Therefore, each fine output block is a different modified portion of shape 128(y). Inference engine 180 then aggregates the fine input blocks to generate shape 128(y+1). In some embodiments, shape 128(y+1) is predicted to converge more to one or more design objectives than shape 128(y). In the same or other embodiments, shape 128(y+1) is a modified version of shape 128(y) predicted to be topology-optimized relative to shape 128(y) according to one or more design objectives.

[0085] Advantageously, since the coarse raster engine 170 generates shape 128(y+1) based on shape 128(y) and coarse analysis result 176(y), the topology optimization application 120 can use a trained machine learning model 192 to reduce the computational complexity associated with solving the topology optimization problem. More precisely, since the coarse raster engine 170 configures the structure analyzer 162(2) to perform structural analysis on coarse shape 174(y) instead of shape 128(y), the structure analyzer 162(2) performs structural analysis operations at a coarser resolution. Therefore, the computational complexity associated with each topology optimization iteration performed by the coarse raster engine 170 is reduced relative to the computational complexity associated with each of the topology optimization iterations performed by the fine raster engine 160.

[0086] It should be noted that the techniques described herein are illustrative and not restrictive, and changes may be made without departing from the broader spirit and scope of the invention. Many modifications and variations to the functionality provided by the topology optimization application 120, mesh engine 134, fine grid engine 160, coarse grid engine 170, remeshing engine 172, structure analyzer 162, shape optimizer 168, inference engine 180, and training application 190 will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments.

[0087] It should be understood that the system 100 shown herein is illustrative, and variations and modifications are possible. For example, the functionality provided by the topology optimization application 120, mesh engine 134, fine-grid engine 160, coarse-grid engine 170, re-mesh engine 172, structure analyzer 162, shape optimizer 168, inference engine 180, and training application 190 as described herein can be integrated into or distributed across any number of software applications (including one) and any number of components of system 100. Furthermore, modifications can be made as needed. Figure 1 The connection topology between various units in the system.

[0088] Figure 2 It is based on various implementation plans. Figure 1 A more detailed illustration of the inference engine 180. For illustrative purposes only. Figure 2 The functionality of the inference engine 180 is described within the context of a more generalized version of the exemplary implementation depicted herein. Subsequently, a detailed description is provided. Figure 2 The functionality of an exemplary implementation of the inference engine 180 depicted herein.

[0089] As shown in the figure, inference engine 180 generates shape 128(y+1) based on any part of parameter set 140, shape 128(y), coarse shape 174(y), and coarse analysis result 176(y), where y is an integer that can represent any topology optimization iteration performed by coarse grid engine 170. (As previously combined in this paper...) Figure 1 As described, in some embodiments, parameter set 140 includes, but is not limited to, fine grid size 142, grid ratio 144, block size 146, and any number and / or type of other parameter values ​​(indicated by ellipses) organized in any technically feasible manner.

[0090] In some embodiments, the fine grid size 142 specifies the 3D dimensions of the fine grid 210 that defines the 3D mesh of voxels (not shown), where each voxel corresponds to a different portion of the 3D space. In the same or other embodiments, each of the shapes 128 (including shapes 128(y) and 128(y+1)) is a 3D mesh of different instances of fine shape elements 212 (not explicitly depicted) of each of the voxels in the fine grid 210.

[0091] For illustrative purposes only, instances of fine shape element 212 are also referred to herein individually as "fine shape element 212" and collectively as "fine shape element 212," regardless of whether instances are explicitly depicted in any figure. Each of the fine shape elements 212 specifies, but is not limited to, any number and / or type of values ​​associated with the corresponding voxel. Although not shown, in some embodiments, each fine shape element 212 includes, but is not limited to, a directed distance field representing the portion of shape 128 associated with the corresponding voxel and a reserved item label.

[0092] In some embodiments, the grid ratio 144 specifies the ratio between the fine grid 210 and the coarse grid 220, which is a downsampled version of the fine grid 210. As mentioned herein, the coarse grid 220 defines a 3D mesh of coarse voxels (not shown), where each coarse voxel corresponds to a different portion of 3D space. Each coarse voxel corresponds to a plurality of voxels in the fine grid 210. In the same or other embodiments, each of the coarse shapes 174 (including coarse shapes 174(y)) is a 3D mesh of different instances of coarse shape elements 222 (not explicitly depicted) for each voxel in the coarse grid 220.

[0093] For illustrative purposes only, instances of coarse shape element 222 are also referred to herein individually as "coarse shape element 222" and collectively as "coarse shape element 222," regardless of whether instances are explicitly depicted in any figure. Each of the coarse shape elements 222 corresponds to a different coarse voxel in the coarse grid 220 and is specified, but not limited to, any number and / or type of value. Although not shown, in some embodiments, each of the coarse shape elements 222 includes, but is not limited to, a directed distance field representing the portion of the coarse shape 174 associated with the corresponding coarse voxel and a reserved item label.

[0094] In some embodiments, each of the coarse analysis results 176 (including coarse analysis results 176(y)) may specify any amount and / or type of structural analysis data for each of the coarse shape elements 222 included in the corresponding instance of the coarse shape 174. For example, in some embodiments, coarse analysis results 176(y) includes, but is not limited to, different strain energy values ​​(not shown) for each of the coarse shape elements 222 included in the coarse shape 174(y). For illustrative purposes only, the structural analysis data included in coarse analysis results 176 are also referred to herein as “coarse structural analysis data” and “unnormalized coarse structural analysis data”.

[0095] As shown in the figure, in some implementations, the inference engine 180 includes, but is not limited to, a normalization engine 242 and a trained machine learning model 192. qAny number of instances and aggregation engine 270. In some implementations, inference engine 180 inputs coarse analysis result 176(y) into normalization engine 242. In response, normalization engine 242 performs any number and / or type of normalization operation on any portion of coarse analysis result 176(y) in any technically feasible manner to generate and output normalized coarse analysis result 246. Normalized coarse analysis result 246 may include, but is not limited to, any amount and / or type of normalized structural analysis data, any amount and / or type of unnormalized structural analysis data, or any combination thereof, of each of the coarse shape elements 222 included in coarse shape 174(y). For illustrative purposes only, the structural analysis data included in normalized coarse analysis result 246 is also referred to herein as “coarse structural analysis data”.

[0096] Specifically, in some embodiments, the coarse analysis result 176 includes, but is not limited to, any number of strain energy values ​​without bounds. As those skilled in the art will recognize, the strain energy distribution can differ significantly between different topology optimization iterations associated with the same topology optimization problem. To improve the robustness of the trained machine learning model 192, in some embodiments, the normalization engine 242 performs any number and / or type of normalization operations on any number of strain energy values ​​included in the coarse analysis result 176(y).

[0097] For example, in some implementations, for each strain energy value included in the coarse analysis result 176(y), the normalization engine 242 sets the corresponding normalized strain energy value to be equal to the logarithm of the z-score. The normalization engine 242 then generates a normalized coarse analysis result 246 including, but not limited to, the normalized strain energy values, wherein each of the normalized strain energy values ​​corresponds to a different coarse shape element in the coarse shape elements 222 included in the coarse shape 174(y).

[0098] In some implementations, the inference engine 180 generates any number of instances of the inference set 250 (not explicitly shown) based on shape 128(y), normalized coarse analysis result 246, fine grid size 142, grid ratio 144, and block size 146. For illustrative purposes only, instances of the inference set 250 are also referred to herein individually as "inference set 250" and collectively as "inference set 250," regardless of whether the instances are explicitly depicted in any figure.

[0099] Each element in the inference set 250 specifies a distinct set of values ​​for the input of the trained machine learning model 192. The inference engine 180 can generate the inference set 250 in any technically feasible manner consistent with the input of the trained machine learning model 192. (As previously mentioned in this document...) Figure 1As described, in some embodiments, each of the inference sets 250 corresponds to a different non-overlapping inference block (not shown). The inference engine 180 can determine the inference block in any technically feasible manner.

[0100] In some implementations, the fine block size 146 defines the 3D size of each inference block relative to the fine grid 210. The inference engine 180 defines non-overlapping inference blocks based on the fine block size 146, such that the inference blocks collectively span the 3D space associated with the fine grid 210 and the coarse grid 220. It should be noted that the fine block size 146 and the grid ratio 144 define the 3D size of each inference block relative to the coarse grid 220.

[0101] To generate the inference set 250, in some embodiments, the inference engine 180 divides the shape 128(y) into non-overlapping instances of fine input blocks 252 (not explicitly shown), each of which corresponds to a different inference block in the inference blocks. For illustrative purposes only, instances of fine input blocks 252 are also referred to herein individually as “fine input block 252” and collectively as “fine input block 252”, regardless of whether the instances are explicitly depicted in any figure. Each of the fine input blocks 252 derived from the shape 128(y) includes, but is not limited to, different subsets of the fine shape elements 212 included in the shape 128(y).

[0102] In the same or other embodiments, the inference engine 180 divides the coarse shape 174(y) into non-overlapping instances of coarse blocks 254 (not explicitly shown), each of the instances of coarse blocks 254 corresponding to a different inference block in the inference blocks. For illustrative purposes only, instances of coarse blocks 254 are also referred to herein individually as “coarse block 254” and collectively as “coarse block 254”, regardless of whether the instances are explicitly depicted in any figure. Each of the coarse blocks 254 derived from the coarse shape 174(y) includes, but is not limited to, different subsets of the coarse shape elements 222 included in the coarse shape 174(y).

[0103] In some implementations, the inference engine 180 divides the normalized coarse analysis result 246 into non-overlapping instances of coarse result blocks 248 (not explicitly shown), each of which corresponds to a different inference block in the inference blocks. For illustrative purposes only, instances of coarse result blocks 248 are also referred to herein individually as "coarse result blocks 248" and collectively as "coarse result blocks 248," regardless of whether the instances are explicitly depicted in any figure.

[0104] Each of the coarse result blocks 248 corresponds to a different coarse block in coarse block 254, and includes, but is not limited to, any amount and / or type of normalized structural analysis data, any amount and / or type of unnormalized structural analysis data, or any combination thereof, associated with coarse block 254. For example, in some embodiments, each of the coarse result blocks 248 includes a normalized strain energy value associated with a coarse shape element 222 included in a different coarse block in coarse block 254.

[0105] In some implementations, the total number of fine input blocks 252, the total number of coarse blocks 254, the total number of coarse result blocks 248, and the total number of inference blocks are equal. Furthermore, each inference block specifies a different portion of 3D space associated with one of the fine input blocks 252, one of the coarse blocks 254, and one of the coarse result blocks 248.

[0106] For each inference block, the inference engine 180 generates different inference sets in inference set 250, which include, but are not limited to, fine input blocks 252, coarse blocks 254, and coarse result blocks 248 corresponding to the inference blocks. Commonly, in some embodiments, inference set 250 represents, but is not limited to, fine shape elements 212 included in shape 128(y), coarse shape elements 222 included in coarse shape 174(y), and normalized strain energy values ​​included in normalized coarse analysis result 246 derived from coarse analysis result 176(y).

[0107] In some other embodiments, the inference engine 180 can generate any number of inference sets 250 in any technically feasible manner based on any number and / or type of parameter values, shape 128(y), coarse shape 174(y), and coarse analysis results 176(y). In the same or other embodiments, the normalization engine 242 is omitted from the inference engine 180, and the inference engine 180 partitions the coarse analysis results 176(y) to generate coarse result blocks 254.

[0108] In some implementations, the inference engine 180 feeds each of the inference set 250 into a trained machine learning model 192. q In different instances. For illustrative purposes only, as used in this article, "trained machine learning model 192" q "" refers to any instance of the latest version of the trained machine learning model 192, regardless of whether that particular instance is depicted in any graph. In response, the trained machine learning model 192 q Each instance outputs a fine output block of 260 different instances.

[0109] In some other implementations, the inference engine 180 feeds the inference set 250 into the trained machine learning model 192 sequentially, simultaneously, or in any combination thereof.q In any number of instances. For example, in some implementations, the inference engine 180 sequentially feeds the inference set 250 into the trained machine learning model 192. q In a single instance. In response, for each of the 250 inference sets, a trained machine learning model 192 q Individual instances of fine output block 260 are output sequentially from different instances of fine output block 260. For illustrative purposes only, instances of fine output block 260 are also referred to individually as "fine output block 260" and collectively as "fine output block 260" in this document, regardless of whether the instances are explicitly depicted in any figure.

[0110] In some implementations, for each instance of the inference set 250, a trained machine learning model 192 modifies the fine input block 252 based on the coarse block 254 and the coarse result block 248 to generate a fine output block 260. In the same or other implementations, each of the fine output blocks 260 is predicted to converge more to one or more design goals than the fine input block 252 used to generate the fine output block 260. Each of the fine output blocks 260 and each of the fine input blocks 252 includes, but is not limited to, the same total number of fine shape elements 212.

[0111] As shown in the figure, in some embodiments, the aggregation engine 270 generates shape 128(y+1) based on the fine output block 260. The aggregation engine 270 can generate shape 128(y+1) in any technically feasible manner. In some embodiments, the aggregation engine 270 performs any number and / or type of aggregation operations on the fine output block 260 based on the corresponding portion in 3D space to generate shape 128(y+1).

[0112] It should be noted that the total number of fine shape elements 212 included in shape 128(y+1) is equal to the total number of fine shape elements 212 included in shape 128(y). Therefore, the resolution of shape 128(y+1) is equal to the resolution of shape 128(y). Advantageously, in some embodiments, shape 128(y+1) is predicted to converge more to one or more design objectives than shape 128(y). In the same or other embodiments, shape 128(y+1) is a modified version of shape 128(y) predicted to be topology optimized relative to shape 128(y) according to one or more design objectives.

[0113] For the purpose of explanation only, Figure 2An exemplary embodiment is depicted in association with exemplary values ​​of fine grid size 142, grid ratio 144, and fine block size 146, depicted in italics, and exemplary boundaries of shape 128(y) and coarse shape 174(y), depicted in bold black lines. As shown, in the exemplary embodiment, the fine grid size 142 specifies that the size of the fine grid 210 is 8×16×8, the grid ratio 144 between the fine grid 210 and the coarse grid 220 is 2:1, and the fine block size 146 is 4×4×4.

[0114] exist Figure 2 In the depicted embodiment, since the fine grid size 142 is 8×16×8, the fine grid 210 includes, but is not limited to, 1024 voxels. Therefore, the shape 128(y) includes, but is not limited to, fine shape elements 212(1) to 212(1024). Furthermore, since the grid ratio 144 is 2:1, the size of the coarse grid 220 is 4×8×4. Therefore, the coarse grid 220 includes, but is not limited to, 128 coarse voxels. Therefore, the coarse shape 174(y) includes, but is not limited to, coarse shape elements 222(1) to 222(128).

[0115] For the purpose of explanation only, Figure 2 In the depicted implementation, the coarse analysis result 176(y) includes, but is not limited to, 128 different strain energy values ​​(not shown), each of which is associated with a different coarse shape element from coarse shape elements 222(1) to 222(128). The inference engine 180 inputs the coarse analysis result 176(y) into the normalization engine 242. In response, the normalization engine 242 generates a normalized coarse analysis result 246, which includes, but is not limited to, the 128 different normalized strain energy values.

[0116] In some implementations, the inference engine 180 determines 16 non-overlapping inference blocks based on an 8×16×8 fine mesh grid size 142 and a 4×4×4 fine block size 146. Since the grid ratio 144 is 2:1, each of the inference blocks corresponds to a different 4×4×4 block of the fine shape element 212 and a different 2×2×2 block of the coarse shape element 222. For example, and as depicted via dashed lines, the first inference block corresponds to the 4×4×4 block of the fine shape element 212 and the 2×2×2 block of the coarse shape element 222.

[0117] for Figure 2In the exemplary embodiment depicted, based on inference blocks, the inference engine 180 divides the shape 128(y), coarse shape 174(y), and normalized coarse analysis result 246 into fine input blocks 252(1) to 252(16), coarse blocks 254(1) to 254(16), and coarse result blocks 248(1) to 248(16), respectively. Each of the fine input blocks 252(1) to 252(16) includes, but is not limited to, a different subset of 64 fine shape elements in the fine shape element 212 included in the shape 128(y). Each of the coarse blocks 254(1) to 254(16) includes, but is not limited to, a different subset of 16 coarse shape elements in the coarse shape element 222. Each of the coarse result blocks 248(1) to 248(16) includes, but is not limited to, a different subset of 16 normalized strain energy values ​​in the normalized strain energy values ​​included in the normalized coarse analysis result 246.

[0118] The inference engine 180 generates inference sets 250(1) to 250(16) based on fine input blocks 252(1) to 252(16), coarse blocks 254(1) to 254(16), and coarse result blocks 248(1) to 248(16), each of which corresponds to a different inference block. For example, and as depicted by arrows and dashed lines, inference set 250(1) corresponds to the first inference block. As shown, inference set 250(1) includes, but is not limited to, fine input block 252(1), coarse block 254(1), and coarse result block 248(1). Also as shown, inference set 250(16) includes, but is not limited to, fine input block 252(16), coarse block 254(16), and coarse result block 248(16). Although not explicitly shown, for integers i from 2 to 15, the inference set 250(i) includes, but is not limited to, fine input block 252(i), coarse block 254(i) and coarse result block 248(i).

[0119] As described, for in Figure 2 In the exemplary implementation described herein, inference engine 180 inputs inference sets 250(1) to 250(16) into trained machine learning model 192, respectively. q (1) to 192 q (16) In response, the trained machine learning model 192 q (1) to 192 q (16) Output fine output blocks 260(1) to 260(16) respectively. In some implementations, fine output blocks 260(1) to 260(16) are modified versions of fine input blocks 252(1) to 252(16) respectively predicted to be topology optimized relative to fine input blocks 252(1) to 252(16) according to one or more design objectives.

[0120] exist Figure 2In the depicted implementation, inference engine 180 aggregates fine output blocks 260(1) to 260(16) to generate shape 128(y+1). Therefore, the resolution of shape 128(y+1) is equal to the resolution of shape 128(y). As depicted, shape 128(y+1) converges more towards the design goal of “minimizing mass” than shape 128(y). More precisely, shape 128(y+1) has, but is not limited to, less material and therefore less mass compared to shape 128(y).

[0121] Figure 3 This is a flowchart illustrating the steps of a method for solving topology optimization problems when designing 3D objects, based on various implementation schemes. (Although references are available...) Figure 1 and Figure 2 The system describes the method steps, but those skilled in the art will understand that any system configured to implement the method steps in any order falls within the scope of this invention.

[0122] As shown in the figure, method 300 begins with step 302, where the topology optimization application 120 determines the fine grid 210 based on parameter set 140 and generates an initial version of shape 128 based on the fine grid 210 and shape definition 148. At step 304, the topology optimization application 120 initiates a training process that iteratively generates any number of versions of the trained machine learning model 192 based on iterative dataset 178. The topology optimization application 120 can initiate the training process in any technically feasible manner. For example, in some embodiments, the topology optimization application 120 configures the training application 190 to perform the following combined... Figure 6 The described methods and steps.

[0123] At step 306, the fine grid engine 160 configures the structure analyzer 162 to perform structural analysis on shape 128 based on parameter set 140 to generate fine analysis result 166. At step 308, the fine grid engine 160 configures the shape optimizer 168 to perform topology optimization on shape 128 based on fine analysis result 166 and parameter set 140. As part of step 308, the fine grid engine 160 optionally generates and stores a new iterative dataset in iterative dataset 178.

[0124] At step 310, the topology optimization application 120 determines whether it has completed the current grid stage. If at step 310, the topology optimization application 120 determines that it has not yet completed the current grid stage, then method 300 returns to step 306, where the fine grid engine 160 configures the structure analyzer 162 to perform structural analysis on shape 128.

[0125] However, if at step 310, the topology optimization application 120 determines that it has completed the current grid phase, then method 300 proceeds to step 312. At step 312, the topology optimization application 120 determines whether it has completed. The topology optimization application 120 can determine whether it has completed in any technically feasible manner. For example (Based on any quantity and / or type of completion criteria).

[0126] If, at step 312, the topology optimization application 120 determines that it has completed, then method 300 proceeds to step 314. At step 314, the topology optimization application 120 stores the newly modified shape 128 as the optimized shape 198 and / or transfers it to any number and / or type of other software applications. Method 300 then terminates.

[0127] However, if at step 312, the topology optimization application 120 determines that it has not yet completed, then method 300 proceeds directly to step 316. At step 316, the coarse raster engine 170 calculates a coarse shape 174 based on shape 128 and the raster ratio 144 specified in parameter set 140. At step 318, the coarse raster engine 170 configures the structure analyzer 162 to perform structural analysis on the coarse shape 174 based on parameter set 140 to generate a coarse analysis result 176, and then normalizes the coarse analysis result 176 to generate a normalized coarse analysis result 246.

[0128] At step 320, inference engine 180 generates an inference set 250 for each non-overlapping inference block based on shape 128, coarse shape 174, and normalized coarse analysis result 246. At step 322, inference engine 180 feeds each of the inference sets 250 into the latest version of the trained machine learning model 192 to compute fine output block 260. At step 324, aggregation engine 270 generates a new shape based on the fine output block 260 and then sets shape 128 to be equal to the new shape.

[0129] At step 326, the topology optimization application 120 determines whether it has completed the current grid stage. If at step 326 the topology optimization application 120 determines that it has not yet completed the current grid stage, then method 300 returns to step 316, where the coarse grid engine 170 generates a coarse shape 174 based on shape 128 and the grid ratio 144 specified in parameter set 140.

[0130] However, if at step 326 the topology optimization application 120 determines that it has completed the current grid phase, then method 300 returns to step 306, where the fine grid engine 160 performs structural analysis on shape 128. Method 300 continues to loop through steps 306 to 326 until at step 314, when the topology optimization application 120 stores the newly modified version of shape 128 as optimized shape 198 and / or transfers it to any number and / or type of other software applications. Method 300 then terminates.

[0131] Machine learning models are trained based on low-resolution structural analysis data to optimize shape.

[0132] Figure 4 It is based on various implementation plans. Figure 1 A more detailed illustration of the training application 190 is provided. As shown, in some embodiments, the training application 190 includes, but is not limited to, a data converter 420, a data filtering engine 460, a transformation engine 470, a training engine 490, and a current machine learning model 498. For illustrative purposes only, apostrophes are used after the reference numerals of objects having different instances associated with the topology optimization application 120 and the training application 190 to distinguish instances associated with the training application 190 where necessary.

[0133] During the initialization phase, the training application 190 may initialize the current machine learning model 498 in any technically feasible manner. In some implementations, the training application 190 initializes the current machine learning model 498 based on any number and / or type of untrained machine learning models, any number and / or type of pre-trained machine learning models, any number and / or type of trained machine learning models 192, or any combination thereof.

[0134] For example, in some embodiments, the training application 190 sets the current machine learning model 498 to be equal to an untrained neural network. In some other embodiments, the training application 190 sets the current machine learning model 498 to be equal to a composite machine learning model. In some embodiments, composite machine learning models include, but are not limited to, any number and / or types of machine learning models that work together and can be trained independently, dependently, or in any combination thereof. In still other embodiments, the training application 190 sets the current machine learning model 498 to be equal to a trained machine learning model 192 associated with a relevant and previously solved topology optimization problem.

[0135] In some implementations, during subsequent training phases, the training application 190 sequentially acquires each of the iterative datasets 178. The training application 190 iteratively performs machine learning operations on the current machine learning model 498 based on the iterative datasets 178 to generate any number of versions of the trained machine learning model 192. In some other implementations, instead of the iterative datasets 178 or otherwise, the training application 190 performs any number and / or type of operations on any amount and / or type of data to train the current machine learning model 498.

[0136] In some implementations, each version of the trained machine learning model 192 is associated with a different time point and is equal to a version of the current machine learning model 498 trained on a dataset 178 with a different number of iterations. Therefore, the type of each version of the trained machine learning model 192 matches the type of the current machine learning model 498. (See below for further details.) Figure 5 In more detail, in some implementations, each version of the trained machine learning model 192 is a trained neural network.

[0137] The training application 190 can generate any number of different versions of the trained machine learning model 192 in any technically feasible manner. In some implementations, the training application 190 repeatedly saves the current machine learning model 498 as a new version of the trained machine learning model 192 whenever a trigger is activated. The trigger can be activated based on any number and / or type of criteria.

[0138] In some implementations, parameter set 140 specifies, but is not limited to, any number and type of parameter values ​​associated with the activation trigger. Some examples of parameter values ​​associated with the activation trigger include, but are not limited to, the time interval between activations, the total number of iteration datasets 178 obtained between activations, etc. For illustrative purposes only, at any given point in time, the latest version of the trained machine learning model 192 is referred to herein as trained machine learning model 192. q , where q is an integer between 1 and Q, and Q can be any positive integer.

[0139] For the purpose of explanation only, Figure 4 This describes the operations performed by the training application 190 to train the current machine learning model 498 based on any portion of the iterative dataset 178(x) and parameter set 140. As shown in the figure, in some implementations, parameter set 140 includes, but is not limited to, fine grid size 142, grid ratio 144, fine patch size 146, fine step size 446, and any number and / or type of other parameter values ​​(indicated by ellipses) organized in any technically feasible manner. As previously combined herein... Figure 1 As described, x is an integer that can represent any topology optimization iteration performed by the fine grid engine 160.

[0140] As shown in the figure, the iterative dataset 178(x) includes, but is not limited to, shape 128(x), fine analysis result 166(x), and shape 128(x+1). As previously combined in this paper... Figure 1 As described, shape 128(x+1) is a modified version of shape 128(x) generated by shape optimizer 168 based on fine analysis result 166(x). In some implementations, shape 128(x+1) is topologically optimized relative to shape 128(x) according to one or more design objectives.

[0141] As previously mentioned in this article Figure 2 As described, in some embodiments, shape 128(x+1) and shape 128(x) include, but are not limited to, the same total number of fine shape elements 212. In the same or other embodiments, the fine analysis result 166(x) includes, but is not limited to, any amount and / or type of structural analysis data of each of the fine shape elements 212 included in shape 128(x). In the context of the iterative dataset 178(x), and for illustrative purposes only, shape 128(x), shape 128(x+1), and fine analysis result 166(x) are also referred to herein as the “input shape,” the “structural analysis result,” and the “output shape,” respectively.

[0142] The training application 190 can acquire the iterative dataset 178(x) in any technically feasible manner. In some implementations, the training application 190 receives the iterative dataset 178(x) in real time from the fine raster engine 160. In some other implementations, the training application 190 reads the iterative dataset 178(x) from any memory accessible to both the fine raster engine 160 and the training application 190.

[0143] As shown in the figure, in some embodiments, the data converter 420 includes, but is not limited to, a re-gridization engine 172'(1), a re-gridization engine 172'(2), and a normalization engine 242'. The re-gridization engine 172(1) and the re-gridization engine 172(2) are previously combined herein. Figure 1 The remeshing engine 172 described herein is one of two distinct instances. The normalization engine 242' is the one previously combined in this paper. Figure 2 Different instances of the normalization engine 242 described.

[0144] As shown in the figure, in some embodiments, the data converter 420 inputs the shape 128(x) and the raster ratio 144 into the remeshing engine 172'(1). In response, the remeshing engine 172(1) generates a coarse shape 174(x). The coarse shape 174(x) is a downsampled version of the shape 128(x), associated with a coarse raster 220, and can be represented in any technically feasible manner. In some embodiments, the coarse shape 174(x) includes, but is not limited to, coarse shape elements 222, the total number of coarse shape elements 212 included in the shape 128(x) and the total number of raster ratio 144.

[0145] In the same or other embodiments, data converter 420 inputs the fine analysis result 166(x) and raster ratio 144 into remeshing engine 172'(2). In response, remeshing engine 172'(2) generates coarse analysis result 176(x). Coarse analysis result 176(x) is a downsampled version of fine analysis result 166(x), associated with coarse raster 220, and can be represented in any technically feasible manner. In some embodiments, coarse analysis result 176(x) includes, but is not limited to, any amount and / or type of structural analysis data of each of the coarse shape elements 222 included in coarse shape 174(x).

[0146] In some implementations, the data converter 420 inputs the coarse analysis result 176(x) into the normalization engine 242'. In response, the normalization engine 242' generates a normalized coarse analysis result 246'. The functionality of the normalization engine 242' for the coarse analysis result 176(x) is consistent with that previously described herein. Figure 2 The normalization engine 242, described in detail, functions identically for the coarse analysis result 176(y). For each of the coarse shape elements 222 included in the coarse shape 174(x), the normalized coarse analysis result 246' may include, but is not limited to, any amount and / or type of normalized structural analysis data, any amount and / or type of unnormalized structural analysis data, or any combination thereof.

[0147] As shown in the figure, in some implementations, the data converter 420 generates potential training data 450 based on shape 128(x), shape 128(x+1), coarse shape 174(x), normalized coarse analysis result 246', and any part of parameter set 140. Potential training data 450 includes, but is not limited to, training sets 452(1) to 452(T), where T is an integer representing the training block count 422. For illustrative purposes only, training sets 452(1) to 452(T) are also collectively referred to herein as “training set 452” and “potential training set”. Training sets 452(1) to 452(T) are also individually referred to herein as “training set 452” and “potential training set”. The training block count 422 specifies the total number of training blocks (not shown) and can be equal to any positive integer.

[0148] In some implementations, each of the training blocks defines a different portion of the 3D space associated with both the fine grid 210 and the coarse grid 220. In the same or other implementations, any number of training blocks may partially overlap with any number of other training blocks. The data converter 420 may define the training blocks and the training block count 422 in any technically feasible manner.

[0149] In some implementations, the data converter 420 defines training blocks based on a sliding window algorithm, a fine grid size 142, a fine block size 146, and a fine stride 446. The fine grid size 142 and the fine block size 146 are previously combined herein. Figure 1 and Figure 2 Detailed Description. The fine step size 446 specifies the different step sizes relative to voxels in each of the three dimensions within the fine grid 210. In some embodiments, the data converter 420 defines a training block as a portion of the 3D space depicted by a sliding window as it scans the entire 3D space associated with the fine grid 210, moving one step at a time in one of the three dimensions. The sliding window has a size of fine block size 146 relative to the fine grid 210, and the size of each step is defined by the fine step size 446. In the same or other embodiments, the data converter 420 sets the training block count 422 to be equal to the total number of training blocks.

[0150] As shown in the figure, in some embodiments, training set 452(1) includes, but is not limited to, fine input block 252'(1), coarse block 254'(1), coarse result block 248'(1), and fine output block 260'(1). Although not shown, training sets 452(2) to 452(T) include, but are not limited to, fine input blocks 252'(2) to 252'(T), coarse blocks 254'(2) to 254'(T), coarse result blocks 248'(2) to 248'(T), and fine output blocks 260'(2) to 260'(T). In some embodiments, each of the training sets 452 corresponds to a different training block. Data converter 420 can generate training set 452 in any technically feasible manner.

[0151] In some implementations, the data converter 420 initializes the training set 452 as an empty set. Subsequently, the data converter 420 applies a sliding window algorithm to shape 128(x) based on the fine block size 146 and the fine step size 446 to generate fine input blocks 252'(1) to 252'(T). Therefore, each of the fine input blocks 252'(1) to 252'(T) includes, but is not limited to, different subsets of the fine shape elements 212 included in shape 128(x), where any number of subsets may partially overlap. The data converter 420 then adds the fine input blocks 252'(1) to 252'(T) to the training set 452(1) to 452(T), respectively.

[0152] In the same or other embodiments, the data converter 420 applies a sliding window algorithm to shape 128(x+1) based on the fine block size 146 and the fine step size 446 to generate fine output blocks 260'(1) to 260'(T). Therefore, each of the fine output blocks 260'(1) to 260'(T) includes, but is not limited to, different subsets of the fine shape elements 212 included in shape 128(x+1), wherein any number of subsets may partially overlap. The data converter 420 then adds the fine output blocks 260'(1) to 260'(T) to training sets 452(1) to 452(T), respectively.

[0153] In some implementations, the data converter 420 calculates the coarse block size (not shown) and coarse step size (not shown) based on a raster ratio of 144, a fine block size of 146, and a fine step size of 446. The coarse block size specifies the 3D size of each of the training blocks relative to the coarse voxels in the coarse raster 220. The coarse step size specifies the different step sizes relative to the coarse voxels in each of the three dimensions in the coarse raster 220.

[0154] In the same or other embodiments, the data converter 420 applies a sliding window algorithm to the coarse block shape 174(x) based on the coarse block size and coarse step size to generate coarse blocks 254'(1) to 254'(T). Therefore, each of the coarse blocks 254'(1) to 254'(T) includes, but is not limited to, different subsets of the coarse shape elements 222 included in the coarse shape 174(y), wherein any number of subsets may partially overlap. The data converter 420 then adds the coarse blocks 254'(1) to 254'(T) to the training sets 452(1) to 452(T), respectively.

[0155] In some implementations, the data converter 420 applies a sliding window algorithm to the normalized coarse analysis results 246' based on the coarse block size and coarse step size to generate coarse result blocks 248'(1) to 248'(T). In some other implementations, the data converter 420 omits the normalization engine 242', and applies a sliding window algorithm to the coarse analysis results 176(x) based on the coarse block size and coarse step size to generate coarse result blocks 248'(1) to 248'(T). Each of the coarse result blocks 248'(1) to 248'(T) includes, but is not limited to, any amount and / or type of structural analysis data of each of the coarse shape elements 222 respectively included in the coarse blocks 254'(1) to 254'(T). The data converter 420 then adds the coarse result blocks 248'(1) to 248'(T) to the training sets 452(1) to 452(T), respectively.

[0156] For illustrative purposes only, example values ​​for fine grid size 142, grid ratio 144, fine block size 146, fine step size 446, and training block count 422 are depicted in italics. As shown in the figure, in some embodiments, fine grid size 142 specifies that the size of fine grid 210 is 8×16×8, grid ratio 144 specifies that the ratio between fine grid 210 and coarse grid 220 is 2:1, fine block size 146 is 4×4×4, and fine step size 446 is 2×2×2.

[0157] Based on a fine grid size of 8×16×8 142, shape 128(x) and shape 128(x+1) each include, but are not limited to, 1024 fine shape elements 212. Based on the fine grid size 142 and a grid ratio of 2:1 144, coarse shape 174(x) includes, but is not limited to, 128 coarse shape elements 222. Furthermore, the coarse analysis result 176(y) includes, but is not limited to, any quantity and / or type of structural analysis data for each of the 128 coarse shape elements 222 included in coarse shape 174(x).

[0158] Those skilled in the art will recognize that applying the sliding window algorithm to the fine grid 210 based on a fine block size of 4×4×4 146 and a fine step size of 2×2×2 446 defines 63 different training blocks. In some embodiments, in order to generate training sets 452(1) to 452(63) (not explicitly shown), the data converter 420 applies a 4×4×4 sliding window to shapes 128(x) and 128(x+1) based on the step size of both in the fine shape elements 212 in each dimension to generate fine input blocks 252'(1) to 252'(63) and fine output blocks 260'(1) to 260'(63), respectively.

[0159] In the same or other embodiments, the data converter 420 calculates a 2×2×2 coarse block size based on a 2:1 raster ratio 144 and a 4×4×4 fine block size 146. The data converter 420 also calculates a 1×1×1 coarse step size based on a 2:1 raster ratio 144 and a 1×1×1 fine step size 446. Thus, the data converter 420 applies a 2×2×2 sliding window to the coarse shape 174(x) and the normalized coarse analysis result 246' based on the step size of one of the coarse shape elements 222 in each dimension to generate coarse blocks 254'(1) to 254'(63) and coarse result blocks 248'(1) to 248'(63), respectively.

[0160] As shown in the figure, in some embodiments, the data converter 420 inputs potential training data 450 into the data filtering engine 460. In response, the data filtering engine 460 filters out any number of training sets 452 included in the potential training data 450 to generate filtered training data 462. The data filtering engine 460 can determine which training sets 452 to filter out in any technically feasible manner. In some embodiments, the data filtering engine 460 performs any number and / or type of filtering operations and / or any number and / or type of sampling operations on the training sets 452 included in the potential training data 450 to generate filtered training data 462.

[0161] In some implementations, the data filtering engine 460 preferably retains ( Right now The data filtering engine 460 adds a training set 452 to the filtered training data 462 that is associated with the portion of the coarse shape 174(x) closest to its boundary. Those skilled in the art will recognize that preferentially retaining the training set 452 associated with the portion of the coarse shape 174(x) closest to its boundary can improve the efficiency of training application 190 in training the current machine learning model 498. The data filtering engine 460 can be implemented in any technically feasible manner ( For exampleThe distance from a portion of the coarse shape 174(x) to the boundary (or surface) of the coarse shape 174(x) is determined by a directed distance field.

[0162] More precisely, in some implementations, the data filtering engine 460 classifies the training set 452(1) to 452(T) based on whether the coarse blocks 254'(1) to 254'(T) represent the portion of the coarse shape 174(x) that is on the boundary of the coarse shape 174(x), inside the coarse shape 174(x), or outside the coarse shape 174(x). For a subset of the training set 452 associated with the "boundary" category, the data filtering engine 460 performs a process of retaining a relatively high percentage ( For example The sampling operation of the training set 452 (60%) was performed and the remaining training set 452 was discarded.

[0163] In some implementations, for a subset of the training set 452 associated with the “external” category, the data filtering engine 460 performs a retention of a relatively low percentage ( For example The data filtering engine 460 performs a weighted sampling operation on the training set 452 (15%). For each of the training sets 452 included in the outer category, the data filtering engine 460 calculates an associated sampling weight based on the proximity of the portion of the coarse shape 174(x) represented by the coarse block 254' included in the training set 452 to the boundary of the coarse shape 174(x). In this way, for the training set 452 included in the outer category, the data filtering engine 460 preferentially retains the training set 452 associated with the portion of the coarse shape 174(x) that is closer to the surface of the coarse shape 174(x).

[0164] In the same or other implementations, for a subset of the training set 452 associated with the "internal" category, the data filtering engine 460 performs a retention of a relatively low percentage ( For example The data filtering engine 460 performs a weighted sampling operation on the training set 452 (25%). For each of the training sets 452 included in the inner categories, the data filtering engine 460 calculates the associated sampling weight based on the proximity of the portion of the coarse shape 174(x) represented by the coarse block 254' included in the training set 452 to the boundary of the coarse shape 174(x). In this way, for the training set 452 associated with the inner category, the data filtering engine 460 preferentially retains the training set 452 associated with the portion of the coarse shape 174(x) that is closer to the surface of the coarse shape 174(x).

[0165] As shown in the figure, in some implementations, the training application 190 feeds filtered training data 462 into the transformation engine 470. In response, the transformation engine 470 generates a training dataset 480, which includes, but is not limited to, the training set 452 included in the filtered training data 462, and any number of new instances of the training set 452. The transformation engine 470 can generate new instances of the training set 452 based on any number of training sets 452 included in the filtered training data 462 in any technically feasible manner.

[0166] Importantly, in some implementations, the variation engine 470 performs any number and / or type of data augmentation operations on the filtered training data 462, which increases the variation on the training dataset 480. As those skilled in the art will recognize, increasing the variation on the training dataset 480 can increase the generalization ability of the trained machine learning model 192. The variation engine 470 can perform any number and / or type of data augmentation operations on the filtered training data 462 in any technically feasible manner.

[0167] In some implementations, for each of the training sets 452 included in the filtered training data 462, the transformation engine 470 generates a rotated version of the training set 452. The rotated version of each of the training sets 452 is associated with a randomly rotated version of the training block corresponding to the training set 452. To generate a rotated version of the training set 452(i), where i can be any integer between 1 and T, the transformation engine 470 randomly selects a 3D rotation direction. The transformation engine 470 rotates each of the fine input block 252'(i), fine output block 260'(i), coarse block 254'(i), and coarse result block 248'(i) based on the 3D rotation direction to generate fine input block 252'(j), fine output block 260'(j), coarse block 254'(j), and coarse result block 248'(j), where j can be any integer greater than T. Although not shown, the fine input block 252'(j), fine output block 260'(j), coarse block 254'(j), and coarse result block 248'(j) are aligned and correspond to a new training block that does not correspond to the coarse shape 174(x).

[0168] Variation engine 470 generates training set 452(j), which includes, but is not limited to, fine input block 252'(j), fine output block 260'(j), coarse block 254'(j), and coarse result block 248'(j). Variation engine 470 then adds training set 452(i) and training set 452(j) to training dataset 480. In some other embodiments, variation engine 470 can generate any number of variations of any number of training sets 452 included in the filtered training data 462 in any technically feasible manner. In the same or other embodiments, variation engine 470 can generate training dataset 480 based on the filtered training data 462 in any technically feasible manner.

[0169] As shown in the figure, in some implementations, training engine 490 performs any number and / or type of machine learning operations on the current machine learning model 498 based on training dataset 480. In some implementations, for each of the training sets 452 included in training dataset 480, training engine 490 incrementally trains the current machine learning model 498 to map coarse blocks 254', coarse result blocks 248', and fine input blocks 252' to fine output blocks 260'. As previously combined herein... Figure 1 As described, in some implementations, the fine grid engine 160 generates a shape 128(x+1) including a fine output block 260'. Therefore, the training engine 490 incrementally teaches the current machine learning model 498 to predict the fine output block 260' included in the shape 128(x) based on the fine input block 252', coarse block 254', and coarse result block 248' included in the shape 128(x).

[0170] In some other embodiments, each of the training set 452 may include, but is not limited to, any amount and type of data that enables the training engine 490 to train the current machine learning model 498 to predict the fine output block 260'. For example, in some other embodiments, each of the training set 452 omits the fine input block 252', and the training engine 490 incrementally trains the current machine learning model 498 to map the coarse block 254' and the coarse result block 248' to the fine output block 260'. In still other embodiments, each of the training set 452 omits the coarse block 254', and the training engine 490 incrementally trains the current machine learning model 498 to map the fine input block 252' and the coarse result block 248' to the fine output block 260'.

[0171] As depicted by the dashed arrow, in some implementations, the training application 190 is based on any number and / or type of criteria ( For example (Activate trigger) to repeatedly save a copy of the current machine learning model 498 as a new version of the trained machine learning model, denoted as training machine learning model 192.q In some implementations, the generated trained machine learning model 192 q Next, the training application 190 will train the machine learning model 192. q The training application 190 stores the trained machine learning model 192 in any memory accessible to the topology optimization application 120. In the same or other embodiments, the training application 190 trains the machine learning model 192 in any technically feasible manner. q Transmitted to any number and / or type of software application ( For example Topology optimization application 120 and / or coarse raster engine 170).

[0172] Figure 5 It is based on various implementation plans. Figure 1 192 trained machine learning models q More detailed illustrations. In Figure 5 In the described implementation scheme, the trained machine learning model 192 q It is a trained neural network with an exemplary architecture. As previously combined in this paper... Figure 4 As described, the current machine learning model 498 is associated with each trained machine learning model 192 (including trained machine learning model 192). q The same type of model. Furthermore, the current machine learning model 498 and each trained machine learning model 192 (including trained machine learning model 192) q They share the same architecture.

[0173] In some implementation schemes (including) Figure 5 In the described implementation scheme, the trained machine learning model 192 q The architecture is similar to that typically associated with a type of neural network commonly known as a 3D autoencoder. In some other implementations, the trained machine learning model 192 q This can be a trained version of a neutral network with different types of architectures. In other implementations, the trained machine learning model 192... q It can be a trained version of a different type of machine learning model, or a trained composite machine learning model that includes trained versions of any number and / or types of machine learning models.

[0174] Although not shown, the current machine learning model 498 and each trained machine learning model 192 share the same total number of parameters. For example (weights and / or biases). Those skilled in the art will recognize that in training engine 490 ( Figure 5When performing machine learning operations on the current machine learning model 498 (not shown), the current machine learning model 498 learns the values ​​of the parameters. Therefore, the values ​​of any number of parameters can differ among the trained machine learning models 192.

[0175] In some implementations, the trained machine learning model 192 q The input is included in the inference set 250. As previously combined in this paper... Figure 2 As described, in some implementations, the inference set 250 includes, but is not limited to, a fine input block 252, a coarse block 254, and a coarse result block 248 corresponding to one of the inference blocks.

[0176] As shown in the figure, in some implementation schemes, the trained machine learning model 192 q A 3D convolution operation 510(1) is performed on the fine input block 252. The 3D convolution operation 510(1) compresses the fine input block 252 to generate fine input features 520. The trained machine learning model 192 q The fine input features 520 and coarse blocks 254 are then combined to generate a cascade 530 (1). Subsequently, a trained machine learning model 192 is used. q A 3D convolution operation 510(2) is performed on the concatenation 530(1). The 3D convolution operation 510(2) compresses the concatenation 530(1) to generate a volumetric feature 540. In some implementations, the volumetric feature 540 is associated with a prediction of a finer version of the coarse block 254.

[0177] 192 trained machine learning models q The volumetric feature 540 and the coarse result block 248 are then combined to generate a cascade 530 (2). Subsequently, a trained machine learning model 192 is used. q A 3D convolution operation 510(3) is performed on the concatenation 530(2). The 3D convolution operation 510(3) compresses the concatenation 530(2) to generate feature 550. In some implementations, feature 550 is associated with a prediction of how to perform topology optimization on a more refined version of the prediction of the coarse block 254.

[0178] As shown in the figure, the trained machine learning model 192 q A 3D deconvolution operation 560 is performed on feature 550. The 3D deconvolution operation 560 upsamples feature 550 to generate fine incremental features 570. In some implementations, the fine incremental features 570 are associated with predictions of how to perform topology optimization on the fine input block 252. Subsequently, a trained machine learning model 192... qA 3D convolution operation 510(4) is performed on the fine incremental feature 570. The 3D convolution operation 510(4) compresses the fine incremental feature 570 to generate a shape increment 580. In some embodiments, the shape increment 580 is associated with any number and / or type of spatial modification to the fine input block 252 that is predicted to perform topology optimization of the fine input block 252 according to one or more design objectives.

[0179] 192 trained machine learning models q Then, any number of addition operations are performed between shape increment 580 and fine input block 252 to generate fine output block 260. In some embodiments, fine output block 260 is predicted to converge more to one or more design goals than fine input block 252. In the same or other embodiments, fine output block 260 is a modified version of fine input block 252 predicted to perform topology optimization relative to fine input block 252 according to one or more design goals. As shown in the figure, the trained machine learning model 192 q Output fine output block 260.

[0180] For illustrative purposes only, some exemplary dimensions of the exemplary embodiments are depicted in italics. Furthermore, the dimensions of various instances of various objects are specified relative to four dimensions, where the product of the four dimensions for a given instance equals the total number of discrete values ​​associated with that instance.

[0181] In an exemplary implementation, fine input block 252 is the previously combined [specific feature] described herein. Figure 2 The fine shape element 212 is described as a 4×4×4 block. Although not shown, each of the fine shape elements 212 includes, but is not limited to, a directed distance field and a reserved item label. Therefore, the fine input block 252 has a size of 4×4×4×2 relative to the four dimensions.

[0182] In an exemplary embodiment, block 254 is the previously combined [structure / feature] described herein. Figure 2 The description describes a 2×2×2 block of coarse shape element 222. Although not shown, each of the coarse shape elements 222 includes, but is not limited to, a directed distance field and a reserved term label. Therefore, the size of the coarse block 254 with respect to the four dimensions is 2×2×2×2.

[0183] Although not shown, in an exemplary embodiment, the coarse result block 248 is a 2×2×2 block of strain energy values, where each strain energy value corresponds to a different coarse shape element in the coarse shape elements 222 included in the coarse block 254. Therefore, the size of the coarse result block 248 relative to the four dimensions is 2×2×2×1.

[0184] In this exemplary implementation, the trained machine learning model 192 qA 3D convolution operation 510(1) is performed on the fine input block 252 to generate a fine input feature 520 with a size of 2×2×2×24. After combining the fine input feature 520 and the coarse block 254 to generate a concatenation 530(1), the trained machine learning model 192... q A 3D convolution operation 510(2) is performed on the concatenation 530(1) to generate a volumetric feature 540 with a size of 2×2×2×24. After combining the volumetric feature 540 and the coarse result block 248 to generate the concatenation 530(2), the trained machine learning model 192 q Perform a 3D convolution operation 510(3) on the concatenation 530(2) to generate a feature 550 with a size of 2×2×2×32.

[0185] Subsequently, the trained machine learning model 192 q Perform a 3D deconvolution operation 560 on feature 550 to generate fine incremental features 570 with a size of 4×4×4×24. Trained machine learning model 192 q A 3D convolution operation 510(4) is performed on the fine incremental features 570 to generate a shape increment 580 with dimensions of 4×4×4×1. In some implementations, the shape increment 580 includes, but is not limited to, different directed distance field increments for each of the directed distance fields included in the fine input block 252. The trained machine learning model 192 q Then perform any number of addition operations between shape increment 580 and fine input block 252 to generate fine output block 260.

[0186] In an exemplary embodiment, the fine output block 260 is a 4×4×4 block of fine shape elements 212, each of which includes, but is not limited to, a directed distance field and a reserved item label. Therefore, the size of the fine output block 260 relative to 4D space is 4×4×4×2. In some other embodiments, the fine output block 260 can be replaced by an SDF output block. For each of the fine shape elements 212 included in the fine input block 252, the SDF output block includes, but is not limited to, different directed distance fields. Therefore, if the size of the fine input block 252 is 4×4×4×4, then the size of the SDF block will be 4×4×4×1. In some such embodiments, the inference engine 180 generates the fine output block 260 based on the SDF output block and the reserved item labels included in the fine input block 252.

[0187] Figure 6 This is a flowchart of method steps for training a machine learning model to modify the shape when designing 3D objects, according to various implementation schemes. (See references...) Figure 1 , Figure 2 , Figure 4 and Figure 5 The system describes the method steps, but those skilled in the art will understand that any system configured to implement the method steps in any order falls within the scope of this invention.

[0188] As shown in the figure, method 600 begins with step 602, where training application 190 determines the current machine learning model 498 and parameter set 140. At step 604, training application 190 acquires an iterative dataset 178, which includes, but is not limited to, the input shape, detailed analysis results 166 associated with the input shape, and the output shape. For example, and as previously combined herein... Figure 4 As described, in some implementations, the training application 190 acquires an iterative dataset 178(x), which includes, but is not limited to, shape 128(x), fine analysis results 166(x), and shape 128(x+1).

[0189] At step 606, data converter 420 performs any amount and / or type of downsampling operation on the input shape based on the raster ratio 144 specified in parameter set 140 to generate a coarse shape 174. At step 608, data converter 420 performs any amount and / or type of downsampling operation on the fine analysis result 166 based on the raster ratio 144 specified in parameter set 140 to generate a coarse analysis result 176. As part of step 608, in some embodiments, data converter 420 performs any amount and / or type of normalization operation on the coarse analysis result 176 to generate a normalized coarse analysis result 246'.

[0190] At step 610, the training application 190 determines the fine input block 252', coarse block 254', coarse result block 248', and fine output block 260' based on the input shape, coarse shape 174, coarse analysis result 176 (or normalized coarse analysis result 246'), and output shape, as well as the parameter set 140. At step 612, the training application 190 generates the training set 452 included in the potential training data 450 based on the fine input block 252', coarse block 254', coarse result block 248', and fine output block 260'.

[0191] At step 614, data filtering engine 460 generates filtered training data 462 based on potential training data 450. At step 616, variation engine 470 generates any number of variations of any number of training sets 452 included in the filtered training data 462 to generate training dataset 480. At step 618, training engine 490 performs any number and / or type of machine learning operations on the current machine learning model 498 based on the training sets 452 included in the training dataset 480.

[0192] At step 620, the training application 190 determines whether to save the current machine learning model 498. The training application 190 can determine whether to save the current machine learning model 498 in any technically feasible manner based on any amount and / or type of data. If at step 620, the training application determines not to save the current machine learning model 498, then method 600 proceeds directly to step 624.

[0193] However, if at step 620 the training application 190 determines to save the current machine learning model 498, then method 600 proceeds to step 622. At step 622, the training application 190 saves a copy of the current machine learning model 498 and / or transfers a copy of the current machine learning model 498 as a new version of the trained machine learning model 192.

[0194] At step 624, training application 190 determines whether it has completed training the current machine learning model 498. Training application 190 may determine whether it has completed training the current machine learning model 498 in any technically feasible manner. In some implementations, training application 190 determines whether it has completed training the current machine learning model 498 based on whether it has detected any new instances of the iterative dataset 178. If, at step 624, training application 190 determines that it has completed training the current machine learning model 498, then method 600 terminates.

[0195] However, if at step 624, training application 190 determines that it has not yet finished training the current machine learning model 498, then method 600 returns to step 604, where training application 190 obtains a new instance of iterative dataset 178. Method 600 continues to loop through steps 604 to 624 until at step 624, training application 190 determines that it has finished training the current machine learning model 498. Method 600 then terminates.

[0196] In summary, the disclosed techniques can be used to efficiently solve topology optimization problems associated with the generative design of 3D objects. In some implementations, a generative design application configures a topology optimization application to solve the topology optimization problem associated with 3D objects. The topology optimization application implements a fine grid and a coarse grid as a downsampled version of the fine grid, associated with a resolution that will optimize the shape representing the 3D object. The topology optimization application generates an initial version of the shape, which includes, but is not limited to, different fine shape elements for each voxel in the fine grid. The topology optimization application iteratively modifies the shape during alternating fine grid and coarse grid stages, each stage including any number of topology optimization iterations to solve the topology optimization problem.

[0197] During the x-th topology optimization iteration, where x represents any topology optimization iteration during the fine grid stage, the topology optimization application configures the fine grid engine to modify the x-th shape. Right now The fine grid engine generates a (x+1)th shape from the xth shape, which is a topology-optimized version of the xth shape according to one or more design objectives. In operation, the fine grid engine configures the structure analyzer to generate fine analysis results based on the xth shape. The fine analysis results include different strain energy values ​​for each of the fine shape elements included in the xth shape. Subsequently, the fine grid engine configures the shape optimizer to perform any number and / or type of topology optimization operations on the xth shape based on the fine analysis results to generate the (x+1)th shape. The fine grid engine then generates an iterative dataset, which includes, but is not limited to, the xth shape, the fine analysis results, and the (x+1)th shape. The fine grid engine provides the iterative dataset to the training application.

[0198] In some implementations, the training application executes at least partially in parallel with the fine-grid engine. Initially, the training application sets the current machine learning model to be equal to an untrained machine learning model. Subsequently, the training application incrementally trains the current machine learning model based on the iterative dataset received from the fine-grid engine. In some implementations, after obtaining the iterative dataset associated with the x-th topology optimization iteration, the training application generates a coarse shape and a coarse analysis result based on the x-th shape and the fine analysis result, respectively. The coarse shape and the coarse analysis result are downsampled versions of the x-th shape and the fine analysis result, respectively, and correspond to the coarse grid. The training application then performs any number and / or type of normalization operations on the coarse analysis result to generate a normalized coarse analysis result.

[0199] The training application generates distinct training sets for each of any number of training blocks based on the x-th shape, coarse shape, coarse analysis result, and (x+1)-th shape. Each of the training blocks is associated with a different non-overlapping portion of the 3D space associated with both the fine and coarse grids. In some implementations, to determine the training blocks, the training application applies a sliding window algorithm to each of the fine input shape, coarse shape, normalized coarse result, and fine output shape. Each of the training blocks includes, but is not limited to, the fine input block, coarse block, coarse result block, and fine output block corresponding to the associated training blocks.

[0200] The training application then performs any number and / or type of filtering operations and / or any number and / or type of rotation operations on the training set to generate a training dataset that includes any number of training sets and any number of variations of the training sets. The training application performs any number of machine learning operations on the current machine learning model based on the training dataset. These machine learning operations incrementally train the current machine learning model to map coarse blocks, normalized coarse result blocks, and fine input blocks to fine output blocks. The fine output blocks generated by the current machine learning model are modified versions of the fine input blocks that are predicted to converge more to one or more design objectives than the fine input blocks. The training application periodically saves the current machine learning model as a new version of the trained machine learning model.

[0201] The topology optimization application uses a coarse grid engine and a recently updated trained machine learning model to perform the coarse grid phase. During the y-th topology optimization iteration, where y represents any topology optimization iteration during the coarse grid phase, the topology optimization application configures the coarse grid engine to modify the y-th shape (i.e., the y-th version of the shape) to generate the (y+1)-th shape, which is predicted to converge more to one or more design objectives than the y-th shape.

[0202] In operation, the coarse raster engine generates a coarse shape based on the y-th shape, where the coarse shape is a downsampled version of the y-th shape. In some implementations, the coarse shape includes different coarse shape elements for each coarse voxel included in the coarse raster. The coarse raster engine configures the structure analyzer to generate coarse analysis results based on the coarse shape. The coarse analysis results include different strain energy values ​​for each of the coarse shape elements included in the coarse shape. Subsequently, the inference engine included in the coarse raster engine performs any number and / or type of normalization operations on the strain energy values ​​included in the coarse analysis results to generate normalized coarse analysis results. The inference engine then determines any number of non-overlapping inference blocks, which together separate the 3D space associated with the fine and coarse rasters. Based on the inference blocks, the inference engine divides each of the y-th shape, the coarse shape, and the normalized coarse analysis results into a fine input block, a coarse block, and a coarse result block, respectively.

[0203] For each inference block, the inference engine generates an inference set comprising the corresponding fine input block, the corresponding coarse block, and the corresponding coarse result block. The inference engine feeds each element in the inference set into the latest version of the trained machine learning model. In response, the trained machine learning model outputs fine output blocks. Each element in the fine output block is a modified version of the associated fine input block and has the same resolution as the fine input block. The inference engine aggregates the fine input blocks to generate the (y+1)th shape.

[0204] After the topology optimization application determines that the completion criteria are met, it saves the shape version generated during the previous topology optimization iteration as the optimized shape. The optimized shape is the solution to the associated topology optimization problem. The topology optimization application then transfers the optimized shape to the generative design application.

[0205] At least one technical advantage of the disclosed technique over existing techniques is that, utilizing the disclosed technique, topology optimization applications can reduce the computational complexity associated with solving topology optimization problems by using trained machine learning models. More specifically, because the coarse grid engine uses a trained machine learning model to optimize fine shape elements based on the structural analysis results of coarse shape elements, the total number of structural analysis operations performed when solving a given topology optimization problem is reduced. Therefore, when the amount of time and / or computational resources allocated to design activities is limited, generative design applications can use topology optimization applications to explore the overall design space more comprehensively than existing methods. Consequently, generative design applications can produce designs that are more convergent to the design objectives. These technical advantages provide one or more technical improvements over existing methods.

[0206] 1. In some embodiments, a computer-implemented method for solving a topology optimization problem when designing a three-dimensional (“3D”) object includes: converting a first shape having a first resolution and representing the 3D object into a coarse shape having a second resolution lower than the first resolution; calculating coarse structural analysis data based on the coarse shape; and generating a second shape having the first resolution and representing the 3D object based on the first shape and the coarse structural analysis data via a trained machine learning model, wherein the trained machine learning model modifies a portion of the shape having the first resolution based on the structural analysis data having the second resolution.

[0207] 2. The computer-implemented method as described in Clause 1, wherein the second shape is more convergent to a design objective associated with the topology optimization problem than the first shape.

[0208] 3. The computer-implemented method as described in Clause 1 or 2, wherein converting the first shape to the coarse shape includes performing one or more downsampling operations on the first shape.

[0209] 4. A computer-implemented method as described in any one of Clauses 1 to 3, wherein the first shape comprises a 3D mesh of shape elements, and wherein each shape element is associated with a different voxel of a 3D grid having the first resolution.

[0210] 5. The computer-implemented method as described in any one of Clauses 1 to 4, wherein each shape element includes at least one of a directional distance field or a reserved item label.

[0211] 6. The computer-implemented method as described in any one of Clauses 1 to 5, wherein the coarse structural analysis data includes at least one of a plurality of strain energy values, a plurality of displacements, or a plurality of rotations.

[0212] 7. A computer-implemented method as described in any one of Clauses 1 to 6, wherein calculating the coarse structure analysis data comprises: performing one or more structure analysis operations on the coarse shape to generate unnormalized coarse structure analysis data; and performing one or more normalization operations on at least a portion of the unnormalized coarse structure analysis data to generate the coarse structure analysis data.

[0213] 8. A computer-implemented method as described in any one of Clauses 1 to 7, wherein generating the second shape comprises: performing one or more partitioning operations on the coarse structure analysis data and at least one of the first shape or the coarse shape to generate a plurality of inference sets; inputting the inference sets into the trained machine learning model, wherein, in response, the trained machine learning model outputs a plurality of modified portions of the first shape; and aggregating the plurality of modified portions of the first shape to generate the second shape.

[0214] 9. A computer-implemented method as described in any one of Clauses 1 to 8, wherein the trained machine learning model comprises a trained neural network.

[0215] 10. A computer-implemented method as described in any one of clauses 1 to 9, wherein the 3D object is designed via a generative design process involving the topology optimization problem, and the first shape is generated based on the specification of the topology optimization problem.

[0216] 11. In some embodiments, one or more non-transitory computer-readable media include instructions that, when executed by one or more processors, cause the one or more processors to solve a topology optimization problem when designing a three-dimensional (“3D”) object by performing the following steps: converting a first shape having a first resolution and representing the 3D object into a coarse shape having a second resolution lower than the first resolution; calculating coarse structural analysis data based on the coarse shape; and generating a second shape having the first resolution and representing the 3D object based on the first shape and the coarse structural analysis data via a trained machine learning model, wherein the trained machine learning model modifies a portion of the shape having the first resolution based on the structural analysis data having the second resolution.

[0217] 12. One or more non-transitory computer-readable media as described in Clause 11, wherein the second shape is more convergent to a design objective associated with the topology optimization problem than the first shape.

[0218] 13. One or more non-transitory computer-readable media as described in Clause 11 or 12, wherein converting the first shape to the coarse shape includes performing one or more field transfer operations or remeshing operations on the first shape.

[0219] 14. One or more non-transitory computer-readable media as described in any one of clauses 11 to 13, wherein the coarse shape comprises a 3D mesh of shape elements, and wherein each shape element is associated with a different voxel of a 3D grid having the second resolution.

[0220] 15. One or more non-transitory computer-readable media as described in any one of Clauses 11 to 14, wherein the coarse structure analysis data includes at least one of a plurality of strain energy values, a plurality of displacements, or a plurality of rotations.

[0221] 16. One or more non-transitory computer-readable media as described in any one of Clauses 11 to 15, wherein calculating the coarse structural analysis data comprises: performing one or more structural analysis operations on the coarse shape to generate a plurality of strain energy values; and performing one or more normalization operations on the plurality of strain energy values ​​to generate the coarse structural analysis data.

[0222] 17. One or more non-transitory computer-readable media as described in any one of clauses 11 to 16, wherein generating the second shape comprises: performing one or more partitioning operations on the coarse structure analysis data and at least one of the first shape or the coarse shape to generate a plurality of inference sets; inputting the plurality of inference sets into the trained machine learning model, wherein, in response, the trained machine learning model outputs a plurality of modified portions of the first shape; and aggregating the plurality of modified portions of the first shape to generate the second shape.

[0223] 18. One or more non-transitory computer-readable media as described in any one of clauses 11 to 17, wherein generating the second shape comprises: calculating a first inference set associated with a first portion of the first shape based on the coarse structure analysis data and at least one of the first shape or the coarse shape; inputting the first inference set into the trained machine learning model, wherein, in response, the trained machine learning model generates a modified first portion of the first shape; and aggregating the modified first portion of the first shape with at least a modified second portion of the first shape to generate the second shape.

[0224] 19. One or more non-transitory computer-readable media as described in any one of clauses 11 to 18, wherein the 3D object is designed via a generative design process involving the topology optimization problem, and the first shape is generated based on the specification of the topology optimization problem.

[0225] 20. In some embodiments, a system includes: one or more memories storing instructions; and one or more processors coupled to the one or more memories, the one or more processors performing the following steps when executing the instructions: converting a first shape having a first resolution and representing a three-dimensional (“3D”) object into a coarse shape having a second resolution lower than the first resolution; calculating coarse structural analysis data based on the coarse shape; and generating a second shape having the first resolution and representing the 3D object based on the first shape and the coarse structural analysis data via a trained machine learning model, wherein the trained machine learning model modifies a portion of the shape having the first resolution based on the structural analysis data having the second resolution.

[0226] Any and all combinations of any element of the claim set forth in any claim and / or any element described in this application, in any manner, fall within the scope of the implementation and protection contemplated.

[0227] Various embodiments have been described for illustrative purposes; however, these descriptions are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. Aspects of the embodiments of the invention may be embodied as systems, methods, or computer program products. Therefore, aspects of this disclosure may take the form of an all-hardware implementation, an all-software implementation (including firmware, resident software, microcode, etc.), or an implementation combining software and hardware aspects, which may be generally referred to herein as “modules,” “systems,” or “computers.” Furthermore, any hardware and / or software technology, process, function, component, engine, module, or system described in this disclosure may be implemented as a circuit or a set of circuits. Additionally, aspects of this disclosure may take the form of a computer program product embodied in one or more computer-readable media having a computer-readable program codec embodied thereon.

[0228] Any combination of one or more computer-readable media may be used. Each computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example, but not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or apparatuses, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of computer-readable storage media will include the following: electrical connections having one or more wires, portable computer disks, hard disks, random access memory, read-only memory, erasable programmable read-only memory, flash memory, optical fiber, portable optical disc read-only memory, optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. In the context of this document, a computer-readable storage medium may be any tangible medium that can contain or store programs for use by or in conjunction with an instruction execution system, device, or apparatus.

[0229] The aspects of this disclosure have been described above with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this disclosure. It will be understood that each block in the flowchart illustrations and / or block diagrams, as well as combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine. When executed via a processor of a computer or other programmable data processing apparatus, the instructions cause the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams to be implemented. Such a processor can be, but is not limited to, a general-purpose processor, a special-purpose processor, an application-specific processor, or a field-programmable gate array (FPGA).

[0230] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code comprising one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may not occur in the order shown in the drawings. For example, two blocks shown consecutively may actually be executed substantially simultaneously, or the blocks may sometimes be executed in reverse order, depending on the functions involved. It will also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented by a system based on dedicated hardware or a combination of dedicated hardware and computer instructions that performs the specified function or action.

[0231] Although the foregoing relates to embodiments of this disclosure, other and additional embodiments of this disclosure may be contemplated without departing from the essential scope of this disclosure, the scope of which is defined by the appended claims.

Claims

1. A computer-implemented method for solving topology optimization problems when designing 3D objects, the method comprising: A first shape representing the 3D object with a first resolution is converted into a coarse shape with a second resolution lower than the first resolution; Coarse structure analysis data is calculated based on the coarse shape; as well as A second shape representing the 3D object is generated based on the first shape and the coarse structure analysis data using a trained machine learning model, wherein the trained machine learning model modifies the directed distance field of at least a portion of the shape elements of the first shape based on at least the coarse structure analysis data to generate one or more shape elements of the second shape, the coarse structure analysis data having the second resolution.

2. The computer-implemented method of claim 1, wherein the second shape is more convergent to a design objective associated with the topology optimization problem than the first shape.

3. The computer-implemented method of claim 1, wherein converting the first shape to the coarse shape comprises performing one or more downsampling operations on the first shape.

4. The computer-implemented method of claim 1, wherein the first shape comprises a 3D mesh of shape elements, and wherein each shape element is associated with a different voxel of a 3D grid having the first resolution.

5. The computer-implemented method of claim 4, wherein each shape element includes at least one of a directed distance field or a reserved item label.

6. The computer-implemented method of claim 1, wherein the coarse structural analysis data includes at least one of a plurality of strain energy values, a plurality of displacements, or a plurality of rotations.

7. The computer-implemented method of claim 1, wherein calculating the coarse-structure analysis data comprises: Perform one or more structural analysis operations on the coarse shape to generate unnormalized coarse structural analysis data; as well as One or more normalization operations are performed on at least a portion of the unnormalized coarse structure analysis data to generate the coarse structure analysis data.

8. The computer-implemented method of claim 1, wherein generating the second shape comprises: Perform one or more partitioning operations on the coarse structure analysis data and at least one of the first shape or the coarse shape to generate multiple inference sets; The inference set is input into the trained machine learning model, and in response, the trained machine learning model outputs multiple modified portions of the first shape; as well as The multiple modified portions of the first shape are aggregated to generate the second shape.

9. The computer-implemented method of claim 1, wherein the trained machine learning model comprises a trained neural network.

10. The computer-implemented method of claim 1, wherein the 3D object is designed via a generative design process involving the topology optimization problem, and the first shape is generated based on the specification of the topology optimization problem.

11. One or more non-transitory computer-readable media, the non-transitory computer-readable media comprising instructions that, when executed by one or more processors, cause the one or more processors to solve a topology optimization problem in designing a three-dimensional 3D object by performing the following steps: A first shape representing the 3D object with a first resolution is converted into a coarse shape with a second resolution lower than the first resolution; Coarse structure analysis data is calculated based on the coarse shape; as well as A second shape representing the 3D object is generated based on the first shape and the coarse structure analysis data using a trained machine learning model, wherein the trained machine learning model modifies the directed distance field of at least a portion of the shape elements of the first shape based on at least the coarse structure analysis data to generate one or more shape elements of the second shape, the coarse structure analysis data having the second resolution.

12. One or more non-transitory computer-readable media as claimed in claim 11, wherein the second shape is more convergent to a design objective associated with the topology optimization problem than the first shape.

13. One or more non-transitory computer-readable media as claimed in claim 11, wherein converting the first shape to the coarse shape includes performing one or more field transfer operations or remeshing operations on the first shape.

14. One or more non-transitory computer-readable media as claimed in claim 11, wherein the coarse shape comprises a 3D mesh of shape elements, and wherein each shape element is associated with a different voxel of a 3D grid having the second resolution.

15. One or more non-transitory computer-readable media as claimed in claim 11, wherein the coarse structure analysis data includes at least one of a plurality of strain energy values, a plurality of displacements, or a plurality of rotations.

16. One or more non-transitory computer-readable media as claimed in claim 11, wherein calculating the coarse structure analysis data comprises: Perform one or more structural analysis operations on the coarse shape to generate multiple strain energy values; as well as One or more normalization operations are performed on the plurality of strain energy values ​​to generate the coarse structure analysis data.

17. One or more non-transitory computer-readable media as claimed in claim 11, wherein generating the second shape comprises: Perform one or more partitioning operations on the coarse structure analysis data and at least one of the first shape or the coarse shape to generate multiple inference sets; The plurality of inference sets are input into the trained machine learning model, and in response, the trained machine learning model outputs a plurality of modified portions of the first shape; as well as The multiple modified portions of the first shape are aggregated to generate the second shape.

18. One or more non-transitory computer-readable media as claimed in claim 11, wherein generating the second shape comprises: A first inference set associated with a first portion of the first shape is calculated based on the coarse structure analysis data and at least one of the first shape or the coarse shape. The first inference set is input into the trained machine learning model, and in response, the trained machine learning model generates a first portion of the modification of the first shape; as well as The first modified portion of the first shape is combined with at least a second modified portion of the first shape to generate the second shape.

19. One or more non-transitory computer-readable media as claimed in claim 11, wherein the 3D object is designed via a generative design process involving the topology optimization problem, and the first shape is generated based on the specification of the topology optimization problem.

20. A system for solving topology optimization problems when designing three-dimensional (3D) objects, the system comprising: One or more memories, wherein the one or more memories store instructions; as well as One or more processors, coupled to one or more memories, wherein the one or more processors perform the following steps when executing the instructions: A first shape representing a 3D object with a first resolution is converted into a coarse shape with a second resolution lower than the first resolution. Coarse structure analysis data is calculated based on the coarse shape; as well as A second shape representing the 3D object is generated based on the first shape and the coarse structure analysis data using a trained machine learning model, wherein the trained machine learning model modifies the directed distance field of at least a portion of the shape elements of the first shape based on at least the coarse structure analysis data to generate one or more shape elements of the second shape, the coarse structure analysis data having the second resolution.

Images