System

Abstract

A system is provided.SOLUTION: A system including means for receiving an entry file and storing the entry file in a database, means for identifying a format of the entry file and preprocessing the entry file, means for setting an evaluation criterion and reflecting the evaluation criterion in a generated AI model, means for evaluating an entry by using the generated AI and calculating an evaluation score, means for storing the evaluation score in the database, and means for aggregating the evaluation scores and notifying a result.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] Conventional contest selection processes have the problem of requiring a great deal of time and effort to manually review a large number of entries and select winners based on evaluation criteria. Furthermore, subjective evaluation by judges makes it difficult to ensure the fairness and consistency of the judging results. The present invention aims to solve these problems, streamline the contest selection process, and achieve fair and consistent evaluation. [Means for solving the problem]

[0005] The present invention provides a system that utilizes generative AI to streamline the contest selection process. The system includes means for receiving entry files and storing them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in a generative AI model, means for evaluating the entries using generative AI and calculating evaluation scores, means for storing the evaluation scores in a database, and means for aggregating the evaluation scores and notifying the results. This enables efficient, fair, and consistent evaluation of a large number of entries. The present invention also provides further convenience and flexibility by including means for resizing entry files to a standard size based on their format, adjusting brightness and contrast, and setting evaluation criteria and weighting for each evaluation item through an administration screen.

[0006] "Entry File" means an electronic file of the work or materials submitted by a Contestant.

[0007] A "database" is a system that systematically stores and manages entry files and related information.

[0008] "Generative AI" is a system that uses artificial intelligence technology to generate, analyze, and evaluate data.

[0009] "Preprocessing" refers to the process of converting the entry file into a format that is easy to evaluate.

[0010] "Evaluation criteria" are specific items or indicators used to evaluate entries.

[0011] The "evaluation score" is a numerical evaluation result calculated by the generation AI for each entry.

[0012] The "management screen" is a user interface for configuring and operating the system.

[0013] "Standard size" is the size of the file that the system uses as a standard for evaluation.

[0014] "Resizing" means changing the image, video, or other file of an entry to a specific size.

[0015] "Brightness and contrast adjustment" is a type of image processing performed to improve the visibility and quality of an image file.

[0016] The "weight for each evaluation item" is a ratio that reflects the importance of each item in the set evaluation criteria. [Brief explanation of the drawings]

[0017] [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

[0018] 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.

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

[0020] 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).

[0021] 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.

[0022] 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.

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

[0024] 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."

[0025] [First embodiment]

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

[0027] 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.

[0028] 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).

[0029] 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.

[0030] 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.

[0031] 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.

[0032] 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.

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

[0034] 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.

[0035] 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.

[0036] 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.

[0037] 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."

[0038] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluation. Specific embodiments of the system are described below.

[0039] Collecting Entries

[0040] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[0041] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0042] Entry classification and preprocessing

[0043] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[0044] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[0045] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[0046] Setting evaluation criteria

[0047] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[0048] The server saves the set evaluation criteria in a database and reflects them in the generative AI model. Weights for each evaluation item may also be set at the same time. For example, the evaluation criteria set by the user, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%," are saved in the database and applied to the generative AI model.

[0049] Rating the entry

[0050] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0051] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the AI ​​generator. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these up to arrive at an overall score of "8.1 points."

[0052] The server stores the evaluation scores and the overall score in a database.

[0053] Calculation and notification of results

[0054] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[0055] The server generates the results and notifies users. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[0056] The system of the present invention allows contest entries to be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing a more transparent and fair evaluation for participants.

[0057] The processing flow will be explained below.

[0058] Step 1: Collecting Entries

[0059] A user submits an entry through an online form, for example, by uploading a JPEG image of a drawing for a painting contest.

[0060] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0061] Step 2: Classifying and preprocessing entries

[0062] The server periodically retrieves new entry files from the database.

[0063] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[0064] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[0065] Step 3: Set evaluation criteria

[0066] Users can set evaluation criteria through the management screen, such as "creativity," "technical ability," and "expression of the theme."

[0067] The user sets the weight of each evaluation item, for example, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%."

[0068] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0069] Step 4: Evaluate the entries

[0070] The server launches the generative AI to evaluate the pre-processed input file, for example, an image, extracts features using a deep learning model, and generates a score based on the evaluation criteria.

[0071] The server calculates an evaluation score for each entry. For example, image "E001" might be given scores such as "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[0072] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added up to arrive at an overall score of "8.0 points."

[0073] The server stores the evaluation scores and the overall score in a database.

[0074] Step 5: Counting and notifying results

[0075] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[0076] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[0077] Example 1

[0078] 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."

[0079] In traditional contest selection processes, the collection, classification, and evaluation of entry data is often done manually, which is time-consuming and labor-intensive, and can lack fairness and consistency. Furthermore, the evaluation criteria and weighting are often unclear, leading to problems of subjective variation among evaluators. Furthermore, when there are a large number of entries, it is difficult to evaluate quickly, and it is difficult to notify participants of the results promptly. To solve these issues, an automated evaluation system is needed.

[0080] 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.

[0081] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in an AI model, means for evaluating the entries using AI and calculating evaluation scores, means for saving the evaluation scores in a database, and means for aggregating the evaluation scores and notifying the results. This automates the process from collecting entries to evaluating them and notifying the results, enabling a fast and fair evaluation process.

[0082] "Entry Data" refers to data provided by Contest participants in the form of images, text, videos, etc.

[0083] "Database" refers to an information system for systematically storing and managing entry data, its metadata, evaluation scores, etc.

[0084] "Format identification" refers to the process of identifying the type of entry data (e.g., JPEG image, TXT text, MP4 video) it belongs to.

[0085] "Preprocessing" refers to processes such as resizing and adjusting brightness and contrast to convert the entry data into a format suitable for evaluation.

[0086] "Evaluation Criteria" refers to the criteria and their respective weightings for evaluating Entries.

[0087] "Artificial intelligence model" refers to a program or algorithm that automatically evaluates entry data according to set evaluation criteria.

[0088] "Evaluation score" refers to the numerical value calculated by the artificial intelligence model for each entry data based on the set evaluation criteria.

[0089] "Aggregation" refers to the process of adding up and comparing multiple evaluation scores to arrive at an overall ranking or result.

[0090] "Notification of results" refers to the act of informing contest participants and organizers of the evaluation scores and aggregated results.

[0091] The system of the present invention uses a generative AI model to streamline the contest selection process and provide fair and consistent evaluation. The system of the present invention combines artificial intelligence, a database, an image processing library, and a text processing library, and specific embodiments of the system are described below.

[0092] First, a user submits an entry to a contest through an online form. Entry data can be submitted in the form of an image, text, video, or other format. For example, a user may enter a painting contest in JPEG image format. The server receives this entry and stores it in a database along with metadata such as the entry ID and upload date and time. This storage is achieved using a web application framework (e.g., Django, Ruby on Rails) and a database management system (e.g., PostgreSQL, MySQL (registered trademark)).

[0093] The server then periodically retrieves the entries from the database, either in batches for processing or by retrieving new entries all at once.

[0094] The server identifies the format of the input data and uses an image processing library (e.g., OpenCV) or a file format analysis library (e.g., ffmpeg) to identify the format, such as image, text, or video.

[0095] For example, if image data in JPEG format is uploaded, the server checks the format. Then, the server preprocesses this input data. For example, it resizes the JPEG image to a standard size of 800x800 pixels and uses an image processing library (e.g., Pillow, scikit-image) to adjust the brightness and contrast.

[0096] Users set the evaluation criteria through the management screen. Specifically, in the case of a painting contest, they can set items such as "creativity," "technical ability," and "expression of the theme." In addition, it is possible to set weights for each evaluation item. For example, settings could be "creativity: 40%," "technical ability: 30%," and "expression of the theme: 30%." These settings are received by the server, stored in a database, and reflected in the generative AI model.

[0097] The server then launches the generative AI model and evaluates the preprocessed input data according to the set criteria.

[0098] For example, a prompt might be entered: "Rate this image on creativity, technical ability, and expression of the theme." The generative AI model returns a score for each evaluation criterion, which the server then adds up to calculate an overall score. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Expression of the theme: 9 points," the server will weight these scores accordingly to calculate an overall score of 8.1 points (8 x 0.4 + 7 x 0.3 + 9 x 0.3).

[0099] Finally, the server tally the evaluation scores of all the entry data and select the entry with the highest score. For example, it selects the top 10 entries. The server also generates the results and notifies the participants. Notification methods include displaying the results via email and the management screen. Contest participants are notified of the evaluation results by email, and the organizer sees the details on the management screen.

[0100] In this way, contest entries can be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing participants with a transparent and fair evaluation.

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

[0102] Step 1:

[0103] The user enters entry data into the online form and presses the submit button.

[0104] Input: Data entered by a user into a form (e.g., image files, text, video, etc.).

[0105] How it works: The server receives and temporarily stores user input data. Specifically, it receives HTTP requests and stores uploaded files in a temporary directory.

[0106] Output: Entry data stored on the server.

[0107] Step 2:

[0108] The server stores the entry data in a database.

[0109] Input: Temporarily saved entry data and metadata (entry ID, upload date and time, etc.).

[0110] How it works: The server generates metadata and stores it in a database along with the entry data, e.g., generating an entry ID and recording the upload date and time.

[0111] Output: Entry data and metadata stored in a database.

[0112] Step 3:

[0113] The server retrieves the new entry data from the database.

[0114] Input: Entry data stored in a database.

[0115] How it works: The server retrieves new entries in batches, e.g., by executing an SQL query to retrieve raw entry data.

[0116] Output: A list of the retrieved entries.

[0117] Step 4:

[0118] The server identifies the type of the entry data and pre-processes it.

[0119] Input: The acquired entry data.

[0120] How it works: The server uses an image processing library (e.g. OpenCV) or a file format parsing library (e.g. ffmpeg) to identify the format, then resizes and adjusts brightness and contrast if it's an image.

[0121] Output: Preprocessed input data.

[0122] Step 5:

[0123] The user sets the evaluation criteria through the management screen.

[0124] Input: Evaluation criteria (e.g., "creativity," "technical ability," "representation of the theme") and weighting information.

[0125] Operation: The user inputs the evaluation criteria on the management screen and saves the settings. Specifically, the evaluation criteria and weighting information are saved in the database.

[0126] Output: Evaluation criteria and weighting information stored in a database.

[0127] Step 6:

[0128] The server launches the generative AI model and evaluates the preprocessed input data.

[0129] Input: Preprocessed entry data and set evaluation criteria.

[0130] How it works: The server inputs a prompt (e.g., "Rate this image on creativity, technical ability, and thematic expression") into the generative AI model, which then calculates a score for each criterion.

[0131] Output: Evaluation score for each entry.

[0132] Step 7:

[0133] The server sums the evaluation scores to calculate an overall score.

[0134] Input: Rating scores and weighting information.

[0135] How it works: The server applies weighting to each evaluation score and calculates the overall score. For example, it calculates "Creativity: 8 points x 0.4 + Technical ability: 7 points x 0.3 + Theme expression: 9 points x 0.3".

[0136] Output: The calculated overall score.

[0137] Step 8:

[0138] The server stores the evaluation scores and the overall score in a database.

[0139] Input: Overall score and evaluation score for each entry data.

[0140] Operation: The server associates the evaluation score and overall score with each entry data and stores them in a database.

[0141] Output: Evaluation scores and overall score stored in a database.

[0142] Step 9:

[0143] The server will tally the evaluation scores of all the entries and select the top entries.

[0144] Input: The total score of all entries stored in the database.

[0145] How it works: The server sorts the total scores in descending order and selects the top 10 entries.

[0146] Output: A list of top entry data.

[0147] Step 10:

[0148] The server generates the results and notifies the user.

[0149] Input: List of top entry data and contact information for each participant.

[0150] What it does: The server generates and sends a result email to the participants, and also provides the organizer with a link to view details on the admin page.

[0151] Output: The result notification email sent and the result displayed on the admin page.

[0152] (Application example 1)

[0153] 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."

[0154] Product inspections in factories are typically done manually, which requires a lot of time and effort. Furthermore, consistency and fairness of evaluations are not guaranteed, which creates quality control issues. Furthermore, similar issues arise when evaluating entries for events such as contests, creating a need for efficient and fair evaluations.

[0155] 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.

[0156] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for collecting sensor data for inspecting product quality in factories, and means for preprocessing the collected sensor data and evaluating quality using the generative AI model. This enables efficient and fair product inspection in factories and evaluation of various contest entries, automating the evaluation process and improving quality control.

[0157] An "entry file" is digital data (images, text, video, etc.) that will be evaluated in contests and product inspections.

[0158] A "database" is a system for organizing, storing, and managing entry files, evaluation scores, metadata, etc.

[0159] A "generative AI model" is an algorithm that uses artificial intelligence techniques such as generative adversarial networks (GANs) to evaluate and generate data based on specific criteria.

[0160] "Preprocessing" refers to data conversion and processing to prepare the entry file in a state suitable for evaluation, depending on its format.

[0161] "Evaluation Criteria" means the criteria and weightings set for evaluating entries and products.

[0162] "Sensor data" refers to input data such as images, audio, and motion data collected by robots and sensors within a factory.

[0163] "Resize" is a process of changing an entry file such as an image to a specified standard size.

[0164] The "evaluation score" is the result of the generative AI model quantifying the entry file and product quality based on the evaluation criteria.

[0165] The "management screen" is a graphical interface that allows users to set evaluation criteria and check evaluation results.

[0166] "Notification" refers to a means of communication to inform users or participants of the evaluation results and information based on them.

[0167] The system for implementing this invention consists of the following steps: First, the server receives the entry file and stores it in a database. Next, the server identifies the entry file format (image, text, video, etc.) and performs appropriate preprocessing. After preprocessing, the user sets evaluation criteria through the management screen and reflects them in the generative AI model.

[0168] After the evaluation criteria are set, the server evaluates the entry files using the generative AI model and calculates an evaluation score based on each evaluation criterion.The evaluation score is then saved in the database again.Finally, the server tallys up the evaluation scores and notifies the user of the results.

[0169] Hardware and software used

[0170] Hardware:

[0171] Robot body (e.g. NVIDIA Jetson): Used for image processing and database communication

[0172] Camera: Used to collect image and video data

[0173] Microphone: Used to collect audio data (optional)

[0174] software:

[0175] TENSORFLOW(R) / PyTorch: Used to run generative AI models

[0176] OpenCV: Used as an image processing library

[0177] Transformers: Used as a generative AI pipeline for Huggingface

[0178] SQLite / MySQL: Used as a database management system

[0179] Data processing and calculation

[0180] The server first receives the entry file (image, text, video) and stores it in a database. The received data is preprocessed according to its format. For example, image data is resized and its brightness and contrast are adjusted, while text data is tokenized and noise is removed.

[0181] After preprocessing is complete, the user inputs evaluation criteria through the management screen and applies them to the generative AI model. The generative AI model evaluates the quality of the entry file based on the set evaluation criteria and calculates a score based on each criterion. The calculated scores for each evaluation criterion are added up and stored in the database as an overall score.

[0182] Add specific examples to the description

[0183] For example, you can collect images of products in a factory and then input the following prompt sentences into a generative AI model:

[0184] Example prompt sentence:

[0185] 1. "Please rate the quality of this product image based on the following criteria: 1) Creativity of the design: 40%, 2) Accuracy of the process: 30%, 3) Appearance of the final product: 30%."

[0186] 2. "Please rate the quality of this text and provide a score for each category: 1) grammatical accuracy, 2) content relevance, 3) editing quality."

[0187] This allows for efficient and fair inspection of products in factories and evaluation of contest entries, resulting in automation of the evaluation process and improved quality control.

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

[0189] Step 1:

[0190] The server receives the entry file and stores it in the database. The entry file contains images, text, videos, etc., and is saved in the database with metadata such as an ID and upload date and time. Specifically, the server receives the entry file via an HTTP request and stores its contents and metadata in the database using an SQL insert operation.

[0191] Step 2:

[0192] The server retrieves the entry file from the database and identifies the entry file format (e.g., JPEG image, TXT text, MP4 video, etc.). It then performs preprocessing based on the identified format. Specifically, it checks the file extension and performs preprocessing using a library (OpenCV, NLTK, etc.) appropriate for each file format.

[0193] Step 3:

[0194] Using the preprocessed entry file, the server launches the generative AI model and calculates an evaluation score based on the evaluation criteria. The specific operation here is a process in which the preprocessed data is input into the AI ​​model to be used (for example, a classification model using TensorFlow or PyTorch) and an evaluation score is output. The input is the preprocessed data, and the output is a score for each evaluation criterion.

[0195] Step 4:

[0196] The user sets the evaluation criteria through the management screen, and the server reflects those criteria in the generative AI model. Specifically, the server receives the evaluation criteria input through the web interface, stores them in the database, and then applies them to the generative AI model. The input is the criteria specified by the user, and the output is a reflection of the criteria settings for the model.

[0197] Step 5:

[0198] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the generative AI model. Specifically, the server adds up the individual evaluation scores with weighting, outputs the result as an overall score, and saves it back in the database. The input is the individual evaluation scores, and the output is the overall score.

[0199] Step 6:

[0200] The server aggregates the evaluation scores of all entries and notifies the user of the results. The specific operation here is the process of selecting the top N entries and notifying the user of this information via email or the administration screen. The input is the database data where the evaluation scores are stored, and the output is sending a notification.

[0201] Step 7:

[0202] To inspect product quality in a factory, a server collects sensor data (images, audio, video, etc.) and performs preprocessing. For example, it resizes product images taken with a camera and adjusts their brightness and contrast. Specifically, it acquires data from IoT sensors in real time and inputs it into a preprocessing algorithm (e.g., OpenCV). The input is raw sensor data, and the output is preprocessed data.

