system

Abstract

We provide the system. [Solution] A means for the user to input their requests regarding the floor plan of the house, A means of sending the input request data to the server, A means for inputting the request data received by the server into a generative artificial intelligence model, A means by which a generative artificial intelligence model generates a house floor plan based on requested data, A means of allowing the user to visually confirm the generated floor plan, A means of resending user correction requests to the server, A means by which the server reprocesses the correction request and generates a new floor plan, A system that includes a means of providing home builders with floor plans that have been ultimately approved by the user.

Description

Technical Field

[0001] The technology of the present disclosure relates to a system.

Background Art

[0002] Patent Document 1 discloses a method for controlling a persona chatbot performed by at least one processor, the method including steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a character of the chatbot, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] In the design of custom-built houses, the task of conveying the floor plan desired by the user to the house builder is cumbersome and requires many revisions to be repeated. For this reason, it is difficult and time-consuming to create drawings that accurately reflect the floor plan desired by the user. Furthermore, when the user himself / herself does not have specialized knowledge about the structure and design of houses, there is a problem that it is difficult to translate the request into specific drawings.

Means for Solving the Problems

[0005] To solve this problem, the present invention provides the following means. First, a means is provided for the user to input their requests regarding the layout of a house. Next, a means is provided for transmitting the input request data to a server. The server inputs the received request data into a generative artificial intelligence model, and this model generates a house layout based on the request data. A means is provided for the user to visually confirm the generated layout, and a means is also provided for the user to send any revision requests back to the server. The server reprocesses the revision requests and generates a new layout. This process is repeated, and finally, a means is provided for providing the house builder with the layout approved by the user. This streamlines communication between the user's requests and the house design, making it easier to create an ideal layout.

[0006] A "user" is an individual or legal entity that inputs requests regarding the layout of a house and then reviews and modifies the generated floor plan.

[0007] A "terminal" is an electronic device used by users to input requests and to view and modify the generated floor plan, and includes personal computers, tablets, smartphones, and other similar devices.

[0008] A "server" is a computer system that receives request data sent from users and processes it for input into a generative artificial intelligence model and for generating new floor plans.

[0009] "Request data" refers to information including the user's preferences and requirements regarding the floor plan of a house.

[0010] A "generative artificial intelligence model" is an algorithm or program that learns from past housing design data and generates new floor plans based on user requests.

[0011] A "floor plan" is a drawing that shows the room layout and structure of a house, created by a generative artificial intelligence model, and is displayed in 2D or 3D format.

[0012] A "revision request" is data containing changes that a user requests after reviewing the generated floor plan.

[0013] A "house builder" is a company or professional that designs and constructs houses based on the user's requests. [Brief explanation of the drawing]

[0014] [Figure 1] This is a conceptual diagram showing an example of the configuration of a data processing system according to the first embodiment. [Figure 2] This is a conceptual diagram showing an example of the essential functions of a data processing device and a smart device according to the first embodiment. [Figure 3] This is a conceptual diagram showing an example of the configuration of a data processing system according to the second embodiment. [Figure 4] This is a conceptual diagram showing an example of the main functions of a data processing device and smart glasses according to the second embodiment. [Figure 5] This is a conceptual diagram showing an example of the configuration of a data processing system according to the third embodiment. [Figure 6] This is a conceptual diagram showing an example of the main functions of a data processing device and a headset-type terminal according to the third embodiment. [Figure 7] This is a conceptual diagram showing an example of the configuration of a data processing system according to the fourth embodiment. [Figure 8] This is a conceptual diagram showing an example of the main functions of a data processing device and a robot according to the fourth embodiment. [Figure 9] This shows an emotion map where multiple emotions are mapped. [Figure 10] This shows an emotion map where multiple emotions are mapped. [Figure 11] This is a sequence diagram showing the processing flow of the data processing system in Example 1. [Figure 12] This is a sequence diagram showing the processing flow of the data processing system in Application Example 1. [Figure 13]It is a sequence diagram showing the processing flow of the data processing system in Embodiment 2 when combined with an emotion engine. [Figure 14] It is a sequence diagram showing the processing flow of the data processing system in Application Example 2 when combined with an emotion engine.

Mode for Carrying Out the Invention

[0015] Hereinafter, an example of an embodiment of a system according to the technology of the present disclosure will be described with reference to the accompanying drawings.

[0016] First, the language used in the following description will be explained.

[0017] In the following embodiments, a labeled processor (hereinafter simply referred to as "processor") may be a single arithmetic unit or a combination of multiple arithmetic units. Also, the processor may be a single type of arithmetic unit or a combination of multiple types of arithmetic units. Examples of arithmetic units include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), an APU (Accelerated Processing Unit), and the like.

[0018] In the following embodiments, a labeled RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a work memory by the processor.

[0019] In the following embodiments, a labeled storage is one or more non-volatile storage devices that store various programs and various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), or magnetic tapes, etc.

[0020] In the following embodiments, the signed communication interface (I / F) is an interface that includes a communication processor and an antenna, etc. The communication interface manages communication between multiple computers. Examples of communication standards applicable to the communication interface include wireless communication standards such as 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), or Bluetooth (registered trademark).

[0021] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." That is, "A and / or B" means that it may be A alone, or B alone, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" applies when expressing three or more things linked by "and / or."

[0022] [First Embodiment]

[0023] Figure 1 shows an example of the configuration of the data processing system 10 according to the first embodiment.

[0024] As shown in Figure 1, the data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0025] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0026] The smart device 14 comprises a computer 36, a reception device 38, an output device 40, a camera 42, and a communication interface 44. The computer 36 comprises a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The reception device 38, output device 40, and camera 42 are also connected to the bus 52.

[0027] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0028] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0029] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various types of information between processor 46 and processor 28 via network 54.

[0030] Figure 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0031] As shown in Figure 2, in the data processing device 12, a specific processing is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" related to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 according to the specific processing program 56 executed on the RAM 30.

[0032] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0033] In the smart device 14, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The reception output program 60 is used in conjunction with a specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0034] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0035] This invention relates to a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model generates a layout based on those requirements, and finally provides it to a house builder. The program and processing of this system are described below.

[0036] 1. The user enters their request.

[0037] The user opens a dedicated application or web form on their device (e.g., PC, tablet, smartphone).

[0038] Users enter detailed requests regarding the layout of their home, such as the number of rooms, orientation, specific functions, and size, into a form.

[0039] For example, specific requests such as "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom" can be entered.

[0040] 2. Sending request data

[0041] The terminal sends the request data entered by the user to the server. The request data is sent in a structured format (e.g., JSON).

[0042] example:

[0043] json

[0044] {

[0045] "rooms": 4,

[0046] "orientation": "south",

[0047] "kitchen_dining": "connected",

[0048] "bathroom": "large"

[0049] }

[0050] 3. Data reception and input into the AI ​​model

[0051] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[0052] The server inputs the data, whose integrity has been verified, into the generative artificial intelligence model.

[0053] 4. AI-powered floor plan generation

[0054] The generative artificial intelligence model uses an algorithm trained on past housing design data to calculate the optimal floor plan based on user requests.

[0055] The generative artificial intelligence model determines the size and layout of each room based on the input request data.

[0056] 5. Output and transmission of generated results

[0057] The server receives the generated floor plan and visualizes it in two-dimensional (2D) and three-dimensional (3D) formats.

[0058] The server sends the visualized floor plan data to the terminal.

[0059] 6. User review and input of correction requests.

[0060] The user reviews the floor plan generated on their device. They visually check elements such as room layout, size, and orientation as checkpoints on the plan.

[0061] If a user wants to make a change, they simply re-enter their request into the terminal, for example, "I want the kitchen to be a little bigger."

[0062] The device sends this correction request data to the server. The correction request data is also sent in JSON format.

[0063] json

[0064] {

[0065] "modify": "expand",

[0066] "target": "kitchen",

[0067] "details": "more space"

[0068] }

[0069] 7. Reprocessing of correction requests

[0070] The server then inputs the requested correction data back into the generative artificial intelligence model and instructs it to generate a new floor plan.

[0071] The generative artificial intelligence model recalculates based on the requested modifications and generates a revised floor plan.

[0072] 8. Generation and verification of the final drawing

[0073] The server generates a new floor plan and sends it back to the terminal.

[0074] The user reviews the design again, and if a satisfactory floor plan is generated, it will be approved as the final drawing.

[0075] 9. Provision of final drawings

[0076] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0077] The final drawings are sent to the home builder via email or a dedicated online portal.

[0078] In this way, the system of the present invention can generate floor plans that quickly and accurately reflect the user's requests, significantly streamlining the design process for custom-built homes.

[0079] The following describes the processing flow.

[0080] Step 1:

[0081] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, layout, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[0082] Step 2:

[0083] The terminal sends the entered request data to the server in JSON format. Example data:

[0084] json

[0085] {

[0086] "rooms": 4,

[0087] "orientation": "south",

[0088] "kitchen_dining": "connected",

[0089] "bathroom": "large"

[0090] }

[0091] Step 3:

[0092] The server receives the submitted request data and checks its integrity. This integrity check includes verifying the data format and required fields.

[0093] Step 4:

[0094] The server inputs the verified request data into the generative artificial intelligence model. Specifically, it processes the data to conform to the model's format.

[0095] Step 5:

[0096] The generative artificial intelligence model calculates and generates a house layout based on the given request data. Specifically, it automatically generates the size, arrangement, and orientation of rooms according to the request.

[0097] Step 6:

[0098] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[0099] Step 7:

[0100] The server sends visualized floor plan data to the terminal. The user receives and reviews this data via a responsive design or a dedicated application.

[0101] Step 8:

[0102] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[0103] Step 9:

[0104] The device resends the user's correction request data to the server. The correction request data is again sent in JSON format. Example data:

[0105] json

[0106] {

[0107] "modify": "expand",

[0108] "target": "kitchen",

[0109] "details": "more space"

[0110] }

[0111] Step 10:

[0112] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[0113] Step 11:

[0114] The generative artificial intelligence model recalculates the floor plan based on the requested modifications and generates a new floor plan.

[0115] Step 12:

[0116] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[0117] Step 13:

[0118] Repeat steps 8 through 12 until the user has reviewed and is satisfied with the final drawing.

[0119] Step 14:

[0120] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0121] Step 15:

[0122] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[0123] (Example 1)

[0124] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0125] Conventional residential design systems have difficulty quickly and accurately reflecting user requests, particularly the time-consuming and labor-intensive process of generating and modifying floor plans. Furthermore, visual confirmation of generated floor plans and the rapid incorporation of modification requests are difficult, resulting in an inefficient design process for custom-built homes. This invention aims to solve these problems and streamline the process of generating and modifying floor plans based on user requests.

[0126] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0127] In this invention, the server includes means for inputting user-entered request data into a generative artificial intelligence model, means for the generative artificial intelligence model to learn past housing design data, and means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats. This enables the rapid and accurate generation and modification of the optimal floor plan based on the user's requests.

[0128] "Request data" refers to information that users input regarding the layout of a house, including details such as the number of rooms, orientation, specific functions, and size.

[0129] A "generative artificial intelligence model" is an artificial intelligence system that includes an algorithm that learns from past housing design data and generates the optimal floor plan based on user request data.

[0130] A "server" is a computer system that receives request data sent by users and inputs it into a generative artificial intelligence model.

[0131] "Two-dimensional and three-dimensional formats" refer to the formats used to visually display the generated floor plan, and include both 2D formats that display it as a plan view and 3D formats that visualize it in three dimensions.

[0132] A "revision request" is data entered by the user after reviewing the generated floor plan, indicating the parts they wish to change or modify.

[0133] A "construction contractor" refers to a company or individual that constructs a house based on the floor plan ultimately approved by the user.

[0134] This invention is a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model is used to generate a layout based on those requirements, and the layout is ultimately provided to a construction company. The program and processing of this system are described in detail below.

[0135] Users access a dedicated application or web form using devices such as PCs, tablets, or smartphones. A login function is available, and users log in by entering their account information. Users then enter detailed requests in an input form, such as the number of rooms in the house, its orientation, specific functions, and size. For example, they might enter specific requests like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[0136] The terminal converts the user's input request data into JSON format. The following data format is generated:

[0137] json

[0138] {

[0139] "rooms": 4,

[0140] "orientation": "south",

[0141] "kitchen_dining": "connected",

[0142] "bathroom": "large"

[0143] }

[0144] The terminal sends this JSON data to the server using the HTTPS protocol. The server checks the integrity of the received request data and returns an error message if necessary. Once integrity is confirmed, the server converts the data into a format suitable for generative artificial intelligence models.

[0145] The server inputs the converted data into a generative artificial intelligence model. The model uses an algorithm trained on past housing design data to calculate the optimal floor plan. This algorithm automatically generates a floor plan including the size and placement of each room.

[0146] Once the generative AI model finishes its calculations, the server visualizes the generated floor plan in 2D and 3D formats. Technologies such as WebGL and Three.js may be used for visualization. This visualized floor plan data is then converted back into JSON format, and the server sends it to the terminal.

[0147] The user reviews the floor plan generated on their device. While visually reviewing it, they input modification requests such as "I'd like the kitchen to be a little bigger." For example, they might input a modification request like "Make the kitchen bigger" in text format as follows:

[0148] "modify: expand, target: kitchen, details: more space"

[0149] The terminal converts the revision request data into JSON format and sends it back to the server. The server re-inputs the revision request data into the generative artificial intelligence model and generates a new floor plan.

[0150] The server generates a new floor plan and sends it back to the terminal. The user reviews it again, and if they are finally satisfied with the generated drawing, they give it final approval. The server generates the final floor plan in PDF or CAD data format and provides it to the builder. The final drawing is sent to the builder via email or a dedicated online portal. This system can generate floor plans that quickly and accurately meet the user's requests, significantly streamlining the custom home design process.

[0151] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0152] Step 1:

[0153] The user launches the application. The user opens the dedicated application or web form using a device such as a PC, tablet, or smartphone. The user enters their account information and logs in. Input: Account information, Output: Login session.

[0154] Step 2:

[0155] The user enters their requirements. The user enters detailed requirements such as the number of rooms in the house, orientation, specific functions, and size into an input form. For example, they might enter specific requirements like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom." Input: Request data; Output: Structured input data (e.g., JSON format).

[0156] Step 3:

[0157] The device sends data. The device converts the user-entered request data into JSON format and then sends it to the server using the HTTPS protocol. Specifically, it generates an HTTP request and sends the data. Input: Structured input data; Output: Data contained in the HTTP request.

[0158] Step 4:

[0159] The server receives the data. The server checks the integrity of the requested data received via the HTTPS protocol and returns an error message if necessary. Once integrity is confirmed, the data is converted into a format suitable for a generative artificial intelligence model. Input: Data received from the HTTP request; Output: Converted data.

[0160] Step 5:

[0161] The server inputs data into the AI ​​model. The server then inputs the transformed data into a generative artificial intelligence model. Data interpolation and preprocessing are performed as needed. Input: Data that has been formatted; Output: Data input into the AI ​​model.

[0162] Step 6:

[0163] A generative artificial intelligence model generates floor plans. The AI ​​model uses an algorithm to calculate the optimal floor plan based on the input request data. The model references past housing design data stored in a database. Input: Data entered into the AI ​​model; Output: Generated floor plan data.

[0164] Step 7:

[0165] The server receives the floor plan. The server visualizes the generated floor plan data in 2D and 3D formats. Visualization may utilize technologies such as WebGL or Three.js. The visualized data is then converted back to JSON format and sent to the terminal. Input: Generated floor plan data, Output: Visualized data.

[0166] Step 8:

[0167] The user reviews the floor plan. The user reviews the floor plan generated on their device and makes a visual evaluation. They check the room layout, size, orientation, etc., and may also enter revision requests. Input: Visualized data; Output: User feedback and revision requests.

[0168] Step 9:

[0169] The terminal sends a correction request. The correction request entered by the user is converted to JSON format and sent back to the server. A concrete example of a request might be "Make the kitchen bigger." Input: Correction request data, Output: Correction request data included in the HTTP request.

[0170] Step 10:

[0171] The server processes the revision request. The server re-inputs the revision request data into the generative artificial intelligence model and instructs it to generate a new floor plan. Input: Revision request data received from the HTTP request; Output: Revision data input into the AI ​​model.

[0172] Step 11:

[0173] The generative artificial intelligence model performs a recalculation. The AI ​​model recalculates based on the requested modifications and generates a new floor plan. Input: Modification data entered into the AI ​​model; Output: Modified floor plan data.

[0174] Step 12:

[0175] The server generates a new floor plan. The server generates a new floor plan and sends it back to the terminal. Input: Modified floor plan data, Output: Visualized new floor plan data.

[0176] Step 13:

[0177] The user performs the final review. The user checks the new floor plan on their device and, if the generated drawing is satisfactory, gives final approval. Input: Visualized new floor plan data, Output: Final approval.

[0178] Step 14:

[0179] The server provides the final drawings. The server generates the final floor plans in PDF or CAD data format and provides them to the construction company. The final drawings are provided via email or a dedicated online portal. Input: Final approved floor plan data; Output: Final drawings in PDF or CAD data format.

[0180] (Application Example 1)

[0181] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0182] Designing the layout of machinery and work within a factory is crucial for maximizing efficiency, safety, and productivity. However, traditional layout design is often done manually, which is time-consuming and costly. Furthermore, finding the optimal layout requires advanced expertise, and any modifications or changes necessitate redesign. To address these challenges, there is a need for a system that allows users to easily design factory layouts and quickly provide optimized layouts using generative artificial intelligence models.

[0183] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0184] In this invention, the server includes means for the user to input layout requests, means for transmitting the input request data to the server, means for the server to input the received request data into a generative artificial intelligence model, means for allowing the user to visually confirm the generated layout diagram, means for the user to send revision requests to the server again, means for the server to reprocess the revision requests and generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This enables the rapid and efficient design of the optimal layout within the factory, simplifying the design process and improving its accuracy.

[0185] A "user" is an individual or group that uses the system to design layouts.

[0186] "Layout" refers to the arrangement of machinery, work stations, employee movement routes, safety areas, and other elements within a factory.

[0187] "Request data" refers to data that includes the user's desired conditions and requirements for layout design.

[0188] A "server" is a computer system that receives request data sent by users and generates and regenerates layouts using a generative artificial intelligence model.

[0189] A "generative artificial intelligence model" is an artificial intelligence system that includes algorithms for generating the optimal layout based on user request data.

[0190] "Means of visual confirmation" refers to an interface that displays the generated layout diagram in a way that allows the user to view it in two-dimensional and three-dimensional formats.

[0191] A "revision request" is a request from a user for additional changes or adjustments to a layout diagram that has been generated.

[0192] The "finally approved layout diagram" is the layout diagram that the user deemed to be the optimal state and ultimately approved for adoption.

[0193] "Means of provision" refers to the means of providing the finally approved layout diagram to users and other related systems in digital format or other means.

[0194] In order to implement this invention, it is necessary to build a system in which users, servers, and terminals work closely together to efficiently and quickly design factory layouts.

[0195] Hardware and software configuration

[0196] 1. User terminal:

[0197] This involves using devices with input interfaces, such as tablets and smartphones, to allow users to input their factory layout requirements.

[0198] 2. Server:

[0199] High-performance computing servers (e.g., AWS® EC2) are used to receive request data, operate generative artificial intelligence models, and transform data.

[0200] 3. Generative artificial intelligence models:

[0201] Using frameworks such as TENSORFLOW® and PyTorch, an algorithm is executed to generate the optimal factory layout based on user request data.

[0202] Program processing flow

[0203] The user enters the request data.

[0204] The user opens the application on their terminal and enters their requirements regarding the factory layout. These requirements include the number of work lines, the types and number of machines needed, employee movement routes, and the setting of safety areas. For example, the following requirements are entered in text format:

[0205] Number of production lines: 3

[0206] Types and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units

[0207] Employee travel routes: Line 1, Line 2

[0208] Safety area settings: Storage area

[0209] Sending request data to the server

[0210] The entered request data is converted into a structured format and sent to the server. The server receives the data and checks its integrity.

[0211] Input to a generative artificial intelligence model

[0212] The server inputs the verified request data into a generative artificial intelligence model. Based on past factory layout design data, the model calculates the optimal layout that best suits the user's requests.

[0213] Providing the generated layout diagram to the user

[0214] The generated layout diagrams are visualized in two-dimensional and three-dimensional formats and sent to the user's terminal. The user visually reviews them and re-enters any revision requests if necessary.

[0215] Reprocessing of correction requests

[0216] The user's revision requests are sent back to the server, where a generative artificial intelligence model recalculates and generates a new layout diagram. This process is repeated until a satisfactory layout diagram is completed.

[0217] Provision of the final layout drawing

[0218] The final layout diagram approved by the user is provided in digital format and sent to the user and other relevant systems.

[0219] Through the above process, the optimal factory layout can be designed quickly and efficiently. This system enables improvements in factory production efficiency and safety.

[0220] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0221] Step 1:

[0222] The user enters the request data.

[0223] The user opens an application on their terminal and enters their requirements for the factory layout. Input fields include the number of work lines, the type and number of machines required, employee movement routes, and safety area settings. For example, "Number of work lines: 3," "Type and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units," "Employee movement routes: Line 1, Line 2," and "Safety area settings: Storage area." The input data is converted into a structured format (JSON).

[0224] Step 2:

[0225] Sending request data to the server

[0226] The terminal sends the request data entered by the user to the server. The server checks the integrity of the received request data. Specifically, it verifies the data format, checks required fields, and validates the value range. Once the integrity check is complete, the data is converted into a format that can be input into a generative artificial intelligence model. The input is the user's request data, and the output is the data whose integrity has been verified.

[0227] Step 3:

[0228] Input to a generative artificial intelligence model

[0229] The server inputs verified request data into a generative artificial intelligence model. Based on past factory layout design data, the generative AI model calculates the optimal layout suitable for the user's requests. Specifically, it optimizes the placement of various machines, the design of work lines, employee movement routes, and the definition of safety areas through data calculations. The input is consistent request data, and the output is a generated layout diagram.

[0230] Step 4:

[0231] Providing the generated layout diagram to the user

[0232] The server visualizes the generated layout diagram in two-dimensional and three-dimensional formats and sends the data to the user's terminal. The user then reviews the visualized layout diagram. Specifically, the layout diagram is displayed in 2D and 3D on the terminal. The user visually confirms the arrangement of each work line, the location of machines, the location of safety areas, etc. The input is the generated layout diagram, and the output is the visualized layout diagram.

[0233] Step 5:

[0234] User input for correction requests

[0235] If a user is dissatisfied with the layout diagram, they can submit a request for revision. For example, specific requests such as "Move the machine placement on line 1 to the left" or "Expand the storage area." The terminal then sends the revision request data to the server. The input is the user's revision request data, and the output is the revision request data sent to the server.

[0236] Step 6:

[0237] Reprocessing of correction requests

[0238] The server re-inputs the requested modification data into the generative artificial intelligence model and generates a new layout diagram. The model recalculates and updates the layout based on the requested modifications. Specifically, it optimizes the overall layout while reflecting the changes requested by the user. The input is the requested modification data, and the output is the modified layout diagram.

[0239] Step 7:

[0240] Provision of the final layout drawing

[0241] The server sends the revised layout drawing back to the user's terminal. The user performs a final review and approves it if they are satisfied. The finally approved layout drawing is provided in digital format. Specifically, it is output as PDF or CAD data and provided to the user via email or online portal. The input is the final reviewed layout drawing, and the output is a digital layout drawing.

[0242] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0243] This invention relates to a system that allows users to input and modify their requests regarding the layout of a house and generates a floor plan based on those requests, as well as a system that includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. The program and processing of this system are described below.

[0244] 1. The user enters their request.

[0245] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. For example, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[0246] 2. Sending request data

[0247] The terminal sends the entered request data to the server in JSON format. Example data:

[0248] json

[0249] {

[0250] "rooms": 4,

[0251] "orientation": "south",

[0252] "kitchen_dining": "connected",

[0253] "bathroom": "large"

[0254] }

[0255] 3. Data reception and input into the AI ​​model

[0256] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[0257] 4. Complementing user emotions with an emotion engine

[0258] The server is equipped with an emotion engine that recognizes the user's emotions when they enter a request. This emotion data is reflected in the request data, and if the user is, for example, "feeling stressed," the system will provide supplementary information such as suggesting a more concise request.

[0259] 5. AI-powered floor plan generation

[0260] The generative AI model calculates and generates house floor plans based on verified request data. The generative AI model automatically generates the size and placement of each room according to the user's requests.

[0261] 6. Output and transmission of generated results

[0262] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[0263] 7. User review and input of correction requests.

[0264] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[0265] 8. Revision suggestions based on the emotion engine

[0266] The emotion engine recognizes the user's emotions when reviewing a floor plan, and if, for example, the user is feeling anxious, it automatically generates modification suggestions based on that emotion. As an example of a suggestion, it might offer a specific suggestion such as, "If you feel the kitchen is too small, how about converting part of the living room into a kitchen?"

[0267] 9. Reprocessing of correction requests

[0268] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[0269] 10. Recalculation by generative AI

[0270] The generative artificial intelligence model recalculates based on modification requests and suggestions from the emotion engine to generate a new floor plan.

[0271] 11. Generate and send a new floor plan.

[0272] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[0273] 12. Review and approval of the final drawings

[0274] This process is repeated until the user reviews it again and is satisfied with the final drawing.

[0275] The emotion engine recognizes the user's emotions when they review the final drawing and provides a means to gather further feedback if they are not satisfied.

[0276] 13. Provision of final drawings

[0277] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0278] The final drawings are sent to the house builder via email or a dedicated online portal, completing the house design process based on the user's requirements.

[0279] Thus, the system of the present invention can generate a floor plan that quickly and accurately reflects the user's desires while recognizing the user's emotions, greatly enhancing the efficiency of the custom house design process.

[0280] The following describes the processing flow.

[0281] Step 1:

[0282] The user opens the application or web form on the terminal. The user enters their desires regarding the floor plan of the house (e.g., number of rooms, layout, specific functions, size, etc.) into the form. Specifically, enter desires such as "4LDK", "Living room faces south", "Kitchen and dining are connected", "Large bathroom".

[0283] Step 2:

[0284] The terminal sends the entered desire data and the user's emotion data (e.g., the result of emotion analysis of the expression or voice displayed by the user during input) to the server in JSON format. Data example:

[0285] json

[0286] {

[0287] "rooms": 4,

[0288] "orientation": "south",

[0289] "kitchen_dining": "connected",

[0290] "bathroom": "large",

[0291] "user_emotion": "neutral"

[0292] }

[0293] Step 3:

[0294] The server checks the consistency between the received request data and sentiment data. It verifies that the format and required fields of the request data are correct.

[0295] Step 4:

[0296] The server inputs the verified request data into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions for supplementing or modifying the request data.

[0297] Step 5:

[0298] The generative artificial intelligence model calculates and generates house floor plans based on verified request data. Specifically, it automatically generates the size and placement of each room.

[0299] Step 6:

[0300] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. It then formats the generated floor plan so that the user can visually review it.

[0301] Step 7:

[0302] The server sends visualized floor plan data to the terminal. It is then displayed via a responsive design or a dedicated application for user review.

[0303] Step 8:

[0304] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they might enter a request such as, "I'd like the kitchen to be a little bigger."

[0305] Step 9:

[0306] The terminal resends the user's modification request data and the emotion data at that time to the server. The modification request data is also sent in JSON format. Example of data:

[0307] json

[0308] {

[0309] "modify": "expand",

[0310] "target": "kitchen",

[0311] "details": "more space",

[0312] "user_emotion": "concerned"

[0313] }

[0314] Step 10:

[0315] The server receives the modification request data and the emotion data, and inputs them into the generative AI model. Furthermore, the emotion engine analyzes the user's emotion and makes a proposal according to the modification request.

[0316] Step 11:

[0317] The generative AI model performs recalculation based on the modification request and the proposal of the emotion engine, and generates a new floor plan.

[0318] Step 12:

[0319] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[0320] Step 13:

[0321] Repeat this process from step 8 to step 12 until the user has reviewed it again and is satisfied with the final drawing.

[0322] Step 14:

[0323] The emotion engine recognizes the user's emotions when they review the final drawing and, if the user is not satisfied, provides a means to gather further feedback. The process is repeated until the user expresses a positive emotion such as "satisfied" or "happy."

[0324] Step 15:

[0325] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0326] Step 16:

[0327] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[0328] (Example 2)

[0329] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0330] In residential floor plan design, it is essential to quickly and accurately reflect the user's requests. Furthermore, understanding the user's emotions and providing suggestions and advice to alleviate stress and dissatisfaction is also crucial. Conventional systems struggle not only to properly understand user requests and generate optimal floor plans, but also to consider user emotions, making it difficult to increase user satisfaction. This invention solves these problems.

[0331] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0332] In this invention, the server includes means for the user to input requests regarding the layout of a house; means for transmitting the input request data to the server; means for the server to input the received request data into a generative artificial intelligence model; means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats; means for the user to send revision requests to the server again; means for the server to reprocess the revision requests and generate a new floor plan; means including an emotion engine that recognizes the user's emotions and makes input and revision suggestions based on those emotions; and means for finally providing the floor plan approved by the user in digital format. This makes it possible to quickly and accurately reflect the user's requests and generate an optimal floor plan that also takes the user's emotions into consideration.

[0333] A "user" is someone who uses the system to input requests regarding the layout of a house, and then reviews and approves the final floor plan.

[0334] A "server" is a core information processing device that receives request data sent from users, processes the data using a generative artificial intelligence model and an emotion engine, and generates and provides the final floor plan.

[0335] A "generative artificial intelligence model" refers to an artificial intelligence algorithm and related software for automatically generating floor plans of houses based on user request data.

[0336] An "emotion engine" is a technology that recognizes emotions from user input and actions, and provides suggestions and corrective advice based on those emotions.

[0337] A "floor plan" is a drawing that shows the arrangement of rooms and facilities in a house, and is provided to the user visually in two-dimensional and three-dimensional formats.

[0338] "Request data" refers to information entered by users regarding their wishes and requests about the layout of their homes, which is transmitted to the server in data format such as JSON.

[0339] A "revision request" refers to a user's wishes or requests for changes or additions to a floor plan after reviewing the generated plan.

[0340] "Two-dimensional and three-dimensional formats" refer to formats for displaying and reviewing floor plans using different visual representations, and include plan views (2D) and three-dimensional views (3D).

[0341] "Digital format" refers to electronic data formats, such as providing floor plans and other information in PDF or CAD data formats.

[0342] This invention relates to a system that allows a user to input their preferences regarding the layout of a house and generates a floor plan based on those preferences. Furthermore, it includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. Details of this system, including the hardware and software used and specific processes, are described below.

[0343] System Configuration

[0344] This system consists of the following main elements:

[0345] A terminal where users enter their requests.

[0346] Server that processes request data

[0347] Generative artificial intelligence models

[0348] Emotional Engine

[0349] Hardware and software

[0350] terminal

[0351] The devices on which users can enter requests include desktop computers, laptops, tablets, and smartphones. On these devices, a browser-based web form or a dedicated application will operate.

[0352] Examples of use: Google Chrome® browser and custom mobile apps

[0353] server

[0354] The server receives request data sent by the user, checks the data's integrity, and then inputs it into a generative artificial intelligence model. The following technologies are primarily used:

[0355] Web servers: Apache®, NGINX

[0356] Server-side languages: Python, Node.js

[0357] Generative artificial intelligence models

[0358] The generative artificial intelligence model is used to generate floor plans of houses based on received request data. The model is based on deep learning and utilizes the following framework:

[0359] TensorFlow, PyTorch

[0360] Emotional Engine

[0361] The emotion engine recognizes the user's emotions when they input requests or review drawings, and uses that information to provide suggestions and advice.

[0362] Sentiment analysis libraries: Python's NLTK, spaCy

[0363] Specific example of processing

[0364] 1. Entering request data

[0365] Users enter specific requests regarding the layout of their home through a web form or application on their device. Examples include "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[0366] 2. Sending request data

[0367] The terminal converts the entered request data into JSON format and sends it to the server.

[0368] 3. Data integrity check

[0369] The server checks the integrity of the received request data, verifying that there is no missing data or format errors.

[0370] 4. Emotion recognition

[0371] The emotion engine built into the server analyzes the user's input and input circumstances to recognize the user's emotions. If the user is experiencing stress, it provides appropriate guidance.

[0372] 5. Generating a floor plan

[0373] The server inputs the verified request data into a generative artificial intelligence model, and the AI ​​model generates a floor plan.

[0374] 6. Visualization of floor plans

[0375] The server receives the generated floor plan data, visualizes it in 2D and 3D formats, and sends it to the user's device. Tools such as Three.js and Blender are used for visualization.

[0376] 7. Enter your request for corrections.

[0377] Users can review the visualized floor plan and submit revision requests as needed. For example, they might enter specific requests such as wanting the kitchen to be a little larger.

[0378] 8. Emotion-based proposals

[0379] The emotion engine recognizes the emotions a user feels when submitting a revision request, and, for example, if the user is feeling anxious, it makes revision suggestions based on that emotion.

[0380] Example of a prompt

[0381] As an example of a prompt message to be input to a generative artificial intelligence model based on user requests,

[0382] "Based on the user's requests, please generate a floor plan that includes a 4LDK layout, a south-facing living room, a connected kitchen and dining area, and a large bathroom."

[0383] This configuration allows for the real-time reflection of user requests and emotions, enabling the generation of optimal floor plans.

[0384] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0385] Step 1: The user enters their request.

[0386] Users open a web form or dedicated app on their device and enter their requests regarding the layout of their home. Specifically, they enter requests in text format, such as "4LDK" and "south-facing living room."

[0387] Input: User-submitted request data (e.g., "4LDK", "Living room faces south")

[0388] Output: The request data is stored in the form.

[0389] Step 2: Submit your request

[0390] The terminal converts the entered request data into JSON format and sends it to the server. Specifically, it converts the form data into the following JSON format and sends it to the server as an HTTP request.

[0391] Input: Request data stored in the form

[0392] Output: JSON data sent to the server

[0393] json

[0394] {

[0395] "rooms": 4,

[0396] "orientation": "south",

[0397] "kitchen_dining": "connected"

[0398] }

[0399] Step 3: Data reception and integrity check

[0400] The server receives the request data sent from the terminal and checks the data's integrity. Specifically, it parses the received data and verifies that there is no missing data and that the data format is correct.

[0401] Input: JSON data sent to the server

[0402] Output: Confirmed consistency of request data

[0403] Step 4: Emotion recognition by the emotion engine

[0404] The server's built-in emotion engine analyzes the user's emotions during this request input process. Specifically, it uses a Python NLP library to assign emotion labels to the input text.

[0405] Input: Request data and user text and behavior captured during input.

[0406] Output: Request data with emotion labels

[0407] Step 5: Inputting the request data into the AI ​​model

[0408] The server inputs emotion-labeled request data into a generative artificial intelligence model. Specifically, it converts the data into an appropriate format and sends it to the AI ​​model's API.

[0409] Input: Request data with emotion labels

[0410] Output: Data sent to the generative artificial intelligence model

[0411] Step 6: AI-powered floor plan generation

[0412] The generative artificial intelligence model generates floor plans for houses based on submitted request data. Specifically, it analyzes the request data, calculates an appropriate floor plan, and generates it.

[0413] Input: Request data sent from the server

[0414] Output: Generated floor plan data

[0415] Step 7: Visualize and submit the floor plan.

[0416] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. Specifically, it visualizes the data using Three.js or Blender and sends that data to the terminal.

[0417] Input: Generated floor plan data

[0418] Output: Visualized 2D and 3D floor plans

[0419] Step 8: User review and input of correction requests

[0420] Users review the floor plan generated on their device and enter revision requests as needed. Specifically, they look at the floor plan and enter revision requests such as "Make the kitchen a little bigger."

[0421] Input: Visualized floor plan and user modification requests

[0422] Output: Correction request data

[0423] Step 9: Reprocessing the correction request

[0424] The server re-inputs the correction request data sent by the user into the generative artificial intelligence model and instructs it to generate a new floor plan.

[0425] Input: User correction request data

[0426] Output: Generative artificial intelligence model that received correction instructions

[0427] Step 10: Generate and submit a new floor plan.

[0428] The generative artificial intelligence model generates a new floor plan based on the requested modification data and sends it to the server. Specifically, it performs recalculations and generates new floor plan data.

[0429] Input: Data for which correction instructions were received

[0430] Output: New floor plan data

[0431] Step 11: Review and approval of the final drawings

[0432] The user reviews the floor plan again and gives final approval. This process is repeated until a satisfactory drawing is obtained.

[0433] Input: New floor plan data

[0434] Output: Final approved floor plan data

[0435] Step 12: Submitting the final drawings

[0436] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder. Specifically, it exports the floor plan in the appropriate digital format and sends it via email or a dedicated portal.

[0437] Input: Final approved floor plan data

[0438] Output: Drawings in PDF or CAD data format provided to the house builder.

[0439] The above is a detailed explanation of the system's program processing flow.

[0440] (Application Example 2)

[0441] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as a "server" and the smart device 14 as a "terminal".

[0442] Conventional spatial layout design systems merely mechanically generate layouts based on user request data, failing to reflect user emotions. Therefore, they couldn't reproduce the layout the user considered optimal, making it difficult to sufficiently improve user satisfaction. Furthermore, when users submitted revision requests, the suggestions weren't based on emotions, meaning the regenerated layouts didn't always match the user's wishes.

[0443] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for the user to input a request regarding the layout of a space, means for transmitting the input request data to the server, means for the server to input the received request data to a generative artificial intelligence model, means for the generative artificial intelligence model to generate a layout of a space based on the request data, means for an emotion engine that recognizes the user's emotions and optimizes the request data based on the emotion data, means for allowing the user to visually confirm the generated layout diagram, means for transmitting the user's correction requests to the server again, means for the server to reprocess the correction requests and emotion data to generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This makes it possible to generate an optimal layout that reflects the user's emotions and increase user satisfaction.

[0444] "Spatial layout" refers to drawings or plans that show the physical arrangement and structure within a specific space.

[0445] "Request data" refers to data that indicates the user's wishes and requirements regarding the layout of the space.

[0446] A "server" is a computer system that receives, processes, stores, and transmits data from users.

[0447] A "generative artificial intelligence model" is an artificial intelligence algorithm that automatically generates spatial layouts based on user request data.

[0448] An "emotion engine" is a system that recognizes the user's emotions and reflects that emotional data in the request data.

[0449] "Optimization" refers to adjusting or modifying data or processes to obtain the best possible results under specific conditions or constraints.

[0450] A "layout diagram" is a diagram that visually represents the layout and structure of a space, and includes both two-dimensional and three-dimensional formats.

[0451] "Visual confirmation" refers to displaying the generated layout diagram in a format visible to the user.

[0452] "Revision requests" are data that users indicate additional requests or changes they would like to make to existing layout diagrams.

[0453] "Reprocessing" is the process of regenerating a new layout based on requested modifications and other relevant data.

[0454] "The layout diagram that the user ultimately approved" refers to the layout diagram that the user ultimately found satisfactory and determined did not require any changes.

[0455] System Overview

[0456] This invention is a system that generates an optimal layout by having the user input their preferences regarding the layout of a space and then analyzing emotional data. The system consists of the following main components:

[0457] A terminal for users to input request data.

[0458] A server that receives, sends, and processes request data and emotion data.

[0459] Generative artificial intelligence model that generates layouts based on request data

[0460] An emotion engine that analyzes user emotions.

[0461] Hardware and software to use

[0462] Hardware:

[0463] Smartphones and tablets: Users input request data and check the results.

[0464] Server: Used for receiving, processing, storing, and transmitting data.

[0465] software:

[0466] Flask: Used as a server-side web framework.

[0467] EmotionAnalyzer: A library for analyzing user emotion data.

[0468] LayoutGenerator: A generative artificial intelligence model for generating layouts based on request data.

[0469] Processing flow details

[0470] 1. Inputting user request data:

[0471] Users use smartphones or tablets to input specific requests regarding the layout of the space in text format. For example, "I would like a spacious layout in front of the cash registers."

[0472] 2. Collection of emotional data:

[0473] The user's emotions are also collected simultaneously and analyzed by EmotionAnalyzer. For example, information such as "feeling stressed" is analyzed.

[0474] 3. Submitting request data:

[0475] The terminal sends the entered request data and emotion data to the server in JSON format.

[0476] 4. Data optimization and layout generation:

[0477] The server processes the received data and optimizes the request data based on emotional data. For example, if the user is feeling stressed, it suggests a simpler layout. This optimized data is then input into a generative artificial intelligence model to generate the spatial layout.

[0478] 5. Visualizing the generated layout:

[0479] The generated layout diagrams are presented to the user visually in both two-dimensional and three-dimensional formats. For example, they might be displayed as "a layout with wide checkout counters and wide aisles."

[0480] 6. Implementation of requested revisions:

[0481] The user reviews the generated layout diagram and enters revision requests as needed. Requests such as "It's too large, I'd like to make it a bit more compact" are entered here.

[0482] 7. Regeneration process:

[0483] The server reprocesses the revision request, re-analyzes the sentiment data, and generates a new layout diagram. This process is repeated until the user is satisfied.

[0484] 8. Providing the final layout:

[0485] The fully satisfactory layout diagram will ultimately be provided to the user in PDF or other digital formats.

[0486] Specific examples and prompt statements

[0487] As a concrete example, a store owner using the app to design a new layout generates a layout where "the area in front of the checkout counter is spacious, making the shopping process feel smoother."

[0488] Example of a prompt:

[0489] "Please create a store layout with a spacious area in front of the cash registers and a user-friendly counter."

[0490] In this way, the invention makes it possible to realize an optimal spatial layout that reflects the user's emotions, thereby increasing user satisfaction.

[0491] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0492] Step 1:

[0493] Users use their smartphones or tablets to input specific requests regarding the layout of the space into the application. For example, they might enter a request such as, "I want a spacious area in front of the cash registers." This input data is saved in text format.

[0494] Step 2:

[0495] The terminal sends the entered request data to the server in JSON format. Simultaneously, user emotion data (e.g., "feeling stressed") is also collected and sent to the server in JSON format. This data is sent from the terminal to the server as an HTTP request.

[0496] Step 3:

[0497] The server receives the submitted request and sentiment data and checks the data's integrity. It verifies that the received data is in the correct format and returns an error message if there are any inconsistencies. Once the data's integrity is confirmed, it proceeds to the next process.

