A data engine instruction rewriting method and device based on a large language model

Abstract

The application discloses a data engine instruction rewriting method and device based on a large language model. The method comprises the following steps: after receiving a debugging request, generating a debugging instruction according to instruction description information carried by the debugging request; obtaining a debugging running log corresponding to the debugging instruction, wherein the debugging running log is obtained by processing the debugging instruction; if the debugging running log indicates an abnormal running, rewriting the debugging instruction according to abnormal processing information corresponding to the abnormal running to obtain a rewritten instruction; if the debugging running log indicates a normal running, rewriting the debugging instruction according to difference description information between an expected debugging result carried by the debugging request and an actual debugging result corresponding to the debugging instruction to obtain the rewritten instruction. Thus, the automatic rewriting of the instruction can be realized, the defects caused by the manual rewriting of the instruction can be effectively overcome, and the debugging efficiency is improved.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a method, apparatus, electronic device, and computer-readable medium for rewriting data engine instructions based on a large language model. Background Technology

[0002] For some data engines, such as Flink and Spark, tasks in these engines need to go through development, debugging, release, and deployment before they can be used to provide corresponding services to users.

[0003] Furthermore, during the debugging phase, relevant personnel need to manually rewrite and test multiple times to obtain debugging instructions that meet the debugging requirements, such as Structured Query Language (SQL) statements. This results in a relatively long debugging process. The debugging instructions refer to the instructions used when debugging the tasks described above. Summary of the Invention

[0004] To address the aforementioned technical problems, this application provides a method, apparatus, electronic device, and computer-readable medium for rewriting data engine instructions based on a large language model, which is beneficial for debugging efficiency.

[0005] To achieve the above objectives, the technical solution provided in this application is as follows:

[0006] This application provides a method for rewriting instructions in a data engine based on a large language model. The method includes:

[0007] Upon receiving a debugging request, debugging instructions are generated based on the instruction description information carried in the debugging request.

[0008] Obtain the debug execution log corresponding to the debug command, wherein the debug execution log is obtained by processing the debug command;

[0009] If the debugging log indicates an abnormal operation, the debugging instructions are rewritten based on the abnormality handling information corresponding to the abnormality to obtain the rewritten instructions.

[0010] If the debug log indicates normal operation, the debug command is rewritten based on the difference description information between the expected debug result carried in the debug request and the actual debug result corresponding to the debug command, resulting in a rewritten command; the actual debug result is obtained by processing the debug command.

[0011] In one possible implementation, the rewritten instructions are obtained by rewriting the debug instructions using a pre-built instruction rewriting model.

[0012] In one possible implementation, the instruction rewriting model is used to perform rewriting processing based on the instruction constraints corresponding to the data engine, the data source constraints corresponding to the data engine, and the rewriting constraints corresponding to the data engine; the data engine is used to process the debugging instructions.

[0013] In one possible implementation, the process of determining the exception handling information corresponding to the exception includes:

[0014] If the debug log indicates an operational anomaly, then the debug log is vectorized to obtain a debug log vector.

[0015] Based on the debug log vector, a target anomaly representation vector is searched from at least one candidate anomaly representation vector, wherein the similarity between the target anomaly representation vector and the debug log vector is higher than the similarity between any other candidate anomaly representation vector (excluding the target anomaly representation vector) and the debug log vector.

[0016] Based on the anomaly handling information corresponding to the target anomaly representation vector, the anomaly handling information corresponding to the anomaly is determined.

[0017] In one possible implementation, the debugging instructions are obtained by performing instruction generation processing on the instruction description information using a pre-built instruction generation model.

[0018] In one possible implementation, after obtaining the rewritten instructions, the method further includes:

[0019] Based on the rewritten instructions, generate the response information corresponding to the debugging request.

[0020] In one possible implementation, the response information includes instruction adjustment prompt information, which is determined based on a description of the differences between the rewritten instruction and the debugging instruction.

[0021] In one possible implementation, if the debug log indicates normal operation, the response information is generated based on the rewritten instructions and the actual debug results.

[0022] In one possible implementation, the response information includes descriptive information about the difference between the expected debugging result and the actual debugging result.

[0023] In one possible implementation, the response information is generated using a pre-built encapsulation model, which is used to perform readable encapsulation processing on the input data of the encapsulation model.

[0024] In one possible implementation, after generating the response information corresponding to the debugging request, the method further includes:

[0025] Display the response information;

[0026] If a request to use the instruction is received, the rewritten instruction will be identified as the debugging instruction.

[0027] If an instruction adjustment request is received, the debugging instruction is updated according to the instruction adjustment description information carried in the instruction adjustment request.

[0028] This application provides a data engine instruction rewriting device based on a large language model, comprising:

[0029] The instruction generation unit is used to generate debugging instructions based on the instruction description information carried in the debugging request after receiving the debugging request.

[0030] The log acquisition unit is used to acquire the debug execution log corresponding to the debug instruction, wherein the debug execution log is obtained by processing the debug instruction;

[0031] The first rewriting unit is used to rewrite the debugging instructions based on the exception handling information corresponding to the exception if the debugging log indicates an exception, so as to obtain the rewritten instructions.

[0032] The second rewriting unit is used to rewrite the debugging instruction based on the difference description information between the expected debugging result carried by the debugging request and the actual debugging result corresponding to the debugging instruction if the debugging operation log indicates that the operation is normal, so as to obtain the rewritten instruction; the actual debugging result is obtained by processing the debugging instruction.

[0033] This application provides an electronic device, the device comprising: a processor and a memory;

[0034] The memory is used to store instructions or computer programs;

[0035] The processor is configured to execute the instructions or computer program in the memory, so that the electronic device executes the data engine instruction rewriting method based on a large language model provided in this application.

[0036] This application provides a computer-readable medium storing instructions or computer programs that, when executed on a device, cause the device to perform the data engine instruction rewriting method based on a large language model provided in this application.

[0037] This application provides a computer program product comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for executing the data engine instruction rewriting method based on a large language model provided in this application.

[0038] Compared with related technologies, this application has at least the following advantages:

[0039] In the technical solution provided in this application, after receiving a debugging request, a debugging instruction is first generated based on the instruction description information carried in the debugging request, so that the debugging instruction meets the instruction requirements described by the instruction description information; then, the debugging operation log corresponding to the debugging instruction is obtained. The debugging operation log is obtained by processing the debugging instruction so that the debugging operation log can describe the state presented when processing the debugging instruction; if the debugging operation log indicates an abnormal operation, the debugging instruction is rewritten based on the abnormality handling information corresponding to the abnormality to obtain a rewritten instruction, so that the abnormality will not occur when processing the rewritten instruction; however, if the debugging operation log indicates normal operation, the debugging instruction is rewritten based on the difference description information between the expected debugging result carried in the debugging request and the actual debugging result corresponding to the debugging instruction, so that the result obtained by processing the rewritten instruction is as consistent as possible with the expected debugging result. This can realize automatic instruction rewriting, thereby effectively overcoming the defects caused by manual instruction rewriting, such as long time consumption and a large number of rewriting times, and thus improving debugging efficiency. Attached Figure Description

[0040] To more clearly illustrate the technical solutions in the embodiments or related technologies of this application, the drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0041] Figure 1 A flowchart illustrating a data engine instruction rewriting method based on a large language model, provided in this application embodiment;

[0042] Figure 2 A schematic diagram of a debugging process provided for an embodiment of this application;

[0043] Figure 3 A schematic diagram of the structure of a data engine instruction rewriting device based on a large language model provided in this application embodiment;

[0044] Figure 4This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0045] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present application.

[0046] To better understand the technical solution provided in this application, the method for rewriting data engine instructions based on a large language model provided in this application will be explained below with reference to some accompanying figures. For example... Figure 1 As shown, the data engine instruction rewriting method based on a large language model provided in this application includes S1-S4 below. Wherein, the... Figure 1 A flowchart illustrating a data engine instruction rewriting method based on a large language model, provided in an embodiment of this application.

[0047] S1: After receiving a debug request, generate debug instructions based on the instruction description information carried in the debug request.

[0048] Debugging requests refer to requests triggered when debugging tasks within the data engine. For example, such debugging requests could use... Figure 2 The debugging request shown is executed.

[0049] It should be noted that this application does not limit the implementation method of the data engine. For example, it can be implemented using any existing or future data engine, such as a streaming computing engine like Flink or a data analysis engine like Spark.

[0050] In addition, the aforementioned debugging request can carry instruction description information and expected debugging results, so that the debugging request can not only describe the instructions required when debugging tasks in the data engine, but also describe the results that the user hopes to obtain by following the instructions.

[0051] The instruction description information is used to describe the instructions required when debugging tasks in the data engine; and this application does not limit the implementation of the instruction description information. For example, the instruction description information may include at least one of input instructions and instruction description text. The input instructions refer to instructions manually written by the user for tasks in the data engine; and this application does not limit the input instructions. For example, when the data engine is Flink, the input instructions may be FlinkSQL statements manually entered by the user. The instruction description text is used to describe in text form what the instructions required or what characteristics they have when debugging tasks in the data engine, so that the instruction description text can describe the instruction requirements specified by the user; and this application does not limit the implementation of the instruction description text. For example, the instruction description text may be implemented as a prompt text manually written by the user.

[0052] The expected debugging result is used to describe the expected result when the debugging process is performed in accordance with the instructions described in the above instruction description information; and this application does not limit the implementation of the expected debugging result.

[0053] Furthermore, this application does not limit the triggering method of the aforementioned debugging request. For example, the debugging request can be triggered using any existing or future request triggering method. Additionally, in some application scenarios, users can leverage... Figure 2 The interactive service module shown triggers the debugging request. This interactive service module provides human-computer interaction services to the user; moreover, this application does not limit the implementation method of this interactive service module. For example, the interactive service module can be implemented using an Orchestrator. The Orchestrator is used to distribute requests and provide response results to the user.

[0054] Debugging instructions refer to instructions generated based on the instruction description information carried in the aforementioned debugging request, such as SQL statements. Furthermore, this application does not limit the generation process of the debugging instructions. For example, in some application scenarios, to better improve the instruction generation effect, the debugging instructions can be obtained by using a pre-built instruction generation model to process the instruction description information. The instruction generation model is used to process the input data of the instruction generation model. Moreover, this application does not limit the implementation method of the instruction generation model. For example, the instruction generation model can be implemented using any existing or future model capable of instruction generation processing, such as Large Language Models (LLM). Alternatively, the instruction generation model can be implemented using... Figure 2The instruction generation model shown is implemented accordingly. Furthermore, this application does not limit the construction process of this instruction generation model.

[0055] Based on the relevant content in S1 above, in some application scenarios, for a task in the data engine that needs to be debugged, such as a streaming task in Flink, if a user-triggered debug request is detected during the debugging phase of the task, a pre-built instruction generation model can be used to generate instructions from the instruction description information carried by the debug request, and output debug instructions so that the data engine can process the debug instructions and obtain the relevant processing information of the debug instructions.

[0056] S2: Obtain the debug log corresponding to the debug command. The debug log is obtained by processing the debug command.

[0057] The debug run log is used to describe the logs generated when debugging is performed according to the debug instructions above, so that the debug run log can describe the state presented when the debug instructions are processed. Therefore, in one possible implementation, the debug run log can be obtained by processing the debug instructions, so that the debug run log can describe the state presented when the debug instructions are processed.

[0058] Furthermore, in some application scenarios, the data engine can be used to process the aforementioned debugging instructions. Based on this, this application also provides a possible implementation of the aforementioned debugging runtime log. In this implementation, the debugging runtime log can be obtained by the data engine processing the debugging instructions, so that the debugging runtime log can describe the log generated when the data engine performs debugging processing according to the debugging instructions, thereby enabling the debugging runtime log to represent the running state presented when the data engine processes the debugging instructions.

[0059] Based on the relevant content of S2 above, for some application scenarios, after generating debugging instructions using the above instruction generation model, the data engine can perform debugging processing according to the debugging instructions to obtain debugging operation logs, so that the debugging operation logs can represent the running status when the data engine processes the debugging instructions.

