A Reproducible AI-Assisted Workflow for Concept Development in Stage Art Design and Lighting Optimization through the GSAD Framework

Summary

Here, the authors present a protocol to implement the generative stage art design (GSAD) framework, an AI-driven workflow integrating diffusion models, generative adversarial networks (GANs), and intelligent elephant clan optimization (IECO) to standardize the transition from narrative scripts to optimized 3D visual concepts.

Abstract

Artificial intelligence (AI) is fundamentally reshaping creative design processes by enabling rapid ideation and consistent visualization, particularly within stage art and scenography. However, existing workflows remain heavily dependent on manual sketching and subjective interpretation, limiting scalability and reducing reproducibility across design teams. This gap underscores the need for a structured, AI-assisted generative stage art design (GSAD) framework that integrates deep learning, generative modeling, and optimization techniques to support systematic and repeatable concept development. The core objective of the GSAD framework is to combine diffusion models for initial concept generation, generative adversarial networks (GANs) for texture and lighting refinement, and intelligent elephant clan optimization (IECO) for optimizing stage layout and lighting placement. The Stage Art Design Dataset, comprising 2,500 high-resolution images, includes annotated theater scripts, lighting diagrams, and 3D layouts to facilitate multimodal learning. Experimental evaluation demonstrates substantial improvements in qualitative metrics, including improved semantic alignment between script content and generated visuals, and greater layout optimization efficiency achieved through IECO-driven spatial analysis. Implementing the framework in a Python-based environment resulted in 98.88% predictive accuracy, 26.58 mega floating-point operations per second (MFPOs), and a parameter quantity of 1.08 M. The GSAD framework presents a scalable, reproducible, and technically robust AI-assisted workflow that enhances creative output, ensures visual consistency, and supports efficient concept development in modern stage art design.

Introduction

Stage art design is a complex multidisciplinary field that integrates scenography, lighting, set design, and spatial storytelling^1,2. Historically, the development of stage concepts has relied on human ingenuity expressed through physical models, hand-drawn sketches, mood boards, and iterative brainstorming sessions^3,4. This evolution has been profoundly shaped by the tension between artistic vision and the material constraints of the performance space⁵. As performance requirements grow increasingly sophisticated, the demand for resource-efficient, visually rich, and rapid concept generation has outpaced traditional manual workflows^6,7. The emergence of generative artificial intelligence (GenAI) and large language models (LLMs) offers a transformative path to augment the creative process, facilitating design ideation and co-creation in architecture and entertainment^8,9.

Traditional scenography often faces a semantic gap where the abstract emotions of a theater script struggle to find a precise visual equivalent without extensive trial and error^2,10. Current AI tools in the creative industries allow for the flexible search and recombination of reference photos, yet many lack the structural rigor required for professional stage production^11,12. Furthermore, the subjective nature of aesthetic evaluation often makes it difficult to align machine-generated outputs with specific narrative intent¹³. This shift from experience-driven manual workflows to data-driven human-AI collaboration is becoming a defining characteristic of 21st-century design practice^14,15. The integration of these computational tools necessitates a new form of "practice-based" research that bridges the gap between digital tool development and live performance¹⁶. Recent studies emphasize that AI systems can facilitate brainstorming and broad exploration of alternatives, yet the transition from 2D ideation to 3D optimized realization remains technically challenging⁹.

The generative stage art design (GSAD) framework addressed these shortcomings by establishing a repeatable AI-assisted workflow^17,18. The rationale for this framework stems from the need to automate design components while preserving the artistic integrity of the original narrative. By integrating multimodal AI systems, designers can quickly iterate both visually and verbally, ensuring that lighting and texture refinements are semantically aligned with the dramatic content¹⁹. A critical component of this innovation is the use of the intelligent elephant clan optimization (IECO) algorithm, which draws inspiration from the social behavior of elephant populations to navigate complex spatial constraints in stage layout and lighting placement^20,21. This class of metaheuristic algorithms has proven particularly effective in solving multi-objective design problems where traditional gradient-based methods fail.

In the broader context of literature, AI-powered computer-aided design (CAD) systems have already demonstrated efficiency gains of up to 20% in architectural workflows^22,23. Specifically, AI-driven generative design allows for the exploration of non-standard spatial topologies that would be impossible to conceive manually²⁴. While recent studies over the past two years have successfully utilized conditional GANs (CGANs) to automate 2D planar floorplan generation and architectural spatial layouts, extending these 2D generative principles to the complex, three-dimensional spatial requirements of stage lighting and set design remains critically under-explored. However, traditional deep learning models, such as convolutional neural networks (CNNs), often struggle with the long-range dependencies required to understand complex 3D stage arrangements^25,26. The GSAD framework overcomes these limitations by utilizing vision transformers (ViT) to extract global visual features and bidirectional encoder representations from transformers (BERT) encoders to capture narrative semantics^27,28. As transformers capture the global context of a design scene more effectively than local filters, these models provide a more holistic representation of spatial relationships²⁹. This dual-stream feature extraction ensures that the resulting stage designs are not only aesthetically consistent but also narratively relevant.

The advantages of the GSAD approach over alternative techniques, such as the deep convolutional embedding attention mechanism (DL-CBAM), are multifaceted^30,31. While previous models improved recognition accuracy on motion detection datasets, these previous models often required higher computational overhead and lacked the spatial optimization capabilities found in GSAD. By contrast, GSAD achieves a 98.88% accuracy rate while maintaining a parameter count of 1.08 M, striking an optimal balance between model complexity and predictive capability^32,33. Such efficiency is critical for real-time creative tools, as demonstrated by the success of mobile-scale architectures in specialized design tasks³⁴. This makes the framework highly appropriate for professional theater designers, digital art creators, and architectural engineering educators who require high-fidelity, reproducible visualizations³⁵.

Furthermore, the integration of GANs for texture and lighting refinement addresses the limitations of standard diffusion models, which can sometimes produce "stylistically flat" outputs^36,37. By utilizing a style-based generator, the framework can synthesize high-resolution textures that exhibit both variety and artistic depth³⁸. By employing adversarial training, the GSAD framework ensures that artistic details and visual realism are enhanced to professional standards³⁹. This approach also mitigates ethical concerns regarding authorship and bias by providing a controllable, "designer-in-the-loop" collaboration platform^40,41. The ultimate goal is not to replace human intuition but to provide a collaborative partner that extends the creative agency of the artist⁴². As the field moves toward more immersive and digitally integrated performances, the need for robust, AI-native design protocols will only increase⁴³. The following protocol provides the technical roadmap for implementing the GSAD framework, ensuring that modern stage art design remains both imaginative and reproducible.

Protocol

1. Computational environment and data acquisition

1. System setup (Ensure that all computational steps are performed on a workstation with sufficient GPU capabilities for deep learning tasks).
   1. Set up a Python programming environment on a workstation with sufficient GPU capabilities for deep learning simulation to serve as the foundation for the GSAD framework in Figure 1.
   2. Install the necessary dependencies, specifically configuring Python (version 3.8 or higher) and PyTorch (version 2.0.1 or higher), along with standard libraries required for deep learning simulation to ensure consistent execution.
   3. Configure the memory management system to handle high-resolution image processing.
2. Dataset collection
   1. Access the "Stage Art Design Dataset" from the Kaggle repository to acquire the raw data.
      NOTE: The images comprise publicly licensed materials and original conceptual designs to comply with copyright standards.
   2. Download the dataset containing 2,500 high-resolution JPG images and associated metadata.
   3. Verify the file structure, ensuring it contains 2,500 high-resolution images categorized by varying stage types, performance styles, and cultural backgrounds to prevent stylistic bias.
   4. Apply standardized data annotation rules before training. Map semantic script elements (e.g., 'moody lighting') directly to specific hex color codes, and annotate lighting parameters using standardized 3D coordinate bounding boxes (x, y, z) to ensure consistent semantic-to-visual mapping.

2. Data preprocessing

1. Image normalization
   1. Perform Min-Max Normalization on the raw image data to scale all feature values uniformly and improve data stability.
   2. Apply Equation 1 to transform the original feature values (M) into normalized values (M_norm):
         (1)
      Where M_norm represents the normalized value, M is the original feature value, and min(M) and max(M) are the minimum and maximum values of the dataset, respectively.
   3. Confirm that the convergence and feature representation quality have improved by comparing the original images with the preprocessed images, as shown in Figure 2.
2. Text semantic cleaning
   1. Process the textual scripts associated with the stage designs to remove "noise" that could confuse the AI.
   2. Eliminate misspellings, extraneous symbols, punctuation, stop words, and inconsistent formatting.
   3. Standardize the text case (lowercase) to ensure semantic consistency¹³. Refer to Table 1 for examples of the semantic cleaning process.
3. Tokenization
   1. Divide the cleaned text into smaller, manageable units called "tokens" (words or characters).
   2. Ensure that undesirable components are removed during this step to facilitate precise conceptual analysis by the AI models.

3. Feature extraction (GSAD framework)

1. Visual feature extraction using vision transformer (ViT)
   1. Initialize the ViT architecture as depicted in Figure 3 to process the 3D stage art images.
   2. Patch Embedding: Divide the input image into fixed-size patches (visual words) to reduce dimensionality.
   3. Construct the visual tokens (u) and add positional embeddings (u') using Equations 2, 3, and 4:
        (2)
      (3)
      (4)
      Where  represents the projected patch token, k is the flattened input image patch, w_c is the linear projection weight matrix, u is the unrolled patch sequence, is the positional embedding added to retain spatial information, and d_k is the added classification token.
      NOTE: Refer to Table 2 for a detailed description of the ViT variables such as patch size (O) and projection dimension (d).
   4. Transformer Encoder: Feed the processed tokens into the Transformer Encoder. Use self-attention mechanisms to identify correlations between different image patches (e.g., lighting vs. backdrop).
   5. Apply normalization and activation functions using Equations 5 through 8 to generate the final feature map:
          (5)
         (6)
         (7)
         (8)
      Where u' is the normalized token sequence, RL represents the self-attention weights derived from queries R and L^SC keys (with scaling factor SC), w is the attention output computed using U values and linear (w) and GeLU (w) denote the transformations within the feed-forward network.
   6. Visualize the output feature map, which highlights key design elements and reduces noise, as shown in Figure 4.
2. Textual feature extraction using BERT
   1. Initialize the BERT (bidirectional encoder representations from transformers) model to process the stage scripts.
   2. Convert the natural language scripts into continuous vectors using word embedding to capture semantic meaning. Refer to Table 3 for the feature extraction structure.
   3. Combine token embeddings, segment embeddings, and positional embeddings as inputs to the encoder.
   4. Execute the transformer encoder unit steps (Multi-Head Attention, Add & Norm, Feed Forward) as illustrated in Figure 5 to create contextualized token sequences.
   5. Concatenate the output contextualized token sequences (from BERT) with the visual feature maps (from ViT). Feed this fused multimodal data as the direct conditional input vector into the GAN refinement module in Step 4.
3. Initial concept generation
   1. Input the extracted textual features (from BERT) and visual features (from ViT) into the Diffusion Model.
   2. Generate initial 2D conceptual stage designs based on the integrated multimodal features.
   3. Pass these initial 2D concepts as base inputs to the Generative Adversarial Network (GAN) in Step 4 for further texture and lighting refinement.

4. Texture and lighting refinement using GAN

1. Generative adversarial network (GAN) Setup
   1. Construct the GSAD refinement module consisting of a Generator (H) and a Discriminator (C) as shown in Figure 6.
   2. Configure the Discriminator to distinguish between real stage images and generated ones, and the Generator to create realistic textures and lighting.
2. Training and optimization
   1. Define the objective function for the conditional GAN (CGAN) using Equation 9 to introduce condition variables (y) for better stability:
      (9)
      ​Where x represents the input stage design condition, y is the real target image, z represents the random noise vector, G is the generator, and D is the discriminator.
   2. For low-light image enhancement, apply Equation 10 to optimize the light-enhanced image output (H_low):
      (10)
      Where U(C, H) represents the objective value function, H is the Generator network, C is the Discriminator (Critic) network, w represents real data sampled from the distribution O_data, y is the input condition, z is the conditional noise variable, qha represents the real high-quality stage images, and H_Low denotes the generator's output from low-light inputs.
   3. Apply adaptive modulation to the feature transformation using Equation 11:
      (11)
      Where hE_i(w) represents the feature map at layer i, AM denotes the adaptive modulation function with learned parameters α_i and β_i,  is the layer weight, and is the bias.
   4. Implement skip connections and pooling layers in the generative network using Equations 12 and 13 to preserve spatial details:
        (12)
      (13)
      Where Skip(w) denotes the features preserved via skip connections from the convolutional blocks hE, and H_jw represents the output feature map after max pooling at the encoder stages (0 < j ≤ 3).
3. Image reconstruction
   1. Perform up-sampling and concatenation in the decoding phase using Equations 14 and 15:
        (14)
      (15)
      Where up(w) represents the up-sampled features concatenated with the corresponding skip(w)  connections, v°H_j-1(w) denotes the combined input to the decoder stages (4 < j  ≤7), and h_out(w) is the final refined stage image generated via the sigmoid activation function, utilizing the final layer's weights X₈ and bias a₈.
   2. Generate the final refined image output using the sigmoid activation function in Equation 16:
        (16)
   3. Follow the iterative training procedure outlined in Algorithm 1 (Pseudocode of GAN-Texture Lighting Refinement).

Algorithm 1: Pseudocode of GAN-texture lighting refinement
Input: Low-light stage art image H(low), number of training iterations N, batch size B
Output: Enhanced image H enhanced
1: Initialize Generator with parameters H
2: Initialize Discriminator with parameters C
3: learning rates
4: conditional variable z (optional for GAN)
5: Adaptive modulation parameters α_i and β_i
6: Skip connections list skip(w)
7: for iteration = 1 to F do
Discriminator Training
8: Sample a batch of real images
9: Sample a batch of noise/random low-light images
10: If CGAN, append the conditional variable z to the inputs
Generate fake images
Compute discriminator loss
Update discriminator parameters
Generator Training
Generate fake images
Compute generator loss
Update generator parameters
for j = 1 to 3 do

end for
11: Bottleneck convolution
12: Decoder/upsampling
for j = 5 to 7 do

end for
13: Output layer

14: end for
15: return H and C enhanced

5. Stage layout optimization (IECO)

1. IECO initialization
   1. Initialize the intelligent elephant clan optimization (IECO) algorithm to optimize the spatial arrangement of stage elements.
   2. Define the population of "elephants" (representing potential design solutions) and the associated clans. Refer to Figure 7 for the IECO flowchart.
2. Movement and evolution
   1. Calculate the independent movement of each elephant to explore the design space using Equations 17 and 18:
      (17)
      (18)
      Where represents the movement increment calculated using a random distribution factor r bounded between a minimum () and maximum () step size, and is the updated independent spatial position of the elephant.
   2. Reduce the movement range over time using Equation 19 to facilitate convergence as the solution improves.
   3. Matriarch Update: Update the position of the clan leader (matriarch) towards the global best solution using Equation 20:
      (19)
      Where represents the newly updated position of the matriarch, is the weighted current position, is the global best layout solution found so far, and β acts as a scale factor controlling the influence of the best solution.
   4. Male elephant update: Update male elephant positions relative to the clan center using Equations 21 and 22:
      (20)
      (21)
      Where   represents the updated position of the male elephant, is its current reference position, XCenter_js denotes the central position of the family clan calculated from all male members, M_d is the total number of male family members in the clan, and r and p are random distribution probabilities guiding the movement toward the clan center.
3. Population replacement
   1. Calculate Clan Center: First, evaluate the fitness of the layout solutions. Then, compute the central position () of each family clan using Equation 22, where M_f is the number of family members:
      (22)
   2. Adult elephant replacement: To improve convergence speed, replace inferior "adult elephants" (solutions) with superior ones generated from the clan center. Apply Equation 23 to calculate the new position ():
       (23)
      Where represents the central position of the adult elephants, M_f is the number of adult family members, denotes the newly calculated replacement position for an inferior adult elephant, is the reference position being replaced, and and represent superior positions within the clan used to guide the replacement process to accelerate convergence.
      (NOTE: Here, and represent intermediate weighted positions used to guide the replacement.)
   3. Young elephant replacement: To prevent local optima and preserve diversity, replace the weakest "young elephants" (). Update the positions of these elements positions using Equation 24:
      (24)
      Where denotes the current position of the weakest young elephant, and is its newly generated position. This replacement is driven by a random factor r and the superior clan members to prevent the optimization process from falling into local optima and to preserve spatial diversity.
   4. Termination: Merge the updated clans, recalculate fitness, and repeat the optimization loop until the termination criteria are met as detailed in Algorithm 2.

Algorithm 2: Pseudocode of IECO for optimizing stage layout and lighting placement
Input: Population size M:, max iterations X^max:
Output: Optimal stage layout & lighting placement
Initialize elephant clans with random positions (stage layout + lighting parameters)
Evaluate the fitness of each elephant
For t = 1 to X^max:
For each clan:
Identify matriarch (best elephant), male elephants, and young elephant independent Movement
For each elephant:
Compute movement increment ΔX^max
Update independent position
Reduce movement range over iterations
Matriarch Update

For each matriarch:
Update position toward global best
Male Elephant Update

For each male elephant
Compute the clan center and update the position toward the center with adult replacement

Compute the clan center of adults
Replace inferior adults with superior of small Elephant Replacement

Replace the weakest young elephants to preserve diversity
Merge updated clans, recalculate the fitness of all elephants, and update the global best solution
Return the global best stage layout & lighting arrangement

Results

The experimental set-up and analytical workflow, as outlined in Figures 1 through 7 and Tables 1 through 3, provided a robust foundation for the GSAD framework's data preprocessing, feature extraction, and layout optimization.

Model training dynamics and convergence
The experimental evaluation of the GSAD framework yielded significant quantitative and qualitative data regarding its efficacy in stage art de...

Discussion

The primary contribution of this study is the development of a reproducible AI-assisted workflow that standardizes the conceptualization of stage art design^2,10. By focusing on the GSAD framework, the authors provide a structured methodology that overcomes the limitations of manual ideation and subjective interpretation common in traditional scenography. A critical step within the protocol is the integration of GANs for texture and lighting refinement, as it ensu...

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
BERT (Bidirectional Encoder Representations from Transformers)	Hugging Face Transformers	Open Source
Python Programming Language	Python Software Foundation	Version 3.8 or higher
PyTorch Deep Learning Framework	Linux Foundation / Meta AI	Version 2.0.1 or higher
Stage Art Design Dataset	Kaggle Repository	Publicly Accessible
Vision Transformer (ViT) Implementation	PyTorch Image Models (timm)	Open Source
Workstation with GPU capabilities	N/A (Standard Hardware)	N/A