System

Abstract

A system is provided.SOLUTION: A system comprising: means for receiving, pre-processing, and storing agricultural information in a database; means for extracting agricultural information from the database and training a generative AI model; means for receiving a request from a user, converting a format of the request, and transmitting the request to a server; means for inferring an optimal planting method based on the request from the user, converting a format of a result of the inference, and transmitting the result to a device; and means for displaying the received result to the user.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] As the birthrate declines and the population ages, it is becoming increasingly difficult to pass on agricultural know-how to the next generation. It is particularly difficult for new entrants to acquire the specific knowledge and skills needed to farm efficiently, resulting in an unstable supply of delicious vegetables. Furthermore, climate change and changes in environmental conditions in agriculture make it difficult to cultivate vegetables effectively using traditional methods. Given this background, there is a growing need for a system to provide efficient and easy-to-understand agricultural know-how. [Means for solving the problem]

[0005] The present invention provides a means for receiving and preprocessing agricultural data and storing that data in a database. This allows past agricultural know-how and experience to be digitized and preserved. It also includes a means for training a generative AI model using data extracted from the database to learn efficient cultivation methods. Furthermore, it provides a means for converting the format of user requests, sending them to a server, and inferring the optimal cultivation method based on those requests. Finally, it provides a system that includes a means for converting the format of the inference results, sending them to a terminal, and displaying the results to the user. This creates an environment where even newcomers can efficiently cultivate delicious vegetables.

[0006] "Agricultural data" refers to various information related to agriculture, such as crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[0007] "Preprocessing" refers to the process of removing noise and missing values ​​from agricultural data and maintaining data quality.

[0008] "Database" refers to a system for storing and managing agricultural data in digital form.

[0009] "AI model" refers to a model that uses machine learning algorithms to learn optimal cultivation methods from agricultural data.

[0010] "Format conversion" refers to the operation of converting data into a format that is easy for other systems to process.

[0011] "Server" refers to a computer system that receives, stores, and retrieves data, trains AI models, and makes inferences based on user requests.

[0012] "Terminal" refers to a device for receiving input from a user and displaying the processing results.

[0013] "Users" refer to new entrants and existing farmers seeking to acquire agricultural know-how and cultivation methods. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0022] [First embodiment]

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

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

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

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

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

[0028] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form 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.

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

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

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

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

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

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

[0035] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. This system receives agricultural data, stores it in a database, trains an AI model, and suggests optimal cultivation methods to users. The program processing of this system is explained below in natural language.

[0036] Program processing and specific examples

[0037] Data collection and storage

[0038] Subject: Server

[0039] The server receives agricultural data provided by farmers. For example, it receives data about tomato cultivation (e.g., soil pH, fertilizer application rate, irrigation schedule, etc.). This data includes details such as cultivation method, weather conditions, soil composition, and yield. This received data is preprocessed to remove noise and missing values. The preprocessed data is then stored in a database.

[0040] Examples:

[0041] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes noise, and stores the data in a database.

[0042] Creating a database of know-how and training AI models

[0043] Subject: Server

[0044] The server extracts past data on the target crop from the database. For example, it extracts all data related to tomato cultivation. This extracted data is used to generate a training dataset for the AI ​​model. The training dataset is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). Based on this, the AI ​​model is trained to learn optimal cultivation conditions and techniques.

[0045] Examples:

[0046] The server trains the AI ​​model based on "cold climate tomato cultivation data" extracted from the database, learning the optimal irrigation schedule and fertilizer combinations.

[0047] Providing information based on user requests

[0048] Subject: Terminal

[0049] The terminal receives the cultivation conditions and desired crop type input by the user. For example, it receives input such as "How to grow tomatoes in cold climates." This request is converted into a format that the server can easily process and sent to the server.

[0050] Examples:

[0051] The terminal allows new farmers to input "I want to grow tomatoes in a cold climate" and sends the request to the server.

[0052] Proposal of optimal cultivation methods

[0053] Subject: Server

[0054] The server receives a user request sent from the device and searches for relevant information from a database based on that request. For example, it searches for data on tomato cultivation in cold climates. It then uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a format that is easy for the user to understand and sent to the device.

[0055] Examples:

[0056] Based on tomato cultivation data from cold regions, the server uses a generative AI model to generate a specific suggestion, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends this to the device.

[0057] Displaying suggestions to users

[0058] Subject: Terminal

[0059] The terminal receives the optimal cultivation method proposal sent from the server and displays it to the user, who can then create a specific cultivation plan based on the proposal.

[0060] Examples:

[0061] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins cultivating tomatoes based on this suggestion.

[0062] In this way, this system can provide farmers and new entrants with efficient and easy-to-understand agricultural know-how, enabling a stable supply of delicious vegetables.

[0063] The processing flow will be explained below.

[0064] Step 1: Data collection and preprocessing

[0065] Subject: Server

[0066] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer application rate, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[0067] Examples:

[0068] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[0069] Step 2: Store in the database

[0070] Subject: Server

[0071] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[0072] Examples:

[0073] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[0074] Step 3: Data extraction

[0075] Subject: Server

[0076] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[0077] Examples:

[0078] The server extracts data on "growing tomatoes in cold climates" from the database.

[0079] Step 4: Generate a training dataset for the AI ​​model

[0080] Subject: Server

[0081] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[0082] Examples:

[0083] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[0084] Step 5: Training the AI ​​model

[0085] Subject: Server

[0086] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[0087] Examples:

[0088] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[0089] Step 6: Receiving a request from the user

[0090] Subject: Terminal

[0091] The terminal receives cultivation conditions and desired crop types input by the user, and converts the received requests into a format that the server can easily process.

[0092] Examples:

[0093] The terminal receives a request input by the user, such as "I want to grow tomatoes in a cold climate," and sends it to the server.

[0094] Step 7: Submitting the request

[0095] Subject: Terminal

[0096] The terminal then sends the converted request to the server, which includes the specific growing conditions and type of crop.

[0097] Examples:

[0098] The terminal transmits the user's request "How to grow tomatoes in cold regions" to the server.

[0099] Step 8: Information Search

[0100] Subject: Server

[0101] The server searches the database for relevant information based on the request sent from the device, extracts the necessary data, and inputs it into the AI ​​model.

[0102] Examples:

[0103] The server searches and extracts data related to tomato cultivation in cold climates from a database.

[0104] Step 9: Inference with the AI ​​model

[0105] Subject: Server

[0106] The server uses an AI model to infer the optimal cultivation method based on the extracted data, converts the inference results into a different format, and sends them to the device.

[0107] Examples:

[0108] The server uses an AI model to infer the optimal cultivation method, which is to sow seeds in April and keep them warm in a plastic tunnel, then converts the format and sends it to the terminal.

[0109] Step 10: View the results

[0110] Subject: Terminal

[0111] The terminal receives the results of the optimal cultivation method sent from the server and displays them to the user.

[0112] Examples:

[0113] The device displays the inference result to the user, "Sow the seeds in April and keep them warm in a plastic tunnel," and the user uses this as a reference when cultivating the crops.

[0114] Example 1

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

[0116] In the agricultural sector, there is a problem in that farmers cannot easily obtain optimal methods for efficiently cultivating delicious vegetables. It is particularly difficult for newcomers and inexperienced farmers to select appropriate cultivation methods and conditions. There is also a need to find cultivation methods that can quickly adapt to variables such as local weather conditions and soil composition.

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

[0118] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database, a means for extracting agricultural data from the database and training a generative AI model, and a means for collecting requests from users, converting the format, and sending the requests to the server, thereby enabling farmers to easily obtain efficient and optimal cultivation methods.

[0119] "Agricultural data" refers to data including information on crop cultivation methods, soil composition, weather conditions, irrigation information, fertilizer amounts, yields, and pest and disease control measures.

[0120] "Preprocessing" refers to processing that removes noise from the received data, complements abnormal values, and standardizes the data format.

[0121] A "database" is a data storage system that stores data in a structured format and allows the data to be easily searched and retrieved as needed.

[0122] A "generative AI model" is a model that outputs optimal cultivation methods and prediction results for input features based on a machine learning algorithm.

[0123] "User requirements" are input information including specific agricultural cultivation conditions, types of crops, and other desired items.

[0124] "Format conversion" is the process of changing data into a format that is easy for the server or terminal to process.

[0125] "Inference" refers to the use of trained generative AI models to calculate optimal cultivation methods and conditions.

[0126] A "terminal" is a device that a user operates to input and receive data. Examples include smartphones and personal computers.

[0127] "Results" are information about optimal cultivation methods and conditions obtained based on inferences from the generative AI model.

[0128] "Display" refers to providing information visually on a terminal screen, etc.

[0129] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. An overview of the system and specific implementation procedures are described below.

[0130] System Overview

[0131] The system is based on the interaction of a server, a terminal, and a user, and has the following main functions:

[0132] 1. Receive agricultural data, preprocess it and store it in a database.

[0133] 2. Train a generative AI model using agricultural data extracted from the database.

[0134] 3. Receive the user's cultivation request, convert it into a different format, and send it to the server.

[0135] 4. The generative AI model is used to infer the optimal cultivation method and the results are sent to the device.

[0136] 5. The terminal displays the received results to the user.

[0137] Data collection and preprocessing

[0138] Subject: Server

[0139] The server receives agricultural data provided by farmers via HTTPS. The received data undergoes preprocessing, such as noise removal and missing value completion. This preprocessing is performed using Python data processing libraries (e.g., Pandas and NumPy). For example, if the soil pH value is abnormal, it is completed using an appropriate predictive model.

[0140] Examples:

[0141] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes outliers, and then stores the data in a database.

[0142] Storing data in a database

[0143] Subject: Server

[0144] Once the preprocessing is complete, the data is stored in an SQL database. MySQL or PostgreSQL are recommended for this system. The data is stored in a structured format that can be later searched and extracted as needed.

[0145] Training an AI model

[0146] Subject: Server

[0147] The server extracts historical data on specific crops from the database and trains a generative AI model using machine learning frameworks such as TensorFlow and PyTorch. For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[0148] Examples:

[0149] The server uses cold-climate tomato cultivation data to train an AI model and learn optimal irrigation schedules and fertilizer combinations.

[0150] User requirement collection and format conversion

[0151] Subject: Terminal

[0152] The user inputs the cultivation conditions and desired crop type via a terminal. The input information is converted into JSON format and sent to the server. Specific software examples include the use of a web-based front-end framework (e.g., React or Vue.js).

[0153] Examples:

[0154] A new farmer types into the terminal, "I want to grow tomatoes in a cold climate," and the request is converted into JSON format and sent to the server.

[0155] Inferring and providing optimal cultivation methods

[0156] Subject: Server

[0157] The server receives the user's request, searches the database for relevant information, uses a generative AI model to infer the optimal cultivation method, and then converts the results into a different format and sends them to the device.

[0158] Examples:

[0159] Based on cold-climate tomato cultivation data, the server generates specific suggestions, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends them to the terminal.

[0160] Displaying suggestions to users

[0161] Subject: Terminal

[0162] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[0163] Examples:

[0164] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins growing tomatoes based on this suggestion.

[0165] This system will enable farmers and new entrants to the industry to receive efficient and easy-to-understand agricultural know-how, ensuring a stable supply of delicious vegetables.

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

[0167] Step 1: Receiving and preprocessing agricultural data

[0168] Subject: Server

[0169] Input: Agricultural data provided by farmers (e.g. soil pH, fertilizer application rates, irrigation schedules, etc.)

[0170] Output: Preprocessed data

[0171] The server receives agricultural data sent by farmers. After receiving the data, it removes noise, complements outliers, and standardizes the data format. Specifically, it uses Python data processing libraries (e.g., Pandas and NumPy) to clean and shape the data. For example, if the received soil pH value is outside the normal range, it is complemented using a predictive model.

[0172] Specific behavior:

[0173] The data receiving module obtains data from the farmer's terminal via HTTPS.

[0174] The data cleansing module checks for outliers (outlier filtering) and performs imputation using appropriate predictive models.

[0175] Step 2: Store the data in the database

[0176] Subject: Server

[0177] Input: Preprocessed data

[0178] Output: Results stored in the database

[0179] The preprocessed data is stored in a database. This system uses an SQL database (e.g., MySQL or PostgreSQL). The data is structured and stored in a format that can be searched and extracted later.

[0180] Specific behavior:

[0181] The database insert module converts the preprocessed data into SQL queries and inserts them into the database.

[0182] Step 3: Extract historical data and train the AI ​​model

[0183] Subject: Server

[0184] Input: Agricultural data extracted from the database

[0185] Output: A trained AI model

[0186] The server extracts historical data on specific crops from a database and trains a generative AI model using Python machine learning libraries (e.g., TensorFlow and PyTorch). For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[0187] Specific behavior:

[0188] The data extraction module retrieves the required information from the database using SQL queries.

[0189] The machine learning module builds an AI model based on the acquired data, generates a training dataset, and trains the model.

[0190] Step 4: Collecting and formatting user requirements

[0191] Subject: Terminal

[0192] Input: Cultivation conditions and crop types entered by the user

[0193] Output: Reformatted user request (JSON format)

[0194] Users input cultivation conditions and the type of crop they want through their terminal. This information is then converted into JSON format for easy processing by the server and sent to the server. Specific software used is a web-based front-end framework (e.g., React or Vue.js).

[0195] Specific behavior:

[0196] A front-end interface displays user input forms and collects input from the user.

[0197] The input data is converted to JSON format and sent to the server.

[0198] Step 5: Infer and provide optimal cultivation methods

[0199] Subject: Server

[0200] Input: User request (JSON format)

[0201] Output: Inference result (optimal cultivation method)

[0202] The server receives the user's request and searches the database for relevant information. It uses a generative AI model to infer the optimal cultivation method, converts the results, and sends them to the device. It uses a Python model inference library (e.g., Scikit-Learn, TensorFlow Serving).

[0203] Specific behavior:

[0204] The request analysis module analyzes the received request and obtains the necessary information from the database.

[0205] The inference module uses a generative AI model to infer optimal cultivation methods.

[0206] The inference results are converted into JSON format or similar and sent to the terminal.

[0207] Step 6: Displaying suggestions to users

[0208] Subject: Terminal

[0209] Input: Inference results sent from the server (JSON format)

[0210] Output: Optimal cultivation method displayed to the user

[0211] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[0212] Specific behavior:

[0213] The response receiving module receives the data from the server.

[0214] A front-end interface analyzes the received data and presents it visually to the user.

[0215] These are the specific processing steps of the program for this system, which allows farmers and newcomers to easily acquire efficient and easy-to-understand agricultural know-how.

[0216] (Application example 1)

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

[0218] Previously, there were systems that proposed optimal cultivation methods based on agricultural data, but these systems required users to manually input data and check the results. Furthermore, the proposed cultivation methods were fixed, making it difficult to provide information in real time. This meant that retailers and store managers, in particular, had few opportunities to instantly learn optimal cultivation methods, making efficient and effective cultivation management difficult.

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

[0220] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the data to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the result, and sending it to a terminal, means for displaying the received result to the user, and means for suggesting cultivation methods to the user in real time via a smart device. This allows managers of brick-and-mortar stores and users of retail stores to instantly learn effective cultivation methods, enabling efficient and flexible crop management and sales.

[0221] "Agricultural data" is a set of information including crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[0222] "Preprocessing" is a data processing step to remove noise and missing values ​​from received data.

[0223] "Database" means a system for efficiently storing, retrieving, and managing pre-processed agricultural data.

[0224] A "generative AI model" is an artificial intelligence algorithm that is trained based on agricultural data and used to infer optimal cultivation methods and conditions.

[0225] "Format conversion" is the process of converting user requests and inference results into an easy-to-handle format.

[0226] The "server" is a central control unit that receives, pre-processes, and stores agricultural data, trains AI models, performs inference, and provides information to users.

[0227] "Smart devices" are mobile information terminals such as smartphones or smart glasses that are used to display cultivation methods in real time.

[0228] "Inference" is the process of using a generative AI model to determine the optimal cultivation method based on user requirements.

[0229] "Real-time" refers to immediate processing and information delivery with minimal delay.

[0230] A "prompt" is a specific instruction or question that inputs the user's request into the generative AI model.

[0231] This invention is a system that allows retailers and store managers to easily propose optimal vegetable cultivation methods for selling in their stores. The program processing of this system is explained below.

[0232] Server Processing

[0233] The server first receives agricultural data, which includes detailed information on cultivation methods, fertilizer usage, weather conditions, and pest control measures. This data is preprocessed to remove noise and missing values, and the formatted data is stored in a database. A high-performance database server is suitable for this purpose.

[0234] Next, the server extracts historical data on the target crop from the database and trains the generative AI model. Here, the training data is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). For training, a random forest regression model is built using Python's sklearn library. This model then learns the optimal cultivation conditions and techniques.

[0235] Terminal handling

[0236] When a user accesses the system through a smart device (such as a smartphone or smart glasses), the terminal receives input from the user. For example, the user may enter "How to grow tomatoes in cold climates" as a prompt. This request is formatted and sent to the server.

[0237] Proposal of optimal cultivation methods

[0238] The server receives the user's request, searches for relevant information from the database, and uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a user-friendly format and sent to the device.

[0239] Displaying suggestions to users

[0240] The terminal displays the optimal cultivation method received from the server to the user. The user can then create a specific cultivation plan based on this suggestion. In addition, by suggesting cultivation methods to users in real time via their smart devices, it is possible to provide instant information to consumers as well.

[0241] Specific examples

[0242] For example, the server receives "tomato cultivation data in cold regions" and stores it in a database. Then, the generative AI model learns optimal irrigation schedules and fertilizer combinations. If a user inputs a request such as "I want to grow tomatoes in a cold region," the server generates a specific suggestion, such as "Sow the seeds in April and keep them warm in a plastic tunnel," and displays it on the smart device.

[0243] Prompt Sentence Examples

[0244] "Tell me about growing tomatoes in cold climates. Can you suggest the best way to grow them?"

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

[0246] Step 1:

[0247] The server first receives agricultural data. Specifically, it receives data sent by API or file transfer from farms and related institutions. This data includes detailed information such as cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures. The input is agricultural data, and the output is data that has been improved through preprocessing.

[0248] Step 2:

[0249] The server preprocesses the received agricultural data. It removes noise and missing values ​​from the input data, and fills and normalizes missing values. This improves the quality of the data and allows it to be stored efficiently in the database. Examples of data processing include removing outliers and filling missing values ​​with the average value. The preprocessed data is then stored in the database.

[0250] Step 3:

[0251] The server extracts historical data about a target crop from a database. For example, it retrieves all historical data about tomato cultivation. The input is a query condition in the database, and the output is the historical data extracted as a result of the query.

[0252] Step 4:

[0253] The server trains a generative AI model based on the extracted data. Specifically, it creates a training dataset by dividing the data into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, palatability index). It then uses Python's sklearn library to build and train a random forest regression model. The input is the training data, and the output is a trained generative AI model.

[0254] Step 5:

[0255] A user accesses the system through a terminal (such as a smartphone or smart glasses) and inputs a prompt. For example, they ask, "How to grow tomatoes in cold climates." This request is sent to the server as user input. The input is the user's prompt, and the output is the request data sent to the server.

[0256] Step 6:

[0257] The server converts the format of the requested data received from the user and performs processing. Specifically, it uses a generative AI model to infer the optimal cultivation method. For example, "Sow seeds in April and keep them warm in a plastic tunnel." The input is the format-converted user request data, and the output is the inference result.

[0258] Step 7:

[0259] The server converts the inference results into a format that is easy for the user to understand (e.g., text or graphics) and sends them to the terminal. The input is the inference results, and the output is the converted result data.

[0260] Step 8:

[0261] The device displays the optimal cultivation method received from the server to the user. For example, a suggested result such as "Sow seeds in April and keep them warm in a plastic tunnel" may be displayed on the screen of a smartphone or smart glasses. The input is the format-converted result data, and the output is the information displayed to the user. This allows the user to create a specific cultivation plan based on the suggestion.

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

[0263] This invention is a vegetable production suggestion service that combines a series of operations, including receiving agricultural data, preprocessing, storing it in a database, training an AI model, processing user requests, and providing information, with an emotion engine that recognizes and analyzes user emotions. The purpose of this system is to provide optimal agricultural support based on the user's emotions. The program processing of this system is explained in detail below.

[0264] Program processing and specific examples

[0265] Data collection and preprocessing

[0266] Subject: Server

[0267] The server receives agricultural data provided by farmers. The data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[0268] Examples:

[0269] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[0270] Storage in the database

[0271] Subject: Server

[0272] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[0273] Examples:

[0274] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[0275] Data Extraction

[0276] Subject: Server

[0277] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[0278] Examples:

[0279] The server extracts data on "growing tomatoes in cold climates" from the database.

[0280] Generating training datasets for AI models

[0281] Subject: Server

[0282] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[0283] Examples:

[0284] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[0285] Training an AI model

[0286] Subject: Server

[0287] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[0288] Examples:

[0289] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[0290] Receiving a user request

[0291] Subject: Terminal

[0292] The terminal receives input from the user, such as cultivation conditions and the type of crop desired. For example, it receives input such as "How to grow tomatoes in cold climates."

[0293] Examples:

[0294] The user inputs "I want to grow tomatoes in a cold climate" into the terminal, which then converts the request into a different format and sends it to the server.

[0295] Emotion recognition by emotion engine

[0296] Subject: Terminal

[0297] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[0298] Examples:

[0299] The device uses an emotion engine to analyze the voice when the user inputs a request and detects the user's stress level.

[0300] Submitting a request

[0301] Subject: Terminal

[0302] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[0303] Examples:

[0304] The terminal transmits the user's request "How to grow tomatoes in cold climates" and its emotional state to the server.

[0305] Information Retrieval and Reasoning

[0306] Subject: Server

[0307] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[0308] Examples:

[0309] The server searches for data on "growing tomatoes in cold climates" and uses a generative AI model to infer the optimal cultivation method: "Sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also suggests simpler methods and additional advice.

[0310] Displaying the results

[0311] Subject: Terminal

[0312] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[0313] Examples:

[0314] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[0315] In this way, this system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[0316] The processing flow will be explained below.

[0317] Step 1: Data collection and preprocessing

[0318] Subject: Server

[0319] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing data. Normalization is also performed to standardize the data format.

[0320] Examples:

[0321] The server receives the "rice cultivation data" (e.g., soil pH 5.5, temperature fluctuations, irrigation frequency) provided by Farmer A, removes outliers and missing data, and normalizes it into a standard format.

[0322] Step 2: Store in the database

[0323] Subject: Server

[0324] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[0325] Examples:

[0326] The server stores the preprocessed "rice cultivation data" in the "rice" category of the database.

[0327] Step 3: Data extraction

[0328] Subject: Server

[0329] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[0330] Examples:

[0331] The server extracts data on "rice cultivation in cool regions" from the database.

[0332] Step 4: Generate a training dataset for the AI ​​model

[0333] Subject: Server

[0334] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[0335] Examples:

[0336] Based on rice cultivation data from cool regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and quality.

[0337] Step 5: Training the AI ​​model

[0338] Subject: Server

[0339] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[0340] Examples:

[0341] The server uses the generated training dataset to train an AI model to learn optimal fertilizer combinations and irrigation schedules for rice cultivation in cool climates.

[0342] Step 6: Receiving a request from the user

[0343] Subject: Terminal

[0344] The terminal receives input from the user about cultivation conditions and the type of crop desired. For example, it receives input such as "How to cultivate rice in cool regions."

[0345] Examples:

[0346] The terminal allows the user to input a request for "the best method for growing rice in cool regions," and then converts the request into a different format before sending it to the server.

[0347] Step 7: Emotion Recognition with the Emotion Engine

[0348] Subject: Terminal

[0349] The device uses an emotion engine to analyze the user's voice and facial expressions to understand the user's emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[0350] Examples:

[0351] The device uses an emotion engine to analyze the voice of the user when requesting cultivation methods and recognizes signs that the user is tired.

[0352] Step 8: Submitting the request

[0353] Subject: Terminal

[0354] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[0355] Examples:

[0356] The terminal transmits the user's request "How to grow rice in cool climates" and its emotional state to the server.

[0357] Step 9: Information retrieval and reasoning

[0358] Subject: Server

[0359] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[0360] Examples:

[0361] The server searches for data related to "rice cultivation in cool climates" and uses a generative AI model to infer the optimal cultivation method, such as "sowing seeds in May and creating a specific irrigation schedule." If the user is feeling stressed, the server also suggests ways to reduce the workload.

[0362] Step 10: View the results

[0363] Subject: Terminal

[0364] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[0365] Examples:

[0366] The device displays the inference result, "seeds should be sown in May and irrigation should be performed every two days," along with a "rest schedule to reduce workload," to the user, who then uses this information to cultivate rice.

[0367] Example 2

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

[0369] In conventional agricultural data management systems, the quality of data is not uniform when receiving, preprocessing, and subsequently utilizing agricultural data, making it difficult to propose highly accurate cultivation methods.In addition, because proposals are made uniformly without taking into account the user's emotional state, there is also the issue of not being able to appropriately address user stress and satisfaction.

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

[0371] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the results to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the results, and sending the results to the terminal, means for recognizing the user's emotional state and analyzing the emotional data, means for adjusting the inference results based on the emotional data, and means for displaying the received results to the user. This makes it possible to propose optimal and personalized cultivation methods to users in different situations and conditions.

[0372] "Agricultural data" refers to a collection of various information related to agriculture, such as crop types, cultivation methods, fertilizer amounts, weather conditions, and pest and disease control measures.

[0373] "Preprocessing" refers to the process of removing noise and missing values ​​from the received data, correcting outliers, and standardizing the data format.

[0374] "Database" refers to a collection of information structured to store pre-processed agricultural data and to enable efficient retrieval and use.

[0375] "Generative AI model" refers to an artificial intelligence model that learns and infers optimal cultivation conditions and methods based on received and preprocessed agricultural data.

[0376] "User requirements" refers to information input by the user specifying the cultivation conditions and the type of crop desired.

[0377] "Format conversion" refers to the process of converting received data or requests into a standardized format.

[0378] "Emotion engine" refers to a function that analyzes the user's voice and facial expression data and recognizes the user's emotional state.

[0379] "Emotion data" refers to information about a user's emotional state analyzed by an emotion engine.

[0380] "Inference results" refer to the results of the generative AI model deriving the optimal cultivation method based on the user's requirements.

[0381] "Terminal" refers to a computing device used by a user to enter data and receive results.

[0382] MODE FOR CARRYING OUT THE INVENTION

[0383] This invention is a system that receives agricultural data, preprocesses it, stores it in a database, trains an AI model, processes user requests, provides information, and recognizes user emotions using an emotion engine. This system is realized using multiple specific hardware and software. Specific embodiments for implementing the invention are described below.

[0384] Data collection and preprocessing

[0385] Subject: Server

[0386] The server receives agricultural data provided by farmers via the Internet. The received data includes information on crop type, cultivation method, fertilizer application rate, weather conditions, and pest and disease control measures. The received data is preprocessed using data processing libraries such as Python and R. This preprocessing includes removing noise and missing values ​​and normalizing the data format.

[0387] Examples:

[0388] The server receives data sent by Farmer A, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%" via an API endpoint. The server uses Python's Pandas library to remove outliers and missing data from the received data and converts it into a unified data format.

[0389] Storage in the database

[0390] Subject: Server

[0391] Once the preprocessing is complete, the data is stored in a database by the server. A relational database such as MySQL or PostgreSQL is used as the database. The data is classified by crop and cultivation conditions, and an index is generated to enable efficient searches.

[0392] Examples:

[0393] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates the necessary indexes.

[0394] Data extraction and AI model training

[0395] Subject: Server

[0396] The server extracts agricultural data from the database and uses it to train a generative AI model. Machine learning libraries such as Scikit-learn and TensorFlow are used to train the AI ​​model. The extracted data is divided into input features and output values ​​and used as a training dataset.

[0397] Examples:

[0398] The server extracts data related to "growing tomatoes in cold climates" from the database and uses Scikit-learn to train a model that learns irrigation schedules and fertilizer combinations appropriate for cold climate conditions.

[0399] User request reception and emotion engine

[0400] Subject: Terminal

[0401] The device receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server. The user can input text or voice, and the device's emotion engine analyzes the user's emotional state. The emotion engine uses a commercial emotion recognition library (such as Microsoft Azure's emotion recognition API).

[0402] Examples:

[0403] The user makes a request through a smartphone app by voice, saying, "I want to grow tomatoes in a cold climate." The device analyzes the voice data with its emotion engine and detects that the user is feeling stressed.

[0404] Submitting requests and providing information

[0405] Subject: Server

[0406] The request data, including emotional data, is sent from the device to the server. The server searches for relevant agricultural information from a database based on the user's request and infers the optimal cultivation method using a generative AI model. It then adjusts the recommendations based on the user's emotional state, converts the results, and sends them to the device.

[0407] Examples:

[0408] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow seeds in April and keep them warm in a plastic tunnel." It also suggests simpler methods and additional advice if the user is feeling stressed.

[0409] Displaying the results

[0410] Subject: Terminal

[0411] The device receives the inference results and advice based on emotions sent from the server and displays them to the user, who then uses the inference results and advice to cultivate the plants.

[0412] Examples:

[0413] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[0414] Example prompt sentence:

[0415] What is the best way to grow tomatoes in cold climates?

[0416] I'd like to know how to grow tomatoes in cold climates. They're currently stressed, so please suggest some easy solutions.

[0417] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

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

[0419] Step 1: Data collection

[0420] Subject: Server

[0421] The server receives agricultural data provided by farmers via the internet, specifically via a dedicated API endpoint, and the data includes crop type, cultivation method, fertilizer amount, weather conditions, and pest and disease control measures.

[0422] Input: Agricultural data from farmers

[0423] Output: Raw data received

[0424] Specific behavior:

[0425] The server receives data sent by Farmer A via the API, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%."

[0426] Step 2: Data Preprocessing

[0427] Subject: Server

[0428] The server preprocesses the received agricultural data to remove noise and missing values ​​and normalize the data format, using the Python Pandas library.

[0429] Input: Raw data received

[0430] Output: Preprocessed data

[0431] Specific behavior:

[0432] The server detects missing values ​​(for example, missing temperature data) and abnormal values ​​(for example, an abnormal pH value of 20) in the received data, corrects and complements them in an appropriate manner, and also standardizes the data format and converts it into JSON format.

[0433] Step 3: Store in the database

[0434] Subject: Server

[0435] After preprocessing, the server stores the data in a database, typically a relational database such as MySQL or PostgreSQL. The data is categorized by crop and cultivation conditions, and an index is generated.

[0436] Input: Preprocessed data

[0437] Output: Data stored in the database

[0438] Specific behavior:

[0439] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates an index to improve search efficiency.

[0440] Step 4: Data extraction

[0441] Subject: Server

[0442] The server extracts agricultural data from the database based on specific conditions, for example, data related to specific growing conditions according to a user's request.

[0443] Input: Data in the database

[0444] Output: Extracted data

[0445] Specific behavior:

[0446] The server uses SQL queries to search and extract data related to "growing tomatoes in cold climates" from the database.

[0447] Step 5: Generate a training dataset for the AI ​​model

[0448] Subject: Server

[0449] The server creates a training dataset for the AI ​​model based on the extracted agricultural data. The dataset is organized into input features and output values.

[0450] Input: Extracted data

[0451] Output: Training dataset

[0452] Specific behavior:

[0453] Based on the extracted cold-region tomato cultivation data, the server uses the Scikit-learn library to separate and organize the data into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, taste index).

[0454] Step 6: Training the AI ​​model

[0455] Subject: Server

[0456] The server uses the training dataset to train the AI ​​model, specifically using machine learning algorithms to learn optimal growing conditions from agricultural data.

[0457] Input: Training dataset

[0458] Output: Trained AI model

[0459] Specific behavior:

[0460] The server uses Scikit-learn and TensorFlow to train a model that learns optimal cultivation conditions based on a training dataset.

[0461] Step 7: Receiving the user's request

[0462] Subject: Terminal

[0463] The terminal receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server.

[0464] Input: User request

[0465] Output: Reformatted request data

[0466] Specific behavior:

[0467] The user inputs "I want to grow tomatoes in a cold climate" through a smartphone app, and the device converts the request into JSON format and sends it to the server.

[0468] Step 8: Emotion Recognition with the Emotion Engine

[0469] Subject: Terminal

[0470] The device analyzes the user's voice and facial expression data using an emotion engine to recognize the user's emotional state.

[0471] Input: User's voice and facial expression data

[0472] Output: Parsed emotion data

[0473] Specific behavior:

[0474] The device collects facial photos and voice data when the user inputs a request, and uses an emotion engine to determine whether the user is "feeling stressed."

[0475] Step 9: Submitting the request

[0476] Subject: Terminal

[0477] The terminal transmits the request data, including the emotional state, to the server.

[0478] Input: Format-converted request data and emotion data

[0479] Output: Request data and emotion data sent to the server

[0480] Specific behavior:

[0481] The terminal transmits the user's request "Please tell me how to grow tomatoes in a cold climate" and data including the user's emotional state to the server.

[0482] Step 10: Information Retrieval and Reasoning

[0483] Subject: Server

[0484] The server searches for relevant agricultural information from a database based on the requested data, uses AI models to infer optimal cultivation methods, and adjusts its suggestions according to the user's emotional state.

[0485] Input: Request data and emotion data

[0486] Output: Inference results and adjusted recommendations

[0487] Specific behavior:

[0488] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also offers easier methods and additional advice.

[0489] Step 11: View the results

[0490] Subject: Terminal

[0491] The terminal receives advice based on optimal cultivation methods and emotions sent from the server and displays it to the user.

[0492] Input: Inference results and adjusted proposals

[0493] Output: Cultivation methods and advice displayed to the user

[0494] Specific behavior:

[0495] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[0496] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[0497] (Application example 2)

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

[0499] In modern agriculture, finding the optimal method for growing crops is important, but this process often causes stress for farmers. There is also a need for detailed support that takes farmers' emotions into consideration while effectively utilizing agricultural data. Therefore, there is a need for a system that proposes optimal cultivation methods based on farmers' emotions, reduces their stress, and enables efficient cultivation.

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

[0501] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database; a means for extracting agricultural data from the database and training a generative AI model; a means for recognizing a user's emotions, adjusting the optimal cultivation method based on the emotions, converting the format of the results, and transmitting them to a terminal; and a means for displaying advice to the user based on the received results and emotions. This makes it possible to propose optimal cultivation methods that take the user's emotions into consideration. It also reduces user stress and provides support for efficient agricultural work.

[0502] "Agricultural data" refers to data that includes information related to agriculture, such as crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[0503] "Preprocessing" refers to a series of processes that remove noise and missing values ​​from received agricultural data and standardize the data format.

[0504] A "database" is a repository of information that stores data in an organized format and makes it easy to search and retrieve.

[0505] A "generative AI model" is a model that uses machine learning algorithms to learn from a training dataset and has the ability to perform a specific task (e.g., infer optimal cultivation methods).

[0506] "User emotion recognition" is the process of analyzing data such as the user's voice and facial expressions to understand their emotional state.

[0507] "Emotion-based adjustment" refers to appropriately changing the cultivation methods and advice provided depending on the user's emotional state.

[0508] "Format conversion" is the operation of converting data into an appropriate format before transmitting the data.

[0509] A "terminal" is a device (e.g., a smartphone or tablet) that a user uses as an interface.

[0510] "Inference" is the process by which a generative AI model determines the best solution or method based on specific input data.

[0511] "Emotion-based advice" is specific advice or recommendations that are provided taking into account the user's emotional state.

[0512] This invention is a food delivery system that combines agricultural data with user emotional information to suggest optimal cultivation methods.

[0513] The server first receives the agricultural data, preprocesses it, and then stores it in a database. Specifically, the agricultural data includes information on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc. The server normalizes this data and removes noise and missing values.

[0514] The server then extracts agricultural data from the database and uses it to train a generative AI model. The AI ​​model outputs indicators of yield and taste based on input features such as soil pH, temperature, and rainfall. The model can also adjust cultivation methods based on the user's emotional information.

[0515] The device receives requests from the user, converts the format, and sends the data to the server.The device also has an emotion engine that recognizes emotional information from the user's voice and facial expressions and analyzes their emotional state.

[0516] The server infers the optimal cultivation method based on the request and emotional information sent from the device, converts the format of the result, and sends it to the device. The inferred result also includes advice based on the user's emotional state. For example, if the user is feeling stressed, simple cultivation methods or additional advice will be provided.

[0517] Finally, the device displays the results and emotional advice sent from the server to the user, allowing the user to implement optimal cultivation methods.

[0518] The system's hardware includes a server for processing data and a smartphone or tablet for users. It uses Python, TensorFlow, OpenCV, pandas, and scikit-learn for software, performing a series of operations: receiving data, preprocessing, storing data, training an AI model, performing emotion recognition, inference, and displaying the results.

[0519] As a concrete example, if a user types into a device, "I want to grow tomatoes in a cold climate," the device converts the request and sends it to the server. At the same time, the device analyzes the user's voice and facial expressions to detect whether the user is feeling stressed. Based on this information, the server infers the optimal cultivation method - "sow the seeds in April and keep them warm in a plastic tunnel" - and adds advice to reduce the user's stress (for example, a schedule for frequent rest and light work) and sends the results to the device. The device displays these results to the user, who uses them as a reference when cultivating the plants.

[0520] Example prompt sentence:

[0521] Analyze a user's facial photo, recognize their emotional state (e.g., stress, joy), and suggest food recommendations based on that. Recommend meals that match your current emotional state.

[0522] In this way, it becomes possible to propose optimal cultivation methods that take the user's emotions into consideration, thereby realizing a system that reduces user stress and supports efficient cultivation work.

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

[0524] Step 1:

[0525] The server receives agricultural data and performs preprocessing. Specifically, it receives data on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc., normalizes the data, and removes noise and missing values. The preprocessed data is then converted into a unified format.

[0526] Input: Agricultural data

[0527] Output: Preprocessed agricultural data

[0528] Step 2:

[0529] The server stores the pre-processed agricultural data in a database, where the data is categorized by crop and structured for easy later retrieval.

[0530] Input: Preprocessed agricultural data

[0531] Output: Agricultural data stored in a database

[0532] Step 3:

[0533] The server extracts agricultural data from the database and trains the generative AI model. The data is divided into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, palatability index), and used as a training dataset for the AI ​​model.

[0534] Input: Agricultural data extracted from a database

[0535] Output: training dataset, generative AI model

[0536] Step 4:

[0537] The server uses a generative AI model to infer optimal cultivation methods, specifically by providing input data to the model, which infers optimal irrigation schedules and fertilizer combinations.

[0538] Input: training dataset, generative AI model

[0539] Output: Inferred optimal cultivation method

[0540] Step 5:

[0541] The terminal receives requests from users, converts the format, and sends the data to the server. Users input cultivation conditions and desired crop types using a smartphone or tablet.

[0542] Input: Request from the user

[0543] Output: Reformatted request data, sent to the server

[0544] Step 6:

[0545] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state, for example, determining whether they are feeling stressed.

[0546] Input: User's voice and facial expression data

[0547] Output: Parsed emotional state

[0548] Step 7:

[0549] The server uses a generative AI model to infer the optimal cultivation method based on the request and emotional information sent from the device, converts the results into a different format, and sends them to the device. The inferred results also include advice based on the emotional information.

[0550] Input: Formatted request data, emotional state

[0551] Output: Inferred optimal cultivation method and advice, format-converted result data, sent to terminal

[0552] Step 8:

[0553] The device displays the results and advice based on the user's emotions to the user, allowing the user to implement optimal cultivation methods.

[0554] Input: Results and advice sent by the server

[0555] Output: What is displayed to the user

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

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

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

[0559] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0572] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. This system receives agricultural data, stores it in a database, trains an AI model, and suggests optimal cultivation methods to users. The program processing of this system is explained below in natural language.

[0573] Program processing and specific examples

[0574] Data collection and storage

[0575] Subject: Server

[0576] The server receives agricultural data provided by farmers. For example, it receives data about tomato cultivation (e.g., soil pH, fertilizer application rate, irrigation schedule, etc.). This data includes details such as cultivation method, weather conditions, soil composition, and yield. This received data is preprocessed to remove noise and missing values. The preprocessed data is then stored in a database.

[0577] Examples:

[0578] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes noise, and stores the data in a database.

[0579] Creating a database of know-how and training AI models

[0580] Subject: Server

[0581] The server extracts past data on the target crop from the database. For example, it extracts all data related to tomato cultivation. This extracted data is used to generate a training dataset for the AI ​​model. The training dataset is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). Based on this, the AI ​​model is trained to learn optimal cultivation conditions and techniques.

[0582] Examples:

[0583] The server trains the AI ​​model based on "cold climate tomato cultivation data" extracted from the database, learning the optimal irrigation schedule and fertilizer combinations.

[0584] Providing information based on user requests

[0585] Subject: Terminal

[0586] The terminal receives the cultivation conditions and desired crop type input by the user. For example, it receives input such as "How to grow tomatoes in cold climates." This request is converted into a format that the server can easily process and sent to the server.

[0587] Examples:

[0588] The terminal allows new farmers to input "I want to grow tomatoes in a cold climate" and sends the request to the server.

[0589] Proposal of optimal cultivation methods

[0590] Subject: Server

[0591] The server receives a user request sent from the device and searches for relevant information from a database based on that request. For example, it searches for data on tomato cultivation in cold climates. It then uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a format that is easy for the user to understand and sent to the device.

[0592] Examples:

[0593] Based on tomato cultivation data from cold regions, the server uses a generative AI model to generate a specific suggestion, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends this to the device.

[0594] Displaying suggestions to users

[0595] Subject: Terminal

[0596] The terminal receives the optimal cultivation method proposal sent from the server and displays it to the user, who can then create a specific cultivation plan based on the proposal.

[0597] Examples:

[0598] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins cultivating tomatoes based on this suggestion.

[0599] In this way, this system can provide farmers and new entrants with efficient and easy-to-understand agricultural know-how, enabling a stable supply of delicious vegetables.

[0600] The processing flow will be explained below.

[0601] Step 1: Data collection and preprocessing

[0602] Subject: Server

[0603] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer application rate, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[0604] Examples:

[0605] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[0606] Step 2: Store in the database

[0607] Subject: Server

[0608] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[0609] Examples:

[0610] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[0611] Step 3: Data extraction

[0612] Subject: Server

[0613] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[0614] Examples:

[0615] The server extracts data on "growing tomatoes in cold climates" from the database.

[0616] Step 4: Generate a training dataset for the AI ​​model

[0617] Subject: Server

[0618] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[0619] Examples:

[0620] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[0621] Step 5: Training the AI ​​model

[0622] Subject: Server

[0623] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[0624] Examples:

[0625] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[0626] Step 6: Receiving a request from the user

[0627] Subject: Terminal

[0628] The terminal receives cultivation conditions and desired crop types input by the user, and converts the received requests into a format that the server can easily process.

[0629] Examples:

[0630] The terminal receives a request input by the user, such as "I want to grow tomatoes in a cold climate," and sends it to the server.

[0631] Step 7: Submitting the request

[0632] Subject: Terminal

[0633] The terminal then sends the converted request to the server, which includes the specific growing conditions and type of crop.

[0634] Examples:

[0635] The terminal transmits the user's request "How to grow tomatoes in cold regions" to the server.

[0636] Step 8: Information Search

[0637] Subject: Server

[0638] The server searches the database for relevant information based on the request sent from the device, extracts the necessary data, and inputs it into the AI ​​model.

[0639] Examples:

[0640] The server searches and extracts data related to tomato cultivation in cold climates from a database.

[0641] Step 9: Inference with the AI ​​model

[0642] Subject: Server

[0643] The server uses an AI model to infer the optimal cultivation method based on the extracted data, converts the inference results into a different format, and sends them to the device.

[0644] Examples:

[0645] The server uses an AI model to infer the optimal cultivation method, which is to sow seeds in April and keep them warm in a plastic tunnel, then converts the format and sends it to the terminal.

[0646] Step 10: View the results

[0647] Subject: Terminal

[0648] The terminal receives the results of the optimal cultivation method sent from the server and displays them to the user.

[0649] Examples:

[0650] The device displays the inference result to the user, "Sow the seeds in April and keep them warm in a plastic tunnel," and the user uses this as a reference when cultivating the crops.

[0651] Example 1

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

[0653] In the agricultural sector, there is a problem in that farmers cannot easily obtain optimal methods for efficiently cultivating delicious vegetables. It is particularly difficult for newcomers and inexperienced farmers to select appropriate cultivation methods and conditions. There is also a need to find cultivation methods that can quickly adapt to variables such as local weather conditions and soil composition.

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

[0655] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database, a means for extracting agricultural data from the database and training a generative AI model, and a means for collecting requests from users, converting the format, and sending the requests to the server, thereby enabling farmers to easily obtain efficient and optimal cultivation methods.

[0656] "Agricultural data" refers to data including information on crop cultivation methods, soil composition, weather conditions, irrigation information, fertilizer amounts, yields, and pest and disease control measures.

[0657] "Preprocessing" refers to processing that removes noise from the received data, complements abnormal values, and standardizes the data format.

[0658] A "database" is a data storage system that stores data in a structured format and allows the data to be easily searched and retrieved as needed.

[0659] A "generative AI model" is a model that outputs optimal cultivation methods and prediction results for input features based on a machine learning algorithm.

[0660] "User requirements" are input information including specific agricultural cultivation conditions, types of crops, and other desired items.

[0661] "Format conversion" is the process of changing data into a format that is easy for the server or terminal to process.

[0662] "Inference" refers to the use of trained generative AI models to calculate optimal cultivation methods and conditions.

[0663] A "terminal" is a device that a user operates to input and receive data. Examples include smartphones and personal computers.

[0664] "Results" are information about optimal cultivation methods and conditions obtained based on inferences from the generative AI model.

[0665] "Display" refers to providing information visually on a terminal screen, etc.

[0666] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. An overview of the system and specific implementation procedures are described below.

[0667] System Overview

[0668] The system is based on the interaction of a server, a terminal, and a user, and has the following main functions:

[0669] 1. Receive agricultural data, preprocess it and store it in a database.

[0670] 2. Train a generative AI model using agricultural data extracted from the database.

[0671] 3. Receive the user's cultivation request, convert it into a different format, and send it to the server.

[0672] 4. The generative AI model is used to infer the optimal cultivation method and the results are sent to the device.

[0673] 5. The terminal displays the received results to the user.

[0674] Data collection and preprocessing

[0675] Subject: Server

[0676] The server receives agricultural data provided by farmers via HTTPS. The received data undergoes preprocessing, such as noise removal and missing value completion. This preprocessing is performed using Python data processing libraries (e.g., Pandas and NumPy). For example, if the soil pH value is abnormal, it is completed using an appropriate predictive model.

[0677] Examples:

[0678] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes outliers, and then stores the data in a database.

[0679] Storing data in a database

[0680] Subject: Server

[0681] Once the preprocessing is complete, the data is stored in an SQL database. MySQL or PostgreSQL are recommended for this system. The data is stored in a structured format that can be later searched and extracted as needed.

[0682] Training an AI model

[0683] Subject: Server

[0684] The server extracts historical data on specific crops from the database and trains a generative AI model using machine learning frameworks such as TensorFlow and PyTorch. For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[0685] Examples:

[0686] The server uses cold-climate tomato cultivation data to train an AI model and learn optimal irrigation schedules and fertilizer combinations.

[0687] User requirement collection and format conversion

[0688] Subject: Terminal

[0689] The user inputs the cultivation conditions and desired crop type via a terminal. The input information is converted into JSON format and sent to the server. Specific software examples include the use of a web-based front-end framework (e.g., React or Vue.js).

[0690] Examples:

[0691] A new farmer types into the terminal, "I want to grow tomatoes in a cold climate," and the request is converted into JSON format and sent to the server.

[0692] Inferring and providing optimal cultivation methods

[0693] Subject: Server

[0694] The server receives the user's request, searches the database for relevant information, uses a generative AI model to infer the optimal cultivation method, and then converts the results into a different format and sends them to the device.

[0695] Examples:

[0696] Based on cold-climate tomato cultivation data, the server generates specific suggestions, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends them to the terminal.

[0697] Displaying suggestions to users

[0698] Subject: Terminal

[0699] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[0700] Examples:

[0701] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins growing tomatoes based on this suggestion.

[0702] This system will enable farmers and new entrants to the industry to receive efficient and easy-to-understand agricultural know-how, ensuring a stable supply of delicious vegetables.

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

[0704] Step 1: Receiving and preprocessing agricultural data

[0705] Subject: Server

[0706] Input: Agricultural data provided by farmers (e.g. soil pH, fertilizer application rates, irrigation schedules, etc.)

[0707] Output: Preprocessed data

[0708] The server receives agricultural data sent by farmers. After receiving the data, it removes noise, complements outliers, and standardizes the data format. Specifically, it uses Python data processing libraries (e.g., Pandas and NumPy) to clean and shape the data. For example, if the received soil pH value is outside the normal range, it is complemented using a predictive model.

[0709] Specific behavior:

[0710] The data receiving module obtains data from the farmer's terminal via HTTPS.

[0711] The data cleansing module checks for outliers (outlier filtering) and performs imputation using appropriate predictive models.

[0712] Step 2: Store the data in the database

[0713] Subject: Server

[0714] Input: Preprocessed data

[0715] Output: Results stored in the database

[0716] The preprocessed data is stored in a database. This system uses an SQL database (e.g., MySQL or PostgreSQL). The data is structured and stored in a format that can be searched and extracted later.

[0717] Specific behavior:

[0718] The database insert module converts the preprocessed data into SQL queries and inserts them into the database.

[0719] Step 3: Extract historical data and train the AI ​​model

[0720] Subject: Server

[0721] Input: Agricultural data extracted from the database

[0722] Output: A trained AI model

[0723] The server extracts historical data on specific crops from a database and trains a generative AI model using Python machine learning libraries (e.g., TensorFlow and PyTorch). For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[0724] Specific behavior:

[0725] The data extraction module retrieves the required information from the database using SQL queries.

[0726] The machine learning module builds an AI model based on the acquired data, generates a training dataset, and trains the model.

[0727] Step 4: Collecting and formatting user requirements

[0728] Subject: Terminal

[0729] Input: Cultivation conditions and crop types entered by the user

[0730] Output: Reformatted user request (JSON format)

[0731] Users input cultivation conditions and the type of crop they want through their terminal. This information is then converted into JSON format for easy processing by the server and sent to the server. Specific software used is a web-based front-end framework (e.g., React or Vue.js).

[0732] Specific behavior:

[0733] A front-end interface displays user input forms and collects input from the user.

[0734] The input data is converted to JSON format and sent to the server.

[0735] Step 5: Infer and provide optimal cultivation methods

[0736] Subject: Server

[0737] Input: User request (JSON format)

[0738] Output: Inference result (optimal cultivation method)

[0739] The server receives the user's request and searches the database for relevant information. It uses a generative AI model to infer the optimal cultivation method, converts the results, and sends them to the device. It uses a Python model inference library (e.g., Scikit-Learn, TensorFlow Serving).

[0740] Specific behavior:

[0741] The request analysis module analyzes the received request and obtains the necessary information from the database.

[0742] The inference module uses a generative AI model to infer optimal cultivation methods.

[0743] The inference results are converted into JSON format or similar and sent to the terminal.

[0744] Step 6: Displaying suggestions to users

[0745] Subject: Terminal

[0746] Input: Inference results sent from the server (JSON format)

[0747] Output: Optimal cultivation method displayed to the user

[0748] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[0749] Specific behavior:

[0750] The response receiving module receives the data from the server.

[0751] A front-end interface analyzes the received data and presents it visually to the user.

[0752] These are the specific processing steps of the program for this system, which allows farmers and newcomers to easily acquire efficient and easy-to-understand agricultural know-how.

[0753] (Application example 1)

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

[0755] Previously, there were systems that proposed optimal cultivation methods based on agricultural data, but these systems required users to manually input data and check the results. Furthermore, the proposed cultivation methods were fixed, making it difficult to provide information in real time. This meant that retailers and store managers, in particular, had few opportunities to instantly learn optimal cultivation methods, making efficient and effective cultivation management difficult.

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

[0757] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the data to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the result, and sending it to a terminal, means for displaying the received result to the user, and means for suggesting cultivation methods to the user in real time via a smart device. This allows managers of brick-and-mortar stores and users of retail stores to instantly learn effective cultivation methods, enabling efficient and flexible crop management and sales.

[0758] "Agricultural data" is a set of information including crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[0759] "Preprocessing" is a data processing step to remove noise and missing values ​​from received data.

[0760] "Database" means a system for efficiently storing, retrieving, and managing pre-processed agricultural data.

[0761] A "generative AI model" is an artificial intelligence algorithm that is trained based on agricultural data and used to infer optimal cultivation methods and conditions.

[0762] "Format conversion" is the process of converting user requests and inference results into an easy-to-handle format.

[0763] The "server" is a central control unit that receives, pre-processes, and stores agricultural data, trains AI models, performs inference, and provides information to users.

[0764] "Smart devices" are mobile information terminals such as smartphones or smart glasses that are used to display cultivation methods in real time.

[0765] "Inference" is the process of using a generative AI model to determine the optimal cultivation method based on user requirements.

[0766] "Real-time" refers to immediate processing and information delivery with minimal delay.

[0767] A "prompt" is a specific instruction or question that inputs the user's request into the generative AI model.

[0768] This invention is a system that allows retailers and store managers to easily propose optimal vegetable cultivation methods for selling in their stores. The program processing of this system is explained below.

[0769] Server Processing

[0770] The server first receives agricultural data, which includes detailed information on cultivation methods, fertilizer usage, weather conditions, and pest control measures. This data is preprocessed to remove noise and missing values, and the formatted data is stored in a database. A high-performance database server is suitable for this purpose.

[0771] Next, the server extracts historical data on the target crop from the database and trains the generative AI model. Here, the training data is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). For training, a random forest regression model is built using Python's sklearn library. This model then learns the optimal cultivation conditions and techniques.

[0772] Terminal handling

[0773] When a user accesses the system through a smart device (such as a smartphone or smart glasses), the terminal receives input from the user. For example, the user may enter "How to grow tomatoes in cold climates" as a prompt. This request is formatted and sent to the server.

[0774] Proposal of optimal cultivation methods

[0775] The server receives the user's request, searches for relevant information from the database, and uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a user-friendly format and sent to the device.

[0776] Displaying suggestions to users

[0777] The terminal displays the optimal cultivation method received from the server to the user. The user can then create a specific cultivation plan based on this suggestion. In addition, by suggesting cultivation methods to users in real time via their smart devices, it is possible to provide instant information to consumers as well.

[0778] Specific examples

[0779] For example, the server receives "tomato cultivation data in cold regions" and stores it in a database. Then, the generative AI model learns optimal irrigation schedules and fertilizer combinations. If a user inputs a request such as "I want to grow tomatoes in a cold region," the server generates a specific suggestion, such as "Sow the seeds in April and keep them warm in a plastic tunnel," and displays it on the smart device.

[0780] Prompt Sentence Examples

[0781] "Tell me about growing tomatoes in cold climates. Can you suggest the best way to grow them?"

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

[0783] Step 1:

[0784] The server first receives agricultural data. Specifically, it receives data sent by API or file transfer from farms and related institutions. This data includes detailed information such as cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures. The input is agricultural data, and the output is data that has been improved through preprocessing.

[0785] Step 2:

[0786] The server preprocesses the received agricultural data. It removes noise and missing values ​​from the input data, and fills and normalizes missing values. This improves the quality of the data and allows it to be stored efficiently in the database. Examples of data processing include removing outliers and filling missing values ​​with the average value. The preprocessed data is then stored in the database.

[0787] Step 3:

[0788] The server extracts historical data about a target crop from a database. For example, it retrieves all historical data about tomato cultivation. The input is a query condition in the database, and the output is the historical data extracted as a result of the query.

[0789] Step 4:

[0790] The server trains a generative AI model based on the extracted data. Specifically, it creates a training dataset by dividing the data into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, palatability index). It then uses Python's sklearn library to build and train a random forest regression model. The input is the training data, and the output is a trained generative AI model.

[0791] Step 5:

[0792] A user accesses the system through a terminal (such as a smartphone or smart glasses) and inputs a prompt. For example, they ask, "How to grow tomatoes in cold climates." This request is sent to the server as user input. The input is the user's prompt, and the output is the request data sent to the server.

[0793] Step 6:

[0794] The server converts the format of the requested data received from the user and performs processing. Specifically, it uses a generative AI model to infer the optimal cultivation method. For example, "Sow seeds in April and keep them warm in a plastic tunnel." The input is the format-converted user request data, and the output is the inference result.

[0795] Step 7:

[0796] The server converts the inference results into a format that is easy for the user to understand (e.g., text or graphics) and sends them to the terminal. The input is the inference results, and the output is the converted result data.

[0797] Step 8:

[0798] The device displays the optimal cultivation method received from the server to the user. For example, a suggested result such as "Sow seeds in April and keep them warm in a plastic tunnel" may be displayed on the screen of a smartphone or smart glasses. The input is the format-converted result data, and the output is the information displayed to the user. This allows the user to create a specific cultivation plan based on the suggestion.

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

[0800] This invention is a vegetable production suggestion service that combines a series of operations, including receiving agricultural data, preprocessing, storing it in a database, training an AI model, processing user requests, and providing information, with an emotion engine that recognizes and analyzes user emotions. The purpose of this system is to provide optimal agricultural support based on the user's emotions. The program processing of this system is explained in detail below.

[0801] Program processing and specific examples

[0802] Data collection and preprocessing

[0803] Subject: Server

[0804] The server receives agricultural data provided by farmers. The data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[0805] Examples:

[0806] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[0807] Storage in the database

[0808] Subject: Server

[0809] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[0810] Examples:

[0811] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[0812] Data Extraction

[0813] Subject: Server

[0814] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[0815] Examples:

[0816] The server extracts data on "growing tomatoes in cold climates" from the database.

[0817] Generating training datasets for AI models

[0818] Subject: Server

[0819] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[0820] Examples:

[0821] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[0822] Training an AI model

[0823] Subject: Server

[0824] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[0825] Examples:

[0826] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[0827] Receiving a user request

[0828] Subject: Terminal

[0829] The terminal receives input from the user, such as cultivation conditions and the type of crop desired. For example, it receives input such as "How to grow tomatoes in cold climates."

[0830] Examples:

[0831] The user inputs "I want to grow tomatoes in a cold climate" into the terminal, which then converts the request into a different format and sends it to the server.

[0832] Emotion recognition by emotion engine

[0833] Subject: Terminal

