system

Abstract

We provide the system. [Solution] A means of receiving conversion requests from users, A means for converting input program code into a specified programming language using a natural language processing model, A means of proposing multiple checking methods for converted program code, A means of verifying the accuracy of the program code by performing the proposed checking method, A means of instructing the program code to be modified based on the check results, A system that includes this.

Description

Technical Field

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

Background Art

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

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] When converting program code from one programming language to another, it is difficult to ensure that the code generated by a natural language processing model is accurate. Therefore, in order to confirm the accuracy of the converted program, a final confirmation by a human is required, which is a factor reducing business efficiency. Also, when the generated code is inaccurate, corrections are required, leading to further consumption of time and labor. There is a need to address these problems and provide a process for more efficiently generating accurate program code.

Means for Solving the Problems

[0005] This invention provides a system that, based on a program language conversion request received from a user, converts program code using a natural language processing model and then automatically proposes multiple checking methods for the converted code. By executing the proposed checking methods to verify the accuracy of the program code and repeatedly correcting the code as needed, it is possible to minimize the need for final verification by the user. This system improves the accuracy of the generated program code by using checking means including syntax checking, type checking, and functional testing.

[0006] A "user" refers to an individual or organization that makes specific requests or demands to a system.

[0007] A "conversion request" refers to a request to convert the source code of a program from one programming language to another.

[0008] A "natural language processing model" is a type of artificial intelligence designed to understand and generate text data, and it combines various algorithms and techniques to perform specific tasks such as program transformation.

[0009] "Program code" refers to a series of instructions written for the purpose of causing a computer to perform a specific action.

[0010] "Proposed means" refers to the process of outlining possible methods and measures to achieve a certain objective.

[0011] "Accuracy" refers to the degree to which a process or result meets the expected standard without error.

[0012] "Checking methods" refer to the procedures and criteria used to evaluate the accuracy and efficiency of program code.

[0013] "Correction instructions" refer to the act of indicating improvements to resolve detected errors or problems.

[0014] "Syntax checking" refers to the procedure of verifying whether the format and notation of program code are correctly written in accordance with the language specification.

[0015] "Type checking" refers to the procedure of verifying whether the data types used within a program are appropriate.

[0016] "Functional testing" refers to testing methods used to verify that a program operates as intended and produces the correct results. [Brief explanation of the drawing]

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

Mode for Carrying Out the Invention

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

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

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

[0021] In the following embodiments, a numbered RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a work memory by the processor. <00​In the following embodiments, the signed storage is one or more non-volatile storage devices that store various programs and various parameters. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), or magnetic tapes.

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

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

[0025] [First Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0038] The present invention comprises a process in which a user requests the conversion of program code, and a system processes that request to ultimately generate highly accurate program code. The user uses a terminal to request the server to convert code written in a specific programming language. For example, a user can send a request to convert a list manipulation program written in Python to JavaScript®.

[0039] The server receives this request and performs the requested transformation using a natural language processing model. Once the transformation is complete, the server reuses the natural language processing model and suggests several checks to verify the accuracy of the generated program code.

[0040] The server sends the proposed checking method to the terminal, and based on the results, the terminal checks various aspects of the program code. First, a syntax check is performed, followed by a type check. If this is successful, a functional test is then performed to confirm that the program works as expected.

[0041] If the check reveals an error, the terminal reports the details to the server. The server then uses the natural language processing model again to correct the program code and undergoes another check. This cycle of correction and checking is repeated until all conditions are met.

[0042] For example, when a user converts a Python program to JavaScript, type mismatches may be discovered during the first conversion. In this case, the server attempts to correct them and continues correcting until the type checks pass. In this way, the user can obtain accurate program code with minimal intervention.

[0043] The following describes the processing flow.

[0044] Step 1:

[0045] The user sends a program code conversion request to the server using their terminal. This request includes the original program language and the converted program language.

[0046] Step 2:

[0047] The server parses the request received from the user and uses a natural language processing model to translate the specified program code into the target language. The translated code is temporarily stored.

[0048] Step 3:

[0049] The server again uses the natural language processing model and proposes several checks to verify the accuracy of the translated program code. This list of checks includes syntax checking, type checking, and functional testing.

[0050] Step 4:

[0051] The server sends the proposed checking method to the terminal, which first performs a syntax check. The syntax check verifies whether the program adheres to the language's grammatical rules.

[0052] Step 5:

[0053] If the syntax check is successful, the terminal then performs a type check. The type check verifies that the data types used in the program are appropriate.

[0054] Step 6:

[0055] If no problems are found during type checking, the terminal will run a functional test. The functional test verifies that the converted program works as expected.

[0056] Step 7:

[0057] If any of the checks find a problem, the terminal reports the error details to the server. The server then requests a fix from the natural language processing model and modifies the code again.

[0058] Step 8:

[0059] The corrected code is sent back to the terminal and the checking process starts again from step 4. This cycle continues until all checks are successful.

[0060] Step 9:

[0061] After all checks have passed, the server notifies the user of the successful program code and provides the completed code.

[0062] (Example 1)

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

[0064] Converting between programming languages ​​manually is time-consuming and labor-intensive, and prone to conversion errors and inconsistencies. Furthermore, verifying the accuracy of the converted program code requires advanced expertise, increasing the workload of programmers. Conventional technologies have limited means of automating and accurately performing these tasks, thus necessitating new solutions.

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

[0066] In this invention, the server includes means for receiving input data conversion requests from a user, means for converting the input program description into a specified description language using a language processing model, means for proposing multiple verification methods for the converted program description, means for verifying the accuracy of the program description by executing the proposed verification methods, and means for instructing modifications to the program description based on the verification results. This makes it possible to automatically, accurately, and quickly convert program code and verify the accuracy of the conversion.

[0067] "Means for receiving input data conversion requests from users" refers to a mechanism for a server to receive program code conversion requests made by users via a terminal.

[0068] A "language processing model" is an algorithm that uses natural language processing techniques to convert the language in which a program is written into a different language.

[0069] A "program description" is a set of instructions written using a specific programming language, in a form that can be executed by a computer.

[0070] "Means for converting to a specified description language" refers to a mechanism that executes a process for replacing an input program description with another programming language.

[0071] "Means of proposing multiple verification methods" refers to a mechanism that presents multiple verification processes, including syntax checking and type checking, to ensure the accuracy and consistency of the converted program description.

[0072] "Means for verifying the accuracy of the program description by performing the proposed verification method" refers to a mechanism that uses a server or terminal to execute the proposed verification process and determine whether the program description has been correctly converted.

[0073] "Means for instructing program description modifications based on verification results" refers to a mechanism that instructs the server to modify the program description to address problems identified based on the verification results.

[0074] "Means for verifying the accuracy of generated code and providing a verification process including syntax checking, type checking, and functionality evaluation" refers to a set of procedures for checking the transformed code for syntactic errors and data type consistency, and for testing whether the code works as intended.

[0075] This invention relates to a system that automates the process of converting program code between different programming languages ​​using a terminal, generating code with a high degree of accuracy. Specifically, the user sends a program code conversion request from the terminal to a server. In this case, if the user wants to convert code written in Python to JavaScript, the user can enter a prompt such as "Please convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)".

[0076] The server receives the request and performs the transformation using a language processing model. The generative AI model used here is, for example, an open-source natural language processing framework. The server provides verification processes for the transformed code, such as syntax checking and type checking. For example, the server uses a parsing tool to check whether the transformed JavaScript code has correct syntax.

[0077] Next, the server suggests a checking method to the terminal, and the user uses the terminal to execute that method. In addition to syntax and type checking, the user runs test cases to verify that the functions of the converted program work as expected.

[0078] If errors or inconsistencies are detected, the terminal sends this information to the server, which then attempts to correct them using the generated AI model again. This process is repeated until all conditions are met, allowing the user to receive accurate program code with minimal intervention.

[0079] This enables efficient code conversion between different programming languages, significantly reducing the user's workload. This system provides a means to effectively utilize valuable development resources, even without advanced programming knowledge.

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

[0081] Step 1:

[0082] The user uses a terminal to create a request to convert code written in Python to JavaScript. The input provided by the user is a prompt, which might look like this: "Convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)". The conversion process begins when the terminal sends this input to the server.

[0083] Step 2:

[0084] The server parses the prompt message received from the terminal. The input arrives at the server in the form of a prompt message, and the server initializes its language processing model. As a result of the analysis, the server identifies the target language (in this case, Python) and the destination language (JavaScript). As part of the data processing, the generative AI model is set up.

[0085] Step 3:

[0086] The server uses a language processing model to perform the transformation of the specified program description. It parses the input Python code and performs data processing to generate code that conforms to JavaScript syntax. At this point, the output is the transformed JavaScript code. As a concrete example of the output, the sum_list function is transformed into "function sumList(lst) { return lst.reduce((a, b) => a + b, 0);}".

[0087] Step 4:

[0088] The server proposes several verification methods for the converted program code. These include syntax checking, type checking, and functionality evaluation. The input is the converted JavaScript code, and the output is a list of recommended verification processes. The server prepares the code for the checks to be performed using its parsing and type checking tools.

[0089] Step 5:

[0090] The terminal executes a process to verify the accuracy of the program code based on the verification suggestions received from the server. The input is the verification method and conversion code, and the output is the verification result. For example, the terminal evaluates whether the JavaScript syntax is correct, whether the types match, and whether it functions correctly. It applies test cases and verifies whether the program behaves as expected.

[0091] Step 6:

[0092] If an error is found during the check, the terminal reports the error details to the server. The input is the error report, and the output is the correction instruction. Specifically, by providing detailed information about what went wrong at each step, the server can adjust the processing in the next step.

[0093] Step 7:

[0094] Based on the error information received, the server attempts to correct the program code again using the generated AI model. The input is the error information, and the output is the corrected code. This generates a new output, and the verification process described above is repeated. This cycle continues until all conditions are met.

[0095] (Application Example 1)

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

[0097] In today's information processing environments, there is a demand for seamless conversion and efficient use of code across different information processing devices and platforms. However, code conversion between multiple languages ​​presents numerous technical challenges, particularly in maintaining accuracy and efficient checking processes. Furthermore, optimization for performing this in real time on mobile devices is lacking.

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

[0099] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for proposing a plurality of checking methods for the converted program code. This makes it possible to optimize application processing between different information processing devices in real time and to convert code efficiently and accurately.

[0100] "Means for receiving conversion requests from users" refers to an interface for users to request conversion from one programming language to another, and a mechanism for processing such requests.

[0101] "A means of converting input program code into a specified programming language using a natural language processing model" refers to a process that utilizes machine learning algorithms to convert given source code into another programming language, and the mechanism for executing that process.

[0102] "A means of proposing multiple checking methods for converted program code" refers to a mechanism that presents users with multiple verification methods to verify the accuracy and efficiency of the generated code.

[0103] "Means for verifying the accuracy of program code by performing the proposed checking method" refers to a process and apparatus for verifying whether a program operates correctly based on the indicated testing method.

[0104] "A means of instructing program code modifications based on check results" refers to a system that issues instructions to correct errors and defects discovered through verification.

[0105] "Means for optimizing application processing between different information processing devices in a mobile information terminal in real time" refers to a system that dynamically adjusts the execution efficiency of programs on different computing devices and environments on a mobile device.

[0106] The system that realizes this application is a platform for efficiently converting and optimizing program code between multiple information processing devices. Users use a mobile device to send conversion requests. Requests received from the device are sent to a server, which processes them.

[0107] The server utilizes a natural language processing model based on TENSORFLOW® to convert a given input code into a specified programming language. The converted code is then checked for syntax, type, and functionality using tools such as Mocha, and corrective actions are taken if problems are found. The server repeats this process until it generates accurate code.

[0108] Mobile information terminals provide users with an interface through applications developed using Flutter®. These applications optimize real-time application processing and enable seamless collaboration between various information processing devices.

[0109] As a concrete example, if a user writes a Python script for a purchase process using a QR code (registered trademark), a prompt will be sent to convert that code to JavaScript so that it can be used on different platforms. An example of the prompt message is as follows:

[0110] "Please convert the QR code scanning purchase processing code written in Python so that it can be used in a JavaScript environment. Please perform as many checks as possible on the syntax, types, and functionality."

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

[0112] Step 1:

[0113] The user uses a mobile device to request the conversion of program code through an interface. The input is a QR code scanning purchase processing code written in Python, and the output is the conversion request information. The user specifies that they want the code to be available as JavaScript by entering a prompt within the app.

[0114] Step 2:

[0115] The terminal sends the generated conversion request information to the server. The server receives this information and parses the request. The input is the conversion request information, and the output is the parsing result. Based on this parsing, the server determines the specific steps to proceed with the conversion.

[0116] Step 3:

[0117] The server uses a natural language processing model running on TensorFlow to convert Python code into specified JavaScript code. The input is the parsed request and the original Python code, and the output is the converted JavaScript code. Data processing and calculations are performed by this natural language processing model.

[0118] Step 4:

[0119] The server first checks the syntax of the generated JavaScript code. The input is the converted JavaScript code, and the output is the result of the syntax check. Correction instructions are given as needed until the syntax is correct.

[0120] Step 5:

[0121] The server then performs type checking. The input is JavaScript code that has passed syntax checking, and the output is the result of type checking. It verifies that the expected data types match the actual data types, and attempts to correct any type mismatches found.

[0122] Step 6:

[0123] The server uses the Mocha testing framework to perform functional tests on the code. The input is type-checked JavaScript code, and the output is the result of the functional tests. Corrections and retests are repeated as needed until the tests pass.

[0124] Step 7:

[0125] After the server confirms that all checks have passed, it sends the completed JavaScript code back to the terminal. The terminal receives this code and notifies the user. The input is the JavaScript code that passed the functional tests, and the output is the final code and the notification.

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

[0127] This invention is a system for recognizing user emotions and optimizing the program conversion process. The system begins by receiving a conversion request entered by the user via a terminal. For example, if a user wants to convert a program written in Python to JavaScript, the server receives this request.

[0128] Next, the server uses a natural language processing model to translate the specified program code into the target language. For the translated program code, the server proposes several checking methods, including syntax checking, type checking, and functional testing. This verifies the accuracy of the program code, and if any problems are found, the natural language processing model is called again to instruct the code to be corrected.

[0129] A notable aspect here is the use of an emotion engine. The server uses the emotion engine to evaluate the user's emotional state. Based on this evaluation, the transformation and correction process is dynamically adjusted. For example, if the server determines that the user is feeling frustrated, it can provide the user with more detailed debugging information and guidance. In this way, the user experience is improved, and as a result, the efficiency of program transformation is also improved.

[0130] For example, when a user converts code that involves complex data processing, it may require more steps than usual. In this case, the user may become frustrated if they are asked to make multiple corrections. The emotion engine quickly recognizes these emotions, and the server provides appropriate support to ensure a smooth process.

[0131] Thus, the present invention provides a means to optimize each stage of program conversion according to the user's emotions and improve the quality of the user experience.

[0132] The following describes the processing flow.

[0133] Step 1:

[0134] The user sends a program conversion request to the server via their terminal. This request includes the original programming language and the target programming language.

[0135] Step 2:

[0136] The server parses the received request and uses a natural language processing model to translate the original program code into the specified language. The translated code is temporarily stored.

[0137] Step 3:

[0138] The server utilizes an emotion engine to evaluate the user's emotional state in real time. User stress levels and satisfaction levels are used as evaluation criteria.

[0139] Step 4:

[0140] The server proposes several methods for checking the converted program code. These methods include syntax checking, type checking, and functional testing.

[0141] Step 5:

[0142] The terminal executes the checks suggested by the server and verifies the program code. If errors are found during verification, it collects detailed error messages.

[0143] Step 6:

[0144] The device reports the verification results to the server. The server also considers the results of the emotion engine and adjusts the content and format of the feedback according to the user's emotions.

[0145] Step 7:

[0146] The server will call the natural language processing model again based on the error message and attempt to correct the generated code. It will also provide additional guidance and help to the user as needed.

[0147] Step 8:

[0148] The corrected code is sent back to the terminal and enters the checking process again. This loop continues until all validations are successful.

[0149] Step 9:

[0150] Once all processes are complete, the server notifies the user of the final result, and the user can receive the exact program code.

[0151] (Example 2)

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

[0153] Conventional program code conversion systems have faced challenges in reducing errors that occur during code conversion and the psychological burden on users. In particular, when multiple corrections and checks are required, users are prone to frustration, and the efficiency of the conversion process decreases. Solutions to these problems are needed.

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

[0155] In this invention, the server includes means for receiving conversion requests from an information input device, means for converting input software code into a specified programming language using a generation AI model, and means for evaluating the emotional state of the user of the information input device using an emotion analysis engine and adjusting the conversion and modification process. This makes it possible to provide optimal support according to the user's emotions, reduce frustration that occurs during the code conversion process, and improve the efficiency of the conversion.

[0156] An "information input device" is a device used by a user to input a request for program code conversion.

[0157] A "conversion request" is an instruction that includes a user's request to convert code from one programming language to another.

[0158] A "generative AI model" is an artificial intelligence model that uses natural language processing technology to convert software code into another programming language.

[0159] "Software code" refers to text written in a language that describes the instructions and processes that make up a computer program.

[0160] A "programming language" is a language used to give instructions to a computer, and it is based on a specific syntax and set of rules.

[0161] A "verification method" is a procedure used to confirm the accuracy and functionality of the converted software code.

[0162] An "emotion analysis engine" is a system that evaluates the user's psychological state and enables adaptive feedback based on that evaluation.

[0163] "Support" refers to assistance and information provided to enable users to perform code conversion smoothly.

[0164] The embodiments for carrying out the present invention are shown below.

[0165] The user uses a terminal to input a program that requires software code conversion. The input information is sent to a server, where processing begins. The server receives the conversion request from the information input device and then uses a generating AI model to convert the original program code into another programming language. This process employs natural language processing technology, with the AI ​​model appropriately interpreting the grammar and meaning of the code to perform the conversion.

[0166] The server further performs syntactic analysis, type checking, and functional testing to ensure the accuracy of the converted code. This verifies that the program code works as intended. If any problems are found during the verification phase, the server uses the generated AI model again to correct or improve the code.

[0167] The server also uses an emotion analysis engine to assess the user's emotional state. Based on this assessment, it adjusts the conversion process and feedback to provide the user with optimal support. This allows users to achieve their goals more efficiently while reducing the stress of code conversion.

[0168] For example, if a user wants to convert a data analysis program written in Python to JavaScript, a prompt such as "Please convert the data analysis program written in Python to JavaScript" would be used. This system achieves rapid and accurate program conversion by effectively combining a generative AI model and an emotion analysis engine.

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

[0170] Step 1:

[0171] The user enters a request to convert software code via a terminal. A specific prompt might read, "Please convert a data analysis program written in Python to JavaScript." This input prompt is sent from the terminal to the server, which then receives it.

[0172] Step 2:

[0173] The server initiates a process to analyze the received transformation request. Here, it determines which generative AI model to use based on the prompt text received from the user. The criteria for this decision include the target software language and the complexity of the code. As a result of the analysis, an appropriate generative AI model is selected.

[0174] Step 3:

[0175] The server uses a generative AI model to convert the input software code into a specified programming language. The generative AI model employs natural language processing techniques to understand the code's structure and convert it to a different syntax. The output at this stage is the initial converted code written in the target programming language.

[0176] Step 4:

[0177] The server performs a series of verifications on the converted code, including syntax analysis, type checking, and functional testing. The input is the initial converted code generated in step 3. The verification process confirms that the code functions correctly through variation tests and other methods, and outputs a verification report as a result.

[0178] Step 5:

[0179] The server reuses the generated AI model to correct problems found during the verification process. The input consists of an error report based on the verification results and the initial conversion code. The server performs error correction and optimization processes and outputs the improved code.

[0180] Step 6:

[0181] The server uses an emotion analysis engine to assess the user's emotional state. If it determines that the user is feeling frustrated, the server provides code debugging information and additional guidance as needed. The input is user response data, and the output is a user emotional state report and accompanying appropriate support information.

[0182] Step 7:

[0183] The server returns the final improved code and related support information to the user. The final output provides accurate and functional code in the target programming language, along with user-friendly feedback.

[0184] (Application Example 2)

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

[0186] Conventional program conversion systems provided a uniform conversion process without considering the user's emotions. Therefore, they failed to alleviate the stress and frustration users experienced during program conversion operations, potentially compromising the user experience. This invention aims to improve user operational efficiency and create a more comfortable program conversion experience by providing a program conversion process optimized according to the user's emotional state.

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

[0188] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for acquiring the user's visual and auditory information and evaluating the user's emotional state. This makes it possible to dynamically adjust the conversion process according to the user's emotions and provide support information appropriate to the user.

[0189] A "user" is someone who operates an information processing system and utilizes specific services or functions.

[0190] A "conversion request" is a request from a user to convert input program code into another programming language.

[0191] A "natural language processing model" is an artificial intelligence model designed to analyze text information and perform specific tasks.

[0192] "Input program code" refers to the code of a computer program that the user wishes to convert.

[0193] "Specified programming language" refers to the target programming language that the user specifies they want to convert the input code to.

[0194] "Visual information" refers to information about the user's face and facial expressions, and is data acquired using devices such as cameras.

[0195] "Voice information" refers to voice data emitted by the user, which is acquired using devices such as microphones.

[0196] "Emotional state" refers to the emotions a user is feeling at a particular moment, and is evaluated using an emotion engine.

[0197] A "conversion process" is a series of processing steps that convert input program code into a specified programming language.

[0198] "Support information" refers to additional information and guides provided to help users perform their tasks smoothly.

[0199] The system that implements this application optimizes the program code conversion process based on the user's emotions. The server receives conversion requests from the user terminal and processes the input program code using a natural language processing model to convert it into the specified programming language.

[0200] This system uses smartphones and wearable devices to acquire the user's visual and auditory information, and analyzes this data with an emotion engine. The emotion engine uses an emotion recognition API (e.g., a common cloud service API) to evaluate the user's emotional state.

[0201] If the server determines that a user is experiencing frustration with the operation, it dynamically adjusts the translation process to provide the most appropriate support information for the user. Specifically, it improves the user experience by providing a simpler interface, detailed debugging information, and additional support guides.

[0202] For example, if a user fails to convert code multiple times, the emotion engine will quickly sense the user's emotions, and the system will display a pop-up guiding them with hints for improvement and steps to success. Examples of prompts can also be provided, such as, "Analyze the user's camera footage and audio, and determine their emotions using a common cloud service's emotion recognition API," and "If the user is stressed, simplify the in-app interface and display guidance."

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

[0204] Step 1:

[0205] The user creates a request to convert program code to another programming language via their terminal and sends it to the server. The input data includes the source code (e.g., Python code) and the target language. Based on this input information, the server receives the conversion request.

[0206] Step 2:

[0207] The server uses a natural language processing model to convert the received input program code into a specified language (e.g., JavaScript). The input consists of the program code and the target language within the conversion request, and the output is the converted program code. As a data operation, code conversion processing is performed using an API.

[0208] Step 3:

[0209] The server sends the user's visual information (camera footage) and audio information (audio data) obtained from the terminal to an emotion recognition API to evaluate their emotional state. The input to this process is video and audio data, and the output is information about the user's emotional state. Data processing includes image analysis and audio analysis.

[0210] Step 4:

[0211] Based on the emotional state, the server dynamically adjusts the transformation process. If stress or frustration is detected, the server sends debugging information, guidance, or a different interface to the terminal. The input is the emotional state, and the output is supportive information or a change in the interface.

[0212] Step 5:

[0213] The user continues the conversion process using the adjusted information. They optimize their operation by utilizing the support information and interface displayed on the terminal. This improves the user experience and allows for a smoother process. The input is the support information provided by the server, and the output is the streamlining of user operations.

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

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

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

[0217] [Second Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0230] This invention comprises a process in which a user requests the conversion of program code, and a system processes that request to ultimately generate highly accurate program code. The user uses a terminal to request the server to convert code written in a specific programming language. For example, a user can send a request to convert a list manipulation program written in Python to JavaScript.

[0231] The server receives this request and performs the requested transformation using a natural language processing model. Once the transformation is complete, the server reuses the natural language processing model and suggests several checks to verify the accuracy of the generated program code.

[0232] The server sends the proposed checking method to the terminal, and based on the results, the terminal checks various aspects of the program code. First, a syntax check is performed, followed by a type check. If this is successful, a functional test is then performed to confirm that the program works as expected.

[0233] If the check reveals an error, the terminal reports the details to the server. The server then uses the natural language processing model again to correct the program code and undergoes another check. This cycle of correction and checking is repeated until all conditions are met.

[0234] For example, when a user converts a Python program to JavaScript, type mismatches may be discovered during the first conversion. In this case, the server attempts to correct them and continues correcting until the type checks pass. In this way, the user can obtain accurate program code with minimal intervention.

[0235] The following describes the processing flow.

[0236] Step 1:

[0237] The user sends a program code conversion request to the server using their terminal. This request includes the original program language and the converted program language.

[0238] Step 2:

[0239] The server parses the request received from the user and uses a natural language processing model to translate the specified program code into the target language. The translated code is temporarily stored.

[0240] Step 3:

[0241] The server again uses the natural language processing model and proposes several checks to verify the accuracy of the translated program code. This list of checks includes syntax checking, type checking, and functional testing.

[0242] Step 4:

[0243] The server sends the proposed checking method to the terminal, which first performs a syntax check. The syntax check verifies whether the program adheres to the language's grammatical rules.

[0244] Step 5:

[0245] If the syntax check is successful, the terminal then performs a type check. The type check verifies that the data types used in the program are appropriate.

[0246] Step 6:

[0247] If no problems are found during type checking, the terminal will run a functional test. The functional test verifies that the converted program works as expected.

[0248] Step 7:

[0249] If any of the checks find a problem, the terminal reports the error details to the server. The server then requests a fix from the natural language processing model and modifies the code again.

[0250] Step 8:

[0251] The corrected code is sent back to the terminal and the checking process starts again from step 4. This cycle continues until all checks are successful.

[0252] Step 9:

[0253] After all checks have passed, the server notifies the user of the successful program code and provides the completed code.

[0254] (Example 1)

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

[0256] Converting between programming languages ​​manually is time-consuming and labor-intensive, and prone to conversion errors and inconsistencies. Furthermore, verifying the accuracy of the converted program code requires advanced expertise, increasing the workload of programmers. Conventional technologies have limited means of automating and accurately performing these tasks, thus necessitating new solutions.

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

[0258] In this invention, the server includes means for receiving input data conversion requests from a user, means for converting the input program description into a specified description language using a language processing model, means for proposing multiple verification methods for the converted program description, means for verifying the accuracy of the program description by executing the proposed verification methods, and means for instructing modifications to the program description based on the verification results. This makes it possible to automatically, accurately, and quickly convert program code and verify the accuracy of the conversion.

[0259] "Means for receiving input data conversion requests from users" refers to a mechanism for a server to receive program code conversion requests made by users via a terminal.

[0260] A "language processing model" is an algorithm that uses natural language processing techniques to convert the language in which a program is written into a different language.

[0261] A "program description" is a set of instructions written using a specific programming language, in a form that can be executed by a computer.

[0262] "Means for converting to a specified description language" refers to a mechanism that executes a process for replacing an input program description with another programming language.

[0263] "Means of proposing multiple verification methods" refers to a mechanism that presents multiple verification processes, including syntax checking and type checking, to ensure the accuracy and consistency of the converted program description.

[0264] "Means for verifying the accuracy of the program description by performing the proposed verification method" refers to a mechanism that uses a server or terminal to execute the proposed verification process and determine whether the program description has been correctly converted.

[0265] "Means for instructing program description modifications based on verification results" refers to a mechanism that instructs the server to modify the program description to address problems identified based on the verification results.

[0266] "Means for verifying the accuracy of generated code and providing a verification process including syntax checking, type checking, and functionality evaluation" refers to a set of procedures for checking the transformed code for syntactic errors and data type consistency, and for testing whether the code works as intended.

[0267] This invention relates to a system that automates the process of converting program code between different programming languages ​​using a terminal, generating code with a high degree of accuracy. Specifically, the user sends a program code conversion request from the terminal to a server. In this case, if the user wants to convert code written in Python to JavaScript, the user can enter a prompt such as "Please convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)".

[0268] The server receives the request and performs the transformation using a language processing model. The generative AI model used here is, for example, an open-source natural language processing framework. The server provides verification processes for the transformed code, such as syntax checking and type checking. For example, the server uses a parsing tool to check whether the transformed JavaScript code has correct syntax.

[0269] Next, the server suggests a checking method to the terminal, and the user uses the terminal to execute that method. In addition to syntax and type checking, the user runs test cases to verify that the functions of the converted program work as expected.

[0270] If errors or inconsistencies are detected, the terminal sends this information to the server, which then attempts to correct them using the generated AI model again. This process is repeated until all conditions are met, allowing the user to receive accurate program code with minimal intervention.

[0271] This enables efficient code conversion between different programming languages, significantly reducing the user's workload. This system provides a means to effectively utilize valuable development resources, even without advanced programming knowledge.

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

[0273] Step 1:

[0274] The user uses a terminal to create a request to convert code written in Python to JavaScript. The input provided by the user is a prompt, which might look like this: "Convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)". The conversion process begins when the terminal sends this input to the server.

[0275] Step 2:

[0276] The server parses the prompt message received from the terminal. The input arrives at the server in the form of a prompt message, and the server initializes its language processing model. As a result of the analysis, the server identifies the target language (in this case, Python) and the destination language (JavaScript). As part of the data processing, the generative AI model is set up.

[0277] Step 3:

[0278] The server uses a language processing model to perform the transformation of the specified program description. It parses the input Python code and performs data processing to generate code that conforms to JavaScript syntax. At this point, the output is the transformed JavaScript code. As a concrete example of the output, the sum_list function is transformed into "function sumList(lst) { return lst.reduce((a, b) => a + b, 0);}".

[0279] Step 4:

[0280] The server proposes multiple verification methods for the converted program code. In this case, it includes syntax checking, type checking, and function evaluation. The input is the converted JavaScript code, and the output is a list of recommended verification processes. The server uses a syntax analysis tool and a type checking tool to prepare for the execution of the checks.

[0281] Step 5:

[0282] Based on the verification proposal received from the server, the terminal executes a process to confirm the accuracy of the program code. The input is the verification method and the converted code, and the output is the verification result. The terminal evaluates, for example, whether the syntax of JavaScript is correct, whether the types match, and whether it functions. Apply test cases to check whether the operation of the program is as expected.

[0283] Step 6:

[0284] If an error is found as a result of the check, the terminal reports the error details to the server. The input is the error report, and the output is a correction instruction. Specifically, by communicating in detail what went wrong at which step, the server can adjust the processing in the next step.

[0285] Step 7:

[0286] Based on the received error information, the server attempts to correct the program code by using the generated AI model again. The input is the error information, and the output is the corrected code. As a result, new output is generated, and the above-mentioned verification process is repeated. This cycle continues until all conditions are met.

[0287] (Application Example 1)

[0288] Next, Application Example 1 will be described. In the following description, the data processing device 12 is referred to as the "server", and the smart glasses 214 are referred to as the "terminal".

[0289] In today's information processing environments, there is a demand for seamless conversion and efficient use of code across different information processing devices and platforms. However, code conversion between multiple languages ​​presents numerous technical challenges, particularly in maintaining accuracy and efficient checking processes. Furthermore, optimization for performing this in real time on mobile devices is lacking.

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

[0291] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for proposing a plurality of checking methods for the converted program code. This makes it possible to optimize application processing between different information processing devices in real time and to convert code efficiently and accurately.

[0292] "Means for receiving conversion requests from users" refers to an interface for users to request conversion from one programming language to another, and a mechanism for processing such requests.

[0293] "A means of converting input program code into a specified programming language using a natural language processing model" refers to a process that utilizes machine learning algorithms to convert given source code into another programming language, and the mechanism for executing that process.

[0294] "A means of proposing multiple checking methods for converted program code" refers to a mechanism that presents users with multiple verification methods to verify the accuracy and efficiency of the generated code.

[0295] "Means for verifying the accuracy of program code by performing the proposed checking method" refers to a process and apparatus for verifying whether a program operates correctly based on the indicated testing method.

[0296] "A means of instructing program code modifications based on check results" refers to a system that issues instructions to correct errors and defects discovered through verification.

[0297] "Means for optimizing application processing between different information processing devices in a mobile information terminal in real time" refers to a system that dynamically adjusts the execution efficiency of programs on different computing devices and environments on a mobile device.

[0298] The system that realizes this application is a platform for efficiently converting and optimizing program code between multiple information processing devices. Users use a mobile device to send conversion requests. Requests received from the device are sent to a server, which processes them.

[0299] The server utilizes a natural language processing model based on TensorFlow to convert given input code into a specified programming language. The converted code is then checked for syntax, type, and functionality using tools such as Mocha, and corrective actions are taken if problems are found. The server repeats this process until it generates accurate code.

[0300] Mobile information terminals provide users with an interface through applications developed using Flutter. These applications optimize real-time application processing and enable seamless collaboration between various information processing devices.

[0301] As a specific example, when a user writes "Purchase processing by QR code scanning" in Python, a prompt is sent to convert the code into JavaScript so that it can be used on different platforms. Examples of prompt sentences are as follows:

[0302] "Please convert the Python code for QR code scanning purchase processing so that it can be used in a JavaScript environment. Please perform as many checks as possible on syntax, types, and functions."

[0303] The flow of the specific process in Application Example 1 will be described using FIG. 12.

[0304] Step 1:

[0305] The user uses a mobile information terminal to request the conversion of program code through an interface. The input is the Python code for QR code scanning purchase processing, and the output is the conversion request information. The user specifies that they want to make the code available as JavaScript by entering the prompt sentence in the app.

[0306] Step 2:

[0307] The terminal sends the generated conversion request information to the server. The server receives this information and analyzes the request content. The input is the conversion request information, and the output is the analysis result. Based on this analysis, the server determines the specific procedure for proceeding with the conversion.

[0308] Step 3:

[0309] The server uses a natural language processing model operating on TensorFlow to convert the Python code into the specified JavaScript code. The input is the analyzed request content and the original Python code, and the output is the converted JavaScript code. Data processing and operations are performed by this natural language processing model.

[0310] Step 4:

[0311] The server first checks the syntax of the generated JavaScript code. The input is the converted JavaScript code, and the output is the result of the syntax check. Correction instructions are given as needed until the syntax is correct.

[0312] Step 5:

[0313] The server then performs type checking. The input is JavaScript code that has passed syntax checking, and the output is the result of type checking. It verifies that the expected data types match the actual data types, and attempts to correct any type mismatches found.

[0314] Step 6:

[0315] The server uses the Mocha testing framework to perform functional tests on the code. The input is type-checked JavaScript code, and the output is the result of the functional tests. Corrections and retests are repeated as needed until the tests pass.

[0316] Step 7:

[0317] After the server confirms that all checks have passed, it sends the completed JavaScript code back to the terminal. The terminal receives this code and notifies the user. The input is the JavaScript code that passed the functional tests, and the output is the final code and the notification.

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

[0319] This invention is a system for recognizing user emotions and optimizing the program conversion process. The system begins by receiving a conversion request entered by the user via a terminal. For example, if a user wants to convert a program written in Python to JavaScript, the server receives this request.

[0320] Next, the server uses a natural language processing model to translate the specified program code into the target language. For the translated program code, the server proposes several checking methods, including syntax checking, type checking, and functional testing. This verifies the accuracy of the program code, and if any problems are found, the natural language processing model is called again to instruct the code to be corrected.

[0321] A notable aspect here is the use of an emotion engine. The server uses the emotion engine to evaluate the user's emotional state. Based on this evaluation, the transformation and correction process is dynamically adjusted. For example, if the server determines that the user is feeling frustrated, it can provide the user with more detailed debugging information and guidance. In this way, the user experience is improved, and as a result, the efficiency of program transformation is also improved.

[0322] For example, when a user converts code that involves complex data processing, it may require more steps than usual. In this case, the user may become frustrated if they are asked to make multiple corrections. The emotion engine quickly recognizes these emotions, and the server provides appropriate support to ensure a smooth process.

[0323] Thus, the present invention provides a means to optimize each stage of program conversion according to the user's emotions and improve the quality of the user experience.

[0324] The following describes the processing flow.

[0325] Step 1:

[0326] The user sends a program conversion request to the server via their terminal. This request includes the original programming language and the target programming language.

[0327] Step 2:

[0328] The server parses the received request and uses a natural language processing model to translate the original program code into the specified language. The translated code is temporarily stored.

[0329] Step 3:

[0330] The server utilizes an emotion engine to evaluate the user's emotional state in real time. User stress levels and satisfaction levels are used as evaluation criteria.

[0331] Step 4:

[0332] The server proposes several methods for checking the converted program code. These methods include syntax checking, type checking, and functional testing.

[0333] Step 5:

[0334] The terminal executes the checks suggested by the server and verifies the program code. If errors are found during verification, it collects detailed error messages.

[0335] Step 6:

[0336] The device reports the verification results to the server. The server also considers the results of the emotion engine and adjusts the content and format of the feedback according to the user's emotions.

[0337] Step 7:

[0338] The server will call the natural language processing model again based on the error message and attempt to correct the generated code. It will also provide additional guidance and help to the user as needed.

[0339] Step 8:

[0340] The corrected code is sent back to the terminal and enters the checking process again. This loop continues until all validations are successful.

[0341] Step 9:

[0342] Once all processes are complete, the server notifies the user of the final result, and the user can receive the exact program code.

[0343] (Example 2)

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

[0345] Conventional program code conversion systems have faced challenges in reducing errors that occur during code conversion and the psychological burden on users. In particular, when multiple corrections and checks are required, users are prone to frustration, and the efficiency of the conversion process decreases. Solutions to these problems are needed.

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

[0347] In this invention, the server includes means for receiving conversion requests from an information input device, means for converting input software code into a specified programming language using a generation AI model, and means for evaluating the emotional state of the user of the information input device using an emotion analysis engine and adjusting the conversion and modification process. This makes it possible to provide optimal support according to the user's emotions, reduce frustration that occurs during the code conversion process, and improve the efficiency of the conversion.

[0348] An "information input device" is a device used by a user to input a request for program code conversion.

[0349] A "conversion request" is an instruction that includes a user's request to convert code from one programming language to another.

[0350] A "generative AI model" is an artificial intelligence model that uses natural language processing technology to convert software code into another programming language.

[0351] "Software code" refers to text written in a language that describes the instructions and processes that make up a computer program.

[0352] A "programming language" is a language used to give instructions to a computer, and it is based on a specific syntax and set of rules.

[0353] A "verification method" is a procedure used to confirm the accuracy and functionality of the converted software code.

[0354] An "emotion analysis engine" is a system that evaluates the user's psychological state and enables adaptive feedback based on that evaluation.

[0355] "Support" refers to assistance and information provided to enable users to perform code conversion smoothly.

[0356] The embodiments for carrying out the present invention are shown below.

[0357] The user uses a terminal to input a program that requires software code conversion. The input information is sent to a server, where processing begins. The server receives the conversion request from the information input device and then uses a generating AI model to convert the original program code into another programming language. This process employs natural language processing technology, with the AI ​​model appropriately interpreting the grammar and meaning of the code to perform the conversion.

[0358] The server further performs syntactic analysis, type checking, and functional testing to ensure the accuracy of the converted code. This verifies that the program code works as intended. If any problems are found during the verification phase, the server uses the generated AI model again to correct or improve the code.

[0359] The server also uses an emotion analysis engine to assess the user's emotional state. Based on this assessment, it adjusts the conversion process and feedback to provide the user with optimal support. This allows users to achieve their goals more efficiently while reducing the stress of code conversion.

[0360] For example, if a user wants to convert a data analysis program written in Python to JavaScript, a prompt such as "Please convert the data analysis program written in Python to JavaScript" would be used. This system achieves rapid and accurate program conversion by effectively combining a generative AI model and an emotion analysis engine.

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

[0362] Step 1:

[0363] The user enters a request to convert software code via a terminal. A specific prompt might read, "Please convert a data analysis program written in Python to JavaScript." This input prompt is sent from the terminal to the server, which then receives it.

[0364] Step 2:

[0365] The server initiates a process to analyze the received transformation request. Here, it determines which generative AI model to use based on the prompt text received from the user. The criteria for this decision include the target software language and the complexity of the code. As a result of the analysis, an appropriate generative AI model is selected.

[0366] Step 3:

[0367] The server uses a generative AI model to convert the input software code into a specified programming language. The generative AI model employs natural language processing techniques to understand the code's structure and convert it to a different syntax. The output at this stage is the initial converted code written in the target programming language.

[0368] Step 4:

[0369] The server performs a series of verifications on the converted code, including syntax analysis, type checking, and functional testing. The input is the initial converted code generated in step 3. The verification process confirms that the code functions correctly through variation tests and other methods, and outputs a verification report as a result.

[0370] Step 5:

[0371] The server reuses the generated AI model to correct problems found during the verification process. The input consists of an error report based on the verification results and the initial conversion code. The server performs error correction and optimization processes and outputs the improved code.

[0372] Step 6:

[0373] The server uses an emotion analysis engine to assess the user's emotional state. If it determines that the user is feeling frustrated, the server provides code debugging information and additional guidance as needed. The input is user response data, and the output is a user emotional state report and accompanying appropriate support information.

[0374] Step 7:

[0375] The server returns the final improved code and related support information to the user. The final output provides accurate and functional code in the target programming language, along with user-friendly feedback.

[0376] (Application Example 2)

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

[0378] Conventional program conversion systems provided a uniform conversion process without considering the user's emotions. Therefore, they failed to alleviate the stress and frustration users experienced during program conversion operations, potentially compromising the user experience. This invention aims to improve user operational efficiency and create a more comfortable program conversion experience by providing a program conversion process optimized according to the user's emotional state.

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

[0380] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for acquiring the user's visual and auditory information and evaluating the user's emotional state. This makes it possible to dynamically adjust the conversion process according to the user's emotions and provide support information appropriate to the user.

[0381] A "user" is someone who operates an information processing system and utilizes specific services or functions.

[0382] A "conversion request" is a request from a user to convert input program code into another programming language.

[0383] A "natural language processing model" is an artificial intelligence model designed to analyze text information and perform specific tasks.

[0384] "Input program code" refers to the code of a computer program that the user wishes to convert.

[0385] "Specified programming language" refers to the target programming language that the user specifies they want to convert the input code to.

[0386] "Visual information" refers to information about the user's face and facial expressions, and is data acquired using devices such as cameras.

[0387] "Voice information" refers to voice data emitted by the user, which is acquired using devices such as microphones.

[0388] "Emotional state" refers to the emotions a user is feeling at a particular moment, and is evaluated using an emotion engine.

[0389] A "conversion process" is a series of processing steps that convert input program code into a specified programming language.

[0390] "Support information" refers to additional information and guides provided to help users perform their tasks smoothly.

[0391] The system that implements this application optimizes the program code conversion process based on the user's emotions. The server receives conversion requests from the user terminal and processes the input program code using a natural language processing model to convert it into the specified programming language.

[0392] This system uses smartphones and wearable devices to acquire the user's visual and auditory information, and analyzes this data with an emotion engine. The emotion engine uses an emotion recognition API (e.g., a common cloud service API) to evaluate the user's emotional state.

[0393] If the server determines that a user is experiencing frustration with the operation, it dynamically adjusts the translation process to provide the most appropriate support information for the user. Specifically, it improves the user experience by providing a simpler interface, detailed debugging information, and additional support guides.

[0394] For example, if a user fails to convert code multiple times, the emotion engine will quickly sense the user's emotions, and the system will display a pop-up guiding them with hints for improvement and steps to success. Examples of prompts can also be provided, such as, "Analyze the user's camera footage and audio, and determine their emotions using a common cloud service's emotion recognition API," and "If the user is stressed, simplify the in-app interface and display guidance."

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

[0396] Step 1:

[0397] The user creates a request to convert program code to another programming language via their terminal and sends it to the server. The input data includes the source code (e.g., Python code) and the target language. Based on this input information, the server receives the conversion request.

[0398] Step 2:

[0399] The server uses a natural language processing model to convert the received input program code into a specified language (e.g., JavaScript). The input consists of the program code and the target language within the conversion request, and the output is the converted program code. As a data operation, code conversion processing is performed using an API.

[0400] Step 3:

[0401] The server sends the user's visual information (camera footage) and audio information (audio data) obtained from the terminal to an emotion recognition API to evaluate their emotional state. The input to this process is video and audio data, and the output is information about the user's emotional state. Data processing includes image analysis and audio analysis.

[0402] Step 4:

[0403] Based on the emotional state, the server dynamically adjusts the transformation process. If stress or frustration is detected, the server sends debugging information, guidance, or a different interface to the terminal. The input is the emotional state, and the output is supportive information or a change in the interface.

[0404] Step 5:

[0405] The user continues the conversion process using the adjusted information. They optimize their operation by utilizing the support information and interface displayed on the terminal. This improves the user experience and allows for a smoother process. The input is the support information provided by the server, and the output is the streamlining of user operations.

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

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

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

[0409] [Third Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0422] This invention comprises a process in which a user requests the conversion of program code, and a system processes that request to ultimately generate highly accurate program code. The user uses a terminal to request the server to convert code written in a specific programming language. For example, a user can send a request to convert a list manipulation program written in Python to JavaScript.

[0423] The server receives this request and performs the requested transformation using a natural language processing model. Once the transformation is complete, the server reuses the natural language processing model and suggests several checks to verify the accuracy of the generated program code.

[0424] The server sends the proposed checking method to the terminal, and based on the results, the terminal checks various aspects of the program code. First, a syntax check is performed, followed by a type check. If this is successful, a functional test is then performed to confirm that the program works as expected.

[0425] If the check reveals an error, the terminal reports the details to the server. The server then uses the natural language processing model again to correct the program code and undergoes another check. This cycle of correction and checking is repeated until all conditions are met.

[0426] For example, when a user converts a Python program to JavaScript, type mismatches may be discovered during the first conversion. In this case, the server attempts to correct them and continues correcting until the type checks pass. In this way, the user can obtain accurate program code with minimal intervention.

[0427] The following describes the processing flow.

[0428] Step 1:

[0429] The user sends a program code conversion request to the server using their terminal. This request includes the original program language and the converted program language.

[0430] Step 2:

[0431] The server parses the request received from the user and uses a natural language processing model to translate the specified program code into the target language. The translated code is temporarily stored.

[0432] Step 3:

[0433] The server again uses the natural language processing model and proposes several checks to verify the accuracy of the translated program code. This list of checks includes syntax checking, type checking, and functional testing.

[0434] Step 4:

[0435] The server sends the proposed checking method to the terminal, which first performs a syntax check. The syntax check verifies whether the program adheres to the language's grammatical rules.

[0436] Step 5:

[0437] If the syntax check is successful, the terminal then performs a type check. The type check verifies that the data types used in the program are appropriate.

[0438] Step 6:

[0439] If no problems are found during type checking, the terminal will run a functional test. The functional test verifies that the converted program works as expected.

[0440] Step 7:

[0441] If any of the checks find a problem, the terminal reports the error details to the server. The server then requests a fix from the natural language processing model and modifies the code again.

[0442] Step 8:

[0443] The corrected code is sent back to the terminal and the checking process starts again from step 4. This cycle continues until all checks are successful.

[0444] Step 9:

[0445] After all checks have passed, the server notifies the user of the successful program code and provides the completed code.

[0446] (Example 1)

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

[0448] Converting between programming languages ​​manually is time-consuming and labor-intensive, and prone to conversion errors and inconsistencies. Furthermore, verifying the accuracy of the converted program code requires advanced expertise, increasing the workload of programmers. Conventional technologies have limited means of automating and accurately performing these tasks, thus necessitating new solutions.

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

[0450] In this invention, the server includes means for receiving input data conversion requests from a user, means for converting the input program description into a specified description language using a language processing model, means for proposing multiple verification methods for the converted program description, means for verifying the accuracy of the program description by executing the proposed verification methods, and means for instructing modifications to the program description based on the verification results. This makes it possible to automatically, accurately, and quickly convert program code and verify the accuracy of the conversion.

[0451] "Means for receiving input data conversion requests from users" refers to a mechanism for a server to receive program code conversion requests made by users via a terminal.

[0452] A "language processing model" is an algorithm that uses natural language processing techniques to convert the language in which a program is written into a different language.

[0453] A "program description" is a set of instructions written using a specific programming language, in a form that can be executed by a computer.

[0454] "Means for converting to a specified description language" refers to a mechanism that executes a process for replacing an input program description with another programming language.

[0455] "Means of proposing multiple verification methods" refers to a mechanism that presents multiple verification processes, including syntax checking and type checking, to ensure the accuracy and consistency of the converted program description.

[0456] "Means for verifying the accuracy of the program description by performing the proposed verification method" refers to a mechanism that uses a server or terminal to execute the proposed verification process and determine whether the program description has been correctly converted.

[0457] "Means for instructing program description modifications based on verification results" refers to a mechanism that instructs the server to modify the program description to address problems identified based on the verification results.

[0458] "Means for verifying the accuracy of generated code and providing a verification process including syntax checking, type checking, and functionality evaluation" refers to a set of procedures for checking the transformed code for syntactic errors and data type consistency, and for testing whether the code works as intended.

[0459] This invention relates to a system that automates the process of converting program code between different programming languages ​​using a terminal, generating code with a high degree of accuracy. Specifically, the user sends a program code conversion request from the terminal to a server. In this case, if the user wants to convert code written in Python to JavaScript, the user can enter a prompt such as "Please convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)".

[0460] The server receives the request and performs the transformation using a language processing model. The generative AI model used here is, for example, an open-source natural language processing framework. The server provides verification processes for the transformed code, such as syntax checking and type checking. For example, the server uses a parsing tool to check whether the transformed JavaScript code has correct syntax.

[0461] Next, the server suggests a checking method to the terminal, and the user uses the terminal to execute that method. In addition to syntax and type checking, the user runs test cases to verify that the functions of the converted program work as expected.

[0462] If errors or inconsistencies are detected, the terminal sends this information to the server, which then attempts to correct them using the generated AI model again. This process is repeated until all conditions are met, allowing the user to receive accurate program code with minimal intervention.

[0463] This enables efficient code conversion between different programming languages, significantly reducing the user's workload. This system provides a means to effectively utilize valuable development resources, even without advanced programming knowledge.

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

[0465] Step 1:

[0466] The user uses a terminal to create a request to convert code written in Python to JavaScript. The input provided by the user is a prompt, which might look like this: "Convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)". The conversion process begins when the terminal sends this input to the server.

[0467] Step 2:

[0468] The server parses the prompt message received from the terminal. The input arrives at the server in the form of a prompt message, and the server initializes its language processing model. As a result of the analysis, the server identifies the target language (in this case, Python) and the destination language (JavaScript). As part of the data processing, the generative AI model is set up.

[0469] Step 3:

[0470] The server uses a language processing model to perform the transformation of the specified program description. It parses the input Python code and performs data processing to generate code that conforms to JavaScript syntax. At this point, the output is the transformed JavaScript code. As a concrete example of the output, the sum_list function is transformed into "function sumList(lst) { return lst.reduce((a, b) => a + b, 0);}".

[0471] Step 4:

[0472] The server proposes several verification methods for the converted program code. These include syntax checking, type checking, and functionality evaluation. The input is the converted JavaScript code, and the output is a list of recommended verification processes. The server prepares the code for the checks to be performed using its parsing and type checking tools.

[0473] Step 5:

[0474] The terminal executes a process to verify the accuracy of the program code based on the verification suggestions received from the server. The input is the verification method and conversion code, and the output is the verification result. For example, the terminal evaluates whether the JavaScript syntax is correct, whether the types match, and whether it functions correctly. It applies test cases and verifies whether the program behaves as expected.

[0475] Step 6:

[0476] If an error is found during the check, the terminal reports the error details to the server. The input is the error report, and the output is the correction instruction. Specifically, by providing detailed information about what went wrong at each step, the server can adjust the processing in the next step.

[0477] Step 7:

[0478] Based on the error information received, the server attempts to correct the program code again using the generated AI model. The input is the error information, and the output is the corrected code. This generates a new output, and the verification process described above is repeated. This cycle continues until all conditions are met.

[0479] (Application Example 1)

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

[0481] In today's information processing environments, there is a demand for seamless conversion and efficient use of code across different information processing devices and platforms. However, code conversion between multiple languages ​​presents numerous technical challenges, particularly in maintaining accuracy and efficient checking processes. Furthermore, optimization for performing this in real time on mobile devices is lacking.

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

[0483] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for proposing a plurality of checking methods for the converted program code. This makes it possible to optimize application processing between different information processing devices in real time and to convert code efficiently and accurately.

[0484] "Means for receiving conversion requests from users" refers to an interface for users to request conversion from one programming language to another, and a mechanism for processing such requests.

[0485] "A means of converting input program code into a specified programming language using a natural language processing model" refers to a process that utilizes machine learning algorithms to convert given source code into another programming language, and the mechanism for executing that process.

[0486] "A means of proposing multiple checking methods for converted program code" refers to a mechanism that presents users with multiple verification methods to verify the accuracy and efficiency of the generated code.

[0487] "Means for verifying the accuracy of program code by performing the proposed checking method" refers to a process and apparatus for verifying whether a program operates correctly based on the indicated testing method.

[0488] "A means of instructing program code modifications based on check results" refers to a system that issues instructions to correct errors and defects discovered through verification.

[0489] "Means for optimizing application processing between different information processing devices in a mobile information terminal in real time" refers to a system that dynamically adjusts the execution efficiency of programs on different computing devices and environments on a mobile device.

[0490] The system that realizes this application is a platform for efficiently converting and optimizing program code between multiple information processing devices. Users use a mobile device to send conversion requests. Requests received from the device are sent to a server, which processes them.

[0491] The server utilizes a natural language processing model based on TensorFlow to convert given input code into a specified programming language. The converted code is then checked for syntax, type, and functionality using tools such as Mocha, and corrective actions are taken if problems are found. The server repeats this process until it generates accurate code.

[0492] Mobile information terminals provide users with an interface through applications developed using Flutter. These applications optimize real-time application processing and enable seamless collaboration between various information processing devices.

[0493] As a concrete example, if a user writes a Python script for a QR code scan-based purchase process, a prompt will be sent to convert that code to JavaScript so that it can be used on different platforms. An example of the prompt message is as follows:

[0494] "Please convert the QR code scanning purchase processing code written in Python so that it can be used in a JavaScript environment. Please perform as many checks as possible on the syntax, types, and functionality."

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

[0496] Step 1:

[0497] The user uses a mobile device to request the conversion of program code through an interface. The input is a QR code scanning purchase processing code written in Python, and the output is the conversion request information. The user specifies that they want the code to be available as JavaScript by entering a prompt within the app.

[0498] Step 2:

[0499] The terminal sends the generated conversion request information to the server. The server receives this information and parses the request. The input is the conversion request information, and the output is the parsing result. Based on this parsing, the server determines the specific steps to proceed with the conversion.

[0500] Step 3:

[0501] The server uses a natural language processing model running on TensorFlow to convert Python code into specified JavaScript code. The input is the parsed request and the original Python code, and the output is the converted JavaScript code. Data processing and calculations are performed by this natural language processing model.

[0502] Step 4:

[0503] The server first checks the syntax of the generated JavaScript code. The input is the converted JavaScript code, and the output is the result of the syntax check. Correction instructions are given as needed until the syntax is correct.

[0504] Step 5:

[0505] The server then performs type checking. The input is JavaScript code that has passed syntax checking, and the output is the result of type checking. It verifies that the expected data types match the actual data types, and attempts to correct any type mismatches found.

[0506] Step 6:

[0507] The server uses the Mocha testing framework to perform functional tests on the code. The input is type-checked JavaScript code, and the output is the result of the functional tests. Corrections and retests are repeated as needed until the tests pass.

[0508] Step 7:

[0509] After the server confirms that all checks have passed, it sends the completed JavaScript code back to the terminal. The terminal receives this code and notifies the user. The input is the JavaScript code that passed the functional tests, and the output is the final code and the notification.

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

[0511] This invention is a system for recognizing user emotions and optimizing the program conversion process. The system begins by receiving a conversion request entered by the user via a terminal. For example, if a user wants to convert a program written in Python to JavaScript, the server receives this request.

[0512] Next, the server uses a natural language processing model to translate the specified program code into the target language. For the translated program code, the server proposes several checking methods, including syntax checking, type checking, and functional testing. This verifies the accuracy of the program code, and if any problems are found, the natural language processing model is called again to instruct the code to be corrected.

[0513] A notable aspect here is the use of an emotion engine. The server uses the emotion engine to evaluate the user's emotional state. Based on this evaluation, the transformation and correction process is dynamically adjusted. For example, if the server determines that the user is feeling frustrated, it can provide the user with more detailed debugging information and guidance. In this way, the user experience is improved, and as a result, the efficiency of program transformation is also improved.

[0514] For example, when a user converts code that involves complex data processing, it may require more steps than usual. In this case, the user may become frustrated if they are asked to make multiple corrections. The emotion engine quickly recognizes these emotions, and the server provides appropriate support to ensure a smooth process.

[0515] Thus, the present invention provides a means to optimize each stage of program conversion according to the user's emotions and improve the quality of the user experience.

[0516] The following describes the processing flow.

[0517] Step 1:

[0518] The user sends a program conversion request to the server via their terminal. This request includes the original programming language and the target programming language.

[0519] Step 2:

[0520] The server parses the received request and uses a natural language processing model to translate the original program code into the specified language. The translated code is temporarily stored.

[0521] Step 3:

[0522] The server utilizes an emotion engine to evaluate the user's emotional state in real time. User stress levels and satisfaction levels are used as evaluation criteria.

[0523] Step 4:

[0524] The server proposes several methods for checking the converted program code. These methods include syntax checking, type checking, and functional testing.

[0525] Step 5:

[0526] The terminal executes the checks suggested by the server and verifies the program code. If errors are found during verification, it collects detailed error messages.

[0527] Step 6:

[0528] The device reports the verification results to the server. The server also considers the results of the emotion engine and adjusts the content and format of the feedback according to the user's emotions.

[0529] Step 7:

[0530] The server will call the natural language processing model again based on the error message and attempt to correct the generated code. It will also provide additional guidance and help to the user as needed.

[0531] Step 8:

[0532] The corrected code is sent back to the terminal and enters the checking process again. This loop continues until all validations are successful.

[0533] Step 9:

[0534] Once all processes are complete, the server notifies the user of the final result, and the user can receive the exact program code.

[0535] (Example 2)

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

[0537] Conventional program code conversion systems have faced challenges in reducing errors that occur during code conversion and the psychological burden on users. In particular, when multiple corrections and checks are required, users are prone to frustration, and the efficiency of the conversion process decreases. Solutions to these problems are needed.

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

[0539] In this invention, the server includes means for receiving conversion requests from an information input device, means for converting input software code into a specified programming language using a generation AI model, and means for evaluating the emotional state of the user of the information input device using an emotion analysis engine and adjusting the conversion and modification process. This makes it possible to provide optimal support according to the user's emotions, reduce frustration that occurs during the code conversion process, and improve the efficiency of the conversion.

[0540] An "information input device" is a device used by a user to input a request for program code conversion.

[0541] A "conversion request" is an instruction that includes a user's request to convert code from one programming language to another.

[0542] A "generative AI model" is an artificial intelligence model that uses natural language processing technology to convert software code into another programming language.

[0543] "Software code" refers to text written in a language that describes the instructions and processes that make up a computer program.

[0544] A "programming language" is a language used to give instructions to a computer, and it is based on a specific syntax and set of rules.

[0545] A "verification method" is a procedure used to confirm the accuracy and functionality of the converted software code.

[0546] An "emotion analysis engine" is a system that evaluates the user's psychological state and enables adaptive feedback based on that evaluation.

[0547] "Support" refers to assistance and information provided to enable users to perform code conversion smoothly.

[0548] The embodiments for carrying out the present invention are shown below.

[0549] The user uses a terminal to input a program that requires software code conversion. The input information is sent to a server, where processing begins. The server receives the conversion request from the information input device and then uses a generating AI model to convert the original program code into another programming language. This process employs natural language processing technology, with the AI ​​model appropriately interpreting the grammar and meaning of the code to perform the conversion.

[0550] The server further performs syntactic analysis, type checking, and functional testing to ensure the accuracy of the converted code. This verifies that the program code works as intended. If any problems are found during the verification phase, the server uses the generated AI model again to correct or improve the code.

[0551] The server also uses an emotion analysis engine to assess the user's emotional state. Based on this assessment, it adjusts the conversion process and feedback to provide the user with optimal support. This allows users to achieve their goals more efficiently while reducing the stress of code conversion.

[0552] For example, if a user wants to convert a data analysis program written in Python to JavaScript, a prompt such as "Please convert the data analysis program written in Python to JavaScript" would be used. This system achieves rapid and accurate program conversion by effectively combining a generative AI model and an emotion analysis engine.

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

[0554] Step 1:

[0555] The user enters a request to convert software code via a terminal. A specific prompt might read, "Please convert a data analysis program written in Python to JavaScript." This input prompt is sent from the terminal to the server, which then receives it.

[0556] Step 2:

[0557] The server initiates a process to analyze the received transformation request. Here, it determines which generative AI model to use based on the prompt text received from the user. The criteria for this decision include the target software language and the complexity of the code. As a result of the analysis, an appropriate generative AI model is selected.

[0558] Step 3:

[0559] The server uses a generative AI model to convert the input software code into a specified programming language. The generative AI model employs natural language processing techniques to understand the code's structure and convert it to a different syntax. The output at this stage is the initial converted code written in the target programming language.

[0560] Step 4:

[0561] The server performs a series of verifications on the converted code, including syntax analysis, type checking, and functional testing. The input is the initial converted code generated in step 3. The verification process confirms that the code functions correctly through variation tests and other methods, and outputs a verification report as a result.

[0562] Step 5:

[0563] The server reuses the generated AI model to correct problems found during the verification process. The input consists of an error report based on the verification results and the initial conversion code. The server performs error correction and optimization processes and outputs the improved code.

[0564] Step 6:

[0565] The server uses an emotion analysis engine to assess the user's emotional state. If it determines that the user is feeling frustrated, the server provides code debugging information and additional guidance as needed. The input is user response data, and the output is a user emotional state report and accompanying appropriate support information.

[0566] Step 7:

[0567] The server returns the final improved code and related support information to the user. The final output provides accurate and functional code in the target programming language, along with user-friendly feedback.

[0568] (Application Example 2)

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

[0570] Conventional program conversion systems provided a uniform conversion process without considering the user's emotions. Therefore, they failed to alleviate the stress and frustration users experienced during program conversion operations, potentially compromising the user experience. This invention aims to improve user operational efficiency and create a more comfortable program conversion experience by providing a program conversion process optimized according to the user's emotional state.

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

[0572] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for acquiring the user's visual and auditory information and evaluating the user's emotional state. This makes it possible to dynamically adjust the conversion process according to the user's emotions and provide support information appropriate to the user.

[0573] A "user" is someone who operates an information processing system and utilizes specific services or functions.

[0574] A "conversion request" is a request from a user to convert input program code into another programming language.

[0575] A "natural language processing model" is an artificial intelligence model designed to analyze text information and perform specific tasks.

[0576] "Input program code" refers to the code of a computer program that the user wishes to convert.

[0577] "Specified programming language" refers to the target programming language that the user specifies they want to convert the input code to.

[0578] "Visual information" refers to information about the user's face and facial expressions, and is data acquired using devices such as cameras.

[0579] "Voice information" refers to voice data emitted by the user, which is acquired using devices such as microphones.

[0580] "Emotional state" refers to the emotions a user is feeling at a particular moment, and is evaluated using an emotion engine.

[0581] A "conversion process" is a series of processing steps that convert input program code into a specified programming language.

[0582] "Support information" refers to additional information and guides provided to help users perform their tasks smoothly.

[0583] The system that implements this application optimizes the program code conversion process based on the user's emotions. The server receives conversion requests from the user terminal and processes the input program code using a natural language processing model to convert it into the specified programming language.

[0584] This system uses smartphones and wearable devices to acquire the user's visual and auditory information, and analyzes this data with an emotion engine. The emotion engine uses an emotion recognition API (e.g., a common cloud service API) to evaluate the user's emotional state.

[0585] If the server determines that a user is experiencing frustration with the operation, it dynamically adjusts the translation process to provide the most appropriate support information for the user. Specifically, it improves the user experience by providing a simpler interface, detailed debugging information, and additional support guides.

[0586] For example, if a user fails to convert code multiple times, the emotion engine will quickly sense the user's emotions, and the system will display a pop-up guiding them with hints for improvement and steps to success. Examples of prompts can also be provided, such as, "Analyze the user's camera footage and audio, and determine their emotions using a common cloud service's emotion recognition API," and "If the user is stressed, simplify the in-app interface and display guidance."

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

[0588] Step 1:

[0589] The user creates a request to convert program code to another programming language via their terminal and sends it to the server. The input data includes the source code (e.g., Python code) and the target language. Based on this input information, the server receives the conversion request.

[0590] Step 2:

[0591] The server uses a natural language processing model to convert the received input program code into a specified language (e.g., JavaScript). The input consists of the program code and the target language within the conversion request, and the output is the converted program code. As a data operation, code conversion processing is performed using an API.

[0592] Step 3:

[0593] The server sends the user's visual information (camera footage) and audio information (audio data) obtained from the terminal to an emotion recognition API to evaluate their emotional state. The input to this process is video and audio data, and the output is information about the user's emotional state. Data processing includes image analysis and audio analysis.

[0594] Step 4:

[0595] Based on the emotional state, the server dynamically adjusts the transformation process. If stress or frustration is detected, the server sends debugging information, guidance, or a different interface to the terminal. The input is the emotional state, and the output is supportive information or a change in the interface.

[0596] Step 5:

[0597] The user continues the conversion process using the adjusted information. They optimize their operation by utilizing the support information and interface displayed on the terminal. This improves the user experience and allows for a smoother process. The input is the support information provided by the server, and the output is the streamlining of user operations.

[0598] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

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

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

[0601] [Fourth Embodiment]

[0602] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[0603] As shown in Figure 7, the data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

[0605] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

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

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

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

[0609] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[0610] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

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

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

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

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

[0615] This invention comprises a process in which a user requests the conversion of program code, and a system processes that request to ultimately generate highly accurate program code. The user uses a terminal to request the server to convert code written in a specific programming language. For example, a user can send a request to convert a list manipulation program written in Python to JavaScript.

[0616] The server receives this request and performs the requested transformation using a natural language processing model. Once the transformation is complete, the server reuses the natural language processing model and suggests several checks to verify the accuracy of the generated program code.

[0617] The server sends the proposed checking method to the terminal, and based on the results, the terminal checks various aspects of the program code. First, a syntax check is performed, followed by a type check. If this is successful, a functional test is then performed to confirm that the program works as expected.

[0618] If the check reveals an error, the terminal reports the details to the server. The server then uses the natural language processing model again to correct the program code and undergoes another check. This cycle of correction and checking is repeated until all conditions are met.

[0619] For example, when a user converts a Python program to JavaScript, type mismatches may be discovered during the first conversion. In this case, the server attempts to correct them and continues correcting until the type checks pass. In this way, the user can obtain accurate program code with minimal intervention.

[0620] The following describes the processing flow.

[0621] Step 1:

[0622] The user sends a program code conversion request to the server using their terminal. This request includes the original program language and the converted program language.

[0623] Step 2:

[0624] The server parses the request received from the user and uses a natural language processing model to translate the specified program code into the target language. The translated code is temporarily stored.

[0625] Step 3:

[0626] The server again uses the natural language processing model and proposes several checks to verify the accuracy of the translated program code. This list of checks includes syntax checking, type checking, and functional testing.

[0627] Step 4:

[0628] The server sends the proposed checking method to the terminal, which first performs a syntax check. The syntax check verifies whether the program adheres to the language's grammatical rules.

[0629] Step 5:

[0630] If the syntax check is successful, the terminal then performs a type check. The type check verifies that the data types used in the program are appropriate.

[0631] Step 6:

[0632] If no problems are found during type checking, the terminal will run a functional test. The functional test verifies that the converted program works as expected.

[0633] Step 7:

[0634] If any of the checks find a problem, the terminal reports the error details to the server. The server then requests a fix from the natural language processing model and modifies the code again.

[0635] Step 8:

[0636] The corrected code is sent back to the terminal and the checking process starts again from step 4. This cycle continues until all checks are successful.

[0637] Step 9:

[0638] After all checks have passed, the server notifies the user of the successful program code and provides the completed code.

[0639] (Example 1)

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

[0641] Converting between programming languages ​​manually is time-consuming and labor-intensive, and prone to conversion errors and inconsistencies. Furthermore, verifying the accuracy of the converted program code requires advanced expertise, increasing the workload of programmers. Conventional technologies have limited means of automating and accurately performing these tasks, thus necessitating new solutions.

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

[0643] In this invention, the server includes means for receiving input data conversion requests from a user, means for converting the input program description into a specified description language using a language processing model, means for proposing multiple verification methods for the converted program description, means for verifying the accuracy of the program description by executing the proposed verification methods, and means for instructing modifications to the program description based on the verification results. This makes it possible to automatically, accurately, and quickly convert program code and verify the accuracy of the conversion.

[0644] "Means for receiving input data conversion requests from users" refers to a mechanism for a server to receive program code conversion requests made by users via a terminal.

[0645] A "language processing model" is an algorithm that uses natural language processing techniques to convert the language in which a program is written into a different language.

[0646] A "program description" is a set of instructions written using a specific programming language, in a form that can be executed by a computer.

[0647] "Means for converting to a specified description language" refers to a mechanism that executes a process for replacing an input program description with another programming language.

[0648] "Means of proposing multiple verification methods" refers to a mechanism that presents multiple verification processes, including syntax checking and type checking, to ensure the accuracy and consistency of the converted program description.

[0649] "Means for verifying the accuracy of the program description by performing the proposed verification method" refers to a mechanism that uses a server or terminal to execute the proposed verification process and determine whether the program description has been correctly converted.

[0650] "Means for instructing program description modifications based on verification results" refers to a mechanism that instructs the server to modify the program description to address problems identified based on the verification results.

[0651] "Means for verifying the accuracy of generated code and providing a verification process including syntax checking, type checking, and functionality evaluation" refers to a set of procedures for checking the transformed code for syntactic errors and data type consistency, and for testing whether the code works as intended.

[0652] This invention relates to a system that automates the process of converting program code between different programming languages ​​using a terminal, generating code with a high degree of accuracy. Specifically, the user sends a program code conversion request from the terminal to a server. In this case, if the user wants to convert code written in Python to JavaScript, the user can enter a prompt such as "Please convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)".

[0653] The server receives the request and performs the transformation using a language processing model. The generative AI model used here is, for example, an open-source natural language processing framework. The server provides verification processes for the transformed code, such as syntax checking and type checking. For example, the server uses a parsing tool to check whether the transformed JavaScript code has correct syntax.

[0654] Next, the server suggests a checking method to the terminal, and the user uses the terminal to execute that method. In addition to syntax and type checking, the user runs test cases to verify that the functions of the converted program work as expected.

[0655] If errors or inconsistencies are detected, the terminal sends this information to the server, which then attempts to correct them using the generated AI model again. This process is repeated until all conditions are met, allowing the user to receive accurate program code with minimal intervention.

[0656] This enables efficient code conversion between different programming languages, significantly reducing the user's workload. This system provides a means to effectively utilize valuable development resources, even without advanced programming knowledge.

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

[0658] Step 1:

[0659] The user uses a terminal to create a request to convert code written in Python to JavaScript. The input provided by the user is a prompt, which might look like this: "Convert the following Python code to JavaScript: def sum_list(lst): return sum(lst)". The conversion process begins when the terminal sends this input to the server.

[0660] Step 2:

[0661] The server parses the prompt message received from the terminal. The input arrives at the server in the form of a prompt message, and the server initializes its language processing model. As a result of the analysis, the server identifies the target language (in this case, Python) and the destination language (JavaScript). As part of the data processing, the generative AI model is set up.

[0662] Step 3:

[0663] The server uses a language processing model to perform the transformation of the specified program description. It parses the input Python code and performs data processing to generate code that conforms to JavaScript syntax. At this point, the output is the transformed JavaScript code. As a concrete example of the output, the sum_list function is transformed into "function sumList(lst) { return lst.reduce((a, b) => a + b, 0);}".

[0664] Step 4:

[0665] The server proposes several verification methods for the converted program code. These include syntax checking, type checking, and functionality evaluation. The input is the converted JavaScript code, and the output is a list of recommended verification processes. The server prepares the code for the checks to be performed using its parsing and type checking tools.

[0666] Step 5:

[0667] The terminal executes a process to verify the accuracy of the program code based on the verification suggestions received from the server. The input is the verification method and conversion code, and the output is the verification result. For example, the terminal evaluates whether the JavaScript syntax is correct, whether the types match, and whether it functions correctly. It applies test cases and verifies whether the program behaves as expected.

[0668] Step 6:

[0669] If an error is found during the check, the terminal reports the error details to the server. The input is the error report, and the output is the correction instruction. Specifically, by providing detailed information about what went wrong at each step, the server can adjust the processing in the next step.

[0670] Step 7:

[0671] Based on the error information received, the server attempts to correct the program code again using the generated AI model. The input is the error information, and the output is the corrected code. This generates a new output, and the verification process described above is repeated. This cycle continues until all conditions are met.

[0672] (Application Example 1)

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

[0674] In today's information processing environments, there is a demand for seamless conversion and efficient use of code across different information processing devices and platforms. However, code conversion between multiple languages ​​presents numerous technical challenges, particularly in maintaining accuracy and efficient checking processes. Furthermore, optimization for performing this in real time on mobile devices is lacking.

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

[0676] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for proposing a plurality of checking methods for the converted program code. This makes it possible to optimize application processing between different information processing devices in real time and to convert code efficiently and accurately.

[0677] "Means for receiving conversion requests from users" refers to an interface for users to request conversion from one programming language to another, and a mechanism for processing such requests.

[0678] "A means of converting input program code into a specified programming language using a natural language processing model" refers to a process that utilizes machine learning algorithms to convert given source code into another programming language, and the mechanism for executing that process.

[0679] "A means of proposing multiple checking methods for converted program code" refers to a mechanism that presents users with multiple verification methods to verify the accuracy and efficiency of the generated code.

[0680] "Means for verifying the accuracy of program code by performing the proposed checking method" refers to a process and apparatus for verifying whether a program operates correctly based on the indicated testing method.

[0681] "A means of instructing program code modifications based on check results" refers to a system that issues instructions to correct errors and defects discovered through verification.

[0682] "Means for optimizing application processing between different information processing devices in a mobile information terminal in real time" refers to a system that dynamically adjusts the execution efficiency of programs on different computing devices and environments on a mobile device.

[0683] The system that realizes this application is a platform for efficiently converting and optimizing program code between multiple information processing devices. Users use a mobile device to send conversion requests. Requests received from the device are sent to a server, which processes them.

[0684] The server utilizes a natural language processing model based on TensorFlow to convert given input code into a specified programming language. The converted code is then checked for syntax, type, and functionality using tools such as Mocha, and corrective actions are taken if problems are found. The server repeats this process until it generates accurate code.

[0685] Mobile information terminals provide users with an interface through applications developed using Flutter. These applications optimize real-time application processing and enable seamless collaboration between various information processing devices.

[0686] As a concrete example, if a user writes a Python script for a QR code scan-based purchase process, a prompt will be sent to convert that code to JavaScript so that it can be used on different platforms. An example of the prompt message is as follows:

[0687] "Please convert the QR code scanning purchase processing code written in Python so that it can be used in a JavaScript environment. Please perform as many checks as possible on the syntax, types, and functionality."

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

[0689] Step 1:

[0690] The user uses a mobile device to request the conversion of program code through an interface. The input is a QR code scanning purchase processing code written in Python, and the output is the conversion request information. The user specifies that they want the code to be available as JavaScript by entering a prompt within the app.

[0691] Step 2:

[0692] The terminal sends the generated conversion request information to the server. The server receives this information and parses the request. The input is the conversion request information, and the output is the parsing result. Based on this parsing, the server determines the specific steps to proceed with the conversion.

[0693] Step 3:

[0694] The server uses a natural language processing model running on TensorFlow to convert Python code into specified JavaScript code. The input is the parsed request and the original Python code, and the output is the converted JavaScript code. Data processing and calculations are performed by this natural language processing model.

[0695] Step 4:

[0696] The server first checks the syntax of the generated JavaScript code. The input is the converted JavaScript code, and the output is the result of the syntax check. Correction instructions are given as needed until the syntax is correct.

[0697] Step 5:

[0698] The server then performs type checking. The input is JavaScript code that has passed syntax checking, and the output is the result of type checking. It verifies that the expected data types match the actual data types, and attempts to correct any type mismatches found.

[0699] Step 6:

[0700] The server uses the Mocha testing framework to perform functional tests on the code. The input is type-checked JavaScript code, and the output is the result of the functional tests. Corrections and retests are repeated as needed until the tests pass.

[0701] Step 7:

[0702] After the server confirms that all checks have passed, it sends the completed JavaScript code back to the terminal. The terminal receives this code and notifies the user. The input is the JavaScript code that passed the functional tests, and the output is the final code and the notification.

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

[0704] This invention is a system for recognizing user emotions and optimizing the program conversion process. The system begins by receiving a conversion request entered by the user via a terminal. For example, if a user wants to convert a program written in Python to JavaScript, the server receives this request.

[0705] Next, the server uses a natural language processing model to translate the specified program code into the target language. For the translated program code, the server proposes several checking methods, including syntax checking, type checking, and functional testing. This verifies the accuracy of the program code, and if any problems are found, the natural language processing model is called again to instruct the code to be corrected.

[0706] A notable aspect here is the use of an emotion engine. The server uses the emotion engine to evaluate the user's emotional state. Based on this evaluation, the transformation and correction process is dynamically adjusted. For example, if the server determines that the user is feeling frustrated, it can provide the user with more detailed debugging information and guidance. In this way, the user experience is improved, and as a result, the efficiency of program transformation is also improved.

[0707] For example, when a user converts code that involves complex data processing, it may require more steps than usual. In this case, the user may become frustrated if they are asked to make multiple corrections. The emotion engine quickly recognizes these emotions, and the server provides appropriate support to ensure a smooth process.

[0708] Thus, the present invention provides a means to optimize each stage of program conversion according to the user's emotions and improve the quality of the user experience.

[0709] The following describes the processing flow.

[0710] Step 1:

[0711] The user sends a program conversion request to the server via their terminal. This request includes the original programming language and the target programming language.

[0712] Step 2:

[0713] The server parses the received request and uses a natural language processing model to translate the original program code into the specified language. The translated code is temporarily stored.

[0714] Step 3:

[0715] The server utilizes an emotion engine to evaluate the user's emotional state in real time. User stress levels and satisfaction levels are used as evaluation criteria.

[0716] Step 4:

[0717] The server proposes several methods for checking the converted program code. These methods include syntax checking, type checking, and functional testing.

[0718] Step 5:

[0719] The terminal executes the checks suggested by the server and verifies the program code. If errors are found during verification, it collects detailed error messages.

[0720] Step 6:

[0721] The device reports the verification results to the server. The server also considers the results of the emotion engine and adjusts the content and format of the feedback according to the user's emotions.

[0722] Step 7:

[0723] The server will call the natural language processing model again based on the error message and attempt to correct the generated code. It will also provide additional guidance and help to the user as needed.

[0724] Step 8:

[0725] The corrected code is sent back to the terminal and enters the checking process again. This loop continues until all validations are successful.

[0726] Step 9:

[0727] Once all processes are complete, the server notifies the user of the final result, and the user can receive the exact program code.

[0728] (Example 2)

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

[0730] Conventional program code conversion systems have faced challenges in reducing errors that occur during code conversion and the psychological burden on users. In particular, when multiple corrections and checks are required, users are prone to frustration, and the efficiency of the conversion process decreases. Solutions to these problems are needed.

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

[0732] In this invention, the server includes means for receiving conversion requests from an information input device, means for converting input software code into a specified programming language using a generation AI model, and means for evaluating the emotional state of the user of the information input device using an emotion analysis engine and adjusting the conversion and modification process. This makes it possible to provide optimal support according to the user's emotions, reduce frustration that occurs during the code conversion process, and improve the efficiency of the conversion.

[0733] An "information input device" is a device used by a user to input a request for program code conversion.

[0734] A "conversion request" is an instruction that includes a user's request to convert code from one programming language to another.

[0735] A "generative AI model" is an artificial intelligence model that uses natural language processing technology to convert software code into another programming language.

[0736] "Software code" refers to text written in a language that describes the instructions and processes that make up a computer program.

[0737] A "programming language" is a language used to give instructions to a computer, and it is based on a specific syntax and set of rules.

[0738] A "verification method" is a procedure used to confirm the accuracy and functionality of the converted software code.

[0739] An "emotion analysis engine" is a system that evaluates the user's psychological state and enables adaptive feedback based on that evaluation.

[0740] "Support" refers to assistance and information provided to enable users to perform code conversion smoothly.

[0741] The embodiments for carrying out the present invention are shown below.

[0742] The user uses a terminal to input a program that requires software code conversion. The input information is sent to a server, where processing begins. The server receives the conversion request from the information input device and then uses a generating AI model to convert the original program code into another programming language. This process employs natural language processing technology, with the AI ​​model appropriately interpreting the grammar and meaning of the code to perform the conversion.

[0743] The server further performs syntactic analysis, type checking, and functional testing to ensure the accuracy of the converted code. This verifies that the program code works as intended. If any problems are found during the verification phase, the server uses the generated AI model again to correct or improve the code.

[0744] The server also uses an emotion analysis engine to assess the user's emotional state. Based on this assessment, it adjusts the conversion process and feedback to provide the user with optimal support. This allows users to achieve their goals more efficiently while reducing the stress of code conversion.

[0745] For example, if a user wants to convert a data analysis program written in Python to JavaScript, a prompt such as "Please convert the data analysis program written in Python to JavaScript" would be used. This system achieves rapid and accurate program conversion by effectively combining a generative AI model and an emotion analysis engine.

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

[0747] Step 1:

[0748] The user enters a request to convert software code via a terminal. A specific prompt might read, "Please convert a data analysis program written in Python to JavaScript." This input prompt is sent from the terminal to the server, which then receives it.

[0749] Step 2:

[0750] The server initiates a process to analyze the received transformation request. Here, it determines which generative AI model to use based on the prompt text received from the user. The criteria for this decision include the target software language and the complexity of the code. As a result of the analysis, an appropriate generative AI model is selected.

[0751] Step 3:

[0752] The server uses a generative AI model to convert the input software code into a specified programming language. The generative AI model employs natural language processing techniques to understand the code's structure and convert it to a different syntax. The output at this stage is the initial converted code written in the target programming language.

[0753] Step 4:

[0754] The server performs a series of verifications on the converted code, including syntax analysis, type checking, and functional testing. The input is the initial converted code generated in step 3. The verification process confirms that the code functions correctly through variation tests and other methods, and outputs a verification report as a result.

[0755] Step 5:

[0756] The server reuses the generated AI model to correct problems found during the verification process. The input consists of an error report based on the verification results and the initial conversion code. The server performs error correction and optimization processes and outputs the improved code.

[0757] Step 6:

[0758] The server uses an emotion analysis engine to assess the user's emotional state. If it determines that the user is feeling frustrated, the server provides code debugging information and additional guidance as needed. The input is user response data, and the output is a user emotional state report and accompanying appropriate support information.

[0759] Step 7:

[0760] The server returns the final improved code and related support information to the user. The final output provides accurate and functional code in the target programming language, along with user-friendly feedback.

[0761] (Application Example 2)

[0762] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[0763] Conventional program conversion systems provided a uniform conversion process without considering the user's emotions. Therefore, they failed to alleviate the stress and frustration users experienced during program conversion operations, potentially compromising the user experience. This invention aims to improve user operational efficiency and create a more comfortable program conversion experience by providing a program conversion process optimized according to the user's emotional state.

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

[0765] In this invention, the server includes means for receiving a conversion request from a user, means for converting input program code into a specified programming language using a natural language processing model, and means for acquiring the user's visual and auditory information and evaluating the user's emotional state. This makes it possible to dynamically adjust the conversion process according to the user's emotions and provide support information appropriate to the user.

[0766] A "user" is someone who operates an information processing system and utilizes specific services or functions.

[0767] A "conversion request" is a request from a user to convert input program code into another programming language.

[0768] A "natural language processing model" is an artificial intelligence model designed to analyze text information and perform specific tasks.

[0769] "Input program code" refers to the code of a computer program that the user wishes to convert.

[0770] "Specified programming language" refers to the target programming language that the user specifies they want to convert the input code to.

[0771] "Visual information" refers to information about the user's face and facial expressions, and is data acquired using devices such as cameras.

[0772] "Voice information" refers to voice data emitted by the user, which is acquired using devices such as microphones.

[0773] "Emotional state" refers to the emotions a user is feeling at a particular moment, and is evaluated using an emotion engine.

[0774] A "conversion process" is a series of processing steps that convert input program code into a specified programming language.

[0775] "Support information" refers to additional information and guides provided to help users perform their tasks smoothly.

[0776] The system that implements this application optimizes the program code conversion process based on the user's emotions. The server receives conversion requests from the user terminal and processes the input program code using a natural language processing model to convert it into the specified programming language.

[0777] This system uses smartphones and wearable devices to acquire the user's visual and auditory information, and analyzes this data with an emotion engine. The emotion engine uses an emotion recognition API (e.g., a common cloud service API) to evaluate the user's emotional state.

[0778] If the server determines that a user is experiencing frustration with the operation, it dynamically adjusts the translation process to provide the most appropriate support information for the user. Specifically, it improves the user experience by providing a simpler interface, detailed debugging information, and additional support guides.

[0779] For example, if a user fails to convert code multiple times, the emotion engine will quickly sense the user's emotions, and the system will display a pop-up guiding them with hints for improvement and steps to success. Examples of prompts can also be provided, such as, "Analyze the user's camera footage and audio, and determine their emotions using a common cloud service's emotion recognition API," and "If the user is stressed, simplify the in-app interface and display guidance."

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

[0781] Step 1:

[0782] The user creates a request to convert program code to another programming language via their terminal and sends it to the server. The input data includes the source code (e.g., Python code) and the target language. Based on this input information, the server receives the conversion request.

[0783] Step 2:

[0784] The server uses a natural language processing model to convert the received input program code into a specified language (e.g., JavaScript). The input consists of the program code and the target language within the conversion request, and the output is the converted program code. As a data operation, code conversion processing is performed using an API.

[0785] Step 3:

[0786] The server sends the user's visual information (camera footage) and audio information (audio data) obtained from the terminal to an emotion recognition API to evaluate their emotional state. The input to this process is video and audio data, and the output is information about the user's emotional state. Data processing includes image analysis and audio analysis.

[0787] Step 4:

[0788] Based on the emotional state, the server dynamically adjusts the transformation process. If stress or frustration is detected, the server sends debugging information, guidance, or a different interface to the terminal. The input is the emotional state, and the output is supportive information or a change in the interface.

[0789] Step 5:

[0790] The user continues the conversion process using the adjusted information. They optimize their operation by utilizing the support information and interface displayed on the terminal. This improves the user experience and allows for a smoother process. The input is the support information provided by the server, and the output is the streamlining of user operations.

[0791] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

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

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

[0794] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[0795] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[0796] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[0797] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[0798] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[0799] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In other words, it is when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is the emotion around the positive "desire" on the reaction side. In other words, it is when the robot has positive feelings such as "I want more" or "I want to know more."

[0800] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​representing each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple training data sets, which are combinations of user input and emotion values ​​representing each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions located close together have similar values, as shown in the emotion map 900 in Figure 10. Figure 10 shows an example where multiple emotions such as "reassured," "calm," and "confident" have similar emotion values.

[0801] The above description primarily focuses on the functions of the data processing device 12 in relation to this disclosure. However, the system related to this disclosure is not necessarily implemented on a server. The system related to this disclosure may be implemented as a general information processing system. This disclosure may be implemented, for example, as a software program that runs on a personal computer or as an application that runs on a smartphone. The method related to this disclosure may be provided to users in SaaS (Software as a Service) format.

[0802] In the above embodiment, an example was given in which a specific process is performed by a single computer 22. However, the technology of this disclosure is not limited thereto, and a distributed processing of the specific process may be performed by multiple computers, including computer 22. For example, a data generation model 58 may be provided in an external device of the data processing device 12, and the external device may generate data according to the input data.

[0803] In the above embodiment, an example was given in which the specific processing program 56 is stored in the storage 32, but the technology of this disclosure is not limited thereto. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-temporary storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-temporary storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes specific processing according to the specific processing program 56.

[0804] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[0805] Furthermore, it is not necessary to store the entirety of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store the entirety of the specific processing program 56 in the storage 32; it is acceptable to store only a portion of the specific processing program 56.

[0806] The following types of processors can be used as hardware resources to perform specific processing. Examples of processors include a CPU, a general-purpose processor that functions as a hardware resource to perform specific processing by executing software, i.e., a program. Other examples of processors include dedicated electrical circuits, such as FPGAs (Field-Programmable Gate Arrays), PLDs (Programmable Logic Devices), or ASICs (Application Specific Integrated Circuits), which have circuit configurations specifically designed to perform specific processing. All of these processors have built-in or connected memory, and all of them perform specific processing by using memory.

[0807] The hardware resource that performs a specific process may consist of one of these various processors, or it may consist of a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Alternatively, the hardware resource that performs a specific process may consist of a single processor.

[0808] Examples of configurations using a single processor include, firstly, a configuration in which one or more CPUs and software are combined to form a single processor, and this processor functions as a hardware resource that performs a specific process. Secondly, there is a configuration using a processor that realizes the functions of the entire system, including multiple hardware resources that perform a specific process, on a single IC chip, as exemplified by SoCs (System-on-a-chip). In this way, a specific process is realized using one or more of the above types of processors as hardware resources.

[0809] Furthermore, the hardware structure of these various processors can more specifically utilize electrical circuits that combine circuit elements such as semiconductor devices. Also, the specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps can be deleted, new steps added, or the processing order rearranged, as long as it does not deviate from the main purpose.

[0810] The descriptions and illustrations presented above are detailed explanations of the technical aspects of this disclosure and are merely examples of the technical aspects. For example, the above descriptions of the structure, function, operation, and effect are examples of the structure, function, operation, and effect of the technical aspects of this disclosure. Therefore, it goes without saying that you may delete unnecessary parts, add new elements, or replace elements in the descriptions and illustrations presented above, as long as you do not deviate from the essence of the technical aspects of this disclosure. Furthermore, in order to avoid confusion and facilitate understanding of the technical aspects of this disclosure, explanations of common technical knowledge and the like that do not require special explanation to enable the implementation of the technical aspects of this disclosure have been omitted from the descriptions and illustrations presented above.

[0811] All documents, patent applications, and technical standards described herein are incorporated by reference to the same extent as if each individual document, patent application, and technical standard were specifically and individually noted to be incorporated by reference.

[0812] The following is further disclosed regarding the embodiments described above.

[0813] (Claim 1)

[0814] A means of receiving conversion requests from users,

[0815] A means for converting input program code into a specified programming language using a natural language processing model,

[0816] A means of proposing multiple checking methods for converted program code,

[0817] A means of verifying the accuracy of the program code by performing the proposed checking method,

[0818] A means of instructing the program code to be modified based on the check results,

[0819] A system that includes this.

[0820] (Claim 2)

[0821] The system according to claim 1, comprising means for repeatedly providing suggestions for checking methods and instructions for correction until the accuracy of the program code is confirmed.

[0822] (Claim 3)

[0823] The system according to claim 1, comprising means including syntax checking, type checking, and functional testing as checking methods.

[0824] "Example 1"

[0825] (Claim 1)

[0826] A means for receiving input data conversion requests from the user,

[0827] A means for converting an input program description into a specified description language using a language processing model,

[0828] A means of proposing multiple verification methods for the converted program description,

[0829] A means to verify the accuracy of the program description by performing the proposed verification method,

[0830] A means to instruct the program description to be modified based on the verification results,

[0831] Means for verifying the accuracy of generated code and providing a verification process including syntax checking, type checking, and functional evaluation,

[0832] A system that includes this.

[0833] (Claim 2)

[0834] The system according to claim 1, comprising means for repeatedly proposing verification methods and providing correction instructions until the accuracy of the program description is confirmed.

[0835] (Claim 3)

[0836] The system according to claim 1, comprising means including syntax checking, type checking, and functional evaluation as verification methods.

[0837] "Application Example 1"

[0838] (Claim 1)

[0839] A means of receiving conversion requests from users,

[0840] A means for converting input program code into a specified programming language using a natural language processing model,

[0841] A means of proposing multiple checking methods for converted program code,

[0842] A means of verifying the accuracy of the program code by performing the proposed checking method,

[0843] A means of instructing the program code to be modified based on the check results,

[0844] A means for optimizing application processing between different information processing devices in a mobile information terminal in real time,

[0845] An information processing system that includes this.

[0846] (Claim 2)

[0847] The information processing system according to claim 1, comprising means for repeatedly performing the proposed checking method and correction instructions until the accuracy of the program code is confirmed.

[0848] (Claim 3)

[0849] The information processing system according to claim 1, comprising means including sign configuration verification, data type verification, and operational testing as a checking method.

[0850] "Example 2 of combining an emotion engine"

[0851] (Claim 1)

[0852] Means for receiving conversion requests from an information input device,

[0853] A means of converting input software code into a specified programming language using a generative AI model,

[0854] A means of proposing multiple verification methods for converted software code,

[0855] A means of verifying the accuracy of the software code by performing the proposed verification method,

[0856] A means of instructing software code modifications based on the verification results,

[0857] A means for evaluating the emotional state of the user of an information input device using an emotion analysis engine and adjusting the conversion and modification process,

[0858] A system that includes this.

[0859] (Claim 2)

[0860] The system according to claim 1, comprising means for repeatedly proposing verification methods and providing correction instructions until the accuracy of the software code is confirmed.

[0861] (Claim 3)

[0862] The system according to claim 1, comprising means including syntactic analysis, type verification, and functional testing as verification methods.

[0863] "Application example 2 when combining with an emotional engine"

[0864] (Claim 1)

[0865] A means of receiving conversion requests from users,

[0866] A means for converting input program code into a specified programming language using a natural language processing model,

[0867] A means of proposing multiple checking methods for converted program code,

[0868] A means of verifying the accuracy of the program code by performing the proposed checking method,

[0869] A means of instructing the program code to be modified based on the check results,

[0870] A means for acquiring user visual and auditory information and evaluating the user's emotional state,

[0871] A means for adjusting the program conversion process based on the user's emotional state,

[0872] A means of providing different interfaces and presenting support information tailored to the user's emotions,

[0873] A system that includes this.

[0874] (Claim 2)

[0875] The system according to claim 1, comprising means for repeatedly providing suggestions for checking methods and instructions for correction until the accuracy of the program code is confirmed.

[0876] (Claim 3)

[0877] The system according to claim 1, comprising means including syntax checking, type checking, and functional testing as checking methods. [Explanation of Symbols]

[0878] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Devices 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robots< / url:> < / url:> < / url:> < / url:>

Claims

1. A means of receiving conversion requests from users, A means for converting input program code into a specified programming language using a natural language processing model, A means of proposing multiple checking methods for converted program code, A means of verifying the accuracy of the program code by performing the proposed checking method, A means of instructing the program code to be modified based on the check results, A system that includes this.

2. The system according to claim 1, comprising means for repeatedly providing suggestions for checking methods and instructions for correction until the accuracy of the program code is confirmed.

3. The system according to claim 1, comprising means including syntax checking, type checking, and functional testing as checking methods.

Images