Datasets:

MarkrAI

/

AutoRAG-evaluation-2024-LLM-paper-v1

like 8

0ed40445-9196-4b9f-b222-19e7ac87ddb1

# Rules | | | | | | = | | | | | | | 3 | 85.5% | 78.5% | | | | | > | | | | | | | = | | | | | | | 4 | 84.1% | 77.7% | | | |

09e77d98-0629-47c9-8a2f-4568b5f8fbdc

# Rules | | | | | 4 | 84.1% | 77.7% | | | | | > | | | | | | | = | | | | | | | 5 | 80.4% | 71.7% | | | | | > | | | | | | | = |

75c692ea-1ed2-4b0f-99e5-33593e152a24

# Rules | | | > | | | | | | | = | | | | | | | 6 | 69.4% | 63.3% | | | | | (a) GPT-4-turbo. | (b) PaLM 2-L. | | | | | | # Steps | Init Acc | Reorder Acc | # Steps | Init Acc | Reorder Acc | | > | | | | | |

3e79f9a6-b441-4e86-90bf-b45e6c2e622d

# Rules Init Acc | Reorder Acc | # Steps | Init Acc | Reorder Acc | | > | | | | | | | = | | | | | | | 2 | 80.5% | 69.1% | | | | | > | | | | | | | = | | | | | | | 3 | 79.

a7be759d-63d2-4a8a-81f6-4191c6fd1d65

# Rules | | = | | | | | | | 3 | 79.0% | 68.0% | | | | | > | | | | | | | = | | | | | | | 4 | 80.3% | 66.2% | | | | | > | |

76a57fc7-fe3a-4624-bf42-9324cc06938b

# Rules | 80.3% | 66.2% | | | | | > | | | | | | | = | | | | | | | 5 | 80.4% | 59.8% | | | | | > | | | | | | | = | | | |

018f247c-52b5-4b54-984f-2437dd75c47d

# Rules | | | | | | = | | | | | | | 6 | 71.4% | 55.1% | | | | | > | | | | | | | = | | | | | | | 2 | 67.3% | 51.8% | | |

067e2800-c685-467d-af11-cbac7af1abc2

# Rules | | | | | 2 | 67.3% | 51.8% | | | | | > | | | | | | | = | | | | | | | 3 | 66.5% | 51.0% | | | | | > | | | | | | | =

d84306e9-b01f-4316-bf21-6a2174070360

# Rules | | | > | | | | | | | = | | | | | | | 4 | 63.1% | 47.8% | | | | | > | | | | | | | = | | | | | | | 5 | 58.7% |

064518a5-9b00-4f6b-86ff-5f61d090fe0d

# Rules | = | | | | | | | 5 | 58.7% | 39.1% | | | | | > | | | | | | | = | | | | | | | 6 | 42.9% | 26.5% | | | | | (c) Gemini Pro. | (d) GPT-3.5-turbo. | | |

bbf6d867-627b-4d6d-bded-de280243812a

# Rules 9% | 26.5% | | | | | (c) Gemini Pro. | (d) GPT-3.5-turbo. | | | | | | # Sentences | Init Acc | Reorder Acc | # Sentences | Init Acc | Reorder Acc | |------------------|---------------|---------------|---------------|------------|---------------| | > | | | | | | | = | | | | | | | 5 | 94.1% | 85.0% | | | | | > | |

bbb20204-fa5e-4816-8343-78d07f4be972

# Rules | 5 | 94.1% | 85.0% | | | | | > | | | | | | | = | | | | | | | 6 | 89.7% | 81.6% | | | | | > | | | | | | | = | | | |

30b62975-188d-4436-8b7a-5e2f9c71505d

# Rules | | | | | | = | | | | | | | 7 | 86.4% | 68.2% | | | | | > | | | | | | | = | | | | | | | 5 | 86.4% | 79.5% | | | | | >

94288dc4-1ee7-4841-81b6-e36ee8252515

# Rules | | | | 5 | 86.4% | 79.5% | | | | | > | | | | | | | = | | | | | | | 6 | 78.2% | 69.0% | | | | | > | | | | | | | = |

aad33352-ae74-4750-a897-23f7123b1152

# Rules | | > | | | | | | | = | | | | | | | 7 | 77.3% | 72.7% | | | | | (a) GPT-4-turbo. | (b) PaLM 2-L. | | | | | | # Sentences | Init Acc | Reorder Acc | # Sentences | Init Acc | Reorder Acc | | > | | | | | | | = |

4c09beba-da5c-4a7b-893b-c4e213ae6991

# Rules | # Sentences | Init Acc | Reorder Acc | | > | | | | | | | = | | | | | | | 5 | 80.5% | 69.1% | | | | | > | | | | | | | = | | | | | | | 6 | 80.5% | 60.9%

f786e758-cd1f-49c7-b7a1-cc4e5304f03f

# Rules | | | | | | | 6 | 80.5% | 60.9% | | | | | > | | | | | | | = | | | | | | | 7 | 72.7% | 54.5% | | | | | > | | | |

6d55741f-2443-40a3-9c5d-5973e00f4ae8

# Rules | 54.5% | | | | | > | | | | | | | = | | | | | | | 5 | 67.3% | 51.8% | | | | | > | | | | | | | = | | | | | | | 6

f189e75a-1913-409c-8556-3d97268eee65

# Rules | | | | = | | | | | | | 6 | 62.1% | 46.0% | | | | | > | | | | | | | = | | | | | | | 7 | 54.5% | 36.4% | | | | (c) Gemini Pro. (d) GPT-3.5-turbo.

babe4da5-5d27-4de1-945e-134347d186ec

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference Taesu Kim Jongho Lee Daehyun Ahn Sarang Kim Jiwoong Choi Minkyu Kim Hyungjun Kim SqueezeBits Inc.

6f2b34ce-6897-445b-82aa-366638a91947

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## Abstract We introduce QUICK, a group of novel optimized CUDA kernels for the efficient inference of quantized Large Language Models (LLMs). QUICK addresses the shared memory bank-conflict problem of state-of-the-art mixed precision matrix multiplication kernels. Our method interleaves the quantized weight matrices of LLMs offline to skip the shared memory write-back after the dequantization. We demonstrate up to 1.91x speedup over existing kernels of AutoAWQ on larger batches and up to 1.94x throughput gain on representative LLM models on various NVIDIA GPU devices. Code: https://github.com/SqueezeBits/QUICK

cae24cca-e03d-49df-890d-3a1581560948

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 1 Introduction Enhancing the efficiency of Large Language Models (LLMs) has become increasingly crucial due to the escalating demand for deploying state-of-the-art models in real-world scenarios [2, 8, 9, 15, 16]. The improved performance of LLMs is attributed to their growing size, characterized by a trend toward larger models with parameter counts exceeding several hundred billion. However, the substantial size of these models has necessitated the adoption of model compression techniques such as quantization and pruning [1, 4, 5, 11, 12, 17]. Among these techniques, weight-only quantization has garnered significant attention for its potential to compress the memory footprint of LLMs [6, 11, 12]. This approach aims to reduce model size and accelerate computation by quantizing weights to smaller bit sizes while retaining activation tensors at higher precision. Consequently, there is a growing need for fast mixed-precision General Matrix Multiplication (GEMM) kernels to support such operations. Despite these advancements, existing open-source kernels for mixed-precision GEMM have demonstrated limitations in throughput, primarily due to the overhead associated with weight dequantization. Analysis of these kernels has revealed shared memory write-back bank conflicts during the dequantization process as a significant bottleneck. Leveraging this insight, we introduce QUICK, a solution designed to mitigate shared memory bank conflicts by reordering weight matrices offline.

1a1625c6-89ec-4cdc-bdb9-390942fe73d7

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 2 Preliminary 2.1 Quantization And Dequantization Quantization involves the reduction of precision or range of a continuous variable to a discrete set of values. This process is commonly employed to decrease the bit precision of tensors, thereby reducing the memory footprint of Neural Network models. When supported by appropriate computation kernels, quantization enables acceleration of the models with low-precision computations. Given that LLMs typically encompass billions of parameters, researchers have explored quantization as a means to reduce memory usage and improve inference efficiency. Specifically, weight-only quantization focuses solely on quantizing the weights of the model while maintaining activations at a higher precision, such as 16-bit floating point [6, 11, 12]. This strategy effectively reduces memory requirements by representing weights with fewer bits while retaining activation tensors in floating point precision. Weight-only quantization is generally recognized for dramatically reducing the memory requirements and preserving the performance of LLMs. However, since activations remain in higher precision, weights must undergo dequantization back to higher precision before being multiplied by activations during inference. This dequantization process has minimal impact on inference efficiency when the batch size is 1 since the computation is mainly memory-bounded in such case. However, for larger batch sizes, GEMMs are mostly computation-bounded, where mixed-precision GEMM operations become slower than their floating-point counterparts due to the overhead associated with dequantization.

915aae8a-773f-4f3e-aacc-ed6bcbaca048

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 2.2 Gemm Kernel Using Tensor Core A substantial portion of the computational workload associated with LLMs primarily comprises GEMMs. Optimizing GEMM operations plays a pivotal role in enhancing the overall efficiency of LLM inference. Particularly on NVIDIA GPUs, GEMM computation has relied on the tiling strategy, which is widely employed to maximize memory reuse through the utilization of shared memory, thereby achieving a more favorable compute-memory ratio. Recent advancements in NVIDIA GPUs have showcased significant performance improvements in GEMM computation through the utilization of Tensor Cores. These Tensor Core-based GEMMs leverage warp-level PTX instructions, namely *ldmatrix* and *mma*. The *ldmatrix* instruction efficiently loads multiple matrices across all threads within a warp from shared memory into designated registers. As illustrated in Figure 1, this loading pattern assigns small fragments of a row to each thread, facilitating warp-level matrix multiply-accumulation using the subsequent *mma* instruction. The *mma* instruction, following the *ldmatrix* operation, executes the matrix multiply-accumulate operation at the warp level. This instruction performs the multiply-accumulate operation on matrices, requiring specific data patterns for each row of the multiplicands, as well as the accumulators. As previously described, loading matrices into each thread from shared memory is efficiently achieved using the *ldmatrix* instruction. Tensor Core-based GEMM computation entails repetitive calls to these instructions, relying on shared memory to rearrange input tensors to align with the data access pattern required by the mma instruction. Compared to CUDA Core-based GEMM computation, Tensor Core-based approaches are renowned for achieving significantly higher throughput.

a8598208-8784-4a5c-a904-09b39f60f776

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 2.3 Mixed Precision Gemm Kernel Mixed precision GEMM kernels find widespread application in the inference phase of weight-only quantized LLMs, owing to the inherent difference in bit precision between activation tensors and weight tensors. When employing weight-only quantization, it becomes necessary to dequantize the quantized weights before executing the matrix multiplication operation within the GEMM kernel, as recent NVIDIA GPUs' Tensor Cores do not inherently support mixed-precision GEMMs. Consequently, numerous implementations of efficient mixed-precision GEMM kernels leveraging Tensor Cores adopt parallel dequantization of quantized weights. Typically, these kernels adhere to a common workflow for weight dequantization, as depicted in Figure 2. They fetch quantized and packed weights from global memory to registers, dequantize weights using CUDA cores, and then write the dequantized weights back to shared memory for the following *ldmatrix* instruction. The dequantization process employing CUDA cores involves bitwise AND operations to extract target sub-byte weights, bitwise SHIFT operations to rearrange bit positions, and parallel half-precision additions and multiplications to apply zero points and scales. Parallel dequantization involves expanding quantized weights to larger bit sizes. For example, from 128-bit weight vectors consisting of 32 4-bit weights, dequantization produces 512-bit weight vectors containing 32 16-bit floating-point weights. This results in quantized weights that are four times larger compared to their full precision counterparts under same bandwidth requirement, increasing the burden of shared memory write-back. The augmented quantity of weights exacerbates shared memory bank conflicts during the write-back process of dequantized weights. Given that the *ldmatrix* instruction requires the weight matrices to be fully visible on shared memory, this significantly harms the end-to-end latency of mixed-precision matrix multiplication. Benchmarks conducted on state-of-the-art mixed-precision GEMM kernels using NVIDIA's Nsight Compute [14] indicate a notable prevalence of shared memory bank conflicts stemming from the write-back after dequantization, as depicted in Figure 3. Consequently, mixed-precision GEMM kernels often struggle to achieve enhanced throughput compared to half-precision GEMM kernels, particularly with larger batch sizes.

97c249ef-013f-4bdf-8904-3e79fea733c6

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 3 Avoiding Bank Conflict In this section, we propose QUICK, a novel way to remove the shared memory write-back bank conflicts of mixed precision matrix multiplication. To alleviate these conflicts effectively, our proposal involves reordering the quantized weight matrix offline to align with the load pattern required by the mma instruction without the *ldmatrix* instruction.

852a638d-a703-4834-b88d-45913f9b33fa

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 3.1 Skipping Shared Memory Write-Back During Mixed Precision Gemm As previously discussed, state-of-the-art mixed precision GEMM kernels rely on a specific sequence involving dequantization, shared memory write-back, *ldmatrix*, and *mma*. The *ldmatrix* instruction is responsible for loading operands for the subsequent *mma* instruction, adhering to a designated pattern among the threads within a warp. With this instruction, each thread in a warp loads fragments of a row, as depicted in Figure 1. Using the *ldmatrix* instruction to load GEMM operands to registers is a straightforward approach for floating-point GEMM kernels because transferring data from global memory to shared memory can be efficiently executed. From the Ampere architecture and beyond, asynchronous CUDA memory copy supports pipelining the *mma* instruction with global memory load, thereby enhancing the performance of GEMM kernels. This enhancement occurs as the effective memory load overhead can be reduced to the copy from shared memory to registers. However, in the case of mixed precision GEMM, there exists a noticeable overhead due to shared memory write-back. This is because the loaded quantized weights must be dequantized using CUDA cores, and the resulting dequantized weights in registers must then be written back to shared memory to serve as operands for the *ldmatrix* instruction. This overhead is further exacerbated by numerous shared memory bank-conflict stalls, which ultimately degrade the throughput of kernels. From the data loading pattern of the *ldmatrix* instruction, we observe that this pattern can be preapplied to the original data since the weight data remains static. Considering the static nature of weight matrices throughout deployment, it becomes feasible to bypass the *ldmatrix* instruction for quantized weight matrices via suitable reordering. In this scenario, a direct load from global memory to registers proves sufficient to meet the data pattern requirements essential for the mma operation. Consequently, we opt to rearrange the quantized weight matrices and bypass the ldmatrix instruction prior to the *mma* operation. Through the optimization of both the weight pattern and the associated computing kernel, we can successfully eliminate shared memory write-back bank conflicts, consequently improving the end-to-end latency of mixed precision GEMM. Importantly, since the total amount of quantized weights to be read from DRAM remains the same, the overall memory bandwidth requirement can be maintained at the same level.