[0203] Step 8:

[0204] Based on the collected and preprocessed sensor data, the server evaluates the quality using a generative AI model. The specific operation here is that the AI ​​model calculates a quality score based on the preprocessed data and stores the result in a database. The input is the preprocessed sensor data, and the output is the quality score.

[0205] 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.

[0206] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluations. Furthermore, by incorporating an emotion engine that recognizes user emotions and dynamically adjusts the evaluation process based on those emotions, the system becomes more flexible and effective. Specific embodiments of the present invention are described below.

[0207] Collecting Entries

[0208] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[0209] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0210] Entry classification and preprocessing

[0211] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[0212] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[0213] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[0214] Setting evaluation criteria

[0215] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[0216] The user sets the weight of each evaluation item. For example, the weights of the evaluation items can be set as "Creativity: 40%", "Technical ability: 30%", and "Expression of the theme: 30%".

[0217] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0218] Rating the entry

[0219] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0220] The server calculates an evaluation score for each entry. For example, if image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these scores together to arrive at an overall score of "8.0 points."

[0221] The server stores the evaluation scores and the overall score in a database.

[0222] Calculation and notification of results

[0223] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[0224] The server generates the results and notifies users of the results. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[0225] Incorporating an emotion engine

[0226] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data, thereby recognizing the user's emotional state in real time.

[0227] The server analyzes the user's emotion data obtained from the emotion engine and dynamically adjusts the evaluation process based on the user's emotions. For example, if the user is feeling stressed, the evaluation process is simplified to reduce the burden.

[0228] As a specific example, when a user is setting evaluation criteria, the emotion engine acquires the user's facial expression data, and if it determines that the stress level is high, the system automatically adjusts the weighting of the evaluation criteria, allowing the user to make the evaluation in a more relaxed state.

[0229] The system of the present invention not only allows contest entries to be evaluated efficiently and fairly, but also allows for flexible responses to users' emotional states, making the evaluation process more accurate and convenient.

[0230] The processing flow will be explained below.

[0231] Step 1: Collecting Entries

[0232] Users submit their entries through an online form, for example by uploading a JPEG image of their drawing for a painting contest.

[0233] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0234] Step 2: Classifying and preprocessing entries

[0235] The server periodically retrieves new entry files from the database.

[0236] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[0237] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[0238] Step 3: Recognize emotions

[0239] The device collects biometric and facial expression data from the user, for example, by using a webcam or smartphone camera to capture the user's facial expressions.

[0240] The emotion engine analyzes the collected biometric information and facial expression data to recognize the user's emotional state (e.g., stress, joy, excitement, etc.).

[0241] Step 4: Set evaluation criteria

[0242] Users set the evaluation criteria through the management screen. For example, in a painting contest, they can set criteria such as "creativity," "technical ability," and "expression of the theme."

[0243] The server receives emotion recognition data from the emotion engine and dynamically adjusts the evaluation criteria based on that data. For example, if the user is feeling stressed, the weight of the evaluation items will be reduced.

[0244] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0245] Step 5: Evaluate the entries

[0246] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0247] The server calculates an evaluation score for each entry. For example, image "E001" might receive scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[0248] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added together to arrive at an overall score of 8.0 points.

[0249] The server stores the evaluation scores and the overall score in a database.

[0250] Step 6: Counting and notifying results

[0251] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[0252] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[0253] Example 2

[0254] 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."

[0255] Traditional contest selection processes require manual evaluation of many entries, which is time-consuming and labor-intensive, and prone to human bias. Furthermore, the emotional state of the evaluator can affect the evaluation results, making it difficult to provide fair and consistent evaluations.

[0256] 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.

[0257] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, and means for acquiring user emotional data and dynamically adjusting the evaluation process. This not only enables efficient and fair evaluation of entries, but also allows for flexible responses depending on the emotional state of the evaluators.

[0258] An "entry file" is digital data that a user submits to a contest, and may include images, text, videos, and other formats.

[0259] A "database" is a system for efficiently storing and managing data such as entry files and evaluation scores.

[0260] "Preprocessing" is the process of identifying the format, resizing, adjusting brightness and contrast, etc., to make the entry files easier to evaluate.

[0261] The "evaluation criteria" are indicators for objectively evaluating the quality of entries, and include "creativity," "technical ability," and "expression of the theme."

[0262] A "generative AI model" is an artificial intelligence algorithm that evaluates entries based on set evaluation criteria and calculates an evaluation score.

[0263] The "evaluation score" is a numerical value calculated for each entry using a generative AI model, and is calculated for each category, such as "creativity," "technical ability," and "expression of the theme."

[0264] "Emotion data" is data obtained from the user's facial expressions and biometric information, and indicates the user's stress level and emotional state.

[0265] "Dynamic adjustment" is the process of changing the system's behavior or settings based on real-time information, including changing the evaluation process in response to the user's emotional state.

[0266] "Notification" is the process of communicating evaluation results and other important information to users, and is done via email or the system's administration screen.

[0267] The system of the present invention utilizes generative AI to streamline the contest selection process and provide fair and consistent evaluations. It also incorporates an emotion engine that analyzes user emotion data and dynamically adjusts the evaluation process based on that data. A specific embodiment of the system will now be described.

[0268] System Overview

[0269] This system mainly consists of the following hardware and software:

[0270] Server: Responsible for database management, receiving, processing, and evaluating entry files, and analyzing emotion data.

[0271] Terminal: Provides an interface for users to submit entry files and set evaluation criteria.

[0272] Generative AI model: Used to evaluate entries and calculate a rating score.

[0273] Emotion engine: Captures user emotional data and dynamically adjusts the rating process based on that data.

[0274] Collecting Entries

[0275] A user submits an entry through an online form. For example, in the case of a painting contest, the user selects a JPEG image and clicks the upload button. The server receives this entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, a JPEG image with an entry ID of "E001" on October 1, 2023, is saved at "2023-10-01 15:42:00."

[0276] Entry classification and preprocessing

[0277] The server retrieves the entry file from the database and identifies its format. For example, it checks the file extension to identify whether it is a JPEG image, a TXT text file, or an MP4 video file. Then, as preprocessing, it resizes the image to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, the JPEG image with entry ID "E001" is resized to 800x800 pixels.

[0278] Setting evaluation criteria

[0279] Users can set evaluation criteria through the management screen. For example, in the case of a painting contest, they input "creativity," "technical ability," "expression of theme," etc. Furthermore, they specify the weighting of each evaluation item (e.g., "creativity: 40%," "technical ability: 30%," "expression of theme: 30%). The server saves these settings in a database and reflects them in the generative AI model.

[0280] Rating the entry

[0281] The server launches the generation AI and evaluates the preprocessed entry files. The evaluation is performed according to the set criteria. For example, for the JPEG image "E001," the generation AI model obtains scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points." These scores are added together to arrive at an overall score of "8.0 points." The server saves the evaluation scores and overall score in a database.

[0282] Calculation and notification of results

[0283] The server will tally the evaluation scores of all entries and select the top-scoring entries. For example, the top 10 entries will be selected. The server will then generate the results and notify the user. Notifications will be sent via email or the admin panel.

[0284] Incorporating an emotion engine

[0285] While the user sets the evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data. The server analyzes the acquired emotion data and dynamically adjusts the evaluation process based on the user's emotional state. For example, if the user is feeling stressed, the weights of the evaluation criteria will be automatically adjusted, allowing the user to evaluate in a more relaxed state.

[0286] Specific prompt examples

[0287] "Based on the JPEG image, please calculate a score out of 10 for creativity, technical ability, and expression of the theme."

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

[0289] Step 1: Submit your entry file

[0290] A user submits an entry file through an online form. The input is an image, text, or video file selected by the user, which is sent to the server by submitting the form. The output is the entry file received by the server. Specifically, a user accesses the form on a web browser, clicks the "Participate Entry" button, selects a file, and presses the "Submit" button.

[0291] Step 2: Receiving and saving the entry file

[0292] The server receives the submitted entry file and generates metadata such as the entry ID, upload date and time, and file format. The input is the submitted entry file, and the output is a file stored in a database along with the entry ID and upload date and time. Specifically, the server receives the request, extracts the file's metadata, generates an entry ID of "E001", and stores it in the database.

[0293] Step 3: Obtaining the entry file

[0294] The server retrieves entry files from the database. The input is the entry ID in the database, and the output is the retrieved entry file. Specifically, the server sends a query to the database to "get new entries" and retrieves the entry files in bulk.

[0295] Step 4: Identify the file format

[0296] The server identifies the format of each entry file. The input is the retrieved entry file, and the output is the identified file format. Specifically, the server checks the file extension and determines that "E001.jpeg" is in JPEG format.

[0297] Step 5: Preprocessing

[0298] The server preprocesses the acquired entry file. The input is the identified entry file, and the output is the preprocessed file. Specifically, the server uses the "resize" function to resize "E001.jpeg" to 800x800 pixels and adjust the brightness and contrast.

[0299] Step 6: Set evaluation criteria

[0300] The user sets the evaluation criteria through the management screen. The input is the evaluation criteria and weights entered on the management screen, and the output is the evaluation criteria and weights saved in the database. Specifically, the user enters the "Evaluation Criteria Settings" section on the management screen, enters "Creativity," "Technical Ability," and "Theme Expression," and sets the weights.

[0301] Step 7: Reflecting the generative AI model

[0302] The server reflects the set evaluation criteria and weights in the generative AI model. The input is the evaluation criteria and weights stored in the database, and the output is the updated generative AI model. Specifically, the server provides the "evaluation criteria" and "weight" data to the generative AI model and updates the model parameters.

[0303] Step 8: Evaluate the entry file

[0304] The server launches the generation AI to evaluate the preprocessed entry files. The input is the preprocessed entry files and the evaluation criteria, and the output is the evaluation score for each entry file. Specifically, the server uses the "generateAI" function to evaluate the entry files according to the evaluation criteria.

[0305] Step 9: Calculate and store the evaluation score

[0306] The server calculates the evaluation score for each entry and saves it in the database. The input is the evaluation result, and the output is the evaluation score saved in the database. Specifically, the server calculates the score for each entry using the "evaluateEntry" function and saves it in the database using the "saveScores" function.

[0307] Step 10: Aggregating the results

[0308] The server aggregates the rating scores of all entries and selects the top-scoring entries. The input is the rating scores in the database, and the output is a list of the top entries. Specifically, the server queries the score data and lists the top 10 entries.

[0309] Step 11: Notification of results

[0310] The server generates the results and notifies the user of the results. The input is the top entry information, and the output is the notified result. Specifically, the server generates a notification email and sends it to the participants, and displays the results on the management screen for the organizer.

[0311] Step 12: Obtaining Emotion Data

[0312] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background and acquires the user's emotion data. The input is the user's biometric information and facial expression data, and the output is emotion data. Specifically, the emotion engine collects data in real time from webcams and sensors.

[0313] Step 13: Analyze emotion data and calibrate ratings

[0314] The server analyzes the emotion data obtained from the emotion engine and dynamically adjusts the evaluation process. The input is the emotion data, and the output is the adjusted evaluation process. Specifically, when the server uses the "analyzeEmotion" function and determines that the user's stress level is high, it automatically adjusts the weights of the evaluation criteria and simplifies the evaluation process.

[0315] (Application example 2)

[0316] 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."

[0317] Conventional contest evaluation systems have had problems with the cumbersome process of evaluating entries and the lack of consistency in evaluation criteria. Furthermore, the emotional state of the evaluator can affect the evaluation results, limiting the fairness and accuracy of the evaluation. Furthermore, it is often difficult to evaluate entries in real time on-site.

[0318] 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.

[0319] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in a generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for analyzing user emotions in real time and dynamically adjusting the evaluation criteria based on the user's emotional state, and means for evaluating entries using data obtained from a smart device. This makes the evaluation process more efficient, fairer, and possible to evaluate entries in real time.

[0320] "Entry Data" means data submitted for a contest or evaluation, and includes various file formats such as images, text, and video.

[0321] A "database" is a system for structuring and storing entry data, evaluation scores, etc.

[0322] "Preprocessing" refers to processing performed to make the input data easier to analyze, and includes image resizing, brightness and contrast adjustment, text tokenization, noise removal, etc.

[0323] "Evaluation criteria" are the standards for evaluating the entry data, and include items such as creativity, technical ability, and expression of the theme.

[0324] A "generative AI model" is an artificial intelligence model that automatically evaluates entry data based on pre-set evaluation criteria and generates the results.

[0325] The "emotion engine" is a system that analyzes the user's emotional state in real time and dynamically adjusts evaluation criteria based on that data.

[0326] A "smart device" is an electronic device carried by a user, such as a wearable device or smartphone that can connect to the Internet.

[0327] An "evaluation score" is the evaluation result of the entry data calculated by the generative AI model based on the evaluation criteria.

[0328] "Real-time evaluation" is the process of instantly evaluating entry data on the spot.

[0329] The system of the present invention involves a server, terminals, and users working together to evaluate entry data. This system utilizes a generative AI model and an emotion engine to streamline the evaluation process of entry data and perform evaluations in real time while maintaining fairness.

[0330] The server first receives the entry data via an online form and stores it in a database. The entry data can be submitted in the form of images, text, videos, etc., and is preprocessed according to the format. Image data is resized to a standard size (e.g., 800x800 pixels) and brightness and contrast are adjusted. Text data is tokenized and noise is removed.

[0331] Users can set the evaluation criteria through the management screen, and can also set the weighting of evaluation items based on these criteria. For example, "Creativity: 40%," "Technical ability: 30%," "Theme expression: 30%," etc. These settings are saved on the server and reflected in the generative AI model.

[0332] After the entry data is preprocessed, it is evaluated by a generative AI model, which evaluates each entry based on the set evaluation criteria and calculates an evaluation score, which is then stored in the database.

[0333] The key is the function of the emotion engine. This engine analyzes the user's emotional state in real time and dynamically adjusts the evaluation criteria. For example, if the user indicates a high stress level, the weight of the evaluation criteria is automatically adjusted so that the user can continue to evaluate in a relaxed state. To achieve this, the emotion engine uses a smart device (such as smart glasses) to acquire the user's biometric information and facial expressions in real time.

[0334] This system enables a more efficient evaluation process, improved fairness, and accurate evaluations in real time. As a concrete example, consider a scenario in which a user is evaluating the latest clothing collection in a physical store. When a user wears smart glasses and evaluates each garment, if the emotion engine detects a high stress level, the weights of the evaluation criteria are automatically adjusted. This allows the user to continue evaluating in a more relaxed state.

[0335] Example prompt sentence:

[0336] "A user uses smart glasses to evaluate the latest clothing collection. If high stress levels are detected, the weights of the evaluation criteria are automatically adjusted, allowing the user to continue evaluating in a more relaxed state."

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

[0338] Step 1:

[0339] The server receives entry data through an online form. This data is a file containing images, text, video, and other formats submitted by users. The server stores this entry data in a database along with the entry ID and upload date and time. The input is the entry data, and the output is the stored database record. Specific operations include parsing the form data and writing it to the database.

[0340] Step 2:

[0341] The server retrieves the entry data from the database and identifies its format. It identifies the format (image, text, video, etc.) and performs preprocessing. For example, for images, it resizes them to a standard size and adjusts the brightness and contrast. The input is the stored entry data, and the output is the preprocessed data. Specific operations include identifying the file format and performing preprocessing calculations.

[0342] Step 3:

[0343] Through the management screen, users can set the evaluation criteria and weights for each evaluation item. For example, they can set "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%." These settings are saved on the server and reflected in the generative AI model. The input is the evaluation criteria set by the user, and the output is the saved evaluation criteria data. Specific operations include operating the user interface and saving data.

[0344] Step 4:

[0345] The server launches the generative AI model and evaluates the preprocessed entry data. The generative AI model evaluates each entry based on the set evaluation criteria and calculates an evaluation score. The input is the preprocessed entry data and the evaluation criteria, and the output is the evaluation score. The specific operation is to run the AI ​​model and calculate the evaluation.

[0346] Step 5:

[0347] The server stores the evaluation scores for each entry in a database. This storage is necessary for subsequent aggregation and notification. The input is the evaluation score calculated by the generative AI model, and the output is the evaluation score stored in the database. The specific operation is to write the data.

[0348] Step 6:

[0349] The server aggregates the reputation scores and calculates the final result, which is used to select and notify top entries. The input is the stored reputation scores, and the output is the aggregated result. The specific operation is to aggregate the data and run the algorithm.

[0350] Step 7:

[0351] The server notifies the user of the aggregation results. Notification methods include email and display on the management screen. The input is the aggregation results, and the output is a notification to the user. The specific operation is to call the notification mechanism.

[0352] Step 8:

[0353] The device analyzes the user's emotional state in real time through the emotion engine and sends it to the server. This automatically adjusts the weights of the evaluation criteria when the user feels stressed. The input is the user's emotional data, and the output is the adjusted evaluation criteria. The specific operation is to analyze and send the emotional data.

[0354] Step 9:

[0355] The terminal allows users to rate entries in real time using their smart devices. If the emotion engine detects high stress, it adjusts the weights of the evaluation criteria, allowing users to continue rating in a relaxed state. The input is the user's emotional state and evaluation criteria, and the output is the real-time evaluation result. Specific operations include analyzing emotion data, adjusting evaluation criteria, and conducting real-time evaluation.

[0356] 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.

[0357] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (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.

[0358] 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.

[0359] [Second embodiment]

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

[0361] 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.

[0362] 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).

[0363] 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.

[0364] 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.

[0365] 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).

[0366] 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.

[0367] 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.

[0368] 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.

[0369] 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.

[0370] 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.

[0371] 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."

[0372] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluation. Specific embodiments of the system are described below.

