System

Abstract

A system is provided.SOLUTION: A system, comprising: means for receiving an image; means for applying a generative AI model to analyze the received image based on a display guideline; means for generating a modification instruction based on the analysis; and means for transmitting the generated modification instruction to a user device.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the chatbot character, 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] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] Designers and creators spend a lot of time and effort checking whether the images they create meet display guidelines. Especially when display guidelines change frequently or the types of images become more diverse, the burden of creating revision requests and rechecking them increases. There is a need to solve these issues and significantly reduce the time required for creative checks. [Means for solving the problem]

[0005] In order to solve the above problems, the present invention provides the following means. First, the system includes a means for receiving images. Second, the system includes a means for applying a generative AI model to analyze the received images based on display guidelines. Furthermore, the system includes a means for generating correction instructions based on the analysis results and a means for sending the generated correction instructions to a user terminal, thereby making the creative check of produced images more efficient. Additionally, the system includes a means for registering the display guidelines in a database in advance and a means for the user terminal to receive the correction instructions and re-upload the corrected images, thereby providing a system that realizes an even more efficient check process.

[0006] The "means for receiving images" is a function that allows the server to receive image data sent by the user from the terminal.

[0007] "Display guidelines" refer to standards and rules regarding image display, such as the placement of elements within an image, color contrast ratio, and the position of a brand logo.

[0008] A "generative AI model" is an artificial intelligence model trained to perform image analysis, detecting and evaluating each element of an image based on display guidelines.

[0009] The "means for generating correction instructions based on the analysis results" is a function that creates specific correction instructions for differences from the display guidelines detected by the generative AI model.

[0010] The "means for transmitting a correction instruction to a user terminal" is a function for transmitting the generated correction instruction to the terminal used by the user via communication.

[0011] The "means for registering in a database" is a function for saving display guidelines and other necessary data in a database within the server.

[0012] The "means for receiving correction instructions and re-uploading the corrected image" is a function that allows the user to receive correction instructions at the terminal, correct the image, and then re-upload the image to the server. [Brief explanation of the drawings]

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

[0014] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0015] First, the terms used in the following description will be explained.

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

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

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

[0019] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0020] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0021] [First embodiment]

[0022] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0023] 1, a 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.

[0024] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0026] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the 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.

[0027] 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 of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0028] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

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

[0030] 2, in the data processing device 12, a specific process 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" according to the technology of the present 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 process 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.

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

[0032] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

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

[0034] The present invention relates to a system for efficiently checking the creativity of images. This system is mainly composed of a server, a terminal, and user operations.

[0035] Server-side processing

[0036] Display guidelines registration

[0037] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[0038] Receiving and saving images

[0039] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0040] Image analysis

[0041] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0042] Generate correction instructions

[0043] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[0044] Sending correction instructions

[0045] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[0046] Terminal side processing

[0047] Select and upload an image

[0048] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0049] Receiving correction instructions

[0050] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[0051] Corrective work

[0052] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0053] Specific examples

[0054] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0055] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0056] "The brand logo is centered. Please place it in the top left."

[0057] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0058] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0059] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0060] As described above, the system of the present invention provides a means for efficiently performing creative checks and reducing the workload of the user.

[0061] The processing flow will be explained below.

[0062] Step 1: Register display guidelines

[0063] The server receives display guideline data provided by an administrator.

[0064] The server stores the received display guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[0065] Step 2: Select and upload an image

[0066] The user selects the image they want to check on their device.

[0067] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[0068] Step 3: Receive and save the image

[0069] The server receives the image data sent from the user's terminal.

[0070] The server stores the received image data in a temporary storage area until the analysis is complete.

[0071] Step 4: Image analysis

[0072] The server reads the image data from the temporary storage area.

[0073] The server inputs the image data into the generative AI model and begins analysis.

[0074] The generative AI model detects each element in the image and compares it to display guidelines.

[0075] Step 5: Detect discrepancies and generate correction instructions

[0076] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[0077] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[0078] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[0079] Step 6: Send correction instructions

[0080] The server collects the generated revision comments and diagrams into a single package.

[0081] The server sends a package of correction instructions to the user's terminal.

[0082] Step 7: Receiving and confirming correction instructions

[0083] The user's terminal receives the correction instructions sent from the server.

[0084] The user reviews the correction instructions and understands the text comments and diagrams.

[0085] Step 8: Corrective action

[0086] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[0087] Step 9: Re-upload the corrected image

[0088] The user then performs an operation to upload the corrected image back to the server.

[0089] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[0090] Through the above steps, the system of the present invention realizes efficient creative checks and reduces the workload of the user.

[0091] Example 1

[0092] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0093] The present invention aims to provide a system that efficiently and accurately performs creative checks on images. Conventional manual image checks are time-consuming, labor-intensive, and prone to errors. In particular, checking images according to guidelines such as the position of brand logos and text, font size, and color contrast ratio requires specialized knowledge and experience. The present invention provides new technical means to solve these problems.

[0094] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0095] In this invention, the server includes means for receiving images, means for storing the received image data in a temporary storage area, means for inputting the image data into a generative AI model for analysis, means for comparing each element in the analyzed image with a display guideline, means for generating correction instructions based on the display guideline, and means for transmitting the generated correction instructions to a user terminal, thereby enabling efficient and accurate creative check of images for users.

[0096] 1. "Means for receiving images" refers to the function that allows the server to receive image data sent by the user from the terminal.

[0097] 2. "Means for storing received image data in a temporary storage area" refers to the function of storing image data received by the server in an area for temporary storage.

[0098] 3. "Means of inputting image data into a generative AI model for analysis" refers to the function of the server reading stored image data into the generative AI model and performing analytical processing.

[0099] 4. "Means for comparing each element in the analyzed image with the display guidelines" refers to the function by which the server compares each element in the image detected by the generative AI model with pre-established display guidelines.

[0100] 5. "Means for generating correction instructions based on the display guidelines" refers to the function by which the server generates appropriate correction instructions for parts that differ from the display guidelines.

[0101] 6. "Means for sending generated correction instructions to the user terminal" refers to the function by which the server sends the created correction instructions to the user terminal.

[0102] The present invention relates to a system for efficiently performing creative checks on images. A specific embodiment of this system will be described below.

[0103] The system of the present invention is mainly composed of operations of a server, a terminal, and a user.

[0104] Server-side processing

[0105] 1. Registration of display guidelines

[0106] The server registers display guidelines in a database via an API. These guidelines include the placement of elements in images, color contrast ratios, and the position of brand logos. This process is performed using database software such as MySQL or PostgreSQL.

[0107] 2. Receiving and saving images

[0108] When a user uploads an image from a terminal, the server receives the image data. It receives an HTTP POST request and saves the image data in a temporary storage area (e.g., the / tmp directory). This process uses the HTTP protocol and web server software such as Apache or Nginx.

[0109] 3. Image Analysis

[0110] The server reads the image data from the temporary storage area and inputs it into the generative AI model, which uses machine learning frameworks such as TensorFlow and PyTorch. Image analysis compares the image with display guidelines to check whether it complies with the guidelines.

[0111] 4. Comparison with display guidelines

[0112] The server compares the elements detected by the generative AI model with the display guidelines using a scripting language such as Python, determining whether each element complies and listing any violations.

[0113] 5. Generate correction instructions

[0114] The server generates textual correction instructions for any deviations from the display guidelines. For example, it might say, "The brand logo is not positioned in the top left corner." It also generates a visual representation of the corrections. This process uses image processing libraries such as Pillow and OpenCV.

[0115] 6. Sending correction instructions

[0116] The generated correction instructions are sent to the user's device in text and visual formats using the HTTP and WebSocket communication protocols.

[0117] Explanation of terminal processing

[0118] 1. Select and upload an image

[0119] The user selects the image they want to check using a file selection dialog on their device, and the selected image is uploaded to the server via a dedicated interface (e.g., a web form or a dedicated application) using HTML, JavaScript, and CSS.

[0120] 2. Receiving correction instructions

[0121] The device receives correction instructions sent from the server, which are displayed in textual and visual formats using AJAX (Asynchronous JavaScript and XML) and Fetch API technologies.

[0122] 3. Correction work

[0123] The user follows the correction instructions received on the device and edits the image using image editing software (e.g., Adobe Photoshop, GIMP), and then uploads the edited image back to the server using a dedicated interface.

[0124] Specific examples

[0125] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines stipulate that "the brand logo should be placed in the upper left," "the text font size should be 12pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0126] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0127] "The brand logo is centered. Please place it in the top left."

[0128] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0129] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0130] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0131] A concrete example of a prompt to be input to a generative AI model would be something like this:

[0132] "Compare the placement of your brand logo, the font size of your text, and the contrast ratio of your primary colors within your uploaded image to our display guidelines."

[0133] The above is a specific embodiment of the present invention. This system enables efficient and accurate creative check of images, and reduces the workload of the user.

[0134] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0135] Step 1:

[0136] Display guidelines registration

[0137] The server registers the display guidelines in the database through the API. It receives the display guidelines set by the user (for example, the position of the brand logo, the font size of the text, the color contrast ratio, etc.) as JSON format data. It stores this data using database software such as MySQL or PostgreSQL. It receives the JSON data as input and inserts it into the database table. The output is a confirmation message indicating that the display guidelines have been successfully registered in the database.

[0138] Step 2:

[0139] Select and upload an image

[0140] The user selects the image they want to check from their device and uploads it to the server via a dedicated interface. This operation uses a file selection dialog or a web form. The image file selected by the user is given as input, and an HTTP POST request is sent to the server as output. This transfers the image data to the server.

[0141] Step 3:

[0142] Receiving and saving images

[0143] The server receives the image data sent from the terminal. It saves the received image data in a temporary storage area (e.g., the / tmp directory). The input is the image file included in the data portion of the HTTP POST request, and the output is the image file saved in the temporary storage area.

[0144] Step 4:

[0145] Image analysis

[0146] The server reads the image data from the temporary storage area and inputs it into the generative AI model. The generative AI model uses machine learning frameworks such as TensorFlow and PyTorch. The generative AI model performs analysis by entering the following prompt: "Compare the placement of the brand logo, the font size of the text, and the contrast ratio of the primary colors in the uploaded image with the display guidelines." The input is the image file stored in the temporary storage area, and the output is the analysis result provided by the generative AI model. The analysis result includes detection information for each element in the image (brand logo, text, color, etc.).

[0147] Step 5:

[0148] Comparison with display guidelines

[0149] The server compares the results of the analysis by the generative AI model with the display guidelines. This comparison is performed using a scripting language such as Python. The input is information about each element in the analyzed image and the display guidelines that have been registered in advance in a database. The output is a list of areas that comply with the display guidelines and areas that do not comply with them.

[0150] Step 6:

[0151] Generate correction instructions

[0152] The server generates correction instructions for any deviations from the display guidelines. For example, textual instructions such as "The brand logo is not positioned in the upper left corner" are created. It also generates a visual representation of the corrections. The input is the result of the comparison with the display guidelines, and the output is textual and visual correction instructions. Image processing libraries such as Pillow and OpenCV are used in this process.

[0153] Step 7:

[0154] Sending correction instructions

[0155] The generated correction instructions are sent from the server to the user's device. The correction instructions are sent using HTTP or WebSocket protocol. The input is the generated correction instructions (in textual and visual formats), and the output is the correction instructions displayed on the user's device.

[0156] Step 8:

[0157] Receiving correction instructions

[0158] The user's terminal receives the correction instructions sent from the server. The correction instructions are displayed in text and visual form for the user to confirm. The input is the correction instruction data sent from the server, and the output is the correction instructions displayed on the screen.

[0159] Step 9:

[0160] Image correction

[0161] The user follows the received correction instructions and corrects the image using image editing software (e.g., Adobe Photoshop, GIMP). The input is the correction instructions displayed on the screen, and the output is the corrected image file.

[0162] Step 10:

[0163] Re-upload for recheck

[0164] The user uploads the image with the corrections completed to the server again. The input is the corrected image file, and the output is an HTTP POST request sent to the server. This executes the process from step 3 onwards again, and the corrections are rechecked.

[0165] (Application example 1)

[0166] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0167] When creating advertising banners and images, there is a lack of efficient ways to check whether they comply with display guidelines. This means that if display elements such as the position of the brand logo, the size of the text font, and the color contrast ratio are not accurate, a lot of time and effort must be spent. A system that solves this problem and reduces the workload of creative checks is needed.

[0168] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0169] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for displaying the correction instructions in text and visual format on the user terminal, and means for the user terminal to correct the images based on the correction instructions. This allows for efficient checking of whether advertising banners and images comply with the display guidelines, enabling rapid and accurate correction.

[0170] The "means for receiving images" is a mechanism by which the server receives image data uploaded from a user terminal.

[0171] A "generative AI model" is an artificial intelligence model that analyzes uploaded images and detects and evaluates various elements based on display guidelines.

[0172] The "means of analysis" is a mechanism that uses a generative AI model to analyze and evaluate each element of the received image based on display guidelines.

[0173] The "means for generating correction instructions" is a mechanism that determines the areas of the image that need to be corrected and the specific content of those corrections based on the analysis results, and creates instructions.

[0174] The "means for transmitting a correction instruction to a user terminal" is a mechanism for transmitting the generated correction instruction to a terminal used by a user.

[0175] The "means for displaying the correction instructions in text and visual form on the user terminal" is a mechanism for displaying the received correction instructions in text and visual (illustrated) form on the user terminal.

[0176] "Means for the user terminal to modify an image based on modification instructions" refers to a function for editing and modifying an image based on modification instructions on the user terminal.

[0177] The "means for registering display guidelines in advance in a database" is a mechanism for registering guidelines to be used as display standards for advertising images and the like in a database in advance.

[0178] The present invention provides a system for efficiently checking whether advertising banners and other images comply with display guidelines. The system includes a server, a user terminal, and a generative AI model.

[0179] Server-side processing

[0180] Display guidelines registration

[0181] The server has the ability to pre-register display guidelines in a database, including the placement of elements in an image, color contrast ratio, brand logo position, etc. This ensures that images uploaded by users are evaluated according to specific standards.

[0182] Receiving and saving images

[0183] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0184] Image analysis

[0185] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0186] Generate correction instructions

[0187] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[0188] Sending correction instructions

[0189] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[0190] Terminal side processing

[0191] Select and upload an image

[0192] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0193] Receive and display correction instructions

[0194] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[0195] Corrective work

[0196] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0197] As a concrete example of this system, consider the case where a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results show that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[0198] "The brand logo is centered. Please place it in the top left."

[0199] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0200] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0201] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0202] Examples of prompts to input to a generative AI model include:

[0203] Please review user-uploaded ad banner images and analyze them based on the following display guidelines:

[0204] The brand logo is placed in the upper left

[0205] Text font size must be 12pt or larger

[0206] Contrast ratio of 4.5:1 or higher for primary colors

[0207] Please output the analysis results and specific correction instructions based on them in text format.

[0208] In this way, the system of the present invention enables efficient creative checks of advertising banners and images, and provides a means for reducing the workload of the user.

[0209] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0210] Step 1: Select and upload an image

[0211] Users select the images they want to check from their own devices, which can include advertising banners, etc. The selected images are then uploaded to the server via a dedicated interface.

[0212] Input: An image file selected by the user.

[0213] Output: Image data transferred to the server

[0214] Step 2: Receive and save the image

[0215] The server receives the image data uploaded from the device and stores the image data in a temporary storage area until the analysis is complete.

[0216] Input: Image data transferred from the terminal

[0217] Output: Image data stored in the temporary storage area of ​​the server

[0218] Step 3: Analyze the images

[0219] The server reads the image data from the temporary storage area and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image (e.g., brand logo, text font size, color contrast ratio, etc.) and compares it with display guidelines.

[0220] Input: Image data saved in the temporary storage area

[0221] Output: Image elements and their conformance to display guidelines

[0222] Step 4: Generate correction instructions

[0223] The server generates correction instructions based on the analysis results obtained from the generative AI model. Specifically, it detects any discrepancies with the display guidelines and creates text-based correction comments for those discrepancies. It also generates illustrated correction guides to make the corrections easier to understand visually.

[0224] Input: Elements in the image and the results of matching the display guidelines

[0225] Output: Textual revision comments and graphical revision guide

[0226] Step 5: Send correction instructions

[0227] The server transmits the generated correction instruction to the user's terminal, whereby the user receives the correction instruction.

[0228] Input: Correction comments and correction guide

[0229] Output: Correction instructions sent to the user's terminal

[0230] Step 6: Receive and display correction instructions

[0231] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to clearly understand the corrections that need to be made.

[0232] Input: Correction instructions sent from the server

[0233] Output: Text and visual correction instructions displayed on the user's terminal

[0234] Step 7: Image Correction

[0235] The user follows the instructions displayed on the device to edit the image, and once the edits are complete, the image is uploaded back to the server.

[0236] Input: User-modified image file

[0237] Output: Corrected image data sent to the server

[0238] Step 8: Request a recheck

[0239] Once the image is uploaded and corrected, it is re-checked through the same process, allowing you to check and correct it as many times as necessary until the image perfectly complies with the display guidelines.

[0240] Input: Corrected image data

[0241] Output: Final image conforming to display guidelines

[0242] By following the above steps, you can efficiently check whether advertising banners and images comply with display guidelines and make quick and accurate corrections.

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

[0244] This invention is a system for improving the efficiency of creative image checks, and in particular improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[0245] Server-side processing

[0246] Display guidelines registration

[0247] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[0248] Receiving and saving images

[0249] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0250] Image analysis