ddbc2aee-852f-43e0-8e8e-cf58b67ea4a3

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 3.2 Interleaving Data Pattern The interleaving pattern of the quantized weight matrices corresponds to the data loading pattern of the *ldmatrix* instruction. To bypass the *ldmatrix.sync.aligned.m8n8* instruction of the quantized weight matrices, we rearrange the weights following the data loading pattern of the instruction, as illustrated in Figure 4. Since the CUDA kernels of QUICK rely on the *mma.m16n8k16* with half-precision, we further devise the reordering pattern to group quantized weights for two 8×8 weight blocks. This rearrangement pattern enhances the memory locality of quantized weights and eliminates shared memory write-back bank conflicts. Moreover, QUICK implements an additional rearrangement of quantized weights based on the pattern of the dequantization kernel. QUICK utilizes a modified version of the parallel dequantization kernel from FasterTransformer [13]. The kernel introduces a simple interleaved pattern, as shown in Figure 5. To mitigate the overhead associated with rearranging the dequantized weights and further enhance data locality, an additional rearrangement pattern ensuring a sequential weight pattern after dequantization is applied. Both weight rearrangement patterns avoid shared memory write-backs and ensure the sequential weight pattern after dequantization can be applied concurrently, as the patterns are independent. QUICK integrates both patterns as described in Figure 6, achieving optimal end-to-end latency while reducing shared memory bank conflicts and enhancing data locality.

08b4318c-c60d-4338-a186-e8a8a68e322a

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 3.3 Tile Size Optimization Optimizing the number of active warps per multiprocessor plays an important role in improving the performance of computation kernels. Achieving higher number of active warps per multiprocessor can be beneficial as it facilitates the interleaving of warps and enables better latency hiding. Several factors, including the number of required registers and the size of shared memory, can limit the number of active warps per multiprocessor. In addition to improving throughput by eliminating shared memory write-back bank conflicts, QUICK leverages the reduced shared memory usage within the computation kernel to further enhance computational throughput. Previous mixed precision GEMM kernels have utilized shared memory to store both activation and weight matrices, with benchmarks indicating that the shared memory size per warp exerts the greatest pressure on the number of active warps per multiprocessor. In contrast, QUICK avoids allocating shared memory for the weight matrices, thereby shifting the pressure from shared memory size to the number of required registers. Leveraging this opportunity, QUICK increases the tile size of mixed precision GEMM, further reducing DRAM accesses while maintaining similar theoretical multiprocessor occupancy. With increased number of activation values processed per computation tile, weight matrices need to be loaded less frequently from DRAM. This optimization results in a further increase in throughput for larger batch sizes, particularly those exceeding 32.

b17c9818-e65b-4579-a51d-55fdbd0368da

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 4 Experimental Results In this section, we evaluate the performance improvement provided by QUICK in comparison to both the baseline fp16 kernel and AutoAWQ-Kernel. We first compare the efficiency of a single matrix multiplication, followed by the comparison of end-to-end token generation throughput across various LLMs. Furthermore, we also present the benchmark results showcasing the integration of QUICK with the vLLM [10] framework. Note that all experiments involving AutoAWQ-Kernel and QUICK are based on 4-bit weight-only quantization.

0c848571-2271-4838-a126-68e785f3c9c5

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 4.1 Matrix Multiplication Performance We initially evaluate the performance of QUICK with unit matrix multiplications, with the matrix multiplication dimensions set to *batch size* × 8192 × 8192(M × N × K). Figure 7 illustrates the performance of different kernels in terms of Tera-operations per second (TOPS). Notably, QUICK demonstrates superior performance compared to previous implementations such as AutoAWQ-Kernel [7], particularly evident with larger batch sizes. For instance, when the batch size is 256, QUICK demonstrates a speed improvement of 1.33∼1.91 times compared to AutoAWQ-Kernel. With larger batch sizes, the token generation process tends to become computation-bounded, making the overhead from the dequantization process more significant. As a result, AutoAWQ-Kernel tends to show prominently degraded throughput compared to fp16 kernel when the batch size approaches 128. On the other hand, QUICK, by reducing shared memory bank conflict problem, occasionally demonstrates faster speeds than the fp16 kernel, even with larger batch sizes like 128.

e08478dc-8a9b-443b-ac91-ed284e7accea

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 4.2 End-To-End Throughput To illustrate the advantages of QUICK in the inference of quantized LLMs, we further evaluate the end-to-end token generation speed of various LLMs. We conducted tests on four different models across four different GPUs: Mistral-7B [8] on RTX 4090, Vicuna-13B [3] on RTX A6000, LLaMA- 2-13B [15] on L40, and LLaMA-33B [16] on A100. The token generation throughput at the decoding stage was measured in terms of tokens per second. As the batch size increases, the memory required to store activations and the KV cache also increases, leading to Out-of-Memory (OOM) problem. For example, when running Mistral-7B on an RTX 4090 GPU, it is impossible to run the fp16 model with batch size of 256 due to the OOM problem. Applying weight-only quantization reduces the amount of memory used to store weights, thereby enabling usage of more memory for storing activations and the KV cache. Consequently, larger batch inference becomes possible. Even with the same RTX 4090 GPU, a 4-bit quantized Mistral-7B can be operated at a batch size of 256. Moreover, QUICK can achieve up to 1.94 times higher throughput compared to AutoAWQ-Kernel. Similar to the Matrix Multiplication performance mentioned in the previous section, QUICK demonstrates superior performance over the fp16 case even at larger batch sizes.

d341c2c1-6415-4f08-bbe3-43a8e73e0f86

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 4.3 Vllm Throughput In this section, we present the throughput benchmark results of our initial version of vLLM [10] integrated with QUICK (Table 1). Benchmarks were done using the throughput benchmark script and the recommended dataset within the vLLM [10] framework. Two models, Vicuna-13B [3] and Llama-2-70B [15], were benchmarked to demonstrate scenarios where the full precision model could and could not be loaded onto the GPU device. vLLM with QUICK demonstrated a throughput gain of 27-29% compared to the AWQ implementation in vLLM, and a 33% throughput gain compared to the full precision model.

ceaec2ae-839f-4337-8855-b1cc34fdb60d

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 5 Limitation And Future Work While the proposed QUICK technique has demonstrated enhanced throughput at larger batch sizes, such as 128, enabling the utilization of weight-only quantization for larger batch sizes, it still falls short of the efficiency achieved in the fp16 case, particularly at even larger batch sizes (> 512). Model FP16 AWQ QUICK Speedup Speedup (tokens/s) (tokens/s) (tokens/s) (FP16) (AWQ) Vicuna-13B 985.2 1030.4 1308.6 33% 27% Llama-2-70B OOM 224.3 290.2 - 29% Therefore, further research is needed to optimize the dequantization process further and enhance the efficiency of mixed precision GEMM kernels under such circumstances. For instance, future works could focus on exploring methods to leverage the unused shared memory budget resulting from the direct dequantization of quantized weights at registers. Additional software optimizations, such as automated split-k parameter optimization, could be explored further to ensure optimal throughput considering the model, generation configuration, and the GPU device.

2a7919c0-6d73-4e04-9c75-085710192355

# Quick: Quantization-Aware Interleaving And Conflict-Free Kernel For Efficient Llm Inference ## 6 Conclusion In this work, we introduce QUICK, a suite of optimized CUDA kernels designed for efficient execution of mixed precision GEMM operations. Previous implementations exhibited advantages only for small batch sizes due to shared memory bank conflict problem. QUICK, however, overcomes this limitation by employing an interleaving data pattern, which enables superior throughput over fp16 kernels even for larger batch sizes. Furthermore, QUICK has demonstrated enhanced end-to-end token generation throughput in various LLM inference frameworks, including AutoAWQ and vLLM.

c4d7d26a-9a20-4e2f-9d32-972a4b4aefcb

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem Davor Hafnar1 and Jure Demˇsar1,2 1Faculty of Computer and Information Science, University of Ljubljana, Ljubljana, Slovenia 2Department of Psychology, Faculty of Arts, University of Ljubljana, Ljubljana, Slovenia Abstract—Procedural content generation uses algorithmic techniques to create large amounts of new content for games at much lower production costs. In newer approaches, procedural content generation utilizes machine learning. However, these methods usually require expensive collection of large amounts of data, as well as the development and training of fairly complex learning models, which can be both extremely time-consuming and expensive. The core of our research is to explore whether we can lower the barrier to the use of personalized procedural content generation through a more practical and generalizable approach with large language models. Matching game content with player preferences benefits both players, who enjoy the game more, and developers, who increasingly depend on players enjoying the game before being able to monetize it. Therefore, this paper presents a novel approach to achieving personalization by using large language models to propose levels based on the gameplay data continuously collected from individual players. We compared the levels generated using our approach with levels generated with more traditional procedural generation techniques. Our easily reproducible method has proven viable in a production setting and outperformed levels generated by traditional methods in the probability that a player will not quit the game mid-level. Index Terms—artificial intelligence, large language models, procedural content generation, game personalization. I. INTRODUCTION M OBILE game market is highly saturated and simply creating a good game is no longer enough to succeed. Besides a good game, you usually also need a sizeable advertising investment. Because of this, the cost per install can be high and retaining players is very important. We can keep the player in the game by providing new and engaging content, which can again be expensive, as its production requires a lot of time from developers, artists and game designers. A popular way to address this is through procedural content generation (PCG). PCG uses algorithmic techniques to create content for games. It is employed to increase replay value, reduce production costs and effort, or

05fd0bbd-cff5-4122-8df5-39dcf69d2545

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem creating a good game is no longer enough to succeed. Besides a good game, you usually also need a sizeable advertising investment. Because of this, the cost per install can be high and retaining players is very important. We can keep the player in the game by providing new and engaging content, which can again be expensive, as its production requires a lot of time from developers, artists and game designers. A popular way to address this is through procedural content generation (PCG). PCG uses algorithmic techniques to create content for games. It is employed to increase replay value, reduce production costs and effort, or save storage space. Apart from accounting for difficulty, it is usually not personalized - content is not generated to match the preferences of a specific player. In other words, procedurally generated content is the same for all players, regardless of their play style. Some interesting work has already been done in the area of game personalization, such as the proposal of Play Data Profiling (PDP) framework [1], which included psychophysiological measurements and eye tracking for the purpose of adjusting the game to the given player's current state. There has also been some industry-driven research, mostly done by game studios [2], whose data science teams aim to improve the key performance indicators (KPIs) of their games. Only a limited amount of their research appears to be published and even in those cases, implementation details are very scarce. Our idea is to leverage the latest developments in machine learning (ML) to develop a new type of PCG framework. Most recent large language models (LLMs) have introduced the ability for few-shot learning and zero-shot reasoning, meaning that they can be used for solving tasks they were not specifically trained for. This way they avoid the cold start problem, which presents a significant barrier to the integration of ML in recommendation systems. Cold start problem refers to the challenge of providing useful recommendations to players without first accumulating a sufficient amount of data [3]. One recent approach to accumulating a substantial volume of data, to ensure that players receive high-quality recommendations from the start, is through the generation of synthetic data, often employing deep reinforcement learning techniques [4], [5]. However, even after addressing the cold start problem, there remains the necessity to train task-specific models, which can be a costly endeavour. This training process does not generalize and must be repeated for each game or even for major updates within the same game. These

5b8e835e-3a09-423d-b2fb-61f9dfb140a9

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem in recommendation systems. Cold start problem refers to the challenge of providing useful recommendations to players without first accumulating a sufficient amount of data [3]. One recent approach to accumulating a substantial volume of data, to ensure that players receive high-quality recommendations from the start, is through the generation of synthetic data, often employing deep reinforcement learning techniques [4], [5]. However, even after addressing the cold start problem, there remains the necessity to train task-specific models, which can be a costly endeavour. This training process does not generalize and must be repeated for each game or even for major updates within the same game. These problems are not present in state-of-the-art LLMs, which have so far mostly been used to generate human-like text [6]. In the context of PCG, even though they are a relatively new technique, LLMs have been already successfully used to generate texts for quest-based games [7] and, with human supervision, entire levels [8]. As LLMs get more powerful and tuned to flawlessly provide computer-readable JSON formatted output [9], they can be, as we validated in our research, used to generate personalized level parameters. The purpose of our study is threefold: 1) To validate that modern LLMs (for example GPT-4) can be used in production for personalized PCG with no additional training and without human-in-the-loop with high reliability. 2) To verify if through zero-shot reasoning capable LLMs, ML can be used in personalized PCG without a cold start problem, which would lower the barrier to using personalized PCG in games. 3) To compare our approach with traditional PCG, by analyzing play data in order to check whether our approach can outperform traditional PCG when it comes to players completing the levels they started.

75a1ccd9-ffd7-4633-a4d0-139bef806f9b

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Ii. Related Work PCG has been discussed in the literature for decades [10], [11]. One of its subareas is called personalized PCG, which is about generating content for individual players based on their skills, style and preferences [12]. In recent years, approaches that incorporate ML [13], deep learning [12], and more recently LLMs [8], [14] have started to gain popularity. Our research is positioned in the area of LLM-based personalized PCG. Personalized PCG, sometimes also referred to as adaptive or player-driven PCG [15], is a less explored area of PCG [12]. A possible design for such games was described by Rajanen and Rajanen [1]. Their idea is that a gaming system should be built in a way that it collects real-time play data which is used for player profiling even after the system has been developed. They introduce a PDP model which proposes that gamification elements are adapted based on the data derived from the interaction and the personal data of the player. A periodic reassessment of the player may determine that a player is moved from one profile cluster to another. Our research puts this idea into practice. A more limited personalized approach aimed at player retention was utilized by Miloˇsevi´c et al. [16]. They focused on retaining players in a mobile game by utilizing early churn prediction and personalized player targeting. They first predicted which players were likely to churn and sent each one of them a personalized notification. They determined that such a personalized approach can retain players who would have otherwise left the game. Researchers at Electronic Arts [2] tackled dynamic difficulty adjustment as an optimization problem. The Match 3 game generated random levels with varying difficulty. The goal of ML-based optimization in their case was to maximize player engagement over the entire game. Their solution increased core engagement metrics such as rounds played and gameplay duration, however, it only focused on adjusting the difficulty, while our research aims to facilitate broader personalization. In literature, research on the use of LLMs often leverages an OpenAI GPT-2 model, which is open-source and allows finetuning [17]. Van Stegeren and My´sliwiec [18] investigated the usability of fine-tuned GPT-2 for dialogue line generation for a quest giver in a role-playing game. They tested the quality of generated quests with human judges. Even though GPT-2 generated quests

