JP7422367B2 - Approximate string matching method and computer program for realizing the method - Google Patents

Description

The present invention relates to an approximate character string matching technique, and in particular to an approximate character string matching device and an approximate string matching method that can be used in human genome analysis, and a computer program for implementing the method.

The human genome is a set of genetic information possessed by humans, and the substance that carries this information is DNA (deoxyribonucleic acid), which is a chain of about 3 billion pairs of bases. The bases include adenine (A), guanine (G), cytosine (C), and thymine (T). That is, a person's genetic information is determined by the arrangement (sequence) of these bases.

A device called a sequencer is used to read the human genome. A sequencer reads a sample of the human genome, shreds it into pieces of a predetermined upper limit (about several hundred base pairs), amplifies it, and outputs it as a huge data array made up of data pieces. Current sequencers can read the human genome for one person in about an hour.

The disparate pieces of data read out by the sequencer are compared with the human genome reference sequence, which has been defined as the standard human genome sequence, to reconstruct and analyze the original length human genome sequence. For example, the position of each data piece in comparison with the human genome reference sequence is investigated (mapping), and the types of mutations present are analyzed. Normally, data read from a sequencer contains errors, so errors are reduced by performing statistical processing using, for example, 30 times as much redundant data as one human genome sequence per sample. Therefore, since an enormous amount of calculation is required to analyze the human genome sequence, a high-performance computer such as a supercomputer, a cluster computer, or an FPGA (Field-Programmable Gate Array)-based computer is typically used.

A program tool such as BWA (Burrow-Wheeler Aligner) is used to map data pieces. BWA consists of three algorithms: BWA-backtrack, BWA-SW, and BWA-MEM. Among these, BWA-MEM is widely used as a high-speed algorithm compatible with indels (insertions and deletions). BWA-MEM is an algorithm that uses a suffix array to create an index and perform mapping for parts that repeatedly appear in the human genome reference sequence among query strings based on read data pieces (Non-patent Document 1). ).

Furthermore, the data pieces are compared with partial sequences of the human genome reference sequence obtained through mapping, and the types of mutations are analyzed. For example, an alignment algorithm is used to match a partial sequence of the human genome reference sequence with a piece of data. In the alignment algorithm, approximate character strings are identified while calculating the degree of variation (degree of similarity) for each element of an array called an alignment table, according to dynamic programming (Non-Patent Document 2).

Heng Li, “Aligning sequence reads, clone sequences and assembly contigs with BWA-MEM”, May 26, 2013, arXiv:1303.3997 (q-bio.GN) Masao Uchiyama et al., “High-speed scanning method of suffix array for full text search using approximate string matching”, September 15, 2002, Information Processing Society of Japan, Vol. 43 No. SIG 9 (TOD 15)

The BWA-MEM described above is widely used as an algorithm that allows gaps and enables high-speed mapping, but it has the problem of requiring a large amount of memory resources because the size of the index created is very large. there were. In addition, in BWA-MEM, memory access is required a number of times according to the number of characters (i.e., number of bases) in the query string, so random access to memory occurs frequently, which causes processor processing There was a problem in that the speed was limited by the access time to the memory.

More specifically, in BWA-MEM, in order to identify the position where a substring (sometimes referred to as a "key") in a query string appears in the human genome reference sequence, Random access is performed as many times as the total number of characters in the query string. This is because the amount of data used to analyze the human genome is so large that the required data array cannot be accommodated all at once in a cache memory that can be accessed at higher speeds. Here, in current computers, the waiting time for one random access to main memory (the time from when the access occurs until the data is actually obtained) is approximately 1 μs (0.000001 seconds) per bank. ). Therefore, in the case of analyzing the human genome of 3 billion base pairs, assuming the redundancy is 30, the total access time T for the total number of characters is:
T=3,000,000,000×0.000001×30
=90,000 (seconds)
becomes. In other words, in analyzing the human genome, it would take about 90,000 seconds (about 25 hours) just to randomly access the main memory. For this reason, even if a computer equipped with a high-performance processor is used, the memory access time is limited, and there is a limit to reducing the mapping time.

Furthermore, as mentioned above, it currently takes about one hour to read out one person's human genome using a sequencer. On the other hand, when BWA-MEM is executed using a high-performance computer, mapping is completed within the sequencer read time, and the balance between the two is generally maintained.

On the other hand, it is said that next-generation sequencers have lower costs and can further shorten readout time, and along with this, it is desired that analysis time also be shortened. One possible approach to shorten analysis time is to further improve the performance of computers, but increasing the performance of computers requires a significant increase in cost, making it difficult to put this into practical use.

Furthermore, conventional alignment algorithms used to analyze mapped data pieces have the problem that the degree of variation is calculated for all elements in the alignment table, which increases the amount of calculation and takes time.

Therefore, an object of the present invention is to provide a new technique that can quickly and/or efficiently analyze given query data using reference data.

More specifically, one object of the present invention is to provide an approximate string matching device that can quickly and/or efficiently perform approximate string matching between a given query string and a reference string, and the same. The purpose of this invention is to provide an approximate string matching method using .

Another object of the present invention is to provide an approximate character string matching device that can quickly and/or efficiently perform analysis using a human genome reference sequence based on a data piece read out by a sequencer, and an approximate character string matching device using the same. The purpose is to provide a string matching method.

Another object of the present invention is to provide a technique for creating a hierarchical index based on reference strings that are compatible with the above-mentioned approximate string matching.

The present invention for solving the above-mentioned problems includes the following invention specific matters and technical features.

SUMMARY OF THE INVENTION According to one aspect, the invention is a computer program product for causing a computing device to implement a method for searching for an approximate string in a reference string based on a query string.
The method includes creating a hierarchical index based on the reference string, and using the hierarchical index to identify substrings in the reference string that match at least a portion of the query string. mapping the query string to the reference string; and deriving the approximate string based on at least one partial string identified by the mapping. .
Here, creating the hierarchical index involves cutting out each first key of a predetermined length from the reference character string, and using a predetermined hash function for each of the cut out first keys. creating a first key array to which a hash value calculated based on the key is assigned, updating the created first key array, and updating the updated first key array to the and outputting it as a hierarchical index.
Furthermore, updating the first key arrangement includes identifying, for each of the first keys in the first key arrangement, the number of occurrences of the first key in the reference character string. create a new first key by adding a first additional key to the first key according to the number of appearances of the first key; This includes updating the key layout of No. 1.

Creating the first key array may include sorting each of the first keys in the first key array according to the hash value.

Furthermore, updating the first keyboard layout includes determining whether the identified number of occurrences exceeds a predetermined tolerance value, and updating the first keyboard layout includes determining whether the identified number of occurrences exceeds a predetermined tolerance value. If it is determined that The method may include creating a first key and identifying, for the new first key, a number of occurrences of the first key in the reference string.

Moreover, updating the first keyboard layout may further include sorting the new first keys in the first keyboard layout according to the first additional keys.

Furthermore, updating the first key arrangement may include adding a new first key arrangement to the current first key until it is determined that the identified number of occurrences does not exceed a predetermined tolerance value. The method may include creating a new first key by sequentially adding additional keys.

Further, outputting the keyboard layout as the hierarchical index may include outputting the current keyboard layout as the hierarchical index when it is determined that the identified number of appearances does not exceed a predetermined tolerance value. may include outputting.

