class Generator(nn.Module):
    def __init__(self):
        super().__init__()

        self.noise_block = nn.Sequential(
            nn.Linear(nz, 64 * 7 * 7),
            nn.BatchNorm1d(64 * 7 * 7),
            nn.LeakyReLU(0.1),
            nn.Unflatten(1, (64, 7, 7)),  # (batch, 64, 7, 7)

            nn.ConvTranspose2d(64, 64, 4, 2, 1, bias=False),  # (batch, 64, 14, 14)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),
        )

        self.label_mapper = nn.Sequential(
            nn.Linear(label_dim, 64),
            nn.BatchNorm1d(64),
            nn.LeakyReLU(0.1),
            nn.Linear(64, 64 * 14 * 14),
            nn.Tanh(),
            nn.Unflatten(1, (64, 14, 14))   # (batch, 64, 14, 14)
        )

        self.net = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1, bias=False),  # (batch, 64, 28, 28)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),

            nn.ConvTranspose2d(64, 32, 3, 1, 1, bias=False),  # (batch, 32, 28, 28)
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.1),

            nn.ConvTranspose2d(32, 1, 3, 1, 1, bias=False),  # (batch, 1, 28, 28)
            nn.Tanh()
        )

    def forward(self, z, label):
        x = self.noise_block(z)
        label = self.label_mapper(label)
        x = torch.cat([x, label], dim=1)
        y = self.net(x)
        return y

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(1 + label_dim, 64, 4, 2, 1),  # (batch, 64, 14, 14)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),
            nn.Dropout2d(0.3),

            nn.Conv2d(64, 64, 4, 2, 1),  # (batch, 64, 7, 7)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),
            nn.Dropout2d(0.3),

            nn.Conv2d(64, 128, 4, 1, 0),  # (batch, 128, 4, 4)
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.1),
            nn.Dropout2d(0.3),

            nn.Conv2d(128, 128, 3, 1, 1),  # (batch, 128, 4, 4)
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.1),

            nn.Flatten(),   # 2048
            nn.Linear(2048, 1),
            nn.Sigmoid()  # probability (0~1)
        )

    def forward(self, x, label):
        label = label.view(label.size(0), label_dim, 1, 1)  # (batch_size, label_dim, 1, 1)
        label = label.expand(label.size(0), label_dim, x.size(2), x.size(3))  # (batch_size, label_dim, img_size, img_size)

        x = torch.cat([x, label], 1)  # (batch, 1 + label_dim, img_size, img_size)
        y = self.net(x)
        return y

  class Regressor(nn.Module):
    def __init__(self):
        super().__init__()
        self.label_dim = label_dim

        self.net = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=4, stride=2, padding=1),  # (batch_size, 32, 14, 14)
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.1),

            nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1),  # (batch_size, 64, 7, 7)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),

            nn.Flatten(),  # (batch_size, 3136)
            nn.Linear(64 * 7 * 7, 128),
            nn.LeakyReLU(0.1),
            nn.Linear(128, label_dim),
            nn.Tanh()
        )

    def forward(self, x):
        return self.net(x)

# --- Model instantiation ---
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
netD = Discriminator().to(device)
netG = Generator().to(device)
netR = Regressor().to(device)

# --- Loss functions ---
adv_loss_fn = nn.BCELoss()   # adversarial loss
reg_loss_fn = nn.MSELoss()   # regression loss

real_labels = torch.full((batch_size, 1), 0.9, device=device)
fake_labels = torch.zeros(batch_size, 1).to(device)

