System design optimization system and method

Abstract

To provide a system design optimization system and method that can efficiently optimize the design of a target system.SOLUTION: A system design optimization system 1 for optimizing the design of a target system obtains feedback regarding improvements to the target system from stakeholders 1000 of the target system, interprets the obtained feedback for application to the target system, generates a set of instructions to be applied to the target system based on the interpretation results, provides the implementation status of the instruction set to the stakeholders, and continues obtaining feedback on improvements to the target system until approved by the stakeholders.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The present disclosure relates to a system design optimization system and method. [Background technology]

[0002] The field of system design optimization has traditionally relied on computational models to automate and enhance the decision-making process. Traditional system design methods lack continuous oversight by systems engineers or other experts throughout the design process. This poses a significant limitation when optimizing complex target systems with complex dependencies and performance requirements.

[0003] Known system optimization techniques include approximate Bayesian Monte Carlo tree search (ABMCTS) (Patent Document 1). This prior art attempts to automatically optimize design parameters using a sophisticated algorithmic approach. [Prior art documents] [Patent documents]

[0004] [Patent Document 1] US Patent Application Publication No. 2023 / 0088146 Summary of the Invention [Problem to be solved by the invention]

[0005] However, the prior art has the following problems.

[0006] First, there is no direct integration of human expertise and feedback to the target system, which can result in a lack of nuanced insights.

[0007] Second, they may not be able to adapt well to unforeseen design requirements or changes that were not anticipated in the initial model.

[0008] Third, the iterative search and optimization process relies heavily on computational resources, which can be inefficient if the target system is complex.

[0009] Fourth, the algorithm may converge to a local optimum, thus missing a better solution that would require more fundamental design changes.

[0010] Furthermore, the prior art lacks the ability to incorporate timely and detailed feedback from key stakeholders, such as the designers and managers of the target system, making it difficult for the target system design to meet actual needs. The prior art typically does not allow for adjustments to the system design based on new requirements or feedback, which can result in ineffective system design and lengthy development times.

[0011] The present disclosure has been made in consideration of the above-mentioned problems, and aims to provide a system design optimization system and method that can efficiently optimize the design of a target system. [Means for solving the problem]

[0012] In order to solve the above problem, a system design optimization system according to one aspect of the present disclosure is a system design optimization system that optimizes the design of a target system, obtains feedback regarding improvements to the target system from stakeholders of the target system, interprets the obtained feedback in order to apply it to the target system, generates an instruction set to be given to the target system from the results of the interpretation, provides the stakeholders with the implementation status of the instruction set, and obtains feedback regarding improvements to the target system until the stakeholders approve it. [Effects of the Invention]

[0013] According to the present disclosure, feedback regarding improvements to a target system can be obtained from stakeholders, the feedback can be applied to the target system, and the feedback can be repeatedly applied until approval is obtained from stakeholders, thereby enabling the target system to be improved efficiently and appropriately. [Brief explanation of the drawings]

[0014] [Figure 1] FIG. 1 is an explanatory diagram showing the overall configuration of a system optimization system. [Figure 2] 1 is a flowchart showing the overall flow of the system optimization system. [Figure 3] FIG. 10 is a diagram illustrating a method for creating each table. [Figure 4] 10 is a flowchart showing the processing executed by the feedback interpretation unit (FIM). [Figure 5] 10 is a flowchart showing the process performed by a context feedback integrator (CFIM). [Figure 6] 1 is a flowchart showing the process performed by a design enhancement engine (DRE). [Figure 7] 10 is an example of a structured instruction table. [Figure 8] 10 is an example of an executable change instruction table. [Figure 9] 1 is an example of an integrated planning table. [Figure 10] 10 is an example of an action space table. [Figure 11] 1 is an example of a state space table. DETAILED DESCRIPTION OF THE INVENTION

[0015] Hereinafter, embodiments of the present disclosure will be described with reference to the drawings. Hereinafter, embodiments of the present disclosure will be described with reference to the drawings. The following description and drawings are examples for explaining the present disclosure, and have been omitted or simplified as appropriate for clarity of explanation. The present disclosure can be implemented in various other forms. Unless otherwise specified, each component may be singular or plural.

[0016] To facilitate understanding of the invention, the position, size, shape, range, etc. of each component shown in the drawings may not represent the actual position, size, shape, range, etc. The present disclosure is not necessarily limited to the position, size, shape, range, etc. disclosed in the drawings.

[0017] In the following explanation, various types of information may be described using expressions such as "database," "table," and "list," but the various types of information may also be expressed using data structures other than these. To indicate that the information is not dependent on the data structure, "XX table," "XX list," etc. may be referred to as "XX information." When describing identification information, expressions such as "identification information," "identifier," "name," "ID," and "number" are used, and these are interchangeable.

[0018] When there are multiple components with the same or similar functions, they may be described using the same reference numeral with different subscripts. However, when there is no need to distinguish between these multiple components, the subscripts may be omitted.

[0019] In the following description, processing performed by executing a computer program may be described. However, a computer program is executed by a processor (e.g., a CPU (Central Processing Unit), a GPU (Graphics Processing Unit)) to perform a predetermined process using storage resources (e.g., memory) and / or interface devices (e.g., communication ports) as appropriate, and therefore the processor may be the subject of the processing. Similarly, the subject of the processing performed by executing a computer program may be a controller, device, system, computer, or node having a processor. The subject of the processing performed by executing a computer program may be any computing unit, and may include a dedicated circuit (e.g., an FPGA (Field-Programmable Gate Array) or an ASIC (Application Specific Integrated Circuit)) that performs a specific process.

[0020] A computer program may be installed on a device such as a computer from a program source. The program source may be, for example, a computer program distribution server or a computer-readable storage medium. When the program source is a program distribution server, the program distribution server may include a processor and storage resources for storing the program to be distributed, and the processor of the program distribution server may distribute the program to be distributed to other computers. Also, in the following description, two or more programs may be realized as one program, and one program may be realized as two or more programs.

[0021] The present disclosure relates to a technology for optimizing system design. The present disclosure relates to a method for iteratively improving a draft design of a target system using feedback from stakeholders. The system design optimization system of the present disclosure utilizes a reinforcement learning (RL)-based approach to directly incorporate the expertise of system engineers into the design process for optimizing the target system. In this way, the system design optimization system of the present disclosure automatically learns from feedback from experts, such as system engineers, and iteratively evolves the system design.

[0022] The present disclosure does not limit the type of target system. Any type of information processing system can be a target system. The method of the present disclosure can continuously and iteratively improve systems such as financial processing systems, inventory management systems, video distribution systems, e-commerce systems, image processing systems, file sharing systems, sales support systems, learning support systems, drug discovery support systems, railway management systems, power generation control systems, and factory production management systems.