a50825fa-1faf-4e88-9a29-b89c7c2139c5

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Ii. Related Work such as rounds played and gameplay duration, however, it only focused on adjusting the difficulty, while our research aims to facilitate broader personalization. In literature, research on the use of LLMs often leverages an OpenAI GPT-2 model, which is open-source and allows finetuning [17]. Van Stegeren and My´sliwiec [18] investigated the usability of fine-tuned GPT-2 for dialogue line generation for a quest giver in a role-playing game. They tested the quality of generated quests with human judges. Even though GPT-2 generated quests on average performed worse than humangenerated ones, authors found the method a viable option for generating text in games. A more extensive study in the field of quest generation was performed by V¨artinen et al. [7] who explored the possibility of quest generation using GPT-2 and GPT-3. They fine-tuned GPT-2 with additional data and asked players for feedback. They concluded that GPT-2 was not yet up to the task, but future models like GPT-3 are likely to provide the ability to generate high-quality content autonomously. The use of LLMs to generate levels for the game Sokoban was tested by Todd et al. [8]. They devised a scoring model to determine the level's novelty, playability, diversity and score. They concluded that, despite it being a very different domain from natural language, the use of LLMs for game-level generation shows promise. Similarly, the study by Sudhakaran et al. [14] presents MarioGPT, a GPT-2 model proficient in procedural content generation. The study exhibits MarioGPT's capability to generate diverse gaming environments. Generated levels were playable approximately 88% of the time. Studies on LLMs still mostly dealt with the feasibility of LLMs for PCG, while the goal of our research is to test the feasibility of a reproducible, production-level framework.

ea56b7e3-eb06-4af9-9faa-4e3faf4e9c8d

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Iii. Large Language Models LLMs have in recent years revolutionized and dominated the field of natural language processing (NLP) [19]. They have been used for tasks such as dialogue systems, text summarization and machine translation [20]. In NLP, text generation is typically approached by assigning the probability of the next token based on the preceding tokens. Statistical approach can be described as ci ∼ p(ci | c1, . . . , ci−1; θ), where ci denotes the ith token in the text sequence and θ represents the parameters of the sampling distribution. The task is to maximize the probabilities of all tokens in the training data [7], [21]. A token can be a word, a part of the word or a letter. For example, given the words "Grand Theft", a model pre-trained on text found on the internet is likely to assign the next word "Auto", as this word is most likely to follow two preceding words. The development of Generative Pre-Trained Transformer (GPT) by OpenAI, starting with the original GPT [22], followed by GPT-2 [17], GPT-3 [23] and most recent GPT- 4 [20] introduced models that can generate coherent and contextually relevant text across a wide range of topics. These models are based on the transformer architecture, which makes training more parallelizable and significantly faster than NLP architectures before them [24].

9cb63e13-f0b3-4047-add1-8d4384af03f6

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Iv. Zero-Shot Reasoning The pre-training of LLMs involves learning to predict the next word in a sentence by consuming vast amounts of text data. This enables the model to capture a wide range of linguistic patterns and world knowledge. This pre-training can be followed by fine-tuning for specific tasks. Even without fine-tuning, GPT-3's and GPT-4's size allows for few-shot learning or *zero-shot reasoning*, where the model can perform tasks with little to no task-specific training data [23]. Historically, *zero-shot learning* has been used to refer to classifying instances without requiring training samples of the target classes [25], translating between unseen language pairs [26] and modelling on unseen languages [27]. The term is recently used to describe how models generalize to unseen tasks, an emerging ability of language models [28]. In the paper introducing GPT-3, researchers have shown that the 175 billion parameter language model has shown performance almost matching state-of-the-art fine-tuned systems on many NLP tasks in zero-shot, one-shot and few-shot settings [23]. While the term *zero-shot learning* is used also in the context of LLMs [28], we prefer to use the term zero-shot reasoning [29], [30]. For our experiment, we used GPT-4, a state-of-the-art successor to GPT-3. While it is a proprietary model whose inner workings are not published, it outperforms the predecessor on most tasks [20]. In the context of PCG, the zero-shot performance of capable LLM models can be used to generate level parameters with minimal examples or guidance. This is particularly useful for indie developers or small studios that may not have extensive datasets to train more traditional ML models.

91b8cb0d-d01a-4405-901f-207b2d3cb2f6

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## V. Approach And Basic Components For our research, we have developed and published a basic Match 3 mobile game. The game was developed in C# programming language using the Unity game engine [31] and interacted with a Google Cloud micro services-based back end. Products from the Google Cloud such as Cloud Functions and BigQuery were used for data collection. The machine learning model used for personalization was an LLM provided by OpenAI called GPT-4 [20], with which we interacted using a REST API under commercial terms. The game was published on the Google Play Store and players were acquired using Google Ads as is traditional for any commercially available game. This approach enabled us to obtain a representative sample of players, which would have been more challenging to achieve had we recruited participants ourselves.

6d7273f6-eedd-4c96-85f5-e785140931a7

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## A. The Match 3 Game Our game uses the Match 3 mechanics, which was proven suitable for such research by Xue et al. [2]. The basic gameplay is visualized in Figure 1. Before starting a level, a player is shown a pop-up with objectives and limitations for the level. An example of an objective is a score that the player has to reach combined with the number of elements of a specific colour he needs to connect and consequently remove from the board. Additionally, the game includes boosters, which are special items that can be used to clear more pieces or overcome challenging obstacles. The player is constrained by the number of moves: he needs to use the available moves strategically to clear the assigned amount of pieces in a certain colour as well as collect enough points to complete the level. The popularity of Unity, a game development engine, as well as the popularity of the Match 3 genre, helped with development as multiple useful templates are readily available. Our game was based on one such template [32].

61de22ef-771b-4807-8594-8004ffb1a760

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## B. Data Collection The gameplay data describes how a player interacts with the game. They are acquired through gameplay, the more the player plays the more of his gameplay data we have. The mobile game collected gameplay data and sent it to our back-end system periodically. The most important data for level generation was collected upon the completion of each level. At that time, the player was asked to rank the level they just completed on a scale from 1 to 5. After they ranked the level, the data was sent to the backend. The data collected included the number of the level completed, remaining moves, number of failed moves, overall clicks on the board, number of boosters used and how the player rated the level. Additionally, parameters of the level, such as the number of different pieces, board width and height, collection goals for individual pieces, along with the score required to pass and the allowed number of moves, were also collected. For our analysis, we also collected data about players starting and completing a level, allowing us to calculate the completion rate. Additionally, to be able to track their progress, we wanted to know at which screen players are and send this data in real-time. This data helped us determine potential bottlenecks in the game. Our design focused on gameplay data, so we did not collect or use any demographic or personal data from the players. C. Prompting the LLM We used the gameplay data to generate plaintext descriptions and sent them to the GPT-4 LLM. The data for at most last five levels was sent each time the player completed a level. The gameplay data, along with hardcoded instructions, were used to prompt the model to generate the next three levels and return them as JSON-formatted level parameters. The response itself was JSON formatted as the prompt dictated the following steps: Your task is to: 1) Consider the data on the player. 2) Consider parameters of the levels the player already completed. 3) Determine what type of player we are dealing with based on a list of player types. Mostly consider the level of skill, fun vs. complex, puzzly vs arcade. 4) Suggest the next 3 levels for this player based on the type of gamer and the list of level completion parameters. 5) Explain your reasoning for the type of gamer and next 3 levels. The first two steps instructed the model to incorporate data from the player's device regarding completed game levels. In

96d967fd-13d2-498f-a32e-dd76edfeb327

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## B. Data Collection ) Consider the data on the player. 2) Consider parameters of the levels the player already completed. 3) Determine what type of player we are dealing with based on a list of player types. Mostly consider the level of skill, fun vs. complex, puzzly vs arcade. 4) Suggest the next 3 levels for this player based on the type of gamer and the list of level completion parameters. 5) Explain your reasoning for the type of gamer and next 3 levels. The first two steps instructed the model to incorporate data from the player's device regarding completed game levels. In the third step, the model was tasked to categorically assign players to predefined types based on the player's skill and playstyle (not so skilled player, casual player, *great player*). In the fourth step, we asked the model to propose the next three levels for the assigned player type within the predetermined parameters. We did this after each level, appending the gameplay descriptions of at most five last completed levels. In addition, for analytical purposes, we asked the model to provide the reasoning for the player type selection and level parameters. We logged any additional data returned from the model for further analysis and review. We decided to generate three levels and not just one to make sure there were always some levels ready for the player in case of latency or backend technical difficulties. An example of how a prompt with two levels was sent to the LLM: "For level 3, the user scored 1460 where 900 was the minimum to pass. They had 18 moves left out of 25. They made 3 failed moves. They made 59 clicks on the board. They used 0 boosters. The player rated the level as 1 out of 5. The level contained 3 different pieces. Board width x height was 4 x 4. For level 4, the user scored 1860 where 800 was the minimum to pass. They had 18 moves left out of 25. They made 0 failed moves. They made 67 clicks on the board. They used 0 boosters. The player rated the level as 5 out of 5. The level contained 3 different pieces. Board width x height was 4 x 4." In this case, the player was assigned to be a casual player and the following explanation was given: "The player consistently completes levels with a significant number of moves left, indicating a good understanding of the game mechanics. However, the player's high number of clicks and occasional failed moves

7d0c916e-3e14-4383-8c5a-f6d3284179e4

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## B. Data Collection 4, the user scored 1860 where 800 was the minimum to pass. They had 18 moves left out of 25. They made 0 failed moves. They made 67 clicks on the board. They used 0 boosters. The player rated the level as 5 out of 5. The level contained 3 different pieces. Board width x height was 4 x 4." In this case, the player was assigned to be a casual player and the following explanation was given: "The player consistently completes levels with a significant number of moves left, indicating a good understanding of the game mechanics. However, the player's high number of clicks and occasional failed moves suggest they are not overly concerned with efficiency or perfect play. The player's ratings indicate they prefer levels that are not too challenging, as they rated the level they performed best on (level 4) the highest." We decided to construct human-readable prompts, as this did not produce much overhead, while it simplified the debugging and analysis. As we were able to provide the model with a concise summary of the gameplay for the last five levels, we decided against using the GPT-4 model in a chatbot-like capacity where we would keep and append the entirety of all past interactions to each new call to the model.

b4dd453e-83b9-4a46-8060-b6524e7efc22

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## D. Procedural Content Generation Module We designed our game to generate the levels based on selected key parameters. Those input parameters for the generation of a level for a specific player were provided by the LLM. For example, if the game was played by a lower-skilled player, the model might recommend parameters such as a smaller size grid, fewer pieces and more available moves. Apart from delivering a personalized experience, a PCG model helps keep the game fresh as levels keep changing. We generated the next three levels on the backend every time the player completed and rated a level. For personalized PCG, we considered the gameplay data of the completed level and up to four last levels. Levels were generated within given parameters and were for our experiment either generated using the LLM or a uniform random algorithm. Ranges for parameters were the same for both groups. Parameters for the levels were the number of different pieces in the level, board width and height, overall score goal, individual goals per piece and the number of moves allowed to complete the level. The colours of the board pieces and the colours of the pieces the player had to collect were randomly assigned each time the player started the level. Based on these parameters, our game was able to generate a level and serve it to the player.

2cfb9752-95c9-4efd-bf27-070876bff48f

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## E. Personalized Gameplay One of the key characteristics of our framework is that it not only adjusts for difficulty but personalizes the experience in other aspects as well. Any two players who download and open the game are likely to be served different levels very early on. The recommendations refresh periodically as new data is collected. Our framework should be able to provide a game of suitable challenge and style for a small child as well as an adult used to the genre and expecting a challenge. By making sure the game suits the player, we are also maximizing the chance to retain the player.

095c487c-85a7-4dae-bfca-4752183c9e01

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Vi. Experiment Design There is little incentive to implement personalized PCG if the produced personalized content does not bring any measurable benefits. To validate our approach, we used a method known as multivariate testing (also known as AB testing), where players are assigned to groups that are served different versions of the game. In our case, the difference was in how we generated levels. The superior method is determined based on how well it is capable of retaining the players, meaning that players do not abandon the levels they started. We also asked the players to rate each completed level. Multivariate testing helped us determine if serving personalized levels outperforms randomly served levels. We distributed our game to players who were split into two groups as follows: 1) players were served traditionally generated levels (procedural content generation with randomized parameters within certain thresholds), 2) players were served personalised levels based on parameters generated by the LLM. The group the player belongs to was determined the first time he opened the game. Upper and lower bounds for specific parameters were the same for both groups.

79d02d06-60f1-4ee6-90ee-f77927aeee35

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Vii. Serving Initial Levels As the model generates subsequent levels based on the gameplay data from at least one completed level, a different approach was needed for the first level a player gets. If the player was assigned personalised levels, they were generated using a similar prompt as before, just instead of multiple steps as described in Chapter V-C, we used a simpler prompt: "Your task is to suggest 3 levels of a game to a player that is completely new to it and starts with level 1." For players assigned random levels, level generation was the same for the first level as for levels that followed. For both groups, the levels were regenerated each time they were downloaded by a player's mobile device.

4217d75d-f301-420a-b702-79ceaec76091

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Viii. Participants As we wanted the population of our players to be unbiased and reflective of the real world, we used the same approach as games traditionally used when published. Our game is publicly available through the Google Play platform. To acquire players, we used paid advertising through the Google Ads system. We invested on average 3C per day for 26 days, through this, we onboarded 102 unique players, who started 928 levels and completed 422 of them.

9f244702-2f06-49a4-b389-492dfa05bfd7

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Ix. Statistical Analysis We used Bayesian statistics to analyse the results. All analyses were conducted using Stan - a state-of-the-art platform for executing modern Bayesian statistical analyses [33]. To analyse if players were more likely to complete levels that were generated with LLM-empowered procedural content generation in comparison to traditional approaches, we facilitated a simple Bernoulli model: $y\mid\theta\sim$ bernoulli($\theta$). Values 1 in the input data vector (y) denote successful completions of a level, while values 0 denote unsuccessful completions, either because of running out of moves or giving up. Stan's default non-informative prior was used for the θ parameter. We fit the above model to both groups and then compared posterior parameters to determine whether there is a difference between the completion rate and to determine the certainty of our claims. To analyse if player ratings between the two groups differ, we used an ordered GLM model [34]: $y\mid\beta,x,c\sim$ ordered_logistic$(x\beta,c)$, (2) $\beta\sim$ Cauchy$(0,2.5)$. (3) where y are player ratings, x is the independent variable (the group) in our case, c are the model's intercepts (or cutpoints) and β is the regression coefficient. We put a default weakly informative Cauchy prior on the beta coefficient [35]. We use the β parameter to estimate whether ratings in one group were larger than the other as well as the certainty of our claim. To distinguish reported Bayesian probabilities from frequentist p-values we denote them with a capital P. Unlike p-values, the reported probabilities directly describe the probability by which we can claim that our hypotheses are true or not. The probability that the opposite of our claim is true can be calculated as 1 − P. We used Monte Carlo Standard Error (MCSE) to estimate uncertainty in our quantifications. Since MCSE was in all cases lower than 1%, we decided to omit it for the sake of brevity.