[0060] S3: If the debug log indicates an error, the debug instructions are rewritten based on the error handling information to obtain the rewritten instructions.

[0061] The term "running exception" indicates that an error occurred during the processing of the aforementioned debugging instruction. Furthermore, this application does not limit the determination process of the running exception. For example, it can be specifically stated that if there is an error record in the aforementioned debugging log, it can be determined that a running exception occurred when processing the debugging instruction, thus determining that the processing of the debugging instruction was interrupted due to the exception, and consequently determining that the processing result of the debugging instruction cannot be obtained.

[0062] In addition, the exception handling information corresponding to the above-mentioned exception is used to describe how to resolve the runtime exception described in the above-mentioned debug running log; and this application does not limit the process of obtaining the exception handling information.

[0063] In addition, in order to better improve the acquisition of abnormal solutions, this application also provides a possible implementation of the process for determining the abnormal handling information corresponding to the above-mentioned abnormality, which may specifically include steps 11-13 below.

[0064] Step 11: If the above debug log indicates an abnormal operation, then the debug log is vectorized to obtain a debug log vector.

[0065] Among them, the debug log vector refers to the result of vectorizing the debug run log mentioned above, so that the debug log vector can represent the characteristics of the runtime exception described by the debug run log.

[0066] In addition, in some application scenarios, to improve the efficiency of determining the solution to the anomaly, this application also provides a possible implementation of step 11 above. In this implementation, step 11 can specifically be: if the above-mentioned debug log indicates a runtime anomaly, then the anomaly error record in the debug log is vectorized to obtain a debug log vector, so that the debug log vector can be used to characterize the characteristics of the anomaly described by the anomaly error record. This helps to reduce the amount of information carried by the debug log vector, thereby reducing the time consumption of subsequent vectorization search. The anomaly error record is used to describe the runtime anomaly.

[0067] Step 12: Based on the debug log vector above, find the target anomaly representation vector from at least one candidate anomaly representation vector. The similarity between the target anomaly representation vector and the debug log vector is higher than the similarity between any other candidate anomaly representation vector (excluding the target anomaly representation vector) and the debug log vector.

[0068] The nth candidate anomaly representation vector is used to represent the characteristics of the pre-provided nth candidate anomaly. n is a positive integer, n≤N, N is a positive integer, and N represents the number of vectors in at least one candidate anomaly representation vector mentioned above.

[0069] Furthermore, this application does not limit the method of obtaining the at least one candidate anomaly representation vector mentioned above. For example, it can specifically be: first, searching for some anomaly description information and the anomaly handling information corresponding to each anomaly description information from a pre-built corpus; then, vectorizing each of the searched anomaly description information to obtain the at least one candidate anomaly representation vector, so that the at least one candidate anomaly representation vector includes the vectorization results of these searched anomaly description information; finally, determining the anomaly handling information corresponding to each candidate anomaly representation vector from the anomaly handling information corresponding to these searched anomaly description information, so that a solution for any anomaly can be quickly found based on these candidate anomaly representation vectors and their corresponding anomaly handling information. The corpus is used to describe the relevant content of the data engine mentioned above; and this application does not limit the corpus. For example, the corpus may include multiple anomaly information databases, such as... Figure 2 The information bases 1 to 4 shown are designed to ensure that the corpus can cover as many anomaly-related information types as possible. Each anomaly-providing information base can be used to provide at least one type of anomaly-related information.

[0070] It should be noted that, regarding the above text Figure 2 Regarding the information repositories 1 to 4 shown, this application does not limit the implementation methods of these four information repositories. For example, information repository 1 can be implemented using a pre-built Q&A document, and this Q&A document can at least be used to record some common exception error-related knowledge. Information repository 2 can be implemented using open-source documentation pre-built for the data engine. Information repository 3 can be implemented using a code library pre-built for the data engine, and this code library can at least be used to record some source code error information. Information repository 4 can use some pre-built code libraries associated with the data engine, and these code libraries can at least be used to record some source code error information associated with the data engine.

[0071] It should also be noted that for any anomaly description information searched from the pre-built corpus, the anomaly description information is used to describe the characteristics of an anomaly; and the anomaly handling information corresponding to the anomaly description information is used to describe how to resolve the anomaly described by the anomaly description information.

[0072] The target anomaly representation vector refers to the candidate anomaly representation vector found from at least one candidate anomaly representation vector that is most similar to the debug log vector. Therefore, the similarity between the target anomaly representation vector and the debug log vector is higher than the similarity between any other candidate anomaly representation vector (excluding the target anomaly representation vector) and the debug log vector. It should be noted that this application does not limit the method of calculating this similarity; for example, it can be implemented using any existing or future method capable of calculating the similarity between two vectors, such as Euclidean distance, or based on a pre-built model with similarity calculation capabilities.

[0073] Step 13: Based on the anomaly handling information corresponding to the target anomaly representation vector above, determine the anomaly handling information corresponding to the anomaly above.

[0074] It should be noted that this application does not limit the implementation of step 13 above. For example, it can specifically be: directly determining the anomaly handling information corresponding to the target anomaly representation vector above as the anomaly handling information corresponding to the anomaly above.

[0075] Based on the content of steps 11 to 13 above, it is clear that for some application scenarios, if the debugging logs indicate an operational error, a pre-built database can be utilized, such as... Figure 2 The database shown performs vectorized search processing on the debug log to obtain the exception handling information corresponding to the anomaly. This allows for subsequent rewriting of debug instructions based on the exception handling information, resulting in rewritten instructions that prevent the occurrence of the runtime anomaly when processing these rewritten instructions. The database records candidate anomaly representation vectors and their corresponding exception handling information, enabling it to describe various anomaly problems and their corresponding solutions as comprehensively as possible.

[0076] The rewritten instruction refers to the result of rewriting the debugging instruction above; moreover, this application does not limit the process of determining the rewritten instruction. For example, it may specifically include: if the debugging log corresponding to the debugging instruction above indicates an abnormal operation, then based on the exception handling information corresponding to the exception, the debugging instruction is rewritten to obtain the rewritten instruction, so that when debugging is performed according to the rewritten instruction, the abnormal problem overcome by the exception handling information will not occur.