[0251] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0252] Utilizing the Emotion Engine

[0253] The server uses an emotion engine to analyze the user's emotional state, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[0254] Generate and adjust correction instructions

[0255] Based on the analysis results, the server generates correction instructions. The generated correction instructions specifically indicate the areas that differ from the display guidelines. For example, a text instruction such as "The brand logo is not positioned in the upper left corner" is generated. In addition, a diagrammatic correction guide is generated to make the corrections easier to understand visually.

[0256] Emotional regulation of corrective instructions

[0257] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction prompts. For example, if the user is stressed, the system generates concise, encouraging correction prompts.

[0258] Sending correction instructions

[0259] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[0260] Terminal side processing

[0261] Select and upload an image

[0262] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0263] Receiving correction instructions

[0264] The user's device receives the correction instructions sent from the server. The received correction instructions are displayed in text and visual formats. Furthermore, the tone of the instructions is adjusted according to the user's emotional state.

[0265] Corrective work

[0266] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0267] Specific examples

[0268] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0269] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0270] "The brand logo is centered. Please place it in the top left."

[0271] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0272] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0273] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts may be adjusted, e.g., to:

[0274] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[0275] "Try increasing the font size of the text to 12pt or larger for better readability."

[0276] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[0277] The user receives these correction instructions, corrects the image accordingly, and then uploads the corrected banner back to the server, where it is rechecked using the same process.

[0278] As described above, the system of the present invention reduces the workload of the user by efficiently performing creative checks while taking the user's feelings into consideration.

[0279] The processing flow will be explained below.

[0280] Step 1: Register display guidelines

[0281] The server receives display guideline data provided by an administrator.

[0282] The server stores the received guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[0283] Step 2: Select and upload an image

[0284] The user selects the image they want to check on their device.

[0285] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[0286] Step 3: Receive and save the image

[0287] The server receives the image data sent from the user's terminal.

[0288] The server stores the received image data in a temporary storage area until the analysis is complete.

[0289] Step 4: Image analysis

[0290] The server reads the image data from the temporary storage area.

[0291] The server inputs the image data into the generative AI model and begins analysis.

[0292] The generative AI model detects each element in the image and compares it to display guidelines.

[0293] Step 5: Detect discrepancies and generate correction instructions

[0294] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[0295] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[0296] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[0297] Step 6: Leverage your emotional engine

[0298] The server uses an emotion engine to analyze the user's emotional state, which is acquired from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[0299] Based on the analysis results of the emotion engine, the server determines whether the user is feeling stressed or relaxed.

[0300] Step 7: Emotional Regulation of Corrective Instructions

[0301] The server adjusts the tone and format of the correction instructions based on the user's emotional state analyzed by the emotion engine.

[0302] For example, if the user is feeling stressed, generate a brief, encouraging tone of correction instruction, such as, "Good job! Your design would be more effective if you placed your brand logo in the upper left corner."

[0303] Step 8: Send correction instructions

[0304] The server assembles the generated correction comments and the emotion-adjusted illustrations into a single package.

[0305] The server sends a package of correction instructions to the user's terminal.

[0306] Step 9: Receiving and confirming correction instructions

[0307] The user's terminal receives the correction instructions sent from the server.

[0308] Users see correction instructions and understand text comments and illustrations. Emotionally attuned instructions allow users to receive the information they need in a familiar format.

[0309] Step 10: Corrective action

[0310] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[0311] Step 11: Re-upload the corrected image

[0312] The user then performs an operation to upload the corrected image back to the server.

[0313] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[0314] Through the above steps, the system of the present invention realizes efficient creative checks that take into account the user's emotions, thereby reducing the user's workload.

[0315] Example 2

[0316] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0317] In conventional image creative check systems, users often felt stressed and pressured because they only received one-way instructions on how to correct images. Furthermore, they lacked the functionality to automatically check compliance with display guidelines and provide specific, visual correction instructions. This increased the user's workload and reduced efficiency. Furthermore, the mechanical correction instructions, which did not take the user's emotional state into consideration, could lead to a decrease in motivation and misunderstandings. To solve these issues, a system was needed that could analyze the user's emotional state and flexibly adjust the tone and format of feedback.

[0318] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0319] In this invention, the server includes means for receiving an image, means for applying a generative AI model to analyze the received image based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for analyzing the user's emotional state and using an emotion engine to adjust the tone and format of the correction instructions, and means for correcting the image based on the correction instructions received by the user and re-uploading it. This enables friendly feedback that takes the user's emotional state into consideration, makes the correction process more efficient, and reduces the user's workload.

[0320] The "means for receiving images" refers to a method or device for capturing image data sent from a user into the server.

[0321] A "generative AI model" is a program or algorithm that uses machine learning and artificial intelligence techniques to analyze elements within an image and evaluate whether they comply with display guidelines.

[0322] "Display guidelines" are instructions or regulations that set out specific standards and rules, such as the placement of elements within an image, color contrast, and the positioning of brand logos.

[0323] "Analysis results" refers to the data and information obtained when the generative AI model analyzes an image, including compliance with display guidelines and any violations.

[0324] The "correction instructions" are specific instructions that are created based on the analysis results and indicate how the image should be corrected.

[0325] An "emotion engine" is software or algorithms that analyze a user's emotional state and adjust the tone and format of correction instructions.

[0326] A "user terminal" is a device used by a user, such as a computer or smartphone, that communicates with a server to upload images and receive correction instructions.

[0327] The "means for correcting an image and re-uploading it" refers to a method or device that allows a user to correct an image based on correction instructions and then transmit the corrected image to the server again.

[0328] The "means for displaying in textual and visual form" refers to a method or device for displaying the received correction instructions to the user in a visually easy-to-understand format.

[0329] This invention is a system for improving the efficiency of creative image checks, and in particular, improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[0330] Server-side configuration

[0331] Display guidelines registration

[0332] The server has a function to register display guidelines in advance in a database. This registration includes the layout of elements within the image, color contrast ratio, and the position of the brand logo. The database used is a relational database such as MySQL or PostgreSQL.

[0333] Receiving and saving images

[0334] When a user uploads an image from their device, the server receives the image data. The received image is then stored in a temporary storage area. This temporary storage area can be stored in the server or in cloud storage such as Amazon S3.

[0335] Image analysis

[0336] The server reads the stored image data and inputs it into a generative AI model for analysis. This generative AI model is built using frameworks such as TensorFlow and PyTorch. During analysis, each element in the image is detected and compared with display guidelines.

[0337] Utilizing the Emotion Engine

[0338] The server analyzes the user's emotional state using an emotion engine, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions. The emotion engine uses, for example, Microsoft's Azure Emotion API.

[0339] Generate and adjust correction instructions

[0340] The server generates correction instructions based on the analysis results. For example, text instructions such as "The brand logo is not positioned in the upper left corner" or "The text font size is 10 pt. Please enlarge it to 12 pt or larger" are created. A diagrammatic correction guide is also generated to make the corrections easier to understand visually.

[0341] Emotional regulation of corrective instructions

[0342] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction instructions. For example, if the user is feeling stressed, the system generates correction instructions in a concise and encouraging tone, such as, "Good job. If you place your brand logo in the upper left corner, the design will be more effective."

[0343] Sending correction instructions

[0344] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[0345] Terminal configuration

[0346] Select and upload an image

[0347] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface, using the file upload function via the HTTP protocol.

[0348] Receive and display correction instructions

[0349] The user's device receives the correction instructions sent from the server and displays them in text and visual form, with the tone of the instructions adjusted to suit the user's emotional state.

[0350] Image correction

[0351] The user then follows the instructions received on the device to edit the image. After editing, the user can upload the image back to the server and request a recheck. This re-upload also uses the HTTP protocol, just like the initial upload.

[0352] Specific examples

[0353] For example, suppose a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results indicate that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[0354] "The brand logo is centered. Please place it in the top left."

[0355] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0356] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0357] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts will be adjusted and changed to:

[0358] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[0359] "Try increasing the font size of the text to 12pt or larger for better readability."

[0360] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[0361] The user receives these correction instructions and corrects the image accordingly. The corrected banner is then uploaded back to the server and rechecked using the same process. As described above, the system of this invention reduces the user's workload by efficiently checking the creative work while taking the user's feelings into consideration.

[0362] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0363] Step 1: Register display guidelines

[0364] The server registers the display guidelines provided by the administrator in a database. These guidelines include the placement of image elements, color contrast ratio, and the position of the brand logo. The input is the guideline data provided by the administrator, and the output is the guideline information stored in the database. Specifically, the server converts the guidelines received from the administrator into JSON format and saves them in a relational database such as MySQL or PostgreSQL using an INSERT statement.

[0365] Step 2: Select and upload an image

[0366] The user selects the image they want to check from their device and uploads it to the server through a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. Specific operations include the user selecting an image using a file selection dialog and clicking the "Upload" button. This operation sends the file to the server via the HTTP protocol.

[0367] Step 3: Receive and save the image

[0368] The server receives images sent by the user and stores them in a temporary storage area. The input is the image data sent by the user, and the output is an image file stored in the temporary storage area. Specifically, the server receives the uploaded file and stores it in a specified directory (for example, the "uploads" directory). At this time, a unique identifier is added to the file name.

[0369] Step 4: Image analysis

[0370] The server inputs the saved image data into a generative AI model for analysis. The input is the saved image file, and the output is the analysis result data. Specifically, the server reads the image file and inputs it into a generative AI model based on TensorFlow or PyTorch. This model detects elements within the image and generates data such as the element's position and size. The analysis results are compared with the display guidelines mentioned above.

[0371] Step 5: Leverage the Emotion Engine

[0372] The server uses an emotion engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is data indicating the user's emotional state. Specifically, the server acquires facial expression images and voice data sent from the user's device and sends this to an emotion analysis API (for example, Azure Emotion API). The API performs the analysis and returns the user's emotional state, such as "stress" or "joy," in JSON format.

[0373] Step 6: Generate and adjust correction instructions

[0374] The server generates correction instructions based on the analysis results. The input is the image analysis results data and emotion analysis results data, and the output is adjusted correction instructions. Specifically, the server points out in text form any violations of the display guidelines based on the analysis results of the generated AI model. At this time, the instructions are adjusted in tone based on the results of the emotion engine, depending on the user's emotional state. For example, the tone could be something like, "Thank you for your hard work. Placing the brand logo in the upper left corner would make for a more effective design."

[0375] Step 7: Send correction instructions

[0376] The generated correction instructions are sent to the user's device after emotion adjustment. The input is the adjusted correction instructions, and the output is the correction instructions sent to the user's device. Specifically, the server sends the correction instructions to the user's device using an HTTP request. The instructions are displayed in an application or web interface on the user's device.

[0377] Step 8: Receive and display correction instructions

[0378] The user's device receives the modification instructions sent from the server and displays them in text and visual form. The input is the modification instructions from the server, and the output is the modification instructions displayed on the user's device. Specifically, the user's device receives the HTTP response and displays the instructions to the user via an application or web interface. This display is provided in a visually easy-to-understand form.

[0379] Step 9: Image Correction

[0380] The user edits the image according to the editing instructions received on the terminal. The input is the editing instructions, and the output is the edited image file. Specifically, the user uses image editing software to edit the image as instructed. After editing is complete, the user uploads the image to the server again and requests a recheck. This re-upload is also done via the HTTP protocol, just like the first time.

[0381] (Application example 2)

[0382] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0383] In conventional image creative check systems, the feedback users receive is uniform and does not take into account the user's emotional state, which can cause stress for the user. Also, correction instructions are only in text format, which can make it difficult to understand visually and emotionally.

[0384] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0385] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, and means for generating correction instructions based on the analysis results, thereby enabling efficient creative checks of images that take into account the emotional state of the user.

[0386] The server further includes means for recognizing the user's emotion using an emotion analysis engine, means for adjusting the tone of the correction instruction based on the emotion, and means for conveying the correction instruction to the user by voice, thereby enabling the user to receive friendly feedback according to his or her emotional state and obtain correction instructions that are easy to understand visually and audibly.

[0387] The "means for receiving images" is a function for importing image data sent from a user into the server.

[0388] "Means for applying a generative AI model" refers to the ability to apply an artificial intelligence model used to analyze received images and evaluate their conformance to display guidelines.

[0389] The "means for generating correction instructions" is a function that identifies the areas of an image that need to be corrected based on the analysis results of the generative AI model and creates specific instructions for those areas.

[0390] The "means for transmitting to the user terminal" is a function for transmitting the created correction instructions to the terminal used by the user.

[0391] "Means for recognizing a user's emotions using an emotion analysis engine" is a function for analyzing a user's emotions from voice and facial expression data and recognizing their emotional state.

[0392] The "means for adjusting the tone of correction instructions based on emotion" is a function for adjusting the wording and tone of correction instructions based on the recognized emotional state of the user.

[0393] The "means for audibly informing the user of the correction instructions" is a function for audibly explaining the created correction instructions to the user.

[0394] The present invention is a system that improves the efficiency of image creative checks by combining an emotion engine that recognizes user emotions. This system operates through cooperation between a server and a user terminal, and processing is carried out in the following manner.

[0395] Server-side processing

[0396] The server first receives the image. The image data uploaded by the user from their device is temporarily stored on the server. Next, a generative AI model is applied to analyze the received image based on display guidelines. This model detects elements within the image and compares them with the display guidelines. In doing so, it checks the placement of elements within the image, color contrast ratio, and brand logo position.

[0397] Once the analysis by the generative AI model is complete, the server generates correction instructions based on the analysis results. The correction instructions are written in text format and indicate the specific areas to be corrected. The server also analyzes the user's emotional state using an emotion analysis engine. The emotion analysis engine recognizes emotions using the user's facial expressions and voice data at the time of uploading and sending correction instructions.

[0398] The system then adjusts the tone of the correction instructions based on the user's emotion. For example, if the user is feeling stressed, the system softens the tone of the instructions. It also generates a voice guide to convey the correction instructions to the user. The server then transmits the final, adjusted correction instructions to the user's terminal.

[0399] Terminal side processing

[0400] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server. The user's device receives and displays the correction instructions sent from the server. The correction instructions are provided in text and audio format, with the tone adjusted to match the user's emotional state, allowing the user to receive the instructions without stress.

[0401] The user then follows the instructions to edit the image. Once the edits are complete, the image can be uploaded back to the server for rechecking. This allows the editing process to proceed efficiently until the image finally complies with the display guidelines.

[0402] Specific examples

[0403] When a user creates an advertising banner and uploads it to the system, the server uses a generative AI model to analyze the image. Based on the display guidelines, non-compliances are detected, such as "the brand logo must be centered," "the text font size must be 10pt," and "the contrast ratio of the primary color must be 3.0:1." Based on this, the server generates correction instructions such as:

[0404] "The brand logo is centered. Please place it in the top left."

[0405] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0406] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0407] Additionally, if the sentiment analysis engine determines that the user is stressed, the tone of the instructions will be adjusted as follows:

[0408] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[0409] "Try increasing the font size of the text to 12pt or larger for better readability."

[0410] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[0411] In this way, users receive friendly feedback that takes their emotions into consideration, and can efficiently perform creative checks.

[0412] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0413] Step 1:

[0414] Uploading an image

[0415] The user selects the image they want to check from their own device and uploads it to the server via a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. The specific operation of the process is that the user selects the image file on the interface and presses the send button, which sends the image data to the server.

[0416] Step 2:

[0417] Receiving and saving images

[0418] The server receives image data sent from the user's device and saves it in a temporary storage area. The input is the image data sent from the device, and the output is the image data saved in the temporary storage area. Specifically, the server receives an HTTP request, extracts the image data from the payload, and saves it as a file.

[0419] Step 3:

[0420] Image analysis

[0421] The server reads the saved image data and performs image analysis using a generative AI model. The input is the saved image data, and the output is the analyzed image element information (e.g., logo position, font size, contrast ratio). Specifically, the image data is input into the AI ​​model, and the model detects and evaluates various elements.

[0422] Step 4:

[0423] Generate correction instructions based on analysis results

[0424] The server generates correction instructions based on the results of image analysis. The input is the image analysis results, and the output is specific correction instructions in text. Specifically, it performs conditional branching based on the analysis results and generates specific correction instructions in text format for parts that do not comply with the guidelines.

[0425] Step 5:

[0426] Emotion analysis

[0427] The server uses an emotion analysis engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is the analyzed user's emotional state. Specifically, the server collects facial expression and voice data when the user uploads an image or receives correction instructions, and inputs this data into the emotion analysis engine to determine the user's emotional state.

[0428] Step 6:

[0429] Tone adjustment for correction instructions

[0430] The server adjusts the tone of the correction instruction based on the emotional state. The input is the analyzed emotional state and the generated correction instruction text, and the output is the adjusted correction instruction text. Specific operations include changing the phrases and expressions of the correction instruction text depending on the emotional state.

[0431] Step 7:

[0432] Sending correction instructions

[0433] The server sends the adjusted correction instructions to the user terminal. The input is the adjusted correction instruction text, and the output is the correction instructions displayed on the terminal. As a specific operation, a message including the adjusted correction instruction text is sent to the user terminal as an HTTP response.

[0434] Step 8:

[0435] Receive and display correction instructions

[0436] The user device receives the correction instructions sent from the server and presents them to the user in text and audio format. The input is the correction instruction message from the server, and the output is the correction instructions that are displayed and played back to the user. Specifically, the device receives the HTTP response, displays the text instructions on the screen, and plays back the audio instructions using a text-to-speech engine.

[0437] Step 9:

[0438] Image correction

