JP2973883B2 - User interface evaluation device - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a user interface evaluation device for evaluating the operability (ease of use) of a dialog system having a user interface .

[0002]

2. Description of the Related Art For the purpose of evaluating the operability (ease of use) of a dialogue system having a user interface unit, a conventional user interface evaluation apparatus for extracting an erroneous operation pattern common among a plurality of user operation histories has been proposed. Processing Society of Japan, Vol. 93, no. 80 (September 17, 1993), pp. 25-32.

In this conventional apparatus, a user operation history and a correct operation history (reference operation history) are compared in order from the top,
In the user operation history, a part not included in the reference operation history is extracted as an erroneous operation pattern. The erroneous operation patterns extracted for each user are compared among a plurality of users, and erroneous operation patterns common to the users are found. This makes it possible for multiple users to find the same mistake in the operation, and by improving the user interface design so that the user is less likely to make mistakes at this point, the usability of the system is improved. Can be improved.

On the other hand, for the purpose of analyzing code patterns included in a code sequence, a conventional iterative code pattern extraction method for extracting a code pattern repeatedly appearing in a code sequence is disclosed in A.M. Information Systems (ACM Transac
Tions on Information System
ems), Vol. 9, No. 4 (October, 1
991), pp. 309-335. In the literature, a method using a character string instead of a code string is described, but so that characters and codes correspond one-to-one,
Because codes can be assigned to characters, generality is not lost even if one character represents one code.

In this conventional method, a code sequence is expanded into a tree structure, and a repetition code pattern is extracted from the tree. Using this conventional method, for example, when the target code string is “abcabcxab”, two “abc” and “ab” are extracted as the repetition code patterns.
Sections (appearance sections) where “abc” appears in the original code string are [1, 3] and [4, 6], and “ab”
Are [1,2], [4,5], [8,9]. However, "the appearance section of a certain pattern p is [A, B]
The expression “is” indicates that the pattern between the A-th code from the beginning of the original code sequence and the B-th code from the beginning matches p (where A ≦ B). "Ab
“cabcxab” includes “a”, “b”, “c”,
The four code patterns “bc” are also repeated,
Since it is a part of "abc", only "abc" is extracted. On the other hand, “ab” is also a part of “abc”,
Since there is a section that appears alone without being included in “abc” ([8, 9]), “ab” is also extracted as a repeated code pattern.

[0006]

However, the conventional user interface evaluation device described above is effective when the difference extracted by comparing the reference operation history and the user operation history in order from the top indicates an erroneous operation pattern. However, there are cases where the correct operation procedure has an arbitrary order (when any one of the plurality of operation procedures is correct first) or when there is a selection of a plurality of operation procedures (when a plurality of operation procedures are selected). If all of the steps in the procedure are correct)
The difference obtained by comparing the addresses in order from the top does not always indicate an erroneous operation pattern, and thus is not effective.

[0007] Further, the above-mentioned document (ACM Transactions on Information Systems, Inc.)
operation Systems), Vol. 9, N
o. 4 (October, 1991), pp. 309-33
5), an attempt is made to analyze the user operation history using the above-described conventional iterative code pattern extraction method for the purpose of evaluating the usability of the interactive system. Only the repetitive operation pattern is extracted, but the operation pattern common to the users is not extracted. Further, no erroneous operation pattern is extracted by comparing the user operation history with the reference operation history.

On the other hand, the above-described conventional method for extracting a repetitive code pattern has three problems.

First, as an example, if the code string is "abcab"
Consider the case of “cabc”. At this time, the repetition code pattern extracted by the conventional method is “abcabc” (appearing sections are [1, 6] and [4, 9]). It can be seen that “abc” in FIG.
However, intuitively, “abc” (appearing section is [1,
3], [4, 6], [7, 9]).
As described above, in the conventional method, a pattern that does not match the intuition due to occurrence of overlap in the appearance section may be extracted.

Also, as an example, if the code string is "xabya
bxabyab ". At this time, the repetition code pattern extracted by the conventional method is" xabyab "(appearance intervals are [1, 6] and [7, 12]).
When not only the length of the repetition code pattern but also the number of repetitions is to be similarly emphasized, the pattern “ab” (the occurrence interval is [2, 3], [5, 6], [8,
9], [11, 12]) should also be extracted. In the conventional method, the pattern having the longest length is extracted only when there is a section that appears alone, so as in the example here,
If all the appearance sections are included, it cannot be extracted.

Further, as an example, if the code string is "abxc
Consider the case of "deabycfzbc". At this time,
The repetition code patterns extracted by the conventional method are “ab” (appearance section is [1,2], [7,8]), “a” (appearance section is [1,1], [7,7], [ 12, 12]), "b"
(Appearance sections are [2,2], [8,8], [14,1
4]), “c” (appearing sections are [4, 4], [10, 1
0], [15, 15]). On the other hand, considering extraction of a repetition code pattern that does not exactly match, even if it does not match exactly, "abxc" in [1, 4],
“Abyc” of [7, 10] and “azbc” of [12, 15] include one code that does not match each other, but roughly, the code pattern “abc” is generated in these sections. It is repeating. In the conventional method, only patterns that match exactly can be extracted, so that patterns containing such ambiguity cannot be extracted.

[0012] An object of the present invention is to solve the above-mentioned problems, so that even when the correct operation procedure has an arbitrary order, or when there are a plurality of selections of the operation procedure, a common operation among a plurality of users is performed. An object of the present invention is to provide a user interface evaluation device capable of appropriately extracting an erroneous operation pattern .

[0013]