Performing the mapping includes cutting out each second key of a predetermined length from the query string, and using the predetermined hash function to calculate each second key cut out from the query string. creating a second key array to which a hash value calculated based on the key is assigned; and for each second key, referencing the hierarchical index at a predetermined sampling interval according to the hash value. , identifying the starting position and number of occurrences of the second key.

Identifying the appearance start position and the number of appearances of the second key includes determining whether the number of appearances of the second key exceeds the predetermined tolerance value; consists of at least one or more characters following the second key in the query string for the second key when it is determined that the number of occurrences of the key exceeds the predetermined tolerance value. creating a new second key by adding a second additional key; and if it is determined that the number of occurrences of the second key does not exceed the predetermined tolerance value; outputting the current second key as a matching character string and outputting the appearance start position of the second key.

Further, identifying the appearance start position and the number of appearances of the second key may be performed until it is determined that the identified number of appearances of the second key does not exceed the predetermined tolerance value. The method may further include creating the new second key by sequentially adding a new second additional key to the current second key.

Further, when it is determined that the number of appearances of the second key exceeds the predetermined tolerance value, the predetermined sampling interval of the second key may be changed to become larger.

Deriving the approximate string includes receiving a string pair consisting of a string to be matched and a string to be matched based on the matching string identified by the mapping, and deriving the string pair based on the string pair. The method may include performing a predetermined alignment process to derive at least one approximate character string, and outputting the derived at least one approximate character string.

Executing the predetermined alignment process includes creating a predetermined alignment table based on the character string to be matched and the character string to be matched, and calculating a width m centered on a diagonal element of the alignment table. calculating a degree of variation for each element in the set calculation area; determining a maximum degree of variation based on the calculated degree of variation; The method may include deriving the at least one approximate character string based on the maximum degree of variation.

Furthermore, executing the predetermined alignment process may include comparing the maximum degree of variation with a predetermined lower limit value to determine whether the maximum degree of variation exceeds the predetermined lower limit value; In order to set a new calculation area when it is determined that the degree of variation does not exceed the predetermined lower limit value, the width m of the calculation area is widened, and the maximum degree of variation is set to the predetermined lower limit. The method may include deriving the at least one approximate character string based on the element having the maximum degree of variation when it is determined that the lower limit value is exceeded. The method is configured to repeat calculating the degree of variation by expanding the calculation area and setting a new calculation area until it is determined that the maximum degree of variation exceeds the lower limit value. can be done.

The predetermined lower limit value may be a value of the degree of variation when it is assumed that there are m consecutive gaps in the predetermined element sequence and that the other parts are completely or substantially matched.

The method also includes creating the matched character string by adding a corresponding predetermined character string in the reference string to the matched character string, and adding the query character string to the matched character string. creating the match string by adding corresponding predetermined strings in a column.

The invention according to one aspect is also a computer program product for implementing a method for creating a hierarchical index for searching a reference string based on a query string in a computing device.
The method includes cutting out each first key of a predetermined length from the reference character string, and calculating a hash based on the first key using a predetermined hash function for each of the cut out first keys. Creating a first key array to which a value is assigned, updating the created first key array, and outputting the updated first key array as the hierarchical index; including.
Here, updating the first key layout includes identifying, for each of the first keys in the first key layout, the appearance start position and number of appearances of the first key in the reference character string. and creating a new first key by adding a first additional key to the first key according to the appearance start position and the number of appearances of the identified first key, and updating the first key arrangement based on the first key.

The invention according to one aspect is also a computer program product for causing a computing device to implement a method for mapping a query string to a reference string.
The method includes reading a hierarchical index based on the reference string, creating a key array by cutting each key having a predetermined key length from the query string, and creating a key array by cutting each key having a predetermined key length from the query string. creating a key array in which a hash value calculated based on the key by the predetermined hash function is assigned to each of the keys; identifying the starting position and number of occurrences of the key with reference to a hierarchical index; determining whether the identified number of occurrences exceeds a predetermined threshold; If it is determined that the number of occurrences exceeds a predetermined tolerance value, a new key is created by adding an additional key consisting of at least one character following the key in the query string to the key. and outputting the identified current appearance start position of the key and the key when it is determined that the identified number of appearances does not exceed a predetermined threshold. include.
Then, identifying the appearance start position and the number of appearances of the key includes adding a new one to the current key until it is determined that the identified number of appearances does not exceed a predetermined threshold. The method includes sequentially adding additional keys to create the new key.

Here, if it is determined that the identified number of appearances exceeds a predetermined tolerance value, the predetermined sampling interval of the key may be changed to become larger.

Further, the present invention according to a certain aspect is a computer program for causing a computing device to implement a method of identifying a variation between a substring in a reference string and a query string using a predetermined alignment process.
The method includes receiving a string pair consisting of a matched string and a matching string based on a matching string identified by mapping, and deriving at least one approximate string based on the string pair. performing a predetermined alignment process in order to
outputting the derived at least one approximate character string.
Executing the predetermined alignment process includes creating a predetermined alignment table based on the string to be matched and the string to be matched, and determining the width of the alignment table based on the diagonal elements of the alignment table. m, calculating a degree of variation for each element in the set calculation area, determining a maximum degree of variation based on the calculated degree of variation, and determining deriving the at least one approximate character string based on the maximum variation degree determined.

Furthermore, executing the predetermined alignment process may include comparing the maximum degree of variation with a predetermined lower limit value to determine whether the maximum degree of variation exceeds the predetermined lower limit value; In order to set a new calculation area when it is determined that the degree of variation does not exceed the predetermined lower limit value, the width m of the calculation area is widened, and the maximum degree of variation is set to the predetermined lower limit. The method may include deriving the at least one approximate character string based on the element having the maximum variation degree when it is determined that the lower limit value is exceeded.
Then, the calculation of the degree of variation by expanding the calculation area to set a new calculation area may be repeated until it is determined that the maximum degree of variation exceeds the lower limit value.

Furthermore, executing the predetermined alignment process calculates the value of the degree of variation when it is assumed that there are m consecutive gaps in the predetermined element sequence and that the other parts are completely or substantially matched. It may further include setting the predetermined lower limit value as the predetermined lower limit value.

Note that the present invention can also be implemented as a recording medium that stores the computer program. The invention can also be implemented as a device comprising hardware and/or firmware configured to carry out the method. An approximate character string matching device is one form of the present invention.

Note that in this specification and the like, the term "means" or "unit" does not simply mean physical means, but also includes cases in which the functions of the means or unit are realized by software. Furthermore, the functions of one means or section may be realized by two or more physical means, or the functions of two or more means or sections may be realized by one physical means. In addition, a "system" refers to a logical collection of multiple devices (or functional modules that realize a specific function), and whether each device or functional module is in a single housing or not. There is no particular question.

According to the present invention, it is possible to quickly and/or efficiently analyze given query data using reference data. In particular, according to the present invention, approximate string matching between a given query string and a reference string can be performed quickly and/or efficiently.

Further, according to the present invention, analysis using a human genome reference sequence based on data pieces read by a sequencer can be performed quickly and/or efficiently.

Further, according to the present invention, it is possible to provide a hierarchical index based on reference strings suitable for approximate string matching.

Other technical features, objects, effects, and advantages of the present invention will be made clear by the following embodiments described with reference to the accompanying drawings. The effects described in this specification are merely examples and are not limiting, and other effects may also be present.