# --- Single-epoch training function ---
def train():
    netD.train(); netG.train(); netR.train()

    for real_imgs, label in dataloader:
        real_imgs = real_imgs.to(device)
        label = label.to(device)

        # --- Discriminator update ---
        optimD.zero_grad()
        z = torch.randn(batch_size, nz, device=device)
        with torch.no_grad():
            fake_imgs = netG(z, label)

        pred_fake = netD(fake_imgs, label)
        pred_real = netD(real_imgs, label)

        lossD = adv_loss_fn(pred_fake, fake_labels) + adv_loss_fn(pred_real, real_labels)
        lossD.backward()
        optimD.step()

        # --- Generator update ---
        optimG.zero_grad()
        z = torch.randn(batch_size, nz, device=device)
        fake_imgs = netG(z, label)

        # Adversarial loss
        pred_fake = netD(fake_imgs, label)
        loss_adv = adv_loss_fn(pred_fake, real_labels)

        # Regression loss
        loss_reg = reg_loss_fn(netR(fake_imgs), label)

        # Mode Seeking loss
        z2 = torch.randn(batch_size, nz, device=device)
        fake_imgs2 = netG(z2, label)
        loss_ms = mode_seeking_loss(fake_imgs, fake_imgs2, z, z2)

        lossG = loss_adv + lambda1 * loss_reg + lambda2 * loss_ms
        lossG.backward()
        optimG.step()

        # --- Regressor update ---
        optimR.zero_grad()
        lossR = reg_loss_fn(netR(real_imgs), label) + reg_loss_fn(netR(fake_imgs), label)
        lossR.backward()
        optimR.step()

0. Introduction

Deep learning (DL)–based generative techniques have advanced remarkably, making it increasingly common to automatically generate text or images from simple prompts. These generative models can produce plausible outputs based on training data, without the need for explicitly defined rules or parameter settings.

In contrast, our company's design workflows involve deriving structural geometries from functional requirements by applying a variety of optimization methods. Each method has its strengths and weaknesses, and considerable effort is required in problem formulation, parameter tuning, and method integration—often through extensive trial and error.

A DL-based generative model that directly produces structural geometries from specified conditions could eliminate much of this trial-and-error and dramatically improve design efficiency. The key question, then, is whether such a model—one that accepts functional specifications as input and outputs appropriate geometries—can be realized in the structural design domain.

1. Generative Models

A generative model learns the distribution of training data and produces new “plausible” samples that resemble the training data.

There are many types of deep neural network–based generative models. In this work, I adopt the Generative Adversarial Network (GAN), as it was the quickest for me to understand and implement.
A GAN consists of two networks—a Generator and a Discriminator—that are trained in opposition. Through this adversarial training, the Generator becomes capable of producing images that closely resemble the training set. The main advantages are that it can generate outputs with sharp, well-defined edges and do so at high speed.

In a standard GAN, the generated images depend entirely on random noise, so there is no way to control the output.

To address this, we employ a Conditional GAN (cGAN). By feeding the condition label into both the Generator and the Discriminator, cGAN enables the generation of outputs that conform to the specified condition. This approach can be applied to tasks such as generating structural geometries that meet specific functional requirements.

In this article, I omit a detailed description of generative models. For a more precise and comprehensive explanation, please refer to specialized books or academic literature.

2. Design Target

As the subject for functional-to-geometric generation, we focus on a plate with periodic corrugations—such as a checker plate.

The corrugation pattern of a checker plate is primarily designed for anti-slip purposes, but it also serves to enhance the plate’s bending stiffness.

The macroscopic bending behavior of a periodically corrugated plate can be homogenized and modeled as a continuous shell element (see our previous article). For simplicity, we here assume an orthotropic material and ignore torsional stiffness, focusing exclusively on the bending stiffness components.

For example, as illustrated in the figure, if the corrugations extend predominantly in the x-direction, the plate exhibits higher bending stiffness about the X-axis and lower stiffness about the Y-axis. In other words, in the bending stiffness matrix, the \(D_{11}\) component is large while the \(D_{22}\) component is small.

In practical design, there are often situations where a member must have just the right combination of stiffness properties. Although we simplify the problem setting here, simultaneously tuning three bending stiffness parameters is not an easy task unless performed by a technician with specialized training.

3. Dataset Preparation

A generative model cannot be created from scratch—it requires a suitable dataset for training.

To build a dataset with diverse shape patterns, we generate corrugated geometries based on different characters. We then perform finite element analysis on each geometry to compute its bending stiffness, which serves as the condition label for training.

3.1 Analysis Model

For this study, we assume an orthotropic structure and perform finite element analysis (FEA) on a quarter-unit model of each character-based geometry to extract its bending stiffness.