Means for Solving the Problems The present invention, the first invention,
When a user operates a dialogue system having a user interface unit, a user interface evaluation device that evaluates operability of the dialogue system using an operation history obtained by recording an operation performed by the user, From among, the operation filtering means for removing the unit operation data defined by the operation filter, the operation filter storage means for storing the operation filter, and the operation pattern appearing in the operation history according to the operation pattern replacement table, Operation pattern replacement means for replacing with another operation pattern,
An operation pattern replacement table storing means for storing the operation pattern replacement table, and a code for converting each unit operation data in the operation history into a one-to-one corresponding code and creating a correspondence table between the unit operation data and the code Coding means, a code table storage means for storing a correspondence table between unit operation data and codes created by the coding means, and a plurality of code strings obtained by converting the plurality of operation histories by the coding means. A code string coupling means for serially coupling, a code string storage means for storing a code string output by the code string coupling means, and a code string stored in the code string storage means for coupling with the code string coupling means. Common code pattern extraction means for extracting a common code pattern between at least two of the preceding code strings; Restoring means for restoring unit operation data with reference to a correspondence table between unit operation data and codes stored in the storage unit and restoring the common code pattern into a common operation pattern, and an output for controlling an output of the common operation pattern And control means.

According to a second aspect of the present invention, in the first aspect, a plurality of operation patterns having the same meaning are registered in the operation pattern replacement table held by the operation pattern replacement table storage means. One of the plurality of operation patterns is registered as a representative pattern, and the operation pattern replacement means refers to the operation pattern replacement table and assigns a plurality of operation patterns having the same meaning to the representative pattern corresponding to the operation pattern. It is characterized by being replaced with

Further, the present invention and the third invention are characterized in that, in the first or second invention, the coding means further adds a code serving as an identifier of the code sequence to an end of the code sequence. I do.

Further, according to the present invention, a fourth invention is directed to the first, second or third invention, wherein the common code pattern extracting means comprises a code pattern repeatedly appearing in a code sequence.
By extracting the code, it is stored in the code string storage means.
From the obtained code string by the code string combining means
Code path common to at least two of the previous code strings
It is characterized by extracting a tongue .

[0017]

[0018]

[0019]

Further, according to a fifth aspect of the present invention, in the first, second or third aspect, the common code pattern extracting means includes a code string stored in the code string storing means.
From the code string before being combined by the code string combining means.
Extract common code patterns between at least two
When the extracted repetition code pattern is
Model when there is overlap between sections appearing in
To correct the repetition code pattern without duplication.
And the code string stored in the code string storage means.
Appears repeatedly in the code sequence stored in the storage means
It is characterized by extracting a code pattern .

Further, according to the sixth and sixth aspects of the present invention, in the first, second or third aspect, the common code pattern extracting means includes a code string stored in the code string storing means.
From the code string before being combined by the code string combining means.
Extract common code patterns between at least two
Appear repeatedly in the extracted repetition code pattern
When there is one or more code patterns to be extracted,
From all repetition code patterns
By recursively extracting code patterns,
Stored in the code string storage means.
Extracted code patterns that appear repeatedly in the
It is characterized by putting out .

Further, the present invention, a seventh invention, according to the first, second or third invention, wherein the common code pattern extraction means is the common code pattern extraction means.
From the code string stored in the code string storage means,
Between at least two of the code strings before being joined by the joining means
When extracting code patterns common to
The section in which the code pattern appears in the original code sequence
Predetermine codes that do not match each other between any two
Extract code patterns by ignoring the specified number of times
Characterized in that it.

[0023]

In the user interface evaluation device according to the first to fourth aspects of the present invention, an erroneous operation pattern common to a plurality of user operation histories is extracted and output using an arbitrary repetition code pattern extraction method.

More specifically, unnecessary unit operation data defined by the operation filter is first removed from all operation histories. However, the operation histories used are the operation histories of two or more users and the operation histories (reference operation histories) recorded when the designer or evaluator of the dialogue system operated the dialogue system according to the correct procedure. .

Next, a plurality of operation patterns having the same meaning in all operation histories are replaced with representative patterns.
For example, if three different operation patterns P, Q, and R are operation patterns having the same meaning, and if a representative pattern among these three is P, the operation patterns Q and R that appear in all operation histories are Replace with P.

Next, all operation histories are converted into a code string while one code corresponds to one unit operation data one-to-one. Further, a code serving as an identifier of the original operation history is added to the end of each code string.

Next, all the code strings obtained by converting the operation history are connected in series in an arbitrary order to form one code string.

Next, the repetition code pattern in this code sequence is extracted by using an arbitrary repetition code pattern extraction method. Since the target code string is created from a plurality of operation histories, the extracted repetition code pattern indicates an operation pattern common to the operation histories. Therefore, this repetition code pattern is also called a common code pattern. If a certain common code pattern also appears in a code string obtained from the reference operation history, this common code pattern represents a correct operation pattern. vice versa,
If a certain common code pattern does not appear in the code sequence obtained from the reference operation history and only appears in the code sequence obtained from the user operation history, this common code pattern
Indicates an erroneous operation pattern. However, the reference operation history to be used does not have to exist for the correct operation procedure of all combinations. The problem is whether the common operation pattern also appears in the reference operation history,
Since the appearance section may be arbitrarily set, even if the correct operation procedure has arbitrariness in the order, all combinations thereof are not required. Further, even when a plurality of different operation patterns having the same meaning are all correct, since all of these operation patterns are replaced with the representative patterns, all of these combinations are not required. That is, when recording the reference operation history, the operation may be performed according to any one of the correct answer procedures of all the combinations.

Next, each code in the common code pattern is restored to the original unit operation data, and the common code pattern is converted into a common operation pattern. Of the common operation patterns, only the erroneous operation patterns (patterns that do not appear in the reference operation history but appear only in the user operation history) are output to the output device.