[0373] Collecting Entries

[0374] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[0375] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0376] Entry classification and preprocessing

[0377] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[0378] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[0379] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[0380] Setting evaluation criteria

[0381] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[0382] The server saves the set evaluation criteria in a database and reflects them in the generative AI model. Weights for each evaluation item may also be set at the same time. For example, the evaluation criteria set by the user, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%," are saved in the database and applied to the generative AI model.

[0383] Rating the entry

[0384] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0385] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the AI ​​generator. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these up to arrive at an overall score of "8.1 points."

[0386] The server stores the evaluation scores and the overall score in a database.

[0387] Calculation and notification of results

[0388] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[0389] The server generates the results and notifies users. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[0390] The system of the present invention allows contest entries to be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing a more transparent and fair evaluation for participants.

[0391] The processing flow will be explained below.

[0392] Step 1: Collecting Entries

[0393] A user submits an entry through an online form, for example, by uploading a JPEG image of a drawing for a painting contest.

[0394] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0395] Step 2: Classifying and preprocessing entries

[0396] The server periodically retrieves new entry files from the database.

[0397] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[0398] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[0399] Step 3: Set evaluation criteria

[0400] Users can set evaluation criteria through the management screen, such as "creativity," "technical ability," and "expression of the theme."

[0401] The user sets the weight of each evaluation item, for example, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%."

[0402] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0403] Step 4: Evaluate the entries

[0404] The server launches the generative AI to evaluate the pre-processed input file, for example, an image, extracts features using a deep learning model, and generates a score based on the evaluation criteria.

[0405] The server calculates an evaluation score for each entry. For example, image "E001" might be given scores such as "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[0406] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added up to arrive at an overall score of "8.0 points."

[0407] The server stores the evaluation scores and the overall score in a database.

[0408] Step 5: Counting and notifying results

[0409] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[0410] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[0411] Example 1

[0412] 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."

[0413] In traditional contest selection processes, the collection, classification, and evaluation of entry data is often done manually, which is time-consuming and labor-intensive, and can lack fairness and consistency. Furthermore, the evaluation criteria and weighting are often unclear, leading to problems of subjective variation among evaluators. Furthermore, when there are a large number of entries, it is difficult to evaluate quickly, and it is difficult to notify participants of the results promptly. To solve these issues, an automated evaluation system is needed.

[0414] 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.

[0415] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in an AI model, means for evaluating the entries using AI and calculating evaluation scores, means for saving the evaluation scores in a database, and means for aggregating the evaluation scores and notifying the results. This automates the process from collecting entries to evaluating them and notifying the results, enabling a fast and fair evaluation process.

[0416] "Entry Data" refers to data provided by Contest participants in the form of images, text, videos, etc.

[0417] "Database" refers to an information system for systematically storing and managing entry data, its metadata, evaluation scores, etc.

[0418] "Format identification" refers to the process of identifying the type of entry data (e.g., JPEG image, TXT text, MP4 video) it belongs to.

[0419] "Preprocessing" refers to processes such as resizing and adjusting brightness and contrast to convert the entry data into a format suitable for evaluation.

[0420] "Evaluation Criteria" refers to the criteria and their respective weightings for evaluating Entries.

[0421] "Artificial intelligence model" refers to a program or algorithm that automatically evaluates entry data according to set evaluation criteria.

[0422] "Evaluation score" refers to the numerical value calculated by the artificial intelligence model for each entry data based on the set evaluation criteria.

[0423] "Aggregation" refers to the process of adding up and comparing multiple evaluation scores to arrive at an overall ranking or result.

[0424] "Notification of results" refers to the act of informing contest participants and organizers of the evaluation scores and aggregated results.

[0425] The system of the present invention uses a generative AI model to streamline the contest selection process and provide fair and consistent evaluation. The system of the present invention combines artificial intelligence, a database, an image processing library, and a text processing library, and specific embodiments of the system are described below.

[0426] First, a user submits an entry to a contest through an online form. Entry data can be submitted in the form of an image, text, video, or other format. For example, a user may enter a painting contest in JPEG image format. The server receives this entry and stores it in a database along with metadata such as the entry ID and upload date and time. This storage is achieved using a web application framework (e.g., Django, Ruby on Rails) and a database management system (e.g., PostgreSQL, MySQL).

[0427] The server then periodically retrieves the entries from the database, either in batches for processing or by retrieving new entries all at once.

[0428] The server identifies the format of the input data and uses an image processing library (e.g., OpenCV) or a file format analysis library (e.g., ffmpeg) to identify the format, such as image, text, or video.

[0429] For example, if image data in JPEG format is uploaded, the server checks the format. Then, the server preprocesses this input data. For example, it resizes the JPEG image to a standard size of 800x800 pixels and uses an image processing library (e.g., Pillow, scikit-image) to adjust the brightness and contrast.

[0430] Users set the evaluation criteria through the management screen. Specifically, in the case of a painting contest, they can set items such as "creativity," "technical ability," and "expression of the theme." In addition, it is possible to set weights for each evaluation item. For example, settings could be "creativity: 40%," "technical ability: 30%," and "expression of the theme: 30%." These settings are received by the server, stored in a database, and reflected in the generative AI model.

[0431] The server then launches the generative AI model and evaluates the preprocessed input data according to the set criteria.

[0432] For example, a prompt might be entered: "Rate this image on creativity, technical ability, and expression of the theme." The generative AI model returns a score for each evaluation criterion, which the server then adds up to calculate an overall score. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Expression of the theme: 9 points," the server will weight these scores accordingly to calculate an overall score of 8.1 points (8 x 0.4 + 7 x 0.3 + 9 x 0.3).

[0433] Finally, the server tally the evaluation scores of all the entry data and select the entry with the highest score. For example, it selects the top 10 entries. The server also generates the results and notifies the participants. Notification methods include displaying the results via email and the management screen. Contest participants are notified of the evaluation results by email, and the organizer sees the details on the management screen.

[0434] In this way, contest entries can be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing participants with a transparent and fair evaluation.

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

[0436] Step 1:

[0437] The user enters entry data into the online form and presses the submit button.

[0438] Input: Data entered by a user into a form (e.g., image files, text, video, etc.).

[0439] How it works: The server receives and temporarily stores user input data. Specifically, it receives HTTP requests and stores uploaded files in a temporary directory.

[0440] Output: Entry data stored on the server.

[0441] Step 2:

[0442] The server stores the entry data in a database.

[0443] Input: Temporarily saved entry data and metadata (entry ID, upload date and time, etc.).

[0444] How it works: The server generates metadata and stores it in a database along with the entry data, e.g., generating an entry ID and recording the upload date and time.

[0445] Output: Entry data and metadata stored in a database.

[0446] Step 3:

[0447] The server retrieves the new entry data from the database.

[0448] Input: Entry data stored in a database.

[0449] How it works: The server retrieves new entries in batches, e.g., by executing an SQL query to retrieve raw entry data.

[0450] Output: A list of the retrieved entries.

[0451] Step 4:

[0452] The server identifies the type of the entry data and pre-processes it.

[0453] Input: The acquired entry data.

[0454] How it works: The server uses an image processing library (e.g. OpenCV) or a file format parsing library (e.g. ffmpeg) to identify the format, then resizes and adjusts brightness and contrast if it's an image.

[0455] Output: Preprocessed input data.

[0456] Step 5:

[0457] The user sets the evaluation criteria through the management screen.

[0458] Input: Evaluation criteria (e.g., "creativity," "technical ability," "representation of the theme") and weighting information.

[0459] Operation: The user inputs the evaluation criteria on the management screen and saves the settings. Specifically, the evaluation criteria and weighting information are saved in the database.

[0460] Output: Evaluation criteria and weighting information stored in a database.

[0461] Step 6:

[0462] The server launches the generative AI model and evaluates the preprocessed input data.

[0463] Input: Preprocessed entry data and set evaluation criteria.

[0464] How it works: The server inputs a prompt (e.g., "Rate this image on creativity, technical ability, and thematic expression") into the generative AI model, which then calculates a score for each criterion.

[0465] Output: Evaluation score for each entry.

[0466] Step 7:

[0467] The server sums the evaluation scores to calculate an overall score.

[0468] Input: Rating scores and weighting information.

[0469] How it works: The server applies weighting to each evaluation score and calculates the overall score. For example, it calculates "Creativity: 8 points x 0.4 + Technical ability: 7 points x 0.3 + Theme expression: 9 points x 0.3".

[0470] Output: The calculated overall score.

[0471] Step 8:

[0472] The server stores the evaluation scores and the overall score in a database.

[0473] Input: Overall score and evaluation score for each entry data.

[0474] Operation: The server associates the evaluation score and overall score with each entry data and stores them in a database.

[0475] Output: Evaluation scores and overall score stored in a database.

[0476] Step 9:

[0477] The server will tally the evaluation scores of all the entries and select the top entries.

[0478] Input: The total score of all entries stored in the database.

[0479] How it works: The server sorts the total scores in descending order and selects the top 10 entries.

[0480] Output: A list of top entry data.

[0481] Step 10:

[0482] The server generates the results and notifies the user.

[0483] Input: List of top entry data and contact information for each participant.

[0484] What it does: The server generates and sends a result email to the participants, and also provides the organizer with a link to view details on the admin page.

[0485] Output: The result notification email sent and the result displayed on the admin page.

[0486] (Application example 1)

[0487] 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."

[0488] Product inspections in factories are typically done manually, which requires a lot of time and effort. Furthermore, consistency and fairness of evaluations are not guaranteed, which creates quality control issues. Furthermore, similar issues arise when evaluating entries for events such as contests, creating a need for efficient and fair evaluations.

[0489] 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.

[0490] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for collecting sensor data for inspecting product quality in factories, and means for preprocessing the collected sensor data and evaluating quality using the generative AI model. This enables efficient and fair product inspection in factories and evaluation of various contest entries, automating the evaluation process and improving quality control.

[0491] An "entry file" is digital data (images, text, video, etc.) that will be evaluated in contests and product inspections.

[0492] A "database" is a system for organizing, storing, and managing entry files, evaluation scores, metadata, etc.

[0493] A "generative AI model" is an algorithm that uses artificial intelligence techniques such as generative adversarial networks (GANs) to evaluate and generate data based on specific criteria.

[0494] "Preprocessing" refers to data conversion and processing to prepare the entry file in a state suitable for evaluation, depending on its format.

[0495] "Evaluation Criteria" means the criteria and weightings set for evaluating entries and products.

[0496] "Sensor data" refers to input data such as images, audio, and motion data collected by robots and sensors within a factory.

[0497] "Resize" is a process of changing an entry file such as an image to a specified standard size.

[0498] The "evaluation score" is the result of the generative AI model quantifying the entry file and product quality based on the evaluation criteria.

[0499] The "management screen" is a graphical interface that allows users to set evaluation criteria and check evaluation results.

[0500] "Notification" refers to a means of communication to inform users or participants of the evaluation results and information based on them.

[0501] The system for implementing this invention consists of the following steps: First, the server receives the entry file and stores it in a database. Next, the server identifies the entry file format (image, text, video, etc.) and performs appropriate preprocessing. After preprocessing, the user sets evaluation criteria through the management screen and reflects them in the generative AI model.

[0502] After the evaluation criteria are set, the server evaluates the entry files using the generative AI model and calculates an evaluation score based on each evaluation criterion.The evaluation score is then saved in the database again.Finally, the server tallys up the evaluation scores and notifies the user of the results.

[0503] Hardware and software used

[0504] Hardware:

[0505] Robot body (e.g. NVIDIA Jetson): Used for image processing and database communication

[0506] Camera: Used to collect image and video data

[0507] Microphone: Used to collect audio data (optional)

[0508] software:

[0509] TensorFlow / PyTorch: Used to run generative AI models

[0510] OpenCV: Used as an image processing library

[0511] Transformers: Used as a generative AI pipeline for Huggingface

[0512] SQLite / MySQL: Used as a database management system

[0513] Data processing and calculation

[0514] The server first receives the entry file (image, text, video) and stores it in a database. The received data is preprocessed according to its format. For example, image data is resized and its brightness and contrast are adjusted, while text data is tokenized and noise is removed.

[0515] After preprocessing is complete, the user inputs evaluation criteria through the management screen and applies them to the generative AI model. The generative AI model evaluates the quality of the entry file based on the set evaluation criteria and calculates a score based on each criterion. The calculated scores for each evaluation criterion are added up and stored in the database as an overall score.

[0516] Add specific examples to the description

[0517] For example, you can collect images of products in a factory and then input the following prompt sentences into a generative AI model:

[0518] Example prompt sentence:

[0519] 1. "Please rate the quality of this product image based on the following criteria: 1) Creativity of the design: 40%, 2) Accuracy of the process: 30%, 3) Appearance of the final product: 30%."

[0520] 2. "Please rate the quality of this text and provide a score for each category: 1) grammatical accuracy, 2) content relevance, 3) editing quality."

[0521] This allows for efficient and fair inspection of products in factories and evaluation of contest entries, resulting in automation of the evaluation process and improved quality control.

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

[0523] Step 1:

[0524] The server receives the entry file and stores it in the database. The entry file contains images, text, videos, etc., and is saved in the database with metadata such as an ID and upload date and time. Specifically, the server receives the entry file via an HTTP request and stores its contents and metadata in the database using an SQL insert operation.

[0525] Step 2:

[0526] The server retrieves the entry file from the database and identifies the entry file format (e.g., JPEG image, TXT text, MP4 video, etc.). It then performs preprocessing based on the identified format. Specifically, it checks the file extension and performs preprocessing using a library (OpenCV, NLTK, etc.) appropriate for each file format.

[0527] Step 3:

[0528] Using the preprocessed entry file, the server launches the generative AI model and calculates an evaluation score based on the evaluation criteria. The specific operation here is a process in which the preprocessed data is input into the AI ​​model to be used (for example, a classification model using TensorFlow or PyTorch) and an evaluation score is output. The input is the preprocessed data, and the output is a score for each evaluation criterion.

[0529] Step 4:

[0530] The user sets the evaluation criteria through the management screen, and the server reflects those criteria in the generative AI model. Specifically, the server receives the evaluation criteria input through the web interface, stores them in the database, and then applies them to the generative AI model. The input is the criteria specified by the user, and the output is a reflection of the criteria settings for the model.

[0531] Step 5:

[0532] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the generative AI model. Specifically, the server adds up the individual evaluation scores with weighting, outputs the result as an overall score, and saves it back in the database. The input is the individual evaluation scores, and the output is the overall score.

[0533] Step 6:

[0534] The server aggregates the evaluation scores of all entries and notifies the user of the results. The specific operation here is the process of selecting the top N entries and notifying the user of this information via email or the administration screen. The input is the database data where the evaluation scores are stored, and the output is sending a notification.

[0535] Step 7:

[0536] To inspect product quality in a factory, a server collects sensor data (images, audio, video, etc.) and performs preprocessing. For example, it resizes product images taken with a camera and adjusts their brightness and contrast. Specifically, it acquires data from IoT sensors in real time and inputs it into a preprocessing algorithm (e.g., OpenCV). The input is raw sensor data, and the output is preprocessed data.

[0537] Step 8:

[0538] Based on the collected and preprocessed sensor data, the server evaluates the quality using a generative AI model. The specific operation here is that the AI ​​model calculates a quality score based on the preprocessed data and stores the result in a database. The input is the preprocessed sensor data, and the output is the quality score.

[0539] 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.

[0540] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluations. Furthermore, by incorporating an emotion engine that recognizes user emotions and dynamically adjusts the evaluation process based on those emotions, the system becomes more flexible and effective. Specific embodiments of the present invention are described below.

[0541] Collecting Entries

[0542] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[0543] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0544] Entry classification and preprocessing

[0545] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[0546] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[0547] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[0548] Setting evaluation criteria

[0549] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[0550] The user sets the weight of each evaluation item. For example, the weights of the evaluation items can be set as "Creativity: 40%", "Technical ability: 30%", and "Expression of the theme: 30%".

[0551] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0552] Rating the entry

[0553] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0554] The server calculates an evaluation score for each entry. For example, if image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these scores together to arrive at an overall score of "8.0 points."

[0555] The server stores the evaluation scores and the overall score in a database.

[0556] Calculation and notification of results

[0557] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[0558] The server generates the results and notifies users of the results. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[0559] Incorporating an emotion engine

[0560] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data, thereby recognizing the user's emotional state in real time.

[0561] The server analyzes the user's emotion data obtained from the emotion engine and dynamically adjusts the evaluation process based on the user's emotions. For example, if the user is feeling stressed, the evaluation process is simplified to reduce the burden.

[0562] As a specific example, when a user is setting evaluation criteria, the emotion engine acquires the user's facial expression data, and if it determines that the stress level is high, the system automatically adjusts the weighting of the evaluation criteria, allowing the user to make the evaluation in a more relaxed state.

[0563] The system of the present invention not only allows contest entries to be evaluated efficiently and fairly, but also allows for flexible responses to users' emotional states, making the evaluation process more accurate and convenient.

[0564] The processing flow will be explained below.

[0565] Step 1: Collecting Entries

[0566] Users submit their entries through an online form, for example by uploading a JPEG image of their drawing for a painting contest.

[0567] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0568] Step 2: Classifying and preprocessing entries

[0569] The server periodically retrieves new entry files from the database.

[0570] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[0571] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[0572] Step 3: Recognize emotions

[0573] The device collects biometric and facial expression data from the user, for example, by using a webcam or smartphone camera to capture the user's facial expressions.

[0574] The emotion engine analyzes the collected biometric information and facial expression data to recognize the user's emotional state (e.g., stress, joy, excitement, etc.).

[0575] Step 4: Set evaluation criteria