To generate the geometries, each character is placed within a 10 × 10 mm square and then binarized into a 28 × 28 pixel image. Regions corresponding to the character are interpreted as beads (raised portions). Although such sharp-edged beads would be difficult to manufacture in reality, we deliberately omit any smoothing of curves or height variations here to keep the analysis model simple.

The bead height is uniformly set to 0.3 mm, and and the plane passing through the center of mass in the Z direction is assumed to be the neutral plane. Material properties are defined as a plate thickness of 0.1 mm, Young’s modulus of 1 GPa, and Poisson’s ratio of 0.3. Shell elements are used for modeling, and the bending stiffness matrix is computed from the reaction moments obtained when the model is bent about the X- and Y-axes.

3.2 Geometry Patterns

To avoid arbitrary shape selection and ensure dataset diversity, we generated geometries based on the English alphabet.

We used all 52 English alphabet characters (A–Z and a–z). Using the Times New Roman font, we applied variations in font style (regular, bold, italic, and bold–italic) and in placement (position and scale) to generate 2,496 distinct shape patterns.

Each generated shape is saved as a 28 × 28-pixel image for training the generative model. In these images, the raised regions (beads) are depicted in black.

3.3 Analysis Results of Dataset

Finite element analysis (FEA) for each individual shape takes only a few seconds, allowing the computation of bending stiffness across the entire dataset to complete in a matter of hours. The resulting bending stiffness components are plotted in the figure below.

As a reference, we also plot the bending stiffness of a flat plate (without corrugations), calculated by the following formula, as red dots.

Because many of our patterns feature elements aligned along the vertical axis, the overall distribution shows higher bending stiffness in the Y-direction. Although this dataset alone would merit a detailed analysis, which this margin is too narrow to contain, doing so would fall outside the scope of this article and is therefore omitted.

3.4 Data Augmentation

In training generative models, both the quantity of training data and the distributional bias can significantly affect model performance. In the present dataset, many of the shapes derived from characters exhibit vertical continuity, resulting in a relatively large number of samples with high bending stiffness in the y-direction. To mitigate this bias and enhance the diversity of the training data, we introduced data augmentation.

Data augmentation is a technique that artificially increases dataset variation by applying transformations—such as rotations, flips, and scaling—to existing samples.

In this study, we performed augmentation using rotations:

• 180° rotation: The rotated shape has identical bending-stiffness components, so it can be used with its original labels unchanged.
• 90° and 270° rotations: These rotations swap the shape’s principal directions, so we exchange the \(D_{11}\) and \(D_{22}\) components in the bending-stiffness matrix to keep the labels consistent.

Note that color inversion (inverting bead and recess) and horizontal flipping also preserve the same bending‐stiffness values and could be applied in the same way. However, we prioritized training speed and convergence stability over maximizing output diversity, so we limited augmentation to rotations only.

As a result, the total dataset size was quadrupled.

4. NN Architecture and Training

In this section, we describe the architecture and training methodology of our Conditional GAN (cGAN)–based generative model. While standard GANs are known for their powerful generation capabilities, constructing the model alone does not definitely lead to satisfactory outputs; training presents its own set of challenges that require careful design and extensive experimentation.

Moreover, our goal is to generate shapes that faithfully satisfy specified functional conditions. This condition fidelity must be balanced against the inherently multi-modal nature of the problem, in which multiple valid solutions may exist for a single condition. Since fidelity and output diversity often exhibit conflicting tendencies, achieving both requires thoughtful architectural choices and training strategies.

4.1 Challenges in Training GANs

Generative Adversarial Networks (GANs) are known to suffer from several challenges:

• The absence of an explicit loss function in GANs complicates the evaluation of performance and the assessment of convergence.
• Training tends to be unstable, and issues such as mode collapse (where the generator fails to produce diverse outputs) and training imbalance (where the Generator and Discriminator diverge in performance, leading to stalled) often occur.

To mitigate these problems, the following adjustments are typically required:

• Fine-tuning the learning rates to maintain a balance between the Generator and Discriminator.
• Carefully selecting and tuning hyperparameters such as batch size, latent space dimensionality, dropout rate, and activation functions.

4.2 Training Architecture and Design Strategies

In this study, we adopted a training architecture that goes beyond a simple Generator–Discriminator setup. To improve conditional fidelity and ensure output diversity, we introduced several key design strategies. This section outlines the implementation techniques, network components, and loss functions used in our model.