As described above, by using the user interface evaluation device according to the first to fourth aspects of the present invention, even when the correct operation procedure has an arbitrary order or a plurality of operation procedure options are available, a plurality of operation procedures can be selected. An erroneous operation pattern common among users can be appropriately extracted.

Further, in the iterative code pattern extraction method that can be used in the present invention, any two appearance sections [a, b] of the repetitive code pattern extracted by the conventional method are used .
[C, d] overlaps with [c, b] (where c ≦
b) In this case, the duplicate model is applied to the code string of [a, d]. This duplication model expresses this structure, paying attention to the fact that the appearance sections of the repetition code patterns extracted by the conventional method always have a certain structure. By applying the duplicate model, a code sequence that corresponds to a component of the model is identified, and based on the identified code sequence, the repetitive code pattern is corrected so that the occurrence sections do not overlap.

By using this repetitive code pattern extraction method, it is possible to extract patterns whose appearance sections do not overlap.

Further, in the iterative code pattern extraction method that can be used in the present invention , first, the conventional method is applied to the original code sequence to extract the first iteration code pattern. Next, the conventional method is further applied to each of the repeated code patterns extracted at the i-th time to extract the (i + 1) -th repeated code pattern (i is an integer of 1 or more). This recursive cycle is repeated until no new repetition code pattern is extracted.

With this repetition code pattern extraction method, a repetition code pattern having a larger number of repetitions included in the repetition code pattern can be extracted, so that both the pattern length and the repetition number can be emphasized. .

Furthermore, in the iterative code pattern extraction method that can be used in the present invention, when a code sequence is expanded into a tree structure by a conventional method, a code pattern whose code pattern does not match another code pattern can be used. Is ignored a predetermined number of times. As a result, conventionally, when a code that does not match first appears, the code pattern becomes the terminal node of the tree, so that only a strictly matching pattern can be extracted. However, in the method of the present invention, the code pattern is The timing to make the terminal node is postponed by a predetermined number of times.

By using this iterative code pattern extraction method, it becomes possible to extract a pattern that matches vaguely.

Further, the user interface evaluation device according to the eighth to tenth aspects uses the iterative code pattern extraction method according to the fifth to seventh aspects of the present invention. Therefore, it is possible to extract a pattern in which the appearance sections do not overlap, to attach importance to both the pattern length and the number of repetitions, and to construct a user interface evaluation device capable of extracting a vaguely matching pattern.

[0038]

Next, embodiments of the present invention will be described with reference to the drawings. However, in the present embodiment, characters are used instead of codes to simplify the notation in the drawings. One code represents one character, and the code and the character correspond one-to-one.

FIG. 1 is a block diagram showing one embodiment of the user interface evaluation device of the first to fourth inventions.

The user interface evaluation device 10 is connected to the operation history storage device 100 and the output device 112.

The operation history storage device 100 stores one reference operation history and a plurality of user operation histories. FIG. 2 shows examples of these operation histories. The operation history of FIG. 2 is an example of an operation history of a dialog system having a graphical user interface composed of components such as windows, icons, menus, buttons, and the like. In FIG. 2, reference numeral 20 denotes a reference operation history of a certain work, and 21 to 2
Reference numeral 4 denotes an operation history recorded when four users respectively perform this work. In each operation history, the line surrounded by <> indicates the operation history name,
Each other line represents unit operation data. The unit operation data is composed of a pair of a command and a component identifier. For example, the unit operation data 201 is such that the command is Menu
, The component identifier is mnu13, indicating that the menu item of the component identifier mnu13 has been selected. Similarly, the unit operation data 202 indicates that the command is Bu
In ton, the part identifier is btn08, indicating that the button of the part identifier btn08 has been pressed. The same applies to other unit operation data.

The operation filtering means 101 reads the operation history from the operation history storage device 100 and removes the unit operation data defined in advance. The unit operation data to be removed is defined by the operation filter stored in the operation filter storage unit 102. FIG. 3 shows an example of the operation filter. In the operation filter 30 of FIG. 3, the symbol * of the unit operation data 301 indicates that the item is optional. Therefore, reference numeral 301 denotes that the command removes all the WinMove unit operation data without depending on the component identifier. The definition of other unit operation data in 30 is the same. The operation filtering means 101 reads the operation histories 20 to 24 of FIG. 2 and the operation filter 30 of FIG.
44 is output.

The operation pattern replacement means 103 refers to a previously defined operation pattern replacement table in the operation history output from the operation filtering means 101 and replaces one operation pattern with another operation pattern. This operation pattern replacement table is stored in the operation pattern replacement table storage unit 104. FIG. 5 shows an example of the operation pattern replacement table. In the operation pattern replacement table 50, a plurality of operation patterns described in the same numbered line have the same meaning. Further, among the plurality of operation patterns shown on the same line, the operation pattern described at the leftmost is a representative pattern for those operation patterns. If the operation history output by the operation filtering means 101 includes an operation pattern that matches the pattern to be converted, the operation pattern is replaced with a corresponding representative pattern. For example, if there is an operation pattern that matches 502 or 503 in FIG. 5, the operation pattern is replaced with a representative pattern 501. The same applies to the set of patterns described in the other lines. The operation pattern replacement means 103 reads the operation histories 40 to 44 of FIG. 4 and the operation pattern replacement table 50 of FIG. 5, and outputs operation histories 60 to 64 shown in FIG.