[0498] Step 4:

[0499] The server uses an emotion engine to analyze the user's emotional data. For example, the emotion engine might analyze the user's stress level and output a result such as "high stress level." This result is then used to optimize the request data.

[0500] Step 5:

[0501] The server optimizes request data based on emotional data. For example, if the analysis indicates that the user is "feeling stressed," it will suggest a wider layout, implementing stress reduction measures in response to the request data. This optimized data is then input into a generative artificial intelligence model.

[0502] Step 6:

[0503] The server receives request data optimized for a generative artificial intelligence model, which then generates a spatial layout. The generative AI model automatically generates two-dimensional and three-dimensional layout diagrams based on the input data. The results are output in JSON format.

[0504] Step 7:

[0505] The server visualizes the generated layout diagram and sends it to the user's terminal. The user can review the generated layout diagram on the application and enter revision requests as needed. For example, a revision request might be, "The checkout area is too large; I'd like to make it more compact."

[0506] Step 8:

[0507] The terminal resends the entered correction request to the server. This correction request data is sent in JSON format, as before, and after receiving it, the server uses the sentiment engine again to analyze the user's current sentiment data.

[0508] Step 9:

[0509] The server performs the optimization process again based on the requested modifications and the re-analyzed sentiment data. The optimized data is re-input, and the generative artificial intelligence model regenerates the new layout. This regeneration process is repeated until the user is satisfied.

[0510] Step 10:

[0511] The final layout diagram, once approved by the user, is provided to the user from the server in PDF or other digital formats. The user can then view this final layout diagram on their device and download or print it as needed.

[0512] In this way, it becomes possible to generate an optimal spatial layout that reflects the user's needs and emotions, thereby increasing user satisfaction.

[0513] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0514] Data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0515] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart device 14.

[0516] [Second Embodiment]

[0517] Figure 3 shows an example of the configuration of the data processing system 210 according to the second embodiment.

[0518] As shown in Figure 3, the data processing system 210 includes a data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0519] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0520] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication interface 44. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, and camera 42 are also connected to the bus 52.

[0521] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0522] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0523] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0524] Figure 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Figure 4, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0525] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0526] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0527] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0528] Next, the identification processing performed by the identification processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0529] This invention relates to a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model generates a layout based on those requirements, and finally provides it to a house builder. The program and processing of this system are described below.

[0530] 1. The user enters their request.

[0531] The user opens a dedicated application or web form on their device (e.g., PC, tablet, smartphone).

[0532] Users enter detailed requests regarding the layout of their home, such as the number of rooms, orientation, specific functions, and size, into a form.

[0533] For example, specific requests such as "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom" can be entered.

[0534] 2. Sending request data

[0535] The terminal sends the request data entered by the user to the server. The request data is sent in a structured format (e.g., JSON).

[0536] example:

[0537] json

[0538] {

[0539] "rooms": 4,

[0540] "orientation": "south",

[0541] "kitchen_dining": "connected",

[0542] "bathroom": "large"

[0543] }

[0544] 3. Data reception and input into the AI ​​model

[0545] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[0546] The server inputs the data, whose integrity has been verified, into the generative artificial intelligence model.

[0547] 4. AI-powered floor plan generation

[0548] The generative artificial intelligence model uses an algorithm trained on past housing design data to calculate the optimal floor plan based on user requests.

[0549] The generative artificial intelligence model determines the size and layout of each room based on the input request data.

[0550] 5. Output and transmission of generated results

[0551] The server receives the generated floor plan and visualizes it in two-dimensional (2D) and three-dimensional (3D) formats.

[0552] The server sends the visualized floor plan data to the terminal.

[0553] 6. User review and input of correction requests.

[0554] The user reviews the floor plan generated on their device. They visually check elements such as room layout, size, and orientation as checkpoints on the plan.

[0555] If a user wants to make a change, they simply re-enter their request into the terminal, for example, "I want the kitchen to be a little bigger."

[0556] The device sends this correction request data to the server. The correction request data is also sent in JSON format.

[0557] json

[0558] {

[0559] "modify": "expand",

[0560] "target": "kitchen",

[0561] "details": "more space"

[0562] }

[0563] 7. Reprocessing of correction requests

[0564] The server then inputs the requested correction data back into the generative artificial intelligence model and instructs it to generate a new floor plan.

[0565] The generative artificial intelligence model recalculates based on the requested modifications and generates a revised floor plan.

[0566] 8. Generation and verification of the final drawing

[0567] The server generates a new floor plan and sends it back to the terminal.

[0568] The user reviews the design again, and if a satisfactory floor plan is generated, it will be approved as the final drawing.

[0569] 9. Provision of final drawings

[0570] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0571] The final drawings are sent to the home builder via email or a dedicated online portal.

[0572] In this way, the system of the present invention can generate floor plans that quickly and accurately reflect the user's requests, significantly streamlining the design process for custom-built homes.

[0573] The following describes the processing flow.

[0574] Step 1:

[0575] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, layout, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[0576] Step 2:

[0577] The terminal sends the entered request data to the server in JSON format. Example data:

[0578] json

[0579] {

[0580] "rooms": 4,

[0581] "orientation": "south",

[0582] "kitchen_dining": "connected",

[0583] "bathroom": "large"

[0584] }

[0585] Step 3:

[0586] The server receives the submitted request data and checks its integrity. This integrity check includes verifying the data format and required fields.

[0587] Step 4:

[0588] The server inputs the verified request data into the generative artificial intelligence model. Specifically, it processes the data to conform to the model's format.

[0589] Step 5:

[0590] The generative artificial intelligence model calculates and generates a house layout based on the given request data. Specifically, it automatically generates the size, arrangement, and orientation of rooms according to the request.

[0591] Step 6:

[0592] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[0593] Step 7:

[0594] The server sends visualized floor plan data to the terminal. The user receives and reviews this data via a responsive design or a dedicated application.

[0595] Step 8:

[0596] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[0597] Step 9:

[0598] The device resends the user's correction request data to the server. The correction request data is again sent in JSON format. Example data:

[0599] json

[0600] {

[0601] "modify": "expand",

[0602] "target": "kitchen",

[0603] "details": "more space"

[0604] }

[0605] Step 10:

[0606] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[0607] Step 11:

[0608] The generative artificial intelligence model recalculates the floor plan based on the requested modifications and generates a new floor plan.

[0609] Step 12:

[0610] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[0611] Step 13:

[0612] Repeat steps 8 through 12 until the user has reviewed and is satisfied with the final drawing.

[0613] Step 14:

[0614] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0615] Step 15:

[0616] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[0617] (Example 1)

[0618] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0619] Conventional residential design systems have difficulty quickly and accurately reflecting user requests, particularly the time-consuming and labor-intensive process of generating and modifying floor plans. Furthermore, visual confirmation of generated floor plans and the rapid incorporation of modification requests are difficult, resulting in an inefficient design process for custom-built homes. This invention aims to solve these problems and streamline the process of generating and modifying floor plans based on user requests.

[0620] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0621] In this invention, the server includes means for inputting user-entered request data into a generative artificial intelligence model, means for the generative artificial intelligence model to learn past housing design data, and means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats. This enables the rapid and accurate generation and modification of the optimal floor plan based on the user's requests.

[0622] "Request data" refers to information that users input regarding the layout of a house, including details such as the number of rooms, orientation, specific functions, and size.

[0623] A "generative artificial intelligence model" is an artificial intelligence system that includes an algorithm that learns from past housing design data and generates the optimal floor plan based on user request data.

[0624] A "server" is a computer system that receives request data sent by users and inputs it into a generative artificial intelligence model.

[0625] "Two-dimensional and three-dimensional formats" refer to the formats used to visually display the generated floor plan, and include both 2D formats that display it as a plan view and 3D formats that visualize it in three dimensions.

[0626] A "revision request" is data entered by the user after reviewing the generated floor plan, indicating the parts they wish to change or modify.

[0627] A "construction contractor" refers to a company or individual that constructs a house based on the floor plan ultimately approved by the user.

[0628] This invention is a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model is used to generate a layout based on those requirements, and the layout is ultimately provided to a construction company. The program and processing of this system are described in detail below.

[0629] Users access a dedicated application or web form using devices such as PCs, tablets, or smartphones. A login function is available, and users log in by entering their account information. Users then enter detailed requests in an input form, such as the number of rooms in the house, its orientation, specific functions, and size. For example, they might enter specific requests like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[0630] The terminal converts the user's input request data into JSON format. The following data format is generated:

[0631] json

[0632] {

[0633] "rooms": 4,

[0634] "orientation": "south",

[0635] "kitchen_dining": "connected",

[0636] "bathroom": "large"

[0637] }

[0638] The terminal sends this JSON data to the server using the HTTPS protocol. The server checks the integrity of the received request data and returns an error message if necessary. Once integrity is confirmed, the server converts the data into a format suitable for generative artificial intelligence models.

[0639] The server inputs the converted data into a generative artificial intelligence model. The model uses an algorithm trained on past housing design data to calculate the optimal floor plan. This algorithm automatically generates a floor plan including the size and placement of each room.

[0640] Once the generative AI model finishes its calculations, the server visualizes the generated floor plan in 2D and 3D formats. Technologies such as WebGL and Three.js may be used for visualization. This visualized floor plan data is then converted back into JSON format, and the server sends it to the terminal.

[0641] The user reviews the floor plan generated on their device. While visually reviewing it, they input modification requests such as "I'd like the kitchen to be a little bigger." For example, they might input a modification request like "Make the kitchen bigger" in text format as follows:

[0642] "modify: expand, target: kitchen, details: more space"

[0643] The terminal converts the revision request data into JSON format and sends it back to the server. The server re-inputs the revision request data into the generative artificial intelligence model and generates a new floor plan.

[0644] The server generates a new floor plan and sends it back to the terminal. The user reviews it again, and if they are finally satisfied with the generated drawing, they give it final approval. The server generates the final floor plan in PDF or CAD data format and provides it to the builder. The final drawing is sent to the builder via email or a dedicated online portal. This system can generate floor plans that quickly and accurately meet the user's requests, significantly streamlining the custom home design process.

[0645] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0646] Step 1:

[0647] The user launches the application. The user opens the dedicated application or web form using a device such as a PC, tablet, or smartphone. The user enters their account information and logs in. Input: Account information, Output: Login session.

[0648] Step 2:

[0649] The user enters their requirements. The user enters detailed requirements such as the number of rooms in the house, orientation, specific functions, and size into an input form. For example, they might enter specific requirements like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom." Input: Request data; Output: Structured input data (e.g., JSON format).

[0650] Step 3:

[0651] The device sends data. The device converts the user-entered request data into JSON format and then sends it to the server using the HTTPS protocol. Specifically, it generates an HTTP request and sends the data. Input: Structured input data; Output: Data contained in the HTTP request.

[0652] Step 4:

[0653] The server receives the data. The server checks the integrity of the requested data received via the HTTPS protocol and returns an error message if necessary. Once integrity is confirmed, the data is converted into a format suitable for a generative artificial intelligence model. Input: Data received from the HTTP request; Output: Converted data.

[0654] Step 5:

[0655] The server inputs data into the AI ​​model. The server then inputs the transformed data into a generative artificial intelligence model. Data interpolation and preprocessing are performed as needed. Input: Data that has been formatted; Output: Data input into the AI ​​model.

[0656] Step 6:

[0657] A generative artificial intelligence model generates floor plans. The AI ​​model uses an algorithm to calculate the optimal floor plan based on the input request data. The model references past housing design data stored in a database. Input: Data entered into the AI ​​model; Output: Generated floor plan data.

[0658] Step 7:

[0659] The server receives the floor plan. The server visualizes the generated floor plan data in 2D and 3D formats. Visualization may utilize technologies such as WebGL or Three.js. The visualized data is then converted back to JSON format and sent to the terminal. Input: Generated floor plan data, Output: Visualized data.

[0660] Step 8:

[0661] The user reviews the floor plan. The user reviews the floor plan generated on their device and makes a visual evaluation. They check the room layout, size, orientation, etc., and may also enter revision requests. Input: Visualized data; Output: User feedback and revision requests.

[0662] Step 9:

[0663] The terminal sends a correction request. The correction request entered by the user is converted to JSON format and sent back to the server. A concrete example of a request might be "Make the kitchen bigger." Input: Correction request data, Output: Correction request data included in the HTTP request.

[0664] Step 10:

[0665] The server processes the revision request. The server re-inputs the revision request data into the generative artificial intelligence model and instructs it to generate a new floor plan. Input: Revision request data received from the HTTP request; Output: Revision data input into the AI ​​model.

[0666] Step 11:

[0667] The generative artificial intelligence model performs a recalculation. The AI ​​model recalculates based on the requested modifications and generates a new floor plan. Input: Modification data entered into the AI ​​model; Output: Modified floor plan data.

[0668] Step 12:

[0669] The server generates a new floor plan. The server generates a new floor plan and sends it back to the terminal. Input: Modified floor plan data, Output: Visualized new floor plan data.

[0670] Step 13:

[0671] The user performs the final review. The user checks the new floor plan on their device and, if the generated drawing is satisfactory, gives final approval. Input: Visualized new floor plan data, Output: Final approval.

[0672] Step 14:

[0673] The server provides the final drawings. The server generates the final floor plans in PDF or CAD data format and provides them to the construction company. The final drawings are provided via email or a dedicated online portal. Input: Final approved floor plan data; Output: Final drawings in PDF or CAD data format.

[0674] (Application Example 1)

[0675] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0676] Designing the layout of machinery and work within a factory is crucial for maximizing efficiency, safety, and productivity. However, traditional layout design is often done manually, which is time-consuming and costly. Furthermore, finding the optimal layout requires advanced expertise, and any modifications or changes necessitate redesign. To address these challenges, there is a need for a system that allows users to easily design factory layouts and quickly provide optimized layouts using generative artificial intelligence models.

[0677] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0678] In this invention, the server includes means for the user to input layout requests, means for transmitting the input request data to the server, means for the server to input the received request data into a generative artificial intelligence model, means for allowing the user to visually confirm the generated layout diagram, means for the user to send revision requests to the server again, means for the server to reprocess the revision requests and generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This enables the rapid and efficient design of the optimal layout within the factory, simplifying the design process and improving its accuracy.

[0679] A "user" is an individual or group that uses the system to design layouts.

[0680] "Layout" refers to the arrangement of machinery, work stations, employee movement routes, safety areas, and other elements within a factory.

[0681] "Request data" refers to data that includes the user's desired conditions and requirements for layout design.

[0682] A "server" is a computer system that receives request data sent by users and generates and regenerates layouts using a generative artificial intelligence model.

[0683] A "generative artificial intelligence model" is an artificial intelligence system that includes algorithms for generating the optimal layout based on user request data.

[0684] "Means of visual confirmation" refers to an interface that displays the generated layout diagram in a way that allows the user to view it in two-dimensional and three-dimensional formats.

[0685] A "revision request" is a request from a user for additional changes or adjustments to a layout diagram that has been generated.

[0686] The "finally approved layout diagram" is the layout diagram that the user deemed to be the optimal state and ultimately approved for adoption.

[0687] "Means of provision" refers to the means of providing the finally approved layout diagram to users and other related systems in digital format or other means.

[0688] In order to implement this invention, it is necessary to build a system in which users, servers, and terminals work closely together to efficiently and quickly design factory layouts.

[0689] Hardware and software configuration

[0690] 1. User terminal:

[0691] This involves using devices with input interfaces, such as tablets and smartphones, to allow users to input their factory layout requirements.

[0692] 2. Server:

[0693] High-performance computing servers (e.g., AWS EC2) are used to receive request data, operate generative artificial intelligence models, and transform data.

[0694] 3. Generative artificial intelligence models:

[0695] Using frameworks such as TensorFlow and PyTorch, we execute algorithms that generate the optimal factory layout based on user request data.

[0696] Program processing flow

[0697] The user enters the request data.

[0698] The user opens the application on their terminal and enters their requirements regarding the factory layout. These requirements include the number of work lines, the types and number of machines needed, employee movement routes, and the setting of safety areas. For example, the following requirements are entered in text format:

[0699] Number of production lines: 3

[0700] Types and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units

[0701] Employee travel routes: Line 1, Line 2

[0702] Safety area settings: Storage area

[0703] Sending request data to the server

[0704] The entered request data is converted into a structured format and sent to the server. The server receives the data and checks its integrity.

[0705] Input to a generative artificial intelligence model

[0706] The server inputs the verified request data into a generative artificial intelligence model. Based on past factory layout design data, the model calculates the optimal layout that best suits the user's requests.

[0707] Providing the generated layout diagram to the user

[0708] The generated layout diagrams are visualized in two-dimensional and three-dimensional formats and sent to the user's terminal. The user visually reviews them and re-enters any revision requests if necessary.

[0709] Reprocessing of correction requests

[0710] The user's revision requests are sent back to the server, where a generative artificial intelligence model recalculates and generates a new layout diagram. This process is repeated until a satisfactory layout diagram is completed.

[0711] Provision of the final layout drawing

[0712] The final layout diagram approved by the user is provided in digital format and sent to the user and other relevant systems.

[0713] Through the above process, the optimal factory layout can be designed quickly and efficiently. This system enables improvements in factory production efficiency and safety.

[0714] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0715] Step 1:

[0716] The user enters the request data.

[0717] The user opens an application on their terminal and enters their requirements for the factory layout. Input fields include the number of work lines, the type and number of machines required, employee movement routes, and safety area settings. For example, "Number of work lines: 3," "Type and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units," "Employee movement routes: Line 1, Line 2," and "Safety area settings: Storage area." The input data is converted into a structured format (JSON).

[0718] Step 2:

[0719] Sending request data to the server

[0720] The terminal sends the request data entered by the user to the server. The server checks the integrity of the received request data. Specifically, it verifies the data format, checks required fields, and validates the value range. Once the integrity check is complete, the data is converted into a format that can be input into a generative artificial intelligence model. The input is the user's request data, and the output is the data whose integrity has been verified.

[0721] Step 3:

[0722] Input to a generative artificial intelligence model

[0723] The server inputs verified request data into a generative artificial intelligence model. Based on past factory layout design data, the generative AI model calculates the optimal layout suitable for the user's requests. Specifically, it optimizes the placement of various machines, the design of work lines, employee movement routes, and the definition of safety areas through data calculations. The input is consistent request data, and the output is a generated layout diagram.

[0724] Step 4:

[0725] Providing the generated layout diagram to the user

[0726] The server visualizes the generated layout diagram in two-dimensional and three-dimensional formats and sends the data to the user's terminal. The user then reviews the visualized layout diagram. Specifically, the layout diagram is displayed in 2D and 3D on the terminal. The user visually confirms the arrangement of each work line, the location of machines, the location of safety areas, etc. The input is the generated layout diagram, and the output is the visualized layout diagram.

[0727] Step 5:

[0728] User input for correction requests

[0729] If a user is dissatisfied with the layout diagram, they can submit a request for revision. For example, specific requests such as "Move the machine placement on line 1 to the left" or "Expand the storage area." The terminal then sends the revision request data to the server. The input is the user's revision request data, and the output is the revision request data sent to the server.

[0730] Step 6:

[0731] Reprocessing of correction requests

[0732] The server re-inputs the requested modification data into the generative artificial intelligence model and generates a new layout diagram. The model recalculates and updates the layout based on the requested modifications. Specifically, it optimizes the overall layout while reflecting the changes requested by the user. The input is the requested modification data, and the output is the modified layout diagram.

[0733] Step 7:

[0734] Provision of the final layout drawing

[0735] The server sends the revised layout drawing back to the user's terminal. The user performs a final review and approves it if they are satisfied. The finally approved layout drawing is provided in digital format. Specifically, it is output as PDF or CAD data and provided to the user via email or online portal. The input is the final reviewed layout drawing, and the output is a digital layout drawing.

[0736] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0737] This invention relates to a system that allows users to input and modify their requests regarding the layout of a house and generates a floor plan based on those requests, as well as a system that includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. The program and processing of this system are described below.

[0738] 1. The user enters their request.

[0739] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. For example, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[0740] 2. Sending request data

[0741] The terminal sends the entered request data to the server in JSON format. Example data:

[0742] json

[0743] {

[0744] "rooms": 4,

[0745] "orientation": "south",

[0746] "kitchen_dining": "connected",

[0747] "bathroom": "large"

[0748] }

[0749] 3. Data reception and input into the AI ​​model

[0750] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[0751] 4. Complementing user emotions with an emotion engine

[0752] The server is equipped with an emotion engine that recognizes the user's emotions when they enter a request. This emotion data is reflected in the request data, and if the user is, for example, "feeling stressed," the system will provide supplementary information such as suggesting a more concise request.

[0753] 5. AI-powered floor plan generation

[0754] The generative AI model calculates and generates house floor plans based on verified request data. The generative AI model automatically generates the size and placement of each room according to the user's requests.

[0755] 6. Output and transmission of generated results

[0756] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[0757] 7. User review and input of correction requests.

[0758] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[0759] 8. Revision suggestions based on the emotion engine

[0760] The emotion engine recognizes the user's emotions when reviewing a floor plan, and if, for example, the user is feeling anxious, it automatically generates modification suggestions based on that emotion. As an example of a suggestion, it might offer a specific suggestion such as, "If you feel the kitchen is too small, how about converting part of the living room into a kitchen?"