4.2.1 Implementation Design

To stabilize training and obtain the expected outputs, we introduced the following implementation strategies:

• Intermediate label injection in the Generator:
  
  To give meaning to the conditional labels and help stabilize learning, the labels are injected into the intermediate layers of the Generator.

• Introduction of a Regressor for condition fidelity:
  
  To maintain fidelity to the specified conditions, a Regressor is added to predict bending stiffness from the generated images.

• Addition of Mode Seeking Loss (MSGAN):
  
  To ensure diversity in the output, a mode seeking loss is introduced so that changes in input noise result in differences in the generated output.

4.2.2 Components

The model consists of the following three networks:

• Generator :
  
  Takes random noise \(z\) and condition labels \((D_{11}, D_{22}, D_{12})\) as input and generates an image.

• Discriminator :
  
  Takes an image and condition labels as input and determines whether the input is real (from the dataset) or fake (generated).

• Regressor :
  
  Predicts the bending stiffness\((\hat{D}_{11}, \hat{D}_{22}, \hat{D}_{12})\) from the generated image and checks its consistency with the input condition.

4.2.3 Loss Functions

The loss functions for each network are defined as follows. Here, \(x\) denotes a real image, \(y\) denotes the condition label, and \(z\) denotes the input noise. The losses are computed as averages over mini-batches of multiple samples.

• Discriminator loss : \(\text{Loss}_D = -\log D(x,y)-\log(1-D(G(z,y),y))\)
  
  The Discriminator is trained to output a high probability when a real data sample is input, and a low probability when a generated (fake) sample is input.

• Generator loss : \(\text{Loss}_G=\underbrace{-\log D(G(z,y),y)}_\text{adversarial}+\underbrace{||R(G(z,y))-y||^2}_\text{regressor}+\underbrace{\text{Loss}_{MS}(G(z,y),G(z',y),z,z')}_\text{mode-seeking}\)
  

  The Generator’s loss consists of the adversarial term (to fool the Discriminator), a regression term via the Regressor to ensure consistency with the condition, and the Mode Seeking Loss \(\text{Loss}_{\text{MS}}\) to encourage output diversity.

• Regressor loss : \(LossR=||R(x)-y||^2+||R(G(z,y))-y||^2\)
  
  The Regressor is trained to output the correct bending stiffness labels \(y\) for both real data x and generated data \(G(z, y)\).

　　　

Below is an excerpt of the PyTorch-based code used to construct and train the neural networks. Please note that some auxiliary processes have been omitted for brevity, and the code may not run as-is.

class Generator(nn.Module):
    def __init__(self):
        super().__init__()

        self.noise_block = nn.Sequential(
            nn.Linear(nz, 64 * 7 * 7),
            nn.BatchNorm1d(64 * 7 * 7),
            nn.LeakyReLU(0.1),
            nn.Unflatten(1, (64, 7, 7)),  # (batch, 64, 7, 7)

            nn.ConvTranspose2d(64, 64, 4, 2, 1, bias=False),  # (batch, 64, 14, 14)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),
        )

        self.label_mapper = nn.Sequential(
            nn.Linear(label_dim, 64),
            nn.BatchNorm1d(64),
            nn.LeakyReLU(0.1),
            nn.Linear(64, 64 * 14 * 14),
            nn.Tanh(),
            nn.Unflatten(1, (64, 14, 14))   # (batch, 64, 14, 14)
        )

        self.net = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1, bias=False),  # (batch, 64, 28, 28)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),

            nn.ConvTranspose2d(64, 32, 3, 1, 1, bias=False),  # (batch, 32, 28, 28)
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.1),

            nn.ConvTranspose2d(32, 1, 3, 1, 1, bias=False),  # (batch, 1, 28, 28)
            nn.Tanh()
        )

    def forward(self, z, label):
        x = self.noise_block(z)
        label = self.label_mapper(label)
        x = torch.cat([x, label], dim=1)
        y = self.net(x)
        return y

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(1 + label_dim, 64, 4, 2, 1),  # (batch, 64, 14, 14)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),
            nn.Dropout2d(0.3),

            nn.Conv2d(64, 64, 4, 2, 1),  # (batch, 64, 7, 7)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),
            nn.Dropout2d(0.3),

            nn.Conv2d(64, 128, 4, 1, 0),  # (batch, 128, 4, 4)
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.1),
            nn.Dropout2d(0.3),

            nn.Conv2d(128, 128, 3, 1, 1),  # (batch, 128, 4, 4)
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.1),

            nn.Flatten(),   # 2048
            nn.Linear(2048, 1),
            nn.Sigmoid()  # probability (0~1)
        )

    def forward(self, x, label):
        label = label.view(label.size(0), label_dim, 1, 1)  # (batch_size, label_dim, 1, 1)
        label = label.expand(label.size(0), label_dim, x.size(2), x.size(3))  # (batch_size, label_dim, img_size, img_size)

        x = torch.cat([x, label], 1)  # (batch, 1 + label_dim, img_size, img_size)
        y = self.net(x)
        return y

  class Regressor(nn.Module):
    def __init__(self):
        super().__init__()
        self.label_dim = label_dim

        self.net = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=4, stride=2, padding=1),  # (batch_size, 32, 14, 14)
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.1),

            nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1),  # (batch_size, 64, 7, 7)
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.1),

            nn.Flatten(),  # (batch_size, 3136)
            nn.Linear(64 * 7 * 7, 128),
            nn.LeakyReLU(0.1),
            nn.Linear(128, label_dim),
            nn.Tanh()
        )

    def forward(self, x):
        return self.net(x)