[0439] The user modifies the image according to the modification instructions received on the terminal. The input is the modification instructions and the original image data, and the output is the modified image data. In concrete terms, the user modifies the image based on the instructions using image editing software.

[0440] Step 10:

[0441] Re-uploading the corrected image

[0442] The user uploads the corrected image to the server again and requests a recheck. The input is the corrected image file, and the output is the corrected image data saved on the server again. Specifically, the user uploads the corrected image, and the process from step 1 is repeated.

[0443] 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 a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the 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.

[0444] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0445] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0446] [Second embodiment]

[0447] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0448] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0449] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0451] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0453] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0454] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0455] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[0457] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0458] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. 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."

[0459] The present invention relates to a system for efficiently checking the creativity of images. This system is mainly composed of a server, a terminal, and user operations.

[0460] Server-side processing

[0461] Display guidelines registration

[0462] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[0463] Receiving and saving images

[0464] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0465] Image analysis

[0466] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0467] Generate correction instructions

[0468] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[0469] Sending correction instructions

[0470] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[0471] Terminal side processing

[0472] Select and upload an image

[0473] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0474] Receiving correction instructions

[0475] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[0476] Corrective work

[0477] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0478] Specific examples

[0479] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0480] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0481] "The brand logo is centered. Please place it in the top left."

[0482] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0483] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0484] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0485] As described above, the system of the present invention provides a means for efficiently performing creative checks and reducing the workload of the user.

[0486] The processing flow will be explained below.

[0487] Step 1: Register display guidelines

[0488] The server receives display guideline data provided by an administrator.

[0489] The server stores the received display guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[0490] Step 2: Select and upload an image

[0491] The user selects the image they want to check on their device.

[0492] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[0493] Step 3: Receive and save the image

[0494] The server receives the image data sent from the user's terminal.

[0495] The server stores the received image data in a temporary storage area until the analysis is complete.

[0496] Step 4: Image analysis

[0497] The server reads the image data from the temporary storage area.

[0498] The server inputs the image data into the generative AI model and begins analysis.

[0499] The generative AI model detects each element in the image and compares it to display guidelines.

[0500] Step 5: Detect discrepancies and generate correction instructions

[0501] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[0502] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[0503] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[0504] Step 6: Send correction instructions

[0505] The server collects the generated revision comments and diagrams into a single package.

[0506] The server sends a package of correction instructions to the user's terminal.

[0507] Step 7: Receiving and confirming correction instructions

[0508] The user's terminal receives the correction instructions sent from the server.

[0509] The user reviews the correction instructions and understands the text comments and diagrams.

[0510] Step 8: Corrective action

[0511] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[0512] Step 9: Re-upload the corrected image

[0513] The user then performs an operation to upload the corrected image back to the server.

[0514] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[0515] Through the above steps, the system of the present invention realizes efficient creative checks and reduces the workload of the user.

[0516] Example 1

[0517] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0518] The present invention aims to provide a system that efficiently and accurately performs creative checks on images. Conventional manual image checks are time-consuming, labor-intensive, and prone to errors. In particular, checking images according to guidelines such as the position of brand logos and text, font size, and color contrast ratio requires specialized knowledge and experience. The present invention provides new technical means to solve these problems.

[0519] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0520] In this invention, the server includes means for receiving images, means for storing the received image data in a temporary storage area, means for inputting the image data into a generative AI model for analysis, means for comparing each element in the analyzed image with a display guideline, means for generating correction instructions based on the display guideline, and means for transmitting the generated correction instructions to a user terminal, thereby enabling efficient and accurate creative check of images for users.

[0521] 1. "Means for receiving images" refers to the function that allows the server to receive image data sent by the user from the terminal.

[0522] 2. "Means for storing received image data in a temporary storage area" refers to the function of storing image data received by the server in an area for temporary storage.

[0523] 3. "Means of inputting image data into a generative AI model for analysis" refers to the function of the server reading stored image data into the generative AI model and performing analytical processing.

[0524] 4. "Means for comparing each element in the analyzed image with the display guidelines" refers to the function by which the server compares each element in the image detected by the generative AI model with pre-established display guidelines.

[0525] 5. "Means for generating correction instructions based on the display guidelines" refers to the function by which the server generates appropriate correction instructions for parts that differ from the display guidelines.

[0526] 6. "Means for sending generated correction instructions to the user terminal" refers to the function by which the server sends the created correction instructions to the user terminal.

[0527] The present invention relates to a system for efficiently performing creative checks on images. A specific embodiment of this system will be described below.

[0528] The system of the present invention is mainly composed of operations of a server, a terminal, and a user.

[0529] Server-side processing

[0530] 1. Registration of display guidelines

[0531] The server registers display guidelines in a database via an API. These guidelines include the placement of elements in images, color contrast ratios, and the position of brand logos. This process is performed using database software such as MySQL or PostgreSQL.

[0532] 2. Receiving and saving images

[0533] When a user uploads an image from a terminal, the server receives the image data. It receives an HTTP POST request and saves the image data in a temporary storage area (e.g., the / tmp directory). This process uses the HTTP protocol and web server software such as Apache or Nginx.

[0534] 3. Image Analysis

[0535] The server reads the image data from the temporary storage area and inputs it into the generative AI model, which uses machine learning frameworks such as TensorFlow and PyTorch. Image analysis compares the image with display guidelines to check whether it complies with the guidelines.

[0536] 4. Comparison with display guidelines

[0537] The server compares the elements detected by the generative AI model with the display guidelines using a scripting language such as Python, determining whether each element complies and listing any violations.

[0538] 5. Generate correction instructions

[0539] The server generates textual correction instructions for any deviations from the display guidelines. For example, it might say, "The brand logo is not positioned in the top left corner." It also generates a visual representation of the corrections. This process uses image processing libraries such as Pillow and OpenCV.

[0540] 6. Sending correction instructions

[0541] The generated correction instructions are sent to the user's device in text and visual formats using the HTTP and WebSocket communication protocols.

[0542] Explanation of terminal processing

[0543] 1. Select and upload an image

[0544] The user selects the image they want to check using a file selection dialog on their device, and the selected image is uploaded to the server via a dedicated interface (e.g., a web form or a dedicated application) using HTML, JavaScript, and CSS.

[0545] 2. Receiving correction instructions

[0546] The device receives correction instructions sent from the server, which are displayed in textual and visual formats using AJAX (Asynchronous JavaScript and XML) and Fetch API technologies.

[0547] 3. Correction work

[0548] The user follows the correction instructions received on the device and edits the image using image editing software (e.g., Adobe Photoshop, GIMP), and then uploads the edited image back to the server using a dedicated interface.

[0549] Specific examples

[0550] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines stipulate that "the brand logo should be placed in the upper left," "the text font size should be 12pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0551] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0552] "The brand logo is centered. Please place it in the top left."

[0553] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0554] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0555] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0556] A concrete example of a prompt to be input to a generative AI model would be something like this:

[0557] "Compare the placement of your brand logo, the font size of your text, and the contrast ratio of your primary colors within your uploaded image to our display guidelines."

[0558] The above is a specific embodiment of the present invention. This system enables efficient and accurate creative check of images, and reduces the workload of the user.

[0559] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0560] Step 1:

[0561] Display guidelines registration

[0562] The server registers the display guidelines in the database through the API. It receives the display guidelines set by the user (for example, the position of the brand logo, the font size of the text, the color contrast ratio, etc.) as JSON format data. It stores this data using database software such as MySQL or PostgreSQL. It receives the JSON data as input and inserts it into the database table. The output is a confirmation message indicating that the display guidelines have been successfully registered in the database.

[0563] Step 2:

[0564] Select and upload an image

[0565] The user selects the image they want to check from their device and uploads it to the server via a dedicated interface. This operation uses a file selection dialog or a web form. The image file selected by the user is given as input, and an HTTP POST request is sent to the server as output. This transfers the image data to the server.

[0566] Step 3:

[0567] Receiving and saving images

[0568] The server receives the image data sent from the terminal. It saves the received image data in a temporary storage area (e.g., the / tmp directory). The input is the image file included in the data portion of the HTTP POST request, and the output is the image file saved in the temporary storage area.

[0569] Step 4:

[0570] Image analysis

[0571] The server reads the image data from the temporary storage area and inputs it into the generative AI model. The generative AI model uses machine learning frameworks such as TensorFlow and PyTorch. The generative AI model performs analysis by entering the following prompt: "Compare the placement of the brand logo, the font size of the text, and the contrast ratio of the primary colors in the uploaded image with the display guidelines." The input is the image file stored in the temporary storage area, and the output is the analysis result provided by the generative AI model. The analysis result includes detection information for each element in the image (brand logo, text, color, etc.).

[0572] Step 5:

[0573] Comparison with display guidelines

[0574] The server compares the results of the analysis by the generative AI model with the display guidelines. This comparison is performed using a scripting language such as Python. The input is information about each element in the analyzed image and the display guidelines that have been registered in advance in a database. The output is a list of areas that comply with the display guidelines and areas that do not comply with them.

[0575] Step 6:

[0576] Generate correction instructions

[0577] The server generates correction instructions for any deviations from the display guidelines. For example, textual instructions such as "The brand logo is not positioned in the upper left corner" are created. It also generates a visual representation of the corrections. The input is the result of the comparison with the display guidelines, and the output is textual and visual correction instructions. Image processing libraries such as Pillow and OpenCV are used in this process.

[0578] Step 7:

[0579] Sending correction instructions

[0580] The generated correction instructions are sent from the server to the user's device. The correction instructions are sent using HTTP or WebSocket protocol. The input is the generated correction instructions (in textual and visual formats), and the output is the correction instructions displayed on the user's device.

[0581] Step 8:

[0582] Receiving correction instructions

[0583] The user's terminal receives the correction instructions sent from the server. The correction instructions are displayed in text and visual form for the user to confirm. The input is the correction instruction data sent from the server, and the output is the correction instructions displayed on the screen.

[0584] Step 9:

[0585] Image correction

[0586] The user follows the received correction instructions and corrects the image using image editing software (e.g., Adobe Photoshop, GIMP). The input is the correction instructions displayed on the screen, and the output is the corrected image file.

[0587] Step 10:

[0588] Re-upload for recheck

[0589] The user uploads the image with the corrections completed to the server again. The input is the corrected image file, and the output is an HTTP POST request sent to the server. This executes the process from step 3 onwards again, and the corrections are rechecked.

[0590] (Application example 1)

[0591] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0592] When creating advertising banners and images, there is a lack of efficient ways to check whether they comply with display guidelines. This means that if display elements such as the position of the brand logo, the size of the text font, and the color contrast ratio are not accurate, a lot of time and effort must be spent. A system that solves this problem and reduces the workload of creative checks is needed.

[0593] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0594] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for displaying the correction instructions in text and visual format on the user terminal, and means for the user terminal to correct the images based on the correction instructions. This allows for efficient checking of whether advertising banners and images comply with the display guidelines, enabling rapid and accurate correction.

[0595] The "means for receiving images" is a mechanism by which the server receives image data uploaded from a user terminal.

[0596] A "generative AI model" is an artificial intelligence model that analyzes uploaded images and detects and evaluates various elements based on display guidelines.

[0597] The "means of analysis" is a mechanism that uses a generative AI model to analyze and evaluate each element of the received image based on display guidelines.

[0598] The "means for generating correction instructions" is a mechanism that determines the areas of the image that need to be corrected and the specific content of those corrections based on the analysis results, and creates instructions.

[0599] The "means for transmitting a correction instruction to a user terminal" is a mechanism for transmitting the generated correction instruction to a terminal used by a user.

[0600] The "means for displaying the correction instructions in text and visual form on the user terminal" is a mechanism for displaying the received correction instructions in text and visual (illustrated) form on the user terminal.

[0601] "Means for the user terminal to modify an image based on modification instructions" refers to a function for editing and modifying an image based on modification instructions on the user terminal.

[0602] The "means for registering display guidelines in advance in a database" is a mechanism for registering guidelines to be used as display standards for advertising images and the like in a database in advance.

[0603] The present invention provides a system for efficiently checking whether advertising banners and other images comply with display guidelines. The system includes a server, a user terminal, and a generative AI model.

[0604] Server-side processing

[0605] Display guidelines registration

[0606] The server has the ability to pre-register display guidelines in a database, including the placement of elements in an image, color contrast ratio, brand logo position, etc. This ensures that images uploaded by users are evaluated according to specific standards.

[0607] Receiving and saving images

[0608] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0609] Image analysis

[0610] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0611] Generate correction instructions

[0612] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[0613] Sending correction instructions

[0614] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[0615] Terminal side processing

[0616] Select and upload an image

[0617] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0618] Receive and display correction instructions

[0619] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[0620] Corrective work

[0621] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0622] As a concrete example of this system, consider the case where a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results show that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[0623] "The brand logo is centered. Please place it in the top left."

[0624] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0625] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0626] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0627] Examples of prompts to input to a generative AI model include:

[0628] Please review user-uploaded ad banner images and analyze them based on the following display guidelines:

[0629] The brand logo is placed in the upper left

[0630] Text font size must be 12pt or larger

[0631] Contrast ratio of 4.5:1 or higher for primary colors

[0632] Please output the analysis results and specific correction instructions based on them in text format.

[0633] In this way, the system of the present invention enables efficient creative checks of advertising banners and images, and provides a means for reducing the workload of the user.

[0634] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0635] Step 1: Select and upload an image

[0636] Users select the images they want to check from their own devices, which can include advertising banners, etc. The selected images are then uploaded to the server via a dedicated interface.

[0637] Input: An image file selected by the user.

[0638] Output: Image data transferred to the server

[0639] Step 2: Receive and save the image

[0640] The server receives the image data uploaded from the device and stores the image data in a temporary storage area until the analysis is complete.

[0641] Input: Image data transferred from the terminal

[0642] Output: Image data stored in the temporary storage area of ​​the server

[0643] Step 3: Analyze the images

[0644] The server reads the image data from the temporary storage area and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image (e.g., brand logo, text font size, color contrast ratio, etc.) and compares it with display guidelines.

[0645] Input: Image data saved in the temporary storage area

[0646] Output: Image elements and their conformance to display guidelines

[0647] Step 4: Generate correction instructions

[0648] The server generates correction instructions based on the analysis results obtained from the generative AI model. Specifically, it detects any discrepancies with the display guidelines and creates text-based correction comments for those discrepancies. It also generates illustrated correction guides to make the corrections easier to understand visually.

[0649] Input: Elements in the image and the results of matching the display guidelines

[0650] Output: Textual revision comments and graphical revision guide

[0651] Step 5: Send correction instructions

[0652] The server transmits the generated correction instruction to the user's terminal, whereby the user receives the correction instruction.

[0653] Input: Correction comments and correction guide

[0654] Output: Correction instructions sent to the user's terminal

[0655] Step 6: Receive and display correction instructions

[0656] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to clearly understand the corrections that need to be made.

[0657] Input: Correction instructions sent from the server

[0658] Output: Text and visual correction instructions displayed on the user's terminal

[0659] Step 7: Image Correction

[0660] The user follows the instructions displayed on the device to edit the image, and once the edits are complete, the image is uploaded back to the server.

[0661] Input: User-modified image file

[0662] Output: Corrected image data sent to the server

[0663] Step 8: Request a recheck

[0664] Once the image is uploaded and corrected, it is re-checked through the same process, allowing you to check and correct it as many times as necessary until the image perfectly complies with the display guidelines.

[0665] Input: Corrected image data

[0666] Output: Final image conforming to display guidelines

[0667] By following the above steps, you can efficiently check whether advertising banners and images comply with display guidelines and make quick and accurate corrections.

[0668] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0669] This invention is a system for improving the efficiency of creative image checks, and in particular improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[0670] Server-side processing

[0671] Display guidelines registration

[0672] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[0673] Receiving and saving images

[0674] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0675] Image analysis

[0676] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0677] Utilizing the Emotion Engine

[0678] The server uses an emotion engine to analyze the user's emotional state, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[0679] Generate and adjust correction instructions

[0680] Based on the analysis results, the server generates correction instructions. The generated correction instructions specifically indicate the areas that differ from the display guidelines. For example, a text instruction such as "The brand logo is not positioned in the upper left corner" is generated. In addition, a diagrammatic correction guide is generated to make the corrections easier to understand visually.

[0681] Emotional regulation of corrective instructions

[0682] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction prompts. For example, if the user is stressed, the system generates concise, encouraging correction prompts.

[0683] Sending correction instructions

[0684] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[0685] Terminal side processing

[0686] Select and upload an image

[0687] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0688] Receiving correction instructions

[0689] The user's device receives the correction instructions sent from the server. The received correction instructions are displayed in text and visual formats. Furthermore, the tone of the instructions is adjusted according to the user's emotional state.

[0690] Corrective work

[0691] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0692] Specific examples

[0693] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0694] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0695] "The brand logo is centered. Please place it in the top left."

[0696] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0697] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0698] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts may be adjusted, e.g., to:

[0699] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[0700] "Try increasing the font size of the text to 12pt or larger for better readability."

[0701] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[0702] The user receives these correction instructions, corrects the image accordingly, and then uploads the corrected banner back to the server, where it is rechecked using the same process.

[0703] As described above, the system of the present invention reduces the workload of the user by efficiently performing creative checks while taking the user's feelings into consideration.

[0704] The processing flow will be explained below.

[0705] Step 1: Register display guidelines

[0706] The server receives display guideline data provided by an administrator.

[0707] The server stores the received guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[0708] Step 2: Select and upload an image

[0709] The user selects the image they want to check on their device.

[0710] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[0711] Step 3: Receive and save the image