[0077] In addition, in some application scenarios, in order to better improve the instruction rewriting effect, this application also provides a possible implementation of S3 above. In this implementation, S3 can specifically be: if the debugging log corresponding to the debugging instruction above indicates an abnormal operation, then based on the expected debugging result carried by the debugging request above and the exception handling information corresponding to the exception, the debugging instruction is rewritten to obtain the rewritten instruction, so that when debugging is performed according to the rewritten instruction, the abnormal problem overcome by the exception handling information will not occur, and the result obtained by debugging according to the rewritten instruction is as close as possible to the expected debugging result, such as the result obtained by debugging according to the rewritten instruction being consistent with the expected debugging result.

[0078] Furthermore, in some application scenarios, to better improve the rewriting effect, this application also provides a possible implementation method for obtaining the rewritten instructions mentioned above. In this implementation method, the rewritten instructions can be obtained by rewriting the debugging instructions mentioned above using a pre-built instruction rewriting model. Therefore, in one possible implementation method, S3 above can specifically be: if the debugging log corresponding to the debugging instructions indicates a running exception, then the exception handling information corresponding to the exception is input into the instruction rewriting model, so that the instruction rewriting model can rewrite the debugging instructions according to the exception handling information, obtain and output the rewritten instructions, so that when debugging according to the rewritten instructions, the exception problems overcome by the exception handling information will not occur. In another possible implementation, S3 can specifically be: if the debugging log corresponding to the debugging instruction indicates an abnormal operation, then the expected debugging result carried in the above debugging request and the exception handling information corresponding to the abnormality are input into the instruction rewriting model, so that the instruction rewriting model can rewrite the debugging instruction according to the expected debugging result and the exception handling information, obtain and output the rewritten instruction, so that when the debugging is performed according to the rewritten instruction, the abnormal problem overcome by the exception handling information will not occur, and the result obtained by the debugging is as close as possible to the expected debugging result, such as the result obtained by the debugging is consistent with the expected debugging result.

[0079] The instruction rewriting model described above is used to perform instruction rewriting processing on the input data of the instruction rewriting model; moreover, this application does not limit the implementation method of the instruction rewriting model. For example, it can be implemented using any existing or future model capable of instruction rewriting processing, such as the LLM model. Furthermore, the instruction rewriting model can employ... Figure 2 The instruction rewriting model shown is implemented.

[0080] Furthermore, to further improve the instruction rewriting effect, this application also provides a possible implementation of the above instruction rewriting model. In this implementation, when the above debugging instructions are processed using a data engine, the instruction rewriting model can be used to rewrite the instructions based on the instruction constraints, data source constraints, and rewriting constraints corresponding to the data engine. This ensures that the rewritten instructions output by the instruction rewriting model satisfy the instruction constraints, data source constraints, and rewriting constraints, thereby improving the instruction rewriting effect. The instruction constraints describe the characteristics of the instructions processed by the data engine. Moreover, this application does not limit the implementation of the instruction constraints. For example, the instruction constraints can be implemented using the data engine's instruction parsing service, such as Flink SQL Parser, so that the instruction rewriting model can modify the instruction expression and other aspects based on the instruction constraints. The data source constraint describes the characteristics of the data description information appearing in the instructions processed by the data engine. Furthermore, this application does not limit the implementation method of the data source constraint. For example, the data source constraint can be implemented using a metadata service (catalog server), so that the instruction rewriting model can modify data descriptions such as data source name, database name, and table name based on the data source constraint. The rewriting constraint describes some instruction rewriting rules pre-configured for the data engine. Furthermore, this application does not limit the implementation method of the rewriting constraint. For example, the rewriting constraint can be implemented using a rewriting service pre-built for the data engine, such as a Flink rewrite server, so that the instruction rewriting model can determine the rules to be observed when performing instruction rewriting processing based on the rewriting constraint.

[0081] It should be noted that, in order to better improve the rewriting effect, the above instruction rewriting model can also be used for field missing repair and / or spelling error repair, etc.

[0082] Based on the relevant content of S3 above, for some application scenarios, after obtaining the debugging log corresponding to the debugging instruction above, if the debugging log indicates an exception, the debugging instruction is rewritten according to the pre-built instruction rewriting model and the exception handling information corresponding to the exception, so as to obtain the rewritten instruction, so that when debugging according to the rewritten instruction, the exception problem overcome by the exception handling information will not occur.

[0083] S4: If the debug log indicates that the operation is normal, then based on the difference description information between the expected debug result carried in the debug request and the actual debug result corresponding to the debug instruction, the debug instruction is rewritten to obtain the rewritten instruction; the actual debug result is obtained by processing the debug instruction.

[0084] The term "operating normally" indicates that no abnormal errors occurred during the processing of the debugging instructions mentioned above. Moreover, this application does not limit the determination process of "operating normally". For example, it can be: if there are no abnormal error records in the debugging operation log mentioned above, it can be determined that no abnormality occurred when processing the debugging instructions, thus it can be determined that the processing of the debugging instructions was not interrupted, and thus it can be determined that the processing result of the debugging instructions can be obtained, that is, the actual debugging result corresponding to the debugging instructions.

[0085] Regarding the actual debugging result corresponding to the debugging command mentioned above, the actual debugging result refers to the result obtained by performing debugging processing according to the debugging command, so that the actual debugging result can represent the processing result obtained by processing the debugging command. Therefore, in one possible implementation, the actual debugging result can be obtained by processing the debugging command, so that the actual debugging result can describe the processing result of the debugging command.

[0086] In another possible implementation, the actual debugging result mentioned above can be obtained by the data engine processing the debugging instruction, so that the actual debugging result can represent the debugging result obtained by the data engine according to the debugging instruction, thereby enabling the actual debugging result to represent the result obtained by the data engine processing the debugging instruction.

[0087] Furthermore, for the actual debugging result corresponding to the debugging instruction above, the difference description information between the expected debugging result carried in the debugging request above and the actual debugging result corresponding to the debugging instruction is used to describe the difference between the expected debugging result and the actual debugging result; and this application does not limit the implementation of the difference description information.

[0088] Furthermore, this application does not limit the method of obtaining the difference description information mentioned above. For example, it can be implemented using any existing or future difference determination method. Or, for instance, this difference description information can be obtained using... Figure 2 The difference analysis module shown is used to determine the differences between two sets of data. This application does not limit the implementation of the difference analysis module; for example, the difference analysis module can be implemented using a pre-built difference analysis model.

[0089] Furthermore, this application does not limit the implementation of S4 above. For example, it can specifically be: if the debugging log corresponding to the debugging instruction above indicates that the operation is normal, then based on the difference description information between the expected debugging result carried by the debugging request above and the actual debugging result corresponding to the debugging instruction, the debugging instruction is rewritten to obtain the rewritten instruction, so that the result obtained by debugging according to the rewritten instruction is as close as possible to the expected debugging result, such as the result obtained by debugging according to the rewritten instruction being consistent with the expected debugging result, etc.

[0090] In practice, in some application scenarios, to better improve the rewriting effect, this application also provides a possible implementation of S4 above. In this implementation, S4 can specifically be: if the debugging log corresponding to the debugging instruction above indicates normal operation, then the difference description information between the expected debugging result carried in the debugging request above and the actual debugging result corresponding to the debugging instruction can be obtained first; then the difference description information is input into a pre-built instruction rewriting model so that the instruction rewriting model can rewrite the debugging instruction based on the difference description information, and obtain and output the rewritten instruction. It should be noted that the implementation of this instruction rewriting model is similar to the implementation of the instruction rewriting model mentioned in S3 above. For example, this instruction rewriting model can at least be used for field missing repair based on the expected debugging result and the actual debugging result.

[0091] Based on the relevant content of S1 to S4 above, for the data engine instruction rewriting method based on a large language model provided in this application embodiment, after receiving a debugging request, a debugging instruction is first generated according to the instruction description information carried in the debugging request, so that the debugging instruction meets the instruction requirements described by the instruction description information; then, the debugging operation log corresponding to the debugging instruction is obtained, which is obtained by processing the debugging instruction, so that the debugging operation log can describe the state presented when processing the debugging instruction; if the debugging operation log indicates a running exception, the debugging operation log is then processed according to the exception handling information corresponding to the exception. The test instruction is rewritten to obtain a rewritten instruction, so that the exception will not occur when processing the rewritten instruction. However, if the debug log indicates that the operation is normal, the debug instruction is rewritten based on the difference description information between the expected debug result carried by the debug request and the actual debug result corresponding to the debug instruction, so that the result obtained from processing the rewritten instruction is as consistent as possible with the expected debug result. This can realize automatic instruction rewriting, thereby effectively overcoming the defects caused by manual instruction rewriting, such as long time consumption and many rewriting times, and thus improving debugging efficiency.

[0092] Furthermore, this application does not limit the executing entity of the data engine instruction rewriting method based on a large language model provided in the embodiments of this application. For example, the data engine instruction rewriting method based on a large language model provided in the embodiments of this application can be applied to a terminal device or a server. Alternatively, the data engine instruction rewriting method based on a large language model provided in the embodiments of this application can also be implemented through the data interaction process between the terminal device and the server. The terminal device can be a smartphone, computer, personal digital assistant (PDA), tablet computer, etc. The server can be a standalone server, a cluster server, or a cloud server.

[0093] Furthermore, to improve the debugging experience, this application also provides a possible implementation of the data engine instruction rewriting method based on a large language model described above. In this implementation, the data engine instruction rewriting method based on a large language model includes not only S1-S4 above, but may also include step 21 below. The execution time of step 21 is later than the execution time of S3 or S4 above.

[0094] Step 21: Based on the rewritten instructions above, generate the response information corresponding to the debugging request above.

[0095] The response information describes the response content determined in response to the debugging request above. For example, this response information could use... Figure 2 Implement the response information shown.

[0096] Furthermore, this application does not limit the implementation method of the above response information. For example, the response information may at least include the above rewritten instructions so that the user can learn about the rewritten instructions from the response information.

[0097] Furthermore, in some application scenarios, to better improve the debugging experience, this application also provides a possible implementation of the above response information. In this implementation, the response information may at least include instruction adjustment prompts, so that the user can learn from the response information how to optimize the instruction description information provided by the user. Specifically, the instruction adjustment prompts describe some optimization suggestions for the instruction description information carried in the above debugging request; moreover, the instruction adjustment prompts may be determined based on the difference description information between the rewritten instruction and the above debugging instruction, so that the instruction adjustment prompts can convey these difference description information and the corresponding optimization suggestions to the user, thereby enabling the user to quickly understand some instruction optimization aspects from the instruction adjustment prompts.

[0098] Furthermore, in some application scenarios, in order to better improve the debugging experience, this application also provides a possible implementation of the above response information. In this implementation, if the debugging log corresponding to the above debugging instruction indicates that the operation is normal, the response information is generated based on the above rewritten instruction and the actual debugging result corresponding to the debugging instruction, so that the user can directly know or indirectly analyze the rewritten instruction and the actual debugging result from the response information.

[0099] Furthermore, this application does not limit the implementation method of the response information in the preceding paragraph. For example, in some application scenarios, in order to better improve the debugging experience, the response information may at least include a description of the difference between the expected debugging result and the actual debugging result, so that the user can learn from the response information the difference between the expected debugging result and the actual debugging result, thereby enabling the user to analyze the actual debugging result indirectly from the response information. This is beneficial to improving the richness of the response information, thereby improving the debugging experience.

[0100] In practice, to improve the debugging experience in some application scenarios, this application provides a possible implementation of the above-mentioned response information. In this implementation, the response information is generated using a pre-built encapsulation model. This encapsulation model is used to perform readability encapsulation processing on the input data, resulting in highly readable response information. This allows users to better understand the relevant content of the current debugging round from the response information, effectively avoiding the defects caused by poor readability of debugging logs and actual debugging results, thus improving the user's debugging experience.

