N-tuple-based classification with association processing units

Abstract

A system for classifying N-tuples in a region of interest via hyperdimensional computation includes an associative memory array and a controller. The associative memory array stores hyperdimensional vectors in rows of the array. The hyperdimensional vectors represent symbols in the region of interest, and the array includes bitline processors along portions of bitlines of the array. The controller activates rows of the array to perform XNOR, permutation, and addition operations on the hyperdimensional vectors using the bitline processors, encodes N-tuples having N symbols therein, generates fingerprints of a portion of the region of interest based on the N-tuples, stores the fingerprints in the associative memory array, and matches an input sequence against one of the stored fingerprints.

Description

[0001] Cross-reference to related applications

[0002] This application claims priority to U.S. Provisional Patent Application No. 63 / 167,905, filed March 30, 2021, which is incorporated herein by reference. Technical Field

[0003] In general, the present invention relates to classification based on N-grams, and more specifically, to classification using hyperdimensional vectors. Background Technology

[0004] Hyperdimensional computing (HDC) is a computational paradigm for simulating neural activity patterns in the brain, taking into account the fact that most neurons receive a large amount of input. Neural activity patterns are modeled using points in a hyperdimensional space, where each pattern is a hyperdimensional vector called a "hypervector," and each hypervector can have 1,000 to 10,000 points connected to it.

[0005] HDC has been used in many different types of learning applications that involve the manipulation and comparison of very large patterns, typically in memory. For example, U.S. Patent Publication 2020 / 0380384 by Karunaratne et al. describes a system for performing hyperdimensional computations for reasoning tasks (such as language classification) using in-memory computations, wherein the memory array is a memristor array.

[0006] Now for reference Figure 1 , Figure 1 The HDC process for language classification is illustrated. A large body of text 10 in a single language, such as many books, newspapers, websites, etc., can typically be represented by a set of feature vectors, each of which is usually very large, for example, 16K bits. These feature vectors can be provided to a feature extractor 12, which extracts “N-tuples” from the text’s feature vectors. An N-tuple is an ordered sequence of N items. In the case of language classification, an N-tuple is a sequence of N letters arranged in the order they appear in the text. Therefore, if N is 3 and the text is “hello world”, there are 9 distinct 3-tuples: “hel”, “ell”, “llo”, “lo_”, “o_w”, “_wo”, “wor”, “orl”, and “rld”, where _ indicates a space. This effectively distinguishes the sequences “hel” and “hle”.

[0007] The language classifier 14 can operate on N-tuples to determine the language feature fingerprint vector of the text 10 and can store the fingerprint in the database 16. The language classifier 14 can operate on multiple text subjects 10, each text subject using a different language, to generate a fingerprint vector for each language.

[0008] When a text segment in an unknown language is received, the feature extractor 12 can generate an N-tuple for it and provide it to the language classifier 14. The language classifier 14 can then compare its fingerprint vector with the fingerprint vectors of each language to determine which language the new text segment is closest to.

[0009] In HDC, each letter or symbol of the language (including the space character) is represented by a separate D-dimensional hypervector V. Typically, D can be over 10,000 bits long, and each bit can be randomly set to 1 or 0. Due to this randomness, unrelated hypervectors are almost orthogonal to each other.

[0010] Now for a brief reference Figure 2 It shows three hypervectors V, each 16384 bits long, representing the English letters “a”, “b”, and “z”. In the example, the hypervector for “a” begins with the sequence 1001 and ends with 01, while the hypervector for “b” begins with the sequence 0011 and ends with 10. The hypervector for “z” begins with 0101 and ends with 10.

[0011] To represent N-tuples in HDC, feature extractor 12 computes the following function on N hypervectors representing letters and / or symbols (e.g., "llo") in the N-tuples:

[0012] A k = β (N-1) V[1] XNOR β (N-2) V[2] XNOR …. XNOR β 1 V[N-1] XNOR V[N] (1)

[0013] Among them, A k Let XNOR be the HDC representation of the k-th N-tuple, where XNOR is a mutually exclusive NOR operation, and β... (N-X) V[X] indicates that an NX permutation operation (i.e., shift and rotate NX times) is performed on the supervector V[X] representing the Xth symbol in the N-tuple.

[0014] In HDC, in order to create a language fingerprint, the language classifier 14 first processes a large number of N-tuples A from the text 10. k Convert to bipolar form. Converting to bipolar form involves converting each "0" value to a "-1" value. The language classifier 14 then uses a large number of bipolar N-tuples A.k Add to the signed global language vector, where HDC N-tuple A k Each vector element is summed individually. Finally, the language classifier 14 binarizes the signed global language vector into a binary global language vector (i.e., a language fingerprint) and stores the language fingerprint in the database 16.

[0015] Once the fingerprints for various languages ​​have been created, the language classifier 14 can then proceed to the "retrieval phase," where fingerprints for unknown languages ​​are generated and compared with fingerprints stored in the database 16. Typically, a K-nearest neighbor (KNN) similarity search is used to perform the comparison, generating a "Top-K" candidate language fingerprint.

[0016] Because the hypervector is so large, performing the operation of calculating the N-tuple of Equation 1 on a standard CPU (Central Processing Unit) is computationally difficult. Karunaratne et al. implemented HDC in memory on a memristor array. However, Karunaratne et al. claimed that Equation 1 is computationally difficult to implement as is. Therefore, they first transformed Equation 1 into "2 N-1 They calculated the summation of each subterm by component, and then, since the sum grows exponentially with N, they found a two-term approximation that is true when N is even. Summary of the Invention

[0017] According to a preferred embodiment of the present invention, a system for classifying N-tuples in a region of interest via hyperdimensional computation is provided. The system includes an associative memory array and a controller. The associative memory array stores hyperdimensional vectors in rows of the array. The hyperdimensional vectors represent symbols in the region of interest, and the array includes bitline processors along portions of the bitlines of the array. The controller activates rows of the array to perform XNOR, permutation, and addition operations on the hyperdimensional vectors using the bitline processors, encodes N-tuples having N symbols therein, generates fingerprints of a portion of the region of interest based on the N-tuples, stores the fingerprints in the associative memory array, and matches an input sequence against one of the stored fingerprints.

[0018] Furthermore, according to a preferred embodiment of the present invention, the field of interest is music.

[0019] Furthermore, according to a preferred embodiment of the present invention, the controller stores the intermediate N-tuple result of the first N-tuple and generates subsequent N-tuples, which are generated based on the intermediate N-tuple result of their previous N-tuples.

[0020] According to a preferred embodiment of the present invention, a method for classifying N-tuples in a region of interest via hyperdimensional computation is also provided. The method includes: storing a hyperdimensional vector in rows of an associative memory array; activating rows of the array to perform XNOR, permutation, and addition operations on the hyperdimensional vector using the bitline processor, encoding N-tuples having N symbols, where N is greater than 2, generating a fingerprint of a portion of the region of interest based on the N-tuples, storing the fingerprint in the associative memory array, and matching an input sequence against one of the stored fingerprints.

[0021] In addition, according to a preferred embodiment of the present invention, the method includes: storing the intermediate N-tuple result of the first N-tuple and generating a subsequent N-tuple, the subsequent N-tuple being generated based on the intermediate N-tuple result of its previous N-tuple. Attached Figure Description

[0022] The subject matter of this invention is specifically pointed out and explicitly claimed at the end of the specification. However, the invention, relating to both the organization and the method of operation, together with its objects, features and advantages, can be best understood by referring to the following detailed description when reading the accompanying drawings, wherein:

[0023] Figure 1 This is a schematic diagram of the HDC process used for language classification;

[0024] Figure 2 This is a schematic diagram of three exemplary hypervectors V;

[0025] Figure 3A , 3B 3C is a schematic diagram of the components of the associated processing unit that can be used in the system of the present invention;

[0026] Figure 4 This is a schematic diagram of the three storage volumes of a hypervector;

[0027] Figure 5 yes Figure 3A , Figure 3B and Figure 3C A diagram illustrating the types of operations that the APU can implement for HDC processes categorized by N-tuples;

[0028] Figure 6 This is a schematic diagram illustrating the creation of an exemplary HDC N-tuple for the exemplary 3-tuple "hel" and the next 3-tuple "ell"; and

[0029] Figure 7 Is using Figure 6 A schematic diagram illustrating the process of creating a language fingerprint using an exemplary HDC N-tuple A3(hel).

[0030] It should be understood that, for the sake of simplicity and clarity, the elements shown in the figures are not necessarily drawn to scale. For example, the dimensions of some elements may be exaggerated relative to others for clarity. Furthermore, where deemed appropriate, reference numerals may be repeated in the figures to indicate corresponding or similar elements. Detailed Implementation

[0031] In the detailed description below, numerous specific details are set forth in order to provide a thorough understanding of the invention. However, those skilled in the art will understand that the invention can be practiced without these specific details. In other instances, well-known methods, processes, and components have not been described in detail to avoid obscuring the invention.

[0032] The applicant has recognized that the approximate hyperdimensional computation (HDC) N-tuple formula (Formula 1) is not required, nor is it necessary for N to be an even number. The applicant has recognized that when HDC N-tuple operations are implemented on an associative processing unit (APU) (e.g., a Gemini APU available from GSI Technologies Inc.), the number of operations required to compute the HDC N-tuple formula is linearly related to N, making N-tuple classification (especially HDC language classification) significantly faster and more efficient.

[0033] Brief Reference Figure 3A , Figure 3B and Figure 3C Together, these illustrate the components of APU 14. APU 14 includes an associative memory array 30, a row decoder 32, a column decoder 36, and a controller 34. Array 30 comprises multiple sections ( Figure 3A An example is shown, each portion having multiple cells arranged in rows (defined by word lines) and columns (defined by bit lines), where vectors to be operated on can be stored in columns, and multiple vectors can be stored at once. Array 30 can be a single array, or it can be distributed across multiple memory banks. For example, associative memory storage devices and associative processing units are described in U.S. Patent No. 8,238,173, issued August 7, 2012 (titled "USINGSTORAGE CELLS TO PERFORM COMPUTATION") and U.S. Patent No. 9,859,005, issued January 2, 2018 (titled "MEMORY DEVICE"), both of which are assigned to the applicant and incorporated herein by reference.

[0034] The row decoder 32 can activate multiple word lines simultaneously, which can cause cells in those rows to be activated and their data to be provided to their associated bit lines. Each bit line in a section can be connected to a column of cells, and when multiple word lines are activated, each bit line can receive a Boolean function of the activated cells in its column. The column decoder 36 can have a sense amplifier therein, which can receive the result of the Boolean function for each column. Each bit line can affect the bit line processor (…). Figure 3B The results are provided to the column decoder 36 and operated on the cells in its columns. An exemplary bitline processor is described in U.S. Patent No. 10,153,042, issued December 11, 2018 (titled “IN-MEMORY COMPUTATIONAL DEVICE WITH BIT LINE PROCESSORS”), which has been assigned to the applicant and is incorporated herein by reference.

[0035] Each section ( Figure 3C A bitline processor (BP) can be provided for a single bit of a vector. A column of bitline processors can operate on a single vector, and a row of bitline processors can operate on the same bit of multiple vectors, thus forming a memory bank. Activating multiple rows of a portion may result in concurrent computation on the same bit of multiple vectors. Activating multiple rows of multiple portions of a stored vector may result in concurrent computation on multiple vectors. Controller 34 can control the activation of rows and columns to perform specific computations. For example, U.S. Patent Publication No. 2018 / 0341642, published November 29, 2018 (titled “NATURAL LANGUAGE PROCESSING WITH KNN”), assigned to the applicant and incorporated herein by reference, describes an exemplary K-nearest neighbor (KNN) search operation that can be performed by APU 14.

[0036] According to a preferred embodiment of the invention, the controller 34 can implement an HDC classifier, and the hypervectors V can be stored horizontally (i.e., row-wise) in the associative memory array 30. Because each hypervector V can be large, they can be longer than a single row of the memory array 30. According to a preferred embodiment of the invention and as... Figure 4 As shown, each supervector V can be a 16K-bit vector and can be horizontally stored in all eight storage banks 31, where each row of storage bank 31 stores 2K bits. Figure 4 Three memory banks are shown: memory bank 0, memory bank 1, and memory bank 7, which store bits 0-2047, 2048-4095, and 14337-16383, respectively.

[0037] For each computation, two or more hypervectors V can be stored in the relevant rows of the bitline processor BP. The correlation controller 34 can activate multiple rows at once, thereby enabling Boolean operations between the relevant rows in each bitline processor BP. It should be understood that each bitline processor BP can operate on a single bit i. The output of each bitline processor BP can be sensed by the column decoder 36 and, if necessary, copied back to another row of array 30. In this way, each Boolean operation can be performed in parallel on all bits of the hypervector V.

[0038] Formula 1 is copied here:

[0039] A k = β (N-1) V[1] XNOR β (N-2) V[2] XNOR …. XNOR β 1 V[N-1] XNOR V[N] (1)

[0040] Among them, as mentioned above, A k Let XNOR be the HDC tuple representation of the k-th N-tuple, where XNOR is a mutually exclusive NOR operation, and β (N-X) V[X] indicates that an NX permutation operation (i.e., shift and rotate NX times) is performed on the supervector V[X] representing the Xth symbol in the N-tuple.

[0041] Now for reference Figure 5 , Figure 5 The types of operations that controller 34 can implement for the HDC process for language classification described in the background art are illustrated. Three exemplary hypervectors 33, 35, and 37 are shown, representing the letters “a” and “b” (hypervectors 33 and 35, respectively) and an “accumulation” vector (hypervector 37). As described in the previous example, the hypervector of “a” begins with sequence 10 and ends with 1001, while the hypervector of “b” begins with sequence 01 and ends with 1100.

[0042] An accumulation vector stores not the sum of binary values, but the sum of "bipolar" values. A binary vector can be converted to a bipolar vector by converting any "0" bits in the binary vector to "-1". Therefore, the values ​​of a bipolar vector are "1" and "-1". An accumulation vector can accumulate the bipolar versions of related binary vectors. Figure 5 In the sequence, the cumulative vector begins with the sequence 75, 3654 and ends with the sequences 895, -1, -1542 and 32767.

[0043] To perform the XNOR operation, controller 34 can activate two rows storing the two hypervectors V to be multiplied and instruct the bit-line processor BP to perform a bit-by-bit XNOR operation on them. Controller 34 can then copy the result received by the sense amplifiers in all columns back to the selected row of the array. Figure 5 In the example, controller 34 can activate rows 33 and 35, and the result of the XNOR operation between them can be stored in row 40. Note that row 40 is aligned with rows 33 and 35, so the XNOR of the leftmost bits of vectors 33 and 35 (i.e., 10 XNOR with 01 XNOR) is located in the leftmost column of row 40 (i.e., 00).

[0044] To perform the substitution operation, controller 34 can activate the relevant data row and, using registers and logic units (not shown), right-shift all data in the data row by one unit, then rotate (i.e., write) the rightmost bit of the row to the leftmost bit of the row. Figure 5 In the middle, line 42 shows the result of the permutation operation on the supervector 33, which begins with sequence 10 and ends with 1001, and is permuted with sequence 00 ending with sequence x100, where "x" is the shifted value of the sequence portion not shown in the original version of the supervector 33.

[0045] The addition operation for generating the global language vector can be implemented as an integer addition operation between the accumulation row 36 and a selected hypervector row (e.g., row 33 representing the letter "a"). To this end, the controller 34 can perform the integer addition operation between the hypervector row 33 and the accumulation row 36 (as described in US10,402,165, entitled "CONCURRENT MULTI-BIT ADDER," granted September 3, 2019, which has been assigned to the applicant and incorporated herein by reference), wherein the integer addition function can be modified to receive the bipolar representation of the hypervector row 33. The controller 34 can then copy the result back to the accumulation row 37. Figure 5 In the diagram, line 44 shows the result of the addition operation between the accumulator line 40 and the bipolar version of the supervector line 33. However, it should be noted that the value of the rightmost cell (marked as 46 in line 37 and 48 in line 44) has not changed because its counter is saturated at 32767.

[0046] Now for reference Figure 6 The creation of an exemplary vector A3(hel) for the 3-tuple “hel” is shown, where each exemplary vector V has 6 elements. In this example, “h” is represented by the sequence 100101, “e” by the sequence 001110, and “l” by the sequence 111001, and each sequence is stored in a separate row and labeled as 50, 52, and 54 respectively.

[0047] Controller 34 can first perform permutations on the hypervectors of "h", "e", and "l", where the hypervector of "h" is permuted twice, the hypervector of "e" is permuted once, and the hypervector of "l" is not permuted at all. In this example, the permutation is a left shift followed by a rotation, where the rotation is indicated by arrows 51 and 53 for "h" after two permutations, and by arrow 55 for "e" after permutation. The results of the permutations are stored in lines 54 and 56, respectively.

[0048] Then, controller 34 can perform XNOR on the permuted values ​​together to produce A3(hel) = β 2 'h'XNORβ 1 The 3-tuple 'e'XNOR'l', i.e., "hel", is generated. To do this, controller 34 can first activate lines 54 and 58 to generate an XNOR of "l" with the permuted "e", and can store the intermediate result in line 59. Controller 34 can then activate line 59, where line 56 stores "h" after the two permutations. Controller 34 can write the result sequence 110011, i.e., the HDC N-tuple A3(hel) of "hel", in line 60. These operations are bitwise, with the leftmost bit indicated by arrow 57.

[0049] For the next N-tuple (“ell” in this example), controller 34 can utilize the intermediate result stored in line 59, which stores “one-permutation “e” and the unpermuted “l”. Controller 34 can permutate the intermediate result stored in line 59 (indicated by arrow 61) to generate “e” with two permutations and “l” with one permutation (sequence 001101, stored in line 62), and can then perform an XNOR (indicated by arrow 63) on line 62 with the unpermuted “1” from line 54 (sequence 111001) to generate A3(ell) in line 64, which is sequence 001011.

[0050] To generate the next triplet "llo", controller 34 can first generate the next intermediate supervector, i.e., intermediate vector T, based on the previous triplet "ell" by subtracting the supervector of "e" from the previous triplet A3(ell) after two permutations. For the previous triplet, controller 34 can permutate the temporary vector T and add it to the supervector of the next symbol (i.e., the symbol of "o").

[0051] A general process can be defined as:

[0052] 1. Perform two permutations on the hypervector of each symbol Q to generate P2(Q) and store them.

[0053] 2. Given a computed triplet A3(UVX), generate a temporary vector T (i.e., T = A3(UVX) - P2(U)) by subtracting the supervector P2(U) after two permutations from the computed triplet A3(UVX). The subtraction operation can be a slightly modified XNOR operation.

[0054] 3. Calculate the next 3-tuple by permuting T to generate P1(T), and add the next hypervector to it (i.e., A3(VXY) = P1(T) + Y).

[0055] The controller 34 can repeat this process for each 3-tuple. Furthermore, the process can be extended to N-tuples by storing the maximum permutation P(n-1) for each symbol. Therefore, the performance improvement of performing a single permutation while computing each sequential N-tuple requires storing an additional vector of multiple permutations for each symbol.

[0056] Therefore, for each N-tuple except the first one (which must be fully computed), controller 34 can simply permutate the temporary vector T and XNOR it with the supervector of the next sign, instead of fully implementing Equation 1.

[0057] use Figure 6 The process of creating a language fingerprint using the exemplary HDC N-tuple A3(hel) is as follows: Figure 7 As shown in the image, now refer to Figure 7 As described above, controller 34 can add the bipolar form of the HDC N-tuple A3(hel) in line 60 (shown as sequence 11-1-111 in line 68) to the accumulated signed global language vector stored in line 70, where the bipolar N-tuple A k Each vector element is summed individually. The result is displayed in line 72, although controller 34 may alternatively write the result back to line 70. Once all bipolar N-tuples have been accumulated, controller 34 can binarize the resulting signed global language vector stored in line 72 into a language fingerprint stored in line 74 by replacing each positive vector element in line 72 with "1" and each zero or negative vector element in line 72 with "0".

[0058] It should be understood that controller 34 generates N-tuple A k The operations are simple row operations that can be performed in parallel on the bits of each sequence in memory array 30. Therefore, each operation can require only a few cycles. Similarly, the operation of the controller 34 to generate each language fingerprint can also be performed in parallel in memory array 30. Furthermore, once the first N-tuple is determined, each subsequent N-tuple can be generated using very simple operations based on the intermediate calculations of the previous N-tuples.

[0059] The controller 34 can store the obtained language fingerprints in rows of the memory array 30, and can repeat the above operation for each language of interest, thereby generating a set of language fingerprints in a portion of the memory array 30.

[0060] According to a preferred embodiment of the present invention, the controller 34 can also perform a language classifier on a set of language fingerprints stored in the memory array 30. When the controller 34 can receive query text, the controller 34 can generate a query language fingerprint of the query text by performing the operations discussed above.

[0061] Then, to determine the language used to compose the query text, controller 34 can calculate the distance, such as the Hamming distance, between the query language fingerprint and each language fingerprint stored in memory array 30. Using the KNN search operation discussed in U.S. Patent Publication No. 2018 / 0341642 (titled "NATURAL LANGUAGE PROCESSING WITH KNN"), controller 34 can compare the obtained distance values ​​and select the K smallest distances. Sufficiently small distances indicate that the N-tuple frequency of the query text is close to the frequency of the language in the language fingerprint. Therefore, the query text is likely composed in a matching language.

[0062] Table 1 below shows the results when running such fingerprint comparisons on a single thread on APUs and Intel CPUs.

[0063]

[0064] The table above shows the number of memory banks, and the APU 14 has 64 memory banks. Therefore, the APU 14 is 55 times faster than a 64-core CPU.

[0065] It should be understood that the HDC process described above can be implemented for classification of any type of input sequence to which N-tuples can be applied. It is not limited to the example of language classification for text or speech provided in this paper. It can also be used to classify other domains of interest, such as speech, music, EEG, etc. In the latter, the hyperdimensional vector can represent symbols in the relevant domain of interest. For example, the paper "CLARAPRINT: AChord and Melody Based Fingerprint for Western Classical MusicCover Detection" uploaded to arXiv by Mickael Arcos in 2009 and incorporated into this paper by reference. https: / / arxiv.org / ftp / arxiv / papers / 2009 / 2009.10128.pdfThis paper discusses a method for generating musical fingerprints for music retrieval by defining chords as a musical alphabet. Controller 34 can implement the method described in this paper. The paper uses the term "Shingle" to denote an N-tuple and suggests 2-7 shingles (i.e., 2-tuples to 7-tuples).

[0066] Although certain features of the invention have been described and illustrated herein, many modifications, substitutions, alterations, and equivalents will now occur to those skilled in the art. Therefore, it should be understood that the appended claims are intended to cover all such modifications and variations that fall within the true spirit of the invention.

Claims

1. A system for classifying N-tuples in a domain of interest via hyperdimensional computation, the system comprising: An associative memory array that stores hyperdimensional vectors in vector rows of the array, the hyperdimensional vectors representing symbols in the region of interest, the array including multiple bit lines connecting a column of cells, each bit line implementing at least one bit line processor for operating on activation cells within its column; as well as A controller is configured to activate at least two vector rows of the array to perform at least XNOR and addition operations on the hyperdimensional vectors within the activated vector rows using the bitline processor, and to copy the temporary vector output of the bitline processor to the middle row of the array, the controller activating the middle row relative to at least one other vector row. The controller performs the activation and replication operations to encode an N-tuple having N symbols, where N is greater than 2, generate a fingerprint of a portion of the region of interest based on the N-tuple, store the fingerprint in the array, and match an input sequence with one of the stored fingerprints.

2. The system according to claim 1, wherein, The area of ​​interest is music.

3. The system according to claim 1, wherein the controller is configured to store the intermediate N-tuple results of the first N-tuple and generate subsequent N-tuples, the subsequent N-tuples being generated based on the intermediate N-tuple results of their previous N-tuples.

4. A method for classifying N-tuples in a domain of interest via hyperdimensional computation, the method comprising: The hyperdimensional vectors are stored in vector rows of an associative memory array, the hyperdimensional vectors representing symbols in the region of interest, the array including multiple bit lines connecting a column of cells, each bit line implementing at least one bit line processor for operating on the activation cells within its column; as well as Activate at least two vector rows of the array to perform at least XNOR and addition operations on the hyperdimensional vectors in the activated vector rows using the bitline processor. The temporary vector output of the bitline processor is copied to the middle row of the array, the copying activating the middle row relative to at least one other vector row; The activation and replication are performed to encode an N-tuple having N symbols, where N is greater than 2, a fingerprint of a portion of the region of interest is generated from the N-tuple, the fingerprint is stored in the associative memory array, and an input sequence is matched against one of the stored fingerprints.

5. The method according to claim 4, wherein, The area of ​​interest is music.

6. The method of claim 4, further comprising storing intermediate N-tuple results of the first N-tuple and generating subsequent N-tuples, the subsequent N-tuples being generated based on the intermediate N-tuple results of their previous N-tuples.

Images