[0712] The server receives the image data sent from the user's terminal.

[0713] The server stores the received image data in a temporary storage area until the analysis is complete.

[0714] Step 4: Image analysis

[0715] The server reads the image data from the temporary storage area.

[0716] The server inputs the image data into the generative AI model and begins analysis.

[0717] The generative AI model detects each element in the image and compares it to display guidelines.

[0718] Step 5: Detect discrepancies and generate correction instructions

[0719] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[0720] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[0721] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[0722] Step 6: Leverage your emotional engine

[0723] The server uses an emotion engine to analyze the user's emotional state, which is acquired from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[0724] Based on the analysis results of the emotion engine, the server determines whether the user is feeling stressed or relaxed.

[0725] Step 7: Emotional Regulation of Corrective Instructions

[0726] The server adjusts the tone and format of the correction instructions based on the user's emotional state analyzed by the emotion engine.

[0727] For example, if the user is feeling stressed, generate a brief, encouraging tone of correction instruction, such as, "Good job! Your design would be more effective if you placed your brand logo in the upper left corner."

[0728] Step 8: Send correction instructions

[0729] The server assembles the generated correction comments and the emotion-adjusted illustrations into a single package.

[0730] The server sends a package of correction instructions to the user's terminal.

[0731] Step 9: Receiving and confirming correction instructions

[0732] The user's terminal receives the correction instructions sent from the server.

[0733] Users see correction instructions and understand text comments and illustrations. Emotionally attuned instructions allow users to receive the information they need in a familiar format.

[0734] Step 10: Corrective action

[0735] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[0736] Step 11: Re-upload the corrected image

[0737] The user then performs an operation to upload the corrected image back to the server.

[0738] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[0739] Through the above steps, the system of the present invention realizes efficient creative checks that take into account the user's emotions, thereby reducing the user's workload.

[0740] Example 2

[0741] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0742] In conventional image creative check systems, users often felt stressed and pressured because they only received one-way instructions on how to correct images. Furthermore, they lacked the functionality to automatically check compliance with display guidelines and provide specific, visual correction instructions. This increased the user's workload and reduced efficiency. Furthermore, the mechanical correction instructions, which did not take the user's emotional state into consideration, could lead to a decrease in motivation and misunderstandings. To solve these issues, a system was needed that could analyze the user's emotional state and flexibly adjust the tone and format of feedback.

[0743] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0744] In this invention, the server includes means for receiving an image, means for applying a generative AI model to analyze the received image based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for analyzing the user's emotional state and using an emotion engine to adjust the tone and format of the correction instructions, and means for correcting the image based on the correction instructions received by the user and re-uploading it. This enables friendly feedback that takes the user's emotional state into consideration, makes the correction process more efficient, and reduces the user's workload.

[0745] The "means for receiving images" refers to a method or device for capturing image data sent from a user into the server.

[0746] A "generative AI model" is a program or algorithm that uses machine learning and artificial intelligence techniques to analyze elements within an image and evaluate whether they comply with display guidelines.

[0747] "Display guidelines" are instructions or regulations that set out specific standards and rules, such as the placement of elements within an image, color contrast, and the positioning of brand logos.

[0748] "Analysis results" refers to the data and information obtained when the generative AI model analyzes an image, including compliance with display guidelines and any violations.

[0749] The "correction instructions" are specific instructions that are created based on the analysis results and indicate how the image should be corrected.

[0750] An "emotion engine" is software or algorithms that analyze a user's emotional state and adjust the tone and format of correction instructions.

[0751] A "user terminal" is a device used by a user, such as a computer or smartphone, that communicates with a server to upload images and receive correction instructions.

[0752] The "means for correcting an image and re-uploading it" refers to a method or device that allows a user to correct an image based on correction instructions and then transmit the corrected image to the server again.

[0753] The "means for displaying in textual and visual form" refers to a method or device for displaying the received correction instructions to the user in a visually easy-to-understand format.

[0754] This invention is a system for improving the efficiency of creative image checks, and in particular, improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[0755] Server-side configuration

[0756] Display guidelines registration

[0757] The server has a function to register display guidelines in advance in a database. This registration includes the layout of elements within the image, color contrast ratio, and the position of the brand logo. The database used is a relational database such as MySQL or PostgreSQL.

[0758] Receiving and saving images

[0759] When a user uploads an image from their device, the server receives the image data. The received image is then stored in a temporary storage area. This temporary storage area can be stored in the server or in cloud storage such as Amazon S3.

[0760] Image analysis

[0761] The server reads the stored image data and inputs it into a generative AI model for analysis. This generative AI model is built using frameworks such as TensorFlow and PyTorch. During analysis, each element in the image is detected and compared with display guidelines.

[0762] Utilizing the Emotion Engine

[0763] The server analyzes the user's emotional state using an emotion engine, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions. The emotion engine uses, for example, Microsoft's Azure Emotion API.

[0764] Generate and adjust correction instructions

[0765] The server generates correction instructions based on the analysis results. For example, text instructions such as "The brand logo is not positioned in the upper left corner" or "The text font size is 10 pt. Please enlarge it to 12 pt or larger" are created. A diagrammatic correction guide is also generated to make the corrections easier to understand visually.

[0766] Emotional regulation of corrective instructions

[0767] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction instructions. For example, if the user is feeling stressed, the system generates correction instructions in a concise and encouraging tone, such as, "Good job. If you place your brand logo in the upper left corner, the design will be more effective."

[0768] Sending correction instructions

[0769] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[0770] Terminal configuration

[0771] Select and upload an image

[0772] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface, using the file upload function via the HTTP protocol.

[0773] Receive and display correction instructions

[0774] The user's device receives the correction instructions sent from the server and displays them in text and visual form, with the tone of the instructions adjusted to suit the user's emotional state.

[0775] Image correction

[0776] The user then follows the instructions received on the device to edit the image. After editing, the user can upload the image back to the server and request a recheck. This re-upload also uses the HTTP protocol, just like the initial upload.

[0777] Specific examples

[0778] For example, suppose a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results indicate that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[0779] "The brand logo is centered. Please place it in the top left."

[0780] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0781] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0782] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts will be adjusted and changed to:

[0783] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[0784] "Try increasing the font size of the text to 12pt or larger for better readability."

[0785] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[0786] The user receives these correction instructions and corrects the image accordingly. The corrected banner is then uploaded back to the server and rechecked using the same process. As described above, the system of this invention reduces the user's workload by efficiently checking the creative work while taking the user's feelings into consideration.

[0787] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0788] Step 1: Register display guidelines

[0789] The server registers the display guidelines provided by the administrator in a database. These guidelines include the placement of image elements, color contrast ratio, and the position of the brand logo. The input is the guideline data provided by the administrator, and the output is the guideline information stored in the database. Specifically, the server converts the guidelines received from the administrator into JSON format and saves them in a relational database such as MySQL or PostgreSQL using an INSERT statement.

[0790] Step 2: Select and upload an image

[0791] The user selects the image they want to check from their device and uploads it to the server through a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. Specific operations include the user selecting an image using a file selection dialog and clicking the "Upload" button. This operation sends the file to the server via the HTTP protocol.

[0792] Step 3: Receive and save the image

[0793] The server receives images sent by the user and stores them in a temporary storage area. The input is the image data sent by the user, and the output is an image file stored in the temporary storage area. Specifically, the server receives the uploaded file and stores it in a specified directory (for example, the "uploads" directory). At this time, a unique identifier is added to the file name.

[0794] Step 4: Image analysis

[0795] The server inputs the saved image data into a generative AI model for analysis. The input is the saved image file, and the output is the analysis result data. Specifically, the server reads the image file and inputs it into a generative AI model based on TensorFlow or PyTorch. This model detects elements within the image and generates data such as the element's position and size. The analysis results are compared with the display guidelines mentioned above.

[0796] Step 5: Leverage the Emotion Engine

[0797] The server uses an emotion engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is data indicating the user's emotional state. Specifically, the server acquires facial expression images and voice data sent from the user's device and sends this to an emotion analysis API (for example, Azure Emotion API). The API performs the analysis and returns the user's emotional state, such as "stress" or "joy," in JSON format.

[0798] Step 6: Generate and adjust correction instructions

[0799] The server generates correction instructions based on the analysis results. The input is the image analysis results data and emotion analysis results data, and the output is adjusted correction instructions. Specifically, the server points out in text form any violations of the display guidelines based on the analysis results of the generated AI model. At this time, the instructions are adjusted in tone based on the results of the emotion engine, depending on the user's emotional state. For example, the tone could be something like, "Thank you for your hard work. Placing the brand logo in the upper left corner would make for a more effective design."

[0800] Step 7: Send correction instructions

[0801] The generated correction instructions are sent to the user's device after emotion adjustment. The input is the adjusted correction instructions, and the output is the correction instructions sent to the user's device. Specifically, the server sends the correction instructions to the user's device using an HTTP request. The instructions are displayed in an application or web interface on the user's device.

[0802] Step 8: Receive and display correction instructions

[0803] The user's device receives the modification instructions sent from the server and displays them in text and visual form. The input is the modification instructions from the server, and the output is the modification instructions displayed on the user's device. Specifically, the user's device receives the HTTP response and displays the instructions to the user via an application or web interface. This display is provided in a visually easy-to-understand form.

[0804] Step 9: Image Correction

[0805] The user edits the image according to the editing instructions received on the terminal. The input is the editing instructions, and the output is the edited image file. Specifically, the user uses image editing software to edit the image as instructed. After editing is complete, the user uploads the image to the server again and requests a recheck. This re-upload is also done via the HTTP protocol, just like the first time.

[0806] (Application example 2)

[0807] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0808] In conventional image creative check systems, the feedback users receive is uniform and does not take into account the user's emotional state, which can cause stress for the user. Also, correction instructions are only in text format, which can make it difficult to understand visually and emotionally.

[0809] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0810] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, and means for generating correction instructions based on the analysis results, thereby enabling efficient creative checks of images that take into account the emotional state of the user.

[0811] The server further includes means for recognizing the user's emotion using an emotion analysis engine, means for adjusting the tone of the correction instruction based on the emotion, and means for conveying the correction instruction to the user by voice, thereby enabling the user to receive friendly feedback according to his or her emotional state and obtain correction instructions that are easy to understand visually and audibly.

[0812] The "means for receiving images" is a function for importing image data sent from a user into the server.

[0813] "Means for applying a generative AI model" refers to the ability to apply an artificial intelligence model used to analyze received images and evaluate their conformance to display guidelines.

[0814] The "means for generating correction instructions" is a function that identifies the areas of an image that need to be corrected based on the analysis results of the generative AI model and creates specific instructions for those areas.

[0815] The "means for transmitting to the user terminal" is a function for transmitting the created correction instructions to the terminal used by the user.

[0816] "Means for recognizing a user's emotions using an emotion analysis engine" is a function for analyzing a user's emotions from voice and facial expression data and recognizing their emotional state.

[0817] The "means for adjusting the tone of correction instructions based on emotion" is a function for adjusting the wording and tone of correction instructions based on the recognized emotional state of the user.

[0818] The "means for audibly informing the user of the correction instructions" is a function for audibly explaining the created correction instructions to the user.

[0819] The present invention is a system that improves the efficiency of image creative checks by combining an emotion engine that recognizes user emotions. This system operates through cooperation between a server and a user terminal, and processing is carried out in the following manner.

[0820] Server-side processing

[0821] The server first receives the image. The image data uploaded by the user from their device is temporarily stored on the server. Next, a generative AI model is applied to analyze the received image based on display guidelines. This model detects elements within the image and compares them with the display guidelines. In doing so, it checks the placement of elements within the image, color contrast ratio, and brand logo position.

[0822] Once the analysis by the generative AI model is complete, the server generates correction instructions based on the analysis results. The correction instructions are written in text format and indicate the specific areas to be corrected. The server also analyzes the user's emotional state using an emotion analysis engine. The emotion analysis engine recognizes emotions using the user's facial expressions and voice data at the time of uploading and sending correction instructions.

[0823] The system then adjusts the tone of the correction instructions based on the user's emotion. For example, if the user is feeling stressed, the system softens the tone of the instructions. It also generates a voice guide to convey the correction instructions to the user. The server then transmits the final, adjusted correction instructions to the user's terminal.

[0824] Terminal side processing

[0825] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server. The user's device receives and displays the correction instructions sent from the server. The correction instructions are provided in text and audio format, with the tone adjusted to match the user's emotional state, allowing the user to receive the instructions without stress.

[0826] The user then follows the instructions to edit the image. Once the edits are complete, the image can be uploaded back to the server for rechecking. This allows the editing process to proceed efficiently until the image finally complies with the display guidelines.

[0827] Specific examples

[0828] When a user creates an advertising banner and uploads it to the system, the server uses a generative AI model to analyze the image. Based on the display guidelines, non-compliances are detected, such as "the brand logo must be centered," "the text font size must be 10pt," and "the contrast ratio of the primary color must be 3.0:1." Based on this, the server generates correction instructions such as:

[0829] "The brand logo is centered. Please place it in the top left."

[0830] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0831] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0832] Additionally, if the sentiment analysis engine determines that the user is stressed, the tone of the instructions will be adjusted as follows:

[0833] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[0834] "Try increasing the font size of the text to 12pt or larger for better readability."

[0835] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[0836] In this way, users receive friendly feedback that takes their emotions into consideration, and can efficiently perform creative checks.

[0837] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0838] Step 1:

[0839] Uploading an image

[0840] The user selects the image they want to check from their own device and uploads it to the server via a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. The specific operation of the process is that the user selects the image file on the interface and presses the send button, which sends the image data to the server.

[0841] Step 2:

[0842] Receiving and saving images

[0843] The server receives image data sent from the user's device and saves it in a temporary storage area. The input is the image data sent from the device, and the output is the image data saved in the temporary storage area. Specifically, the server receives an HTTP request, extracts the image data from the payload, and saves it as a file.

[0844] Step 3:

[0845] Image analysis

[0846] The server reads the saved image data and performs image analysis using a generative AI model. The input is the saved image data, and the output is the analyzed image element information (e.g., logo position, font size, contrast ratio). Specifically, the image data is input into the AI ​​model, and the model detects and evaluates various elements.

[0847] Step 4:

[0848] Generate correction instructions based on analysis results

[0849] The server generates correction instructions based on the results of image analysis. The input is the image analysis results, and the output is specific correction instructions in text. Specifically, it performs conditional branching based on the analysis results and generates specific correction instructions in text format for parts that do not comply with the guidelines.

[0850] Step 5:

[0851] Emotion analysis

[0852] The server uses an emotion analysis engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is the analyzed user's emotional state. Specifically, the server collects facial expression and voice data when the user uploads an image or receives correction instructions, and inputs this data into the emotion analysis engine to determine the user's emotional state.

[0853] Step 6:

[0854] Tone adjustment for correction instructions

[0855] The server adjusts the tone of the correction instruction based on the emotional state. The input is the analyzed emotional state and the generated correction instruction text, and the output is the adjusted correction instruction text. Specific operations include changing the phrases and expressions of the correction instruction text depending on the emotional state.

[0856] Step 7:

[0857] Sending correction instructions

[0858] The server sends the adjusted correction instructions to the user terminal. The input is the adjusted correction instruction text, and the output is the correction instructions displayed on the terminal. As a specific operation, a message including the adjusted correction instruction text is sent to the user terminal as an HTTP response.

[0859] Step 8:

[0860] Receive and display correction instructions

[0861] The user device receives the correction instructions sent from the server and presents them to the user in text and audio format. The input is the correction instruction message from the server, and the output is the correction instructions that are displayed and played back to the user. Specifically, the device receives the HTTP response, displays the text instructions on the screen, and plays back the audio instructions using a text-to-speech engine.

[0862] Step 9:

[0863] Image correction

[0864] The user modifies the image according to the modification instructions received on the terminal. The input is the modification instructions and the original image data, and the output is the modified image data. In concrete terms, the user modifies the image based on the instructions using image editing software.

[0865] Step 10:

[0866] Re-uploading the corrected image

[0867] The user uploads the corrected image to the server again and requests a recheck. The input is the corrected image file, and the output is the corrected image data saved on the server again. Specifically, the user uploads the corrected image, and the process from step 1 is repeated.

[0868] 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 a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0869] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0870] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[0871] [Third embodiment]

[0872] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[0873] 5, the data processing system 310 includes the data processing device 12 and a headset type terminal 314. An example of the data processing device 12 is a server.

[0874] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0876] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0878] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0879] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0880] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[0882] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0883] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. 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."

[0884] The present invention relates to a system for efficiently checking the creativity of images. This system is mainly composed of a server, a terminal, and user operations.

[0885] Server-side processing

[0886] Display guidelines registration

[0887] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[0888] Receiving and saving images

[0889] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[0890] Image analysis

[0891] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[0892] Generate correction instructions

[0893] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[0894] Sending correction instructions

[0895] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[0896] Terminal side processing

[0897] Select and upload an image

[0898] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[0899] Receiving correction instructions

[0900] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[0901] Corrective work

[0902] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[0903] Specific examples

[0904] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0905] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0906] "The brand logo is centered. Please place it in the top left."

[0907] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0908] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0909] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0910] As described above, the system of the present invention provides a means for efficiently performing creative checks and reducing the workload of the user.

[0911] The processing flow will be explained below.

[0912] Step 1: Register display guidelines

[0913] The server receives display guideline data provided by an administrator.

[0914] The server stores the received display guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[0915] Step 2: Select and upload an image

[0916] The user selects the image they want to check on their device.