[0761] 9. Reprocessing of correction requests

[0762] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[0763] 10. Recalculation by generative AI

[0764] The generative artificial intelligence model recalculates based on modification requests and suggestions from the emotion engine to generate a new floor plan.

[0765] 11. Generate and send a new floor plan.

[0766] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[0767] 12. Review and approval of the final drawings

[0768] This process is repeated until the user reviews it again and is satisfied with the final drawing.

[0769] The emotion engine recognizes the user's emotions when they review the final drawing and provides a means to gather further feedback if they are not satisfied.

[0770] 13. Provision of final drawings

[0771] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0772] The final drawings are sent to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[0773] Thus, the system of the present invention can recognize the user's emotions and generate floor plans that quickly and accurately reflect the user's requests, thereby significantly streamlining the design process for custom-built homes.

[0774] The following describes the processing flow.

[0775] Step 1:

[0776] The user opens the application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[0777] Step 2:

[0778] The terminal sends the input request data and user emotion data (e.g., the results of emotion analysis of the user's facial expressions and voice while inputting) to the server in JSON format. Example data:

[0779] json

[0780] {

[0781] "rooms": 4,

[0782] "orientation": "south",

[0783] "kitchen_dining": "connected",

[0784] "bathroom": "large",

[0785] "user_emotion": "neutral"

[0786] }

[0787] Step 3:

[0788] The server checks the consistency between the received request data and sentiment data. It verifies that the format and required fields of the request data are correct.

[0789] Step 4:

[0790] The server inputs the verified request data into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions for supplementing or modifying the request data.

[0791] Step 5:

[0792] The generative artificial intelligence model calculates and generates house floor plans based on verified request data. Specifically, it automatically generates the size and placement of each room.

[0793] Step 6:

[0794] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. It then formats the generated floor plan so that the user can visually review it.

[0795] Step 7:

[0796] The server sends visualized floor plan data to the terminal. It is then displayed via a responsive design or a dedicated application for user review.

[0797] Step 8:

[0798] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they might enter a request such as, "I'd like the kitchen to be a little bigger."

[0799] Step 9:

[0800] The device then resends the user's correction request data and their current sentiment data to the server. The correction request data is also sent in JSON format. Example data:

[0801] json

[0802] {

[0803] "modify": "expand",

[0804] "target": "kitchen",

[0805] "details": "more space",

[0806] "user_emotion": "concerned"

[0807] }

[0808] Step 10:

[0809] The server receives correction request data and emotion data, and inputs them into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions in response to the correction requests.

[0810] Step 11:

[0811] The generative artificial intelligence model recalculates based on modification requests and suggestions for the emotion engine, generating a new floor plan.

[0812] Step 12:

[0813] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[0814] Step 13:

[0815] Repeat this process from step 8 to step 12 until the user has reviewed it again and is satisfied with the final drawing.

[0816] Step 14:

[0817] The emotion engine recognizes the user's emotions when they review the final drawing and, if the user is not satisfied, provides a means to gather further feedback. The process is repeated until the user expresses a positive emotion such as "satisfied" or "happy."

[0818] Step 15:

[0819] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[0820] Step 16:

[0821] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[0822] (Example 2)

[0823] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal".

[0824] In residential floor plan design, it is essential to quickly and accurately reflect the user's requests. Furthermore, understanding the user's emotions and providing suggestions and advice to alleviate stress and dissatisfaction is also crucial. Conventional systems struggle not only to properly understand user requests and generate optimal floor plans, but also to consider user emotions, making it difficult to increase user satisfaction. This invention solves these problems.

[0825] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0826] In this invention, the server includes means for the user to input requests regarding the layout of a house; means for transmitting the input request data to the server; means for the server to input the received request data into a generative artificial intelligence model; means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats; means for the user to send revision requests to the server again; means for the server to reprocess the revision requests and generate a new floor plan; means including an emotion engine that recognizes the user's emotions and makes input and revision suggestions based on those emotions; and means for finally providing the floor plan approved by the user in digital format. This makes it possible to quickly and accurately reflect the user's requests and generate an optimal floor plan that also takes the user's emotions into consideration.

[0827] A "user" is someone who uses the system to input requests regarding the layout of a house, and then reviews and approves the final floor plan.

[0828] A "server" is a core information processing device that receives request data sent from users, processes the data using a generative artificial intelligence model and an emotion engine, and generates and provides the final floor plan.

[0829] A "generative artificial intelligence model" refers to an artificial intelligence algorithm and related software for automatically generating floor plans of houses based on user request data.

[0830] An "emotion engine" is a technology that recognizes emotions from user input and actions, and provides suggestions and corrective advice based on those emotions.

[0831] A "floor plan" is a drawing that shows the arrangement of rooms and facilities in a house, and is provided to the user visually in two-dimensional and three-dimensional formats.

[0832] "Request data" refers to information entered by users regarding their wishes and requests about the layout of their homes, which is transmitted to the server in data format such as JSON.

[0833] A "revision request" refers to a user's wishes or requests for changes or additions to a floor plan after reviewing the generated plan.

[0834] "Two-dimensional and three-dimensional formats" refer to formats for displaying and reviewing floor plans using different visual representations, and include plan views (2D) and three-dimensional views (3D).

[0835] "Digital format" refers to electronic data formats, such as providing floor plans and other information in PDF or CAD data formats.

[0836] This invention relates to a system that allows a user to input their preferences regarding the layout of a house and generates a floor plan based on those preferences. Furthermore, it includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. Details of this system, including the hardware and software used and specific processes, are described below.

[0837] System Configuration

[0838] This system consists of the following main elements:

[0839] A terminal where users enter their requests.

[0840] Server that processes request data

[0841] Generative artificial intelligence models

[0842] Emotional Engine

[0843] Hardware and software

[0844] terminal

[0845] The devices on which users can enter requests include desktop computers, laptops, tablets, and smartphones. On these devices, a browser-based web form or a dedicated application will operate.

[0846] Examples of use: Google® Chrome browser and custom mobile apps

[0847] server

[0848] The server receives request data sent by the user, checks the data's integrity, and then inputs it into a generative artificial intelligence model. The following technologies are primarily used:

[0849] Web servers: Apache, NGINX

[0850] Server-side languages: Python, Node.js

[0851] Generative artificial intelligence models

[0852] The generative artificial intelligence model is used to generate floor plans of houses based on received request data. The model is based on deep learning and utilizes the following framework:

[0853] TensorFlow, PyTorch

[0854] Emotional Engine

[0855] The emotion engine recognizes the user's emotions when they input requests or review drawings, and uses that information to provide suggestions and advice.

[0856] Sentiment analysis libraries: Python's NLTK, spaCy

[0857] Specific example of processing

[0858] 1. Entering request data

[0859] Users enter specific requests regarding the layout of their home through a web form or application on their device. Examples include "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[0860] 2. Sending request data

[0861] The terminal converts the entered request data into JSON format and sends it to the server.

[0862] 3. Data integrity check

[0863] The server checks the integrity of the received request data, verifying that there is no missing data or format errors.

[0864] 4. Emotion recognition

[0865] The emotion engine built into the server analyzes the user's input and input circumstances to recognize the user's emotions. If the user is experiencing stress, it provides appropriate guidance.

[0866] 5. Generating a floor plan

[0867] The server inputs the verified request data into a generative artificial intelligence model, and the AI ​​model generates a floor plan.

[0868] 6. Visualization of floor plans

[0869] The server receives the generated floor plan data, visualizes it in 2D and 3D formats, and sends it to the user's device. Tools such as Three.js and Blender are used for visualization.

[0870] 7. Enter your request for corrections.

[0871] Users can review the visualized floor plan and submit revision requests as needed. For example, they might enter specific requests such as wanting the kitchen to be a little larger.

[0872] 8. Emotion-based proposals

[0873] The emotion engine recognizes the emotions a user feels when submitting a revision request, and, for example, if the user is feeling anxious, it makes revision suggestions based on that emotion.

[0874] Example of a prompt

[0875] As an example of a prompt message to be input to a generative artificial intelligence model based on user requests,

[0876] "Based on the user's requests, please generate a floor plan that includes a 4LDK layout, a south-facing living room, a connected kitchen and dining area, and a large bathroom."

[0877] This configuration allows for the real-time reflection of user requests and emotions, enabling the generation of optimal floor plans.

[0878] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0879] Step 1: The user enters their request.

[0880] Users open a web form or dedicated app on their device and enter their requests regarding the layout of their home. Specifically, they enter requests in text format, such as "4LDK" and "south-facing living room."

[0881] Input: User-submitted request data (e.g., "4LDK", "Living room faces south")

[0882] Output: The request data is stored in the form.

[0883] Step 2: Submit your request

[0884] The terminal converts the entered request data into JSON format and sends it to the server. Specifically, it converts the form data into the following JSON format and sends it to the server as an HTTP request.

[0885] Input: Request data stored in the form

[0886] Output: JSON data sent to the server

[0887] json

[0888] {

[0889] "rooms": 4,

[0890] "orientation": "south",

[0891] "kitchen_dining": "connected"

[0892] }

[0893] Step 3: Data reception and integrity check

[0894] The server receives the request data sent from the terminal and checks the data's integrity. Specifically, it parses the received data and verifies that there is no missing data and that the data format is correct.

[0895] Input: JSON data sent to the server

[0896] Output: Confirmed consistency of request data

[0897] Step 4: Emotion recognition by the emotion engine

[0898] The server's built-in emotion engine analyzes the user's emotions during this request input process. Specifically, it uses a Python NLP library to assign emotion labels to the input text.

[0899] Input: Request data and user text and behavior captured during input.

[0900] Output: Request data with emotion labels

[0901] Step 5: Inputting the request data into the AI ​​model

[0902] The server inputs emotion-labeled request data into a generative artificial intelligence model. Specifically, it converts the data into an appropriate format and sends it to the AI ​​model's API.

[0903] Input: Request data with emotion labels

[0904] Output: Data sent to the generative artificial intelligence model

[0905] Step 6: AI-powered floor plan generation

[0906] The generative artificial intelligence model generates floor plans for houses based on submitted request data. Specifically, it analyzes the request data, calculates an appropriate floor plan, and generates it.

[0907] Input: Request data sent from the server

[0908] Output: Generated floor plan data

[0909] Step 7: Visualize and submit the floor plan.

[0910] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. Specifically, it visualizes the data using Three.js or Blender and sends that data to the terminal.

[0911] Input: Generated floor plan data

[0912] Output: Visualized 2D and 3D floor plans

[0913] Step 8: User review and input of correction requests

[0914] Users review the floor plan generated on their device and enter revision requests as needed. Specifically, they look at the floor plan and enter revision requests such as "Make the kitchen a little bigger."

[0915] Input: Visualized floor plan and user modification requests

[0916] Output: Correction request data

[0917] Step 9: Reprocessing the correction request

[0918] The server re-inputs the correction request data sent by the user into the generative artificial intelligence model and instructs it to generate a new floor plan.

[0919] Input: User correction request data

[0920] Output: Generative artificial intelligence model that received correction instructions

[0921] Step 10: Generate and submit a new floor plan.

[0922] The generative artificial intelligence model generates a new floor plan based on the requested modification data and sends it to the server. Specifically, it performs recalculations and generates new floor plan data.

[0923] Input: Data for which correction instructions were received

[0924] Output: New floor plan data

[0925] Step 11: Review and approval of the final drawings

[0926] The user reviews the floor plan again and gives final approval. This process is repeated until a satisfactory drawing is obtained.

[0927] Input: New floor plan data

[0928] Output: Final approved floor plan data

[0929] Step 12: Submitting the final drawings

[0930] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder. Specifically, it exports the floor plan in the appropriate digital format and sends it via email or a dedicated portal.

[0931] Input: Final approved floor plan data

[0932] Output: Drawings in PDF or CAD data format provided to the house builder.

[0933] The above is a detailed explanation of the system's program processing flow.

[0934] (Application Example 2)

[0935] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0936] Conventional spatial layout design systems merely mechanically generate layouts based on user request data, failing to reflect user emotions. Therefore, they couldn't reproduce the layout the user considered optimal, making it difficult to sufficiently improve user satisfaction. Furthermore, when users submitted revision requests, the suggestions weren't based on emotions, meaning the regenerated layouts didn't always match the user's wishes.

[0937] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for the user to input a request regarding the layout of a space, means for transmitting the input request data to the server, means for the server to input the received request data to a generative artificial intelligence model, means for the generative artificial intelligence model to generate a layout of a space based on the request data, means for an emotion engine that recognizes the user's emotions and optimizes the request data based on the emotion data, means for allowing the user to visually confirm the generated layout diagram, means for transmitting the user's correction requests to the server again, means for the server to reprocess the correction requests and emotion data to generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This makes it possible to generate an optimal layout that reflects the user's emotions and increase user satisfaction.

[0938] "Spatial layout" refers to drawings or plans that show the physical arrangement and structure within a specific space.

[0939] "Request data" refers to data that indicates the user's wishes and requirements regarding the layout of the space.

[0940] A "server" is a computer system that receives, processes, stores, and transmits data from users.

[0941] A "generative artificial intelligence model" is an artificial intelligence algorithm that automatically generates spatial layouts based on user request data.

[0942] An "emotion engine" is a system that recognizes the user's emotions and reflects that emotional data in the request data.

[0943] "Optimization" refers to adjusting or modifying data or processes to obtain the best possible results under specific conditions or constraints.

[0944] A "layout diagram" is a diagram that visually represents the layout and structure of a space, and includes both two-dimensional and three-dimensional formats.

[0945] "Visual confirmation" refers to displaying the generated layout diagram in a format visible to the user.

[0946] "Revision requests" are data that users indicate additional requests or changes they would like to make to existing layout diagrams.

[0947] "Reprocessing" is the process of regenerating a new layout based on requested modifications and other relevant data.

[0948] "The layout diagram that the user ultimately approved" refers to the layout diagram that the user ultimately found satisfactory and determined did not require any changes.

[0949] System Overview

[0950] This invention is a system that generates an optimal layout by having the user input their preferences regarding the layout of a space and then analyzing emotional data. The system consists of the following main components:

[0951] A terminal for users to input request data.

[0952] A server that receives, sends, and processes request data and emotion data.

[0953] Generative artificial intelligence model that generates layouts based on request data

[0954] An emotion engine that analyzes user emotions.

[0955] Hardware and software to use

[0956] Hardware:

[0957] Smartphones and tablets: Users input request data and check the results.

[0958] Server: Used for receiving, processing, storing, and transmitting data.

[0959] software:

[0960] Flask: Used as a server-side web framework.

[0961] EmotionAnalyzer: A library for analyzing user emotion data.

[0962] LayoutGenerator: A generative artificial intelligence model for generating layouts based on request data.

[0963] Processing flow details

[0964] 1. Inputting user request data:

[0965] Users use smartphones or tablets to input specific requests regarding the layout of the space in text format. For example, "I would like a spacious layout in front of the cash registers."

[0966] 2. Collection of emotional data:

[0967] The user's emotions are also collected simultaneously and analyzed by EmotionAnalyzer. For example, information such as "feeling stressed" is analyzed.

[0968] 3. Submitting request data:

[0969] The terminal sends the entered request data and emotion data to the server in JSON format.

[0970] 4. Data optimization and layout generation:

[0971] The server processes the received data and optimizes the request data based on emotional data. For example, if the user is feeling stressed, it suggests a simpler layout. This optimized data is then input into a generative artificial intelligence model to generate the spatial layout.

[0972] 5. Visualizing the generated layout:

[0973] The generated layout diagrams are presented to the user visually in both two-dimensional and three-dimensional formats. For example, they might be displayed as "a layout with wide checkout counters and wide aisles."

[0974] 6. Implementation of requested revisions:

[0975] The user reviews the generated layout diagram and enters revision requests as needed. Requests such as "It's too large, I'd like to make it a bit more compact" are entered here.

[0976] 7. Regeneration process:

[0977] The server reprocesses the revision request, re-analyzes the sentiment data, and generates a new layout diagram. This process is repeated until the user is satisfied.

[0978] 8. Providing the final layout:

[0979] The fully satisfactory layout diagram will ultimately be provided to the user in PDF or other digital formats.

[0980] Specific examples and prompt statements

[0981] As a concrete example, a store owner using the app to design a new layout generates a layout where "the area in front of the checkout counter is spacious, making the shopping process feel smoother."

[0982] Example of a prompt:

[0983] "Please create a store layout with a spacious area in front of the cash registers and a user-friendly counter."

[0984] In this way, the invention makes it possible to realize an optimal spatial layout that reflects the user's emotions, thereby increasing user satisfaction.

[0985] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0986] Step 1:

[0987] Users use their smartphones or tablets to input specific requests regarding the layout of the space into the application. For example, they might enter a request such as, "I want a spacious area in front of the cash registers." This input data is saved in text format.

[0988] Step 2:

[0989] The terminal sends the entered request data to the server in JSON format. Simultaneously, user emotion data (e.g., "feeling stressed") is also collected and sent to the server in JSON format. This data is sent from the terminal to the server as an HTTP request.

[0990] Step 3:

[0991] The server receives the submitted request and sentiment data and checks the data's integrity. It verifies that the received data is in the correct format and returns an error message if there are any inconsistencies. Once the data's integrity is confirmed, it proceeds to the next process.

[0992] Step 4:

[0993] The server uses an emotion engine to analyze the user's emotional data. For example, the emotion engine might analyze the user's stress level and output a result such as "high stress level." This result is then used to optimize the request data.

[0994] Step 5:

[0995] The server optimizes request data based on emotional data. For example, if the analysis indicates that the user is "feeling stressed," it will suggest a wider layout, implementing stress reduction measures in response to the request data. This optimized data is then input into a generative artificial intelligence model.

[0996] Step 6:

[0997] The server receives request data optimized for a generative artificial intelligence model, which then generates a spatial layout. The generative AI model automatically generates two-dimensional and three-dimensional layout diagrams based on the input data. The results are output in JSON format.

[0998] Step 7:

[0999] The server visualizes the generated layout diagram and sends it to the user's terminal. The user can review the generated layout diagram on the application and enter revision requests as needed. For example, a revision request might be, "The checkout area is too large; I'd like to make it more compact."

[1000] Step 8:

[1001] The terminal resends the entered correction request to the server. This correction request data is sent in JSON format, as before, and after receiving it, the server uses the sentiment engine again to analyze the user's current sentiment data.

[1002] Step 9:

[1003] The server performs the optimization process again based on the requested modifications and the re-analyzed sentiment data. The optimized data is re-input, and the generative artificial intelligence model regenerates the new layout. This regeneration process is repeated until the user is satisfied.

[1004] Step 10:

[1005] The final layout diagram, once approved by the user, is provided to the user from the server in PDF or other digital formats. The user can then view this final layout diagram on their device and download or print it as needed.

[1006] In this way, it becomes possible to generate an optimal spatial layout that reflects the user's needs and emotions, thereby increasing user satisfaction.

[1007] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1008] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1009] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart glasses 214.

[1010] [Third Embodiment]

[1011] Figure 5 shows an example of the configuration of the data processing system 310 according to the third embodiment.

[1012] As shown in Figure 5, the data processing system 310 includes a data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[1013] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1014] The headset terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a display 343. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and display 343 are also connected to the bus 52.

[1015] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[1016] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[1017] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1018] Figure 6 shows an example of the main functions of the data processing device 12 and the headset terminal 314. As shown in Figure 6, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1019] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1020] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1021] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1022] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the headset terminal 314 will be referred to as the "terminal".

[1023] This invention relates to a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model generates a layout based on those requirements, and finally provides it to a house builder. The program and processing of this system are described below.

[1024] 1. The user enters their request.

[1025] The user opens a dedicated application or web form on their device (e.g., PC, tablet, smartphone).

[1026] Users enter detailed requests regarding the layout of their home, such as the number of rooms, orientation, specific functions, and size, into a form.

[1027] For example, specific requests such as "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom" can be entered.

[1028] 2. Sending request data

[1029] The terminal sends the request data entered by the user to the server. The request data is sent in a structured format (e.g., JSON).

[1030] example:

[1031] json

[1032] {

[1033] "rooms": 4,

[1034] "orientation": "south",

[1035] "kitchen_dining": "connected",

[1036] "bathroom": "large"

[1037] }

[1038] 3. Data reception and input into the AI ​​model

[1039] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[1040] The server inputs the data, whose integrity has been verified, into the generative artificial intelligence model.

[1041] 4. AI-powered floor plan generation

[1042] The generative artificial intelligence model uses an algorithm trained on past housing design data to calculate the optimal floor plan based on user requests.

[1043] The generative artificial intelligence model determines the size and layout of each room based on the input request data.

[1044] 5. Output and transmission of generated results

[1045] The server receives the generated floor plan and visualizes it in two-dimensional (2D) and three-dimensional (3D) formats.

[1046] The server sends the visualized floor plan data to the terminal.

[1047] 6. User review and input of correction requests.

[1048] The user reviews the floor plan generated on their device. They visually check elements such as room layout, size, and orientation as checkpoints on the plan.

[1049] If a user wants to make a change, they simply re-enter their request into the terminal, for example, "I want the kitchen to be a little bigger."

[1050] The device sends this correction request data to the server. The correction request data is also sent in JSON format.

[1051] json

[1052] {

[1053] "modify": "expand",

[1054] "target": "kitchen",

[1055] "details": "more space"

[1056] }

