A system and method for automatically calculating the number of buildings and machines that predict and generate as-built quantities and details from graph neural networks (GNN) and hostile generation and interpolation models (GAN / GAIN)-based initial design (construction permit) drawings

Abstract

The present invention relates to a system and method for automatically generating a complete and precise bill of materials by learning the structural and logical relationships between design components using a graph neural network (GNN) from heterogeneous design data sources such as 2D CAD drawings, 3D BIM models, and specifications, and by predicting and interpolating the actual quantities to be input at the time of final completion from incomplete initial design data using a generative adversarial interpolation neural network (GAIN). The effects according to the present invention are as follows. First, the present invention precisely interpolates missing attributes using a Generative Adversarial Interpolation Network (GAIN) even in incomplete situations where input data, such as drawings, BIM, and specifications, is heterogeneous and some information (thickness, material, specifications, etc.) is missing. Through this, the reliability and integrity of input data, which forms the basis of quantity calculation, can be dramatically improved even in the initial design stage where data quality is low. Second, active risk management and design quality improvement through learning design change trajectories. Unlike existing methods that simply sum dimensions on drawings or predict only the final result, this invention predicts future change risks in advance by learning the trajectory of design changes through LSTM-based time-series historical analysis. By providing real-time feedback to the designer regarding warnings and alternatives for potential change-inducing factors, it fundamentally prevents unnecessary design changes, maximizes the accuracy of completion predictions, and minimizes the risk of increased construction costs and project delays. Third, it structurally learns the physical support, connectivity, inclusion, and spatial adjacency relationships of a building through a Graph Neural Network (GNN). This enables the automatic generation of a consistent bill of materials that aligns with the structural hierarchy and engineering correlations of the entire building (e.g., the relationship between column load and foundation reinforcement quantity), rather than merely calculating the fragmentary quantities of individual objects. Fourth, by utilizing a Large Language Model (LLM), the generated bill of materials items are double-checked to ensure they logically align with text-based specifications and building codes. By comprehensively evaluating semantic similarity and logical validity, legal and technical risks are minimized by preventing errors in advance where the quantity is correct but the specifications are incorrect (e.g., standard gypsum board vs. fire-resistant gypsum board). Fifth, by applying X-ray Influence Analysis (XAI) technology to the results generated by AI, it explains, using 3D heatmaps and causal text, which object (node) on the drawing is the origin of a specific volume increase. This resolves the 'black box' problem of AI and provides a reliable environment where users can clearly trace the basis of calculations. Sixth, regarding scalability, it enables risk-based estimation by providing multiple scenarios in the form of 'average value + range of variation (confidence interval)' rather than a single predicted value. Furthermore, by linking the calculated quantity data with cost and schedule data, it provides full-cycle project management efficiency that allows for the immediate simulation of the impact of design changes on total construction costs (5D) and construction duration (4D).

Description

Technology Field

[0001] The present invention relates to a system and method for automatically generating a complete and precise bill of materials by learning the structural and logical relationships between design components using a graph neural network (GNN) from heterogeneous design data sources such as 2D CAD drawings, 3D BIM models, and specifications, interpolating missing attributes of incomplete initial design data using a generative adversarial interpolation neural network (GAIN), and predicting and generating the actual quantities to be input at the time of final completion using a generative adversarial neural network (GAN) based on this. Background Technology

[0002] In the traditional architecture and construction industry, the tasks of quantity surveying and preparing Bills of Quantities (BOQ) have relied heavily on manual work that requires a tremendous amount of time and effort. This process is not only labor-intensive, as it requires comparing drawings and specifications one by one, but it is also highly susceptible to human error, which can have a serious impact on subsequent processes such as project bidding, material procurement, and cost management. Consequently, this inefficiency and potential for error have been major causes of cost overruns and schedule delays in construction projects.

[0003] To address these issues, artificial intelligence (AI) technology has recently been introduced into the construction sector, leading to the development of software that automatically extracts material quantities from drawings and specifications. However, these existing systems have an inherent limitation in that they primarily function as sophisticated data extraction tools, and their accuracy is guaranteed only when the input data consists of well-structured BIM models or 2D drawings with clear annotations. In other words, the system's performance depends heavily on the quality and completeness of the input data, and it fails to produce reliable results if information is missing or ambiguous.

[0004] Particularly due to the nature of construction projects, inevitable fluctuations occur between the quantities calculated during the initial design phase and the final quantities (actual settlement details) after the completion of construction and approval for use, caused by site conditions, material supply issues, and changes in client requirements. While existing AI systems can accurately interpret initial design data, they face fundamental limitations in reducing the discrepancy between the initial and final bills of materials because they fail to predict these inherent 'change patterns' that occur during the construction process.

[0005] Meanwhile, although Generative Adversarial Interpolation (GAIN) technology exists to supplement missing data, simply applying it to the generation of construction bills is not effective. This is because each item in the bill is not an independent number but possesses close physical and structural causal relationships, such as how the amount of concrete in a column is related to the amount of rebar. Therefore, a new dimension of artificial intelligence is required that goes beyond simple data interpolation to understand the structural context of the design and learn from the history of past design changes, thereby predicting quantities that are structurally sound and closest to the actual construction results. Prior art literature

[0006] Korean Registered Patent Publication No. 10-2890450 (2025.11.19) The problem to be solved

[0007] The present invention aims to solve the following technical problems.

[0008] First, the present invention defines project metadata, including 2D CAD, 3D BIM, and text specifications as well as the building's use, scale, region, client type, construction period, and construction method, as an integrated learning data schema. In addition, the invention aims to ensure data consistency by incorporating an initial-completion mapping rule into the learning model that normalizes item codes, construction type classifications, units, and conversion factors that appear differently during the initial design and completion stages.

[0009] Second, the present invention aims to predict the quantity / details at the time of final completion of a new project using a conditional generation (interpolation) method, even at the initial drawing stage, by learning the initial design-completion data and design change time series of past projects.

[0010] Third, the present invention aims to automatically supplement (GAIN) missing or unstructured information, ensure engineering consistency of result history by reflecting physical support relationships and logical rules, and provide traceable basis for calculations. means of solving the problem

[0011] To solve the above-mentioned problems, the present invention relates to a system for generating a bill of materials for architectural or mechanical design, comprising one or more processors and a memory for storing instructions executed by said processors, wherein the system comprises: a graph construction unit (200) that receives design data and converts it into a graph structure including nodes representing design components and edges representing relationships between said components; a graph neural network-based context awareness module (300) that generates a context awareness embedding including structural relationship information of said design components by processing said graph structure using a graph neural network (GNN); and an adversarial generative interpolation model (GAN / GAIN) that learns the relationship between the initial design and final completion data of a past project, wherein the GAIN secures integrity by interpolating missing attributes of the input design data, and the GAN generates as-built quantities based on the GNN embedding and interpolation reliability as conditions, and wherein the system comprises a quantity generation module (400) that receives said context awareness embedding as input and generates final quantity data for said design, wherein the design data includes 2D drawings, 3D BIM models, and The heterogeneous data includes specifications in text format, and the system further includes a multi-source data collection unit (100) that collects and preprocesses the design data, and a bill of materials generation and reporting unit (500) that converts the generated quantity data into an industrial standard format and outputs it, and the quantity generation module (400) includes a GAIN-based missing interpolation unit that secures data integrity by interpolating missing attribute information of the input initial design data, and a GAN-based conditional quantity generation unit that predicts and generates potential fluctuating quantities at the time of completion based on the interpolated design data and the situation awareness embedding.The present invention provides an automatic bill of materials generation system using a generative adversarial neural network and a graph neural network, characterized by generating a final bill of materials by mutually complementarily combining current design information interpolated by the missing data interpolation unit and future prediction information generated by the conditional quantity generation unit.

[0012] In addition, regarding a method for automatically generating a bill of materials executed by a computer, the method comprises the following steps: a processor receiving initial design data and converting it into a graph structure including nodes and edges; the processor generating a situational awareness embedding for each node from the graph structure using a graph neural network (GNN); the processor securing data integrity by interpolating missing attributes and intermediate features of the input design data using a generative adversarial interpolation neural network (GAIN); the processor predicting and generating as-built quantity data based on the situational awareness embedding and interpolation reliability using a generative adversarial neural network (GAN); and the processor verifying the consistency between the generated bill of materials data and specifications / regulations using a large language model (LLM). Effects of the invention

[0013] The effects according to the present invention are as follows.

[0014] First, the present invention precisely interpolates missing attributes using a Generative Adversarial Interpolation Network (GAIN) even in incomplete situations where input data, such as drawings, BIM, and specifications, is heterogeneous and some information (thickness, material, specifications, etc.) is missing. Through this, the reliability and integrity of input data, which forms the basis of quantity calculation, can be dramatically improved even in the initial design stage where data quality is low.

[0015] Second, active risk management and design quality improvement through learning design change trajectories. Unlike existing methods that simply sum dimensions on drawings or predict only the final result, this invention predicts future change risks in advance by learning the trajectory of design changes through LSTM-based time-series historical analysis. By providing real-time feedback to the designer regarding warnings and alternatives for potential change-inducing factors, it fundamentally prevents unnecessary design changes, maximizes the accuracy of completion predictions, and minimizes the risk of increased construction costs and project delays.

[0016] Third, it structurally learns the physical support, connectivity, inclusion, and spatial adjacency relationships of a building through a Graph Neural Network (GNN). This enables the automatic generation of a consistent bill of materials that aligns with the structural hierarchy and engineering correlations of the entire building (e.g., the relationship between column load and foundation reinforcement quantity), rather than merely calculating the fragmentary quantities of individual objects.

[0017] Fourth, by utilizing a Large Language Model (LLM), the generated bill of materials items are double-checked to ensure they logically align with text-based specifications and building codes. By comprehensively evaluating semantic similarity and logical validity, legal and technical risks are minimized by preventing errors in advance where the quantity is correct but the specifications are incorrect (e.g., standard gypsum board vs. fire-resistant gypsum board).

[0018] Fifth, by applying X-ray Influence Analysis (XAI) technology to the results generated by AI, it explains, using 3D heatmaps and causal text, which object (node) on the drawing is the origin of a specific volume increase. This resolves the 'black box' problem of AI and provides a reliable environment where users can clearly trace the basis of calculations.

[0019] Sixth, regarding scalability, it enables risk-based estimation by providing multiple scenarios in the form of 'average value + range of variation (confidence interval)' rather than a single predicted value. Furthermore, by linking the calculated quantity data with cost and schedule data, it provides full-cycle project management efficiency that allows for the immediate simulation of the impact of design changes on total construction costs (5D) and construction duration (4D). Brief explanation of the drawing

[0020] FIG. 1 is a diagram showing the overall configuration of the system of the present invention. FIG. 2 is a diagram showing the operation sequence of the present invention. FIG. 3 is a conceptual diagram illustrating the process of generating multiple scenarios by having a missing interpolation unit (GAIN) and a conditional quantity generation unit (GAN) process data complementarily within a quantity generation module (400) according to one embodiment of the present invention. FIG. 4 is an example of an interface screen that provides the analysis results of a backtracking-based variation factor visualization module (700) and a law and specification consistency verification unit (600) to a user according to one embodiment of the present invention. FIG. 5 is a diagram relating to an embodiment of multi-source data collection and preprocessing of the present invention. FIG. 6 is an example diagram illustrating the process of a graph configuration unit (200) according to one embodiment of the present invention converting an object on a two-dimensional architectural drawing into a graph structure including nodes and edges. FIG. 7 is a logical flowchart in which a law and specification consistency verification unit (600) according to one embodiment of the present invention verifies data integrity in a dual path (semantic / logical) by utilizing a massive language model (LLM). Specific details for implementing the invention

[0021] Hereinafter, various embodiments are described in more detail with reference to the attached drawings. The embodiments described in this specification may be modified in various ways. Specific embodiments may be depicted in the drawings and described in detail in the detailed description. However, specific embodiments disclosed in the attached drawings are intended only to facilitate understanding of various embodiments. Accordingly, the technical concept is not limited by specific embodiments disclosed in the attached drawings, and it should be understood that it includes all equivalents or substitutions that fall within the spirit and scope of the invention.

