One-Shot Generation of Near-Optimal Topology through Theory-Driven Machine Learning
Ruijin Cang Hope Yao Yi Ren







label1]Ruijin Cang
cruijin@asu.edu
[label1]Mechanical Engineering, Arizona State University, Tempe

label1]Hope Yao
houpu.Yao@asu.edu

label1]Yi Rencor1
yiren@asu.edu
[url]designinformaticslab.github.io
[cor1]Corresponding author


We introduce a theory-driven mechanism for learning a neural network model that performs generative topology design in one shot given a problem setting, circumventing the conventional iterative process that computational design tasks usually entail. The proposed mechanism can lead to machines that quickly response to new design requirements based on its knowledge accumulated through past experiences of design generation. Achieving such a mechanism through supervised learning would require an impractically large amount of problem-solution pairs for training, due to the known limitation of deep neural networks in knowledge generalization. 
To this end, we introduce an interaction between a student (the neural network) and a teacher (the optimality conditions underlying topology optimization): The student learns from existing data and is tested on unseen problems. Deviation of the student's solutions from the optimality conditions is quantified, and used for choosing new data points to learn from. We call this learning mechanism “theory-driven”, as it explicitly uses domain-specific theories to guide the learning, thus distinguishing itself from purely data-driven supervised learning.
We show through a compliance minimization problem that the proposed learning mechanism leads to topology generation with near-optimal structural compliance, much improved from standard supervised learning under the same computational budget. 




Topology Optimization Meta-learning Active Learning









§ INTRODUCTION


This paper is motivated by the observation that experienced human engineers can quickly generate solutions based on accumulated knowledge, while algorithms are only programmed to solve individual problems from scratch, even when the problems are structured similarly. The lack of ability to generalize from experience makes algorithms often too slow to respond to real-world challenges, especially when a stringent time or cost budget is in place. For example, the design of vehicle body-in-white is often done by experienced structure engineers, since topology optimization (TO) on full-scale crash simulation is not yet fast enough to respond to requests from higher-level design tasks, e.g., geometry design with style and aerodynamic considerations, and thus may slow down the entire design process[The authors learned about this challenge through personal communication with an engineer at a major car manufacturer.]. 

Research exists in developing deep neural network models that learn to create structured solutions in a one-shot fashion, circumventing the need of iterations (e.g., in solving systems of equations <cit.>, simulating dynamical systems <cit.>, or searching for optimal solutions <cit.>).
Learning of such models through data, however, is often criticized to have limited generalization capability, especially when highly nonlinear input-output relations or high-dimensional output spaces exist <cit.>. In the context of TO, this means that the network may create structures with unreasonably poor physical properties when it responds to new problem settings. More concretely, consider a topology with a tiny crack in one of its trusses. This design would be far from optimal if the goal is to lower compliance, yet standard data-driven learning mechanisms do not prevent this from happening, i.e., they don't know that they don't know (physics). 


Our goal is to create a learning mechanism that knows what it does not know, and thus can self-improve in an effective way. Specifically, we are curious about how physics-based knowledge, e.g., in the forms of dynamical models, theoretical bounds, and optimality conditions, can be directly injected into the learning of networks that perform one-shot solution generation. We call this type of learning mechanisms “theory-driven”. This idea is particularly enchanting as such knowledge widely exists in engineering disciplines and is often differentiable, which is important for gradient-based learning algorithms. 

As an initial attempt in this direction, this paper will focus on TO, and uses a compliance minimization problem <cit.> as a running example.

To overview, we introduce an interaction between a student (the neural network) and a teacher (the optimality conditions underlying the TO): The student learns from existing data and is tested on unseen problems. Deviation of the student's solutions from the optimality conditions is quantified, and used to choose new data points for the student to learn from.

We use this mechanism to learn a solution generator from a distribution of compliance minimization problems with different load settings. We show that the proposed method has significantly better performance in predicting the optimal topologies for unseen loads, than using a static data collection, under the same computational cost for data acquisition. 