[1057] 7. Reprocessing of correction requests

[1058] The server then inputs the requested correction data back into the generative artificial intelligence model and instructs it to generate a new floor plan.

[1059] The generative artificial intelligence model recalculates based on the requested modifications and generates a revised floor plan.

[1060] 8. Generation and verification of the final drawing

[1061] The server generates a new floor plan and sends it back to the terminal.

[1062] The user reviews the design again, and if a satisfactory floor plan is generated, it will be approved as the final drawing.

[1063] 9. Provision of final drawings

[1064] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1065] The final drawings are sent to the home builder via email or a dedicated online portal.

[1066] In this way, the system of the present invention can generate floor plans that quickly and accurately reflect the user's requests, significantly streamlining the design process for custom-built homes.

[1067] The following describes the processing flow.

[1068] Step 1:

[1069] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, layout, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[1070] Step 2:

[1071] The terminal sends the entered request data to the server in JSON format. Example data:

[1072] json

[1073] {

[1074] "rooms": 4,

[1075] "orientation": "south",

[1076] "kitchen_dining": "connected",

[1077] "bathroom": "large"

[1078] }

[1079] Step 3:

[1080] The server receives the submitted request data and checks its integrity. This integrity check includes verifying the data format and required fields.

[1081] Step 4:

[1082] The server inputs the verified request data into the generative artificial intelligence model. Specifically, it processes the data to conform to the model's format.

[1083] Step 5:

[1084] The generative artificial intelligence model calculates and generates a house layout based on the given request data. Specifically, it automatically generates the size, arrangement, and orientation of rooms according to the request.

[1085] Step 6:

[1086] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[1087] Step 7:

[1088] The server sends visualized floor plan data to the terminal. The user receives and reviews this data via a responsive design or a dedicated application.

[1089] Step 8:

[1090] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[1091] Step 9:

[1092] The device resends the user's correction request data to the server. The correction request data is again sent in JSON format. Example data:

[1093] json

[1094] {

[1095] "modify": "expand",

[1096] "target": "kitchen",

[1097] "details": "more space"

[1098] }

[1099] Step 10:

[1100] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[1101] Step 11:

[1102] The generative artificial intelligence model recalculates the floor plan based on the requested modifications and generates a new floor plan.

[1103] Step 12:

[1104] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[1105] Step 13:

[1106] Repeat steps 8 through 12 until the user has reviewed and is satisfied with the final drawing.

[1107] Step 14:

[1108] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1109] Step 15:

[1110] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[1111] (Example 1)

[1112] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[1113] Conventional residential design systems have difficulty quickly and accurately reflecting user requests, particularly the time-consuming and labor-intensive process of generating and modifying floor plans. Furthermore, visual confirmation of generated floor plans and the rapid incorporation of modification requests are difficult, resulting in an inefficient design process for custom-built homes. This invention aims to solve these problems and streamline the process of generating and modifying floor plans based on user requests.

[1114] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1115] In this invention, the server includes means for inputting user-entered request data into a generative artificial intelligence model, means for the generative artificial intelligence model to learn past housing design data, and means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats. This enables the rapid and accurate generation and modification of the optimal floor plan based on the user's requests.

[1116] "Request data" refers to information that users input regarding the layout of a house, including details such as the number of rooms, orientation, specific functions, and size.

[1117] A "generative artificial intelligence model" is an artificial intelligence system that includes an algorithm that learns from past housing design data and generates the optimal floor plan based on user request data.

[1118] A "server" is a computer system that receives request data sent by users and inputs it into a generative artificial intelligence model.

[1119] "Two-dimensional and three-dimensional formats" refer to the formats used to visually display the generated floor plan, and include both 2D formats that display it as a plan view and 3D formats that visualize it in three dimensions.

[1120] A "revision request" is data entered by the user after reviewing the generated floor plan, indicating the parts they wish to change or modify.

[1121] A "construction contractor" refers to a company or individual that constructs a house based on the floor plan ultimately approved by the user.

[1122] This invention is a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model is used to generate a layout based on those requirements, and the layout is ultimately provided to a construction company. The program and processing of this system are described in detail below.

[1123] Users access a dedicated application or web form using devices such as PCs, tablets, or smartphones. A login function is available, and users log in by entering their account information. Users then enter detailed requests in an input form, such as the number of rooms in the house, its orientation, specific functions, and size. For example, they might enter specific requests like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[1124] The terminal converts the user's input request data into JSON format. The following data format is generated:

[1125] json

[1126] {

[1127] "rooms": 4,

[1128] "orientation": "south",

[1129] "kitchen_dining": "connected",

[1130] "bathroom": "large"

[1131] }

[1132] The terminal sends this JSON data to the server using the HTTPS protocol. The server checks the integrity of the received request data and returns an error message if necessary. Once integrity is confirmed, the server converts the data into a format suitable for generative artificial intelligence models.

[1133] The server inputs the converted data into a generative artificial intelligence model. The model uses an algorithm trained on past housing design data to calculate the optimal floor plan. This algorithm automatically generates a floor plan including the size and placement of each room.

[1134] Once the generative AI model finishes its calculations, the server visualizes the generated floor plan in 2D and 3D formats. Technologies such as WebGL and Three.js may be used for visualization. This visualized floor plan data is then converted back into JSON format, and the server sends it to the terminal.

[1135] The user reviews the floor plan generated on their device. While visually reviewing it, they input modification requests such as "I'd like the kitchen to be a little bigger." For example, they might input a modification request like "Make the kitchen bigger" in text format as follows:

[1136] "modify: expand, target: kitchen, details: more space"

[1137] The terminal converts the revision request data into JSON format and sends it back to the server. The server re-inputs the revision request data into the generative artificial intelligence model and generates a new floor plan.

[1138] The server generates a new floor plan and sends it back to the terminal. The user reviews it again, and if they are finally satisfied with the generated drawing, they give it final approval. The server generates the final floor plan in PDF or CAD data format and provides it to the builder. The final drawing is sent to the builder via email or a dedicated online portal. This system can generate floor plans that quickly and accurately meet the user's requests, significantly streamlining the custom home design process.

[1139] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1140] Step 1:

[1141] The user launches the application. The user opens the dedicated application or web form using a device such as a PC, tablet, or smartphone. The user enters their account information and logs in. Input: Account information, Output: Login session.

[1142] Step 2:

[1143] The user enters their requirements. The user enters detailed requirements such as the number of rooms in the house, orientation, specific functions, and size into an input form. For example, they might enter specific requirements like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom." Input: Request data; Output: Structured input data (e.g., JSON format).

[1144] Step 3:

[1145] The device sends data. The device converts the user-entered request data into JSON format and then sends it to the server using the HTTPS protocol. Specifically, it generates an HTTP request and sends the data. Input: Structured input data; Output: Data contained in the HTTP request.

[1146] Step 4:

[1147] The server receives the data. The server checks the integrity of the requested data received via the HTTPS protocol and returns an error message if necessary. Once integrity is confirmed, the data is converted into a format suitable for a generative artificial intelligence model. Input: Data received from the HTTP request; Output: Converted data.

[1148] Step 5:

[1149] The server inputs data into the AI ​​model. The server then inputs the transformed data into a generative artificial intelligence model. Data interpolation and preprocessing are performed as needed. Input: Data that has been formatted; Output: Data input into the AI ​​model.

[1150] Step 6:

[1151] A generative artificial intelligence model generates floor plans. The AI ​​model uses an algorithm to calculate the optimal floor plan based on the input request data. The model references past housing design data stored in a database. Input: Data entered into the AI ​​model; Output: Generated floor plan data.

[1152] Step 7:

[1153] The server receives the floor plan. The server visualizes the generated floor plan data in 2D and 3D formats. Visualization may utilize technologies such as WebGL or Three.js. The visualized data is then converted back to JSON format and sent to the terminal. Input: Generated floor plan data, Output: Visualized data.

[1154] Step 8:

[1155] The user reviews the floor plan. The user reviews the floor plan generated on their device and makes a visual evaluation. They check the room layout, size, orientation, etc., and may also enter revision requests. Input: Visualized data; Output: User feedback and revision requests.

[1156] Step 9:

[1157] The terminal sends a correction request. The correction request entered by the user is converted to JSON format and sent back to the server. A concrete example of a request might be "Make the kitchen bigger." Input: Correction request data, Output: Correction request data included in the HTTP request.

[1158] Step 10:

[1159] The server processes the revision request. The server re-inputs the revision request data into the generative artificial intelligence model and instructs it to generate a new floor plan. Input: Revision request data received from the HTTP request; Output: Revision data input into the AI ​​model.

[1160] Step 11:

[1161] The generative artificial intelligence model performs a recalculation. The AI ​​model recalculates based on the requested modifications and generates a new floor plan. Input: Modification data entered into the AI ​​model; Output: Modified floor plan data.

[1162] Step 12:

[1163] The server generates a new floor plan. The server generates a new floor plan and sends it back to the terminal. Input: Modified floor plan data, Output: Visualized new floor plan data.

[1164] Step 13:

[1165] The user performs the final review. The user checks the new floor plan on their device and, if the generated drawing is satisfactory, gives final approval. Input: Visualized new floor plan data, Output: Final approval.

[1166] Step 14:

[1167] The server provides the final drawings. The server generates the final floor plans in PDF or CAD data format and provides them to the construction company. The final drawings are provided via email or a dedicated online portal. Input: Final approved floor plan data; Output: Final drawings in PDF or CAD data format.

[1168] (Application Example 1)

[1169] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[1170] Designing the layout of machinery and work within a factory is crucial for maximizing efficiency, safety, and productivity. However, traditional layout design is often done manually, which is time-consuming and costly. Furthermore, finding the optimal layout requires advanced expertise, and any modifications or changes necessitate redesign. To address these challenges, there is a need for a system that allows users to easily design factory layouts and quickly provide optimized layouts using generative artificial intelligence models.

[1171] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1172] In this invention, the server includes means for the user to input layout requests, means for transmitting the input request data to the server, means for the server to input the received request data into a generative artificial intelligence model, means for allowing the user to visually confirm the generated layout diagram, means for the user to send revision requests to the server again, means for the server to reprocess the revision requests and generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This enables the rapid and efficient design of the optimal layout within the factory, simplifying the design process and improving its accuracy.

[1173] A "user" is an individual or group that uses the system to design layouts.

[1174] "Layout" refers to the arrangement of machinery, work stations, employee movement routes, safety areas, and other elements within a factory.

[1175] "Request data" refers to data that includes the user's desired conditions and requirements for layout design.

[1176] A "server" is a computer system that receives request data sent by users and generates and regenerates layouts using a generative artificial intelligence model.

[1177] A "generative artificial intelligence model" is an artificial intelligence system that includes algorithms for generating the optimal layout based on user request data.

[1178] "Means of visual confirmation" refers to an interface that displays the generated layout diagram in a way that allows the user to view it in two-dimensional and three-dimensional formats.

[1179] A "revision request" is a request from a user for additional changes or adjustments to a layout diagram that has been generated.

[1180] The "finally approved layout diagram" is the layout diagram that the user deemed to be the optimal state and ultimately approved for adoption.

[1181] "Means of provision" refers to the means of providing the finally approved layout diagram to users and other related systems in digital format or other means.

[1182] In order to implement this invention, it is necessary to build a system in which users, servers, and terminals work closely together to efficiently and quickly design factory layouts.

[1183] Hardware and software configuration

[1184] 1. User terminal:

[1185] This involves using devices with input interfaces, such as tablets and smartphones, to allow users to input their factory layout requirements.

[1186] 2. Server:

[1187] High-performance computing servers (e.g., AWS EC2) are used to receive request data, operate generative artificial intelligence models, and transform data.

[1188] 3. Generative artificial intelligence models:

[1189] Using frameworks such as TensorFlow and PyTorch, we execute algorithms that generate the optimal factory layout based on user request data.

[1190] Program processing flow

[1191] The user enters the request data.

[1192] The user opens the application on their terminal and enters their requirements regarding the factory layout. These requirements include the number of work lines, the types and number of machines needed, employee movement routes, and the setting of safety areas. For example, the following requirements are entered in text format:

[1193] Number of production lines: 3

[1194] Types and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units

[1195] Employee travel routes: Line 1, Line 2

[1196] Safety area settings: Storage area

[1197] Sending request data to the server

[1198] The entered request data is converted into a structured format and sent to the server. The server receives the data and checks its integrity.

[1199] Input to a generative artificial intelligence model

[1200] The server inputs the verified request data into a generative artificial intelligence model. Based on past factory layout design data, the model calculates the optimal layout that best suits the user's requests.

[1201] Providing the generated layout diagram to the user

[1202] The generated layout diagrams are visualized in two-dimensional and three-dimensional formats and sent to the user's terminal. The user visually reviews them and re-enters any revision requests if necessary.

[1203] Reprocessing of correction requests

[1204] The user's revision requests are sent back to the server, where a generative artificial intelligence model recalculates and generates a new layout diagram. This process is repeated until a satisfactory layout diagram is completed.

[1205] Provision of the final layout drawing

[1206] The final layout diagram approved by the user is provided in digital format and sent to the user and other relevant systems.

[1207] Through the above process, the optimal factory layout can be designed quickly and efficiently. This system enables improvements in factory production efficiency and safety.

[1208] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1209] Step 1:

[1210] The user enters the request data.

[1211] The user opens an application on their terminal and enters their requirements for the factory layout. Input fields include the number of work lines, the type and number of machines required, employee movement routes, and safety area settings. For example, "Number of work lines: 3," "Type and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units," "Employee movement routes: Line 1, Line 2," and "Safety area settings: Storage area." The input data is converted into a structured format (JSON).

[1212] Step 2:

[1213] Sending request data to the server

[1214] The terminal sends the request data entered by the user to the server. The server checks the integrity of the received request data. Specifically, it verifies the data format, checks required fields, and validates the value range. Once the integrity check is complete, the data is converted into a format that can be input into a generative artificial intelligence model. The input is the user's request data, and the output is the data whose integrity has been verified.

[1215] Step 3:

[1216] Input to a generative artificial intelligence model

[1217] The server inputs verified request data into a generative artificial intelligence model. Based on past factory layout design data, the generative AI model calculates the optimal layout suitable for the user's requests. Specifically, it optimizes the placement of various machines, the design of work lines, employee movement routes, and the definition of safety areas through data calculations. The input is consistent request data, and the output is a generated layout diagram.

[1218] Step 4:

[1219] Providing the generated layout diagram to the user

[1220] The server visualizes the generated layout diagram in two-dimensional and three-dimensional formats and sends the data to the user's terminal. The user then reviews the visualized layout diagram. Specifically, the layout diagram is displayed in 2D and 3D on the terminal. The user visually confirms the arrangement of each work line, the location of machines, the location of safety areas, etc. The input is the generated layout diagram, and the output is the visualized layout diagram.

[1221] Step 5:

[1222] User input for correction requests

[1223] If a user is dissatisfied with the layout diagram, they can submit a request for revision. For example, specific requests such as "Move the machine placement on line 1 to the left" or "Expand the storage area." The terminal then sends the revision request data to the server. The input is the user's revision request data, and the output is the revision request data sent to the server.

[1224] Step 6:

[1225] Reprocessing of correction requests

[1226] The server re-inputs the requested modification data into the generative artificial intelligence model and generates a new layout diagram. The model recalculates and updates the layout based on the requested modifications. Specifically, it optimizes the overall layout while reflecting the changes requested by the user. The input is the requested modification data, and the output is the modified layout diagram.

[1227] Step 7:

[1228] Provision of the final layout drawing

[1229] The server sends the revised layout drawing back to the user's terminal. The user performs a final review and approves it if they are satisfied. The finally approved layout drawing is provided in digital format. Specifically, it is output as PDF or CAD data and provided to the user via email or online portal. The input is the final reviewed layout drawing, and the output is a digital layout drawing.

[1230] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[1231] This invention relates to a system that allows users to input and modify their requests regarding the layout of a house and generates a floor plan based on those requests, as well as a system that includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. The program and processing of this system are described below.

[1232] 1. The user enters their request.

[1233] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. For example, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[1234] 2. Sending request data

[1235] The terminal sends the entered request data to the server in JSON format. Example data:

[1236] json

[1237] {

[1238] "rooms": 4,

[1239] "orientation": "south",

[1240] "kitchen_dining": "connected",

[1241] "bathroom": "large"

[1242] }

[1243] 3. Data reception and input into the AI ​​model

[1244] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[1245] 4. Complementing user emotions with an emotion engine

[1246] The server is equipped with an emotion engine that recognizes the user's emotions when they enter a request. This emotion data is reflected in the request data, and if the user is, for example, "feeling stressed," the system will provide supplementary information such as suggesting a more concise request.

[1247] 5. AI-powered floor plan generation

[1248] The generative AI model calculates and generates house floor plans based on verified request data. The generative AI model automatically generates the size and placement of each room according to the user's requests.

[1249] 6. Output and transmission of generated results

[1250] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[1251] 7. User review and input of correction requests.

[1252] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[1253] 8. Revision suggestions based on the emotion engine

[1254] The emotion engine recognizes the user's emotions when reviewing a floor plan, and if, for example, the user is feeling anxious, it automatically generates modification suggestions based on that emotion. As an example of a suggestion, it might offer a specific suggestion such as, "If you feel the kitchen is too small, how about converting part of the living room into a kitchen?"

[1255] 9. Reprocessing of correction requests

[1256] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[1257] 10. Recalculation by generative AI

[1258] The generative artificial intelligence model recalculates based on modification requests and suggestions from the emotion engine to generate a new floor plan.

[1259] 11. Generate and send a new floor plan.

[1260] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[1261] 12. Review and approval of the final drawings

[1262] This process is repeated until the user reviews it again and is satisfied with the final drawing.

[1263] The emotion engine recognizes the user's emotions when they review the final drawing and provides a means to gather further feedback if they are not satisfied.

[1264] 13. Provision of final drawings

[1265] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1266] The final drawings are sent to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[1267] Thus, the system of the present invention can recognize the user's emotions and generate floor plans that quickly and accurately reflect the user's requests, thereby significantly streamlining the design process for custom-built homes.

[1268] The following describes the processing flow.

[1269] Step 1:

[1270] The user opens the application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[1271] Step 2:

[1272] The terminal sends the input request data and user emotion data (e.g., the results of emotion analysis of the user's facial expressions and voice while inputting) to the server in JSON format. Example data:

[1273] json

[1274] {

[1275] "rooms": 4,

[1276] "orientation": "south",

[1277] "kitchen_dining": "connected",

[1278] "bathroom": "large",

[1279] "user_emotion": "neutral"

[1280] }

[1281] Step 3:

[1282] The server checks the consistency between the received request data and sentiment data. It verifies that the format and required fields of the request data are correct.

[1283] Step 4:

[1284] The server inputs the verified request data into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions for supplementing or modifying the request data.

[1285] Step 5:

[1286] The generative artificial intelligence model calculates and generates house floor plans based on verified request data. Specifically, it automatically generates the size and placement of each room.

[1287] Step 6:

[1288] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. It then formats the generated floor plan so that the user can visually review it.

[1289] Step 7:

[1290] The server sends visualized floor plan data to the terminal. It is then displayed via a responsive design or a dedicated application for user review.

[1291] Step 8:

[1292] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they might enter a request such as, "I'd like the kitchen to be a little bigger."

[1293] Step 9:

[1294] The device then resends the user's correction request data and their current sentiment data to the server. The correction request data is also sent in JSON format. Example data:

[1295] json

[1296] {

[1297] "modify": "expand",

[1298] "target": "kitchen",

[1299] "details": "more space",

[1300] "user_emotion": "concerned"

[1301] }

[1302] Step 10:

[1303] The server receives correction request data and emotion data, and inputs them into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions in response to the correction requests.

[1304] Step 11:

[1305] The generative artificial intelligence model recalculates based on modification requests and suggestions for the emotion engine, generating a new floor plan.

[1306] Step 12:

[1307] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[1308] Step 13:

[1309] Repeat this process from step 8 to step 12 until the user has reviewed it again and is satisfied with the final drawing.

[1310] Step 14:

[1311] The emotion engine recognizes the user's emotions when they review the final drawing and, if the user is not satisfied, provides a means to gather further feedback. The process is repeated until the user expresses a positive emotion such as "satisfied" or "happy."

[1312] Step 15:

[1313] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1314] Step 16:

[1315] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[1316] (Example 2)

[1317] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[1318] In residential floor plan design, it is essential to quickly and accurately reflect the user's requests. Furthermore, understanding the user's emotions and providing suggestions and advice to alleviate stress and dissatisfaction is also crucial. Conventional systems struggle not only to properly understand user requests and generate optimal floor plans, but also to consider user emotions, making it difficult to increase user satisfaction. This invention solves these problems.

[1319] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[1320] In this invention, the server includes means for the user to input requests regarding the layout of a house; means for transmitting the input request data to the server; means for the server to input the received request data into a generative artificial intelligence model; means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats; means for the user to send revision requests to the server again; means for the server to reprocess the revision requests and generate a new floor plan; means including an emotion engine that recognizes the user's emotions and makes input and revision suggestions based on those emotions; and means for finally providing the floor plan approved by the user in digital format. This makes it possible to quickly and accurately reflect the user's requests and generate an optimal floor plan that also takes the user's emotions into consideration.

[1321] A "user" is someone who uses the system to input requests regarding the layout of a house, and then reviews and approves the final floor plan.

