Patent Application
20230325435
The present invention relates to the field of digital computer systems, and more specifically, a set of resonator networks for factorizing hypervectors.
Resonator networks are defined in the following references: E. Paxon Frady et al. “Resonator networks for factoring distributed representations of data structures”, Neural Computation 2020 and Spencer J. Kent et al. “Resonator Networks outperform optimization methods at solving high-dimensional vector factorization,” Neural Computation 2020. Given a hypervector formed from an element-wise product of two or more atomic hypervectors (each from a fixed codebook), the resonator network may find its factors. The resonator network may iteratively search over the alternatives for each factor individually rather than all possible combinations until a set of factors is found that agrees with the input hypervector.
Various embodiments provide a method and resonator network system as described by the subject matter of the independent claims. Advantageous embodiments are described in the dependent claims. Embodiments of the present invention can be freely combined with each other if they are not mutually exclusive.
In one aspect, the invention relates to a method providing an encoder for representing data structures in a vector space, the vector space being defined by a set of matrices, referred to herein as codebooks, which encode a set of cognitive concepts respectively, the codebooks comprising candidate code hypervectors representing items of the respective concept; providing a set of N resonator networks, where N>1, each resonator network being configured to receive an input hypervector representing a data structure and to perform an iterative process in order to factorize the input hypervector into individual hypervectors representing the set of concepts respectively, the set of N resonator networks being associated with N permutations respectively; representing using the encoder a set of N data structures by N hypervectors (herein referred to as N first hypervectors) respectively; applying the N permutations to the N first hypervectors respectively; combining the N permuted hypervectors into a bundled hypervector; processing the bundled hypervector by the resonator networks, thereby factorizing the N first hypervectors.
With this embodiment, the processing of the bundled hypervector at the respective resonator network includes applying to the bundled hypervector an inverse permutation of the permutation associated with the resonator network resulting in a second hypervector; and processing the second hypervector.
With this embodiment, the processing of the bundled hypervector being performed in parallel by the set of resonator networks.
With this embodiment, the processing includes ranking the N resonator networks; scaling the bundled hypervector by the number N of resonator networks; sequentially processing the scaled bundled hypervector in accordance with the ranking; wherein the processing by a current resonator network includes producing a second hypervector by subtracting from the scaled bundled hypervector zero or more outputs of the zero or more preceding resonator networks; processing by the resonator network the second hypervector.
With this embodiment, the ranking of the resonator network being performed such that an ordering of subtractions is applied to prevent noise amplification in the second hypervector.
With this embodiment, a search space is defined by the number of candidate code hypervectors each having a size D, the method further including increasing the size D of the candidate hypervectors while maintaining the same search space.
With this embodiment, the method further includes preventing access to a permutation of a given resonator network by the other resonator networks.
With this embodiment, the iterative process including for each concept of the set of concepts: computing an unbound version of a hypervector representing the concept, computing a similarity vector indicating a similarity of the unbound version with each candidate code hypervector of the concept, and generating an estimate of a hypervector representing the concept by a linear combination of the candidate code hypervectors, with weights given by the similarity vector, followed by an application of a non-linear function.
With this embodiment, the non-linear function is a sign function.
With this embodiment, the encoder being a feed forward neural network.
With this embodiment, the data structure being an image, the codebooks representing the concept of colours, the concept of shapes, the concept vertical positioning and the concept of horizontal positioning.
In one aspect, the invention relates to a resonator network system comprising a set of resonator networks, each resonator network being configured to receive an input hypervector representing a data structure and to perform an iterative process in order to factorize the input hypervector into individual hypervectors representing a set of concepts respectively, the set of N resonator networks being associated with N permutations respectively; the resonator network system being configured for applying the N permutations to N first hypervectors respectively, the N first hypervectors representing a set of N data structures respectively; and combining the N permuted hypervectors into a bundled hypervector; the resonator networks being configured for processing the bundled hypervector, thereby factorizing the N first hypervectors.
These and other objects, features, and advantages of the present invention will become apparent from the following detailed description of illustrative embodiments thereof, which is to be read in connection with the accompanying drawings. The various features of the drawings are not to scale as the illustrations are for clarity in facilitating one skilled in the art in understanding the invention in conjunction with the detailed description. In the drawings:
In the following embodiments of the invention are explained in greater detail, by way of example only, making reference to the drawings in which:
The descriptions of the various embodiments of the present invention will be presented for purposes of illustration but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
Data structures may enable to represent cognitive concepts, such as colours, shapes, positions, etc. Each cognitive concept may comprise items e.g., items of the colour concept may comprise red, green, blue etc. The data structure may contain a combination (e.g., product) of multiple components each representing a cognitive concept. For example, the data structure may be an image of a red disk in the bottom right and a green rectangle in the top left, wherein the cognitive concepts may be the colour, shape, and position. In another example, a data structure may form a distributed representation of a tree, wherein each leaf in the tree may represent a concept, and each type of traversal operations in the tree may represent concepts.
The data structure may be encoded by an encoder into a hypervector that uniquely represents the data structure. A hypervector may be a vector of bits, integers, real or complex numbers. The hypervector is a vector having a dimension higher than a minimum dimension, e.g., 100. The hypervector may be holographic with independent and identically distributed (i.i.d) components. The hypervector being holographic means that each bit position in the hypervector may have an equal weight, in contrast to a conventional model with most significant bits and least significant bits. The encoder may combine hypervectors that represent individual concepts with operations in order to represent a data structure. For example, the above mentioned image may be described as a combination of multiplication (or binding) and addition (or superposition) operations as follows: (bottom right*red*disk)+(top left*green*rectangle). The encoder may represent the image using hypervectors that represent the individual concepts and said operations to obtain the representation of the image as a single hypervector that distinctively represents the knowledge that the disk is red and placed at the bottom right and the rectangle is green and placed at the top left. The encoder may be defined by a vector space of a set of hypervectors which encode a set of cognitive concepts and algebraic operations on this set. The algebraic operations may, for example, comprise a superposition operation and a binding operation. In addition, the algebraic operations may comprise a permutation operation. The vector space may, for example, be a D-dimensional space, where D>100. The hypervector may be a D-dimensional vector comprising D numbers that define the coordinates of a point in the vector space. The D-dimensional hypervectors may be in {±1}D and thus may be referred to as “bipolar.” For example, a hypervector may be understood as a line drawn from the origin to the coordinates specified by the hypervector. The length of the line may be the hypervector's magnitude. The direction of the hypervector may encode the meaning of the representation. The similarity in meaning may be measured by the size of the angles between hypervectors. This may typically be quantified as a dot product between hypervectors. The encoder may be a decomposable (i.e., factored) model to represent the data structures. This may be advantageous as the access to the hypervectors may be decomposed into the primitive or atomic hypervectors that represent the individual items of the concepts in the data structure. For example, the encoder may use a Vector Symbolic Architecture (VSA) technique in order to represent the data structure by a hypervector. The encoder may enable to perform an elementwise multiply operation. The encoder may, for example, comprise a trained feed-forward neural network.
Hence, the encoding of data structures may be based on a predefined set of F concepts, where F>1 and candidate items that belong to each of the F concepts. Each candidate item may be represented by a respective hypervector. Each concept may be represented by a matrix of the hypervectors representing candidate items of the concept, e.g., each column of the matrix may be a distinct hypervector. The matrix may be referred to as codebook and the hypervector representing one item of the concept may be referred to as code hypervector. The components of the code hypervector may, for example, be randomly chosen. For example, a codebook representing the concept of colours may comprise seven possible colours as candidate items, a codebook representing the concept of shapes may comprise 26 possible shapes as candidate items etc. The codebooks representing the set of concepts may be referred to as X1, X2 . . . XF respectively. Each codebook X1 may comprise Mx
Querying such data structures through their hypervector representations may require decoding the hypervectors. For example, to read the components of an encoded data structure, the hypervector representing it may be decomposed into the primitives or atomic vectors from which it is built. This procedure is called decoding. Decoding such hypervectors may be performed by testing every combination of code hypervectors. However, this may be very resource consuming. The present subject matter may solve this issue by using the resonator network. The resonator network may be an iterative approach. In particular, the resonator network can efficiently decode a given hypervector without needing to directly test every combination of factors making use of the fact that the superposition operation is used for the encoding of multiple concept items in the given hypervector and the fact that randomized code hypervectors may be highly likely to be close to orthogonal in the vector space, meaning that they can be superposed without much interference. For that, the resonator network may search for possible factorizations of the given hypervector by combining a strategy of superposition and clean-up memory. The clean-up memory may reduce some crosstalk noise between the superposed concept items. The resonator network combines the strategy of superposition and clean-up memory to efficiently search over the combinatorially large space of possible factorizations.
Assuming for a simplified description of the iterative process of the resonator network that the set of concepts comprises three concepts i.e., F=3, but it is not limited to. The codebooks/matrices representing the set of concepts may be referred to as X, Y and Z respectively (i.e., X=X1, Y=X2 and Z=X3.). The codebook X may comprise Mx code hypervectors x1 . . . xM
The present subject matter may provide a set of N resonator networks, each resonator network r (r=1, . . . N) being configured to perform the iterative process in order to factorize a respective input hypervector sr (which is assumed to be defined as s=xα
The iterative process may be implemented according to the present subject matter by each resonator network as follows. Given the hypervector sr that represents the data structure and given the set of predefined concepts, an initialization step may be performed by initializing an estimate of the hypervector that represents each concept of the set of concepts. The initial estimates {circumflex over (x)}(0), ŷ(0) and {circumflex over (z)}(0) may, for example, be defined as a superposition of all candidate code hypervectors of the respective concept e.g., {circumflex over (x)}(0)=sign(Σi=1, . . . , M
And, for each current iteration t of the iterative process, the following may be performed. Unbound hypervectors {tilde over (x)}(t), {tilde over (y)}(t) and {tilde over (z)}(t) may be computed. Each of the unbound hypervectors may be an estimate of the hypervector that represents the respective concept of the set of concepts. Each of the unbound hypervectors may be inferred from the hypervector sr based on the estimates of hypervectors for the other remaining F−1 concepts of the set of concepts which are currently stored in the second set of buffers. The unbound hypervectors may be computed as follows: {tilde over (z)}(t)=sr⊙ŷ(t)⊙{circumflex over (z)}(t)), {tilde over (y)}(t)=sr⊙{circumflex over (x)}(t)⊙{circumflex over (z)}(t) and {tilde over (z)}(t)=sr⊙{circumflex over (x)}(t)⊙ŷ(t), where ⊙ refers to elementwise multiplication. This first definition of the unbound hypervectors may particularly be advantageous if the estimate hypervectors {circumflex over (x)}(t), ŷ(t) and {circumflex over (z)}(t) may be computed in parallel and the unbound hypervectors may be computed in parallel. For that, the resonator network may comprise a circuit that is configured to read the first buffer and the second set of buffers and to apply the elementwise multiplications. This may be referred to as an inference step. The inference step may, however, be noisy if many estimates (e.g., F−1 is high) are tested simultaneously. The unbound hypervectors {tilde over (x)}(t), {tilde over (y)}(t) and {tilde over (z)}(t) may be noisy. This noise may result from crosstalk of many quasi-orthogonal code hypervectors, and may be reduced through a clean-up memory. After providing the unbound version of a hypervector of a given concept, the clean-up memory may be used to find the similarity of each code hypervector of said concept to the unbound version of the hypervector. This may be referred to as a similarity step. The similarity may be computed as a dot product of the codebook that represents said concept by the unbound version of the hypervector, resulting in an attention vector αx(t), αy(t) and αz(t) respectively. The attention vector may be referred to herein as similarity vector. The similarity vectors αx(t), αy(t) and αz(t) have sizes Mx, My and Mz respectively and may be obtained as follows: αx(t)=XT {tilde over (x)}(t)∈M
M
M
The present subject matter may make use of the set of resonator networks to efficiently process multiple data structures. For that, a set of N data structures may be provided, wherein the number of data structures is equal to the number of resonator networks in the set of resonator networks. Each data structure may be encoded by the encoder in order to obtain a hypervector br that represents the data structure. A set of N permutations ρ1, ρ2 . . . ρN may be applied on the N hypervectors b1, b2 . . . bN respectively as follows: ρ1b1, ρ2b2 . . . βNbN. The set of N permutations ρ1, ρ2 . . . ρN may be assigned to the set of set of N resonator networks respectively. Assigning separate permutations to the resonator networks may enable to protect individual resonator networks from each other, and may thus be referred to as resonator islands. These permutations may be advantageous as they may create quasi-orthogonal subspaces (e.g., the set of resonator networks may be considered as different protected resonator islands), that is, the resulting hypervectors ρ1b1, ρ2b2 . . . βNbN may not be interfering with each other. The resulting hypervectors ρ1b1, ρ2b2 . . . ρNbN may be combined (summed) into one hypervector S∈{±1}D as follows: S=[ρ1b1+ρ2b2 . . . +ρNbN], where hypervector S may be referred to as bundled hypervector. The brackets refer to a sign clipping that normalizes the values of the bundled hypervector to +1. All product vectors b1, b2 . . . bN may have the same power in the bundled hypervector by construction. A generation method may be performed for generating for each resonator network of the set of resonator networks an input hypervector sr from the bundled hypervector S. Using the input hypervectors s1, s2 . . . sN the set of resonator networks may provide N factorized hypervectors f1, f2 . . . fN (fr=xα
The computational complexity of the factorization of a resonator network may be mainly determined by O(D×I) where D is the hypervector dimension, and I the number of iterations to converge. The present subject matter may provide an architecture that may significantly reduce this complexity by jointly exploiting the additive and multiplicative superpositions of multiple resonator networks. The present subject matter may efficiently factorize the hypervector representing a data structure into the primitives from which it is composed. For example, given a hypervector formed from an element-wise product of two or more hypervectors, its factors (i.e., the two or more hypervectors) may be efficiently found. According to the present subject matter, initial hypervectors may first be bound together (creating product vectors), and bundled (i.e., added) together after permutations. Therefore, the present subject matter may jointly exploit the additive and multiplicative aspects of hypervectors. This is by contrast to a single resonator which is only exploiting multiplicative superposition (without additive superposition).
In one example implementation, the generation method comprises generating for each resonator network r of the set of resonator networks the respective input hypervector sr by applying the inverse of the permutation ρr−1 associated with the resonator network r to the bundled hypervector S as follows: ρr−1S=sr i.e., ρ1−1S=s1, μ2−1S=s2 . . . ρN−1S=sN. Each resonator network may apply its own inverse permutation, and iterate independently to disentangle the bundled hypervector. The set of resonator networks may process the respective inputs s1, s2 . . . sN to provide N factorized hypervectors f1, f2 . . . fN (fr=xα
In one example implementation, the generation method comprises: ranking the set of N resonator networks and scaling the bundled hypervector S by the number N (×N) of resonator networks. The scaled bundled hypervector may still be bipolar as bundled hypervector S to enable successive interference cancellation. The scaled bundled hypervector S×N may be processed sequentially in accordance with the ranking. For example, the first ranked resonator network may be indexed by 1, the second resonator network by 2 and so on. The processing may first be performed by the resonator network 1, followed by the resonator network 2 and so on. The processing by a current resonator network r comprises: producing an input hypervector sr by subtracting from the scaled bundled hypervector S×N the r−1 factorized hypervectors f1 . . . fr-1 that resulted from the preceding resonator networks 1, r−1 respectively. That is, sr=S×N−Σj=1r-1fj if r>1, otherwise sr=S×N. This sequential processing may further improve the convergence speed.
All product vectors b1, b2 . . . bN may have the same power in the bundled hypervector by construction. However, when noise is added to bundled hypervector S, the ranking may be advantageous as it may determine an optimal ordering of subtractions to be applied. For example, the sequence of subtractions may be guided to avoid noise amplification. Hence, in one example, the ranking may be performed based on the similarly scores between the bundled hypervector and estimated product vectors from the resonator islands. These ranked similarity scores can guide the subtractions to avoid noise amplification.
As described herein, the search space may be defined by the number of code hypervectors, per concept, each having a size D as follows: M=Mx·My·Mz, in case F=3. The possible combinations C that can be covered by the search space M may depend on the size D of the hypervectors by the following operational capacity equation C=σ0+σ1D+σ2D2. In one example, the method further comprises: increasing the size D of the candidate hypervectors to a new size Dover while maintaining the same search space M=Mx·My·Mz e.g., so that C<<σ0+σ1Dover+σ2Dover2. This may enable to overspecify a resonator network. The vector dimensionality may be intentionally set to a larger value than what it is defined by the operational capacity equation. It may lead to faster convergence and hence lower the effective number of operations in the decoding stage. In one example, the value of new size Dover may be obtained using an optimization method. The optimization method may search the optimal value of the new size Dover that is higher than the initial size D but still providing better performance. An example optimization method is shown with reference to
Referring now to
The resonator network 100 may be configured to execute a resonator network to decode hypervectors that are encoded in a vector space defined by three concepts. The codebooks representing the set of concepts may be referred to as X, Y and Z respectively. The codebook X may comprise Mx code hypervectors x1 . . . xM
An input hypervector 101 named s may be received by the resonator network 100. The input hypervector s may be the result of encoding a data structure such as a coloured image comprising MNIST digits. The encoding may be performed by a VSA technique. At t=0 the resonator network 100 may initialize an estimate of the hypervector that represents each concept of the set of concepts as a superposition of all candidate code hypervectors of said concept as follows: {circumflex over (x)}(0)=sign(Σi=1, . . . , M
The operation of the resonator network 100 may be described for a current iteration t. The network nodes 102x, 102y and 102z may receive simultaneously or substantially simultaneously the respective triplet (s, ŷ(t), {tilde over (z)}(t)), (s, {tilde over (x)}(t), {tilde over (z)}(t)) and (s, {tilde over (x)}(t), ŷ(t)). The three network nodes may compute the first estimates {tilde over (x)}(t), {tilde over (y)}(t) and {tilde over (z)}(t) of the hypervectors that represent the set of concepts respectively as follows: {tilde over (x)}(t)=s⊙ŷ(t)⊙{tilde over (z)}(t), {tilde over (y)}(t)=s⊙{tilde over (x)}(t)⊙{tilde over (z)}(t) and {tilde over (z)}(t)=s⊙{tilde over (x)}(t)⊙ŷ(t), where ⊙ refers to elementwise multiplication. This may be referred to as an inference step. That is, the nodes may be perform the inference step on respective input triplets.
The similarity of the first estimate {tilde over (x)}(t) with each of the Mx code hypervectors xi . . . xMM
M
M
After obtaining the similarity vectors αx(t), αy(t) and αz(t), a weighted superposition of the similarity vectors αx(t), αy(t) and αz(t) may be performed using the codebooks XT, YT and ZT stored in memories 108x, 108y, and 108z respectively. This may be performed by the following matrix vector multiplications: Xαx(t), Yαy(t) and Zαz(t). The resulting hypervectors Xαx(t), Yαy(t) and Zαz(t) may be fed to the sign units 110x, 110y and 110z respectively. This may enable to obtain: {circumflex over (x)}(t+1)=sign(Xαx(t)), ŷ(t+1)=sign(Yαy(t)) and {circumflex over (z)}(t+1)=sign(Zαz(t)) respectively, in order to obtain the estimate of the hypervectors {circumflex over (x)}(t+1), ŷ(t+1) and {circumflex over (z)}(t+1) respectively for the next iteration t+1. This may enable the superposition step of the iterative process. For each concept of the concepts the superposition step may receive as input the respective one of the similarity vectors αx(t), αy(t) and αz(t) and provides as an output the respective one of the hypervectors {circumflex over (x)}(t+1), ŷ(t+1) and {circumflex over (z)}(t+1). Hence, the estimate of the hypervectors representing the set of concepts respectively may be defined according to the present system as follows {circumflex over (x)}(t+1)=g(XXT(s⊙ŷ(t)⊙{tilde over (z)}(t))), ŷ(t+1)=g(YYT(s⊙{tilde over (z)}(t)⊙{tilde over (z)}(t))) and {circumflex over (z)}(t+1)=g(ZZT(s⊙{tilde over (z)}(t)⊙ŷ(t))) where g is the activation function such as a sign function.
The iterative process may stop if a stopping criterion is fulfilled. The stopping criterion may, for example, require that {circumflex over (x)}(t+1)={circumflex over (x)}(t), ŷ(t+1)=ŷ(t) and {circumflex over (z)}(t+1)={circumflex over (z)}(t) or that a maximum number of iterations is reached.
Referring now to
A set of N resonator networks such as the resonator network of
Referring now to
A set of N resonator networks such as the resonator network of
For each resonator network r of the set of resonator networks 326.1-N the respective input hypervector sr may be generated in step 309 by applying the inverse of the permutation ρr−1 associated with the resonator network r to the bundled hypervector S as follows: ρr−1S=sr i.e., ρ1−1S=s1, ρ−1S=s2 . . . ρN−1S=sN. The set of resonator networks 326.1-N may process in step 311 the respective inputs s1, s2 . . . sN to provide N factorized hypervectors f1, f2 . . . fN. For example, the processing of each input hypervector sr by the resonator network may find the code hypervectors xα
Referring now to
A set of N resonator networks such as the resonator network of
The bundled hypervector may be scaled in step 409 by a scaler 424 of the decoder 420 by the number N of resonator networks. The scaled bundled hypervector may be processed sequentially in step 411 by the set of resonator networks 426.1-N. In a first processing step, the resonator network 426.1 may receive the input hypervector s1 which is the scaled signal S×N and factorize the hypervector s1 to obtain a factorized hypervector f1. The factorized hypervector f1 may be subtracted from the scaled hypervector S×N and the resulting hypervector s2=S×N−f1 may be factorized by the second resonator network 426.2 to obtain factorized hypervector f2. The factorized hypervector f2 may be subtracted from the hypervector s2 and the resulting hypervector s3=S×N−f1−f2 may be factorized by the third resonator network 426.3 to obtain factorized hypervector h. The factorized hypervector f3 may be subtracted from the hypervector s3 and the resulting hypervector s4=S×N−f1−f2−f3 may be factorized by the fourth resonator network 426.4 to obtain factorized hypervector f4 and so on. The last resonator network 426.N may factorize hypervector sN=S×N−Σj=1N-1fj in order to obtain the factorized hypervector fN.
Referring now to
Plot 500 shows the results of factorizing hypervectors with different sizes D using a single resonator network (represented by dots 504 linked by a line) and using a set of three (N=3) resonator networks (represented by dots 506) according to the present subject matter. In this example, the number of concepts is three, F=3 and the size of each codebook is defined as follows: Mx=7, My=8 and Mz=9. Compared to a single multiplicative resonator, the set of three resonator networks according to the present subject matter may reduce the hypervector dimension D by four orders (as indicated in the plot 500) of magnitude for the same functionality (e.g., at the same decoded accuracy, information bits, and convergence speed). A larger set of resonator networks (N>3) may further improve the performance.
Referring now to
Referring now to
The present subject matter may comprise the following clauses.
Clause 1. A method comprising: providing an encoder for representing data structures in a vector space, the vector space being defined by a set of matrices, referred to herein as codebooks, which encode a set of cognitive concepts respectively, the codebooks comprising candidate code hypervectors representing items of the respective concept; providing a set of N resonator networks, where N>1, each resonator network being configured to receive an input hypervector representing a data structure and to perform an iterative process in order to factorize the input hypervector into individual hypervectors representing the set of concepts respectively, the set of N resonator networks being associated with N permutations respectively; representing using the encoder a set of N data structures by N first hypervectors respectively; applying the N permutations to the N first hypervectors respectively; combining the N permuted hypervectors into a bundled hypervector; processing the bundled hypervector by the resonator networks, thereby factorizing the N first hypervectors.
Clause 2. The method of clause 1, the processing of the bundled hypervector at the respective resonator network comprising: applying to the bundled hypervector an inverse permutation of the permutation associated with the resonator network resulting in a second hypervector; and processing the second hypervector.
Clause 3. The method of clause 2, the processing of the bundled hypervector being performed in parallel by the set of resonator networks.
Clause 4. The method of clause 1, the processing comprising: ranking the N resonator networks; scaling the bundled hypervector by the number N of resonator networks; sequentially processing the scaled bundled hypervector in accordance with the ranking; wherein the processing by a current resonator network comprises:producing a second hypervector by subtracting from the scaled bundled hypervector zero or more outputs of the zero or more preceding resonator networks; processing by the resonator network the second hypervector.
Clause 5. The method of clause 4, the ranking of the resonator network being performed such that an ordering of subtractions is applied to prevent noise amplification in the second hypervector.
Clause 6. The method of any of the preceding clauses 1 to 5, wherein a search space is defined by the number of candidate code hypervectors each having a size D, the method further comprising: increasing the size D of the candidate hypervectors while maintaining the same search space.
Clause 7. The method of any of the preceding clauses 1 to 6, comprising preventing access to a permutation of a given resonator network by the other resonator networks.
Clause 8. The method of any of the preceding clauses 1 to 7, the iterative process comprising for each concept of the set of concepts: computing an unbound version of a hypervector representing the concept, computing a similarity vector indicating a similarity of the unbound version with each candidate code hypervector of the concept, and generating an estimate of a hypervector representing the concept by a linear combination of the candidate code hypervectors, with weights given by the similarity vector, followed by an application of a non-linear function.
Clause 9. The method of clause 8, wherein the non-linear function is a sign function.
Clause 10. The method of any of the preceding clauses 1 to 9, the encoder being a feed forward neural network.
Clause 11. The method of any of the preceding clauses 1 to 10, the data structure being an image, the codebooks representing the concept of colours, the concept of shapes, the concept vertical positioning and the concept of horizontal positioning.
The present invention may be a system, a method, and/or a computer program product at any possible technical detail level of integration. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.
Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, configuration data for integrated circuitry, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++, or the like, and procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.
Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.
These computer readable program instructions may be provided to a processor of a computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the Figures. For example, two blocks shown in succession may, in fact, be accomplished as one step, executed concurrently, substantially concurrently, in a partially or wholly temporally overlapping manner, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.
Based on the foregoing, a method, system, and computer program product have been disclosed. However, numerous modifications and substitutions can be made without deviating from the scope of the present invention. Therefore, the present invention has been disclosed by way of example and not limitation.
The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises,” “comprising,” “includes,” “including,” “has,” “have,” “having,” “with,” and the like, when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
The descriptions of the various embodiments of the present invention have been presented for purposes of illustration but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
It will be appreciated that, although specific embodiments have been described herein for purposes of illustration, various modifications may be made without departing from the spirit and scope of the embodiments. In particular, transfer learning operations may be carried out by different computing platforms or across multiple devices. Furthermore, the data storage and/or corpus may be localized, remote, or spread across multiple systems. Accordingly, the scope of protection of the embodiments is limited only by the following claims and their equivalent.