a6287f4f-05a2-4c64-8024-46d63ea50ffe

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## X. Generated Levels Analysis In our personalised PCG experiment group, we asked the model to sort players into types based on their gameplay. The classification was driven by the model without additional guidelines from us about the characteristics of each player type. Once the player type was assigned, the model was asked to generate the next three levels for the player. Examples of the recommended levels are available in Appendix A. To assess the correlation between the parameters of the generated levels and the assigned player types, we applied k-means clustering, setting the number of clusters equal to the number of player types. Since our approach consistently recommended three levels per player, we used the parameters from all three suggested levels, treating each as separate input columns for the k-means algorithm. After clustering, we used a method called t-distributed Stochastic Neighbor Embedding (t-SNE) [36] with which we reduced the dimensionality to two, enabling us to calculate alignment and plot the data. The results of this analysis are shown in Figure 2. Based on the visualization the group that seems to stand out the most are the levels assigned to the *great player* group. To measure how the clustering matched the model's assignments, we used the Adjusted Rand Index (ARI) [37]. ARI is an established measure for evaluating clustering with values from −1 to 1. An ARI value of 1 indicates perfect agreement between two clusterings, which in our case would mean that the clustering algorithm and player type assignment by LLM were identical for every data point. A value close to 0 suggests that the two clusterings are no more similar to each other than they would be by random chance while a rare negative value suggests a systematic disagreement between the clusterings. Comparing assigned player types between the clustering labels and LMM labels, the ARI score was 0.34, meaning that the alignment was stronger than random. For the players assigned to the traditional PCG experiment group, the next three levels were generated without considering the gameplay. Adding those levels to comparison, we can see in Figure 2 that levels generated using traditional PCG tend to be closer to the LLM-generated levels assigned to great players, perhaps indicating that they were more challenging than the ones the model assigned to the *casual* and not so skilled players. The ARI score for the comparison was 0.53, indicating a moderate level of agreement between the clustering and the labels assigned by the model and random

f267cf40-cae4-425b-85b4-6b8a846ea03b

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## X. Generated Levels Analysis 34, meaning that the alignment was stronger than random. For the players assigned to the traditional PCG experiment group, the next three levels were generated without considering the gameplay. Adding those levels to comparison, we can see in Figure 2 that levels generated using traditional PCG tend to be closer to the LLM-generated levels assigned to great players, perhaps indicating that they were more challenging than the ones the model assigned to the *casual* and not so skilled players. The ARI score for the comparison was 0.53, indicating a moderate level of agreement between the clustering and the labels assigned by the model and random levels.

d1e865bd-df12-46e9-9e05-ac847e6fdced

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Xi. Results We compared the results for level completion between the group that was served levels generated with traditional PCG and the group that was served levels generated using LLM PCG. About a third of players (34%) completed the first level that was generated using LLMs, while only 18% completed the traditionally generated first level. Results are displayed in Figure 3. Comparing the data for all levels, the completion rate of levels started for LLMs is 55% and for traditional PCG 35%. The probability that a greater proportion of players would complete any given level when using LLMs, as opposed to the traditionally served level is near certain (P ≈ 1.00). Similarly, the probability that more players would complete the first level when using LLMs compared to the traditionally generated is also extremely high (P ≈ 1.00). Apart from level completion, we also collected data on how much players liked the levels. We asked them to vote on the levels after they completed them. This vote was passed to the LLM and was used to personalize the next levels for the player. As demonstrated in Figure 4, average player ratings were 3.87/5 for LLM levels and 4.22/5 for traditional PCG. As shown in Figure 5, we can say with high confidence, that the ratings were lower for LLM-based PCG, a result which surprised us. An overview of ratings can be seen in Figure 6.

8a95cb9a-8b09-496f-a258-17906eb27d40

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Xii. Study Limitations The weakness of using zero-shot reasoning is that while it offers a simple way to personalize a mobile game, it is limited in how well it can perform compared to custom-trained ML models. To mitigate this shortcoming, our initial multivariate test design included a third group. In this group instructions for the LLM included the comparison of player's data for the completed level against the average, minimum, maximum and median of all the data on this level for players that have previously completed it. This approach would potentially enable our game to leverage collected data to provide increasingly accurate suggestions over time. However, as each level is unique, the approach required clustering to approximate similar levels and relying on just the player data until players completed enough levels. Given the added complexities and discretionary decisions we would have to make we decided to omit an additional group for this experiment. Retrospectively, such a design might be better suited using more objective metrics like level completion, as using data on level rankings, according to our analysis, might not be an accurate reflection of a player's satisfaction with the game. In our testing, levels generated using traditional PCG received a higher average rating than levels generated using LLM-based PCG. The result surprised us and further analysis has shown a big discrepancy in really low scores for traditional PCG. Rating a level requires level completion and the player's action to cast a vote at the end of the level. As Figure 6 suggests, players were a lot more likely to assign the lowest score to LLM-based PCG but were much more likely to actually complete and rate levels, as is shown in Figure 3. Traditional PCG used a random algorithm to generate levels and did not account for difficulty. This suggests that players assigned to the traditional PCG group who did not like the level likely abandoned the game without casting a negative vote. We are aware that at the time of testing, using a commercial solution like GPT-4 could incur significant costs, especially when scaling to really large numbers of players. A cheaper solution like GPT-3.5 might produce similar results at lower costs. However, we decided to perform our tests using a state-of-the-art model, as the field is developing rapidly and optimizations and new developments have driven costs down over time in the past. Our framework encompasses a wide range of settings and parameters, such as which parameters to adjust for the levels, ranges for these parameters, what player types to choose from and how to formulate the instructions

e09bdf3e-4d60-483c-9099-e7f39c2a469b

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Xii. Study Limitations the time of testing, using a commercial solution like GPT-4 could incur significant costs, especially when scaling to really large numbers of players. A cheaper solution like GPT-3.5 might produce similar results at lower costs. However, we decided to perform our tests using a state-of-the-art model, as the field is developing rapidly and optimizations and new developments have driven costs down over time in the past. Our framework encompasses a wide range of settings and parameters, such as which parameters to adjust for the levels, ranges for these parameters, what player types to choose from and how to formulate the instructions for the LLM. We arrived at sensible configurations through a process of experimentation and hands-on gameplay. Our focus was not on the most optimal configuration, but rather on determining whether LLMs can be effectively employed for PCG. While our prototype confirms they can be employed, we are aware there is room for further optimizations. One particular area of further optimization would be further experimentation with the predefined list of player types. As our level analysis has shown, there was a clear distinction between great player and others, but there was some overlap between not so skilled player and *casual player*. It would be tempting to rerun the experiment using simpler terms or just telling the model to suggest levels on a traditional difficulty scale like easy, normal and hard, but we decided against it due to time and cost such additional testing would require, as we got some clear conclusion from using existing types. XIII. DISCUSSION Our results suggest that LLMs can be used to introduce personalized PCG into level-based games. Furthermore, they can be used without *fine-tuning* by utilising *zero-shot reasoning*, where the model performs prediction based on instructions with zero training examples. The most obvious benefit of using LLMs versus using recommendation algorithms (like matrix factorisation) is that this approach avoids the cold start problem and is able to provide reasonable suggestions based simply on a combination of prompts and gameplay data. This massively reduces the cost and complexity of bringing games with intelligent, ML-based personalized PCG to market while, as our experiment suggests, still offering measurable benefits. Approaches like ours signal a shift to what some are calling *post-training era*, where innovation is driven by applying generative AI to solve practical problems [38]. Another interesting finding is the reliability of LLMs when used for PCG. GPT-4's *function calling

bed13549-19b0-4aca-a913-4fce47fb00df

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Xii. Study Limitations recommendation algorithms (like matrix factorisation) is that this approach avoids the cold start problem and is able to provide reasonable suggestions based simply on a combination of prompts and gameplay data. This massively reduces the cost and complexity of bringing games with intelligent, ML-based personalized PCG to market while, as our experiment suggests, still offering measurable benefits. Approaches like ours signal a shift to what some are calling *post-training era*, where innovation is driven by applying generative AI to solve practical problems [38]. Another interesting finding is the reliability of LLMs when used for PCG. GPT-4's *function calling* capability, which is designed to return data as valid JSON [39], consistently delivers valid levels. There were also no problems when parsing the JSON format, as the output was consistently properly formatted. Our implementation with the Google Play Storepublished game and Google Cloud backend was designed to mimic production quality and work without disclaimers. We solved the problem of high latency of the LLM model by generating and serving three levels at once. The game only checked for new levels based on updated predictions after level completion and used a level generated on older data as a fallback, so players never had to wait for the response. For our testing, the cost of using LLMs was low, as the amount of players was limited and prompts were not very long. As the analysis of the levels shows, LLM did generate different types of levels for different player types it assigned to players. We did some preliminary testing before determining player types. Random levels are clustered close to levels generated for *great players*. This hints that given the same parameters, using LLMs in our case mostly brought benefits in terms of effectively lowering the difficulty for less skilled players.

3b0429b5-d55a-4e86-a8d4-1bac842f8940

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Xiv. Conclusions And Future Work We presented a proof-of-concept framework for personalized PCG in mobile games implemented using zero-shot reasoning. The framework is an end-to-end solution for personalized PCG based on LLMs. We validated our framework by developing and publishing a mobile game that interacted with an OpenAI GPT-4 LLM model to provide personalized levels. We used our game to perform a multivariate test, which has shown that players who are served levels created by our framework were significantly more likely to complete a level they started than those served levels generated using traditional PCG. A direct result of our approach is that players are provided with a potentially unlimited, personalized game experience. To address the scarcity of detailed, production-focused research in the area of personalized PCG, our framework is designed to be easily reproducible. While there have been developments in real-time content generation using ML, procedurally generated content is typically the same for all players, regardless of their play style. Additionally, PCG using LLMs was not validated in a production environment. A major advantage of using LLMs capable of zero-shot reasoning - that can generate levels based solely on instructions and do not require additional training - is that it eliminates the cold-start problem and is able to generate decent personalized levels from the beginning. Utilising advances in generative AI, particularly zero-shot reasoning capable LLMs like GPT-4, our validated framework will make it easier for game developers to switch from conventional game design to a design that - by leveraging modern ML approaches - increases their chance of creating a game that the players will enjoy. Our research aims to bridge the gap between purely academic research, which is often not directly usable by industry and industry research, which has practical goals but is not easily reproducible by developers with limited resources. Our test has shown that using LLMs in the proposed way is feasible and beneficial, however, it only scratches the surface of what a more complex and more optimized game using our framework can be and achieve. LLMs can be used to personalize any aspect of the game, from difficulty to style and possibly even cross existing genres. We encourage developers to explore our framework to bring forward a type of game that starts the same but is unrecognisable from player to player a few levels in due to continuous personalization.

16d008d0-60a4-4a4a-b354-86c9f6cefd46

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Xv. Data And Code Availability All data and code are available at https://github.com/dhafnar/match3.

2f52d4ef-26d4-4194-bfb3-38151644c785

# Zero-Shot Reasoning: Personalized Content Generation Without The Cold Start Problem ## Appendix A Json Representation Of A Level [ { "num_different_pieces": 4, "score_goal": 1500, "board_width": 6, "board_height": 6, "num_moves": 30, "collection_goals": [ 20, 25, 30 ] }, { "num_different_pieces": 5, "score_goal": 1800, "board_width": 6, "board_height": 6, "num_moves": 35, "collection_goals": [ 25, 30, 35 ] }, { "num_different_pieces": 5, "score_goal": 2000, "board_width": 6, "board_height": 6, "num_moves": 40, "collection_goals": [ 30, 35, 40 ] } ]

5da1ffbb-58f7-4179-8962-9598bbc4ef87

Advancing Building Energy Modeling with Large Language Models: Exploration and Case Studies Liang Zhang1,2, Zhelun Chen3, Vitaly Ford4 1. University of Arizona, Tucson, AZ 2. National Renewable Energy Laboratory, Golden, CO 3. Drexel University, Philadelphia, PA 4. Acadia University, Glenside, PA

2d1c0a6c-10c7-4f7d-b696-454721180571

## Highlights - Exploring and Highlighting LLM's transformative impact on BEM applications - Case studies illustrate LLM's role in enhancing BEM's efficiency and accessibility - Selecting suitable LLM techniques critical for optimizing BEM process efficiency - Challenges in LLMs' computational demands and consistency addressed by research

7cef490d-c7d7-4d7b-958a-d2a5028c297c

## Keywords building energy modeling, large language models, prompt engineering, multi-agent systems, self-consistency

d0438b70-b0bd-47c6-8b2f-ccba873ba291

## Abstract The rapid progression in artificial intelligence has facilitated the emergence of large language models like ChatGPT, offering potential applications extending into specialized engineering modeling, especially physics-based building energy modeling. This paper investigates the innovative integration of large language models with building energy modeling software, focusing specifically on the fusion of ChatGPT with EnergyPlus. A literature review is first conducted to reveal a growing trend of incorporating of large language models in engineering modeling, albeit limited research on their application in building energy modeling. We underscore the potential of large language models in addressing building energy modeling challenges and outline potential applications including 1) simulation input generation, 2) simulation output analysis and visualization, 3) conducting error analysis, 4) co-simulation, 5) simulation knowledge extraction and training, and 6) simulation optimization. Three case studies reveal the transformative potential of large language models in automating and optimizing building energy modeling tasks, underscoring the pivotal role of artificial intelligence in advancing sustainable building practices and energy efficiency. The case studies demonstrate that selecting the right large language model techniques is essential to enhance performance and reduce engineering efforts. Besides direct use of large language models, three specific techniques were utilized: 1) prompt engineering, 2) retrieval-augmented generation, and 3) multi-agent large language models. The findings advocate a multidisciplinary approach in future artificial intelligence research, with implications extending beyond building energy modeling to other specialized engineering modeling.

2da73b0b-3678-427e-8410-70c96b352a76