The proposed method will enable learning of solution generators for engineering problems that need to be solved repetitively with variations in their settings, e.g., optimal design (structures, networks, geometries, etc.) as an inner loop of a larger-scale system design, or real-time optimal control with context-dependent parameters. The generated solutions kick-start iterative solvers with good initial guesses and thus shorten the design (solution searching) processes. 








The rest of the paper is structured as follows: In Sec. <ref> we review related work at the intersection of generative design and machine learning, and highlight the new contributions from this paper. We then revisit in Sec. <ref> the compliance minimization problem, which will be used as a running example throughout the paper, and explain the need for learning one-shot solution generators. Sec. <ref> introduces the proposed learning mechanism, which will then be validated in Sec. <ref> against two benchmark methods on the running example. Sec. <ref> discusses the connection between the proposed method and recent developments in machine learning, and suggests future directions. Sec. <ref> concludes the paper.




§ RELATED WORK





Existing research on generative design answer three types of questions: (1) What is the design representation? (2) What is the goodness measure of a design? And based on these two, (3) how do we search for a good design? 

Challenges in answering these questions include high-dimensional or ill-defined design spaces such as for topologies <cit.>, material microstructures <cit.>, or complex geometries <cit.>, expensive evaluations of designs and their sensitivities, e.g., due to model nonlinearity <cit.>, coupled materials or physics <cit.>, or subjective goodness measures <cit.>, or search inefficiency due to the absence of sensitivities <cit.> or the existence of random variables <cit.>. 




This paper takes a different angle by focusing on design tasks for which answers to the above three questions exist, yet applying them to real-world design tasks is computationally unaffordable, thus the need for algorithms that learn to improve their efficiency through problem solving. Below we review related work, and explain how this paper is similar and different from them.


To start with, the task of improving learning efficiency through experience is known as meta-learning <cit.> (with close connections to transfer learning <cit.> and life-long learning <cit.>). 

While there exists a broad range of problem settings within the literature of meta-learning, the setup commonly involves a student and a learning mechanism that specifies how the student updates its way of learning or solving problems. The student outputs a solution for every input problem, for example, the input can be a labeled dataset and the output a classifier that explains the data, or the input an optimization problem and the output an optimal solution. In the former case, the student updates its way of learning a classifier <cit.> or its hypothesis space of classifiers <cit.>; in the latter, it updates its gradient <cit.> or non-gradient <cit.> search strategies. These updates are governed by the learning mechanism, the design of which is driven by a goodness measure of the student, e.g., the generalization performance of a classifier or the convergence rate of an optimization solver. 

The problem of learning to generate designs can be cast as a meta-learning problem, where the student is the generator that takes in settings of the design problem (e.g., the distribution and magnitude of loads, the material properties, or the boundary conditions for a topology optimization problem) and outputs a design solution, whereas the learning mechanism updates the architecture or parameters of the generator. 

It is worth noting two differences between the proposed method and contemporary meta-learning. 
First, typical mechanisms proposed in meta-learning literature are iterative, e.g., in forms of recurrent neural networks <cit.>. This choice of model is due to the iterative nature of problem solving and the need of memory in decision making during the iteration. In contrary, we model the transition from problem settings to solutions using a feedforward neural network, which is one-shot in nature. We made this choice based on the finding that optimal solutions to a distribution of TO problems often form a continuous manifold (see Sec. <ref> for details), which suggests that directly learning the manifold through a feedforward network might be achievable, in which case we circumvent the challenges from modeling iterative solvers. 