FIG. 1 is a block diagram showing an example of a schematic configuration of a computer system according to an embodiment of the present invention. FIG. 2 is a flowchart illustrating an example of an approximate character string matching process performed by a computer system according to an embodiment of the present invention. FIG. 3 is a flowchart illustrating an example of index creation processing by a computer system according to an embodiment of the present invention. FIG. 4 is a diagram showing an example of a reference character string used in a computer system according to an embodiment of the present invention. FIG. 4A is a diagram for explaining an example of a data array structure in the process of creating a hierarchical index based on the reference character strings shown in FIG. 4. FIG. 4B is a diagram for explaining an example of a data array structure in the process of creating a hierarchical index based on the reference character strings shown in FIG. 4. FIG. 4C is a diagram for explaining an example of a data array structure in the process of creating a hierarchical index based on the reference character strings shown in FIG. 4. FIG. 5 is a diagram showing an example of a table structure showing the key start position and number of appearances in the process of creating a hierarchical index based on the reference character string shown in FIG. 4. FIG. 6 is a diagram showing an example of a reference character string used in a computer system according to an embodiment of the present invention. FIG. 7 is a flowchart illustrating an example of a reference string search process based on a query string by the computer system according to an embodiment of the present invention. FIG. 8A is a diagram showing an example of an alignment table for explaining the Needleman-Wunsch algorithm. FIG. 8B is a diagram showing an example of an alignment table for explaining the Needleman-Wunsch algorithm. FIG. 8C is a diagram showing an example of an alignment table for explaining the Needleman-Wunsch algorithm. FIG. 8D is a diagram showing an example of an alignment table for explaining the Needleman-Wunsch algorithm. FIG. 9 is a flowchart illustrating an example of alignment processing using dynamic programming by a computer system according to an embodiment of the present invention. FIG. 10A is a diagram showing an example of an alignment table for explaining alignment using dynamic programming according to an embodiment of the present invention. FIG. 10B is a diagram showing an example of an alignment table for explaining alignment using dynamic programming according to an embodiment of the present invention. FIG. 10C is a diagram showing an example of an alignment table for explaining alignment using dynamic programming according to an embodiment of the present invention. FIG. 11A is a diagram illustrating an example of an approximate character string obtained by alignment using dynamic programming according to an embodiment of the present invention. FIG. 11B is a diagram showing an example of an approximate character string obtained by alignment using dynamic programming according to an embodiment of the present invention. 1 is a diagram illustrating an example of a hardware configuration of a computing device in a system according to an embodiment of the present invention.

Embodiments of the present invention will be described below with reference to the drawings. However, the embodiments described below are merely examples, and there is no intention to exclude the application of various modifications and techniques not specified below. The present invention can be implemented in various ways (for example, by combining the embodiments) without departing from the spirit thereof. In addition, in the description of the drawings below, the same or similar parts are denoted by the same or similar symbols. The drawings are schematic and do not necessarily correspond to actual dimensions or proportions. The drawings may also include portions that differ in dimensional relationships and ratios.

FIG. 1 is a block diagram showing an example of a schematic configuration of a computer system according to an embodiment of the present invention. As shown in the figure, the computer system 1 includes, for example, a higher-level computer 10, a plurality of lower-level computers 20(1) to 20(n), and a database 30. The upper computer 10 and the lower computers 20(1) to 20(n) are communicably connected via a predetermined interface. In the present disclosure, the computer system 1 is configured as a centralized computer system in which the higher-level computer 10 centrally controls the multiple lower-level computers 20(1) to 20(n), but is not limited to this, for example, distributed It may also be configured as a type computer system. In a distributed computer system, each computer can operate cooperatively through parallel distributed processing, but there may be cases where only one representative computer executes a specific process. The hardware configurations of the higher-level computer 10 and lower-level computer 20 are illustrated in FIG. 12, but since they are obvious to those skilled in the art, detailed description thereof will be omitted. In the present disclosure, the lower-level computer 20 processes tasks in parallel under the control of the higher-level computer 10. For example, each of the plurality of lower-level computers 20 performs an analysis process based on each given query string in comparison with a reference string. Below, the lower-level computers 20(1) to 20(n) may be simply referred to as "lower-level computers 20" unless there is a particular need to distinguish between them.

The database 30 stores various data such as reference character strings under the control of the host computer 10. As an example, database 30 stores human genome reference sequences. The human genome reference sequence is data indicating a base pair sequence defined as a standard human genome sequence. The database 30 also stores indexes created based on reference character strings. An index is a type of data array structure used to search for reference strings. In the figure, the database 30 is configured to be accessible only to the upper level computer 10, but the configuration is not limited to this, and the configuration may be such that the lower level computer 20 is also connected for access.

FIG. 2 is a flowchart illustrating an example of an approximate character string matching process performed by a computer system according to an embodiment of the present invention. Such processing is realized, for example, by the higher-level computer 10 and the plurality of lower-level computers 20 cooperating with other hardware components by executing an approximate string matching program under the control of a processor.

That is, as shown in the figure, the host computer 10 first reads a reference character string stored in the database 30, and creates an index based on the read reference character string (S201). Specifically, the host computer 10 creates an index having a predetermined data array structure by expanding and/or sorting and arranging partial strings in the reference string according to predetermined conditions. The data array structure consists of a hierarchical tree structure. In this disclosure, such an index will be referred to as a hierarchical index. The host computer 10 stores an index based on the created reference character string in the database 30. Details of the hierarchical index creation process based on reference character strings will be described later. Note that if a hierarchical index based on the reference character string has already been created and stored in the database 30, processing S201 may be omitted.

Subsequently, the host computer 10 receives a query string from an external device (not shown), and performs mapping based on the received query string with reference to the hierarchical index (S202). In one example, the external device is a sequencer that reads the human genome, and the query string is a data piece of about 150 to 200 base pairs output from the sequencer. In the present disclosure, the lower-level computer 20 also performs mapping under the control of the higher-level computer 10 by referring to the hierarchical index based on the assigned query string.

Mapping is a process of identifying a substring (matching string) in a reference string that matches at least a portion of a query string. That is, the mapping identifies the appearance start position and length (number of characters) of a substring that matches at least a portion of the query string in the reference string. In the mapping according to the present disclosure, each key in the query string and its starting position in the reference string are identified by searching or searching a hierarchical index for each key in the query string. Note that in order to speed up processing, the created hierarchical index may be developed in high-speed memory such as main memory or cache memory.

Furthermore, in the mapping according to the present disclosure, when searching for a hierarchical index, the sampling interval of the appearance start position of a key in a query string is adjusted to be somewhat larger than in the prior art. For example, in an algorithm called BLAST (Basic Local Alignment Search Tool) for sequence alignment of DNA base sequences and protein amino acid sequences, the interval between the starting positions of keys is set to 3 to 5 characters. In the search according to the present disclosure, the number may be set to 10 characters or more, for example. During a search, if the sampling interval of the key appearance start position is small, the number of searches will increase and the efficiency will decrease, whereas if the sampling interval of the key appearance start position is always large, the search will be slow. In exchange for increased speed, the probability of oversight increases. Therefore, in the present disclosure, while increasing the length of the key, if the key length exceeds a certain length, the sampling interval of the appearance start position is increased to prevent key matches from being overlooked and to improve search efficiency. We are trying to improve.

Note that in the above example, the upper computer 10 and the lower computer 20 each perform mapping according to the assigned query string, but the invention is not limited to this. For example, only the upper computer 10 performs mapping according to the assigned query string. Searches may be performed based on columns and with reference to hierarchical indexes.