[0576] Users set the evaluation criteria through the management screen. For example, in a painting contest, they can set criteria such as "creativity," "technical ability," and "expression of the theme."

[0577] The server receives emotion recognition data from the emotion engine and dynamically adjusts the evaluation criteria based on that data. For example, if the user is feeling stressed, the weight of the evaluation items will be reduced.

[0578] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0579] Step 5: Evaluate the entries

[0580] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0581] The server calculates an evaluation score for each entry. For example, image "E001" might receive scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[0582] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added together to arrive at an overall score of 8.0 points.

[0583] The server stores the evaluation scores and the overall score in a database.

[0584] Step 6: Counting and notifying results

[0585] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[0586] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[0587] Example 2

[0588] 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."

[0589] Traditional contest selection processes require manual evaluation of many entries, which is time-consuming and labor-intensive, and prone to human bias. Furthermore, the emotional state of the evaluator can affect the evaluation results, making it difficult to provide fair and consistent evaluations.

[0590] 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.

[0591] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, and means for acquiring user emotional data and dynamically adjusting the evaluation process. This not only enables efficient and fair evaluation of entries, but also allows for flexible responses depending on the emotional state of the evaluators.

[0592] An "entry file" is digital data that a user submits to a contest, and may include images, text, videos, and other formats.

[0593] A "database" is a system for efficiently storing and managing data such as entry files and evaluation scores.

[0594] "Preprocessing" is the process of identifying the format, resizing, adjusting brightness and contrast, etc., to make the entry files easier to evaluate.

[0595] The "evaluation criteria" are indicators for objectively evaluating the quality of entries, and include "creativity," "technical ability," and "expression of the theme."

[0596] A "generative AI model" is an artificial intelligence algorithm that evaluates entries based on set evaluation criteria and calculates an evaluation score.

[0597] The "evaluation score" is a numerical value calculated for each entry using a generative AI model, and is calculated for each category, such as "creativity," "technical ability," and "expression of the theme."

[0598] "Emotion data" is data obtained from the user's facial expressions and biometric information, and indicates the user's stress level and emotional state.

[0599] "Dynamic adjustment" is the process of changing the system's behavior or settings based on real-time information, including changing the evaluation process in response to the user's emotional state.

[0600] "Notification" is the process of communicating evaluation results and other important information to users, and is done via email or the system's administration screen.

[0601] The system of the present invention utilizes generative AI to streamline the contest selection process and provide fair and consistent evaluations. It also incorporates an emotion engine that analyzes user emotion data and dynamically adjusts the evaluation process based on that data. A specific embodiment of the system will now be described.

[0602] System Overview

[0603] This system mainly consists of the following hardware and software:

[0604] Server: Responsible for database management, receiving, processing, and evaluating entry files, and analyzing emotion data.

[0605] Terminal: Provides an interface for users to submit entry files and set evaluation criteria.

[0606] Generative AI model: Used to evaluate entries and calculate a rating score.

[0607] Emotion engine: Captures user emotional data and dynamically adjusts the rating process based on that data.

[0608] Collecting Entries

[0609] A user submits an entry through an online form. For example, in the case of a painting contest, the user selects a JPEG image and clicks the upload button. The server receives this entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, a JPEG image with an entry ID of "E001" on October 1, 2023, is saved at "2023-10-01 15:42:00."

[0610] Entry classification and preprocessing

[0611] The server retrieves the entry file from the database and identifies its format. For example, it checks the file extension to identify whether it is a JPEG image, a TXT text file, or an MP4 video file. Then, as preprocessing, it resizes the image to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, the JPEG image with entry ID "E001" is resized to 800x800 pixels.

[0612] Setting evaluation criteria

[0613] Users can set evaluation criteria through the management screen. For example, in the case of a painting contest, they input "creativity," "technical ability," "expression of theme," etc. Furthermore, they specify the weighting of each evaluation item (e.g., "creativity: 40%," "technical ability: 30%," "expression of theme: 30%). The server saves these settings in a database and reflects them in the generative AI model.

[0614] Rating the entry

[0615] The server launches the generation AI and evaluates the preprocessed entry files. The evaluation is performed according to the set criteria. For example, for the JPEG image "E001," the generation AI model obtains scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points." These scores are added together to arrive at an overall score of "8.0 points." The server saves the evaluation scores and overall score in a database.

[0616] Calculation and notification of results

[0617] The server will tally the evaluation scores of all entries and select the top-scoring entries. For example, the top 10 entries will be selected. The server will then generate the results and notify the user. Notifications will be sent via email or the admin panel.

[0618] Incorporating an emotion engine

[0619] While the user sets the evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data. The server analyzes the acquired emotion data and dynamically adjusts the evaluation process based on the user's emotional state. For example, if the user is feeling stressed, the weights of the evaluation criteria will be automatically adjusted, allowing the user to evaluate in a more relaxed state.

[0620] Specific prompt examples

[0621] "Based on the JPEG image, please calculate a score out of 10 for creativity, technical ability, and expression of the theme."

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

[0623] Step 1: Submit your entry file

[0624] A user submits an entry file through an online form. The input is an image, text, or video file selected by the user, which is sent to the server by submitting the form. The output is the entry file received by the server. Specifically, a user accesses the form on a web browser, clicks the "Participate Entry" button, selects a file, and presses the "Submit" button.

[0625] Step 2: Receiving and saving the entry file

[0626] The server receives the submitted entry file and generates metadata such as the entry ID, upload date and time, and file format. The input is the submitted entry file, and the output is a file stored in a database along with the entry ID and upload date and time. Specifically, the server receives the request, extracts the file's metadata, generates an entry ID of "E001", and stores it in the database.

[0627] Step 3: Obtaining the entry file

[0628] The server retrieves entry files from the database. The input is the entry ID in the database, and the output is the retrieved entry file. Specifically, the server sends a query to the database to "get new entries" and retrieves the entry files in bulk.

[0629] Step 4: Identify the file format

[0630] The server identifies the format of each entry file. The input is the retrieved entry file, and the output is the identified file format. Specifically, the server checks the file extension and determines that "E001.jpeg" is in JPEG format.

[0631] Step 5: Preprocessing

[0632] The server preprocesses the acquired entry file. The input is the identified entry file, and the output is the preprocessed file. Specifically, the server uses the "resize" function to resize "E001.jpeg" to 800x800 pixels and adjust the brightness and contrast.

[0633] Step 6: Set evaluation criteria

[0634] The user sets the evaluation criteria through the management screen. The input is the evaluation criteria and weights entered on the management screen, and the output is the evaluation criteria and weights saved in the database. Specifically, the user enters the "Evaluation Criteria Settings" section on the management screen, enters "Creativity," "Technical Ability," and "Theme Expression," and sets the weights.

[0635] Step 7: Reflecting the generative AI model

[0636] The server reflects the set evaluation criteria and weights in the generative AI model. The input is the evaluation criteria and weights stored in the database, and the output is the updated generative AI model. Specifically, the server provides the "evaluation criteria" and "weight" data to the generative AI model and updates the model parameters.

[0637] Step 8: Evaluate the entry file

[0638] The server launches the generation AI to evaluate the preprocessed entry files. The input is the preprocessed entry files and the evaluation criteria, and the output is the evaluation score for each entry file. Specifically, the server uses the "generateAI" function to evaluate the entry files according to the evaluation criteria.

[0639] Step 9: Calculate and store the evaluation score

[0640] The server calculates the evaluation score for each entry and saves it in the database. The input is the evaluation result, and the output is the evaluation score saved in the database. Specifically, the server calculates the score for each entry using the "evaluateEntry" function and saves it in the database using the "saveScores" function.

[0641] Step 10: Aggregating the results

[0642] The server aggregates the rating scores of all entries and selects the top-scoring entries. The input is the rating scores in the database, and the output is a list of the top entries. Specifically, the server queries the score data and lists the top 10 entries.

[0643] Step 11: Notification of results

[0644] The server generates the results and notifies the user of the results. The input is the top entry information, and the output is the notified result. Specifically, the server generates a notification email and sends it to the participants, and displays the results on the management screen for the organizer.

[0645] Step 12: Obtaining Emotion Data

[0646] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background and acquires the user's emotion data. The input is the user's biometric information and facial expression data, and the output is emotion data. Specifically, the emotion engine collects data in real time from webcams and sensors.

[0647] Step 13: Analyze emotion data and calibrate ratings

[0648] The server analyzes the emotion data obtained from the emotion engine and dynamically adjusts the evaluation process. The input is the emotion data, and the output is the adjusted evaluation process. Specifically, when the server uses the "analyzeEmotion" function and determines that the user's stress level is high, it automatically adjusts the weights of the evaluation criteria and simplifies the evaluation process.

[0649] (Application example 2)

[0650] 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."

[0651] Conventional contest evaluation systems have had problems with the cumbersome process of evaluating entries and the lack of consistency in evaluation criteria. Furthermore, the emotional state of the evaluator can affect the evaluation results, limiting the fairness and accuracy of the evaluation. Furthermore, it is often difficult to evaluate entries in real time on-site.

[0652] 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.

[0653] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in a generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for analyzing user emotions in real time and dynamically adjusting the evaluation criteria based on the user's emotional state, and means for evaluating entries using data obtained from a smart device. This makes the evaluation process more efficient, fairer, and possible to evaluate entries in real time.

[0654] "Entry Data" means data submitted for a contest or evaluation, and includes various file formats such as images, text, and video.

[0655] A "database" is a system for structuring and storing entry data, evaluation scores, etc.

[0656] "Preprocessing" refers to processing performed to make the input data easier to analyze, and includes image resizing, brightness and contrast adjustment, text tokenization, noise removal, etc.

[0657] "Evaluation criteria" are the standards for evaluating the entry data, and include items such as creativity, technical ability, and expression of the theme.

[0658] A "generative AI model" is an artificial intelligence model that automatically evaluates entry data based on pre-set evaluation criteria and generates the results.

[0659] The "emotion engine" is a system that analyzes the user's emotional state in real time and dynamically adjusts evaluation criteria based on that data.

[0660] A "smart device" is an electronic device carried by a user, such as a wearable device or smartphone that can connect to the Internet.

[0661] An "evaluation score" is the evaluation result of the entry data calculated by the generative AI model based on the evaluation criteria.

[0662] "Real-time evaluation" is the process of instantly evaluating entry data on the spot.

[0663] The system of the present invention involves a server, terminals, and users working together to evaluate entry data. This system utilizes a generative AI model and an emotion engine to streamline the evaluation process of entry data and perform evaluations in real time while maintaining fairness.

[0664] The server first receives the entry data via an online form and stores it in a database. The entry data can be submitted in the form of images, text, videos, etc., and is preprocessed according to the format. Image data is resized to a standard size (e.g., 800x800 pixels) and brightness and contrast are adjusted. Text data is tokenized and noise is removed.

[0665] Users can set the evaluation criteria through the management screen, and can also set the weighting of evaluation items based on these criteria. For example, "Creativity: 40%," "Technical ability: 30%," "Theme expression: 30%," etc. These settings are saved on the server and reflected in the generative AI model.

[0666] After the entry data is preprocessed, it is evaluated by a generative AI model, which evaluates each entry based on the set evaluation criteria and calculates an evaluation score, which is then stored in the database.

[0667] The key is the function of the emotion engine. This engine analyzes the user's emotional state in real time and dynamically adjusts the evaluation criteria. For example, if the user indicates a high stress level, the weight of the evaluation criteria is automatically adjusted so that the user can continue to evaluate in a relaxed state. To achieve this, the emotion engine uses a smart device (such as smart glasses) to acquire the user's biometric information and facial expressions in real time.

[0668] This system enables a more efficient evaluation process, improved fairness, and accurate evaluations in real time. As a concrete example, consider a scenario in which a user is evaluating the latest clothing collection in a physical store. When a user wears smart glasses and evaluates each garment, if the emotion engine detects a high stress level, the weights of the evaluation criteria are automatically adjusted. This allows the user to continue evaluating in a more relaxed state.

[0669] Example prompt sentence:

[0670] "A user uses smart glasses to evaluate the latest clothing collection. If high stress levels are detected, the weights of the evaluation criteria are automatically adjusted, allowing the user to continue evaluating in a more relaxed state."

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

[0672] Step 1:

[0673] The server receives entry data through an online form. This data is a file containing images, text, video, and other formats submitted by users. The server stores this entry data in a database along with the entry ID and upload date and time. The input is the entry data, and the output is the stored database record. Specific operations include parsing the form data and writing it to the database.

[0674] Step 2:

[0675] The server retrieves the entry data from the database and identifies its format. It identifies the format (image, text, video, etc.) and performs preprocessing. For example, for images, it resizes them to a standard size and adjusts the brightness and contrast. The input is the stored entry data, and the output is the preprocessed data. Specific operations include identifying the file format and performing preprocessing calculations.

[0676] Step 3:

[0677] Through the management screen, users can set the evaluation criteria and weights for each evaluation item. For example, they can set "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%." These settings are saved on the server and reflected in the generative AI model. The input is the evaluation criteria set by the user, and the output is the saved evaluation criteria data. Specific operations include operating the user interface and saving data.

[0678] Step 4:

[0679] The server launches the generative AI model and evaluates the preprocessed entry data. The generative AI model evaluates each entry based on the set evaluation criteria and calculates an evaluation score. The input is the preprocessed entry data and the evaluation criteria, and the output is the evaluation score. The specific operation is to run the AI ​​model and calculate the evaluation.

[0680] Step 5:

[0681] The server stores the evaluation scores for each entry in a database. This storage is necessary for subsequent aggregation and notification. The input is the evaluation score calculated by the generative AI model, and the output is the evaluation score stored in the database. The specific operation is to write the data.

[0682] Step 6:

[0683] The server aggregates the reputation scores and calculates the final result, which is used to select and notify top entries. The input is the stored reputation scores, and the output is the aggregated result. The specific operation is to aggregate the data and run the algorithm.

[0684] Step 7:

[0685] The server notifies the user of the aggregation results. Notification methods include email and display on the management screen. The input is the aggregation results, and the output is a notification to the user. The specific operation is to call the notification mechanism.

[0686] Step 8:

[0687] The device analyzes the user's emotional state in real time through the emotion engine and sends it to the server. This automatically adjusts the weights of the evaluation criteria when the user feels stressed. The input is the user's emotional data, and the output is the adjusted evaluation criteria. The specific operation is to analyze and send the emotional data.

[0688] Step 9:

[0689] The terminal allows users to rate entries in real time using their smart devices. If the emotion engine detects high stress, it adjusts the weights of the evaluation criteria, allowing users to continue rating in a relaxed state. The input is the user's emotional state and evaluation criteria, and the output is the real-time evaluation result. Specific operations include analyzing emotion data, adjusting evaluation criteria, and conducting real-time evaluation.

[0690] 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.

[0691] 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.

[0692] 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.

[0693] [Third embodiment]

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

[0695] 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.

[0696] 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).

[0697] 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.

[0698] 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.

[0699] 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).

[0700] 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.

[0701] 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.

[0702] 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.

[0703] 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.

[0704] 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.

[0705] 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."

[0706] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluation. Specific embodiments of the system are described below.

[0707] Collecting Entries

[0708] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[0709] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0710] Entry classification and preprocessing

[0711] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[0712] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[0713] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[0714] Setting evaluation criteria

[0715] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[0716] The server saves the set evaluation criteria in a database and reflects them in the generative AI model. Weights for each evaluation item may also be set at the same time. For example, the evaluation criteria set by the user, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%," are saved in the database and applied to the generative AI model.

[0717] Rating the entry

[0718] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0719] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the AI ​​generator. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these up to arrive at an overall score of "8.1 points."

[0720] The server stores the evaluation scores and the overall score in a database.

[0721] Calculation and notification of results

[0722] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[0723] The server generates the results and notifies users. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[0724] The system of the present invention allows contest entries to be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing a more transparent and fair evaluation for participants.

[0725] The processing flow will be explained below.

[0726] Step 1: Collecting Entries

[0727] A user submits an entry through an online form, for example, by uploading a JPEG image of a drawing for a painting contest.

[0728] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0729] Step 2: Classifying and preprocessing entries

[0730] The server periodically retrieves new entry files from the database.

[0731] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[0732] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[0733] Step 3: Set evaluation criteria

[0734] Users can set evaluation criteria through the management screen, such as "creativity," "technical ability," and "expression of the theme."

[0735] The user sets the weight of each evaluation item, for example, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%."

[0736] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0737] Step 4: Evaluate the entries

[0738] The server launches the generative AI to evaluate the pre-processed input file, for example, an image, extracts features using a deep learning model, and generates a score based on the evaluation criteria.

[0739] The server calculates an evaluation score for each entry. For example, image "E001" might be given scores such as "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[0740] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added up to arrive at an overall score of "8.0 points."

[0741] The server stores the evaluation scores and the overall score in a database.

[0742] Step 5: Counting and notifying results

[0743] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[0744] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[0745] Example 1

[0746] 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."

[0747] In traditional contest selection processes, the collection, classification, and evaluation of entry data is often done manually, which is time-consuming and labor-intensive, and can lack fairness and consistency. Furthermore, the evaluation criteria and weighting are often unclear, leading to problems of subjective variation among evaluators. Furthermore, when there are a large number of entries, it is difficult to evaluate quickly, and it is difficult to notify participants of the results promptly. To solve these issues, an automated evaluation system is needed.

[0748] 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.

[0749] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in an AI model, means for evaluating the entries using AI and calculating evaluation scores, means for saving the evaluation scores in a database, and means for aggregating the evaluation scores and notifying the results. This automates the process from collecting entries to evaluating them and notifying the results, enabling a fast and fair evaluation process.

[0750] "Entry Data" refers to data provided by Contest participants in the form of images, text, videos, etc.