[0917] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[0918] Step 3: Receive and save the image

[0919] The server receives the image data sent from the user's terminal.

[0920] The server stores the received image data in a temporary storage area until the analysis is complete.

[0921] Step 4: Image analysis

[0922] The server reads the image data from the temporary storage area.

[0923] The server inputs the image data into the generative AI model and begins analysis.

[0924] The generative AI model detects each element in the image and compares it to display guidelines.

[0925] Step 5: Detect discrepancies and generate correction instructions

[0926] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[0927] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[0928] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[0929] Step 6: Send correction instructions

[0930] The server collects the generated revision comments and diagrams into a single package.

[0931] The server sends a package of correction instructions to the user's terminal.

[0932] Step 7: Receiving and confirming correction instructions

[0933] The user's terminal receives the correction instructions sent from the server.

[0934] The user reviews the correction instructions and understands the text comments and diagrams.

[0935] Step 8: Corrective action

[0936] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[0937] Step 9: Re-upload the corrected image

[0938] The user then performs an operation to upload the corrected image back to the server.

[0939] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[0940] Through the above steps, the system of the present invention realizes efficient creative checks and reduces the workload of the user.

[0941] Example 1

[0942] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0943] The present invention aims to provide a system that efficiently and accurately performs creative checks on images. Conventional manual image checks are time-consuming, labor-intensive, and prone to errors. In particular, checking images according to guidelines such as the position of brand logos and text, font size, and color contrast ratio requires specialized knowledge and experience. The present invention provides new technical means to solve these problems.

[0944] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0945] In this invention, the server includes means for receiving images, means for storing the received image data in a temporary storage area, means for inputting the image data into a generative AI model for analysis, means for comparing each element in the analyzed image with a display guideline, means for generating correction instructions based on the display guideline, and means for transmitting the generated correction instructions to a user terminal, thereby enabling efficient and accurate creative check of images for users.

[0946] 1. "Means for receiving images" refers to the function that allows the server to receive image data sent by the user from the terminal.

[0947] 2. "Means for storing received image data in a temporary storage area" refers to the function of storing image data received by the server in an area for temporary storage.

[0948] 3. "Means of inputting image data into a generative AI model for analysis" refers to the function of the server reading stored image data into the generative AI model and performing analytical processing.

[0949] 4. "Means for comparing each element in the analyzed image with the display guidelines" refers to the function by which the server compares each element in the image detected by the generative AI model with pre-established display guidelines.

[0950] 5. "Means for generating correction instructions based on the display guidelines" refers to the function by which the server generates appropriate correction instructions for parts that differ from the display guidelines.

[0951] 6. "Means for sending generated correction instructions to the user terminal" refers to the function by which the server sends the created correction instructions to the user terminal.

[0952] The present invention relates to a system for efficiently performing creative checks on images. A specific embodiment of this system will be described below.

[0953] The system of the present invention is mainly composed of operations of a server, a terminal, and a user.

[0954] Server-side processing

[0955] 1. Registration of display guidelines

[0956] The server registers display guidelines in a database via an API. These guidelines include the placement of elements in images, color contrast ratios, and the position of brand logos. This process is performed using database software such as MySQL or PostgreSQL.

[0957] 2. Receiving and saving images

[0958] When a user uploads an image from a terminal, the server receives the image data. It receives an HTTP POST request and saves the image data in a temporary storage area (e.g., the / tmp directory). This process uses the HTTP protocol and web server software such as Apache or Nginx.

[0959] 3. Image Analysis

[0960] The server reads the image data from the temporary storage area and inputs it into the generative AI model, which uses machine learning frameworks such as TensorFlow and PyTorch. Image analysis compares the image with display guidelines to check whether it complies with the guidelines.

[0961] 4. Comparison with display guidelines

[0962] The server compares the elements detected by the generative AI model with the display guidelines using a scripting language such as Python, determining whether each element complies and listing any violations.

[0963] 5. Generate correction instructions

[0964] The server generates textual correction instructions for any deviations from the display guidelines. For example, it might say, "The brand logo is not positioned in the top left corner." It also generates a visual representation of the corrections. This process uses image processing libraries such as Pillow and OpenCV.

[0965] 6. Sending correction instructions

[0966] The generated correction instructions are sent to the user's device in text and visual formats using the HTTP and WebSocket communication protocols.

[0967] Explanation of terminal processing

[0968] 1. Select and upload an image

[0969] The user selects the image they want to check using a file selection dialog on their device, and the selected image is uploaded to the server via a dedicated interface (e.g., a web form or a dedicated application) using HTML, JavaScript, and CSS.

[0970] 2. Receiving correction instructions

[0971] The device receives correction instructions sent from the server, which are displayed in textual and visual formats using AJAX (Asynchronous JavaScript and XML) and Fetch API technologies.

[0972] 3. Correction work

[0973] The user follows the correction instructions received on the device and edits the image using image editing software (e.g., Adobe Photoshop, GIMP), and then uploads the edited image back to the server using a dedicated interface.

[0974] Specific examples

[0975] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines stipulate that "the brand logo should be placed in the upper left," "the text font size should be 12pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[0976] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[0977] "The brand logo is centered. Please place it in the top left."

[0978] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[0979] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[0980] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[0981] A concrete example of a prompt to be input to a generative AI model would be something like this:

[0982] "Compare the placement of your brand logo, the font size of your text, and the contrast ratio of your primary colors within your uploaded image to our display guidelines."

[0983] The above is a specific embodiment of the present invention. This system enables efficient and accurate creative check of images, and reduces the workload of the user.

[0984] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0985] Step 1:

[0986] Display guidelines registration

[0987] The server registers the display guidelines in the database through the API. It receives the display guidelines set by the user (for example, the position of the brand logo, the font size of the text, the color contrast ratio, etc.) as JSON format data. It stores this data using database software such as MySQL or PostgreSQL. It receives the JSON data as input and inserts it into the database table. The output is a confirmation message indicating that the display guidelines have been successfully registered in the database.

[0988] Step 2:

[0989] Select and upload an image

[0990] The user selects the image they want to check from their device and uploads it to the server via a dedicated interface. This operation uses a file selection dialog or a web form. The image file selected by the user is given as input, and an HTTP POST request is sent to the server as output. This transfers the image data to the server.

[0991] Step 3:

[0992] Receiving and saving images

[0993] The server receives the image data sent from the terminal. It saves the received image data in a temporary storage area (e.g., the / tmp directory). The input is the image file included in the data portion of the HTTP POST request, and the output is the image file saved in the temporary storage area.

[0994] Step 4:

[0995] Image analysis

[0996] The server reads the image data from the temporary storage area and inputs it into the generative AI model. The generative AI model uses machine learning frameworks such as TensorFlow and PyTorch. The generative AI model performs analysis by entering the following prompt: "Compare the placement of the brand logo, the font size of the text, and the contrast ratio of the primary colors in the uploaded image with the display guidelines." The input is the image file stored in the temporary storage area, and the output is the analysis result provided by the generative AI model. The analysis result includes detection information for each element in the image (brand logo, text, color, etc.).

[0997] Step 5:

[0998] Comparison with display guidelines

[0999] The server compares the results of the analysis by the generative AI model with the display guidelines. This comparison is performed using a scripting language such as Python. The input is information about each element in the analyzed image and the display guidelines that have been registered in advance in a database. The output is a list of areas that comply with the display guidelines and areas that do not comply with them.

[1000] Step 6:

[1001] Generate correction instructions

[1002] The server generates correction instructions for any deviations from the display guidelines. For example, textual instructions such as "The brand logo is not positioned in the upper left corner" are created. It also generates a visual representation of the corrections. The input is the result of the comparison with the display guidelines, and the output is textual and visual correction instructions. Image processing libraries such as Pillow and OpenCV are used in this process.

[1003] Step 7:

[1004] Sending correction instructions

[1005] The generated correction instructions are sent from the server to the user's device. The correction instructions are sent using HTTP or WebSocket protocol. The input is the generated correction instructions (in textual and visual formats), and the output is the correction instructions displayed on the user's device.

[1006] Step 8:

[1007] Receiving correction instructions

[1008] The user's terminal receives the correction instructions sent from the server. The correction instructions are displayed in text and visual form for the user to confirm. The input is the correction instruction data sent from the server, and the output is the correction instructions displayed on the screen.

[1009] Step 9:

[1010] Image correction

[1011] The user follows the received correction instructions and corrects the image using image editing software (e.g., Adobe Photoshop, GIMP). The input is the correction instructions displayed on the screen, and the output is the corrected image file.

[1012] Step 10:

[1013] Re-upload for recheck

[1014] The user uploads the image with the corrections completed to the server again. The input is the corrected image file, and the output is an HTTP POST request sent to the server. This executes the process from step 3 onwards again, and the corrections are rechecked.

[1015] (Application example 1)

[1016] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1017] When creating advertising banners and images, there is a lack of efficient ways to check whether they comply with display guidelines. This means that if display elements such as the position of the brand logo, the size of the text font, and the color contrast ratio are not accurate, a lot of time and effort must be spent. A system that solves this problem and reduces the workload of creative checks is needed.

[1018] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1019] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for displaying the correction instructions in text and visual format on the user terminal, and means for the user terminal to correct the images based on the correction instructions. This allows for efficient checking of whether advertising banners and images comply with the display guidelines, enabling rapid and accurate correction.

[1020] The "means for receiving images" is a mechanism by which the server receives image data uploaded from a user terminal.

[1021] A "generative AI model" is an artificial intelligence model that analyzes uploaded images and detects and evaluates various elements based on display guidelines.

[1022] The "means of analysis" is a mechanism that uses a generative AI model to analyze and evaluate each element of the received image based on display guidelines.

[1023] The "means for generating correction instructions" is a mechanism that determines the areas of the image that need to be corrected and the specific content of those corrections based on the analysis results, and creates instructions.

[1024] The "means for transmitting a correction instruction to a user terminal" is a mechanism for transmitting the generated correction instruction to a terminal used by a user.

[1025] The "means for displaying the correction instructions in text and visual form on the user terminal" is a mechanism for displaying the received correction instructions in text and visual (illustrated) form on the user terminal.

[1026] "Means for the user terminal to modify an image based on modification instructions" refers to a function for editing and modifying an image based on modification instructions on the user terminal.

[1027] The "means for registering display guidelines in advance in a database" is a mechanism for registering guidelines to be used as display standards for advertising images and the like in a database in advance.

[1028] The present invention provides a system for efficiently checking whether advertising banners and other images comply with display guidelines. The system includes a server, a user terminal, and a generative AI model.

[1029] Server-side processing

[1030] Display guidelines registration

[1031] The server has the ability to pre-register display guidelines in a database, including the placement of elements in an image, color contrast ratio, brand logo position, etc. This ensures that images uploaded by users are evaluated according to specific standards.

[1032] Receiving and saving images

[1033] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[1034] Image analysis

[1035] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[1036] Generate correction instructions

[1037] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[1038] Sending correction instructions

[1039] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[1040] Terminal side processing

[1041] Select and upload an image

[1042] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[1043] Receive and display correction instructions

[1044] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[1045] Corrective work

[1046] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[1047] As a concrete example of this system, consider the case where a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results show that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[1048] "The brand logo is centered. Please place it in the top left."

[1049] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1050] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1051] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[1052] Examples of prompts to input to a generative AI model include:

[1053] Please review user-uploaded ad banner images and analyze them based on the following display guidelines:

[1054] The brand logo is placed in the upper left

[1055] Text font size must be 12pt or larger

[1056] Contrast ratio of 4.5:1 or higher for primary colors

[1057] Please output the analysis results and specific correction instructions based on them in text format.

[1058] In this way, the system of the present invention enables efficient creative checks of advertising banners and images, and provides a means for reducing the workload of the user.

[1059] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1060] Step 1: Select and upload an image

[1061] Users select the images they want to check from their own devices, which can include advertising banners, etc. The selected images are then uploaded to the server via a dedicated interface.

[1062] Input: An image file selected by the user.

[1063] Output: Image data transferred to the server

[1064] Step 2: Receive and save the image

[1065] The server receives the image data uploaded from the device and stores the image data in a temporary storage area until the analysis is complete.

[1066] Input: Image data transferred from the terminal

[1067] Output: Image data stored in the temporary storage area of ​​the server

[1068] Step 3: Analyze the images

[1069] The server reads the image data from the temporary storage area and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image (e.g., brand logo, text font size, color contrast ratio, etc.) and compares it with display guidelines.

[1070] Input: Image data saved in the temporary storage area

[1071] Output: Image elements and their conformance to display guidelines

[1072] Step 4: Generate correction instructions

[1073] The server generates correction instructions based on the analysis results obtained from the generative AI model. Specifically, it detects any discrepancies with the display guidelines and creates text-based correction comments for those discrepancies. It also generates illustrated correction guides to make the corrections easier to understand visually.

[1074] Input: Elements in the image and the results of matching the display guidelines

[1075] Output: Textual revision comments and graphical revision guide

[1076] Step 5: Send correction instructions

[1077] The server transmits the generated correction instruction to the user's terminal, whereby the user receives the correction instruction.

[1078] Input: Correction comments and correction guide

[1079] Output: Correction instructions sent to the user's terminal

[1080] Step 6: Receive and display correction instructions

[1081] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to clearly understand the corrections that need to be made.

[1082] Input: Correction instructions sent from the server

[1083] Output: Text and visual correction instructions displayed on the user's terminal

[1084] Step 7: Image Correction

[1085] The user follows the instructions displayed on the device to edit the image, and once the edits are complete, the image is uploaded back to the server.

[1086] Input: User-modified image file

[1087] Output: Corrected image data sent to the server

[1088] Step 8: Request a recheck

[1089] Once the image is uploaded and corrected, it is re-checked through the same process, allowing you to check and correct it as many times as necessary until the image perfectly complies with the display guidelines.

[1090] Input: Corrected image data

[1091] Output: Final image conforming to display guidelines

[1092] By following the above steps, you can efficiently check whether advertising banners and images comply with display guidelines and make quick and accurate corrections.

[1093] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1094] This invention is a system for improving the efficiency of creative image checks, and in particular improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[1095] Server-side processing

[1096] Display guidelines registration

[1097] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[1098] Receiving and saving images

[1099] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[1100] Image analysis

[1101] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[1102] Utilizing the Emotion Engine

[1103] The server uses an emotion engine to analyze the user's emotional state, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[1104] Generate and adjust correction instructions

[1105] Based on the analysis results, the server generates correction instructions. The generated correction instructions specifically indicate the areas that differ from the display guidelines. For example, a text instruction such as "The brand logo is not positioned in the upper left corner" is generated. In addition, a diagrammatic correction guide is generated to make the corrections easier to understand visually.

[1106] Emotional regulation of corrective instructions

[1107] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction prompts. For example, if the user is stressed, the system generates concise, encouraging correction prompts.

[1108] Sending correction instructions

[1109] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[1110] Terminal side processing

[1111] Select and upload an image

[1112] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[1113] Receiving correction instructions

[1114] The user's device receives the correction instructions sent from the server. The received correction instructions are displayed in text and visual formats. Furthermore, the tone of the instructions is adjusted according to the user's emotional state.

[1115] Corrective work

[1116] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[1117] Specific examples

[1118] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[1119] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[1120] "The brand logo is centered. Please place it in the top left."

[1121] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1122] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1123] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts may be adjusted, e.g., to:

[1124] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[1125] "Try increasing the font size of the text to 12pt or larger for better readability."

[1126] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[1127] The user receives these correction instructions, corrects the image accordingly, and then uploads the corrected banner back to the server, where it is rechecked using the same process.

[1128] As described above, the system of the present invention reduces the workload of the user by efficiently performing creative checks while taking the user's feelings into consideration.

[1129] The processing flow will be explained below.

[1130] Step 1: Register display guidelines

[1131] The server receives display guideline data provided by an administrator.

[1132] The server stores the received guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[1133] Step 2: Select and upload an image

[1134] The user selects the image they want to check on their device.

[1135] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[1136] Step 3: Receive and save the image

[1137] The server receives the image data sent from the user's terminal.

[1138] The server stores the received image data in a temporary storage area until the analysis is complete.

[1139] Step 4: Image analysis

[1140] The server reads the image data from the temporary storage area.

[1141] The server inputs the image data into the generative AI model and begins analysis.

[1142] The generative AI model detects each element in the image and compares it to display guidelines.

[1143] Step 5: Detect discrepancies and generate correction instructions

[1144] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[1145] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[1146] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[1147] Step 6: Leverage your emotional engine

[1148] The server uses an emotion engine to analyze the user's emotional state, which is acquired from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[1149] Based on the analysis results of the emotion engine, the server determines whether the user is feeling stressed or relaxed.

[1150] Step 7: Emotional Regulation of Corrective Instructions

[1151] The server adjusts the tone and format of the correction instructions based on the user's emotional state analyzed by the emotion engine.

[1152] For example, if the user is feeling stressed, generate a brief, encouraging tone of correction instruction, such as, "Good job! Your design would be more effective if you placed your brand logo in the upper left corner."

[1153] Step 8: Send correction instructions

[1154] The server assembles the generated correction comments and the emotion-adjusted illustrations into a single package.

[1155] The server sends a package of correction instructions to the user's terminal.

[1156] Step 9: Receiving and confirming correction instructions

[1157] The user's terminal receives the correction instructions sent from the server.

[1158] Users see correction instructions and understand text comments and illustrations. Emotionally attuned instructions allow users to receive the information they need in a familiar format.

[1159] Step 10: Corrective action

[1160] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[1161] Step 11: Re-upload the corrected image