Next, the upper computer 10 and the lower computer 20 each create a string pair for approximate string matching, which will be described later (S203). A string pair consists of a matched string in a reference string and a matched string in a query string, including a matched string identified by mapping.

Specifically, the higher-level computer 10 and the lower-level computer 20 add a character string of a predetermined length corresponding to the reference character string to the beginning and end of the matching character string identified by mapping, thereby determining the matched character. Create columns. In other words, the matched character string is a character string in the vicinity of the matched character string that includes the matched character string identified in the reference character string. For example, when the reference character string is "CCGATCTGTATACCCTACGA" and the matching character string is "TACC", the character string "TATACCCT", which is obtained by adding two characters before and after, becomes the character string to be matched. In the case of human genome analysis, the length of bases added to the beginning and end of a matching character string for a reference character string can be, for example, about 50 bases.

Further, the host computer 10 creates a matching string by adding a corresponding character string of a predetermined length in the query string to the end of the matching string. In the case of human genome analysis, the length of the string added to the end of the matching string with respect to the query string is, for example, about 50 bases.

Note that in the present disclosure, a character string of a predetermined length is added to the beginning and end of a matching character string for the reference character string, but the invention is not limited to this. For example, a character string of a predetermined length is added only to either the beginning or the end. Strings may be added. Also, regarding the query string, you may add character strings of a predetermined length to the beginning and end of the matching string, or you may add the matching string itself to the matching string without adding any strings. It can also be treated as a column.

Next, the upper computer 10 and the lower computer 20 derive at least one approximate character string based on the character string pair consisting of the character string to be matched based on the reference character string and the character string to be matched based on the query character string (S204 ). A predetermined alignment using dynamic programming is applied to derive the approximate character string. Alignment is a method of comparing two sequences (character strings) while allowing substitutions, insertions, and deletions among their elements, and calculating the degree of variation (similarity) according to a defined score/penalty. As algorithms for realizing alignment, the Smith-Waterman algorithm and the Needleman-Wunsch algorithm are known. Furthermore, dynamic programming is a method of calculating the optimal solution for the next stage based on the optimal solution obtained at one stage. In other words, in calculating the degree of variation, a score is calculated for each element of the array-like alignment table according to dynamic programming, and the element with the maximum score is determined. is derived.

As described above, in the approximate string matching of this embodiment, after a hierarchical index is created based on a reference string, the matching string ( and its length) are identified, and an approximate string is derived by performing approximate string matching on a string pair consisting of a string to be matched and a matching string based on the identified matching string. Ru.

FIG. 3 is a flowchart illustrating an example of index creation processing by a computer system according to an embodiment of the present invention. That is, FIG. 3 shows details of the hierarchical index creation process (S201) shown in FIG. 2. Further, FIG. 4 is a diagram showing an example of a reference character string for creating a hierarchical index, and FIGS. 4A to 4C are diagrams showing an example of a data array structure in the process of creating a hierarchical index based on the reference character string. It is a diagram. Further, FIG. 5 is a diagram showing an example of a table structure showing the appearance start position and number of appearances of keys in the process of creating a hierarchical index, and FIG. 6 is a diagram for explaining the hierarchical index.

First, as shown in FIG. 3, the host computer 10 receives a reference character string for creating a hierarchical index (S301). For example, in the case of a human genome reference sequence, the host computer 10 accesses the database 30 and reads out the stored human genome reference sequence. In the following, for ease of understanding, a reference character string "CCGATCTGTATACCCTACGA" composed of four types of characters "A", "C", "G", and "T" will be explained as an example (see FIG. 4).

The host computer 10 cuts out each partial character string (ie, key) from the received reference character string according to a predetermined key length to create a key arrangement (S302). For example, when the key length is "2", the key arrangement is as shown in FIG. 4A(a). In the figure, the number at the left end is the sequence number. Further, the key starting with the 19th "A", which is the end of the reference character string, is omitted here to simplify the explanation.

Next, the host computer 10 calculates a hash value for each key of the created key array using a predetermined hash function, and assigns this to the key (S303). As a result, the key arrangement becomes as shown in FIG. 4A(b). The hash function in this disclosure outputs a value expressed in quaternary digits using numerical values from “0” to “3” assigned to four types of characters “A”, “C”, “G”, and “T”, respectively. However, it is not limited to this. For example, for the 1st key "CG", the hash value is h(CG)=1×4+2=6, and for the 11th key "AC", the hash value is h(AC)=0 ×4+1=1.

Next, the host computer 10 sorts each key in the keyboard array, for example, in ascending order according to the assigned hash value (S304). As a result, the key arrangement becomes as shown in FIG. 4A(c). In this example, each key arrangement after sorting may include the arrangement number before sorting. For example, in FIG. 4A(c), the 0th key "AC" in the key array after sorting retains the (original) array number "11" before sorting, and the 1st key "AC" after sorting retains the (original) array number "11". AC” holds the array number “16” before sorting.

Note that, in the above example, the calculated hash value is assigned to each extracted key and sorted, but the present invention is not limited to this. For example, regardless of the key that is extracted from the reference string, a hash value is calculated and assigned based on the combination of all characters that appear in the reference string, and a key array is prepared, and the appearance start position corresponding to the extracted key is determined. May be assigned. That is, in a reference character string consisting of four types of characters "A", "C", "G", and "T", for example, if the key length is 2 characters, 4 ² elements are A key array is first created, and a hash value is assigned to each key array. Subsequently, the extracted key is assigned to the corresponding element (element of the same key) in the created key array along with the appearance start position in the reference character string, resulting in a key array as shown in FIG. 4A(c). is obtained.

Next, the host computer 10 identifies the appearance start position and number of appearances of each key in the current key arrangement (S305). FIG. 5(a) shows the appearance start position and number of appearances of each key in the key arrangement shown in FIG. 4A(c). For example, the key "AC" is shown to appear twice in the key arrangement, starting from the appearance start position "0" (array number "0"). Further, it is shown that the key "CC" appears three times with the appearance start position "4" as the base point. In addition, here, the appearance start position and number of appearances are shown for key patterns consisting of all combinations of each character (i.e. 16 patterns), and for example, the key "AA" which is not included in the illustrated key arrangement. ", the appearance start position is indicated as "-" and the number of occurrences is "0".

Next, the host computer 10 determines whether the number of appearances of each key exceeds a predetermined allowable value (S306). In this disclosure, the predetermined tolerance value is a value that allows the same key to exist twice in the hierarchical index. In this example, the predetermined tolerance value is "1". That is, if the predetermined tolerance value is "1", each key exists uniquely in the hierarchical index. Also, the larger the predetermined tolerance value, the more likely it is that duplicate keys will exist in the hierarchical index, while the faster the creation of the hierarchical index. If the host computer 10 determines that there is a key whose number of appearances exceeds a predetermined tolerance value (S306: Yes), it adds an additional key to that key (S308).

An additional key is one or more characters that follow the key in the original string. In this example, the additional key is one character. A substring obtained by adding an additional key is considered a new key. Hereinafter, a new key to which an additional key has been added will be referred to as an "extended key" to distinguish it from the original key, and its arrangement may be referred to as an extended key arrangement. By adding additional keys, each key is identified as being different from each other. FIG. 4B(a) shows an example of an extended key array consisting of extended keys in which one additional key is added to the original key. Note that for the extended key "GA" with array array number "12", since there is no character following "A" in the original character string, for example, "$" is assigned as the terminal character string. Furthermore, since the keys with array numbers "13", "17", and "18" appear only once, no additional keys are added.