The coding means 105 converts the operation history output from the operation pattern replacement means 103 into a code string corresponding one-to-one. More specifically, all the unit operation data in the operation history is converted into a one-to-one corresponding code. Further, a code serving as an identifier of the operation history name is added to the end of each code string. Further, a pair of the unit operation data and the code is registered in the code table. This code table is stored in the code table storage means 106. The coding unit 105 converts the unit operation data into a code with reference to the code table in order to make the correspondence between the unit operation data and the code one-to-one. For example, the operation histories 60 to 64 in FIG. 6 are converted into code strings 70 to 74 shown in FIG. 7, respectively. FIG. 8 shows a code table generated at this time. The code table is not prepared in advance, and each time a new code is used, a pair of the code and the unit operation data is registered. For example, the code table 80 in FIG. 8 indicates that the code “A” of 801 has been assigned to the unit operation data (Menu, mnu13) of 802. The other pairs are similar.

The code string combining means 107 serially combines the code strings output from the coding means 105 in an arbitrary order into one code string. For example, the code strings 70 to 74 in FIG. 7 are combined into one to form the code string shown in FIG. However, the code strings in FIG. 9 are an example in which the code strings are combined in the order of 70 to 74, and the code strings 90 and 91 are connected by "" and "". The code string output by the code string combining means 107 is stored in the code string storage means 108.

The common code pattern extraction means 109 reads the code string stored in the code string storage means 108,
Using any repetitive code pattern extraction method, code patterns that appear repeatedly in this code sequence are extracted. 10
8 is generated from a plurality of user operation histories, code patterns that appear repeatedly in the code sequence correspond to operation patterns common to a plurality of users. ing. Therefore, the repetition code pattern can be called a common code pattern. A pattern that repeatedly appears in only one user operation history can be similarly extracted. In the present embodiment, such a pattern is regarded as a special case of the common operation pattern and is collectively handled. Alternatively, a pattern that repeatedly appears in only one user operation history can be strictly distinguished from a common operation pattern among a plurality of users and removed.

In this embodiment, as an iterative code pattern extraction method, ACM Transactions on Information Systems (ACM Transa) is used.
actions on Information Sys
tems), Vol. 9, No. 4 (October,
1991), pp. 309-335 will be described. (Of course, the iterative code pattern extraction method of the fifth to seventh inventions described later may be used instead of the conventional method.) ). FIG. 10 shows a flow chart of the processing of this conventional method.

In St101, the target code string is expanded into a tree structure. In this tree structure, a link connecting nodes corresponds to a code, and a node corresponds to a code pattern and its appearance section. The links connecting the head node and its child nodes are generated by the number of different codes included in the code sequence. Also, assuming that the length of the code string is n, the terminal node (a node having no child nodes) is n
Are generated.

In St102, a candidate for a solution of an iterative code pattern is obtained using the expanded tree. Specifically, the parent node of each terminal node represents a pattern candidate.

In St103, the inclusion relation of the appearance section of the pattern is examined among these candidates, and the candidates whose appearance sections are all included in other candidates are removed. As a result, the remaining repetition code pattern is the solution to be found.

As an example, consider the case of the code string "abcabcxab" of 111 shown in FIG. However, the number described above the code string indicates the position of each code in the code string. For example, the code “x” indicates that it is the seventh code from the head. FIG. 12 shows a tree generated based on this code sequence. Since the code string 111 includes four different codes (“a”, “b”, “c”, “x”), the head node has four links corresponding to these codes. . Also, since the length of the code string 111 is 9, the number of terminal nodes is nine.

In the tree shown in FIG. 12, reference numeral 120 is the first node. A code “b” corresponds to the link 123 connecting the nodes 121 and 122. The same applies to other links. The node 122 is the first node 1
A code pattern “ab” represented by a link from 20 to this node is defined as a section [1, [1] in the original code sequence.
2], [4, 5], and [8, 9]. The same applies to other nodes except the first node (the first node does not correspond to a code pattern). Links and child nodes are generated in order from the first node,
When the number of appearance sections of the code pattern represented by the node becomes one, the node becomes a terminal node. For example, the node 124 indicates that the code pattern “bcx” appears in the section [5, 7], and is a terminal node since there is one appearance section. Further, the appearance section of the code pattern of length 1 is expressed as a section where the lower limit and the upper limit are equal. For example, the node 125 has a code pattern “x”
Appear in the section [7, 7] (that is, position number 7). “＄” is a code representing the end of the code string 111 (hereinafter, “＄” is used similarly).

Next, candidates for the repetition code pattern are obtained from this tree. The parent node of each terminal node represents a code pattern that appears twice or more in the original code sequence (except when the parent node of the terminal node is the first node). These code patterns are candidates for the repeated code pattern. In the example of the tree shown in FIG. 12, nodes 122 and 126 to 129 are nodes corresponding to the candidates. That is, five code patterns “ab” (section [1,
2], [4,5], [8,9]), “abc”
(Appears in sections [1,3] and [4,6]), "b" (appears in sections [2,2], [5,5], [9,9]), "b
c "(appears in the section [2, 3], [5, 6])," c "
(Appearing in sections [3, 3] and [6, 6]) are candidates for the repeated code pattern. If any of these candidates includes at least one occurrence section in at least one other candidate, the candidate is removed. For example, in the five candidates, the appearance section of “b” is all included in the appearance section of “ab”. Therefore, "b" is removed. Similarly, “bc” and “c” are both removed because “abc” includes all occurrence sections. As a result, the remaining "ab" and "abc" are the solutions of the repetition code pattern to be obtained.

Using the repetitive code pattern extraction method described above, the common code pattern extraction means 109
A repetition code pattern (common code pattern) is extracted from the code strings 90 and 91 (actually connected to one) in FIG. First, from the code string of FIG.
The tree shown in FIG. 6 is generated. Actually, these trees are one, and the first node 130 of each tree represents the same node. However, since the size of the tree is large, it is shown separately in FIGS. In these trees, parent nodes of the terminal node (nodes 131 to 134,
141 to 143, 151, 152, 161 to 163), the candidates for the repeated code pattern shown in FIG. 17 are obtained.
Of these candidates, “Iue”, “Ue” and “E”
Is deleted because all the appearing sections are included in the “aiue”. Similarly, “kiku” and “ku” (included in “kakiku”), “su” (included in “cis”), and “chi” and “tsu” (included in “tatsuki”) are erased. . As a result, the remaining one is the solution of the iterative code pattern to be obtained. This is shown in FIG.

