System

Abstract

A system is provided.SOLUTION: A system including means for receiving a program code input by a user, means for using a generation AI that generates an improvement proposal by analyzing the received program code, means for adjusting the generated improvement proposal according to a skill level of the user, means for transmitting the adjusted improvement proposal and a reason thereof to a terminal of the user, and means for managing a learning progress by storing a code change history and an improvement proposal history of 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] Conventional programming learning systems often lack the ability to provide real-time feedback to help users improve the quality of their input. Furthermore, the lack of appropriate feedback tailored to the user's programming skill level leads to a decline in learning efficiency. Furthermore, the lack of a way to properly manage the user's learning progress makes it difficult to maintain motivation to learn. [Means for solving the problem]

[0005] To solve the above problems, the present invention provides the following means. It employs a means using a generation AI that receives program code entered by a user, analyzes the received code, and generates improvement suggestions. Natural language processing can be used for the analysis by this generation AI. It also provides a means for adjusting the generated improvement suggestions according to the user's skill level and sending the adjusted improvement suggestions and the reasons for their adjustments to the user's device. It also provides a means for saving the user's code change history and improvement suggestion history to manage learning progress. It also provides a means for obtaining the user's skill level as a self-evaluation form upon initial login and saving it in their profile. This configuration allows users to improve their programming skills while receiving effective feedback in real time, and centralizes the management of their learning progress.

[0006] "User" refers to an entity that uses this system to study and improve program code.

[0007] "Program code" refers to a set of computer-executable instructions.

[0008] The "means for receiving" refers to a function that allows the system to take in the program code entered by the user.

[0009] "Analysis" refers to the process of evaluating program code for syntax, style, and functionality.

[0010] "Improvement suggestions" refer to specific instructions or advice for improving the quality of code that are generated based on the results of the analysis.

[0011] "Generative AI" refers to a system that uses artificial intelligence to analyze program code and generate improvement suggestions.

[0012] "Skill level" refers to an indicator that indicates the user's programming ability and degree of experience.

[0013] "Adjustment" refers to the process of changing the improvement suggestions generated by the generation AI to suit the user's skill level.

[0014] "Terminal" refers to a computer or mobile device that a user uses to access the System.

[0015] "Code change history" refers to data that records how a user's code has changed.

[0016] "Improvement suggestion history" refers to the record of improvement suggestions made by the generation AI to the user.

[0017] "Learning progress" refers to an indicator that shows the degree and process by which a user has improved their programming skills.

[0018] "Self-assessment form" refers to an interface for users to enter and rate their own skill level.

[0019] "Profile" refers to the portion of a database that stores information about a user. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0028] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0041] As an embodiment of the present invention, a specific method for analyzing program code and proposing improvements will be described. This system uses generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[0042] Basic System Configuration

[0043] User-side configuration

[0044] 1. User: Operates the device on which the software is installed.

[0045] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connection capabilities.

[0046] Server-side configuration

[0047] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0048] 2. Generative AI: Artificial intelligence for program code analytics, including a natural language processing (NLP) engine and a coding style analysis engine.

[0049] Analysis of program code and improvement suggestions

[0050] Initial Setup and Login

[0051] 1. User: Launch the programming learning software and enter the required authentication information on the login screen.

[0052] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[0053] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[0054] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[0055] Code entry and analysis

[0056] 1. User: Enter the program code into the coding area of ​​the learning platform. For example, enter the following Python code:

[0057] python

[0058] for i in range(10):

[0059] print(i)

[0060] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[0061] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[0062] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0063] View and provide feedback on improvement suggestions

[0064] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[0065] python

[0066] Recommended way: More Pythonic way

[0067] for i in range(10):

[0068] print(f"{i}")

[0069] Why: String formatting improves code readability.

[0070] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[0071] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[0072] Learning progress management

[0073] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[0074] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[0075] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and individual learning progress management allow users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can easily understand why they should do something, rather than just receiving instructions.

[0076] The processing flow will be explained below.

[0077] Step 1:

[0078] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[0079] Step 2:

[0080] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[0081] Step 3:

[0082] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[0083] Step 4:

[0084] Terminal: Displays a form and allows users to enter their self-assessment.

[0085] Step 5:

[0086] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[0087] Step 6:

[0088] Server: Receives the entered skill information and saves it in the user profile.

[0089] Step 7:

[0090] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[0091] python

[0092] for i in range(10):

[0093] print(i)

[0094] Step 8:

[0095] User: After entering the code, click the Run button.

[0096] Step 9:

[0097] Terminal: The entered code and the click event of the Run button are sent to the server.

[0098] Step 10:

[0099] Server: Sends the received code to the Generator AI and associated analysis engine, which analyzes the code and generates improvement suggestions.

[0100] Step 11:

[0101] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0102] Step 12:

[0103] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device.

[0104] Step 13:

[0105] Device: Display the suggestion in the user interface, for example:

[0106] python

[0107] Recommended way: More Pythonic way

[0108] for i in range(10):

[0109] print(f"{i}")

[0110] Why: String formatting improves code readability.

[0111] Step 14:

[0112] User: Review the suggested improvements and reasons, then fix their code.

[0113] Step 15:

[0114] User: Click the Run button to run the modified code again.

[0115] Step 16:

[0116] Terminal: Send the modified code to the server.

[0117] Step 17:

[0118] Server: Re-analyze the modified code to ensure there are no problems.

[0119] Step 18:

[0120] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[0121] Step 19:

[0122] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[0123] Step 20:

[0124] On your device: Shows the feedback you received and your next learning steps.

[0125] These are the specific processing steps from when the user enters the code to when they receive improvement suggestions and manage their learning progress.

[0126] Example 1

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

[0128] Conventional programming learning systems have the problem that they only provide uniform feedback to users and do not offer appropriate improvement suggestions based on individual skill levels or learning progress. This means that users do not receive feedback tailored to their own skill level, making it difficult to progress effectively. Furthermore, they lack the functionality to record code change history and improvement suggestion history and centrally manage learning progress, making it difficult to track continuous learning effects.

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

[0130] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for managing learning progress by saving the user's code change history and improvement suggestion history; means for analyzing and evaluating the readability, efficiency, and safety of the code based on prompts to the generation AI model; and means for reanalyzing the corrected program code and generating further improvement suggestions. This enables appropriate feedback according to the user's skill level and centralized management of learning progress.

[0131] "Program code" refers to the set of instructions written by a user to create software or an application.

[0132] "Generative AI" is artificial intelligence that uses natural language processing and coding style analysis engines to analyze input program code and generate improvement suggestions.

[0133] "User skill level" is an index showing the user's programming skill level, and is information obtained based on a self-evaluation form when logging in for the first time.

[0134] A "profile" is a database entry that stores information related to a user, including information such as skill level and learning progress.

[0135] "Improvement suggestions" are guidelines and advice obtained by the generative AI when it analyzes program code, and are intended to improve the readability, efficiency, and safety of the code.

[0136] "Code change history" refers to data that records the history of modifications to program code entered by the user.

[0137] "Improvement proposal history" refers to data that records the history of improvement proposals provided to the user by the generation AI.

[0138] "Study progress management" is a function that centrally monitors and records the user's learning status and provides feedback and learning suggestions as needed.

[0139] A "prompt sentence to a generative AI model" is an input command given to the generative AI for analysis and evaluation.

[0140] "Natural language processing" is a technology that uses computers to process human language, and is used in this system to understand and analyze program code.

[0141] "Reanalysis" refers to the process of reanalyzing modified or changed program code in order to generate further improvement suggestions.

[0142] This system uses a generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[0143] Basic System Configuration

[0144] User-side configuration

[0145] User: Operates the device on which the software is installed.

[0146] Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connectivity.

[0147] Server-side configuration

[0148] Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and monitors learning progress.

[0149] Generative AI: Artificial intelligence for analyzing program code, including natural language processing (NLP) engines and coding style analysis engines.

[0150] Analysis of program code and improvement suggestions

[0151] Initial Setup and Login

[0152] The user starts the programming learning software and enters the required authentication information on the login screen. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the user's profile information is obtained. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is sent to the server. The server saves the received skill level information in the user profile and centrally manages the user's learning progress.

[0153] Code entry and analysis

[0154] Users enter program code into the coding area of ​​the learning platform, for example, the following Python code:

[0155] for i in range(10):

[0156] print(i)

[0157] The device sends the entered code and the event of clicking the run button to the server. The server then sends the received code to the generation AI and related analysis engine for analysis. The generation AI analyzes the code and generates improvement suggestions. The server adjusts the generated improvement suggestions according to the user's skill level. For example, it provides simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0158] View and provide feedback on improvement suggestions

[0159] The server will send the adjusted improvement suggestions and the reasons for them to the user's device, for example, as shown below:

[0160] Recommended way: More Pythonic way

[0161] for i in range(10):

[0162] print(f"{i}")

[0163] Why: String formatting improves code readability.

[0164] The device displays suggestions and reasons for the suggestions on the user's screen, making it easier for the user to correct the code. The user corrects the code based on the suggested improvements, and then clicks the Run button to run the corrected code again.

[0165] Learning progress management

[0166] The server then analyzes the modified code again, records and saves the user's code change history and improvement suggestion history, and manages the user's learning progress, generating additional feedback and next learning suggestions as needed and sending them to the device.

[0167] Prompt Sentence Examples

[0168] Entered code example

[0169] for i in range(5):

[0170] print(i)

[0171] Example prompts for generative AI models

[0172] Analyze the following Python code and offer suggestions to improve its readability and efficiency:

[0173] for i in range(5):

[0174] print(i)

[0175] The user's skill level is intermediate.

[0176] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. This allows real-time feedback and individual learning progress management, allowing users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can more easily understand why they should do something, rather than just receiving instructions.

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

[0178] Step 1:

[0179] Initial Setup and Login

[0180] User: Starts the programming learning software and enters the required authentication information (e.g., username and password) on the login screen.

[0181] Input: Username, Password

[0182] Output: Credentials

[0183] Server: Receives the authentication information, queries the user management database, and performs authentication. If the user is successfully authenticated, obtains the user's profile information (e.g., skill level) and sends it to the device.

[0184] Input: Credentials

[0185] Output: Profile information

[0186] Users: When they log in for the first time, they enter their skill level through a self-assessment form and submit it.

[0187] Input: Skill level information

[0188] Output: Self-assessment information

[0189] Server: The received skill level information is saved in the user profile and used to manage learning progress.

[0190] Input: Self-assessment information

[0191] Output: Updated profile

[0192] Step 2:

[0193] Code entry and analysis

[0194] User: Enter the program code in the coding area. For example, enter the following Python code:

[0195] python

[0196] for i in range(10):

[0197] print(i)

[0198] Input: Program code

[0199] Output: None

[0200] Terminal: Captures the entered code and the click event of the Run button and sends it to the server.

[0201] Input: Program code, Run button click event

[0202] Output: Data sent to the server

[0203] Server: Sends the received code to the Generator AI and associated analysis engine for analysis.

[0204] Input: Program code

[0205] Output: Prompt for the generation AI

[0206] Generative AI: Analyzes program code and generates improvement suggestions.

[0207] Input: prompt statement

[0208] Output: Improvement suggestions

[0209] Step 3:

[0210] Generate and refine improvement proposals

[0211] Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0212] Input: improvement suggestions, user skill level

[0213] Output: Adjusted improvement suggestions

[0214] Step 4:

[0215] View and provide feedback on improvement suggestions

[0216] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[0217] python

[0218] Recommended way: More Pythonic way

[0219] for i in range(10):

[0220] print(f"{i}")

[0221] Why: String formatting improves code readability.

[0222] Input: Adjusted improvement proposal

[0223] Output: Data for display

[0224] Terminal: Suggestions and their reasons are displayed on the screen, helping the user to fix their code.

[0225] Input: Data to display

[0226] Output: Feedback to the user

[0227] User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[0228] Input: Improvement suggestion, user modified code

[0229] Output: Corrected code

[0230] Step 5:

[0231] Learning progress management

[0232] Server: Analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[0233] Input: Correction Code

[0234] Output: Code change history, improvement proposal history

[0235] Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[0236] Input: Code change history, improvement proposal history

[0237] Output: Additional feedback, next learning suggestions

[0238] In this way, the system provides a learning environment for users to efficiently improve their programming skills. In addition, by providing suggestions and reasons for them, users can improve their learning effectiveness.

[0239] (Application example 1)

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

[0241] Conventional optimization of control programs for factory automation equipment requires specialized knowledge and a great deal of effort, and is heavily dependent on the skills and experience of the engineer. Furthermore, appropriate improvement proposals are not provided promptly, and malfunctions and performance degradation are likely to occur. This makes it difficult to improve the efficiency of factory operations.

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

[0243] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for saving the user's code change history and improvement suggestion history to manage learning progress; means for receiving a control program entered by a user and making suggestions related to the operation of factory automation equipment; means for generating improvement suggestions for improving performance or preventing malfunctions based on the received control program; and means for optimizing the generated improvement suggestions for the operation of the equipment. This enables the optimization of the control program for factory automation equipment and improvement suggestions to be performed quickly and accurately without relying on the skill of an engineer, thereby improving the efficiency of factory operations.

[0244] A "user" is someone who uses the system to input program code and receive improvement suggestions.

[0245] "Program code" is a series of instructions that a user inputs into a system to control factory automation equipment and the like.

[0246] "Generative AI" refers to artificial intelligence technology that analyzes received program code and generates improvement suggestions.

[0247] "Skill level" indicates the user's programming ability and affects the complexity and detail of the suggestions generated by the system.

[0248] "Terminal" refers to a computer or mobile device used by a user that has the function of displaying generated improvement suggestions, etc.

[0249] "Code change history" means the record of modifications and changes made by the user to the program code.

[0250] The "improvement proposal history" is a record of improvement proposals for program code generated by the system.

[0251] "Learning progress" is an indicator that shows how much a user has improved their programming skills by using the system.

[0252] "Factory automation equipment" refers to machines that perform factory work automatically and operate based on control programs.

[0253] "Improvement proposal" refers to the specific content of the improvement proposal for the program code generated by the generation AI.

[0254] "Magic prevention" refers to measures taken to prevent factory automation equipment from operating in an unintended manner.

[0255] This invention relates to a control program optimization system for factory automation equipment, which receives program code entered by a user, analyzes it using a generation AI, generates improvement proposals, and adjusts them according to the user's skill level. Below, we will explain how this system is specifically implemented.

[0256] 1. System Configuration

[0257] User-side configuration

[0258] 1. User: An engineer who operates a terminal on which programming learning software is installed. He / she inputs control programs and receives suggestions for improvements.

[0259] 2. Terminal: A computer or mobile device used by a user that has an input interface, a display interface, and network connection capabilities.

[0260] Server-side configuration

[0261] 1. Server: This is the central processing unit that processes requests from users. It receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0262] 2. Generative AI: Uses artificial intelligence techniques to analyze program code, including natural language processing (NLP) engines and coding style analysis engines.

[0263] 2. Program processing explanation

[0264] Entering and receiving program code

[0265] The user enters the control program for the factory automation device into the code input area of ​​the terminal. For example, the user enters the following Python code:

[0266] for i in range(10):

[0267] send_command("move", i)

[0268] The terminal sends the entered program code to the server, which receives it and proceeds to the next stage of analysis.

[0269] Code analysis and generation of improvement suggestions

[0270] The server sends the received program code to the generation AI, which analyzes it by inputting the following prompt sentence into the generation AI model:

[0271] Analyze the following code and provide enhancement suggestions for a beginner level user:

[0272] for i in range(10):

[0273] send_command("move", i)

[0274] Based on the code analyzed by the generative AI model, improvement suggestions are generated, such as:

[0275] Recommended improvement: Add a short delay beTWEEN® commands to safely control the robot.

[0276] import time

[0277] for i in range(10):

[0278] send_command("move", i)

[0279] time.sleep(0.1) Add a delay of 0.1 seconds

[0280] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[0281] Adjust and display improvement suggestions

[0282] The generated improvement suggestions are tailored to the user's skill level: beginners receive easy-to-understand suggestions, while advanced users receive more specific and sophisticated suggestions.

[0283] These adjustment suggestions and their reasons are then sent to the terminal and displayed on the user's screen. The user can then modify the control program based on the displayed suggestions and their reasons.

[0284] Save history and manage learning progress

[0285] The server stores the history of code changes made by the user and the history of improvement suggestions provided by the generation AI. This history data is used to manage the user's learning progress and to make the next improvement suggestions.

[0286] 3. Adding concrete examples

[0287] If a technician enters the following robot control program:

[0288] for i in range(5):

[0289] move_arm("up", i)

[0290] After analysis, the generative AI provides specific improvement suggestions for beginners:

[0291] Recommended improvement: Add a check to ensure safe arm movement.

[0292] if arm_position < max_limit:

[0293] for i in range(5):

[0294] move_arm("up", i)

[0295] Reason: This prevents the robotic arm from exceeding its maximum safe position.

[0296] In this manner, the system of the present invention provides an environment for users to safely and efficiently optimize control programs for factory automation equipment.

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

[0298] Step 1:

[0299] User: Entering program code

[0300] The user enters the control program for the factory automation device into the code input area of ​​the terminal. An example input is the following Python code:

[0301] for i in range(10):

[0302] send_command("move", i)

[0303] Input: Control program code entered by the user into the terminal.

[0304] Output: Entered program code in the terminal

[0305] Step 2:

[0306] Terminal: Sending program code

[0307] The terminal sends the program code entered by the user to the server, which analyzes the code.

[0308] Input: Program code entered into the terminal

[0309] Output: The program code sent to the server

[0310] Step 3:

[0311] Server: Receives program code

[0312] The server receives the program code sent from the terminal and proceeds to the next stage of analysis.

[0313] Input: Program code sent from the terminal

[0314] Output: The program code received by the server

[0315] Step 4:

[0316] Server: Generates prompts for the AI

[0317] The server generates a prompt sentence to be input to the generative AI model based on the received program code. An example of a prompt sentence is as follows:

[0318] Analyze the following code and provide enhancement suggestions for a beginner level user:

[0319] for i in range(10):

[0320] send_command("move", i)

[0321] Input: Program code received by the server

[0322] Output: A prompt to be fed to the generative AI model

[0323] Step 5:

[0324] Generative AI: Analyzing program code and generating improvement proposals

[0325] The generative AI model analyzes the program code based on the prompt and generates improvement suggestions, which are formatted as follows:

[0326] Recommended improvement: Add a short delay between commands to safely control the robot.

[0327] import time

[0328] for i in range(10):

[0329] send_command("move", i)

[0330] time.sleep(0.1) Add a delay of 0.1 seconds

[0331] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[0332] Input: A prompt sent to the generative AI model

[0333] Output: Improvement suggestions generated by the generative AI model

[0334] Step 6:

[0335] Server: Adjustment of improvement proposals

[0336] The server adjusts the improvement suggestions generated by the generative AI model according to the user's skill level: beginners are provided with easy-to-understand suggestions, while advanced users are provided with more advanced suggestions.

[0337] Input: Improvement suggestions generated by the generative AI model, user skill level

[0338] Output: Skill-level-adjusted improvement suggestions