[1322] A "server" is a core information processing device that receives request data sent from users, processes the data using a generative artificial intelligence model and an emotion engine, and generates and provides the final floor plan.

[1323] A "generative artificial intelligence model" refers to an artificial intelligence algorithm and related software for automatically generating floor plans of houses based on user request data.

[1324] An "emotion engine" is a technology that recognizes emotions from user input and actions, and provides suggestions and corrective advice based on those emotions.

[1325] A "floor plan" is a drawing that shows the arrangement of rooms and facilities in a house, and is provided to the user visually in two-dimensional and three-dimensional formats.

[1326] "Request data" refers to information entered by users regarding their wishes and requests about the layout of their homes, which is transmitted to the server in data format such as JSON.

[1327] A "revision request" refers to a user's wishes or requests for changes or additions to a floor plan after reviewing the generated plan.

[1328] "Two-dimensional and three-dimensional formats" refer to formats for displaying and reviewing floor plans using different visual representations, and include plan views (2D) and three-dimensional views (3D).

[1329] "Digital format" refers to electronic data formats, such as providing floor plans and other information in PDF or CAD data formats.

[1330] This invention relates to a system that allows a user to input their preferences regarding the layout of a house and generates a floor plan based on those preferences. Furthermore, it includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. Details of this system, including the hardware and software used and specific processes, are described below.

[1331] System Configuration

[1332] This system consists of the following main elements:

[1333] A terminal where users enter their requests.

[1334] Server that processes request data

[1335] Generative artificial intelligence models

[1336] Emotional Engine

[1337] Hardware and software

[1338] terminal

[1339] The devices on which users can enter requests include desktop computers, laptops, tablets, and smartphones. On these devices, a browser-based web form or a dedicated application will operate.

[1340] Examples of use: Google Chrome browser and custom mobile apps

[1341] server

[1342] The server receives request data sent by the user, checks the data's integrity, and then inputs it into a generative artificial intelligence model. The following technologies are primarily used:

[1343] Web servers: Apache, NGINX

[1344] Server-side languages: Python, Node.js

[1345] Generative artificial intelligence models

[1346] The generative artificial intelligence model is used to generate floor plans of houses based on received request data. The model is based on deep learning and utilizes the following framework:

[1347] TensorFlow, PyTorch

[1348] Emotional Engine

[1349] The emotion engine recognizes the user's emotions when they input requests or review drawings, and uses that information to provide suggestions and advice.

[1350] Sentiment analysis libraries: Python's NLTK, spaCy

[1351] Specific example of processing

[1352] 1. Entering request data

[1353] Users enter specific requests regarding the layout of their home through a web form or application on their device. Examples include "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[1354] 2. Sending request data

[1355] The terminal converts the entered request data into JSON format and sends it to the server.

[1356] 3. Data integrity check

[1357] The server checks the integrity of the received request data, verifying that there is no missing data or format errors.

[1358] 4. Emotion recognition

[1359] The emotion engine built into the server analyzes the user's input and input circumstances to recognize the user's emotions. If the user is experiencing stress, it provides appropriate guidance.

[1360] 5. Generating a floor plan

[1361] The server inputs the verified request data into a generative artificial intelligence model, and the AI ​​model generates a floor plan.

[1362] 6. Visualization of floor plans

[1363] The server receives the generated floor plan data, visualizes it in 2D and 3D formats, and sends it to the user's device. Tools such as Three.js and Blender are used for visualization.

[1364] 7. Enter your request for corrections.

[1365] Users can review the visualized floor plan and submit revision requests as needed. For example, they might enter specific requests such as wanting the kitchen to be a little larger.

[1366] 8. Emotion-based proposals

[1367] The emotion engine recognizes the emotions a user feels when submitting a revision request, and, for example, if the user is feeling anxious, it makes revision suggestions based on that emotion.

[1368] Example of a prompt

[1369] As an example of a prompt message to be input to a generative artificial intelligence model based on user requests,

[1370] "Based on the user's requests, please generate a floor plan that includes a 4LDK layout, a south-facing living room, a connected kitchen and dining area, and a large bathroom."

[1371] This configuration allows for the real-time reflection of user requests and emotions, enabling the generation of optimal floor plans.

[1372] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1373] Step 1: The user enters their request.

[1374] Users open a web form or dedicated app on their device and enter their requests regarding the layout of their home. Specifically, they enter requests in text format, such as "4LDK" and "south-facing living room."

[1375] Input: User-submitted request data (e.g., "4LDK", "Living room faces south")

[1376] Output: The request data is stored in the form.

[1377] Step 2: Submit your request

[1378] The terminal converts the entered request data into JSON format and sends it to the server. Specifically, it converts the form data into the following JSON format and sends it to the server as an HTTP request.

[1379] Input: Request data stored in the form

[1380] Output: JSON data sent to the server

[1381] json

[1382] {

[1383] "rooms": 4,

[1384] "orientation": "south",

[1385] "kitchen_dining": "connected"

[1386] }

[1387] Step 3: Data reception and integrity check

[1388] The server receives the request data sent from the terminal and checks the data's integrity. Specifically, it parses the received data and verifies that there is no missing data and that the data format is correct.

[1389] Input: JSON data sent to the server

[1390] Output: Confirmed consistency of request data

[1391] Step 4: Emotion recognition by the emotion engine

[1392] The server's built-in emotion engine analyzes the user's emotions during this request input process. Specifically, it uses a Python NLP library to assign emotion labels to the input text.

[1393] Input: Request data and user text and behavior captured during input.

[1394] Output: Request data with emotion labels

[1395] Step 5: Inputting the request data into the AI ​​model

[1396] The server inputs emotion-labeled request data into a generative artificial intelligence model. Specifically, it converts the data into an appropriate format and sends it to the AI ​​model's API.

[1397] Input: Request data with emotion labels

[1398] Output: Data sent to the generative artificial intelligence model

[1399] Step 6: AI-powered floor plan generation

[1400] The generative artificial intelligence model generates floor plans for houses based on submitted request data. Specifically, it analyzes the request data, calculates an appropriate floor plan, and generates it.

[1401] Input: Request data sent from the server

[1402] Output: Generated floor plan data

[1403] Step 7: Visualize and submit the floor plan.

[1404] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. Specifically, it visualizes the data using Three.js or Blender and sends that data to the terminal.

[1405] Input: Generated floor plan data

[1406] Output: Visualized 2D and 3D floor plans

[1407] Step 8: User review and input of correction requests

[1408] Users review the floor plan generated on their device and enter revision requests as needed. Specifically, they look at the floor plan and enter revision requests such as "Make the kitchen a little bigger."

[1409] Input: Visualized floor plan and user modification requests

[1410] Output: Correction request data

[1411] Step 9: Reprocessing the correction request

[1412] The server re-inputs the correction request data sent by the user into the generative artificial intelligence model and instructs it to generate a new floor plan.

[1413] Input: User correction request data

[1414] Output: Generative artificial intelligence model that received correction instructions

[1415] Step 10: Generate and submit a new floor plan.

[1416] The generative artificial intelligence model generates a new floor plan based on the requested modification data and sends it to the server. Specifically, it performs recalculations and generates new floor plan data.

[1417] Input: Data for which correction instructions were received

[1418] Output: New floor plan data

[1419] Step 11: Review and approval of the final drawings

[1420] The user reviews the floor plan again and gives final approval. This process is repeated until a satisfactory drawing is obtained.

[1421] Input: New floor plan data

[1422] Output: Final approved floor plan data

[1423] Step 12: Submitting the final drawings

[1424] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder. Specifically, it exports the floor plan in the appropriate digital format and sends it via email or a dedicated portal.

[1425] Input: Final approved floor plan data

[1426] Output: Drawings in PDF or CAD data format provided to the house builder.

[1427] The above is a detailed explanation of the system's program processing flow.

[1428] (Application Example 2)

[1429] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the headset-type terminal 314 will be referred to as the "terminal."

[1430] Conventional spatial layout design systems merely mechanically generate layouts based on user request data, failing to reflect user emotions. Therefore, they couldn't reproduce the layout the user considered optimal, making it difficult to sufficiently improve user satisfaction. Furthermore, when users submitted revision requests, the suggestions weren't based on emotions, meaning the regenerated layouts didn't always match the user's wishes.

[1431] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for the user to input a request regarding the layout of a space, means for transmitting the input request data to the server, means for the server to input the received request data to a generative artificial intelligence model, means for the generative artificial intelligence model to generate a layout of a space based on the request data, means for an emotion engine that recognizes the user's emotions and optimizes the request data based on the emotion data, means for allowing the user to visually confirm the generated layout diagram, means for transmitting the user's correction requests to the server again, means for the server to reprocess the correction requests and emotion data to generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This makes it possible to generate an optimal layout that reflects the user's emotions and increase user satisfaction.

[1432] "Spatial layout" refers to drawings or plans that show the physical arrangement and structure within a specific space.

[1433] "Request data" refers to data that indicates the user's wishes and requirements regarding the layout of the space.

[1434] A "server" is a computer system that receives, processes, stores, and transmits data from users.

[1435] A "generative artificial intelligence model" is an artificial intelligence algorithm that automatically generates spatial layouts based on user request data.

[1436] An "emotion engine" is a system that recognizes the user's emotions and reflects that emotional data in the request data.

[1437] "Optimization" refers to adjusting or modifying data or processes to obtain the best possible results under specific conditions or constraints.

[1438] A "layout diagram" is a diagram that visually represents the layout and structure of a space, and includes both two-dimensional and three-dimensional formats.

[1439] "Visual confirmation" refers to displaying the generated layout diagram in a format visible to the user.

[1440] "Revision requests" are data that users indicate additional requests or changes they would like to make to existing layout diagrams.

[1441] "Reprocessing" is the process of regenerating a new layout based on requested modifications and other relevant data.

[1442] "The layout diagram that the user ultimately approved" refers to the layout diagram that the user ultimately found satisfactory and determined did not require any changes.

[1443] System Overview

[1444] This invention is a system that generates an optimal layout by having the user input their preferences regarding the layout of a space and then analyzing emotional data. The system consists of the following main components:

[1445] A terminal for users to input request data.

[1446] A server that receives, sends, and processes request data and emotion data.

[1447] Generative artificial intelligence model that generates layouts based on request data

[1448] An emotion engine that analyzes user emotions.

[1449] Hardware and software to use

[1450] Hardware:

[1451] Smartphones and tablets: Users input request data and check the results.

[1452] Server: Used for receiving, processing, storing, and transmitting data.

[1453] software:

[1454] Flask: Used as a server-side web framework.

[1455] EmotionAnalyzer: A library for analyzing user emotion data.

[1456] LayoutGenerator: A generative artificial intelligence model for generating layouts based on request data.

[1457] Processing flow details

[1458] 1. Inputting user request data:

[1459] Users use smartphones or tablets to input specific requests regarding the layout of the space in text format. For example, "I would like a spacious layout in front of the cash registers."

[1460] 2. Collection of emotional data:

[1461] The user's emotions are also collected simultaneously and analyzed by EmotionAnalyzer. For example, information such as "feeling stressed" is analyzed.

[1462] 3. Submitting request data:

[1463] The terminal sends the entered request data and emotion data to the server in JSON format.

[1464] 4. Data optimization and layout generation:

[1465] The server processes the received data and optimizes the request data based on emotional data. For example, if the user is feeling stressed, it suggests a simpler layout. This optimized data is then input into a generative artificial intelligence model to generate the spatial layout.

[1466] 5. Visualizing the generated layout:

[1467] The generated layout diagrams are presented to the user visually in both two-dimensional and three-dimensional formats. For example, they might be displayed as "a layout with wide checkout counters and wide aisles."

[1468] 6. Implementation of requested revisions:

[1469] The user reviews the generated layout diagram and enters revision requests as needed. Requests such as "It's too large, I'd like to make it a bit more compact" are entered here.

[1470] 7. Regeneration process:

[1471] The server reprocesses the revision request, re-analyzes the sentiment data, and generates a new layout diagram. This process is repeated until the user is satisfied.

[1472] 8. Providing the final layout:

[1473] The fully satisfactory layout diagram will ultimately be provided to the user in PDF or other digital formats.

[1474] Specific examples and prompt statements

[1475] As a concrete example, a store owner using the app to design a new layout generates a layout where "the area in front of the checkout counter is spacious, making the shopping process feel smoother."

[1476] Example of a prompt:

[1477] "Please create a store layout with a spacious area in front of the cash registers and a user-friendly counter."

[1478] In this way, the invention makes it possible to realize an optimal spatial layout that reflects the user's emotions, thereby increasing user satisfaction.

[1479] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1480] Step 1:

[1481] Users use their smartphones or tablets to input specific requests regarding the layout of the space into the application. For example, they might enter a request such as, "I want a spacious area in front of the cash registers." This input data is saved in text format.

[1482] Step 2:

[1483] The terminal sends the entered request data to the server in JSON format. Simultaneously, user emotion data (e.g., "feeling stressed") is also collected and sent to the server in JSON format. This data is sent from the terminal to the server as an HTTP request.

[1484] Step 3:

[1485] The server receives the submitted request and sentiment data and checks the data's integrity. It verifies that the received data is in the correct format and returns an error message if there are any inconsistencies. Once the data's integrity is confirmed, it proceeds to the next process.

[1486] Step 4:

[1487] The server uses an emotion engine to analyze the user's emotional data. For example, the emotion engine might analyze the user's stress level and output a result such as "high stress level." This result is then used to optimize the request data.

[1488] Step 5:

[1489] The server optimizes request data based on emotional data. For example, if the analysis indicates that the user is "feeling stressed," it will suggest a wider layout, implementing stress reduction measures in response to the request data. This optimized data is then input into a generative artificial intelligence model.

[1490] Step 6:

[1491] The server receives request data optimized for a generative artificial intelligence model, which then generates a spatial layout. The generative AI model automatically generates two-dimensional and three-dimensional layout diagrams based on the input data. The results are output in JSON format.

[1492] Step 7:

[1493] The server visualizes the generated layout diagram and sends it to the user's terminal. The user can review the generated layout diagram on the application and enter revision requests as needed. For example, a revision request might be, "The checkout area is too large; I'd like to make it more compact."

[1494] Step 8:

[1495] The terminal resends the entered correction request to the server. This correction request data is sent in JSON format, as before, and after receiving it, the server uses the sentiment engine again to analyze the user's current sentiment data.

[1496] Step 9:

[1497] The server performs the optimization process again based on the requested modifications and the re-analyzed sentiment data. The optimized data is re-input, and the generative artificial intelligence model regenerates the new layout. This regeneration process is repeated until the user is satisfied.

[1498] Step 10:

[1499] The final layout diagram, once approved by the user, is provided to the user from the server in PDF or other digital formats. The user can then view this final layout diagram on their device and download or print it as needed.

[1500] In this way, it becomes possible to generate an optimal spatial layout that reflects the user's needs and emotions, thereby increasing user satisfaction.

[1501] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1502] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1503] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and specific processing may also be performed by the headset terminal 314.

[1504] [Fourth Embodiment]

[1505] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[1506] As shown in Figure 7, the data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[1507] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1508] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

[1509] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[1510] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[1511] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1512] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[1513] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1514] The specific processing program 56 is an example of a "program" relating to the technology of this disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1515] The storage 32 stores the data generation model 58 and the emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1516] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1517] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1518] This invention relates to a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model generates a layout based on those requirements, and finally provides it to a house builder. The program and processing of this system are described below.

[1519] 1. The user enters their request.

[1520] The user opens a dedicated application or web form on their device (e.g., PC, tablet, smartphone).

[1521] Users enter detailed requests regarding the layout of their home, such as the number of rooms, orientation, specific functions, and size, into a form.

[1522] For example, specific requests such as "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom" can be entered.

[1523] 2. Sending request data

[1524] The terminal sends the request data entered by the user to the server. The request data is sent in a structured format (e.g., JSON).

[1525] example:

[1526] json

[1527] {

[1528] "rooms": 4,

[1529] "orientation": "south",

[1530] "kitchen_dining": "connected",

[1531] "bathroom": "large"

[1532] }

[1533] 3. Data reception and input into the AI ​​model

[1534] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[1535] The server inputs the data, whose integrity has been verified, into the generative artificial intelligence model.

[1536] 4. AI-powered floor plan generation

[1537] The generative artificial intelligence model uses an algorithm trained on past housing design data to calculate the optimal floor plan based on user requests.

[1538] The generative artificial intelligence model determines the size and layout of each room based on the input request data.

[1539] 5. Output and transmission of generated results

[1540] The server receives the generated floor plan and visualizes it in two-dimensional (2D) and three-dimensional (3D) formats.

[1541] The server sends the visualized floor plan data to the terminal.

[1542] 6. User review and input of correction requests.

[1543] The user reviews the floor plan generated on their device. They visually check elements such as room layout, size, and orientation as checkpoints on the plan.

[1544] If a user wants to make a change, they simply re-enter their request into the terminal, for example, "I want the kitchen to be a little bigger."

[1545] The device sends this correction request data to the server. The correction request data is also sent in JSON format.

[1546] json

[1547] {

[1548] "modify": "expand",

[1549] "target": "kitchen",

[1550] "details": "more space"

[1551] }

[1552] 7. Reprocessing of correction requests

[1553] The server then inputs the requested correction data back into the generative artificial intelligence model and instructs it to generate a new floor plan.

[1554] The generative artificial intelligence model recalculates based on the requested modifications and generates a revised floor plan.

[1555] 8. Generation and verification of the final drawing

[1556] The server generates a new floor plan and sends it back to the terminal.

[1557] The user reviews the design again, and if a satisfactory floor plan is generated, it will be approved as the final drawing.

[1558] 9. Provision of final drawings

[1559] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1560] The final drawings are sent to the home builder via email or a dedicated online portal.

[1561] In this way, the system of the present invention can generate floor plans that quickly and accurately reflect the user's requests, significantly streamlining the design process for custom-built homes.

[1562] The following describes the processing flow.

[1563] Step 1:

[1564] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, layout, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[1565] Step 2:

[1566] The terminal sends the entered request data to the server in JSON format. Example data:

[1567] json

[1568] {

[1569] "rooms": 4,

[1570] "orientation": "south",

[1571] "kitchen_dining": "connected",

[1572] "bathroom": "large"

[1573] }

[1574] Step 3:

[1575] The server receives the submitted request data and checks its integrity. This integrity check includes verifying the data format and required fields.

[1576] Step 4:

[1577] The server inputs the verified request data into the generative artificial intelligence model. Specifically, it processes the data to conform to the model's format.

[1578] Step 5:

[1579] The generative artificial intelligence model calculates and generates a house layout based on the given request data. Specifically, it automatically generates the size, arrangement, and orientation of rooms according to the request.

[1580] Step 6:

[1581] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[1582] Step 7:

[1583] The server sends visualized floor plan data to the terminal. The user receives and reviews this data via a responsive design or a dedicated application.

[1584] Step 8:

[1585] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[1586] Step 9:

[1587] The device resends the user's correction request data to the server. The correction request data is again sent in JSON format. Example data:

[1588] json

[1589] {

[1590] "modify": "expand",

[1591] "target": "kitchen",

[1592] "details": "more space"

[1593] }

[1594] Step 10:

[1595] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[1596] Step 11:

[1597] The generative artificial intelligence model recalculates the floor plan based on the requested modifications and generates a new floor plan.

[1598] Step 12:

[1599] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[1600] Step 13:

[1601] Repeat steps 8 through 12 until the user has reviewed and is satisfied with the final drawing.

[1602] Step 14:

[1603] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1604] Step 15:

[1605] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[1606] (Example 1)

[1607] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1608] Conventional residential design systems have difficulty quickly and accurately reflecting user requests, particularly the time-consuming and labor-intensive process of generating and modifying floor plans. Furthermore, visual confirmation of generated floor plans and the rapid incorporation of modification requests are difficult, resulting in an inefficient design process for custom-built homes. This invention aims to solve these problems and streamline the process of generating and modifying floor plans based on user requests.

[1609] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1610] In this invention, the server includes means for inputting user-entered request data into a generative artificial intelligence model, means for the generative artificial intelligence model to learn past housing design data, and means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats. This enables the rapid and accurate generation and modification of the optimal floor plan based on the user's requests.

[1611] "Request data" refers to information that users input regarding the layout of a house, including details such as the number of rooms, orientation, specific functions, and size.

[1612] A "generative artificial intelligence model" is an artificial intelligence system that includes an algorithm that learns from past housing design data and generates the optimal floor plan based on user request data.

[1613] A "server" is a computer system that receives request data sent by users and inputs it into a generative artificial intelligence model.

[1614] "Two-dimensional and three-dimensional formats" refer to the formats used to visually display the generated floor plan, and include both 2D formats that display it as a plan view and 3D formats that visualize it in three dimensions.

[1615] A "revision request" is data entered by the user after reviewing the generated floor plan, indicating the parts they wish to change or modify.

[1616] A "construction contractor" refers to a company or individual that constructs a house based on the floor plan ultimately approved by the user.

[1617] This invention is a system in which a user inputs their requirements for a house layout, a generative artificial intelligence model is used to generate a layout based on those requirements, and the layout is ultimately provided to a construction company. The program and processing of this system are described in detail below.