[0101] Based on the relevant content of step 21 above, in some application scenarios, after obtaining the rewritten instructions, the response information corresponding to the debugging request can be generated according to the rewritten instructions. This response information can better convey some relevant content of the current debugging process to the user, so that the user can better adjust the instructions based on the response information. This can effectively avoid the defects caused by the user analyzing the debugging logs and actual debugging results, such as long analysis time and easy analysis errors, thereby improving the user's debugging experience.

[0102] In practice, in some application scenarios, to better improve the instruction debugging effect, this application also provides a possible implementation of the data engine instruction rewriting method based on a large language model. In this implementation, the data engine instruction rewriting method based on a large language model includes not only S1-S4 and step 21 above, but may also include steps 22-24 below. Among them, the execution time of step 22 is later than the execution time of step 21.

[0103] Step 22: Display the response information corresponding to the debugging request above.

[0104] It should be noted that this application does not limit the way the above response information is displayed. For example, the response information can be displayed through an information display interface; and this application does not limit the implementation method of the information display interface. For example, the information display interface may include the four modules shown in ① to ④ below.

[0105] ① Initial Input Information Display Module. This module describes the initial state of the current debugging round, such as the description of the user-input command, the expected debugging result, and the debugging commands generated based on the command description.

[0106] ② Operable Module. This operable module includes an automatic repair control and an editing control. The automatic repair control triggers the automatic instruction repair process, allowing the next round of debugging to be automatically executed according to the rewritten instructions when triggered. Furthermore, this application does not limit the implementation method of the automatic repair control; for example, it can be implemented using a button. The editing control provides text input services to the user when the user does not accept the automatic instruction repair result, enabling the user to re-enter new instruction description information using the editing control. Furthermore, this application does not limit the implementation method of the editing control; for example, it can be implemented using an input box.

[0107] ③ Result Difference Display Module. This module displays the differences between the expected debugging results and the actual debugging results.

[0108] ④ Debugging termination condition configuration module. This module provides users with configuration services for debugging termination conditions, such as the number of debugging rounds before outputting the final result.

[0109] Step 23: If a request to use the instruction is received, the rewritten instruction above will be identified as a debugging instruction, and the process will return to continue executing S2 and its subsequent steps.

[0110] The instruction usage request is used to request the execution of the next round of debugging process according to the rewritten instructions above, so that the instruction usage request can indicate that the user accepts the automatic repair result of the instructions above; and this application does not limit the triggering method of the instruction usage request. For example, it can be implemented by triggering the automatic repair control above.

[0111] Based on the relevant content of step 23 above, for some application scenarios, after displaying the response information corresponding to the debugging request above to the user, if the user triggers a command usage request, it can be determined that the user accepts the command to automatically repair the result. Therefore, the rewritten command above can be directly identified as a debugging command, and return to continue executing S2 above and its subsequent steps to achieve the next round of debugging process.

[0112] Step 24: If an instruction adjustment request is received, adjust the instruction description information according to the instruction adjustment request, update the debugging instructions, and return to continue executing S2 and subsequent steps above.

[0113] The instruction adjustment request is used to request instruction adjustment processing for the above debugging instructions, so that the instruction adjustment request can indicate that the user does not accept the automatic repair result of the above instructions.

[0114] Furthermore, regarding the aforementioned instruction adjustment request, the instruction adjustment description information carried by the instruction adjustment request refers to the text information carried by the instruction adjustment request, so that the instruction adjustment description information can describe what kind of adjustment is made to the aforementioned debugging instruction; and this application does not limit the implementation method of the instruction adjustment description information. For example, the instruction adjustment description information may include new text content entered by the user through a text box.

[0115] Furthermore, this application does not limit the implementation method of step 23 above, which involves "adjusting the description information of the instruction adjustment request according to the instruction adjustment request and updating the debugging instruction." For example, this step can be implemented using any existing or future instruction update method, such as an instruction update method using an LLM model. Alternatively, this step can be implemented using... Figure 2 The instruction generation model shown is implemented. This instruction generation model can be used to leverage... Figure 2 The instruction rewriting model shown demonstrates instruction rewriting capabilities to enable instruction update processing.

[0116] Based on the relevant content of step 24 above, for some application scenarios, after displaying the response information corresponding to the debugging request above to the user, if a user-triggered instruction adjustment request is detected, the instruction adjustment description information carried by the instruction adjustment request is used to update the debugging instruction, and then return to continue executing S2 above and its subsequent steps. This enables the next round of debugging process, which is beneficial to improving the debugging experience.

[0117] Based on the relevant content of steps 22 to 24 above, it can be seen that in some application scenarios, after displaying the response information corresponding to the debugging request above to the user, the user can quickly determine the instructions needed for the next round of debugging based on the response information, which is conducive to improving debugging efficiency.

[0118] Based on the above content regarding the data engine instruction rewriting method based on a large language model, the technical solution provided in this application can automatically analyze debugging-related information, such as debugging logs and actual debugging results. This effectively overcomes the shortcomings caused by the difficulty in reading debugging-related information, such as long analysis time and high analysis costs, thereby improving problem discovery efficiency and reducing analysis costs, such as the cost of debugging error analysis and the cost of analyzing actual debugging results. Furthermore, the technical solution provided in this application can automatically rewrite debugging instructions, effectively overcoming the shortcomings caused by manually rewriting debugging instructions, such as long processing time and high costs, thereby improving debugging efficiency and reducing instruction rewriting costs. Therefore, the technical solution provided in this application can reduce the overall debugging cost and improve the debugging efficiency of tasks in the data engine.

[0119] Based on the data engine instruction rewriting method based on a large language model provided in the embodiments of this application, the embodiments of this application also provide a data engine instruction rewriting device based on a large language model, which will be described below in conjunction with... Figure 3 Explanation and clarification will be provided. Among them, Figure 3 This is a schematic diagram of a data engine instruction rewriting device based on a large language model, provided in an embodiment of this application. It should be noted that for technical details of the data engine instruction rewriting device based on a large language model provided in this embodiment, please refer to the relevant content of the data engine instruction rewriting method based on a large language model described above.