Secondly, we note that existing meta-learning tasks are often set in contexts where large data acquisition is affordable. This does not hold in our case, since finite element analysis and design sensitivity analysis are costly yet necessary for training the neural network. This requires us to focus on adaptively choosing data points to improve the generator, thus rendering our approach somewhat more similar to active learning <cit.>, where the goal is to improve data efficiency of learning by querying data based on the learned model. Nonetheless, active learning strategies are usually statistics-based. For example, in the context of classification, new data points are chosen based on uncertainty of their predicted labels <cit.> or their predicted contribution to the prediction error of the learned model <cit.>. These methods, however, are not suitable for our case since we care about the physical optimality of the generated topologies, rather than the pixel-wise matching between the generated topologies and the corresponding true optima (e.g., l2-norm or cross-entropy defined on image differences often used as metrics of prediction error). The method we introduce is thus distinctively different from active learning, as we choose data based on the optimality conditions of TO, which are problem-dependent and theory-driven.  

Lastly, the proposed learning method is aligned with the recent surge of machine learning techniques with integrated physics knowledge. Among this body of work, <cit.> proposes to learn a neural network for predicting intrinsic physical properties of objects with the assistance of a physical simulator that computes object interactions based on the predicted properties. <cit.> developed an encoder that computes object positions and velocities from images of objects, by enforcing these properties to be compliant with common sense. Similarly, <cit.> proposed a physics-based regularization to learn object trajectories and human movements from videos. Instead of being taught physics, <cit.> demonstrated a grounded way for machines to acquire an intuition of the physical world through reinforcement learning. Our paper is similar to those learning mechanisms with injected physics constraints, while employing adaptive sampling rather than batch-mode training to avoid expensive simulations. In addition, the use of theory-driven constraints for learning also aligns our method with Q learning, where values are learned to satisfy Bellman's equation.















§ PROBLEM STATEMENT




 §.§ One-shot solution generator

We define a one-shot solution generator as a feedforword neural network x = g(s,θ) that computes a solution x∈𝒳 (e.g., a topology) given problem settings s∈𝒮 (e.g., loads) and network parameters θ, where 𝒳 is a solution space, and 𝒮 is a problem space (e.g., a space of locations and orientations of loads). The generator is one-shot in the sense that computing x through g is much less expensive than using an iterative algorithm. We also define the generalization performance of the generator (denoted by F(θ)) as the expected performance of its solutions over a distribution of problems specified by a probability density function p(s):

    F(θ) = 𝔼_p(s) f(g(s,θ), s),

where f(x,s) measures the performance of x under s.



 §.§ The compliance minimization problem

We now review the mechanical compliance minimization problem introduced in <cit.> to substantiate f(x,s). In this context, a solution x is a N-by-1 vector with values between 0 and 1, elements of which control a density vector, denoted as ρ, of the corresponding physical elements of a meshed structure through the following relation: 

    ρ_e = tanh(β/2)+tanh(β(x̃_e-0.5))/2tanh(β/2),

where x_e and ρ_e are the elements of x and ρ, respectively, for e=1,⋯,N. The shape parameter β controls the sharpness of the transition to the density ρ_e from a filtered variable x̃_̃ẽ, which is a weighted average of neighbours of x_e: 

    x̃_e = ∑_i∈ℳ_eω_i,e x_i/∑_i ∈ℳ_eω_i,e,

where ℳ_e is the set of neighbours of element e, and weights ω_i,e are defined as 

    ω_i,e = 1-||z_i - z_e||_2/r_e,
 
with z_i the coordinates of meshed element i, and r_e the filter radius. In TO, this filter (Eq. (<ref>)) is used to prevent convergence to impractical checkerboard topologies <cit.>. 

The connection from x to the global stiffness matrix of the topology (denoted as K) can be established through the density vector ρ. Given loads s and boundary conditions, the displacement u of the structure can be found by solving Ku=s, under the assumption that K is independent of u (e.g., linear elastic material and small displacement). The compliance minimization problem can be formulated as 


    min_x      f(x,s) = 1/2u^TKu
    subject to     Ku = s, 
          x_e ∈ [0, 1],  ∀ e ∈{1,⋯,N}, 
          g_0(x) = 1/N∑_e ρ_e - α≤ 0,
          g_1(x) = ||ρ̅||_p - α≤ 0.
        TO