[0339] Step 7:

[0340] Server: Submit improvement suggestions

[0341] The server then sends the adjusted improvement proposals and the reasons for the proposals to the user's terminal, who then modifies the control program based on these proposals.

[0342] Input: Skill-level-adjusted improvement suggestions

[0343] Output: Improvement suggestions sent to the device

[0344] Step 8:

[0345] Device: Show improvement suggestions

[0346] The terminal displays the improvement proposal received from the server and the reason for it on the user's screen.

[0347] Input: Improvement suggestions sent by the server

[0348] Output: Improvement suggestions displayed on the user's screen

[0349] Step 9:

[0350] User: Modifying the program code

[0351] The user modifies the control program based on the improvement suggestions displayed on the terminal, and the modified program is then analyzed again.

[0352] Input: Improvement suggestions displayed on the device

[0353] Output: Modified program code

[0354] Step 10:

[0355] Server: Save history and manage learning progress

[0356] The server stores the history of the program code modified by the user and the improvement suggestions provided by the generation AI, allowing for efficient management of the user's learning progress.

[0357] Input: Modified program code, improvement suggestions provided by the generative AI

[0358] Output: A saved history of code changes and improvement suggestions

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

[0360] As an embodiment of the present invention, we will explain a specific method that combines a system that analyzes a user's program code and makes improvement suggestions with an emotion engine that recognizes the user's emotions. This system analyzes program code and makes improvement suggestions using generative AI, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress.

[0361] Basic System Configuration

[0362] User-side configuration

[0363] 1. User: Operates the device on which the software is installed.

[0364] 2. Terminal: A computer or mobile device running programming learning software, equipped with an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[0365] Server-side configuration

[0366] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0367] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[0368] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback.

[0369] Analysis of program code and improvement suggestions

[0370] Initial Setup and Login

[0371] 1. User: Launch the programming learning software, enter the required authentication information on the login screen, and click the login button.

[0372] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[0373] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[0374] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[0375] Code entry and analysis

[0376] 1. User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[0377] python

[0378] for i in range(10):

[0379] print(i)

[0380] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[0381] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[0382] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0383] Emotion recognition and feedback regulation

[0384] 1. Terminal: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[0385] 2. Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it detects when the user is feeling stressed or confident.

[0386] 3. Server: Based on the emotional state recognized by the emotion engine, the production AI further adjusts its improvement suggestions. For example, it may provide a user who is feeling stressed with a less difficult suggestion or a more detailed explanation.

[0387] View and provide feedback on improvement suggestions

[0388] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[0389] python

[0390] Recommended way: More Pythonic way

[0391] for i in range(10):

[0392] print(f"{i}")

[0393] Why: String formatting improves code readability.

[0394] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[0395] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[0396] Learning progress management

[0397] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[0398] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[0399] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Furthermore, by providing suggestions and reasons alongside them, users can more easily understand why they should do something, rather than just being told what to do. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[0400] The processing flow will be explained below.

[0401] Step 1:

[0402] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[0403] Step 2:

[0404] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[0405] Step 3:

[0406] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[0407] Step 4:

[0408] Terminal: Displays a form and allows users to enter their self-assessment.

[0409] Step 5:

[0410] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[0411] Step 6:

[0412] Server: Receives the entered skill information and saves it in the user profile.

[0413] Step 7:

[0414] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[0415] python

[0416] for i in range(10):

[0417] print(i)

[0418] Step 8:

[0419] User: After entering the code, click the Run button.

[0420] Step 9:

[0421] Terminal: The entered code and the click event of the Run button are sent to the server.

[0422] Step 10:

[0423] Server: Sends received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[0424] Step 11:

[0425] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0426] Step 12:

[0427] Device: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[0428] Step 13:

[0429] Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it can detect when the user is feeling stressed or confident.

[0430] Step 14:

[0431] Server: Based on the emotional state recognized by the emotion engine, the generative AI further adjusts the improvement suggestions. For example, it provides a user who is feeling stressed with a less difficult suggestion or a detailed explanation.

[0432] Step 15:

[0433] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[0434] python

[0435] Recommended way: More Pythonic way

[0436] for i in range(10):

[0437] print(f"{i}")

[0438] Why: String formatting improves code readability.

[0439] Step 16:

[0440] Terminal: Display suggestions in the user interface.

[0441] Step 17:

[0442] User: Review the suggested improvements and reasons, then fix their code.

[0443] Step 18:

[0444] User: Click the Run button to run the modified code again.

[0445] Step 19:

[0446] Terminal: Send the modified code to the server.

[0447] Step 20:

[0448] Server: Re-analyze the modified code to ensure there are no problems.

[0449] Step 21:

[0450] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[0451] Step 22:

[0452] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[0453] Step 23:

[0454] On your device: Shows the feedback you received and your next learning steps.

[0455] These are the specific steps in the process from when a user enters code to when they receive suggestions for improvement and manage their learning progress. This system allows users to efficiently improve their programming skills while receiving appropriate feedback based on their emotional state.

[0456] Example 2

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

[0458] Conventional programming learning systems provide uniform feedback without fully considering the user's skill level or emotional state, making effective learning difficult. Furthermore, they often lack mechanisms for managing users' progress or providing detailed reasons for code improvements, making it difficult to maintain motivation to learn.

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

[0460] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal, means for saving the user's code change history and improvement suggestion history to manage learning progress, means for recognizing the user's emotions, and means for adjusting feedback based on the recognized emotions. This maximizes the effectiveness of program learning and enables personalized feedback that adapts to the user's individual learning pace and emotional state.

[0461] "User" refers to an individual who uses the system to input program code and aims to improve their skills.

[0462] A "terminal" is a computer or mobile device operated by a user, and is a device for inputting program code and receiving feedback from the system.

[0463] A "server" is a central processing unit that processes requests from users, analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0464] "Generative AI" refers to artificial intelligence that analyzes received program code and generates improvement suggestions, and includes natural language processing (NLP) engines and coding style analysis engines.

[0465] The "emotion engine" is a system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[0466] "Program code" refers to the text of a computer program entered by a user.

[0467] "Improvement suggestions" refer to code optimization and correction suggestions generated by the generative AI after analyzing program code.

[0468] "Skill level" is an evaluation that indicates the user's level of proficiency in programming skills, and is entered in the self-evaluation form when logging in for the first time.

[0469] "Emotional state" refers to the user's current mental state, which is recognized by the emotion engine from facial expressions and voice data.

[0470] "Feedback" refers to improvement suggestions and advice provided to users by the generative AI based on the analyzed program code.

[0471] "Code change history" refers to a record of changes made to program code by the user up to now.

[0472] "Improvement suggestion history" refers to a record of improvement suggestions provided to a user.

[0473] "Study progress" refers to the content and progress a user has achieved in learning programming, and is managed by the server.

[0474] This invention is a system that analyzes program code entered by a user and makes improvement suggestions, and also has the function of recognizing the user's emotions and adjusting the feedback. The basic components of this system are a terminal operated by the user, a server that handles central processing, a generation AI that analyzes the program code and generates improvement suggestions, and an emotion engine that recognizes the user's emotional state.

[0475] Basic System Configuration

[0476] User-side configuration

[0477] 1. User: Operates a device on which programming learning software is installed.

[0478] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[0479] Server-side configuration

[0480] 1. Server: This is the central server that processes requests from users, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0481] 2. Generative AI: Artificial intelligence that analyzes received program code and generates improvement suggestions, including natural language processing (NLP) engines and coding style analysis engines.

[0482] 3. Emotion engine: A system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[0483] Analysis of program code and improvement suggestions

[0484] In this system, the user's device sends the program code they enter into the coding area to the server. The server then passes the received code to the generation AI, which analyzes it and generates improvement suggestions. The generated improvement suggestions are adjusted according to the user's skill level, and the adjusted suggestions and the reasons for the adjustments are sent to the user's device.

[0485] Emotion recognition and feedback regulation

[0486] The device sends the user's facial and voice data to the emotion engine, which analyzes it to recognize the user's emotional state. The server then further adjusts the improvement suggestions based on the user's emotional state. For example, if the user is feeling stressed, the difficulty level may be reduced or detailed explanations may be added.

[0487] Examples and prompts

[0488] If the user enters the following Python code:

[0489] for i in range(10):

[0490] print(i)

[0491] The server uses generative AI to generate improvement suggestions such as the following, which are adjusted according to the user's skill level and emotional state:

[0492] Recommended way: More Pythonic way

[0493] for i in range(10):

[0494] print(f"{i}")

[0495] Why: String formatting improves code readability.

[0496] Also, enter the following prompt for the generated AI:

[0497] Analyze user-supplied code, check if it is optimized, and generate any suggestions for improvement. Here is the input code:

[0498] for i in range(10):

[0499] print(i)

[0500] In this way, the system of the present invention provides a learning environment for users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace.

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

[0502] Step 1:

[0503] The user starts the programming learning software and enters the required authentication information on the login screen.

[0504] Specifically, the user double-clicks the software icon to start it and enters a user name and password.

[0505] Input: Username, Password

[0506] Output: None

[0507] Step 2:

[0508] The user clicks the login button.

[0509] The user clicks the "Login" button and the entered authentication information is sent to the server.

[0510] Input: Login button click event, authentication information

[0511] Output: Authentication request

[0512] Step 3:

[0513] The server receives the authentication information and accesses the user management database to perform authentication.

[0514] The server compares the authentication information it receives with the registration information in the database, and if authentication is successful, obtains the profile information.

[0515] Input: Credentials

[0516] Output: Authentication results, profile information

[0517] Step 4:

[0518] When a user logs in for the first time, he or she enters the skill level into a self-evaluation form and sends it to the server.

[0519] The user enters their skill level in the displayed self-assessment form and clicks the "Submit" button.

[0520] Input: Skill level, Send button click event

[0521] Output: Skill level information

[0522] Step 5:

[0523] The server stores the received skill level information in a user profile.

[0524] The server stores the skill level information in a database and updates the profile information.

[0525] Input: Skill level information

[0526] Output: Updated profile information

[0527] Step 6:

[0528] The user inputs the program code into the coding area of ​​the learning platform.

[0529] The user enters the following code into the coding area:

[0530] for i in range(10):

[0531] print(i)

[0532] Input: Program code

[0533] Output: The code entered

[0534] Step 7:

[0535] The user clicks the "Go" button.

[0536] The user clicks the "Run" button to send the entered code to the server.

[0537] Input: Click event of the Run button, program code

[0538] Output: Code analysis request

[0539] Step 8:

[0540] The server sends the received code to the generation AI.

[0541] The server passes the code to a generative AI model, instructing it to analyze the code and generate improvement suggestions.

[0542] Input: Program code, analysis request

[0543] Output: analysis results, improvement suggestions

[0544] Step 9:

[0545] Generative AI analyzes the code and generates improvement suggestions.

[0546] The generative AI analyzes the structure and content of the code and creates prompts that generate improvement suggestions.

[0547] Input: Program code

[0548] Output: Improvement suggestions

[0549] example:

[0550] Recommended way: More Pythonic way

[0551] for i in range(10):

[0552] print(f"{i}")

[0553] Why: String formatting improves code readability.

[0554] Step 10:

[0555] The server adjusts the generated improvement suggestions according to the user's skill level.

[0556] The server tailors the suggestions to suit the user's skill level, adding detailed explanations for beginners, for example.

[0557] Input: improvement suggestions, skill level information

[0558] Output: Adjusted improvement suggestions

[0559] Step 11:

[0560] The device sends the user's facial expressions and voice data to the emotion engine.

[0561] The camera and microphone connected to the device capture the user's facial expressions and voice and send them to the emotion engine.

[0562] Input: facial expression data, voice data

[0563] Output: Sending emotion data

[0564] Step 12:

[0565] An emotion engine analyzes the user's emotional state.

[0566] The emotion engine uses facial expression and voice analysis algorithms to recognize the user's emotional state.

[0567] Input: facial expression data, voice data

[0568] Output: Emotional state

[0569] Step 13:

[0570] The server adjusts the improvement suggestions based on the emotional state.

[0571] Based on the data from the emotion engine, the server reduces the difficulty of improvement suggestions or adds detailed explanations.

[0572] Input: Emotional state, improvement suggestions

[0573] Output: Finalized improvement proposals

[0574] Step 14:

[0575] The server transmits the adjusted improvement proposal to the user terminal.

[0576] The server sends the finalized proposal and the reasons for it to the user's terminal.

[0577] Input: Finalized improvement proposal

[0578] Output: Submit proposal

[0579] Step 15:

[0580] The terminal displays the suggestion and the reason to the user.

[0581] The device displays the content of the proposal and the reason for it on the screen, allowing the user to intuitively understand the content of the proposal.

[0582] Input: Submit Proposal

[0583] Output:Suggestion display

[0584] Step 16:

[0585] The user modifies the code based on the suggestions.

[0586] The user modifies the code based on the suggestions and clicks the "Run" button again.

[0587] Input: Proposal content, correction code

[0588] Output: Modified code

[0589] Step 17:

[0590] The server re-analyzes the modified code and records and saves the code change history and improvement proposal history.

[0591] The server passes the corrected code back to the generation AI and saves it as history in the database along with the analysis results.

[0592] Input: Correction Code

[0593] Output: Analysis results, saving of change history

[0594] Step 18:

[0595] The server manages the user's learning progress, generates additional feedback and next learning suggestions, and sends them to the device.

[0596] The server suggests the next step based on the data accumulated, and continuously supports the user's learning progress.

[0597] Input: Change history, improvement proposal history

[0598] Output: Next learning suggestions, feedback

[0599] This allows the entire system to effectively support users in learning programming.

[0600] (Application example 2)

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

[0602] While conventional program code improvement systems provide appropriate feedback according to the user's skill level, they do not take into account the user's emotional state, making it difficult to provide effective improvement suggestions when the user is feeling stressed or losing confidence.In addition, because factory robot programming requires high accuracy and efficiency, it is necessary to reduce the stress and fatigue that engineers feel during development and improve productivity.

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

[0604] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for managing the user's learning progress by saving the user's code change history and improvement suggestion history, means for recognizing the user's emotional state and adjusting feedback, and means for analyzing the user's facial expressions and voice using a smart device to acquire the user's emotional state. This makes it possible to provide appropriate feedback according to the user's emotional state, reducing stress and fatigue felt by the user and improving the programming productivity of factory robots.

[0605] "User" means a person who uses the system to input and improve program code.

[0606] "Program code" is a set of instructions that a computer executes to perform a particular operation.

[0607] "Generative AI" is an artificial intelligence technology used to analyze received program code and generate improvement suggestions.

[0608] "Improvement suggestions" are suggestions for improving the quality of the code that the generation AI presents after analyzing the received program code.

[0609] "Skill level" is an index that indicates the degree of a user's programming ability and knowledge.

[0610] The "code change history" is a record of changes made by the user to the program code.

[0611] "Improvement proposal history" is a record of improvement proposals presented to the user by the generation AI.

[0612] "Study progress" indicates the degree of growth and achievement of the user as they progress through their programming studies.

[0613] "Emotional state" refers to a user's current mental or emotional state.

[0614] "Feedback" refers to advice and comments provided by the system regarding the program code entered by the user.

[0615] A "smart device" is an electronic device that has the ability to recognize a user's facial expressions and voice and acquire their emotional state.

[0616] "Facial expression" refers to the emotions and psychological state that are revealed through the user's facial movements and expressions.

[0617] "Voice" refers to the emotions and psychological state that are expressed through the user's voice and speaking style.

[0618] This invention is a system that analyzes a user's program code and makes suggestions for improvements when programming factory robots. This system uses generative AI to analyze program code and make suggestions for improvements, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress. Furthermore, it optimizes the programming environment by recognizing the user's emotional state and adjusting feedback.

[0619] Basic System Configuration

[0620] User-side configuration

[0621] 1. User: Operates the device on which the software is installed.

[0622] 2. Device: A computer or smartphone running programming learning software, equipped with an input interface, display interface, network connectivity, and a camera and microphone for emotion recognition.

[0623] Server-side configuration

[0624] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0625] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[0626] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback. It analyzes data obtained through the camera and microphone.

[0627] Analysis of program code and improvement suggestions

[0628] Initial Setup and Login

[0629] 1. The user launches the programming learning software and enters the required authentication information on the login screen.

[0630] 2. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the server retrieves the user's profile information.

[0631] 3. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is then sent to the server.

[0632] 4. The server stores the received skill level information in the user profile and centrally manages the user's learning progress.

[0633] Code entry and analysis

[0634] 1. The user enters the program code into the coding area of ​​the learning platform.

[0635] 2. The terminal sends the entered code and the event of clicking the run button to the server.

[0636] 3. The server sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[0637] 4. The server tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0638] Emotion recognition and feedback regulation

[0639] 1. The device sends the user's facial expressions and voice to the emotion engine when entering a code or confirming a suggestion.

[0640] 2. The emotion engine analyzes the user's facial expressions, voice, or text input to recognize their emotional state, for example, detecting when they are stressed or confident.

[0641] 3. The server further adjusts the generative AI's improvement suggestions based on the emotional state recognized by the emotion engine. For example, it may provide a user who is feeling stressed with a less difficult suggestion or more detailed explanation.

[0642] View and provide feedback on improvement suggestions

[0643] 1. The server sends the adjusted improvement proposal and the reason for it to the user's device. For example, it will be displayed as follows:

[0644] python

[0645] Recommended way: More Pythonic way

[0646] for i in range(10):

[0647] print(f"{i}")

[0648] Why: String formatting improves code readability.

[0649] 2. The device displays the suggestions and reasons on the user's screen, making it easier for the user to fix the code.

[0650] 3. The user modifies the code based on the suggested improvements and clicks the Run button to run the modified code again.

[0651] Learning progress management

[0652] 1. The server analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[0653] 2. The server manages the user's learning progress and generates additional feedback and next learning suggestions as needed and sends them to the device.

[0654] This allows for efficient analysis of factory robot program code and suggestions for improvement. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Proposals and their rationale are displayed alongside each suggestion, helping users understand why they should do something rather than simply receiving instructions. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[0655] Prompt Sentence Examples

[0656] Analyze the code entered by the user and make suggestions for improvement based on the emotion recognition results.

[0657] User input code:

[0658] {User input code}

[0659] User's emotional state:

[0660] {Emotional state}

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

[0662] Step 1:

[0663] The user starts the programming learning software and enters the required authentication information on the login screen. The entered authentication information is sent from the terminal to the server. The server receives this authentication information, accesses the user management database, and performs authentication. If authentication is successful, the user's profile information is obtained and sent to the terminal. The input here is the authentication information, and the output is the user's profile information.

[0664] Step 2:

[0665] When a user logs in for the first time, they enter their skill level in a self-assessment form, and this information is sent to the server. The server saves the received skill level information in the user profile and uses it as data for centrally managing the user's learning progress. The input here is the user's skill level information, and the output is the saved profile.

[0666] Step 3:

[0667] The user inputs the program code into the coding area of ​​the learning platform, and the input program code is sent to the server by the terminal. Here, the input is the program code, and the output is the sending of the code to the server.

[0668] Step 4:

[0669] The server sends the received program code to a generative AI and related analysis engine for analysis. The generative AI analyzes the received code and generates improvement suggestions. This analysis is performed using a natural language processing (NLP) engine and a coding style analysis engine. The input here is the program code, and the output is improvement suggestions.

[0670] Step 5:

[0671] The server adjusts the generated improvement suggestions according to the user's skill level. It provides simple suggestions to novice users and detailed and advanced suggestions to advanced users. The input here is the improvement suggestions and the user's skill level information, and the output is the adjusted improvement suggestions.

[0672] Step 6:

[0673] The device sends the user's facial expressions and voice to the emotion engine when entering a code or confirming a suggestion. The emotion engine analyzes the user's facial expressions, voice, or text input to recognize the user's emotional state. This recognition is performed using a camera and microphone. The input here is the user's facial expressions and voice data, and the output is their emotional state.

[0674] Step 7:

[0675] The server further adjusts the improvement suggestions made by the generative AI based on the emotional state recognized by the emotion engine. For example, if the user is feeling stressed, the difficulty of the suggestions will be reduced. The input here is the emotional state and improvement suggestions, and the output is further adjusted improvement suggestions.

[0676] Step 8:

[0677] The server sends the adjusted improvement proposals and the reasons for them to the terminal. The terminal displays the proposals and the reasons for them on the user's screen, providing an interface to make it easier for the user to modify the code. The input here is the further adjusted improvement proposals, and the output is the display on the user's screen.

[0678] Step 9:

[0679] The user modifies the code based on the proposed improvements. To run the modified code again, the user clicks the Run button, and the terminal sends the modified code to the server again. The input here is the modified program code, and the output is the code sent to the server.

[0680] Step 10:

[0681] The server analyzes the corrected code again and records and saves the user's code change history and improvement proposal history. Based on the recorded data, it manages the user's learning progress and generates additional feedback and next learning suggestions as needed, which are sent to the device. The input here is the corrected code, and the output is a record of the user's code change history and improvement proposal history.

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

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

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

[0685] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0698] As an embodiment of the present invention, a specific method for analyzing program code and proposing improvements will be described. This system uses generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[0699] Basic System Configuration

[0700] User-side configuration

[0701] 1. User: Operates the device on which the software is installed.

[0702] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connection capabilities.

[0703] Server-side configuration

[0704] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0705] 2. Generative AI: Artificial intelligence for program code analytics, including a natural language processing (NLP) engine and a coding style analysis engine.

[0706] Analysis of program code and improvement suggestions

[0707] Initial Setup and Login

[0708] 1. User: Launch the programming learning software and enter the required authentication information on the login screen.

[0709] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[0710] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[0711] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[0712] Code entry and analysis

[0713] 1. User: Enter the program code into the coding area of ​​the learning platform. For example, enter the following Python code:

[0714] python

[0715] for i in range(10):

[0716] print(i)

[0717] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[0718] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[0719] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0720] View and provide feedback on improvement suggestions

[0721] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[0722] python

[0723] Recommended way: More Pythonic way

[0724] for i in range(10):

[0725] print(f"{i}")

[0726] Why: String formatting improves code readability.

[0727] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[0728] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[0729] Learning progress management

[0730] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[0731] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[0732] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and individual learning progress management allow users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can easily understand why they should do something, rather than just receiving instructions.

[0733] The processing flow will be explained below.

[0734] Step 1:

[0735] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[0736] Step 2:

[0737] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[0738] Step 3:

[0739] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[0740] Step 4:

[0741] Terminal: Displays a form and allows users to enter their self-assessment.

[0742] Step 5:

[0743] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[0744] Step 6:

[0745] Server: Receives the entered skill information and saves it in the user profile.

[0746] Step 7:

[0747] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[0748] python

[0749] for i in range(10):

[0750] print(i)

[0751] Step 8:

[0752] User: After entering the code, click the Run button.

[0753] Step 9:

[0754] Terminal: The entered code and the click event of the Run button are sent to the server.

[0755] Step 10:

[0756] Server: Sends the received code to the Generator AI and associated analysis engine, which analyzes the code and generates improvement suggestions.

[0757] Step 11:

[0758] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0759] Step 12:

[0760] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device.

[0761] Step 13:

[0762] Device: Display the suggestion in the user interface, for example:

[0763] python

[0764] Recommended way: More Pythonic way

[0765] for i in range(10):

[0766] print(f"{i}")

[0767] Why: String formatting improves code readability.

[0768] Step 14:

[0769] User: Review the suggested improvements and reasons, then fix their code.

[0770] Step 15:

[0771] User: Click the Run button to run the modified code again.

[0772] Step 16:

[0773] Terminal: Send the modified code to the server.

[0774] Step 17:

[0775] Server: Re-analyze the modified code to ensure there are no problems.

[0776] Step 18:

[0777] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[0778] Step 19:

[0779] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[0780] Step 20:

[0781] On your device: Shows the feedback you received and your next learning steps.

[0782] These are the specific processing steps from when the user enters the code to when they receive improvement suggestions and manage their learning progress.

[0783] Example 1

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

[0785] Conventional programming learning systems have the problem that they only provide uniform feedback to users and do not offer appropriate improvement suggestions based on individual skill levels or learning progress. This means that users do not receive feedback tailored to their own skill level, making it difficult to progress effectively. Furthermore, they lack the functionality to record code change history and improvement suggestion history and centrally manage learning progress, making it difficult to track continuous learning effects.

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

[0787] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for managing learning progress by saving the user's code change history and improvement suggestion history; means for analyzing and evaluating the readability, efficiency, and safety of the code based on prompts to the generation AI model; and means for reanalyzing the corrected program code and generating further improvement suggestions. This enables appropriate feedback according to the user's skill level and centralized management of learning progress.

[0788] "Program code" refers to the set of instructions written by a user to create software or an application.

[0789] "Generative AI" is artificial intelligence that uses natural language processing and coding style analysis engines to analyze input program code and generate improvement suggestions.

[0790] "User skill level" is an index showing the user's programming skill level, and is information obtained based on a self-evaluation form when logging in for the first time.

[0791] A "profile" is a database entry that stores information related to a user, including information such as skill level and learning progress.

[0792] "Improvement suggestions" are guidelines and advice obtained by the generative AI when it analyzes program code, and are intended to improve the readability, efficiency, and safety of the code.

[0793] "Code change history" refers to data that records the history of modifications to program code entered by the user.

[0794] "Improvement proposal history" refers to data that records the history of improvement proposals provided to the user by the generation AI.

[0795] "Study progress management" is a function that centrally monitors and records the user's learning status and provides feedback and learning suggestions as needed.

[0796] A "prompt sentence to a generative AI model" is an input command given to the generative AI for analysis and evaluation.

[0797] "Natural language processing" is a technology that uses computers to process human language, and is used in this system to understand and analyze program code.

[0798] "Reanalysis" refers to the process of reanalyzing modified or changed program code in order to generate further improvement suggestions.

[0799] This system uses a generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[0800] Basic System Configuration

[0801] User-side configuration

[0802] User: Operates the device on which the software is installed.

[0803] Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connectivity.

[0804] Server-side configuration

[0805] Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and monitors learning progress.

[0806] Generative AI: Artificial intelligence for analyzing program code, including natural language processing (NLP) engines and coding style analysis engines.

[0807] Analysis of program code and improvement suggestions

[0808] Initial Setup and Login

[0809] The user starts the programming learning software and enters the required authentication information on the login screen. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the user's profile information is obtained. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is sent to the server. The server saves the received skill level information in the user profile and centrally manages the user's learning progress.

[0810] Code entry and analysis

[0811] Users enter program code into the coding area of ​​the learning platform, for example, the following Python code:

[0812] for i in range(10):

[0813] print(i)

[0814] The device sends the entered code and the event of clicking the run button to the server. The server then sends the received code to the generation AI and related analysis engine for analysis. The generation AI analyzes the code and generates improvement suggestions. The server adjusts the generated improvement suggestions according to the user's skill level. For example, it provides simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0815] View and provide feedback on improvement suggestions

[0816] The server will send the adjusted improvement suggestions and the reasons for them to the user's device, for example, as shown below:

[0817] Recommended way: More Pythonic way

[0818] for i in range(10):

[0819] print(f"{i}")

[0820] Why: String formatting improves code readability.

[0821] The device displays suggestions and reasons for the suggestions on the user's screen, making it easier for the user to correct the code. The user corrects the code based on the suggested improvements, and then clicks the Run button to run the corrected code again.

[0822] Learning progress management

[0823] The server then analyzes the modified code again, records and saves the user's code change history and improvement suggestion history, and manages the user's learning progress, generating additional feedback and next learning suggestions as needed and sending them to the device.

[0824] Prompt Sentence Examples

[0825] Entered code example

[0826] for i in range(5):

[0827] print(i)

[0828] Example prompts for generative AI models

[0829] Analyze the following Python code and offer suggestions to improve its readability and efficiency:

[0830] for i in range(5):

[0831] print(i)

[0832] The user's skill level is intermediate.

[0833] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. This allows real-time feedback and individual learning progress management, allowing users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can more easily understand why they should do something, rather than just receiving instructions.

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

[0835] Step 1:

[0836] Initial Setup and Login

[0837] User: Starts the programming learning software and enters the required authentication information (e.g., username and password) on the login screen.

[0838] Input: Username, Password

[0839] Output: Credentials

[0840] Server: Receives the authentication information, queries the user management database, and performs authentication. If the user is successfully authenticated, obtains the user's profile information (e.g., skill level) and sends it to the device.

[0841] Input: Credentials

[0842] Output: Profile information

[0843] Users: When they log in for the first time, they enter their skill level through a self-assessment form and submit it.

[0844] Input: Skill level information

[0845] Output: Self-assessment information

[0846] Server: The received skill level information is saved in the user profile and used to manage learning progress.

[0847] Input: Self-assessment information

[0848] Output: Updated profile

[0849] Step 2:

[0850] Code entry and analysis

[0851] User: Enter the program code in the coding area. For example, enter the following Python code:

[0852] python

[0853] for i in range(10):

[0854] print(i)

[0855] Input: Program code

[0856] Output: None

[0857] Terminal: Captures the entered code and the click event of the Run button and sends it to the server.

[0858] Input: Program code, Run button click event

[0859] Output: Data sent to the server

[0860] Server: Sends the received code to the Generator AI and associated analysis engine for analysis.

[0861] Input: Program code

[0862] Output: Prompt for the generation AI

[0863] Generative AI: Analyzes program code and generates improvement suggestions.

[0864] Input: prompt statement

[0865] Output: Improvement suggestions

[0866] Step 3:

[0867] Generate and refine improvement proposals

[0868] Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[0869] Input: improvement suggestions, user skill level

[0870] Output: Adjusted improvement suggestions

[0871] Step 4:

[0872] View and provide feedback on improvement suggestions

[0873] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[0874] python

[0875] Recommended way: More Pythonic way

[0876] for i in range(10):

[0877] print(f"{i}")

[0878] Why: String formatting improves code readability.

[0879] Input: Adjusted improvement proposal

[0880] Output: Data for display

[0881] Terminal: Suggestions and their reasons are displayed on the screen, helping the user to fix their code.

[0882] Input: Data to display

[0883] Output: Feedback to the user

[0884] User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[0885] Input: Improvement suggestion, user modified code

[0886] Output: Corrected code

[0887] Step 5:

[0888] Learning progress management

[0889] Server: Analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[0890] Input: Correction Code

[0891] Output: Code change history, improvement proposal history

[0892] Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[0893] Input: Code change history, improvement proposal history

[0894] Output: Additional feedback, next learning suggestions

[0895] In this way, the system provides a learning environment for users to efficiently improve their programming skills. In addition, by providing suggestions and reasons for them, users can improve their learning effectiveness.

[0896] (Application example 1)

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

[0898] Conventional optimization of control programs for factory automation equipment requires specialized knowledge and a great deal of effort, and is heavily dependent on the skills and experience of the engineer. Furthermore, appropriate improvement proposals are not provided promptly, and malfunctions and performance degradation are likely to occur. This makes it difficult to improve the efficiency of factory operations.

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

[0900] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for saving the user's code change history and improvement suggestion history to manage learning progress; means for receiving a control program entered by a user and making suggestions related to the operation of factory automation equipment; means for generating improvement suggestions for improving performance or preventing malfunctions based on the received control program; and means for optimizing the generated improvement suggestions for the operation of the equipment. This enables the optimization of the control program for factory automation equipment and improvement suggestions to be performed quickly and accurately without relying on the skill of an engineer, thereby improving the efficiency of factory operations.

[0901] A "user" is someone who uses the system to input program code and receive improvement suggestions.

[0902] "Program code" is a series of instructions that a user inputs into a system to control factory automation equipment and the like.

[0903] "Generative AI" refers to artificial intelligence technology that analyzes received program code and generates improvement suggestions.

[0904] "Skill level" indicates the user's programming ability and affects the complexity and detail of the suggestions generated by the system.

[0905] "Terminal" refers to a computer or mobile device used by a user that has the function of displaying generated improvement suggestions, etc.

[0906] "Code change history" means the record of modifications and changes made by the user to the program code.

[0907] The "improvement proposal history" is a record of improvement proposals for program code generated by the system.

[0908] "Learning progress" is an indicator that shows how much a user has improved their programming skills by using the system.

[0909] "Factory automation equipment" refers to machines that perform factory work automatically and operate based on control programs.

[0910] "Improvement proposal" refers to the specific content of the improvement proposal for the program code generated by the generation AI.

[0911] "Magic prevention" refers to measures taken to prevent factory automation equipment from operating in an unintended manner.

[0912] This invention relates to a control program optimization system for factory automation equipment, which receives program code entered by a user, analyzes it using a generation AI, generates improvement proposals, and adjusts them according to the user's skill level. Below, we will explain how this system is specifically implemented.

[0913] 1. System Configuration

[0914] User-side configuration

[0915] 1. User: An engineer who operates a terminal on which programming learning software is installed. He / she inputs control programs and receives suggestions for improvements.

[0916] 2. Terminal: A computer or mobile device used by a user that has an input interface, a display interface, and network connection capabilities.

[0917] Server-side configuration

[0918] 1. Server: This is the central processing unit that processes requests from users. It receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[0919] 2. Generative AI: Uses artificial intelligence techniques to analyze program code, including natural language processing (NLP) engines and coding style analysis engines.

[0920] 2. Program processing explanation

[0921] Entering and receiving program code

[0922] The user enters the control program for the factory automation device into the code input area of ​​the terminal. For example, the user enters the following Python code:

[0923] for i in range(10):

[0924] send_command("move", i)

[0925] The terminal sends the entered program code to the server, which receives it and proceeds to the next stage of analysis.

[0926] Code analysis and generation of improvement suggestions

[0927] The server sends the received program code to the generation AI, which analyzes it by inputting the following prompt sentence into the generation AI model:

[0928] Analyze the following code and provide enhancement suggestions for a beginner level user:

[0929] for i in range(10):

[0930] send_command("move", i)

[0931] Based on the code analyzed by the generative AI model, improvement suggestions are generated, such as:

[0932] Recommended improvement: Add a short delay between commands to safely control the robot.

[0933] import time

[0934] for i in range(10):

[0935] send_command("move", i)

[0936] time.sleep(0.1) Add a delay of 0.1 seconds

[0937] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[0938] Adjust and display improvement suggestions

[0939] The generated improvement suggestions are tailored to the user's skill level: beginners receive easy-to-understand suggestions, while advanced users receive more specific and sophisticated suggestions.

[0940] These adjustment suggestions and their reasons are then sent to the terminal and displayed on the user's screen. The user can then modify the control program based on the displayed suggestions and their reasons.

[0941] Save history and manage learning progress

[0942] The server stores the history of code changes made by the user and the history of improvement suggestions provided by the generation AI. This history data is used to manage the user's learning progress and to make the next improvement suggestions.

[0943] 3. Adding concrete examples

[0944] If a technician enters the following robot control program:

[0945] for i in range(5):

[0946] move_arm("up", i)

[0947] After analysis, the generative AI provides specific improvement suggestions for beginners:

[0948] Recommended improvement: Add a check to ensure safe arm movement.

[0949] if arm_position < max_limit:

[0950] for i in range(5):

[0951] move_arm("up", i)

[0952] Reason: This prevents the robotic arm from exceeding its maximum safe position.

[0953] In this manner, the system of the present invention provides an environment for users to safely and efficiently optimize control programs for factory automation equipment.

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

[0955] Step 1:

[0956] User: Entering program code

[0957] The user enters the control program for the factory automation device into the code input area of ​​the terminal. An example input is the following Python code:

[0958] for i in range(10):

[0959] send_command("move", i)

[0960] Input: Control program code entered by the user into the terminal.

[0961] Output: Entered program code in the terminal

[0962] Step 2:

[0963] Terminal: Sending program code

[0964] The terminal sends the program code entered by the user to the server, which analyzes the code.

[0965] Input: Program code entered into the terminal

[0966] Output: The program code sent to the server

[0967] Step 3:

[0968] Server: Receives program code

[0969] The server receives the program code sent from the terminal and proceeds to the next stage of analysis.

[0970] Input: Program code sent from the terminal

[0971] Output: The program code received by the server

[0972] Step 4:

[0973] Server: Generates prompts for the AI

[0974] The server generates a prompt sentence to be input to the generative AI model based on the received program code. An example of a prompt sentence is as follows:

[0975] Analyze the following code and provide enhancement suggestions for a beginner level user:

[0976] for i in range(10):

[0977] send_command("move", i)

[0978] Input: Program code received by the server

[0979] Output: A prompt to be fed to the generative AI model

[0980] Step 5:

[0981] Generative AI: Analyzing program code and generating improvement proposals

[0982] The generative AI model analyzes the program code based on the prompt and generates improvement suggestions, which are formatted as follows:

[0983] Recommended improvement: Add a short delay between commands to safely control the robot.

[0984] import time

[0985] for i in range(10):

[0986] send_command("move", i)

[0987] time.sleep(0.1) Add a delay of 0.1 seconds

[0988] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[0989] Input: A prompt sent to the generative AI model

[0990] Output: Improvement suggestions generated by the generative AI model

[0991] Step 6:

[0992] Server: Adjustment of improvement proposals

[0993] The server adjusts the improvement suggestions generated by the generative AI model according to the user's skill level: beginners are provided with easy-to-understand suggestions, while advanced users are provided with more advanced suggestions.

[0994] Input: Improvement suggestions generated by the generative AI model, user skill level

[0995] Output: Skill-level-adjusted improvement suggestions

[0996] Step 7:

[0997] Server: Submit improvement suggestions

[0998] The server then sends the adjusted improvement proposals and the reasons for the proposals to the user's terminal, who then modifies the control program based on these proposals.

[0999] Input: Skill-level-adjusted improvement suggestions

[1000] Output: Improvement suggestions sent to the device

[1001] Step 8:

[1002] Device: Show improvement suggestions

[1003] The terminal displays the improvement proposal received from the server and the reason for it on the user's screen.

[1004] Input: Improvement suggestions sent by the server

[1005] Output: Improvement suggestions displayed on the user's screen

[1006] Step 9:

[1007] User: Modifying the program code

[1008] The user modifies the control program based on the improvement suggestions displayed on the terminal, and the modified program is then analyzed again.

[1009] Input: Improvement suggestions displayed on the device

[1010] Output: Modified program code

[1011] Step 10:

[1012] Server: Save history and manage learning progress

[1013] The server stores the history of the program code modified by the user and the improvement suggestions provided by the generation AI, allowing for efficient management of the user's learning progress.

[1014] Input: Modified program code, improvement suggestions provided by the generative AI

[1015] Output: A saved history of code changes and improvement suggestions

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

[1017] As an embodiment of the present invention, we will explain a specific method that combines a system that analyzes a user's program code and makes improvement suggestions with an emotion engine that recognizes the user's emotions. This system analyzes program code and makes improvement suggestions using generative AI, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress.

[1018] Basic System Configuration

[1019] User-side configuration

[1020] 1. User: Operates the device on which the software is installed.

[1021] 2. Terminal: A computer or mobile device running programming learning software, equipped with an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[1022] Server-side configuration

[1023] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1024] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[1025] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback.

[1026] Analysis of program code and improvement suggestions

[1027] Initial Setup and Login

[1028] 1. User: Launch the programming learning software, enter the required authentication information on the login screen, and click the login button.

[1029] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[1030] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[1031] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[1032] Code entry and analysis

[1033] 1. User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[1034] python

[1035] for i in range(10):

[1036] print(i)

[1037] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[1038] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1039] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1040] Emotion recognition and feedback regulation

[1041] 1. Terminal: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[1042] 2. Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it detects when the user is feeling stressed or confident.

[1043] 3. Server: Based on the emotional state recognized by the emotion engine, the production AI further adjusts its improvement suggestions. For example, it may provide a user who is feeling stressed with a less difficult suggestion or a more detailed explanation.

[1044] View and provide feedback on improvement suggestions

[1045] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[1046] python

[1047] Recommended way: More Pythonic way

[1048] for i in range(10):

[1049] print(f"{i}")

[1050] Why: String formatting improves code readability.

[1051] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[1052] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[1053] Learning progress management

[1054] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[1055] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[1056] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Furthermore, by providing suggestions and reasons alongside them, users can more easily understand why they should do something, rather than just being told what to do. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[1057] The processing flow will be explained below.

[1058] Step 1:

[1059] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[1060] Step 2:

[1061] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[1062] Step 3:

[1063] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[1064] Step 4:

[1065] Terminal: Displays a form and allows users to enter their self-assessment.

[1066] Step 5:

[1067] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[1068] Step 6:

[1069] Server: Receives the entered skill information and saves it in the user profile.

[1070] Step 7:

[1071] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[1072] python

[1073] for i in range(10):

[1074] print(i)

[1075] Step 8:

[1076] User: After entering the code, click the Run button.

[1077] Step 9:

[1078] Terminal: The entered code and the click event of the Run button are sent to the server.

[1079] Step 10:

[1080] Server: Sends received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1081] Step 11:

[1082] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1083] Step 12:

[1084] Device: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[1085] Step 13:

[1086] Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it can detect when the user is feeling stressed or confident.

[1087] Step 14:

[1088] Server: Based on the emotional state recognized by the emotion engine, the generative AI further adjusts the improvement suggestions. For example, it provides a user who is feeling stressed with a less difficult suggestion or a detailed explanation.

[1089] Step 15:

[1090] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[1091] python

[1092] Recommended way: More Pythonic way

[1093] for i in range(10):

[1094] print(f"{i}")

[1095] Why: String formatting improves code readability.

[1096] Step 16:

[1097] Terminal: Display suggestions in the user interface.

[1098] Step 17:

[1099] User: Review the suggested improvements and reasons, then fix their code.

[1100] Step 18:

[1101] User: Click the Run button to run the modified code again.

[1102] Step 19:

[1103] Terminal: Send the modified code to the server.

[1104] Step 20:

[1105] Server: Re-analyze the modified code to ensure there are no problems.

[1106] Step 21:

[1107] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[1108] Step 22:

[1109] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[1110] Step 23:

[1111] On your device: Shows the feedback you received and your next learning steps.

[1112] These are the specific steps in the process from when a user enters code to when they receive suggestions for improvement and manage their learning progress. This system allows users to efficiently improve their programming skills while receiving appropriate feedback based on their emotional state.

[1113] Example 2

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

[1115] Conventional programming learning systems provide uniform feedback without fully considering the user's skill level or emotional state, making effective learning difficult. Furthermore, they often lack mechanisms for managing users' progress or providing detailed reasons for code improvements, making it difficult to maintain motivation to learn.

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

[1117] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal, means for saving the user's code change history and improvement suggestion history to manage learning progress, means for recognizing the user's emotions, and means for adjusting feedback based on the recognized emotions. This maximizes the effectiveness of program learning and enables personalized feedback that adapts to the user's individual learning pace and emotional state.

[1118] "User" refers to an individual who uses the system to input program code and aims to improve their skills.

[1119] A "terminal" is a computer or mobile device operated by a user, and is a device for inputting program code and receiving feedback from the system.

[1120] A "server" is a central processing unit that processes requests from users, analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1121] "Generative AI" refers to artificial intelligence that analyzes received program code and generates improvement suggestions, and includes natural language processing (NLP) engines and coding style analysis engines.

[1122] The "emotion engine" is a system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[1123] "Program code" refers to the text of a computer program entered by a user.

[1124] "Improvement suggestions" refer to code optimization and correction suggestions generated by the generative AI after analyzing program code.

[1125] "Skill level" is an evaluation that indicates the user's level of proficiency in programming skills, and is entered in the self-evaluation form when logging in for the first time.

[1126] "Emotional state" refers to the user's current mental state, which is recognized by the emotion engine from facial expressions and voice data.

[1127] "Feedback" refers to improvement suggestions and advice provided to users by the generative AI based on the analyzed program code.

[1128] "Code change history" refers to a record of changes made to program code by the user up to now.

[1129] "Improvement suggestion history" refers to a record of improvement suggestions provided to a user.

[1130] "Study progress" refers to the content and progress a user has achieved in learning programming, and is managed by the server.

[1131] This invention is a system that analyzes program code entered by a user and makes improvement suggestions, and also has the function of recognizing the user's emotions and adjusting the feedback. The basic components of this system are a terminal operated by the user, a server that handles central processing, a generation AI that analyzes the program code and generates improvement suggestions, and an emotion engine that recognizes the user's emotional state.

[1132] Basic System Configuration

[1133] User-side configuration

[1134] 1. User: Operates a device on which programming learning software is installed.

[1135] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[1136] Server-side configuration

[1137] 1. Server: This is the central server that processes requests from users, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1138] 2. Generative AI: Artificial intelligence that analyzes received program code and generates improvement suggestions, including natural language processing (NLP) engines and coding style analysis engines.

[1139] 3. Emotion engine: A system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[1140] Analysis of program code and improvement suggestions

[1141] In this system, the user's device sends the program code they enter into the coding area to the server. The server then passes the received code to the generation AI, which analyzes it and generates improvement suggestions. The generated improvement suggestions are adjusted according to the user's skill level, and the adjusted suggestions and the reasons for the adjustments are sent to the user's device.

[1142] Emotion recognition and feedback regulation

[1143] The device sends the user's facial and voice data to the emotion engine, which analyzes it to recognize the user's emotional state. The server then further adjusts the improvement suggestions based on the user's emotional state. For example, if the user is feeling stressed, the difficulty level may be reduced or detailed explanations may be added.

[1144] Examples and prompts

[1145] If the user enters the following Python code:

[1146] for i in range(10):

[1147] print(i)

[1148] The server uses generative AI to generate improvement suggestions such as the following, which are adjusted according to the user's skill level and emotional state:

[1149] Recommended way: More Pythonic way

[1150] for i in range(10):

[1151] print(f"{i}")

[1152] Why: String formatting improves code readability.

[1153] Also, enter the following prompt for the generated AI:

[1154] Analyze user-supplied code, check if it is optimized, and generate any suggestions for improvement. Here is the input code:

[1155] for i in range(10):

[1156] print(i)

[1157] In this way, the system of the present invention provides a learning environment for users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace.

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

[1159] Step 1:

[1160] The user starts the programming learning software and enters the required authentication information on the login screen.

[1161] Specifically, the user double-clicks the software icon to start it and enters a user name and password.

[1162] Input: Username, Password

[1163] Output: None

[1164] Step 2:

[1165] The user clicks the login button.

[1166] The user clicks the "Login" button and the entered authentication information is sent to the server.

[1167] Input: Login button click event, authentication information

[1168] Output: Authentication request

[1169] Step 3:

[1170] The server receives the authentication information and accesses the user management database to perform authentication.

[1171] The server compares the authentication information it receives with the registration information in the database, and if authentication is successful, obtains the profile information.

[1172] Input: Credentials

[1173] Output: Authentication results, profile information

[1174] Step 4:

[1175] When a user logs in for the first time, he or she enters the skill level into a self-evaluation form and sends it to the server.

[1176] The user enters their skill level in the displayed self-assessment form and clicks the "Submit" button.

[1177] Input: Skill level, Send button click event

[1178] Output: Skill level information

[1179] Step 5:

[1180] The server stores the received skill level information in a user profile.

[1181] The server stores the skill level information in a database and updates the profile information.

[1182] Input: Skill level information

[1183] Output: Updated profile information

[1184] Step 6:

[1185] The user inputs the program code into the coding area of ​​the learning platform.

[1186] The user enters the following code into the coding area:

[1187] for i in range(10):

[1188] print(i)

[1189] Input: Program code

[1190] Output: The code entered

[1191] Step 7:

[1192] The user clicks the "Go" button.

[1193] The user clicks the "Run" button to send the entered code to the server.

[1194] Input: Click event of the Run button, program code

[1195] Output: Code analysis request

[1196] Step 8:

[1197] The server sends the received code to the generation AI.

[1198] The server passes the code to a generative AI model, instructing it to analyze the code and generate improvement suggestions.

[1199] Input: Program code, analysis request

[1200] Output: analysis results, improvement suggestions

[1201] Step 9:

[1202] Generative AI analyzes the code and generates improvement suggestions.

[1203] The generative AI analyzes the structure and content of the code and creates prompts that generate improvement suggestions.

[1204] Input: Program code

[1205] Output: Improvement suggestions

[1206] example:

[1207] Recommended way: More Pythonic way

[1208] for i in range(10):

[1209] print(f"{i}")

[1210] Why: String formatting improves code readability.

[1211] Step 10:

[1212] The server adjusts the generated improvement suggestions according to the user's skill level.

[1213] The server tailors the suggestions to suit the user's skill level, adding detailed explanations for beginners, for example.

[1214] Input: improvement suggestions, skill level information

[1215] Output: Adjusted improvement suggestions

[1216] Step 11:

[1217] The device sends the user's facial expressions and voice data to the emotion engine.

[1218] The camera and microphone connected to the device capture the user's facial expressions and voice and send them to the emotion engine.

[1219] Input: facial expression data, voice data

[1220] Output: Sending emotion data

[1221] Step 12:

[1222] An emotion engine analyzes the user's emotional state.

[1223] The emotion engine uses facial expression and voice analysis algorithms to recognize the user's emotional state.

[1224] Input: facial expression data, voice data

[1225] Output: Emotional state

[1226] Step 13:

[1227] The server adjusts the improvement suggestions based on the emotional state.

[1228] Based on the data from the emotion engine, the server reduces the difficulty of improvement suggestions or adds detailed explanations.

[1229] Input: Emotional state, improvement suggestions

[1230] Output: Finalized improvement proposals

[1231] Step 14:

[1232] The server transmits the adjusted improvement proposal to the user terminal.

[1233] The server sends the finalized proposal and the reasons for it to the user's terminal.

[1234] Input: Finalized improvement proposal

[1235] Output: Submit proposal

[1236] Step 15:

[1237] The terminal displays the suggestion and the reason to the user.

[1238] The device displays the content of the proposal and the reason for it on the screen, allowing the user to intuitively understand the content of the proposal.

[1239] Input: Submit Proposal

[1240] Output:Suggestion display

[1241] Step 16:

[1242] The user modifies the code based on the suggestions.

[1243] The user modifies the code based on the suggestions and clicks the "Run" button again.

[1244] Input: Proposal content, correction code

[1245] Output: Modified code

[1246] Step 17:

[1247] The server re-analyzes the modified code and records and saves the code change history and improvement proposal history.

[1248] The server passes the corrected code back to the generation AI and saves it as history in the database along with the analysis results.

[1249] Input: Correction Code

[1250] Output: Analysis results, saving of change history

[1251] Step 18:

[1252] The server manages the user's learning progress, generates additional feedback and next learning suggestions, and sends them to the device.

[1253] The server suggests the next step based on the data accumulated, and continuously supports the user's learning progress.

[1254] Input: Change history, improvement proposal history

[1255] Output: Next learning suggestions, feedback

[1256] This allows the entire system to effectively support users in learning programming.

[1257] (Application example 2)

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

[1259] While conventional program code improvement systems provide appropriate feedback according to the user's skill level, they do not take into account the user's emotional state, making it difficult to provide effective improvement suggestions when the user is feeling stressed or losing confidence.In addition, because factory robot programming requires high accuracy and efficiency, it is necessary to reduce the stress and fatigue that engineers feel during development and improve productivity.

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

[1261] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for managing the user's learning progress by saving the user's code change history and improvement suggestion history, means for recognizing the user's emotional state and adjusting feedback, and means for analyzing the user's facial expressions and voice using a smart device to acquire the user's emotional state. This makes it possible to provide appropriate feedback according to the user's emotional state, reducing stress and fatigue felt by the user and improving the programming productivity of factory robots.

[1262] "User" means a person who uses the system to input and improve program code.

[1263] "Program code" is a set of instructions that a computer executes to perform a particular operation.

[1264] "Generative AI" is an artificial intelligence technology used to analyze received program code and generate improvement suggestions.

[1265] "Improvement suggestions" are suggestions for improving the quality of the code that the generation AI presents after analyzing the received program code.

[1266] "Skill level" is an index that indicates the degree of a user's programming ability and knowledge.

[1267] The "code change history" is a record of changes made by the user to the program code.

[1268] "Improvement proposal history" is a record of improvement proposals presented to the user by the generation AI.

[1269] "Study progress" indicates the degree of growth and achievement of the user as they progress through their programming studies.

[1270] "Emotional state" refers to a user's current mental or emotional state.

[1271] "Feedback" refers to advice and comments provided by the system regarding the program code entered by the user.

[1272] A "smart device" is an electronic device that has the ability to recognize a user's facial expressions and voice and acquire their emotional state.

[1273] "Facial expression" refers to the emotions and psychological state that are revealed through the user's facial movements and expressions.

[1274] "Voice" refers to the emotions and psychological state that are expressed through the user's voice and speaking style.

[1275] This invention is a system that analyzes a user's program code and makes suggestions for improvements when programming factory robots. This system uses generative AI to analyze program code and make suggestions for improvements, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress. Furthermore, it optimizes the programming environment by recognizing the user's emotional state and adjusting feedback.

[1276] Basic System Configuration

[1277] User-side configuration

[1278] 1. User: Operates the device on which the software is installed.

[1279] 2. Device: A computer or smartphone running programming learning software, equipped with an input interface, display interface, network connectivity, and a camera and microphone for emotion recognition.

[1280] Server-side configuration

[1281] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1282] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[1283] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback. It analyzes data obtained through the camera and microphone.

[1284] Analysis of program code and improvement suggestions

[1285] Initial Setup and Login

[1286] 1. The user launches the programming learning software and enters the required authentication information on the login screen.

[1287] 2. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the server retrieves the user's profile information.

[1288] 3. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is then sent to the server.

[1289] 4. The server stores the received skill level information in the user profile and centrally manages the user's learning progress.

[1290] Code entry and analysis

[1291] 1. The user enters the program code into the coding area of ​​the learning platform.

[1292] 2. The terminal sends the entered code and the event of clicking the run button to the server.

[1293] 3. The server sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1294] 4. The server tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1295] Emotion recognition and feedback regulation

[1296] 1. The device sends the user's facial expressions and voice to the emotion engine when entering a code or confirming a suggestion.

[1297] 2. The emotion engine analyzes the user's facial expressions, voice, or text input to recognize their emotional state, for example, detecting when they are stressed or confident.

[1298] 3. The server further adjusts the generative AI's improvement suggestions based on the emotional state recognized by the emotion engine. For example, it may provide a user who is feeling stressed with a less difficult suggestion or more detailed explanation.

[1299] View and provide feedback on improvement suggestions

[1300] 1. The server sends the adjusted improvement proposal and the reason for it to the user's device. For example, it will be displayed as follows:

[1301] python

[1302] Recommended way: More Pythonic way

[1303] for i in range(10):

[1304] print(f"{i}")

[1305] Why: String formatting improves code readability.

[1306] 2. The device displays the suggestions and reasons on the user's screen, making it easier for the user to fix the code.

[1307] 3. The user modifies the code based on the suggested improvements and clicks the Run button to run the modified code again.

[1308] Learning progress management

[1309] 1. The server analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[1310] 2. The server manages the user's learning progress and generates additional feedback and next learning suggestions as needed and sends them to the device.

[1311] This allows for efficient analysis of factory robot program code and suggestions for improvement. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Proposals and their rationale are displayed alongside each suggestion, helping users understand why they should do something rather than simply receiving instructions. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[1312] Prompt Sentence Examples

[1313] Analyze the code entered by the user and make suggestions for improvement based on the emotion recognition results.

[1314] User input code:

[1315] {User input code}

[1316] User's emotional state:

[1317] {Emotional state}

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

[1319] Step 1:

[1320] The user starts the programming learning software and enters the required authentication information on the login screen. The entered authentication information is sent from the terminal to the server. The server receives this authentication information, accesses the user management database, and performs authentication. If authentication is successful, the user's profile information is obtained and sent to the terminal. The input here is the authentication information, and the output is the user's profile information.

[1321] Step 2:

[1322] When a user logs in for the first time, they enter their skill level in a self-assessment form, and this information is sent to the server. The server saves the received skill level information in the user profile and uses it as data for centrally managing the user's learning progress. The input here is the user's skill level information, and the output is the saved profile.

[1323] Step 3:

[1324] The user inputs the program code into the coding area of ​​the learning platform, and the input program code is sent to the server by the terminal. Here, the input is the program code, and the output is the sending of the code to the server.

[1325] Step 4:

[1326] The server sends the received program code to a generative AI and related analysis engine for analysis. The generative AI analyzes the received code and generates improvement suggestions. This analysis is performed using a natural language processing (NLP) engine and a coding style analysis engine. The input here is the program code, and the output is improvement suggestions.

[1327] Step 5:

[1328] The server adjusts the generated improvement suggestions according to the user's skill level. It provides simple suggestions to novice users and detailed and advanced suggestions to advanced users. The input here is the improvement suggestions and the user's skill level information, and the output is the adjusted improvement suggestions.

[1329] Step 6:

[1330] The device sends the user's facial expressions and voice to the emotion engine when entering a code or confirming a suggestion. The emotion engine analyzes the user's facial expressions, voice, or text input to recognize the user's emotional state. This recognition is performed using a camera and microphone. The input here is the user's facial expressions and voice data, and the output is their emotional state.

[1331] Step 7:

[1332] The server further adjusts the improvement suggestions made by the generative AI based on the emotional state recognized by the emotion engine. For example, if the user is feeling stressed, the difficulty of the suggestions will be reduced. The input here is the emotional state and improvement suggestions, and the output is further adjusted improvement suggestions.

[1333] Step 8:

[1334] The server sends the adjusted improvement proposals and the reasons for them to the terminal. The terminal displays the proposals and the reasons for them on the user's screen, providing an interface to make it easier for the user to modify the code. The input here is the further adjusted improvement proposals, and the output is the display on the user's screen.

[1335] Step 9:

[1336] The user modifies the code based on the proposed improvements. To run the modified code again, the user clicks the Run button, and the terminal sends the modified code to the server again. The input here is the modified program code, and the output is the code sent to the server.

[1337] Step 10:

[1338] The server analyzes the corrected code again and records and saves the user's code change history and improvement proposal history. Based on the recorded data, it manages the user's learning progress and generates additional feedback and next learning suggestions as needed, which are sent to the device. The input here is the corrected code, and the output is a record of the user's code change history and improvement proposal history.

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

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

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

[1342] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1355] As an embodiment of the present invention, a specific method for analyzing program code and proposing improvements will be described. This system uses generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[1356] Basic System Configuration

[1357] User-side configuration

[1358] 1. User: Operates the device on which the software is installed.

[1359] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connection capabilities.

[1360] Server-side configuration

[1361] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1362] 2. Generative AI: Artificial intelligence for program code analytics, including a natural language processing (NLP) engine and a coding style analysis engine.

[1363] Analysis of program code and improvement suggestions

[1364] Initial Setup and Login

[1365] 1. User: Launch the programming learning software and enter the required authentication information on the login screen.

[1366] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[1367] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[1368] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[1369] Code entry and analysis

[1370] 1. User: Enter the program code into the coding area of ​​the learning platform. For example, enter the following Python code:

[1371] python

[1372] for i in range(10):

[1373] print(i)

[1374] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[1375] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1376] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1377] View and provide feedback on improvement suggestions

[1378] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[1379] python

[1380] Recommended way: More Pythonic way

[1381] for i in range(10):

[1382] print(f"{i}")

[1383] Why: String formatting improves code readability.

[1384] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[1385] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[1386] Learning progress management

[1387] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[1388] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[1389] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and individual learning progress management allow users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can easily understand why they should do something, rather than just receiving instructions.

[1390] The processing flow will be explained below.

[1391] Step 1:

[1392] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[1393] Step 2:

[1394] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[1395] Step 3:

[1396] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[1397] Step 4:

[1398] Terminal: Displays a form and allows users to enter their self-assessment.

[1399] Step 5:

[1400] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[1401] Step 6:

[1402] Server: Receives the entered skill information and saves it in the user profile.

[1403] Step 7:

[1404] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[1405] python

[1406] for i in range(10):

[1407] print(i)

[1408] Step 8:

[1409] User: After entering the code, click the Run button.

[1410] Step 9:

[1411] Terminal: The entered code and the click event of the Run button are sent to the server.

[1412] Step 10:

[1413] Server: Sends the received code to the Generator AI and associated analysis engine, which analyzes the code and generates improvement suggestions.

[1414] Step 11:

[1415] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1416] Step 12:

[1417] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device.

[1418] Step 13:

[1419] Device: Display the suggestion in the user interface, for example:

[1420] python

[1421] Recommended way: More Pythonic way

[1422] for i in range(10):

[1423] print(f"{i}")

[1424] Why: String formatting improves code readability.

[1425] Step 14:

[1426] User: Review the suggested improvements and reasons, then fix their code.

[1427] Step 15:

[1428] User: Click the Run button to run the modified code again.

[1429] Step 16:

[1430] Terminal: Send the modified code to the server.

[1431] Step 17:

[1432] Server: Re-analyze the modified code to ensure there are no problems.

[1433] Step 18:

[1434] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[1435] Step 19:

[1436] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[1437] Step 20:

[1438] On your device: Shows the feedback you received and your next learning steps.

[1439] These are the specific processing steps from when the user enters the code to when they receive improvement suggestions and manage their learning progress.

[1440] Example 1

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

[1442] Conventional programming learning systems have the problem that they only provide uniform feedback to users and do not offer appropriate improvement suggestions based on individual skill levels or learning progress. This means that users do not receive feedback tailored to their own skill level, making it difficult to progress effectively. Furthermore, they lack the functionality to record code change history and improvement suggestion history and centrally manage learning progress, making it difficult to track continuous learning effects.

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

[1444] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for managing learning progress by saving the user's code change history and improvement suggestion history; means for analyzing and evaluating the readability, efficiency, and safety of the code based on prompts to the generation AI model; and means for reanalyzing the corrected program code and generating further improvement suggestions. This enables appropriate feedback according to the user's skill level and centralized management of learning progress.

[1445] "Program code" refers to the set of instructions written by a user to create software or an application.

[1446] "Generative AI" is artificial intelligence that uses natural language processing and coding style analysis engines to analyze input program code and generate improvement suggestions.

[1447] "User skill level" is an index showing the user's programming skill level, and is information obtained based on a self-evaluation form when logging in for the first time.

[1448] A "profile" is a database entry that stores information related to a user, including information such as skill level and learning progress.

[1449] "Improvement suggestions" are guidelines and advice obtained by the generative AI when it analyzes program code, and are intended to improve the readability, efficiency, and safety of the code.

[1450] "Code change history" refers to data that records the history of modifications to program code entered by the user.

[1451] "Improvement proposal history" refers to data that records the history of improvement proposals provided to the user by the generation AI.

[1452] "Study progress management" is a function that centrally monitors and records the user's learning status and provides feedback and learning suggestions as needed.

[1453] A "prompt sentence to a generative AI model" is an input command given to the generative AI for analysis and evaluation.

[1454] "Natural language processing" is a technology that uses computers to process human language, and is used in this system to understand and analyze program code.

[1455] "Reanalysis" refers to the process of reanalyzing modified or changed program code in order to generate further improvement suggestions.

[1456] This system uses a generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[1457] Basic System Configuration

[1458] User-side configuration

[1459] User: Operates the device on which the software is installed.

[1460] Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connectivity.

[1461] Server-side configuration

[1462] Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and monitors learning progress.

[1463] Generative AI: Artificial intelligence for analyzing program code, including natural language processing (NLP) engines and coding style analysis engines.

[1464] Analysis of program code and improvement suggestions

[1465] Initial Setup and Login

[1466] The user starts the programming learning software and enters the required authentication information on the login screen. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the user's profile information is obtained. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is sent to the server. The server saves the received skill level information in the user profile and centrally manages the user's learning progress.

[1467] Code entry and analysis

[1468] Users enter program code into the coding area of ​​the learning platform, for example, the following Python code:

[1469] for i in range(10):

[1470] print(i)

[1471] The device sends the entered code and the event of clicking the run button to the server. The server then sends the received code to the generation AI and related analysis engine for analysis. The generation AI analyzes the code and generates improvement suggestions. The server adjusts the generated improvement suggestions according to the user's skill level. For example, it provides simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1472] View and provide feedback on improvement suggestions

[1473] The server will send the adjusted improvement suggestions and the reasons for them to the user's device, for example, as shown below:

[1474] Recommended way: More Pythonic way

[1475] for i in range(10):

[1476] print(f"{i}")

[1477] Why: String formatting improves code readability.

[1478] The device displays suggestions and reasons for the suggestions on the user's screen, making it easier for the user to correct the code. The user corrects the code based on the suggested improvements, and then clicks the Run button to run the corrected code again.

[1479] Learning progress management

[1480] The server then analyzes the modified code again, records and saves the user's code change history and improvement suggestion history, and manages the user's learning progress, generating additional feedback and next learning suggestions as needed and sending them to the device.

[1481] Prompt Sentence Examples

[1482] Entered code example

[1483] for i in range(5):

[1484] print(i)

[1485] Example prompts for generative AI models

[1486] Analyze the following Python code and offer suggestions to improve its readability and efficiency:

[1487] for i in range(5):

[1488] print(i)

[1489] The user's skill level is intermediate.

[1490] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. This allows real-time feedback and individual learning progress management, allowing users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can more easily understand why they should do something, rather than just receiving instructions.

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

[1492] Step 1:

[1493] Initial Setup and Login

[1494] User: Starts the programming learning software and enters the required authentication information (e.g., username and password) on the login screen.

[1495] Input: Username, Password

[1496] Output: Credentials

[1497] Server: Receives the authentication information, queries the user management database, and performs authentication. If the user is successfully authenticated, obtains the user's profile information (e.g., skill level) and sends it to the device.

[1498] Input: Credentials

[1499] Output: Profile information

[1500] Users: When they log in for the first time, they enter their skill level through a self-assessment form and submit it.

[1501] Input: Skill level information

[1502] Output: Self-assessment information

[1503] Server: The received skill level information is saved in the user profile and used to manage learning progress.

[1504] Input: Self-assessment information

[1505] Output: Updated profile

[1506] Step 2:

[1507] Code entry and analysis

[1508] User: Enter the program code in the coding area. For example, enter the following Python code:

[1509] python

[1510] for i in range(10):

[1511] print(i)

[1512] Input: Program code

[1513] Output: None

[1514] Terminal: Captures the entered code and the click event of the Run button and sends it to the server.

[1515] Input: Program code, Run button click event

[1516] Output: Data sent to the server

[1517] Server: Sends the received code to the Generator AI and associated analysis engine for analysis.

[1518] Input: Program code

[1519] Output: Prompt for the generation AI

[1520] Generative AI: Analyzes program code and generates improvement suggestions.

[1521] Input: prompt statement

[1522] Output: Improvement suggestions

[1523] Step 3:

[1524] Generate and refine improvement proposals

[1525] Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1526] Input: improvement suggestions, user skill level

[1527] Output: Adjusted improvement suggestions

[1528] Step 4:

[1529] View and provide feedback on improvement suggestions

[1530] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[1531] python

[1532] Recommended way: More Pythonic way

[1533] for i in range(10):

[1534] print(f"{i}")

[1535] Why: String formatting improves code readability.

[1536] Input: Adjusted improvement proposal

[1537] Output: Data for display

[1538] Terminal: Suggestions and their reasons are displayed on the screen, helping the user to fix their code.

[1539] Input: Data to display

[1540] Output: Feedback to the user

[1541] User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[1542] Input: Improvement suggestion, user modified code

[1543] Output: Corrected code

[1544] Step 5:

[1545] Learning progress management

[1546] Server: Analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[1547] Input: Correction Code

[1548] Output: Code change history, improvement proposal history

[1549] Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[1550] Input: Code change history, improvement proposal history

[1551] Output: Additional feedback, next learning suggestions

[1552] In this way, the system provides a learning environment for users to efficiently improve their programming skills. In addition, by providing suggestions and reasons for them, users can improve their learning effectiveness.

[1553] (Application example 1)

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

[1555] Conventional optimization of control programs for factory automation equipment requires specialized knowledge and a great deal of effort, and is heavily dependent on the skills and experience of the engineer. Furthermore, appropriate improvement proposals are not provided promptly, and malfunctions and performance degradation are likely to occur. This makes it difficult to improve the efficiency of factory operations.

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

[1557] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for saving the user's code change history and improvement suggestion history to manage learning progress; means for receiving a control program entered by a user and making suggestions related to the operation of factory automation equipment; means for generating improvement suggestions for improving performance or preventing malfunctions based on the received control program; and means for optimizing the generated improvement suggestions for the operation of the equipment. This enables the optimization of the control program for factory automation equipment and improvement suggestions to be performed quickly and accurately without relying on the skill of an engineer, thereby improving the efficiency of factory operations.

[1558] A "user" is someone who uses the system to input program code and receive improvement suggestions.

[1559] "Program code" is a series of instructions that a user inputs into a system to control factory automation equipment and the like.

[1560] "Generative AI" refers to artificial intelligence technology that analyzes received program code and generates improvement suggestions.

[1561] "Skill level" indicates the user's programming ability and affects the complexity and detail of the suggestions generated by the system.

[1562] "Terminal" refers to a computer or mobile device used by a user that has the function of displaying generated improvement suggestions, etc.

[1563] "Code change history" means the record of modifications and changes made by the user to the program code.

[1564] The "improvement proposal history" is a record of improvement proposals for program code generated by the system.

[1565] "Learning progress" is an indicator that shows how much a user has improved their programming skills by using the system.

[1566] "Factory automation equipment" refers to machines that perform factory work automatically and operate based on control programs.

[1567] "Improvement proposal" refers to the specific content of the improvement proposal for the program code generated by the generation AI.

[1568] "Magic prevention" refers to measures taken to prevent factory automation equipment from operating in an unintended manner.

[1569] This invention relates to a control program optimization system for factory automation equipment, which receives program code entered by a user, analyzes it using a generation AI, generates improvement proposals, and adjusts them according to the user's skill level. Below, we will explain how this system is specifically implemented.

[1570] 1. System Configuration

[1571] User-side configuration

[1572] 1. User: An engineer who operates a terminal on which programming learning software is installed. He / she inputs control programs and receives suggestions for improvements.

[1573] 2. Terminal: A computer or mobile device used by a user that has an input interface, a display interface, and network connection capabilities.

[1574] Server-side configuration

[1575] 1. Server: This is the central processing unit that processes requests from users. It receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1576] 2. Generative AI: Uses artificial intelligence techniques to analyze program code, including natural language processing (NLP) engines and coding style analysis engines.

[1577] 2. Program processing explanation

[1578] Entering and receiving program code

[1579] The user enters the control program for the factory automation device into the code input area of ​​the terminal. For example, the user enters the following Python code:

[1580] for i in range(10):

[1581] send_command("move", i)

[1582] The terminal sends the entered program code to the server, which receives it and proceeds to the next stage of analysis.

[1583] Code analysis and generation of improvement suggestions

[1584] The server sends the received program code to the generation AI, which analyzes it by inputting the following prompt sentence into the generation AI model:

[1585] Analyze the following code and provide enhancement suggestions for a beginner level user:

[1586] for i in range(10):

[1587] send_command("move", i)

[1588] Based on the code analyzed by the generative AI model, improvement suggestions are generated, such as:

[1589] Recommended improvement: Add a short delay between commands to safely control the robot.

[1590] import time

[1591] for i in range(10):

[1592] send_command("move", i)

[1593] time.sleep(0.1) Add a delay of 0.1 seconds

[1594] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[1595] Adjust and display improvement suggestions

[1596] The generated improvement suggestions are tailored to the user's skill level: beginners receive easy-to-understand suggestions, while advanced users receive more specific and sophisticated suggestions.

[1597] These adjustment suggestions and their reasons are then sent to the terminal and displayed on the user's screen. The user can then modify the control program based on the displayed suggestions and their reasons.

[1598] Save history and manage learning progress

[1599] The server stores the history of code changes made by the user and the history of improvement suggestions provided by the generation AI. This history data is used to manage the user's learning progress and to make the next improvement suggestions.

[1600] 3. Adding concrete examples

[1601] If a technician enters the following robot control program:

[1602] for i in range(5):

[1603] move_arm("up", i)

[1604] After analysis, the generative AI provides specific improvement suggestions for beginners:

[1605] Recommended improvement: Add a check to ensure safe arm movement.

[1606] if arm_position < max_limit:

[1607] for i in range(5):

[1608] move_arm("up", i)

[1609] Reason: This prevents the robotic arm from exceeding its maximum safe position.

[1610] In this manner, the system of the present invention provides an environment for users to safely and efficiently optimize control programs for factory automation equipment.

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

[1612] Step 1:

[1613] User: Entering program code

[1614] The user enters the control program for the factory automation device into the code input area of ​​the terminal. An example input is the following Python code:

[1615] for i in range(10):

[1616] send_command("move", i)

[1617] Input: Control program code entered by the user into the terminal.

[1618] Output: Entered program code in the terminal

[1619] Step 2:

[1620] Terminal: Sending program code

[1621] The terminal sends the program code entered by the user to the server, which analyzes the code.

[1622] Input: Program code entered into the terminal

[1623] Output: The program code sent to the server

[1624] Step 3:

[1625] Server: Receives program code

[1626] The server receives the program code sent from the terminal and proceeds to the next stage of analysis.

[1627] Input: Program code sent from the terminal

[1628] Output: The program code received by the server

[1629] Step 4:

[1630] Server: Generates prompts for the AI

[1631] The server generates a prompt sentence to be input to the generative AI model based on the received program code. An example of a prompt sentence is as follows:

[1632] Analyze the following code and provide enhancement suggestions for a beginner level user:

[1633] for i in range(10):

[1634] send_command("move", i)

[1635] Input: Program code received by the server

[1636] Output: A prompt to be fed to the generative AI model

[1637] Step 5:

[1638] Generative AI: Analyzing program code and generating improvement proposals

[1639] The generative AI model analyzes the program code based on the prompt and generates improvement suggestions, which are formatted as follows:

[1640] Recommended improvement: Add a short delay between commands to safely control the robot.

[1641] import time

[1642] for i in range(10):

[1643] send_command("move", i)

[1644] time.sleep(0.1) Add a delay of 0.1 seconds

[1645] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[1646] Input: A prompt sent to the generative AI model

[1647] Output: Improvement suggestions generated by the generative AI model

[1648] Step 6:

[1649] Server: Adjustment of improvement proposals

[1650] The server adjusts the improvement suggestions generated by the generative AI model according to the user's skill level: beginners are provided with easy-to-understand suggestions, while advanced users are provided with more advanced suggestions.

[1651] Input: Improvement suggestions generated by the generative AI model, user skill level

[1652] Output: Skill-level-adjusted improvement suggestions

[1653] Step 7:

[1654] Server: Submit improvement suggestions

[1655] The server then sends the adjusted improvement proposals and the reasons for the proposals to the user's terminal, who then modifies the control program based on these proposals.

[1656] Input: Skill-level-adjusted improvement suggestions

[1657] Output: Improvement suggestions sent to the device

[1658] Step 8:

[1659] Device: Show improvement suggestions

[1660] The terminal displays the improvement proposal received from the server and the reason for it on the user's screen.

[1661] Input: Improvement suggestions sent by the server

[1662] Output: Improvement suggestions displayed on the user's screen

[1663] Step 9:

[1664] User: Modifying the program code

[1665] The user modifies the control program based on the improvement suggestions displayed on the terminal, and the modified program is then analyzed again.

[1666] Input: Improvement suggestions displayed on the device

[1667] Output: Modified program code

[1668] Step 10:

[1669] Server: Save history and manage learning progress

[1670] The server stores the history of the program code modified by the user and the improvement suggestions provided by the generation AI, allowing for efficient management of the user's learning progress.

[1671] Input: Modified program code, improvement suggestions provided by the generative AI

[1672] Output: A saved history of code changes and improvement suggestions

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

[1674] As an embodiment of the present invention, we will explain a specific method that combines a system that analyzes a user's program code and makes improvement suggestions with an emotion engine that recognizes the user's emotions. This system analyzes program code and makes improvement suggestions using generative AI, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress.

[1675] Basic System Configuration

[1676] User-side configuration

[1677] 1. User: Operates the device on which the software is installed.

[1678] 2. Terminal: A computer or mobile device running programming learning software, equipped with an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[1679] Server-side configuration

[1680] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1681] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[1682] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback.

[1683] Analysis of program code and improvement suggestions

[1684] Initial Setup and Login

[1685] 1. User: Launch the programming learning software, enter the required authentication information on the login screen, and click the login button.

[1686] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[1687] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[1688] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[1689] Code entry and analysis

[1690] 1. User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[1691] python

[1692] for i in range(10):

[1693] print(i)

[1694] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[1695] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1696] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1697] Emotion recognition and feedback regulation

[1698] 1. Terminal: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[1699] 2. Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it detects when the user is feeling stressed or confident.

[1700] 3. Server: Based on the emotional state recognized by the emotion engine, the production AI further adjusts its improvement suggestions. For example, it may provide a user who is feeling stressed with a less difficult suggestion or a more detailed explanation.

[1701] View and provide feedback on improvement suggestions

[1702] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[1703] python

[1704] Recommended way: More Pythonic way

[1705] for i in range(10):

[1706] print(f"{i}")

[1707] Why: String formatting improves code readability.

[1708] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[1709] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[1710] Learning progress management

[1711] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[1712] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[1713] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Furthermore, by providing suggestions and reasons alongside them, users can more easily understand why they should do something, rather than just being told what to do. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[1714] The processing flow will be explained below.

[1715] Step 1:

[1716] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[1717] Step 2:

[1718] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[1719] Step 3:

[1720] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[1721] Step 4:

[1722] Terminal: Displays a form and allows users to enter their self-assessment.

[1723] Step 5:

[1724] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[1725] Step 6:

[1726] Server: Receives the entered skill information and saves it in the user profile.

[1727] Step 7:

[1728] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[1729] python

[1730] for i in range(10):

[1731] print(i)

[1732] Step 8:

[1733] User: After entering the code, click the Run button.

[1734] Step 9:

[1735] Terminal: The entered code and the click event of the Run button are sent to the server.

[1736] Step 10:

[1737] Server: Sends received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1738] Step 11:

[1739] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1740] Step 12:

[1741] Device: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[1742] Step 13:

[1743] Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it can detect when the user is feeling stressed or confident.

[1744] Step 14:

[1745] Server: Based on the emotional state recognized by the emotion engine, the generative AI further adjusts the improvement suggestions. For example, it provides a user who is feeling stressed with a less difficult suggestion or a detailed explanation.

[1746] Step 15:

[1747] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[1748] python

[1749] Recommended way: More Pythonic way

[1750] for i in range(10):

[1751] print(f"{i}")

[1752] Why: String formatting improves code readability.

[1753] Step 16:

[1754] Terminal: Display suggestions in the user interface.

[1755] Step 17:

[1756] User: Review the suggested improvements and reasons, then fix their code.

[1757] Step 18:

[1758] User: Click the Run button to run the modified code again.

[1759] Step 19:

[1760] Terminal: Send the modified code to the server.

[1761] Step 20:

[1762] Server: Re-analyze the modified code to ensure there are no problems.

[1763] Step 21:

[1764] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[1765] Step 22:

[1766] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[1767] Step 23:

[1768] On your device: Shows the feedback you received and your next learning steps.

[1769] These are the specific steps in the process from when a user enters code to when they receive suggestions for improvement and manage their learning progress. This system allows users to efficiently improve their programming skills while receiving appropriate feedback based on their emotional state.

[1770] Example 2

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

[1772] Conventional programming learning systems provide uniform feedback without fully considering the user's skill level or emotional state, making effective learning difficult. Furthermore, they often lack mechanisms for managing users' progress or providing detailed reasons for code improvements, making it difficult to maintain motivation to learn.

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

[1774] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal, means for saving the user's code change history and improvement suggestion history to manage learning progress, means for recognizing the user's emotions, and means for adjusting feedback based on the recognized emotions. This maximizes the effectiveness of program learning and enables personalized feedback that adapts to the user's individual learning pace and emotional state.

[1775] "User" refers to an individual who uses the system to input program code and aims to improve their skills.

[1776] A "terminal" is a computer or mobile device operated by a user, and is a device for inputting program code and receiving feedback from the system.

[1777] A "server" is a central processing unit that processes requests from users, analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1778] "Generative AI" refers to artificial intelligence that analyzes received program code and generates improvement suggestions, and includes natural language processing (NLP) engines and coding style analysis engines.

[1779] The "emotion engine" is a system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[1780] "Program code" refers to the text of a computer program entered by a user.

[1781] "Improvement suggestions" refer to code optimization and correction suggestions generated by the generative AI after analyzing program code.

[1782] "Skill level" is an evaluation that indicates the user's level of proficiency in programming skills, and is entered in the self-evaluation form when logging in for the first time.

[1783] "Emotional state" refers to the user's current mental state, which is recognized by the emotion engine from facial expressions and voice data.

[1784] "Feedback" refers to improvement suggestions and advice provided to users by the generative AI based on the analyzed program code.

[1785] "Code change history" refers to a record of changes made to program code by the user up to now.

[1786] "Improvement suggestion history" refers to a record of improvement suggestions provided to a user.

[1787] "Study progress" refers to the content and progress a user has achieved in learning programming, and is managed by the server.

[1788] This invention is a system that analyzes program code entered by a user and makes improvement suggestions, and also has the function of recognizing the user's emotions and adjusting the feedback. The basic components of this system are a terminal operated by the user, a server that handles central processing, a generation AI that analyzes the program code and generates improvement suggestions, and an emotion engine that recognizes the user's emotional state.

[1789] Basic System Configuration

[1790] User-side configuration

[1791] 1. User: Operates a device on which programming learning software is installed.

[1792] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[1793] Server-side configuration

[1794] 1. Server: This is the central server that processes requests from users, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1795] 2. Generative AI: Artificial intelligence that analyzes received program code and generates improvement suggestions, including natural language processing (NLP) engines and coding style analysis engines.

[1796] 3. Emotion engine: A system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[1797] Analysis of program code and improvement suggestions

[1798] In this system, the user's device sends the program code they enter into the coding area to the server. The server then passes the received code to the generation AI, which analyzes it and generates improvement suggestions. The generated improvement suggestions are adjusted according to the user's skill level, and the adjusted suggestions and the reasons for the adjustments are sent to the user's device.

[1799] Emotion recognition and feedback regulation

[1800] The device sends the user's facial and voice data to the emotion engine, which analyzes it to recognize the user's emotional state. The server then further adjusts the improvement suggestions based on the user's emotional state. For example, if the user is feeling stressed, the difficulty level may be reduced or detailed explanations may be added.

[1801] Examples and prompts

[1802] If the user enters the following Python code:

[1803] for i in range(10):

[1804] print(i)

[1805] The server uses generative AI to generate improvement suggestions such as the following, which are adjusted according to the user's skill level and emotional state:

[1806] Recommended way: More Pythonic way

[1807] for i in range(10):

[1808] print(f"{i}")

[1809] Why: String formatting improves code readability.

[1810] Also, enter the following prompt for the generated AI:

[1811] Analyze user-supplied code, check if it is optimized, and generate any suggestions for improvement. Here is the input code:

[1812] for i in range(10):

[1813] print(i)

[1814] In this way, the system of the present invention provides a learning environment for users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace.

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

[1816] Step 1:

[1817] The user starts the programming learning software and enters the required authentication information on the login screen.

[1818] Specifically, the user double-clicks the software icon to start it and enters a user name and password.

[1819] Input: Username, Password

[1820] Output: None

[1821] Step 2:

[1822] The user clicks the login button.

[1823] The user clicks the "Login" button and the entered authentication information is sent to the server.

[1824] Input: Login button click event, authentication information

[1825] Output: Authentication request

[1826] Step 3:

[1827] The server receives the authentication information and accesses the user management database to perform authentication.

[1828] The server compares the authentication information it receives with the registration information in the database, and if authentication is successful, obtains the profile information.

[1829] Input: Credentials

[1830] Output: Authentication results, profile information

[1831] Step 4:

[1832] When a user logs in for the first time, he or she enters the skill level into a self-evaluation form and sends it to the server.

[1833] The user enters their skill level in the displayed self-assessment form and clicks the "Submit" button.

[1834] Input: Skill level, Send button click event

[1835] Output: Skill level information

[1836] Step 5:

[1837] The server stores the received skill level information in a user profile.

[1838] The server stores the skill level information in a database and updates the profile information.

[1839] Input: Skill level information

[1840] Output: Updated profile information

[1841] Step 6:

[1842] The user inputs the program code into the coding area of ​​the learning platform.

[1843] The user enters the following code into the coding area:

[1844] for i in range(10):

[1845] print(i)

[1846] Input: Program code

[1847] Output: The code entered

[1848] Step 7:

[1849] The user clicks the "Go" button.

[1850] The user clicks the "Run" button to send the entered code to the server.

[1851] Input: Click event of the Run button, program code

[1852] Output: Code analysis request

[1853] Step 8:

[1854] The server sends the received code to the generation AI.

[1855] The server passes the code to a generative AI model, instructing it to analyze the code and generate improvement suggestions.

[1856] Input: Program code, analysis request

[1857] Output: analysis results, improvement suggestions

[1858] Step 9:

[1859] Generative AI analyzes the code and generates improvement suggestions.

[1860] The generative AI analyzes the structure and content of the code and creates prompts that generate improvement suggestions.

[1861] Input: Program code

[1862] Output: Improvement suggestions

[1863] example:

[1864] Recommended way: More Pythonic way

[1865] for i in range(10):

[1866] print(f"{i}")

[1867] Why: String formatting improves code readability.

[1868] Step 10:

[1869] The server adjusts the generated improvement suggestions according to the user's skill level.

[1870] The server tailors the suggestions to suit the user's skill level, adding detailed explanations for beginners, for example.

[1871] Input: improvement suggestions, skill level information

[1872] Output: Adjusted improvement suggestions

[1873] Step 11:

[1874] The device sends the user's facial expressions and voice data to the emotion engine.

[1875] The camera and microphone connected to the device capture the user's facial expressions and voice and send them to the emotion engine.

[1876] Input: facial expression data, voice data

[1877] Output: Sending emotion data

[1878] Step 12:

[1879] An emotion engine analyzes the user's emotional state.

[1880] The emotion engine uses facial expression and voice analysis algorithms to recognize the user's emotional state.

[1881] Input: facial expression data, voice data

[1882] Output: Emotional state

[1883] Step 13:

[1884] The server adjusts the improvement suggestions based on the emotional state.

[1885] Based on the data from the emotion engine, the server reduces the difficulty of improvement suggestions or adds detailed explanations.

[1886] Input: Emotional state, improvement suggestions

[1887] Output: Finalized improvement proposals

[1888] Step 14:

[1889] The server transmits the adjusted improvement proposal to the user terminal.

[1890] The server sends the finalized proposal and the reasons for it to the user's terminal.

[1891] Input: Finalized improvement proposal

[1892] Output: Submit proposal

[1893] Step 15:

[1894] The terminal displays the suggestion and the reason to the user.

[1895] The device displays the content of the proposal and the reason for it on the screen, allowing the user to intuitively understand the content of the proposal.

[1896] Input: Submit Proposal

[1897] Output:Suggestion display

[1898] Step 16:

[1899] The user modifies the code based on the suggestions.

[1900] The user modifies the code based on the suggestions and clicks the "Run" button again.

[1901] Input: Proposal content, correction code

[1902] Output: Modified code

[1903] Step 17:

[1904] The server re-analyzes the modified code and records and saves the code change history and improvement proposal history.

[1905] The server passes the corrected code back to the generation AI and saves it as history in the database along with the analysis results.

[1906] Input: Correction Code

[1907] Output: Analysis results, saving of change history

[1908] Step 18:

[1909] The server manages the user's learning progress, generates additional feedback and next learning suggestions, and sends them to the device.

[1910] The server suggests the next step based on the data accumulated, and continuously supports the user's learning progress.

[1911] Input: Change history, improvement proposal history

[1912] Output: Next learning suggestions, feedback

[1913] This allows the entire system to effectively support users in learning programming.

[1914] (Application example 2)

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

[1916] While conventional program code improvement systems provide appropriate feedback according to the user's skill level, they do not take into account the user's emotional state, making it difficult to provide effective improvement suggestions when the user is feeling stressed or losing confidence.In addition, because factory robot programming requires high accuracy and efficiency, it is necessary to reduce the stress and fatigue that engineers feel during development and improve productivity.

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

[1918] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for managing the user's learning progress by saving the user's code change history and improvement suggestion history, means for recognizing the user's emotional state and adjusting feedback, and means for analyzing the user's facial expressions and voice using a smart device to acquire the user's emotional state. This makes it possible to provide appropriate feedback according to the user's emotional state, reducing stress and fatigue felt by the user and improving the programming productivity of factory robots.

[1919] "User" means a person who uses the system to input and improve program code.

[1920] "Program code" is a set of instructions that a computer executes to perform a particular operation.

[1921] "Generative AI" is an artificial intelligence technology used to analyze received program code and generate improvement suggestions.

[1922] "Improvement suggestions" are suggestions for improving the quality of the code that the generation AI presents after analyzing the received program code.

[1923] "Skill level" is an index that indicates the degree of a user's programming ability and knowledge.

[1924] The "code change history" is a record of changes made by the user to the program code.

[1925] "Improvement proposal history" is a record of improvement proposals presented to the user by the generation AI.

[1926] "Study progress" indicates the degree of growth and achievement of the user as they progress through their programming studies.

[1927] "Emotional state" refers to a user's current mental or emotional state.

[1928] "Feedback" refers to advice and comments provided by the system regarding the program code entered by the user.

[1929] A "smart device" is an electronic device that has the ability to recognize a user's facial expressions and voice and acquire their emotional state.

[1930] "Facial expression" refers to the emotions and psychological state that are revealed through the user's facial movements and expressions.

[1931] "Voice" refers to the emotions and psychological state that are expressed through the user's voice and speaking style.

[1932] This invention is a system that analyzes a user's program code and makes suggestions for improvements when programming factory robots. This system uses generative AI to analyze program code and make suggestions for improvements, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress. Furthermore, it optimizes the programming environment by recognizing the user's emotional state and adjusting feedback.

[1933] Basic System Configuration

[1934] User-side configuration

[1935] 1. User: Operates the device on which the software is installed.

[1936] 2. Device: A computer or smartphone running programming learning software, equipped with an input interface, display interface, network connectivity, and a camera and microphone for emotion recognition.

[1937] Server-side configuration

[1938] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[1939] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[1940] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback. It analyzes data obtained through the camera and microphone.

[1941] Analysis of program code and improvement suggestions

[1942] Initial Setup and Login

[1943] 1. The user launches the programming learning software and enters the required authentication information on the login screen.

[1944] 2. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the server retrieves the user's profile information.

[1945] 3. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is then sent to the server.

[1946] 4. The server stores the received skill level information in the user profile and centrally manages the user's learning progress.

[1947] Code entry and analysis

[1948] 1. The user enters the program code into the coding area of ​​the learning platform.

[1949] 2. The terminal sends the entered code and the event of clicking the run button to the server.

[1950] 3. The server sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[1951] 4. The server tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[1952] Emotion recognition and feedback regulation

[1953] 1. The device sends the user's facial expressions and voice to the emotion engine when entering a code or confirming a suggestion.

[1954] 2. The emotion engine analyzes the user's facial expressions, voice, or text input to recognize their emotional state, for example, detecting when they are stressed or confident.

[1955] 3. The server further adjusts the generative AI's improvement suggestions based on the emotional state recognized by the emotion engine. For example, it may provide a user who is feeling stressed with a less difficult suggestion or more detailed explanation.

[1956] View and provide feedback on improvement suggestions

[1957] 1. The server sends the adjusted improvement proposal and the reason for it to the user's device. For example, it will be displayed as follows:

[1958] python

[1959] Recommended way: More Pythonic way

[1960] for i in range(10):

[1961] print(f"{i}")

[1962] Why: String formatting improves code readability.

[1963] 2. The device displays the suggestions and reasons on the user's screen, making it easier for the user to fix the code.

[1964] 3. The user modifies the code based on the suggested improvements and clicks the Run button to run the modified code again.

[1965] Learning progress management

[1966] 1. The server analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[1967] 2. The server manages the user's learning progress and generates additional feedback and next learning suggestions as needed and sends them to the device.

[1968] This allows for efficient analysis of factory robot program code and suggestions for improvement. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Proposals and their rationale are displayed alongside each suggestion, helping users understand why they should do something rather than simply receiving instructions. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[1969] Prompt Sentence Examples

[1970] Analyze the code entered by the user and make suggestions for improvement based on the emotion recognition results.

[1971] User input code:

[1972] {User input code}

[1973] User's emotional state:

[1974] {Emotional state}

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

[1976] Step 1:

[1977] The user starts the programming learning software and enters the required authentication information on the login screen. The entered authentication information is sent from the terminal to the server. The server receives this authentication information, accesses the user management database, and performs authentication. If authentication is successful, the user's profile information is obtained and sent to the terminal. The input here is the authentication information, and the output is the user's profile information.

[1978] Step 2:

[1979] When a user logs in for the first time, they enter their skill level in a self-assessment form, and this information is sent to the server. The server saves the received skill level information in the user profile and uses it as data for centrally managing the user's learning progress. The input here is the user's skill level information, and the output is the saved profile.

[1980] Step 3:

[1981] The user inputs the program code into the coding area of ​​the learning platform, and the input program code is sent to the server by the terminal. Here, the input is the program code, and the output is the sending of the code to the server.

[1982] Step 4:

[1983] The server sends the received program code to a generative AI and related analysis engine for analysis. The generative AI analyzes the received code and generates improvement suggestions. This analysis is performed using a natural language processing (NLP) engine and a coding style analysis engine. The input here is the program code, and the output is improvement suggestions.

[1984] Step 5:

[1985] The server adjusts the generated improvement suggestions according to the user's skill level. It provides simple suggestions to novice users and detailed and advanced suggestions to advanced users. The input here is the improvement suggestions and the user's skill level information, and the output is the adjusted improvement suggestions.

[1986] Step 6:

[1987] The device sends the user's facial expressions and voice to the emotion engine when entering a code or confirming a suggestion. The emotion engine analyzes the user's facial expressions, voice, or text input to recognize the user's emotional state. This recognition is performed using a camera and microphone. The input here is the user's facial expressions and voice data, and the output is their emotional state.

[1988] Step 7:

[1989] The server further adjusts the improvement suggestions made by the generative AI based on the emotional state recognized by the emotion engine. For example, if the user is feeling stressed, the difficulty of the suggestions will be reduced. The input here is the emotional state and improvement suggestions, and the output is further adjusted improvement suggestions.

[1990] Step 8:

[1991] The server sends the adjusted improvement proposals and the reasons for them to the terminal. The terminal displays the proposals and the reasons for them on the user's screen, providing an interface to make it easier for the user to modify the code. The input here is the further adjusted improvement proposals, and the output is the display on the user's screen.

[1992] Step 9:

[1993] The user modifies the code based on the proposed improvements. To run the modified code again, the user clicks the Run button, and the terminal sends the modified code to the server again. The input here is the modified program code, and the output is the code sent to the server.

[1994] Step 10:

[1995] The server analyzes the corrected code again and records and saves the user's code change history and improvement proposal history. Based on the recorded data, it manages the user's learning progress and generates additional feedback and next learning suggestions as needed, which are sent to the device. The input here is the corrected code, and the output is a record of the user's code change history and improvement proposal history.

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

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

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

[1999] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[2013] As an embodiment of the present invention, a specific method for analyzing program code and proposing improvements will be described. This system uses generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[2014] Basic System Configuration

[2015] User-side configuration

[2016] 1. User: Operates the device on which the software is installed.

[2017] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connection capabilities.

[2018] Server-side configuration

[2019] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[2020] 2. Generative AI: Artificial intelligence for program code analytics, including a natural language processing (NLP) engine and a coding style analysis engine.

[2021] Analysis of program code and improvement suggestions

[2022] Initial Setup and Login

[2023] 1. User: Launch the programming learning software and enter the required authentication information on the login screen.

[2024] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[2025] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[2026] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[2027] Code entry and analysis

[2028] 1. User: Enter the program code into the coding area of ​​the learning platform. For example, enter the following Python code:

[2029] python

[2030] for i in range(10):

[2031] print(i)

[2032] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[2033] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[2034] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[2035] View and provide feedback on improvement suggestions

[2036] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[2037] python

[2038] Recommended way: More Pythonic way

[2039] for i in range(10):

[2040] print(f"{i}")

[2041] Why: String formatting improves code readability.

[2042] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[2043] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[2044] Learning progress management

[2045] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[2046] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[2047] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and individual learning progress management allow users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can easily understand why they should do something, rather than just receiving instructions.

[2048] The processing flow will be explained below.

[2049] Step 1:

[2050] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[2051] Step 2:

[2052] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[2053] Step 3:

[2054] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[2055] Step 4:

[2056] Terminal: Displays a form and allows users to enter their self-assessment.

[2057] Step 5:

[2058] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[2059] Step 6:

[2060] Server: Receives the entered skill information and saves it in the user profile.

[2061] Step 7:

[2062] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[2063] python

[2064] for i in range(10):

[2065] print(i)

[2066] Step 8:

[2067] User: After entering the code, click the Run button.

[2068] Step 9:

[2069] Terminal: The entered code and the click event of the Run button are sent to the server.

[2070] Step 10:

[2071] Server: Sends the received code to the Generator AI and associated analysis engine, which analyzes the code and generates improvement suggestions.

[2072] Step 11:

[2073] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[2074] Step 12:

[2075] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device.

[2076] Step 13:

[2077] Device: Display the suggestion in the user interface, for example:

[2078] python

[2079] Recommended way: More Pythonic way

[2080] for i in range(10):

[2081] print(f"{i}")

[2082] Why: String formatting improves code readability.

[2083] Step 14:

[2084] User: Review the suggested improvements and reasons, then fix their code.

[2085] Step 15:

[2086] User: Click the Run button to run the modified code again.

[2087] Step 16:

[2088] Terminal: Send the modified code to the server.

[2089] Step 17:

[2090] Server: Re-analyze the modified code to ensure there are no problems.

[2091] Step 18:

[2092] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[2093] Step 19:

[2094] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[2095] Step 20:

[2096] On your device: Shows the feedback you received and your next learning steps.

[2097] These are the specific processing steps from when the user enters the code to when they receive improvement suggestions and manage their learning progress.

[2098] Example 1

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

[2100] Conventional programming learning systems have the problem that they only provide uniform feedback to users and do not offer appropriate improvement suggestions based on individual skill levels or learning progress. This means that users do not receive feedback tailored to their own skill level, making it difficult to progress effectively. Furthermore, they lack the functionality to record code change history and improvement suggestion history and centrally manage learning progress, making it difficult to track continuous learning effects.

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

[2102] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for managing learning progress by saving the user's code change history and improvement suggestion history; means for analyzing and evaluating the readability, efficiency, and safety of the code based on prompts to the generation AI model; and means for reanalyzing the corrected program code and generating further improvement suggestions. This enables appropriate feedback according to the user's skill level and centralized management of learning progress.

[2103] "Program code" refers to the set of instructions written by a user to create software or an application.

[2104] "Generative AI" is artificial intelligence that uses natural language processing and coding style analysis engines to analyze input program code and generate improvement suggestions.

[2105] "User skill level" is an index showing the user's programming skill level, and is information obtained based on a self-evaluation form when logging in for the first time.

[2106] A "profile" is a database entry that stores information related to a user, including information such as skill level and learning progress.

[2107] "Improvement suggestions" are guidelines and advice obtained by the generative AI when it analyzes program code, and are intended to improve the readability, efficiency, and safety of the code.

[2108] "Code change history" refers to data that records the history of modifications to program code entered by the user.

[2109] "Improvement proposal history" refers to data that records the history of improvement proposals provided to the user by the generation AI.

[2110] "Study progress management" is a function that centrally monitors and records the user's learning status and provides feedback and learning suggestions as needed.

[2111] A "prompt sentence to a generative AI model" is an input command given to the generative AI for analysis and evaluation.

[2112] "Natural language processing" is a technology that uses computers to process human language, and is used in this system to understand and analyze program code.

[2113] "Reanalysis" refers to the process of reanalyzing modified or changed program code in order to generate further improvement suggestions.

[2114] This system uses a generative AI to analyze program code and propose improvements, providing appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement proposal history, and managing learning progress.

[2115] Basic System Configuration

[2116] User-side configuration

[2117] User: Operates the device on which the software is installed.

[2118] Terminal: A computer or mobile device that runs programming learning software and has an input interface, display interface, and network connectivity.

[2119] Server-side configuration

[2120] Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and monitors learning progress.

[2121] Generative AI: Artificial intelligence for analyzing program code, including natural language processing (NLP) engines and coding style analysis engines.

[2122] Analysis of program code and improvement suggestions

[2123] Initial Setup and Login

[2124] The user starts the programming learning software and enters the required authentication information on the login screen. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the user's profile information is obtained. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is sent to the server. The server saves the received skill level information in the user profile and centrally manages the user's learning progress.

[2125] Code entry and analysis

[2126] Users enter program code into the coding area of ​​the learning platform, for example, the following Python code:

[2127] for i in range(10):

[2128] print(i)

[2129] The device sends the entered code and the event of clicking the run button to the server. The server then sends the received code to the generation AI and related analysis engine for analysis. The generation AI analyzes the code and generates improvement suggestions. The server adjusts the generated improvement suggestions according to the user's skill level. For example, it provides simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[2130] View and provide feedback on improvement suggestions

[2131] The server will send the adjusted improvement suggestions and the reasons for them to the user's device, for example, as shown below:

[2132] Recommended way: More Pythonic way

[2133] for i in range(10):

[2134] print(f"{i}")

[2135] Why: String formatting improves code readability.

[2136] The device displays suggestions and reasons for the suggestions on the user's screen, making it easier for the user to correct the code. The user corrects the code based on the suggested improvements, and then clicks the Run button to run the corrected code again.

[2137] Learning progress management

[2138] The server then analyzes the modified code again, records and saves the user's code change history and improvement suggestion history, and manages the user's learning progress, generating additional feedback and next learning suggestions as needed and sending them to the device.

[2139] Prompt Sentence Examples

[2140] Entered code example

[2141] for i in range(5):

[2142] print(i)

[2143] Example prompts for generative AI models

[2144] Analyze the following Python code and offer suggestions to improve its readability and efficiency:

[2145] for i in range(5):

[2146] print(i)

[2147] The user's skill level is intermediate.

[2148] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. This allows real-time feedback and individual learning progress management, allowing users to effectively progress through their learning at their own pace. Furthermore, by providing suggestions and reasons for each suggestion, users can more easily understand why they should do something, rather than just receiving instructions.

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

[2150] Step 1:

[2151] Initial Setup and Login

[2152] User: Starts the programming learning software and enters the required authentication information (e.g., username and password) on the login screen.

[2153] Input: Username, Password

[2154] Output: Credentials

[2155] Server: Receives the authentication information, queries the user management database, and performs authentication. If the user is successfully authenticated, obtains the user's profile information (e.g., skill level) and sends it to the device.

[2156] Input: Credentials

[2157] Output: Profile information

[2158] Users: When they log in for the first time, they enter their skill level through a self-assessment form and submit it.

[2159] Input: Skill level information

[2160] Output: Self-assessment information

[2161] Server: The received skill level information is saved in the user profile and used to manage learning progress.

[2162] Input: Self-assessment information

[2163] Output: Updated profile

[2164] Step 2:

[2165] Code entry and analysis

[2166] User: Enter the program code in the coding area. For example, enter the following Python code:

[2167] python

[2168] for i in range(10):

[2169] print(i)

[2170] Input: Program code

[2171] Output: None

[2172] Terminal: Captures the entered code and the click event of the Run button and sends it to the server.

[2173] Input: Program code, Run button click event

[2174] Output: Data sent to the server

[2175] Server: Sends the received code to the Generator AI and associated analysis engine for analysis.

[2176] Input: Program code

[2177] Output: Prompt for the generation AI

[2178] Generative AI: Analyzes program code and generates improvement suggestions.

[2179] Input: prompt statement

[2180] Output: Improvement suggestions

[2181] Step 3:

[2182] Generate and refine improvement proposals

[2183] Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[2184] Input: improvement suggestions, user skill level

[2185] Output: Adjusted improvement suggestions

[2186] Step 4:

[2187] View and provide feedback on improvement suggestions

[2188] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[2189] python

[2190] Recommended way: More Pythonic way

[2191] for i in range(10):

[2192] print(f"{i}")

[2193] Why: String formatting improves code readability.

[2194] Input: Adjusted improvement proposal

[2195] Output: Data for display

[2196] Terminal: Suggestions and their reasons are displayed on the screen, helping the user to fix their code.

[2197] Input: Data to display

[2198] Output: Feedback to the user

[2199] User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[2200] Input: Improvement suggestion, user modified code

[2201] Output: Corrected code

[2202] Step 5:

[2203] Learning progress management

[2204] Server: Analyzes the modified code again and records and saves the user's code change history and improvement proposal history.

[2205] Input: Correction Code

[2206] Output: Code change history, improvement proposal history

[2207] Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[2208] Input: Code change history, improvement proposal history

[2209] Output: Additional feedback, next learning suggestions

[2210] In this way, the system provides a learning environment for users to efficiently improve their programming skills. In addition, by providing suggestions and reasons for them, users can improve their learning effectiveness.

[2211] (Application example 1)

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

[2213] Conventional optimization of control programs for factory automation equipment requires specialized knowledge and a great deal of effort, and is heavily dependent on the skills and experience of the engineer. Furthermore, appropriate improvement proposals are not provided promptly, and malfunctions and performance degradation are likely to occur. This makes it difficult to improve the efficiency of factory operations.

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

[2215] In this invention, the server includes: means for receiving program code entered by a user; means for using a generation AI to analyze the received program code and generate improvement suggestions; means for adjusting the generated improvement suggestions according to the user's skill level; means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal; means for saving the user's code change history and improvement suggestion history to manage learning progress; means for receiving a control program entered by a user and making suggestions related to the operation of factory automation equipment; means for generating improvement suggestions for improving performance or preventing malfunctions based on the received control program; and means for optimizing the generated improvement suggestions for the operation of the equipment. This enables the optimization of the control program for factory automation equipment and improvement suggestions to be performed quickly and accurately without relying on the skill of an engineer, thereby improving the efficiency of factory operations.

[2216] A "user" is someone who uses the system to input program code and receive improvement suggestions.

[2217] "Program code" is a series of instructions that a user inputs into a system to control factory automation equipment and the like.

[2218] "Generative AI" refers to artificial intelligence technology that analyzes received program code and generates improvement suggestions.

[2219] "Skill level" indicates the user's programming ability and affects the complexity and detail of the suggestions generated by the system.

[2220] "Terminal" refers to a computer or mobile device used by a user that has the function of displaying generated improvement suggestions, etc.

[2221] "Code change history" means the record of modifications and changes made by the user to the program code.

[2222] The "improvement proposal history" is a record of improvement proposals for program code generated by the system.

[2223] "Learning progress" is an indicator that shows how much a user has improved their programming skills by using the system.

[2224] "Factory automation equipment" refers to machines that perform factory work automatically and operate based on control programs.

[2225] "Improvement proposal" refers to the specific content of the improvement proposal for the program code generated by the generation AI.

[2226] "Magic prevention" refers to measures taken to prevent factory automation equipment from operating in an unintended manner.

[2227] This invention relates to a control program optimization system for factory automation equipment, which receives program code entered by a user, analyzes it using a generation AI, generates improvement proposals, and adjusts them according to the user's skill level. Below, we will explain how this system is specifically implemented.

[2228] 1. System Configuration

[2229] User-side configuration

[2230] 1. User: An engineer who operates a terminal on which programming learning software is installed. He / she inputs control programs and receives suggestions for improvements.

[2231] 2. Terminal: A computer or mobile device used by a user that has an input interface, a display interface, and network connection capabilities.

[2232] Server-side configuration

[2233] 1. Server: This is the central processing unit that processes requests from users. It receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[2234] 2. Generative AI: Uses artificial intelligence techniques to analyze program code, including natural language processing (NLP) engines and coding style analysis engines.

[2235] 2. Program processing explanation

[2236] Entering and receiving program code

[2237] The user enters the control program for the factory automation device into the code input area of ​​the terminal. For example, the user enters the following Python code:

[2238] for i in range(10):

[2239] send_command("move", i)

[2240] The terminal sends the entered program code to the server, which receives it and proceeds to the next stage of analysis.

[2241] Code analysis and generation of improvement suggestions

[2242] The server sends the received program code to the generation AI, which analyzes it by inputting the following prompt sentence into the generation AI model:

[2243] Analyze the following code and provide enhancement suggestions for a beginner level user:

[2244] for i in range(10):

[2245] send_command("move", i)

[2246] Based on the code analyzed by the generative AI model, improvement suggestions are generated, such as:

[2247] Recommended improvement: Add a short delay between commands to safely control the robot.

[2248] import time

[2249] for i in range(10):

[2250] send_command("move", i)

[2251] time.sleep(0.1) Add a delay of 0.1 seconds

[2252] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[2253] Adjust and display improvement suggestions

[2254] The generated improvement suggestions are tailored to the user's skill level: beginners receive easy-to-understand suggestions, while advanced users receive more specific and sophisticated suggestions.

[2255] These adjustment suggestions and their reasons are then sent to the terminal and displayed on the user's screen. The user can then modify the control program based on the displayed suggestions and their reasons.

[2256] Save history and manage learning progress

[2257] The server stores the history of code changes made by the user and the history of improvement suggestions provided by the generation AI. This history data is used to manage the user's learning progress and to make the next improvement suggestions.

[2258] 3. Adding concrete examples

[2259] If a technician enters the following robot control program:

[2260] for i in range(5):

[2261] move_arm("up", i)

[2262] After analysis, the generative AI provides specific improvement suggestions for beginners:

[2263] Recommended improvement: Add a check to ensure safe arm movement.

[2264] if arm_position < max_limit:

[2265] for i in range(5):

[2266] move_arm("up", i)

[2267] Reason: This prevents the robotic arm from exceeding its maximum safe position.

[2268] In this manner, the system of the present invention provides an environment for users to safely and efficiently optimize control programs for factory automation equipment.

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

[2270] Step 1:

[2271] User: Entering program code

[2272] The user enters the control program for the factory automation device into the code input area of ​​the terminal. An example input is the following Python code:

[2273] for i in range(10):

[2274] send_command("move", i)

[2275] Input: Control program code entered by the user into the terminal.

[2276] Output: Entered program code in the terminal

[2277] Step 2:

[2278] Terminal: Sending program code

[2279] The terminal sends the program code entered by the user to the server, which analyzes the code.

[2280] Input: Program code entered into the terminal

[2281] Output: The program code sent to the server

[2282] Step 3:

[2283] Server: Receives program code

[2284] The server receives the program code sent from the terminal and proceeds to the next stage of analysis.

[2285] Input: Program code sent from the terminal

[2286] Output: The program code received by the server

[2287] Step 4:

[2288] Server: Generates prompts for the AI

[2289] The server generates a prompt sentence to be input to the generative AI model based on the received program code. An example of a prompt sentence is as follows:

[2290] Analyze the following code and provide enhancement suggestions for a beginner level user:

[2291] for i in range(10):

[2292] send_command("move", i)

[2293] Input: Program code received by the server

[2294] Output: A prompt to be fed to the generative AI model

[2295] Step 5:

[2296] Generative AI: Analyzing program code and generating improvement proposals

[2297] The generative AI model analyzes the program code based on the prompt and generates improvement suggestions, which are formatted as follows:

[2298] Recommended improvement: Add a short delay between commands to safely control the robot.

[2299] import time

[2300] for i in range(10):

[2301] send_command("move", i)

[2302] time.sleep(0.1) Add a delay of 0.1 seconds

[2303] Reason: Excessive high-speed commands may cause the robot to malfunction, adding a delay between commands prevents this.

[2304] Input: A prompt sent to the generative AI model

[2305] Output: Improvement suggestions generated by the generative AI model

[2306] Step 6:

[2307] Server: Adjustment of improvement proposals

[2308] The server adjusts the improvement suggestions generated by the generative AI model according to the user's skill level: beginners are provided with easy-to-understand suggestions, while advanced users are provided with more advanced suggestions.

[2309] Input: Improvement suggestions generated by the generative AI model, user skill level

[2310] Output: Skill-level-adjusted improvement suggestions

[2311] Step 7:

[2312] Server: Submit improvement suggestions

[2313] The server then sends the adjusted improvement proposals and the reasons for the proposals to the user's terminal, who then modifies the control program based on these proposals.

[2314] Input: Skill-level-adjusted improvement suggestions

[2315] Output: Improvement suggestions sent to the device

[2316] Step 8:

[2317] Device: Show improvement suggestions

[2318] The terminal displays the improvement proposal received from the server and the reason for it on the user's screen.

[2319] Input: Improvement suggestions sent by the server

[2320] Output: Improvement suggestions displayed on the user's screen

[2321] Step 9:

[2322] User: Modifying the program code

[2323] The user modifies the control program based on the improvement suggestions displayed on the terminal, and the modified program is then analyzed again.

[2324] Input: Improvement suggestions displayed on the device

[2325] Output: Modified program code

[2326] Step 10:

[2327] Server: Save history and manage learning progress

[2328] The server stores the history of the program code modified by the user and the improvement suggestions provided by the generation AI, allowing for efficient management of the user's learning progress.

[2329] Input: Modified program code, improvement suggestions provided by the generative AI

[2330] Output: A saved history of code changes and improvement suggestions

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

[2332] As an embodiment of the present invention, we will explain a specific method that combines a system that analyzes a user's program code and makes improvement suggestions with an emotion engine that recognizes the user's emotions. This system analyzes program code and makes improvement suggestions using generative AI, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress.

[2333] Basic System Configuration

[2334] User-side configuration

[2335] 1. User: Operates the device on which the software is installed.

[2336] 2. Terminal: A computer or mobile device running programming learning software, equipped with an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[2337] Server-side configuration

[2338] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[2339] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[2340] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback.

[2341] Analysis of program code and improvement suggestions

[2342] Initial Setup and Login

[2343] 1. User: Launch the programming learning software, enter the required authentication information on the login screen, and click the login button.

[2344] 2. Server: Receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, obtains the user's profile information.

[2345] 3. User: When logging in for the first time, the user enters their skill level in a self-assessment form, which is then sent to the server.

[2346] 4. Server: The received skill level information is saved in the user profile and the user's learning progress is managed centrally.

[2347] Code entry and analysis

[2348] 1. User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[2349] python

[2350] for i in range(10):

[2351] print(i)

[2352] 2. Terminal: The entered code and the click event of the Run button are sent to the server.

[2353] 3. Server: Sends the received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[2354] 4. Server: Tailors the generated improvement suggestions to the user's skill level, for example providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[2355] Emotion recognition and feedback regulation

[2356] 1. Terminal: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[2357] 2. Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it detects when the user is feeling stressed or confident.

[2358] 3. Server: Based on the emotional state recognized by the emotion engine, the production AI further adjusts its improvement suggestions. For example, it may provide a user who is feeling stressed with a less difficult suggestion or a more detailed explanation.

[2359] View and provide feedback on improvement suggestions

[2360] 1. Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[2361] python

[2362] Recommended way: More Pythonic way

[2363] for i in range(10):

[2364] print(f"{i}")

[2365] Why: String formatting improves code readability.

[2366] 2. Terminal: Display suggestions and reasons on the user's screen to help them fix their code.

[2367] 3. User: Modify the code based on the suggested improvements. Click the Run button to run the modified code again.

[2368] Learning progress management

[2369] 1. Server: Re-analyzes the modified code and records and saves the user's code change history and improvement proposal history.

[2370] 2. Server: Manages the user's learning progress and generates and sends additional feedback and next learning suggestions to the device as needed.

[2371] In this way, the system of the present invention provides a learning environment that allows users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace. Furthermore, by providing suggestions and reasons alongside them, users can more easily understand why they should do something, rather than just being told what to do. Taking into account the user's emotional state makes the learning experience more personalized, helping to maintain motivation.

[2372] The processing flow will be explained below.

[2373] Step 1:

[2374] User: Start the programming learning software, enter your user ID and password on the login screen, and click the login button.

[2375] Step 2:

[2376] Server: Receives the user ID and password, accesses the user management database to perform authentication, and if authentication is successful, obtains the user's profile information.

[2377] Step 3:

[2378] Server: When logging in for the first time, generate the user's programming skills self-assessment form and send it to the terminal.

[2379] Step 4:

[2380] Terminal: Displays a form and allows users to enter their self-assessment.

[2381] Step 5:

[2382] User: Fill out the self-assessment form to assess their programming skills and click the submit button.

[2383] Step 6:

[2384] Server: Receives the entered skill information and saves it in the user profile.

[2385] Step 7:

[2386] User: Enter the program code in the coding area of ​​the learning platform. For example, enter the following Python code:

[2387] python

[2388] for i in range(10):

[2389] print(i)

[2390] Step 8:

[2391] User: After entering the code, click the Run button.

[2392] Step 9:

[2393] Terminal: The entered code and the click event of the Run button are sent to the server.

[2394] Step 10:

[2395] Server: Sends received code to the Generative AI and associated analysis engine for analysis. The Generative AI analyzes the code and generates improvement suggestions.

[2396] Step 11:

[2397] Server: Tailors the generated improvement suggestions to the user's skill level, for example, providing simple suggestions to novice users and detailed and advanced suggestions to advanced users.

[2398] Step 12:

[2399] Device: Sends the user's facial expressions and voice to the emotion engine when entering code or confirming suggestions.

[2400] Step 13:

[2401] Emotion engine: Recognizes the user's emotional state by analyzing their facial expressions, voice, or text input. For example, it can detect when the user is feeling stressed or confident.

[2402] Step 14:

[2403] Server: Based on the emotional state recognized by the emotion engine, the generative AI further adjusts the improvement suggestions. For example, it provides a user who is feeling stressed with a less difficult suggestion or a detailed explanation.

[2404] Step 15:

[2405] Server: Sends the adjusted improvement suggestions and the reasons for them to the user's device. For example, it will be displayed as follows:

[2406] python

[2407] Recommended way: More Pythonic way

[2408] for i in range(10):

[2409] print(f"{i}")

[2410] Why: String formatting improves code readability.

[2411] Step 16:

[2412] Terminal: Display suggestions in the user interface.

[2413] Step 17:

[2414] User: Review the suggested improvements and reasons, then fix their code.

[2415] Step 18:

[2416] User: Click the Run button to run the modified code again.

[2417] Step 19:

[2418] Terminal: Send the modified code to the server.

[2419] Step 20:

[2420] Server: Re-analyze the modified code to ensure there are no problems.

[2421] Step 21:

[2422] Server: Records the user's code change history and improvement proposal history in a learning progress database and manages the user's learning progress.

[2423] Step 22:

[2424] Server: Generates additional feedback and next learning suggestions as needed and sends them to the device.

[2425] Step 23:

[2426] On your device: Shows the feedback you received and your next learning steps.

[2427] These are the specific steps in the process from when a user enters code to when they receive suggestions for improvement and manage their learning progress. This system allows users to efficiently improve their programming skills while receiving appropriate feedback based on their emotional state.

[2428] Example 2

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

[2430] Conventional programming learning systems provide uniform feedback without fully considering the user's skill level or emotional state, making effective learning difficult. Furthermore, they often lack mechanisms for managing users' progress or providing detailed reasons for code improvements, making it difficult to maintain motivation to learn.

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

[2432] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for transmitting the adjusted improvement suggestions and the reasons for the adjustments to the user's terminal, means for saving the user's code change history and improvement suggestion history to manage learning progress, means for recognizing the user's emotions, and means for adjusting feedback based on the recognized emotions. This maximizes the effectiveness of program learning and enables personalized feedback that adapts to the user's individual learning pace and emotional state.

[2433] "User" refers to an individual who uses the system to input program code and aims to improve their skills.

[2434] A "terminal" is a computer or mobile device operated by a user, and is a device for inputting program code and receiving feedback from the system.

[2435] A "server" is a central processing unit that processes requests from users, analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[2436] "Generative AI" refers to artificial intelligence that analyzes received program code and generates improvement suggestions, and includes natural language processing (NLP) engines and coding style analysis engines.

[2437] The "emotion engine" is a system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[2438] "Program code" refers to the text of a computer program entered by a user.

[2439] "Improvement suggestions" refer to code optimization and correction suggestions generated by the generative AI after analyzing program code.

[2440] "Skill level" is an evaluation that indicates the user's level of proficiency in programming skills, and is entered in the self-evaluation form when logging in for the first time.

[2441] "Emotional state" refers to the user's current mental state, which is recognized by the emotion engine from facial expressions and voice data.

[2442] "Feedback" refers to improvement suggestions and advice provided to users by the generative AI based on the analyzed program code.

[2443] "Code change history" refers to a record of changes made to program code by the user up to now.

[2444] "Improvement suggestion history" refers to a record of improvement suggestions provided to a user.

[2445] "Study progress" refers to the content and progress a user has achieved in learning programming, and is managed by the server.

[2446] This invention is a system that analyzes program code entered by a user and makes improvement suggestions, and also has the function of recognizing the user's emotions and adjusting the feedback. The basic components of this system are a terminal operated by the user, a server that handles central processing, a generation AI that analyzes the program code and generates improvement suggestions, and an emotion engine that recognizes the user's emotional state.

[2447] Basic System Configuration

[2448] User-side configuration

[2449] 1. User: Operates a device on which programming learning software is installed.

[2450] 2. Terminal: A computer or mobile device that runs programming learning software and has an input interface, a display interface, network connectivity, and a camera and microphone for emotion recognition.

[2451] Server-side configuration

[2452] 1. Server: This is the central server that processes requests from users, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[2453] 2. Generative AI: Artificial intelligence that analyzes received program code and generates improvement suggestions, including natural language processing (NLP) engines and coding style analysis engines.

[2454] 3. Emotion engine: A system that analyzes the user's facial expressions and voice to recognize their emotional state and adjust feedback accordingly.

[2455] Analysis of program code and improvement suggestions

[2456] In this system, the user's device sends the program code they enter into the coding area to the server. The server then passes the received code to the generation AI, which analyzes it and generates improvement suggestions. The generated improvement suggestions are adjusted according to the user's skill level, and the adjusted suggestions and the reasons for the adjustments are sent to the user's device.

[2457] Emotion recognition and feedback regulation

[2458] The device sends the user's facial and voice data to the emotion engine, which analyzes it to recognize the user's emotional state. The server then further adjusts the improvement suggestions based on the user's emotional state. For example, if the user is feeling stressed, the difficulty level may be reduced or detailed explanations may be added.

[2459] Examples and prompts

[2460] If the user enters the following Python code:

[2461] for i in range(10):

[2462] print(i)

[2463] The server uses generative AI to generate improvement suggestions such as the following, which are adjusted according to the user's skill level and emotional state:

[2464] Recommended way: More Pythonic way

[2465] for i in range(10):

[2466] print(f"{i}")

[2467] Why: String formatting improves code readability.

[2468] Also, enter the following prompt for the generated AI:

[2469] Analyze user-supplied code, check if it is optimized, and generate any suggestions for improvement. Here is the input code:

[2470] for i in range(10):

[2471] print(i)

[2472] In this way, the system of the present invention provides a learning environment for users to efficiently improve their programming skills. Real-time feedback and personalized adjustments based on emotion recognition allow users to learn effectively at their own pace.

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

[2474] Step 1:

[2475] The user starts the programming learning software and enters the required authentication information on the login screen.

[2476] Specifically, the user double-clicks the software icon to start it and enters a user name and password.

[2477] Input: Username, Password

[2478] Output: None

[2479] Step 2:

[2480] The user clicks the login button.

[2481] The user clicks the "Login" button and the entered authentication information is sent to the server.

[2482] Input: Login button click event, authentication information

[2483] Output: Authentication request

[2484] Step 3:

[2485] The server receives the authentication information and accesses the user management database to perform authentication.

[2486] The server compares the authentication information it receives with the registration information in the database, and if authentication is successful, obtains the profile information.

[2487] Input: Credentials

[2488] Output: Authentication results, profile information

[2489] Step 4:

[2490] When a user logs in for the first time, he or she enters the skill level into a self-evaluation form and sends it to the server.

[2491] The user enters their skill level in the displayed self-assessment form and clicks the "Submit" button.

[2492] Input: Skill level, Send button click event

[2493] Output: Skill level information

[2494] Step 5:

[2495] The server stores the received skill level information in a user profile.

[2496] The server stores the skill level information in a database and updates the profile information.

[2497] Input: Skill level information

[2498] Output: Updated profile information

[2499] Step 6:

[2500] The user inputs the program code into the coding area of ​​the learning platform.

[2501] The user enters the following code into the coding area:

[2502] for i in range(10):

[2503] print(i)

[2504] Input: Program code

[2505] Output: The code entered

[2506] Step 7:

[2507] The user clicks the "Go" button.

[2508] The user clicks the "Run" button to send the entered code to the server.

[2509] Input: Click event of the Run button, program code

[2510] Output: Code analysis request

[2511] Step 8:

[2512] The server sends the received code to the generation AI.

[2513] The server passes the code to a generative AI model, instructing it to analyze the code and generate improvement suggestions.

[2514] Input: Program code, analysis request

[2515] Output: analysis results, improvement suggestions

[2516] Step 9:

[2517] Generative AI analyzes the code and generates improvement suggestions.

[2518] The generative AI analyzes the structure and content of the code and creates prompts that generate improvement suggestions.

[2519] Input: Program code

[2520] Output: Improvement suggestions

[2521] example:

[2522] Recommended way: More Pythonic way

[2523] for i in range(10):

[2524] print(f"{i}")

[2525] Why: String formatting improves code readability.

[2526] Step 10:

[2527] The server adjusts the generated improvement suggestions according to the user's skill level.

[2528] The server tailors the suggestions to suit the user's skill level, adding detailed explanations for beginners, for example.

[2529] Input: improvement suggestions, skill level information

[2530] Output: Adjusted improvement suggestions

[2531] Step 11:

[2532] The device sends the user's facial expressions and voice data to the emotion engine.

[2533] The camera and microphone connected to the device capture the user's facial expressions and voice and send them to the emotion engine.

[2534] Input: facial expression data, voice data

[2535] Output: Sending emotion data

[2536] Step 12:

[2537] An emotion engine analyzes the user's emotional state.

[2538] The emotion engine uses facial expression and voice analysis algorithms to recognize the user's emotional state.

[2539] Input: facial expression data, voice data

[2540] Output: Emotional state

[2541] Step 13:

[2542] The server adjusts the improvement suggestions based on the emotional state.

[2543] Based on the data from the emotion engine, the server reduces the difficulty of improvement suggestions or adds detailed explanations.

[2544] Input: Emotional state, improvement suggestions

[2545] Output: Finalized improvement proposals

[2546] Step 14:

[2547] The server transmits the adjusted improvement proposal to the user terminal.

[2548] The server sends the finalized proposal and the reasons for it to the user's terminal.

[2549] Input: Finalized improvement proposal

[2550] Output: Submit proposal

[2551] Step 15:

[2552] The terminal displays the suggestion and the reason to the user.

[2553] The device displays the content of the proposal and the reason for it on the screen, allowing the user to intuitively understand the content of the proposal.

[2554] Input: Submit Proposal

[2555] Output:Suggestion display

[2556] Step 16:

[2557] The user modifies the code based on the suggestions.

[2558] The user modifies the code based on the suggestions and clicks the "Run" button again.

[2559] Input: Proposal content, correction code

[2560] Output: Modified code

[2561] Step 17:

[2562] The server re-analyzes the modified code and records and saves the code change history and improvement proposal history.

[2563] The server passes the corrected code back to the generation AI and saves it as history in the database along with the analysis results.

[2564] Input: Correction Code

[2565] Output: Analysis results, saving of change history

[2566] Step 18:

[2567] The server manages the user's learning progress, generates additional feedback and next learning suggestions, and sends them to the device.

[2568] The server suggests the next step based on the data accumulated, and continuously supports the user's learning progress.

[2569] Input: Change history, improvement proposal history

[2570] Output: Next learning suggestions, feedback

[2571] This allows the entire system to effectively support users in learning programming.

[2572] (Application example 2)

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

[2574] While conventional program code improvement systems provide appropriate feedback according to the user's skill level, they do not take into account the user's emotional state, making it difficult to provide effective improvement suggestions when the user is feeling stressed or losing confidence.In addition, because factory robot programming requires high accuracy and efficiency, it is necessary to reduce the stress and fatigue that engineers feel during development and improve productivity.

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

[2576] In this invention, the server includes means for receiving program code entered by a user, means for using a generation AI to analyze the received program code and generate improvement suggestions, means for adjusting the generated improvement suggestions according to the user's skill level, means for managing the user's learning progress by saving the user's code change history and improvement suggestion history, means for recognizing the user's emotional state and adjusting feedback, and means for analyzing the user's facial expressions and voice using a smart device to acquire the user's emotional state. This makes it possible to provide appropriate feedback according to the user's emotional state, reducing stress and fatigue felt by the user and improving the programming productivity of factory robots.

[2577] "User" means a person who uses the system to input and improve program code.

[2578] "Program code" is a set of instructions that a computer executes to perform a particular operation.

[2579] "Generative AI" is an artificial intelligence technology used to analyze received program code and generate improvement suggestions.

[2580] "Improvement suggestions" are suggestions for improving the quality of the code that the generation AI presents after analyzing the received program code.

[2581] "Skill level" is an index that indicates the degree of a user's programming ability and knowledge.

[2582] The "code change history" is a record of changes made by the user to the program code.

[2583] "Improvement proposal history" is a record of improvement proposals presented to the user by the generation AI.

[2584] "Study progress" indicates the degree of growth and achievement of the user as they progress through their programming studies.

[2585] "Emotional state" refers to a user's current mental or emotional state.

[2586] "Feedback" refers to advice and comments provided by the system regarding the program code entered by the user.

[2587] A "smart device" is an electronic device that has the ability to recognize a user's facial expressions and voice and acquire their emotional state.

[2588] "Facial expression" refers to the emotions and psychological state that are revealed through the user's facial movements and expressions.

[2589] "Voice" refers to the emotions and psychological state that are expressed through the user's voice and speaking style.

[2590] This invention is a system that analyzes a user's program code and makes suggestions for improvements when programming factory robots. This system uses generative AI to analyze program code and make suggestions for improvements, adjusts feedback by recognizing the user's emotions, and provides appropriate feedback according to the user's skill level. It also has the function of saving the user's code change history and improvement suggestion history and managing learning progress. Furthermore, it optimizes the programming environment by recognizing the user's emotional state and adjusting feedback.

[2591] Basic System Configuration

[2592] User-side configuration

[2593] 1. User: Operates the device on which the software is installed.

[2594] 2. Device: A computer or smartphone running programming learning software, equipped with an input interface, display interface, network connectivity, and a camera and microphone for emotion recognition.

[2595] Server-side configuration

[2596] 1. Server: A central server that processes user requests, receives and analyzes program code, generates improvement suggestions, manages user profiles, and manages learning progress.

[2597] 2. Generative AI: Artificial intelligence for analyzing program code and suggesting improvements. Includes a natural language processing (NLP) engine and a coding style analysis engine.

[2598] 3. Emotion Engine: A system for recognizing the user's emotional state and adjusting feedback. It analyzes data obtained through the camera and microphone.

[2599] Analysis of program code and improvement suggestions

[2600] Initial Setup and Login

[2601] 1. The user launches the programming learning software and enters the required authentication information on the login screen.

[2602] 2. The server receives the authentication information and accesses the user management database to perform authentication. If authentication is successful, the server retrieves the user's profile information.

[2603] 3. When the user logs in for the first time, they enter their skill level in a self-assessment form, which is then sent to the server.

[2604] 4. The server stores the received skill level information in the user profile and centrally manages the user's learning progress.

[2605] Code entry ...

Claims

1. means for receiving program code entered by a user; A means using a generative AI that analyzes the received program code and generates improvement suggestions; means for adjusting the generated improvement suggestions according to the skill level of the user; means for transmitting the adjusted improvement proposal and the reason for the proposal to the user's terminal; A means to manage learning progress by storing the user's code change history and improvement proposal history; A system including:

2. The system according to claim 1, further comprising means for analyzing the program code using natural language processing in the analysis by the generative AI.

3. 2. The system according to claim 1, further comprising means for acquiring a user's skill level as a self-evaluation form at the first login and storing the acquired skill level in a profile.

Images