about Generative Design Optimize

Over the last few years of executing Generative Design (GD) projects, my deepest focus has been on 'Spatial Layout' and 'Feasibility Studies' for buildings, industrial plants, and specialized facilities.

Throughout this process, clients and engineers alike share a common curiosity:

Here, "better" doesn't just mean faster calculation speeds. It asks whether the solution is a 'Rational Alternative' one that balances economic feasibility (including construction costs), on-site constructability, and the intrinsic functionality of the facility.

Today, to transform this curiosity from vague expectation into tangible results, I will discuss the specific methodology of 'Optimization' and how we must orchestrate GD to achieve it.

1. Optimization Comes from 'Preparation', Not a 'Button'

Many people mistake Generative Design (GD) for a "magic button" solution where an answer appears instantly. However, in practice, obtaining an alternative that is "better than human" requires rigorous preparation behind the scenes.

Data Standardization: Building robust libraries and templates.

Definition of Rules: Quantifying design logic, such as "Room A must be adjacent to Room B" or "Circulation paths must be minimized."

Algorithm Sophistication: Designing logic to handle complex constraints and resolve conflicts.

Ordering an AI or algorithm to "Optimize" without this foundation is like asking someone to navigate without a map.

Here, we encounter the 'Automation Paradox.' To automate a specific process, the ingredient AI needs most desperately is the 'deep-rooted experience of a seasoned expert' in that field. Ironically, to train AI to reduce human intervention, we must hire the most highly skilled experts who know the process best.

Ultimately, this suggests that 'Optimization' is not about technology replacing humans, but the process of transplanting human experience into technology. This is the "double-edged sword" of optimization we face, and the real reason why engineers must understand this technology.

2. The Power to 'Guide' AI (Methodology)

With the explosive growth of AI technology, we are now moving beyond simple Rule-based systems into an era where AI can reason on its own. However, even as technology evolves, one principle remains unchanged.

Do you remember the [🔑 4 Keywords for Successful Automation] and [🚀 Redefining Methodology] mentioned in the previous newsletter?

When AI analyzes countless requirements and performs computations, guiding that direction is ultimately the engineer's responsibility. If we do not implant clear 'Fitness Functions' and 'Design Objectives' into the algorithm, AI will merely spew out countless—but useless—Garbage Options.

Therefore, what we need right now is not just coding skills, but the time to design the direction for accurate computation and infuse our practical experience into the algorithm.

3. GD Optimize - A Technical Journey from Curiosity to Conviction

Asking simply to "find a good alternative" is the mark of a novice. In this chapter, I will share the specific methodology of moving from the Randomize phase to the Optimize phase, using a sample test case I constructed: [Spatial Layout and Auto-routing].

a. The Limitations of 'Randomize' and Test Scenario Setup

Most GD beginners prefer the 'Randomize' option. I, too, used it frequently in the early exploration stages. It is a method of shuffling input values in hopes of stumbling upon a good alternative by chance.

But does this work for problems with complex, intertwined correlations? Let me introduce the test environment I set up.

📍 Test Logic (Logic Setup):

• Placement Targets: 3 types of spaces (Green, Red, and a list of multiple Blue spaces).
• Placement Rules: I designed an algorithm to recognize the site boundaries and automatically align elements according to the Boundary Vector. I also applied a mandatory Constraint to ensure no space extends beyond these boundaries.

⚠️ The Issue: Since Randomize set Rotation values arbitrarily, a problem arose. As spaces rotated, alternatives were generated where elements slightly encroached upon the boundaries.

In such cases, simply "rolling the dice" repeatedly (Randomize) is inefficient. One could modify the priority of random rotation rules versus boundary constraints or refine the logic. However, what is more important is the standard for judging 'Placement Quality.'

📊 Defined Outputs: To judge 'Efficient Placement' beyond simple arrangement, I established three key metrics:

• L1 (Red ↔ Green): Shortest routing distance between the Red space and Green space.
• L2 (Blue Underground): Auto-routing length connecting multiple Blue spaces via buried piping.
• L3 (Blue ↔ Rack): Shortest piping distance from Blue spaces to a specific 'Rack Section.' (Mandatory connection condition)

💡 Intermediate Conclusion: In projects like my test case, where there is a clear causality—"Piping Length (Cost) changes based on Specific Location (Target)"—it is difficult to find the optimal solution with Randomize alone. Rather than rolling the dice tens of thousands of times, we need an approach that identifies the 'Tendency' of the data and evolves.

This is precisely why we must transition to the Optimize mode.

b. Test Scenario: Why Did We Abandon Shuffle for UV? (UV Tendency)

The core of this test is finding the location where the sum of connecting piping lengths is minimized as three targets (Red, Green, Blue) move on a limited Surface. The most critical technical turning point here is discarding 'Shuffle' and introducing the 'UV Coordinate System'.

🛑 The Trap of Shuffle: An Environment Impossible to Learn From

In the previous Randomize phase, we used the List.Shuffle node to scramble the order of placement points in every run to catch a lucky break. However, in the Optimize phase using Genetic Algorithms, Shuffle is fatal.

"Genetic Algorithms work by breeding the best individuals from each generation." — (Ref: generativedesign.org , Genetic Algorithms)