The restoring means 110 is provided with the code table storing means 10
6 and the code string stored in the code string storage means 108, the individual codes in the common code pattern (repeated code pattern) output by the common code pattern extraction means 109 are By restoring the original unit operation data, the common code pattern is converted into the common operation pattern, and the appearance section of the common operation pattern in the operation history is obtained. For example, the four code patterns in FIG. 18 can be obtained by referring to the code table 80 in FIG.
Is restored to the operation pattern shown in FIG. Further, from the code table 80 in FIG. 8, the codes "q", "sa", "so", "na",
“N” is the operation history name std. log, usr0
1. log to usr04. Since it is understood that the data represents the log, in the code strings 90 and 91 in FIG. 9, the sections [1, 8], [10, 17], [19, 28], [3]
[0, 43] and [45, 54] are the operation history st
d. log, usr01. log to usr04. log
It can be seen that Using this, the appearance section of each operation pattern in FIG. 19 is converted into an appearance section for each operation history as shown in FIG.

From FIG. 20, the common operation patterns of Nos. 1 and 2 are the standard operation history std. log, it can be seen that the operation pattern is the correct operation pattern. Conversely, the common operation pattern of numbers 3 and 4 is std. Since it does not appear in the log, it can be seen that it is an erroneous operation pattern.

The output control means 111 shapes and outputs only erroneous operation patterns from the common operation patterns output by the restoration means 110. For example, when the output device 112 is a printer and the common operation pattern shown in FIG. 20 is output (printed) in a text format, the processing result shown in FIG. 21 is output. In the output example of FIG. 21, not only the common operation pattern and the appearance section for each operation history, but also the length of the pattern,
It shows the degree of commonality between users (what percentage of all users performed this operation pattern). The output control means 111 may shape and output the common operation pattern into a table, a graph, or the like instead of a text format.

Next, embodiments of the fifth to seventh inventions will be described with reference to the drawings. Further, the eighth to tenth inventions are the first to third inventions that can use the iterative code pattern extraction method of the fifth to seventh inventions, and
The individual embodiments of the tenth invention will be omitted.

FIG. 22 is a flowchart showing a process according to an embodiment of the iterative code pattern extraction method according to the fifth invention. The processing unit 220 represents a new process for solving the problem of the conventional method.

First, at St 221, ACM Transactions on Information Systems (ACM Transactions on Information Systems)
formation Systems), Vol. 9,
No. 4 (October, 1991), pp. 309-3
Using a conventional method described on page 35, a code pattern P [i] that repeatedly appears in a code string is extracted. Here, i is a pattern number, and when the number of extracted patterns is n, i = 1 to n. When no repetition code pattern is extracted, P
[I] does not exist.

As an example, if the code string is "abcabcab"
Consider the case of c ″. From this code string, a tree shown in FIG. 23 is generated. Node 230 in this tree
From 235 to 235, a candidate for the repeated code pattern shown in FIG. 24 is extracted. Among these candidates, the appearance section of “abcabc” includes all the appearance sections of other candidates, so that only “abcabc” remains, and all other candidates are removed. As a result, the remaining pattern P [1] =
“Abcabc” is the repeated code pattern extracted by the conventional method. This is shown in FIG. In FIG.
The appearance section of “abcabc” is [1, 6] and [4, 9]
Therefore, “abc” appearing in the section [4, 6]
Are found to be duplicated. This is shown in FIG.

In St222, among the patterns extracted by the conventional method, those having an overlap in the appearance section are found.
In the example of “abcabcabc”, since the appearance sections of the extracted code pattern P [1] = “abcabc” overlap, P [1] is set to P ′ [1].

In St223, it is checked whether one or more P '[i] exist. When there is no such pattern, there is no overlap in the appearance intervals in all the repetition code patterns extracted by the conventional method, so these patterns are used as solutions. On the other hand, when one or more P '[i] exists, for each P' [i], an overlapping model, which is a general type of overlapping, is applied to two overlapping overlapping sections, and The component is identified (St224). This overlapping model is shown in FIG. In FIG. 27, A represents an arbitrary code string having a length of 1 or more, B represents an arbitrary code string having a length of 0 or more, and A ≠ B. However, when the length of the code string is 0, it indicates that the code string does not actually exist. That is, when the length of B is 0, the overlapping model shown in FIG. 27 matches FIG. In the overlapping model of FIG. 27, the code patterns 270 and 271 are the extracted repetition code patterns, and overlap in the section of 272. Further, this overlapped portion includes m code strings A.
Due to the characteristics of the conventional method, this form is always used when the extracted repetition code pattern has overlapping occurrence sections.

When the overlapping model shown in FIG. 27 is applied to the example of the repetition code pattern shown in FIG. 26 and the components A and B of the model are identified, A = “abc”, B
= "" (Code sequence of length 0). In addition, the number m of occurrences of A in the overlapping section is one.