## 1. Introduction Buildings are significant contributors to global energy consumption and carbon emissions, responsible for approximately 30% of the world's energy use and 26% of CO2 emissions [1]. Buildings represent a critical sector in the global pursuit of decarbonization and reduction of greenhouse gas emissions [2]. Building Energy Modeling (BEM) plays a pivotal role in this endeavor. BEM is a computational technique that uses algorithms to simulate and predict the energy consumption of buildings based on various parameters, such as architectural design, materials, operational schedules, and local climate. It serves as a powerful tool for architects, engineers, and policymakers, aiding in the design and operation of energy-efficient buildings, as well as in the formulation of effective building codes and standards. By optimizing energy use and implementing renewable energy systems, BEM facilitates the path to building decarbonization. BEM, at its core, is a highly technical and specialized discipline, steeped in a need for extensive knowledge and experience. This necessity stems from the multifaceted and interconnected nature of building science and the diverse range of systems that underpin a building's operations, particularly in the field of heating, ventilation, and air conditioning (HVAC). Users of BEM must understand the fundamentals of these systems, as well as the principles of physics that govern their interactions, in order to accurately capture building characteristics and thus correctly model its energy consumption. This deep understanding needs to be paired with proficiency in specific BEM software. Each of these software packages comes with its own nuances, language, and operational complexities. Mastering these tools demands a significant investment of time and effort, often deterring those who lack the necessary background or resources from effectively leveraging BEM in their work. Furthermore, the sophistication of modern buildings, equipped with complex mechanical systems and novel materials, adds to the challenges faced by BEM practitioners. Buildings are no longer standalone entities but parts of broader energy networks, connected to other buildings and infrastructures. This expanded scope, coupled with an ever-increasing push for sustainability, means that users of BEM now must possess an even more diversified range of expertise, from understanding emerging technologies to interpreting complex regulations and codes. All these factors make BEM an expertise-intensive area, requiring a deep and broad knowledge base that spans multiple disciplines, making it an intricate field to navigate for newcomers and even some experienced professionals. The rapid progression in the field of artificial intelligence (AI) has facilitated the emergence of Large Language Models (LLMs) like ChatGPT, offering potential applications extending

7e2b4624-2c00-43fc-9b39-1d9d1d6a1061

## 1. Introduction energy networks, connected to other buildings and infrastructures. This expanded scope, coupled with an ever-increasing push for sustainability, means that users of BEM now must possess an even more diversified range of expertise, from understanding emerging technologies to interpreting complex regulations and codes. All these factors make BEM an expertise-intensive area, requiring a deep and broad knowledge base that spans multiple disciplines, making it an intricate field to navigate for newcomers and even some experienced professionals. The rapid progression in the field of artificial intelligence (AI) has facilitated the emergence of Large Language Models (LLMs) like ChatGPT, offering potential applications extending into the realm of BEM. The integration of LLMs in BEM holds significant potential due to its transformative impact on human-machine interactions. Traditionally, user engagement with complex machinery or systems, like BEM software, has been constrained by a steep learning curve and the need for specialist knowledge. However, LLMs, with their ability to comprehend and generate reasonable natural language, can significantly streamline these interactions, making them more accessible and intuitive. LLMs essentially serve as an interface, allowing users to communicate with the BEM software using natural language. This drastically lowers the technical barrier, enabling those without specialist knowledge to interact with BEM systems. For instance, a user could instruct the system to modify certain parameters or request an interpretation of the simulation results in simple, everyday language, and the LLM can translate these instructions into actions or provide explanations. Moreover, LLMs are not limited to merely simplifying interactions; they can also contribute to knowledge enhancement. Given their vast training data encompassing various topics, LLMs can offer valuable insights, explanations, or suggest best practices related to BEM. They can potentially serve as an intelligent assistant, guiding users through complex BEM tasks, enhancing their understanding, and helping them make informed decisions. This shift in how users interact with BEM tools could democratize access to these systems, broadening their application and thus contributing more effectively to decarbonization goals. In order to explore this topic of how we can advance BEM with LLM, in Section 2, we first review the development and characteristics of LLM and its application in facilitating the usage of specialized and professional software; then we summarize the promising applications of LLMs in BEM. In Section 3, we design preliminary case studies to demonstrate the effectiveness of potential LLM applications in BEM. In Section 4 and 5, we discuss the results of the case studies and conclude with an outlook on future trends and developments

62dd94c2-90aa-4541-8071-85fccf0a4904

## 1. Introduction EM tools could democratize access to these systems, broadening their application and thus contributing more effectively to decarbonization goals. In order to explore this topic of how we can advance BEM with LLM, in Section 2, we first review the development and characteristics of LLM and its application in facilitating the usage of specialized and professional software; then we summarize the promising applications of LLMs in BEM. In Section 3, we design preliminary case studies to demonstrate the effectiveness of potential LLM applications in BEM. In Section 4 and 5, we discuss the results of the case studies and conclude with an outlook on future trends and developments in the application of LLMs in BEM.

7dde3d4a-8f8c-4bbb-b729-cb646aef76a3

## 2. Llm In Engineering Modeling And Bem At the point of writing the paper, we found few papers discussing the topic of LLM in BEM. To understand the existing work that can benefit this particular topic, we review the papers from a broader perspective. Since BEM is a type of interaction between humans and software requiring expert knowledge, it is worth investigating how LLM has already helped with benefiting the usage of specialized and professional software-based modeling requiring expert knowledge. 2.1 User Interfaces LLMs can provide a conversational interface to interact with complex software, simplifying the user experience. For instance, they can enable users to perform tasks using natural language commands, rather than having to navigate complicated menus or learn specific programming languages. Wen et al. [3] use LLM to enable voice-based handsfree user interaction with smartphones apps. In BEM, a user interface is crucial for ease of use. Consider EnergyPlus [4], where all the user interfaces (e.g., OpenStudio, DesignBuilder, and Ladybug Tools) are graphical user interfaces. However, the forms of interface should not be limited. A well-designed interface empowers BEM users to easily express their modeling needs and receive simulation results in a manner that is most direct and comprehensible, making the natural-language-based user interface a promising field. Currently, there is a lack of such interfaces in BEM, and we posit that their integration into software tools would substantially enhance workflow efficiency. 2.2 Code Generation LLMs have the capability to comprehend programming languages and generate code snippets from natural language prompts. GitHub Copilot (https://github.com/features/copilot), a collaborative effort between GitHub and OpenAI, serves as an AI pair programmer, offering code suggestions while developers write, thus accelerating the coding process, reducing error potential, and offering a learning resource. LLMs can further automate data and modeling workflow through code generation capabilities. This allows LLM to automate complex processes by coordinating tasks across various software tools. They can interpret instructions given in natural language, create the required commands or scripts, and then perform or arrange the tasks as needed. Many LLM-based tools (e.g., AutoGen [5] and MetaGPT [6]) have already proven their ability in LLM-based workflow automation. In data-intensive fields, LLMs can automate tasks such as data cleaning, preprocessing, analysis, and visualization. They can understand high-level descriptions of the desired data transformations or analyses, generate the necessary code, and

a1e1c942-cdce-49ad-9b73-607a577e2b2e

## 2. Llm In Engineering Modeling And Bem through code generation capabilities. This allows LLM to automate complex processes by coordinating tasks across various software tools. They can interpret instructions given in natural language, create the required commands or scripts, and then perform or arrange the tasks as needed. Many LLM-based tools (e.g., AutoGen [5] and MetaGPT [6]) have already proven their ability in LLM-based workflow automation. In data-intensive fields, LLMs can automate tasks such as data cleaning, preprocessing, analysis, and visualization. They can understand high-level descriptions of the desired data transformations or analyses, generate the necessary code, and provide the results in a user-friendly format. The automation of simulation tasks is a very important branch of BEM. Currently, the most widely used BEM automation methodology is OpenStudio Measure [7]. OpenStudio Measures are Ruby scripts that extend OpenStudio's functionality, enabling users to customize energy models, implement energy-saving strategies, and automate tasks in a collaborative platform. However, the development of OpenStudio Measure has a very high requirement for the skills of Ruby programming language, OpenStudio, EnergyPlus, as well as knowledge in building science and building equipment. LLM has great potential to further "automate the automation" by auto-generating Ruby scripts. It will bring the automation of BEM to the next level from data collection, model generation, and simulation results reporting. The LLM has proven to be highly effective in workflow automation, seamlessly orchestrating tasks across a diverse range of software tools. This capability makes it an ideal candidate for BEM co-simulation tasks. BEM co-simulations require the integration of multiple software tools and models to meticulously simulate and analyze a building's energy performance, considering a multitude of factors including HVAC systems, weather conditions, occupant behavior, and the characteristics of the building envelope. The expertise of the LLM in code generation, workflow automation, and data processing positions it as a valuable asset in streamlining and enhancing the efficiency of BEM automation processes. 2.3 Documentations, Tutorials, and Training Documentations, tutorials, and training play a crucial role in the effective and efficient use of any professional software. They serve as the first point of contact for new users and a reference guide for experienced ones. In the past, these resources were static and sometimes difficult to comprehend, especially for complex software. However, the advent of LLM is ushering in a new era of intelligent, dynamic, and interactive user assistance.

e32291d7-8182-4519-9bf1-59ce1dad79ee

## 2. Llm In Engineering Modeling And Bem M in code generation, workflow automation, and data processing positions it as a valuable asset in streamlining and enhancing the efficiency of BEM automation processes. 2.3 Documentations, Tutorials, and Training Documentations, tutorials, and training play a crucial role in the effective and efficient use of any professional software. They serve as the first point of contact for new users and a reference guide for experienced ones. In the past, these resources were static and sometimes difficult to comprehend, especially for complex software. However, the advent of LLM is ushering in a new era of intelligent, dynamic, and interactive user assistance. One of the most exciting capabilities of LLMs is their ability to generate and reorganize content in a way that makes it more accessible and user-friendly. LLMs can produce well-structured documentation, interactive tutorials, and step-by-step guides in real-time, tailored to the specific needs of the user. For instance, an LLM could produce a beginner's guide to a complex data analysis software by generating explanations and examples in plain language, or generate a more advanced tutorial focusing on a particular feature or use case based on the user's specific query. In addition, LLMs also offer real-time support by answering specific questions about software features. Rather than having to sift through a FAQ page or search for a relevant tutorial or question-and-answer forum, users can simply ask the LLM their question in natural language. The LLM can understand the query, find the most relevant information, and generate a helpful response. This kind of interactive, on-demand assistance can significantly reduce the learning curve associated with complex software, making it more accessible to a broader range of users. MacNeil et al. [8] reported on their experiences generating multiple code explanation types using LLMs and integrating them into an interactive e-book on web software development. Three different types of explanations - a line-by-line explanation, a list of important concepts, and a high-level summary of the code - were created. Their results show that all explanation types were viewed by students and that the majority of students perceived the code explanations as helpful to them. Su et al. [9] explores the question of how to make software documentation more useful with an LLM. They investigate a general, one-model-fit-all solution through a state-of-the-art LLM (ChatGPT). The paper covers three representative tasks: extracting locking rules from comments, synthesizing exception pred

09dd8931-0c1d-4e0d-99d5-aecde648b54f

## 2. Llm In Engineering Modeling And Bem Three different types of explanations - a line-by-line explanation, a list of important concepts, and a high-level summary of the code - were created. Their results show that all explanation types were viewed by students and that the majority of students perceived the code explanations as helpful to them. Su et al. [9] explores the question of how to make software documentation more useful with an LLM. They investigate a general, one-model-fit-all solution through a state-of-the-art LLM (ChatGPT). The paper covers three representative tasks: extracting locking rules from comments, synthesizing exception predicates from comments, and identifying performance-related configurations; it also reveals challenges and opportunities in applying LLMs to system maintenance. 2.4 Error Identification and Troubleshooting Error identification and troubleshooting have traditionally been complex processes, requiring specialized knowledge and experience. However, the incorporation of LLM into these systems is transforming how these tasks are performed, making them more efficient and accessible to a broader range of users. LLMs can assist in identifying and troubleshooting errors by interpreting descriptions of issues provided by the users. This involves natural language processing capabilities that allow the AI to understand the user's language, including technical terms and even colloquial or less precise descriptions of problems. The LLMs can then match these descriptions with known errors or issues, helping to pinpoint what may be going wrong. One of the main benefits of using LLMs in error identification is that they can significantly reduce the time taken to understand and diagnose the problem. For example, if a user encounters a software crash, they could describe the issue to the LLM, which would then process this description, correlate it with known bugs or issues, and suggest possible causes for the crash. In terms of troubleshooting, LLMs can provide step-by-step guidance to resolve the identified issues. Based on the identified error, the LLM can generate a list of potential solutions, ordered by their likelihood of success or ease of implementation. This could range from simple solutions like restarting the software to more complex procedures such as modifying specific settings or running certain commands. In each case, the LLM can provide clear, easy-to-follow instructions, making it easier for non-expert users to resolve issues on their own. Moreover, LLMs can learn from each interaction, thereby enhancing their ability to handle similar issues in the future. This capability allows them to become more effective over time, ultimately improving the efficiency of the troubleshooting process. This debugging

2bf526c5-ab3a-494e-ba42-96bdcd3919ad

## 2. Llm In Engineering Modeling And Bem error, the LLM can generate a list of potential solutions, ordered by their likelihood of success or ease of implementation. This could range from simple solutions like restarting the software to more complex procedures such as modifying specific settings or running certain commands. In each case, the LLM can provide clear, easy-to-follow instructions, making it easier for non-expert users to resolve issues on their own. Moreover, LLMs can learn from each interaction, thereby enhancing their ability to handle similar issues in the future. This capability allows them to become more effective over time, ultimately improving the efficiency of the troubleshooting process. This debugging process can also be automated and integrated within the software's operational cycle, allowing the system to self-correct iteratively until it operates without faults, thus streamlining the modeling process and enhancing system reliability. Overall, the use of LLMs in error identification and troubleshooting represents a significant leap forward. By enabling rapid diagnosis and resolution of software issues, they not only enhance the user experience but also increase the overall efficiency and reliability of software systems. Most commercial LLM tools are available for general error identification and troubleshooting. For instance, ChatGPT can assist with debugging by pinpointing and clarifying common errors like syntax or logical mistakes. Unfortunately, similar tools specifically designed for professional software are currently lacking. In the context of BEM, error identification and troubleshooting have traditionally been complex processes, especially for expert-knowledge-dependent software such as EnergyPlus. Users often have to sift through dense technical documentation or rely on trial-and-error methods to identify and rectify issues, which can be time-consuming and inefficient. However, with the introduction of LLMs, these processes could be significantly streamlined and enhanced. 2.5 Potential Applications of LLM in BEM In this sub-section, we further summarize the advances and advantages of LLMs in the context of the key challenges in BEM, especially its heavy dependency on expert knowledge. We explore and propose several potential applications of LLMs with case studies to enhance and streamline the BEM process. 2.5.1 Simulation Input Generation Defining simulation input is a foundational step in BEM, where detailed parameters such as building geometry, material properties, HVAC system configurations, occupancy patterns, and local climate data are defined to represent a building's characteristics for energy modeling. LLMs, equipped with vast knowledge bases and adept natural language processing capabilities, are uniquely positioned to streamline this intricate process. For instance,