Genetic algorithms must learn from the results of the previous generation and evolve in a better direction through mutation. However, if the criteria for placement are randomly scrambled in every Run due to Shuffle? From the AI's perspective, it becomes impossible to learn the causality of "which action produced a positive result."

✅ UV Coordinate System: The Start of a 'Game' to Learn Tendency

Therefore, we apply the UV Coordinate System (0~1) as a Variable for the spatial placement method. Now, a clear link is established between the Input and Output.

1. Continuity: "When I increased the U value by 0.1, L3 (piping length) decreased."
2. Identifying Tendency: The GD learns this pattern through repeated Runs.
3. Convergence: Now, GD begins a 'Sophisticated Number Game', finely adjusting the Input Seeds (UV values) to find the minimum value of L3, rather than making random guesses.

Only when this environment is established do we finally qualify to command the AI to "Optimize."

Optimize with the goal of minimizing Outputs L1 and L3 (the shortest distances)

A distinct tendency emerges where the Red and Green spaces actively swap positions to cluster as closely as possible.

If you observe the Optimize process running in real-time, the initial results may look completely random or erratic. However, as the [Generations] progress, the AI learns the tendencies required to meet the objectives and iteratively refines the layout to converge on the optimal solution.

An interesting observation arises from how we configure Set Goals. When L3 was selected as the sole objective, the Input values varied, but significant mutations did not occur, resulting in repetitive and simplistic outcomes.

However, as shown in the result images below, when multiple objectives (e.g., L1 and L3) were set to [Minimize] simultaneously, the AI finally began to explore diverse possibilities, actively generating mutations and converging on the optimal value.

This sample highlights the critical importance of aligning Input and Output settings with your design goals. The human design process inherently contains surprisingly diverse underlying conditions. While humans rely on experience and habit to handle these subconsciously (Tacit Knowledge), computers require explicit, step-by-step guidance for every single factor to successfully replicate the act of "design."

c. 🛠️ The Definitive Guide: GD Optimize Settings

I have summarized the 'Optimization Setting Guide' that you can apply immediately when running GD. (Based on the 'Define Study' window)

① Method

• Selection: Optimize
• Why? This isn't just simple exploration. The AI needs to learn the correlation between input changes (UV coordinates) and output results (Pipe Length) to evolve.

② Inputs (Variable Settings)

• Check Items: target_u/v (Blue, Green, Red) — 6 items in total.
• Setting: Check all as Variable (Range 0 to 1).
• Core Strategy: Give the AI full autonomy. You must tell it, "Move all three colors wherever you want," so it can discover complex interactions like "lowering Red to raise Blue." (Note: Uncheck other inputs like Seed or Density to keep them Constant.)

③ Set Goals

• Core Goal (L3 - Blue Pipe): Must be Minimize.
• Secondary Goals (L1, L2): Recommend Minimize as well.
• Why? If you only tell it to minimize L3, the AI might use a "cheat" by throwing L1 and L2 off the map to achieve that single goal. To find a solution that is "efficient overall, but with L3 being the shortest," the standard practice is to set all to Minimize and filter for L3 in the Explore phase.

④ Generation Settings (Learning Volume) ★ Important The default values (Population 20 / Generations 10) are too low for this problem. With 6 variables (3 sets of UV coordinates), the calculation is complex.

• Population Size: 40 ~ 50 recommended (Need to try diverse attempts in one go).
• Optimize with the goal of minimizing Outputs L1 and L3 (the shortest distances): 30 ~ 40 recommended (You must run at least 30 generations for the AI to gain 'insight' and converge).

d: 🔮 Expected Scenario (The AI's Thought Process)

If you run with these settings, you will witness the following evolutionary process:

• Early Phase (Gen 1~5): The era of chaos. Placements are random, and L3 values fluctuate wildly.
• Mid Phase (Gen 10~20): The AI discovers a pattern (Tendency).
• Late Phase (Gen 30+): Completion of Optimization. Blue sticks tightly to the pipe rack, while Red and Green find optimal spots in the corners without interfering.

Ultimately, GD Optimization is not magic. When the Data (Input) and Goals are clear, the AI simply proves the UV tendencies that we couldn't see.

Conclusion: From Chance (Random) to Certainty (Optimize)

We often ask, "Will AI replace design?" However, the results of this test tell a different story.

The fact that the AI found the optimal solution after 30 generations of evolution is ultimately because there was an engineer's design intent that set the board and defined the rules.

Generative Design is not a magic box. It is a tool that transforms your 'vague curiosity' into 'quantified conviction.'

• If Randomize is the Inspiration that subtly suggests, "This is also possible,"
• Optimize is the Solution that proves, "This is the best," within the logic we defined.

Now, the role of the engineer is shifting from drawing plans to becoming an 'Architect of Algorithms'—one who defines the 'Playground (Inputs & Constraints)' where AI plays and the 'Goal Posts (Goals)' it must reach.

In this issue, we focused on GD Optimize settings designed to identify tendencies in spatial layout. If there are other optimization methods or directions you are struggling with in your projects, please share them in the comments. We will actively reflect your feedback in future newsletters. Also, if you are interested in the sample file used in this test, please leave a comment below. (Note: This example was built using Python nodes.) If there are enough requests from those less familiar with Python, I will prepare a follow-up guide explaining how to achieve the same logic using only basic Nodes.