JPH0439707B2 - - Google Patents

Description

[Detailed Description of the Invention] [Summary] A debugging control method for a natural language processing system. The state of the analysis process for understanding natural language is retained, the state is designated and the process is re-executed, and the history information of the retained state is outputted to assist system debugging.

[Industrial application field]

The present invention relates to a debug control method for a natural language processing system in a computer system.

A system that analyzes the meaning of a sentence in a so-called natural language such as Japanese and executes, for example, a database search according to the specifications of the sentence, is about to be put into practical use.

In the process of developing such a system or adding/changing functions by a user, a powerful tool is needed to assist in so-called debugging of the system.

[Conventional technology]

FIG. 2 is a block diagram showing an example of the configuration of a natural language processing system.

This system receives input from the terminal device 1.
For example, it interprets a request in a Japanese natural language sentence, executes a specified search on the database 2, and sends the resulting data to the terminal device 1.

To this end, the interactor 3 controls data exchange between the terminal device 1 and the required processing units of the system, and first inputs an input sentence from the terminal device to the semantic analysis unit 4.
give it to

The meaning analysis unit 4 divides the input sentence into clauses by referring to the word dictionary 5 or the like, processes each clause sequentially, and determines the meaning of the sentence.

In general, when dividing bunsetsu, multiple candidates may be generated, and if the candidate fails to arrive at the meaning of the sentence, another candidate is tried, and if successful, it is sent to the terminal device 1. Show it to the user and confirm it.
If the request is rejected, other candidates are tried.

When the semantic analysis unit 4 obtains a valid result, the context processing unit 6 identifies whether the sentence refers to the item indicated in the previous input sentence, and if there is a corresponding part, it changes that part. Replaced by previous analysis results.

Based on the output of the context processing section 6, the paraphrase generation section 7 generates a sentence that is paraphrased into a strict expression so as to remove ambiguity in the normal expression, and passes it to the command generation section 8.

The command generation unit 8 generates a database access command in a normal format from the Japanese sentence output of the paraphrase generation unit 7 and passes it to the database management system 9, so that a known database access is executed from then on, and even if it is a search command. For example, the resulting data is output from the database management system 9 to the terminal device 1 via the interactor 3.

FIG. 3 is a flowchart of the processing of the semantic analysis unit 4. When the process is started, in step 10 of the process, the state buffer 25 is first looked at to identify if there is a state to be processed.

A state is information indicating the status and control of each stage for analysis processing, and as will become clear from the following explanation, the state is information that indicates the state and control of each stage of the analysis process. Positions in the input sentence (L1, R1, R2, which will be explained in detail later in Figure 4)
etc.) and the predetermined part-of-speech classification of the clause (“no” described later).
It consists of information indicating for each clause (such as "noun clause"), information indicating the clause currently being processed (C), and others.

Since there is no state at first, it is determined in step 11 whether the request input statement from the terminal device 1 has been input, and if it has not been input, it waits for input in step 12.
The input sentence is divided into clauses and the process proceeds to step 13.

At this point, multiple division candidates are generally generated.

In step 13, it is determined whether there are any splitting candidates for the input sentence. If there are no splitting candidates, this means that the analysis has not been completed even after processing all the splitting candidates for the input sentence, in which case it is treated as an error. end.

If there are division candidates, select one of the division candidates in step 14.
One is selected, and the process proceeds to step 15 to analyze the division candidate.

In step 15, the next state to be executed is taken out from the state buffer 25. However, it is assumed that the information on the first state is attached to the division candidate.

The next step, step 16, is the step of executing the analysis rules.In the state determined in step 15, an analysis rule determined by the type of clause is specified, so according to the specification, the analysis rule as exemplified later is executed. Run the program.

Each analysis rule generally consists of a plurality of rules arranged in a disjunctive manner. For each rule, the semantic syntax check condition is determined in step 17. If the condition is satisfied, the main body of the rule is determined in step 18. The process of generating a new state by executing the rule is executed for all rules.

Therefore, generally a plurality of states are generated in step 16, and the generated states are held in the state buffer 25.

When it is determined in step 19 that processing of all rules has been completed, the current processing state is deleted from the state buffer 25 in step 20, and the process returns to step 10 to further proceed with the analysis.

In step 17 within step 16, it is also identified that all analysis of the division candidate being processed has been completed, and in that case, naturally, no new state is generated.
In step 21, the analysis result is output to the terminal device 1 for confirmation, and the response is identified in step 22. If approved, the analysis is terminated.

If the analysis result is rejected, the process returns to step 10 to start analyzing the remaining division candidates.

FIG. 4 is a diagram illustrating the contents of the analysis process by way of example.