Next, the host computer 10 further sorts each key (that is, extended key) according to the additional key, for example, in ascending order, as shown in FIG. 4B(b) (S308). In this case, the original key sort order takes precedence. In the figure, for example, it can be seen that the order of the key arrays "AT" with array numbers "2" and "3" is changed by sorting by the additional keys. Subsequently, the host computer 10 returns to process S306 and repeats the above process until the number of appearances of all keys no longer exceeds a predetermined tolerance value.

That is, the host computer 10 identifies the appearance start position and number of appearances of each key in the keyboard layout (S305), and if it is determined that there is no key whose number of appearances exceeds a predetermined tolerance value (No in S306), Since the desired hierarchical index has been created, the process ends.

FIG. 5 is a diagram for explaining the appearance start position and number of appearances of keys in the process of creating a hierarchical index based on the reference character strings shown in FIG. 4. For example, an additional key is added to a key that appears two or more times in FIG. 5(a) (FIG. 4B(a)), and each key (extended key) is sorted according to the additional key (FIG. 4B(a)). b)). As a result, as shown in FIG. 5(b), the appearance start position and number of appearances of each key in the current key arrangement are identified. In the example shown in the figure, the number of appearances of the extended keys "CGA" and "TAC" is 2. Therefore, additional keys are similarly added and sorted for each of these extended keys (FIGS. 4C(a) and (b)). Note that for the key "CG" of the original array number "17" (array number "8" after sorting by hash value), there is no character following the key "A", so for example "$" is used as the terminal string. Assigned. As a result, as shown in FIG. 5(c), the appearance start position and number of appearances of the key are identified. As a result of the above, the number of occurrences of all extended keys becomes "1", so the index creation process ends.

As an example, consider the key "TA". Since the key "TA" is located in array numbers "14" to "16" (see FIG. 4A(c)), its appearance start position is "14" and the number of appearances is "14" as shown in FIG. 6(a). It becomes "3". Next, by adding an additional key to the key "TA" and sorting it (see FIG. 4B(b)), as shown in FIG. 6(b), regarding the extended key "TAC" including the additional key "C", The appearance start position is "14" and the appearance number is "2", while the appearance start position is "16" and the appearance number is "1" for the extended key "TAT" that includes the additional key "T". ”. Therefore, for the key "TAC" whose number of occurrences is "2", additional keys "C" and "G" are added, respectively, and as a result, as shown in FIG. 6(c), the number of occurrences of the key "TACG" becomes "1". In this way, the extended keyboard layout is understood as a hierarchical tree structure.

As described above, the host computer 10 creates a hierarchical index based on, for example, the human genome reference sequence. Since such a hierarchical index is sorted according to the hash value, the partial data array structure of the hierarchical index related to a particular key (substring) is concentrated in a particular address area in main memory. (data sequentialization), which greatly reduces the number of random accesses to main memory.

Note that the above explanation uses an extremely short string as an example for simplicity, but for example, when dealing with the human genome, the key length of the partial string should be about 10 to 20, and the key length of the additional key should be about 2. ~8. Preferably, the predetermined tolerance value is 5 to 40, the key length of the substring is approximately 10 to 15, the key length of the additional key is 2 to 4, and the predetermined tolerance value is 10 to 20. is more preferable.

FIG. 7 is a flowchart illustrating an example of a reference string search process based on a query string by the computer system according to an embodiment of the present invention. That is, FIG. 7 shows details of the reference string search process (S202) based on the query string shown in FIG. 2. Through this search process, a predetermined key in the query string is mapped to the reference string, and a matching string and its appearance start position in the reference string are identified. Note that, although the search processing by the higher-level computer 10 will be described below, the same applies to the search processing by the lower-level computers 20 that operate in parallel.

As shown in the figure, the host computer 10 reads the hierarchical index from the database 30, develops it on the memory, and stores it (S701). From the viewpoint of speeding up, the host computer 10 continuously develops and stores data constituting the hierarchical index on the main memory. Here, "continuously expanding" includes arranging data at consecutive memory addresses in the same bank.

Next, the host computer 10 receives a query string for mapping the reference string (S702). For example, if the reference string is a human genome reference sequence, the query string is a piece of base pair data read from a sequencer. In the following description, for ease of understanding, it is assumed that the query string is "TACC".

Next, the host computer 10 successively cuts out each key from the received query string according to a predetermined key length (S703). In this example, it is assumed that the initial value of the predetermined key length is "2". Therefore, the keys to be extracted are "TA", "AC", "CC", and "C$". Further, in this example, it is assumed that the initial value of the sampling interval for each key is 1. The sampling interval of a key is the interval of starting positions for sequentially referencing the hierarchical index according to the key. Note that in the case of human genome analysis, the initial value of the sampling interval may be, for example, about 3 to 5. As described below, the sampling interval is extended depending on the length of the key.

Next, the host computer 10 calculates a hash value for each extracted key using a predetermined hash function (S704). As mentioned above, the hash function is a value expressed in quaternary by the numerical values ``0'' to ``3'' assigned to four types of characters ``A'', ``C'', ``G'', and ``T''. Defined as a function that outputs . For example, for the key “TA”, the hash value is h(TA)=3×4+0=12.

Next, the host computer 10 refers to the hierarchical index according to the calculated hash value (S705), and identifies the appearance start position and number of appearances of each key in the reference character string (S706). For example, for the key "TA", it is identified that the appearance start position in the hierarchical index is 14 and the number of appearances is 3 according to the hash value (see FIG. 6(a)).

Next, the host computer 10 determines whether the number of appearances of each key exceeds a predetermined allowable value (S707). As described above, in this example, the predetermined tolerance value is 1. If the host computer 10 determines that the number of appearances of the key exceeds a predetermined allowable value (Yes in S707), it then determines whether the current key length exceeds a predetermined upper limit ( S708). The predetermined upper limit may be, for example, about 20 in the case of human genome analysis, but is not limited to this.

If the host computer 10 determines that the current key length does not exceed the predetermined upper limit for each key (No in S708), it creates an extended key by adding an additional key to the key. (S709), the process returns to S706.

For example, the host computer 10 adds an additional key "C" to the key "TA", checks the number of occurrences thereof (see FIG. 6(b)), and then adds the additional key (extended key ), the number of appearances thereof is checked (see FIG. 6(c)), and the process is repeated until the number of appearances reaches 1.

On the other hand, if the host computer 10 determines that the current key length exceeds the predetermined upper limit for each key (Yes in S708), it extends (increases) the sampling interval for the key (S710), and in S705 Return to processing. Note that the sampling interval may be expanded a predetermined number of times (for example, once) for each key.

Further, when the host computer 10 determines that the number of appearances of the current key (that is, the extended key) does not exceed a predetermined tolerance value (No in S707), the host computer 10 character string) and its appearance start position are output (S711).

As described above, the host computer 10 can use the hierarchical index to search for at least a portion of the query string from among the reference strings. In particular, according to this embodiment, since each key in the hierarchical index is sorted according to the hash value, the search according to the query string can be performed for partial and continuous data array structures in the hierarchical index. This will greatly reduce the number of random accesses to main memory.

In addition, when searching a hierarchical index, if the length of the current key (extended key) exceeds a certain length, the sampling interval of the appearance start position is extended, so the number of searches is efficiently reduced, and the search The speed can be increased. On the other hand, extending the sampling interval may increase the probability of missing keys that should have been identified, but since the sampling interval is lengthened when the key length exceeds a certain value, this This effectively prevents such oversights from occurring.

Next, alignment using dynamic programming will be explained. That is, the host computer 10 estimates how much variation (degree of variation) the query string (matching string) has with respect to the string (matching string) in the vicinity of the identified appearance start position in the reference string. For this purpose, alignment processing using dynamic programming is performed.

Alignment is a method of comparing two sequences (character strings) while allowing substitutions, insertions, and deletions among their elements, and calculating the degree of variation (similarity) according to a defined score/penalty. For example, when comparing string X (i.e., a match string based on a reference string) and string Y (i.e., a match string based on a query string), some characters of string , is inserted or deleted, it is determined that the character string Y does not match the character string X. In other words, the relationships between the characters at each position in each of the character strings I can say that. Here, the score in the case of a match is defined as, for example, "+2", the score in the case of a mismatch is defined as, for example, "-1", and the score in the case of a gap is defined as, for example, "-2". Then, the elements (characters) of the character strings X and Y are compared, and the degree of variation of each element is calculated using these scores. In the present disclosure, an improved alignment algorithm based on the Needleman-Wunsch algorithm, which is an example of global alignment, is used to calculate the degree of variation. Below, the basic idea of the Needleman-Wunsch algorithm will be explained, and further, an improved alignment algorithm applied to the present invention will be explained.

ここで、ｍａｘは与えられた式の値の中から最大値を出力する関数、ｓはスコア関数（一致：ｓ＝２、不一致：ｓ＝－１、ギャップ：ｓ＝－２）、ｄはギャップによるペナルティ（ｄ＝２）である。 For _{example ,} in comparing _{the character} string X ₌ x ₁ x _{2 ..} It is defined as below.

Here, max is a function that outputs the maximum value from among the values of the given expression, s is a score function (match: s=2, mismatch: s=-1, gap: s=-2), and d is the gap The penalty is (d=2).

In the following, for ease of understanding, alignment using dynamic programming between the character string to be matched "GCCTCGCT" and the character string to be matched "GCCATTCA" will be explained.

FIG. 8A is an alignment table in which character strings to be compared in this example are arranged. In the table, "φ" is a blank character, and F(0,0)=0. Furthermore, in Equation 1, if the argument of the degree of variation F(i, j) is a negative value, it is outside the range, so the calculation is omitted (the output is set to Null). The alignment table is expanded on memory as a type of data structure and made available to the processor.

First, in the case of j=0, for F(1,0), from equation 1, each of the max functions is
F (0, -1) + s (x ₁ , y ₀ ) = Null
F(0,0)-d=0-2=-2
F(1,-1)-d=Null
Because it is,
F(1,0)=-2
becomes.

Next, F(2,0) is
F(2,0)=F(1,0)-d=-4
becomes. Similarly,
F(n,0)=-nd
F(0,n)=-nd
Therefore, the alignment table becomes as shown in FIG. 8B.

Next, in the case of j=1, it is calculated in the same way. For F(1,1), each in the max function is
F(0,0)+s( _x1 , _y1 )=0+2=2
F(0,1)-d=-2-2=-4
F(1,0)-d=-2-2=-4
and, thereby,
F(1,1)=2
Therefore, the alignment table becomes as shown in FIG. 8C.

By repeating the above calculation in the same way, an alignment table as shown in FIG. 8D is created. In the created alignment table, the degree of variation F(6,7) at element position (6,7) has a maximum value of "7". Therefore, as shown in the figure, backtracking is performed from element position (6, 7) to element position (1, 1). In the table, an arrow pointing diagonally to the lower right indicates a match of characters, an arrow pointing to the right indicates a deletion, and an arrow pointing downward indicates an insertion. As a result, the approximate character string "GCC<A>T[T]G" is derived. However, the symbol "< >" represents insertion between characters, and the symbol "[ ]" represents replacement. In other words, where the reference string is "GCCTCG", the query string has "A" inserted between "C" and "T" in the reference string, and "C" in the reference string "TCG" is It can be seen that it has been replaced with "T".

As described above, by specifying the element position in the alignment table where the degree of variation is the maximum value according to the Needleman-Wunsch algorithm, an approximate character string can be derived therefrom. However, since the Needleman-Wunsch algorithm calculates the degree of variation of all elements in the alignment table, the amount of calculation becomes enormous and takes a long time. Therefore, in the present disclosure, the following improved alignment algorithm is proposed, thereby reducing the amount of calculation and speeding up the processing.

That is, the improved alignment algorithm applied to the present invention generally defines a calculation region having a predetermined width centered on elements located on the diagonal line in the alignment table, and performs mutation only on the elements within the calculation region. The method includes determining the maximum value by calculating the degree, and deriving an approximate character string from elements based on the maximum value when the maximum value satisfies a predetermined condition. If the maximum value does not satisfy the predetermined condition, the calculation area is expanded, and the degree of variation is similarly calculated to determine the maximum value, and this is repeated until the maximum value satisfies the predetermined condition.

FIG. 9 is a flowchart illustrating an example of alignment processing using dynamic programming by a computer system according to an embodiment of the present invention. That is, FIG. 9 shows details of (S204) of the alignment process shown in FIG. 2. Although alignment processing based on one query string by the higher-level computer 10 will be described below, alignment processing based on other query strings by the lower-level computers 20 operating in parallel is also the same.

As shown in the figure, the host computer 10 creates an alignment table based on a character string pair consisting of a character string to be matched and a character string to be matched (S901). As mentioned above, the alignment table is developed in memory as some kind of data structure.

Next, the host computer 10 sets the width m (where m is a positive number) of the calculation area to an initial value (S902). The initial value of the width m may be, for example, the length of the matching character string obtained by mapping, but is not limited thereto. Further, since the width m is centered at the element position on the diagonal line of the alignment table, it is set to an odd value, but it is not limited to this. As a result, a calculation area of width m centered on the element position on the diagonal of the alignment table is determined.

Subsequently, the host computer 10 sets a predetermined dummy value to each element defining the boundary of the calculation area (S903). As the dummy value, a value that is sufficiently small as the value of the degree of variation F is selected. For example, the dummy value is a negative value, for example, about 2 to 3 times the width m of the initial value, and can be set arbitrarily.

Next, the host computer 10 calculates the degree of variation F for each element in the calculation area according to Equation 1 (S904). Subsequently, the host computer 10 determines the maximum degree of variation F _max having the maximum value in the calculation area, and specifies the position of the element (S905). Note that the number of elements having the maximum degree of variation F _max is not necessarily one.

The host computer 10 also calculates the lower limit value F _Low of the degree of variation F in the row or column of the alignment table (S906). The lower limit value F _Low is based on the assumption that there are m consecutive gaps when comparing the reference string and query string in the row or column, and that the other parts are completely or substantially matched. This is the value of the degree of variation F for the case. That is, the lower limit value F _Low is
F _Low = (character string length - m) x s...Formula 2
However, s=2.
It is calculated by

Next, the host computer 10 compares the maximum degree of variation F _max and the lower limit value F _Low and determines whether the maximum degree of variation F _max exceeds the lower limit value F _Low (S907). When the host computer 10 determines that the maximum degree of variation F _max does not exceed the lower limit value F _Low (No in S907), the host computer 10 widens the width m by a predetermined size δ (S908). For example, δ is assumed to be m+1 (provided that m does not exceed the number of characters in the character string).