[0751] "Database" refers to an information system for systematically storing and managing entry data, its metadata, evaluation scores, etc.

[0752] "Format identification" refers to the process of identifying the type of entry data (e.g., JPEG image, TXT text, MP4 video) it belongs to.

[0753] "Preprocessing" refers to processes such as resizing and adjusting brightness and contrast to convert the entry data into a format suitable for evaluation.

[0754] "Evaluation Criteria" refers to the criteria and their respective weightings for evaluating Entries.

[0755] "Artificial intelligence model" refers to a program or algorithm that automatically evaluates entry data according to set evaluation criteria.

[0756] "Evaluation score" refers to the numerical value calculated by the artificial intelligence model for each entry data based on the set evaluation criteria.

[0757] "Aggregation" refers to the process of adding up and comparing multiple evaluation scores to arrive at an overall ranking or result.

[0758] "Notification of results" refers to the act of informing contest participants and organizers of the evaluation scores and aggregated results.

[0759] The system of the present invention uses a generative AI model to streamline the contest selection process and provide fair and consistent evaluation. The system of the present invention combines artificial intelligence, a database, an image processing library, and a text processing library, and specific embodiments of the system are described below.

[0760] First, a user submits an entry to a contest through an online form. Entry data can be submitted in the form of an image, text, video, or other format. For example, a user may enter a painting contest in JPEG image format. The server receives this entry and stores it in a database along with metadata such as the entry ID and upload date and time. This storage is achieved using a web application framework (e.g., Django, Ruby on Rails) and a database management system (e.g., PostgreSQL, MySQL).

[0761] The server then periodically retrieves the entries from the database, either in batches for processing or by retrieving new entries all at once.

[0762] The server identifies the format of the input data and uses an image processing library (e.g., OpenCV) or a file format analysis library (e.g., ffmpeg) to identify the format, such as image, text, or video.

[0763] For example, if image data in JPEG format is uploaded, the server checks the format. Then, the server preprocesses this input data. For example, it resizes the JPEG image to a standard size of 800x800 pixels and uses an image processing library (e.g., Pillow, scikit-image) to adjust the brightness and contrast.

[0764] Users set the evaluation criteria through the management screen. Specifically, in the case of a painting contest, they can set items such as "creativity," "technical ability," and "expression of the theme." In addition, it is possible to set weights for each evaluation item. For example, settings could be "creativity: 40%," "technical ability: 30%," and "expression of the theme: 30%." These settings are received by the server, stored in a database, and reflected in the generative AI model.

[0765] The server then launches the generative AI model and evaluates the preprocessed input data according to the set criteria.

[0766] For example, a prompt might be entered: "Rate this image on creativity, technical ability, and expression of the theme." The generative AI model returns a score for each evaluation criterion, which the server then adds up to calculate an overall score. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Expression of the theme: 9 points," the server will weight these scores accordingly to calculate an overall score of 8.1 points (8 x 0.4 + 7 x 0.3 + 9 x 0.3).

[0767] Finally, the server tally the evaluation scores of all the entry data and select the entry with the highest score. For example, it selects the top 10 entries. The server also generates the results and notifies the participants. Notification methods include displaying the results via email and the management screen. Contest participants are notified of the evaluation results by email, and the organizer sees the details on the management screen.

[0768] In this way, contest entries can be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing participants with a transparent and fair evaluation.

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

[0770] Step 1:

[0771] The user enters entry data into the online form and presses the submit button.

[0772] Input: Data entered by a user into a form (e.g., image files, text, video, etc.).

[0773] How it works: The server receives and temporarily stores user input data. Specifically, it receives HTTP requests and stores uploaded files in a temporary directory.

[0774] Output: Entry data stored on the server.

[0775] Step 2:

[0776] The server stores the entry data in a database.

[0777] Input: Temporarily saved entry data and metadata (entry ID, upload date and time, etc.).

[0778] How it works: The server generates metadata and stores it in a database along with the entry data, e.g., generating an entry ID and recording the upload date and time.

[0779] Output: Entry data and metadata stored in a database.

[0780] Step 3:

[0781] The server retrieves the new entry data from the database.

[0782] Input: Entry data stored in a database.

[0783] How it works: The server retrieves new entries in batches, e.g., by running an SQL query to retrieve raw entry data.

[0784] Output: A list of the retrieved entries.

[0785] Step 4:

[0786] The server identifies the type of the entry data and pre-processes it.

[0787] Input: The acquired entry data.

[0788] How it works: The server uses an image processing library (e.g. OpenCV) or a file format parsing library (e.g. ffmpeg) to identify the format, then resizes and adjusts brightness and contrast if it's an image.

[0789] Output: Preprocessed input data.

[0790] Step 5:

[0791] The user sets the evaluation criteria through the management screen.

[0792] Input: Evaluation criteria (e.g., "creativity," "technical ability," "representation of the theme") and weighting information.

[0793] Operation: The user inputs the evaluation criteria on the management screen and saves the settings. Specifically, the evaluation criteria and weighting information are saved in the database.

[0794] Output: Evaluation criteria and weighting information stored in a database.

[0795] Step 6:

[0796] The server launches the generative AI model and evaluates the preprocessed input data.

[0797] Input: Preprocessed entry data and set evaluation criteria.

[0798] How it works: The server inputs a prompt (e.g., "Rate this image on creativity, technical ability, and thematic expression") into the generative AI model, which then calculates a score for each criterion.

[0799] Output: Evaluation score for each entry.

[0800] Step 7:

[0801] The server sums the evaluation scores to calculate an overall score.

[0802] Input: Rating scores and weighting information.

[0803] How it works: The server applies weighting to each evaluation score and calculates the overall score. For example, it calculates "Creativity: 8 points x 0.4 + Technical ability: 7 points x 0.3 + Theme expression: 9 points x 0.3".

[0804] Output: The calculated overall score.

[0805] Step 8:

[0806] The server stores the evaluation scores and the overall score in a database.

[0807] Input: Overall score and evaluation score for each entry data.

[0808] Operation: The server associates the evaluation score and overall score with each entry data and stores them in a database.

[0809] Output: Evaluation scores and overall score stored in a database.

[0810] Step 9:

[0811] The server will tally the evaluation scores of all the entries and select the top entries.

[0812] Input: The total score of all entries stored in the database.

[0813] How it works: The server sorts the total scores in descending order and selects the top 10 entries.

[0814] Output: A list of top entry data.

[0815] Step 10:

[0816] The server generates the results and notifies the user.

[0817] Input: List of top entry data and contact information for each participant.

[0818] What it does: The server generates and sends a result email to the participants, and also provides the organizer with a link to view details on the admin page.

[0819] Output: The result notification email sent and the result displayed on the admin page.

[0820] (Application example 1)

[0821] 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."

[0822] Product inspections in factories are typically done manually, which requires a lot of time and effort. Furthermore, consistency and fairness of evaluations are not guaranteed, which creates quality control issues. Furthermore, similar issues arise when evaluating entries for events such as contests, creating a need for efficient and fair evaluations.

[0823] 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.

[0824] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for collecting sensor data for inspecting product quality in factories, and means for preprocessing the collected sensor data and evaluating quality using the generative AI model. This enables efficient and fair product inspection in factories and evaluation of various contest entries, automating the evaluation process and improving quality control.

[0825] An "entry file" is digital data (images, text, video, etc.) that will be evaluated in contests and product inspections.

[0826] A "database" is a system for organizing, storing, and managing entry files, evaluation scores, metadata, etc.

[0827] A "generative AI model" is an algorithm that uses artificial intelligence techniques such as generative adversarial networks (GANs) to evaluate and generate data based on specific criteria.

[0828] "Preprocessing" refers to data conversion and processing to prepare the entry file in a state suitable for evaluation, depending on its format.

[0829] "Evaluation Criteria" means the criteria and weightings set for evaluating entries and products.

[0830] "Sensor data" refers to input data such as images, audio, and motion data collected by robots and sensors within a factory.

[0831] "Resize" is a process of changing an entry file such as an image to a specified standard size.

[0832] The "evaluation score" is the result of the generative AI model quantifying the entry file and product quality based on the evaluation criteria.

[0833] The "management screen" is a graphical interface that allows users to set evaluation criteria and check evaluation results.

[0834] "Notification" refers to a means of communication to inform users or participants of the evaluation results and information based on them.

[0835] The system for implementing this invention consists of the following steps: First, the server receives the entry file and stores it in a database. Next, the server identifies the entry file format (image, text, video, etc.) and performs appropriate preprocessing. After preprocessing, the user sets evaluation criteria through the management screen and reflects them in the generative AI model.

[0836] After the evaluation criteria are set, the server evaluates the entry files using the generative AI model and calculates an evaluation score based on each evaluation criterion.The evaluation score is then saved in the database again.Finally, the server tallys up the evaluation scores and notifies the user of the results.

[0837] Hardware and software used

[0838] Hardware:

[0839] Robot body (e.g. NVIDIA Jetson): Used for image processing and database communication

[0840] Camera: Used to collect image and video data

[0841] Microphone: Used to collect audio data (optional)

[0842] software:

[0843] TensorFlow / PyTorch: Used to run generative AI models

[0844] OpenCV: Used as an image processing library

[0845] Transformers: Used as a generative AI pipeline for Huggingface

[0846] SQLite / MySQL: Used as a database management system

[0847] Data processing and calculation

[0848] The server first receives the entry file (image, text, video) and stores it in a database. The received data is preprocessed according to its format. For example, image data is resized and its brightness and contrast are adjusted, while text data is tokenized and noise is removed.

[0849] After preprocessing is complete, the user inputs evaluation criteria through the management screen and applies them to the generative AI model. The generative AI model evaluates the quality of the entry file based on the set evaluation criteria and calculates a score based on each criterion. The calculated scores for each evaluation criterion are added up and stored in the database as an overall score.

[0850] Add specific examples to the description

[0851] For example, you can collect images of products in a factory and then input the following prompt sentences into a generative AI model:

[0852] Example prompt sentence:

[0853] 1. "Please rate the quality of this product image based on the following criteria: 1) Creativity of the design: 40%, 2) Accuracy of the process: 30%, 3) Appearance of the final product: 30%."

[0854] 2. "Please rate the quality of this text and provide a score for each category: 1) grammatical accuracy, 2) content relevance, 3) editing quality."

[0855] This allows for efficient and fair inspection of products in factories and evaluation of contest entries, resulting in automation of the evaluation process and improved quality control.

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

[0857] Step 1:

[0858] The server receives the entry file and stores it in the database. The entry file contains images, text, videos, etc., and is saved in the database with metadata such as an ID and upload date and time. Specifically, the server receives the entry file via an HTTP request and stores its contents and metadata in the database using an SQL insert operation.

[0859] Step 2:

[0860] The server retrieves the entry file from the database and identifies the entry file format (e.g., JPEG image, TXT text, MP4 video, etc.). It then performs preprocessing based on the identified format. Specifically, it checks the file extension and performs preprocessing using a library (OpenCV, NLTK, etc.) appropriate for each file format.

[0861] Step 3:

[0862] Using the preprocessed entry file, the server launches the generative AI model and calculates an evaluation score based on the evaluation criteria. The specific operation here is a process in which the preprocessed data is input into the AI ​​model to be used (for example, a classification model using TensorFlow or PyTorch) and an evaluation score is output. The input is the preprocessed data, and the output is a score for each evaluation criterion.

[0863] Step 4:

[0864] The user sets the evaluation criteria through the management screen, and the server reflects those criteria in the generative AI model. Specifically, the server receives the evaluation criteria input through the web interface, stores them in the database, and then applies them to the generative AI model. The input is the criteria specified by the user, and the output is a reflection of the criteria settings for the model.

[0865] Step 5:

[0866] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the generative AI model. Specifically, the server adds up the individual evaluation scores with weighting, outputs the result as an overall score, and saves it back in the database. The input is the individual evaluation scores, and the output is the overall score.

[0867] Step 6:

[0868] The server aggregates the evaluation scores of all entries and notifies the user of the results. The specific operation here is the process of selecting the top N entries and notifying the user of this information via email or the administration screen. The input is the database data where the evaluation scores are stored, and the output is sending a notification.

[0869] Step 7:

[0870] To inspect product quality in a factory, a server collects sensor data (images, audio, video, etc.) and performs preprocessing. For example, it resizes product images taken with a camera and adjusts their brightness and contrast. Specifically, it acquires data from IoT sensors in real time and inputs it into a preprocessing algorithm (e.g., OpenCV). The input is raw sensor data, and the output is preprocessed data.

[0871] Step 8:

[0872] Based on the collected and preprocessed sensor data, the server evaluates the quality using a generative AI model. The specific operation here is that the AI ​​model calculates a quality score based on the preprocessed data and stores the result in a database. The input is the preprocessed sensor data, and the output is the quality score.

[0873] 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.

[0874] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluations. Furthermore, by incorporating an emotion engine that recognizes user emotions and dynamically adjusts the evaluation process based on those emotions, the system becomes more flexible and effective. Specific embodiments of the present invention are described below.

[0875] Collecting Entries

[0876] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[0877] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0878] Entry classification and preprocessing

[0879] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[0880] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[0881] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[0882] Setting evaluation criteria

[0883] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[0884] The user sets the weight of each evaluation item. For example, the weights of the evaluation items can be set as "Creativity: 40%", "Technical ability: 30%", and "Expression of the theme: 30%".

[0885] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0886] Rating the entry

[0887] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0888] The server calculates an evaluation score for each entry. For example, if image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these scores together to arrive at an overall score of "8.0 points."

[0889] The server stores the evaluation scores and the overall score in a database.

[0890] Calculation and notification of results

[0891] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[0892] The server generates the results and notifies users of the results. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[0893] Incorporating an emotion engine

[0894] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data, thereby recognizing the user's emotional state in real time.

[0895] The server analyzes the user's emotion data obtained from the emotion engine and dynamically adjusts the evaluation process based on the user's emotions. For example, if the user is feeling stressed, the evaluation process is simplified to reduce the burden.

[0896] As a specific example, when a user is setting evaluation criteria, the emotion engine acquires the user's facial expression data, and if it determines that the stress level is high, the system automatically adjusts the weighting of the evaluation criteria, allowing the user to make the evaluation in a more relaxed state.

[0897] The system of the present invention not only allows contest entries to be evaluated efficiently and fairly, but also allows for flexible responses to users' emotional states, making the evaluation process more accurate and convenient.

[0898] The processing flow will be explained below.

[0899] Step 1: Collecting Entries

[0900] Users submit their entries through an online form, for example by uploading a JPEG image of their drawing for a painting contest.

[0901] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[0902] Step 2: Classifying and preprocessing entries

[0903] The server periodically retrieves new entry files from the database.

[0904] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[0905] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[0906] Step 3: Recognize emotions

[0907] The device collects biometric and facial expression data from the user, for example, by using a webcam or smartphone camera to capture the user's facial expressions.

[0908] The emotion engine analyzes the collected biometric information and facial expression data to recognize the user's emotional state (e.g., stress, joy, excitement, etc.).

[0909] Step 4: Set evaluation criteria

[0910] Users set the evaluation criteria through the management screen. For example, in a painting contest, they can set criteria such as "creativity," "technical ability," and "expression of the theme."

[0911] The server receives emotion recognition data from the emotion engine and dynamically adjusts the evaluation criteria based on that data. For example, if the user is feeling stressed, the weight of the evaluation items will be reduced.

[0912] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[0913] Step 5: Evaluate the entries

[0914] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[0915] The server calculates an evaluation score for each entry. For example, image "E001" might receive scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[0916] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added together to arrive at an overall score of 8.0 points.

[0917] The server stores the evaluation scores and the overall score in a database.

[0918] Step 6: Counting and notifying results

[0919] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[0920] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[0921] Example 2

[0922] 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."

[0923] Traditional contest selection processes require manual evaluation of many entries, which is time-consuming and labor-intensive, and prone to human bias. Furthermore, the emotional state of the evaluator can affect the evaluation results, making it difficult to provide fair and consistent evaluations.

[0924] 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.

[0925] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, and means for acquiring user emotional data and dynamically adjusting the evaluation process. This not only enables efficient and fair evaluation of entries, but also allows for flexible responses depending on the emotional state of the evaluators.

[0926] An "entry file" is digital data that a user submits to a contest, and may include images, text, videos, and other formats.

[0927] A "database" is a system for efficiently storing and managing data such as entry files and evaluation scores.

[0928] "Preprocessing" is the process of identifying the format, resizing, adjusting brightness and contrast, etc., to make the entry files easier to evaluate.

[0929] The "evaluation criteria" are indicators for objectively evaluating the quality of entries, and include "creativity," "technical ability," and "expression of the theme."

[0930] A "generative AI model" is an artificial intelligence algorithm that evaluates entries based on set evaluation criteria and calculates an evaluation score.

[0931] The "evaluation score" is a numerical value calculated for each entry using a generative AI model, and is calculated for each category, such as "creativity," "technical ability," and "expression of the theme."

[0932] "Emotion data" is data obtained from the user's facial expressions and biometric information, and indicates the user's stress level and emotional state.

[0933] "Dynamic adjustment" is the process of changing the system's behavior or settings based on real-time information, including changing the evaluation process in response to the user's emotional state.

[0934] "Notification" is the process of communicating evaluation results and other important information to users, and is done via email or the system's administration screen.

[0935] The system of the present invention utilizes generative AI to streamline the contest selection process and provide fair and consistent evaluations. It also incorporates an emotion engine that analyzes user emotion data and dynamically adjusts the evaluation process based on that data. A specific embodiment of the system will now be described.

[0936] System Overview

[0937] This system mainly consists of the following hardware and software:

[0938] Server: Responsible for database management, receiving, processing, and evaluating entry files, and analyzing emotion data.