Here the constraint g_0 (g_1) limits the global (local) density of the structure to be lower than a threshold α. ||x||_p = (1/N∑_e x_e^p)^1/p is the p-norm defined on ℝ^N. p is set to 16 following <cit.> so that ||x||_p approximately computes the maximum of |x| while being differentiable. The averaged local density ρ̅_e = (∑_i ∈𝒩_eρ_i)/(∑_i ∈𝒩_e 1) is defined on the neighborhood 𝒩_e = {i |  ||x_i - x_e||_2 ≤ R_e } with radius R_e. Note that R_e for the local density constraint is different from the filter radius r_e. The optimality conditions of (<ref>) are listed as follows

    ∇_x L := -u^T ∂K/∂xu + μ_0 ∇_x g_0 + μ_1 ∇_x g_1 +
            μ_u^T - μ_l^T = 0^T  
        x_e ∈ [0, 1],  ∀ e ∈{1,⋯,N}, 
        g_0 ≤ 0,   g_1 ≤ 0,  μ_0 g_0=0,  μ_1 g_1=0, 
       μ_l^Tx = 0,
            μ_u^T(x -1) = 0
       μ_0 ≥ 0,  μ_1 ≥ 0, 
             μ_u ≥0,  μ_l ≥0,

where ∇_x y(x,·) is the partial derivative of function y with respect to variables x, and is defined as a row vector. Finding a solution to comply with Eq. (<ref>) can be done through a gradient-based solver, e.g., an augmented Lagrangian algorithm (see Sec. <ref>). However, we need to note that the computational cost for converging to an optimal solution usually does not scale well. In particular, solving Eq. (<ref>) with a problem size N=4800 requires on average around 5000 finite element analyses (i.e., computing u from Ku=s).



 §.§ Learning a solution generator

With the above setup, the problem of learning a one-shot solution generator can be formulated as follows:

    min_θ      F(θ) = 𝔼_p(s) f(x,s) 
    subject to     x = g(s,θ), 
         Ku = s, 
          f(x,s) = 1/2u^TKu
          g_0(x) = 1/N∑_e ρ_e - α≤ 0,
          g_1(x) = ||ρ̅||_p - α≤ 0.
        P

We will force network outputs to be within (0,1)^N by attaching sigmoid activations to its output layer.




§ LEARNING WITH A PHYSICS-BASED CRITERION


(<ref>) can be solved by matching the input-output pairs of the generator to a dataset 𝒟 = {x_i^D, s_i^D}_i=1^n where x_i^D are optimal for s_i^D. This leads to the data-driven learning formulated as follows:

    min_θ   ∑_𝒟 ||g(s_i^D,θ) - x_i^D||_2^2.
        P1

As we reviewed in the last section, collecting 𝒟 can be costly due to the iterative nature of solving the topology optimization problem (<ref>). On the other hand, checking the compliance of an arbitrary topology x to the optimality conditions (Eq. (<ref>)) only requires solving Ku=s once. This finding indicates that the optimality conditions may offer affordable means to identify new data point that will most effectively improve the generalization performance of g. Specifically, we define the deviation of solution x from the optimality conditions as

    d(x,μ) = ||∇_x L||_2^2 + w_0 g_0^2 + w_1 g_1^2

where 

the algorithmic parameters w_0 and w_1 weight the penalties on constraints g_0 and g_1, respectively. 
One issue in evaluating d is that we do not know the values of the Lagrangian multipliers (which are denoted by μ^T = [μ_0, μ_1, μ_l^T, μ_u^T]) before solving the problem. To this end, we propose to find μ^* that minimizes the deviation of ∇_x L from 0 subject to their constraints from (<ref>):

    min_μ      ||∇_x L||_2^2 
    subject to     μ≥ 0,  μ^T g=0.
        P2