[0023] This disclosure recognizes the important role of systems engineers' knowledge in managing the design process and proposes the following solutions. Furthermore, this disclosure more effectively uses valuable input (feedback) from stakeholders including systems engineers as well as systems engineers. Stakeholders in this specification are those who contribute to the iterative improvement of the target system. Stakeholders are, for example, technical experts on the target system (system engineers), technical consultants on the improvement of the target system, administrators of the target system, users of the target system, etc.

[0024] Typically, systems engineers have the knowledge and experience to improve the design quality and validity of the target system during the design process, but manually updating the design based on feedback is a tedious task, and the more complex the target system, the more difficult it becomes.

[0025] This disclosure introduces a novel RL-based approach that learns from feedback provided by systems engineers. This method trains an algorithm to make better design choices, gradually aligning the target system's design with desired goals over time. The RL component, acting as a "reinforcement learning unit," selects optimal "design update instructions" using a set of "actionable change instructions" created from previous feedback analysis and synthesis. This selection process includes the expert input of systems engineers in an automated design improvement process, helping to ensure that each design update brings the target system closer to its set goals.

[0026] In this way, the disclosed system design optimization system improves upon the prior art by efficiently iteratively refining system designs, saving time and effort and improving the system's ability to adapt to changing needs and expert advice for the target system.

[0027] The invention described herein utilizes stakeholder feedback, as described above, to improve the design of a target system through a process that incorporates systems engineer expertise directly into an automated design refinement process. The method uses advanced natural language processing (NLP), machine learning, and reinforcement learning (RL) techniques to translate stakeholder feedback into tangible, actionable changes to the target system's design.

[0028] The disclosed process begins with the Feedback Interpreter (FIM), which receives detailed technical specifications and feedback from stakeholders (including system engineers) through a structured interface. The FIM analyzes these inputs to identify and quantify desired system performance changes, such as processing speed and latency. These changes are prioritized by the FIM based on the design goals of the target system and their potential impact on the overall performance of the target system.

[0029] The Contextual Feedback Integration Mechanism (CFIM) receives structured and prioritized feedback from the FIM and applies that feedback to specific system components within the target system.

[0030] CFIM performs a detailed analysis of the proposed changes to see how they will affect other parts of the target system. CFIM compares the proposed changes with the current capabilities of the target system to ensure they are feasible. CFIM then creates a detailed, actionable change order and plan showing how best to implement these changes.

[0031] These instructions are fed into a Design Reinforcement Engine (DRE), which uses RL techniques to select the most effective design updates. The DRE has a clear reward function for evaluating the success of different design changes and refines its approach through several rounds to select the action that most improves the design. Over time, the DRE learns from the effects of the changes and continuously improves the design, reflecting the decisions of the system engineers who are the stakeholders. The DRE selects "design update instructions" that are likely to result in the desired improvements within the constraints and requirements of the target system.

[0032] This iterative process allows for continuous learning and adjustment, as DRE continues to improve the design using past updates and ongoing feedback from stakeholders. This results in a continuously improving target system design, benefiting from both the efficiency of machine learning and human expertise. This improvement process is dynamic, adapting in real time to changing system requirements and stakeholder feedback. Thus, the target system design remains flexible and aligned with the project goals of improving the target system.

[0033] Overall, this disclosure provides a powerful framework for iteratively improving system designs in response to stakeholder feedback and based on realistic realities of the target system's operating context. This is a significant advancement in the field of automated system design optimization, leading to greater efficiency, shorter development times, and better alignment of user needs with system performance goals. [Example]

[0034] Example 1 will be described using Figures 1 to 11. Hereinafter, a system targeted by the system design optimization system 1 will be referred to as a "target system" or a "system." In Figure 1, the target system is not labeled with a reference symbol, but the design information for the target system is stored in a system design vector database 1120. As mentioned above, the type of target system that the system design optimization system 1 iteratively improves is not important. In the figures, the database may be abbreviated as DB.

[0035] The system design optimization system 1 is generated using computer resources 10 possessed by a computer. The computer resources 10 include, for example, a processor, memory, a communication unit, and a user interface (UI). The memory includes a main storage device and an auxiliary storage device. Furthermore, the memory may include a storage medium that is detachable from the computer. The storage medium can non-temporarily store a computer program for realizing some or all of the functions of the system design optimization system 1.

[0036] Herein, feedback is defined. Feedback herein includes various types of information for iteratively improving a system design. This feedback comes from the observations, knowledge, and direction of stakeholders (including system engineers) and represents a deep understanding of what the target system needs and what end users need. Feedback serves as data that drives continuous enhancements to the system design and guides each new round of updates. However, the above descriptions are exemplary, and feedback is not limited to the above descriptions. Feedback referred to herein is not limited to these.

[0037] System Requirements: System requirements are detailed technical and functional specifications that describe the goals of a target system. They can be quantitative specifications, such as "The system must process a transaction within two seconds," or quality specifications, such as "The system should have an intuitive user interface."

[0038] Customer needs: Customer needs include the ease of use, reliability, expected performance of the target system, and other factors that affect user satisfaction and ease of use of the system.

[0039] Requirements Update Feedback: Requirements update feedback is information used to adjust the target system's specifications based on new discoveries, advances in technology, and changing end-user needs, keeping the target system's design up-to-date and meeting stakeholder goals.

[0040] Design Update Feedback: Design update feedback are suggested or required changes to the current design prompted by testing results, stakeholder user feedback, or updates required for compliance. These changes help maintain proper functionality and performance of the target system.

[0041] Specification Update Feedback: Specification update feedback is the continuous updating of the target system documentation to reflect the latest design changes, ensuring stakeholders have the most up-to-date information on the target system's functionality and the reasoning behind its design.

[0042] In this specification, feedback is a critical starting point from which the design of the target system is constantly evaluated and enhanced. Feedback is viewed as a strategic resource that guides decision-making throughout the design process, from initial concept to final deployment and beyond.

[0043] The Importance of Systems Engineer Feedback in the Design Automation Process: Feedback from stakeholders, system engineers, provides perspective on the intricate details of the target system's design. With their extensive technical knowledge and practical experience, system engineers provide feedback that ensures the design is technically robust and effectively meets the end-user needs.

[0044] In the process of iteratively optimizing the system design of the present disclosure, the feedback of the system engineer is important for the following reasons.

[0045] This acts as a quality control measure, adding a human element to check and verify automated design decisions.

[0046] They bring specialized knowledge to help identify subtle and complex issues that automated systems might miss or misinterpret.

[0047] It provides real-world insights to help theoretical designs work effectively in practical situations.

[0048] When changes are proposed to a target system, the systems engineer's feedback places these changes within the target system's larger operational context to ensure that these changes do not unintentionally introduce new problems or degrade the target system's performance. In this disclosure, system design is optimized through an iterative process of feedback information involving stakeholders, including systems engineers. The system design optimization system 1 incorporates a series of sophisticated technical components that work together to refine the design according to both technical specifications and the user's nuanced needs. Below, we clarify the structure and function of these components and explain the workflow that leads to an optimized system design, as shown in Figures 1 and 2.

[0049] System Overview Referring to Figure 1, the system design optimization system 1 includes, for example, a stakeholder platform 1010, a large-scale language model (LLM) 1030, a feedback interpretation unit (FIM) 1050, a contextual feedback integration unit 1060, a design reinforcement engine (DRE) 1070, a design agent orchestrator 1080, a system update monitor 1100, a system design vector database 1120, and a design information acquisition unit 1130, each of which will be described below.

[0050] The system design optimization process begins when stakeholders 1000, including systems engineers, input high-level feedback 1020 into a stakeholder platform 1010. As a "feedback receiver," the stakeholder platform 1010 serves as the initial collection point for feedback. This feedback can include broad conceptual ideas or specific technical instructions. The high-level feedback 1020 is forwarded to a large-scale language model (LLM) 1030, a sophisticated algorithm that can process complex input and generate detailed technical specifications 1040. These specifications form the basis for further design iterations. The LLM 1030 is an example of a "large-scale language model."

[0051] These Technical Specifications 1040 are processed by the Feedback Interpretation Unit (FIM) 1050, the primary component tasked with decomposing and analyzing the Technical Specifications. As a "Feedback Interpretation Unit," FIM 1050 uses advanced natural language processing to segment and categorize the Technical Specifications 1040 in order to extract and understand specific performance metrics from them. FIM ensures that the nuances of the language used in the Technical Specifications are correctly interpreted, resulting in a structured, prioritized, and actionable set of instructions.

[0052] The structured output from FIM is then forwarded to the Contextual Feedback Integrator (CFIM) 1060, a "contextual feedback integrator." CFIM 1060's function is to contextually map feedback to the design elements and components of the target system. This mapping identifies where and how the feedback should be applied within the current system setup, pinpointing the specific components, such as the CPU, database, network setup, or algorithm, to which the feedback corresponds. Beyond mapping, CFIM also analyzes dependencies between system components to understand how proposed changes will affect other system components.

[0053] CFIM1060 validates against system constraints, along with dependency analysis, to ensure that feedback-driven proposals are feasible within the operational and technical limits of the target system. For example, CFIM evaluates whether a proposed 20% increase in processing speed is achievable without exceeding thermal and power limits. This step is performed to maintain the integrity of the target system and ensure that the proposed enhancements are theoretically correct and practically feasible. After validation, CFIM1060 evaluates the impact of the proposed changes. This comprehensive assessment evaluates the impact of the changes on system performance, cost, and compliance with established metrics. CFIM utilizes advanced analytical tools to predict the outcomes of proposed changes and support informed decision-making about which optimizations to implement.

[0054] The outcome of CFIM1060's analysis is the generation of a set of actionable change instructions. These instructions, based on the feedback, clearly define the modifications necessary to achieve the desired goals. These instructions include actions such as adjusting server settings, optimizing database queries, or upgrading hardware components to achieve a specific increase in processing speed. CFIM uses advanced algorithms to resolve conflicts between competing objectives and identify changes that maximize the system's overall performance.

[0055] These Actionable Change Instructions are translated into specific tasks for the Design Agent Orchestrator (DAO) 1080 and its array of specialized design agents as the "implementation controller." The Design Agent Orchestrator 1060 coordinates the actions of these agents, ensuring that each change is executed correctly and fits into the overall design strategy.

[0056] The System Update Tracker 1100, acting as an "update tracker," monitors the process of optimizing the system design based on the design draft 1090 received from the DA01060. The System Update Tracker 1100 provides real-time monitoring information to the system engineer to monitor the status of the update to the target system. Tracking by the System Update Tracker 1100 oversees the iterative process and ensures that each design iteration progresses to meet the performance and functional goals of the target system.

[0057] The revised design drafts are stored in a design version database 1110 that records the history of all design iterations. This database 1110 is used to retrieve past designs as needed. The database 1110 provides a chronological context for the design decisions made during the process of optimizing the design of the target system.

[0058] Additionally, the system design optimization system 1 includes a system design vector database 1120. This database 1120 stores information related to the design of the target system, such as industry standards, technical publications, and verified use cases. A design information retriever 1130 accesses this database 1120 to retrieve relevant information and provide it to the target system design process. This ensures that the target system design is always up-to-date and compliant with the latest standards and best practices.

[0059] As shown in Figure 2, the workflow of the overall process P2000 begins when it is initiated (P2010), with stakeholders, including systems engineers, providing high-level feedback 1020 (P2020). The LLM 1030 generates technical specifications 1040 (P2030) from the provided feedback 1020. The FIM 1050 converts these technical specifications 1040 into structured, prioritized instructions (P2040).

[0060] CFIM1060 receives instructions from FIM1060 and converts them into "executable change instructions" suitable for input to DRE1070 (P2050), where a reinforcement learning model learns to select the most appropriate "design update instruction" based on an optimal policy that evaluates the potential success of different design changes (P2060).

[0061] The Design Agent Orchestrator 1080 directs the actions of specialized agents to implement selected design updates (P2070), ensuring systematic and consistent application across components of the target system.

[0062] Throughout this process, the system update monitor 1100 continuously monitors the optimization and provides detailed reports on the progress of the design update to the system engineer (SE) (P2080), ensuring transparency and traceability. Once the design agent orchestrator 1080 implements the changes, a loop is entered to iteratively improve the target system (P2110).

[0063] The updated design is then reevaluated by the systems engineer to determine if it meets the initial requirements (P2090, P2100). This step (P2100) verifies whether the system design is moving in the right direction and whether the changes are producing the desired improvements.

[0064] If the design draft 1080 does not meet the requirements (P2100: NO), further refinements are made (P2110). This loop continues until the system engineer confirms that the design draft meets all the specified requirements (P2100: YES), and finally the final design draft 1080 is completed (P2120).

[0065] The process outlined in Figure 2 embodies a dynamic, feedback-driven approach to optimizing the design of a target system. The System Design Optimization System 1 integrates the expertise of stakeholders, including systems engineers, with advanced artificial intelligence (AI) and machine learning techniques to ensure that the target system design is not only technically robust, but also continuously evolves to meet the nuanced needs and expectations of stakeholders.

[0066] The detailed description above outlines a comprehensive methodology that exemplifies modern system design optimization principles, as illustrated in Figures 1 and 2. This approach effectively refines system designs by adaptively and iteratively incorporating technical insights provided by system engineers to achieve designs that are functional and aligned with user needs.

[0067] Further sections explore the functionality of the Feedback Interpreter (FIM), Contextual Feedback Integration Mechanism (CFIM), and Design Reinforcement Engine (DRE), providing examples of how feedback is processed through these systems to achieve the goal of optimized system design.

[0068] Figure 3 provides an overview of the main part 100 of the process for optimizing the design of a target system. The main part 100 highlights how various data structures are used to translate a technical specification 1040 into an enhanced system design. Figure 3 is a schematic diagram of the workflow, detailing the flow of information through the FIM 1050, CFIM 1060, and DRE 1070.

[0069] The illustrated process begins with the technical specifications 1040, shown in the upper left. These are the fundamental requirements and objectives that the target system design must meet. These technical specifications 1040 are the initial inputs to the FIM 1050 and define the desired functionality and performance metrics of the target system.

[0070] The FIM 1050 processes these technical specifications 1040 using a structured instruction generator 3210, breaking down the complex requirements contained in the technical specifications 1040 and translating them into a set of structured instructions. This step ensures that the technical specifications 1040 are interpretable by subsequent mechanisms within the target system.

[0071] The output from the structured command generator 3210 is organized and recorded in a structured command table T5500 (3410), which converts the structured commands into a coherent format in preparation for the next phase of integration and action planning.

[0072] CFIM 1060 receives organized instructions from FIM 1050 and introduces context through its executable change instruction generator 3310. The instructions generated by generator 3310 are aligned with current system design and operational constraints to ensure each proposed change is feasible and beneficial.

[0073] The output of the generator 3310 is documented and recorded in an actionable change instructions table T6000 (3420). Table T6000 details the specific, actionable steps required to implement the design change. This table T6000 is used to translate high-level instructions into practical actions.

[0074] The consolidated plan generator 3320 creates a consolidated plan table T7000 (3450) to schedule and prioritize executable instructions. Prioritization ensures that the target system is updated in an order that maximizes the efficiency of target system improvements and minimizes disruption to ongoing system operations.

[0075] The DRE 1070 functions as the decision-making core of the main unit 100 and constructs a reinforcement learning environment using the RL initializer 3520. The DRE 1070 includes an action state space generator 3510. The action state space generator 3510 determines the optimal action sequence for the DRE 1070 to learn and improve the system design.

[0076] The action space table T8000 (3430) and the state space table T9000 (3440) are generated by the DRE 1070. Table T8000, shown in Figure 10, represents the range of possible actions. Table T9000, shown in Figure 11, represents various system states. These tables T8000 and T9000 are used by the reinforcement learning algorithm to identify possible design updates that optimize system performance.

[0077] The policy executor 3530 applies the learned policies to generate "design update instructions." These instructions are integrated into the target system design through the design version database 1110, which records each iteration of the system design.

[0078] The design agent orchestrator (DAO) 1080 manages the application of the "design update instructions" and coordinates with various design agents to ensure that changes to the target system are implemented in accordance with the integrated plan table T7000.

[0079] The data store 3400 serves as a central repository for all information generated throughout the optimization process, from structured instructions to the final design version. The data store 3400 is used to maintain data integrity and support the continuous learning and adaptation of the main part 100.

[0080] FIM Explained 4 shows in detail the process (P3000) performed by the Feedback Interpretation Unit (FIM) 1050. When activated (P3010), the process P3000 of the FIM 1050 receives (P3030) the technical specification 1040 derived from high-level feedback and interprets (P3030) it into structured, executable, and quantifiable instructions.

[0081] This explanation uses the example of technical specifications "improve processing speed by 20%" and "reduce waiting time by 30%" (P3020) to clarify the transformation process within FIM and includes a discussion of the mathematical equations and formulas that facilitate this transformation.

[0082] [P3030] Quantitative interpretation of technical specifications: FIM 1050 begins its work by engaging in a quantitative interpretation of the Technical Specification 1040. This step P3030 involves analyzing the language used in the Technical Specification and identifying key performance indicators and their desired changes. This interpretation step is based on language processing algorithms that can identify technical terms and extract specific quantitative targets.

[0083] For the given example, the FIM identifies two main directives:

[0084] (1) Percent (20%) improvement in “processing speed.”

[0085] Action: 'Increase', Subject: 'Processing Speed', Unit: 'By 20%'

[0086] (2) "Latency" is reduced by a certain percentage (30%).

[0087] Action: 'Decrease', Subject: 'Latency', Unit: 'Up to 30%' These instructions are mathematically formalized so that the target system can understand and process them in terms of mathematical operations.

[0088] [P3040] Numerical Metric Conversions: FIM 1050 proceeds to a quantifiable metrics conversion step P3040, which converts the qualitative indications into measurable metrics using mathematical formulas to precisely quantify the intended changes.

[0089] If we want to "improve processing speed by 20%, the transformation can be expressed as the formula: Pt target = P current × 1.20 (Equation 1) Similarly, for "reduce latency by 30%", the current latency (L_current) is used as a baseline and a new latency target (L_target) is calculated: Ltarget=L current×0.70 (Formula 2) These equations are the basis for the subsequent transformation of the specification into structured instructions.

[0090] [P3050] Structured instruction generation: Following the metric transformation, FIM 1050 uses the mathematical results to generate structured instructions. This step P3050 converts the mathematical formulation into a standardized format that clearly defines the nature of the change, the target metric, and the exact value to which the metric should be changed.

[0091] Using the results of Equation 1 and Equation 2, the structured command can be expressed as follows: Instruction A (Order A. Same below.) {{'change':{'target':'processing_speed', 'value':'current value*1.2'}}···(Equation 3).

[0092] Instruction B {{'change':{'target':'latency', 'value':'current value*0.7'}} (Equation 4) These instructions are a machine-readable version of the technical specifications that clearly details the required changes. Table T5500 will be updated to maintain these structured instructions.

[0093] [P3060] CFIM Output Generation: The final step in the FIM1050 process is preparing the output for the CFIM. The FIM packs its structured instructions into an output set of tables, T5500, designed for use by the CFIM. This output is not just data, but a carefully prepared package tailored to the working needs of the CFIM, ensuring that the instructions can be used directly in the CFIM process.

[0094] The output of the CFIM includes structured instructions (such as Instruction A and Instruction B above) along with additional details that explain the instruction's origin, importance, and relationship to other instructions. This detailed output ensures that the CFIM has everything it needs to effectively guide the system design optimization process.

[0095] In step P3070, if the system engineer agrees with the design version and no improvements are made (P3070: NO), the FIM process stops (P3080). Otherwise (P3070: YES), the process proceeds to a new round using new technical specifications created from the latest feedback (P3020).

[0096] CFIM Description 5 is a flow chart illustrating process P4000 executed by CFIM 1060. CFIM 1060 translates technical specifications 1040 from FIM 1050 into executable changes to the system design. This description explains the steps involved in CFIM using the example of structured instructions aimed at increasing processing speed and reducing latency within the target system.

[0097] The CFIM serves as a central point where feedback from the FIM is contextualized within the existing system design. The CFIM uses the System Design Vector Database 1120 and references past design iterations to guide its process and decisions. The CFIM does not simply receive instructions; it actively processes and analyzes structured feedback, translating it into a plan that is feasible and meets the operational limits and performance objectives of the target system. The CFIM process P4000 begins by invoking (P4010) and retrieving structured instructions (P4020) from table T5500, shown in Figure 7.

[0098] [P4030] Contextual Mapping: The first step in CFIM1060 is context mapping, which aligns structured instructions with specific components of the system design. CFIM evaluates instructions: {{'change':{'target':'processing_speed', 'value':'current value*1.2'}} (Equation 5) {{'change':{'target':'latency','value':'current value*0.7'}}} (Equation 6) CFIM creates these and maps them to the relevant system components. For example, an instruction to increase "processing_speed" would be mapped to the target system's CPU, database configuration, or algorithmic processes that may affect computation speed. Conversely, an instruction to decrease "latency" would be associated with network hardware, communication protocols, or data processing methods that may affect the target system's responsiveness.

[0099] [P4040] Dependency analysis: In mapping change orders to related system components, CFIM1060 performs dependency analysis, which reveals the complex network of interdependencies within the target system's architecture and shows how each component affects and is affected by other components.

[0100] For the command "improve processing speed by 20%", dependency analysis creates a graph showing processing speed as a node and identifies all other system nodes that contribute to or are affected by this metric.

[0101] CFIM recognizes that processing speed is directly linked to CPU performance, which is affected by factors such as clock rate, number of cores, thermal design power (TDP), and the efficiency of the cooling system. Additionally, CFIM also takes into account secondary effects such as increased power consumption, which puts more strain on the power supply unit (PSU).

[0102] Similarly, with the instruction "reduce latency by 30%," CFIM maps network components such as routers, switches, and interfaces, as well as the protocols that manage data transmission. The analysis examines how reducing latency affects network throughput, data packet integrity, and real-time application performance.

[0103] Dependency graphs are dynamic and change with each design iteration, reflecting the evolution of the target system and its components. Dependency graphs help visualize bottlenecks and points of failure that may arise from proposed changes, enabling pre-emptive mitigation strategies.

[0104] [P4050] Verification against system constraints: After understanding dependencies, CFIM validates proposed changes against the target system's existing capabilities and limitations. This validation uses a combination of knowledge of the target system and historical data to determine whether changes can be made without adversely affecting the target system. For example, if the target system's processing speed is to be increased, CFIM uses thermal simulation software to estimate the additional heat generated by a faster CPU. This estimate is then checked against the CPU's thermal design power (TDP) rating and the capacity of the cooling system. Similarly, for power consumption, CFIM compares the expected additional power load with the rated output of the power supply unit (PSU). To reduce latency, CFIM examines the network infrastructure to ensure it can handle faster data transmissions without increasing errors or congestion. CFIM determines whether the current hardware can meet the low-latency needs or whether an update or upgrade is required.

[0105] [P4060] Impact Assessment and Dispute Resolution: After successful validation, CFIM conducts an impact assessment to evaluate how the proposed changes will affect overall system performance. CFIM uses predictive modeling to estimate the impact of a 20% increase in processing speed on task completion time, energy efficiency, potential thermal throttling, and more. A 30% reduction in latency might note the expected improvement in responsiveness and the impact on network operations. Conflict resolution is a key part of impact assessment. CFIM uses algorithms to resolve conflicts between competing goals. For example, if faster processing causes excessive heat, CFIM might suggest redistributing the computational load or improving cooling to reach the desired speed without overheating. This often involves making trade-offs between various performance aspects to find a solution that balances improvements with minimal drawbacks. CFIM uses steps such as dependency analysis, validation, and impact assessment to ensure that proposed changes are technically sound and optimized for overall system performance and sustainability. These steps ensure that each design change benefits system development, stays within operational constraints, and meets goals based on stakeholder feedback.

[0106] [P4070] Executable change orders: After completing the impact assessment and resolving conflicts, CFIM compiles the results into "actionable change instructions." These instructions specify the changes required to the system design to fit the specific components identified earlier. Table T6000 lists the specific tasks, their objectives, the scope of the changes, and the reason for each instruction. For example, in Table T6000 shown in Figure 8, instruction ID "ACI-101" records that the CPU clock speed must be increased by 1.2 times the current speed to achieve the expected performance.

[0107] [P4080] Instruction prioritization and formulation updates in reinforcement learning: CFIM prioritizes instructions based on their impact and urgency. This prioritization helps determine the order of implementation. Prioritization is important when resources are limited or when one change depends on another being implemented first. The priority table T7000, shown in Figure 9, ranks each instruction by its importance. For example, "ACI-101" may be given the highest priority because it significantly impacts the core functionality of the target system. In contrast, "ACI-104" may be given a lower priority because it is a secondary upgrade to improve latency.

[0108] In this way, CFIM1060 acts as a central control center in the system design optimization process, handling the planning, prioritization, and communication to ensure each step is a deliberate movement toward an optimized system design.

[0109] DRE Description Figure 6 is a flowchart illustrating process P5000 performed by DRE 1070. The DRE is the final stage in the system design optimization process, translating executable instructions from CFIM 1060 into actual changes to the system design. When invoked (P5010), DRE 1070 uses an advanced reinforcement learning (RL) component that employs sophisticated algorithms to identify the most effective actions to optimize the system design.

[0110] [P5020] Transforming actionable instructions into action space: DRE starts by converting the actionable change instruction table into an action space, which consists of potential actions that the RL algorithm can choose from. This action space is defined by the available actions and the states that the system can take following these actions. This step converts the tabular data into a format that the RL model can understand, such as a vector or matrix. Figure 8 is an example of an executable change instruction table T6000. Each row in table T6000 represents, for example, an action, the component to be changed, the new value to which it should be changed, the expected state of the system after the change, and a probability weight that reflects the likelihood that the action is the best choice.

[0111] For example, taking the action of increasing the CPU clock speed (ACI-101) is encapsulated as follows: ActionCPU_Increase= {component':'CPU', 'operation':'increase_speed', 'factor':1.2} (Equation 7) This action specifies the component (CPU), the operation (increase in speed), and the factor by which to increase the speed (1.2x the current speed). The action space is therefore the collection of such actions for all components that need to be changed as directed by the CFIM. The DRE ensures that each action is encoded with sufficient metadata to reflect the imperative, dependencies, and expected impacts inferred from the analysis of the CFIM.

[0112] [P5030] Initializing a reinforcement learning model DRE first initializes the RL model and sets the state space, action space, and reward function. The state space represents all possible configurations of the system in high dimensions. The action space, as defined above, includes all actions the model can take, each with a probability weight indicating the likelihood of being the optimal choice. The reward function is created to evaluate the effectiveness of each action the model takes.

[0113] Initially, the RL model starts neutrally, with no prior knowledge, and begins exploring the action space. As it performs actions, it receives feedback in the form of rewards or penalties, which it uses to refine its strategy and improve its decision-making capabilities.

[0114] As actions are encoded, the DRE updates the state space to represent the potential states of the system after the actions are executed. This update process incorporates the latest system data, including performance metrics and constraints, ensuring that the state space accurately reflects the current state of the system design.

[0115] For example, in a scenario calling for increased processing speed and decreased latency, the state space would encompass dimensions for processing speed, latency, power consumption, thermal output, and other appropriate parameters. Figure 11 shows an exemplary table T9000 of the state space. Each row in this table T9000 describes a unique state the system may be in, along with the corresponding values ​​for each dimension. Additionally, a "compliance" column serves as a binary indicator, indicating whether the state satisfies all system constraints and requirements.

[0116] The reward function is continuously refined to match updated system goals and performance benchmarks. The DRE modifies the reward function to award higher rewards for achieving substantial performance improvements and adhering to important system constraints, such as power consumption or thermal output limits.

[0117] The reward function algorithm for the current scenario is constructed as follows:

[0118] (1) Initialize the reward to zero.

[0119] (2) For each action, calculate the change in processing speed and latency.

[0120] (3) If processing speed improves by 20%, a significant positive value is added to the reward.

[0121] (4) If the waiting time is reduced by 30%, a significant positive value is added to the reward.

[0122] (5) If the power consumption or thermal output exceeds the system constraints, a significant value is subtracted from the reward.

[0123] (6) After the action, if the system complies with all design specifications, add a moderate positive value to the reward.

[0124] (7) The reward for each action is the sum of the values ​​(3) to (6) above.

[0125] The reward function can be summarized as the following formula: R(a)=w1·ΔPS(a)+w2·ΔL(a)-w3·ΔPC(a)-w4·ΔTO(a)+w5·C(a)···(Formula 8) where: R(a) is the reward for action 'a', ΔPS(a) is the change in processing speed due to action 'a', ΔL(a) is the change in waiting time due to action 'a', ΔPC(a) is the change in power consumption due to action 'a', ΔTO(a) is the change in thermal output due to the following factors: Action 'a' C(a) is a binary value indicating compliance with the design specification after action a; w1, w2, w3, w4, w5 are weights assigned to each item, reflecting their relative importance in the overall design goal.

[0126] For example, a reward function might add a high positive reward for actions that meet or exceed a target 20% increase in processing speed. If an action improves processing speed by exactly 20%, ΔPS(a) might be set to 1 (fully achieving the target), and w1 might be a high positive number reflecting the importance of this metric. If the target is exceeded, ΔPS(a) might be a number slightly greater than 1, providing the additional reward for exceeding the target. Conversely, if the action fails to achieve the target, ΔPS(a) would be less than 1, resulting in a smaller reward.

[0127] A similar approach is taken for latency reduction: if exactly 30% reduction is achieved, ΔL(a) is set to 1 and w2 is another high positive number. If the latency reduction goal is overachieved, the value of ΔL(a) will be greater than 1, and if it is underachieved, it will be less than 1.

[0128] Actions that increase power consumption or heat output beyond the system's operating constraints have a negative impact on the reward. For example, if an action increases power consumption beyond the system's power capacity, ΔPC(a) will be positive and w3 will be a negative weight, reducing the overall reward. Similarly, if heat output exceeds the cooling system's capacity, ΔTO(a) will be positive and w4 (also negative) will reduce the reward.

[0129] Finally, compliance with the design specifications after each action is crucial. If an action maintains or improves compliance, C(a) is set to 1 and a positive weight, w5, increases the reward. If compliance is compromised, C(a) is 0 and no reward is added.

[0130] The reward function serves as an overarching measure of the effectiveness of actions to guide the target system toward a desired state, balancing the improvement of performance metrics with the need to adhere to operational constraints and design specifications. This function is central to the DRE learning process, guiding the RL algorithm toward optimal decisions that align with the system's overarching design goals.

[0131] [P5040] Learning and Policy Development Returning to Figure 6, DRE1070 employs a policy-based reinforcement learning approach, where a policy defines the agent's actions at a given time. A policy is a function that maps states to actions with the goal of maximizing cumulative reward.

[0132] During the learning process, the DRE takes actions, observes rewards, and adjusts its policy accordingly. During the DRE's learning and policy development phase, the engine tackles the important task of developing a policy: a strategy that dictates the best action to take in a given state, maximizing the cumulative reward over time. In the current scenario, which requires a balance between the ability to handle complex, high-dimensional action and state spaces and the need for stability and reliability in the learning process, Proximal Policy Optimization (PPO) is chosen as the optimal algorithm.

[0133] The PPO algorithm has the following steps:

[0134] (1) Collect data by interacting with the environment: The DRE interacts with a simulation of the system design environment, or the real environment if safe, taking actions based on the current policy and collecting data on state, actions, rewards, and next state.

[0135] (2) Quote Advantage Features: The algorithm calculates an advantage function, which measures how good it is to take a particular action compared to the average action in that state, and this is usually done using Generalized Advantage Estimation (GAE).

[0136] (3) Optimize the surrogate goal: The PPO algorithm optimizes a surrogate objective function that rewards policies that take more favorable actions while keeping policy updates within a trust region so that the policy updates do not become too large.

[0137] (4) Using clipped odds ratios: PPO introduces a clipping mechanism in the objective function to prevent drastic policy updates by clipping the probability ratio between the old and new policies and keeping it within a range of values ​​close to 1.

[0138] (5) Stochastic Gradient Ascent Update Policy: The policy is updated using stochastic gradient ascent to maximize a truncated surrogate objective function. This step is repeated multiple times using the same batch of collected data, making PPO more sample-efficient.

[0139] (6) Repeat the process: Steps (1) through (5) above are repeated multiple times, with each iteration further refining the policy and improving performance over time.

[0140] (7) Policy Evaluation: Periodically, the updated policies are evaluated in the system design environment to ensure that they actually improve performance and monitor convergence.

[0141] An example update rule for the PPO algorithm can be written as follows: Each iteration: a. Collect a set of tuples (st, at, rt, st+1), where st is the current state, at is the action taken, rt is the reward received, and st+1 is the next state.

[0142] b. Use GAE to calculate the advantage estimate At.

[0143] c. Optimize a surrogate objective: L_CLIP(θ)=Et[min(rt(θ)At,clip(rt(θ),1-e,1+e)At)] (Equation 9) Here, rt(θ),=[πθ(at I st)] / [πθold(at I st)] is the probability ratio, θ is the policy parameter, π is the policy, and e is a hyperparameter that defines the clipping range.

[0144] d. Update the policy parameter θ by increasing the gradient (∇θLCLIP(θ)).

[0145] e. Validate the performance of the updated policy and repeat the process until convergence.

[0146] The strength of the PPO algorithm lies in its balance between exploration (trying new actions) and exploitation (refinement of the policy to increase the reward). By implementing a clipping mechanism, PPO maintains stable and reliable convergence behavior, which is useful in system design optimization where drastic changes can have significant impacts.

[0147] [P5050] Iterative refinement and convergence DRE repeats the training and simulation cycles, refining the policy with each cycle. Convergence is achieved when the policy does not change significantly with each training cycle, indicating that the model has identified an optimal or near-optimal set of actions.

[0148] This phase involves a series of cycles in which the DRE interacts with the system environment, enforces the current policy, observes the results, and fine-tunes the policy based on the feedback received. The iterative refinement process includes the following steps: a. Apply Policy: The DRE applies the current policy to the system design environment, which involves performing a set of actions dictated by the policy across various states of the system.

[0149] b. Observe Results: The DRE observes the effect of each action in terms of changes in system performance, user experience, and other relevant metrics. These observations are important for the DRE to measure the impact of its actions.

[0150] c. Collect Rewards: After performing an action, the DRE collects rewards based on a predefined reward function. These rewards reflect the desirability of the performed action.

[0151] d. Policy Update: Using feedback from the bounty, the DRE updates policies to incentivize actions that have produced positive results and discourage actions that have been less effective.

[0152] e. Convergence Assessment: DRE assesses whether the policy has stabilized. This assessment is based on how much the actions and rewards fluctuate over time. If there is still significant fluctuation between updates, the policy has not yet converged.

[0153] f. Iterate: The DRE implements the revised policy, observes the results, collects the rewards, updates the policy, and again evaluates convergence, repeating the cycle.

[0154] Convergence is confirmed when the DRE strategy is stable across iterations and adjustments to the system design consistently produce results that effectively satisfy the system's goals and constraints.

[0155] [P5060] Policy execution Once the DRE's policies are stable, the engine proceeds to implement them by applying the selected actions to the system. This implementation is coordinated with the design agent orchestrator 1080 and the various design agents responsible for the actual changes to the target system.

[0156] Policy enforcement involves executing the "design update directives" generated during this phase. These directives are detailed instructions that specify the exact changes required to the system design to improve performance, stability, or compliance with requirements. The process of creating "design update directives" includes the following: · Translate recommended actions from policies into concrete design changes.

[0157] · Validate these changes against the current state and constraints of the system.

[0158] ·Format instructions clearly and precisely so that they can be implemented effectively by the designer.

[0159] An integrated planning table T7000 is created to list the "design update instructions" and schedule their implementation. This table T7000 ensures that each change is executed in a logical order and coordinates the work of the various design agents.

[0160] The integration plan table T7000 is communicated to the design agent orchestrator 1080, which manages the execution of the "design update instructions." The orchestrator 1080 coordinates with specialized design agents, each tasked with executing specific changes according to the integration plan. This coordination ensures smooth collaboration between all agents and maintains system integrity throughout the update process.

[0161] Table T7000 acts as an integrated planning table. Each design agent is assigned a task and a corresponding instruction ID and completion timeline from the prioritization table. This structure ensures that all tasks are completed efficiently and effectively.

[0162] [P5070] Logging and Continuous Learning DRE1070 features a comprehensive logging system that records all decisions, actions, and results in the design optimization process, allowing system engineers to review and understand the DRE's decision-making process, ensuring transparency.

[0163] Continuous learning is a key part of DRE's operation. The engine reviews logs from each iteration to learn from successes and identify areas for improvement. The results of this analysis feed into DRE's learning algorithms, allowing the engine to adjust and refine its policies based on new data and evolving system requirements.

[0164] Furthermore, a continuous learning process updates the state space and reward function to take into account new constraints and goals. As the system evolves, DRE's understanding of the system also improves, ensuring the optimization process stays in sync with the system's current and future needs.

[0165] Design Agent Orchestrator Following activity within the DRE, system design optimization proceeds through several key stages led by the design agent orchestrator 1080. During this phase, design drafts are created and reviewed and decided upon by system engineers.

[0166] The design agent orchestrator 1080 acts as a central command center for enforcing the sophisticated policies developed by the DRE. The orchestrator 1080 coordinates the actions of various design agents that perform specific tasks related to updating the system design. The orchestrator 1080 ensures that each design agent understands its role and performs its assigned tasks in line with the overarching design goals.

[0167] The main functions of the design agent orchestrator 108 are as follows:

[0168] · Task distribution: Allocating specific tasks to design agents according to the action plan derived from the DRE's policies.

[0169] · Synchronization: Ensuring that tasks are performed in the correct order, especially when one task depends on the completion of another.

[0170] · Execution monitoring: Overseeing the execution of tasks and ensuring that all actions adhere to the planned strategy and timelines.

[0171] Creating a design draft Once the design agent orchestrator 1080 has coordinated the implementation of all necessary design changes, a new version of the system design, called design draft 1090, is created. This draft 1090 reflects the current state of the target system after implementing the optimized changes and illustrates the iterative learning and decision-making process.

[0172] Creating a design draft includes: · Integration: Integrating all the individual changes into a cohesive system design.

[0173] · Validation: Ensuring that the design draft meets all specified requirements and functions as expected.

[0174] · Documentation: Record any changes you make, including the reasons behind the changes and their expected impact on system performance.

[0175] System Update Management Department The System Update Manager 1100 is a tool for recording and analyzing the progress of a system design through the optimization process. The System Update Manager 1100 records each action taken, its results, and its impact on the system's performance and compliance with requirements.

[0176] The functions of the System Update Manager are: · Change Recording: Maintaining a detailed record of all design changes made during the optimization process.

[0177] · Performance Tracking: Monitor key performance indicators and evaluate the effectiveness of design changes.

[0178] · Historical analysis: Providing insight into the evolution of system design to aid future decision-making processes.

[0179] Once the design draft 1090 is complete, it is presented to stakeholders 1000, including system engineers, as shown in Figure 1, for a comprehensive evaluation. This evaluation checks the design draft against the initial requirements, performance criteria, and stakeholder expectations. The stakeholders, including system engineers, critically examine the design to ensure that it meets the desired specifications and serves the intended purpose of the target system.

[0180] Decision on further feedback or approval of the design draft Based on the evaluation, the systems engineer makes important decisions: Further Feedback: If the design draft 1090 does not fully meet the requirements or there is potential for further optimization, stakeholders, including system engineers, can provide additional feedback, initiating another cycle of refinement.

[0181] · Approval: If the draft design meets all criteria and is deemed satisfactory, stakeholders, including the systems engineer, approve the design, thereby marking a successful conclusion to the design optimization process.

[0182] As described above, the present disclosure includes a comprehensive system for optimizing system design through an iterative feedback information process. By integrating reinforcement learning with the expertise of system engineers, the system design optimization system 1 of the present disclosure can continuously optimize the design of a target system efficiently and appropriately.

[0183] The disclosed approach leverages the PPO algorithms in the DRE 1070 to iteratively refine the design of the target system to meet or exceed performance criteria and stakeholder expectations. The Design Agent Orchestrator 1080 plays a pivotal role in translating these refined policies into executable changes, producing optimized design drafts. This process is tracked by the System Update Manager 1100, providing valuable data for system engineers to evaluate and ultimately decide on design approval or the need for further refinement.

[0184] In this way, the system design optimization system 1 of the present disclosure provides a dynamic and adaptable framework that integrates the expertise of stakeholders, including system engineers, with artificial intelligence. The present disclosure is not limited to the above-described embodiments as they are, and in the implementation stage, the components can be modified and embodied within the scope of the gist of the disclosure, or multiple components disclosed in the above-described embodiments can be appropriately combined. [Explanation of symbols]

[0185] 1: System design optimization system, 10: Computer resources, 100: Main part, 1010: Stakeholder platform, 1020: Feedback, 1030: LLM, 1040: Technical specifications, 1050: Feedback interpretation part, 1060: Context feedback integration part, 1070: Design enhancement engine, 1080: Design agent orchestrator, 1100: System update monitoring part, 1120: System design vector database, 1130: Design information acquisition part

Claims

1. A system design optimization system that optimizes the design of a target system, obtaining feedback from stakeholders of the target system regarding improvements to the target system; interpreting the obtained feedback for application to the target system; generating a set of instructions to be provided to the target system from the results of the interpretation; providing the stakeholder with a status of implementation of the instruction set; Obtaining feedback regarding improvements to the target system until approved by the stakeholders. System design optimization system.

2. a feedback receiving unit that receives the feedback from the interested party regarding the target system; a large-scale language model unit trained to generate technical specifications from input information, the large-scale language model unit generating the technical specifications from the feedback received by the feedback receiving unit; a feedback interpretation unit that interprets the technical specification generated by the large-scale language model unit; a context feedback integration unit that generates a structured executable instruction set indicating elements to be changed among a plurality of elements of the target system and the details of the changes based on the interpretation result by the feedback interpretation unit; a design enhancement unit that generates design update instructions for updating a design of the target system from the instruction set generated by the context feedback integration unit; an implementation control unit that sends the design update instruction to a change execution unit that implements the design update instruction in the target system based on the design update instruction generated by the design strengthening unit, and drives the change execution unit; an update monitoring unit that monitors the mounting status by the mounting control unit and provides monitoring information including the monitoring result to the interested party; The system design optimization system of claim 1 , comprising:

3. The feedback receiving unit receives new feedback from the interested party who has received the monitoring information. The system design optimization system according to claim 2 .

4. The contextual feedback aggregator assigns an implementation priority to each instruction in the structured executable instruction set. The system design optimization system according to claim 3 .

5. The context feedback integration unit generates the instruction set based on dependencies between an element to be changed among the elements and other elements among the elements. The system design optimization system according to claim 4 .

6. The context feedback integration unit generates the instruction set so as to satisfy system constraints set for the target system. The system design optimization system according to claim 5 .

7. The design reinforcing unit includes a reinforcement learning unit that learns based on the received feedback, and the reinforcement learning unit generates the design update instruction. The system design optimization system according to claim 6.

8. The design reinforcing unit repeatedly generates the design update instructions using the reinforcement learning unit based on the defined state space, action space, and reward function. The system design optimization system according to claim 7.

9. The state space represents all possible configurations of the target system, the action space includes all possible actions the target model can take, each with a probability weight indicating the likelihood of being an optimal choice, and the reward function evaluates the effectiveness of each action taken by the target model. The system design optimization system of claim 8.

10. A system design optimization method for optimizing a design of a target system by a computer, comprising: The computer receiving feedback from stakeholders of the target system regarding improvements to the target system; generating a technical specification from the received feedback using a large scale language model trained to generate technical specifications from input information; Interpreting the generated technical specification; generating a structured executable instruction set indicating which elements of the target system should be changed and what changes should be made based on the results of the interpretation; generating design update instructions from the generated instruction set to update the design of the target system; Implementing the design update instruction in the target system based on the generated design update instruction; Monitor the status of the implementation and provide monitoring information including the monitoring results to the interested party. System design optimization methods.

11. The computer receives new feedback from the stakeholders who received the monitoring information. The system design optimization method of claim 10.

12. The computer assigns an implementation priority to each instruction included in the instruction set. The system design optimization method of claim 11.

13. The computer generates the instruction set based on the dependency between an element to be changed among the elements and other elements among the elements.

13. The system design optimization method of claim 12.

14. The computer generates the instruction set so as to satisfy system constraints set for the target system.

14. The system design optimization method of claim 13.

15. The computer generates the design update instruction using a reinforcement learning unit that learns based on the received feedback.

15. The system design optimization method of claim 14.

Images