[0939] Terminal: Provides an interface for users to submit entry files and set evaluation criteria.

[0940] Generative AI model: Used to evaluate entries and calculate a rating score.

[0941] Emotion engine: Captures user emotional data and dynamically adjusts the rating process based on that data.

[0942] Collecting Entries

[0943] A user submits an entry through an online form. For example, in the case of a painting contest, the user selects a JPEG image and clicks the upload button. The server receives this entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, a JPEG image with an entry ID of "E001" on October 1, 2023, is saved at "2023-10-01 15:42:00."

[0944] Entry classification and preprocessing

[0945] The server retrieves the entry file from the database and identifies its format. For example, it checks the file extension to identify whether it is a JPEG image, a TXT text file, or an MP4 video file. Then, as preprocessing, it resizes the image to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, the JPEG image with entry ID "E001" is resized to 800x800 pixels.

[0946] Setting evaluation criteria

[0947] Users can set evaluation criteria through the management screen. For example, in the case of a painting contest, they input "creativity," "technical ability," "expression of theme," etc. Furthermore, they specify the weighting of each evaluation item (e.g., "creativity: 40%," "technical ability: 30%," "expression of theme: 30%). The server saves these settings in a database and reflects them in the generative AI model.

[0948] Rating the entry

[0949] The server launches the generation AI and evaluates the preprocessed entry files. The evaluation is performed according to the set criteria. For example, for the JPEG image "E001," the generation AI model obtains scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points." These scores are added together to arrive at an overall score of "8.0 points." The server saves the evaluation scores and overall score in a database.

[0950] Calculation and notification of results

[0951] The server will tally the evaluation scores of all entries and select the top-scoring entries. For example, the top 10 entries will be selected. The server will then generate the results and notify the user. Notifications will be sent via email or the admin panel.

[0952] Incorporating an emotion engine

[0953] While the user sets the evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data. The server analyzes the acquired emotion data and dynamically adjusts the evaluation process based on the user's emotional state. For example, if the user is feeling stressed, the weights of the evaluation criteria will be automatically adjusted, allowing the user to evaluate in a more relaxed state.

[0954] Specific prompt examples

[0955] "Based on the JPEG image, please calculate a score out of 10 for creativity, technical ability, and expression of the theme."

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

[0957] Step 1: Submit your entry file

[0958] A user submits an entry file through an online form. The input is an image, text, or video file selected by the user, which is sent to the server by submitting the form. The output is the entry file received by the server. Specifically, a user accesses the form on a web browser, clicks the "Participate Entry" button, selects a file, and presses the "Submit" button.

[0959] Step 2: Receiving and saving the entry file

[0960] The server receives the submitted entry file and generates metadata such as the entry ID, upload date and time, and file format. The input is the submitted entry file, and the output is a file stored in a database along with the entry ID and upload date and time. Specifically, the server receives the request, extracts the file's metadata, generates an entry ID of "E001", and stores it in the database.

[0961] Step 3: Obtaining the entry file

[0962] The server retrieves entry files from the database. The input is the entry ID in the database, and the output is the retrieved entry file. Specifically, the server sends a query to the database to "get new entries" and retrieves the entry files in bulk.

[0963] Step 4: Identify the file format

[0964] The server identifies the format of each entry file. The input is the retrieved entry file, and the output is the identified file format. Specifically, the server checks the file extension and determines that "E001.jpeg" is in JPEG format.

[0965] Step 5: Perform preprocessing

[0966] The server preprocesses the acquired entry file. The input is the identified entry file, and the output is the preprocessed file. Specifically, the server uses the "resize" function to resize "E001.jpeg" to 800x800 pixels and adjust the brightness and contrast.

[0967] Step 6: Set evaluation criteria

[0968] The user sets the evaluation criteria through the management screen. The input is the evaluation criteria and weights entered on the management screen, and the output is the evaluation criteria and weights saved in the database. Specifically, the user enters the "Evaluation Criteria Settings" section on the management screen, enters "Creativity," "Technical Ability," and "Theme Expression," and sets the weights.

[0969] Step 7: Reflecting the generative AI model

[0970] The server reflects the set evaluation criteria and weights in the generative AI model. The input is the evaluation criteria and weights stored in the database, and the output is the updated generative AI model. Specifically, the server provides the "evaluation criteria" and "weight" data to the generative AI model and updates the model parameters.

[0971] Step 8: Evaluate the entry file

[0972] The server launches the generation AI to evaluate the preprocessed entry files. The input is the preprocessed entry files and the evaluation criteria, and the output is the evaluation score for each entry file. Specifically, the server uses the "generateAI" function to evaluate the entry files according to the evaluation criteria.

[0973] Step 9: Calculate and store the evaluation score

[0974] The server calculates the evaluation score for each entry and saves it in the database. The input is the evaluation result, and the output is the evaluation score saved in the database. Specifically, the server calculates the score for each entry using the "evaluateEntry" function and saves it in the database using the "saveScores" function.

[0975] Step 10: Aggregating the results

[0976] The server aggregates the rating scores of all entries and selects the top-scoring entries. The input is the rating scores in the database, and the output is a list of the top entries. Specifically, the server queries the score data and lists the top 10 entries.

[0977] Step 11: Notification of results

[0978] The server generates the results and notifies the user of the results. The input is the top entry information, and the output is the notified result. Specifically, the server generates a notification email and sends it to the participants, and displays the results on the management screen for the organizer.

[0979] Step 12: Obtaining Emotion Data

[0980] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background and acquires the user's emotion data. The input is the user's biometric information and facial expression data, and the output is emotion data. Specifically, the emotion engine collects data in real time from webcams and sensors.

[0981] Step 13: Analyze emotion data and calibrate ratings

[0982] The server analyzes the emotion data obtained from the emotion engine and dynamically adjusts the evaluation process. The input is the emotion data, and the output is the adjusted evaluation process. Specifically, when the server uses the "analyzeEmotion" function and determines that the user's stress level is high, it automatically adjusts the weights of the evaluation criteria and simplifies the evaluation process.

[0983] (Application example 2)

[0984] 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."

[0985] Conventional contest evaluation systems have had problems with the cumbersome process of evaluating entries and the lack of consistency in evaluation criteria. Furthermore, the emotional state of the evaluator can affect the evaluation results, limiting the fairness and accuracy of the evaluation. Furthermore, it is often difficult to evaluate entries in real time on-site.

[0986] 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.

[0987] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in a generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for analyzing user emotions in real time and dynamically adjusting the evaluation criteria based on the user's emotional state, and means for evaluating entries using data obtained from a smart device. This makes the evaluation process more efficient, fairer, and possible to evaluate entries in real time.

[0988] "Entry Data" means data submitted for a contest or evaluation, and includes various file formats such as images, text, and video.

[0989] A "database" is a system for structuring and storing entry data, evaluation scores, etc.

[0990] "Preprocessing" refers to processing performed to make the input data easier to analyze, and includes image resizing, brightness and contrast adjustment, text tokenization, noise removal, etc.

[0991] "Evaluation criteria" are the standards for evaluating the entry data, and include items such as creativity, technical ability, and expression of the theme.

[0992] A "generative AI model" is an artificial intelligence model that automatically evaluates entry data based on pre-set evaluation criteria and generates the results.

[0993] The "emotion engine" is a system that analyzes the user's emotional state in real time and dynamically adjusts evaluation criteria based on that data.

[0994] A "smart device" is an electronic device carried by a user, such as a wearable device or smartphone that can connect to the Internet.

[0995] An "evaluation score" is the evaluation result of the entry data calculated by the generative AI model based on the evaluation criteria.

[0996] "Real-time evaluation" is the process of instantly evaluating entry data on the spot.

[0997] The system of the present invention involves a server, terminals, and users working together to evaluate entry data. This system utilizes a generative AI model and an emotion engine to streamline the evaluation process of entry data and perform evaluations in real time while maintaining fairness.

[0998] The server first receives the entry data via an online form and stores it in a database. The entry data can be submitted in the form of images, text, videos, etc., and is preprocessed according to the format. Image data is resized to a standard size (e.g., 800x800 pixels) and brightness and contrast are adjusted. Text data is tokenized and noise is removed.

[0999] Users can set the evaluation criteria through the management screen, and can also set the weighting of evaluation items based on these criteria. For example, "Creativity: 40%," "Technical ability: 30%," "Theme expression: 30%," etc. These settings are saved on the server and reflected in the generative AI model.

[1000] After the entry data is preprocessed, it is evaluated by a generative AI model, which evaluates each entry based on the set evaluation criteria and calculates an evaluation score, which is then stored in the database.

[1001] The key is the function of the emotion engine. This engine analyzes the user's emotional state in real time and dynamically adjusts the evaluation criteria. For example, if the user indicates a high stress level, the weight of the evaluation criteria is automatically adjusted so that the user can continue to evaluate in a relaxed state. To achieve this, the emotion engine uses a smart device (such as smart glasses) to acquire the user's biometric information and facial expressions in real time.

[1002] This system enables a more efficient evaluation process, improved fairness, and accurate evaluations in real time. As a concrete example, consider a scenario in which a user is evaluating the latest clothing collection in a physical store. When a user wears smart glasses and evaluates each garment, if the emotion engine detects a high stress level, the weights of the evaluation criteria are automatically adjusted. This allows the user to continue evaluating in a more relaxed state.

[1003] Example prompt sentence:

[1004] "A user uses smart glasses to evaluate the latest clothing collection. If high stress levels are detected, the weights of the evaluation criteria are automatically adjusted, allowing the user to continue evaluating in a more relaxed state."

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

[1006] Step 1:

[1007] The server receives entry data through an online form. This data is a file containing images, text, video, and other formats submitted by users. The server stores this entry data in a database along with the entry ID and upload date and time. The input is the entry data, and the output is the stored database record. Specific operations include parsing the form data and writing it to the database.

[1008] Step 2:

[1009] The server retrieves the entry data from the database and identifies its format. It identifies the format (image, text, video, etc.) and performs preprocessing. For example, for images, it resizes them to a standard size and adjusts the brightness and contrast. The input is the stored entry data, and the output is the preprocessed data. Specific operations include identifying the file format and performing preprocessing calculations.

[1010] Step 3:

[1011] Through the management screen, users can set the evaluation criteria and weights for each evaluation item. For example, they can set "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%." These settings are saved on the server and reflected in the generative AI model. The input is the evaluation criteria set by the user, and the output is the saved evaluation criteria data. Specific operations include operating the user interface and saving data.

[1012] Step 4:

[1013] The server launches the generative AI model and evaluates the preprocessed entry data. The generative AI model evaluates each entry based on the set evaluation criteria and calculates an evaluation score. The input is the preprocessed entry data and the evaluation criteria, and the output is the evaluation score. The specific operation is to run the AI ​​model and calculate the evaluation.

[1014] Step 5:

[1015] The server stores the evaluation scores for each entry in a database. This storage is necessary for subsequent aggregation and notification. The input is the evaluation score calculated by the generative AI model, and the output is the evaluation score stored in the database. The specific operation is to write the data.

[1016] Step 6:

[1017] The server aggregates the reputation scores and calculates the final result, which is used to select and notify top entries. The input is the stored reputation scores, and the output is the aggregated result. The specific operation is to aggregate the data and run the algorithm.

[1018] Step 7:

[1019] The server notifies the user of the aggregation results. Notification methods include email and display on the management screen. The input is the aggregation results, and the output is a notification to the user. The specific operation is to call the notification mechanism.

[1020] Step 8:

[1021] The device analyzes the user's emotional state in real time through the emotion engine and sends it to the server. This automatically adjusts the weights of the evaluation criteria when the user feels stressed. The input is the user's emotional data, and the output is the adjusted evaluation criteria. The specific operation is to analyze and send the emotional data.

[1022] Step 9:

[1023] The terminal allows users to rate entries in real time using their smart devices. If the emotion engine detects high stress, it adjusts the weights of the evaluation criteria, allowing users to continue rating in a relaxed state. The input is the user's emotional state and evaluation criteria, and the output is the real-time evaluation result. Specific operations include analyzing emotion data, adjusting evaluation criteria, and conducting real-time evaluation.

[1024] 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.

[1025] 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.

[1026] 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.

[1027] [Fourth embodiment]

[1028] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1029] 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.

[1030] 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).

[1031] 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.

[1032] 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.

[1033] 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).

[1034] 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.

[1035] 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.

[1036] 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.

[1037] 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.

[1038] 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.

[1039] 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.

[1040] 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."

[1041] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluation. Specific embodiments of the system are described below.

[1042] Collecting Entries

[1043] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[1044] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[1045] Entry classification and preprocessing

[1046] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[1047] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[1048] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[1049] Setting evaluation criteria

[1050] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[1051] The server saves the set evaluation criteria in a database and reflects them in the generative AI model. Weights for each evaluation item may also be set at the same time. For example, the evaluation criteria set by the user, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%," are saved in the database and applied to the generative AI model.

[1052] Rating the entry

[1053] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[1054] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the AI ​​generator. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these up to arrive at an overall score of "8.1 points."

[1055] The server stores the evaluation scores and the overall score in a database.

[1056] Calculation and notification of results

[1057] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[1058] The server generates the results and notifies users. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[1059] The system of the present invention allows contest entries to be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing a more transparent and fair evaluation for participants.

[1060] The processing flow will be explained below.

[1061] Step 1: Collecting Entries

[1062] A user submits an entry through an online form, for example, by uploading a JPEG image of a drawing for a painting contest.

[1063] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[1064] Step 2: Classifying and preprocessing entries

[1065] The server periodically retrieves new entry files from the database.

[1066] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[1067] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[1068] Step 3: Set evaluation criteria

[1069] Users can set evaluation criteria through the management screen, such as "creativity," "technical ability," and "expression of the theme."

[1070] The user sets the weight of each evaluation item, for example, "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%."

[1071] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[1072] Step 4: Evaluate the entries

[1073] The server launches the generative AI to evaluate the pre-processed input file, for example, an image, extracts features using a deep learning model, and generates a score based on the evaluation criteria.

[1074] The server calculates an evaluation score for each entry. For example, image "E001" might be given scores such as "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[1075] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added up to arrive at an overall score of "8.0 points."

[1076] The server stores the evaluation scores and the overall score in a database.

[1077] Step 5: Counting and notifying results

[1078] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[1079] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[1080] Example 1

[1081] 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."

[1082] In traditional contest selection processes, the collection, classification, and evaluation of entry data is often done manually, which is time-consuming and labor-intensive, and can lack fairness and consistency. Furthermore, the evaluation criteria and weighting are often unclear, leading to problems of subjective variation among evaluators. Furthermore, when there are a large number of entries, it is difficult to evaluate quickly, and it is difficult to notify participants of the results promptly. To solve these issues, an automated evaluation system is needed.

[1083] 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.

[1084] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in an AI model, means for evaluating the entries using AI and calculating evaluation scores, means for saving the evaluation scores in a database, and means for aggregating the evaluation scores and notifying the results. This automates the process from collecting entries to evaluating them and notifying the results, enabling a fast and fair evaluation process.

[1085] "Entry Data" refers to data provided by Contest participants in the form of images, text, videos, etc.

[1086] "Database" refers to an information system for systematically storing and managing entry data, its metadata, evaluation scores, etc.

[1087] "Format identification" refers to the process of identifying the type of entry data (e.g., JPEG image, TXT text, MP4 video) it belongs to.

[1088] "Preprocessing" refers to processes such as resizing and adjusting brightness and contrast to convert the entry data into a format suitable for evaluation.

[1089] "Evaluation Criteria" refers to the criteria and their respective weightings for evaluating Entries.

[1090] "Artificial intelligence model" refers to a program or algorithm that automatically evaluates entry data according to set evaluation criteria.

[1091] "Evaluation score" refers to the numerical value calculated by the artificial intelligence model for each entry data based on the set evaluation criteria.

[1092] "Aggregation" refers to the process of adding up and comparing multiple evaluation scores to arrive at an overall ranking or result.

[1093] "Notification of results" refers to the act of informing contest participants and organizers of the evaluation scores and aggregated results.

[1094] The system of the present invention uses a generative AI model to streamline the contest selection process and provide fair and consistent evaluation. The system of the present invention combines artificial intelligence, a database, an image processing library, and a text processing library, and specific embodiments of the system are described below.

[1095] First, a user submits an entry to a contest through an online form. Entry data can be submitted in the form of an image, text, video, or other format. For example, a user may enter a painting contest in JPEG image format. The server receives this entry and stores it in a database along with metadata such as the entry ID and upload date and time. This storage is achieved using a web application framework (e.g., Django, Ruby on Rails) and a database management system (e.g., PostgreSQL, MySQL).

[1096] The server then periodically retrieves the entries from the database, either in batches for processing or by retrieving new entries all at once.

[1097] The server identifies the format of the input data and uses an image processing library (e.g., OpenCV) or a file format analysis library (e.g., ffmpeg) to identify the format, such as image, text, or video.

[1098] For example, if image data in JPEG format is uploaded, the server checks the format. Then, the server preprocesses this input data. For example, it resizes the JPEG image to a standard size of 800x800 pixels and uses an image processing library (e.g., Pillow, scikit-image) to adjust the brightness and contrast.

[1099] Users set the evaluation criteria through the management screen. Specifically, in the case of a painting contest, they can set items such as "creativity," "technical ability," and "expression of the theme." In addition, it is possible to set weights for each evaluation item. For example, settings could be "creativity: 40%," "technical ability: 30%," and "expression of the theme: 30%." These settings are received by the server, stored in a database, and reflected in the generative AI model.

[1100] The server then launches the generative AI model and evaluates the preprocessed input data according to the set criteria.