By solving (<ref>) for all s in a validation set 𝒮_v, we can then choose a new training data point (s^*, x^*) for which the minimal deviation d(g(s^*,θ),μ^*) is the largest among 𝒮_v. It is worth noting that (<ref>) is a (2N+2)-dimensional quadratic programming problem and can be solved efficiently using standard solvers (e.g., sequential quadratic programming). 













The learning algorithm can now be summarized in Alg. <ref>. Details on setting the initial training set 𝒮_0, the validation set 𝒮_v, the computational budget B, and the budget lower bound b will be introduced along the case studies in Sec. <ref>.






§ CASE STUDIES


This section presents two case studies where we demonstrate the superior learning efficiency of the proposed algorithm in comparison with two benchmark mechanisms. The first benchmark uses a static dataset (𝒟_static) for training, and is denoted as Benchmark I. The second benchmark, denoted as Benchmark II, is similar to the proposed approach, but chooses data points using a different heuristic. For all three learning mechanisms (Benchmarks I, II, and ours), the topology optimization problem is solved by an Augmented Lagrangian algorithm, details of which is deferred to the appendix.



 §.§ The heuristic of Benchmark II






In Benchmark II, we evaluate the performance of the generator g by measuring the difference between the compliance produced by g and the predicted compliance based on the training data 𝒟:

    d_h(g(s_i,θ^*)) = |f(g(s_i,θ^*),s_i) - f̂(s_i)|,

where s_i comes from the validation set 𝒮_v, and f̂ is an ordinary least square model that fits to {(s^*_i, f(x^*_i,s^*_i)  |  (x^*_i,s^*_i) ∈𝒟}. In this study, polynomial models are used for curve fitting. 

The validation data point with the highest value of d_h is chosen, and its true optimal topology is then computed and used to improve the generator.



 §.§ Study setups

The topology optimization problems to be solved follow (<ref>). Two cases are created to demonstrate the scalability of the proposed method. In Case 1, the input s represents a single load applied to a 2D structure represented by a 40-by-120 mesh, see Fig. <ref>a. In this case, the input to the generator is the angle of the load, uniformly distributed in between 0 and π, i.e., p(s) = 1/π. In Case 2, s encodes (1) the x- and y-coordinates of the loading, which is drawn uniformly from all nodes in the highlighted area in Fig. <ref>b, and (2) the direction of the point load uniformly drawn from 0 to 2π. 



To compare the three learning mechanisms, each is executed 10 times to account for the randomness in the sampling of the initial dataset 𝒟_0 (and 𝒟_static in the case of Benchmark I) and the validation set at each iteration. The generalization performance is measured by 

    F(θ^*) = ∑_s_i ∈𝒮_t f(g(s_i,θ^*),s_i),

where 𝒮_t is a separate test set drawn from p(s). For Case 1, the sample sizes are |𝒮_0| = 5, |𝒮_v| = 100, |𝒮_t| = 100, and |𝒟_static| = 16. For Case 2, since the problem space is much larger, the sample sizes are set to |𝒮_0| = 1000, |𝒮_v| = 6000, |𝒮_t| = 1000, and |𝒟_static| = 7000. In addition, since validating a large number of inputs becomes expensive, we uniformly sample 100 validation points from |𝒮_v| to perform active learning in each iteration. All previously sampled points will be removed from 𝒮_v. For both cases, the computational budget B_0 is set as b_min|𝒟_static|, where b_min is the minimal solution cost among all problems sampled for Benchmark I. The budget lower bound b is set to the maximal cost among the same set of problems. This setting ensures that the adaptive methods (Benchmark II and the proposed method) will always use less computational resource than the static method for topology optimization, thus creating a comparison in favor of the latter. For the following results, we set w_0=w_1=1 for the proposed method. A full parametric study on these hyper-parameters has not been conducted, yet the effectiveness of the current setting is validated (Sec. <ref>). 




 §.§ Architectures of the solution generators

The architectures of the solution generators are summarized in Fig. <ref>. For Case 1, we use a two-dimensional input to represent the x- and y-components of the point load. For Case 2, we use a three-dimensional input to represent the x, y location and the orientation of the point load. The choice of these input representations are based on empirical tests of the generalization performance of the learned models. In particular, we found in Case 2 that using a sparse load representation as network inputs will lead to much worse generation performance for all learning mechanisms.























 §.§ Results







  
Case 1 results For Case 1, Fig. <ref>a compares the compliance of the topologies generated by all three learning mechanisms with the ground truth for all test inputs; Fig. <ref>b reports the corresponding compliance gaps produced by these mechanisms. The generalization performance of a learning mechanism is measured by the mean and the standard deviation of the average compliance gaps across all test inputs. 

The result shows that the proposed mechanism outperforms the benchmarks at predicting optimal topologies for unseen loading conditions in a low-dimensional case. To further demonstrate the difference between the three mechanisms, we visualize and compare generations for four test loads in Fig. <ref>. The loading directions are marked in the last row of the figure, which are 0.3π, 0.4π, 0.45π,0.55π respectively. The resultant compliance values are shown at the bottom of each topology. 










  
Challenges in Case 2
Case 2 examines the performance of the proposed mechanism under a higher-dimensional and larger input space. We notice that the learning becomes significantly more challenging in this case. see Sec <ref>). Specifically, for all three algorithms under the same budget (which is equivalent to solving 7000 TO problems), there exist inputs for which the generated topologies have significantly larger compliance than the ground truth. We mark test data points with a compliance gap of over 1000 as failed designs. 
For Benchmark I, II and the proposed method, the mean failure rates over the entire test are 14%,  0.8%, and 0.6% respectively.
Some failed generations are shown in Fig. <ref> along side the corresponding ground truth.







  
An augmented learning objective
To alleviate this issue, we introduce design sensitivity ∇_x f at the optimal solution as a weighting factor of the learning loss in (<ref>), based on the insight that structural elements with higher sensitivity contribute more to the compliance and thus should have higher priority during model training. Concretely, the training problem at each iteration of the active learning process is now formulated as

    min_θ   ∑_(s_i, x_i) ∈𝒟  ||g(s_i,θ) - x_i||_Λ_i^2,