[1618] Users access a dedicated application or web form using devices such as PCs, tablets, or smartphones. A login function is available, and users log in by entering their account information. Users then enter detailed requests in an input form, such as the number of rooms in the house, its orientation, specific functions, and size. For example, they might enter specific requests like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[1619] The terminal converts the user's input request data into JSON format. The following data format is generated:

[1620] json

[1621] {

[1622] "rooms": 4,

[1623] "orientation": "south",

[1624] "kitchen_dining": "connected",

[1625] "bathroom": "large"

[1626] }

[1627] The terminal sends this JSON data to the server using the HTTPS protocol. The server checks the integrity of the received request data and returns an error message if necessary. Once integrity is confirmed, the server converts the data into a format suitable for generative artificial intelligence models.

[1628] The server inputs the converted data into a generative artificial intelligence model. The model uses an algorithm trained on past housing design data to calculate the optimal floor plan. This algorithm automatically generates a floor plan including the size and placement of each room.

[1629] Once the generative AI model finishes its calculations, the server visualizes the generated floor plan in 2D and 3D formats. Technologies such as WebGL and Three.js may be used for visualization. This visualized floor plan data is then converted back into JSON format, and the server sends it to the terminal.

[1630] The user reviews the floor plan generated on their device. While visually reviewing it, they input modification requests such as "I'd like the kitchen to be a little bigger." For example, they might input a modification request like "Make the kitchen bigger" in text format as follows:

[1631] "modify: expand, target: kitchen, details: more space"

[1632] The terminal converts the revision request data into JSON format and sends it back to the server. The server re-inputs the revision request data into the generative artificial intelligence model and generates a new floor plan.

[1633] The server generates a new floor plan and sends it back to the terminal. The user reviews it again, and if they are finally satisfied with the generated drawing, they give it final approval. The server generates the final floor plan in PDF or CAD data format and provides it to the builder. The final drawing is sent to the builder via email or a dedicated online portal. This system can generate floor plans that quickly and accurately meet the user's requests, significantly streamlining the custom home design process.

[1634] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1635] Step 1:

[1636] The user launches the application. The user opens the dedicated application or web form using a device such as a PC, tablet, or smartphone. The user enters their account information and logs in. Input: Account information, Output: Login session.

[1637] Step 2:

[1638] The user enters their requirements. The user enters detailed requirements such as the number of rooms in the house, orientation, specific functions, and size into an input form. For example, they might enter specific requirements like "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom." Input: Request data; Output: Structured input data (e.g., JSON format).

[1639] Step 3:

[1640] The device sends data. The device converts the user-entered request data into JSON format and then sends it to the server using the HTTPS protocol. Specifically, it generates an HTTP request and sends the data. Input: Structured input data; Output: Data contained in the HTTP request.

[1641] Step 4:

[1642] The server receives the data. The server checks the integrity of the requested data received via the HTTPS protocol and returns an error message if necessary. Once integrity is confirmed, the data is converted into a format suitable for a generative artificial intelligence model. Input: Data received from the HTTP request; Output: Converted data.

[1643] Step 5:

[1644] The server inputs data into the AI ​​model. The server then inputs the transformed data into a generative artificial intelligence model. Data interpolation and preprocessing are performed as needed. Input: Data that has been formatted; Output: Data input into the AI ​​model.

[1645] Step 6:

[1646] A generative artificial intelligence model generates floor plans. The AI ​​model uses an algorithm to calculate the optimal floor plan based on the input request data. The model references past housing design data stored in a database. Input: Data entered into the AI ​​model; Output: Generated floor plan data.

[1647] Step 7:

[1648] The server receives the floor plan. The server visualizes the generated floor plan data in 2D and 3D formats. Visualization may utilize technologies such as WebGL or Three.js. The visualized data is then converted back to JSON format and sent to the terminal. Input: Generated floor plan data, Output: Visualized data.

[1649] Step 8:

[1650] The user reviews the floor plan. The user reviews the floor plan generated on their device and makes a visual evaluation. They check the room layout, size, orientation, etc., and may also enter revision requests. Input: Visualized data; Output: User feedback and revision requests.

[1651] Step 9:

[1652] The terminal sends a correction request. The correction request entered by the user is converted to JSON format and sent back to the server. A concrete example of a request might be "Make the kitchen bigger." Input: Correction request data, Output: Correction request data included in the HTTP request.

[1653] Step 10:

[1654] The server processes the revision request. The server re-inputs the revision request data into the generative artificial intelligence model and instructs it to generate a new floor plan. Input: Revision request data received from the HTTP request; Output: Revision data input into the AI ​​model.

[1655] Step 11:

[1656] The generative artificial intelligence model performs a recalculation. The AI ​​model recalculates based on the requested modifications and generates a new floor plan. Input: Modification data entered into the AI ​​model; Output: Modified floor plan data.

[1657] Step 12:

[1658] The server generates a new floor plan. The server generates a new floor plan and sends it back to the terminal. Input: Modified floor plan data, Output: Visualized new floor plan data.

[1659] Step 13:

[1660] The user performs the final review. The user checks the new floor plan on their device and, if the generated drawing is satisfactory, gives final approval. Input: Visualized new floor plan data, Output: Final approval.

[1661] Step 14:

[1662] The server provides the final drawings. The server generates the final floor plans in PDF or CAD data format and provides them to the construction company. The final drawings are provided via email or a dedicated online portal. Input: Final approved floor plan data; Output: Final drawings in PDF or CAD data format.

[1663] (Application Example 1)

[1664] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1665] Designing the layout of machinery and work within a factory is crucial for maximizing efficiency, safety, and productivity. However, traditional layout design is often done manually, which is time-consuming and costly. Furthermore, finding the optimal layout requires advanced expertise, and any modifications or changes necessitate redesign. To address these challenges, there is a need for a system that allows users to easily design factory layouts and quickly provide optimized layouts using generative artificial intelligence models.

[1666] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1667] In this invention, the server includes means for the user to input layout requests, means for transmitting the input request data to the server, means for the server to input the received request data into a generative artificial intelligence model, means for allowing the user to visually confirm the generated layout diagram, means for the user to send revision requests to the server again, means for the server to reprocess the revision requests and generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This enables the rapid and efficient design of the optimal layout within the factory, simplifying the design process and improving its accuracy.

[1668] A "user" is an individual or group that uses the system to design layouts.

[1669] "Layout" refers to the arrangement of machinery, work stations, employee movement routes, safety areas, and other elements within a factory.

[1670] "Request data" refers to data that includes the user's desired conditions and requirements for layout design.

[1671] A "server" is a computer system that receives request data sent by users and generates and regenerates layouts using a generative artificial intelligence model.

[1672] A "generative artificial intelligence model" is an artificial intelligence system that includes algorithms for generating the optimal layout based on user request data.

[1673] "Means of visual confirmation" refers to an interface that displays the generated layout diagram in a way that allows the user to view it in two-dimensional and three-dimensional formats.

[1674] A "revision request" is a request from a user for additional changes or adjustments to a layout diagram that has been generated.

[1675] The "finally approved layout diagram" is the layout diagram that the user deemed to be the optimal state and ultimately approved for adoption.

[1676] "Means of provision" refers to the means of providing the finally approved layout diagram to users and other related systems in digital format or other means.

[1677] In order to implement this invention, it is necessary to build a system in which users, servers, and terminals work closely together to efficiently and quickly design factory layouts.

[1678] Hardware and software configuration

[1679] 1. User terminal:

[1680] This involves using devices with input interfaces, such as tablets and smartphones, to allow users to input their factory layout requirements.

[1681] 2. Server:

[1682] High-performance computing servers (e.g., AWS EC2) are used to receive request data, operate generative artificial intelligence models, and transform data.

[1683] 3. Generative artificial intelligence models:

[1684] Using frameworks such as TensorFlow and PyTorch, we execute algorithms that generate the optimal factory layout based on user request data.

[1685] Program processing flow

[1686] The user enters the request data.

[1687] The user opens the application on their terminal and enters their requirements regarding the factory layout. These requirements include the number of work lines, the types and number of machines needed, employee movement routes, and the setting of safety areas. For example, the following requirements are entered in text format:

[1688] Number of production lines: 3

[1689] Types and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units

[1690] Employee travel routes: Line 1, Line 2

[1691] Safety area settings: Storage area

[1692] Sending request data to the server

[1693] The entered request data is converted into a structured format and sent to the server. The server receives the data and checks its integrity.

[1694] Input to a generative artificial intelligence model

[1695] The server inputs the verified request data into a generative artificial intelligence model. Based on past factory layout design data, the model calculates the optimal layout that best suits the user's requests.

[1696] Providing the generated layout diagram to the user

[1697] The generated layout diagrams are visualized in two-dimensional and three-dimensional formats and sent to the user's terminal. The user visually reviews them and re-enters any revision requests if necessary.

[1698] Reprocessing of correction requests

[1699] The user's revision requests are sent back to the server, where a generative artificial intelligence model recalculates and generates a new layout diagram. This process is repeated until a satisfactory layout diagram is completed.

[1700] Provision of the final layout drawing

[1701] The final layout diagram approved by the user is provided in digital format and sent to the user and other relevant systems.

[1702] Through the above process, the optimal factory layout can be designed quickly and efficiently. This system enables improvements in factory production efficiency and safety.

[1703] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1704] Step 1:

[1705] The user enters the request data.

[1706] The user opens an application on their terminal and enters their requirements for the factory layout. Input fields include the number of work lines, the type and number of machines required, employee movement routes, and safety area settings. For example, "Number of work lines: 3," "Type and number of machines: 5 assembly robots, 2 conveyor belts, 4 storage units," "Employee movement routes: Line 1, Line 2," and "Safety area settings: Storage area." The input data is converted into a structured format (JSON).

[1707] Step 2:

[1708] Sending request data to the server

[1709] The terminal sends the request data entered by the user to the server. The server checks the integrity of the received request data. Specifically, it verifies the data format, checks required fields, and validates the value range. Once the integrity check is complete, the data is converted into a format that can be input into a generative artificial intelligence model. The input is the user's request data, and the output is the data whose integrity has been verified.

[1710] Step 3:

[1711] Input to a generative artificial intelligence model

[1712] The server inputs verified request data into a generative artificial intelligence model. Based on past factory layout design data, the generative AI model calculates the optimal layout suitable for the user's requests. Specifically, it optimizes the placement of various machines, the design of work lines, employee movement routes, and the definition of safety areas through data calculations. The input is consistent request data, and the output is a generated layout diagram.

[1713] Step 4:

[1714] Providing the generated layout diagram to the user

[1715] The server visualizes the generated layout diagram in two-dimensional and three-dimensional formats and sends the data to the user's terminal. The user then reviews the visualized layout diagram. Specifically, the layout diagram is displayed in 2D and 3D on the terminal. The user visually confirms the arrangement of each work line, the location of machines, the location of safety areas, etc. The input is the generated layout diagram, and the output is the visualized layout diagram.

[1716] Step 5:

[1717] User input for correction requests

[1718] If a user is dissatisfied with the layout diagram, they can submit a request for revision. For example, specific requests such as "Move the machine placement on line 1 to the left" or "Expand the storage area." The terminal then sends the revision request data to the server. The input is the user's revision request data, and the output is the revision request data sent to the server.

[1719] Step 6:

[1720] Reprocessing of correction requests

[1721] The server re-inputs the requested modification data into the generative artificial intelligence model and generates a new layout diagram. The model recalculates and updates the layout based on the requested modifications. Specifically, it optimizes the overall layout while reflecting the changes requested by the user. The input is the requested modification data, and the output is the modified layout diagram.

[1722] Step 7:

[1723] Provision of the final layout drawing

[1724] The server sends the revised layout drawing back to the user's terminal. The user performs a final review and approves it if they are satisfied. The finally approved layout drawing is provided in digital format. Specifically, it is output as PDF or CAD data and provided to the user via email or online portal. The input is the final reviewed layout drawing, and the output is a digital layout drawing.

[1725] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[1726] This invention relates to a system that allows users to input and modify their requests regarding the layout of a house and generates a floor plan based on those requests, as well as a system that includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. The program and processing of this system are described below.

[1727] 1. The user enters their request.

[1728] The user opens an application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. For example, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[1729] 2. Sending request data

[1730] The terminal sends the entered request data to the server in JSON format. Example data:

[1731] json

[1732] {

[1733] "rooms": 4,

[1734] "orientation": "south",

[1735] "kitchen_dining": "connected",

[1736] "bathroom": "large"

[1737] }

[1738] 3. Data reception and input into the AI ​​model

[1739] The server receives the submitted request data and checks its integrity. If necessary, it converts the data format to one suitable for the generative artificial intelligence model.

[1740] 4. Complementing user emotions with an emotion engine

[1741] The server is equipped with an emotion engine that recognizes the user's emotions when they enter a request. This emotion data is reflected in the request data, and if the user is, for example, "feeling stressed," the system will provide supplementary information such as suggesting a more concise request.

[1742] 5. AI-powered floor plan generation

[1743] The generative AI model calculates and generates house floor plans based on verified request data. The generative AI model automatically generates the size and placement of each room according to the user's requests.

[1744] 6. Output and transmission of generated results

[1745] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. The generated floor plans are visualized in a format that is easy for the user to understand.

[1746] 7. User review and input of correction requests.

[1747] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they can enter specific change requests such as, "I'd like the kitchen to be a little bigger."

[1748] 8. Revision suggestions based on the emotion engine

[1749] The emotion engine recognizes the user's emotions when reviewing a floor plan, and if, for example, the user is feeling anxious, it automatically generates modification suggestions based on that emotion. As an example of a suggestion, it might offer a specific suggestion such as, "If you feel the kitchen is too small, how about converting part of the living room into a kitchen?"

[1750] 9. Reprocessing of correction requests

[1751] The server receives the correction request data and inputs it into the generative artificial intelligence model. It then sends a recalculation instruction to the generative artificial intelligence model.

[1752] 10. Recalculation by generative AI

[1753] The generative artificial intelligence model recalculates based on modification requests and suggestions from the emotion engine to generate a new floor plan.

[1754] 11. Generate and send a new floor plan.

[1755] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[1756] 12. Review and approval of the final drawings

[1757] This process is repeated until the user reviews it again and is satisfied with the final drawing.

[1758] The emotion engine recognizes the user's emotions when they review the final drawing and provides a means to gather further feedback if they are not satisfied.

[1759] 13. Provision of final drawings

[1760] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1761] The final drawings are sent to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[1762] Thus, the system of the present invention can recognize the user's emotions and generate floor plans that quickly and accurately reflect the user's requests, thereby significantly streamlining the design process for custom-built homes.

[1763] The following describes the processing flow.

[1764] Step 1:

[1765] The user opens the application or web form on their device. The user enters their requirements for the house layout (e.g., number of rooms, arrangement, specific functions, size, etc.) into the form. Specifically, they might enter requirements such as "4LDK," "south-facing living room," "kitchen and dining room connected," and "large bathroom."

[1766] Step 2:

[1767] The terminal sends the input request data and user emotion data (e.g., the results of emotion analysis of the user's facial expressions and voice while inputting) to the server in JSON format. Example data:

[1768] json

[1769] {

[1770] "rooms": 4,

[1771] "orientation": "south",

[1772] "kitchen_dining": "connected",

[1773] "bathroom": "large",

[1774] "user_emotion": "neutral"

[1775] }

[1776] Step 3:

[1777] The server checks the consistency between the received request data and sentiment data. It verifies that the format and required fields of the request data are correct.

[1778] Step 4:

[1779] The server inputs the verified request data into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions for supplementing or modifying the request data.

[1780] Step 5:

[1781] The generative artificial intelligence model calculates and generates house floor plans based on verified request data. Specifically, it automatically generates the size and placement of each room.

[1782] Step 6:

[1783] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. It then formats the generated floor plan so that the user can visually review it.

[1784] Step 7:

[1785] The server sends visualized floor plan data to the terminal. It is then displayed via a responsive design or a dedicated application for user review.

[1786] Step 8:

[1787] Users can view the floor plan generated on their device and enter revision requests as needed. For example, they might enter a request such as, "I'd like the kitchen to be a little bigger."

[1788] Step 9:

[1789] The device then resends the user's correction request data and their current sentiment data to the server. The correction request data is also sent in JSON format. Example data:

[1790] json

[1791] {

[1792] "modify": "expand",

[1793] "target": "kitchen",

[1794] "details": "more space",

[1795] "user_emotion": "concerned"

[1796] }

[1797] Step 10:

[1798] The server receives correction request data and emotion data, and inputs them into a generative artificial intelligence model. Furthermore, the emotion engine analyzes the user's emotions and makes suggestions in response to the correction requests.

[1799] Step 11:

[1800] The generative artificial intelligence model recalculates based on modification requests and suggestions for the emotion engine, generating a new floor plan.

[1801] Step 12:

[1802] The server receives the new floor plan data, visualizes it again in 2D and 3D formats, and sends it to the terminal.

[1803] Step 13:

[1804] Repeat this process from step 8 to step 12 until the user has reviewed it again and is satisfied with the final drawing.

[1805] Step 14:

[1806] The emotion engine recognizes the user's emotions when they review the final drawing and, if the user is not satisfied, provides a means to gather further feedback. The process is repeated until the user expresses a positive emotion such as "satisfied" or "happy."

[1807] Step 15:

[1808] After the user approves the final drawings, the server generates the final floor plan in PDF or CAD data format and provides it to the home builder.

[1809] Step 16:

[1810] The server sends the final drawings to the home builder via email or a dedicated online portal, completing the home design process based on the user's requests.

[1811] (Example 2)

[1812] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1813] In residential floor plan design, it is essential to quickly and accurately reflect the user's requests. Furthermore, understanding the user's emotions and providing suggestions and advice to alleviate stress and dissatisfaction is also crucial. Conventional systems struggle not only to properly understand user requests and generate optimal floor plans, but also to consider user emotions, making it difficult to increase user satisfaction. This invention solves these problems.

[1814] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[1815] In this invention, the server includes means for the user to input requests regarding the layout of a house; means for transmitting the input request data to the server; means for the server to input the received request data into a generative artificial intelligence model; means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats; means for the user to send revision requests to the server again; means for the server to reprocess the revision requests and generate a new floor plan; means including an emotion engine that recognizes the user's emotions and makes input and revision suggestions based on those emotions; and means for finally providing the floor plan approved by the user in digital format. This makes it possible to quickly and accurately reflect the user's requests and generate an optimal floor plan that also takes the user's emotions into consideration.

[1816] A "user" is someone who uses the system to input requests regarding the layout of a house, and then reviews and approves the final floor plan.

[1817] A "server" is a core information processing device that receives request data sent from users, processes the data using a generative artificial intelligence model and an emotion engine, and generates and provides the final floor plan.

[1818] A "generative artificial intelligence model" refers to an artificial intelligence algorithm and related software for automatically generating floor plans of houses based on user request data.

[1819] An "emotion engine" is a technology that recognizes emotions from user input and actions, and provides suggestions and corrective advice based on those emotions.

[1820] A "floor plan" is a drawing that shows the arrangement of rooms and facilities in a house, and is provided to the user visually in two-dimensional and three-dimensional formats.

[1821] "Request data" refers to information entered by users regarding their wishes and requests about the layout of their homes, which is transmitted to the server in data format such as JSON.

[1822] A "revision request" refers to a user's wishes or requests for changes or additions to a floor plan after reviewing the generated plan.

[1823] "Two-dimensional and three-dimensional formats" refer to formats for displaying and reviewing floor plans using different visual representations, and include plan views (2D) and three-dimensional views (3D).

[1824] "Digital format" refers to electronic data formats, such as providing floor plans and other information in PDF or CAD data formats.

[1825] This invention relates to a system that allows a user to input their preferences regarding the layout of a house and generates a floor plan based on those preferences. Furthermore, it includes an emotion engine that recognizes the user's emotions and optimizes the floor plan accordingly. Details of this system, including the hardware and software used and specific processes, are described below.

[1826] System Configuration

[1827] This system consists of the following main elements:

[1828] A terminal where users enter their requests.

[1829] Server that processes request data

[1830] Generative artificial intelligence models

[1831] Emotional Engine

[1832] Hardware and software

[1833] terminal

[1834] The devices on which users can enter requests include desktop computers, laptops, tablets, and smartphones. On these devices, a browser-based web form or a dedicated application will operate.

[1835] Examples of use: Google Chrome browser and custom mobile apps

[1836] server

[1837] The server receives request data sent by the user, checks the data's integrity, and then inputs it into a generative artificial intelligence model. The following technologies are primarily used:

[1838] Web servers: Apache, NGINX

[1839] Server-side languages: Python, Node.js

[1840] Generative artificial intelligence models

[1841] The generative artificial intelligence model is used to generate floor plans of houses based on received request data. The model is based on deep learning and utilizes the following framework:

[1842] TensorFlow, PyTorch

[1843] Emotional Engine

[1844] The emotion engine recognizes the user's emotions when they input requests or review drawings, and uses that information to provide suggestions and advice.

[1845] Sentiment analysis libraries: Python's NLTK, spaCy

[1846] Specific example of processing

[1847] 1. Entering request data

[1848] Users enter specific requests regarding the layout of their home through a web form or application on their device. Examples include "4LDK," "south-facing living room," "connected kitchen and dining room," and "large bathroom."

[1849] 2. Sending request data

[1850] The terminal converts the entered request data into JSON format and sends it to the server.

[1851] 3. Data integrity check

[1852] The server checks the integrity of the received request data, verifying that there is no missing data or format errors.