[0120] like Figure 3 As shown in the embodiment of this application, the data engine instruction rewriting device 300 based on a large language model includes:

[0121] The instruction generation unit 301 is used to generate debugging instructions based on the instruction description information carried in the debugging request after receiving the debugging request.

[0122] The log acquisition unit 302 is used to acquire the debug execution log corresponding to the debug instruction, wherein the debug execution log is obtained by processing the debug instruction;

[0123] The first rewriting unit 303 is used to rewrite the debugging instructions based on the exception handling information corresponding to the exception if the debugging operation log indicates an operation exception, so as to obtain the rewritten instructions.

[0124] The second rewriting unit 304 is used to rewrite the debugging instruction based on the difference description information between the expected debugging result carried by the debugging request and the actual debugging result corresponding to the debugging instruction if the debugging log indicates normal operation, so as to obtain the rewritten instruction; the actual debugging result is obtained by processing the debugging instruction.

[0125] In one possible implementation, the rewritten instructions are obtained by rewriting the debug instructions using a pre-built instruction rewriting model.

[0126] In one possible implementation, the instruction rewriting model is used to perform rewriting processing based on the instruction constraints corresponding to the data engine, the data source constraints corresponding to the data engine, and the rewriting constraints corresponding to the data engine; the data engine is used to process the debugging instructions.

[0127] In one possible implementation, the process of determining the exception handling information corresponding to the exception includes: if the debug log indicates a runtime exception, then vectorizing the debug log to obtain a debug log vector; based on the debug log vector, searching for a target exception representation vector from at least one candidate exception representation vector, wherein the similarity between the target exception representation vector and the debug log vector is higher than the similarity between any other candidate exception representation vector (excluding the target exception representation vector) and the debug log vector; and determining the exception handling information corresponding to the exception based on the exception handling information corresponding to the target exception representation vector.

[0128] In one possible implementation, the debugging instructions are obtained by performing instruction generation processing on the instruction description information using a pre-built instruction generation model.

[0129] In one possible implementation, the data engine instruction rewriting device 300 based on a large language model further includes:

[0130] The information generation unit is used to generate response information corresponding to the debugging request based on the rewritten instructions.

[0131] In one possible implementation, the response information includes instruction adjustment prompt information, which is determined based on a description of the differences between the rewritten instruction and the debugging instruction.

[0132] In one possible implementation, if the debug log indicates normal operation, the response information is generated based on the rewritten instructions and the actual debug results.

[0133] In one possible implementation, the response information includes descriptive information about the difference between the expected debugging result and the actual debugging result.

[0134] In one possible implementation, the response information is generated using a pre-built encapsulation model, which is used to perform readable encapsulation processing on the input data of the encapsulation model.

[0135] In one possible implementation, the data engine instruction rewriting device 300 based on a large language model further includes:

[0136] An information display unit is used to display the response information;

[0137] The first update unit is used to determine the rewritten instruction as the debugging instruction if an instruction usage request is received;

[0138] The second update unit is used to update the debugging instruction according to the instruction adjustment description information carried in the instruction adjustment request if an instruction adjustment request is received.

[0139] Based on the above-mentioned content regarding the data engine instruction rewriting device 300 based on a large language model, it can be seen that, for the data engine instruction rewriting device 300 based on a large language model provided in this application embodiment, after receiving a debugging request, it first generates a debugging instruction based on the instruction description information carried in the debugging request, so that the debugging instruction meets the instruction requirements described by the instruction description information; then it obtains the debugging operation log corresponding to the debugging instruction, which is obtained by processing the debugging instruction, so that the debugging operation log can describe the state presented when processing the debugging instruction; if the debugging operation log indicates a running abnormality, then based on the abnormality corresponding to the debugging operation log... The exception handling information involves rewriting the debugging command to obtain a rewritten command, ensuring that the exception will not occur when processing the rewritten command. However, if the debugging log indicates normal operation, the debugging command is rewritten based on the difference description information between the expected debugging result carried in the debugging request and the actual debugging result corresponding to the debugging command, resulting in a rewritten command. This ensures that the result obtained from processing the rewritten command is as consistent as possible with the expected debugging result. This automatic command rewriting effectively overcomes the shortcomings caused by manual command rewriting, such as long processing time and numerous rewriting operations, thereby improving debugging efficiency.

[0140] In addition, this application also provides an electronic device, the device including a processor and a memory: the memory is used to store instructions or computer programs; the processor is used to execute the instructions or computer programs in the memory, so that the electronic device executes any implementation of the data engine instruction rewriting method based on a large language model provided in this application.

[0141] See Figure 4 This diagram illustrates a structural schematic of an electronic device 400 suitable for implementing embodiments of the present disclosure. The terminal devices in these embodiments may include, but are not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 4 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments disclosed herein.

[0142] like Figure 4As shown, electronic device 400 may include a processing unit (e.g., a central processing unit, a graphics processor, etc.) 401, which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 402 or a program loaded from storage device 408 into random access memory (RAM) 403. RAM 403 also stores various programs and data required for the operation of electronic device 400. The processing unit 401, ROM 402, and RAM 403 are interconnected via bus 404. Input / output (I / O) interface 405 is also connected to bus 404.

[0143] Typically, the following devices can be connected to I / O interface 405: input devices 406 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 407 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 408 including, for example, magnetic tapes, hard disks, etc.; and communication devices 409. Communication device 409 allows electronic device 400 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 4 An electronic device 400 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.

[0144] In particular, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device 409, or installed from a storage device 408, or installed from a ROM 402. When the computer program is executed by the processing device 401, it performs the functions defined in the methods of embodiments of this disclosure.

[0145] The electronic device provided in this embodiment belongs to the same inventive concept as the method provided in the above embodiments. Technical details not described in detail in this embodiment can be found in the above embodiments, and this embodiment has the same beneficial effects as the above embodiments.

[0146] This application also provides a computer-readable medium storing instructions or computer programs that, when executed on a device, cause the device to perform any implementation of the data engine instruction rewriting method based on a large language model provided in this application.