where Λ_i = diag([λ_i,1,⋯,λ_i,N]) is a diagonal weighting matrix, λ_i,e = ∇_x f - min(∇_x f)/max(∇_x f)-min(∇_x f), and ||x||_Λ^2 = x^TΛx. It is important to note that Λ_i is a byproduct of computing x_i and does not cost extra budget.







  
Case 2 results
By introducing this augmentation, the mean rate of failures drops to 5.12%, 0.64%, and 0.16% for Benchmark I, II, and the proposed method, respectively. Since the compliance distributions are far from normal due to the failed designs, we report the means and standard deviations of the median compliance gaps from all experiments and learning mechanisms instead. These results are summarized in Table <ref>. As a demonstration, we compare in Fig. <ref> the generations from all mechanisms under four test settings. The proposed method has the closest compliance to the ground truth.  









  
Validity of hyper-parameter settings
For both case studies we set the weights for the local and global constraints (w_0 and w_1 in Eq. <ref>) to be w_0 = 1 and w_1 = 1. To validate this setting, we monitor the violation to the constraints by solutions generated for all test inputs. For a proper measure of constraint satisfaction, test cases where constraints are satisfied will be ignored in the calculation of the mean violation. It is noted that ground truth topologies have none-zero violation due to the non-zero error thresholds set in the augmented Lagrangian algorithm. In Case 1 (Case 2), the mean violation to the global volume fraction constraint is g_0=4.89% (3.0%) for the ground truth and g_0=8.76% (1.6%) for the generated solutions. In both cases, no violation to the local constraints are observed for either the ground truth or the generated solutions. This result indicates that the setting of the hyper-parameters leads to the learning of a generator with reasonable compliance to the global and local volume fraction constraints. A parametric study is yet needed to fully characterize the tradeoff between the learning of effective topologies and that of constraint compliance by tuning the hyper-parameters.




  
Comparison on solution generation speed Lastly, we shall note that the computation time required for generating solutions through the learned model is negligible (in the order of 10^-2 seconds per topology on Intel Xeon CPU E5-1620 @ 3.50GHz) compared with that through a TO solver (in the order of 10^2 to 10^3 seconds per topology).
It is also worth mentioning that the run-time cost of the model does not include the data acquisition cost for training the model, and the above comparison only makes sense for cases where the expected amount of computation (for all TO problems to be solved) is much larger than what is required for training the network. We acknowledge, nonetheless, that quantifying the total computational cost of a design task is challenging (e.g., due to unknown designer preferences), and theoretical upper bounds on the data size for neural networks are yet to be established. However, addressing these issues is beyond the scope of this paper. 