# --- Model instantiation ---
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
netD = Discriminator().to(device)
netG = Generator().to(device)
netR = Regressor().to(device)

# --- Loss functions ---
adv_loss_fn = nn.BCELoss()   # adversarial loss
reg_loss_fn = nn.MSELoss()   # regression loss

real_labels = torch.full((batch_size, 1), 0.9, device=device)
fake_labels = torch.zeros(batch_size, 1).to(device)

# --- Single-epoch training function ---
def train():
    netD.train(); netG.train(); netR.train()

    for real_imgs, label in dataloader:
        real_imgs = real_imgs.to(device)
        label = label.to(device)

        # --- Discriminator update ---
        optimD.zero_grad()
        z = torch.randn(batch_size, nz, device=device)
        with torch.no_grad():
            fake_imgs = netG(z, label)

        pred_fake = netD(fake_imgs, label)
        pred_real = netD(real_imgs, label)

        lossD = adv_loss_fn(pred_fake, fake_labels) + adv_loss_fn(pred_real, real_labels)
        lossD.backward()
        optimD.step()

        # --- Generator update ---
        optimG.zero_grad()
        z = torch.randn(batch_size, nz, device=device)
        fake_imgs = netG(z, label)

        # Adversarial loss
        pred_fake = netD(fake_imgs, label)
        loss_adv = adv_loss_fn(pred_fake, real_labels)

        # Regression loss
        loss_reg = reg_loss_fn(netR(fake_imgs), label)

        # Mode Seeking loss
        z2 = torch.randn(batch_size, nz, device=device)
        fake_imgs2 = netG(z2, label)
        loss_ms = mode_seeking_loss(fake_imgs, fake_imgs2, z, z2)

        lossG = loss_adv + lambda1 * loss_reg + lambda2 * loss_ms
        lossG.backward()
        optimG.step()

        # --- Regressor update ---
        optimR.zero_grad()
        lossR = reg_loss_fn(netR(real_imgs), label) + reg_loss_fn(netR(fake_imgs), label)
        lossR.backward()
        optimR.step()

5. Evaluation of Generated Geometries

To evaluate how closely the generated geometries match the specified bending stiffness conditions, we reconstructed the surface profile from the images output by the Generator and computed the bending stiffness using finite element analysis.

For each condition label, five different noise vectors were input, and the corresponding generated images were evaluated. This process was repeated every 100 epochs to observe how the bending stiffness of the generated shapes evolved over the course of training.

Note that during training, the values of each component of the condition labels were normalized to the range of \([-1, 1]\).

• \(D_{11} \in [0, 2.5]\)
• \(D_{22} \in [0, 2.5]\)
• \(D_{12} \in [0, 0.350]\)