In St 225, P ′ [i] and its appearance section are corrected according to the result of St 224 and the correction rule of the code pattern so as to eliminate duplication. FIG. 29 shows an example of a code pattern correction rule. As a result of identifying the code strings A and B, if the length of B is 0, P ′ [i] = A. This code pattern appears m times consecutively in the overlapping portion 280 in FIG. 28, and appears once each before and after this m times, so that it appears a total of (m + 2) times. On the other hand, if the length of B is 1 or more, P ′
[I] = AB. This code pattern is shown in FIG.
7, (m-1) times consecutively appear in the overlapping portion 272, and once each before and after the (m-1) times, it appears a total of (m + 1) times. For example, in the example of the repetition code pattern shown in FIG.
Since “abc” and the length of B are 0, P ′ [1] =
"Abc". The number of appearances is (1 + 2) = 3 since m = 1. The appearance sections of “abc” are [1, 3], [4, 6], and [7, 9]. Therefore, the iterative pattern P [1] = “a” extracted by the conventional method
bcabc "(appearing in [1,6], [4,9]) is P '[1] =" abc "([1,
3], [4, 6] and [7, 9]).

Next, FIG. 30 is a flowchart showing a process according to an embodiment of the iterative code pattern extraction method according to the sixth invention.
The processing unit 300 represents a new process for solving the problem of the conventional method.

First, in St301, 1 is substituted for a variable i.

Next, in St302, a primary repetition code pattern P (1) [j] is extracted using a conventional method.
Here, j = 1 to n (1) (that is, n (1) is P
(1) represents the number of [j]).

As an example, if the code string is “xabyabxa
31. At this time, the tree shown in FIG. 31 is generated from this code string. From the nodes 310 to 315 in this tree, candidates for the repeated code pattern shown in FIG. 32 are extracted. Of the candidates,
Since the appearance section of “xabyab” includes all the appearance sections of other candidates, only “xabyab” remains, and all other patterns are removed. As a result,
The remaining P (1) [1] = “xabyab” (the number of repetitions is two) is a repetition code pattern (1
Next). This is shown in FIG. On the other hand, “ab” is repeated four times in the original code sequence, and P (1)
[1] is repeated more than once, but all occurrences are P
(1) Since it is included in [1], it is not extracted by the conventional method.

At St303, it is determined whether or not one or more i-th repetition code patterns have been found (i is an integer of 1 or more). If found, the process proceeds to St304, and if not found, the process ends.

At St304, the (i + 1) -th order code pattern is extracted from all the i-th order code patterns by using the conventional method. This recursive cycle (S
t303 to St305) are repeated until a new repetition code pattern is not extracted.

In the example of the code string "xabyabxabyab", the first-order repetition code pattern "x
A secondary repetition code pattern is extracted from "abyab". A tree generated from "xabyab" is shown in FIG.
It is shown in FIG. From node 340 in this tree, FIG.
5 are extracted. Next, if there is any other candidate that includes all of the appearance sections among these candidates, it is removed. In the example shown in FIG. 35, since there is no such candidate, the pattern becomes the secondary repetition code pattern as it is. . This is shown in FIG. However, the appearance section of the secondary repetition code pattern is not an appearance section in the primary repetition code pattern, but an appearance section in the original code sequence. This appearance section is 2 in the original code sequence.
Instead of searching for the next iteration code pattern,
It is obtained using the section where the next repetition code pattern appears in the original code sequence. For example, "xabyabxabyab"
It is known that the primary repetition code pattern “xabyab” appears in [1, 6], [7, 12], and the secondary repetition code pattern “ab” appears in “xabyab”. Appear in [2, 3] and [5, 6], “ab” becomes “xabyabxabby”.
ab ", [2, 3], [5, 6], [8,
9] and [11, 12]. The appearance section in the original code sequence of the third or higher order repetition code pattern is obtained in the same manner.

Next, an attempt is made to extract a tertiary repetition code pattern from the secondary repetition code patterns shown in FIG.
However, it is clear that there is no repetition code pattern in "ab". Since no new pattern was found in the third iteration of the code pattern extraction process, the process ends at this point. The repetition code pattern extracted as a result is “xabyab” ([1,6], [7,1
2]) and “ab” ([2, 3], [5, 6],
[8, 9] and [11, 12]).

Next, FIG. 37 is a flowchart showing a process according to an embodiment of the method for extracting a repetitive code pattern according to the seventh aspect of the present invention.
The processing unit 370 represents a new process for solving the problem of the conventional method.

In St371, an integer equal to or greater than 0 is substituted for a variable r.

At St372, the code string is expanded into a tree structure. However, the difference from the conventional method is that, for all terminal nodes, r codes that cause the nodes to be terminated are ignored. In other words, the timing at which a node becomes a terminal node is postponed r times, and (r
Make that node the terminal node at the +1) th time. However,
If the code that causes the termination of the node is the code “＄” representing the end of the code string, the code is set to the terminal node at that time regardless of the value of r.

As an example, if the code string is “abxcdeab
In the conventional method, a tree shown in FIG. 38 is generated from this code string. From the nodes 380 to 383 in this tree, candidates for the repeated code pattern shown in FIG. 39 are extracted. Among the candidates, there is no candidate whose appearance section is entirely included in the other candidates, so there are no candidates to be deleted, and all candidates are determined as repetition code patterns. This repetition code pattern is shown in FIG. .

On the other hand, in the method for extracting a repetitive code pattern according to the seventh aspect of the present invention, the code string “abxcdabyceazbc”
From this, a tree shown in FIG. 41 is generated. However, FIG.
Is a case where r = 1 is set. The terminal nodes 410 to 412 in FIG. 41 are [1,5] of the original code sequence,
In [7, 11] and [12, 16], it indicates that the code of the position number surrounded by () is ignored. For example, the terminal node 410 is [1, 5] of the original code sequence.
In the code string “abxcd” appearing in the above expression, the code “x” is ignored. In the conventional method, the node of [1, 3] becomes a terminal node due to the code “x” (the terminal node 384 in FIG. 38 represents this), but here, r = 1 is set. Therefore, the code that causes the node to be terminated is ignored only once (in other words, when the code that does not match the other appears the second time, it is set as the terminal node). Other end node 41
1, 412 is the same. FIG. 42 shows the code patterns represented by these end nodes and the ignored codes. FIG.
The second code patterns 420 to 422 correspond to the end nodes 410 to 412 in FIG. 41, respectively, and the underlined codes are ignored codes. The same applies to the symbol () in the other nodes in FIG.