[1853] 4. Emotion recognition

[1854] The emotion engine built into the server analyzes the user's input and input circumstances to recognize the user's emotions. If the user is experiencing stress, it provides appropriate guidance.

[1855] 5. Generating a floor plan

[1856] The server inputs the verified request data into a generative artificial intelligence model, and the AI ​​model generates a floor plan.

[1857] 6. Visualization of floor plans

[1858] The server receives the generated floor plan data, visualizes it in 2D and 3D formats, and sends it to the user's device. Tools such as Three.js and Blender are used for visualization.

[1859] 7. Enter your request for corrections.

[1860] Users can review the visualized floor plan and submit revision requests as needed. For example, they might enter specific requests such as wanting the kitchen to be a little larger.

[1861] 8. Emotion-based proposals

[1862] The emotion engine recognizes the emotions a user feels when submitting a revision request, and, for example, if the user is feeling anxious, it makes revision suggestions based on that emotion.

[1863] Example of a prompt

[1864] As an example of a prompt message to be input to a generative artificial intelligence model based on user requests,

[1865] "Based on the user's requests, please generate a floor plan that includes a 4LDK layout, a south-facing living room, a connected kitchen and dining area, and a large bathroom."

[1866] This configuration allows for the real-time reflection of user requests and emotions, enabling the generation of optimal floor plans.

[1867] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1868] Step 1: The user enters their request.

[1869] Users open a web form or dedicated app on their device and enter their requests regarding the layout of their home. Specifically, they enter requests in text format, such as "4LDK" and "south-facing living room."

[1870] Input: User-submitted request data (e.g., "4LDK", "Living room faces south")

[1871] Output: The request data is stored in the form.

[1872] Step 2: Submit your request

[1873] The terminal converts the entered request data into JSON format and sends it to the server. Specifically, it converts the form data into the following JSON format and sends it to the server as an HTTP request.

[1874] Input: Request data stored in the form

[1875] Output: JSON data sent to the server

[1876] json

[1877] {

[1878] "rooms": 4,

[1879] "orientation": "south",

[1880] "kitchen_dining": "connected"

[1881] }

[1882] Step 3: Data reception and integrity check

[1883] The server receives the request data sent from the terminal and checks the data's integrity. Specifically, it parses the received data and verifies that there is no missing data and that the data format is correct.

[1884] Input: JSON data sent to the server

[1885] Output: Confirmed consistency of request data

[1886] Step 4: Emotion recognition by the emotion engine

[1887] The server's built-in emotion engine analyzes the user's emotions during this request input process. Specifically, it uses a Python NLP library to assign emotion labels to the input text.

[1888] Input: Request data and user text and behavior captured during input.

[1889] Output: Request data with emotion labels

[1890] Step 5: Inputting the request data into the AI ​​model

[1891] The server inputs emotion-labeled request data into a generative artificial intelligence model. Specifically, it converts the data into an appropriate format and sends it to the AI ​​model's API.

[1892] Input: Request data with emotion labels

[1893] Output: Data sent to the generative artificial intelligence model

[1894] Step 6: AI-powered floor plan generation

[1895] The generative artificial intelligence model generates floor plans for houses based on submitted request data. Specifically, it analyzes the request data, calculates an appropriate floor plan, and generates it.

[1896] Input: Request data sent from the server

[1897] Output: Generated floor plan data

[1898] Step 7: Visualize and submit the floor plan.

[1899] The server receives the generated floor plan data and visualizes it in 2D and 3D formats. Specifically, it visualizes the data using Three.js or Blender and sends that data to the terminal.

[1900] Input: Generated floor plan data

[1901] Output: Visualized 2D and 3D floor plans

[1902] Step 8: User review and input of correction requests

[1903] Users review the floor plan generated on their device and enter revision requests as needed. Specifically, they look at the floor plan and enter revision requests such as "Make the kitchen a little bigger."

[1904] Input: Visualized floor plan and user modification requests

[1905] Output: Correction request data

[1906] Step 9: Reprocessing the correction request

[1907] The server re-inputs the correction request data sent by the user into the generative artificial intelligence model and instructs it to generate a new floor plan.

[1908] Input: User correction request data

[1909] Output: Generative artificial intelligence model that received correction instructions

[1910] Step 10: Generate and submit a new floor plan.

[1911] The generative artificial intelligence model generates a new floor plan based on the requested modification data and sends it to the server. Specifically, it performs recalculations and generates new floor plan data.

[1912] Input: Data for which correction instructions were received

[1913] Output: New floor plan data

[1914] Step 11: Review and approval of the final drawings

[1915] The user reviews the floor plan again and gives final approval. This process is repeated until a satisfactory drawing is obtained.

[1916] Input: New floor plan data

[1917] Output: Final approved floor plan data

[1918] Step 12: Submitting the final drawings

[1919] The server generates the final floor plan in PDF or CAD data format and provides it to the home builder. Specifically, it exports the floor plan in the appropriate digital format and sends it via email or a dedicated portal.

[1920] Input: Final approved floor plan data

[1921] Output: Drawings in PDF or CAD data format provided to the house builder.

[1922] The above is a detailed explanation of the system's program processing flow.

[1923] (Application Example 2)

[1924] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1925] Conventional spatial layout design systems merely mechanically generate layouts based on user request data, failing to reflect user emotions. Therefore, they couldn't reproduce the layout the user considered optimal, making it difficult to sufficiently improve user satisfaction. Furthermore, when users submitted revision requests, the suggestions weren't based on emotions, meaning the regenerated layouts didn't always match the user's wishes.

[1926] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for the user to input a request regarding the layout of a space, means for transmitting the input request data to the server, means for the server to input the received request data to a generative artificial intelligence model, means for the generative artificial intelligence model to generate a layout of a space based on the request data, means for an emotion engine that recognizes the user's emotions and optimizes the request data based on the emotion data, means for allowing the user to visually confirm the generated layout diagram, means for transmitting the user's correction requests to the server again, means for the server to reprocess the correction requests and emotion data to generate a new layout diagram, and means for finally providing the layout diagram approved by the user. This makes it possible to generate an optimal layout that reflects the user's emotions and increase user satisfaction.

[1927] "Spatial layout" refers to drawings or plans that show the physical arrangement and structure within a specific space.

[1928] "Request data" refers to data that indicates the user's wishes and requirements regarding the layout of the space.

[1929] A "server" is a computer system that receives, processes, stores, and transmits data from users.

[1930] A "generative artificial intelligence model" is an artificial intelligence algorithm that automatically generates spatial layouts based on user request data.

[1931] An "emotion engine" is a system that recognizes the user's emotions and reflects that emotional data in the request data.

[1932] "Optimization" refers to adjusting or modifying data or processes to obtain the best possible results under specific conditions or constraints.

[1933] A "layout diagram" is a diagram that visually represents the layout and structure of a space, and includes both two-dimensional and three-dimensional formats.

[1934] "Visual confirmation" refers to displaying the generated layout diagram in a format visible to the user.

[1935] "Revision requests" are data that users indicate additional requests or changes they would like to make to existing layout diagrams.

[1936] "Reprocessing" is the process of regenerating a new layout based on requested modifications and other relevant data.

[1937] "The layout diagram that the user ultimately approved" refers to the layout diagram that the user ultimately found satisfactory and determined did not require any changes.

[1938] System Overview

[1939] This invention is a system that generates an optimal layout by having the user input their preferences regarding the layout of a space and then analyzing emotional data. The system consists of the following main components:

[1940] A terminal for users to input request data.

[1941] A server that receives, sends, and processes request data and emotion data.

[1942] Generative artificial intelligence model that generates layouts based on request data

[1943] An emotion engine that analyzes user emotions.

[1944] Hardware and software to use

[1945] Hardware:

[1946] Smartphones and tablets: Users input request data and check the results.

[1947] Server: Used for receiving, processing, storing, and transmitting data.

[1948] software:

[1949] Flask: Used as a server-side web framework.

[1950] EmotionAnalyzer: A library for analyzing user emotion data.

[1951] LayoutGenerator: A generative artificial intelligence model for generating layouts based on request data.

[1952] Processing flow details

[1953] 1. Inputting user request data:

[1954] Users use smartphones or tablets to input specific requests regarding the layout of the space in text format. For example, "I would like a spacious layout in front of the cash registers."

[1955] 2. Collection of emotional data:

[1956] The user's emotions are also collected simultaneously and analyzed by EmotionAnalyzer. For example, information such as "feeling stressed" is analyzed.

[1957] 3. Submitting request data:

[1958] The terminal sends the entered request data and emotion data to the server in JSON format.

[1959] 4. Data optimization and layout generation:

[1960] The server processes the received data and optimizes the request data based on emotional data. For example, if the user is feeling stressed, it suggests a simpler layout. This optimized data is then input into a generative artificial intelligence model to generate the spatial layout.

[1961] 5. Visualizing the generated layout:

[1962] The generated layout diagrams are presented to the user visually in both two-dimensional and three-dimensional formats. For example, they might be displayed as "a layout with wide checkout counters and wide aisles."

[1963] 6. Implementation of requested revisions:

[1964] The user reviews the generated layout diagram and enters revision requests as needed. Requests such as "It's too large, I'd like to make it a bit more compact" are entered here.

[1965] 7. Regeneration process:

[1966] The server reprocesses the revision request, re-analyzes the sentiment data, and generates a new layout diagram. This process is repeated until the user is satisfied.

[1967] 8. Providing the final layout:

[1968] The fully satisfactory layout diagram will ultimately be provided to the user in PDF or other digital formats.

[1969] Specific examples and prompt statements

[1970] As a concrete example, a store owner using the app to design a new layout generates a layout where "the area in front of the checkout counter is spacious, making the shopping process feel smoother."

[1971] Example of a prompt:

[1972] "Please create a store layout with a spacious area in front of the cash registers and a user-friendly counter."

[1973] In this way, the invention makes it possible to realize an optimal spatial layout that reflects the user's emotions, thereby increasing user satisfaction.

[1974] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1975] Step 1:

[1976] Users use their smartphones or tablets to input specific requests regarding the layout of the space into the application. For example, they might enter a request such as, "I want a spacious area in front of the cash registers." This input data is saved in text format.

[1977] Step 2:

[1978] The terminal sends the entered request data to the server in JSON format. Simultaneously, user emotion data (e.g., "feeling stressed") is also collected and sent to the server in JSON format. This data is sent from the terminal to the server as an HTTP request.

[1979] Step 3:

[1980] The server receives the submitted request and sentiment data and checks the data's integrity. It verifies that the received data is in the correct format and returns an error message if there are any inconsistencies. Once the data's integrity is confirmed, it proceeds to the next process.

[1981] Step 4:

[1982] The server uses an emotion engine to analyze the user's emotional data. For example, the emotion engine might analyze the user's stress level and output a result such as "high stress level." This result is then used to optimize the request data.

[1983] Step 5:

[1984] The server optimizes request data based on emotional data. For example, if the analysis indicates that the user is "feeling stressed," it will suggest a wider layout, implementing stress reduction measures in response to the request data. This optimized data is then input into a generative artificial intelligence model.

[1985] Step 6:

[1986] The server receives request data optimized for a generative artificial intelligence model, which then generates a spatial layout. The generative AI model automatically generates two-dimensional and three-dimensional layout diagrams based on the input data. The results are output in JSON format.

[1987] Step 7:

[1988] The server visualizes the generated layout diagram and sends it to the user's terminal. The user can review the generated layout diagram on the application and enter revision requests as needed. For example, a revision request might be, "The checkout area is too large; I'd like to make it more compact."

[1989] Step 8:

[1990] The terminal resends the entered correction request to the server. This correction request data is sent in JSON format, as before, and after receiving it, the server uses the sentiment engine again to analyze the user's current sentiment data.

[1991] Step 9:

[1992] The server performs the optimization process again based on the requested modifications and the re-analyzed sentiment data. The optimized data is re-input, and the generative artificial intelligence model regenerates the new layout. This regeneration process is repeated until the user is satisfied.

[1993] Step 10:

[1994] The final layout diagram, once approved by the user, is provided to the user from the server in PDF or other digital formats. The user can then view this final layout diagram on their device and download or print it as needed.

[1995] In this way, it becomes possible to generate an optimal spatial layout that reflects the user's needs and emotions, thereby increasing user satisfaction.

[1996] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1997] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1998] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the robot 414.

[1999] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[2000] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[2001] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[2002] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[2003] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[2004] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In other words, it is when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is the emotion around the positive "desire" on the reaction side. In other words, it is when the robot has positive feelings such as "I want more" or "I want to know more."

[2005] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​representing each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple training data sets, which are combinations of user input and emotion values ​​representing each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions located close together have similar values, as shown in the emotion map 900 in Figure 10. Figure 10 shows an example where multiple emotions such as "reassured," "calm," and "confident" have similar emotion values.

[2006] The above description primarily focuses on the functions of the data processing device 12 in relation to this disclosure. However, the system related to this disclosure is not necessarily implemented on a server. The system related to this disclosure may be implemented as a general information processing system. This disclosure may be implemented, for example, as a software program that runs on a personal computer or as an application that runs on a smartphone. The method related to this disclosure may be provided to users in SaaS (Software as a Service) format.

[2007] In the above embodiment, an example was given in which a specific process is performed by a single computer 22. However, the technology of this disclosure is not limited thereto, and a distributed processing of the specific process may be performed by multiple computers, including computer 22. For example, a data generation model 58 may be provided in an external device of the data processing device 12, and the external device may generate data according to the input data.

[2008] In the above embodiment, an example was given in which the specific processing program 56 is stored in the storage 32, but the technology of this disclosure is not limited thereto. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-temporary storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-temporary storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes specific processing according to the specific processing program 56.

[2009] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[2010] Furthermore, it is not necessary to store the entirety of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store the entirety of the specific processing program 56 in the storage 32; it is acceptable to store only a portion of the specific processing program 56.

[2011] The following types of processors can be used as hardware resources to perform specific processing. Examples of processors include a CPU, a general-purpose processor that functions as a hardware resource to perform specific processing by executing software, i.e., a program. Other examples of processors include dedicated electrical circuits, such as FPGAs (Field-Programmable Gate Arrays), PLDs (Programmable Logic Devices), or ASICs (Application Specific Integrated Circuits), which have circuit configurations specifically designed to perform specific processing. All of these processors have built-in or connected memory, and all of them perform specific processing by using memory.

[2012] The hardware resource that performs a specific process may consist of one of these various processors, or it may consist of a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Alternatively, the hardware resource that performs a specific process may consist of a single processor.

[2013] Examples of configurations using a single processor include, firstly, a configuration in which one or more CPUs and software are combined to form a single processor, and this processor functions as a hardware resource that performs a specific process. Secondly, there is a configuration using a processor that realizes the functions of the entire system, including multiple hardware resources that perform a specific process, on a single IC chip, as exemplified by SoCs (System-on-a-chip). In this way, a specific process is realized using one or more of the above types of processors as hardware resources.

[2014] Furthermore, the hardware structure of these various processors can more specifically utilize electrical circuits that combine circuit elements such as semiconductor devices. Also, the specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps can be deleted, new steps added, or the processing order rearranged, as long as it does not deviate from the main purpose.

[2015] The descriptions and illustrations presented above are detailed explanations of the technical aspects of this disclosure and are merely examples of the technical aspects. For example, the above descriptions of the structure, function, operation, and effect are examples of the structure, function, operation, and effect of the technical aspects of this disclosure. Therefore, it goes without saying that you may delete unnecessary parts, add new elements, or replace elements in the descriptions and illustrations presented above, as long as you do not deviate from the essence of the technical aspects of this disclosure. Furthermore, in order to avoid confusion and facilitate understanding of the technical aspects of this disclosure, explanations of common technical knowledge and the like that do not require special explanation to enable the implementation of the technical aspects of this disclosure have been omitted from the descriptions and illustrations presented above.

[2016] All documents, patent applications, and technical standards described herein are incorporated by reference to the same extent as if each individual document, patent application, and technical standard were specifically and individually noted as being incorporated by reference.

[2017] The following is further disclosed regarding the embodiments described above.

[2018] (Claim 1)

[2019] A means for users to input their requests regarding the layout of their homes,

[2020] A means of sending the input request data to the server,

[2021] A means for inputting the request data received by the server into a generative artificial intelligence model,

[2022] A means by which a generative artificial intelligence model generates a house floor plan based on requested data,

[2023] A means of allowing the user to visually confirm the generated floor plan,

[2024] A means of resending user correction requests to the server,

[2025] A means by which the server reprocesses the correction request and generates a new floor plan,

[2026] A system that includes a means of providing home builders with floor plans that have been ultimately approved by the user.

[2027] (Claim 2)

[2028] The system according to claim 1, wherein the means for visually displaying the generated floor plan is to display it in two-dimensional and three-dimensional forms.

[2029] (Claim 3)

[2030] The system according to claim 1, which provides the final generated floor plan to a house builder in digital format.

[2031] "Example 1"

[2032] (Claim 1)

[2033] A means for users to input their requests regarding the layout of their homes,

[2034] A means of sending the input request data to the server,

[2035] A means for inputting the request data received by the server into a generative artificial intelligence model,

[2036] A means by which a generative artificial intelligence model generates a house floor plan based on requested data,

[2037] Methods by which generative artificial intelligence models learn from past housing design data,

[2038] A means of visually confirming the generated floor plan in two-dimensional and three-dimensional formats,

[2039] A means of resending user correction requests to the server,

[2040] A method by which the server re-inputs the correction request into a generative artificial intelligence model to generate a new floor plan,

[2041] A system that includes a means of providing the construction company with the floor plan that the user has ultimately approved.

[2042] (Claim 2)

[2043] The system according to claim 1, which displays the generated floor plan in two-dimensional and three-dimensional formats.

[2044] (Claim 3)

[2045] The system according to claim 1, which provides the final generated floor plan to a construction company in digital format.

[2046] "Application Example 1"

[2047] (Claim 1)

[2048] A means for users to input their layout requests,

[2049] A means of sending the input request data to the server,

[2050] A means for inputting the request data received by the server into a generative artificial intelligence model,

[2051] A means by which a generative artificial intelligence model generates a layout based on requested data,

[2052] A means of allowing the user to visually confirm the generated layout diagram,

[2053] A means of resending user correction requests to the server,

[2054] A means by which the server reprocesses the modification request and generates a new layout diagram,

[2055] A system that includes means for providing a layout diagram that has been ultimately approved by the user.

[2056] (Claim 2)

[2057] The system according to claim 1, wherein the means for visually displaying the generated layout diagram is to display it in two-dimensional and three-dimensional forms.

[2058] (Claim 3)

[2059] The system according to claim 1, which provides the final generated layout diagram in digital format.

[2060] "Example 2 of combining an emotion engine"

[2061] (Claim 1)

[2062] A means for users to input their requests regarding the layout of their homes,

[2063] A means of sending the input request data to the server,

[2064] A means for inputting the request data received by the server into a generative artificial intelligence model,

[2065] A means by which a generative artificial intelligence model generates a house floor plan based on requested data,

[2066] A means for visually confirming the generated floor plan in two-dimensional and three-dimensional formats,

[2067] A means of resending user correction requests to the server,

[2068] A means by which the server reprocesses the correction request and generates a new floor plan,

[2069] A means including an emotion engine that recognizes the user's emotions and provides input and correction suggestions based on those emotions,

[2070] A system that includes a means of providing the final floor plan approved by the user in digital format.

[2071] (Claim 2)

[2072] The system according to claim 1, comprising an emotion engine that includes technology for recognizing user emotions and assigning emotion labels.

[2073] (Claim 3)

[2074] The system according to claim 1, which provides the ultimately generated floor plan to an external organization in digital format.

[2075] "Application example 2 when combining with an emotional engine"

[2076] (Claim 1)

[2077] A means for users to input their requests regarding the layout of the space,

[2078] A means of sending the input request data to the server,

[2079] A means for inputting the request data received by the server into a generative artificial intelligence model,

[2080] A means by which a generative artificial intelligence model generates a spatial layout based on requested data,

[2081] Includes an emotion engine that recognizes user emotions, and means for optimizing request data based on emotion data,

[2082] A means of allowing the user to visually confirm the generated layout diagram,

[2083] A means of resending user correction requests to the server,

[2084] A server provides a means for reprocessing revision requests and sentiment data to generate a new layout diagram,

[2085] A system that includes means for providing a layout diagram that has been ultimately approved by the user.

[2086] (Claim 2)

[2087] The system according to claim 1, which displays the generated layout diagram in two-dimensional and three-dimensional formats.

[2088] (Claim 3)

[2089] The system according to claim 1, which provides the final generated layout diagram in digital format. [Explanation of Symbols]

[2090] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Devices 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robots< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for users to input their requests regarding the layout of their homes, A means of sending the input request data to the server, A means for inputting the request data received by the server into a generative artificial intelligence model, A means by which a generative artificial intelligence model generates a house floor plan based on requested data, A means of allowing the user to visually confirm the generated floor plan, A means of resending user correction requests to the server, A means by which the server reprocesses the correction request and generates a new floor plan, A system that includes a means of providing home builders with floor plans that have been ultimately approved by the user.

2. The system according to claim 1, wherein the means for visually displaying the generated floor plan is to display it in two-dimensional and three-dimensional forms.

3. The system according to claim 1, which provides the final generated floor plan to a house builder in digital format.

Images