[1101] For example, a prompt might be entered: "Rate this image on creativity, technical ability, and expression of the theme." The generative AI model returns a score for each evaluation criterion, which the server then adds up to calculate an overall score. For example, if the JPEG image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Expression of the theme: 9 points," the server will weight these scores accordingly to calculate an overall score of 8.1 points (8 x 0.4 + 7 x 0.3 + 9 x 0.3).

[1102] Finally, the server tally the evaluation scores of all the entry data and select the entry with the highest score. For example, it selects the top 10 entries. The server also generates the results and notifies the participants. Notification methods include displaying the results via email and the management screen. Contest participants are notified of the evaluation results by email, and the organizer sees the details on the management screen.

[1103] In this way, contest entries can be evaluated efficiently and fairly, greatly simplifying the judging process, reducing the workload of judges and providing participants with a transparent and fair evaluation.

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

[1105] Step 1:

[1106] The user enters entry data into the online form and presses the submit button.

[1107] Input: Data entered by a user into a form (e.g., image files, text, video, etc.).

[1108] How it works: The server receives and temporarily stores user input data. Specifically, it receives HTTP requests and stores uploaded files in a temporary directory.

[1109] Output: Entry data stored on the server.

[1110] Step 2:

[1111] The server stores the entry data in a database.

[1112] Input: Temporarily saved entry data and metadata (entry ID, upload date and time, etc.).

[1113] How it works: The server generates metadata and stores it in a database along with the entry data, e.g., generating an entry ID and recording the upload date and time.

[1114] Output: Entry data and metadata stored in a database.

[1115] Step 3:

[1116] The server retrieves the new entry data from the database.

[1117] Input: Entry data stored in a database.

[1118] How it works: The server retrieves new entries in batches, e.g., by running an SQL query to retrieve raw entry data.

[1119] Output: A list of the retrieved entries.

[1120] Step 4:

[1121] The server identifies the type of the entry data and pre-processes it.

[1122] Input: The acquired entry data.

[1123] How it works: The server uses an image processing library (e.g. OpenCV) or a file format parsing library (e.g. ffmpeg) to identify the format, then resizes and adjusts brightness and contrast if it's an image.

[1124] Output: Preprocessed input data.

[1125] Step 5:

[1126] The user sets the evaluation criteria through the management screen.

[1127] Input: Evaluation criteria (e.g., "creativity," "technical ability," "representation of the theme") and weighting information.

[1128] Operation: The user inputs the evaluation criteria on the management screen and saves the settings. Specifically, the evaluation criteria and weighting information are saved in the database.

[1129] Output: Evaluation criteria and weighting information stored in a database.

[1130] Step 6:

[1131] The server launches the generative AI model and evaluates the preprocessed input data.

[1132] Input: Preprocessed entry data and set evaluation criteria.

[1133] How it works: The server inputs a prompt (e.g., "Rate this image on creativity, technical ability, and thematic expression") into the generative AI model, which then calculates a score for each criterion.

[1134] Output: Evaluation score for each entry.

[1135] Step 7:

[1136] The server sums the evaluation scores to calculate an overall score.

[1137] Input: Rating scores and weighting information.

[1138] How it works: The server applies weighting to each evaluation score and calculates the overall score. For example, it calculates "Creativity: 8 points x 0.4 + Technical ability: 7 points x 0.3 + Theme expression: 9 points x 0.3".

[1139] Output: The calculated overall score.

[1140] Step 8:

[1141] The server stores the evaluation scores and the overall score in a database.

[1142] Input: Overall score and evaluation score for each entry data.

[1143] Operation: The server associates the evaluation score and overall score with each entry data and stores them in a database.

[1144] Output: Evaluation scores and overall score stored in a database.

[1145] Step 9:

[1146] The server will tally the evaluation scores of all the entries and select the top entries.

[1147] Input: The total score of all entries stored in the database.

[1148] How it works: The server sorts the total scores in descending order and selects the top 10 entries.

[1149] Output: A list of top entry data.

[1150] Step 10:

[1151] The server generates the results and notifies the user.

[1152] Input: List of top entry data and contact information for each participant.

[1153] What it does: The server generates and sends a result email to the participants, and also provides the organizer with a link to view details on the admin page.

[1154] Output: The result notification email sent and the result displayed on the admin page.

[1155] (Application example 1)

[1156] 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."

[1157] Product inspections in factories are typically done manually, which requires a lot of time and effort. Furthermore, consistency and fairness of evaluations are not guaranteed, which creates quality control issues. Furthermore, similar issues arise when evaluating entries for events such as contests, creating a need for efficient and fair evaluations.

[1158] 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.

[1159] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for collecting sensor data for inspecting product quality in factories, and means for preprocessing the collected sensor data and evaluating quality using the generative AI model. This enables efficient and fair product inspection in factories and evaluation of various contest entries, automating the evaluation process and improving quality control.

[1160] An "entry file" is digital data (images, text, video, etc.) that will be evaluated in contests and product inspections.

[1161] A "database" is a system for organizing, storing, and managing entry files, evaluation scores, metadata, etc.

[1162] A "generative AI model" is an algorithm that uses artificial intelligence techniques such as generative adversarial networks (GANs) to evaluate and generate data based on specific criteria.

[1163] "Preprocessing" refers to data conversion and processing to prepare the entry file in a state suitable for evaluation, depending on its format.

[1164] "Evaluation Criteria" means the criteria and weightings set for evaluating entries and products.

[1165] "Sensor data" refers to input data such as images, audio, and motion data collected by robots and sensors within a factory.

[1166] "Resize" is a process of changing an entry file such as an image to a specified standard size.

[1167] The "evaluation score" is the result of the generative AI model quantifying the entry file and product quality based on the evaluation criteria.

[1168] The "management screen" is a graphical interface that allows users to set evaluation criteria and check evaluation results.

[1169] "Notification" refers to a means of communication to inform users or participants of the evaluation results and information based on them.

[1170] The system for implementing this invention consists of the following steps: First, the server receives the entry file and stores it in a database. Next, the server identifies the entry file format (image, text, video, etc.) and performs appropriate preprocessing. After preprocessing, the user sets evaluation criteria through the management screen and reflects them in the generative AI model.

[1171] After the evaluation criteria are set, the server evaluates the entry files using the generative AI model and calculates an evaluation score based on each evaluation criterion.The evaluation score is then saved in the database again.Finally, the server tallys up the evaluation scores and notifies the user of the results.

[1172] Hardware and software used

[1173] Hardware:

[1174] Robot body (e.g. NVIDIA Jetson): Used for image processing and database communication

[1175] Camera: Used to collect image and video data

[1176] Microphone: Used to collect audio data (optional)

[1177] software:

[1178] TensorFlow / PyTorch: Used to run generative AI models

[1179] OpenCV: Used as an image processing library

[1180] Transformers: Used as a generative AI pipeline for Huggingface

[1181] SQLite / MySQL: Used as a database management system

[1182] Data processing and calculation

[1183] The server first receives the entry file (image, text, video) and stores it in a database. The received data is preprocessed according to its format. For example, image data is resized and its brightness and contrast are adjusted, while text data is tokenized and noise is removed.

[1184] After preprocessing is complete, the user inputs evaluation criteria through the management screen and applies them to the generative AI model. The generative AI model evaluates the quality of the entry file based on the set evaluation criteria and calculates a score based on each criterion. The calculated scores for each evaluation criterion are added up and stored in the database as an overall score.

[1185] Add specific examples to the description

[1186] For example, you can collect images of products in a factory and then input the following prompt sentences into a generative AI model:

[1187] Example prompt sentence:

[1188] 1. "Please rate the quality of this product image based on the following criteria: 1) Creativity of the design: 40%, 2) Accuracy of the process: 30%, 3) Appearance of the final product: 30%."

[1189] 2. "Please rate the quality of this text and provide a score for each category: 1) grammatical accuracy, 2) content relevance, 3) editing quality."

[1190] This allows for efficient and fair inspection of products in factories and evaluation of contest entries, resulting in automation of the evaluation process and improved quality control.

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

[1192] Step 1:

[1193] The server receives the entry file and stores it in the database. The entry file contains images, text, videos, etc., and is saved in the database with metadata such as an ID and upload date and time. Specifically, the server receives the entry file via an HTTP request and stores its contents and metadata in the database using an SQL insert operation.

[1194] Step 2:

[1195] The server retrieves the entry file from the database and identifies the entry file format (e.g., JPEG image, TXT text, MP4 video, etc.). It then performs preprocessing based on the identified format. Specifically, it checks the file extension and performs preprocessing using a library (OpenCV, NLTK, etc.) appropriate for each file format.

[1196] Step 3:

[1197] Using the preprocessed entry file, the server launches the generative AI model and calculates an evaluation score based on the evaluation criteria. The specific operation here is a process in which the preprocessed data is input into the AI ​​model to be used (for example, a classification model using TensorFlow or PyTorch) and an evaluation score is output. The input is the preprocessed data, and the output is a score for each evaluation criterion.

[1198] Step 4:

[1199] The user sets the evaluation criteria through the management screen, and the server reflects those criteria in the generative AI model. Specifically, the server receives the evaluation criteria input through the web interface, stores them in the database, and then applies them to the generative AI model. The input is the criteria specified by the user, and the output is a reflection of the criteria settings for the model.

[1200] Step 5:

[1201] The server calculates an overall score by adding up the scores for each evaluation criterion obtained from the generative AI model. Specifically, the server adds up the individual evaluation scores with weighting, outputs the result as an overall score, and saves it back in the database. The input is the individual evaluation scores, and the output is the overall score.

[1202] Step 6:

[1203] The server aggregates the evaluation scores of all entries and notifies the user of the results. The specific operation here is the process of selecting the top N entries and notifying the user of this information via email or the administration screen. The input is the database data where the evaluation scores are stored, and the output is sending a notification.

[1204] Step 7:

[1205] To inspect product quality in a factory, a server collects sensor data (images, audio, video, etc.) and performs preprocessing. For example, it resizes product images taken with a camera and adjusts their brightness and contrast. Specifically, it acquires data from IoT sensors in real time and inputs it into a preprocessing algorithm (e.g., OpenCV). The input is raw sensor data, and the output is preprocessed data.

[1206] Step 8:

[1207] Based on the collected and preprocessed sensor data, the server evaluates the quality using a generative AI model. The specific operation here is that the AI ​​model calculates a quality score based on the preprocessed data and stores the result in a database. The input is the preprocessed sensor data, and the output is the quality score.

[1208] 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.

[1209] The system of the present invention uses generative AI to streamline the contest selection process and provide fair and consistent evaluations. Furthermore, by incorporating an emotion engine that recognizes user emotions and dynamically adjusts the evaluation process based on those emotions, the system becomes more flexible and effective. Specific embodiments of the present invention are described below.

[1210] Collecting Entries

[1211] A user submits an entry to a contest through an online form, which may be in the form of an image, text, video, etc.

[1212] The server receives the entry file and stores it in a database along with metadata such as the entry ID, upload date and time, etc. For example, in a painting contest, a participant submits a JPEG image. This image file is stored in the database with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[1213] Entry classification and preprocessing

[1214] The server retrieves the entry file from the database. This is done for processing batches, retrieving new entries in bulk, etc.

[1215] The server identifies the format of each entry file, for example, JPEG image, TXT text, MP4 video, etc.

[1216] The server preprocesses the input files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts brightness and contrast. For text, it tokenizes and denoises them. For example, it takes the JPEG image "E001", resizes it to 800x800 pixels, and adjusts brightness and contrast appropriately.

[1217] Setting evaluation criteria

[1218] Users set the evaluation criteria from the management screen. For example, in a painting contest, items such as "creativity," "technical ability," and "expression of the theme" are set.

[1219] The user sets the weight of each evaluation item. For example, the weights of the evaluation items can be set as "Creativity: 40%", "Technical ability: 30%", and "Expression of the theme: 30%".

[1220] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[1221] Rating the entry

[1222] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[1223] The server calculates an evaluation score for each entry. For example, if image "E001" receives scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points," the server will add these scores together to arrive at an overall score of "8.0 points."

[1224] The server stores the evaluation scores and the overall score in a database.

[1225] Calculation and notification of results

[1226] The server will tally the evaluation scores of all entries and select the top scoring entries, for example the top 10 entries.

[1227] The server generates the results and notifies users of the results. For example, contest participants are notified of the results by email, and the organizer can view detailed results on the management screen.

[1228] Incorporating an emotion engine

[1229] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data, thereby recognizing the user's emotional state in real time.

[1230] The server analyzes the user's emotion data obtained from the emotion engine and dynamically adjusts the evaluation process based on the user's emotions. For example, if the user is feeling stressed, the evaluation process is simplified to reduce the burden.

[1231] As a specific example, when a user is setting evaluation criteria, the emotion engine acquires the user's facial expression data, and if it determines that the stress level is high, the system automatically adjusts the weighting of the evaluation criteria, allowing the user to make the evaluation in a more relaxed state.

[1232] The system of the present invention not only allows contest entries to be evaluated efficiently and fairly, but also allows for flexible responses to users' emotional states, making the evaluation process more accurate and convenient.

[1233] The processing flow will be explained below.

[1234] Step 1: Collecting Entries

[1235] Users submit their entries through an online form, for example by uploading a JPEG image of their drawing for a painting contest.

[1236] The server receives the entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, it is stored with the entry ID "E001" and the upload date and time "2023-10-01 15:42:00".

[1237] Step 2: Classifying and preprocessing entries

[1238] The server periodically retrieves new entry files from the database.

[1239] The server identifies the format of the entry file, for example by analyzing the file extension and distinguishing between JPEG images, TXT text, MP4 videos, etc.

[1240] The server preprocesses the entry files. For images, it resizes them to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, it resizes the JPEG image "E001" to 800x800 pixels and optimizes the image's brightness and contrast.

[1241] Step 3: Recognize emotions

[1242] The device collects biometric and facial expression data from the user, for example, by using a webcam or smartphone camera to capture the user's facial expressions.

[1243] The emotion engine analyzes the collected biometric information and facial expression data to recognize the user's emotional state (e.g., stress, joy, excitement, etc.).

[1244] Step 4: Set evaluation criteria

[1245] Users set the evaluation criteria through the management screen. For example, in a painting contest, they can set criteria such as "creativity," "technical ability," and "expression of the theme."

[1246] The server receives emotion recognition data from the emotion engine and dynamically adjusts the evaluation criteria based on that data. For example, if the user is feeling stressed, the weight of the evaluation items will be reduced.

[1247] The server stores the set evaluation criteria and weights in a database and reflects them in the generative AI model.

[1248] Step 5: Evaluate the entries

[1249] The server launches the generation AI to evaluate the preprocessed entry files according to the set criteria.

[1250] The server calculates an evaluation score for each entry. For example, image "E001" might receive scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points."

[1251] The server adds up the scores for each evaluation criterion to calculate an overall score. For example, "Creativity (40%): 3.2 points," "Technical ability (30%): 2.1 points," and "Theme expression (30%): 2.7 points" are added together to arrive at an overall score of 8.0 points.

[1252] The server stores the evaluation scores and the overall score in a database.

[1253] Step 6: Counting and notifying results

[1254] The server will tally the evaluation scores of all entries and select the entry with the highest overall score and the top 10 entries.

[1255] The server generates the results and notifies users of the results. For example, contest participants receive the results by email, and the organizer can view the detailed results on the management screen.

[1256] Example 2

[1257] 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."

[1258] Traditional contest selection processes require manual evaluation of many entries, which is time-consuming and labor-intensive, and prone to human bias. Furthermore, the emotional state of the evaluator can affect the evaluation results, making it difficult to provide fair and consistent evaluations.

[1259] 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.

[1260] In this invention, the server includes means for receiving entry files and saving them in a database, means for identifying the format of the entry files and preprocessing them, means for setting evaluation criteria and reflecting them in the generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, and means for acquiring user emotional data and dynamically adjusting the evaluation process. This not only enables efficient and fair evaluation of entries, but also allows for flexible responses depending on the emotional state of the evaluators.

[1261] An "entry file" is digital data that a user submits to a contest, and may include images, text, videos, and other formats.

[1262] A "database" is a system for efficiently storing and managing data such as entry files and evaluation scores.

[1263] "Preprocessing" is the process of identifying the format, resizing, adjusting brightness and contrast, etc., to make the entry files easier to evaluate.

[1264] The "evaluation criteria" are indicators for objectively evaluating the quality of entries, and include "creativity," "technical ability," and "expression of the theme."

[1265] A "generative AI model" is an artificial intelligence algorithm that evaluates entries based on set evaluation criteria and calculates an evaluation score.

[1266] The "evaluation score" is a numerical value calculated for each entry using a generative AI model, and is calculated for each category, such as "creativity," "technical ability," and "expression of the theme."

[1267] "Emotion data" is data obtained from the user's facial expressions and biometric information, and indicates the user's stress level and emotional state.

[1268] "Dynamic adjustment" is the process of changing the system's behavior or settings based on real-time information, including changing the evaluation process in response to the user's emotional state.

[1269] "Notification" is the process of communicating evaluation results and other important information to users, and is done via email or the system's administration screen.

[1270] The system of the present invention utilizes generative AI to streamline the contest selection process and provide fair and consistent evaluations. It also incorporates an emotion engine that analyzes user emotion data and dynamically adjusts the evaluation process based on that data. A specific embodiment of the system will now be described.

[1271] System Overview

[1272] This system mainly consists of the following hardware and software:

[1273] Server: Responsible for database management, receiving, processing, and evaluating entry files, and analyzing emotion data.

[1274] Terminal: Provides an interface for users to submit entry files and set evaluation criteria.

[1275] Generative AI model: Used to evaluate entries and calculate a rating score.

[1276] Emotion engine: Captures user emotional data and dynamically adjusts the rating process based on that data.

[1277] Collecting Entries