[0022] Terms including ordinal numbers, such as first, second, etc., may be used to describe various components, but these components are not limited by the aforementioned terms. The aforementioned terms are used solely for the purpose of distinguishing one component from another.

[0023] Functions related to artificial intelligence according to the present disclosure are operated through a processor and memory. The processor may be composed of one or more processors. In this case, the one or more processors may be general-purpose processors such as CPUs, APs, and DSPs (Digital Signal Processors), graphics-dedicated processors such as GPUs and VPUs (Vision Processing Units), or artificial intelligence-dedicated processors such as NPUs. The one or more processors control the processing of input data according to predefined operation rules or artificial intelligence models stored in memory. Alternatively, if the one or more processors are artificial intelligence-dedicated processors, the artificial intelligence-dedicated processors may be designed with a hardware structure specialized for processing a specific artificial intelligence model.

[0024] The predefined rules of operation or artificial intelligence models are characterized by being created through learning. Here, being created through learning means that a basic artificial intelligence model is trained using a number of training data by a learning algorithm, thereby creating predefined rules of operation or artificial intelligence models configured to perform desired characteristics (or objectives). Such learning may be performed on the device itself where the artificial intelligence according to the present disclosure is executed, or it may be performed through a separate server and / or system. Examples of learning algorithms include supervised learning, unsupervised learning, semi-supervised learning, or reinforcement learning, but are not limited to the examples described above.

[0025] An artificial intelligence model can be composed of multiple neural network layers. Each of the multiple neural network layers has multiple nodes and weight values, and performs neural network operations through calculations between the results of previous layers and the multiple weights. The multiple weights possessed by the multiple neural network layers can be optimized based on the learning results of the artificial intelligence model. For example, multiple weights can be updated so that the loss value or cost value obtained by the artificial intelligence model during the learning process is reduced or minimized. Additionally, to minimize the loss value or cost value, multiple weights can be updated in a direction that minimizes the gradient associated with the loss value or cost value. Artificial neural networks may include deep neural networks (DNNs), such as Convolutional Neural Networks (CNNs), Deep Neural Networks (DNNs), Recurrent Neural Networks (RNNs), Restricted Boltzmann Machines (RBMs), Deep Belief Networks (DBNs), Bidirectional Recurrent Deep Neural Networks (BRDNNs), or Deep Q-Networks, but are not limited to the examples mentioned above.

[0026] A network is a network that serves as a transmission path for web pages; it may be a closed network such as a LAN (Local Area Network) or WAN (Wide Area Network), but it is desirable for it to be an open network such as the Internet. The Internet refers to a global open computer network structure that provides the TCP / IP protocol and various services existing at its upper layers, namely HTTP (HyperText Transfer Protocol), Telnet, FTP (File Transfer Protocol), DNS (Domain Name System), SMTP (Simple Mail Transfer Protocol), SNMP (Simple Network Management Protocol), NFS (Network File Service), and NIS (Network Information Service).

[0027] The terminal can be implemented in various forms. For example, the terminal described in this specification may be a mobile terminal such as a smartphone, tablet PC, PDA (Personal Digital Assistant), PMP (Portable Multimedia Player), or MP3 Player, as well as a fixed terminal such as a smart TV or desktop computer.

[0028] In this specification, terms such as “comprising” or “having” are intended to specify the existence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof. When a component is described as being “connected” or “connected” to another component, it should be understood that it may be directly connected to or connected to that other component, or that there may be other components in between. On the other hand, when a component is described as being “directly connected” or “directly connected” to another component, it should be understood that there are no other components in between.

[0029] Meanwhile, a "module" or "part" for a component as used in this specification performs at least one function or operation. Furthermore, a "module" or "part" may perform a function or operation by hardware, software, or a combination of hardware and software. Additionally, a plurality of "modules" or a plurality of "parts," excluding a "module" or "part" that must be performed on specific hardware or on at least one processor, may be integrated into at least one module. A singular expression includes a plural expression unless the context clearly indicates otherwise.

[0030] In addition, power, power transmission, and control therefor for the following assembly configurations and embodiments, including "by control," follow conventional technology including terminals, applications, hardware control modules, etc., so they are omitted to avoid redundancy.

[0031] In addition, the operation embodiments and configurations described in a general manner without being explained in detail below follow the prior art and are omitted in order to focus on describing the purpose of the present invention and the resulting effects.

[0032] Furthermore, in describing the present invention, if it is determined that a detailed description of related known functions or configurations may unnecessarily obscure the essence of the invention, such detailed description is abbreviated or omitted.

[0034] The definitions of key terms used in this specification are as follows.

[0035] A Generative Adversarial Network (GAN) refers to a neural network that generates results by simulating a target distribution through adversarial learning between a generator and a discriminator. In this invention, the term is used to include a model that conditionally generates a vector of estimated quantities and a set of bill of materials items at the time of completion, taking design conditions (graph features, text features, and project metadata) as input. The aforementioned GAN is a model that generates quantity data and bill of materials items at the time of final completion (as-built) by receiving GNN embeddings and the interpolation reliability of GAIN as inputs.

[0036] GAIN (Generative Adversarial Imputation Network) refers to a neural network that imparts missing input features or attribute values ​​using an adversarial learning structure. In this invention, it is used to refer to a model designed to enhance data reliability for learning and inference by interpolating missing object attributes (specifications, material, thickness, cross-section / pipe diameter, work type attributes, etc.) or intermediate features required for quantity calculation from heterogeneous data such as drawings, BIM, and specifications. The above GAIN (Generative Adversarial Imputation Network) emphasizes that it is a "neural network that imparts missing input features or attribute values" and is "a model designed to secure the integrity of input data and intermediate features that form the basis of quantity calculation."

[0037] A Quantity Take-off Vector refers to a data set that quantifies quantities (length, area, volume, number, weight, etc.) and equivalent calculation results by work type, component, and item such as equipment, piping, or ducts.

[0039] The present invention relates to a system and method for automatically generating a complete and precise bill of materials by learning the structural and logical relationships between design components using a graph neural network (GNN) from heterogeneous design data sources such as 2D CAD drawings, 3D BIM models, and specifications, and by predicting and interpolating the actual quantities to be input at the time of final completion from incomplete initial design data using a generative adversarial interpolation neural network (GAIN).

[0041] A system according to one embodiment of the present invention may be implemented as a hardware device such as a computing device or a server. The system comprises one or more processors that process data and execute instructions, a memory that stores data and instructions, a network interface that transmits and receives data with an external device, and a storage that stores large amounts of data.

[0042] Here, the processor may include not only a central processing unit (CPU) but also an AI-dedicated accelerator such as a graphics processing unit (GPU) or a tensor processing unit (TPU) for processing high-speed parallel operations of a graph neural network (GNN) and a generative adversarial interpolation neural network (GAIN). The processor performs each step of the present invention by loading and executing instructions of software modules (data collection unit, graph construction unit, GNN module, quantity generation module, etc.) stored in memory.

[0043] Memory includes volatile memory (RAM) and non-volatile memory (ROM, Flash Memory), and temporarily or permanently stores parameters of the running AI model, preprocessed graph data, and generated embedding vectors.

[0044] Through this hardware configuration, the software algorithm of the present invention is converted into a physical electrical signal and executed on an actual computing device.

[0046] FIG. 1 is a configuration diagram of a system for calculating architectural and mechanical design quantities and automatically generating bills of materials based on structural relationships of drawings and bills of materials history using a Generative Adversarial Network (GAIN) and a Graph Neural Network (GNN) and AI according to the present invention. The present invention comprises a multi-source data collection unit (100), a graph configuration unit (200), a graph neural network-based situation recognition module (300), a Generative Adversarial Network (GAN / GAIN)-based quantity generation module (400), a bill of materials generation and reporting unit (500), a law and specification consistency verification unit (600), and a backtracking-based variation factor visualization and explanation module (700).

[0048] The specific details of each component are as follows.

[0050] The multi-source data collection unit (100) is a hardware and software module that receives various types of unstructured or semi-structured data related to architectural and mechanical design and converts them into a structured data form that can be processed by a subsequent stage, a 'graph construction engine'. This unit does not simply save files, but performs a preprocessing process to extract meaningful information within the data and normalize it.

[0052] The above multi-source data collection unit (100) is configured to support a wide range of industry standard file formats, such as the following.

[0053] -2D drawing data: DWG, DXF files created with CAD software such as AutoCAD. Includes information on geometric lines, polylines, blocks, and layers.

[0054] -3D Modeling Data: Files such as IFC (Industry Foundation Classes) and RVT generated by BIM (Building Information Modeling) authoring tools. They contain 3D object information and attribute data.

[0055] - Documentary data: PDF, DOCX, and XLSX files including specifications, bills of quantities (BOQ), etc. It contains text-based non-geometric information such as material specifications, construction methods, and strength.

[0056] -Image data: Scanned drawings or image files in raster format

[0058] This unit performs the following differentiated processing logic depending on the type of input data.

[0059] First, using Optical Character Recognition (OCR) and text parsing functions, notes within specifications or drawings in PDF or image format are converted into text data. Specifically, text such as "All interior walls use GWB Type X" written in the drawings is recognized and extracted as a string. This text is then prepared for mapping to attribute information of specific nodes (e.g., walls) through Natural Language Processing (NLP).

[0060] Second, as a raster image vectorization function, it converts pixel-based scanned drawings or images into CAD-like vector data (lines, curves, coordinates). Specifically, by using image processing algorithms to identify wall lines, column boundaries, and other features and converting them into geometric objects with coordinate values, it enables the computer to recognize the structure.

[0061] Third, as a CAD and BIM data parsing function, it breaks down the internal structure of DWG or IFC files to identify them at the object level. Specifically, CAD analyzes layer names to initially classify lines in the 'A-WALL' layer as 'walls' and blocks in the 'DOOR' layer as 'doors', while BIM extracts object classes such as IFCWall and IFCSlab, as well as the metadata contained therein (volume, fire resistance grade, etc.).

[0062] Fourth, as a data normalization function, it unifies the units of data from different sources and removes noise. For example, if CAD uses millimeters (mm) and BIM uses meters (m), it converts them into a single standard unit and removes noise data such as duplicate lines or unnecessary hatch patterns, making the data optimized for graph generation.

[0063] The final output of the multi-source data collection unit (100) is 'preprocessed intermediate data'. This data is in a combined form of geometric information (coordinates, shape) and non-geometric information (text attributes), and is transmitted to the next stage, the 'graph construction engine', to be used as basic data for conversion into nodes and edges.

[0065] The above-mentioned multi-source data collection unit (100) further includes a project meta-information collection module to construct a project-unit data schema. This performs the role of integrating external variables that affect quantity fluctuations, such as the geographical location of the building, characteristics of the client, and applied special construction methods, into the dataset. Additionally, it includes a data standardization preprocessing module to resolve differences in names and specifications between collected heterogeneous data. This increases the precision of learning by normalizing item codes and units that differ between the design and completion stages, even for identical components, according to standardized conversion factors.

[0067] FIG. 5 is a diagram relating to an embodiment of multi-source data collection and preprocessing of the present invention.

[0068] Referring to the drawing, the multi-source data collection unit (100) receives various types of design data given as input and produces integrated intermediate data suitable for processing in the subsequent graph conversion step. The data types supported by this module are as follows.

[0070] -2D Drawing: Vector drawing files such as AutoCAD's DWG / DXF. Extracts information such as lines, polylines, blocks, and layers from the drawing.

[0071] -3D Model: BIM model files such as IFC, Revit (RVT), etc. Parses 3D objects and attributes (e.g., IfcWall, IfcBeam classes and metadata such as volume, material, etc.).

[0072] - Document Data: Extracts information such as material specifications, construction methods, and strength from text in documents / spreadsheets (PDF, DOCX, XLSX) such as specifications and existing bills of materials.

[0073] - Image data: Scanned drawings or raster images (JPEG, PNG, etc.). These are the targets for post-processing to be vectorized.