For example, for the input sentence ``The price of the product is 200 yen...'', one candidate for clause segmentation is the noun clause ``no'' (of the product) (a clause consisting of a noun with the particle ``no''), as shown in the figure. (Same below), “price is”
Suppose that the noun clause ``ga'' is divided into the noun clause ``200 yen,'' and the noun clause without an adjunct ``200 yen.''

The first state 30, as shown, points to the first "goods" clause as the current processing clause, and there is no pre-processing clause. Note that the representation in the diagram is state 30
, the noun clause analysis rule "of" is specified as the analysis rule for the currently processed clause, and as the data,
It indicates that the words "product" and "no" are specified, and are attached to each phrase. C means the currently processed clause, R1, R2, etc. mean the first and second clauses on the right of C, and L1 etc. mean the clauses on the left of C.

Figure 5 shows an example of a parsing rule. This example is a noun clause parsing rule of "no", and each rule has a conditional statement starting with if, and a procedure to be executed when the condition is satisfied. It is expressed as consisting of programs starting with .

This analysis rule indicates a program to be executed under the conditions that R1 is a noun clause and there is a semantic relationship between the nouns in C and R1. In that case, a new state is generated and a state buffer is created. In addition to setting C and R1 to 25, prepare to newly connect C and R1 and analyze them as a noun clause.

Note that a semantic relationship refers to a relationship such as "product" and "price" in which a possibility of connection is expected based on the meaning of the words. The control information is configured to be used for identification.

Also, the rule is executed simply if the condition that R1 is a noun clause is satisfied, and a new state is generated to parse the next clause.

Since the conditions of at least these two rules are satisfied, two states, states 31 and 32, shown by dashed arrows from state 30 in FIG. 4 are generated.

This example corresponds to cases in which “product” modifies the immediately following “price” and cases in which it modifies the word to the right, and it is difficult to determine either of these using the analysis so far. , for example, if you have two states juxtaposed, deepen the analysis on one branch, and decide that a satisfactory analysis cannot be obtained as a result,
We return to this branch point and proceed with the analysis using the remaining states.

That is, when two states are generated by the above processing in step 16 of the processing flow in FIG. 3 and held in the state buffer 25,
State 30, which is the current processing state in step 20
, and return to step 10. In step 15, for example, state 31 is transferred to state buffer 25.
, and start the same analysis process as above.

[Problem that the invention seeks to solve]

Analysis is executed as described above, but when debugging a program when improving system control or when a system user adds/changes analysis rules depending on the application field, it is necessary to The presence of inconvenient processing is detected, for example, by looking at the analysis results.

However, at that time, all the history of the processing process was erased, so there was a problem that it was not possible to efficiently search for the cause and try to correct it.

For this purpose, for example, it is possible to save a record of input and output for each function in the program, and analyze and debug the record.
As mentioned above, in a program where the processing process is not explicitly displayed, the processing progresses by following rules, and the processing process changes dynamically each time it is executed, it is necessary to search for the cause and try to correct it. There was a problem that it could not be done efficiently.

[Means for solving problems]

FIG. 1 is a flowchart of the process of the present invention.

In the figure, 50 is a debug system, and 51 is a state history buffer.

[Effect]

When the debugging system 50 finishes the analysis processing of the one clause, it identifies whether the re-execution mode is specified in step 41 of the processing, and if the re-execution mode is specified, the current processing state is determined in step 42. is deleted from the state buffer 25 and transferred to the state history buffer 51 and held there.

In step 43, it is determined whether a stepper mode is specified, and if stepper mode is specified, information on the new state is displayed on the terminal device 1 in step 44,
At step 45, the process waits for a proceeding instruction, and if there is an instruction, proceeds to the next analysis process.

When the analysis is completed or ends due to an error, the re-execution mode designation is identified in step 46, and if it is in re-execution mode, an instruction is waited for in step 47, and depending on the instruction, the process either ends as is or proceeds to step 48. Control replays.

Step 48 copies the state specified by the instruction from the state history buffer 51, and
Generate a temporary state and create a state buffer 25
, and returns to step 10, so re-execution starts from the specified state.

The state stored in the state history buffer 51 is stored in step 45 and step 47.
It is easy to display and output the information to the terminal device 1 using an appropriate command. Furthermore, if necessary, a function for modifying analysis rules and the like can be made available as well.

As described above, the above-mentioned problems are solved and it becomes possible to improve the efficiency of debugging.

〔Example〕

In FIG. 1, processing steps 10 to 22 perform the same processing as in the conventional case.

When debugging, for example, the re-execution mode and stepper mode are specified as control parameters when starting the natural language processing system to be debugged. is displayed.