The host computer 10 performs the same process on the expanded calculation area of width m, and repeats the above process until the maximum value F _max exceeds the lower limit value F _Low .

When the host computer 10 determines that the maximum value F _max exceeds the lower limit value F _Low (Yes in S907), backtracking is performed from the position of the element having the maximum value to determine an approximate character string ( S909). The host computer 10 then outputs the determined approximate character string (S910).

For example, an example of calculating the degree of variation using the alignment method according to the present invention will be described between the character string to be matched "GGGATCCGATAATCGGTCCCCTAGG" (24 characters) and the character string to be matched "GGGCATTCAACATAAGTCGGCCTG" (24 characters). Note that the use of Equation 1 to calculate the degree of variation F is similar to the example described above. Note that the length of the character string to be matched and the length of the character string to be matched do not need to match, and typically, the length of the character string to be matched is longer than the length of the character string to be matched.

First, the host computer 10 prepares an alignment table in which character strings to be compared are arranged, and sets an initial value of the width m. In this example, it is assumed that the initial value of the width m(0) is 7. Furthermore, the host computer 10 sets dummy values to elements at the boundary of the calculation area defined according to the width m. In this example, it is assumed that the dummy value is -20. FIG. 10A shows an alignment table in which dummy values are set. In the table, the hatched element is the calculation region R(0) with width m(0)=7.

The host computer 10 calculates the degree of variation F of each element within the calculation region R(0) according to Equation 1. FIG. 10B shows a state in which the degree of variation F of each element within the calculation area has been calculated. The host computer 10 determines the maximum degree of mutation F _max from among the calculated degrees of mutation F. In this example, the maximum degree of variation F _max is 17. In the figure, elements with a maximum degree of variation F _max of 17 are hatched.

Subsequently, the host computer 10 calculates the lower limit value F _Low in the row or column of the alignment table. In this example, the lower limit value F _Low is
F _Low = (24-m)×s
=17×2
=34
becomes.

Next, the host computer 10 compares the maximum degree of variation F _max and the lower limit value F _Low , and thereby determines that the maximum degree of variation F _max does not exceed the lower limit value F _Low , so the width m is reduced by δ. Expand. In this example, the expanded width m(1) is expanded to 15. Further, the calculation area of the expanded width m(1) is assumed to be R(1).

The host computer 10 similarly calculates the degree of variation F of each element within the calculation region R(1) according to Equation 1. FIG. 10C shows a state in which the degree of variation F of each element within the calculation area has been calculated. In the figure, hatching is drawn in a region added to the calculation region R(1) by widening. As a result, the maximum degree of variation F _max is 19. Further, the lower limit value F _Low at this time is 18.

Therefore, in order to determine that the maximum degree of variation F _max exceeds the lower limit value F _Low , the host computer 10 backtracks from the element with the maximum degree of variation F _max = 19, and follows the path obtained by this to create an approximate character string. Identify.

That is, in the example shown in FIG. 10C, the host computer 10 starts from the element (18, 22) with the maximum degree of variation F _max = 19 (current element position) and selects adjacent elements in the direction of the element (0, 0). The element with the largest value of the degree of variation F is identified among the elements to be changed, and transition is made to that element. Therefore, the element (17, 21) with the degree of variation F=17 becomes the current element position. By repeating this transition up to element (0,0), an approximate character string is finally derived. Note that the number of paths obtained by backtracking is not limited to one, but may be multiple.

More specifically, in the alignment table shown in FIG. 10C, there are six paths obtained by backtracking, and the approximate character strings following each path are as follows.
(a) First path: GGG<C>A<T>TC<AA>C-ATAA<G>TCG[G]CC
(b) Second path: GGG<C>A<T>TC<A>[A][C]ATAA<G>TCG[G]CC
(c) Third path: GGG<C>AT[T]C<A>[A][C]ATAA<G>TCG[G]CC
(d) Fourth path: GGG<C>AT[T]C[A]<AC>ATAA<G>TCG[G]CC
(e) Fifth path: GGG<C>A<T>TC<AA>C-ATAA<G>TCG[G]CC
(f) Sixth path: GGG<C>AT<T>C<A>[A][C]ATAA<G>TCG[G]CC
However, the symbol "<>" represents insertion between characters, the symbol "[ ]" represents character replacement, and the symbol "-" represents missing character.
For ease of understanding, approximate character strings following each of the above paths are shown in FIGS. 11A and 11B in comparison with reference character strings.

In this way, the improved alignment algorithm does not calculate the degree of variation for all elements in the alignment table, but instead defines a calculation area with a predetermined width and calculates the variation while expanding the calculation area as necessary. Since the degree is calculated, the amount of calculation can be reduced, thereby speeding up the processing.

As described above, according to the present embodiment, after a hierarchical index based on a reference string is created, matching strings (and their lengths) are searched according to a given query string. (a) is identified, and an approximate character string is derived by performing approximate character string matching on a character string pair consisting of a character string to be matched and a character string to be matched based on the identified matching character string.

Each of the embodiments described above is an illustration for explaining the present invention, and the present invention is not intended to be limited only to these embodiments. The present invention can be implemented in various forms without departing from the gist thereof.

For example, steps, acts, or functions in the methods disclosed herein may be performed in parallel or in a different order unless the results are inconsistent. The steps, acts, and functions described are provided by way of example only, and some of the steps, acts, and functions may be omitted or combined with each other without departing from the spirit of the invention. It is also possible to add other steps, actions, or functions.

Further, although various embodiments are disclosed in this specification, specific features (technical matters) in one embodiment may be added to other embodiments while improving them as appropriate, or Certain features in the embodiments may be replaced and such forms are within the scope of the invention.

1...Computer system 10...Upper computer 20...Lower computer 30...Database

Claims (21)