[0075] To process heterogeneous inputs into a single pipeline, the multi-source data collection unit (100) incorporates a preprocessing procedure specialized for each.

[0077] - OCR and Text Extraction: If specifications or drawing notes are provided in PDF / image format, text is extracted using Optical Character Recognition (OCR) technology and passed to the Natural Language Processing (NLP) pipeline. For example, if the drawing image contains the text "All interior walls = 2-ply plasterboard finish," it is read and stored as a string, and then the corresponding attribute is assigned to the wall node.

[0078] - Image Vectorization: In the case of scanned drawings, line detection algorithms identify major line segments and contours and convert them into vector shapes. During this process, techniques such as the Hough transform are used to detect straight lines and curves, and elements such as walls and windows are separated. This converts pixel-based information into a CAD-like format, facilitating structural recognition.

[0079] - CAD / BIM Parsing: For vector drawings (DWG / DXF), it interprets the hierarchical structure. It classifies objects by utilizing layer naming conventions (e.g., "A-WALL" indicates a wall layer), block names, and hatching information. For BIM (3D models), it creates an object list by reading IFC entities and property sets.

[0080] - Data Normalization: Since data from different sources may differ in units and terminology, standardization is performed. For example, if CAD drawings use millimeters and BIM uses meters, the data is converted to a consistent unit system, and duplicate objects are removed and unnecessary information is filtered. Additionally, a code mapping table is applied to replace the same object with a common code if it is referred to by different names (e.g., between design specifications, construction specifications, and BIM attributes). This is crucial for matching items between the design and completion phases, and normalizing item codes and classifications enhances the reliability of the mapping between initial and completion items.

[0081] The preprocessing results are organized into an integrated intermediate data structure. This includes both geometric information (e.g., object coordinates, shape) and attribute information (e.g., text such as material name, specifications, and zoning). In other words, for each object, an object list is created in which numerical attributes extracted from drawings and BIM are linked with text attributes extracted via OCR / NLP. For example, this is a structure such as "Wall #12: Location=(x, y), Length=L, Height=H, Material=Concrete, Thickness=200mm". This data is input into the graph construction unit of the next stage.

[0083] The graph configuration unit (200) is a software module that receives preprocessed intermediate data from the multi-source data collection unit (100) and converts it into a graph data structure (G = (V, E)) composed of nodes and edges. This unit performs the role of integrating fragmented information scattered across heterogeneous data sources (drawings, specifications, etc.) and fusing it into a single structural model.

[0085] The graph configuration unit (200) includes a node generation module, an edge generation module, and a heterogeneous data fusion / integration module.

[0086] The node creation module defines and creates physical objects or logical zones on a design drawing as nodes, which are the vertices of a graph. It also identifies components by analyzing layer names or block attributes in 2D CAD, or object classes in 3D BIM. For example, a polyline in the 'A-WALL' layer of a CAD drawing is converted into a 'Wall' node, and a 'DOOR' block is converted into a 'Door' node.

[0087] In this case, the target objects include not only structural elements such as columns, beams, walls, and slabs, but also non-structural elements such as windows, plumbing, HVAC units, and electrical outlets. Additionally, the node creation module stores attribute vectors extracted from design data in each node. These attribute vectors (data) include information such as material, cross-section dimensions, model number, length, height, and volume.

[0088] The above node generation module stores multidimensional attribute vectors extracted from design data in each node. These attribute vectors include material, cross-section, thickness, strength, level, and location coordinate information. In particular, by combining and storing Spec Text Embeddings—which vectorize unstructured text information from specifications—with the node attributes, the module is configured to ensure that engineering specification information is learned together within the graph structure.

[0090] The edge generation module creates edges, which are the lines of a graph, by defining interactions and relationships between nodes. This is a key step that goes beyond simple geometric adjacency to provide spatiotemporal and structural context.

[0091] The above edge generation module generates subdivided edge types as follows to capture physical and logical correlations between design components.

[0092] -connects_to (connected): Physical connections between pipes and pipes, and between beams and columns.

[0093] -supported_by (supported): Load transfer relationship where a slab is supported by a beam or a wall is supported by a floor (e.g., slab-beam-column)

[0094] - is_part_of (is part of / included in): A dependency relationship where a door or window belongs inside a wall.

[0095] -penetrates: Interference relationships where MEP elements, such as pipes and ducts, pass through a structure.

[0096] - is_located_in: The spatial relationship where an electrical outlet or switch is located on a specific wall.

[0097] -is_adjacent_to(adjacent): A spatially close relationship that does not involve physical contact

[0098] -is_in_zone(spatial_hierarchy): A logical constraint relationship included in a specific floor or zone

[0100] Attributes are assigned to the edges themselves to specify the nature of the connection (e.g., welded joint, bolted joint, etc.).

[0102] The heterogeneous data fusion / integration module merges information derived from different sources into the attributes of a single node. For example, when creating a specific 'Beam' node, geometric information (length, position) is extracted from coordinate data in a 2D CAD drawing, material strength is extracted by finding the specifications for the member in a text-based specification (PDF) document, and fire resistance rating is extracted from separate schedule data. These three pieces of information are integrated and stored as a single 'Beam Node' attribute value {id: B01, length: 5m, strength: 24MPa, fire_rating: 1hr}.

[0104] The graph construction unit applies predefined mapping rules to convert raw data extracted from heterogeneous source data into nodes and edges of the graph. A specific mapping and conversion process according to one embodiment of the present invention is as follows.

[0106] First, the graph construction unit identifies objects by analyzing layer information within a 2D CAD drawing file. For example, if a polyline object included in the 'A-WALL' layer on the drawing is detected, the system defines and creates it as a 'Wall' node. At this time, the geometric information of the polyline is analyzed to extract attribute data such as {id: W01, length: 10m, height: 3m} and store it in the node; if non-geometric information such as material is not present in the drawing, the initial value is set to null. Additionally, if the system recognizes through spatial analysis that a line segment of the wall is in contact with a line segment of another wall (e.g., W02), it creates an edge of type 'connects_to' between the two nodes to represent structural connectivity.

[0107] In addition, objects inserted in the form of blocks within the drawing are also converted into separate nodes. For example, when a block insertion object named 'DOOR' is identified, the system creates it as a 'Door' node. The block's attribute information is parsed to assign specific attribute values ​​to the node, such as {id: D01, type: 'Single-Flush', width: 900mm}. Furthermore, the system determines that the insertion coordinates of the corresponding door block are located on the coordinate line of the previously created Wall node (W01). In this case, to define a dependent relationship where the door is included in the wall, an edge of type 'is_part_of' is created extending from the Door node to the Wall node.

[0108] This system integrates not only geometric information but also specification data in text format. For example, when a text sentence such as "All interior walls use GWB Type X" is parsed from a specification PDF file via OCR and natural language processing, the system interprets it as a graph update command. The graph configuration unit searches for a Wall node (e.g., W01) corresponding to an "interior wall" among the nodes existing in the graph and updates the node's empty Material attribute from null to "GWB Type X." This demonstrates the process of heterogeneous data (drawings and documents) being fused within a single node.

[0109] When a 3D BIM model (e.g., an IFC file) is input, the system performs mapping based on object classes. The 'IFCWall' object is converted into a 'Wall' node, and the rich metadata contained in the BIM model (e.g., {volume: 9m³, fire_rating: '60min'}) is brought in as node attributes. In establishing relationships, the system analyzes 3D spatial coordinates to recognize that the bottom of the wall object is in contact with the top surface of the slab object. Accordingly, it creates an edge of type 'supported_by' indicating that the Wall node is physically supported by the Slab node (S01), thereby reflecting the structural dynamic relationship in the graph.

[0111] Referring to Fig. 6, the process of converting an architectural drawing object into a graph structure (G=(V, E)) for artificial intelligence learning is described in detail.

[0113] The left side of the drawing is an example of a conventional 2D CAD floor plan, in which objects such as columns, beams, walls, pipes, and doors are represented by geometric line segments and symbols. The conventional method recognizes only this shape information, but the graph configuration unit (200) of the present invention redefines it into a structural graph like the one on the right through a central graph transformation process.

[0115] Specifically, in the graph on the right, each object is converted into a node with a unique ID. For example, column objects in the drawing are created as 'C1' nodes, beam objects as 'B1' nodes, and wall objects as 'W1' nodes, respectively.

[0117] The relationships between nodes are defined by edges representing physical and logical correlations, and are created in the following specific types as illustrated in the diagram.

[0119] - Supported by: Represents a load transfer path where a column (C1) physically supports a beam (B1), and the beam (B1) in turn supports a wall (W1), etc.

[0120] -Inclusion(is_part_of): Expresses an inclusion relationship where the door (D1) is installed inside the wall (W1) and is dependent.

[0121] - Penetrates: Represents the interference relationship where the equipment piping (P1) passes through the wall (W1) which is a structure.

[0122] -Connects(connects_to): Represents the continuity of fluid flow where pipe (P1) is connected to another pipe (Pipe).

[0124] Furthermore, as illustrated in the Detail Box at the bottom right, each node stores not only simple shape information but also attribute data such as 'Material (Concrete)' and 'Specifications (200mm)'. In particular, by embedding the 'Spec_Vector'—which is a vectorized version of unstructured text information extracted from specifications—into the node attributes, a data structure is completed that enables a Graph Neural Network (GNN) to integrally learn structural context and text specifications.

[0126] Additionally, the graph configuration unit (200) may further include a structural consistency constraint engine that verifies whether the quantity and structural results generated by the AI ​​model are physically valid. Based on predefined physical constraint rules and optimization algorithms, the engine detects structurally impossible generated results, such as broken load-bearing paths or failure of the specifications of major structural parts to meet minimum engineering standards, and automatically corrects or removes them, thereby ensuring engineering reliability for the final output of the system.

[0128] The graph neural network-based situation recognition module (300) is a computational software module that receives a graph data structure (G = (V, E)) generated by the graph configuration unit (200) and processes it through a graph neural network (GNN), which is a type of deep learning algorithm.

[0129] Here, a Graph Neural Network (GNN) refers to an artificial intelligence model designed to process non-Euclidean graph structure data in which relationships between objects are complexly intertwined, rather than Euclidean data such as images or text. While existing CNNs (Convolutional Neural Networks) are specialized in processing pixel information in a grid structure, GNNs are specialized in propagating information and learning along connection relationships in a structure composed of nodes and edges, making them a model optimized for the present invention to identify the structural relationships of buildings.

[0130] The core objective of this module is to transform initial node data, which contains only simple geometric information or text attributes, into context-aware embeddings that imply the overall design context and structural dynamics.

[0132] The graph neural network-based situation recognition module (300) performs a message delivery algorithm, aggregation and update operations, and embedding generation functions.

[0133] The first step is the message delivery and aggregation process. During this process, each node collects information about neighboring nodes connected to it via edges. For example, a 'Beam' node receives information in message form regarding the 'Column' node that supports it and the attribute information of the 'Slab' node that it supports. At this stage, the importance of the information can be adjusted by assigning different weights based on the edge type (e.g., connected_to, supported_by). This is not merely a simple summation of data, but a process of identifying the role of the object through its relationship with surrounding structures.

[0134] Second is the node state update process. Each node updates its state vector by combining information aggregated from neighbors with its own current state information. This process is repeated across multiple layers. As the layers deepen, each node incorporates information not only about its directly connected neighbors but also about the neighbors of its neighbors. Through this, local design information is expanded into the global context of the entire design.

[0135] Third, the situational awareness embedding is generated. Through an iterative learning process, the vector value of each node that is finally output contains high-dimensional situational information in the form of a mathematical vector, such as "a column that supports 30% of the building load, is located at the main entrance, and requires aesthetically important finishing," going beyond simple information such as "a column that supports 30% of the building load." This embedding vector serves as a decisive judgment criterion for the quantity generation module (400), which will be described later, to predict the details.