036b99ce-d63a-4180-863d-f267513af5f9

## 2. Llm In Engineering Modeling And Bem the context of the key challenges in BEM, especially its heavy dependency on expert knowledge. We explore and propose several potential applications of LLMs with case studies to enhance and streamline the BEM process. 2.5.1 Simulation Input Generation Defining simulation input is a foundational step in BEM, where detailed parameters such as building geometry, material properties, HVAC system configurations, occupancy patterns, and local climate data are defined to represent a building's characteristics for energy modeling. LLMs, equipped with vast knowledge bases and adept natural language processing capabilities, are uniquely positioned to streamline this intricate process. For instance, a user might describe a building's façade as "mostly glass with southern exposure." An LLM, through prompt engineering, can interpret this to generate specific parameters like window-to-wall ratio, glazing type, and solar heat gain coefficients. An LLM can then adeptly transform these descriptions into a structured input format, meticulously populating a BEM input file, such as the Input Data Dictionary (IDD) for EnergyPlus, ensuring all parameters align with the template's requirements. In summary, LLMs significantly enhance the efficiency of setting up BEM by translating natural descriptions into precise simulation inputs, ensuring accurate and streamlined energy analysis. 2.5.2 Simulation Output Analysis and Visualization BEM has structured simulation output format, which is very suitable to be processed by LLM with its ability of code generation to automatically conduct data analysis, modeling, and visualization. Besides, the unique challenges of BEM outputs demand more specialized solutions. LLMs, equipped with capabilities of context-aware data interpretation, can not only contribute to data automation but also assist in offering deeper insights and extracting meaningful knowledge from vast simulation datasets. For instance, when analyzing a spike in energy consumption, an LLM might correlate it with specific HVAC activities during peak occupancy hours, offering a nuanced understanding. 2.5.3 Conducting Error Analysis As simulations grow in complexity, the potential for errors increases, and these errors can manifest in various ways. Some errors, due to violations of basic model assumptions or misconfigurations, can cause the simulation to fail outright. For instance, specifying an impossible combination of materials or an HVAC system operating outside its feasible range might halt an EnergyPlus simulation before it even begins. On the other hand, subtler errors might not stop the simulation but can lead to anomalous results. An incorrectly defined occupancy schedule or a misconfigured shading device might not prevent

fe8c829a-4f58-4764-a105-d57594307a54

## 2. Llm In Engineering Modeling And Bem hours, offering a nuanced understanding. 2.5.3 Conducting Error Analysis As simulations grow in complexity, the potential for errors increases, and these errors can manifest in various ways. Some errors, due to violations of basic model assumptions or misconfigurations, can cause the simulation to fail outright. For instance, specifying an impossible combination of materials or an HVAC system operating outside its feasible range might halt an EnergyPlus simulation before it even begins. On the other hand, subtler errors might not stop the simulation but can lead to anomalous results. An incorrectly defined occupancy schedule or a misconfigured shading device might not prevent the simulation from running but could result in unexpected energy consumption spikes or temperature fluctuations. The challenge arises from error complexity and a lack of feedback mechanism. LLMs can assist in pinpointing and elucidating these errors. For a complete simulation failure, an LLM might trace the issue to a specific input violation. For anomalous results, it might highlight potential inconsistencies or misconfigurations that led to the unexpected behavior. While LLMs can identify and explain many known errors, novel or unprecedented issues might be harder to diagnose. The vast array of potential BEM errors, each with its unique characteristics, makes error analysis in tools like EnergyPlus a nuanced task. Continuous fine tuning of the LLM on the latest BEM datasets and updates is essential. For instance, EnergyPlus has a rich ecosystem of resources like the Engineering Reference, the Input Output Reference, and community forums. An LLM can be trained on these resources to enhance its diagnostic capabilities. When a user encounters an error, the LLM can cross-reference the user's description with known issues from these resources, provide relevant excerpts from user documents, or even suggest similar cases discussed in community forums. Integrating user feedback loops enables LLM to learn from its misses, refining its diagnostic capabilities over time. 2.5.4 Co-Simulation Co-simulation in BEM involves the concurrent use of multiple simulation tools, each specialized in a particular domain, to provide a comprehensive analysis of a building's energy performance. For instance, while EnergyPlus might be used to simulate the overall energy consumption of a building, a separate tool might be employed to model occupant behaviors based on the simulated building environment [10, 11]. The integration of LLMs in co-simulation processes can streamline the coordination between these tools. LLMs can potentially understand the intricacies of each tool and ensure that data is seamlessly transferred and interpreted across

df2b3bea-b84a-4c08-889b-c05aa684a9bb

## 2. Llm In Engineering Modeling And Bem 2.5.4 Co-Simulation Co-simulation in BEM involves the concurrent use of multiple simulation tools, each specialized in a particular domain, to provide a comprehensive analysis of a building's energy performance. For instance, while EnergyPlus might be used to simulate the overall energy consumption of a building, a separate tool might be employed to model occupant behaviors based on the simulated building environment [10, 11]. The integration of LLMs in co-simulation processes can streamline the coordination between these tools. LLMs can potentially understand the intricacies of each tool and ensure that data is seamlessly transferred and interpreted across platforms. However, challenges arise in co-simulation. Ensuring real-time synchronization between different tools, managing data consistency, and handling potential conflicts in overlapping domains are all intricate tasks. Additionally, the sheer diversity of tools, each with its own set of assumptions, parameters, and output formats, can complicate the integration process. 2.5.5 Simulation Knowledge Extraction and Training Efficient and comprehensive documentation and training pose a significant challenge in BEM. Consider EnergyPlus as an instance; substantial efforts have been invested by federal agencies, professional organizations, and companies to create helpful resources. However, most training and tutorials of EnergyPlus limited to the form of 1) static and web-based documentation, 2) online and offline training sessions, 3) question-and-answer site, and 4) online encyclopedia. Since LLMs are revolutionizing how we understand and interact with the documentation and the tutorials of expert software through their ability to generate, reorganize, and present information in an intelligent and user-friendly manner, they are not only simplifying the use of complex software but also enhancing the learning experience for users of all levels. The result is to provide a more inclusive, efficient, and effective learning and documenting experience for BEM. Besides, through the fast-developing BEM technologies, the topic of an up-to-date knowledge is extremely relevant and important. LLMs can stay updated with new knowledge, so they can always provide accurate information and support, something that static documentation can struggle with. 2.5.6 Simulation Optimization Optimizing a building's energy performance is a multifaceted endeavor, drawing heavily on the processes detailed in earlier sections. At its core, optimization refines the myriad parameters that define a building's energy model to achieve the best possible outcomes. For instance, while Section 2.5.1 discussed how an LLM can assist users

88521d0d-b069-428e-8b92-438141717fae

## 2. Llm In Engineering Modeling And Bem fast-developing BEM technologies, the topic of an up-to-date knowledge is extremely relevant and important. LLMs can stay updated with new knowledge, so they can always provide accurate information and support, something that static documentation can struggle with. 2.5.6 Simulation Optimization Optimizing a building's energy performance is a multifaceted endeavor, drawing heavily on the processes detailed in earlier sections. At its core, optimization refines the myriad parameters that define a building's energy model to achieve the best possible outcomes. For instance, while Section 2.5.1 discussed how an LLM can assist users in defining parameters based on their descriptions, in the context of optimization, the LLM's role shifts slightly. Using the building's façade example, instead of merely interpreting a user's description, the LLM might proactively suggest specific parameters, such as windowto-wall ratio, glazing type, or solar heat gain coefficients, to optimize. These suggestions would be informed by a combination of factors: extensive datasets of similar building configurations and their performance metrics, best practices in architectural and engineering design, historical trends in energy consumption, predictive models of future energy needs, and even feedback loops from real-world building performance post-occupancy. Ultimately, the goal of simulation optimization is to harmonize energy efficiency with building functionality and occupant comfort or well-being. While LLMs can provide invaluable data-driven insights and suggestions, the intricate nuances of building design, occupant behaviors, and real-world conditions underscore the irreplaceable value of human judgment in the decision-making process. As we transition into the case studies, it is essential to emphasize that LLMs are tools designed to augment our expertise, not replace it. Their role is to assist and enhance, while the final decisions and creative insights remain inherently human.

47398f70-a119-4269-9726-98de25b183ad

## 3. Case Studies In this section, we design three case studies to demonstrate the effectiveness of potential LLM applications in BEM. In conducting our case studies, we employ three key methodologies harnessing the capabilities of LLMs: 1) prompt engineering, 2) multi-agent LLMs, and 3) retrieval-augmented generation (RAG). The prompt engineering method revolves around carefully crafting prompts or instructions to guide the LLM in executing desired tasks. This method capitalizes on the LLM's ability to interpret and respond to natural language prompts without requiring specific model alterations. It involves a deep understanding of how the model processes and responds to different types of prompts, and leveraging this understanding to generate accurate and effective outcomes. On the other hand, multi-agent LLMs incorporate multiple LLMs working collaboratively to solve complex problems or perform intricate tasks. This approach capitalizes on the collective intelligence and diverse capabilities of multiple LLMs, allowing for more comprehensive and nuanced problem-solving. Both these methodologies offer unique advantages and can be leveraged according to the specific requirements of the task at hand. While the prompt Engineering method can be utilized quickly and efficiently, the multi-agent LLMs offer superior performance for tasks that demand a combination of specialized knowledge, creativity, and collaborative decision-making, providing a robust solution that often surpasses the capabilities of a single LLM. Lastly, RAG uses the model's advanced natural language processing capabilities to perform in-depth searches, extracting contextually relevant information from vast datasets. This approach is crucial for BEM tasks that require a comprehensive understanding of complex subject matter and the synthesis of data from multiple sources to produce informed and precise conclusions. 3.1 Simulation Input Generation In Section 3.1, we will apply LLM and its relevant techniques to generate and modify Input Data File (IDF) objects and files as the input of EnergyPlus. 3.1.1 Single Object Generation We first use LLM to generate a people object by telling the LLM that "Generate a 'People' object for me. I want it to be defined by 'Number of People' which is set to 10, and set other field values either default or blank." We first directly send this request to LLM without prompt engineering, and the output is shown in Figure 1. In Section 3.1, we use ChatGPT-4 July 6, 2023, Version. The generated people object is partially correct. It can be seen that the key field "Number of People Calculation Method" is

41929d2c-be3f-4d22-88ec-e30844190462

## 3. Case Studies .1 Single Object Generation We first use LLM to generate a people object by telling the LLM that "Generate a 'People' object for me. I want it to be defined by 'Number of People' which is set to 10, and set other field values either default or blank." We first directly send this request to LLM without prompt engineering, and the output is shown in Figure 1. In Section 3.1, we use ChatGPT-4 July 6, 2023, Version. The generated people object is partially correct. It can be seen that the key field "Number of People Calculation Method" is left blank, meaning that LLM does not capture the people calculation method from the prompt. Besides, the value of "Enable ASHRAE 55 Comfort Warnings" is "yes" instead of "no" (default value), which is against the requirement in the prompt. We try to use prompt engineering to improve the accuracy of the object generated. We designed a prompt engineering script shown in Figure 2. *In the first paragraph*, we define "temperature" as a parameter that controls the randomness of LLM's output, with a range from 0 to 1. A lower temperature results in more deterministic responses, essential for rule-based tasks such as EnergyPlus object creation. Therefore, we set the temperature to 0. *In the second paragraph*, we provide ground truth to the task by referring to the IDD file. EnergyPlus object is defined by the IDD file, which provides the structure and format of input data required by the simulation program. *The third paragraph* provide a placeholder for the user's request, in this case, to generate a people object with 10 people. *The fourth paragraph* defines the rules for object generation to (1) guarantee the object aligns precisely with user-defined information and (2) prevent syntax errors by ensuring all obligatory fields are accounted for. Furthermore, we instruct the LLM to annotate field values with comments elucidating the rationale behind its decisions, thereby providing modelers with a transparent view of the LLM's decision-making process. The output with prompt engineering is shown in Figure 3. The output format is correct and the values in all fields follow the rules we defined in the prompt template. Besides, the reasoning behind the value is also correctly explained in the comments and in the generated explanation texts. The accuracy of the output is obviously improved compared with that without prompt engineering. After filling TBD values with actual values,

c8ca1afc-9014-4606-ac8c-eba36114ee09

## 3. Case Studies syntax errors by ensuring all obligatory fields are accounted for. Furthermore, we instruct the LLM to annotate field values with comments elucidating the rationale behind its decisions, thereby providing modelers with a transparent view of the LLM's decision-making process. The output with prompt engineering is shown in Figure 3. The output format is correct and the values in all fields follow the rules we defined in the prompt template. Besides, the reasoning behind the value is also correctly explained in the comments and in the generated explanation texts. The accuracy of the output is obviously improved compared with that without prompt engineering. After filling TBD values with actual values, it can be run in EnergyPlus without any error. Although not explored in this paper, we can further add different types of improvements to the prompt, e.g., "assume the role of the best assistant in IDF object generation", "reason step-by-step and logically at all times", "review generated output in terms of errors and fix them", and "iteratively improve output until it is correct and complete." [12] In summary, we observed the necessity of prompt engineering in creating a specific EnergyPlus object based on natural language input. In terms of the time spent on object creation, the user takes less than a minute to write a prompt in the placeholder of the prompt template we designed in LLM; furthermore, the user does not need the expertise in the IDF object. 3.1.2 Whole IDF Modification We will further investigate whether LLM can deal with the complete IDF file in this section. Since the generation of a complete IDF file requires too much information using the natural language input, we just focus on revising the existing IDF based on user's requirements in the case study. We will use multi-agent LLM techniques. The diagram is shown in Figure 4. It consists of a central LLM agent and several LLM task agents. Central LLM agent communicates with the user, plans sub-tasks, assigns sub-tasks to specialized LLM task agents, aggregates the results from LLM task agents, and sends results to users. The central LLM agent is based on the GPT-4 Advanced Data Analysis plugin (September 25, 2023, Version), which supports the upload of complete idf files. The central LLM agent is based on the following prompt template. You are the central LLM agent in a multi-agent LLMs used to modify idf files based on

167cda2e-54fe-4d23-aec0-91c8dc5b791d