A computer program for causing a computing device to perform a method for searching for an approximate string in a reference string based on a query string, the computer program comprising:
The method includes:
creating a hierarchical index based on the reference string;
mapping the query string to the reference string with reference to the hierarchical index to identify substrings in the reference string that match at least a portion of the query string; And,
A matched character string that is a character string in the vicinity of the partial string that includes the partial string identified by the mapping in the reference string, and the partial string identified by the mapping in the query string. deriving a character string that approximates the matched character string and the matched character string as the approximate character string based on the matched character string that is a character string near the partial character string;
Creating the hierarchical index comprises:
cutting out each first key of a predetermined length from the reference character string;
Creating a first key array in which a hash value calculated based on the first key by a predetermined hash function is assigned to each of the extracted first keys;
updating the created first key arrangement;
outputting the updated first key arrangement as the hierarchical index,
Updating the first keyboard layout includes:
For each of the first keys in the first key arrangement, identifying the number of occurrences of the first key in the reference character string;
adding a first additional key consisting of at least one or more characters following the first key in the reference string to the first key according to the number of occurrences of the identified first key; updating the first key arrangement by;
computer program. Creating the first key array includes sorting each of the first keys in the first key array according to the hash value.
The computer program according to claim 1. Updating the first keyboard layout includes:
determining whether the identified number of occurrences exceeds a predetermined tolerance;
consisting of at least one or more characters following the first key in the reference character string for the first key when it is determined that the identified number of occurrences exceeds the predetermined tolerance value. creating a new first key by adding the first additional key;
identifying, for the new first key, the number of occurrences of the new first key in the reference string;
The computer program according to claim 1 or 2. Updating the first keyboard layout further includes sorting the new first keys in the first keyboard layout according to the first additional keys.
The computer program according to claim 3. Updating the first key arrangement includes adding a new first additional key to the current first key until it is determined that the identified number of occurrences does not exceed a predetermined tolerance value. creating a new first key by sequentially adding
The computer program according to claim 3 or 4. Outputting the first key arrangement as the hierarchical index includes:
outputting the current first key arrangement as the hierarchical index when it is determined that the identified number of occurrences does not exceed a predetermined tolerance value;
A computer program according to any one of claims 3 to 5. Performing the mapping includes:
cutting out each second key of a predetermined length from the query string;
creating a second key array in which a hash value calculated based on the second key by the predetermined hash function is assigned to each of the second keys extracted from the query string;
For each of the second keys, refer to the hierarchical index at predetermined sampling intervals according to the hash value, and identify the starting position and number of occurrences of the second key.
A computer program according to any one of claims 1 to 6. Identifying the appearance start position and the number of appearances of the second key,
determining whether the number of appearances of the second key exceeds the predetermined tolerance;
If it is determined that the number of occurrences of the second key exceeds the predetermined tolerance value, at least one or more occurrences following the second key in the query string for the second key creating a new second key by adding a second additional key consisting of characters;
If it is determined that the number of occurrences of the second key does not exceed the predetermined tolerance value, outputting the currently identified second key as the partial character string; outputting the appearance start position of
The computer program according to claim 7. Identifying the occurrence start position and the number of occurrences of the second key may be performed until it is determined that the identified number of occurrences of the second key does not exceed the predetermined tolerance value. further comprising sequentially adding a new second additional key to the second key of the second key to create the new second key.
The computer program according to claim 8. increasing the predetermined sampling interval of the second key when it is determined that the number of appearances of the second key exceeds the predetermined tolerance;
The computer program according to claim 8 or 9. Deriving the approximate string is as follows:
creating a character string pair consisting of the character string to be matched and the character string to be matched based on the partial character string identified by the mapping;
performing a predetermined alignment process to derive at least one approximate string based on the string pair;
outputting the derived at least one approximate character string;
A computer program according to any one of claims 8 to 10. Executing the predetermined alignment process includes:
creating a predetermined alignment table based on the character string to be matched and the character string to be matched;
Setting a calculation area having a width m centered on an element on a diagonal line of the alignment table;
Calculating the degree of variation for each element in the set calculation area;
Determining a maximum degree of mutation based on the calculated degree of mutation;
deriving the at least one approximate character string based on the determined maximum variation degree;
The computer program according to claim 11. Executing the predetermined alignment process includes:
Comparing the maximum mutation degree and a predetermined lower limit value to determine whether the maximum mutation degree exceeds the predetermined lower limit value;
widening the width m of the calculation area in order to set a new calculation area when it is determined that the maximum variation degree does not exceed the predetermined lower limit;
deriving the at least one approximate character string based on the element having the maximum variation degree when it is determined that the maximum variation degree exceeds the predetermined lower limit value;
repeating the calculation of the degree of variation by expanding the calculation area to set a new calculation area until it is determined that the maximum degree of variation exceeds the lower limit;
The computer program according to claim 12. The predetermined lower limit value is a value of the degree of variation when it is assumed that there are m consecutive gaps in the predetermined element sequence and that the other parts match.
The computer program according to claim 13. creating the matched character string by adding a corresponding predetermined character string in the reference character string to the partial character string;
creating the match string by adding a corresponding predetermined string in the query string to the substring;
Computer program according to any one of claims 11 to 14. A computer program for causing a computing device to perform a method for creating a hierarchical index for searching a reference string based on a query string, the computer program comprising:
The method includes:
cutting out each first key of a predetermined length from the reference character string;
Creating a first key array in which a hash value calculated based on the first key by a predetermined hash function is assigned to each of the extracted first keys;
updating the created first key arrangement;
outputting the updated first key arrangement as the hierarchical index,
Updating the first keyboard layout includes:
For each of the first keys in the first key arrangement, identifying the appearance start position and number of appearances of the first key in the reference character string;
a first addition consisting of at least one or more characters following the first key in the reference string to the first key according to the identified start position of the first key and the number of occurrences; updating the first keyboard layout by adding a key;
computer program. A computer program for causing a computing device to perform a method for mapping a query string to a reference string, the computer program comprising:
The method includes:
Each first key cut out from the reference character string, and a first key array to which a hash value calculated by a predetermined hash function based on the first key is assigned to each first key. reading a hierarchical index consisting of the first key arrangement in which an additional key is added to the first key according to the appearance start position and number of appearances of the first key in the reference character string;
cutting out each second key having a predetermined key length from the query string;
creating a second key array in which a hash value calculated based on the second key by a predetermined hash function is assigned to each of the second keys extracted from the query string;
For each of the second keys, the hierarchical index is referenced at a predetermined sampling interval according to the hash value, and the second key is determined by comparing with the first key in the first key array. identifying a starting position and number of occurrences of the matching first key in the reference character string;
determining whether the identified number of occurrences exceeds a predetermined tolerance;
consisting of at least one or more characters following the second key in the query string for the second key when it is determined that the identified number of occurrences exceeds a predetermined tolerance value. creating a new second key by adding an additional key;
If it is determined that the identified number of occurrences does not exceed a predetermined tolerance value, the occurrence start position of the first key that matches the currently identified second key in the reference character string. and outputting the second key,
Identifying the occurrence start position and the number of occurrences in the reference character string of the first key that matches the second key may be performed if the identified number of occurrences does not exceed a predetermined tolerance value. creating the new second key by sequentially adding new additional keys to the current second key until determined;
computer program The method is configured to increase the predetermined sampling interval of the second key if it is determined that the identified number of occurrences exceeds a predetermined tolerance value.
The computer program according to claim 17. A computer program for causing a computing device to execute a method for identifying variations between a substring in a reference string and a query string by a predetermined alignment process, the computer program comprising:
The method includes:
mapping the query string to the reference string;
A matched character string that is a character string in the vicinity of the partial string that includes the partial string identified by the mapping in the reference string, and the partial string identified by the mapping in the query string. creating a string pair consisting of a matching string that is a string near the substring;
Performing a predetermined alignment process based on the character string pair to derive a character string that approximates the to-be-matched character string and the collated character string as at least one approximate character string;
outputting the derived at least one approximate character string;
Executing the predetermined alignment process includes:
creating a predetermined alignment table based on the character string to be matched and the character string to be matched;
Setting a calculation area having a width m centered on an element on a diagonal line of the alignment table;
Calculating the degree of variation for each element in the set calculation area;
Determining a maximum degree of mutation based on the calculated degree of mutation;
deriving the at least one approximate character string based on the determined maximum variation degree;
computer program. Executing the predetermined alignment process includes:
Comparing the maximum mutation degree and a predetermined lower limit value to determine whether the maximum mutation degree exceeds the predetermined lower limit value;
widening the width m of the calculation area in order to set a new calculation area when it is determined that the maximum variation degree does not exceed the predetermined lower limit;
deriving the at least one approximate character string based on the element having the maximum variation degree when it is determined that the maximum variation degree exceeds the predetermined lower limit value;
repeating the calculation of the degree of variation by expanding the calculation area to set a new calculation area until it is determined that the maximum degree of variation exceeds the lower limit;
A computer program according to claim 19. Executing the predetermined alignment process involves setting the degree of variation value, assuming that there are m consecutive gaps in the predetermined element sequence and that the other parts match, as the predetermined lower limit value. further including,
Computer program according to claim 20.

Images