[1162] The user then performs an operation to upload the corrected image back to the server.

[1163] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[1164] Through the above steps, the system of the present invention realizes efficient creative checks that take into account the user's emotions, thereby reducing the user's workload.

[1165] Example 2

[1166] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1167] In conventional image creative check systems, users often felt stressed and pressured because they only received one-way instructions on how to correct images. Furthermore, they lacked the functionality to automatically check compliance with display guidelines and provide specific, visual correction instructions. This increased the user's workload and reduced efficiency. Furthermore, the mechanical correction instructions, which did not take the user's emotional state into consideration, could lead to a decrease in motivation and misunderstandings. To solve these issues, a system was needed that could analyze the user's emotional state and flexibly adjust the tone and format of feedback.

[1168] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1169] In this invention, the server includes means for receiving an image, means for applying a generative AI model to analyze the received image based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for analyzing the user's emotional state and using an emotion engine to adjust the tone and format of the correction instructions, and means for correcting the image based on the correction instructions received by the user and re-uploading it. This enables friendly feedback that takes the user's emotional state into consideration, makes the correction process more efficient, and reduces the user's workload.

[1170] The "means for receiving images" refers to a method or device for capturing image data sent from a user into the server.

[1171] A "generative AI model" is a program or algorithm that uses machine learning and artificial intelligence techniques to analyze elements within an image and evaluate whether they comply with display guidelines.

[1172] "Display guidelines" are instructions or regulations that set out specific standards and rules, such as the placement of elements within an image, color contrast, and the positioning of brand logos.

[1173] "Analysis results" refers to the data and information obtained when the generative AI model analyzes an image, including compliance with display guidelines and any violations.

[1174] The "correction instructions" are specific instructions that are created based on the analysis results and indicate how the image should be corrected.

[1175] An "emotion engine" is software or algorithms that analyze a user's emotional state and adjust the tone and format of correction instructions.

[1176] A "user terminal" is a device used by a user, such as a computer or smartphone, that communicates with a server to upload images and receive correction instructions.

[1177] The "means for correcting an image and re-uploading it" refers to a method or device that allows a user to correct an image based on correction instructions and then transmit the corrected image to the server again.

[1178] The "means for displaying in textual and visual form" refers to a method or device for displaying the received correction instructions to the user in a visually easy-to-understand format.

[1179] This invention is a system for improving the efficiency of creative image checks, and in particular, improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[1180] Server-side configuration

[1181] Display guidelines registration

[1182] The server has a function to register display guidelines in advance in a database. This registration includes the layout of elements within the image, color contrast ratio, and the position of the brand logo. The database used is a relational database such as MySQL or PostgreSQL.

[1183] Receiving and saving images

[1184] When a user uploads an image from their device, the server receives the image data. The received image is then stored in a temporary storage area. This temporary storage area can be stored in the server or in cloud storage such as Amazon S3.

[1185] Image analysis

[1186] The server reads the stored image data and inputs it into a generative AI model for analysis. This generative AI model is built using frameworks such as TensorFlow and PyTorch. During analysis, each element in the image is detected and compared with display guidelines.

[1187] Utilizing the Emotion Engine

[1188] The server analyzes the user's emotional state using an emotion engine, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions. The emotion engine uses, for example, Microsoft's Azure Emotion API.

[1189] Generate and adjust correction instructions

[1190] The server generates correction instructions based on the analysis results. For example, text instructions such as "The brand logo is not positioned in the upper left corner" or "The text font size is 10 pt. Please enlarge it to 12 pt or larger" are created. A diagrammatic correction guide is also generated to make the corrections easier to understand visually.

[1191] Emotional regulation of corrective instructions

[1192] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction instructions. For example, if the user is feeling stressed, the system generates correction instructions in a concise and encouraging tone, such as, "Good job. If you place your brand logo in the upper left corner, the design will be more effective."

[1193] Sending correction instructions

[1194] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[1195] Terminal configuration

[1196] Select and upload an image

[1197] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface, using the file upload function via the HTTP protocol.

[1198] Receive and display correction instructions

[1199] The user's device receives the correction instructions sent from the server and displays them in text and visual form, with the tone of the instructions adjusted to suit the user's emotional state.

[1200] Image correction

[1201] The user then follows the instructions received on the device to edit the image. After editing, the user can upload the image back to the server and request a recheck. This re-upload also uses the HTTP protocol, just like the initial upload.

[1202] Specific examples

[1203] For example, suppose a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results indicate that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[1204] "The brand logo is centered. Please place it in the top left."

[1205] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1206] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1207] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts will be adjusted and changed to:

[1208] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[1209] "Try increasing the font size of the text to 12pt or larger for better readability."

[1210] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[1211] The user receives these correction instructions and corrects the image accordingly. The corrected banner is then uploaded back to the server and rechecked using the same process. As described above, the system of this invention reduces the user's workload by efficiently checking the creative work while taking the user's feelings into consideration.

[1212] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1213] Step 1: Register display guidelines

[1214] The server registers the display guidelines provided by the administrator in a database. These guidelines include the placement of image elements, color contrast ratio, and the position of the brand logo. The input is the guideline data provided by the administrator, and the output is the guideline information stored in the database. Specifically, the server converts the guidelines received from the administrator into JSON format and saves them in a relational database such as MySQL or PostgreSQL using an INSERT statement.

[1215] Step 2: Select and upload an image

[1216] The user selects the image they want to check from their device and uploads it to the server through a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. Specific operations include the user selecting an image using a file selection dialog and clicking the "Upload" button. This operation sends the file to the server via the HTTP protocol.

[1217] Step 3: Receive and save the image

[1218] The server receives images sent by the user and stores them in a temporary storage area. The input is the image data sent by the user, and the output is an image file stored in the temporary storage area. Specifically, the server receives the uploaded file and stores it in a specified directory (for example, the "uploads" directory). At this time, a unique identifier is added to the file name.

[1219] Step 4: Image analysis

[1220] The server inputs the saved image data into a generative AI model for analysis. The input is the saved image file, and the output is the analysis result data. Specifically, the server reads the image file and inputs it into a generative AI model based on TensorFlow or PyTorch. This model detects elements within the image and generates data such as the element's position and size. The analysis results are compared with the display guidelines mentioned above.

[1221] Step 5: Leverage the Emotion Engine

[1222] The server uses an emotion engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is data indicating the user's emotional state. Specifically, the server acquires facial expression images and voice data sent from the user's device and sends this to an emotion analysis API (for example, Azure Emotion API). The API performs the analysis and returns the user's emotional state, such as "stress" or "joy," in JSON format.

[1223] Step 6: Generate and adjust correction instructions

[1224] The server generates correction instructions based on the analysis results. The input is the image analysis results data and emotion analysis results data, and the output is adjusted correction instructions. Specifically, the server points out in text form any violations of the display guidelines based on the analysis results of the generated AI model. At this time, the instructions are adjusted in tone based on the results of the emotion engine, depending on the user's emotional state. For example, the tone could be something like, "Thank you for your hard work. Placing the brand logo in the upper left corner would make for a more effective design."

[1225] Step 7: Send correction instructions

[1226] The generated correction instructions are sent to the user's device after emotion adjustment. The input is the adjusted correction instructions, and the output is the correction instructions sent to the user's device. Specifically, the server sends the correction instructions to the user's device using an HTTP request. The instructions are displayed in an application or web interface on the user's device.

[1227] Step 8: Receive and display correction instructions

[1228] The user's device receives the modification instructions sent from the server and displays them in text and visual form. The input is the modification instructions from the server, and the output is the modification instructions displayed on the user's device. Specifically, the user's device receives the HTTP response and displays the instructions to the user via an application or web interface. This display is provided in a visually easy-to-understand form.

[1229] Step 9: Image Correction

[1230] The user edits the image according to the editing instructions received on the terminal. The input is the editing instructions, and the output is the edited image file. Specifically, the user uses image editing software to edit the image as instructed. After editing is complete, the user uploads the image to the server again and requests a recheck. This re-upload is also done via the HTTP protocol, just like the first time.

[1231] (Application example 2)

[1232] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1233] In conventional image creative check systems, the feedback users receive is uniform and does not take into account the user's emotional state, which can cause stress for the user. Also, correction instructions are only in text format, which can make it difficult to understand visually and emotionally.

[1234] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1235] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, and means for generating correction instructions based on the analysis results, thereby enabling efficient creative checks of images that take into account the emotional state of the user.

[1236] The server further includes means for recognizing the user's emotion using an emotion analysis engine, means for adjusting the tone of the correction instruction based on the emotion, and means for conveying the correction instruction to the user by voice, thereby enabling the user to receive friendly feedback according to his or her emotional state and obtain correction instructions that are easy to understand visually and audibly.

[1237] The "means for receiving images" is a function for importing image data sent from a user into the server.

[1238] "Means for applying a generative AI model" refers to the ability to apply an artificial intelligence model used to analyze received images and evaluate their conformance to display guidelines.

[1239] The "means for generating correction instructions" is a function that identifies the areas of an image that need to be corrected based on the analysis results of the generative AI model and creates specific instructions for those areas.

[1240] The "means for transmitting to the user terminal" is a function for transmitting the created correction instructions to the terminal used by the user.

[1241] "Means for recognizing a user's emotions using an emotion analysis engine" is a function for analyzing a user's emotions from voice and facial expression data and recognizing their emotional state.

[1242] The "means for adjusting the tone of correction instructions based on emotion" is a function for adjusting the wording and tone of correction instructions based on the recognized emotional state of the user.

[1243] The "means for audibly informing the user of the correction instructions" is a function for audibly explaining the created correction instructions to the user.

[1244] The present invention is a system that improves the efficiency of image creative checks by combining an emotion engine that recognizes user emotions. This system operates through cooperation between a server and a user terminal, and processing is carried out in the following manner.

[1245] Server-side processing

[1246] The server first receives the image. The image data uploaded by the user from their device is temporarily stored on the server. Next, a generative AI model is applied to analyze the received image based on display guidelines. This model detects elements within the image and compares them with the display guidelines. In doing so, it checks the placement of elements within the image, color contrast ratio, and brand logo position.

[1247] Once the analysis by the generative AI model is complete, the server generates correction instructions based on the analysis results. The correction instructions are written in text format and indicate the specific areas to be corrected. The server also analyzes the user's emotional state using an emotion analysis engine. The emotion analysis engine recognizes emotions using the user's facial expressions and voice data at the time of uploading and sending correction instructions.

[1248] The system then adjusts the tone of the correction instructions based on the user's emotion. For example, if the user is feeling stressed, the system softens the tone of the instructions. It also generates a voice guide to convey the correction instructions to the user. The server then transmits the final, adjusted correction instructions to the user's terminal.

[1249] Terminal side processing

[1250] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server. The user's device receives and displays the correction instructions sent from the server. The correction instructions are provided in text and audio format, with the tone adjusted to match the user's emotional state, allowing the user to receive the instructions without stress.

[1251] The user then follows the instructions to edit the image. Once the edits are complete, the image can be uploaded back to the server for rechecking. This allows the editing process to proceed efficiently until the image finally complies with the display guidelines.

[1252] Specific examples

[1253] When a user creates an advertising banner and uploads it to the system, the server uses a generative AI model to analyze the image. Based on the display guidelines, non-compliances are detected, such as "the brand logo must be centered," "the text font size must be 10pt," and "the contrast ratio of the primary color must be 3.0:1." Based on this, the server generates correction instructions such as:

[1254] "The brand logo is centered. Please place it in the top left."

[1255] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1256] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1257] Additionally, if the sentiment analysis engine determines that the user is stressed, the tone of the instructions will be adjusted as follows:

[1258] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[1259] "Try increasing the font size of the text to 12pt or larger for better readability."

[1260] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[1261] In this way, users receive friendly feedback that takes their emotions into consideration, and can efficiently perform creative checks.

[1262] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1263] Step 1:

[1264] Uploading an image

[1265] The user selects the image they want to check from their own device and uploads it to the server via a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. The specific operation of the process is that the user selects the image file on the interface and presses the send button, which sends the image data to the server.

[1266] Step 2:

[1267] Receiving and saving images

[1268] The server receives image data sent from the user's device and saves it in a temporary storage area. The input is the image data sent from the device, and the output is the image data saved in the temporary storage area. Specifically, the server receives an HTTP request, extracts the image data from the payload, and saves it as a file.

[1269] Step 3:

[1270] Image analysis

[1271] The server reads the saved image data and performs image analysis using a generative AI model. The input is the saved image data, and the output is the analyzed image element information (e.g., logo position, font size, contrast ratio). Specifically, the image data is input into the AI ​​model, and the model detects and evaluates various elements.

[1272] Step 4:

[1273] Generate correction instructions based on analysis results

[1274] The server generates correction instructions based on the results of image analysis. The input is the image analysis results, and the output is specific correction instructions in text. Specifically, it performs conditional branching based on the analysis results and generates specific correction instructions in text format for parts that do not comply with the guidelines.

[1275] Step 5:

[1276] Emotion analysis

[1277] The server uses an emotion analysis engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is the analyzed user's emotional state. Specifically, the server collects facial expression and voice data when the user uploads an image or receives correction instructions, and inputs this data into the emotion analysis engine to determine the user's emotional state.

[1278] Step 6:

[1279] Tone adjustment for correction instructions

[1280] The server adjusts the tone of the correction instruction based on the emotional state. The input is the analyzed emotional state and the generated correction instruction text, and the output is the adjusted correction instruction text. Specific operations include changing the phrases and expressions of the correction instruction text depending on the emotional state.

[1281] Step 7:

[1282] Sending correction instructions

[1283] The server sends the adjusted correction instructions to the user terminal. The input is the adjusted correction instruction text, and the output is the correction instructions displayed on the terminal. As a specific operation, a message including the adjusted correction instruction text is sent to the user terminal as an HTTP response.

[1284] Step 8:

[1285] Receive and display correction instructions

[1286] The user device receives the correction instructions sent from the server and presents them to the user in text and audio format. The input is the correction instruction message from the server, and the output is the correction instructions that are displayed and played back to the user. Specifically, the device receives the HTTP response, displays the text instructions on the screen, and plays back the audio instructions using a text-to-speech engine.

[1287] Step 9:

[1288] Image correction

[1289] The user modifies the image according to the modification instructions received on the terminal. The input is the modification instructions and the original image data, and the output is the modified image data. In concrete terms, the user modifies the image based on the instructions using image editing software.

[1290] Step 10:

[1291] Re-uploading the corrected image

[1292] The user uploads the corrected image to the server again and requests a recheck. The input is the corrected image file, and the output is the corrected image data saved on the server again. Specifically, the user uploads the corrected image, and the process from step 1 is repeated.

[1293] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1294] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1295] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1296] [Fourth embodiment]

[1297] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1298] 7, a 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.

[1299] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1300] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1301] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[1303] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1304] The control object 443 includes a display device, LEDs in the eyes, and motors for driving 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 emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1305] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1306] The specific processing program 56 is an example of a "program" according to the technology of the present 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.

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

[1308] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. 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 process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1309] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1310] The present invention relates to a system for efficiently checking the creativity of images. This system is mainly composed of a server, a terminal, and user operations.

[1311] Server-side processing

[1312] Display guidelines registration

[1313] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[1314] Receiving and saving images

[1315] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[1316] Image analysis

[1317] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[1318] Generate correction instructions

[1319] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[1320] Sending correction instructions

[1321] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[1322] Terminal side processing

[1323] Select and upload an image

[1324] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[1325] Receiving correction instructions

[1326] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[1327] Corrective work

[1328] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[1329] Specific examples

[1330] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[1331] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[1332] "The brand logo is centered. Please place it in the top left."

[1333] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1334] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1335] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[1336] As described above, the system of the present invention provides a means for efficiently performing creative checks and reducing the workload of the user.

[1337] The processing flow will be explained below.

[1338] Step 1: Register display guidelines

[1339] The server receives display guideline data provided by an administrator.

[1340] The server stores the received display guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[1341] Step 2: Select and upload an image

[1342] The user selects the image they want to check on their device.

[1343] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[1344] Step 3: Receive and save the image

[1345] The server receives the image data sent from the user's terminal.

[1346] The server stores the received image data in a temporary storage area until the analysis is complete.

[1347] Step 4: Image analysis

[1348] The server reads the image data from the temporary storage area.

[1349] The server inputs the image data into the generative AI model and begins analysis.

[1350] The generative AI model detects each element in the image and compares it to display guidelines.

[1351] Step 5: Detect discrepancies and generate correction instructions

[1352] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[1353] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[1354] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[1355] Step 6: Send correction instructions

[1356] The server collects the generated revision comments and diagrams into a single package.

[1357] The server sends a package of correction instructions to the user's terminal.

[1358] Step 7: Receiving and confirming correction instructions

[1359] The user's terminal receives the correction instructions sent from the server.

[1360] The user reviews the correction instructions and understands the text comments and diagrams.

[1361] Step 8: Corrective action

[1362] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[1363] Step 9: Re-upload the corrected image

[1364] The user then performs an operation to upload the corrected image back to the server.

[1365] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[1366] Through the above steps, the system of the present invention realizes efficient creative checks and reduces the workload of the user.

[1367] Example 1

[1368] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1369] The present invention aims to provide a system that efficiently and accurately performs creative checks on images. Conventional manual image checks are time-consuming, labor-intensive, and prone to errors. In particular, checking images according to guidelines such as the position of brand logos and text, font size, and color contrast ratio requires specialized knowledge and experience. The present invention provides new technical means to solve these problems.