[0834] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[0835] Examples:

[0836] The device uses an emotion engine to analyze the voice when the user inputs a request and detects the user's stress level.

[0837] Submitting a request

[0838] Subject: Terminal

[0839] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[0840] Examples:

[0841] The terminal transmits the user's request "How to grow tomatoes in cold climates" and its emotional state to the server.

[0842] Information Retrieval and Reasoning

[0843] Subject: Server

[0844] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[0845] Examples:

[0846] The server searches for data on "growing tomatoes in cold climates" and uses a generative AI model to infer the optimal cultivation method: "Sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also suggests simpler methods and additional advice.

[0847] Displaying the results

[0848] Subject: Terminal

[0849] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[0850] Examples:

[0851] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[0852] In this way, this system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[0853] The processing flow will be explained below.

[0854] Step 1: Data collection and preprocessing

[0855] Subject: Server

[0856] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing data. Normalization is also performed to standardize the data format.

[0857] Examples:

[0858] The server receives the "rice cultivation data" (e.g., soil pH 5.5, temperature fluctuations, irrigation frequency) provided by Farmer A, removes outliers and missing data, and normalizes it into a standard format.

[0859] Step 2: Store in the database

[0860] Subject: Server

[0861] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[0862] Examples:

[0863] The server stores the preprocessed "rice cultivation data" in the "rice" category of the database.

[0864] Step 3: Data extraction

[0865] Subject: Server

[0866] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[0867] Examples:

[0868] The server extracts data on "rice cultivation in cool regions" from the database.

[0869] Step 4: Generate a training dataset for the AI ​​model

[0870] Subject: Server

[0871] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[0872] Examples:

[0873] Based on rice cultivation data from cool regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and quality.

[0874] Step 5: Training the AI ​​model

[0875] Subject: Server

[0876] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[0877] Examples:

[0878] The server uses the generated training dataset to train an AI model to learn optimal fertilizer combinations and irrigation schedules for rice cultivation in cool climates.

[0879] Step 6: Receiving a request from the user

[0880] Subject: Terminal

[0881] The terminal receives input from the user about cultivation conditions and the type of crop desired. For example, it receives input such as "How to cultivate rice in cool regions."

[0882] Examples:

[0883] The terminal allows the user to input a request for "the best method for growing rice in cool regions," and then converts the request into a different format before sending it to the server.

[0884] Step 7: Emotion Recognition with the Emotion Engine

[0885] Subject: Terminal

[0886] The device uses an emotion engine to analyze the user's voice and facial expressions to understand the user's emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[0887] Examples:

[0888] The device uses an emotion engine to analyze the voice of the user when requesting cultivation methods and recognizes signs that the user is tired.

[0889] Step 8: Submitting the request

[0890] Subject: Terminal

[0891] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[0892] Examples:

[0893] The terminal transmits the user's request "How to grow rice in cool climates" and its emotional state to the server.

[0894] Step 9: Information retrieval and reasoning

[0895] Subject: Server

[0896] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[0897] Examples:

[0898] The server searches for data related to "rice cultivation in cool climates" and uses a generative AI model to infer the optimal cultivation method, such as "sowing seeds in May and creating a specific irrigation schedule." If the user is feeling stressed, the server also suggests ways to reduce the workload.

[0899] Step 10: View the results

[0900] Subject: Terminal

[0901] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[0902] Examples:

[0903] The device displays the inference result, "seeds should be sown in May and irrigation should be performed every two days," along with a "rest schedule to reduce workload," to the user, who then uses this information to cultivate rice.

[0904] Example 2

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

[0906] In conventional agricultural data management systems, the quality of data is not uniform when receiving, preprocessing, and subsequently utilizing agricultural data, making it difficult to propose highly accurate cultivation methods.In addition, because proposals are made uniformly without taking into account the user's emotional state, there is also the issue of not being able to appropriately address user stress and satisfaction.

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

[0908] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the results to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the results, and sending the results to the terminal, means for recognizing the user's emotional state and analyzing the emotional data, means for adjusting the inference results based on the emotional data, and means for displaying the received results to the user. This makes it possible to propose optimal and personalized cultivation methods to users in different situations and conditions.

[0909] "Agricultural data" refers to a collection of various information related to agriculture, such as crop types, cultivation methods, fertilizer amounts, weather conditions, and pest and disease control measures.

[0910] "Preprocessing" refers to the process of removing noise and missing values ​​from the received data, correcting outliers, and standardizing the data format.

[0911] "Database" refers to a collection of information structured to store pre-processed agricultural data and to enable efficient retrieval and use.

[0912] "Generative AI model" refers to an artificial intelligence model that learns and infers optimal cultivation conditions and methods based on received and preprocessed agricultural data.

[0913] "User requirements" refers to information input by the user specifying the cultivation conditions and the type of crop desired.

[0914] "Format conversion" refers to the process of converting received data or requests into a standardized format.

[0915] "Emotion engine" refers to a function that analyzes the user's voice and facial expression data and recognizes the user's emotional state.

[0916] "Emotion data" refers to information about a user's emotional state analyzed by an emotion engine.

[0917] "Inference results" refer to the results of the generative AI model deriving the optimal cultivation method based on the user's requirements.

[0918] "Terminal" refers to a computing device used by a user to enter data and receive results.

[0919] MODE FOR CARRYING OUT THE INVENTION

[0920] This invention is a system that receives agricultural data, preprocesses it, stores it in a database, trains an AI model, processes user requests, provides information, and recognizes user emotions using an emotion engine. This system is realized using multiple specific hardware and software. Specific embodiments for implementing the invention are described below.

[0921] Data collection and preprocessing

[0922] Subject: Server

[0923] The server receives agricultural data provided by farmers via the Internet. The received data includes information on crop type, cultivation method, fertilizer application rate, weather conditions, and pest and disease control measures. The received data is preprocessed using data processing libraries such as Python and R. This preprocessing includes removing noise and missing values ​​and normalizing the data format.

[0924] Examples:

[0925] The server receives data sent by Farmer A, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%" via an API endpoint. The server uses Python's Pandas library to remove outliers and missing data from the received data and converts it into a unified data format.

[0926] Storage in the database

[0927] Subject: Server

[0928] Once the preprocessing is complete, the data is stored in a database by the server. A relational database such as MySQL or PostgreSQL is used as the database. The data is classified by crop and cultivation conditions, and an index is generated to enable efficient searches.

[0929] Examples:

[0930] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates the necessary indexes.

[0931] Data extraction and AI model training

[0932] Subject: Server

[0933] The server extracts agricultural data from the database and uses it to train a generative AI model. Machine learning libraries such as Scikit-learn and TensorFlow are used to train the AI ​​model. The extracted data is divided into input features and output values ​​and used as a training dataset.

[0934] Examples:

[0935] The server extracts data related to "growing tomatoes in cold climates" from the database and uses Scikit-learn to train a model that learns irrigation schedules and fertilizer combinations appropriate for cold climate conditions.

[0936] User request reception and emotion engine

[0937] Subject: Terminal

[0938] The device receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server. The user can input text or voice, and the device's emotion engine analyzes the user's emotional state. The emotion engine uses a commercial emotion recognition library (such as Microsoft Azure's emotion recognition API).

[0939] Examples:

[0940] The user makes a request through a smartphone app by voice, saying, "I want to grow tomatoes in a cold climate." The device analyzes the voice data with its emotion engine and detects that the user is feeling stressed.

[0941] Submitting requests and providing information

[0942] Subject: Server

[0943] The request data, including emotional data, is sent from the device to the server. The server searches for relevant agricultural information from a database based on the user's request and infers the optimal cultivation method using a generative AI model. It then adjusts the recommendations based on the user's emotional state, converts the results, and sends them to the device.

[0944] Examples:

[0945] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow seeds in April and keep them warm in a plastic tunnel." It also suggests simpler methods and additional advice if the user is feeling stressed.

[0946] Displaying the results

[0947] Subject: Terminal

[0948] The device receives the inference results and advice based on emotions sent from the server and displays them to the user, who then uses the inference results and advice to cultivate the plants.

[0949] Examples:

[0950] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[0951] Example prompt sentence:

[0952] What is the best way to grow tomatoes in cold climates?

[0953] I'd like to know how to grow tomatoes in cold climates. They're currently stressed, so please suggest some easy solutions.

[0954] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

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

[0956] Step 1: Data collection

[0957] Subject: Server

[0958] The server receives agricultural data provided by farmers via the internet, specifically via a dedicated API endpoint, and the data includes crop type, cultivation method, fertilizer amount, weather conditions, and pest and disease control measures.

[0959] Input: Agricultural data from farmers

[0960] Output: Raw data received

[0961] Specific behavior:

[0962] The server receives data sent by Farmer A via the API, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%."

[0963] Step 2: Data Preprocessing

[0964] Subject: Server

[0965] The server preprocesses the received agricultural data to remove noise and missing values ​​and normalize the data format, using the Python Pandas library.

[0966] Input: Raw data received

[0967] Output: Preprocessed data

[0968] Specific behavior:

[0969] The server detects missing values ​​(for example, missing temperature data) and abnormal values ​​(for example, an abnormal pH value of 20) in the received data, corrects and complements them in an appropriate manner, and also standardizes the data format and converts it into JSON format.

[0970] Step 3: Store in the database

[0971] Subject: Server

[0972] After preprocessing, the server stores the data in a database, typically a relational database such as MySQL or PostgreSQL. The data is categorized by crop and cultivation conditions, and an index is generated.

[0973] Input: Preprocessed data

[0974] Output: Data stored in the database

[0975] Specific behavior:

[0976] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates an index to improve search efficiency.

[0977] Step 4: Data extraction

[0978] Subject: Server

[0979] The server extracts agricultural data from the database based on specific conditions, for example, data related to specific growing conditions according to a user's request.

[0980] Input: Data in the database

[0981] Output: Extracted data

[0982] Specific behavior:

[0983] The server uses SQL queries to search and extract data related to "growing tomatoes in cold climates" from the database.

[0984] Step 5: Generate a training dataset for the AI ​​model

[0985] Subject: Server

[0986] The server creates a training dataset for the AI ​​model based on the extracted agricultural data. The dataset is organized into input features and output values.

[0987] Input: Extracted data

[0988] Output: Training dataset

[0989] Specific behavior:

[0990] Based on the extracted cold-region tomato cultivation data, the server uses the Scikit-learn library to separate and organize the data into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, taste index).

[0991] Step 6: Training the AI ​​model

[0992] Subject: Server

[0993] The server uses the training dataset to train the AI ​​model, specifically using machine learning algorithms to learn optimal growing conditions from agricultural data.

[0994] Input: Training dataset

[0995] Output: Trained AI model

[0996] Specific behavior:

[0997] The server uses Scikit-learn and TensorFlow to train a model that learns optimal cultivation conditions based on a training dataset.

[0998] Step 7: Receiving the user's request

[0999] Subject: Terminal

[1000] The terminal receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server.

[1001] Input: User request

[1002] Output: Reformatted request data

[1003] Specific behavior:

[1004] The user inputs "I want to grow tomatoes in a cold climate" through a smartphone app, and the device converts the request into JSON format and sends it to the server.

[1005] Step 8: Emotion Recognition with the Emotion Engine

[1006] Subject: Terminal

[1007] The device analyzes the user's voice and facial expression data using an emotion engine to recognize the user's emotional state.

[1008] Input: User's voice and facial expression data

[1009] Output: Parsed emotion data

[1010] Specific behavior:

[1011] The device collects facial photos and voice data when the user inputs a request, and uses an emotion engine to determine whether the user is "feeling stressed."

[1012] Step 9: Submitting the request

[1013] Subject: Terminal

[1014] The terminal transmits the request data, including the emotional state, to the server.

[1015] Input: Format-converted request data and emotion data

[1016] Output: Request data and emotion data sent to the server

[1017] Specific behavior:

[1018] The terminal transmits the user's request "Please tell me how to grow tomatoes in a cold climate" and data including the user's emotional state to the server.

[1019] Step 10: Information Retrieval and Reasoning

[1020] Subject: Server

[1021] The server searches for relevant agricultural information from a database based on the requested data, uses AI models to infer optimal cultivation methods, and adjusts its suggestions according to the user's emotional state.

[1022] Input: Request data and emotion data

[1023] Output: Inference results and adjusted recommendations

[1024] Specific behavior:

[1025] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also offers easier methods and additional advice.

[1026] Step 11: View the results

[1027] Subject: Terminal

[1028] The terminal receives advice based on optimal cultivation methods and emotions sent from the server and displays it to the user.

[1029] Input: Inference results and adjusted proposals

[1030] Output: Cultivation methods and advice displayed to the user

[1031] Specific behavior:

[1032] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[1033] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[1034] (Application example 2)

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

[1036] In modern agriculture, finding the optimal method for growing crops is important, but this process often causes stress for farmers. There is also a need for detailed support that takes farmers' emotions into consideration while effectively utilizing agricultural data. Therefore, there is a need for a system that proposes optimal cultivation methods based on farmers' emotions, reduces their stress, and enables efficient cultivation.

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

[1038] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database; a means for extracting agricultural data from the database and training a generative AI model; a means for recognizing a user's emotions, adjusting the optimal cultivation method based on the emotions, converting the format of the results, and transmitting them to a terminal; and a means for displaying advice to the user based on the received results and emotions. This makes it possible to propose optimal cultivation methods that take the user's emotions into consideration. It also reduces user stress and provides support for efficient agricultural work.

[1039] "Agricultural data" refers to data that includes information related to agriculture, such as crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[1040] "Preprocessing" refers to a series of processes that remove noise and missing values ​​from received agricultural data and standardize the data format.

[1041] A "database" is a repository of information that stores data in an organized format and makes it easy to search and retrieve.

[1042] A "generative AI model" is a model that uses machine learning algorithms to learn from a training dataset and has the ability to perform a specific task (e.g., infer optimal cultivation methods).

[1043] "User emotion recognition" is the process of analyzing data such as the user's voice and facial expressions to understand their emotional state.

[1044] "Emotion-based adjustment" refers to appropriately changing the cultivation methods and advice provided depending on the user's emotional state.

[1045] "Format conversion" is the operation of converting data into an appropriate format before transmitting the data.

[1046] A "terminal" is a device (e.g., a smartphone or tablet) that a user uses as an interface.

[1047] "Inference" is the process by which a generative AI model determines the best solution or method based on specific input data.

[1048] "Emotion-based advice" is specific advice or recommendations that are provided taking into account the user's emotional state.

[1049] This invention is a food delivery system that combines agricultural data with user emotional information to suggest optimal cultivation methods.

[1050] The server first receives the agricultural data, preprocesses it, and then stores it in a database. Specifically, the agricultural data includes information on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc. The server normalizes this data and removes noise and missing values.

[1051] The server then extracts agricultural data from the database and uses it to train a generative AI model. The AI ​​model outputs indicators of yield and taste based on input features such as soil pH, temperature, and rainfall. The model can also adjust cultivation methods based on the user's emotional information.

[1052] The device receives requests from the user, converts the format, and sends the data to the server.The device also has an emotion engine that recognizes emotional information from the user's voice and facial expressions and analyzes their emotional state.

[1053] The server infers the optimal cultivation method based on the request and emotional information sent from the device, converts the format of the result, and sends it to the device. The inferred result also includes advice based on the user's emotional state. For example, if the user is feeling stressed, simple cultivation methods or additional advice will be provided.

[1054] Finally, the device displays the results and emotional advice sent from the server to the user, allowing the user to implement optimal cultivation methods.

[1055] The system's hardware includes a server for processing data and a smartphone or tablet for users. It uses Python, TensorFlow, OpenCV, pandas, and scikit-learn for software, performing a series of operations: receiving data, preprocessing, storing data, training an AI model, performing emotion recognition, inference, and displaying the results.

[1056] As a concrete example, if a user types into a device, "I want to grow tomatoes in a cold climate," the device converts the request and sends it to the server. At the same time, the device analyzes the user's voice and facial expressions to detect whether the user is feeling stressed. Based on this information, the server infers the optimal cultivation method - "sow the seeds in April and keep them warm in a plastic tunnel" - and adds advice to reduce the user's stress (for example, a schedule for frequent rest and light work) and sends the results to the device. The device displays these results to the user, who uses them as a reference when cultivating the plants.

[1057] Example prompt sentence:

[1058] Analyze a user's facial photo, recognize their emotional state (e.g., stress, joy), and suggest food recommendations based on that. Recommend meals that match your current emotional state.

[1059] In this way, it becomes possible to propose optimal cultivation methods that take the user's emotions into consideration, thereby realizing a system that reduces user stress and supports efficient cultivation work.

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

[1061] Step 1:

[1062] The server receives agricultural data and performs preprocessing. Specifically, it receives data on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc., normalizes the data, and removes noise and missing values. The preprocessed data is then converted into a unified format.

[1063] Input: Agricultural data

[1064] Output: Preprocessed agricultural data

[1065] Step 2:

[1066] The server stores the pre-processed agricultural data in a database, where the data is categorized by crop and structured for easy later retrieval.

[1067] Input: Preprocessed agricultural data

[1068] Output: Agricultural data stored in a database

[1069] Step 3:

[1070] The server extracts agricultural data from the database and trains the generative AI model. The data is divided into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, palatability index), and used as a training dataset for the AI ​​model.

[1071] Input: Agricultural data extracted from a database

[1072] Output: training dataset, generative AI model

[1073] Step 4:

[1074] The server uses a generative AI model to infer optimal cultivation methods, specifically by providing input data to the model, which infers optimal irrigation schedules and fertilizer combinations.

[1075] Input: training dataset, generative AI model

[1076] Output: Inferred optimal cultivation method

[1077] Step 5:

[1078] The terminal receives requests from users, converts the format, and sends the data to the server. Users input cultivation conditions and desired crop types using a smartphone or tablet.

[1079] Input: Request from the user

[1080] Output: Reformatted request data, sent to the server

[1081] Step 6:

[1082] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state, for example, determining whether they are feeling stressed.

[1083] Input: User's voice and facial expression data

[1084] Output: Parsed emotional state

[1085] Step 7:

[1086] The server uses a generative AI model to infer the optimal cultivation method based on the request and emotional information sent from the device, converts the results into a different format, and sends them to the device. The inferred results also include advice based on the emotional information.

[1087] Input: Formatted request data, emotional state

[1088] Output: Inferred optimal cultivation method and advice, format-converted result data, sent to terminal

[1089] Step 8:

[1090] The device displays the results and advice based on the user's emotions to the user, allowing the user to implement optimal cultivation methods.

[1091] Input: Results and advice sent by the server

[1092] Output: What is displayed to the user

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

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

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

[1096] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1109] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. This system receives agricultural data, stores it in a database, trains an AI model, and suggests optimal cultivation methods to users. The program processing of this system is explained below in natural language.

[1110] Program processing and specific examples

[1111] Data collection and storage

[1112] Subject: Server

[1113] The server receives agricultural data provided by farmers. For example, it receives data about tomato cultivation (e.g., soil pH, fertilizer application rate, irrigation schedule, etc.). This data includes details such as cultivation method, weather conditions, soil composition, and yield. This received data is preprocessed to remove noise and missing values. The preprocessed data is then stored in a database.

[1114] Examples:

[1115] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes noise, and stores the data in a database.

[1116] Creating a database of know-how and training AI models

[1117] Subject: Server

[1118] The server extracts past data on the target crop from the database. For example, it extracts all data related to tomato cultivation. This extracted data is used to generate a training dataset for the AI ​​model. The training dataset is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). Based on this, the AI ​​model is trained to learn optimal cultivation conditions and techniques.

[1119] Examples:

[1120] The server trains the AI ​​model based on "cold climate tomato cultivation data" extracted from the database, learning the optimal irrigation schedule and fertilizer combinations.