[1278] A user submits an entry through an online form. For example, in the case of a painting contest, the user selects a JPEG image and clicks the upload button. The server receives this entry file and stores it in a database along with metadata such as the entry ID and upload date and time. For example, a JPEG image with an entry ID of "E001" on October 1, 2023, is saved at "2023-10-01 15:42:00."

[1279] Entry classification and preprocessing

[1280] The server retrieves the entry file from the database and identifies its format. For example, it checks the file extension to identify whether it is a JPEG image, a TXT text file, or an MP4 video file. Then, as preprocessing, it resizes the image to a standard size (e.g., 800x800 pixels) and adjusts the brightness and contrast. For example, the JPEG image with entry ID "E001" is resized to 800x800 pixels.

[1281] Setting evaluation criteria

[1282] Users can set evaluation criteria through the management screen. For example, in the case of a painting contest, they input "creativity," "technical ability," "expression of theme," etc. Furthermore, they specify the weighting of each evaluation item (e.g., "creativity: 40%," "technical ability: 30%," "expression of theme: 30%). The server saves these settings in a database and reflects them in the generative AI model.

[1283] Rating the entry

[1284] The server launches the generation AI and evaluates the preprocessed entry files. The evaluation is performed according to the set criteria. For example, for the JPEG image "E001," the generation AI model obtains scores of "Creativity: 8 points," "Technical ability: 7 points," and "Theme expression: 9 points." These scores are added together to arrive at an overall score of "8.0 points." The server saves the evaluation scores and overall score in a database.

[1285] Calculation and notification of results

[1286] The server will tally the evaluation scores of all entries and select the top-scoring entries. For example, the top 10 entries will be selected. The server will then generate the results and notify the user. Notifications will be sent via email or the admin panel.

[1287] Incorporating an emotion engine

[1288] While the user sets the evaluation criteria through the management screen, the emotion engine runs in the background, collecting the user's biometric information and facial expression data. The server analyzes the acquired emotion data and dynamically adjusts the evaluation process based on the user's emotional state. For example, if the user is feeling stressed, the weights of the evaluation criteria will be automatically adjusted, allowing the user to evaluate in a more relaxed state.

[1289] Specific prompt examples

[1290] "Based on the JPEG image, please calculate a score out of 10 for creativity, technical ability, and expression of the theme."

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

[1292] Step 1: Submit your entry file

[1293] A user submits an entry file through an online form. The input is an image, text, or video file selected by the user, which is sent to the server by submitting the form. The output is the entry file received by the server. Specifically, a user accesses the form on a web browser, clicks the "Participate Entry" button, selects a file, and presses the "Submit" button.

[1294] Step 2: Receiving and saving the entry file

[1295] The server receives the submitted entry file and generates metadata such as the entry ID, upload date and time, and file format. The input is the submitted entry file, and the output is a file stored in a database along with the entry ID and upload date and time. Specifically, the server receives the request, extracts the file's metadata, generates an entry ID of "E001", and stores it in the database.

[1296] Step 3: Obtaining the entry file

[1297] The server retrieves entry files from the database. The input is the entry ID in the database, and the output is the retrieved entry file. Specifically, the server sends a query to the database to "get new entries" and retrieves the entry files in bulk.

[1298] Step 4: Identify the file format

[1299] The server identifies the format of each entry file. The input is the retrieved entry file, and the output is the identified file format. Specifically, the server checks the file extension and determines that "E001.jpeg" is in JPEG format.

[1300] Step 5: Perform preprocessing

[1301] The server preprocesses the acquired entry file. The input is the identified entry file, and the output is the preprocessed file. Specifically, the server uses the "resize" function to resize "E001.jpeg" to 800x800 pixels and adjust the brightness and contrast.

[1302] Step 6: Set evaluation criteria

[1303] The user sets the evaluation criteria through the management screen. The input is the evaluation criteria and weights entered on the management screen, and the output is the evaluation criteria and weights saved in the database. Specifically, the user enters the "Evaluation Criteria Settings" section on the management screen, enters "Creativity," "Technical Ability," and "Theme Expression," and sets the weights.

[1304] Step 7: Reflecting the generative AI model

[1305] The server reflects the set evaluation criteria and weights in the generative AI model. The input is the evaluation criteria and weights stored in the database, and the output is the updated generative AI model. Specifically, the server provides the "evaluation criteria" and "weight" data to the generative AI model and updates the model parameters.

[1306] Step 8: Evaluate the entry file

[1307] The server launches the generation AI to evaluate the preprocessed entry files. The input is the preprocessed entry files and the evaluation criteria, and the output is the evaluation score for each entry file. Specifically, the server uses the "generateAI" function to evaluate the entry files according to the evaluation criteria.

[1308] Step 9: Calculate and store the evaluation score

[1309] The server calculates the evaluation score for each entry and saves it in the database. The input is the evaluation result, and the output is the evaluation score saved in the database. Specifically, the server calculates the score for each entry using the "evaluateEntry" function and saves it in the database using the "saveScores" function.

[1310] Step 10: Aggregating the results

[1311] The server aggregates the rating scores of all entries and selects the top-scoring entries. The input is the rating scores in the database, and the output is a list of the top entries. Specifically, the server queries the score data and lists the top 10 entries.

[1312] Step 11: Notification of results

[1313] The server generates the results and notifies the user of the results. The input is the top entry information, and the output is the notified result. Specifically, the server generates a notification email and sends it to the participants, and displays the results on the management screen for the organizer.

[1314] Step 12: Obtaining Emotion Data

[1315] When a user sets evaluation criteria through the management screen, the emotion engine runs in the background and acquires the user's emotion data. The input is the user's biometric information and facial expression data, and the output is emotion data. Specifically, the emotion engine collects data in real time from webcams and sensors.

[1316] Step 13: Analyze emotion data and calibrate ratings

[1317] The server analyzes the emotion data obtained from the emotion engine and dynamically adjusts the evaluation process. The input is the emotion data, and the output is the adjusted evaluation process. Specifically, when the server uses the "analyzeEmotion" function and determines that the user's stress level is high, it automatically adjusts the weights of the evaluation criteria and simplifies the evaluation process.

[1318] (Application example 2)

[1319] 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."

[1320] Conventional contest evaluation systems have had problems with the cumbersome process of evaluating entries and the lack of consistency in evaluation criteria. Furthermore, the emotional state of the evaluator can affect the evaluation results, limiting the fairness and accuracy of the evaluation. Furthermore, it is often difficult to evaluate entries in real time on-site.

[1321] 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.

[1322] In this invention, the server includes means for receiving entry data and saving it in a database, means for identifying the format of the entry data and preprocessing it, means for setting evaluation criteria and reflecting them in a generative AI model, means for evaluating entries using the generative AI and calculating evaluation scores, means for saving the evaluation scores in a database, means for aggregating the evaluation scores and notifying the results, means for analyzing user emotions in real time and dynamically adjusting the evaluation criteria based on the user's emotional state, and means for evaluating entries using data obtained from a smart device. This makes the evaluation process more efficient, fairer, and possible to evaluate entries in real time.

[1323] "Entry Data" means data submitted for a contest or evaluation, and includes various file formats such as images, text, and video.

[1324] A "database" is a system for structuring and storing entry data, evaluation scores, etc.

[1325] "Preprocessing" refers to processing performed to make the input data easier to analyze, and includes image resizing, brightness and contrast adjustment, text tokenization, noise removal, etc.

[1326] "Evaluation criteria" are the standards for evaluating the entry data, and include items such as creativity, technical ability, and expression of the theme.

[1327] A "generative AI model" is an artificial intelligence model that automatically evaluates entry data based on pre-set evaluation criteria and generates the results.

[1328] The "emotion engine" is a system that analyzes the user's emotional state in real time and dynamically adjusts evaluation criteria based on that data.

[1329] A "smart device" is an electronic device carried by a user, such as a wearable device or smartphone that can connect to the Internet.

[1330] An "evaluation score" is the evaluation result of the entry data calculated by the generative AI model based on the evaluation criteria.

[1331] "Real-time evaluation" is the process of instantly evaluating entry data on the spot.

[1332] The system of the present invention involves a server, terminals, and users working together to evaluate entry data. This system utilizes a generative AI model and an emotion engine to streamline the evaluation process of entry data and perform evaluations in real time while maintaining fairness.

[1333] The server first receives the entry data via an online form and stores it in a database. The entry data can be submitted in the form of images, text, videos, etc., and is preprocessed according to the format. Image data is resized to a standard size (e.g., 800x800 pixels) and brightness and contrast are adjusted. Text data is tokenized and noise is removed.

[1334] Users can set the evaluation criteria through the management screen, and can also set the weighting of evaluation items based on these criteria. For example, "Creativity: 40%," "Technical ability: 30%," "Theme expression: 30%," etc. These settings are saved on the server and reflected in the generative AI model.

[1335] After the entry data is preprocessed, it is evaluated by a generative AI model, which evaluates each entry based on the set evaluation criteria and calculates an evaluation score, which is then stored in the database.

[1336] The key is the function of the emotion engine. This engine analyzes the user's emotional state in real time and dynamically adjusts the evaluation criteria. For example, if the user indicates a high stress level, the weight of the evaluation criteria is automatically adjusted so that the user can continue to evaluate in a relaxed state. To achieve this, the emotion engine uses a smart device (such as smart glasses) to acquire the user's biometric information and facial expressions in real time.

[1337] This system enables a more efficient evaluation process, improved fairness, and accurate evaluations in real time. As a concrete example, consider a scenario in which a user is evaluating the latest clothing collection in a physical store. When a user wears smart glasses and evaluates each garment, if the emotion engine detects a high stress level, the weights of the evaluation criteria are automatically adjusted. This allows the user to continue evaluating in a more relaxed state.

[1338] Example prompt sentence:

[1339] "A user uses smart glasses to evaluate the latest clothing collection. If high stress levels are detected, the weights of the evaluation criteria are automatically adjusted, allowing the user to continue evaluating in a more relaxed state."

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

[1341] Step 1:

[1342] The server receives entry data through an online form. This data is a file containing images, text, video, and other formats submitted by users. The server stores this entry data in a database along with the entry ID and upload date and time. The input is the entry data, and the output is the stored database record. Specific operations include parsing the form data and writing it to the database.

[1343] Step 2:

[1344] The server retrieves the entry data from the database and identifies its format. It identifies the format (image, text, video, etc.) and performs preprocessing. For example, for images, it resizes them to a standard size and adjusts the brightness and contrast. The input is the stored entry data, and the output is the preprocessed data. Specific operations include identifying the file format and performing preprocessing calculations.

[1345] Step 3:

[1346] Through the management screen, users can set the evaluation criteria and weights for each evaluation item. For example, they can set "Creativity: 40%," "Technical ability: 30%," and "Theme expression: 30%." These settings are saved on the server and reflected in the generative AI model. The input is the evaluation criteria set by the user, and the output is the saved evaluation criteria data. Specific operations include operating the user interface and saving data.

[1347] Step 4:

[1348] The server launches the generative AI model and evaluates the preprocessed entry data. The generative AI model evaluates each entry based on the set evaluation criteria and calculates an evaluation score. The input is the preprocessed entry data and the evaluation criteria, and the output is the evaluation score. The specific operation is to run the AI ​​model and calculate the evaluation.

[1349] Step 5:

[1350] The server stores the evaluation scores for each entry in a database. This storage is necessary for subsequent aggregation and notification. The input is the evaluation score calculated by the generative AI model, and the output is the evaluation score stored in the database. The specific operation is to write the data.

[1351] Step 6:

[1352] The server aggregates the reputation scores and calculates the final result, which is used to select and notify top entries. The input is the stored reputation scores, and the output is the aggregated result. The specific operation is to aggregate the data and run the algorithm.

[1353] Step 7:

[1354] The server notifies the user of the aggregation results. Notification methods include email and display on the management screen. The input is the aggregation results, and the output is a notification to the user. The specific operation is to call the notification mechanism.

[1355] Step 8:

[1356] The device analyzes the user's emotional state in real time through the emotion engine and sends it to the server. This automatically adjusts the weights of the evaluation criteria when the user feels stressed. The input is the user's emotional data, and the output is the adjusted evaluation criteria. The specific operation is to analyze and send the emotional data.

[1357] Step 9:

[1358] The terminal allows users to rate entries in real time using their smart devices. If the emotion engine detects high stress, it adjusts the weights of the evaluation criteria, allowing users to continue rating in a relaxed state. The input is the user's emotional state and evaluation criteria, and the output is the real-time evaluation result. Specific operations include analyzing emotion data, adjusting evaluation criteria, and conducting real-time evaluation.

[1359] 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.

[1360] 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.

[1361] 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.

[1362] 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.

[1363] 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.

[1364] 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.

[1365] 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).

[1366] 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.

[1367] 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."

[1368] 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.

[1369] 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).

[1370] 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.

[1371] 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.

[1372] 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.

[1373] 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.

[1374] 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.

[1375] 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.

[1376] 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.

[1377] 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.

[1378] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1379] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1380] The following is further disclosed regarding the above embodiment.

[1381] (Claim 1)

[1382] means for receiving and storing the entry file in a database;

[1383] means for identifying and preprocessing the entry file format;

[1384] A means to set evaluation criteria and reflect them in the generative AI model,

[1385] a means for evaluating entries using a generative AI and calculating an evaluation score;

[1386] a means for storing the evaluation scores in a database;

[1387] A means for aggregating the evaluation scores and notifying the results;

[1388] A system including:

[1389] (Claim 2)

[1390] 10. The system of claim 1, further comprising means for resizing to a standard size and adjusting brightness and contrast depending on the format of the entry file.

[1391] (Claim 3)

[1392] 2. The system according to claim 1, further comprising means for setting evaluation criteria and weights for each evaluation item through a management screen.

[1393] "Example 1"

[1394] (Claim 1)

[1395] means for receiving and storing entry data in a database;

[1396] means for identifying and preprocessing the format of the entry data;

[1397] A means of setting evaluation criteria and reflecting them in the AI ​​model;

[1398] a means for evaluating the entries using artificial intelligence and calculating an evaluation score;

[1399] a means for storing the evaluation scores in a database;

[1400] A means for aggregating the evaluation scores and notifying the results;

[1401] A system including:

[1402] (Claim 2)

[1403] 10. The system of claim 1, further comprising means for resizing to a standard size and adjusting brightness and contrast depending on the format of the entry data.

[1404] (Claim 3)

[1405] 2. The system according to claim 1, further comprising means for setting evaluation criteria and weights for each evaluation item through a management screen.

[1406] "Application Example 1"

[1407] (Claim 1)

[1408] means for receiving and storing the entry file in a database;

[1409] means for identifying and preprocessing the entry file format;

[1410] A means to set evaluation criteria and reflect them in the generative AI model,

[1411] a means for evaluating entries using a generative AI and calculating an evaluation score;

[1412] a means for storing the evaluation scores in a database;

[1413] A means for aggregating the evaluation scores and notifying the results;

[1414] A means for collecting sensor data for inspecting the quality of products in a factory;

[1415] A means to preprocess collected sensor data and evaluate its quality using a generative AI model;

[1416] A system including:

[1417] (Claim 2)

[1418] 10. The system of claim 1, further comprising means for resizing to a standard size and adjusting brightness and contrast depending on the format of the entry file.

[1419] (Claim 3)

[1420] 2. The system according to claim 1, further comprising means for setting evaluation criteria and weights for each evaluation item through a management screen.

[1421] "Example 2: Combining Emotion Engines"

[1422] (Claim 1)

[1423] means for receiving and storing the entry file in a database;

[1424] means for identifying and preprocessing the entry file format;

[1425] A means to set evaluation criteria and reflect them in the generative AI model,

[1426] a means for evaluating entries using a generative AI and calculating an evaluation score;

[1427] a means for storing the evaluation scores in a database;

[1428] A means for aggregating the evaluation scores and notifying the results;

[1429] a means for acquiring user emotion data and dynamically adjusting the evaluation process;

[1430] A system including:

[1431] (Claim 2)

[1432] 10. The system of claim 1, further comprising means for resizing to a standard size and adjusting brightness and contrast depending on the format of the entry file.

[1433] (Claim 3)

[1434] 2. The system according to claim 1, further comprising means for setting evaluation criteria and weights for each evaluation item through a management screen.

[1435] "Application example 2 when combining emotion engines"

[1436] (Claim 1)

[1437] means for receiving and storing entry data in a database;

[1438] means for identifying and preprocessing the format of the entry data;

[1439] A means to set evaluation criteria and reflect them in the generative AI model,

[1440] a means for evaluating entries using a generative AI and calculating an evaluation score;

[1441] a means for storing the evaluation scores in a database;

[1442] A means for aggregating the evaluation scores and notifying the results;

[1443] means for analyzing a user's emotions in real time and dynamically adjusting evaluation criteria based on the user's emotional state;

[1444] a means for evaluating entries using data obtained from smart devices;

[1445] A system including:

[1446] (Claim 2)

[1447] 10. The system of claim 1, further comprising means for resizing to a standard size and adjusting brightness and contrast depending on the format of the entry data.

[1448] (Claim 3)

[1449] 2. The system according to claim 1, further comprising means for setting evaluation criteria and weights for each evaluation item through a management screen. [Explanation of symbols]

[1450] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. means for receiving and storing the entry file in a database; means for identifying and preprocessing the entry file format; A means to set evaluation criteria and reflect them in the generative AI model, a means for evaluating entries using a generative AI and calculating an evaluation score; a means for storing the evaluation scores in a database; A means for aggregating the evaluation scores and notifying the results; A system including:

2. 2. The system of claim 1, further comprising means for resizing to a standard size and adjusting brightness and contrast depending on the format of the entry file.

3. 2. The system according to claim 1, further comprising means for setting evaluation criteria and weights for each evaluation item through a management screen.

Images