[0147] It should be noted that the computer-readable medium described in this disclosure can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this disclosure, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In this disclosure, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0148] In some implementations, clients and servers can communicate using any currently known or future-developed network protocol such as HTTP (Hypertext Transfer Protocol) and can interconnect with digital data communication (e.g., communication networks) of any form or medium. Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), the Internet (e.g., the Internet of Things), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future-developed networks.

[0149] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device.

[0150] The aforementioned computer-readable medium carries one or more programs, which, when executed by the electronic device, enable the electronic device to perform the aforementioned methods.

[0151] Computer program code for performing the operations of this disclosure can be written in one or more programming languages ​​or a combination thereof, including but not limited to object-oriented programming languages ​​such as Java, Smalltalk, and C++, as well as conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0152] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0153] The units described in the embodiments of this disclosure can be implemented in software or hardware. The names of the units / modules do not necessarily limit the unit itself.

[0154] The functions described above in this document can be performed at least in part by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), system-on-a-chip (SoCs), complex programmable logic devices (CPLDs), and so on.

[0155] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0156] It should be noted that the various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the systems or apparatus disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the descriptions are relatively simple, and relevant parts can be referred to the method section.

[0157] It should be understood that in this application, "at least one (item)" means one or more, and "more than" means two or more. "And / or" is used to describe the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: only A exists, only B exists, and both A and B exist simultaneously, where A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects are in an "or" relationship. "At least one (item) of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one (item) of a, b, or c can represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, and c can be single or multiple.

[0158] It should also be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0159] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein can be implemented directly by hardware, a software module executed by a processor, or a combination of both. The software module can be located in random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art.

[0160] The above description of the disclosed embodiments enables those skilled in the art to make or use this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for rewriting data engine instructions based on a large language model, characterized in that, The method includes: Upon receiving a debugging request, debugging instructions are generated based on the instruction description information carried in the debugging request. Obtain the debug execution log corresponding to the debug command, wherein the debug execution log is obtained by processing the debug command; If the debugging log indicates an abnormal operation, the debugging instructions are rewritten based on the abnormality handling information corresponding to the abnormality to obtain the rewritten instructions. If the debug log indicates normal operation, the debug command is rewritten based on the difference description information between the expected debug result carried in the debug request and the actual debug result corresponding to the debug command, resulting in a rewritten command; the actual debug result is obtained by processing the debug command. The process of determining the exception handling information corresponding to the exception includes: If the debug log indicates an operational anomaly, then the debug log is vectorized to obtain a debug log vector. Based on the debug log vector, a target anomaly representation vector is searched from at least one candidate anomaly representation vector, wherein the similarity between the target anomaly representation vector and the debug log vector is higher than the similarity between any other candidate anomaly representation vector (excluding the target anomaly representation vector) and the debug log vector. Based on the anomaly handling information corresponding to the target anomaly representation vector, the anomaly handling information corresponding to the anomaly is determined.

2. The method according to claim 1, characterized in that, The rewritten instructions are obtained by rewriting the debugging instructions using a pre-built instruction rewriting model.

3. The method according to claim 2, characterized in that, The instruction rewriting model is used to perform rewriting processing based on the instruction constraints corresponding to the data engine, the data source constraints corresponding to the data engine, and the rewriting constraints corresponding to the data engine; the data engine is used to process the debugging instructions.

4. The method according to claim 1, characterized in that, The debugging instructions are obtained by processing the instruction description information using a pre-built instruction generation model.

5. The method according to claim 1, characterized in that, After obtaining the rewritten instructions, the method further includes: Based on the rewritten instructions, generate the response information corresponding to the debugging request.

6. The method according to claim 5, characterized in that, The response information includes instruction adjustment prompts, which are determined based on the difference description information between the rewritten instruction and the debugging instruction.

7. The method according to claim 5, characterized in that, If the debug log indicates normal operation, then the response information is generated based on the rewritten instructions and the actual debug results.

8. The method according to claim 7, characterized in that, The response information includes a description of the difference between the expected debugging result and the actual debugging result.

9. The method according to claim 5, characterized in that, The response information is generated using a pre-built encapsulation model, which is used to perform readable encapsulation processing on the input data of the encapsulation model.

10. The method according to claim 5, characterized in that, After generating the response information corresponding to the debugging request, the method further includes: Display the response information; If a request to use the instruction is received, the rewritten instruction will be identified as the debugging instruction. If an instruction adjustment request is received, the debugging instruction is updated according to the instruction adjustment description information carried in the instruction adjustment request.

11. A data engine instruction rewriting device based on a large language model, characterized in that, include: The instruction generation unit is used to generate debugging instructions based on the instruction description information carried in the debugging request after receiving the debugging request. The log acquisition unit is used to acquire the debug execution log corresponding to the debug instruction, wherein the debug execution log is obtained by processing the debug instruction; The first rewriting unit is used to rewrite the debugging instructions based on the exception handling information corresponding to the exception if the debugging log indicates an exception, so as to obtain the rewritten instructions. The second rewriting unit is used to rewrite the debugging instruction based on the difference description information between the expected debugging result carried by the debugging request and the actual debugging result corresponding to the debugging instruction if the debugging operation log indicates that the operation is normal, so as to obtain the rewritten instruction. The actual debugging result is obtained by processing the debugging command; The process of determining the exception handling information corresponding to the exception includes: If the debug log indicates an operational anomaly, then the debug log is vectorized to obtain a debug log vector. Based on the debug log vector, a target anomaly representation vector is searched from at least one candidate anomaly representation vector, wherein the similarity between the target anomaly representation vector and the debug log vector is higher than the similarity between any other candidate anomaly representation vector (excluding the target anomaly representation vector) and the debug log vector. Based on the anomaly handling information corresponding to the target anomaly representation vector, the anomaly handling information corresponding to the anomaly is determined.

12. An electronic device, characterized in that, The device includes: a processor and a memory; The memory is used to store instructions or computer programs; The processor is configured to execute the instructions or computer program in the memory to cause the electronic device to perform the method according to any one of claims 1-10.

13. A computer-readable medium, characterized in that, The computer-readable medium stores instructions or computer programs that, when executed on the device, cause the device to perform the method according to any one of claims 1-10.

Images