[1370] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1371] In this invention, the server includes means for receiving images, means for storing the received image data in a temporary storage area, means for inputting the image data into a generative AI model for analysis, means for comparing each element in the analyzed image with a display guideline, means for generating correction instructions based on the display guideline, and means for transmitting the generated correction instructions to a user terminal, thereby enabling efficient and accurate creative check of images for users.

[1372] 1. "Means for receiving images" refers to the function that allows the server to receive image data sent by the user from the terminal.

[1373] 2. "Means for storing received image data in a temporary storage area" refers to the function of storing image data received by the server in an area for temporary storage.

[1374] 3. "Means of inputting image data into a generative AI model for analysis" refers to the function of the server reading stored image data into the generative AI model and performing analytical processing.

[1375] 4. "Means for comparing each element in the analyzed image with the display guidelines" refers to the function by which the server compares each element in the image detected by the generative AI model with pre-established display guidelines.

[1376] 5. "Means for generating correction instructions based on the display guidelines" refers to the function by which the server generates appropriate correction instructions for parts that differ from the display guidelines.

[1377] 6. "Means for sending generated correction instructions to the user terminal" refers to the function by which the server sends the created correction instructions to the user terminal.

[1378] The present invention relates to a system for efficiently performing creative checks on images. A specific embodiment of this system will be described below.

[1379] The system of the present invention is mainly composed of operations of a server, a terminal, and a user.

[1380] Server-side processing

[1381] 1. Registration of display guidelines

[1382] The server registers display guidelines in a database via an API. These guidelines include the placement of elements in images, color contrast ratios, and the position of brand logos. This process is performed using database software such as MySQL or PostgreSQL.

[1383] 2. Receiving and saving images

[1384] When a user uploads an image from a terminal, the server receives the image data. It receives an HTTP POST request and saves the image data in a temporary storage area (e.g., the / tmp directory). This process uses the HTTP protocol and web server software such as Apache or Nginx.

[1385] 3. Image Analysis

[1386] The server reads the image data from the temporary storage area and inputs it into the generative AI model, which uses machine learning frameworks such as TensorFlow and PyTorch. Image analysis compares the image with display guidelines to check whether it complies with the guidelines.

[1387] 4. Comparison with display guidelines

[1388] The server compares the elements detected by the generative AI model with the display guidelines using a scripting language such as Python, determining whether each element complies and listing any violations.

[1389] 5. Generate correction instructions

[1390] The server generates textual correction instructions for any deviations from the display guidelines. For example, it might say, "The brand logo is not positioned in the top left corner." It also generates a visual representation of the corrections. This process uses image processing libraries such as Pillow and OpenCV.

[1391] 6. Sending correction instructions

[1392] The generated correction instructions are sent to the user's device in text and visual formats using the HTTP and WebSocket communication protocols.

[1393] Explanation of terminal processing

[1394] 1. Select and upload an image

[1395] The user selects the image they want to check using a file selection dialog on their device, and the selected image is uploaded to the server via a dedicated interface (e.g., a web form or a dedicated application) using HTML, JavaScript, and CSS.

[1396] 2. Receiving correction instructions

[1397] The device receives correction instructions sent from the server, which are displayed in textual and visual formats using AJAX (Asynchronous JavaScript and XML) and Fetch API technologies.

[1398] 3. Correction work

[1399] The user follows the correction instructions received on the device and edits the image using image editing software (e.g., Adobe Photoshop, GIMP), and then uploads the edited image back to the server using a dedicated interface.

[1400] Specific examples

[1401] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines stipulate that "the brand logo should be placed in the upper left," "the text font size should be 12pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[1402] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[1403] "The brand logo is centered. Please place it in the top left."

[1404] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1405] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1406] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[1407] A concrete example of a prompt to be input to a generative AI model would be something like this:

[1408] "Compare the placement of your brand logo, the font size of your text, and the contrast ratio of your primary colors within your uploaded image to our display guidelines."

[1409] The above is a specific embodiment of the present invention. This system enables efficient and accurate creative check of images, and reduces the workload of the user.

[1410] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1411] Step 1:

[1412] Display guidelines registration

[1413] The server registers the display guidelines in the database through the API. It receives the display guidelines set by the user (for example, the position of the brand logo, the font size of the text, the color contrast ratio, etc.) as JSON format data. It stores this data using database software such as MySQL or PostgreSQL. It receives the JSON data as input and inserts it into the database table. The output is a confirmation message indicating that the display guidelines have been successfully registered in the database.

[1414] Step 2:

[1415] Select and upload an image

[1416] The user selects the image they want to check from their device and uploads it to the server via a dedicated interface. This operation uses a file selection dialog or a web form. The image file selected by the user is given as input, and an HTTP POST request is sent to the server as output. This transfers the image data to the server.

[1417] Step 3:

[1418] Receiving and saving images

[1419] The server receives the image data sent from the terminal. It saves the received image data in a temporary storage area (e.g., the / tmp directory). The input is the image file included in the data portion of the HTTP POST request, and the output is the image file saved in the temporary storage area.

[1420] Step 4:

[1421] Image analysis

[1422] The server reads the image data from the temporary storage area and inputs it into the generative AI model. The generative AI model uses machine learning frameworks such as TensorFlow and PyTorch. The generative AI model performs analysis by entering the following prompt: "Compare the placement of the brand logo, the font size of the text, and the contrast ratio of the primary colors in the uploaded image with the display guidelines." The input is the image file stored in the temporary storage area, and the output is the analysis result provided by the generative AI model. The analysis result includes detection information for each element in the image (brand logo, text, color, etc.).

[1423] Step 5:

[1424] Comparison with display guidelines

[1425] The server compares the results of the analysis by the generative AI model with the display guidelines. This comparison is performed using a scripting language such as Python. The input is information about each element in the analyzed image and the display guidelines that have been registered in advance in a database. The output is a list of areas that comply with the display guidelines and areas that do not comply with them.

[1426] Step 6:

[1427] Generate correction instructions

[1428] The server generates correction instructions for any deviations from the display guidelines. For example, textual instructions such as "The brand logo is not positioned in the upper left corner" are created. It also generates a visual representation of the corrections. The input is the result of the comparison with the display guidelines, and the output is textual and visual correction instructions. Image processing libraries such as Pillow and OpenCV are used in this process.

[1429] Step 7:

[1430] Sending correction instructions

[1431] The generated correction instructions are sent from the server to the user's device. The correction instructions are sent using HTTP or WebSocket protocol. The input is the generated correction instructions (in textual and visual formats), and the output is the correction instructions displayed on the user's device.

[1432] Step 8:

[1433] Receiving correction instructions

[1434] The user's terminal receives the correction instructions sent from the server. The correction instructions are displayed in text and visual form for the user to confirm. The input is the correction instruction data sent from the server, and the output is the correction instructions displayed on the screen.

[1435] Step 9:

[1436] Image correction

[1437] The user follows the received correction instructions and corrects the image using image editing software (e.g., Adobe Photoshop, GIMP). The input is the correction instructions displayed on the screen, and the output is the corrected image file.

[1438] Step 10:

[1439] Re-upload for recheck

[1440] The user uploads the image with the corrections completed to the server again. The input is the corrected image file, and the output is an HTTP POST request sent to the server. This executes the process from step 3 onwards again, and the corrections are rechecked.

[1441] (Application example 1)

[1442] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1443] When creating advertising banners and images, there is a lack of efficient ways to check whether they comply with display guidelines. This means that if display elements such as the position of the brand logo, the size of the text font, and the color contrast ratio are not accurate, a lot of time and effort must be spent. A system that solves this problem and reduces the workload of creative checks is needed.

[1444] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1445] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for displaying the correction instructions in text and visual format on the user terminal, and means for the user terminal to correct the images based on the correction instructions. This allows for efficient checking of whether advertising banners and images comply with the display guidelines, enabling rapid and accurate correction.

[1446] The "means for receiving images" is a mechanism by which the server receives image data uploaded from a user terminal.

[1447] A "generative AI model" is an artificial intelligence model that analyzes uploaded images and detects and evaluates various elements based on display guidelines.

[1448] The "means of analysis" is a mechanism that uses a generative AI model to analyze and evaluate each element of the received image based on display guidelines.

[1449] The "means for generating correction instructions" is a mechanism that determines the areas of the image that need to be corrected and the specific content of those corrections based on the analysis results, and creates instructions.

[1450] The "means for transmitting a correction instruction to a user terminal" is a mechanism for transmitting the generated correction instruction to a terminal used by a user.

[1451] The "means for displaying the correction instructions in text and visual form on the user terminal" is a mechanism for displaying the received correction instructions in text and visual (illustrated) form on the user terminal.

[1452] "Means for the user terminal to modify an image based on modification instructions" refers to a function for editing and modifying an image based on modification instructions on the user terminal.

[1453] The "means for registering display guidelines in advance in a database" is a mechanism for registering guidelines to be used as display standards for advertising images and the like in a database in advance.

[1454] The present invention provides a system for efficiently checking whether advertising banners and other images comply with display guidelines. The system includes a server, a user terminal, and a generative AI model.

[1455] Server-side processing

[1456] Display guidelines registration

[1457] The server has the ability to pre-register display guidelines in a database, including the placement of elements in an image, color contrast ratio, brand logo position, etc. This ensures that images uploaded by users are evaluated according to specific standards.

[1458] Receiving and saving images

[1459] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[1460] Image analysis

[1461] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[1462] Generate correction instructions

[1463] Based on the analysis results, the server generates correction instructions. Specifically, it detects any deviations from the display guidelines and creates correction comments for those deviations. For example, it generates text instructions such as "The brand logo is not positioned in the upper left corner." It also generates illustrated correction guides to make corrections easier to understand visually.

[1464] Sending correction instructions

[1465] The generated correction instruction is sent to the user's terminal, so that the user can receive the correction instruction.

[1466] Terminal side processing

[1467] Select and upload an image

[1468] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[1469] Receive and display correction instructions

[1470] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to accurately understand the corrections that need to be made.

[1471] Corrective work

[1472] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[1473] As a concrete example of this system, consider the case where a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results show that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[1474] "The brand logo is centered. Please place it in the top left."

[1475] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1476] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1477] These correction instructions are sent to the user's device, where the user can review and make the necessary corrections. The corrected banner is then uploaded to the server again and rechecked using the same process.

[1478] Examples of prompts to input to a generative AI model include:

[1479] Please review user-uploaded ad banner images and analyze them based on the following display guidelines:

[1480] The brand logo is placed in the upper left

[1481] Text font size must be 12pt or larger

[1482] Contrast ratio of 4.5:1 or higher for primary colors

[1483] Please output the analysis results and specific correction instructions based on them in text format.

[1484] In this way, the system of the present invention enables efficient creative checks of advertising banners and images, and provides a means for reducing the workload of the user.

[1485] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1486] Step 1: Select and upload an image

[1487] Users select the images they want to check from their own devices, which can include advertising banners, etc. The selected images are then uploaded to the server via a dedicated interface.

[1488] Input: An image file selected by the user.

[1489] Output: Image data transferred to the server

[1490] Step 2: Receive and save the image

[1491] The server receives the image data uploaded from the device and stores the image data in a temporary storage area until the analysis is complete.

[1492] Input: Image data transferred from the terminal

[1493] Output: Image data stored in the temporary storage area of ​​the server

[1494] Step 3: Analyze the images

[1495] The server reads the image data from the temporary storage area and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image (e.g., brand logo, text font size, color contrast ratio, etc.) and compares it with display guidelines.

[1496] Input: Image data saved in the temporary storage area

[1497] Output: Image elements and their conformance to display guidelines

[1498] Step 4: Generate correction instructions

[1499] The server generates correction instructions based on the analysis results obtained from the generative AI model. Specifically, it detects any discrepancies with the display guidelines and creates text-based correction comments for those discrepancies. It also generates illustrated correction guides to make the corrections easier to understand visually.

[1500] Input: Elements in the image and the results of matching the display guidelines

[1501] Output: Textual revision comments and graphical revision guide

[1502] Step 5: Send correction instructions

[1503] The server transmits the generated correction instruction to the user's terminal, whereby the user receives the correction instruction.

[1504] Input: Correction comments and correction guide

[1505] Output: Correction instructions sent to the user's terminal

[1506] Step 6: Receive and display correction instructions

[1507] The user's device receives the correction instructions sent from the server and displays them in text and visual format, allowing the user to clearly understand the corrections that need to be made.

[1508] Input: Correction instructions sent from the server

[1509] Output: Text and visual correction instructions displayed on the user's terminal

[1510] Step 7: Image Correction

[1511] The user follows the instructions displayed on the device to edit the image, and once the edits are complete, the image is uploaded back to the server.

[1512] Input: User-modified image file

[1513] Output: Corrected image data sent to the server

[1514] Step 8: Request a recheck

[1515] Once the image is uploaded and corrected, it is re-checked through the same process, allowing you to check and correct it as many times as necessary until the image perfectly complies with the display guidelines.

[1516] Input: Corrected image data

[1517] Output: Final image conforming to display guidelines

[1518] By following the above steps, you can efficiently check whether advertising banners and images comply with display guidelines and make quick and accurate corrections.

[1519] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1520] This invention is a system for improving the efficiency of creative image checks, and in particular improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[1521] Server-side processing

[1522] Display guidelines registration

[1523] The server has a function to register display guidelines in advance in a database, including the placement of elements within an image, color contrast ratio, and the position of the brand logo.

[1524] Receiving and saving images

[1525] When a user uploads an image from their device, the server receives the image data and stores it in a temporary storage area until analysis is complete.

[1526] Image analysis

[1527] The server reads the saved image data and inputs it into the generative AI model for analysis. The generative AI model detects each element in the image and compares it with the display guidelines. This checks whether the image complies with the guidelines.

[1528] Utilizing the Emotion Engine

[1529] The server uses an emotion engine to analyze the user's emotional state, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[1530] Generate and adjust correction instructions

[1531] Based on the analysis results, the server generates correction instructions. The generated correction instructions specifically indicate the areas that differ from the display guidelines. For example, a text instruction such as "The brand logo is not positioned in the upper left corner" is generated. In addition, a diagrammatic correction guide is generated to make the corrections easier to understand visually.

[1532] Emotional regulation of corrective instructions

[1533] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction prompts. For example, if the user is stressed, the system generates concise, encouraging correction prompts.

[1534] Sending correction instructions

[1535] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[1536] Terminal side processing

[1537] Select and upload an image

[1538] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server.

[1539] Receiving correction instructions

[1540] The user's device receives the correction instructions sent from the server. The received correction instructions are displayed in text and visual formats. Furthermore, the tone of the instructions is adjusted according to the user's emotional state.

[1541] Corrective work

[1542] The user can then edit the image according to the instructions received on the device. Once the edits are complete, the image can be uploaded back to the server, allowing the user to request a recheck.

[1543] Specific examples

[1544] For example, let's say a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it based on the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 points or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger."

[1545] If the analysis detects that the brand logo is centered, the text font size is 10pt, and the primary color contrast ratio is 3.0:1, the server generates the following correction instructions:

[1546] "The brand logo is centered. Please place it in the top left."

[1547] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1548] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1549] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts may be adjusted, e.g., to:

[1550] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[1551] "Try increasing the font size of the text to 12pt or larger for better readability."

[1552] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[1553] The user receives these correction instructions, corrects the image accordingly, and then uploads the corrected banner back to the server, where it is rechecked using the same process.

[1554] As described above, the system of the present invention reduces the workload of the user by efficiently performing creative checks while taking the user's feelings into consideration.

[1555] The processing flow will be explained below.

[1556] Step 1: Register display guidelines

[1557] The server receives display guideline data provided by an administrator.

[1558] The server stores the received guideline data in a database, including information such as the placement of elements in an image, color contrast ratios, and the position of the brand logo.

[1559] Step 2: Select and upload an image

[1560] The user selects the image they want to check on their device.

[1561] The user operates a dedicated interface for uploading images and transmits the image data to the server.

[1562] Step 3: Receive and save the image

[1563] The server receives the image data sent from the user's terminal.

[1564] The server stores the received image data in a temporary storage area until the analysis is complete.

[1565] Step 4: Image analysis

[1566] The server reads the image data from the temporary storage area.

[1567] The server inputs the image data into the generative AI model and begins analysis.

[1568] The generative AI model detects each element in the image and compares it to display guidelines.

[1569] Step 5: Detect discrepancies and generate correction instructions

[1570] The server detects areas that differ from the display guidelines based on the analysis results of the generative AI model.

[1571] The server generates correction comments for any discrepancies it detects, for example: "The brand logo is centered. Please place it in the top left corner."

[1572] The server also generates an illustrated correction guide to make the corrections easier to understand visually.

[1573] Step 6: Leverage your emotional engine

[1574] The server uses an emotion engine to analyze the user's emotional state, which is acquired from facial expressions and voice data recorded when the user uploads an image or receives correction instructions on the device.

[1575] Based on the analysis results of the emotion engine, the server determines whether the user is feeling stressed or relaxed.

[1576] Step 7: Emotional Regulation of Corrective Instructions

[1577] The server adjusts the tone and format of the correction instructions based on the user's emotional state analyzed by the emotion engine.

[1578] For example, if the user is feeling stressed, generate a brief, encouraging tone of correction instruction, such as, "Good job! Your design would be more effective if you placed your brand logo in the upper left corner."

[1579] Step 8: Send correction instructions

[1580] The server assembles the generated correction comments and the emotion-adjusted illustrations into a single package.

[1581] The server sends a package of correction instructions to the user's terminal.

[1582] Step 9: Receiving and confirming correction instructions