§ DISCUSSION


We now discuss the remaining issues related to learning manifolds of optimal solutions using neural networks.



 §.§ Curse of dimensionality and potential solutions

So far we assumed that the pre-defined network architecture is able to capture the underlying manifold in high-dimensional spaces. As we see from the two cases, increasing the latent dimension of the manifold from one to three already raised the data demand significantly, indicating that the manifold of optimal topologies underlying Case 2 is much more “complex” than that of Case 1. Indeed, from Narayanan and Mitter <cit.>, the sampling complexity of learning a manifold (to within a specified tolerance) is exponential on the intrinsic dimension (the dimension of the input), linear on the intrinsic volume (the size of the input space), and polynomial on the curvature of the manifold.

This leads to two legitimate concerns. The first regards model sufficiency: pre-defining the network architecture of the generator could be a stab in the dark when a new manifold is to be learned, as we do not know whether the network is sufficiently flexible to fit to the manifold. The second regards data sufficiency: real-world design problems may have solution manifolds that are too data-demanding for active learning alone to handle.

Lei et al. <cit.> recently proposed an approach to the first concern in the context of piecewise linear networks (with ReLU activations). It is shown that both the manifold and the network complexity can be measured by the number of polyhedral cells induced respectively by the geometry of the manifold and the architecture of the network. Further studies following these complexity measures may lead to protocols for determining the network architecture of the generator before learning of generator weights takes place, essentially by computing an upper bound on the number of planes needed to locally and linearly approximate the underlying manifold. An efficient algorithm for doing so, however, is yet to be developed.

The second concern, however, is more critical to the application of the proposed method. One potential solution is based on the insight that the governing equations for training can be derived at arbitrary spatial resolution of the structure. While the intrinsic dimension and volume do not change across resolutions, we hypothesize that lowering the resolution will reduce the manifold curvature, and thus reduce the sampling complexity. In the context of TO, with lower resolution of the structure (i.e., less elements), we expect an easier learning problem. Based on this hypothesis, it is possible that a hierarchical network architecture can be learned progressively to alleviate the curse of dimensionality: At each spatial resolution level, we learn a generator that predicts the transition from coarse solutions to the ones that satisfy the optimality conditions at this level. The coarse solutions are proposed by the generator learned from the lower-level resolution. The investigation of this approach will be reported in a separate paper. It should be reiterated that despite the inevitable scalability challenge, the value of learning models through domain-specific theories is clearly demonstrated in this study.



 §.§ From theory-driven data selection to full theory-driven learning