## 3. Case Studies agent and several LLM task agents. Central LLM agent communicates with the user, plans sub-tasks, assigns sub-tasks to specialized LLM task agents, aggregates the results from LLM task agents, and sends results to users. The central LLM agent is based on the GPT-4 Advanced Data Analysis plugin (September 25, 2023, Version), which supports the upload of complete idf files. The central LLM agent is based on the following prompt template. You are the central LLM agent in a multi-agent LLMs used to modify idf files based on user's input. Here are your tasks: 1. Ask for idf files and the modification requirement from user. 2. Based on the user's input, identify the relevant objects and extract them as texts. 3. Send objects in the form of text to the correspondent LLM task agents. 4. Wait for the feedbacks from all agents 5. Aggregate the feedback, correct object reference, and generate a modified idf file and send it to user. The LLM task agents are in the similar structure with the engineered prompt template for people object creation in Figure 2. The only two differences are 1) the placeholder gets input from the central LLM agent, and 2) adding an extra step to return the results to LLM central agent. All agents are defined, coordinated, and connected through AutoGen framework [5]. Microsoft's Autogen is a platform engineered to propel the creation of LLM applications by facilitating multi-agent dialogues. It allows diverse agents to engage in discussions with each other to address tasks, with the agents being adaptable, capable of conversation, and structured to effortlessly accommodate human involvement across different modes utilizing blends of LLMs, human contributions, and tools. In the case study, we use a simplified IDF file from EnergyPlus official document InterfaceDeveloper.pdf Appendix A. Simple IDF file as a starting point. The user's request is shown as follows. Here is the idf file and I want to 1) create a people object for the only zone, 2) add a schedule for exterior lights that starts at 6:00 PM and ends at 6:00 AM, and 3) change the R13 layer to be R15. Below is the excerpt from the generated IDF file. Due to the page limit, we only show schedule and construction since the people object is already shown in 3.1.1. Sche

67e384f6-c9b7-4fe3-bdb0-dd09f5b45650

## 3. Case Studies document InterfaceDeveloper.pdf Appendix A. Simple IDF file as a starting point. The user's request is shown as follows. Here is the idf file and I want to 1) create a people object for the only zone, 2) add a schedule for exterior lights that starts at 6:00 PM and ends at 6:00 AM, and 3) change the R13 layer to be R15. Below is the excerpt from the generated IDF file. Due to the page limit, we only show schedule and construction since the people object is already shown in 3.1.1. Schedule:Compact, NewSchedule, !- Name Fraction, !- Schedule Type Limits Through: 12/31, !- Field 1 For: AllDays, !- Field 2 Until: 06:00,0, !- Field 3 Until: 18:00,1, !- Field 4 Until: 24:00,0; !- Field 5 … Exterior:Lights, ExtLights, !- Name NewSchedule, !- Schedule Name 5250, !- Design Level {W} AstronomicalClock, !- Control Option Grounds Lights; !- End -Use Subcategory … Material:NoMass, R13LAYER, !- Name Rough, !- Roughness 2.64, !- ThermalResistance{m2K/W} 0.9000000, !- Thermal Absorptance 0.7500000, !- Solar Absorptance 0.7500000; !- Visible Absorptance In terms of construction material, although it is still called R13Layer, the thermal resistance is updated from 2.29 to 2.64 m2K/W (R15), which correctly reflect user input. For exterior lighting, the new schedule is correctly created and successfully applied in exterior lights. We observed the effectiveness of multi-agent LLM applications in multiple inputs generation and revisions for BEM, which is a common task for BEM modelers. 3.2 Simulation Output Visualization The case study explores the use of the code generation ability of LLM

8222c150-8d8c-4968-9b7f-a73354c1c4ce

## 3. Case Studies 7500000; !- Visible Absorptance In terms of construction material, although it is still called R13Layer, the thermal resistance is updated from 2.29 to 2.64 m2K/W (R15), which correctly reflect user input. For exterior lighting, the new schedule is correctly created and successfully applied in exterior lights. We observed the effectiveness of multi-agent LLM applications in multiple inputs generation and revisions for BEM, which is a common task for BEM modelers. 3.2 Simulation Output Visualization The case study explores the use of the code generation ability of LLM in postprocessing and visualizing the simulation output of EnergyPlus. The object virtual building in the case study is a reference building: Large Office developed by National Renewable Energy Laboratory. More details of the building can be found in [13]. The simulation weather file is "2B_USA_AZ_PHOENIX.epw." We use the model ChatGPT-4 (July 6, 2023, Version) Code Interpreter in this case study. The prompt is shown in Figure 5, which first provides a background about the source of the CSV file; then, two visualization tasks are specified. Figure 6 shows the first plot LLM generated, which perfectly matches the description of the stacked plot for enduses in every aspect. It is worth mentioning that the year is 1900 because the timestamp in the TMY weather data is 1900. Figure 7 shows the LLM-generated subplots of weather conditions, which is the second visualization request in the prompt. The lines in the subplots are created correctly, but the y labels in those subplots overlap with each other. As a result, a follow-up prompt "the y labels in those subplots just overlapped with each other. Please refine the plot" is further sent to LLM and Figure 8 is the improved version, which LLM explains that it "1) rotates the y-labels by 45 degrees, 2) adds more spacing between subplots, and 3) reduces the font size of the y-labels", which successfully address the overlapping problem. LLM exhibits remarkable accuracy and robustness in visualization when the users clearly understand and describe their visualization objectives. Besides, the human-in-the-loop validation process can also quickly address shortcomings and improve visualization quality. The time taken to process data and generate plots, which is a key index to evaluate

bf589ef7-c49c-4271-96b8-460bcff168a6

## 3. Case Studies is further sent to LLM and Figure 8 is the improved version, which LLM explains that it "1) rotates the y-labels by 45 degrees, 2) adds more spacing between subplots, and 3) reduces the font size of the y-labels", which successfully address the overlapping problem. LLM exhibits remarkable accuracy and robustness in visualization when the users clearly understand and describe their visualization objectives. Besides, the human-in-the-loop validation process can also quickly address shortcomings and improve visualization quality. The time taken to process data and generate plots, which is a key index to evaluate the LLM performance, is significantly reduced from over 15 minutes (based on authors' Python skills) to manually create a Python code to prepare the data for plotting and set the figure configurations, to less than 1 minute to create the prompt by describing the need. Meanwhile, the high accuracy of code generation as well as the fast feedback-based error-fixing feature of LLM make the quality of visualization the same and even better than manual processing. 3.3 Simulation Knowledge Extraction and Training In this case study, we utilize LLM to transform existing knowledge bases into interactive learning platforms, thereby optimizing the educational experience for BEM learners of all proficiency levels by intelligently generating, reorganizing, and presenting information in a user-friendly manner. Specifically, we use retrieval-augmented generation, or RAG, which leverages the synergy of retrieval mechanisms and generative models to dynamically fetch and integrate external knowledge into the response generation process [14]. We use RAG to make BEMcyclopedia (https://bemcyclopedia.com/), a U.S. Department of Energy sponsored BEM information and education portal, more interactive with BEM learners and users. The diagram of RAG is shown in Figure 9. In Indexing Pipeline, we prepare the document by crawling texts from https://bemcyclopedia.com/ and chunking the document into pieces (paragraphs) and generates the embedding (vector representation) for these chunks. The embeddings are then added to a vector database. Indexing Pipeline is a one-time offline process. Next in the Search Pipeline, two steps are involved. Step 1: Vectorize the search query (question) and match it with the most similar text chunks from the Vector Database. Step 2: The LLM is fed with the question and the matching text chunks as context for it to process. This way the LLM only has to

829967dd-b4fc-4313-a3f5-41eba6b313aa

## 3. Case Studies the document by crawling texts from https://bemcyclopedia.com/ and chunking the document into pieces (paragraphs) and generates the embedding (vector representation) for these chunks. The embeddings are then added to a vector database. Indexing Pipeline is a one-time offline process. Next in the Search Pipeline, two steps are involved. Step 1: Vectorize the search query (question) and match it with the most similar text chunks from the Vector Database. Step 2: The LLM is fed with the question and the matching text chunks as context for it to process. This way the LLM only has to most relevant chunks and returns the results in a timely fashion. Since the Search Pipeline is an online process, the two steps are executed each time the user asks a question. To validate the effectiveness, we compare 1) RAG, 2) ChatGPT (September 25, 2023, Version), and 3) manual search in terms of their ability to answer the questions related to the content in BEMcyclopedia. **The question** we design is "what is the purpose of BEMcyclopedia," and the **answer of RAG** is shown as follows. The purpose of BEMcyclopedia is to serve as a free resource for energy modelers to learn about BEM and share knowledge with others. According to the website's About page, the online, open-content platform intends to provide practical guidance to practitioners on how, when, and why to apply BEM at various stages of the design process and how to use such analyses to inform design decisions. The content is organized into two main sections: (1) "Learn by Design Task" which is a collection of educational resources organized around a typical building design project's timeline, and (2) "Essential BEM Concepts" which is a collection of general knowledge and fundamental skills applicable to various BEM tasks. The site's scope is focused on building performance analysis, with a specific emphasis on energy and emissions. This answer is very comprehensive and include content across many parts of BEMcyclopedia. When we ask ChatGPT, the answer is shown as follows. As of my last update in September 2023, I don't have any information about a "BEMcyclopedia." It's possible that it is a specific resource or tool that has been developed after that date, or it could be a niche or specialized resource that hasn't been widely covered in publicly available data. Obviously, GPT-4 model has

5a266444-234e-4d9a-8c5a-b7f015607b41

## 3. Case Studies various BEM tasks. The site's scope is focused on building performance analysis, with a specific emphasis on energy and emissions. This answer is very comprehensive and include content across many parts of BEMcyclopedia. When we ask ChatGPT, the answer is shown as follows. As of my last update in September 2023, I don't have any information about a "BEMcyclopedia." It's possible that it is a specific resource or tool that has been developed after that date, or it could be a niche or specialized resource that hasn't been widely covered in publicly available data. Obviously, GPT-4 model has not included BEMcyclopedia into its training process, which further showcase the advantage of RAG feature of including the latest knowledge. In terms of the **manual search**, we can find in the webpage that BEMcyclopedia was created as a free resource for energy modelers to learn about BEM, and to share their knowledge with others which is far less comprehensive than the answer from RAG. This method can be further extended to 1) BEM software documentations such as EnergyPlus Input Output Reference, and 2) a combination of multiple BEM training and documentation resources.

d8c02726-edc4-4c13-b17e-7ce79a33606b

## 4 Results And Discussion 4.1 Highlighted Observations This paper explores the potential applications of LLM in BEM. The case studies are designed to provide a preliminary examination of each topic. Based on our findings, several observations are highlighted. **First**, the case studies illustrate the efficacy of incorporating LLMs in various BEM tasks. Visualization of simulation output was particularly successful due to LLM's adept code generation capabilities, simplifying data analysis and plotting with Python code. Knowledge extraction and training from simulations required the use of RAG, adding another layer of complexity. The most intricate task was simulation input generation, which demanded the integration of multiple LLMs with prompt templates to create a multi-agent system for modifying IDF files. Overall, despite their preliminary nature, all case studies were successfully executed and achieved their intended outcomes. Second, the case studies demonstrate that selecting the right LLM techniques is essential to enhance performance and reduce engineering efforts. Besides direct use of LLM, three LLM techniques were utilized: 1) prompt engineering, 2) RAG, and 3) multi-agent LLMs. The complexity and nature of tasks dictate the selection of appropriate LLM techniques. As highlighted in Section 3.4, RAG proved superior to the direct use of LLM. Researchers and engineers should pinpoint the most effective approach among LLM techniques for varied tasks, rather than uniformly applying a single method. In summary, for tasks involving code generation, directly utilizing LLMs typically suffices. When external knowledge is necessary, employing RAG and fine-tuning can effectively handle the task at hand. For more complex, multi-step, and hierarchical processes, well-designed prompt engineering and potentially the use of multiagent LLMs are recommended to navigate the intricacy. 4.2 Observed Limitations While the results are promising, certain limitations are evident. **First**, LLMs require significant computational power, leading to high energy consumption and potential financial burdens, especially when dependent on API-based solutions or necessitating investment in computational hardware like Graphics Processing Units. However, the landscape is changing rapidly, with technological advancements ushering in more efficient and cost-effective LLMs. A prime example is the Llama-2 [15] 7B version, which holds the promise of broadening accessibility and application across diverse fields with low computation cost. Second, self-consistency issue, the tendency of the model to provide different or contradictory responses to the same query, was identified as a challenge affecting the reliability and

3c05151b-f680-44b8-b16b-ee1307a96060

## 4 Results And Discussion significant computational power, leading to high energy consumption and potential financial burdens, especially when dependent on API-based solutions or necessitating investment in computational hardware like Graphics Processing Units. However, the landscape is changing rapidly, with technological advancements ushering in more efficient and cost-effective LLMs. A prime example is the Llama-2 [15] 7B version, which holds the promise of broadening accessibility and application across diverse fields with low computation cost. Second, self-consistency issue, the tendency of the model to provide different or contradictory responses to the same query, was identified as a challenge affecting the reliability and accuracy of the results. In the case studies, we addressed this issue by adjusting the "temperature" parameter of the LLM to zero, although further discussions on alternative solutions were beyond our scope. BEM professionals should remain vigilant and account for these potential inconsistencies when leveraging LLMs in applications requiring high accuracy. Research efforts are actively underway to fundamentally improve the self-consistency of LLMs [16]. These theoretical advancements are crucial in paving the way for more reliable LLMs. However, practical measures are just as vital. Employing continuous validation, corroborating with additional data sources, and seeking expert insights are key strategies to mitigate uncertainties and bolster the reliability of results derived from LLMs. Third, the lack of discussion on fine-tuning is a significant limitation of this study. Fine-tuning is a vital aspect of LLMs, especially for tasks that require in-depth domain knowledge. This process involves refining the model on specialized datasets to enhance its performance. A notable example is the development of BloombergGPT [17], which is a specialized LLM for the financial sector, trained on a diverse range of financial data. The idea of creating a similar model, such as "BEMGPT," is intriguing and holds potential for the field of BEM by eliminating the need for RAG and prompt engineering, which reduces computation cost and engineering effort. However, fine-tuning is even more computationally demanding and poses significant challenges in data design and preparation for training. The creation of a domain-specific model like 'BEMGPT' would require meticulously curated datasets that accurately represent the complexities of BEM. This necessity to refine and adapt LLMs to the specific needs of BEM through fine-tuning presents an important future research direction worth exploring. Fourth, we acknowledge the oversight in addressing the challenges associated with processing long sequences of prompts and managing substantial volumes of

8c272610-01c4-4c2c-b06d-4b1690a47329