[1583] The user's terminal receives the correction instructions sent from the server.

[1584] Users see correction instructions and understand text comments and illustrations. Emotionally attuned instructions allow users to receive the information they need in a familiar format.

[1585] Step 10: Corrective action

[1586] The user then follows the instructions received on the device to modify the image, for example, by using image editing software to modify the position of the brand logo and adjust the font size of the text.

[1587] Step 11: Re-upload the corrected image

[1588] The user then performs an operation to upload the corrected image back to the server.

[1589] The user's terminal transmits the corrected image data to the server and requests a reanalysis.

[1590] Through the above steps, the system of the present invention realizes efficient creative checks that take into account the user's emotions, thereby reducing the user's workload.

[1591] Example 2

[1592] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1593] In conventional image creative check systems, users often felt stressed and pressured because they only received one-way instructions on how to correct images. Furthermore, they lacked the functionality to automatically check compliance with display guidelines and provide specific, visual correction instructions. This increased the user's workload and reduced efficiency. Furthermore, the mechanical correction instructions, which did not take the user's emotional state into consideration, could lead to a decrease in motivation and misunderstandings. To solve these issues, a system was needed that could analyze the user's emotional state and flexibly adjust the tone and format of feedback.

[1594] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1595] In this invention, the server includes means for receiving an image, means for applying a generative AI model to analyze the received image based on display guidelines, means for generating correction instructions based on the analysis results, means for transmitting the generated correction instructions to a user terminal, means for analyzing the user's emotional state and using an emotion engine to adjust the tone and format of the correction instructions, and means for correcting the image based on the correction instructions received by the user and re-uploading it. This enables friendly feedback that takes the user's emotional state into consideration, makes the correction process more efficient, and reduces the user's workload.

[1596] The "means for receiving images" refers to a method or device for capturing image data sent from a user into the server.

[1597] A "generative AI model" is a program or algorithm that uses machine learning and artificial intelligence techniques to analyze elements within an image and evaluate whether they comply with display guidelines.

[1598] "Display guidelines" are instructions or regulations that set out specific standards and rules, such as the placement of elements within an image, color contrast, and the positioning of brand logos.

[1599] "Analysis results" refers to the data and information obtained when the generative AI model analyzes an image, including compliance with display guidelines and any violations.

[1600] The "correction instructions" are specific instructions that are created based on the analysis results and indicate how the image should be corrected.

[1601] An "emotion engine" is software or algorithms that analyze a user's emotional state and adjust the tone and format of correction instructions.

[1602] A "user terminal" is a device used by a user, such as a computer or smartphone, that communicates with a server to upload images and receive correction instructions.

[1603] The "means for correcting an image and re-uploading it" refers to a method or device that allows a user to correct an image based on correction instructions and then transmit the corrected image to the server again.

[1604] The "means for displaying in textual and visual form" refers to a method or device for displaying the received correction instructions to the user in a visually easy-to-understand format.

[1605] This invention is a system for improving the efficiency of creative image checks, and in particular, improves the process of generating correction instructions by combining an emotion engine that recognizes the user's emotions. This system is composed of a server, a terminal, and user operations.

[1606] Server-side configuration

[1607] Display guidelines registration

[1608] The server has a function to register display guidelines in advance in a database. This registration includes the layout of elements within the image, color contrast ratio, and the position of the brand logo. The database used is a relational database such as MySQL or PostgreSQL.

[1609] Receiving and saving images

[1610] When a user uploads an image from their device, the server receives the image data. The received image is then stored in a temporary storage area. This temporary storage area can be stored in the server or in cloud storage such as Amazon S3.

[1611] Image analysis

[1612] The server reads the stored image data and inputs it into a generative AI model for analysis. This generative AI model is built using frameworks such as TensorFlow and PyTorch. During analysis, each element in the image is detected and compared with display guidelines.

[1613] Utilizing the Emotion Engine

[1614] The server analyzes the user's emotional state using an emotion engine, which is obtained from facial expressions and voice data recorded when the user uploads an image or receives correction instructions. The emotion engine uses, for example, Microsoft's Azure Emotion API.

[1615] Generate and adjust correction instructions

[1616] The server generates correction instructions based on the analysis results. For example, text instructions such as "The brand logo is not positioned in the upper left corner" or "The text font size is 10 pt. Please enlarge it to 12 pt or larger" are created. A diagrammatic correction guide is also generated to make the corrections easier to understand visually.

[1617] Emotional regulation of corrective instructions

[1618] The emotion engine analyzes the user's emotional state and adjusts the tone and format of the correction instructions. For example, if the user is feeling stressed, the system generates correction instructions in a concise and encouraging tone, such as, "Good job. If you place your brand logo in the upper left corner, the design will be more effective."

[1619] Sending correction instructions

[1620] The generated correction instructions are sent to the user's device after emotional adjustment, allowing the user to receive friendly feedback according to their emotional state.

[1621] Terminal configuration

[1622] Select and upload an image

[1623] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface, using the file upload function via the HTTP protocol.

[1624] Receive and display correction instructions

[1625] The user's device receives the correction instructions sent from the server and displays them in text and visual form, with the tone of the instructions adjusted to suit the user's emotional state.

[1626] Image correction

[1627] The user then follows the instructions received on the device to edit the image. After editing, the user can upload the image back to the server and request a recheck. This re-upload also uses the HTTP protocol, just like the initial upload.

[1628] Specific examples

[1629] For example, suppose a user creates an advertising banner for a campaign. When this advertising banner is uploaded to the server, the server uses a generative AI model to check it against the display guidelines. The display guidelines state that "the brand logo should be placed in the upper left corner," "the text font size should be 12 pt or larger," and "the contrast ratio of the primary color should be 4.5:1 or larger." If the analysis results indicate that the brand logo is placed in the center, the text font size is 10 pt, and the contrast ratio of the primary color is 3.0:1, the server generates the following correction instructions:

[1630] "The brand logo is centered. Please place it in the top left."

[1631] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1632] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1633] Additionally, if the emotion engine determines that the user's emotional state is stressed, the tone of the prompts will be adjusted and changed to:

[1634] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[1635] "Try increasing the font size of the text to 12pt or larger for better readability."

[1636] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[1637] The user receives these correction instructions and corrects the image accordingly. The corrected banner is then uploaded back to the server and rechecked using the same process. As described above, the system of this invention reduces the user's workload by efficiently checking the creative work while taking the user's feelings into consideration.

[1638] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1639] Step 1: Register display guidelines

[1640] The server registers the display guidelines provided by the administrator in a database. These guidelines include the placement of image elements, color contrast ratio, and the position of the brand logo. The input is the guideline data provided by the administrator, and the output is the guideline information stored in the database. Specifically, the server converts the guidelines received from the administrator into JSON format and saves them in a relational database such as MySQL or PostgreSQL using an INSERT statement.

[1641] Step 2: Select and upload an image

[1642] The user selects the image they want to check from their device and uploads it to the server through a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. Specific operations include the user selecting an image using a file selection dialog and clicking the "Upload" button. This operation sends the file to the server via the HTTP protocol.

[1643] Step 3: Receive and save the image

[1644] The server receives images sent by the user and stores them in a temporary storage area. The input is the image data sent by the user, and the output is an image file stored in the temporary storage area. Specifically, the server receives the uploaded file and stores it in a specified directory (for example, the "uploads" directory). At this time, a unique identifier is added to the file name.

[1645] Step 4: Image analysis

[1646] The server inputs the saved image data into a generative AI model for analysis. The input is the saved image file, and the output is the analysis result data. Specifically, the server reads the image file and inputs it into a generative AI model based on TensorFlow or PyTorch. This model detects elements within the image and generates data such as the element's position and size. The analysis results are compared with the display guidelines mentioned above.

[1647] Step 5: Leverage the Emotion Engine

[1648] The server uses an emotion engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is data indicating the user's emotional state. Specifically, the server acquires facial expression images and voice data sent from the user's device and sends this to an emotion analysis API (for example, Azure Emotion API). The API performs the analysis and returns the user's emotional state, such as "stress" or "joy," in JSON format.

[1649] Step 6: Generate and adjust correction instructions

[1650] The server generates correction instructions based on the analysis results. The input is the image analysis results data and emotion analysis results data, and the output is adjusted correction instructions. Specifically, the server points out in text form any violations of the display guidelines based on the analysis results of the generated AI model. At this time, the instructions are adjusted in tone based on the results of the emotion engine, depending on the user's emotional state. For example, the tone could be something like, "Thank you for your hard work. Placing the brand logo in the upper left corner would make for a more effective design."

[1651] Step 7: Send correction instructions

[1652] The generated correction instructions are sent to the user's device after emotion adjustment. The input is the adjusted correction instructions, and the output is the correction instructions sent to the user's device. Specifically, the server sends the correction instructions to the user's device using an HTTP request. The instructions are displayed in an application or web interface on the user's device.

[1653] Step 8: Receive and display correction instructions

[1654] The user's device receives the modification instructions sent from the server and displays them in text and visual form. The input is the modification instructions from the server, and the output is the modification instructions displayed on the user's device. Specifically, the user's device receives the HTTP response and displays the instructions to the user via an application or web interface. This display is provided in a visually easy-to-understand form.

[1655] Step 9: Image Correction

[1656] The user edits the image according to the editing instructions received on the terminal. The input is the editing instructions, and the output is the edited image file. Specifically, the user uses image editing software to edit the image as instructed. After editing is complete, the user uploads the image to the server again and requests a recheck. This re-upload is also done via the HTTP protocol, just like the first time.

[1657] (Application example 2)

[1658] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1659] In conventional image creative check systems, the feedback users receive is uniform and does not take into account the user's emotional state, which can cause stress for the user. Also, correction instructions are only in text format, which can make it difficult to understand visually and emotionally.

[1660] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1661] In this invention, the server includes means for receiving images, means for applying a generative AI model to analyze the received images based on display guidelines, and means for generating correction instructions based on the analysis results, thereby enabling efficient creative checks of images that take into account the emotional state of the user.

[1662] The server further includes means for recognizing the user's emotion using an emotion analysis engine, means for adjusting the tone of the correction instruction based on the emotion, and means for conveying the correction instruction to the user by voice, thereby enabling the user to receive friendly feedback according to his or her emotional state and obtain correction instructions that are easy to understand visually and audibly.

[1663] The "means for receiving images" is a function for importing image data sent from a user into the server.

[1664] "Means for applying a generative AI model" refers to the ability to apply an artificial intelligence model used to analyze received images and evaluate their conformance to display guidelines.

[1665] The "means for generating correction instructions" is a function that identifies the areas of an image that need to be corrected based on the analysis results of the generative AI model and creates specific instructions for those areas.

[1666] The "means for transmitting to the user terminal" is a function for transmitting the created correction instructions to the terminal used by the user.

[1667] "Means for recognizing a user's emotions using an emotion analysis engine" is a function for analyzing a user's emotions from voice and facial expression data and recognizing their emotional state.

[1668] The "means for adjusting the tone of correction instructions based on emotion" is a function for adjusting the wording and tone of correction instructions based on the recognized emotional state of the user.

[1669] The "means for audibly informing the user of the correction instructions" is a function for audibly explaining the created correction instructions to the user.

[1670] The present invention is a system that improves the efficiency of image creative checks by combining an emotion engine that recognizes user emotions. This system operates through cooperation between a server and a user terminal, and processing is carried out in the following manner.

[1671] Server-side processing

[1672] The server first receives the image. The image data uploaded by the user from their device is temporarily stored on the server. Next, a generative AI model is applied to analyze the received image based on display guidelines. This model detects elements within the image and compares them with the display guidelines. In doing so, it checks the placement of elements within the image, color contrast ratio, and brand logo position.

[1673] Once the analysis by the generative AI model is complete, the server generates correction instructions based on the analysis results. The correction instructions are written in text format and indicate the specific areas to be corrected. The server also analyzes the user's emotional state using an emotion analysis engine. The emotion analysis engine recognizes emotions using the user's facial expressions and voice data at the time of uploading and sending correction instructions.

[1674] The system then adjusts the tone of the correction instructions based on the user's emotion. For example, if the user is feeling stressed, the system softens the tone of the instructions. It also generates a voice guide to convey the correction instructions to the user. The server then transmits the final, adjusted correction instructions to the user's terminal.

[1675] Terminal side processing

[1676] Users select the images they want to check from their own devices and upload them to the server via a dedicated interface. This operation sends the image data to the server. The user's device receives and displays the correction instructions sent from the server. The correction instructions are provided in text and audio format, with the tone adjusted to match the user's emotional state, allowing the user to receive the instructions without stress.

[1677] The user then follows the instructions to edit the image. Once the edits are complete, the image can be uploaded back to the server for rechecking. This allows the editing process to proceed efficiently until the image finally complies with the display guidelines.

[1678] Specific examples

[1679] When a user creates an advertising banner and uploads it to the system, the server uses a generative AI model to analyze the image. Based on the display guidelines, non-compliances are detected, such as "the brand logo must be centered," "the text font size must be 10pt," and "the contrast ratio of the primary color must be 3.0:1." Based on this, the server generates correction instructions such as:

[1680] "The brand logo is centered. Please place it in the top left."

[1681] "The text font size is 10pt. Please enlarge it to 12pt or larger."

[1682] "The contrast ratio for primary colors is 3.0:1. Please adjust it to 4.5:1 or higher."

[1683] Additionally, if the sentiment analysis engine determines that the user is stressed, the tone of the instructions will be adjusted as follows:

[1684] "Great job! If you place your brand logo in the upper left corner, it will be a more effective design."

[1685] "Try increasing the font size of the text to 12pt or larger for better readability."

[1686] "Adjusting the contrast ratio to 4.5:1 or higher will improve visibility."

[1687] In this way, users receive friendly feedback that takes their emotions into consideration, and can efficiently perform creative checks.

[1688] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1689] Step 1:

[1690] Uploading an image

[1691] The user selects the image they want to check from their own device and uploads it to the server via a dedicated interface. The input is the image file selected by the user, and the output is the image data sent to the server. The specific operation of the process is that the user selects the image file on the interface and presses the send button, which sends the image data to the server.

[1692] Step 2:

[1693] Receiving and saving images

[1694] The server receives image data sent from the user's device and saves it in a temporary storage area. The input is the image data sent from the device, and the output is the image data saved in the temporary storage area. Specifically, the server receives an HTTP request, extracts the image data from the payload, and saves it as a file.

[1695] Step 3:

[1696] Image analysis

[1697] The server reads the saved image data and performs image analysis using a generative AI model. The input is the saved image data, and the output is the analyzed image element information (e.g., logo position, font size, contrast ratio). Specifically, the image data is input into the AI ​​model, and the model detects and evaluates various elements.

[1698] Step 4:

[1699] Generate correction instructions based on analysis results

[1700] The server generates correction instructions based on the results of image analysis. The input is the image analysis results, and the output is specific correction instructions in text. Specifically, it performs conditional branching based on the analysis results and generates specific correction instructions in text format for parts that do not comply with the guidelines.

[1701] Step 5:

[1702] Emotion analysis

[1703] The server uses an emotion analysis engine to analyze the user's emotional state. The input is the user's facial expression and voice data, and the output is the analyzed user's emotional state. Specifically, the server collects facial expression and voice data when the user uploads an image or receives correction instructions, and inputs this data into the emotion analysis engine to determine the user's emotional state.

[1704] Step 6:

[1705] Tone adjustment for correction instructions

[1706] The server adjusts the tone of the correction instruction based on the emotional state. The input is the analyzed emotional state and the generated correction instruction text, and the output is the adjusted correction instruction text. Specific operations include changing the phrases and expressions of the correction instruction text depending on the emotional state.

[1707] Step 7:

[1708] Sending correction instructions

[1709] The server sends the adjusted correction instructions to the user terminal. The input is the adjusted correction instruction text, and the output is the correction instructions displayed on the terminal. As a specific operation, a message including the adjusted correction instruction text is sent to the user terminal as an HTTP response.

[1710] Step 8:

[1711] Receive and display correction instructions

[1712] The user device receives the correction instructions sent from the server and presents them to the user in text and audio format. The input is the correction instruction message from the server, and the output is the correction instructions that are displayed and played back to the user. Specifically, the device receives the HTTP response, displays the text instructions on the screen, and plays back the audio instructions using a text-to-speech engine.

[1713] Step 9:

[1714] Image correction

[1715] The user modifies the image according to the modification instructions received on the terminal. The input is the modification instructions and the original image data, and the output is the modified image data. In concrete terms, the user modifies the image based on the instructions using image editing software.

[1716] Step 10:

[1717] Re-uploading the corrected image

[1718] The user uploads the corrected image to the server again and requests a recheck. The input is the corrected image file, and the output is the corrected image data saved on the server again. Specifically, the user uploads the corrected image, and the process from step 1 is repeated.

[1719] 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 control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[1720] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1721] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1722] The emotion identification model 59 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 an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1723] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1724] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1725] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1726] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1727] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs 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 a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1728] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1729] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1730] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1731] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1732] 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.

[1733] It is not necessary to store all 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 all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1734] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1735] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with 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). Also, the hardware resource that executes the specific processing may be a single processor.

[1736] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1737] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1738] The abo...

Claims

1. means for receiving an image; means for applying a generative AI model to analyze the received image based on the display guidelines; means for generating correction instructions based on the analysis results; means for transmitting the generated correction instruction to a user terminal; A system including:

2. 2. The system according to claim 1, further comprising means for registering the display guidelines in advance in a database.

3. 2. The system according to claim 1, further comprising means for receiving a correction instruction from the user terminal and re-uploading the corrected image.

Images