Another direction to explore is based on the note that the proposed method does not solve the learning problem (<ref>) directly. Rather, we collect true solutions and fit a generator (i.e., a neural network) to it, with the hope that by intelligently collecting true solutions on fly, the fit model will effectively converge to the true solution manifold governed by the optimality conditions. An interesting question is whether solving (<ref>) directly through a gradient-based method can be achieved and will be more effective than the presented method. If we consider the presented learning mechanism as theory-driven data selection, then solving (<ref>) directly will be full theory-driven learning. More concretely, in each iteration of the learning, we would need to solve a batch of TO problems partially, i.e., finding feasible topologies that reduce the violation to the optimality conditions, and use the resultant changes in topologies to update the solution generator. The key difference between the presented method and a full theory-driven learning mechanism is that while the former guarantees optimality of known solutions as long as the network is flexible enough to fit through these solutions, the latter does not have such a guarantee at any time during the training; instead, it requires less cost per iteration (since it does not completely solve TO problems), and may afford more iterations (batches of TO problems). Fig. <ref> visualizes the difference between the two using a simple 2D illustration, where the circle is the unknown solution manifold, the curve represents a solution generator, and the dots are sampled solutions.




 §.§ Interpretability of the generators


One additional challenge we face is the interpretation of the learned generator. Given the fact that the generators perform reasonably well in the two cases, one would like to visualize what they learn, e.g., local structural features that serve as puzzle pieces and lead to low-compliance structures when assembled. However, an investigation into the learned generators shows that such interpretable knowledge are not evident from the visualization of the network parameters. One potential reason is that the arbitrarily chosen network architecture may introduce confounding hidden nodes that decompose interpretable features that could have existed. 

One solution could be to impose regularization on all network parameters to be learned. 

Yet this will introduce more hyper-parameter tuning as a result.



 §.§ Value of learning manifolds of optimal designs to designers

Last but not least, we shall come back to discuss and reiterate why and when learning manifolds of optimal designs has a value to designers. As we discussed in the introduction, there are cases where a large number of topology optimization problems (or other forms of optimization problems) need to be solved with only parametric differences. Such cases include when the TO is nested in a larger-scale system-level optimization, or when problem settings of the TO are required to be explored by human designers. In addition, designers may solve problems without knowing that similar ones have been previously solved by others. The proposed learning mechanism would not only allow a machine to accumulate and learn from solutions to similar problems, but also effectively practice by itself to reinforce its intuition at quickly solving common sets of problems, and thus may reduce the computational and energy cost of design tasks of growing complexity. 

On the other hand, the learning itself requires solving more problems during adaptive sampling. Hence, it would be ideal to understand whether the expected total cost of solving a set of problems in the future surpasses the potential cost of learning. If so, the learning mechanism would have a value. The comparison between these two costs, however, will not be straight forward, as we do not know the learning cost beforehand for a certain performance threshold of the resultant generator. Therefore, a performance bound of the generator along the sample size will need to be developed to guide the decision on whether the learning has a practical value or not. 




§ CONCLUSION


We were motivated by the lack of knowledge accumulation capability of existing computational solvers for design problems. This drawback of machines hampers them from quickly creating good solutions in response to changing requirements in real-world design processes. Our solution to this end was to create a solution generator that adaptively learns from true solutions from a distribution of problems and predicts solutions to other unseen problems from the same distribution. The generator was modeled by a feedforward neural network, and thus produces solutions in one-shot, as opposed to through iterations as in conventional approaches. Our key contribution was the introduction of problem-specific optimality conditions as a tractable validation measure to enable more effective learning. We highlight that computing the violation of a generated solution to the optimality conditions requires only a single finite element analysis, while comparing the generated solution with the ground truth would require an entire topology optimization process, which requires thousands of finite element analysis for the problems we studied. 

We showed through two case studies that the proposed learning algorithm achieves significantly better generalization performance than the benchmarks under the same computational cost. While more sophisticated topology optimization settings should be tested, the proposed method is generally applicable to tasks of learning distributions of optimal solutions, provided that the optimality conditions can be derived and computed at low cost. Source codes for reproducing results from the paper are available https//github.com/DesignInformaticsLab/Theory_Driven_TOhere.




§ APPENDIX




 §.§ Topology optimization through augmented Lagrangian


The topology optimization problem of (<ref>) is solved using Alg. <ref>. Note that other algorithms, such as the method of moving asymptotes <cit.>, are also applicable.



































elsarticle-num