## 4 Results And Discussion BEM by eliminating the need for RAG and prompt engineering, which reduces computation cost and engineering effort. However, fine-tuning is even more computationally demanding and poses significant challenges in data design and preparation for training. The creation of a domain-specific model like 'BEMGPT' would require meticulously curated datasets that accurately represent the complexities of BEM. This necessity to refine and adapt LLMs to the specific needs of BEM through fine-tuning presents an important future research direction worth exploring. Fourth, we acknowledge the oversight in addressing the challenges associated with processing long sequences of prompts and managing substantial volumes of formatted text inputs in LLM applications for BEM, especially the application of the simulation input generation. This gap highlights a critical area for future research. To mitigate these issues, future work could explore the implementation of a multi-agent LLM framework. Such a system, featuring a central agent for segmenting extensive text into smaller portions for individual processing and subsequent aggregation, could significantly enhance the handling of large-scale text inputs. Furthermore, RAG can include huge amount of external information outside of LLM prompts, which will not be limited by the input length and token limit. Additionally, the potential of LLM such as Claude (www.claude.ai), known for their capability to process long inputs, warrants further investigation. 5. Conclusion This paper explores the integration of LLMs in BEM by examining potential applications identified through a literature review of various modeling techniques. The paper highlights the potential of LLMs to address the significant reliance on expert knowledge in BEM, proposing applications including 1) simulation input generation, 2) simulation output analysis and visualization, 3) conducting error analysis, 4) co-simulation, 5) simulation knowledge extraction and training, and 6) simulation optimization. In case studies, we observed their effectiveness across a range of tasks, from simplifying data analysis with code generation, to integrating multiple LLMs in a multi-agent system for intricate simulation input generation. Crucially, selecting the right technique—be it direct use, prompt engineering, RAG, or multi-agent systems—is paramount to optimize performance and minimize engineering efforts. While LLMs present immense promise, there are challenges, including their significant computational demands and potential self-consistency issues. However, ongoing technological advancements and research efforts are actively addressing these limitations, thereby broadening the scope and ease of LLM applications in diverse fields. In the future, the integration of

9bc67580-4a57-4507-a32f-4e4844d2128b

## 4 Results And Discussion of tasks, from simplifying data analysis with code generation, to integrating multiple LLMs in a multi-agent system for intricate simulation input generation. Crucially, selecting the right technique—be it direct use, prompt engineering, RAG, or multi-agent systems—is paramount to optimize performance and minimize engineering efforts. While LLMs present immense promise, there are challenges, including their significant computational demands and potential self-consistency issues. However, ongoing technological advancements and research efforts are actively addressing these limitations, thereby broadening the scope and ease of LLM applications in diverse fields. In the future, the integration of LLM and BEM will play a crucial role in advancing sustainable and energy-efficient building designs. Collaborative research between AI and building modelers is key to effectively utilizing LLMs in enhancing BEM. This interdisciplinary approach will address the gap between LLM capabilities and the specific needs of BEM, leveraging domain-specific knowledge from model experts alongside the expertise of AI specialists in complex LLM modeling. Although much of AI expertise is currently focused on sectors like medical science and commerce, establishing incentives and raising awareness is necessary to redirect attention and contributions from AI experts to the building sector. The creation of specialized LLMs, such as "BEMGPT," specifically tailored for BEM, holds promise for the future of sustainable building solutions.

b2bec3f0-c5b2-481f-a3c5-7a212af3a606

## Nomenclature AI: artificial intelligence API: Application Programming Interface BEM: building energy modeling HVAC: heating, ventilation, and air conditioning IDD: input data dictionary IDF: input data file LLM: large language model References 1. IEA, I.E.A. *https://www.iea.org/energy-system/buildings*. 2023; Available from: https://www.iea.org/energy-system/buildings. 2. Xiang, X., et al., *Historical decarbonization of global commercial building operations in the 21st century.* Applied Energy, 2022. 322: p. 119401. 3. Wen, H., et al., *Empowering llm to use smartphone for intelligent task automation.* arXiv preprint arXiv:2308.15272, 2023. 4. Crawley, D.B., et al., *EnergyPlus: creating a new-generation building energy simulation program.* Energy and buildings, 2001. 33(4): p. 319-331. 5. Wu, Q., et al., *Autogen: Enabling next-gen llm applications via multi-agent conversation framework.* arXiv preprint arXiv:2308.08155, 2023. 6. Hong, S., et al., *Metagpt: Meta programming for multi-agent collaborative framework.* arXiv preprint arXiv:2308.00352, 2023. 7. Roth, A., D. Goldwasser, and A. Parker, *There's a measure for that!* Energy and Buildings, 2016. 117: p. 321-331. 8. MacNeil, S., et al. Experiences from using code explanations generated by large language models in a web software development e-book. in Proceedings of the 54th ACM Technical Symposium on Computer Science Education V. 1. 2023. 9. Su, Y., et al. *HotGPT: How to Make Software Documentation More Useful with a Large Language Model?* in *Proceedings of the 19th Workshop on Hot Topics in Operating Systems*. 2023. 10. Chen, Z., et al., A Simulation Framework for Analyzing the Impact of Stochastic Occupant Behaviors on Demand Flexibility in Typical Commercial Buildings. 20

c06ef917-c859-4e24-8b8a-2c3bfc1bdf33

## Nomenclature using code explanations generated by large language models in a web software development e-book. in Proceedings of the 54th ACM Technical Symposium on Computer Science Education V. 1. 2023. 9. Su, Y., et al. *HotGPT: How to Make Software Documentation More Useful with a Large Language Model?* in *Proceedings of the 19th Workshop on Hot Topics in Operating Systems*. 2023. 10. Chen, Z., et al., A Simulation Framework for Analyzing the Impact of Stochastic Occupant Behaviors on Demand Flexibility in Typical Commercial Buildings. 2023. 11. Zhang, L., S.M. Haroon, and A. Ryan, Py-Cosim: Python-Based Building Energy Co-Simulation Infrastructure. Available at SSRN 4572925. 12. White, J., et al., *A prompt pattern catalog to enhance prompt engineering with chatgpt.* arXiv preprint arXiv:2302.11382, 2023. 13. Deru, M., et al., US Department of Energy commercial reference building models of the national building stock. 2011. 14. Lewis, P., et al., *Retrieval-augmented generation for knowledge-intensive nlp tasks.* Advances in Neural Information Processing Systems, 2020. 33: p. 9459-9474. 15. Touvron, H., et al., *Llama 2: Open foundation and fine-tuned chat models.* arXiv preprint arXiv:2307.09288, 2023. 16. Wang, X., et al., *Self-consistency improves chain of thought reasoning in language models.* arXiv preprint arXiv:2203.11171, 2022. 17. Wu, S., et al., *Bloomberggpt: A large language model for finance.* arXiv preprint arXiv:2303.17564, 2023.

3f89a6a7-da75-4b76-885e-4057058d9620

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models Ali AhmadiTeshnizi 1 Wenzhi Gao 2 **Madeleine Udell** 1 2

1745fbb9-6484-4e6b-86bc-9e2ee19530c7

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models ## Abstract Optimization problems are pervasive in sectors from manufacturing and distribution to healthcare. However, most such problems are still solved heuristically by hand rather than optimally by state-of-the-art solvers because the expertise required to formulate and solve these problems limits the widespread adoption of optimization tools and techniques. This paper introduces OptiMUS, a Large Language Model (LLM)-based agent designed to formulate and solve (mixed integer) linear programming problems from their natural language descriptions. OptiMUS can develop mathematical models, write and debug solver code, evaluate the generated solutions, and improve its model and code based on these evaluations. OptiMUS utilizes a modular structure to process problems, allowing it to handle problems with long descriptions and complex data without long prompts. Experiments demonstrate that OptiMUS outperforms existing state-of-the-art methods on easy datasets by more than 20% and on hard datasets (including a new dataset, NLP4LP, released with this paper that features long and complex problems) by more than 30%.

b1adb0f2-7c6d-43c2-a9b2-bf7725e8eb89

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models ## 1. Introduction Optimization problems are common in many fields such as operations, economics, engineering, and computer science. Important applications of optimization include reducing energy costs in smart grids, improving supply chains, and increasing profits in algorithmic trading (Singh, 2012; Antoniou & Lu, 2007). Major advances in optimization algorithms over the last several decades have led to reliable and efficient optimization methods for a wide variety of structured optimization problems, including linear programming (LP) and mixed-integer linear programming (MILP), among many others. Unfortunately, optimization modeling, transforming a business problem into a mathematical optimization problem, still requires expert knowledge. According to a recent survey, 81% of Gurobi's commercial solver users have advanced degrees, with 49 % of them holding a degree in operations research (Gurobi Optimization, 2023). This expertise gap prevents many organizations from using optimization, even when it could significantly improve their operations. Examples include inventory management in supermarkets, patient operations in hospitals, transportation policies in small municipalities, energy management in local solar farms, and operations in small businesses or NGOs (Saghafian et al., 2015; Aastrup & Kotzab, 2010; Yao et al., 2020; Shakoor et al., 2016). Automating optimization modeling would allow sectors that cannot afford to have access to optimization experts to improve efficiency using optimization techniques. Large language models (LLMs) offer a promising way to make optimization more accessible. LLMs have demonstrated the ability to understand, generate, and interpret natural language for many tasks. In the optimization domain, LLMs can make it easier to formulate problems and obtain solutions, making expert-level optimization more accessible (Ramamonjison et al, 2023) However, several challenges remain before LLMs can reliably model reallife optimization problems: - **Ambiguous Terms:** An optimization problem can be described in many ways. For example, a user might use different terms (e.g. vehicle vs. car vs. truck vs. carrier), notations (e.g. *price* and *capacity* vs. p and c vs. x and y), or omit common-sense assumptions (e.g. capacity of a vehicle is non-negative, number of employees is an integer, etc.). Moreover, defining the right variables can be a challenge. For instance, information flow through a network requires a different set of variables than physical goods, as the quantity of information need not be conserved. - **Long

3727b95e-dcf1-455d-bd27-d86ce4a43d54

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models ## 1. Introduction in many ways. For example, a user might use different terms (e.g. vehicle vs. car vs. truck vs. carrier), notations (e.g. *price* and *capacity* vs. p and c vs. x and y), or omit common-sense assumptions (e.g. capacity of a vehicle is non-negative, number of employees is an integer, etc.). Moreover, defining the right variables can be a challenge. For instance, information flow through a network requires a different set of variables than physical goods, as the quantity of information need not be conserved. - **Long Problem Descriptions:** LLMs have a limited context size. However, real-world problems can be long and complex: for example, the energy system problem in (Holzer et al., 2023) has a 60-page documentation. produces several products. Each product requires different amounts of raw materials, machine time, and labor. Each product has a price. The factory needs to determine how much of each product to produce to maximize the revenue while not exceeding resource capacities. ���, [1,4,���, 2]] Even for long-context models, performance decreases substantially as the input context grows (Liu et al., 2023). Consequently, LLMs tend to make more mistakes as the length of the problem description increases and perform poorly on complex problems. - Large Problem Data: The specification of an optimization problem often involves large amounts of data, such as customer attributes or sales of goods. Previous approaches to optimization modeling using LLMs, which pass numerical data to the LLM directly, are thus restricted to the simplest of toy problems. - **Unreliable Outputs:** The solutions provided by LLMs are not always reliable. The generated code may be incorrect or even not executable. It is especially challenging to verify the solution when the code runs, but the output is incorrect. For instance, if the code runs and claims that the problem is unbounded, perhaps a constraint has been accidentally omitted from the formulation. Contributions. This paper develops a novel perspective on optimization modeling that addresses each of these limitations and makes the following contributions: - Existing datasets for natural language optimization modeling are too easy to capture the challenge of long problem descriptions and large problem data. This

447e5727-3431-4700-a658-5b9779af3362

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models ## 1. Introduction :** The solutions provided by LLMs are not always reliable. The generated code may be incorrect or even not executable. It is especially challenging to verify the solution when the code runs, but the output is incorrect. For instance, if the code runs and claims that the problem is unbounded, perhaps a constraint has been accidentally omitted from the formulation. Contributions. This paper develops a novel perspective on optimization modeling that addresses each of these limitations and makes the following contributions: - Existing datasets for natural language optimization modeling are too easy to capture the challenge of long problem descriptions and large problem data. This work introduces NLP4LP, an open source dataset of 67 complex optimization problems. Table 1 compares NLP4LP to existing datasets and Section 4.1 describes NLP4LP. - We develop a modular, LLM-based agent to model and solve optimization problems, which we call OptiMUS. OptiMUS beats the previous state-of-the-art methods on existing datasets by over 20% and on our more challenging dataset by 30%. OptiMUS employs a novel connec- tion graph that allows it to process each constraint and objective independently. Using this connection graph, and separating data from the problem description, OptiMUS can solve problems with long descriptions and large data files without excessively long prompts. Structue of the Paper This paper is organized as follows: Section 2 discusses the background and related work; Section 3 describes the details of our LLM-based optimization agent; Section 4 discusses the datasets and presents the experiments and analysis; Section 5 concludes the paper with future directions and implications. The appendix includes prompts, details on the experiments' setup, and further analysis.

47ce2c45-66e5-41af-9d37-c5d0c79a5366

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models ## 2. Background And Related Work Optimization problems are mathematically defined by an objective function and a set of constraints. For example, an MILP can be written mathematically as $\sum_{j=1}^{n}c_{j}x_{j}$ subject to $\sum_{j=1}^{n}a_{ij}x_{j}$ ($\leq,=,\geq$) $b_{i},i=1,\ldots,m$ $l_{j}\leq x_{j}\leq u_{j},j=1,\ldots,n$ $x_{j}\in\mathbb{Z},j\in\mathcal{I}$ An optimization workflow consists of 1) formulating an optimization problem in mathematical form by identifying its objective and constraints, and then 2) solving the realization of problem from real data, generally using code that calls an optimization solver. | Dataset | Description Length | |---------------|----------------------| | NL4Opt | 518.0 | | ± | | | 110.7 | 1101 (0) | | × | | | ComplexOR | 497.1 | | ± | | | 247.5 | 37 (12) | | ✓ | | | N

89263a12-7c98-4c4e-b732-1943782b95e1

# Optimus: Scalable Optimization Modeling With (Mi)Lp Solvers And Large Language Models ## 2. Background And Related Work 1 | | ± | | | 247.5 | 37 (12) | | ✓ | | | NLP4LP (Ours) | 908.9 | | ± | | | 504.6 | 67 (13) | | ✓ | | Progress in LLMs. Recent progress in Natural Language Processing (NLP) has led to the development of large language models (LLMs) useful for tasks such as answering questions, summarizing text, translating languages, and coding. (OpenAI, 2023; Touvron et al., 2023; Chowdhery et al., 2022; Wei et al., 2023; Gao et al., 2023; Borgeaud et al., 2022). Connections to other software tools extend the reach and accuracy of LLMs, as demonstrated by plug-ins for code writing and execution (Paranjape et al., 2023; Wei et al., 2023). (Yang et al., 2023) use LLMs to directly generate solutions to optimization problems without calling traditional solvers through prompt optimization to improve performance. The approach is limited to small problems since the performance of LLMs degrades as the input context grows, even for explicitly long-context models (Liu et al., 2023). Chatbots for Optimization. In a recent paper, Chen et al. (2023) developed a chatbot to help users