The nodes 413 to 4 in the tree of FIG.
From 15, candidates for the repetition code pattern shown in FIG. 43 are extracted. Of these candidates, the appearance section of “abc” includes all the appearance sections of the other candidates, so “a”
bc ", and all other candidates are removed. As a result, the remaining pattern" abc "becomes a repetition code pattern, which is shown in Fig. 44. The appearance section of this pattern is [1,4]. , [7,10], [12,15], and the ignored codes are “x” (position number 3),
“Y” (position number 9) and “z” (position number 13).

[0080]

As described above, the use of the user interface evaluation device according to the first to fourth aspects of the present invention makes it possible to select a correct operation procedure in an arbitrary order or to select a plurality of operation procedures. Even in some cases, it is possible to appropriately extract an erroneous operation pattern common to a plurality of users. Also,
The use of the repetitive code pattern extraction method according to the fifth aspect makes it possible to extract a pattern in which appearance sections do not overlap. In addition, if the repetition code pattern extraction method of the sixth invention is used, both the pattern length and the number of repetitions can be emphasized.
Further, if the iterative code pattern extraction method of the seventh invention is used, it is possible to extract a pattern that matches vaguely. Further, by using the user interface evaluation device according to the eighth to tenth aspects, it is possible to construct a user interface evaluation apparatus using the above-described repetition code pattern extraction method according to the fifth to seventh aspects.

[Brief description of the drawings]

FIG. 1 is a block diagram showing one embodiment of a configuration of a user interface evaluation device of the present invention.

FIG. 2 is a diagram showing an embodiment of an operation history of the user interface evaluation device of the present invention.

FIG. 3 is a diagram showing an embodiment of an operation filter of the user interface evaluation device of the present invention.

FIG. 4 is a diagram showing an embodiment of an operation history after operation filtering of the user interface evaluation device of the present invention.

FIG. 5 is a diagram showing an embodiment of an operation pattern replacement table of the user interface evaluation device of the present invention.

FIG. 6 is a diagram showing an embodiment of the operation history after the operation pattern replacement of the user interface evaluation device of the present invention.

FIG. 7 is a diagram showing an embodiment of a code sequence after the coding process of the user interface evaluation device of the present invention.

FIG. 8 is a diagram showing an embodiment of a correspondence table between unit operation data and codes of the user interface evaluation device of the present invention.

FIG. 9 is a diagram showing an embodiment of a code string after code string combining processing of the user interface evaluation device of the present invention.

FIG. 10 is a flowchart showing an example of an iterative code pattern extraction method of the user interface evaluation device of the present invention.

FIG. 11 is a diagram showing an embodiment of a code sequence of the user interface evaluation device of the present invention.

FIG. 12 is a diagram showing an example of a tree of a code string of the user interface evaluation device of the present invention.

FIG. 13 is a diagram illustrating an example of a code string tree of the user interface evaluation device of the present invention.

FIG. 14 is a diagram showing an example of a code string tree of the user interface evaluation device of the present invention.

FIG. 15 is a diagram showing an example of a code string tree of the user interface evaluation device of the present invention.

FIG. 16 is a diagram showing an example of a tree of a code string of the user interface evaluation device of the present invention.

FIG. 17 is a diagram showing an example of a candidate for a repeated code pattern of the user interface evaluation device of the present invention.

FIG. 18 is a diagram showing an example of a repeated code pattern of the user interface evaluation device of the present invention.

FIG. 19 is a diagram showing an example of a common operation pattern of the user interface evaluation device of the present invention.

FIG. 20 is a diagram showing an example of a common operation pattern of the user interface evaluation device of the present invention.

FIG. 21 is a diagram illustrating an example of an output result of a common operation pattern of the user interface evaluation device of the present invention.

FIG. 22 is a flowchart showing one embodiment of a processing flow of an iterative code pattern extraction method according to the fifth invention of the present invention;

FIG. 23 is a diagram showing an example of a code string tree according to an embodiment of the fifth invention.

FIG. 24 is a diagram showing an example of a candidate for a repeated code pattern in one embodiment of the fifth invention;

FIG. 25 is a diagram showing an example of a repetition code pattern in one embodiment of the fifth invention.

FIG. 26 is a diagram showing an example of a repetition code pattern according to an embodiment of the fifth invention.

FIG. 27 is a diagram showing an example of an overlapping model of a repetition code pattern in one embodiment of the fifth invention.

FIG. 28 is a diagram showing an example of an overlapping model of a repetition code pattern according to an embodiment of the fifth invention.

FIG. 29 is a diagram showing an example of a repetition code pattern modification rule in one embodiment of the fifth invention.

FIG. 30 is a flowchart showing an embodiment of a processing flow of an iterative code pattern extraction method according to the sixth invention of the present invention;

FIG. 31 is a diagram showing an example of a code string tree in one embodiment of the sixth invention.

FIG. 32 is a diagram showing an example of a candidate for a primary repetition code pattern according to an embodiment of the sixth invention.

FIG. 33 is a diagram showing an example of a primary repetition code pattern according to an embodiment of the sixth invention.

FIG. 34 is a diagram showing an example of a code string tree in one embodiment of the sixth invention.

FIG. 35 is a diagram showing an example of a candidate for a secondary repetition code pattern in one embodiment of the sixth invention.