[0137] In addition, this module can be combined with recurrent neural networks such as LSTM (Long Short-Term Memory) to consider temporal context. If there is a history of design changes, past graph snapshots are analyzed as a time series to extract information on the pattern (trajectory) of how the design has changed, and this is additionally reflected in the final embedding to improve the accuracy of the prediction.

[0138] This module is combined with recurrent neural networks such as LSTM (Long Short-Term Memory) to consider temporal context, and performs active design change management functions beyond simple data extraction.

[0139] The time series analysis sub-module included in this module learns the trajectory of design changes in past projects to predict potential change risks that may occur in new projects. If the current design progress resembles specific change patterns that caused past surges in volume or delays in the project schedule, the system operates as a module that immediately warns the designer and suggests alternatives to minimize the risk.

[0140] The system analyzes the evolutionary path of designs based on past revision data to independently identify chronological causal relationships, such as "if a piping route is initially designed in form A under specific uses and structures, there is a high probability that it will change to form B during the construction phase." Through this, it provides optimal guidance to suppress volume fluctuations and minimize design changes from the initial design stage to the final completion point.

[0142] The graph neural network-based situation recognition module (300) of the present invention may further include a time series analysis submodule including a Recurrent Neural Network (RNN), particularly a Long Short-Term Memory (LSTM) or Gated Recurrent Unit (GRU) algorithm, to capture the dynamic flow of design changes occurring during the project progress, rather than just analyzing static drawing information at a single point in time.

[0144] Construction projects undergo numerous modifications and changes, ranging from the initial plan to the basic design, detailed design, and shop drawings during the construction phase. The present invention utilizes this history of changes not merely as a record, but as information on the trajectory of the design's evolution.

[0146] The specific operating principle is as follows. First, it involves the configuration of time-series graph snapshots. The system sorts the design data of previously completed projects by revision date to generate multiple graph sequences (G_t0, G_t1, ..., G_tn).

[0147] Here, G_t0 represents the initial design, and G_tn represents the final completed drawing. Second is the extraction of temporal feature vectors. Embedding vectors (H_t0, H_t1, ...) extracted for each time point via a Graph Neural Network (GNN) are sequentially input into an LSTM network. The LSTM remembers design state information from previous time points and combines it with the input from the next time point to perform calculations, ultimately outputting a 'temporal feature vector' that indicates how the design has been refined or modified over time. Third is the improvement of prediction accuracy based on change patterns. When a new project is input, the trained LSTM model analyzes the design progress to date to predict potential future change risks.

[0148] For example, the learning model independently identifies a time-series causal relationship, such as, "If a piping route in a building for a specific purpose is initially designed in form A, it tends to be changed to form B during the construction phase, resulting in a 20% increase in volume." Through this time-series analysis configuration, unlike existing technologies that simply learn only the final result value, the present invention can provide more realistic and precise final quantity prediction results by gaining insight into the historical context of design changes.

[0150] The graph neural network-based situation recognition module (300) or a separate time series analysis unit learns the trajectory of design changes to perform active risk management beyond simple prediction.

[0151] The trained LSTM model analyzes the design progress of a new project by comparing it with past change patterns to detect in advance risk factors likely to trigger future design changes. If a surge in volume or a risk of project delay is anticipated in a specific area, the system warns the designer and supports the reduction of design changes at the source by recommending design alternatives that minimized risk in similar past projects.

[0153] The Generative Adversarial Network (GAN / GAIN)-based quantity generation module (400) is an artificial intelligence module that receives a situation awareness embedding vector generated from the graph neural network-based situation awareness module (300) as an input (condition) and generates quantity and history data that is most likely to be finally confirmed. This module operates based on a GAN (Generative Adversarial Network) architecture that uses data refined through GAIN and the situation awareness embedding of GNN as conditional inputs. In particular, it predicts the actual final quantity by combining past design change patterns and field variability with the interpolated data as a noise vector (z).

[0154] In addition, it verifies whether the generated quantity matches the engineering / structural context indicated by the GNN embedding.

[0155] The technical reason for adopting GAIN in this invention is that the initial design data of a construction project is inherently in an 'incomplete' state with some attributes missing. In other words, this invention prioritizes ensuring data integrity by interpolating missing attributes (materials, specifications, etc.) and intermediate features that were not finalized in the initial design through GAIN. Based on this data with secured integrity and GNN embeddings, the invention follows the principle in which the GAN predicts fluctuation patterns in the actual quantities to be input at the time of final completion (As-built) and generates a bill of materials.

[0157] The core function of this module is not simple calculation, but rather to ensure data integrity by interpolating missing attributes and intermediate features through GAIN, and to bridge the gap between the 'incomplete initial design' and the 'completed final construction' using learned patterns by generating quantity variations at the as-built stage through GAN. To achieve this, this module is configured to include a generator, a discriminator, and a hint mechanism.

[0159] First, the generator receives a situation recognition embedding output from a graph neural network-based situation recognition module (300) and a mask vector in which quantity information is empty (or undetermined). Based on a database (DB) of learned past projects, the generator interpolates missing attributes through a GAIN algorithm and simultaneously generates a quantity value at the time of completion that is most reasonable in the current design context (embedding) by predicting it through a GAN algorithm. For example, even if detailed rebar placement information is missing in the initial drawing, the generator generates a ton of rebar to be used during actual construction based on embedding information such as 'a column of this size is located at the bottom of a 10-story building'.

[0160] Second, the discriminator is trained to distinguish between a 'virtual completed bill of materials' generated by the generator and a 'real final completion bill of materials' derived from actual past projects. The discriminator verifies whether the given bill of materials data is structurally valid and consistent with the engineering and structural context indicated by the GNN embeddings. If a wooden house design embedding is input and a large quantity of concrete is generated, the discriminator determines it to be fake.

[0161] Third is optimization through adversarial learning. The model is refined through a competitive process in which the generator strives to produce more sophisticated and realistic quantities to deceive the discriminator, while the discriminator attempts to better detect them. Through this process, this module derives an 'actual final completion quantity' that reflects site conditions, material loss rates, and typical design change patterns that are unpredictable by simple arithmetic calculations.

[0163] In other words, the generator of the quantity generation module (400) based on a Generative Adversarial Network (GAN / GAIN) receives a context awareness embedding and a mask vector received from the graph neural network-based context awareness module (300), interpolates (GAIN) the missing attribute values ​​of the bill of materials, and generates a final quantity (GAN); the discriminator receives the generated data and actual completed project data and determines the authenticity under the design structure indicated by the context awareness embedding, thereby predicting a final quantity that corresponds to the structural context of the initial design data.

[0165] A generative adversarial network (GAN / GAIN)-based quantity generation module (400) according to one embodiment of the present invention is functionally subdivided into a missing interpolation unit and a conditional quantity generation unit, and operates complementarily through the following data processing flow.

[0167] First, the missing value interpolation unit operates based on the GAIN (Generative Adversarial Imputation Network) algorithm. It detects missing attribute information (material, specifications, etc.) in the input initial design data and fills it in using learned patterns to ensure data integrity. Specifically, it calculates an 'interpolation reliability index' based on the probability value determined by the discriminator (D) for the value interpolated by the generator (G).

[0168] This unit identifies mask regions where values ​​are missing in the input initial design data matrix (M) and fills the blanks with interpolated values ​​generated by the generator (G) for those regions. At this time, the discriminator (D) determines whether the filled data is original or interpolated, and calculates an interpolation reliability index for each interpolated attribute based on the probability values ​​output by the discriminator during this process. For example, the higher the probability that the discriminator predicts that it is fake (interpolated), the lower the reliability index of the corresponding data is assigned.

[0170] The interpolation reliability index (R) calculated by the above missing interpolation unit is defined as a normalized real value between 0.0 (completely uncertain) and 1.0 (completely certain). Specifically, when the interpolated design data vector is x' and the hint vector is h', the probability value (D(x', h)_i) for each attribute output by the above discriminator (D) is calculated as the interpolation reliability (R_i) for the corresponding missing attribute (i).

[0171] The system defines the following quantitative confidence intervals based on the calculated reliability score and utilizes them in subsequent processes.

[0172] - High Confidence Interval (R≥0.8): A state where the density of historical similar design data is high, making it highly likely that the interpolated attributes match the actual completion data.

[0173] - Medium confidence range (0.4 ≤ R < 0.8): Reference data exists, but due to variability between projects, scenario review is required during conditional generation. - Low confidence range (R < 0.4): Reference data is insufficient due to new construction methods or special design elements, and the uncertainty of prediction results is very high, making manual review by experts essential.

[0174] In addition, the conditional quantity generation unit (GAN) has a variance (σ) of the quantity data output according to the interpolation confidence (R). 2 Dynamically controls ). Specifically, the variance of the generated scenario is σ 2 GAN It has the relationship ∝ 1 / (R + e) ​​(where e is a small constant to prevent the denominator from becoming zero), and through this, as the reliability decreases, the influence of the noise vector (z) is amplified to create multiple scenarios that set a wider range of possible risks.

[0176] An example of interpolation reliability calculation and application according to one embodiment of the present invention is as shown in [Table 1] below.

[0177] Design Components (Node) Interpolation target attribute Discriminator output (probability) Interpolation reliability score (R) Predicted quantity scenario width Transfer (G-105) Rebar spacing 0.92 0.92 (High Reliability) Narrow (precise prediction) Underground exterior wall (W-201) Waterproofing material thickness 0.45 0.45 (medium reliability) Usually (scenario provided) Special air conditioning equipment (M-01) Device power consumption 0.28 0.28 (low confidence) Wide (reflects maximum volatility risk)

[0179] Second, the conditional quantity generation unit operates based on the Generative Adversarial Network (GAN) algorithm and receives design data corrected by the aforementioned missing data interpolation unit and the situational awareness embeddings of the GNN as input conditions to generate actual quantities and bill of materials items expected at the time of final completion. This unit performs Monte Carlo simulation by combining a noise vector (z) randomly extracted from the latent space with the aforementioned condition vector.

[0180] The generator of this unit receives as input a condition the combination of the completed design feature vector output by the missing interpolation unit and the interpolation reliability index. Specifically, the generation unit generates a final quantity by combining a noise vector (z) randomly extracted from the latent space with the condition vector.

[0181] At this time, the system performs a Monte Carlo simulation that outputs slightly different results even under the same design conditions by resampling the noise vector (z) multiple times (N times) and inputting it.

[0182] If the input interpolation reliability metric is low (when uncertainty is high), the system is trained to increase the variance of the generated results, thereby generating multi-scenario data that includes the ranges of optimistic predictions (minimum variability) and pessimistic predictions (maximum variability).

[0184] Finally, the system applies a 'clamping' policy to items with fixed numerical values ​​in the initial design data by applying an observation mask or a fixed gate to prevent the generated result from altering the initial value of the corresponding item. Through this, the current design information confirmed by the missing value interpolation unit is integrated with the future fluctuation prediction information generated by the conditional quantity generation unit to create a final statement that reflects future risks while forcibly preserving the consistency of the initial design.

[0186] The present invention adopts a strategy of complementarily fusing the powerful pattern learning capabilities of Generative Adversarial Networks (GANs) and the data integrity preservation technology of Generative Adversarial Interpolation Networks (GAINs) to accurately predict data variability between the 'initial design' and 'final completion' of an architectural project.

[0188] General Generative Adversarial Network (GAN) technology excels at learning complex non-linear data distributions and has a strong advantage in generating latent patterns, such as field variables (loss rates, construction errors, etc.) not specified in design drawings. However, methods that generate data from random noise have limitations in terms of reduced precision due to the risk of distorting the unique numerical information of the input initial design drawings.

[0190] On the other hand, GAIN (Generative Adversarial Imputation Network) technology is specialized in filling in only the missing parts of data and has a strength in maintaining the consistency of input data; however, if the blanks are filled simply by the statistical average of surrounding values, it may not adequately reflect the dynamic variability of construction sites.

[0192] Accordingly, the present invention combines the advantages of the two technologies in a mutually complementary manner. Specifically, the system of the present invention utilizes the adversarial learning mechanism of GANs to learn the 'patterns of fluctuation in construction volume relative to design' that occurred in thousands of past projects. This goes beyond simple statistical trends, enabling the AI ​​to acquire high-dimensional generative rules regarding how volume increases or decreases depending on the structure and use of the building.

[0194] At the same time, the system applies GAIN’s masking and hinting mechanisms to apply the variation patterns learned by the AI, while forcing the confirmed initial design quantity to be preserved exactly as it is without ever being modified.

[0196] In other words, it is a structure that predicts 'future fluctuations' using the capabilities of GAN and preserves 'current design values' using GAIN technology. Through this mutually complementary combination, the present invention enables the simulation of actual settlement details (As-built BOQ) from the design stage to the time of completion, and provides the effect of achieving significantly higher precision and prediction accuracy than existing simple calculation methods or statistical correction methods.

[0198] The quantity generation module (400) of the present invention further includes the following control mechanism to increase the precision of the prediction and ensure engineering feasibility.

[0199] First is the scenario width (variance) control rule based on the interpolation reliability metric. The interpolation reliability metric calculated by the missing data interpolation unit (GAIN) is utilized as a weight to determine the output variance of the conditional quantity generation unit (GAN). Specifically, for items with low interpolation reliability and high uncertainty, the influence of the noise vector (z) is amplified to set a wide scenario width (variance), while for items with high reliability, the variance is narrowly restricted, thereby dynamically adjusting the confidence interval of the predicted values. This forms the basis for ultimately providing the user with risk-based multiple scenarios in the form of 'mean value + range of variation (confidence interval)'.

[0200] The quantity generation module (400) ensures statistical significance for Monte Carlo simulation results obtained through N-times resampling of the noise vector (z). Specifically, it calculates the mean and standard deviation of the generated quantity distribution and dynamically applies a 95% confidence interval when the R score is greater than or equal to a threshold (0.8), and a 99% confidence interval when the R score is less than the threshold, thereby determining the range of variation of the scenario. The system extracts optimistic (lower limit), neutral (average), and pessimistic (upper limit) scenarios from among these and provides them to the user along with risk indicators.

[0201] Second is a fixed value protection policy designed to preserve the consistency of the initial design data. The system prevents clear numerical information already established in the initial design drawings from being arbitrarily modified during the AI ​​generation process. To achieve this, observation masks or fixed gates are applied; by forcibly fixing regions within the GAN-generated output where initial observations exist to the original design values ​​and combining only future variations, the consistency of the initial design is absolutely maintained.

[0202] Third is a physics and rule-based 'structural consistency constraint engine.' A structural constraint engine is included as an example to verify whether the quantities and items generated by the AI ​​are engineeringly valid. Based on physical constraints such as the continuity of load-bearing paths and minimum strength regulations for each member, the engine ensures the engineering consistency of the design by filtering out structurally impossible generated results or modifying them through optimization algorithms.

[0204] The aforementioned structural consistency constraint engine executes a step-by-step control logic consisting of penalty application, filtering, and regeneration to ensure the engineering validity of the generated quantities and items. First, the penalty logic applies a weighted penalty to the corresponding loss function when results violating physical constraints—such as disconnected load-bearing paths or substandard specifications of major structural parts—are produced during the AI ​​model's training or optimization phases. This induces the model to autonomously learn the range of engineering validity. Second, the filtering logic automatically identifies non-conforming results among the multiple scenarios generated during the inference phase that do not satisfy minimum engineering standards (e.g., minimum reinforcement ratio per member, lower limit of concrete design strength, etc.) and immediately excludes them from the final list of candidate items. Third, the regeneration logic undergoes a process of resampling the noise vector (z) associated with the relevant node to regenerate quantity data that satisfies physical consistency if valid scenarios are not secured through the filtering or if structural contradictions in specific areas are detected.

[0205] As a specific embodiment, if the quantity of reinforcing bars for a specific transfer beam object is predicted to be below the engineering minimum threshold relative to the upper load, the system determines this as a structural risk scenario and imposes a penalty; and after filtering the scenario, it regenerates the quantity until it passes the consistency criteria, thereby ensuring the engineering reliability of the final output.

[0207] Referring to FIG. 3, the data processing process of the present invention is broadly divided into a missing interpolation step and a conditional generation step.

[0208] First, the input matrix (M) is initial design data and is input to the missing values ​​interpolation unit (GAIN) with some attribute values ​​missing and thus 'missing values'. The missing values ​​interpolation unit outputs complete data by filling in these gaps using learned patterns.

[0209] At this point, an interpolation reliability index representing the uncertainty of the corresponding interpolated value is calculated based on the discriminator's judgment. Subsequently, the Conditional Quantity Generation Unit (GAN) receives the completed data and the interpolation reliability index as input conditions, and performs a final operation by combining them with a random noise vector (z) extracted from the latent space. During this process, through the resampling of the noise vector (z), the system ultimately outputs a multi-scenario result value that includes optimistic and pessimistic scenarios, rather than a single result. This visually demonstrates the core mechanism of the present invention, which ensures data completeness while simultaneously including future uncertainties within the prediction range.

[0211] The statement generation and reporting unit (500) is a user interface (UI / UX) and reporting software that converts and provides high-dimensional vector-shaped prediction data output by a generative adversarial network (GAN / GAIN)-based quantity generation module (400) into an industry standard document format that the user can intuitively understand and utilize.

[0213] The above statement generation and reporting unit (500) performs the following functions.

[0214] First is the data inverse transformation and formatting function. Normalized numerical data processed within the AI ​​model is converted into actual physical units (e.g., m). 2 It converts to ( , ton, ea). In addition, the predicted items are automatically classified and assigned codes according to a standard classification system specified by the user, such as CSI MasterFormat, NRM2 (New Rules of Measurement), or domestic construction cost calculation standards.

[0215] Second is the automatic Bill of Quantities (BOQ) generation function. It aggregates classified items to create summary tables by work type, floor, and room, and exports them in Excel, PDF, or ERP system-compatible formats (XML, JSON). The generated BOQ goes beyond a simple quantity sheet to include traceability information regarding which design drawing object each item originated from. Third is the provision of a visual review and modification interface. When a user reviews a generated BOQ, clicking on a specific item highlights the corresponding object (node) on the linked 2D drawing or 3D model viewer. Additionally, it supports a 'Human-in-the-loop' function that displays a confidence score for AI-predicted values, encouraging experts to directly verify and correct items with low confidence (e.g., cases where the design is ambiguous and prediction deviations are large).

[0217] A system according to one embodiment of the present invention may further include a cost and process integration simulation module (not shown) that automatically calculates the construction cost budget and estimated construction period of the project based on the 'final predicted quantity data' calculated through the Generative Adversarial Network (GAN / GAIN)-based quantity generation module (400).

[0219] While existing estimation systems used a static method of multiplying unit prices by confirmed drawing quantities, this invention reflects 'potential future volume increases' predicted by AI, thereby enabling more realistic risk-based budget and process management.

[0220] The specific operation process is as follows.

[0221] First, there is a dynamic budget (5D) calculation function. The system maps the predicted quantity for each work item classified in the bill of materials generation and reporting unit (500) to the pre-established 'material and labor cost unit price database'. At this time, the unit price data can be adjusted by reflecting the inflation rate or regional markup coefficient.

[0222] Through this, the system goes beyond a simple Bill of Quantities (BOQ) to generate execution budgets by work type, and presents construction costs for multiple scenarios, such as 'optimistic budget' and 'pessimistic budget,' based on the possibility of design changes predicted by AI.

[0223] Second is the project duration (4D) prediction function based on process volume. The system links the calculated quantity data with the Critical Path Method (CPM) system. The quantity of each member (node) (e.g., concrete pouring volume m) 3 The time required for the corresponding task is automatically calculated by dividing ) by the productivity index of the standard cost estimation.

[0224] For example, if a GAN model predicts that the volume of rebar in a specific area will increase by 20% compared to the original design, the system increases the time required for the rebar assembly process in proportion, thereby warning in advance of changes in the overall critical path and the risk of completion delays.

[0225] Third is the automatic mapping of WBS / CBS codes and ERP integration. The generated quantity and cost data is automatically converted into standard Work Breakdown Structure (WBS) and Cost Breakdown Structure (CBS) codes used by the construction company's Enterprise Resource Planning (ERP) system or Project Management Information System (PMIS) and transmitted.

[0226] This ensures data continuity, allowing predictive data from the design phase to be immediately utilized as basic data for resource procurement planning and progress management during the construction phase. Through this extended configuration, the present invention can be expanded beyond a simple quantity calculation tool into a full-cycle construction project management platform capable of integrally simulating and optimizing project costs (5D) and schedules (4D) from the initial design stage.

[0228] The present invention further includes a law and specification consistency verification unit (600), and the law and specification consistency verification unit (600) is an artificial intelligence module based on a massive language model (LLM) that receives preliminary bill of materials data primarily generated by the bill of materials generation and reporting unit (500) and text-based specifications and related building code data collected by the multi-source data collection unit (100), determines whether there are logical contradictions between them, and verifies the integrity of the final data.

[0230] This unit operates by adopting a Large Language Model (LLM) as its core engine. Here, a Large Language Model (LLM) refers to a deep learning model based on a Transformer architecture that possesses billions of parameters and is pre-trained on a vast amount of text data to achieve human-level language understanding and generation capabilities. While existing Natural Language Processing (NLP) technologies were limited to the level of 'keyword matching'—determining the presence or absence of specific words—LLM differs fundamentally in that it can grasp the context surrounding a sentence and infer logical causal relationships embedded in the text. This invention utilizes these characteristics of LLM to interpret complex constraints in specifications written in unstructured text and to qualitatively verify whether the generated numerical details comply with them.

[0232] The above-mentioned law and specification consistency verification unit (600) specifically includes a text vectorization and indexing module, a compliance inference engine, and a consistency score calculation module, and its specific operating principle is as follows.

[0234] Through a text vectorization and indexing module, specifications and regulatory documents composed of unstructured text are divided into paragraphs and embedded and stored in a vector database. At the same time, each item in the bill of materials is also converted into a text description and utilized as a search query.

[0236] When a bill of materials item generated through a compliance inference engine (e.g., "Waterproofing agent for the exterior walls of the first basement floor: Asphalt Primer") is input, related specification clauses (e.g., "All exterior walls of the basement must use penetrating waterproofing agents") are searched in the vector DB using a k-nearest neighbor (k-NN) algorithm based on cosine similarity. The searched clauses and the generated bill of materials item are input as prompts into the LLM to infer whether the two pieces of information logically match, contradict, or are irrelevant.

[0238] To determine the reliability of generated statement items, the consistency score calculation module performs a multi-stage verification procedure that does not simply evaluate a single condition, but sequentially calculates two independent indicators—semantic similarity and logical validity—and makes a final judgment by weighted summing them. The specific calculation and judgment process proceeds in the following chronological order.

[0240] First, the system receives the generated item (T_gen) and the searched specification / regulatory clause (T_spec) as input, and calculates the following two detailed indicators respectively.

[0241] The first step is the calculation of a vector space-based semantic similarity index. The system converts the item text and the specification text into high-dimensional embedding vectors, respectively, and then calculates the cosine similarity between the two vectors. This value is derived as a normalized numerical value between 0 and 1.

[0242] The reason for setting this is not to determine whether the texts correspond superficially, but to determine how contextually they refer to the same object. Additionally, a value closer to 1 indicates that the two texts are linguistically synonyms or very closely related, while a value closer to 0 indicates that they refer to different materials or construction methods.

[0244] Second is the step of calculating the logical validity probability indicator based on LLM. The system inputs two texts into a large language model (LLM) to extract a conditional probability value for the question, "Does the item logically satisfy the constraints of the specification?" Specifically, it instructs the LLM to output a confidence score between 0 and 1, or normalizes and quantifies the probability of generating tokens that determine 'suitable / unsuitable'.

[0245] The reason for establishing this is that simple vector similarity has limitations in distinguishing differences in 'numerical values ​​(specifications).' For example, while 'Reinforcement D10' and 'Reinforcement D13' are very similar in terms of vectors, 'D10' is incorrect if the specifications stipulate 'use of D13 or higher.' LLM can infer whether such numerical and legal constraints are included. The closer this value is to 1, the more perfectly the item complies with the specifications' standards, strength, and material requirements; conversely, the lower the value, the more likely a violation of the specifications or a logical contradiction has occurred.

[0247] When the two indicators above are calculated, the verification unit linearly combines the two values ​​by applying a pre-set weight ratio (a : 1-a). At this time, the weight a is set to a real number greater than 0 and less than 1.

[0248] Specifically, the 'final consistency verification score' is calculated by performing the operation (semantic similarity × a) + (logical validity probability × (1 - a)).

[0249] When initially set, the value of a is set to a range of 0.4 to 0.6 to balance meaning and logic. However, for projects where numerical precision is important (e.g., steel frame construction), the logical validity weight (1-a) can be increased by the manager setting (e.g., 0.7) so that the score drops significantly if the specifications differ even if the text is similar.

[0251] To aid understanding, the following is an example using actual data.

[0253] -Situation: The specifications state that "all interior walls shall use 12.5mm fireproof gypsum board (Type X)," but the generated bill of materials item is "standard gypsum board 9.5mm."

[0254] -Indicator 1 (Semantic Similarity): Due to the commonality of the word 'gypsum board', a relatively high value of vector similarity, such as 0.85, can be calculated.

[0255] -Indicator 2 (Logical Validity): LLM detects discrepancies in thickness (9.5mm vs 12.5mm) and type (general vs fireproof) and calculates a validity probability as low as 0.10.

[0256] - Final score calculation: When weight a is set to 0.5, (0.85×0.5) + (0.10×0.5) = 0.425 + 0.05 = 0.475

[0257] Judgment result: Assuming the verification pass threshold of this system is set to 0.80, the calculated 0.475 is below the threshold value, so the system classifies the item as 'Fail' or 'Needs review' and outputs a warning to the user.

[0259] Meanwhile, the above verification threshold is set and dynamically adjusted according to the following logic based on the system's operation stage and the importance of the application target.

[0260] First is the statistical setting of the initial threshold value. In the early stages of system launch, the threshold value is derived through ROC (Receiver Operating Characteristic) curve analysis on a pre-established verification dataset. Specifically, the J-statistic point, which is the balance point between the 'true positive rate' and the 'false positive rate,' is set as the initial threshold value (e.g., 0.80) to secure an optimal point that prevents excessive alarms while ensuring that actual errors are not missed.

[0261] Second, variable standard values ​​based on importance are applied. For itemized components corresponding to 'major structural parts (columns, beams, load-bearing walls)' that are directly related to the safety of the building, the standard value is adjusted upward from the standard (e.g., 0.90) to perform stricter verification, while for items with low safety impact, such as simple finishing materials or temporary materials, the standard value is adjusted downward (e.g., 0.70) to enhance operational efficiency. To achieve this, a logic is applied that automatically assigns importance weights by analyzing the classification codes of itemized components.

[0262] Third is dynamic optimization based on user feedback. When a user manually approves an item judged by the system as "inappropriate" by stating "this is not an error," the system utilizes this accumulated feedback data as a reward signal for reinforcement learning. Accordingly, for items with similar patterns in the future, the threshold value is automatically adjusted downwards slightly, or the parameters of the discrimination model are updated to continuously improve the accuracy of validation.

[0264] Unlike conventional technology, which failed to detect specification discrepancies by using only keyword matching or cosine similarity (single condition), the present invention applies a complex computational method that combines similarity and logical probability in a weighted manner, thereby effectively filtering out items that appear similar but fall short of actual construction specifications. By finally approving only items that meet or exceed a threshold value, it provides the effect of significantly improving the legal and engineering reliability of the automatically generated bill of materials.

[0266] Referring to Fig. 7, the process of verifying consistency between regulations and specifications based on a Large Language Model (LLM) is explained in detail.

[0267] The law and specification consistency verification unit (600) of the present invention has a dual verification structure that makes a final judgment through two independent paths, semantic similarity and logical validity, to determine whether the generated bill of contents items match the actual specifications and laws.

[0268] First, in the upper (input) stage, the system receives the generated item (e.g., 'waterproofing agent for the exterior wall of the first basement floor') and the corresponding text data from the specifications and regulations database (Vector DB).

[0269] Subsequently, the data is divided into two branches and processed at the central (double verification path) stage. The first path (left) is the process of text vectorization and similarity calculation. The text vectorization and indexing module converts the input text into high-dimensional embedding vectors and then calculates Cosine Similarity to produce a semantic similarity index (0.0–1.0) that indicates how contextually similar two sentences are. This is intended to identify semantic associations beyond just word matching.

[0270] The second path (on the right) is the LLM compliance inference process. The compliance inference engine inputs data into a large language model along with prompts that instruct it to 'determine logical contradictions.' LLM determines whether specifications, numerical values, and constraints are satisfied through sequential inference and outputs the level of confidence as a logical validity probability. This is intended to detect cases where detailed specifications (e.g., 9.5mm vs. 12.5mm) are incorrect even if the text is similar.

[0272] Finally, in the bottom (final judgment) stage, the consistency score calculation module performs a weighted summation of the two aforementioned indicators. The final score is calculated using the formula '(Semantic Similarity × a) + (Logical Validity × (1-a))'. In the judgment branch, if the calculated final score is equal to or greater than a pre-set threshold, it is judged as 'Suitable (Pass)'; if it is lower, it is classified as 'Review Required (Warning)' or 'Unsuitable (Fail)' to provide a warning to the user.

[0274] The dual-path combining logic according to the present invention performs the following step-by-step operations to simultaneously evaluate the surface similarity and substantial compliance of text.

[0275] First, in the first path (calculation of semantic similarity), the generated item details and specification clauses are each converted into high-dimensional embedding vectors, and then a semantic similarity index (S_sem) is calculated by quantifying the contextual association between the two sentences through cosine similarity calculations. This is intended to capture the semantic similarity of the target materials or construction methods regardless of literal word correspondence.

[0276] Second, in the second path (logical validity inference), the Large Language Model (LLM) infers the logical inclusion relationship between numerical constraints in the specifications (e.g., strength, thickness, dimensions, etc.) and the specifications of the items in the bill of materials to calculate the logical validity probability index (P_log)3. This serves to prevent errors caused by minute differences in dimensions (e.g., D10 vs. D13 rebar) that vector similarity cannot capture.

[0277] Third, the final consistency verification score (CS_final) is a linear combination of the two indicators above using weight a as follows.

[0278] CS_final = (S_sem×a) + (P_log× (1 - a))

[0279] At this time, the weight a can be dynamically adjusted according to the characteristics of the project, and for work items where numerical precision is important, the logical validity weight (1-a) is set upward.

[0281] The workflow for reflecting BOQ items based on the final consistency verification score calculated above is performed as follows.

[0283] 1. Automatic Approval and Reflection (Pass): If the final score is higher than the first threshold value (e.g., 0.85) set in advance, the item is considered accepted, immediately reflected in the BOQ, and assigned an item code.

[0284] 2. Conditional Approval and Expert Review (Warning): If the score is between the second threshold and the first threshold (e.g., 0.60 to 0.85), the system displays the corresponding part as 'review needed' on the user interface and presents the 'correction proposal text' generated by the LLM along with the relevant specification clause to induce manual approval by an expert.

[0285] 3. Non-conformity Handling and Automatic Correction (Fail): If the score is below the second threshold, the item is classified as 'non-conformity' and the creation of the item details is temporarily blocked. The system automatically corrects the item to the correct specifications that comply with the specifications, or sends an alert to the designer requesting design changes or specification supplementation.

[0287] The system may further include a backtracking-based variation factor visualization and explanation module (700), and the backtracking-based variation factor visualization and explanation module (700) is a module that visually identifies, by backtracking, what design element had the greatest influence on the result value for the final predicted quantity calculated by the Generative Adversarial Network (GAN / GAIN)-based quantity generation module (400).

[0289] Deep learning models are typically considered 'black boxes' whose internal computational processes are unknown, but this module uses a technique of backpropagating gradients from predicted results toward input nodes to map the causes contributing to a specific quantity increase to specific objects (columns, beams, slabs, etc.) on the drawings. Through this, users can verify not only the result where the AI ​​simply predicted "100 tons of rebar," but also causal relationships such as "the amount of rebar increased by 15% due to the load burden of the transfer beam on the second basement floor."

[0291] The above-mentioned backtracking-based variation factor visualization and explanation module (700) generates and stores 'XAI backtracking log data' to objectively prove the basis of the AI's prediction. The log data is composed of a schema including {details item ID, output quantity (y_c), list of top contributing nodes, contribution score per node, applied causal relationship template ID, LLM consistency verification score}. This provides a data structure that allows for the time-series tracking of the objects within the drawing that caused the specific quantity variation and their engineering basis during post-verification.

[0293] The above backtracking-based variation factor visualization and explanation module (700) specifically includes a contribution calculation engine, a 3D heatmap mapping unit, and a causal text generator.

[0294] - Contribution Calculation Engine: A computational module that quantifies the influence exerted by each graph node (n) on the final calculated quantity (Y). To do this, the degree of activation of each node is calculated by backpropagating the gradient from the final output layer to the last embedding layer of the GNN.

[0295] Specifically, the engine is configured to derive channel-specific importance weights by performing channel-specific global average pooling operations on gradients backpropagated into multidimensional feature maps, and to calculate each node's unique contribution scalar value by combining these with the node's activation map element by element.

[0296] - 3D Heatmap Mapping Unit: This is a rendering module that converts calculated contribution scores into visual information and displays it on a 3D model. It converts the calculated contribution scores into RGB color codes by applying them to a color transition function ranging from 0 (Blue / Cold) to 1 (Red / Hot), and visualizes this by overlaying it on the surface of the corresponding object in the form of textures or vertex colors in a 3D BIM model viewer. In particular, for objects with importance scores below a threshold, this unit renders them by adjusting transparency values ​​to make them semi-transparent or switching to wireframe mode, allowing the user to intuitively identify the absence of key causes of variation, indicated in red, without surrounding interference.

[0297] - Causal Relationship Text Generator: This module converts numerical heatmap information into natural language sentences that are easy for users to understand. It selects the top k nodes with high contribution and extracts their metadata (attribute information: object type, material strength, number of floors, load conditions, etc.).

[0299] Subsequently, natural language generation (NLG) logic is performed to map the extracted attribute data to slots of a predefined causal relationship description template. For example, data is populated into a template such as "{Object Name} contributes {contribution}% to the increase in quantity due to the characteristics of {Attribute 1} and {Attribute 2}", and specific descriptive text such as "Transfer beams contribute 30% to the increase in rebar quantity due to high load support and dense reinforcement characteristics" is automatically generated and output to a report.

[0301] The contribution calculation engine of the present invention performs a backtracking analysis combining 'sensitivity' and 'activation strength' to quantitatively evaluate the influence exerted by each object (node) on the design drawing on the finally calculated quantity of details. The specific calculation and judgment process proceeds according to the following chronological order.

[0302] First, the system traces back the operation path in the direction of the input data starting from the final transaction quantity (y_c) confirmed in the quantity generation module (400), and extracts the following two key factors for each node.

[0304] First is the step of calculating the node's sensitivity to changes in result values.

[0305] Here, 'sensitivity' refers to the gradient, which is the partial derivative of the final predicted result (e.g., the calculated total amount of rebar) with respect to the feature value of the corresponding node. To extract this value, the system performs a backpropagation algorithm from the output layer's result (y_c) toward the last embedding layer of the GNN, while keeping the model's learning parameters fixed. During this process, the system applies the chain rule to calculate the ratio in which a minute change in the output value (Δy) is correlated with a change in the input node's feature value (ΔA). A large value indicates that even a very slight change in the state of the corresponding node will cause the final quantity to fluctuate significantly. In other words, this gradient value serves as an indicator representing the 'potential influence (magnitude)' that the node can exert on determining the result.

[0307] Second is the step of extracting the structural activation strength of the node itself.

[0308] Here, 'activation strength' refers to the numerical size of the feature map that the corresponding node actually possessed during the forward inference process in which data passes through the model.

[0309] To extract this value, the system applies a data hooking function to the last embedding layer of the GNN during the model's inference phase. Through this, the actual feature vector (A) output by the corresponding node after passing through the activation function is separately cached and stored in memory before backpropagation occurs.

[0310] This is to determine the 'substantial contribution' that cannot be explained by sensitivity alone. Mathematically, no matter how high the sensitivity (gradient) is, if the actual input signal (activation strength) is close to zero (inactive state), that node has not contributed to the result. Conversely, if both sensitivity and the actual activation signal are strongly detected, this proves that the node not only has 'high potential but also played an 'actually important role' in the current situation.

[0312] Once the two aforementioned factors are extracted, the contribution calculation engine combines them to produce a final 'node importance score'. This process follows a sequential procedure of factor-wise multiplication, channel aggregation, and non-linear filtering.

[0313] Specifically, for the multidimensional feature vector of each node, (sensitivity of the corresponding channel) × (activation strength of the corresponding channel) is individually calculated, and then the values ​​of all channels are summed to convert them into a single integrated score. Subsequently, negative removal filtering (applying ReLU function) is performed on the summed result.

[0314] The purpose of this module is to identify and explain to the user the causes (positive contributions) that 'increased' the quantity. Since factors that decrease the quantity (negative values) can cause confusion in analysis, all values ​​less than or equal to 0 are replaced with 0 and ignored, and only nodes with positive values ​​are selected.

[0316] The higher the final score, the more the corresponding node (e.g., a specific column) indicates that it is the direct cause of this quantity prediction (e.g., an increase in rebar quantity).

[0318] To aid understanding, the following is an example using actual data.

[0319] Situation: Assume a situation where the AI ​​predicts the amount of rebar for the basement level 1 transfer beam (G-105) to be 30% higher than that of a standard beam.

[0320] - Factor 1 (Sensitivity): Since the transfer beam is a key section for load transfer, its sensitivity (slope) to quantity fluctuations is measured to be very high at 0.8. On the other hand, a simple partition wall has a low sensitivity of 0.1.

[0321] - Factor 2 (Activation Strength): The GNN recognizes the thick cross-section and rebar arrangement pattern of the transfer beam and outputs a high activation strength of 0.9.

[0322] - Final score calculation: Through the calculation of (0.8 × 0.9), the importance score of the transfer beam is calculated as 0.72. On the other hand, the partition wall is calculated as (0.1 × 0.2) = 0.02.

[0323] Visualization judgment: If the system's visualization threshold is set to the top 10% or an absolute value of 0.6 or higher, transfer objects that obtained a score of 0.72 are highlighted with a 'dark red' heatmap in the 3D viewer, and partition walls with a score of 0.02 are treated as transparent.

[0325] This module (700) sequentially performs the following specific algorithmic procedures to determine the causal relationship of the final calculated quantity.

[0327] 1) Backpropagation path activation and target selection step

[0328] As soon as the quantity generation module (400) calculates and confirms the final transaction quantity (y_c), the system designates the quantity value as the target tensor. At this time, the system switches the model to inference mode or sets the weights to a frozen state for gradient calculation so that the weights of the previously trained neural network are not updated. Afterwards, the system activates the derivative path of the operation graph from the target node of the output layer toward the input layer to complete the preparation for backtracking.

[0330] 2) Factor extraction and contribution calculation step

[0331] The system loads the gradient (sensitivity) passing through the last embedding layer of the GNN during the backpropagation process and the feature map (activation strength) stored in the forward pass into a memory buffer.

[0332] Specifically, for a feature vector having multidimensional channels (k) for each node, element-wise multiplication is performed to derive channel-specific weighted activation values. Subsequently, channel summation or global average pooling is performed to integrate the dispersed channel values ​​into a single scalar value, thereby calculating the unique raw contribution score for each node.

[0334] 3) Non-linear filtering and normalization steps

[0335] The calculated raw scores contain a mixture of quantity increase factors (positive) and decrease factors (negative). To clarify the 'cause' of the variation, the present invention applies the Rectified Linear Unit (ReLU) function to replace negative values ​​less than 0 (factors that decrease or suppress the quantity) with 0 and remove them. Subsequently, a min-max normalization logic is performed to compare the relative magnitudes of the remaining positive values. That is, by converting the scores of all nodes into real numbers between 0 and 1—setting the value of the node with the largest score among all nodes to 1 and the value of 0 to 0—the relative importance ranking among objects is determined.

[0337] 4) Heatmap Mapping and Explanation Output Step

[0338] Nodes whose normalized scores exceed a pre-set visualization threshold (e.g., 0.6) are selected as 'key variation factors'. The 3D heatmap mapping unit matches the IDs of the selected nodes with the object IDs of the 3D BIM model and converts the normalized scores of the corresponding nodes into red-based RGB codes by inputting them into a color transition function. The converted color information is overlaid on the 3D mesh surface of the object in the form of texture or vertex color. At the same time, the causal text generator extracts metadata (attribute information) of the top 3 nodes with the highest importance scores and combines them with a natural language template to generate text such as "The high-load support characteristics of the transfer beam (object name) contributed 0.92 (score) to the increase in rebar quantity" and outputs it to the explanation window of the user interface.

[0340] The above visualization threshold is not a fixed value and is dynamically set to a value that is at least twice the standard deviation or within the 'top 5%' by analyzing the distribution of the total node importance scores.

[0341] This configuration selects and displays only a key minority out of thousands of architectural objects that had a decisive impact on quantity fluctuations, thereby enabling users to intuitively grasp the basis of the AI's predictions and trust them without being distracted by unnecessary information.

[0343] FIG. 4 is an example of an interface screen that provides the analysis results of a backtracking-based variation factor visualization module (700) and a law and specification consistency verification unit (600) to a user according to one embodiment of the present invention.

[0344] Referring to Fig. 4, the user interface screen is largely composed of a 3D visualization area (left) and an analysis and explanation area (right). In the 3D visualization area on the left, specific members (e.g., Transfer Girder) that had the greatest impact on quantity fluctuations (increases) on the 3D BIM model are highlighted and displayed as a 'Red Heatmap'. This enables the user to intuitively identify the object causing the problem within the complex model. In the explanation area on the right, two key pieces of information are provided as text.

[0345] First, as a result of XAI analysis, a causal explanation such as "due to the high load-bearing characteristics of the transfer beam, the amount of rebar increased by 30% compared to the original design" is output as a natural language sentence.

[0346] Second, as a result of LLM verification, the "Pass / Fail" judgment—determining whether the specifications or attributes of the relevant component match specifications and regulatory data—is displayed. Through this screen configuration, users can visually verify the basis for quantities calculated by the AI ​​and review legal and technical consistency on a single screen, thereby ensuring the reliability of their decision-making.

[0348] The method for calculating quantities for architectural and mechanical designs and automatically generating bills of materials according to the present invention consists of a series of steps executed by a processor of a computer device or server (see FIG. 2). Each step is described in detail below.

[0350] S1) Data set preparation step

[0351] The data set preparation step (S1) is a step of collecting and preprocessing historical data of past completed projects for learning. The multi-source data collection unit (100) collects data from the initial design phase and final actual settlement data confirmed after the project is completed for a number of past projects in pairs.

[0352] Input data includes project metadata (building use, scale, region, client type, construction period, construction method, etc.) in addition to 2D / 3D drawings and specifications, and correct answer data is defined as as-built settlement details and design change history (Revision graph sequence).

[0353] To normalize cases where the names, specifications, and units of components differ between the design and completion phases, a preprocessing step is performed by applying item code and construction type classification mapping rules to ensure feasibility.

[0355] In the data set preparation stage (S1), the data schema constructed for learning is configured such that input data and ground truth data form pairs. The input data includes initial permit drawings (CAD / BIM), specifications and regulations, and project metadata, while the corresponding ground truth data is defined as a revision graph sequence containing the finalized As-built (BOQ) and design change trajectory after the actual construction is completed. In particular, by formalizing the causal relationship between the original objects in the design and the actual settlement items at the time of completion through component-specific mapping rules, a learning environment is created in which the final quantity can be directly predicted from the initial drawings.

[0357] Here, the initial-to-completion mapping rule is configured as a hybrid form in which a rule-based method based on engineer knowledge and a statistical and learning-based method utilizing historical data are combined complementarily.

[0359] First, rule-based mapping applies industry standard classification systems (e.g., CSI MasterFormat, domestic construction cost calculation standards) and predefined unit conversion factors. This primarily links raw objects on design drawings with standard item codes in the bill of materials and serves as a basic rule that ensures the accuracy of numerical conversions.

[0361] Second, statistical and learning-based mapping handles unstructured items or project-specific names that cannot be resolved by the aforementioned rule-based method. The system learns the similarity between item names, specification texts, and material attributes from design-completion data pairs of multiple past projects to generate a probabilistic mapping path for determining which item was finalized as a specific item at the time of final completion, even though the item was ambiguous at the time of design.

[0363] Finally, the system integrates rule-based confirmed typical mapping results and learning-based predicted unstructured mapping results to build a 'project integrated mapping schema,' thereby resolving the issues of item classification and unit inconsistency between the design and completion phases and ensuring data consistency of the learning model.

[0365] S2) Graph transformation step

[0366] The graph transformation step (S2) is a step of transforming collected raw data into a graph form containing structural relationships. The graph configuration unit (200) identifies design components (columns, beams, walls, piping, etc.) as nodes from the preprocessed data and defines physical and logical connection relationships (connected, supported, included, etc.) between them as edges to generate graph data (G = (V, E)).

[0367] Each node stores an attribute vector containing strength, level, location information, and specification text embedding information, in addition to specifications, material, and thickness. Structural context information is assigned by subdividing the physical and logical relationships between nodes into support, connect, containment, adjacency, penetration (MEP), and floor / zone relationships.

[0368] Through this process, a simple drawing file is transformed into a dataset containing structural context information regarding 'which members are connected to which members to support loads or perform functions.'

[0370] S3) GAIN learning stage

[0371] The GAIN training step (S3) is a key step for training a graph neural network (GNN) and an adversarial generative interpolation model (GAN / GAIN) using the transformed graph data.

[0372] For GNN training, the load-bearing and spatial adjacency relationships between objects are learned to generate context-aware embeddings containing engineering context rather than simple numerical values.

[0373] GAIN is trained to ensure data integrity by interpolating missing attributes and intermediate features of the initial design data, and GAN performs adversarial learning to generate as-built quantities based on the aforementioned GNN embeddings and interpolation reliability.

[0375] S4) New Project Input Step

[0376] In the new project input stage (S4), the user uploads 2D drawings, 3D models, specifications, and project metadata (purpose, scale, etc.) of the new project for which quantities are to be calculated to the system. The input data includes missing data in a state prior to construction where the final quantity information has not been determined.

[0378] S5) Graph generation and embedding step

[0379] The graph generation and embedding step (S5) is a step of processing new project data into a form that an AI model can understand.

[0380] The graph configuration unit (200) analyzes the input new data to generate a new graph structure (G_new). The graph neural network-based context awareness module (300) processes G_new and converts each design element of the new project into a high-dimensional context awareness embedding vector. The structural characteristics of the building and the context of the spatial arrangement are compressed and stored in this embedding.

[0382] S5-1) Time series history pattern analysis step (not shown in drawing)

[0383] The time series history pattern analysis step (S5-1) is performed when there is a design change history in a new project or when it is necessary to refer to the change patterns of similar past projects.

[0384] The system analyzes the temporal trajectory of the generated graph embeddings by activating the LSTM module, and identifies factors that trigger design changes.

[0385] Going beyond simply extracting feature vectors, it quantitatively predicts the risk of future changes and sends feedback to the designer. If the predicted risk exceeds a threshold, the system identifies the design element causing the risk, issues a warning, and recommends successful design alternatives from the past, thereby supporting proactive design optimization.

[0387] S6) Final Details Prediction Step

[0388] The final specification prediction and interpolation step (S6) is a step in which actual quantities are calculated using a trained AI model. In this step, the Generative Adversarial Network (GAIN) ensures data integrity by interpolating missing attributes (e.g., missing materials, specifications) in the input drawings. Simultaneously, the generator of the Generative Adversarial Network (GAN) combines the structural embeddings of S5 and the time-series features of S5-1 to conditionally generate potential quantity fluctuations expected at the time of completion. Through the fusion of these two processes, a final specification document is completed that reflects future predictions while maintaining the consistency of the initial design.

[0389] The final history prediction and interpolation step (S6) controls the scenario width (variance) of the GAN based on the interpolation reliability index calculated by GAIN, and performs clamping processing through an 'observation mask' or 'fixed gate' so that items confirmed in the initial design are not changed.

[0391] S6-1) Consistency verification and correction step (not shown in drawing)

[0392] The consistency verification and correction step (S6-1) is a step in which a law and specification consistency verification unit (600) verifies the integrity of the preliminary bill of materials generated in the above S6 step. The system inputs the generated bill of materials items and the specification / law text stored in the database into the LLM to determine whether there is a logical contradiction between them. Items for which the consistency score, which is the weighted sum of the previously described 'semantic similarity' and 'logical validity probability', is less than the threshold value are classified as 'review needed', or an automatic correction proposal to the correct specification is generated by the LLM.

[0393] The consistency verification and correction step (S6-1) calculates a 'consistency score' to determine whether items generated through LLM comply with specifications and regulations, and filters out engineeringly impossible results through a structural consistency constraint engine.

[0395] S7) Consistency verification and result reporting stage

[0396] The consistency verification and result reporting step (S7) is a step in which the predicted data is processed and provided in a user-friendly format, and the basis for the prediction is explained. At this time, the prediction results are output as multiple scenarios in the form of "average value + range of variation (confidence interval)" rather than as a single value, and the causes of variation are visualized and provided as a 3D heatmap and causal text (XAI).

[0397] The statement generation and reporting unit (500) inversely transforms the vector-shaped data generated in step S6 into actual physical units (m, m 2 , m 3 It converts into units such as kg, and the system generates a forecast statement classified according to industry standards (such as CSI MasterFormat) and displays it on the screen or outputs it as a file such as Excel. At this time, visual materials showing which object in the drawing each item originated from may also be provided.

[0398] In addition, the statement generation and reporting unit (500) outputs the data generated by the AI ​​in the form of multiple scenarios (optimistic / neutral / pessimistic) rather than a single value. By checking the range of quantities and costs for each scenario, the user can proactively manage risks from the budget planning stage.

[0399] At the same time, for items that are requested by the user or have high importance, a backtracking-based variation factor visualization and explanation module (700) is operated. The module tracks the design object that had the greatest impact on the final quantity calculation using a backpropagation algorithm, visualizes it as a heatmap on a 3D model, and generates text explaining the causal relationship, such as "the amount of rebar increased due to the load burden of the transfer beam," and reports it together with the bill of materials.

[0401] Furthermore, in this stage, a unit for verifying compliance with regulations and specifications (600) is activated to finally verify the legal and technical compliance of the generated bill of materials. This unit utilizes a large language model (LLM) to cross-reference the generated bill of materials items with text-based specifications and building code data. Specifically, it calculates a compliance score by weighting the 'semantic similarity' and 'logical validity probability' between items, and for items where this score is below a pre-set threshold value, it displays a 'review needed' warning or includes a suggestion for correction to the correct specifications in the report. Through this, beyond simple quantity prediction, the final output is transferred to a subsequent simulation stage (S8) after securing engineering integrity that complies with building codes and project specifications.

[0403] S8) Cost and process integration simulation phase (drawing not shown)

[0404] The cost and process integration simulation step (S8) is a step for calculating the project's cost and schedule based on the predicted quantities confirmed in step S6. The system maps the predicted quantity data to the material / labor unit price DB to create an execution budget (5D), and automatically generates the duration on the process schedule (CPM) by converting the quantity for each work type into a productivity index (4D). Through this, the user can simulate in advance the impact of quantity fluctuations on the total construction cost and schedule.

[0405] In the cost and process integrated simulation step (S8), the predicted quantity data is linked in real-time with the cost (5D) and process (4D) data. In particular, when a design change occurs, the impact on the total construction cost and the scheduled completion date is immediately simulated by reflecting the change trajectory predicted by the time series analysis unit, thereby maximizing the efficiency of project management throughout the entire lifecycle.

[0406] The above cost and process integration simulation step (S8) goes beyond simple quantity calculation to perform risk transfer modeling. This includes logic that converts quantity variability predicted by the GAN model into construction delay time and increased construction costs in real time. For example, when a pessimistic scenario for rebar quantity is selected, the period of related activities on the linked CPM schedule is automatically extended, and an execution budget reflecting the price fluctuation coefficient is recalculated, thereby immediately simulating the impact of design changes on the overall economic efficiency and schedule of the project.

[0408] To verify the performance and inventiveness of the system according to the present invention, a comparative evaluation experiment was conducted using actual construction project data, comparing the existing calculation method with the step-by-step model configuration of the present invention.

[0410] First, the experimental results for three major performance indicators comparing the existing simple quantity calculation method (Manual / Rule-based) and the present invention (GNN+GAIN+GAN+LLM) are as shown in [Table 2] below, which compares the performance indicators against the existing method.

[0411] Evaluation Indicators Existing calculation method System of the present invention Improvement effect MAPE (Mean Absolute Percentage Error) 18.5% 4.2% 77% decrease Matching error rate 12.4% 0.8% 93% decrease Pre-blocking rate of items violating regulations 25.0% 98.5% 73.5%p improvement

[0412] Here, MAPE refers to the error between the actual quantity at the time of completion and the initial predicted quantity. This invention has significantly reduced the error rate by precisely predicting on-site fluctuation patterns through the combination of GAIN and GAN. Additionally, the consistency error rate represents the proportion of items containing engineering contradictions, and the pre-blocking rate for regulatory violations indicates the percentage of non-compliance with specifications and regulations that the LLM filters out in advance.

[0414] Second, an ablation study was performed to verify the contribution of each core component of the present invention to the overall performance, and the results are as shown in [Table 3] Analysis of Contribution by Component (Ablation Study) below.

[0415] Model configuration Quantity Prediction Accuracy (MAPE) Legal / Engineering Integrity Score Case 1: GNN Exclusive 12.8% 72.5 points Case 2: GNN + GAN 8.4% 75.0 points Case 3: GNN + GAIN + GAN 4.5% 81.2 points Case 4: GNN + GAIN + GAN + LLM (The present invention) 4.2% 98.8 points

[0416] According to the experimental results, the prediction error decreased when a GAN that learned completion variation patterns was combined with Case 1, which learned only the graph structure. In particular, the precision of quantity prediction improved most significantly when a GAIN that compensates for missing initial data was added (Case 3), proving that ensuring data integrity is key to prediction performance. Furthermore, in the final model including LLM-based validation (Case 4), it was confirmed that a bill of materials at a level suitable for actual construction could be completed by fine-tuning the prediction error while simultaneously maximizing the integrity score.

[0419] Although the present invention has been described above with reference to one embodiment, those skilled in the art will understand that various modifications and changes can be made to the invention without departing from the spirit and scope of the invention as described in the following claims. Explanation of the symbols

[0420] Multi-source data collection unit (100) Graph configuration unit (200) Graph neural network-based situation recognition module (300) Quantity generation module (400) Statement generation and reporting unit (500) Compliance verification unit (600) Backtracking-based variation factor visualization and explanation module (700)

Claims

Claim 1 A system for generating a bill of materials for architectural or mechanical design comprises one or more processors and a memory for storing instructions executed by said processors. The system comprises a graph construction unit (200) that receives design data and converts it into a graph structure including nodes representing design components and edges representing relationships between said components; a graph neural network-based context awareness module (300) that generates a context awareness embedding including structural relationship information of said design components by processing said graph structure using a graph neural network (GNN); a generative adversarial neural network (GAIN) that learns the relationship between the initial design and final completion data of a past project; and a quantity generation module (400) that receives said context awareness embedding as a condition and generates final quantity data for said design. The design data is heterogeneous data including 2D drawings, 3D BIM models, and specifications in text format. The system comprises a multi-source data collection unit (100) that collects and preprocesses said design data, and a bill of materials generation and reporting unit that converts said generated quantity data into an industrial standard format and outputs it. A system for automatically generating a bill of materials using a generative adversarial neural network and a graph neural network, further comprising a unit (500), wherein the quantity generation module (400) includes a GAIN-based missing interpolation unit that secures data integrity by interpolating missing attribute information of input initial design data, and a GAN-based conditional quantity generation unit that predicts and generates potential fluctuating quantities at the time of completion based on the interpolated design data and the situation awareness embedding, and is characterized by creating a final bill of materials by mutually complementarily combining the current design information interpolated by the missing interpolation unit and the future prediction information generated by the conditional quantity generation unit. Claim 2 In claim 1, the graph neural network-based situation recognition module (300) further includes time series history analysis that receives design change history data of past projects as a time series and extracts a temporal feature vector of a change pattern according to the progress of the design using an LSTM or RNN algorithm, and the time series history analysis includes a function that predicts potential design change risks that may occur in the future based on the temporal feature vector, and if the predicted risk level exceeds a threshold, transmits a risk warning to a designer terminal or suggests a design alternative that can minimize the design change risk by referring to the change patterns of similar past projects, and the quantity generation module (400) receives the temporal feature vector as an additional condition and predicts the final quantity reflecting the trajectory of the design change, characterized in that it is an automatic bill of materials generation system using a generative adversarial neural network and a graph neural network. Claim 3 A system for automatically generating statements using a generative adversarial neural network and a graph neural network, characterized in that, in the first paragraph, the missing value interpolation unit interpolates missing attributes and simultaneously calculates an interpolation reliability index representing the uncertainty of the corresponding value, the conditional quantity generation unit dynamically controls the influence of a noise vector (z) such that the variance of the generated multiple scenarios increases as the interpolation reliability index is lower, and the quantity generation module (400) performs a fixed value protection policy by applying an observation mask or a fixed gate to items with fixed values ​​in the initial design data to fix the generated result so that the initial design value of the item is not changed, thereby generating a multiple scenario statement reflecting future risks while maintaining the consistency of the initial design. Claim 4 A system for automatically generating bills of quantities using a generative adversarial neural network and a graph neural network, characterized in that, in paragraph 3, it further includes a module that simulates in real-time the total air delay risk and budget overrun range based on the multi-scenario fluctuation range of the generated quantity, and includes a step of generating and storing backtracking log data including {object ID, contribution score, causal template} which serves as the basis for quantity calculation, and determines the upper and lower limits of the multi-scenario range by differentially applying thresholds of the confidence interval according to the interpolation reliability. Claim 5 In claim 1, the system further includes a law and specification consistency verification unit (600), wherein the law and specification consistency verification unit (600) includes a large language model (LLM) and receives input of preliminary bill of materials data generated by the bill of materials generation and reporting unit (500) and text-based specifications and related building code data collected by the multi-source data collection unit (100), determines whether there is a logical contradiction between them and verifies the integrity of the data, and includes a text vectorization and indexing module that divides the specifications and building code data into paragraph units and embeds them in a vector database, and converts the preliminary bill of materials items into search queries to search for the most relevant reference clauses from the vector database, and a compliance inference engine that calculates a semantic similarity index based on the cosine similarity within the vector space between the preliminary bill of materials items and the searched reference clauses, and inputs the preliminary bill of materials items and the reference clauses into the large language model to calculate a logical validity probability index based on conditional probability or confidence scores regarding logical inclusion relationships, and An automatic statement generation system using a generative adversarial neural network and a graph neural network, characterized by including a consistency score calculation module that calculates a final consistency verification score by linearly combining the calculated semantic similarity index and the logical validity probability index by applying pre-set weights to each, and makes a suitability judgment only when the final consistency verification score is greater than or equal to a pre-set threshold value. Claim 6 delete

Images