After the debug system 50 completes the analysis of one clause in step 16, it tests the re-execution mode flag in step 41, and if it is off, branches to the conventional process in step 20.

Therefore, as in the prior art, the current processing state is erased and the process returns to step 10 to start processing in the next state.

If the rerun mode flag is on, the step
42, the current processing state is deleted from the state buffer 25, but the current processing state is deleted from the state history buffer 51.
and save it. Explanatory information useful for debugging, such as the parent state, child state, and executed rule name, is added to the state information saved here.

Step 43 tests the stepper mode flag and returns to step 10 if it is off.

If the stepper mode flag is on, in step 44 information on the next new state to be processed is displayed on the terminal device 1, and in step 45 the process waits for a proceeding instruction.

The user of the terminal device 1 considers this display and
For example, if the scheduled processing is being performed correctly, a progress instruction is input to proceed with the processing as it is, in which case the system returns to step 10 and starts processing in a new state.

For example, if it is determined that the scheduled processing is not being performed, for example, specify the output of the contents of the state history buffer 51 using an appropriate command, investigate the cause of the error, and if necessary, After modifying the analysis rules, instruct the process to proceed, or
Or instruct termination.

As means for reading out and modifying the contents of the memory such as the state history buffer 51, known means used in many general debugging systems can be used. It is desirable to be able to specify and use it from the terminal device 1 at any time during debugging.

The debug system 50 also performs step 13 or 22.
When terminating due to an error or analysis completion, the re-execution mode flag is identified in step 46, and if it is off, the process ends as is, but if it is on, it is executed in step 47.
Waiting for instructions.

If necessary, the user of the terminal device 1 saves the state history buffer 51 as in step 45.
As a result, it is possible to instruct termination or specify one of the states to be saved in the state history buffer 51 and re-execute from the processing of that state. .

If re-execution is specified, proceed to step 48, copy the specified state from the state history buffer 51, generate a temporary state,
The program is placed in the state buffer 25 and the process returns to step 10, so that re-execution starts from the specified state.

That is, the state buffer 25 holds states that have not been analyzed, and one state is selected from therein in accordance with an appropriate priority order and taken out and processed as the current state.

The current state retrieved as a result is deleted from the state buffer 25 (step 20), and if there is one or more new states generated by the analysis process, they are added to the state buffer 25.

When starting re-execution in step 48 above,
Since only the temporary state is placed in the state buffer 25 and the process returns to step 10, the temporary state is forcibly selected and processed in step 15 when the next processing state is determined.

〔Effect of the invention〕

As is clear from the above description, according to the present invention, in a computer system that performs natural language processing in a manner in which the progress of processing is not specified, acquisition of processing history information for debugging the processing system; Since re-execution, step execution, etc. can be performed from an appropriate process, there is a significant industrial effect of improving debugging efficiency.

[Brief explanation of drawings]

Fig. 1 is a flowchart of the processing of the present invention, Fig. 2 is a block diagram of an example configuration of a natural language processing system, Fig. 3 is a flowchart of conventional processing, Fig. 4 is an explanatory diagram of analysis processing, and Fig. 5 is a block diagram of a configuration example of a natural language processing system. It is an explanatory diagram of an analysis rule. In the figure, 1 is a terminal device, 2 is a database, 3 is an interactor, 4 is a semantic analysis unit, 5 is a word dictionary, 6 is a context processing unit, 7 is a paraphrase generation unit, 8
9 is a command generation unit, 9 is a database management system, 10 to 22, 41 to 48 are processing steps,
25 is a state buffer; 30, 31, and 32 are states; 50 is a debug system; and 51 is a state history buffer.

Claims (1)

[Scope of Claims] 1. An input sentence made of natural language is divided into clauses, and information indicating the clause, the position of the clause in the input sentence, and a predetermined part of speech classification of the clause is provided for each clause. , an indication of the clause to be currently processed is provided, the states held in the state buffer 25 are sequentially retrieved as the current state, and the part-of-speech classification of the clause to be currently processed in the current state is determined by analysis processing. In a natural language processing system, a new state is generated by a predetermined analysis according to the above, and stored in the state buffer, and the input sentence is analyzed by repeating the analysis process. The debugging means has a state history buffer 51, and when a predetermined re-execution instruction is set, the debugging means sequentially stores and saves the current state in the state history buffer 51 for each analysis process. 42. If there is a predetermined specified input when finishing the input sentence analysis, generate a temporary state based on the specified state to be retained in the state history buffer, and store the temporary state in the state buffer. 48. A natural language processing debugging control method, characterized in that the natural language processing debugging control method is configured to start re-execution of the analysis processing using the temporary state.