The following shows the generated shapes when the condition label \((D_{11}, D_{22}, D_{12}) = (0.5, 0.25, 0.0875)\) is specified.

Observing the generated shapes, we can see that the curved features characteristic of letters gradually emerge as training progresses. Moreover, given that the bending stiffness in the X-direction \(D_{11}\) is larger than that in the Y-direction \(D_{22}\), the generated shapes tend to be reinforced in the X-direction, suggesting that the model appropriately reflects the mechanical characteristics.

In addition, by changing the input noise, multiple distinct shape candidates are generated, confirming that the model also ensures diversity in its outputs.

The results of the finite element analysis conducted every 100 epochs on the leftmost image above are shown below, where the bending stiffness values were calculated for each generated image.

As the number of training epochs increases, the bending characteristics of the generated shapes gradually approach the target values indicated by the diamond symbol (◇).

But can the model generate shapes with bending stiffness close to the specified conditions for any given input?

To explore this, we evaluated the shapes generated for 6 different conditions, including the one mentioned above. For each condition, 5 different noise vectors were input, and the bending stiffness values of the resulting shapes after 2000 training epochs are shown.

When examining the generated shapes, we can see that the overall structure generally aligns with the specified conditions—for example, the direction of reinforcement and the prominence of the corrugation correspond to the magnitude and directionality of the target stiffness.

On the other hand, when comparing the target values (marked with diamonds ◇) and the generated results (marked with crosses ×) by color, we observe that in regions where training data is sparse, the model tends to show lower condition fidelity. This is because the model is trained to generate shapes similar to the existing data, and to produce shapes that correspond to conditions not covered in the training set, it will likely require additional data and retraining.

Moreover, even in condition regions with high fidelity, discrepancies between the specified conditions and the generated geometries remain, indicating that further challenges must be addressed before the method can be applied in practical design. Incorporating alternative generative models or refining the neural network architecture and hyperparameters may offer some improvements. However, to generate shapes that more closely match the target conditions, it will likely be necessary to adopt approaches such as selective dataset curation or combining with optimization-based techniques.

6. Conclusion

To explore the potential of generative models that derive structural geometries directly from functional requirements, we conducted an investigation using a Conditional GAN (cGAN). A diverse dataset of corrugated plate geometries was constructed based on letter shapes, and we attempted to generate structural forms conditioned on specified bending stiffness values.

As a result, the model was able to generate geometries that showed a degree of consistency with the target stiffness—such as the direction and magnitude of corrugation—suggesting that it learned not only shapes but also a form of "plausibility" related to mechanical function.

At the same time, while this approach may prove useful in scenarios where similar structures need to be generated without explicitly setting shape parameters, allowing for some margin of error, several challenges remain before it can be applied in real-world structural design:

• Requires expertise and effort
  
  Preparing the dataset, designing the network, and tuning hyperparameters all demand domain knowledge and iterative experimentation.

• Good structures require good data
  
  Because the model learns to generate shapes similar to existing data, condition fidelity tends to degrade in regions not well covered by the dataset.
  
  Moreover, since this method is not an optimization process, it produces shapes that might satisfy the desired function, but not necessarily those that do or must. In order to generate appropriate geometries, the dataset needs to consist of high-quality, functionally effective structures—such as those obtained from optimization results.

We have come to recognize the approach presented here is not yet sufficient to realize a generative model that can automatically produce appropriate geometries solely from functional input—something that could surpass our current optimization-based design methods.

We intend to continue exploring the applicability of deep learning to geometry design, striving toward higher-quality structural generation.

In the Japanese version of this article, hiragana characters are used for the dataset instead of the alphabet. If you are interested in comparing the differences between datasets, please take a look at the Japanese version. (You can switch to it using the "JP" button in the bottom-right corner.)

References

The following works were referenced during the writing of this article:

[1] Xiaoyang Zheng et al. Controllable inverse design of auxetic metamaterials using deep learning. Materials & Design. 2021, 221, 110178

[2] Jan-Hendrik Bastek et al. Inverse design of nonlinear mechanical metamaterials via video denoising diffusion models, Nature Machine Intelligence. 2023, 5, 1446-1475