[1121] Providing information based on user requests

[1122] Subject: Terminal

[1123] The terminal receives the cultivation conditions and desired crop type input by the user. For example, it receives input such as "How to grow tomatoes in cold climates." This request is converted into a format that the server can easily process and sent to the server.

[1124] Examples:

[1125] The terminal allows new farmers to input "I want to grow tomatoes in a cold climate" and sends the request to the server.

[1126] Proposal of optimal cultivation methods

[1127] Subject: Server

[1128] The server receives a user request sent from the device and searches for relevant information from a database based on that request. For example, it searches for data on tomato cultivation in cold climates. It then uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a format that is easy for the user to understand and sent to the device.

[1129] Examples:

[1130] Based on tomato cultivation data from cold regions, the server uses a generative AI model to generate a specific suggestion, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends this to the device.

[1131] Displaying suggestions to users

[1132] Subject: Terminal

[1133] The terminal receives the optimal cultivation method proposal sent from the server and displays it to the user, who can then create a specific cultivation plan based on the proposal.

[1134] Examples:

[1135] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins cultivating tomatoes based on this suggestion.

[1136] In this way, this system can provide farmers and new entrants with efficient and easy-to-understand agricultural know-how, enabling a stable supply of delicious vegetables.

[1137] The processing flow will be explained below.

[1138] Step 1: Data collection and preprocessing

[1139] Subject: Server

[1140] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer application rate, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[1141] Examples:

[1142] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[1143] Step 2: Store in the database

[1144] Subject: Server

[1145] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[1146] Examples:

[1147] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[1148] Step 3: Data extraction

[1149] Subject: Server

[1150] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[1151] Examples:

[1152] The server extracts data on "growing tomatoes in cold climates" from the database.

[1153] Step 4: Generate a training dataset for the AI ​​model

[1154] Subject: Server

[1155] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[1156] Examples:

[1157] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[1158] Step 5: Training the AI ​​model

[1159] Subject: Server

[1160] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[1161] Examples:

[1162] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[1163] Step 6: Receiving a request from the user

[1164] Subject: Terminal

[1165] The terminal receives cultivation conditions and desired crop types input by the user, and converts the received requests into a format that the server can easily process.

[1166] Examples:

[1167] The terminal receives a request input by the user, such as "I want to grow tomatoes in a cold climate," and sends it to the server.

[1168] Step 7: Submitting the request

[1169] Subject: Terminal

[1170] The terminal then sends the converted request to the server, which includes the specific growing conditions and type of crop.

[1171] Examples:

[1172] The terminal transmits the user's request "How to grow tomatoes in cold regions" to the server.

[1173] Step 8: Information Search

[1174] Subject: Server

[1175] The server searches the database for relevant information based on the request sent from the device, extracts the necessary data, and inputs it into the AI ​​model.

[1176] Examples:

[1177] The server searches and extracts data related to tomato cultivation in cold climates from a database.

[1178] Step 9: Inference with the AI ​​model

[1179] Subject: Server

[1180] The server uses an AI model to infer the optimal cultivation method based on the extracted data, converts the inference results into a different format, and sends them to the device.

[1181] Examples:

[1182] The server uses an AI model to infer the optimal cultivation method, which is to sow seeds in April and keep them warm in a plastic tunnel, then converts the format and sends it to the terminal.

[1183] Step 10: View the results

[1184] Subject: Terminal

[1185] The terminal receives the results of the optimal cultivation method sent from the server and displays them to the user.

[1186] Examples:

[1187] The device displays the inference result to the user, "Sow the seeds in April and keep them warm in a plastic tunnel," and the user uses this as a reference when cultivating the crops.

[1188] Example 1

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

[1190] In the agricultural sector, there is a problem in that farmers cannot easily obtain optimal methods for efficiently cultivating delicious vegetables. It is particularly difficult for newcomers and inexperienced farmers to select appropriate cultivation methods and conditions. There is also a need to find cultivation methods that can quickly adapt to variables such as local weather conditions and soil composition.

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

[1192] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database, a means for extracting agricultural data from the database and training a generative AI model, and a means for collecting requests from users, converting the format, and sending the requests to the server, thereby enabling farmers to easily obtain efficient and optimal cultivation methods.

[1193] "Agricultural data" refers to data including information on crop cultivation methods, soil composition, weather conditions, irrigation information, fertilizer amounts, yields, and pest and disease control measures.

[1194] "Preprocessing" refers to processing that removes noise from the received data, complements abnormal values, and standardizes the data format.

[1195] A "database" is a data storage system that stores data in a structured format and allows the data to be easily searched and retrieved as needed.

[1196] A "generative AI model" is a model that outputs optimal cultivation methods and prediction results for input features based on a machine learning algorithm.

[1197] "User requirements" are input information including specific agricultural cultivation conditions, types of crops, and other desired items.

[1198] "Format conversion" is the process of changing data into a format that is easy for the server or terminal to process.

[1199] "Inference" refers to the use of trained generative AI models to calculate optimal cultivation methods and conditions.

[1200] A "terminal" is a device that a user operates to input and receive data. Examples include smartphones and personal computers.

[1201] "Results" are information about optimal cultivation methods and conditions obtained based on inferences from the generative AI model.

[1202] "Display" refers to providing information visually on a terminal screen, etc.

[1203] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. An overview of the system and specific implementation procedures are described below.

[1204] System Overview

[1205] The system is based on the interaction of a server, a terminal, and a user, and has the following main functions:

[1206] 1. Receive agricultural data, preprocess it and store it in a database.

[1207] 2. Train a generative AI model using agricultural data extracted from the database.

[1208] 3. Receive the user's cultivation request, convert it into a different format, and send it to the server.

[1209] 4. The generative AI model is used to infer the optimal cultivation method and the results are sent to the device.

[1210] 5. The terminal displays the received results to the user.

[1211] Data collection and preprocessing

[1212] Subject: Server

[1213] The server receives agricultural data provided by farmers via HTTPS. The received data undergoes preprocessing, such as noise removal and missing value completion. This preprocessing is performed using Python data processing libraries (e.g., Pandas and NumPy). For example, if the soil pH value is abnormal, it is completed using an appropriate predictive model.

[1214] Examples:

[1215] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes outliers, and then stores the data in a database.

[1216] Storing data in a database

[1217] Subject: Server

[1218] Once the preprocessing is complete, the data is stored in an SQL database. MySQL or PostgreSQL are recommended for this system. The data is stored in a structured format that can be later searched and extracted as needed.

[1219] Training an AI model

[1220] Subject: Server

[1221] The server extracts historical data on specific crops from the database and trains a generative AI model using machine learning frameworks such as TensorFlow and PyTorch. For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[1222] Examples:

[1223] The server uses cold-climate tomato cultivation data to train an AI model and learn optimal irrigation schedules and fertilizer combinations.

[1224] User requirement collection and format conversion

[1225] Subject: Terminal

[1226] The user inputs the cultivation conditions and desired crop type via a terminal. The input information is converted into JSON format and sent to the server. Specific software examples include the use of a web-based front-end framework (e.g., React or Vue.js).

[1227] Examples:

[1228] A new farmer types into the terminal, "I want to grow tomatoes in a cold climate," and the request is converted into JSON format and sent to the server.

[1229] Inferring and providing optimal cultivation methods

[1230] Subject: Server

[1231] The server receives the user's request, searches the database for relevant information, uses a generative AI model to infer the optimal cultivation method, and then converts the results into a different format and sends them to the device.

[1232] Examples:

[1233] Based on cold-climate tomato cultivation data, the server generates specific suggestions, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends them to the terminal.

[1234] Displaying suggestions to users

[1235] Subject: Terminal

[1236] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[1237] Examples:

[1238] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins growing tomatoes based on this suggestion.

[1239] This system will enable farmers and new entrants to the industry to receive efficient and easy-to-understand agricultural know-how, ensuring a stable supply of delicious vegetables.

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

[1241] Step 1: Receiving and preprocessing agricultural data

[1242] Subject: Server

[1243] Input: Agricultural data provided by farmers (e.g. soil pH, fertilizer application rates, irrigation schedules, etc.)

[1244] Output: Preprocessed data

[1245] The server receives agricultural data sent by farmers. After receiving the data, it removes noise, complements outliers, and standardizes the data format. Specifically, it uses Python data processing libraries (e.g., Pandas and NumPy) to clean and shape the data. For example, if the received soil pH value is outside the normal range, it is complemented using a predictive model.

[1246] Specific behavior:

[1247] The data receiving module obtains data from the farmer's terminal via HTTPS.

[1248] The data cleansing module checks for outliers (outlier filtering) and performs imputation using appropriate predictive models.

[1249] Step 2: Store the data in the database

[1250] Subject: Server

[1251] Input: Preprocessed data

[1252] Output: Results stored in the database

[1253] The preprocessed data is stored in a database. This system uses an SQL database (e.g., MySQL or PostgreSQL). The data is structured and stored in a format that can be searched and extracted later.

[1254] Specific behavior:

[1255] The database insert module converts the preprocessed data into SQL queries and inserts them into the database.

[1256] Step 3: Extract historical data and train the AI ​​model

[1257] Subject: Server

[1258] Input: Agricultural data extracted from the database

[1259] Output: A trained AI model

[1260] The server extracts historical data on specific crops from a database and trains a generative AI model using Python machine learning libraries (e.g., TensorFlow and PyTorch). For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[1261] Specific behavior:

[1262] The data extraction module retrieves the required information from the database using SQL queries.

[1263] The machine learning module builds an AI model based on the acquired data, generates a training dataset, and trains the model.

[1264] Step 4: Collecting and formatting user requirements

[1265] Subject: Terminal

[1266] Input: Cultivation conditions and crop types entered by the user

[1267] Output: Reformatted user request (JSON format)

[1268] Users input cultivation conditions and the type of crop they want through their terminal. This information is then converted into JSON format for easy processing by the server and sent to the server. Specific software used is a web-based front-end framework (e.g., React or Vue.js).

[1269] Specific behavior:

[1270] A front-end interface displays user input forms and collects input from the user.

[1271] The input data is converted to JSON format and sent to the server.

[1272] Step 5: Infer and provide optimal cultivation methods

[1273] Subject: Server

[1274] Input: User request (JSON format)

[1275] Output: Inference result (optimal cultivation method)

[1276] The server receives the user's request and searches the database for relevant information. It uses a generative AI model to infer the optimal cultivation method, converts the results, and sends them to the device. It uses a Python model inference library (e.g., Scikit-Learn, TensorFlow Serving).

[1277] Specific behavior:

[1278] The request analysis module analyzes the received request and obtains the necessary information from the database.

[1279] The inference module uses a generative AI model to infer optimal cultivation methods.

[1280] The inference results are converted into JSON format or similar and sent to the terminal.

[1281] Step 6: Displaying suggestions to users

[1282] Subject: Terminal

[1283] Input: Inference results sent from the server (JSON format)

[1284] Output: Optimal cultivation method displayed to the user

[1285] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[1286] Specific behavior:

[1287] The response receiving module receives the data from the server.

[1288] A front-end interface analyzes the received data and presents it visually to the user.

[1289] These are the specific processing steps of the program for this system, which allows farmers and newcomers to easily acquire efficient and easy-to-understand agricultural know-how.

[1290] (Application example 1)

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

[1292] Previously, there were systems that proposed optimal cultivation methods based on agricultural data, but these systems required users to manually input data and check the results. Furthermore, the proposed cultivation methods were fixed, making it difficult to provide information in real time. This meant that retailers and store managers, in particular, had few opportunities to instantly learn optimal cultivation methods, making efficient and effective cultivation management difficult.

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

[1294] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the data to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the result, and sending it to a terminal, means for displaying the received result to the user, and means for suggesting cultivation methods to the user in real time via a smart device. This allows managers of brick-and-mortar stores and users of retail stores to instantly learn effective cultivation methods, enabling efficient and flexible crop management and sales.

[1295] "Agricultural data" is a set of information including crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[1296] "Preprocessing" is a data processing step to remove noise and missing values ​​from received data.

[1297] "Database" means a system for efficiently storing, retrieving, and managing pre-processed agricultural data.

[1298] A "generative AI model" is an artificial intelligence algorithm that is trained based on agricultural data and used to infer optimal cultivation methods and conditions.

[1299] "Format conversion" is the process of converting user requests and inference results into an easy-to-handle format.

[1300] The "server" is a central control unit that receives, pre-processes, and stores agricultural data, trains AI models, performs inference, and provides information to users.

[1301] "Smart devices" are mobile information terminals such as smartphones or smart glasses that are used to display cultivation methods in real time.

[1302] "Inference" is the process of using a generative AI model to determine the optimal cultivation method based on user requirements.

[1303] "Real-time" refers to immediate processing and information delivery with minimal delay.

[1304] A "prompt" is a specific instruction or question that inputs the user's request into the generative AI model.

[1305] This invention is a system that allows retailers and store managers to easily propose optimal vegetable cultivation methods for selling in their stores. The program processing of this system is explained below.

[1306] Server Processing

[1307] The server first receives agricultural data, which includes detailed information on cultivation methods, fertilizer usage, weather conditions, and pest control measures. This data is preprocessed to remove noise and missing values, and the formatted data is stored in a database. A high-performance database server is suitable for this purpose.

[1308] Next, the server extracts historical data on the target crop from the database and trains the generative AI model. Here, the training data is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). For training, a random forest regression model is built using Python's sklearn library. This model then learns the optimal cultivation conditions and techniques.

[1309] Terminal handling

[1310] When a user accesses the system through a smart device (such as a smartphone or smart glasses), the terminal receives input from the user. For example, the user may enter "How to grow tomatoes in cold climates" as a prompt. This request is formatted and sent to the server.

[1311] Proposal of optimal cultivation methods

[1312] The server receives the user's request, searches for relevant information from the database, and uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a user-friendly format and sent to the device.

[1313] Displaying suggestions to users

[1314] The terminal displays the optimal cultivation method received from the server to the user. The user can then create a specific cultivation plan based on this suggestion. In addition, by suggesting cultivation methods to users in real time via their smart devices, it is possible to provide instant information to consumers as well.

[1315] Specific examples

[1316] For example, the server receives "tomato cultivation data in cold regions" and stores it in a database. Then, the generative AI model learns optimal irrigation schedules and fertilizer combinations. If a user inputs a request such as "I want to grow tomatoes in a cold region," the server generates a specific suggestion, such as "Sow the seeds in April and keep them warm in a plastic tunnel," and displays it on the smart device.

[1317] Prompt Sentence Examples

[1318] "Tell me about growing tomatoes in cold climates. Can you suggest the best way to grow them?"

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

[1320] Step 1:

[1321] The server first receives agricultural data. Specifically, it receives data sent by API or file transfer from farms and related institutions. This data includes detailed information such as cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures. The input is agricultural data, and the output is data that has been improved through preprocessing.

[1322] Step 2:

[1323] The server preprocesses the received agricultural data. It removes noise and missing values ​​from the input data, and fills and normalizes missing values. This improves the quality of the data and allows it to be stored efficiently in the database. Examples of data processing include removing outliers and filling missing values ​​with the average value. The preprocessed data is then stored in the database.

[1324] Step 3:

[1325] The server extracts historical data about a target crop from a database. For example, it retrieves all historical data about tomato cultivation. The input is a query condition in the database, and the output is the historical data extracted as a result of the query.

[1326] Step 4:

[1327] The server trains a generative AI model based on the extracted data. Specifically, it creates a training dataset by dividing the data into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, palatability index). It then uses Python's sklearn library to build and train a random forest regression model. The input is the training data, and the output is a trained generative AI model.

[1328] Step 5:

[1329] A user accesses the system through a terminal (such as a smartphone or smart glasses) and inputs a prompt. For example, they ask, "How to grow tomatoes in cold climates." This request is sent to the server as user input. The input is the user's prompt, and the output is the request data sent to the server.

[1330] Step 6:

[1331] The server converts the format of the requested data received from the user and performs processing. Specifically, it uses a generative AI model to infer the optimal cultivation method. For example, "Sow seeds in April and keep them warm in a plastic tunnel." The input is the format-converted user request data, and the output is the inference result.

[1332] Step 7:

[1333] The server converts the inference results into a format that is easy for the user to understand (e.g., text or graphics) and sends them to the terminal. The input is the inference results, and the output is the converted result data.

[1334] Step 8:

[1335] The device displays the optimal cultivation method received from the server to the user. For example, a suggested result such as "Sow seeds in April and keep them warm in a plastic tunnel" may be displayed on the screen of a smartphone or smart glasses. The input is the format-converted result data, and the output is the information displayed to the user. This allows the user to create a specific cultivation plan based on the suggestion.

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

[1337] This invention is a vegetable production suggestion service that combines a series of operations, including receiving agricultural data, preprocessing, storing it in a database, training an AI model, processing user requests, and providing information, with an emotion engine that recognizes and analyzes user emotions. The purpose of this system is to provide optimal agricultural support based on the user's emotions. The program processing of this system is explained in detail below.

[1338] Program processing and specific examples

[1339] Data collection and preprocessing

[1340] Subject: Server

[1341] The server receives agricultural data provided by farmers. The data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[1342] Examples:

[1343] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[1344] Storage in the database

[1345] Subject: Server

[1346] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[1347] Examples:

[1348] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[1349] Data Extraction

[1350] Subject: Server

[1351] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[1352] Examples:

[1353] The server extracts data on "growing tomatoes in cold climates" from the database.

[1354] Generating training datasets for AI models

[1355] Subject: Server

[1356] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[1357] Examples:

[1358] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[1359] Training an AI model

[1360] Subject: Server

[1361] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[1362] Examples:

[1363] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[1364] Receiving a user request

[1365] Subject: Terminal

[1366] The terminal receives input from the user, such as cultivation conditions and the type of crop desired. For example, it receives input such as "How to grow tomatoes in cold climates."

[1367] Examples:

[1368] The user inputs "I want to grow tomatoes in a cold climate" into the terminal, which then converts the request into a different format and sends it to the server.

[1369] Emotion recognition by emotion engine

[1370] Subject: Terminal

[1371] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[1372] Examples:

[1373] The device uses an emotion engine to analyze the voice when the user inputs a request and detects the user's stress level.

[1374] Submitting a request

[1375] Subject: Terminal

[1376] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[1377] Examples:

[1378] The terminal transmits the user's request "How to grow tomatoes in cold climates" and its emotional state to the server.

[1379] Information Retrieval and Reasoning

[1380] Subject: Server

[1381] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[1382] Examples:

[1383] The server searches for data on "growing tomatoes in cold climates" and uses a generative AI model to infer the optimal cultivation method: "Sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also suggests simpler methods and additional advice.

[1384] Displaying the results

[1385] Subject: Terminal

[1386] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[1387] Examples:

[1388] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[1389] In this way, this system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[1390] The processing flow will be explained below.

[1391] Step 1: Data collection and preprocessing

[1392] Subject: Server

[1393] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing data. Normalization is also performed to standardize the data format.

[1394] Examples:

[1395] The server receives the "rice cultivation data" (e.g., soil pH 5.5, temperature fluctuations, irrigation frequency) provided by Farmer A, removes outliers and missing data, and normalizes it into a standard format.

[1396] Step 2: Store in the database

[1397] Subject: Server

[1398] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[1399] Examples:

[1400] The server stores the preprocessed "rice cultivation data" in the "rice" category of the database.

[1401] Step 3: Data extraction

[1402] Subject: Server

[1403] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[1404] Examples:

[1405] The server extracts data on "rice cultivation in cool regions" from the database.

[1406] Step 4: Generate a training dataset for the AI ​​model

[1407] Subject: Server

[1408] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[1409] Examples:

[1410] Based on rice cultivation data from cool regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and quality.

[1411] Step 5: Training the AI ​​model

[1412] Subject: Server

[1413] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[1414] Examples:

[1415] The server uses the generated training dataset to train an AI model to learn optimal fertilizer combinations and irrigation schedules for rice cultivation in cool climates.

[1416] Step 6: Receiving a request from the user

[1417] Subject: Terminal

[1418] The terminal receives input from the user about cultivation conditions and the type of crop desired. For example, it receives input such as "How to cultivate rice in cool regions."

[1419] Examples:

[1420] The terminal allows the user to input a request for "the best method for growing rice in cool regions," and then converts the request into a different format before sending it to the server.

[1421] Step 7: Emotion Recognition with the Emotion Engine

[1422] Subject: Terminal

[1423] The device uses an emotion engine to analyze the user's voice and facial expressions to understand the user's emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[1424] Examples:

[1425] The device uses an emotion engine to analyze the voice of the user when requesting cultivation methods and recognizes signs that the user is tired.

[1426] Step 8: Submitting the request

[1427] Subject: Terminal

[1428] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[1429] Examples:

[1430] The terminal transmits the user's request "How to grow rice in cool climates" and its emotional state to the server.

[1431] Step 9: Information retrieval and reasoning

[1432] Subject: Server

[1433] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[1434] Examples:

[1435] The server searches for data related to "rice cultivation in cool climates" and uses a generative AI model to infer the optimal cultivation method, such as "sowing seeds in May and creating a specific irrigation schedule." If the user is feeling stressed, the server also suggests ways to reduce the workload.

[1436] Step 10: View the results

[1437] Subject: Terminal

[1438] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[1439] Examples:

[1440] The device displays the inference result, "seeds should be sown in May and irrigation should be performed every two days," along with a "rest schedule to reduce workload," to the user, who then uses this information to cultivate rice.

[1441] Example 2

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

[1443] In conventional agricultural data management systems, the quality of data is not uniform when receiving, preprocessing, and subsequently utilizing agricultural data, making it difficult to propose highly accurate cultivation methods.In addition, because proposals are made uniformly without taking into account the user's emotional state, there is also the issue of not being able to appropriately address user stress and satisfaction.

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

[1445] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the results to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the results, and sending the results to the terminal, means for recognizing the user's emotional state and analyzing the emotional data, means for adjusting the inference results based on the emotional data, and means for displaying the received results to the user. This makes it possible to propose optimal and personalized cultivation methods to users in different situations and conditions.

[1446] "Agricultural data" refers to a collection of various information related to agriculture, such as crop types, cultivation methods, fertilizer amounts, weather conditions, and pest and disease control measures.

[1447] "Preprocessing" refers to the process of removing noise and missing values ​​from the received data, correcting outliers, and standardizing the data format.

[1448] "Database" refers to a collection of information structured to store pre-processed agricultural data and to enable efficient retrieval and use.

[1449] "Generative AI model" refers to an artificial intelligence model that learns and infers optimal cultivation conditions and methods based on received and preprocessed agricultural data.

[1450] "User requirements" refers to information input by the user specifying the cultivation conditions and the type of crop desired.

[1451] "Format conversion" refers to the process of converting received data or requests into a standardized format.

[1452] "Emotion engine" refers to a function that analyzes the user's voice and facial expression data and recognizes the user's emotional state.

[1453] "Emotion data" refers to information about a user's emotional state analyzed by an emotion engine.

[1454] "Inference results" refer to the results of the generative AI model deriving the optimal cultivation method based on the user's requirements.

[1455] "Terminal" refers to a computing device used by a user to enter data and receive results.

[1456] MODE FOR CARRYING OUT THE INVENTION

[1457] This invention is a system that receives agricultural data, preprocesses it, stores it in a database, trains an AI model, processes user requests, provides information, and recognizes user emotions using an emotion engine. This system is realized using multiple specific hardware and software. Specific embodiments for implementing the invention are described below.

[1458] Data collection and preprocessing

[1459] Subject: Server

[1460] The server receives agricultural data provided by farmers via the Internet. The received data includes information on crop type, cultivation method, fertilizer application rate, weather conditions, and pest and disease control measures. The received data is preprocessed using data processing libraries such as Python and R. This preprocessing includes removing noise and missing values ​​and normalizing the data format.

[1461] Examples:

[1462] The server receives data sent by Farmer A, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%" via an API endpoint. The server uses Python's Pandas library to remove outliers and missing data from the received data and converts it into a unified data format.

[1463] Storage in the database

[1464] Subject: Server

[1465] Once the preprocessing is complete, the data is stored in a database by the server. A relational database such as MySQL or PostgreSQL is used as the database. The data is classified by crop and cultivation conditions, and an index is generated to enable efficient searches.

[1466] Examples:

[1467] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates the necessary indexes.

[1468] Data extraction and AI model training

[1469] Subject: Server

[1470] The server extracts agricultural data from the database and uses it to train a generative AI model. Machine learning libraries such as Scikit-learn and TensorFlow are used to train the AI ​​model. The extracted data is divided into input features and output values ​​and used as a training dataset.

[1471] Examples:

[1472] The server extracts data related to "growing tomatoes in cold climates" from the database and uses Scikit-learn to train a model that learns irrigation schedules and fertilizer combinations appropriate for cold climate conditions.

[1473] User request reception and emotion engine

[1474] Subject: Terminal

[1475] The device receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server. The user can input text or voice, and the device's emotion engine analyzes the user's emotional state. The emotion engine uses a commercial emotion recognition library (such as Microsoft Azure's emotion recognition API).

[1476] Examples:

[1477] The user makes a request through a smartphone app by voice, saying, "I want to grow tomatoes in a cold climate." The device analyzes the voice data with its emotion engine and detects that the user is feeling stressed.

[1478] Submitting requests and providing information

[1479] Subject: Server

[1480] The request data, including emotional data, is sent from the device to the server. The server searches for relevant agricultural information from a database based on the user's request and infers the optimal cultivation method using a generative AI model. It then adjusts the recommendations based on the user's emotional state, converts the results, and sends them to the device.

[1481] Examples:

[1482] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow seeds in April and keep them warm in a plastic tunnel." It also suggests simpler methods and additional advice if the user is feeling stressed.

[1483] Displaying the results

[1484] Subject: Terminal

[1485] The device receives the inference results and advice based on emotions sent from the server and displays them to the user, who then uses the inference results and advice to cultivate the plants.

[1486] Examples:

[1487] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[1488] Example prompt sentence:

[1489] What is the best way to grow tomatoes in cold climates?

[1490] I'd like to know how to grow tomatoes in cold climates. They're currently stressed, so please suggest some easy solutions.

[1491] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

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

[1493] Step 1: Data collection

[1494] Subject: Server

[1495] The server receives agricultural data provided by farmers via the internet, specifically via a dedicated API endpoint, and the data includes crop type, cultivation method, fertilizer amount, weather conditions, and pest and disease control measures.

[1496] Input: Agricultural data from farmers

[1497] Output: Raw data received

[1498] Specific behavior:

[1499] The server receives data sent by Farmer A via the API, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%."

[1500] Step 2: Data Preprocessing

[1501] Subject: Server

[1502] The server preprocesses the received agricultural data to remove noise and missing values ​​and normalize the data format, using the Python Pandas library.

[1503] Input: Raw data received

[1504] Output: Preprocessed data

[1505] Specific behavior:

[1506] The server detects missing values ​​(for example, missing temperature data) and abnormal values ​​(for example, an abnormal pH value of 20) in the received data, corrects and complements them in an appropriate manner, and also standardizes the data format and converts it into JSON format.

[1507] Step 3: Store in the database

[1508] Subject: Server

[1509] After preprocessing, the server stores the data in a database, typically a relational database such as MySQL or PostgreSQL. The data is categorized by crop and cultivation conditions, and an index is generated.

[1510] Input: Preprocessed data

[1511] Output: Data stored in the database

[1512] Specific behavior:

[1513] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates an index to improve search efficiency.

[1514] Step 4: Data extraction

[1515] Subject: Server

[1516] The server extracts agricultural data from the database based on specific conditions, for example, data related to specific growing conditions according to a user's request.

[1517] Input: Data in the database

[1518] Output: Extracted data

[1519] Specific behavior:

[1520] The server uses SQL queries to search and extract data related to "growing tomatoes in cold climates" from the database.

[1521] Step 5: Generate a training dataset for the AI ​​model

[1522] Subject: Server

[1523] The server creates a training dataset for the AI ​​model based on the extracted agricultural data. The dataset is organized into input features and output values.

[1524] Input: Extracted data

[1525] Output: Training dataset

[1526] Specific behavior:

[1527] Based on the extracted cold-region tomato cultivation data, the server uses the Scikit-learn library to separate and organize the data into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, taste index).

[1528] Step 6: Training the AI ​​model

[1529] Subject: Server

[1530] The server uses the training dataset to train the AI ​​model, specifically using machine learning algorithms to learn optimal growing conditions from agricultural data.

[1531] Input: Training dataset

[1532] Output: Trained AI model

[1533] Specific behavior:

[1534] The server uses Scikit-learn and TensorFlow to train a model that learns optimal cultivation conditions based on a training dataset.

[1535] Step 7: Receiving the user's request

[1536] Subject: Terminal

[1537] The terminal receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server.

[1538] Input: User request

[1539] Output: Reformatted request data

[1540] Specific behavior:

[1541] The user inputs "I want to grow tomatoes in a cold climate" through a smartphone app, and the device converts the request into JSON format and sends it to the server.

[1542] Step 8: Emotion Recognition with the Emotion Engine

[1543] Subject: Terminal

[1544] The device analyzes the user's voice and facial expression data using an emotion engine to recognize the user's emotional state.

[1545] Input: User's voice and facial expression data

[1546] Output: Parsed emotion data

[1547] Specific behavior:

[1548] The device collects facial photos and voice data when the user inputs a request, and uses an emotion engine to determine whether the user is "feeling stressed."

[1549] Step 9: Submitting the request

[1550] Subject: Terminal

[1551] The terminal transmits the request data, including the emotional state, to the server.

[1552] Input: Format-converted request data and emotion data

[1553] Output: Request data and emotion data sent to the server

[1554] Specific behavior:

[1555] The terminal transmits the user's request "Please tell me how to grow tomatoes in a cold climate" and data including the user's emotional state to the server.

[1556] Step 10: Information Retrieval and Reasoning

[1557] Subject: Server

[1558] The server searches for relevant agricultural information from a database based on the requested data, uses AI models to infer optimal cultivation methods, and adjusts its suggestions according to the user's emotional state.

[1559] Input: Request data and emotion data

[1560] Output: Inference results and adjusted recommendations

[1561] Specific behavior:

[1562] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also offers easier methods and additional advice.

[1563] Step 11: View the results

[1564] Subject: Terminal

[1565] The terminal receives advice based on optimal cultivation methods and emotions sent from the server and displays it to the user.

[1566] Input: Inference results and adjusted proposals

[1567] Output: Cultivation methods and advice displayed to the user

[1568] Specific behavior:

[1569] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[1570] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[1571] (Application example 2)

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

[1573] In modern agriculture, finding the optimal method for growing crops is important, but this process often causes stress for farmers. There is also a need for detailed support that takes farmers' emotions into consideration while effectively utilizing agricultural data. Therefore, there is a need for a system that proposes optimal cultivation methods based on farmers' emotions, reduces their stress, and enables efficient cultivation.

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

[1575] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database; a means for extracting agricultural data from the database and training a generative AI model; a means for recognizing a user's emotions, adjusting the optimal cultivation method based on the emotions, converting the format of the results, and transmitting them to a terminal; and a means for displaying advice to the user based on the received results and emotions. This makes it possible to propose optimal cultivation methods that take the user's emotions into consideration. It also reduces user stress and provides support for efficient agricultural work.

[1576] "Agricultural data" refers to data that includes information related to agriculture, such as crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[1577] "Preprocessing" refers to a series of processes that remove noise and missing values ​​from received agricultural data and standardize the data format.

[1578] A "database" is a repository of information that stores data in an organized format and makes it easy to search and retrieve.

[1579] A "generative AI model" is a model that uses machine learning algorithms to learn from a training dataset and has the ability to perform a specific task (e.g., infer optimal cultivation methods).

[1580] "User emotion recognition" is the process of analyzing data such as the user's voice and facial expressions to understand their emotional state.

[1581] "Emotion-based adjustment" refers to appropriately changing the cultivation methods and advice provided depending on the user's emotional state.

[1582] "Format conversion" is the operation of converting data into an appropriate format before transmitting the data.

[1583] A "terminal" is a device (e.g., a smartphone or tablet) that a user uses as an interface.

[1584] "Inference" is the process by which a generative AI model determines the best solution or method based on specific input data.

[1585] "Emotion-based advice" is specific advice or recommendations that are provided taking into account the user's emotional state.

[1586] This invention is a food delivery system that combines agricultural data with user emotional information to suggest optimal cultivation methods.

[1587] The server first receives the agricultural data, preprocesses it, and then stores it in a database. Specifically, the agricultural data includes information on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc. The server normalizes this data and removes noise and missing values.

[1588] The server then extracts agricultural data from the database and uses it to train a generative AI model. The AI ​​model outputs indicators of yield and taste based on input features such as soil pH, temperature, and rainfall. The model can also adjust cultivation methods based on the user's emotional information.

[1589] The device receives requests from the user, converts the format, and sends the data to the server.The device also has an emotion engine that recognizes emotional information from the user's voice and facial expressions and analyzes their emotional state.

[1590] The server infers the optimal cultivation method based on the request and emotional information sent from the device, converts the format of the result, and sends it to the device. The inferred result also includes advice based on the user's emotional state. For example, if the user is feeling stressed, simple cultivation methods or additional advice will be provided.

[1591] Finally, the device displays the results and emotional advice sent from the server to the user, allowing the user to implement optimal cultivation methods.

[1592] The system's hardware includes a server for processing data and a smartphone or tablet for users. It uses Python, TensorFlow, OpenCV, pandas, and scikit-learn for software, performing a series of operations: receiving data, preprocessing, storing data, training an AI model, performing emotion recognition, inference, and displaying the results.

[1593] As a concrete example, if a user types into a device, "I want to grow tomatoes in a cold climate," the device converts the request and sends it to the server. At the same time, the device analyzes the user's voice and facial expressions to detect whether the user is feeling stressed. Based on this information, the server infers the optimal cultivation method - "sow the seeds in April and keep them warm in a plastic tunnel" - and adds advice to reduce the user's stress (for example, a schedule for frequent rest and light work) and sends the results to the device. The device displays these results to the user, who uses them as a reference when cultivating the plants.

[1594] Example prompt sentence:

[1595] Analyze a user's facial photo, recognize their emotional state (e.g., stress, joy), and suggest food recommendations based on that. Recommend meals that match your current emotional state.

[1596] In this way, it becomes possible to propose optimal cultivation methods that take the user's emotions into consideration, thereby realizing a system that reduces user stress and supports efficient cultivation work.

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

[1598] Step 1:

[1599] The server receives agricultural data and performs preprocessing. Specifically, it receives data on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc., normalizes the data, and removes noise and missing values. The preprocessed data is then converted into a unified format.

[1600] Input: Agricultural data

[1601] Output: Preprocessed agricultural data

[1602] Step 2:

[1603] The server stores the pre-processed agricultural data in a database, where the data is categorized by crop and structured for easy later retrieval.

[1604] Input: Preprocessed agricultural data

[1605] Output: Agricultural data stored in a database

[1606] Step 3:

[1607] The server extracts agricultural data from the database and trains the generative AI model. The data is divided into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, palatability index), and used as a training dataset for the AI ​​model.

[1608] Input: Agricultural data extracted from a database

[1609] Output: training dataset, generative AI model

[1610] Step 4:

[1611] The server uses a generative AI model to infer optimal cultivation methods, specifically by providing input data to the model, which infers optimal irrigation schedules and fertilizer combinations.

[1612] Input: training dataset, generative AI model

[1613] Output: Inferred optimal cultivation method

[1614] Step 5:

[1615] The terminal receives requests from users, converts the format, and sends the data to the server. Users input cultivation conditions and desired crop types using a smartphone or tablet.

[1616] Input: Request from the user

[1617] Output: Reformatted request data, sent to the server

[1618] Step 6:

[1619] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state, for example, determining whether they are feeling stressed.

[1620] Input: User's voice and facial expression data

[1621] Output: Parsed emotional state

[1622] Step 7:

[1623] The server uses a generative AI model to infer the optimal cultivation method based on the request and emotional information sent from the device, converts the results into a different format, and sends them to the device. The inferred results also include advice based on the emotional information.

[1624] Input: Formatted request data, emotional state

[1625] Output: Inferred optimal cultivation method and advice, format-converted result data, sent to terminal

[1626] Step 8:

[1627] The device displays the results and advice based on the user's emotions to the user, allowing the user to implement optimal cultivation methods.

[1628] Input: Results and advice sent by the server

[1629] Output: What is displayed to the user

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

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

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

[1633] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1647] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. This system receives agricultural data, stores it in a database, trains an AI model, and suggests optimal cultivation methods to users. The program processing of this system is explained below in natural language.

[1648] Program processing and specific examples

[1649] Data collection and storage

[1650] Subject: Server

[1651] The server receives agricultural data provided by farmers. For example, it receives data about tomato cultivation (e.g., soil pH, fertilizer application rate, irrigation schedule, etc.). This data includes details such as cultivation method, weather conditions, soil composition, and yield. This received data is preprocessed to remove noise and missing values. The preprocessed data is then stored in a database.

[1652] Examples:

[1653] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes noise, and stores the data in a database.

[1654] Creating a database of know-how and training AI models

[1655] Subject: Server

[1656] The server extracts past data on the target crop from the database. For example, it extracts all data related to tomato cultivation. This extracted data is used to generate a training dataset for the AI ​​model. The training dataset is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). Based on this, the AI ​​model is trained to learn optimal cultivation conditions and techniques.

[1657] Examples:

[1658] The server trains the AI ​​model based on "cold climate tomato cultivation data" extracted from the database, learning the optimal irrigation schedule and fertilizer combinations.

[1659] Providing information based on user requests

[1660] Subject: Terminal

[1661] The terminal receives the cultivation conditions and desired crop type input by the user. For example, it receives input such as "How to grow tomatoes in cold climates." This request is converted into a format that the server can easily process and sent to the server.

[1662] Examples:

[1663] The terminal allows new farmers to input "I want to grow tomatoes in a cold climate" and sends the request to the server.

[1664] Proposal of optimal cultivation methods

[1665] Subject: Server

[1666] The server receives a user request sent from the device and searches for relevant information from a database based on that request. For example, it searches for data on tomato cultivation in cold climates. It then uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a format that is easy for the user to understand and sent to the device.

[1667] Examples:

[1668] Based on tomato cultivation data from cold regions, the server uses a generative AI model to generate a specific suggestion, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends this to the device.

[1669] Displaying suggestions to users

[1670] Subject: Terminal

[1671] The terminal receives the optimal cultivation method proposal sent from the server and displays it to the user, who can then create a specific cultivation plan based on the proposal.

[1672] Examples:

[1673] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins cultivating tomatoes based on this suggestion.

[1674] In this way, this system can provide farmers and new entrants with efficient and easy-to-understand agricultural know-how, enabling a stable supply of delicious vegetables.

[1675] The processing flow will be explained below.

[1676] Step 1: Data collection and preprocessing

[1677] Subject: Server

[1678] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer application rate, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[1679] Examples:

[1680] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[1681] Step 2: Store in the database

[1682] Subject: Server

[1683] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[1684] Examples:

[1685] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[1686] Step 3: Data extraction

[1687] Subject: Server

[1688] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[1689] Examples:

[1690] The server extracts data on "growing tomatoes in cold climates" from the database.

[1691] Step 4: Generate a training dataset for the AI ​​model

[1692] Subject: Server

[1693] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[1694] Examples:

[1695] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[1696] Step 5: Training the AI ​​model

[1697] Subject: Server

[1698] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[1699] Examples:

[1700] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[1701] Step 6: Receiving a request from the user

[1702] Subject: Terminal

[1703] The terminal receives cultivation conditions and desired crop types input by the user, and converts the received requests into a format that the server can easily process.

[1704] Examples:

[1705] The terminal receives a request input by the user, such as "I want to grow tomatoes in a cold climate," and sends it to the server.

[1706] Step 7: Submitting the request

[1707] Subject: Terminal

[1708] The terminal then sends the converted request to the server, which includes the specific growing conditions and type of crop.

[1709] Examples:

[1710] The terminal transmits the user's request "How to grow tomatoes in cold regions" to the server.

[1711] Step 8: Information Search

[1712] Subject: Server

[1713] The server searches the database for relevant information based on the request sent from the device, extracts the necessary data, and inputs it into the AI ​​model.

[1714] Examples:

[1715] The server searches and extracts data related to tomato cultivation in cold climates from a database.

[1716] Step 9: Inference with the AI ​​model

[1717] Subject: Server

[1718] The server uses an AI model to infer the optimal cultivation method based on the extracted data, converts the inference results into a different format, and sends them to the device.

[1719] Examples:

[1720] The server uses an AI model to infer the optimal cultivation method, which is to sow seeds in April and keep them warm in a plastic tunnel, then converts the format and sends it to the terminal.

[1721] Step 10: View the results

[1722] Subject: Terminal

[1723] The terminal receives the results of the optimal cultivation method sent from the server and displays them to the user.

[1724] Examples:

[1725] The device displays the inference result to the user, "Sow the seeds in April and keep them warm in a plastic tunnel," and the user uses this as a reference when cultivating the crops.

[1726] Example 1

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

[1728] In the agricultural sector, there is a problem in that farmers cannot easily obtain optimal methods for efficiently cultivating delicious vegetables. It is particularly difficult for newcomers and inexperienced farmers to select appropriate cultivation methods and conditions. There is also a need to find cultivation methods that can quickly adapt to variables such as local weather conditions and soil composition.

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

[1730] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database, a means for extracting agricultural data from the database and training a generative AI model, and a means for collecting requests from users, converting the format, and sending the requests to the server, thereby enabling farmers to easily obtain efficient and optimal cultivation methods.

[1731] "Agricultural data" refers to data including information on crop cultivation methods, soil composition, weather conditions, irrigation information, fertilizer amounts, yields, and pest and disease control measures.

[1732] "Preprocessing" refers to processing that removes noise from the received data, complements abnormal values, and standardizes the data format.

[1733] A "database" is a data storage system that stores data in a structured format and allows the data to be easily searched and retrieved as needed.

[1734] A "generative AI model" is a model that outputs optimal cultivation methods and prediction results for input features based on a machine learning algorithm.

[1735] "User requirements" are input information including specific agricultural cultivation conditions, types of crops, and other desired items.

[1736] "Format conversion" is the process of changing data into a format that is easy for the server or terminal to process.

[1737] "Inference" refers to the use of trained generative AI models to calculate optimal cultivation methods and conditions.

[1738] A "terminal" is a device that a user operates to input and receive data. Examples include smartphones and personal computers.

[1739] "Results" are information about optimal cultivation methods and conditions obtained based on inferences from the generative AI model.

[1740] "Display" refers to providing information visually on a terminal screen, etc.

[1741] This invention is a system that provides know-how for efficiently cultivating delicious vegetables as a vegetable cultivation suggestion service. An overview of the system and specific implementation procedures are described below.

[1742] System Overview

[1743] The system is based on the interaction of a server, a terminal, and a user, and has the following main functions:

[1744] 1. Receive agricultural data, preprocess it and store it in a database.

[1745] 2. Train a generative AI model using agricultural data extracted from the database.

[1746] 3. Receive the user's cultivation request, convert it into a different format, and send it to the server.

[1747] 4. The generative AI model is used to infer the optimal cultivation method and the results are sent to the device.

[1748] 5. The terminal displays the received results to the user.

[1749] Data collection and preprocessing

[1750] Subject: Server

[1751] The server receives agricultural data provided by farmers via HTTPS. The received data undergoes preprocessing, such as noise removal and missing value completion. This preprocessing is performed using Python data processing libraries (e.g., Pandas and NumPy). For example, if the soil pH value is abnormal, it is completed using an appropriate predictive model.

[1752] Examples:

[1753] The server receives "tomato cultivation data in cold regions" provided by veteran farmers, removes outliers, and then stores the data in a database.

[1754] Storing data in a database

[1755] Subject: Server

[1756] Once the preprocessing is complete, the data is stored in an SQL database. MySQL or PostgreSQL are recommended for this system. The data is stored in a structured format that can be later searched and extracted as needed.

[1757] Training an AI model

[1758] Subject: Server

[1759] The server extracts historical data on specific crops from the database and trains a generative AI model using machine learning frameworks such as TensorFlow and PyTorch. For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[1760] Examples:

[1761] The server uses cold-climate tomato cultivation data to train an AI model and learn optimal irrigation schedules and fertilizer combinations.

[1762] User requirement collection and format conversion

[1763] Subject: Terminal

[1764] The user inputs the cultivation conditions and desired crop type via a terminal. The input information is converted into JSON format and sent to the server. Specific software examples include the use of a web-based front-end framework (e.g., React or Vue.js).

[1765] Examples:

[1766] A new farmer types into the terminal, "I want to grow tomatoes in a cold climate," and the request is converted into JSON format and sent to the server.

[1767] Inferring and providing optimal cultivation methods

[1768] Subject: Server

[1769] The server receives the user's request, searches the database for relevant information, uses a generative AI model to infer the optimal cultivation method, and then converts the results into a different format and sends them to the device.

[1770] Examples:

[1771] Based on cold-climate tomato cultivation data, the server generates specific suggestions, such as "sow the seeds in April and keep them warm in a plastic tunnel," and sends them to the terminal.

[1772] Displaying suggestions to users

[1773] Subject: Terminal

[1774] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[1775] Examples:

[1776] The terminal displays a suggestion to the new farmer to "sow the seeds in April and keep them warm in a plastic tunnel," and the new farmer begins growing tomatoes based on this suggestion.

[1777] This system will enable farmers and new entrants to the industry to receive efficient and easy-to-understand agricultural know-how, ensuring a stable supply of delicious vegetables.

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

[1779] Step 1: Receiving and preprocessing agricultural data

[1780] Subject: Server

[1781] Input: Agricultural data provided by farmers (e.g. soil pH, fertilizer application rates, irrigation schedules, etc.)

[1782] Output: Preprocessed data

[1783] The server receives agricultural data sent by farmers. After receiving the data, it removes noise, complements outliers, and standardizes the data format. Specifically, it uses Python data processing libraries (e.g., Pandas and NumPy) to clean and shape the data. For example, if the received soil pH value is outside the normal range, it is complemented using a predictive model.

[1784] Specific behavior:

[1785] The data receiving module obtains data from the farmer's terminal via HTTPS.

[1786] The data cleansing module checks for outliers (outlier filtering) and performs imputation using appropriate predictive models.

[1787] Step 2: Store the data in the database

[1788] Subject: Server

[1789] Input: Preprocessed data

[1790] Output: Results stored in the database

[1791] The preprocessed data is stored in a database. This system uses an SQL database (e.g., MySQL or PostgreSQL). The data is structured and stored in a format that can be searched and extracted later.

[1792] Specific behavior:

[1793] The database insert module converts the preprocessed data into SQL queries and inserts them into the database.

[1794] Step 3: Extract historical data and train the AI ​​model

[1795] Subject: Server

[1796] Input: Agricultural data extracted from the database

[1797] Output: A trained AI model

[1798] The server extracts historical data on specific crops from a database and trains a generative AI model using Python machine learning libraries (e.g., TensorFlow and PyTorch). For example, based on historical data on tomato cultivation, a model is constructed that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and flavor.

[1799] Specific behavior:

[1800] The data extraction module retrieves the required information from the database using SQL queries.

[1801] The machine learning module builds an AI model based on the acquired data, generates a training dataset, and trains the model.

[1802] Step 4: Collecting and formatting user requirements

[1803] Subject: Terminal

[1804] Input: Cultivation conditions and crop types entered by the user

[1805] Output: Reformatted user request (JSON format)

[1806] Users input cultivation conditions and the type of crop they want through their terminal. This information is then converted into JSON format for easy processing by the server and sent to the server. Specific software used is a web-based front-end framework (e.g., React or Vue.js).

[1807] Specific behavior:

[1808] A front-end interface displays user input forms and collects input from the user.

[1809] The input data is converted to JSON format and sent to the server.

[1810] Step 5: Infer and provide optimal cultivation methods

[1811] Subject: Server

[1812] Input: User request (JSON format)

[1813] Output: Inference result (optimal cultivation method)

[1814] The server receives the user's request and searches the database for relevant information. It uses a generative AI model to infer the optimal cultivation method, converts the results, and sends them to the device. It uses a Python model inference library (e.g., Scikit-Learn, TensorFlow Serving).

[1815] Specific behavior:

[1816] The request analysis module analyzes the received request and obtains the necessary information from the database.

[1817] The inference module uses a generative AI model to infer optimal cultivation methods.

[1818] The inference results are converted into JSON format or similar and sent to the terminal.

[1819] Step 6: Displaying suggestions to users

[1820] Subject: Terminal

[1821] Input: Inference results sent from the server (JSON format)

[1822] Output: Optimal cultivation method displayed to the user

[1823] The terminal receives the optimal cultivation method proposals sent from the server and displays them to the user, who can then create a specific cultivation plan based on these proposals.

[1824] Specific behavior:

[1825] The response receiving module receives the data from the server.

[1826] A front-end interface analyzes the received data and presents it visually to the user.

[1827] These are the specific processing steps of the program for this system, which allows farmers and newcomers to easily acquire efficient and easy-to-understand agricultural know-how.

[1828] (Application example 1)

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

[1830] Previously, there were systems that proposed optimal cultivation methods based on agricultural data, but these systems required users to manually input data and check the results. Furthermore, the proposed cultivation methods were fixed, making it difficult to provide information in real time. This meant that retailers and store managers, in particular, had few opportunities to instantly learn optimal cultivation methods, making efficient and effective cultivation management difficult.

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

[1832] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the data to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the result, and sending it to a terminal, means for displaying the received result to the user, and means for suggesting cultivation methods to the user in real time via a smart device. This allows managers of brick-and-mortar stores and users of retail stores to instantly learn effective cultivation methods, enabling efficient and flexible crop management and sales.

[1833] "Agricultural data" is a set of information including crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[1834] "Preprocessing" is a data processing step to remove noise and missing values ​​from received data.

[1835] "Database" means a system for efficiently storing, retrieving, and managing pre-processed agricultural data.

[1836] A "generative AI model" is an artificial intelligence algorithm that is trained based on agricultural data and used to infer optimal cultivation methods and conditions.

[1837] "Format conversion" is the process of converting user requests and inference results into an easy-to-handle format.

[1838] The "server" is a central control unit that receives, pre-processes, and stores agricultural data, trains AI models, performs inference, and provides information to users.

[1839] "Smart devices" are mobile information terminals such as smartphones or smart glasses that are used to display cultivation methods in real time.

[1840] "Inference" is the process of using a generative AI model to determine the optimal cultivation method based on user requirements.

[1841] "Real-time" refers to immediate processing and information delivery with minimal delay.

[1842] A "prompt" is a specific instruction or question that inputs the user's request into the generative AI model.

[1843] This invention is a system that allows retailers and store managers to easily propose optimal vegetable cultivation methods for selling in their stores. The program processing of this system is explained below.

[1844] Server Processing

[1845] The server first receives agricultural data, which includes detailed information on cultivation methods, fertilizer usage, weather conditions, and pest control measures. This data is preprocessed to remove noise and missing values, and the formatted data is stored in a database. A high-performance database server is suitable for this purpose.

[1846] Next, the server extracts historical data on the target crop from the database and trains the generative AI model. Here, the training data is divided into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, flavor index). For training, a random forest regression model is built using Python's sklearn library. This model then learns the optimal cultivation conditions and techniques.

[1847] Terminal handling

[1848] When a user accesses the system through a smart device (such as a smartphone or smart glasses), the terminal receives input from the user. For example, the user may enter "How to grow tomatoes in cold climates" as a prompt. This request is formatted and sent to the server.

[1849] Proposal of optimal cultivation methods

[1850] The server receives the user's request, searches for relevant information from the database, and uses a generative AI model to infer the optimal cultivation method based on the retrieved data. The inference results are converted into a user-friendly format and sent to the device.

[1851] Displaying suggestions to users

[1852] The terminal displays the optimal cultivation method received from the server to the user. The user can then create a specific cultivation plan based on this suggestion. In addition, by suggesting cultivation methods to users in real time via their smart devices, it is possible to provide instant information to consumers as well.

[1853] Specific examples

[1854] For example, the server receives "tomato cultivation data in cold regions" and stores it in a database. Then, the generative AI model learns optimal irrigation schedules and fertilizer combinations. If a user inputs a request such as "I want to grow tomatoes in a cold region," the server generates a specific suggestion, such as "Sow the seeds in April and keep them warm in a plastic tunnel," and displays it on the smart device.

[1855] Prompt Sentence Examples

[1856] "Tell me about growing tomatoes in cold climates. Can you suggest the best way to grow them?"

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

[1858] Step 1:

[1859] The server first receives agricultural data. Specifically, it receives data sent by API or file transfer from farms and related institutions. This data includes detailed information such as cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures. The input is agricultural data, and the output is data that has been improved through preprocessing.

[1860] Step 2:

[1861] The server preprocesses the received agricultural data. It removes noise and missing values ​​from the input data, and fills and normalizes missing values. This improves the quality of the data and allows it to be stored efficiently in the database. Examples of data processing include removing outliers and filling missing values ​​with the average value. The preprocessed data is then stored in the database.

[1862] Step 3:

[1863] The server extracts historical data about a target crop from a database. For example, it retrieves all historical data about tomato cultivation. The input is a query condition in the database, and the output is the historical data extracted as a result of the query.

[1864] Step 4:

[1865] The server trains a generative AI model based on the extracted data. Specifically, it creates a training dataset by dividing the data into input features (e.g., soil pH, temperature, rainfall, etc.) and output values ​​(e.g., yield, palatability index). It then uses Python's sklearn library to build and train a random forest regression model. The input is the training data, and the output is a trained generative AI model.

[1866] Step 5:

[1867] A user accesses the system through a terminal (such as a smartphone or smart glasses) and inputs a prompt. For example, they ask, "How to grow tomatoes in cold climates." This request is sent to the server as user input. The input is the user's prompt, and the output is the request data sent to the server.

[1868] Step 6:

[1869] The server converts the format of the requested data received from the user and performs processing. Specifically, it uses a generative AI model to infer the optimal cultivation method. For example, "Sow seeds in April and keep them warm in a plastic tunnel." The input is the format-converted user request data, and the output is the inference result.

[1870] Step 7:

[1871] The server converts the inference results into a format that is easy for the user to understand (e.g., text or graphics) and sends them to the terminal. The input is the inference results, and the output is the converted result data.

[1872] Step 8:

[1873] The device displays the optimal cultivation method received from the server to the user. For example, a suggested result such as "Sow seeds in April and keep them warm in a plastic tunnel" may be displayed on the screen of a smartphone or smart glasses. The input is the format-converted result data, and the output is the information displayed to the user. This allows the user to create a specific cultivation plan based on the suggestion.

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

[1875] This invention is a vegetable production suggestion service that combines a series of operations, including receiving agricultural data, preprocessing, storing it in a database, training an AI model, processing user requests, and providing information, with an emotion engine that recognizes and analyzes user emotions. The purpose of this system is to provide optimal agricultural support based on the user's emotions. The program processing of this system is explained in detail below.

[1876] Program processing and specific examples

[1877] Data collection and preprocessing

[1878] Subject: Server

[1879] The server receives agricultural data provided by farmers. The data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing values. Normalization is also performed to standardize the data format.

[1880] Examples:

[1881] The server receives the "tomato cultivation know-how" provided by Farmer A (e.g., soil pH 6.5, 8 hours of sunlight, irrigation frequency), removes outliers and missing data, and normalizes it into a standard format.

[1882] Storage in the database

[1883] Subject: Server

[1884] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[1885] Examples:

[1886] The server stores the preprocessed "tomato cultivation data" in the "tomato" category of the database.

[1887] Data Extraction

[1888] Subject: Server

[1889] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[1890] Examples:

[1891] The server extracts data on "growing tomatoes in cold climates" from the database.

[1892] Generating training datasets for AI models

[1893] Subject: Server

[1894] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[1895] Examples:

[1896] Based on tomato cultivation data from cold regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and sugar content.

[1897] Training an AI model

[1898] Subject: Server

[1899] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[1900] Examples:

[1901] The server uses the generated training dataset to train an AI model to learn the optimal irrigation schedule and fertilizer combination for growing tomatoes in cold climates.

[1902] Receiving a user request

[1903] Subject: Terminal

[1904] The terminal receives input from the user, such as cultivation conditions and the type of crop desired. For example, it receives input such as "How to grow tomatoes in cold climates."

[1905] Examples:

[1906] The user inputs "I want to grow tomatoes in a cold climate" into the terminal, which then converts the request into a different format and sends it to the server.

[1907] Emotion recognition by emotion engine

[1908] Subject: Terminal

[1909] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[1910] Examples:

[1911] The device uses an emotion engine to analyze the voice when the user inputs a request and detects the user's stress level.

[1912] Submitting a request

[1913] Subject: Terminal

[1914] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[1915] Examples:

[1916] The terminal transmits the user's request "How to grow tomatoes in cold climates" and its emotional state to the server.

[1917] Information Retrieval and Reasoning

[1918] Subject: Server

[1919] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[1920] Examples:

[1921] The server searches for data on "growing tomatoes in cold climates" and uses a generative AI model to infer the optimal cultivation method: "Sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also suggests simpler methods and additional advice.

[1922] Displaying the results

[1923] Subject: Terminal

[1924] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[1925] Examples:

[1926] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[1927] In this way, this system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[1928] The processing flow will be explained below.

[1929] Step 1: Data collection and preprocessing

[1930] Subject: Server

[1931] The server receives agricultural data provided by farmers. This data includes information such as crop type, cultivation method, fertilizer amount, weather conditions, and pest control measures. The received data is preprocessed to remove noise and missing data. Normalization is also performed to standardize the data format.

[1932] Examples:

[1933] The server receives the "rice cultivation data" (e.g., soil pH 5.5, temperature fluctuations, irrigation frequency) provided by Farmer A, removes outliers and missing data, and normalizes it into a standard format.

[1934] Step 2: Store in the database

[1935] Subject: Server

[1936] The server stores the pre-processed data in a database, where it is categorized by crop and structured for efficient later retrieval.

[1937] Examples:

[1938] The server stores the preprocessed "rice cultivation data" in the "rice" category of the database.

[1939] Step 3: Data extraction

[1940] Subject: Server

[1941] The server extracts agricultural data from the database, the extracted data relating to the crop and growing conditions of interest.

[1942] Examples:

[1943] The server extracts data on "rice cultivation in cool regions" from the database.

[1944] Step 4: Generate a training dataset for the AI ​​model

[1945] Subject: Server

[1946] The server uses the extracted data to generate a training dataset for the AI ​​model, which is organized into input features (e.g., soil pH, temperature, and rainfall) and output values ​​(e.g., yield and palatability index).

[1947] Examples:

[1948] Based on rice cultivation data from cool regions, the server generates a training dataset with input features such as soil pH, temperature, and rainfall, and output values ​​of yield and quality.

[1949] Step 5: Training the AI ​​model

[1950] Subject: Server

[1951] The server uses the training dataset to train the AI ​​model, which then learns optimal cultivation conditions and techniques and improves its inference capabilities.

[1952] Examples:

[1953] The server uses the generated training dataset to train an AI model to learn optimal fertilizer combinations and irrigation schedules for rice cultivation in cool climates.

[1954] Step 6: Receiving a request from the user

[1955] Subject: Terminal

[1956] The terminal receives input from the user about cultivation conditions and the type of crop desired. For example, it receives input such as "How to cultivate rice in cool regions."

[1957] Examples:

[1958] The terminal allows the user to input a request for "the best method for growing rice in cool regions," and then converts the request into a different format before sending it to the server.

[1959] Step 7: Emotion Recognition with the Emotion Engine

[1960] Subject: Terminal

[1961] The device uses an emotion engine to analyze the user's voice and facial expressions to understand the user's emotional state. For example, it can determine from voice input whether the user is feeling stressed.

[1962] Examples:

[1963] The device uses an emotion engine to analyze the voice of the user when requesting cultivation methods and recognizes signs that the user is tired.

[1964] Step 8: Submitting the request

[1965] Subject: Terminal

[1966] The device sends a request to the server, including the emotional state, which includes the specific growing conditions, the type of crop, and the emotional data.

[1967] Examples:

[1968] The terminal transmits the user's request "How to grow rice in cool climates" and its emotional state to the server.

[1969] Step 9: Information retrieval and reasoning

[1970] Subject: Server

[1971] The server searches for relevant information from a database based on requests sent from the device, and then uses the data to infer optimal cultivation methods using an AI model. It also adjusts its suggestions based on the user's emotional state.

[1972] Examples:

[1973] The server searches for data related to "rice cultivation in cool climates" and uses a generative AI model to infer the optimal cultivation method, such as "sowing seeds in May and creating a specific irrigation schedule." If the user is feeling stressed, the server also suggests ways to reduce the workload.

[1974] Step 10: View the results

[1975] Subject: Terminal

[1976] The terminal receives the results of advice based on optimal cultivation methods and emotions sent from the server and displays them to the user.

[1977] Examples:

[1978] The device displays the inference result, "seeds should be sown in May and irrigation should be performed every two days," along with a "rest schedule to reduce workload," to the user, who then uses this information to cultivate rice.

[1979] Example 2

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

[1981] In conventional agricultural data management systems, the quality of data is not uniform when receiving, preprocessing, and subsequently utilizing agricultural data, making it difficult to propose highly accurate cultivation methods.In addition, because proposals are made uniformly without taking into account the user's emotional state, there is also the issue of not being able to appropriately address user stress and satisfaction.

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

[1983] In this invention, the server includes means for receiving agricultural data, preprocessing it, and storing it in a database, means for extracting agricultural data from the database and training a generative AI model, means for receiving requests from users, converting the format, and sending the results to the server, means for inferring the optimal cultivation method based on the user's request, converting the format of the results, and sending the results to the terminal, means for recognizing the user's emotional state and analyzing the emotional data, means for adjusting the inference results based on the emotional data, and means for displaying the received results to the user. This makes it possible to propose optimal and personalized cultivation methods to users in different situations and conditions.

[1984] "Agricultural data" refers to a collection of various information related to agriculture, such as crop types, cultivation methods, fertilizer amounts, weather conditions, and pest and disease control measures.

[1985] "Preprocessing" refers to the process of removing noise and missing values ​​from the received data, correcting outliers, and standardizing the data format.

[1986] "Database" refers to a collection of information structured to store pre-processed agricultural data and to enable efficient retrieval and use.

[1987] "Generative AI model" refers to an artificial intelligence model that learns and infers optimal cultivation conditions and methods based on received and preprocessed agricultural data.

[1988] "User requirements" refers to information input by the user specifying the cultivation conditions and the type of crop desired.

[1989] "Format conversion" refers to the process of converting received data or requests into a standardized format.

[1990] "Emotion engine" refers to a function that analyzes the user's voice and facial expression data and recognizes the user's emotional state.

[1991] "Emotion data" refers to information about a user's emotional state analyzed by an emotion engine.

[1992] "Inference results" refer to the results of the generative AI model deriving the optimal cultivation method based on the user's requirements.

[1993] "Terminal" refers to a computing device used by a user to enter data and receive results.

[1994] MODE FOR CARRYING OUT THE INVENTION

[1995] This invention is a system that receives agricultural data, preprocesses it, stores it in a database, trains an AI model, processes user requests, provides information, and recognizes user emotions using an emotion engine. This system is realized using multiple specific hardware and software. Specific embodiments for implementing the invention are described below.

[1996] Data collection and preprocessing

[1997] Subject: Server

[1998] The server receives agricultural data provided by farmers via the Internet. The received data includes information on crop type, cultivation method, fertilizer application rate, weather conditions, and pest and disease control measures. The received data is preprocessed using data processing libraries such as Python and R. This preprocessing includes removing noise and missing values ​​and normalizing the data format.

[1999] Examples:

[2000] The server receives data sent by Farmer A, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%" via an API endpoint. The server uses Python's Pandas library to remove outliers and missing data from the received data and converts it into a unified data format.

[2001] Storage in the database

[2002] Subject: Server

[2003] Once the preprocessing is complete, the data is stored in a database by the server. A relational database such as MySQL or PostgreSQL is used as the database. The data is classified by crop and cultivation conditions, and an index is generated to enable efficient searches.

[2004] Examples:

[2005] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates the necessary indexes.

[2006] Data extraction and AI model training

[2007] Subject: Server

[2008] The server extracts agricultural data from the database and uses it to train a generative AI model. Machine learning libraries such as Scikit-learn and TensorFlow are used to train the AI ​​model. The extracted data is divided into input features and output values ​​and used as a training dataset.

[2009] Examples:

[2010] The server extracts data related to "growing tomatoes in cold climates" from the database and uses Scikit-learn to train a model that learns irrigation schedules and fertilizer combinations appropriate for cold climate conditions.

[2011] User request reception and emotion engine

[2012] Subject: Terminal

[2013] The device receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server. The user can input text or voice, and the device's emotion engine analyzes the user's emotional state. The emotion engine uses a commercial emotion recognition library (such as Microsoft Azure's emotion recognition API).

[2014] Examples:

[2015] The user makes a request through a smartphone app by voice, saying, "I want to grow tomatoes in a cold climate." The device analyzes the voice data with its emotion engine and detects that the user is feeling stressed.

[2016] Submitting requests and providing information

[2017] Subject: Server

[2018] The request data, including emotional data, is sent from the device to the server. The server searches for relevant agricultural information from a database based on the user's request and infers the optimal cultivation method using a generative AI model. It then adjusts the recommendations based on the user's emotional state, converts the results, and sends them to the device.

[2019] Examples:

[2020] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow seeds in April and keep them warm in a plastic tunnel." It also suggests simpler methods and additional advice if the user is feeling stressed.

[2021] Displaying the results

[2022] Subject: Terminal

[2023] The device receives the inference results and advice based on emotions sent from the server and displays them to the user, who then uses the inference results and advice to cultivate the plants.

[2024] Examples:

[2025] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[2026] Example prompt sentence:

[2027] What is the best way to grow tomatoes in cold climates?

[2028] I'd like to know how to grow tomatoes in cold climates. They're currently stressed, so please suggest some easy solutions.

[2029] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

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

[2031] Step 1: Data collection

[2032] Subject: Server

[2033] The server receives agricultural data provided by farmers via the internet, specifically via a dedicated API endpoint, and the data includes crop type, cultivation method, fertilizer amount, weather conditions, and pest and disease control measures.

[2034] Input: Agricultural data from farmers

[2035] Output: Raw data received

[2036] Specific behavior:

[2037] The server receives data sent by Farmer A via the API, such as "soil pH 6.5, sunshine hours 8 hours, irrigation frequency, average temperature 15°C, humidity 60%."

[2038] Step 2: Data Preprocessing

[2039] Subject: Server

[2040] The server preprocesses the received agricultural data to remove noise and missing values ​​and normalize the data format, using the Python Pandas library.

[2041] Input: Raw data received

[2042] Output: Preprocessed data

[2043] Specific behavior:

[2044] The server detects missing values ​​(for example, missing temperature data) and abnormal values ​​(for example, an abnormal pH value of 20) in the received data, corrects and complements them in an appropriate manner, and also standardizes the data format and converts it into JSON format.

[2045] Step 3: Store in the database

[2046] Subject: Server

[2047] After preprocessing, the server stores the data in a database, typically a relational database such as MySQL or PostgreSQL. The data is categorized by crop and cultivation conditions, and an index is generated.

[2048] Input: Preprocessed data

[2049] Output: Data stored in the database

[2050] Specific behavior:

[2051] The server inserts the preprocessed "tomato cultivation data" into the "tomato" table of the database and creates an index to improve search efficiency.

[2052] Step 4: Data extraction

[2053] Subject: Server

[2054] The server extracts agricultural data from the database based on specific conditions, for example, data related to specific growing conditions according to a user's request.

[2055] Input: Data in the database

[2056] Output: Extracted data

[2057] Specific behavior:

[2058] The server uses SQL queries to search and extract data related to "growing tomatoes in cold climates" from the database.

[2059] Step 5: Generate a training dataset for the AI ​​model

[2060] Subject: Server

[2061] The server creates a training dataset for the AI ​​model based on the extracted agricultural data. The dataset is organized into input features and output values.

[2062] Input: Extracted data

[2063] Output: Training dataset

[2064] Specific behavior:

[2065] Based on the extracted cold-region tomato cultivation data, the server uses the Scikit-learn library to separate and organize the data into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, taste index).

[2066] Step 6: Training the AI ​​model

[2067] Subject: Server

[2068] The server uses the training dataset to train the AI ​​model, specifically using machine learning algorithms to learn optimal growing conditions from agricultural data.

[2069] Input: Training dataset

[2070] Output: Trained AI model

[2071] Specific behavior:

[2072] The server uses Scikit-learn and TensorFlow to train a model that learns optimal cultivation conditions based on a training dataset.

[2073] Step 7: Receiving the user's request

[2074] Subject: Terminal

[2075] The terminal receives information entered by the user about cultivation conditions and the type of crop desired, converts the format, and sends it to the server.

[2076] Input: User request

[2077] Output: Reformatted request data

[2078] Specific behavior:

[2079] The user inputs "I want to grow tomatoes in a cold climate" through a smartphone app, and the device converts the request into JSON format and sends it to the server.

[2080] Step 8: Emotion Recognition with the Emotion Engine

[2081] Subject: Terminal

[2082] The device analyzes the user's voice and facial expression data using an emotion engine to recognize the user's emotional state.

[2083] Input: User's voice and facial expression data

[2084] Output: Parsed emotion data

[2085] Specific behavior:

[2086] The device collects facial photos and voice data when the user inputs a request, and uses an emotion engine to determine whether the user is "feeling stressed."

[2087] Step 9: Submitting the request

[2088] Subject: Terminal

[2089] The terminal transmits the request data, including the emotional state, to the server.

[2090] Input: Format-converted request data and emotion data

[2091] Output: Request data and emotion data sent to the server

[2092] Specific behavior:

[2093] The terminal transmits the user's request "Please tell me how to grow tomatoes in a cold climate" and data including the user's emotional state to the server.

[2094] Step 10: Information Retrieval and Reasoning

[2095] Subject: Server

[2096] The server searches for relevant agricultural information from a database based on the requested data, uses AI models to infer optimal cultivation methods, and adjusts its suggestions according to the user's emotional state.

[2097] Input: Request data and emotion data

[2098] Output: Inference results and adjusted recommendations

[2099] Specific behavior:

[2100] The server searches the database for data related to "growing tomatoes in cold climates" and uses a generative AI model to infer optimal cultivation methods, such as "sow the seeds in April and keep them warm in a plastic tunnel." If the user is feeling stressed, it also offers easier methods and additional advice.

[2101] Step 11: View the results

[2102] Subject: Terminal

[2103] The terminal receives advice based on optimal cultivation methods and emotions sent from the server and displays it to the user.

[2104] Input: Inference results and adjusted proposals

[2105] Output: Cultivation methods and advice displayed to the user

[2106] Specific behavior:

[2107] The device displays the inference result, "Sow the seeds in April and keep them warm in a plastic tunnel," along with a "schedule for rest and light work to reduce stress," and the user uses this information to cultivate the crops.

[2108] This system integrates agricultural data and the user's emotional state to suggest optimal cultivation methods, providing an environment in which users can efficiently grow delicious vegetables.

[2109] (Application example 2)

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

[2111] In modern agriculture, finding the optimal method for growing crops is important, but this process often causes stress for farmers. There is also a need for detailed support that takes farmers' emotions into consideration while effectively utilizing agricultural data. Therefore, there is a need for a system that proposes optimal cultivation methods based on farmers' emotions, reduces their stress, and enables efficient cultivation.

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

[2113] In this invention, the server includes a means for receiving agricultural data, preprocessing it, and storing it in a database; a means for extracting agricultural data from the database and training a generative AI model; a means for recognizing a user's emotions, adjusting the optimal cultivation method based on the emotions, converting the format of the results, and transmitting them to a terminal; and a means for displaying advice to the user based on the received results and emotions. This makes it possible to propose optimal cultivation methods that take the user's emotions into consideration. It also reduces user stress and provides support for efficient agricultural work.

[2114] "Agricultural data" refers to data that includes information related to agriculture, such as crop cultivation methods, fertilizer usage, weather conditions, and pest and disease control measures.

[2115] "Preprocessing" refers to a series of processes that remove noise and missing values ​​from received agricultural data and standardize the data format.

[2116] A "database" is a repository of information that stores data in an organized format and makes it easy to search and retrieve.

[2117] A "generative AI model" is a model that uses machine learning algorithms to learn from a training dataset and has the ability to perform a specific task (e.g., infer optimal cultivation methods).

[2118] "User emotion recognition" is the process of analyzing data such as the user's voice and facial expressions to understand their emotional state.

[2119] "Emotion-based adjustment" refers to appropriately changing the cultivation methods and advice provided depending on the user's emotional state.

[2120] "Format conversion" is the operation of converting data into an appropriate format before transmitting the data.

[2121] A "terminal" is a device (e.g., a smartphone or tablet) that a user uses as an interface.

[2122] "Inference" is the process by which a generative AI model determines the best solution or method based on specific input data.

[2123] "Emotion-based advice" is specific advice or recommendations that are provided taking into account the user's emotional state.

[2124] This invention is a food delivery system that combines agricultural data with user emotional information to suggest optimal cultivation methods.

[2125] The server first receives the agricultural data, preprocesses it, and then stores it in a database. Specifically, the agricultural data includes information on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc. The server normalizes this data and removes noise and missing values.

[2126] The server then extracts agricultural data from the database and uses it to train a generative AI model. The AI ​​model outputs indicators of yield and taste based on input features such as soil pH, temperature, and rainfall. The model can also adjust cultivation methods based on the user's emotional information.

[2127] The device receives requests from the user, converts the format, and sends the data to the server.The device also has an emotion engine that recognizes emotional information from the user's voice and facial expressions and analyzes their emotional state.

[2128] The server infers the optimal cultivation method based on the request and emotional information sent from the device, converts the format of the result, and sends it to the device. The inferred result also includes advice based on the user's emotional state. For example, if the user is feeling stressed, simple cultivation methods or additional advice will be provided.

[2129] Finally, the device displays the results and emotional advice sent from the server to the user, allowing the user to implement optimal cultivation methods.

[2130] The system's hardware includes a server for processing data and a smartphone or tablet for users. It uses Python, TensorFlow, OpenCV, pandas, and scikit-learn for software, performing a series of operations: receiving data, preprocessing, storing data, training an AI model, performing emotion recognition, inference, and displaying the results.

[2131] As a concrete example, if a user types into a device, "I want to grow tomatoes in a cold climate," the device converts the request and sends it to the server. At the same time, the device analyzes the user's voice and facial expressions to detect whether the user is feeling stressed. Based on this information, the server infers the optimal cultivation method - "sow the seeds in April and keep them warm in a plastic tunnel" - and adds advice to reduce the user's stress (for example, a schedule for frequent rest and light work) and sends the results to the device. The device displays these results to the user, who uses them as a reference when cultivating the plants.

[2132] Example prompt sentence:

[2133] Analyze a user's facial photo, recognize their emotional state (e.g., stress, joy), and suggest food recommendations based on that. Recommend meals that match your current emotional state.

[2134] In this way, it becomes possible to propose optimal cultivation methods that take the user's emotions into consideration, thereby realizing a system that reduces user stress and supports efficient cultivation work.

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

[2136] Step 1:

[2137] The server receives agricultural data and performs preprocessing. Specifically, it receives data on crop cultivation methods, fertilizer usage, weather conditions, pest control measures, etc., normalizes the data, and removes noise and missing values. The preprocessed data is then converted into a unified format.

[2138] Input: Agricultural data

[2139] Output: Preprocessed agricultural data

[2140] Step 2:

[2141] The server stores the pre-processed agricultural data in a database, where the data is categorized by crop and structured for easy later retrieval.

[2142] Input: Preprocessed agricultural data

[2143] Output: Agricultural data stored in a database

[2144] Step 3:

[2145] The server extracts agricultural data from the database and trains the generative AI model. The data is divided into input features (e.g., soil pH, temperature, rainfall) and output values ​​(e.g., yield, palatability index), and used as a training dataset for the AI ​​model.

[2146] Input: Agricultural data extracted from a database

[2147] Output: training dataset, generative AI model

[2148] Step 4:

[2149] The server uses a generative AI model to infer optimal cultivation methods, specifically by providing input data to the model, which infers optimal irrigation schedules and fertilizer combinations.

[2150] Input: training dataset, generative AI model

[2151] Output: Inferred optimal cultivation method

[2152] Step 5:

[2153] The terminal receives requests from users, converts the format, and sends the data to the server. Users input cultivation conditions and desired crop types using a smartphone or tablet.

[2154] Input: Request from the user

[2155] Output: Reformatted request data, sent to the server

[2156] Step 6:

[2157] The device uses an emotion engine to analyze the user's voice and facial expressions to understand their emotional state, for example, determining whether they are feeling stressed.

[2158] Input: User's voice and facial expression data

[2159] Output: Parsed emotional state

[2160] Step 7:

[2161] The server uses a generative AI model to infer the optimal cultivation method based on the request and emotional information sent from the device, converts the results into a different format, and sends them to the device. The inferred results also include advice based on the emotional information.

[2162] Input: Formatted request data, emotional state

[2163] Output: Inferred optimal cultivation method and advice, format-converted result data, sent to terminal

[2164] Step 8:

[2165] The device displays the results and advice based on the user's emotions to the user, allowing the user to implement optimal cultivation methods.

[2166] Input: Results and advice sent by the server

[2167] Output: What is displayed to the user

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

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

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

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

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

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

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

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

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

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

[2178] 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 ap...

Claims

1. means for receiving, preprocessing and storing agricultural data in a database; a means for extracting agricultural data from the database and training a generative AI model; means for receiving a request from a user, converting the format and sending the request to a server; A means for inferring the optimum cultivation method based on the user's request, converting the format of the result, and transmitting it to the terminal; means for displaying the received results to a user; A system including:

2. 10. The system of claim 1, wherein the agricultural data includes data on cultivation methods, fertilizer usage, weather conditions, and pest control measures.

3. The system according to claim 1, wherein the generative AI model is a model that uses soil pH, temperature, and rainfall as input features and outputs indicators of yield and taste.

Images