FIG. 36 is a diagram showing an example of a secondary repetition code pattern in one embodiment of the sixth invention.

FIG. 37 is a flowchart showing an embodiment of a processing flow of an iterative code pattern extraction method according to the seventh invention of the present invention;

FIG. 38 is a diagram of a tree of code strings in a conventional iterative code pattern extraction method.

FIG. 39 is a diagram of a candidate for a repeated code pattern in a conventional repeated code pattern extraction method;

FIG. 40 is a diagram of a repetition code pattern in a conventional repetition code pattern extraction method.

FIG. 41 is a diagram showing an example of a code string tree according to an embodiment of the seventh invention.

FIG. 42 is a diagram showing an example of a code pattern according to an embodiment of the seventh invention.

FIG. 43 is a diagram showing an example of a candidate for a repetition code pattern according to an embodiment of the seventh invention;

FIG. 44 is a diagram showing an example of a repetition code pattern according to an embodiment of the seventh invention.

[Explanation of symbols]

10 User interface evaluation device 20, 40, 60 Reference operation history 21, 22, 23, 24, 41, 42, 43, 44, 6
1, 62, 63, 64 User operation history 30 Operation filter 50 Operation pattern replacement table 70, 71, 72, 73, 74 Code string after coding processing 80 Correspondence table of unit operation data and code 90, 91 Code string combining processing Subsequent code string 100 Operation history storage device 101 Operation filtering means 102 Operation filter storage means 103 Operation pattern replacement means 104 Operation pattern replacement table storage means 105 Encoding means 106 Code table storage means 107 Code string combining means 108 Code string storage means 109 Common code pattern extraction means 110 Restoration means 111 Output control means 112 Output device 111 Code string 120,130 Top node 121 Node 123 Link 122,126,127,128,129,131,1
32,133,134,141,142,143,15
1,152,161,162,163,230,23
1,232,233,234,310,311,31
2,313,314,315,340,380,38
1,382,383,413,414,415 Parent node of terminal node 124,125,410,411,412 Terminal node 201,202 Unit operation data 220,300,370 New processing unit 270,271,420,421 422 Code pattern 272, 280 Overlapping part 301 Unit operation data 501 Representative pattern 502, 503 Pattern to be converted 801 Code 802 Unit operation data

Claims (7)

(57) [Claims] 1. A user interface evaluation device that evaluates the operability of a dialog system using an operation history obtained by recording an operation performed by the user when the user operates a dialog system having a user interface unit. An operation filtering unit that removes unit operation data defined by an operation filter from the operation history; an operation filter storage unit that stores the operation filter; and an operation pattern that appears in the operation history. An operation pattern replacement unit that replaces with another operation pattern according to the pattern replacement table; an operation pattern replacement table storage unit that stores the operation pattern replacement table; and each unit operation data in the operation history has a one-to-one correspondence. Coding means for converting the code into a code and creating a correspondence table between the unit operation data and the code; Code table storage means for storing the correspondence table between the unit operation data and the code created in the above, and code string connecting means for serially connecting a plurality of code strings obtained by converting the plurality of operation histories by the coding means. At least two of a code string storing means for storing a code string output by the code string combining means, and a code string before being combined by the code string combining means from the code strings stored in the code string saving means. Common code pattern extracting means for extracting a common code pattern between the unit and each code in the common code pattern by referring to a correspondence table between unit operation data and codes stored in the code table storing means, Restoring means for restoring operation data and restoring the common code pattern to a common operation pattern; and output control means for controlling output of the common operation pattern. A user interface evaluation device characterized by being formed. 2. A plurality of operation patterns having the same meaning are registered in the operation pattern replacement table held by the operation pattern replacement table storage means, and one of the plurality of operation patterns is registered as a representative pattern. 2. The user according to claim 1, wherein the operation pattern replacement unit refers to the operation pattern replacement table and replaces a plurality of operation patterns having the same meaning with a representative pattern corresponding to the operation pattern. 3. Interface evaluation device. 3. The user interface evaluation device according to claim 1, wherein said coding means further adds a code serving as an identifier of the code string to the end of the code string. 4. The method according to claim 1, wherein said common code pattern extracting means includes a code
Extract code patterns that appear repeatedly in a column
The code string stored in the code string storage means
Thus, the number of code strings before being combined by the code string combining means is reduced.
User interface evaluation apparatus according to claim 1, 2 or 3, characterized in the this <br/> to extract common code pattern between the two even without. 5. The common code pattern extracting means extracts a code pattern common between at least two code strings before being combined by the code string combining means from the code strings stored in the code string storing means. When the extracted repeated code pattern has an overlap between the sections in which the extracted code sequence appears in the original code sequence, by applying a model of the overlap and correcting it to a repeated code pattern having no overlap, the code 4. The user interface evaluation device according to claim 1, wherein a code pattern that repeatedly appears in a code sequence stored in the code sequence storage unit stored in the sequence storage unit is extracted. 6. The common code pattern extracting means extracts a code pattern common to at least two of the code strings before being combined by the code string combining means from the code strings stored in the code string storing means. When there is one or more code patterns that repeatedly appear in the extracted repetition code pattern, the code pattern that appears repeatedly in all of the extracted repetition code patterns is recursively determined. 3. A code pattern repeatedly appearing in a code string stored in the code string storage means stored in the code string storage means is extracted by extracting the code pattern. 4. The user interface evaluation device according to 3. 7. The common code pattern extracting means extracts a code pattern common to at least two of the code strings before being combined by the code string combining means from the code strings stored in the code string storing means. In this case, a code pattern is extracted by ignoring, for a predetermined number of times, codes that do not match each other between any two of the sections where the extracted repeated code pattern appears in the original code sequence. The user interface evaluation device according to claim 1, 2 or 3, wherein: